# Command: Function

NEST HelpDesk | Command Index | NEST Quick Reference

Name:

    Function - creates pure function with named arguments

Synopsis:

      {proc} literal_1 ... literal_n   Function -> proc'
      string literal_1 ... literal_n   Function -> proc'
      [literal_1 ... literal_n] {proc}  Function -> proc'
      [literal_1 ... literal_n] string  Function -> proc'

Examples:

      2   {x 1 x add mul} /x   Function exec --> 6
      2 3 {x 1 x add mul} /x /y Function exec --> 6
      2 3 {x y x add mul} /x /y Function exec --> 10
      2 3   ( x*(y+x) )   /x /y Function exec --> 10

      ( x*(y+x) ) /x /y Function --> {<< >> begin /y Set /x Set x y x add mul end}

      [2. 3. 4. 5.]  (x + (1+x)^3) /x Function Map --> [29. 67. 129. 221.]

      /f ( x*(y+x) )  /x /y  Function def
      /f [/x /y] ( x*(y+x) ) Function def

      /f [/doubletype /doubletype] [/x /y] (y+x^2) Function def
      /f [/doubletype /doubletype] [/x /y] {y x dup mul add} Function def

      /f [] (x=sin(0.7);x^2-3*x) Function def

      Version: 090302

Description:

      Pure functions are one of the most powerful features of SLI. They are
      first class objects and can be assembled at run time like arrays. Some
      times pure functions are constructed for one time execution, however more
      often they are used as arguments of functional operators like Map and Fold
      executing the pure function many times.
      If a pure function has several arguments or a particular argument is used many
      times in the code managing the location of the arguments on the stack can be
      cumbersome. In these situations operator Function is helpful, it assigns each
      argument of the pure function to a formal name which can be used in the body
      of function. If the pure function is specified as a string, Compile Math is
      called for conversion to rpn. Note that the example combining Function and Map
      is efficient. The pure function is constructed from the string only once but
      executed 4 times with different arguments. In the alternative syntax the variables
      are declared by an array prior to the body of the function. This notation increases
      the readability of definitions of  named functions because in most programming
      languages the declaration of variables preceeds the function body. In combination
      with operator def also the type of the arguments can be specified. The definition
      of a function without arguments is useful if the body of the function introduces
      local variables and therefore profits from the automatic restriction of scope by
      operator Function. This is shown in the last example. Without the empty array the
      arguments of Function would not be unique.
      The availability of the alternative version ExecFunction with immediate execution
      highlights the fact that a pure function with named arguments maybe used
      for clarity even in situations where it needs to be evaluated only once.

Parameters:

      proc		- code body using variables
      string		- code body using variables in infix notation
      literal_i 	- the name of the ith argument
      proc'		- pure function with named arguments

References:

      [1] The Mathematica Book "Function"

Author:

    Diesmann

SeeAlso:

- CompileMath
- Inline
- ExecFunction

Source:

    /opt/conda/conda-bld/nest_1512421404550/work/nest-2.12.0/lib/sli/mathematica.sli

NEST HelpDesk | Command Index | NEST Quick Reference

© 2004 The NEST Initiative