Artifact 1cdfdbc0e485a7619f1bd5da47b360de0ca9b7a9b52ac23db4fc686cb60c394f:
- File
r35/src/numeric.red
— part of check-in
[f2fda60abd]
at
2011-09-02 18:13:33
on branch master
— Some historical releases purely for archival purposes
git-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/trunk/historical@1375 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: arthurcnorman@users.sourceforge.net, size: 66269) [annotate] [blame] [check-ins using] [more...]
module numeric; % Header module for the numeric package and % support of numerical evaluation of symbolic % expressions. % Author: Herbert Melenk. % Copyright (c) 1993 ZIB Berlin, RAND. All rights reserved. create!-package('(numeric numeval numsolve newton steepstd bounds numint numfit chebysh rungeku), '(contrib numeric)); fluid '(!*noequiv); fluid '(accuracy!*); global '(iterations!* !*trnumeric); switch trnumeric; % Create .. as the infix operator if not yet done. newtok '( (!. !.) !*interval!*); precedence .., or; algebraic operator ..; put('!*interval!*,'prtch,'! !.!.! ); % some common utilities % intervals symbolic procedure adomainp u; numberp u or (pairp u and idp car u and get(car u,'dname)); symbolic procedure revalnuminterval(u,num); % Evaluate u as interval; numeric bounds required if num=T. begin scalar l; if not eqcar(u,'!*interval!*) then typerr(u,"interval"); l:={reval cadr u,reval caddr u}; if null num or(adomainp car l and adomainp cadr l)then return l; typerr(u,"numeric interval"); end; symbolic procedure mkinterval(u,v); list('!*interval!*,u,v); % Easy coding of numerical procedures with REDUCE: % % In statements or procedure bodies tagged with "dm:" all % arithmetic function calls are replaced by REDUCE domain % arithmetic. symbolic macro procedure dm!: u; subla('((plus2 . !:plus)(times2 . !:times) (plus . !:plusn)(times . !:timesn) (quotient . !:!:quotient) (difference . !:difference) (minus . !:minus) (minusp . !:minusp) (zerop . !:zerop) (lessp . (lambda(a b)(!:minusp (!:difference a b)))) (greaterp . (lambda(a b)(!:minusp (!:difference b a)))) (leq . (lambda(a b)(not (!:minusp (!:difference b a))))) (geq . (lambda(a b)(not (!:minusp (!:difference a b))))) (sqrt . num!-sqrtf) (abs . absf) (min2 . dm!:min) (max2 . dm!:max) (min . dm!:min) (max . dm!:max) ) , cadr u); %wrappers for n-ary plus and times symbolic macro procedure !:plusn u; if null cddr u then cadr u else list('!:plus,cadr u,'!:plusn . cddr u); symbolic macro procedure !:timesn u; if null cddr u then cadr u else list('!:times,cadr u,'!:timesn . cddr u); endmodule; module numeval; % numeric evaluation of algebraic expressions. % Control of accuracy and precision. % % precision: number of digits used for computation, % accuracy: target precision of the results; % % precision might be modified automatically for reaching the % desired accuracy. symbolic procedure accuracycontrol(u,da,di); % u is an evaluated parameter list. Extract % accuracy and iterations. If not present, take % given default values. begin scalar x,n,v; v:=u; accuracy!*:=da; iterations!*:=di; while v do <<x:=car v; v:= cdr v; if eqcar(x,'equal) and cadr x memq'(accuracy iterations) then <<u:=delete(x,u); n:=caddr x; if cadr x='accuracy then accuracy!*:=n else iterations!*:=n; >>>>; return u; end; symbolic procedure update!-precision l; % l is a list of domain elements. IF the minimum of their absolute % values is smaller than 10**(precision*+3), the precision is % increased. begin scalar mn; integer zp,p; mn:=update!-precision1 l; % positive minimum. if null mn then return nil; p := precision 0; zp:=!:recip expt(10,p-3); dm!: << if mn>zp then return nil; while mn<zp do <<p:=p+1;zp:=zp/10>>; >>; precmsg p; end; symbolic procedure update!-precision1 l; dm!:( begin scalar x,y,z; while l do <<x:=car l; l:=cdr l; if not zerop x then <<y:=abs x; z:=if null z or y<z then y else z>> >>; return z; end ); % Switching of mode and introduction of specific simplifiction % rules. algebraic<< rules_rd := {~u ** ~x => exp(log u * x) when not numberp x}; procedure switch!-mode!-rd!-alg u; if u=0 then <<for all x clear exp x; let rules_rd; >> else << for all x let exp x=e**x; clearrules rules_rd; >>; >>; symbolic procedure switch!-mode!-rd u; begin scalar oldmode,prec; if null u then <<if not memq(dmode!*,'(!:rd!: !:cr))then <<oldmode:=t; setdmode('rounded,t)>>; !*noequiv:=t; prec:=precision 0; switch!-mode!-rd!-alg 0; return list(oldmode,prec,!*roundbf) >> else << if car u then setdmode('rounded,nil); precision cadr u; !*roundbf := caddr u; switch!-mode!-rd!-alg 1; >>; end; % Support for the numerical (=domain specific) evaluation of % algebraic equations. % % Roughly equivalent: % evaluate(u,v,p) = numr subsq(simp u,pair(v,p)) % but avoiding resimplification as we know that all components % must evaluate to domain elements. fluid '(dmarith!* !*evaluateerror); dmarith!*:= '( (difference . !:difference) (quotient . !:!:quotient) (minus . negf) (sqrt . num!-sqrtf) (expt . !:dmexpt) (min . dm!:min) (max . dm!:max) ); symbolic procedure evaluate(u,v,p); begin scalar a,r,!*evaluateerror; a:= pair(v,p); r := errorset(list('evaluate1,mkquote u,mkquote a),t,nil) where !*msg=nil,!*protfg=t; if errorp r then rederr "error during function evaluation (e.g. singularity)"; return car r; end; symbolic procedure evaluate!*(u,v,p); % same as evaluate, but returning arithmetic (but not syntactical) % errors to the caller like errorset. begin scalar a,r,!*evaluateerror; a:= pair(v,p); r := errorset(list('evaluate1,mkquote u,mkquote a),nil,nil) where !*msg=nil,!*protfg=t; erfg!* := nil; if null !*evaluateerror then return r else evaluate1(u,a); % once more, but unprotected. end; symbolic procedure evaluate1(u,v); if numberp u or null u then force!-to!-dm u else if pairp u and get(car u,'dname) then u else (if a then cdr a else if atom u then if u='i then if (u:=get(dmode!*,'ivalue)) then numr apply(u,'(nil)) else rederr "i used as indeterminate value" else if u='e or u='pi then force!-to!-dm numr simp u else <<!*evaluateerror:=t; typerr(u,"number")>> else evaluate2(car u,cdr u,v) ) where a=assoc(u,v); symbolic procedure evaluate2(op,pars,v); <<pars:=for each p in pars collect evaluate1(p,v); % arithmetic operator. if op='plus then !:dmpluslst pars else if op='times then !:dmtimeslst pars else if(a:=assoc(op,dmarith!*)) then apply(cdr a,pars) else % elementary function, applicable for current dmode. if pairp car pars and (a:=get(op,caar pars)) then apply(a,pars) else % apply REDUCE siplificator otherwise force!-to!-dm numr simp (op . for each p in pars collect prepf p) >> where a=nil; symbolic procedure list!-evaluate(u,v,p); for each r in u collect evaluate(r,v,p); symbolic procedure matrix!-evaluate(u,v,p); for each r in u collect list!-evaluate(r,v,p); symbolic procedure !:dmexpt(u,v); (if fixp n then !:expt(u,n) else <<u:=force!-to!-dm u; v:=force!-to!-dm v; if !*complex then crexpt!*(u,v) else rdexpt!*(u,v) >>) where n=!:dm2fix v; symbolic procedure dm!:min(a,b); dm!:(if a > b then b else a); symbolic procedure dm!:max(a,b); dm!:(if a > b then a else b); symbolic procedure !:dm2fix u; if fixp u then u else (if fixp(u:=int!-equiv!-chk u) then u else if null u then 0 else if floatp cdr u and 0.0=cdr u-fix cdr u then fix cdr u else u) where !*noequiv=nil; symbolic procedure !:dmtimeslst u; if null u then 1 else if null cdr u then car u else dm!:(car u * !:dmtimeslst cdr u); symbolic procedure !:dmpluslst u; if null u then 0 else if null cdr u then car u else dm!:(car u + !:dmpluslst cdr u); symbolic procedure !:!:quotient(u,v); !:quotient(u,if fixp v then i2rd!* v else v); % vector/matrix arithmetic symbolic procedure list!+list(l1,l2); if null l1 then nil else dm!: (car l1 + car l2) . list!+list(cdr l1,cdr l2); symbolic procedure list!-list(l1,l2); if null l1 then nil else dm!: (car l1 - car l2) . list!-list(cdr l1,cdr l2); symbolic procedure scal!*list(s,l); if null l then nil else dm!: (s * car l) . scal!*list(s,cdr l) ; symbolic procedure innerprod(u,v); if null u then 0 else dm!: ( car u * car v + innerprod(cdr u,cdr v) ); symbolic procedure conjlist u; dm!:(if not !*complex then u else for each x in u collect repartf x - numr apply(get(dmode!*,'ivalue),'(nil))*impartf x ); symbolic procedure normlist u; dm!:(sqrt innerprod(u, conjlist u)); symbolic procedure mat!*list(m,v); if null cdr m then scal!*list(car v,car m) else for each r in m collect innerprod(r,v); symbolic procedure num!-sqrtf a; if domainp a then apply(get('sqrt,dmode!*),list force!-to!-dm a) else <<a:=simpsqrt list prepf a; if not onep denr a or not domainp numr a then rederr "sqrtf called in wrong mode" else numr a>>; symbolic procedure force!-to!-dm a; if not domainp a then typerr(prepf a,"number") else if null a then force!-to!-dm 0 else if numberp a then apply(get(dmode!*,'i2d),list a) else if pairp a and car a = dmode!* then a else (if fcn then apply(fcn,list a) else rederr list("conversion error with ",a) ) where fcn=(pairp a and get(car a,dmode!*)); symbolic procedure printsflist(x); begin integer n; writepri("(",nil); for each y in x do <<if n>0 then writepri(" , ",nil); n:=n+1; writepri(mkquote prepf y,nil)>>; writepri(")",nil); end; endmodule; module numsolve; % root finding. % Author: H. Melenk, ZIB, Berlin % Copyright (c): ZIB Berlin 1991, all rights resrved % Version 2: termination and damping criterion modified to affine % invariance. fluid '(!*noequiv accuracy!* !*exptexpand); global '(iterations!* !*trnumeric erfg!*); symbolic procedure rdsolveeval u; % interface function; begin scalar e,l,vars,y,z,p,r,erfg,mode,all,!*exptexpand; integer n; erfg:= erfg!*; erfg!* := nil; u := for each x in u collect reval x; u:=accuracycontrol(u,6,50); if (all:='all memq u) then u:=delete('all,u); e :=car u; u :=cdr u; % construct the function vector. e:=if eqcar(e,'list) then cdr e else list e; e := for each f in e collect if eqexpr (f:=reval f) then !*eqn2a f else f; n := length e; % starting point & variables. if eqcar(car u,'list) then u := for each x in cdar u collect reval x; for each x in u do <<if eqcar(x,'equal) then <<z:=cadr x; y:=caddr x; if eqcar(y,'!*interval!*) then mode:='i; >> else <<z:=x; y:=random 100>>; vars:=z . vars; p := y . p>>; vars := reversip vars; p := reversip p; if not(n=length vars) then << % lprim "numbers of variables and functions don't match;"; % lprim "using steepest descent method instead of Newton"; % return rdsolvestdeval list ('list.e,'list.u, % {'equal,'accuracy,accuracy!*}, % {'equal,'iterations,iterations!*}); rederr "numbers of variables and functions don't match" >>; if mode='i and length vars>1 or mode neq 'i and all then rederr "mode for num_solve not implemented"; r:=if mode='i then rd!-solve!-interv(e,vars,p,n,all) else rdnewton0(e,vars,p,n); erfg!* := erfg; return r; end; put('num_solve,'psopfn,'rdsolveeval); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % finding root in an interval (secant method and related) % symbolic procedure rd!-solve!-interv(e,vars,p,n,all); (begin scalar u,fu,l,fl,x,acc,r,de,w,oldmode; if length p>1 then typerr('list . p,"single interval"); p:=car p; e:=car e; x:=car vars; w := {'boundseval,mkquote {e,{'equal,x,p}}}; if not memq(dmode!*,'(!:rd!: !:cr!:))then <<oldmode:=t; setdmode('rounded,t)>>; if errorp errorset(w,nil,nil) then typerr(e,"bounded expression"); acc := !:!:quotient(1,expt(10,accuracy!*)); l:=evaluate(cadr p,nil,nil); u:=evaluate(caddr p,nil,nil); fl:=evaluateuni(e,x,l); fu:=evaluateuni(e,x,u); if not all then dm!:(if zerop fl then return prepf l else if zerop fu then return prepf u else if fl*fu<0 then r := regula!-falsi(e,x,l,fl,u,fu,acc)); if null r then de := reval {'df,e,x}; if null r and not all then r:=rd!-solve!-trynewton(e,de,x,l,fl,u,fu,acc); if null r then r:=rd!-solve!-hardcase(e,de,x,l,fl,u,fu,acc,all); if oldmode then setdmode('rounded,nil); if r then return r; rederr "not applicable"; end) where !*roundbf=!*roundbf; symbolic procedure make!-rdsolve!-result1(x,u); 'list.for each r in u collect {'equal,x,prepf r}; symbolic procedure rd!-solve!-trynewton(e,de,x,l,fl,u,fu,acc); begin scalar r,invde; invde := {'quotient,1,de}; dm!: << if fu*evaluateuni(de,x,u) >0 then r := rdnewton2({e},{{invde}},{x},acc,{u},'root,l,u); if null r and fl*evaluateuni(de,x,l) <0 then r := rdnewton2({e},{{invde}},{x},acc,{l},'root,l,u); if r and (r:=car r) and l <= r and r <= u then r := make!-rdsolve!-result1(x,{r}) else r:=nil; >>; return r; end; symbolic procedure regula!-falsi(e,x,l,fl,u,fu,acc); make!-rdsolve!-result1(x, {regula!-falsi1(e,x,l,fl,u,fu,acc,0,1)}); symbolic procedure regula!-falsi1(e,x,l,fl,u,fu,acc,mode1,mode2); % modified regula falsi: using bisection in order to % traverse root as often as possible. dm!: begin scalar m,fm; if mode1=mode2 then m:=(u+l)/2 else m := l*fu/(fu-fl) + u*fl/(fl-fu); if (u-l) < acc then return m; fm := evaluateuni(e,x,m); if zerop fm then return m; return if fl*fm<0 then regula!-falsi1(e,x,l,fl,m,fm,acc,nil,mode1) else regula!-falsi1(e,x,m,fm,u,fu,acc,t,mode1); end; symbolic procedure mkminus u; {'minus,u}; symbolic procedure evaluateuni(e,x,p); evaluate(e,{x},{p}); symbolic procedure dmboundsuni(e,x,l,u); begin scalar i; i:=boundseval {e,{'equal,x,{'!*interval!*,prepf l,prepf u} }}; return numr simp cadr i . numr simp caddr i; end; symbolic procedure rd!-solve!-hardcase(e,de,x,l,fl,u,fu,acc,all); dm!: begin scalar il1,il2,pt,pt1,iv,r,rr,b,b1,q,d; integer lev; il1:={(l.fl) .(u.fu)}; main_loop: lev:=lev+1; il2:=nil; if null il1 then goto done; il1 := reverse il1; rd!-solve!-hardcase!-print(lev,il1); loop: if null il1 then goto bottom; iv :=car il1; il1:= cdr il1; l:=caar iv; fl:=cdar iv; u:=cadr iv; fu:=cddr iv; if (d:=u-l) <0 then goto loop; %empty if abs fl<acc then<<pt:=l;goto root_found>>; if abs fu<acc then<<pt:=u;goto root_found>>; b:=dmboundsuni(de,x,l,u); % left boundary of interval if (fl>0 and not((b1:=car b)<0)) or(fl<0 and not((b1:=cdr b)>0)) or not((pt:=l-fl/b1)<u) then goto loop; if pt=l then goto precerr; q:=evaluateuni(e,x,pt); if not all and q*fl<0 then return regula!-falsi(e,x,l,fl,pt,q,acc); if abs q<acc then goto root_found; l:=pt; fl:=q; % right boundary of interval if (fu>0 and not((b1:=cdr b)>0)) or(fu<0 and not((b1:=car b)<0)) or not((pt:=u-fu/b1)>l) then goto loop; if pt=u then goto precerr; q:=evaluateuni(e,x,pt); if not all and q*fu<0 then return regula!-falsi(e,x,pt,q,u,fu,acc); if abs q<acc then goto root_found; u:=pt; fu:=q; % new point pt :=(l+u)/2; %midpoint q:=evaluateuni(e,x,pt); if not all and q*fu<0 then return regula!-falsi(e,x,l,fl,pt,q,acc); % generate new intervals if not(abs q<acc) then <<il2 :=find!-root!-addinterval(pt.q,u.fu, find!-root!-addinterval(l.fl,pt.q,il2)); goto loop; >>; root_found: r:=pt.r; if not all then goto done; rr:=find!-root!-range(e,x,pt,acc); il2 :=find!-root!-addinterval(cdr rr,u.fu , find!-root!-addinterval(l.fl,car rr,il2)); goto loop; bottom: il1 :=il2; goto main_loop; done: r:=sort(r,function lessp); return make!-rdsolve!-result1(x,r); precerr: rederr "precision not sufficient for finding all roots"; end; symbolic procedure rd!-solve!-hardcase!-print(lev,il1); if !*trnumeric then << prin2t {"recursion level:",lev,"remaining intervals:",length il1}; writepri( mkquote( 'list. for each i in il1 collect {'list,{'!*interval!*,prepf caar i,prepf cadr i}, dm!: prepf(cadr i-caar i)}), 'only); >>; symbolic procedure find!-root!-addinterval(l,h,il); dm!: <<if car l < car h then il:=(l.h).il; il>>; symbolic procedure find!-root!-range(e,x,p,acc); % p is a point in (l .. u) where abs e(x)<acc. % Find the next interval where e(x) > acc. dm!:<< while not(abs(fl:=evaluateuni(e,x,pl:=pl-acc/2))>acc) do; while not(abs(fu:=evaluateuni(e,x,pu:=pu+acc/2))>acc) do; (pl.fl).(pu.fu) >> where pl=p,pu=p,fl=nil,fu:=nil; if errorp errorset('(!:difference nil nil),nil,nil) then << symbolic procedure !:difference(u,v); if null u then !:minus v else if null v then u else if u=v then nil else if atom u and atom v then u-v else dcombine(u,v,'difference); symbolic procedure !:quotient(u,v); if null u or u=0 then nil else if null v or v=0 then rerror(poly,12,"Zero divisor") else if atom u and atom v % We might also check that remainder is zero in integer case. then if null dmode!* then u/v else dcombine(u,!:recip v,'times) else dcombine(u,v,'quotient); >>; endmodule; module newton; % root finding with generalized Newton methods. % Author: H. Melenk, ZIB, Berlin % Copyright (c): ZIB Berlin 1992, all rights resrved % Version 2: termination and damping criterion modified to affine % invariance. fluid '(!*noequiv accuracy!*); global '(iterations!* !*trnumeric erfg!*); symbolic procedure rdnewton0(e,vars,p,n); %preparations for Newton iteration. (begin scalar l,jac,x,y,oldmode,q,!*noequiv; integer prec; if not memq(dmode!*,'(!:rd!: !:cr!:))then <<oldmode:=t; setdmode('rounded,t)>>; prec:=precision 0; p := for each x in p collect force!-to!-dm numr simp x; if !*trnumeric then lprim "computing symbolic Jacobian"; eval list('matrix,mkquote list list('jacobian,n,n)); for i:=1:n do for j:=1:n do setmatelem(list('jacobian,i,j), reval list('df,nth(e,i),nth(vars,j))); if !*trnumeric then lprim "inverting symbolic Jacobian"; jac:= cdr reval'(quotient 1 jacobian); jac := for each r in jac collect for each c in r collect reval c; !*noequiv:=t; x := rdnewton1(e,jac,vars,p,'root); if oldmode then setdmode('rounded,nil); precision prec; if null x then rederr "no solution found"; return 'list. for each p in pair(vars,x) collect list('equal,car p,cdr p); end) where !*roundbf=!*roundbf; symbolic procedure rdnewton1(f,jac,vars,x,mode); begin scalar r,acc; integer n; if !*trnumeric then lprim "starting Newton iteration"; acc := !:!:quotient(1,expt(10,accuracy!*)); r:= rdnewton2(f,jac,vars,acc,x,mode,nil,nil); r:= for each x in r collect prepf x; return r; end; symbolic procedure rdnewton2(f,jac,vars,acc,x,mode,low,high); % Algorithm for finding the root function system f % with technique of adaptively damped Newton. % f: function to minimize (list of algebraic exprs); % jac: symbolic inverted Jacobian; % vars: variables (list of id's); % acc: requested accuracy (e.g. 0.0000001) % x: starting point (list of domain elements). dm!: begin scalar n,n0,n1,n2,e0,e1,dx,dx2,x1,g,dmp,delta,h; scalar dxold,dx2old,dmpold; integer count; e0 := list!-evaluate(f,vars,x); loop: count:=add1 count; if count>iterations!* then <<lprim "requested accuracy not reached within iteration limit"; goto ready>>; % evaluate inverse Jacobian. g := matrix!-evaluate(jac,vars,x); dx := mat!*list(g,e0); % the newton step. n0 := normlist dx; dmp:= 1; step: % evaluate function at new point. x1 := list!-list(x, scal!*list(dmp,dx)); e1 := errorset({'list!-evaluate,mkquote f, mkquote vars,mkquote x1},nil,nil); if errorp e1 then goto contract else e1 := car e1; % anticipated next (simplified) Newton step. n1 := normlist(dx2:=mat!*list(g,e1)); if n1=0 or n1<n0 then goto accept; if null dmpold then goto contract; % predict optimal damping factor h:= dmpold *(normlist list!-list(dx2old,dx) * normlist(dx)) / (normlist(dxold) * normlist(dx2old)); if h>1 then << dmp:=if h<10 then 1/h else 1/10; dmpold := nil; goto step>>; contract: dmp:=dmp/2; if dmp<acc then rederr "Newton method does not converge"; goto step; accept: delta:=dmp*n0; x := x1; e0:=e1; n0:=n1; if low and high and (low>car x or high<car x) then return nil; dmpold := dmp; dxold := dx; dx2old := dx2; rdnewtonprintpoint(count,x,delta,e0); if n1>acc or dmp<1 then<<update!-precision(delta.e0); goto loop>>; ready: x := list!-list(x,dx2); return x; end; symbolic procedure rdnewtonprintpoint(count,x,dx,e0); if !*trnumeric then begin integer n; writepri(count,'first); writepri(". residue=",nil); printsflist e0; writepri(", step length=",nil); writepri(mkquote prepf dx,'last); writepri(" at ",nil); printsflist x; writepri(" ",'last); end; endmodule; module steepstd; % Optimization and root finding with method of % steepest descent. % Author: H. Melenk, ZIB, Berlin % Copyright (c): ZIB Berlin 1991, all rights resrved fluid '(!*noequiv accuracy!*); global '(iterations!* !*trnumeric); symbolic procedure rdmineval u; begin scalar e,l,vars,x,y,z,oldmode,p,!*noequiv; oldmode:=steepdecedmode(nil,nil); u := for each x in u collect reval x; u := accuracycontrol(u,6,40); e :=car u; u :=cdr u; if eqcar(car u,'list) then u := for each x in cdar u collect reval x; for each x in u do <<if eqcar(x,'equal) then <<z:=cadr x; y:=caddr x>> else <<z:=x; y:=random 100>>; vars:=z . vars; p := y . p>>; vars := reversip vars; p := reversip p; x := steepdeceval1(e,vars,p,'min); steepdecedmode(t,oldmode); return list('list, car x, 'list. for each p in pair(vars,cdr x) collect list('equal,car p,cdr p)); end; put('num_min,'psopfn,'rdmineval); symbolic procedure rdsolvestdeval u; % solving a system of equations via minimizing the % sum of sqares. begin scalar e,l,vars,x,y,z,oldmode,p,q,!*noequiv; oldmode:=steepdecedmode(nil,nil); u := for each x in u collect reval x; e :=car u; u :=cdr u; % construct the function to minimize. e:=if eqcar(e,'list) then cdr e else list e; q := 'plus . for each f in e collect list('expt,if eqexpr f then !*eqn2a f else f,2); q := prepsq simp q; % starting point & variables. if eqcar(car u,'list) then u := for each x in cdar u collect reval x; for each x in u do <<if eqcar(x,'equal) then <<z:=cadr x; y:=caddr x>> else <<z:=x; y:=random 100>>; vars:=z . vars; p := y . p>>; vars := reversip vars; p := reversip p; x := steepdeceval1(q,vars,p,'root); steepdecedmode(t,oldmode); if null x then rederr "no solution found"; return 'list. for each p in pair(vars,cdr x) collect list('equal,car p,cdr p); end; symbolic procedure steepdecedmode(m,oldmode); if not m then % initial call << if !*complex then rederr "steepest descent method not applicable under complex"; if not (dmode!*='!:rd!:)then <<oldmode:=t; setdmode('rounded,t)>>; {oldmode,precision 0,!*roundbf}>> else % reset to old dmode. <<if car oldmode then setdmode('rounded,nil); precision cadr oldmode; !*roundbf:=caddr oldmode>>; symbolic procedure steepdeceval1(f,vars,x,mode); begin scalar e,g,r,acc; integer n; n := length vars; % establish the target function and the gradient. e := prepsq simp f; if !*trnumeric then lprim "computing symbolic gradient"; g := for each v in vars collect prepsq simp list('df,f,v); !*noequiv:=t; if !*trnumeric then lprim "starting Fletcher Reeves steepest descent iteration"; acc := !:!:quotient(1,expt(10,accuracy!*)); x := for each u in x collect force!-to!-dm numr simp u; r:= steepdec2(e,g,vars,acc,x,mode); r:= for each x in r collect prepf x; return r; end; symbolic procedure steepdec2(f,grad,vars,acc,x,mode); % Algorithm for finding the minimum of function f % with technique of steepest descent, version Fletcher-Reeves. % f: function to minimize (standard quotient); % grad: symbolic gradient (list of standard quotients); % vars: variables (list of id's); % acc: target precision (e.g. 0.000001) % x: starting point (list of numerical standard forms). % mode: minimum / roots type of operation dm!: begin scalar e0,e00,e1,e2,a,a1,a1a1,a2,a2a2,x1,x2,g,h,dx,w, delta,limit,gold,gnorm,goldnorm,multi; integer count,k,n; n:=length grad; multi:=n>1; n:=10*n; e00 := e0 := evaluate(f,vars,x); a1 := 1; init: k:=0; % evaluate gradient (negative). g := for each v in grad collect -evaluate(v,vars,x); gnorm := normlist g; h:=g; loop: count := add1 count; k:=add1 k; if count>iterations!* then <<lprim "requested accuracy not reached within iteration limit"; % mode := nil; goto ready>>; % quadratic interpolation in direction of h in order % to find the minimum value of f in that direction. a2 := nil; l1: x1 := list!+list(x, scal!*list(a1,h)); e1 := evaluate(f,vars,x1); if e1>e0 then <<a2:=a1; x2:=x1; e2:=e1; a1 := a1/2; goto l1>>; if a2 then goto alph; l2: a2 := a1+a1; x2 := list!+list(x, scal!*list(a2,h)); e2 := evaluate(f,vars,x2); if e2<e1 then <<a1:=a2; e1:=e2; goto l2>>; alph: %compute lowest point of parabel if abs(e1-e2)<acc then goto ready; % constant? a1a1:=a1*a1; a2a2:=a2*a2; a:= (a1a1-a2a2)*e0 + a2a2*e1 - a1a1*e2 ; a:= a/((a1-a2)*e0 + a2*e1-a1*e2); a:= a/2; % new point dx:=scal!*list(a,h); x:=list!+list(x, dx); e0 := evaluate(f,vars,x); if e0>e1 then % a1 was better than interpolation. <<dx:=scal!*list(a1-a ,h); x:=list!+list(x,dx); e0 := e1; dx:=scal!*list(a1,h)>>; delta:= normlist dx; steepdecprintpoint(count,x,delta,e0,gnorm); update!-precision list(delta,e0,gnorm); % compute next direction; if k>n then goto init; % reinitialize time to time. gold := g; goldnorm:= gnorm; g := for each v in grad collect -evaluate(v,vars,x); gnorm := normlist g; if gnorm<limit then goto ready; h := if not multi then g else list!+list(g,scal!*list(gnorm/goldnorm,h)); if mode='min and gnorm > acc or mode='root and e0 > acc then goto loop; ready: if mode='root and not(abs e0 < acc) then <<lprim "probably fallen into local minimum of f^2"; return nil>>; return e0 . x; end; symbolic procedure steepdecprintpoint(count,x,d,e0,ng); if !*trnumeric then begin integer n; writepri(count,'first); writepri(". residue=",nil); writepri(mkquote prepf e0,nil); writepri(", gradient length=",nil); writepri(mkquote prepf ng,'last); writepri(" at (",nil); for each y in x do <<if n>0 then writepri(" , ",nil); n:=n+1; writepri(mkquote prepf y,nil)>>; writepri(")",nil); writepri(", stepsize=",nil); writepri(mkquote prepf d,nil); writepri("",'last); end; endmodule; module bounds; % Upper and lower bound of a % multivariate functional expression in a n-dimensional interval. % Author: H. Melenk, ZIB, Berlin % Copyright (c): ZIB Berlin 1991, all rights resrved put('bounds,'psopfn,'boundseval); put('bounds!-rd,'psopfn,'boundsevalrd); put('bounds,'numericfn,'bounds!-rd); fluid '(boundsdb!* !*msg boundspolynomialdb!* !*boundsfullcheck boundsknown!*); symbolic procedure boundsevalrd u; begin scalar dmode!*; setdmode('rounded,t); return boundseval u; end; symbolic procedure boundseval u; (begin scalar db,y,l,f; u := for each x in u collect reval x; f := car u; u := cdr u; if u and eqcar(car u,'list) then u := for each x in cdar u collect reval x; for each x in u do <<if not eqcar(x,'equal) then typerr(x,"domain description"); y := revalnuminterval(caddr x,nil); l:=list(simp car y,simp cadr y); db := (cadr x . minsq l . maxsq l).db>>; u := boundseval1(f,db); return mkinterval(prepsq car u,prepsq cdr u); end) where !*roundbf=!*roundbf; symbolic procedure boundserr(a,b); if not !*msg then error(99,'bounds) else if a then typerr(a,b) else rederr b; symbolic procedure boundseval0 (f,db,!*msg); % internal calling convention: % f algebraic expression, % db list of (x . lo . hi), where % lo and hi represent the current interval for % variable x as standard quotients. % result is a pair of standard quotients representing % the bounds for f. boundseval1(f,db); symbolic procedure boundseval1(u,boundsdb!*); <<if u member boundsknown!* then !*boundsfullcheck := nil else !*boundsfullcheck := boundsknown!* := u.boundsknown!*; boundseval2 u>>; symbolic procedure boundseval2 u; % Main driver for bounds evaluation if adomainp u then <<u:=simp u;u.u>> else boundspolynomial u or begin scalar v,w,fcn; if (v:=assoc(u,boundsdb!*))then return cdr v; if idp u and (fcn:=get(u,dmode!*)) then <<v:=apply(fcn,nil); v:=(v ./1).(v ./1); goto done>>; if atom u then goto err; if car u='expt and fixp caddr u and caddr u>0 then <<v:=boundsexpt!-int(boundseval2 cadr u,caddr u); goto done>>; w := for each y in cdr u collect boundseval2 y; v:= if cdr w and cddr w and (fcn:=get(car u,'boundsevaln)) then apply1(fcn,w) else if length w>2 then t else if (fcn:=get(car u,'boundseval1)) then apply2(fcn,car u,car w) else if (fcn:=get(car u,'boundseval)) then if null cdr w then apply1(fcn,car w) else apply2(fcn,car w,cadr w) else if cdr w then t else boundsoperator(car u,car w); if v=t then goto err2; if null v or not domainp numr car v or not domainp denr car v or not domainp numr cdr v or not domainp denr cdr v then goto err; % cache result for later usage. done: boundsdb!*:= (u.v).boundsdb!*; return v; err: boundserr(nil,"unbounded in range"); err2: boundserr(nil,"bounds confusion"); end; symbolic procedure boundsoperator(fcn,u); % general external interface: function flagged decreasing, % increasing of explicit bounds given. if flagp(fcn,'increasing) then boundsincreasingfn(fcn,u) else if flagp(fcn,'decreasing) then boundsdecreasingfn(fcn,u) else if get(fcn,'upperbound) and get(fcn,'lowerbound) then simp get(fcn,'lowerbound) . simp get(fcn,'upperbound) else nil; symbolic procedure boundsplus u; if null cdr u then car u else boundsplus2(car u,boundsplus cdr u); symbolic procedure boundsplus2(u,v); addsq(car u,car v) . addsq(cdr u,cdr v); put('plus,'boundsevaln,'boundsplus); put('plus,'boundseval,'boundsplus2); symbolic procedure boundsdifference(x,y); subtrsq(car x,cdr y).subtrsq(cdr x,car y); put('difference,'boundseval,'boundsdifference); symbolic procedure boundsminus(u); negsq cdr u . negsq car u; put('minus,'boundseval,'boundsminus); symbolic procedure boundstimes u; if null cdr u then car u else boundstimes2(car u,boundstimes cdr u); symbolic procedure boundstimes2(x,y); begin scalar z; % first handle simple cases if not minusf numr car x and not minusf numr car y then return multsq(car x,car y) . multsq(cdr x,cdr y); if minusf numr cdr x and minusf numr cdr y then return multsq(cdr x,cdr y) . multsq(car x,car y); z:=list(multsq(car x,car y), multsq(car x,cdr y), multsq(cdr x,car y), multsq(cdr x,cdr y)); return minsq z . maxsq z; end; symbolic procedure minsq l; begin scalar x,z; x := car l; for each y in cdr l do if minusf numr subtrsq(y,x) then x:=y; return x; end; symbolic procedure maxsq l; begin scalar x,z; x:= car l; for each y in cdr l do if minusf numr subtrsq(x,y) then x:=y; return x; end; symbolic procedure sqgreaterp(x,y); minusf numr subtrsq(y,x); put('times,'boundsevaln,'boundstimes); put('times,'boundseval,'boundstimes2); symbolic procedure boundsexp u; boundsexpt(b . b,u) where b = simp 'e; put('exp,'boundseval,'boundsexp); symbolic procedure boundsexpt!-int(b,ex); % Form x ** n. Look for even exponents. begin scalar hi,lo,bh,bl; bl := exptsq(car b,ex); bh := exptsq(cdr b,ex); if not evenp ex then return bl.bh; lo := minusf numr cdr b; hi := not minusf numr car b; return if hi then bl.bh else % both had been positive if lo then bh.bl else % both had been negative: invert (nil ./ 1) . maxsq list(bl,bh); end; symbolic procedure boundsexpt!-const(b,ex); % Form x ** constant, including fractional exponents. begin scalar l; l := list(bounds!-evalfcn2('expt,car b,ex), bounds!-evalfcn2('expt,cdr b,ex)); return minsq l . maxsq l; end; symbolic procedure boundsexpt(b,e); if car e=cdr e then boundsexpt!-const(b,car e) else % Form x ** y. x>0 only. % Either monotonous growing or falling: pick extremal points. begin scalar l; if sqgreaterp(nil./1,car b) then return nil; l := list(bounds!-evalfcn2('expt,car b,car e), bounds!-evalfcn2('expt,car b,cdr e), bounds!-evalfcn2('expt,cdr b,car e), bounds!-evalfcn2('expt,cdr b,cdr e)); return minsq l . maxsq l; end; symbolic procedure boundsprepsq u; prepsq car u . prepsq cdr u; put('expt,'boundseval,'boundsexpt); symbolic procedure boundsquotient(n,d); begin scalar l; if minusf numr multsq(car d,cdr d) then boundserr(nil,"unbounded in range"); l := list(quotsq(car n,car d),quotsq(car n,cdr d), quotsq(cdr n,car d),quotsq(cdr n,cdr d)); return minsq l . maxsq l; end; put('quotient,'boundseval,'boundsquotient); symbolic procedure boundsabs u; if evalgreaterp(prepsq car u,0) then u else if evalgreaterp(0,prepsq cdr u) then negsq cdr u . negsq car u else (nil ./1) . maxsq list (negsq car u,cdr u); put('abs,'boundseval,'boundsabs); symbolic procedure boundsincreasingfn(fn,u); % Bounds for an increasing function. Out-of -range problems will % be detected either by the function evaluation or finally by % the main driver if the result is not an interval with numeric % bounds. bounds!-evalfcn1(fn,car u) . bounds!-evalfcn1(fn,cdr u); put('log,'boundseval1,'boundsincreasingfn); put('asin,'boundseval1,'boundsincreasingfn); put('atan,'boundseval1,'boundsincreasingfn); put('sqrt,'boundseval1,'boundsincreasingfn); symbolic procedure boundsdecreasingfn(fn,u); boundsincreasingfn(fn,cdr u.car u); put('acos,'boundseval1,'boundsdecreasingfn); put('acot,'boundseval1,'boundsdecreasingfn); symbolic procedure boundssincos(fcn,n); % Reason if one of the turn points (n*pi) is in the % range. If yes, include the corresponding value 1 or -1. % Otherwise compute the range spanned by the end points. begin scalar lo,hi,alo,ahi,!1pi,!2pi,!3pi,l,m; integer s; lo := car n; hi := cdr n; <<setdmode('rounded,t); !1pi := simp 'pi; setdmode('rounded,nil); >> where dmode!* =nil; if not domainp numr !1pi then goto trivial; !2pi := addsq(!1pi,!1pi); !3pi := addsq(!1pi,!2pi); % convert sin to cos if fcn = 'sin then <<m :=multsq(!1pi, -1 ./ 2); lo := addsq(lo,m); hi := addsq(hi,m)>>; m := negsq multsq(!2pi,fixsq quotsq(lo,!2pi)); % move interval to main interval lo:=addsq(lo,m); hi:=addsq(hi,m); if minusf numr lo then <<lo := addsq(lo,!2pi); hi := addsq(hi,!2pi)>>; if null numr lo or sqgreaterp(hi,!2pi) then l:= (1 ./ 1) . l; if (sqgreaterp(!1pi,lo) and sqgreaterp(hi,!1pi)) or(sqgreaterp(!3pi,lo) and sqgreaterp(hi,!3pi)) then l := (-1 ./ 1) . l; if l and cdr l then goto trivial; l:=bounds!-evalfcn1('cos,lo) .bounds!-evalfcn1('cos,hi).l; if smemq('cos,l) then goto trivial; return minsq l . maxsq l; trivial: return ((-1)./1) . (1 ./ 1); end; symbolic procedure fixsq u; bounds!-evalfcn1('fix,u); symbolic procedure bounds!-evalfcn1(fcn,u); (if domainp numr u and denr u=1 and (x:=valuechk(fcn,list numr u)) then x else simp list(fcn,prepsq u)) where x=nil; symbolic procedure bounds!-evalfcn2(fcn,u,v); (if domainp numr u and denr u=1 and domainp numr v and denr v=1 and (x:=valuechk(fcn,list(numr u,numr v))) then x else simp list(fcn,prepsq u)) where x=nil; symbolic procedure agreaterp(u,v); (lambda x; if not atom denr x or not domainp numr x then error(99,"number") else numr x and !:minusp numr x) simp!* list('difference,v,u); symbolic procedure boundssin u; boundssincos('sin,u); symbolic procedure boundscos u; boundssincos('cos,u); put('sin,'boundseval,'boundssin); put('cos,'boundseval,'boundscos); symbolic procedure boundstancot(fcn,n); begin scalar lo,hi,alo,ahi,x,m,ppi; integer s; lo := car n; hi := cdr n; ppi := rdpi!*() ./ 1; if sqgreaterp(subtrsq(lo,hi),ppi) then goto no; lo:=bounds!-evalfcn1(fcn,lo); hi:=bounds!-evalfcn1(fcn,hi); if fcn='cot then <<x:=lo;lo:=hi;hi:=x>>; if not sqgreaterp(lo,hi) then return lo.hi; no: return boundserr(nil,"unbounded in range"); end; symbolic procedure boundstan u; boundstancot('tan,u); symbolic procedure boundscot u; boundstancot('cot,u); put('tan,'boundseval,'boundstan); put('cot,'boundseval,'boundscot); symbolic procedure boundsmaxmin u; if null cdr u then car u else boundsmaxmin2(car u,boundsmaxmin cdr u); symbolic procedure boundsmaxmin2(x,y); (if sqgreaterp(car x,car y) then car y else car x). (if sqgreaterp(cdr x,cdr y) then cdr x else cdr y); put('max,'boundsevaln,'boundsmaxmin); put('min,'boundsevaln,'boundsmaxmin); put('max,'boundseval,'boundsmaxmin2); put('min,'boundseval,'boundsmaxmin2); % for univariate polynomials we look at the extremal points and the % interval ends. Assuming that the same expression will be investigated % with different intervals, we store the knowledge about the polynomial. symbolic procedure boundspolynomial e; dm!: begin scalar x,u,z1,z2,lo,hi,mx,mn,d,v,l; if dmode!* neq '!:rd!: then return nil; if(u:=assoc(e,boundspolynomialdb!*)) then goto old; if null !*boundsfullcheck or null(x:=boundspolynomialtest e) then return nil; d := realroots{reval{'df,e,x}}; u := x. for each s in cdr d collect <<d:=numr simp caddr s; d . evaluate(e,{x},{d})>>; u:=e.u; boundspolynomialdb!*:=u.boundspolynomialdb!*; old: x:=cadr u; u :=cddr u; v := assoc(x,boundsdb!*); if null v then return nil; lo:=numr cadr v; hi:=numr cddr v; l:={evaluate(e,{x},{lo})./1 , evaluate(e,{x},{hi}) ./1}; for each p in u do if lo<car p and car p<hi then l:= (cdr p./1).l; return minsq l . maxsq l; end; symbolic procedure boundspolynomialtest e; (pairp r and car r) where r=boundspolynomialtest1(e,nil); symbolic procedure boundspolynomialtest1(e,x); if adomainp e then x or t else if atom e then boundspolynomialtestvariable(e,x) else if car e eq 'expt then fixp caddr e and boundspolynomialtestvariable(cadr e,x) else if car e eq 'minus then boundspolynomialtest1(cadr e,x) else if car e eq 'plus or car e eq 'times then begin scalar r; e:=cdr e; r:=t; while e and r do <<r:=boundspolynomialtest1(car e,x); if r neq t then x:=r; e:=cdr e>>; return x or r; end else boundspolynomialtestvariable(e,x); symbolic procedure boundspolynomialtestvariable(e,x); if x and e=car x then x else if x then nil else if assoc(e,boundsdb!*) then {e}; %-------------------------------------------------------------- % % support for compilation % %-------------------------------------------------------------- fluid '(boundsdb!* boundscompv!* boundscompcode!*); symbolic procedure boundscompile(e,v); % compile bounds evaluation function for expression e, % input intervals v. begin scalar boundsdb!*,boundscompv!*,boundscompcode!*,u; boundsdb!*:=for each x in v collect x.x; u:=boundscompile1(e,nil); return {'lambda,v, 'prog . boundscompv!* . append(reversip boundscompcode!*,{{'return,u}})}; end; symbolic procedure boundscompile1(u,flag); % Main driver for bounds compilation if adomainp u then <<u:=simp u;mkquote(u.u)>> else begin scalar v,w,fcn,var,q; if (v:=assoc(u,boundsdb!*))then return cdr v; if idp u and (fcn:=get(u,dmode!*)) then <<v:=apply(fcn,nil); v:=mkquote((v ./1).(v ./1)); goto done>>; if atom u then goto err1; if car u='expt and fixp caddr u and caddr u>0 then <<v:={'boundsexpt!-int,boundscompile1(cadr u,t),caddr u}; goto done>>; w := for each y in cdr u collect boundscompile1(y,t); v:= if length w>2 and (fcn:=get(car u,'boundsevaln)) then {fcn,'list.w} else if length w>2 then t else if (fcn:=get(car u,'boundseval1)) then {fcn,mkquote car u,car w} else if (fcn:=get(car u,'boundseval)) then if null cdr w then {fcn,car w} else {fcn,car w,cadr w} else if cdr w then t else {'boundsoperator,car u,car w}; done: if v=t then goto err2; if not flag then return v; var:=gensym(); boundscompv!* := var.boundscompv!*; boundscompcode!*:={'setq,var,v}.boundscompcode!*; % cache result for later usage. boundsdb!*:= (u.var).boundsdb!*; return var; err1: typerr(u,"bounded value"); err2: typerr(u,"expression to be compiled for bounds"); end; endmodule; module numint; % compute a numerical integral % Author: H. Melenk, % Version March 1993 % strategy for univariate integrals: % % 1. look for exact antiderivative, use that if it is % bounded in the interval, % % 2. try Chebyshev fit, % % 3. use M. Wulkow's adaptive multilevel quadrature. fluid '(!*noequiv accuracy!* singularities!*); global '(iterations!* !*trnumeric); symbolic procedure intrdeval u; % interface function; begin scalar e,l,vars,y,p,singularities!*; integer n; u := for each x in u collect reval x; u := accuracycontrol(u,3,20); e :=car u; u :=cdr u; % variables and interval's. if eqcar(car u,'list) then u := for each x in cdar u collect reval x; for each x in u do <<if not eqcar(x,'equal) then typerr(x,"interval bounds"); y:=revalnuminterval(caddr x,t); vars:=cadr x.vars; p:=(cadr x. car y. cadr y).p>>; return intrd1(e,vars,p); end; put('num_int,'psopfn,'intrdeval); symbolic procedure intrd1 (e,vars,p); if cdr vars then intrd2(e,vars,p) else % Univariate case. begin scalar fcn,x,u,w,acc,lo,hi,uu,loo,hii,oldmode,cbound; integer ord; fcn := e; x := car vars; lo := car cdar p; hi := cdr cdar p; if evalgreaterp(hi,lo) then <<loo:=lo; hii:=hi>> else <<loo:=hi; hii:=loo>>; % first attempt: look for bounded antiderivative. u := reval{'int,reval fcn,x} where dmode!*=nil,!*rounded=nil; oldmode:=switch!-mode!-rd nil; w:= errorset( {'boundseval,mkquote{u, {'equal,x,{'!*interval!*, loo, hii}}}}, nil,nil) where !*msg=nil; switch!-mode!-rd oldmode; if not smemq('int,u) and not errorp w then << if !*trnumeric then prin2t "Using bounded antiderivative"; oldmode:=switch!-mode!-rd nil; u:=simp u; w:= prepsq subtrsq(subsq(u,{x . hi}),subsq(u,{x . lo})); switch!-mode!-rd oldmode; return w; >>; if !*trnumeric then prin2t "No bounded antiderivative found"; % second attempt: look for a Chebyshev fit. w := nil; oldmode:=switch!-mode!-rd nil; acc := !:!:quotient(1,expt(10,accuracy!*)); cbound := dm!: (acc /(hii - loo)); ord := 20; chebloop: u := chebcoeffs(fcn,x,loo,hii,ord); uu := reverse u; if int!-chebconverges(uu,acc,cbound) then << u:=chebint(u,nil,loo,hii); w:=aeval{'difference,chebeval(u,nil,loo,hii,hi), chebeval(u,nil,loo,hii,lo)}; >>; if null w and ord<60 then <<ord:=ord+20; goto chebloop>>; switch!-mode!-rd oldmode; if w then <<if !*trnumeric then << prin2 "Using Chebyshev approximation or order "; prin2t ord>>; return w; >>; if !*trnumeric then << prin2t "No usable Chebyshev approximation found"; prin2t "Starting adaptive multilevel quadrature"; >>; return intrd2 (e,vars,p); end; symbolic procedure int!-chebconverges(u,acc,ab); % Test the (reverse) Chebyshev coefficients u for convergence. % acc: current accuracy (epsilon), ab: absolute upper bound for % trailing coefficient(s). begin scalar mx; mx := int!-chebmax(u,nil); dm!:(mx := mx*acc); return dm!:(abs car u < mx and abs cadr u < mx and abs caddr u < mx and abs car u < ab and abs cadr u < ab and abs caddr u < ab); end; symbolic procedure int!-chebmax(u,mx); if null u then mx else int!-chebmax(cdr u,if dm!:(w>mx) then w else mx) where w=dm!: abs car u; % ----------------- adaptive multilevel quadrature symbolic procedure intrd2 (e,vars,p); begin scalar acc,r,oldmode,!*noequiv; oldmode:=switch!-mode!-rd nil; acc := !:!:quotient(1,expt(10,accuracy!*)); e := reval e; r := if null cdr p then intrduni(e,p,acc) else intrdmulti(e,p,acc); switch!-mode!-rd oldmode; return r; end; symbolic procedure intevaluate1(e,x,v); (if atom a then <<singularities!*:=v.singularities!*; 0>> else car a)where a=evaluate!*(e,list x,list v); symbolic procedure intevaluate(e,x,v); (if atom a then <<singularities!*:=v.singularities!*; 0>> else car a)where a=evaluate!*(e,x,v); symbolic procedure intrduni (e,p,acc); % univariate integral. dm!: begin scalar lo,flo,hi,fhi,x,d,u,eps,i,il,r,int,oldint; integer n,k; x := car p; p:= cdr p; % evaluate the interval. lo := cadr x; hi := cddr x; x := car x; lo:=force!-to!-dm lo; hi:=force!-to!-dm hi; if hi=lo then return force!-to!-dm nil; % initial interval; il := list intrdmkinterval(e,x, (lo.intevaluate1(e,x,lo)), (hi.intevaluate1(e,x,hi)),1); int:=car lastpair car il; loop: k:=add1 k; n:=add1 n; if remainder(n,25)=0 then intrdmess(n,il); % divide the interval with the biggest local error; i:=car il; il:=cdr il; u:=intrdintersect(e,x,i); if null u then <<il:=i.il; intrdabortmsg(list car cadr i,list x,intcollecteps il); goto ready>>; for each q in u do il := intrdsortin(q,il); if k<5 then goto loop; % control variation of result if n=5 then <<int:=intcollectint il;acc:=acc*abs int>>; % adjust accuracy k:=0; eps := intcollecteps il; if eps>acc then goto loop; ready: return intcollectint il; end; symbolic procedure intrdabortmsg(pt,vars,eps); <<writepri( "requested accuracy cannot be reached within iteration limit",'only); writepri("critical area of function near to ",'first); writepri(mkquote('list . for each u in pair(vars,pt) collect list('equal,car u,prepf cdr u)),'last); writepri("current error estimate: ",'first); writepri(mkquote prepf eps,'last); >>; symbolic procedure intcollectint il; dm!: <<for each i in cdr il do r:= car lastpair i + r; r>> where r=car lastpair(car il); symbolic procedure intcollecteps il; dm!: <<for each i in cdr il do r:= car i + r; r>> where r=car(car il); symbolic procedure intrdsortin(u,l); % sort interval u into l such that l is sorted with descending car. dm!:( if null l then list u else if car u < caar l then car l . intrdsortin(u,cdr l) else u . l); symbolic procedure intrdintersect(e,x,i); begin scalar d,plo,pmi,phi,lev; i:= cdr i; plo := car i; i := cdr i; pmi := car i; i := cdr i; phi := car i; i := cdr i; d := car i; dm!:(d:=d/2); lev := cadr i +1; if lev>iterations!* then return nil; return list (intrdmkinterval(e,x,plo,pmi,lev) , intrdmkinterval(e,x,pmi,phi,lev) ); end; symbolic procedure intrdmkinterval(e,x,lo,hi,lev); dm!: begin scalar eps,it,is,mid,mi,flo,fhi,fmid,d,u; d := car hi- car lo; mid := (car hi+ car lo)/2; flo := cdr lo; fhi := cdr hi; fmid:=intevaluate1(e,x,mid); mi:=mid.fmid; if u:=intrdunisingular(lo,mi,hi) then <<flo:=car u; fmid:=cadr u; fhi:=caddr u>>; it := d*(flo+ 2fmid + fhi) / 4; % order 1 integral; is := d*(4*flo + 16*fmid + 4*fhi)/24; %simpson integral; eps:= abs(is-it); % interval record: return list (eps, % local error contrib lo, mi, hi, % the 3 points d, lev, is); % length and simpson. end; symbolic procedure intrdunisingular(lo,mi,hi); % local extraploation for singular points. if singularities!* then begin scalar slo,smi,shi,fl,fm,fh,u; slo:=member(car lo,singularities!*); smi:=member(car mi,singularities!*); shi:=member(car hi,singularities!*); if not slo and not smi and not shi then return nil; if slo and smi and shi then rederr "too many singularities"; fl:=cdr lo; fm:=cdr mi; fh:=cdr hi; dm!:( u := 2*(fl+fm+fh) ); return list(if slo then u else fl, if smi then u else fm, if shi then u else fh); end; symbolic procedure intrdmulti(e,p,acc); % multivariate integral. dm!: begin scalar vars,x,y,u,eps,i,il,r,int,oldint; integer n,k,dim; dim:=length p; il:=intrdmkinitcube(e,p); vars := car il; il:= cdr il; loop: k:=add1 k; n:=add1 n; if remainder(n,25)=0 then intrdmess(n,il); % divide the simplex with the biggest local error; i:=car il; il:=cdr il; u:=intrdrefinecube(e,vars,i); if null u then <<il:=i.il; intrdabortmsg(car cadr i,vars,intcollecteps il); goto ready>>; for each q in u do il := intrdsortin(q,il); if k<5 then goto loop; % control variation of result if n=5 then <<int:=intcollectint il;acc:=acc*abs int>>; % adjust accuracy k:=0; eps := intcollecteps il; if eps>acc then goto loop; ready: return intcollectint il; end; symbolic procedure intrdmkinitcube(e,p); % make initial element. begin scalar vol,points,vars,il,lo,hi,x,y; vol:=1; for each z in p do <<vars:=car z.vars; x:=force!-to!-dm cadr z; y:=force!-to!-dm cddr z; lo:=x.lo; hi:=y.hi; vol:= dm!:( abs(x-y)*vol ); >>; lo:=lo.intevaluate(e,vars,lo); hi:=hi.intevaluate(e,vars,hi); il:=list intrdmkcube(e,vars,lo,hi,vol,1); return vars.il; end; symbolic procedure intrdrefinecube(e,vars,i); dm!: % divide cube into 2. begin scalar plo,phi,lo,hi,nlo,nhi,vol,x,y,xnew; integer m,lev; i:=cdr i; plo:=car i; i:=cdr i; phi:=car i; i:=cdr i; vol:= car i / 2; lev := add1 cadr i; if lev > iterations!* then return nil; lo:=car plo; hi:=car phi; % select longest edge of interval; m := 1; x := car hi-car lo; for j:=2:length lo do if x<(y:=(nth(hi,j)-nth(lo,j))) then<<m:=j;x:=y>>; nlo := append(lo,nil); nhi := append(hi,nil); xnew:=(nth(hi,m) + nth(lo,m)) /2 ; nth(nlo,m):=xnew; nth(nhi,m):=xnew; nlo := nlo.intevaluate(e,vars,nlo); nhi := nhi.intevaluate(e,vars,nhi); return list( intrdmkcube(e,vars,plo,nhi,vol,lev), intrdmkcube(e,vars,nlo,phi,vol,lev)); end; symbolic procedure intrdmkcube(e,vars,lo,hi,vol,lev); % make a fresh cube record. dm!: begin scalar u,eps,it,is,mid,fmi,flo,fhi; flo:= cdr lo; fhi:= cdr hi; mid:=list!+list(car lo,car hi); mid:=scal!*list(1/2,mid); fmi:= intevaluate(e,vars,mid); if u:=intrdunisingular(lo,mid.fmi,hi) then <<flo:=car u; fmi:=cadr u; fhi:=caddr u>>; is:=flo+fhi; it:=is*vol/2; is:=(2*fmi+is)*vol/4; eps := abs(is-it); return list(eps,lo,hi,vol,lev,is); end; symbolic procedure intrdmess(n,il); if !*trnumeric then <<writepri(2*n,'first); writepri(" intervals, integral=",nil); writepri(mkquote prepf intcollectint il,nil); writepri(", error estimate=",nil); writepri(mkquote prepf intcollecteps il,nil); >>; symbolic procedure prinxt l; begin integer i; for each x in l do if not eqcar(x,'!:rd!:) then prin2 x else if atom cdr x then prin2 x else <<prin2 (float cadr x *expt(10.0,cddr x)); tab (i:=20+i)>>; terpri(); end; endmodule; module numfit; % approximation of functions with least spares. % Author: H. Melenk, ZIB, Berlin % Copyright (c): ZIB Berlin 1991, all rights resrved fluid '(!*noequiv accuracy!* singularities!*); global '(iterations !*trnumeric); symbolic procedure fiteval u; % interface function; begin scalar a,b,c,d,e,r,l,q,x,v,var,pars,fcn,fl,basis,pts, grad,oldmode,!*noequiv; integer n,i; if not(length u=3) then goto synerr; u := for each x in u collect reval x; u := accuracycontrol(u,6,200); fcn :=car u; u :=cdr u; if eqcar(fcn,'list) then fl:=cdr fcn; basis:=car u; u :=cdr u; if not eqcar(basis,'list) then goto synerr; basis := for each x in cdr basis collect simp reval x; var:= car u; u := cdr u; if not eqcar(var,'equal) then goto synerr; if not eqcar(pts:=caddr var,'list) then goto synerr; var := cadr var; pts:=cdr pts; n:=length pts; if !*trnumeric then prin2t "build generic approximation function"; a:=nil./1; for each b in basis do <<v:=gensym(); pars:=v.pars; a:=addsq(multsq(simp v,b),a)>>; % generate the error expression oldmode:=switch!-mode!-rd nil;!*noequiv:=nil; b:=a:=simp prepsq a; fcn:=simp if null fl then fcn else 'dummy; e:=nil./1; for each p in pts do <<i:=i+1;l:=list(var.p); % value to be substituted. if fl then l:=('dummy . reval nth(fl,i)).l; q:=subtrsq(subsq(fcn,l),subsq(b,l)); e:=addsq(e,multsq(q,q))>>; e:=prepsq e; if !*trnumeric then <<lprim "error function is:";writepri(mkquote e,'only)>>; % find minimum. % build gradient. grad:='list . for each v in pars collect reval {'df,e,v}; r:=rdsolveeval list (grad,'list . for each p in pars collect list('equal,p,0), {'equal,'accuracy,accuracy!*}, {'equal,'iterations,iterations!*}); % resubstitute into target function. if !*trnumeric then lprim "resubstituting in approximating form"; l:=nil; pars:= nil; for each p in cdr r collect <<x:=caddr p; pars:=x.pars; l:=(cadr p.x).l>>; a:=prepsq subsq(a,l); switch!-mode!-rd oldmode; return list('list, a ,'list . pars); synerr: rederr "illegal parameters in fit"; end; put('num_fit,'psopfn,'fiteval); endmodule; module chebysh; % Chebyshev approximation. % Literature: Press, Flannery, Teukolski, Vetterling: Numerical % Recipes, Cambridge University Press. % Author: Herbert Melenk % Copyright (c) 1993 ZIB Berlin, RAND. All rights reserved. put('chebyshev_fit,'psopfn,'(lambda(u)(chebysheveval u 'fit))); put('chebyshev_eval,'psopfn,'(lambda(u)(chebysheveval u 'eval))); put('chebyshev_int,'psopfn,'(lambda(u)(chebysheveval u 'int))); put('chebyshev_df,'psopfn,'(lambda(u)(chebysheveval u 'df))); symbolic procedure chebysheveval(u,mode); % interface function; begin scalar w,x,c,e,l,y,p,r,oldmode; integer n; u := for each x in u collect reval x; u := accuracycontrol(u,3,20); e :=car u; u :=cdr u; % variable and interval. w := car u; if not eqcar(w,'equal) then typerr(w,"interval bounds"); oldmode:=switch!-mode!-rd nil; y:=revalnuminterval(caddr w,t); x:=cadr w; if mode = 'fit then << n:=if cdr u then ieval cadr u else 20; c := chebcoeffs(e,x,car y,cadr y,n); r:= {'list, chebpol(c,x,car y,cadr y), 'list . c}; % for each q in c collect prepf q}; >> else if mode = 'eval then << if null cdr u or not eqcar(cadr u,'equal) then rederr("Chebyshev_eval: point missing"); e:=cdr listeval(e,t); w:=numr simp caddr cadr u; r:= prepf chebeval(e,x,car y,cadr y,w); >> else if mode = 'int or mode = 'df then << e:=cdr listeval(e,t); r:= if mode ='int then chebint(e,x,car y,cadr y) else chebdf (e,x,car y,cadr y); r:='list . for each q in r collect prepf q; >>; switch!-mode!-rd oldmode; return r; end; symbolic procedure chebcoeffs(func,x,a,b,n); begin integer k,j,n1; scalar fac,bpa,bma,f,!1pi,c,y,su,nn,half,w; x:={x}; !1pi := rdpi!*(); nn := dm!:(1/n); n1 := n-1; half := dm!:(1/2); dm!: <<bma:=(b-a)/2; bpa:=(b+a)/2>>; w := dm!:(!1pi*nn); f:=for k:=0:n1 collect <<y := dm!: (rdcos!*(w*(k+half))*bma+bpa); evaluate(func,x,{y}) >>; dm!: <<fac:=2*nn>>; c:=for j:=0:n1 collect << w:= dm!:(!1pi*j*nn); su:=nil; for k:=0:n1 do dm!:(su := su+nth(f,iadd1 k) *rdcos!*(w*(k+half))); dm!: (fac*su) >>; return c; end; symbolic procedure chebpol(c,x,a,b); begin scalar d,dd,sv,fac,cnst; integer n; n:=length c; d:=for i:=1:n collect nil; dd:=for i:=1:n collect nil; car dd := nth(c,n); for j:=(n-2) step -1 until 1 do << for k:=(n-j) step -1 until 1 do << sv := nth(d,k+1); nth(d,k+1) := dm!:(2*nth(d,k) - nth(dd,add1 k)); nth(dd,k+1) := sv >>; sv:=car d; car d := dm!:(- car dd + nth(c,add1 j)); car dd := sv; >>; for j:=(n-1) step -1 until 1 do nth(d,j+1) := dm!:(nth(d,j) - nth(dd,add1 j)); car d := dm!:(-car dd + car c/2); cnst:=dm!:(2/(b-a)); fac :=cnst; for j:=1:(n-1) do <<nth(d,add1 j) := dm!:(nth(d,add1 j) * fac); fac := dm!:(fac*cnst); >>; cnst:=dm!:((a+b)/2); for j:=0:(n-2) do for k:=(n-2) step -1 until j do nth(d,add1 k) := dm!:(nth(d,add1 k) - cnst*nth(d,add1 add1 k)); return reval ('plus. for i:=1:n collect {'times,nth(d,i),{'expt,x,i-1}}); end; symbolic procedure chebeval(c,xx,a,b,x); begin scalar d,dd,y,y2,sv; integer m; c:=for each q in c collect numr simp q; m:=length c; y2 := dm!:(2*(y:=(2*x-a-b)/(b-a))); for j:=(m-1) step -1 until 1 do << sv:=d; d:= dm!:(y2*d-dd+nth(c,add1 j)); dd := sv; >>; return dm!:(y*d-dd + car c/2); end; symbolic procedure chebint(c,xx,a,b); begin scalar su,fac,con,cint,w; integer n,jj; n := length c; c:=for each q in c collect numr simp q; fac := 1; con := dm!:((b-a)/4); cint := for j:=1:(n-2) collect << jj:=j+2; dm!:(w:= con*(nth(c,j)-nth(c,jj))/j ); dm!:(su := su + fac*w); dm!:(fac := -fac); w >>; cint := append(cint,{dm!: (con*nth(c,sub1 n)/(n-1))}); dm!:( su := su+fac*nth(c,n)); cint := (dm!:(su+su)) . cint; return cint; end; symbolic procedure chebdf(c,xx,a,b); begin scalar con,cder,w; integer n,jj; n := length c; c:=for each q in c collect numr simp q; cder := for i:=1:n collect nil; nth(cder,n-1) := dm!:(2*(n-1)*nth(c,n)); for j:=(n-3) step -1 until 0 do <<jj:=j+3; nth(cder,j+1):= dm!:(nth(cder,jj)+2*(j+1)*nth(c,add1 add1 j)); >>; con := dm!:(2/(b-a)); return for each q in cder collect dm!:(con * q); end; endmodule; module rungeku; % Numeric solution of ODE's with Runge-Kutta. % Version 2: supporting ODE systems % Author: H. Melenk, ZIB, Berlin % Copyright (c): ZIB Berlin 1993, all rights resrved fluid '(!*noequiv accuracy!*); global '(iterations!* !*trnumeric); put ('num_odesolve,'psopfn,'rungekuttaeval); symbolic procedure rungekuttaeval u; % interface function; begin scalar e,f,x,y,sx,sy,en,d,nd,v,w,q; integer n; u := for each x in u collect reval x; u := accuracycontrol(u,20,6); % equations e :=car u; u :=cdr u; e := if eqcar(e,'list) then cdr e else {e}; % dependent variable q :=car u; u :=cdr u; q := if eqcar(q,'list) then cdr q else {q}; for each yy in q do <<if not eqcar(yy,'equal) or not idp cadr yy then typerr(yy,"expression `dep. variable=starting value'"); sy:=caddr yy.sy; y := cadr yy.y; >>; sy:=reversip sy; y:=reversip y; if length sy neq length e then rederr "number of equations and variables don't correspond"; % independent variable x :=car u; u :=cdr u; if not eqcar(x,'equal) or not idp cadr x or null (w:=revalnuminterval(caddr x,t)) then typerr(x,"expression `indep. variable=interval'"); sx:=car w; en:=cadr w; x := cadr x; % convert expressions to explicit ODE system. q := for each yy in y collect {'df,yy,x}; v:=cdr solveeval list('list. e, 'list . q); if cdr v then ruksyserr(nil,"cannot convert to explicit ODE system"); f := for each d in q collect rukufindrhs(d,v); return rungekutta1(f,x,y,sx,en,sy); end; symbolic procedure rukufindrhs(d,e); % Find the righthand side for d in list e. if atom e then ruksyserr(d," cannot be moved to lhs of system") else if eqcar(car e,'equal) and cadr car e = d then reval caddr car e else if pairp e and eqcar(car e,'list) then rukufindrhs(d,cdar e) else rukufindrhs(d,cdr e); symbolic procedure ruksyserr(u,m); <<if u then writepri(mkquote u,'first); writepri(mkquote m,'last); rederr "Runge-Kutta failed"; >>; symbolic procedure rungekutta1(f,x,y,sx,ex,sy); %preparations for rungekutta iteration. (begin scalar acc,r,oldmode,!*noequiv; integer prec; if not memq(dmode!*,'(!:rd!: !:cr))then <<oldmode:=t; setdmode('rounded,t)>>; !*noequiv:=t; prec:=precision 0; sx := force!-to!-dm numr simp sx; ex := force!-to!-dm numr simp ex; sy := for each z in sy collect force!-to!-dm numr simp z; acc := !:!:quotient(1,expt(10,accuracy!*)); if !*trnumeric then prin2t "starting rungekutta iteration"; r := rungekutta2(f,x,y,sx,ex,sy,acc); if oldmode then setdmode('rounded,nil); precision prec; if null r then rederr "no solution found"; return 'list.r; end) where !*roundbf=!*roundbf; symbolic procedure rungekutta2(f,xx,yy,xs,xe,ys,acc); % Algorithm for numeric ODE solution % f(xx,yy): rhs; % x: independent variable; % y: dependent variable; % s: starting point; % e: endpoint; % acc: required accuracy % f,yy,ys are vectors (lists). dm!: begin scalar n,h,h2,h4,d1,d2,d3,d4,x,y,r,w1,w2,vars,dir; integer count,st; vars := xx.yy; x:=xs; y:=ys; h:=(xe - xs)/iterations!*; dir := h>0; st:= iterations!*; % compute initial stepsize adapt: h2:=h/2; h4:=h/4; % full stepsize. w1:=rungekuttastep(f,vars,x,y,h,h2); % same with half stepsize. w2:=rungekuttastep(f,vars,x,y,h2,h4); w2:=rungekuttastep(f,vars,x+h2,w2,h2,h4); % abs(w2 - w1) if normlist list!-list(w2,w1) > acc then <<h:=h2; st:=st+st; goto adapt>>; if !*trnumeric and not(st=iterations!*) then <<prin2 "*** RungeKutta increased number of steps to "; prin2t st>>; loop: if (dir and x>xe) or (not dir and x<xe) then goto finis; r:=('list.x.y) . r; count:=add1 count; y:= rungekuttastep(f,vars,x,y,h,h2); % Advance solution. x:=x+h; goto loop; finis: r:= ('list.xx.yy).('list.xs.ys). rungekuttares(reversip r,st); return r; end; symbolic procedure rungekuttares(l,st); % eliminate intermediate points. if st=iterations!* then l else << for i:=1:iterations!* collect <<for j:=1:m do l:= cdr l; car l>> >> where m=st/iterations!*; symbolic procedure rungekuttastep(f,vars,x,y,h,h2); dm!: begin scalar d1,d2,d3,d4,q; % f(x,y) d1:= list!-evaluate(f,vars,x.y); % f(x+h2,y+h2*d1) d2:= list!-evaluate(f,vars, (x+h2). list!+list(y,scal!*list(h2,d1))); % f(x+h2,y+h2*d2) d3:= list!-evaluate(f,vars, (x+h2). list!+list(y,scal!*list(h2,d2))); % f(x+h,y+h*d3) d4:= list!-evaluate(f,vars, (x+h).list!+list(y,scal!*list(h,d3))); % find y(x+h) = y+h*(d1 + 2*d2 + 2*d3 + d4)/6. y:=list!+list(y, scal!*list(!:!:quotient(h,6), list!+list(d1, list!+list(scal!*list(2,d2), list!+list(scal!*list(2,d3), d4))))); return y; end; endmodule; end;