Page: (symbolic)Top, Next: (cpl)CHARbyCHAR, Prev: (parallel), Up: (cpl)Library Index

Symbolic differentiation

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> ) or 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 D_<svname>_<fname> 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 D_ are reserved and should not be declared for other purposes when symbolic.cpl is in USE.