SetEvaluationFlag

SetEvaluationFlag(flag, enable, expr)

Sets or resets a flag that has some effect on how Analytica evaluates expressions, and then evaluates «expr» with the indicated flag value. The change takes effect only within the scope of «expr» -- after the function completes, the flag has its original value. This is used primarily for turning on or off certain speed optimizations in cases where those speed optimizations might interact in an undesirable manner with «expr».

The «flag» parameter may be one of the following values: (currently, only one)

evaluationContext

This is described in detail in the sections below.

To set a flag, pass True for the «enable» parameter. To clear a flag, pass False for «enable».

EvaluationContext

Suppose only one slice of an intermediate result will be retained in the final result. Analytica can reduce computation time by only computing the one slice.

The system variable EnableEvalContextUse controls whether this speed optimization is applied globally to the whole model. It is set to 1 by default. SetEvaluationFlag is used to override this global setting just while «expr» is evaluated.

There are a few potential reasons for disabling this speed optimization. Usually it will be because you have a legacy model that was created prior to Analytica 4.6 (when this speed optimization was introduced), and you find that this optimization changes or breaks something in your model. Hence, you can turn the feature off to retain backward compatibility. You might turn it off globally initially, but then later turn it back on globally and use SetEvaluationFlag to turn it off only in specific places.

If a bug is discovered in the future (i.e., the optimization screws up something), SetEvaluationFlag will provide a way to work around it. Hopefully this won't happen.

Consider the expression, where A and B are both indexed by I, an index with 10 elements.

Var count := 0;

Var x[ ] := A;

Var y[ ] := B+x;

MsgBox(x & ',' & y);

count := count + 1;

Uniform(x, y)

The declaration for x specifies that it has no indexes, it is atomic, within the lexical context of x. Since A is indexed by I, this requires the expression that follows to be evaluated 10 times, once for each atomic value of A. The same holds for y. However, the evaluation context optimization allows Analytica to recognize that a second iteration over I is unnecessary. Hence, the body needs to be evaluated only 10 times. When this completes, count will be 10.

Without the evaluation context optimization, two nested iterations occur. You'll see a MsgBox 100 times, count will be 100 at the end, and Uniform will have been called 100 times. This illustrates three differences that the optimization can cause in legacy models: Side-effects in the form of interactions with the user may occur fewer times, side-effects in the form of variable assignments (count) may occur fewer times, and the number of calls to random number generation may occur fewer times, this altering the RandomSeed, which in turn will alter the random values sampled during Monte Carlo analysis.

Here is another example. Suppose x in indexed by I and J.

Function F(A: Array[I]; I: Index; y: atom)

F(x, I, J)[J = "profit"]

Evaluating F(x) by itself requires multiple calls to F, one for each value of J. But because only one slice of the result is used, the evaluation context optimization will cause F to be called only once. If your function F has side-effects -- writing data to a file or external database, showing the user message boxes, assigning to variables, etc. -- the optimization may be undesirable. You would remedy this using

SetEvaluationFlag("evaluationContext", false,

F(x, I, J)[J = "profit"]

)

And one other example. Suppose A is indexed by I.

Function F1(x: atom)

Function F2(x: atom) := F1(x + I)

F2(A)

Even when x is atomic, x + I is an array indexed by I, so F1(x + I) would normally require iteration. But when F2 in being evaluated on the A[I = n] slice of A, only the I = n slice of the result of F2 will be retained, so within F2, F1 can be called a single time, essentially F2(x + n). Again, the smaller number of calls might be an issue if F1 has side-effects.

This case can be addressed either from the calling expression, or from within F2's definition. From the calling expression, we would use

SetEvaluationFlag("evaluationContext", false, F2(A))

This illustrates that the flag applies to User-Defined Functions called directly from «expr», or nested within UDFs called from «expr».

History

This function was introduced in Analytica 4.6.

SetEvaluationFlag

Contents