Error Messages/41302

Example warning message

 Operating over the dynamic index Time in the call to function Sum from within a dynamic loop. 
 The semantics of this operation may be different than you expect.

Cause

This warning usually highlights a conceptual error in your definition(s). It occurs when you do something like this:

Dynamic(0, Sum(Revenue, Time) - newExpenses[Time - 1])

or this:

Dynamic(Cumulate(Revenue, Time))

The key here being that a function is operating over the Time index from within a dynamic loop. The error will result even if the array operation does not appear within the Dynamic function, but is itself inside a dynamic loop formed by a call to Dynamic in another variable. For example:

Variable Revenue := Dynamic(... CumRevenue[Time - 1] ... )

Variable CumRevenue := Cumulate(Revenue, Time)

In most cases when people try something like this, what they are encoding is quite a bit different from what they think they are encoding, which is why the error arises. When a dynamic loop is being evaluated, the definition(s) are being evaluated at a single point in time. An easy way to conceptualize this is that every value involved in the definition has been implicitly sliced to the current time slice. So when the Time = 3 value is being evaluated, the expression being evaluated for CumRevenue is essentially:

Cumulate(Revenue[Time = 3], Time)

When you wrote the expression, you were probably thinking that the parameter inside Cumulate would vary along the time index, perhaps containing the values computed so far or something along those lines. But in fact, what you get is a single element of the array. So instead of an array containing e.g., [23, 24, 50, uncomputed, uncomputed,...] (future times haven't been computed yet), you might get just 56. When you cumulate this over Time, it is treated as if the array being cumulated is constant for every time period, i.e., [50, 50, 50, 50, 50,...]. So the cumulated result would be [50, 100, 150, 200, 250,...] -- which is not what you expected, right?

If you understand that the value being used are pre-sliced, then maybe your expression is doing what you think. Far more likely, however, you have conceptualized incorrect how you should be expressing your logic inside a dynamic loop. One thing to keep in mind is that when you operate over a value, the implication is that its full value has already been computed. So if you compute Sum(A, Time), this makes sense only if A has already been fully computed for all time points. If A requires a result from your current definition (e.g., at an earlier time point), then it cannot possibly be fully computed when your definition is being evaluated.

Remedy

In most cases where people attempt to encode logic, such as a cumulation of previous values, along a dynamic index, there are usually more direct ways to encode this using Dynamic. For example:

Variable CumRevenue := Dynamic(Revenue, Revenue + Self[Time - 1])

Variable PeakRevenue := Dynamic(Revenue, Max([Self[Time - 1], Revenue]))

In some cases, it makes sense to utilize a local index that spans only previous time periods:

Variable PeakRevenue := Dynamic(Revenue,
   Index prevT := Subset(IndexValue(Time) < Time);
      Max(Revenue[Time = prevT], prevT]
   )

See Also

• Time
• Dynamic
• Cumulate
• Sum