axiom-source 20170501-3 / usr / share / axiom-20170501 / src / algebra / UTSODE.spad

This file is indexed.

/usr/share/axiom-20170501/src/algebra/UTSODE.spad is in axiom-source 20170501-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
)abbrev package UTSODE UnivariateTaylorSeriesODESolver
++ Author: Stephen Watt (revised by Clifton J. Williamson)
++ Date Created: February 1988
++ Date Last Updated: 30 September 1993
++ Description:
++ Taylor series solutions of explicit ODE's.
++ This package provides Taylor series solutions to regular
++ linear or non-linear ordinary differential equations of
++ arbitrary order.

UnivariateTaylorSeriesODESolver(Coef,UTS) : SIG == CODE where
  Coef  : Algebra Fraction Integer
  UTS   : UnivariateTaylorSeriesCategory Coef

  L   ==> List
  L2  ==> ListFunctions2
  FN  ==> (L UTS) -> UTS
  ST  ==> Stream Coef
  YS  ==> Y$ParadoxicalCombinatorsForStreams(Coef)
  STT ==> StreamTaylorSeriesOperations(Coef)

  SIG ==> with

    stFunc1 : (UTS -> UTS) -> (ST -> ST)
      ++ stFunc1(f) is a local function exported due to compiler problem.
      ++ This function is of no interest to the top-level user.

    stFunc2 : ((UTS,UTS) -> UTS) -> ((ST,ST) -> ST)
      ++ stFunc2(f) is a local function exported due to compiler problem.
      ++ This function is of no interest to the top-level user.

    stFuncN : FN -> ((L ST) -> ST)
      ++ stFuncN(f) is a local function xported due to compiler problem.
      ++ This function is of no interest to the top-level user.

    fixedPointExquo : (UTS,UTS) -> UTS
      ++ fixedPointExquo(f,g) computes the exact quotient of \spad{f} and
      ++ \spad{g} using a fixed point computation.

    ode1 : ((UTS -> UTS),Coef) -> UTS
      ++ ode1(f,c) is the solution to \spad{y' = f(y)}
      ++ such that \spad{y(a) = c}.

    ode2 : ((UTS, UTS) -> UTS,Coef,Coef) -> UTS
      ++ ode2(f,c0,c1) is the solution to \spad{y'' = f(y,y')} such that
      ++ \spad{y(a) = c0} and \spad{y'(a) = c1}.

    ode : (FN,List Coef) -> UTS
      ++ ode(f,cl) is the solution to \spad{y<n>=f(y,y',..,y<n-1>)} such that
      ++ \spad{y<i>(a) = cl.i} for i in 1..n.

    mpsode : (L Coef,L FN) -> L UTS
      ++ mpsode(r,f) solves the system of differential equations
      ++ \spad{dy[i]/dx =f[i] [x,y[1],y[2],...,y[n]]},
      ++ \spad{y[i](a) = r[i]} for i in 1..n.

  CODE ==> add

    stFunc1 f == s +-> coefficients f series(s)
    stFunc2 f == (s1,s2) +-> coefficients f(series(s1),series(s2))
    stFuncN f == ls +-> coefficients f map(series,ls)$ListFunctions2(ST,UTS)

    import StreamTaylorSeriesOperations(Coef)
    divloopre:(Coef,ST,Coef,ST,ST) -> ST
    divloopre(hx,tx,hy,ty,c) == delay(concat(hx*hy,hy*(tx-(ty*c))))
    divloop: (Coef,ST,Coef,ST) -> ST
    divloop(hx,tx,hy,ty) == YS(s +-> divloopre(hx,tx,hy,ty,s))

    sdiv:(ST,ST) -> ST
    sdiv(x,y) == delay
      empty? x => empty()
      empty? y => error "stream division by zero"
      hx := frst x; tx := rst x
      hy := frst y; ty := rst y
      zero? hy =>
        zero? hx => sdiv(tx,ty)
        error "stream division by zero"
      rhy := recip hy
      rhy case "failed" => error "stream division:no reciprocal"
      divloop(hx,tx,rhy::Coef,ty)

    fixedPointExquo(f,g) == series sdiv(coefficients f,coefficients g)

-- first order

    ode1re: (ST -> ST,Coef,ST) -> ST
    ode1re(f,c,y) == lazyIntegrate(c,f y)$STT

    iOde1: ((ST -> ST),Coef) -> ST
    iOde1(f,c) == YS(s +-> ode1re(f,c,s))

    ode1(f,c) == series iOde1(stFunc1 f,c)

-- second order

    ode2re: ((ST,ST)-> ST,Coef,Coef,ST) -> ST
    ode2re(f,c0,c1,y)==
      yi := lazyIntegrate(c1,f(y,deriv(y)$STT))$STT
      lazyIntegrate(c0,yi)$STT

    iOde2: ((ST,ST) -> ST,Coef,Coef) -> ST
    iOde2(f,c0,c1) == YS(s +-> ode2re(f,c0,c1,s))

    ode2(f,c0,c1) == series iOde2(stFunc2 f,c0,c1)

-- nth order

    odeNre: (List ST -> ST,List Coef,List ST) -> List ST
    odeNre(f,cl,yl) ==
      -- yl is [y, y', ..., y<n>]
      -- integrate [y',..,y<n>] to get [y,..,y<n-1>]
      yil := [lazyIntegrate(c,y)$STT for c in cl for y in rest yl]
      -- use y<n> = f(y,..,y<n-1>)
      concat(yil,[f yil])

    iOde: ((L ST) -> ST,List Coef) -> ST
    iOde(f,cl) == first YS(ls +-> odeNre(f,cl,ls),#cl + 1)

    ode(f,cl) == series iOde(stFuncN f,cl)

    simulre:(L Coef,L ((L ST) -> ST),L ST) -> L ST
    simulre(cst,lsf,c) ==
      [lazyIntegrate(csti,lsfi concat(monom(1,1)$STT,c))_
          for csti in cst for lsfi in lsf]

    iMpsode:(L Coef,L ((L ST) -> ST)) -> L ST
    iMpsode(cs,lsts) == YS(ls +-> simulre(cs,lsts,ls),# cs)

    mpsode(cs,lsts) ==
      stSol := iMpsode(cs,[stFuncN(lst) for lst in lsts])
      map(series,stSol)$L2(ST,UTS)

APT Browse - Built by Thomas Orozco.