$SPAD/src/input expr.input

Timothy Daly December 3, 2016

Abstract

Contents

2

1 License

— license —

--Copyright The Numerical Algorithms Group Limited 1991.

———-

— * —

)set break resume
)spool expr.output
)set message test on
)set message auto off
)clear all
--S 1 of 29
foo := operator 'foo
--R
--R
--R   (1)  foo
--R                                                          Type: BasicOperator
--E 1
--S 2 of 29
bar := operator 'bar
--R
--R
--R   (2)  bar
--R                                                          Type: BasicOperator
--E 2
--S 3 of 29
g := foo x
--R
--R
--R   (3)  foo(x)
--R                                                    Type: Expression(Integer)
--E 3
--S 4 of 29
eval(g, x = x**2 + 1)
--R
--R
--R             2
--R   (4)  foo(x  + 1)
--R                                                    Type: Expression(Integer)
--E 4

———-

The chain rule can be applied formally — * —

--S 5 of 29
differentiate(%, x)
--R
--R
--R             ,  2
--R   (5)  2xfoo (x  + 1)
--R
--R                                                    Type: Expression(Integer)
--E 5

———-

The multivariate case — * —

--S 6 of 29
f := bar(x, y)
--R
--R
--R   (6)  bar(x,y)
--R                                                    Type: Expression(Integer)
--E 6

———-

Parallel substitution is possible — * —

--S 7 of 29
eval(f, [x = y, y = x])
--R
--R
--R   (7)  bar(y,x)
--R                                                    Type: Expression(Integer)
--E 7
--S 8 of 29
[differentiate(f, x), differentiate(f, y)]
--R
--R
--R   (8)  [bar  (x,y),bar  (x,y)]
--R            ,1         ,2
--R                                              Type: List(Expression(Integer))
--E 8

———- The multivariate chain rule

— * —

--S 9 of 29
ff := eval(f, [x = x**2 * foo y, y = x + y])
--R
--R
--R             2
--R   (9)  bar(x foo(y),y + x)
--R                                                    Type: Expression(Integer)
--E 9
--S 10 of 29
differentiate(ff, x)
--R
--R
--R                2                                2
--R   (10)  bar  (x foo(y),y + x) + 2x foo(y)bar  (x foo(y),y + x)
--R            ,2                               ,1
--R                                                    Type: Expression(Integer)
--E 10
--S 11 of 29
differentiate(ff, y)
--R
--R
--R                2                 2       2                ,
--R   (11)  bar  (x foo(y),y + x) + x bar  (x foo(y),y + x)foo (y)
--R            ,2                        ,1
--R                                                    Type: Expression(Integer)
--E 11

———-

Let’s create one with commuting partial derivatives Let’s change the way bar is printed on the screen, make it #1 #2

— * —

--S 12 of 29
pbar(l:List OUTFORM):OUTFORM == infix(" @ "::SYMBOL::OUTFORM, l)
--R
--R   Function declaration pbar : List(OutputForm) -> OutputForm has been
--R      added to workspace.
--R                                                                   Type: Void
--E 12
--S 13 of 29
display(bar, pbar)
--R
--R   Compiling function pbar with type List(OutputForm) -> OutputForm

--R
--R   (13)  bar
--R                                                          Type: BasicOperator
--E 13

———-

Let’s see the result — * —

--S 14 of 29
f
--R
--R
--R   (14)  x @ y
--R                                                    Type: Expression(Integer)
--E 14
--S 15 of 29
ff
--R
--R
--R          2
--R   (15)  x foo(y) @ y + x
--R                                                    Type: Expression(Integer)
--E 15

———-

Back to normal — * —

--S 16 of 29
deleteProperty(bar, "%display")
--R
--R   There are no library operations named deleteProperty
--R      Use HyperDoc Browse or issue
--R                           )what op deleteProperty
--R      to learn if there is any operation containing " deleteProperty "
--R      in its name.
--R
--RDaly Bug
--R   Cannot find a definition or applicable library operation named
--R      deleteProperty with argument type(s)
--R                                BasicOperator
--R                                   String
--R
--R      Perhaps you should use "@" to indicate the required return type,
--R      or "$" to specify which version of the function you need.
--E 16

--S 17 of 29
f
--R
--R
--R   (16)  x @ y
--R                                                    Type: Expression(Integer)
--E 17

———-

Let’s give bar some partial derivatives, say bar(u, v) = u ∗ v — * —

--S 18 of 29
bar1 l == last l
--R
--R                                                                   Type: Void
--E 18
--S 19 of 29
bar2 l == first l
--R
--R                                                                   Type: Void
--E 19
--S 20 of 29
derivative(bar, [bar1, bar2]$(LIST(LIST(EXPR INT) -> EXPR INT)))
--R
--R   Compiling function bar1 with type List(Expression(Integer)) ->
--R      Expression(Integer)
--R   Compiling function bar2 with type List(Expression(Integer)) ->
--R      Expression(Integer)
--R
--R   (19)  bar
--R                                                          Type: BasicOperator
--E 20
--S 21 of 29
[differentiate(f, x), differentiate(f, y)]
--R
--R
--R   (20)  [y,x]
--R                                              Type: List(Expression(Integer))
--E 21
--S 22 of 29
[differentiate(ff, x), differentiate(ff, y)]
--R
--R
--R                    2          2     3    ,       2

--R   (21)  [(2x y + 3x )foo(y),(x y + x )foo (y) + x foo(y)]
--R
--R                                              Type: List(Expression(Integer))
--E 22

———-

Some structural testing — * —

--S 23 of 29
h := inv(x + f + g**2)
--R
--R
--R                  1
--R   (22)  -------------------
--R               2
--R         foo(x)  + x @ y + x
--R                                                    Type: Expression(Integer)
--E 23
--S 24 of 29
isPower h
--R
--R
--R                     2
--R   (23)  [val= foo(x)  + x @ y + x,exponent= - 1]
--R          Type: Union(Record(val: Expression(Integer),exponent: Integer),...)
--E 24
--S 25 of 29
y * g**2 * h
--R
--R
--R                      2
--R              y foo(x)
--R   (24)  -------------------
--R               2
--R         foo(x)  + x @ y + x
--R                                                    Type: Expression(Integer)
--E 25
--S 26 of 29
isTimes %
--R
--R
--R                2            1
--R   (25)  [foo(x) ,y,-------------------]
--R                          2
--R                    foo(x)  + x @ y + x

--R                                   Type: Union(List(Expression(Integer)),...)
--E 26
--S 27 of 29
isPlus(denom(h)::EXPR(INT))
--R
--R
--R                2
--R   (26)  [foo(x) ,x @ y,x]
--R                                   Type: Union(List(Expression(Integer)),...)
--E 27
--S 28 of 29
isExpt(inv(g**2), "foo")
--R
--R
--R   (27)  [var= foo(x),exponent= - 2]
--R  Type: Union(Record(var: Kernel(Expression(Integer)),exponent: Integer),...)
--E 28
--S 29 of 29
isExpt(inv(g**2), "bar")
--R
--R
--R   (28)  "failed"
--R                                                    Type: Union("failed",...)
--E 29
)spool
)lisp (bye)

———-

References^{[1] nothing}

10