Difference between revisions of "Index..Do"

m (Index I := seqExpr Do)
(See Also)
 
(3 intermediate revisions by the same user not shown)
Line 2: Line 2:
 
[[Category:Doc Status C]] <!-- For Lumina use, do not change -->
 
[[Category:Doc Status C]] <!-- For Lumina use, do not change -->
  
= Index I := seqExpr Do body =
+
__TOC__
  
The construct, '''''Index i := seqExpr''''' defines an index local to the definition in which it is used. The expression ''seqExpr'' may be a sequence, literal list, or other expression that generates an unindexed array, as used to define a global index. For example:
+
== Index I := seqExpr Do body ==
Variable PowersOf2
+
The construct, <code>Index i := seqExpr</code> defines an index local to the definition in which it is used. The expression «seqExpr» may be a sequence, literal list, or other expression that generates an unindexed array, as used to define a global index. For example:
Definition: Index J := 0..5;  
+
:<code>Variable PowersOf2</code>
            2^J
+
:<code>Definition: Index J := 0..5;</code>
The new Variable ''PowersOf2'' is an array of powers of two, indexed by the local index ''J'', with values from 0 to 5:
+
::<code>2^J</code>
:PowersOf2 → [[image:PowersOf2.jpg]]
+
  
= Dot Operator: A.I =
+
The new Variable <code>PowersOf2</code> is an array of powers of two, indexed by the local index <code>J</code>, with values from 0 to 5:
 +
:<code>PowersOf2 &rarr;</code>
 +
:[[image:PowersOf2.jpg]]
  
The dot operator in '''''A.I''''' lets you access a local index ''I'' via an array ''A'' that it dimensions. If a local index identifies a dimension of an array that becomes the value of a global Variable, it may persist long after valuation of the expression—unlike other local Variables which disappear after the expression is evaluated.
+
== Dot Operator: A.I ==
 +
The dot operator in '''A.I''' lets you access a local index «I» via an array «A» that it dimensions. If a local index identifies a dimension of an array that becomes the value of a global Variable, it may persist long after valuation of the expression—unlike other local Variables which disappear after the expression is evaluated.
  
Even though local index J has no global identifier, you can access it via its parent Variable with the dot operator, ’.’, for example:
+
Even though local index <code>J</code> has no global identifier, you can access it via its parent Variable with the dot operator, ’.’, for example:
  
:PowersOf2.J [0,1,2,3,4,5]
+
:<code>PowersOf2.J &rarr; [0, 1, 2, 3, 4, 5]</code>
  
When using the subscript operation on a Variable with a local index, you need to include the ’.’ operator, but do not need to repeat the name of the Variable:
+
When using the subscript operation on a <code>Variable</code> with a local index, you need to include the ’.’ operator, but do not need to repeat the name of the <code>Variable</code>:
:PowersOf2[.J=5] 32
+
:<code>PowersOf2[.J = 5] &rarr; 32</code>
Any other Variables depending on ''PowersOf2'' may inherit ''J'' as a local index—for example:
+
Variable P2
+
Definition: PowersOf2/2
+
:P2[.J=5] → 16
+
  
= Examples using a local index =
+
Any other Variables depending on <code>PowersOf2</code> may inherit <code>J</code> as a local index—for example:
 +
:<code>Variable P2</code>
 +
:<code>Definition: PowersOf2/2</code>
 +
::<code>P2[.J = 5] &rarr; 16</code>
  
In this example, ''MatSqr'' is a user-defined function that returns the square of a matrix—i.e., ''A x A''', where ''A''' is the transpose of ''A''. The result is a square matrix. Rather than require a third index as a parameter, ''MatSqr'' creates the local index, ''I2'', as a copy of index ''I''.
+
== Examples using a local index ==
 +
In this example, <code>MatSqr</code> is a user-defined function that returns the square of a matrix—i.e., <code>A x A</code>, where <code>A</code> is the transpose of <code>A</code>. The result is a square matrix. Rather than require a third index as a parameter, <code>MatSqr</code> creates the local index, <code>I2</code>, as a copy of index <code>I</code>.
  
Function MatSqr(a: ArrayType; i,j: IndexType)
+
:<code>Function MatSqr(a: ArrayType; i, j: IndexType)</code>
Definition:
+
:<code>Definition:</code>
  Index I2:=i;
+
::<code>Index I2 := I;</code>
  Sum(a*a[i=I2], j)
+
::<code>Sum(A*A[i = I2], j)</code>
  
''The local Variable,'' I2, in ''MatSqr'' is not within lexical scope in the definition of ''Z'', so we must use the dot operator ’.’ to access this dimension. We underline the dot operator for clarity:
+
The local Variable, <code>I2</code>, in <code>MatSqr</code> is not within lexical scope in the definition of <code>Z</code>, so we must use the dot operator ’.’ to access this dimension. We underline the dot operator for clarity:
Variable Z
+
:<code>Variable Z</code>
Definition:
+
:<code>Definition:</code>
  Var XX := MatSqr(X, Rows, Cols);
+
::<code>Var XX := MatSqr(X, Rows, Cols);</code>
  Sum(XX * Y[Rows=XX.I2], XX.I2)
+
::<code>Sum(XX*Y[Rows = XX.I2], XX.I2)</code>
  
The above definition of Z assumes that the model contains a matrix variable, X, indexed by Rows and Cols, and a variable Y indexed by Rows.
+
The above definition of <code>Z</code> assumes that the model contains a matrix variable, <code>X</code>, indexed by <code>Rows</code> and <code>Cols</code>, and a variable <code>Y</code> indexed by <code>Rows</code>.
 
+
= Detailed Notes =
+
 
+
== Specifying the Index Identifier ==
+
  
 +
== Detailed Notes ==
 +
=== Specifying the Index Identifier ===
 
You can explicitly specify the identifier for an index using:
 
You can explicitly specify the identifier for an index using:
  
Index I / identExpr := seqExpr Do bodyExpr
+
:<code>Index I / identExpr := seqExpr Do bodyExpr</code>
  
the ''identExpr'' is evaluated, so that the identifier can be computed.  The identExpr must evaluate to a text string containing a legal Analytica identifier.  Within the lexical scope of bodyExpr, the local identifier I refers to the index.  To refer to an index using the dot operator, use the identExpr.  If the index appears in result windows or elsewhere, its identifier is displayed.
+
the «identExpr» is evaluated, so that the identifier can be computed.  The «identExpr» must evaluate to a text string containing a legal Analytica identifier.  Within the lexical scope of «bodyExpr», the local identifier «I» refers to the index.  To refer to an index using the dot operator, use the «identExpr».  If the index appears in result windows or elsewhere, its identifier is displayed.
  
 
Examples:
 
Examples:
  
  Var A := ( Index I / "MyInd" := 1..10 do I^2 );
+
:<code>Var A := (Index I / "MyInd" := 1..10 do I^2);</code>
  [[Sum]](A, A.MyInd)
+
:<code>Sum(A, A.MyInd)</code>
  
 
The next, more complex example, creates a list of indexes, one index corresponding to each column of a table (sans the final column).  It then transforms the table into a multi-dimensional array.  The number of indexes created is arbitrary.  The column label is used for the local index name.
 
The next, more complex example, creates a list of indexes, one index corresponding to each column of a table (sans the final column).  It then transforms the table into a multi-dimensional array.  The number of indexes created is arbitrary.  The column label is used for the local index name.
  
  Function Table_to_array(A : Array[Rows,Columns] ; Rows,Columns : IndexType )
+
:<code>Function Table_to_array(A : Array[Rows, Columns] ; Rows, Columns: IndexType)</code>
  Definition:
+
:<code>Definition:</code>
    [[MetaIndex..Do|MetaIndex]] Inds :=  
+
::<code>MetaIndex Inds :=</code>
      (
+
:::<code>(</code>
          [[For..Do|For]] c := 1..[[Size]](Columns)-1 do (
+
::::<code>For c := 1..Size(Columns)-1 do (</code>
              [[Var..Do|Var]] v := [[Subscript/Slice Operator|A[@Columns=c] ]];
+
:::::<code>Var v := A[@Columns = c];</code>
              Index I / [[Slice]](Columns,c) := v[Rows=[[Unique]](v, Rows )];
+
:::::<code>Index I / Slice(Columns, c) := v[Rows = Unique(v, Rows)];</code>
              [[VarTerm]](I)
+
:::::<code>VarTerm(I)</code>
          )
+
::::<code>)</code>
    );
+
:::<code>);</code>
    [[MdTable]](A,Rows,Columns,inds)
+
:::<code>MdTable(A, Rows, Columns, inds)</code>
  
== Setting attributes ==
+
=== Setting attributes ===
  
Index..Do creates a new index object.  It does not exist in the global namespace, but it is a full-fledged object with attributes of its own, in the same way a global index or variable object has attributes.  Therefore, you can set its Units, Title, Description, etc., attributes after it is created.  Analytica 4.0 will allow these side-effects, even if the expression is not being evaluated from a button script.
+
[[Index..Do]] creates a new index object.  It does not exist in the global namespace, but it is a full-fledged object with attributes of its own, in the same way a global index or variable object has attributes.  Therefore, you can set its <code>Units, Title, Description</code>, etc., attributes after it is created.  Analytica 4.0 will allow these side-effects, even if the expression is not being evaluated from a button script.
  
 
Example:
 
Example:
Index T := 1..12;
+
:<code>Index T := 1..12;</code>
Title of T := "Time Offset";
+
:<code>Title of T := "Time Offset";</code>
Units of T := "Months";
+
:<code>Units of T := "Months";</code>
T
+
:<code>T</code>
  
When a local index appears in result views, attributes such as Title, Units, and description may impact what the user sees.  For example, the "Show By Identifier" toggle on the object menu determines whether the title or identifier of the index is shown to the user.
+
When a local index appears in result views, attributes such as <code>Title, Units</code>, and description may impact what the user sees.  For example, the "Show By Identifier" toggle on the '''Object''' menu determines whether the title or identifier of the index is shown to the user.
  
== Using an alias to an index ==
+
=== Using an alias to an index ===
 +
Within an expression, the <code>A.I</code> syntax can sometimes be a lengthy way to refer to an existing index.  This can be shortened by using a local variable as an alias to an existing index.  For example, the following are equivalent:
  
Within an expression, the A.I syntax can sometimes be a lengthy way to refer to an existing index.  This can be shortened by using a local variable as an alias to an existing index.  For example, the following are equivalent:
+
:<code>Subscript(TheFinalResult, TheFinalResult.MyLongIndex, Unique(TheFinalResult, TheFinalResult.MyLongIndex))</code>
  
[[Subscript]]( TheFinalResult, TheFinalResult.MyLongIndex, [[Unique]]( TheFinalResult, TheFinalResult.MyLongIndex ) )
+
:<code>Var R := Handle(TheFinalResult);</code>
 
+
:<code>Var I := Handle(R.MyLongIndex, AsIndex: True);  { ''I'' is an alias for ''TheFinalResult.MyLongIndex'' }</code>
[[Var..Do|Var]] R := [[Handle]](TheFinalResult);
+
:<code>Subscript(r, I, Unique(R, I))</code>
[[Var..Do|Var]] I := [[Handle]](R.MyLongIndex,AsIndex:True);  { ''I'' is an alias for ''TheFinalResult.MyLongIndex'' }
+
[[Subscript]](r,I,[[Unique]](R,I))
+
  
 
Note that when creating an alias for an existing index, you use [[Var..Do]], not [[Index..Do]].  If you were to use [[Index..Do]], you would instantiate a new index object.
 
Note that when creating an alias for an existing index, you use [[Var..Do]], not [[Index..Do]].  If you were to use [[Index..Do]], you would instantiate a new index object.
  
= Assignment =
+
== Assignment ==
 
+
 
Assignment to a local index variable is a bit strange and may have a different effect than you expect unless you have a deep understanding of what is happening.
 
Assignment to a local index variable is a bit strange and may have a different effect than you expect unless you have a deep understanding of what is happening.
  
 
First, it is important to remember that assigning to a local index variable ''does not change the value of the underlying local index.''  Changing the index value directly is not allowed by Analytica, since there may be intermediate arrays already in memory that are indexed by that index.  The following example illustrates this point:
 
First, it is important to remember that assigning to a local index variable ''does not change the value of the underlying local index.''  Changing the index value directly is not allowed by Analytica, since there may be intermediate arrays already in memory that are indexed by that index.  The following example illustrates this point:
  
Index J := 1..5;
+
:<code>Index J := 1..5;</code>
[[Var]] A := J^2;
+
:<code>Var A := J^2;</code>
[[Var]] B := J+5;
+
:<code>Var B := J + 5;</code>
J := [[Subset]]([[Mod]](J,2)=1);
+
:<code>J := Subset(Mod(J, 2) = 1);</code>
...
+
:<code>...</code>
  
The above assignment to ''J'' does not alter arrays ''A'' or ''B''.  Both arrays continue to be indexed by .J, with length 5, even though the result of [[Subset]] is 3.  In other words, the original local index ''J'' is unaltered by the assignment operation -- only the local variable ''J'' (as distinct from the index ''J'') changes.
+
The above assignment to <code>J</code> does not alter arrays <code>A</code> or <code>B</code>.  Both arrays continue to be indexed by <code>.J</code>, with length 5, even though the result of [[Subset]] is 3.  In other words, the original local index <code>J</code> is unaltered by the assignment operation -- only the local variable <code>J</code> (as distinct from the index <code>J</code>) changes.
  
== Assignment of list or 1-D array to local index variable ==
+
=== Assignment of list or 1-D array to local index variable ===
  
''New to Analytica 4.2:'' When you assign a list or 1-D array to a local index variable, Analytica 4.2 creates a new index object with the same identifier as was used previously, and sets it to the new value.  In the above example, therefore, ''J'' continues to function as a valid index and can be used in [[Slice]] or [[Subscript]] operators, etc.  Immediately following the assignment, if the old index is still in use by existing intermediate arrays, two local indexes with the same identifier will momentarily co-exist.  Consider:
+
''New to Analytica 4.2:'' When you assign a list or 1-D array to a local index variable, Analytica 4.2 creates a new index object with the same identifier as was used previously, and sets it to the new value.  In the above example, therefore, <code>J</code> continues to function as a valid index and can be used in [[Slice]] or [[Subscript]] operators, etc.  Immediately following the assignment, if the old index is still in use by existing intermediate arrays, two local indexes with the same identifier will momentarily co-exist.  Consider:
  
Index J := 1..5;
+
:<code>Index J := 1..5;</code>
[[Var]] A := J^2;
+
:<code>Var A := J^2;</code>
[[Var]] B := J+5;
+
:<code>Var B := J + 5;</code>
J := [[Subset]]([[Mod]](J,2)=1);
+
:<code>J := Subset(Mod(J, 2) = 1);</code>
A[.J=J] + B[.J=J]
+
:<code>A[.J = J] + B[.J = J]</code>
  
In the last line, the .J (short for A.I) refers to the original local index object, while the ''J'' to the right of the equal sign refers to the new index object.  The result is indexed by the new local index ''J'' having index values [1,3,5].
+
In the last line, the <code>.J</code> (short for <code>A.I</code>) refers to the original local index object, while the <code>J</code> to the right of the equal sign refers to the new index object.  The result is indexed by the new local index <code>J</code> having index values <code>[1, 3, 5]</code>.
 
+
=== Analytica 4.1 behavior ===
+
  
 +
==== Analytica 4.1 behavior ====
 
''Legacy Analytica 4.1 and earlier''
 
''Legacy Analytica 4.1 and earlier''
  
Line 130: Line 127:
 
To change the index value and keep the index status, you must create a new local index and then reset the local variable value with a handle to that new index.  This is accomplished as follows:
 
To change the index value and keep the index status, you must create a new local index and then reset the local variable value with a handle to that new index.  This is accomplished as follows:
  
  Index J := 1..3;
+
:<code>Index J := 1..3;</code>
  ...
+
:<code>...</code>
  Index tmp / "J" := 4..5 Do J := [[Handle]](tmp, asIndex:true);
+
:<code>Index tmp / "J" := 4..5 Do J := Handle(tmp, asIndex: true);</code>
  ...
+
:<code>...</code>
 
+
== Assignment of scalar or multi-D values to local index ==
+
  
 +
=== Assignment of scalar or multi-D values to local index ===
 
Analytica 4.2 will issue a warning if you attempt to assign a scalar or multi-D array to a local index variable.  But it will allow the operation if you ignore the warnings.  If you assign a handle to a local index variable, Analytica 4.2 will issue a warning if the object pointed to is not a valid index (note that an evaluation of the object's value might be necessary to determine this).  These warnings are not present prior to Analytica 4.2.   
 
Analytica 4.2 will issue a warning if you attempt to assign a scalar or multi-D array to a local index variable.  But it will allow the operation if you ignore the warnings.  If you assign a handle to a local index variable, Analytica 4.2 will issue a warning if the object pointed to is not a valid index (note that an evaluation of the object's value might be necessary to determine this).  These warnings are not present prior to Analytica 4.2.   
  
Line 143: Line 139:
 
When you assign a scalar or multi-D value to a local index variable, the local variable is demoted from being a local index to simply being a local variable that contains the value. From that point on, it behaves similar to a local variable defined using [[Var..Do]].
 
When you assign a scalar or multi-D value to a local index variable, the local variable is demoted from being a local index to simply being a local variable that contains the value. From that point on, it behaves similar to a local variable defined using [[Var..Do]].
  
= See Also =
+
== See Also ==
 
+
* [[Arrays and Indexes]]
 
* [[Local Indexes]]
 
* [[Local Indexes]]
 +
* [[Domain Indexes]]
 
* [[Var..Do]]
 
* [[Var..Do]]
 
* [[MetaIndex..Do]]
 
* [[MetaIndex..Do]]

Latest revision as of 21:49, 1 July 2016


Index I := seqExpr Do body

The construct, Index i := seqExpr defines an index local to the definition in which it is used. The expression «seqExpr» may be a sequence, literal list, or other expression that generates an unindexed array, as used to define a global index. For example:

Variable PowersOf2
Definition: Index J := 0..5;
2^J

The new Variable PowersOf2 is an array of powers of two, indexed by the local index J, with values from 0 to 5:

PowersOf2 →
PowersOf2.jpg

Dot Operator: A.I

The dot operator in A.I lets you access a local index «I» via an array «A» that it dimensions. If a local index identifies a dimension of an array that becomes the value of a global Variable, it may persist long after valuation of the expression—unlike other local Variables which disappear after the expression is evaluated.

Even though local index J has no global identifier, you can access it via its parent Variable with the dot operator, ’.’, for example:

PowersOf2.J → [0, 1, 2, 3, 4, 5]

When using the subscript operation on a Variable with a local index, you need to include the ’.’ operator, but do not need to repeat the name of the Variable:

PowersOf2[.J = 5] → 32

Any other Variables depending on PowersOf2 may inherit J as a local index—for example:

Variable P2
Definition: PowersOf2/2
P2[.J = 5] → 16

Examples using a local index

In this example, MatSqr is a user-defined function that returns the square of a matrix—i.e., A x A, where A is the transpose of A. The result is a square matrix. Rather than require a third index as a parameter, MatSqr creates the local index, I2, as a copy of index I.

Function MatSqr(a: ArrayType; i, j: IndexType)
Definition:
Index I2 := I;
Sum(A*A[i = I2], j)

The local Variable, I2, in MatSqr is not within lexical scope in the definition of Z, so we must use the dot operator ’.’ to access this dimension. We underline the dot operator for clarity:

Variable Z
Definition:
Var XX := MatSqr(X, Rows, Cols);
Sum(XX*Y[Rows = XX.I2], XX.I2)

The above definition of Z assumes that the model contains a matrix variable, X, indexed by Rows and Cols, and a variable Y indexed by Rows.

Detailed Notes

Specifying the Index Identifier

You can explicitly specify the identifier for an index using:

Index I / identExpr := seqExpr Do bodyExpr

the «identExpr» is evaluated, so that the identifier can be computed. The «identExpr» must evaluate to a text string containing a legal Analytica identifier. Within the lexical scope of «bodyExpr», the local identifier «I» refers to the index. To refer to an index using the dot operator, use the «identExpr». If the index appears in result windows or elsewhere, its identifier is displayed.

Examples:

Var A := (Index I / "MyInd" := 1..10 do I^2);
Sum(A, A.MyInd)

The next, more complex example, creates a list of indexes, one index corresponding to each column of a table (sans the final column). It then transforms the table into a multi-dimensional array. The number of indexes created is arbitrary. The column label is used for the local index name.

Function Table_to_array(A : Array[Rows, Columns] ; Rows, Columns: IndexType)
Definition:
MetaIndex Inds :=
(
For c := 1..Size(Columns)-1 do (
Var v := A[@Columns = c];
Index I / Slice(Columns, c) := v[Rows = Unique(v, Rows)];
VarTerm(I)
)
);
MdTable(A, Rows, Columns, inds)

Setting attributes

Index..Do creates a new index object. It does not exist in the global namespace, but it is a full-fledged object with attributes of its own, in the same way a global index or variable object has attributes. Therefore, you can set its Units, Title, Description, etc., attributes after it is created. Analytica 4.0 will allow these side-effects, even if the expression is not being evaluated from a button script.

Example:

Index T := 1..12;
Title of T := "Time Offset";
Units of T := "Months";
T

When a local index appears in result views, attributes such as Title, Units, and description may impact what the user sees. For example, the "Show By Identifier" toggle on the Object menu determines whether the title or identifier of the index is shown to the user.

Using an alias to an index

Within an expression, the A.I syntax can sometimes be a lengthy way to refer to an existing index. This can be shortened by using a local variable as an alias to an existing index. For example, the following are equivalent:

Subscript(TheFinalResult, TheFinalResult.MyLongIndex, Unique(TheFinalResult, TheFinalResult.MyLongIndex))
Var R := Handle(TheFinalResult);
Var I := Handle(R.MyLongIndex, AsIndex: True); { I is an alias for TheFinalResult.MyLongIndex }
Subscript(r, I, Unique(R, I))

Note that when creating an alias for an existing index, you use Var..Do, not Index..Do. If you were to use Index..Do, you would instantiate a new index object.

Assignment

Assignment to a local index variable is a bit strange and may have a different effect than you expect unless you have a deep understanding of what is happening.

First, it is important to remember that assigning to a local index variable does not change the value of the underlying local index. Changing the index value directly is not allowed by Analytica, since there may be intermediate arrays already in memory that are indexed by that index. The following example illustrates this point:

Index J := 1..5;
Var A := J^2;
Var B := J + 5;
J := Subset(Mod(J, 2) = 1);
...

The above assignment to J does not alter arrays A or B. Both arrays continue to be indexed by .J, with length 5, even though the result of Subset is 3. In other words, the original local index J is unaltered by the assignment operation -- only the local variable J (as distinct from the index J) changes.

Assignment of list or 1-D array to local index variable

New to Analytica 4.2: When you assign a list or 1-D array to a local index variable, Analytica 4.2 creates a new index object with the same identifier as was used previously, and sets it to the new value. In the above example, therefore, J continues to function as a valid index and can be used in Slice or Subscript operators, etc. Immediately following the assignment, if the old index is still in use by existing intermediate arrays, two local indexes with the same identifier will momentarily co-exist. Consider:

Index J := 1..5;
Var A := J^2;
Var B := J + 5;
J := Subset(Mod(J, 2) = 1);
A[.J = J] + B[.J = J]

In the last line, the .J (short for A.I) refers to the original local index object, while the J to the right of the equal sign refers to the new index object. The result is indexed by the new local index J having index values [1, 3, 5].

Analytica 4.1 behavior

Legacy Analytica 4.1 and earlier

When you declare a local index variable, Analytica does two things: (1) It creates a local index object, and (2) it creates a local variable and assigns it a handle that points to the index object. When you assign a value to that local variable, it changes the local variable to point to the new value. So prior to the assignment operator, the local variable points to an index object, while after assignment it points to a 1-D array or list value, which is a non-object. Because the local variable no longer points to an index, it loses its index status, and from that point behaves similarly to a local variable defined using Var..Do.

To change the index value and keep the index status, you must create a new local index and then reset the local variable value with a handle to that new index. This is accomplished as follows:

Index J := 1..3;
...
Index tmp / "J" := 4..5 Do J := Handle(tmp, asIndex: true);
...

Assignment of scalar or multi-D values to local index

Analytica 4.2 will issue a warning if you attempt to assign a scalar or multi-D array to a local index variable. But it will allow the operation if you ignore the warnings. If you assign a handle to a local index variable, Analytica 4.2 will issue a warning if the object pointed to is not a valid index (note that an evaluation of the object's value might be necessary to determine this). These warnings are not present prior to Analytica 4.2.

From that point, the behavior of Analytica 4.2 and Analytica 4.1 and earlier is the same.

When you assign a scalar or multi-D value to a local index variable, the local variable is demoted from being a local index to simply being a local variable that contains the value. From that point on, it behaves similar to a local variable defined using Var..Do.

See Also

Comments


You are not allowed to post comments.