View source for Draw arrows to build models

[[Category: Concepts]]
[[Category: Diagrams]]

You can do quite a bit of modeling just by drawing arrows between variables and modules without having to type in definitions explicitly. This works when the definition of the destination variable contains various kinds of list. For example, if variable <code>Y</code> is defined as a simple list in square brackets and you draw an arrow from variable <code>X</code> to <code>Y</code>, it automatically adds <code>X</code> into the list.  You can also connect modules in a similar way by drawing arrows to and from Modules with  [[TemplateInput and TemplateOutput Attributes]].

== Draw arrows to add variables into a definition ==
Suppose you draw an arrow from variable <code>A</code> to <code>B</code>. It automatically adds <code>A</code> into the definition of <code>B</code> when the definition of <code>B</code> contains one of these kinds of list:
; A list in square brackets:
For example:
:<code>B := Sum([X])</code>
* If <code>A</code> isn't already in the list, it adds <code>A</code>:
:<code>B := Sum([X, A])</code>
* Or, if <code>A</code>, is already in the list, it removes it:   
:<code>B := Sum([X])</code>
If A is the only element in the list, it replaces it by expr, for example:
:<code>B := Sum([A])</code>
* After redrawing the arrow from <code>A</code>, is already in the list, it removes it:   
:<code>B := Sum([expr])</code>

; If <code>A</code> is an Index:
If <code>B</code> is an Atom (single number or text value) or an [[Edit table]], it offers to add <code>A</code> as an Index of <code>B</code>. This offers a convenient way to add an index dimension to a model. For example:
:<code>B := 100</code>
* If <code>A</code> isn't already an index of the table, it offers to add <code>A</code> as an index. If you accept, the result is:
:<code>B := Table(A)(...)</code>
* Or, if <code>A</code>, is already an index, it offers to remove it (after warning you that it will lose data by removing a dimension). If you accept, it shows this result:
:<code>B := 100</code>

; [[Handle Functions#Function ListOfHandles|ListOfHandles]]:
For example:
:<code>B := ListofHandles([X])</code>
* If <code>A</code> isn't already in the list, it adds <code>A</code>:
:<code>B := ListofHandles([X, A])</code>
* Or, if <code>A</code>, is already in the list, it removes it:   
:<code>B := ListofHandles([X])</code>

; Repeated parameters: 
If <code>B</code> uses a function whose first parameter is qualified as [[Function_Parameter_Qualifiers#Repeated_parameters_.28....29|Repeated]] (or "..."), it behaves like an explicit list in square brackets. For example,
<pre style="background:white; border:white; margin-left: 1em;">
Function ObjList(vars: ... Variable)
B := Objlist(X)
   draw an arrow from A to B
B := Objlist(X, A)
</pre>

Note: "Repeated" means ''one or more'' elements. If you remove the last input by redrawing an arrow from <code>A</code> to <code>B</code>, it replaces it by "expr", which will not parse. If you want ''zero or more'' elements, you should qualify the parameter with [[Function_Parameter_Qualifiers#Optional_qualifier|Optional]]  along with "...", for example:
:<code>Function ObjList(vars: ... Optional Variable)</code>

'''Note:''' It automatically adds <code>A</code> into the list in <code>B</code> (or removes it if it's already there) if the defintion of <code>B</code> contains one of the above constructs as its ''only'' element. If the Definition contains one of these constructs along with others, e.g.
:<code>B := [X] + 3</code>
it does not do automatic insertion or removal. It simply adds <code>A</code> as a ''possible'' input to <code>B</code>, and leaves it to the modeler as to where to insert it into the definition.

== Delete an arrow ==

If there is an arrow from variable <code>A</code> to <code>B</code>, you can delete it 
* either by selecting the arrow and pressing the "delete" key, 
* or by redrawing the arrow from <code>A</code> to <code>B</code>. 
If <code>A</code> is already in the definition of <code>B</code>, it asks if you want to remove <code>A</code> from the Definition of <code>B</code>. If so, it puts comment brackets around the origin variable <code>{A}</code>, in the definition of <code>B</code>, so you can see what was removed. Often, the resulting definition will have bad syntax, indicated by the node for <code>B</code> becoming cross-hatched.

; Redraw a deleted arrow: If you delete an input to <code>B</code> as above, and then redraw an arrow from <code>A</code> to <code>B</code>, it restores the original definition by removing the comment brackets <code>{A}</code> around the variable, <code>A</code>. 

== Drawing arrows to Modules with TemplateInput and TemplateOutput attributes ==

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 variables as the [[TemplateInput]] attribute of the module, and another variable as the [[TemplateOutput]] attribute. When you draw an arrow into a template module, it's the same as drawing an arrow into its template input variable.  So, if the definition of the Template input variable contains a list [], ListofVariables, Edit table, or uses a function with a repeated parameter (as described above),  when you draw an arrow into the module, it inserts the origin variable into the list. When you draw an arrow from a module with a  [[TemplateOutput]], it's as if you were drawing an arrow from the variable in the [[TemplateOutput]].

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.

==See Also==
* [[Draw arrows]]
* [[Draw arrows between modules]]
* [[Template Modules]]
* [[TemplateInput and TemplateOutput Attributes]]
* [[Creating or editing a definition]]
* [[Function Parameter Qualifiers]]