Vensim Help

The VECTOR SELECT function provides a convenient mechanism for selecting values from elements in an array.

 
Function arguments

 

numerical_action can take the following values

 
error_action tells Vensim how to treat too many or too few entries in the selection array. It can take the following values.

 
The VECTOR SELECT function is very similar to formulations such as:

result[row] = SUM(sarray[row,col!]*expr[col!]) 

but has two important differences. The first is that causal tracing, instead of indicating that every element of expr is a cause of every element of result will only display those elements where there is a nonzero element in sarray. The second is that the expression that appears as the second argument is only evaluated when it will contribute to the computation and not for every possible row and column combination.

Related to the second of these, since some elements of vexp might not be used, Vensim does not verify that all are actually computed. Thus "Used not computed" error messages will not be generated for variables involved in the vexp argument of the VECTOR SELECT function (all other arguments, including sarray are tested).  If an array element is not computed it has the value :NA: which will normally lead to a floating point error or visibly anomalous results during simulation should it be used. However, extra caution is called for when making use of the VECTOR SELECT function.

Note that causal tracing is only changed for the Strip Graph and Table tools. The structural tools do not reference subscripts. When tracing causes using simulation results if there are no runs loaded, or if the loaded runs do not contain values for sarray, then no causes will be listed. If sarray is different in different runs then the union of all possible causes will be displayed. In this case some of the causes will not be applicable to some of the runs, you will need to check the values of sarray to see which apply.

VECTOR SELECT is very useful for prerequisite mapping as well as compression and expansion of array sizes as shown in the examples. For the first two of these err would normally be set to 1 while for vector expansion err would normally be set to 3. If err is 0 or 2 and there are no non-zero elements then the function will return mval. If err is 1 or 3 then mval will never be used and a value of :NA: is recommended.

If sarray is an Unchangeable Constant (defined using ==) then the causality of VECTOR SELECT used in determining equation order is based on only the nonzero elements of sarray. This provides a convenient mechanism for propagating dependencies between subscript elements. An example of this for a project is included below.

Example

In order to determine whether all prerequisite tasks are completed:

task : t1,t2,t3,t4

prereq <-> task

prereq map[task,prereq] == 

0,0,0,0;

1,0,0,0;

1,1,0,0;

0,0,1,0;

Note that the first row of prereq mat is all 0s – so for t1 prereq is complete will use the 3rd argument to the function or 1 which is what we want since t1 does not have any prerequisites.

Example

Quality depends on both work quality and the quality of prerequisite work products. Using the above task and prerequisite definitions:

task quality[task] = work quality[task] * prereq quality[task]

work quality[task] = .8,.9,.7,.9

For this to work we depend on prereq map being defined as an Unchangeable Constant. If it weren’t, then there would be a simultaneous equation involving work quality and task quality.

Example

To move between cohort aggregations and disaggregations:

Age : a1,a2,a3,a4,a5,a6

AgeGroup : ag1,ag2,ag3

age grouping map[AgeGroup,Age] = 

1,1,0,0,0,0;

0,0,1,1,0,0;

0,0,0,0,1,1;

Example

Simplified heat transfer on a two dimensional surface. This uses two subscripts to select from and also treats the edge determination using VECTOR SELECT. The

x:(x1-x3)

y:(y1-y4)

edge : left,right,top,bottom 

xp <-> x 

yp <-> y

average adjacent temp diff[x,y] = (

  VECTOR SELECT(adjacency matrix[x,y,xp!,yp!],

           temp[xp!,yp!]-temp[x,y],:NA:,0,1) + 

  VECTOR SELECT(edge matrix[x,y,edge!],

           edge temp[edge!]-temp[x,y],0,0,0)

       ) / 4

adjacency matrix[x,y,xp,yp] = INITIAL(

 IF THEN ELSE((yp = y+1 :AND: xp = x) :OR:

              (yp = y-1 :AND: xp = x) :OR:

              (xp = x+1 :AND: yp = y) :OR:

              (xp = x-1 :AND: yp = y),

              1,0)) 

edge matrix[x,y,edge] = INITIAL(

 IF THEN ELSE((y = 1 :AND: edge = top) :OR:

              (y = elmcount(y) :AND: edge = bottom) :OR:

              (x = 1 :AND: edge = left) :OR:

              (x = elmcount(x) :AND: edge = right),

              1,0)) 

Note that the VECTOR SELECT function does not use average but sums for this computation. Since some of  the 4 adjacent positions might come from edges and some from other cells the averaging is done outside of the function (with simply /4).

 

Units: VECTOR SELECT(unit1,unit2,units,dmnl,dmnl) --> units=units1*units2

Restrictions: Both sarr and vexpr must have at least one subscript with an !. Normally there will be one subscript acted on with the ! and that subscript will be that is the same in both sarr and vexpr but this is not a requirement.

Availability: Professional and DSS only.

 

See also: PROD, SUM, VMIN and VMAX.

Sample model: VECTOR SELECT.mdl in FunctionExamples