Using ANSI aliasing rules

Your programs are likely to perform better if you follow these guidelines:

Use ANSI aliasing whenever possible.

Declare constant variables with const. This is particularly helpful when using the C++ compiler because if something is qualified as const, the compiler will not be forced to perform unnecessary reloads to see if the value has changed. This can generate significantly faster code.

ggPoint3 operator*(const ggHAffineMatrix3 &m
, const ggPoint3 &p)
 {
  return ggPoint3(
    m.e[0][0] * p.x() + m.e[0][1] * p.y() + m.e[0][2] * p.z() + m.e[0][3],
    m.e[1][0] * p.x() + m.e[1][1] * p.y() + m.e[1][2] * p.z() + m.e[1][3],
    m.e[2][0] * p.x() + m.e[2][1] * p.y() + m.e[2][2] * p.z() + m.e[2][3]
    );
}

Whenever their values cannot change, qualify pointers and their targets as constants, ensuring that you mark the appropriate part as const.
- If only the pointer is constant, you can use a statement that is similar to the following:
```
int * const i = p /* a constant pointer to an integer that may vary */
```
- If only the target is constant, use a statement similar to either of the following:
```
int const * i = p /* a variable pointer to a constant integer */
const int * i = p /* a variable pointer to a constant integer */
```
- If both the target integer and the pointer are constants, use a statement similar to either of the following:
```
const int * const i = &p;  /* a constant pointer to a constant integer  */
int const * const i = &p;  /* a constant pointer to a constant integer  */
```
Use the ROCONST compiler option. The ROCONST option works with both C and C++. This option causes the compiler to treat variables that are defined as const as if they are read-only. In some cases, these variables will be stored in read-only memory. For more information, see ROCONST.
For global variables initialized to large read-only arrays or strings: Use a #pragma variable to ensure that they are implemented as read-only csects. This prevents them from being initialized at load time.
Example: For large initialized arrays
```
# pragma variable (arrayname, norent)
```

In a read-only situation: If you are using the value through a pointer, use a temporary automatic variable. The difference in the source code is significant, as shown in the following table:

ANSIALIAS RENT and OPT(2) NOANSIALIAS RENT and OPT(2)

Table 1. Example of using temporaries to remove aliasing effects
ANSIALIAS RENT and OPT(2)	NOANSIALIAS RENT and OPT(2)
`... while (hot_loop < hot_loop_end) { hot_loop = hot_loop + foo->increment; fun[x] = hot_loop*foo->expansion; } }`	`{ ... increment = foo->increment; expansion = foo->expansion; while (hot_loop < hot_loop_end) { hot_loop = hot_loop + increment; fun[x] = hot_loop*expansion; }`

...
  while (hot_loop < hot_loop_end) {
    hot_loop = hot_loop  + foo->increment;
    fun[x] = hot_loop*foo->expansion;
  }
}

{ 
...
increment = foo->increment;
expansion = foo->expansion;
  while (hot_loop < hot_loop_end) {
    hot_loop = hot_loop  + increment;
    fun[x] = hot_loop*expansion;
}