Draw arrows to build models

It is possible to do quite a bit of modeling and creating definitions without typing -- just by drawing arrows between variables or modules.

Draw arrow from index into a variable

If you draw an arrow from Index I to node A: If I is not already in input of A, it asks if you want to add I as an extra dimension of A. If yes, it adds I as a dimension, making it a an Edit table (if it isn't already). It asks if you want to copy the existing definition of A into each element of the table over I. If not, it puts the old definition in the first element and fills the rest by zeros. If I is already an index of A, it asks if you want to remove it, and warns that doing so will lose data. If yes, it the new definition of A is the first slice over I of the old array.

Redraw or delete an arrow

If you draw an arrow from variable A to B and A is already in the definition of B, it asks if you want to remove A from the Definition of B. If yes, it puts comment brackets around A, {A}, in the definition of B, so you can see what was removed. The resulting definition will often not parse, so the node for B becomes cross-hatched. It does the same if you delete an arrow -- select the arrow and press the "delete" key.

Redraw a deleted arrow

If you delete an input to B as above, and then redraw an arrow from A to B, it restores the original definition by removing the comment brackets {A} around the variable, A.

Arrow into a list

If you draw an arrow from A to B, and B contains a list, enclosed in square brackets, such as

 B := Sum([X])

• It adds A into the list (if it wasn't already in it)"

  B := Sum([X, A]) 

• Or if you draw an arrow from a variable X into B that is already in the list, it removes the origin variable from the list:

 B := Sum([A])

Repeated parameters

If B uses a function whose first parameter is Repeated (ellipsis or "..."), it behaves much the same as an explicit list in square brackets. For example,

Function ObjList(vars: ... Variable)
B := Objlist(X)
   draw an arrow from A to B
B := Objlist(X, A)

Note: "Repeated" usually means one or more elements. If you remove the last input by redrawing an arrow from A to B, it replaces it by "expr", which will not parse. If you want zero or more elements, you should qualify the parameter with Optional along with "...", for example:

 Function ObjList(vars: ... Optional Variable)

By using these methods, you can define functions that let you wire together complex models simply by drawing arrows between nodes -- without having to edit their definitions explicitly.

Module templates

You can even construct models by drawing arrows to and from modules, if the modules are set up as templates. A Template module should have one of its internal variables in the TemplateInput attribute of the module, and another variable in the TemplateInput attribute. When you draw an arrow into a template module, it's the same as drawing an arrow into its template input variable. And when you draw an arrow from the module, it's the same as drawing an arrow from the template output variable. So, if the definition of the Template input variable contains a list [] or uses a function with a repeated parameter, drawing an arrow inserts the origin variable into the list. It's often useful to create a template module and then make copies of it for particular instantiations. You can link them together by drawing arrows.