Page: (symbolic)Top, Next: (cpl)CHARbyCHAR
, Prev: (parallel)
, Up: (cpl)Library Index
The symbolic.cpl library adds concurrent symbolic differentiation to CPL. Symbolic differentiation is seamlessly integrated in the compiler, and is performed at compile time: any desired symbolic derivatives are worked out during compilation, and inlined in the generated code. Contrary to most other symbolic-math environments, therefore, the purpose is not so much to generate user-readable derivatives as to generate (hopefully effective) inline code while keeping the visible code as close to pen-and-paper notation as possible.
Symbolic manipulation operates upon and produces (cpl)INLINE
FUNCTIONs. The INLINE FUNCTION declaration (with untyped arguments) operates similarly to #define:(cpl)
C preprocessor: and is almost interchangeable with it, except that internally it places parentheses around arguments (thus guarding against operator precedence), and that its rhs must be a well-formed algebraic expression rather than an arbitrary string, and thus can end at
like all CPL instructions, rather than at end-of-line only as for #define. An INLINE FUNCTION without arguments is also interchangeable with the == (cpl)Deferred assignment
operator. Being a symbolic construction, an inline expression can contain yet undeclared variables; at the later position where the inline expression directly or indirectly appears in an executable statement, code for it is actually generated just as for ==. If all the required declarations have not appeared before this later point, a compilation error will turn up.
The derivative of an INLINE FUNCTION with respect to a symbolic variable <svname> (which is not allowed to contain an underscore in its name) is denoted by either
D_<svname>( <function name> )
D( <function name> , <svname> )
When the latter form is used, <svname> may also be an array element (in the usual indexed notation). The derivative of an INLINE FUNCTION is another INLINE FUNCTION, and can be differentiated further, given a name or used in the definition of a new compound INLINE FUNCTION, or eventually appear in an executable statement.
Higher derivatives and more general compound differential operators, which take an expression as their argument, can be defined in a similar syntax. For example:
INLINE FUNCTION laplacian(f)=D_x(D_x(f))+D_y(D_y(f))+D_z(D_z(f))
A mechanism is provided to associate a derivative with a user-defined expression (or more generally to override automatic differentiation): if a variable named
is declared, it will be preferentially used as the value of the derivative of function <fname> with respect to variable <svname> wherever such differentiation is attempted. If no such variable is declared and <fname> was previously defined as an INLINE FUNCTION, its derivative will be automatically generated. If <fname> is yet undeclared, or was declared as an ordinary CPL VARIABLE (or CONSTANT) rather than as an INLINE FUNCTION, it will be treated as a constant the derivative of which is zero.
As a side effect, variable and function names starting with
are reserved and should not be declared for other purposes when symbolic.cpl is in USE.