From bfba2334455282165ad3feed6fc09a73095ca921 Mon Sep 17 00:00:00 2001 From: dprodanov Date: Sat, 20 May 2017 21:02:30 +0200 Subject: [PATCH] new version 2.4 2.4 Date 27 Nov 2016 - new implementation clicoeff - new implementation clidual - convenience matrix functions - added algebraical dual functionality - fixed regressive product - added Hestenes product - added xor function --- clifford.mac | 480 +++++++++++++++++++++++++++++-------------------- cliffordan.mac | 265 ++++++++++++++++++++------- maxima | 64 +++++++ 3 files changed, 556 insertions(+), 253 deletions(-) create mode 100644 maxima diff --git a/clifford.mac b/clifford.mac index 22aaf68..483a66a 100644 --- a/clifford.mac +++ b/clifford.mac @@ -4,8 +4,17 @@ a lightweight package for performing Geometric Algebra calculations @version + 2.4 Date 27 Nov 2016 + - new implementation clicoeff + - new implementation clidual + - convenience matrix functions + - added algebraical dual functionality + - fixed regressive product + - added Hestenes product + - added xor function + 2.3.4 Date 11 Sept 2016 - - fixed bug in innerp roduct + - fixed bug in inner product - change in declarations - regressive product -change in dual @@ -57,6 +66,10 @@ a lightweight package for performing Geometric Algebra calculations License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +max_version:build_info ()@version; +if orderlessp(max_version,"5.37") then error("Maxima verision ", max_version, " not supported"); + ttyoff:true; "vector symbol"; @@ -86,23 +99,35 @@ pfeformat: true; custom operators */ - "contractions based on Mcdonald"; + infix ("xor", 60, 60); + "xor" (a, b):= block ([la:[], lb:[]], + if listp(a) and listp(b) then ( + la: sublist (a, lambda([u], not member(u, b)) ), + lb: sublist (b, lambda([u], not member(u, a)) ), + append(la, lb) + ) else + (a or b) and not (a and b) + ); + infix ("|", 135, 134); texput ("|", " \\circ ", infix); wedgesimp:true; inprotype:sym; + "Hestenes product type"; + ipdecomp:false; declare("|", additive); "|"(a, b):= block ([l,r, qq, ret:0], - if ndim=0 then return ( buildq([a,b],"|"(a, b))), + if ndim=0 then return ( buildq([a,b], "|"(a, b))), if scalarp(a) or scalarp(b) then ( if inprotype='lc then if scalarp(a) then ret: a*b else ret:0 elseif inprotype='rc then if scalarp(b) then ret: a*b else ret:0 elseif inprotype='sym then ret:a.b, - return(ret) + if ipdecomp=true and (scalarp(a) or scalarp(b)) then return(0), + return(ret) ), if not mapatom(a) then a:expand(a), if not mapatom(b) then b:expand(b), @@ -120,85 +145,33 @@ pfeformat: true; /*display(l, r, qq),*/ if inprotype='rc then if qq<0 then return(0) - elseif qq<= l+r then ( + elseif qq<= l+r then ret:cliffsimp1(a.b), - ret:grpart(ret, qq) - ), if inprotype='lc then if qq>0 then return(0) else ( - qq:abs(qq), - if qq<= l+r then ( - ret:cliffsimp1(a.b), - ret:grpart(ret, qq) - ) + qq:-qq, + if qq<= l+r then + ret:cliffsimp1(a.b) ), if inprotype='sym then ( qq:abs(qq), - ret:cliffsimp1(a.b), - ret:grpart(ret, qq) + ret:cliffsimp1(a.b) ), - (ret) + grpart(ret, qq) + ); texput ("\\", " \\circ ", infix); - - /*Grassmann product (exprimental) - should be the same as outer product*/ - - infix("~", 135, 134); - declare("~", additive ); - - "~"(a,b):=block([ ss:1, rr:[], l1, l2, w, la, ra, rb, lb, n], - if scalarp(a) or scalarp(b) then - return(a.b), - - if inop(a)="+" then return (map( lambda ([u], u ~ b), a)), - if inop(b)="+" then return (map( lambda ([u], a ~ u), b)), - - if mapatom(a) and mapatom(b) then - if a#b then return(a.b) - else return (0), - - if wedgesimp then ( - if not freeof(".", a) then - a:cliffsimp1(a), - if not freeof(".", b) then - b:cliffsimp1(b) - ), - [ra, la]: oppart(a, lambda([u], freeof ("~", u) and scalarp(u) )), - ra:subst(nil=1, ra), - la:subst(nil=1, la), - if mapatom (la) then l1:[la] else l1: inargs(la), - - [rb, lb]: oppart(b, lambda([u], freeof ("~", u) and scalarp(u) )), - rb:subst(nil=1, rb), - lb:subst(nil=1, lb), - - if mapatom (lb) then l2:[lb] else l2: inargs(lb), - if member(la, lb) or member(lb, la) or la=lb then return (0), - rr:copy(append(l1, l2)), - w:permsign(rr), - rr:sort(rr), - n:length(rr), - rr:endcons (1, rr), - /*display(rr),*/ - for i:1 step 1 thru n do - if rr[i] = rr[i+1] then - return(ss:0) - else - ss: ss . rr[i], - ra*rb*w*ss - ); - - texput ("~", " \\wedge ", infix); - - + + "alt-Grassman product type"; + ipdecompalt:false; "outer product"; infix("&", 135, 134); declare("&", additive); - + "&"(a, b):= block ([l,r, ret:0], if ndim=0 then return ( buildq([a,b], "&"(a, b))), + if ipdecompalt=true and (scalarp(a) or scalarp(b)) then return(0), if not mapatom(a) then a:expand(a), if not mapatom(b) then b:expand(b), if inop(a)="+" then return (map( lambda ([u], u & b), a)), @@ -211,7 +184,6 @@ pfeformat: true; ), l:maxgrade(a), r:maxgrade(b), - /*display(l,r),*/ ret:cliffsimp1(a.b), ret:grpart(ret, l+r), ret @@ -219,9 +191,70 @@ pfeformat: true; texput ("&", " \\wedge ", infix); - regproduct(a, b):=block([ai, bi, inprotype:lc], - ai:cliffsimp1(dual(a)), - (ai | b) + outprod(a, b):= block ([ss:0, ret:0, lva, lvb, z, lvu], + if ipdecompalt=true and (scalarp(a) or scalarp(b)) then return(0) + elseif scalarp(a) or scalarp(b) then return(a*b), + if not mapatom(a) then a:expand(a), + if not mapatom(b) then b:expand(b), + if inop(a)="+" then return (map( lambda ([u], outprod(u , b)), a)), + if inop(b)="+" then return (map( lambda ([u], outprod(a , u)), b)), + if wedgesimp then ( + if not freeof(".", a) then + a:cliffsimp1(a), + if not freeof(".", b) then + b:cliffsimp1(b) + ), + lva:sublist(listofvars(a), lambda([u], not freeof(asymbol, u))), + lvb:sublist(listofvars(b), lambda([u], not freeof(asymbol, u))), + lvu:sublist (lva, lambda([u], member(u, lvb)) ), + z: length(lvu), + if z>0 then 0 else( + ret:cliffsimp1(a.b), + ss:scalarpart(ret), + ret-ss + ) + ); + + scprod(xx, yy):=block ([ret], + ret: dotsimpc(expand(xx.yy)), + scalarpart(ret) + ); + + /*dualcoeff(a):=dual(dotsimpc(a.a.a.dual(a)));*/ + dualcoeff(a):=coeff(dotsimpc(a.a.a.dual(a)), %iv); + + lcprod(a, b):= block([bi, ss, ret ], + bi:dual(b), + ret:outprod(a, bi), + ss:dualcoeff(a), + ss*dual(ret) + ); + + rcprod(a, b):= block([ai, ss, ret ], + ai:dual(a), + ret:outprod(ai, b), + ss:dualcoeff(b), + ss*dual(ret) + ); + + dotproduct(a,b):=block([ ret, u, ss, ai, bi], + ret:lcprod(a, b) + rcprod(a, b), + u:scprod(a, b), + ret -u + ); + + regproduct(a, b):=block([ai, bi, ss], + ai:(dual(a)), + bi:(dual(b)), + ss:dualcoeff(a)*dualcoeff(b)*%ivnorm, + ss*dual(ai & bi) + ); + + regproduct2(a, b):=block([ai, bi, ss], + ai:(dual(a)), + bi:(dual(b)), + ss:dualcoeff(a)*dualcoeff(b)*%ivnorm, + ss*dotsimpc ( ai & bi ) ); /* @@ -269,6 +302,24 @@ oppart(expr, predf):=block( lst ); +/* +splits an expression by occurencess of an operator +*/ +explodeop(expr, sop):=block( + if mapatom(expr) then return ([expr]), + xreduce(append , maplist(lambda([w], explodeop(w, sop)), expr)) + ); + +/* +combinees a list by operator +*/ +implodeop(lsta, sop):=block( + if not listp(lsta) then return (lsta), + xreduce(sop, maplist(lambda([w], implodeop(w, sop)), lsta)) +); + + + realp (x):= featurep(x, real); scalarsym():=sublist(props, lambda( [z], if symbolp(z) then scalarp(z) else false)); @@ -304,6 +355,10 @@ toggles debugging */ toggle_debug():= _debug: not _debug; +clv(expr):=( + sublist(listofvars(expr), lambda([u], not freeof(asymbol, u))) +); + /* simplification of dot-products */ @@ -323,8 +378,8 @@ dotsimpc(ab):=block([ba, c:1, v, w:1, q, r, l, sop], l:subst(".","*",l), r*dotsimpc(l) ) else ( - ba:copy(ab), - v:inargs(ba), + /*ba:copy(ab),*/ + v:copy(inargs(ab)), if _debug=true then display(sop, v), w:sublist( v, lambda ([z], not freeof(asymbol,z) and mapatom(z))), w:permsign(w), @@ -365,18 +420,12 @@ if get('clifford,'version)=false then ( tellsimp(aa[kk].aa[kk], signature[kk] ), tellsimpafter(aa[kk].aa[mm], dotsimp2(aa[kk].aa[mm])), tellsimpafter(bb.ee.cc, dotsimpc(bb.ee.cc)), - tellsimpafter(aa^nn, aa^^nn), + tellsimpafter(aa[kk]^^nn, powsimp(aa[kk]^^nn)), simp:true ); /* experimental code*/ if get('clifford,'version)=false then ( - /* simplification of powers - tellsimpafter(aa[kk]^nn, powsimp(aa[kk]^nn)),*/ - /* - tellsimp(aa[kk] * aa[kk], signature[kk] ), - tellsimp(aa[kk] * aa[mm], 0), - tellsimpafter(aa[kk]^^nn, powsimp(aa[kk]^^nn)),*/ /* simplification of involution*/ tellsimpafter('cinvolve('cinvolve(bb)), bb) ); @@ -387,9 +436,9 @@ simplification rules matchdeclare(dd, lambda([u], freeof(asymbol, u)), gg, lambda([u], not freeof(asymbol, u))); matchdeclare(ds, lambda([u], not freeof(asymbol, u) and not (freeof("^", u) or freeof("^^", u) ) ), rn, numberp); -defrule (clifsimp1, dd*aa, dd.dotsimpc(aa)); -defrule (clifsimp11, bb.aa, bb.dotsimpc(aa)); -defrule (clifsimp10, aa, dotsimpc(aa)); +defrule (clifsimp1, dd*bb, dd.dotsimpc(bb)); +defrule (clifsimp11, bb.cc, bb.dotsimpc(cc)); +defrule (clifsimp10, bb, dotsimpc(bb)); defrule (clifsimp21, bb/gg, bb . dotinvsimp(1/gg)); defrule (clifsimp3, ds, powsimp(ds)); @@ -446,7 +495,6 @@ cinv(ab):=block( [s, b, u:1], if atom(ab) or freeof(asymbol, ab) then if ab#0 then return(1/ab) else return('nan), "first attempt - conjugattion", - "b:cconjugate(ab)", b:dotconjugate(ab), s:expand(b.ab), if not freeof(asymbol, s) then s: apply1(s, clifsimp10, clifsimp21), @@ -471,12 +519,12 @@ powsimp(aa):=block( [a, k, p:1], if inop(aa)="^^" then ( a:inpart(aa,1), k:inpart(aa,2), - for j:1 thru k do - p:p.a, - dotsimpc(p) - ) - else aa - ); + if numberp(k) then ( + for j:1 thru k do p:p.a, + dotsimpc(p) + ) else aa + ) else aa +); @@ -615,13 +663,13 @@ countsym(ab, sym):=block([sop, a, b, s:0, inflag:true ], ); /* experimental code*/ -count_subexpr(ab, sym):=block([inflag:true ], +countsym2(ab, sym):=block([inflag:true ], if freeof(sym, ab) then return(0), if atom(ab) then if sym=ab then return(1), if subvarp(ab) then if sym=op(ab) then return(1), - xreduce("+", maplist( lambda([i], count_subexpr(i, sym)), ab)) + xreduce("+", maplist( lambda([i], countsym2(i, sym)), ab)) ); @@ -653,22 +701,33 @@ grade(expr, [gradexpand]):=block([cc, sop, k ], listarray(cc) ); +/* +grade decomposition of expressions +factors and produces a matrix + */ +matrixgrade(expr):=block([ret], + ret:grade(expr), + ret:maplist ( lambda([u], factorby( u, %elements)) , ret), + transpose(matrix(ret)) +); + /* maximal grade of an expression */ -maxgrade(expr):=block([lst], +maxgrade(expr):=block([lst:[] ], if freeof (asymbol, expr) then return (0), if inop(expr)="+" then ( lst:maplist(maxgrade, expr), lmax(lst) ) else - countsym(expr, asymbol) + countsym2(expr, asymbol) ); /* Partial factoring by subexpression */ factorby(expr, z):=block([quot, res, ret, ee, n, sop, %qq, radsubstflag:true ], + if emptyp(z) then return (expr), if atom(expr) then return (expr), if matrixp(expr) then return(matrixmap(lambda([u], factorby(u, z)), expr)), @@ -723,52 +782,41 @@ simpfact(expr, z):=block([ret:expr], if not mapatom(ret) then map(lambda([u], factorby(u, z)), ret) else ret ); - + + +listofclivars(expr):=( + if length(%elements)=1 then %elements:elements(), + sublist(%elements, lambda ([u], not freeof(u, expr))) +); + +clifact(expr):=block([lcv:[], ret: expr], + if not mapatom(expr) then ( + lcv: listofclivars(expr), + if not emptyp(lcv) then + ret:factorby(expr, lcv) + ), + ret +); /* computes the element decomposition */ -clicoeff(expr, smat):=block([cc, ee, sop, r, l, u, elst, lst, use_fast_arrays:false ], - local(cc, ee), - if not mapatom(expr) then - expr:expand(expr), - sop: inop(expr), - if sop="+" then ( - lst: inargs( (expr)), - for v in lst do ( - if _debug=true then display( v), - if freeof (asymbol, v ) then ( - if cc[1] =arraymake (cc, [1]) then cc[1]:0, - cc[1]:cc[1]+v, - ee[1]:1 - ) else ( - [l,r]: oppart (v, lambda ([u], freeof(asymbol, u))), - ee[r]:r, - l:subst('nil=1, l), - if cc[r] =arraymake (cc, [r]) then cc[r]:0, - cc[r]:cc[r] +l, - if _debug=true then display(r,l, ee[r], cc[r] ) - ) - ) - )else ( "simple expression, separate", - if freeof (asymbol, expr ) then ( - cc[1]:expr, - if expr#0 then - ee[1]:1 else ee[1]:0 - )else ( - [l,r]: oppart (expr, lambda ([u], freeof(asymbol, u))), - if _debug=true then display(r,l), - cc[ r]:subst('nil=1, l), - ee[ r]:r - ) + +clicoeff2(expr, smat):=block([ ee:[], z:[], cc:[], qq ], + if length(%elements)=1 then %elements:elements(), + cc:map(lambda([u], coeff(expr, u)), %elements), + z:sublist_indices(cc, lambda([u], u#0)), + ee:makelist(%elements[i], i, z), + qq:expand(expr-substinpart("+", makelist (cc[i]*%elements[i], i, z), 0)), + cc:makelist(cc[i], i, z), + if qq#0 then ( + cc: cons(qq, cc), + ee: cons(1, ee) ), - lst:listarray(cc), - lst:subst(false=0, lst), - elst:listarray(ee), - elst:unique (elst), if smat='list then - [elst, lst] - else if smat='mat then - [elst, transpose(matrix(lst))] + [ee, cc] + else if smat='mat and not emptyp(cc) then + [ee, transpose(matrix(cc))] else [ ] + ); /* @@ -781,7 +829,7 @@ bdecompose(expr):=block([gr:expr], %elements:elements(), gr:map( lambda([v], factorby(v, %elements) ), gr ), gr:grade(gr), - map(lambda([z], clicoeff(z, 'mat)),gr) + map(lambda([z], clicoeff2(z, 'mat)),gr) ); /* @@ -904,18 +952,34 @@ mtable2i():=block([n, lst], genmatrix( lambda([i,j], dotsimpc(lst[i] | lst[j] ) ), n) ); +/** + outer product table, all elements +*/ mtable2o():=block([n, a, lst], lst: elements(all), n:length(lst), genmatrix( lambda([i,j], dotsimpc(lst[i] & lst[j] ) ), n) ); -mtable21o():=block([n, a, lst], +/** + regressive product table, all elements +*/ +mtable2r():=block([n, a, lst], lst: elements(all), n:length(lst), - genmatrix( lambda([i,j], (lst[i] ~ lst[j] ) ), n) + genmatrix( lambda([i,j], dotsimpc(lst[i] . dual(lst[j]))), n) ); +/** + scalar product table, all elements +*/ +mtable2s():=block([n, a, lst], + lst: elements(all), + n:length(lst), + genmatrix( lambda([i,j], scalarpart ( dotsimpc(lst[i] . lst[j] ) )), n) +); + + /** multiplication table, reduced */ @@ -929,6 +993,9 @@ mtable1([lst]):=block([n], genmatrix( lambda([i,j], dotsimpc(lst[i] . lst[j] ) ), n) ); +/** + inner product table, reduced +*/ mtable1i([lst]):=block([n], if emptyp(lst) then lst:makelist(asymbol[i], i, ndim) @@ -939,6 +1006,9 @@ mtable1i([lst]):=block([n], genmatrix( lambda([i,j], dotsimpc(lst[i] | lst[j] ) ), n) ); +/** + multiplication table, reduced +*/ mtable1o([lst]):=block([n], if emptyp(lst) then lst:makelist(asymbol[i], i, ndim) @@ -949,16 +1019,6 @@ mtable1o([lst]):=block([n], genmatrix( lambda([i,j], dotsimpc(lst[i] & lst[j] ) ), n) ); -mtable11o([lst]):=block([n], - if emptyp(lst) then - lst:makelist(asymbol[i], i, ndim) - else - lst:lst[1], - lst:push(1, lst), - n:length(lst), - genmatrix( lambda([i,j], dotsimpc(lst[i] ~ lst[j] ) ), n) -); - mtable1r([lst]):=block([n], if emptyp(lst) then lst:makelist(asymbol[i], i, ndim) @@ -966,7 +1026,7 @@ mtable1r([lst]):=block([n], lst:lst[1], lst:push(1, lst), n:length(lst), - genmatrix( lambda([i,j], regproduct(lst[i] , lst[j] ) ), n) + genmatrix( lambda([i,j], dotsimpc(lst[i] . dual(lst[j]))), n) ); mtable1s([lst]):=block([n], @@ -985,12 +1045,23 @@ mtable1s([lst]):=block([n], experimental code */ +/* +diagnoal transposition of a matrix +*/ +dtranspose(M):= map(reverse, M); + diag(MM):=block([n], if not matrixp(MM) then error("matrix required"), n:length(MM), genmatrix( lambda([i,j], if i=j then MM[i,j] else 0 ), n) ); +adiag(MM):=block([n], + if not matrixp(MM) then error("matrix required"), + n:length(MM), + genmatrix( lambda([i,j], if i=j then MM[n-i +1, j] else 0 ), n) +); + diaglist(MM):=block([n, LL], if not matrixp(MM) then error("matrix required"), n:length(MM), @@ -998,6 +1069,12 @@ diaglist(MM):=block([n, LL], LL:genmatrix( lambda([i,j], if i=j then MM[i,j] else 0 ), n), list_matrix_entries(matrix(makelist(1, n)).LL) ); + +mdiag(MM):=block([n], + if not listp(MM) then error("list required"), + n:length(MM), + genmatrix( lambda([i,j], if i=j then MM[i] else 0 ), n) +); /* computes the commutation table with all basis vectors @@ -1032,22 +1109,10 @@ cnorm(x):=block([u:expand(x), z, v], u:expand(u | cconjugate(u)), u:cliffsimpall(u), u:expand(u), - /*if not freeof (".", u) then - error ("not free of non-scalars "), */ u:scalarpart(u), u:ratsimp(u) ); -cnorm2(x):=block([u:expand(x), z, v], - u:expand(u | creverse(u)), - u:cliffsimpall(u), - /*if not freeof (".", u) then - error ("not free of non-scalars "), */ - u:expand(u), - u:scalarpart(u), - u:ratsimp(u) -); - /* symmetric bilinear form of the algebra; */ @@ -1116,7 +1181,7 @@ nscalarpart(v):=block([ r, l, sop ], ) else if not freeof(asymbol, v) then r:v else r:0, - r + clifact(r) ); /* @@ -1125,7 +1190,7 @@ nscalarpart(v):=block([ r, l, sop ], vectorpart(v):=block([gr], if freeof(asymbol, v) then return (0), gr:grade(v), - gr[2] + clifact(gr[2]) ); /* @@ -1136,19 +1201,24 @@ mvectorpart(v):=block([ r, l, gr ], gr:grade(v), gr:sublist(gr, lambda([u], not freeof(".", u))), if emptyp(gr) then 0 else - substinpart("+", gr, 0) + gr:substinpart("+", gr, 0), + clifact(gr) ); /** grade of order k */ -grpart(v,k):=block([gr, k:k+1], - if k>ndim+1 then k:ndim+1, - gr:grade(v), - gr[k] +grpart(v, k):=block([gr], + if listp(k) then + substinpart("+", map(lambda([u], grpart (v, u)), k), 0) + else ( + k:k+1, + if k>ndim+1 then k:ndim+1, + gr:grade(v), + clifact(gr[k]) + ) ); - /* constructs a vector */ @@ -1198,27 +1268,52 @@ celem(x, [cc]):=block([ee, ss:0, n, qq], */ /** - dual element - dual(x):= x. %iv; + algebraical dual element */ -dual(x):=block ([ii ], - if listp(x) then maplist(dual, x) - elseif matrixp(x) then matrixmap(dual, x) - else ( - ii:%ivnorm* %iv, - cliffsimp1(x. ii) - ) +dual(expr):=block([lste:[], lsti:[], r, l], + if matrixp(expr) then + return(matrixmap(dual, expr )), + if listp(expr) then + return(maplist(dual, expr )), + if not mapatom(expr) and inop(expr)="+" then + map(dual, expr) + else ( + [l, r]:subst('nil=1, oppart(expr, lambda([u], freeof(asymbol, u)))), + lste:clv(r), + lsti: vectors(), + lste: lste xor lsti, + r:substinpart(".", lste, 0), + l*r + ) ); -/* -conjel(x, k):= (asymbol[k]. x)/asymbol[k] ; -*/ +/** + clifford dual element + */ +clidual(expr):=block([lste:[], lsti:[], r, l, ss:1], + if matrixp(expr) then + return(matrixmap(clidual, expr )), + if listp(expr) then + return(maplist(clidual, expr )), + if not mapatom(expr) and inop(expr)="+" then + map(clidual, expr) + else ( + [l, r]:subst('nil=1, oppart(expr, lambda([u], freeof(asymbol, u)))), + lste:clv(r), + lsti:vectors(), + if %ivnorm#0 then ss:%ivnorm, + ss:ss*permsign( append (lste, lsti)), + lste: lste xor lsti, + r:substinpart(".", lste, 0), + ss*l*r + ) +); /* computes a unit element */ uelem(vv):=block( [qq], - qq:cnorm2(vv), + qq:-cnorm(vv), if qq=0 then return(vv), if %divsimp=true then ( qq:trigsimp(qq), @@ -1246,8 +1341,9 @@ prodecomp(a,b):=block( [ret, gr, l, r, m, inner:0, outer:0], [inner, outer, ret] ); -comm(a,b):=expand(a.b - b.a)/2; -acomm(a,b):=expand(a.b + b.a)/2; +comm(a,b):= cliffsimp1 (expand(a. b - b. a))/2; +acomm(a,b):=cliffsimp1 (expand(a. b + b. a))/2; + /* grade automorphism by predicate @@ -1267,16 +1363,18 @@ predautom(vv, predf):=block ([gr, v:0, k, w], ); /* -Hitzer Sangwine automorphism +Hitzer-Sangwine automorphism */ hautom(vv, lst):=block([listarith:true ], - predautom(A, lambda([u,v], member(v, lst+1))) + predautom(vv, lambda([u,v], member(v, lst+1))) ); /* -scalr part automorphism +scalar part automorphism */ -sautom(vv):=predautom(A, lambda([u,v], not scalarp(u))); +sautom(vv):=predautom(vv, lambda([u,v], not scalarp(u))); + +psautom(vv):=predautom(vv, lambda([u,v], maxgrade(u)=ndim)); /* Shirokov quaternion type classification */ qclass (vv) :=block ( [ar, ai, as, br, bi, bc], @@ -1307,7 +1405,7 @@ cdgrade(vv, classf):=block ([gr, w, k, cs, clist], local(cs), for i:1 thru ndim+1 do ( k:apply(classf, [gr[i], i]), - if op( cs[k])='cs then cs[k]:0, + if op(cs[k])='cs then cs[k]:0, cs[k]:cs[k]+gr[i] ), listarray(cs) @@ -1332,4 +1430,4 @@ print("package name: clifford.mac"); print("author: ", get('clifford,'author)); print("version:", get('clifford,'version)); print("Recommended location: share/contrib"); -print("last update: 28 Aug 2016"); \ No newline at end of file +print("last update: 12 Dec 2016"); \ No newline at end of file diff --git a/cliffordan.mac b/cliffordan.mac index 87dc5ea..a00efc9 100644 --- a/cliffordan.mac +++ b/cliffordan.mac @@ -4,7 +4,9 @@ a lightweight package for performing Geometric Algebra calculations Clifford analysis -@version 1.6.5 Date 13 Jun 2016 +@version 1.7 Data 12 Dec 2016 + - projection derivatives + 1.6.5 Date 13 Jun 2016 1.6 Date 10 Apr 2016 1.5 Date 20 Feb 2016 1.2 Date 22 Jan 2016 @@ -36,8 +38,11 @@ if get('clifford,'version)=false then ( err:errcatch( load("clifford.mac") ), - if emptyp(err) then ( + if emptyp(err) then ( + infix ("|", 130, 129), + infix("&", 130, 129) + /* "inner product", infix ("|", 130, 129), "|"(a, b):= expand((a.b + cinvolve(b).cinvolve(a))/2), @@ -47,13 +52,28 @@ if get('clifford,'version)=false then ( infix("&", 130, 129), "&"(a, b):= expand((a.b - cinvolve(b).cinvolve(a))/2), texput ("&", " \\wedge ", infix) + */ ) + +); + +if get('cliffordan,'version)=false then ( + "inner product", + infix ("@", 130, 129), + "@"(a, b):= scprod(a,b), + print("warning: redefining @") + /* + simp:false, + tellsimpafter(asymbol[kk] * asymbol[mm], if kk#mm then 0 else signature[kk]), + tellsimpafter(asymbol[kk] * asymbol[mm] *bb, if kk#mm then 0 else signature[kk]*bb), + tellsimpafter(aa[kk]^nn, if oddp(nn) then 0 else signature[kk] ), + simp:true + */ ); %clverbose:false; %divsimp:true; - dependsv(F, var):= block([ ee], if subvarp(var) then var:op(var), if subvarp(F) then F:op(F), @@ -66,7 +86,6 @@ dependsv(F, var):= block([ ee], ev(depends(F,ee), nouns) ); - /* Analysis functions @@ -106,6 +125,72 @@ ctotdiff(f, x):=block( [ret:0, lv], ret ); + +/* + Clifford-valued + directional derivative + */ +cdirdiff(f, v, x):=block( [ret:0, lv, uu:0, qq], + if mapatom(x) then + ret: scalarpart(v)*diff( f, x ) + else ( + lv: sublist( listofvars(x), lambda ([z], freeof(asymbol, z))), + for u in lv do ( + qq: cinv(diff(x, u)), + uu: scprod(qq , v), + ret: ret + uu * subst(".", "*", diff( f, u )) + ) + ), + clifact(dotsimpc(ret)) +); + +cdirdualdiff(f, v, x):=block( [ret:0, lv, uu:0, qq, d], + if mapatom(x) then + ret: scalarpart(v)*diff( f, x ) + else ( + d: clidual(v), + lv: sublist( listofvars(x), lambda ([z], freeof(asymbol, z))), + for u in lv do ( + qq: cinv(diff(x, u)), + uu: scprod(qq , d), + ret: ret + uu * subst(".", "*", diff( f, u )) + ) + ), + factorby(dotsimpc(ret), %elements) +); + +cndirdiff(f, v, x):=block( [ret:0, lv, uu:0, qq], + if mapatom(x) then + ret: scalarpart(v)*diff( f, x ) + else ( + lv: sublist( listofvars(x), lambda ([z], freeof(asymbol, z))), + for u in lv do ( + qq: cinv(diff(x, u)), + uu: expand(qq . v) - scprod(qq , v), + uu: dotsimpc(uu), + ret: ret + uu. subst(".", "*", diff( f, u )) + ) + ), + ret:expand(ret), + factorby(dotsimpc(ret), %elements) +); + +ctotprojdiff(f, v, x):=block( [ret:0, lv, uu:0, qq], + if mapatom(x) then + ret: scalarpart(v)*diff( f, x ) + else ( + lv: sublist( listofvars(x), lambda ([z], freeof(asymbol, z))), + for u in lv do ( + qq: cinv(diff(x, u)), + uu: expand(qq . v), + uu: dotsimpc(uu), + ret: ret + uu. subst(".", "*", diff( f, u )) + ) + ), + ret:expand(ret), + dotsimpc(ret) +); + ctotintdiff(f, x):=block( [ret:0, lv], if mapatom(x) then ret: diff( f, x ) @@ -140,41 +225,23 @@ mvectdiff(f, x, [k] ):=block ([s:0, n:1, m, es], f:s ), if %divsimp=true then ( - es: sublist( listofvars(x), lambda ([z], not freeof(asymbol, z))), "display(es)", s:trigsimp(s), - if not emptyp(es) then - s:simpfact(s, es) + s:clifact(s) ), s ); -/* -diffmap(f, x, eps):= block([es, ex, df, q, v, aa, listarith:true, ss:0 ], - [es, ex]: oppart( listofvars(x), lambda ([z], freeof(asymbol, z))), - ex: push(1, ex), - q: makelist(es[i]=es[i]+eps, i, 1, length(es)), - df:expand(subst(q, f) - f), - display(df, ex), - for i:1 thru length(ex) do ( - aa:expand( (df | ex[i]) ), - disp(aa), - aa:expand( aa/eps), - ss:ss+aa - ), - ss -); - */ /* partial derivative */ -pardiff(f, x, [k] ):=block( [ret:0 ], +pardiff(f, x, [k] ):=block( [ret:0, u:gensym() ], if emptyp(k) then k:1 else k: k[1], if mapatom(x) then ret:diff(f, x, k ) else ( - ret:diff(ratsubst( u, x, f),u, k), + ret:diff(ratsubst( u, x, f), u, k), ret:subst(u=x,ret) ), ret @@ -204,13 +271,12 @@ vectdiff(f, x, [k] ):=block ([s, n:1, m, i ], /* multi vector partial derivative */ -parmvectdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq, es ], - [ee, xx]:clicoeff(x, 'list), - if %clverbose=true then - display(xx), +parmvectdiff(f, x, [k] ):=block ([s, m, i, ee, xx, df, qq, es ], + [ee, xx]:clicoeff2(x, 'list), if emptyp(k) then k:1 else k: k[1], es: sublist( listofvars(x), lambda ([z], not freeof(asymbol, z))), - "display(es)", + if %clverbose=true then + display(es), for p:1 thru k do ( i:1, s:0, for m in xx do ( @@ -220,17 +286,36 @@ parmvectdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq, es ], i:i+1 ), if %divsimp=true then ( - /*s:cliffsimpall(s),*/ if not emptyp(es) then s:simpfact(s, es) ), f:s ), + clifact(s) +); + + +parmvectdirdiff(f, v, x, [k] ):=block ([s, ee, xx, df, qq, uu ], + [ee, xx]:clicoeff2(x, 'list), + if %clverbose=true then + display(xx), + if emptyp(k) then k:1 else k: k[1], + for p:1 thru k do ( + s:0, + for i:1 thru length(xx) do ( + df: expand(pardiff( f, xx[i] )), + qq: cinv(ee[i]), + uu: scprod(qq , v), + /*display(qq, uu, df),*/ + s: s + cliffsimpall(uu*subst(".", "*", df )) + ), + f:s + ), s ); parmvectintdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq, es ], - [ee, xx]:clicoeff(x, 'list), + [ee, xx]:clicoeff2(x, 'list), if %clverbose=true then display(xx), if emptyp(k) then k:1 else k: k[1], @@ -258,7 +343,7 @@ parmvectintdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq, es ], directional, inner, derivative */ invectdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq, es ], - [ee, xx]:clicoeff(x,'list), + [ee, xx]:clicoeff2(x,'list), if emptyp(k) then k:1 else k: k[1], es: sublist( listofvars(x), lambda ([z], not freeof(asymbol, z))), display(es), @@ -284,6 +369,9 @@ invectdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq, es ], s ); +/* + interior, dual, vector derivative +*/ intmvectdiff(f, x, [k] ):=block ([s:0, n:1, m, es], if emptyp(k) then k:1 else k: k[1], x:expand(x), @@ -307,7 +395,7 @@ intmvectdiff(f, x, [k] ):=block ([s:0, n:1, m, es], exterior, dual, vector derivative */ extvectdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq ], - [ee, xx]:clicoeff(x, 'list), + [ee, xx]:clicoeff2(x, 'list), if emptyp(k) then k:1 else k: k[1], for p:1 thru k do ( i:1, s:0, @@ -331,6 +419,9 @@ extvectdiff(f, x, [k] ):=block ([s, n:1, m, i, ee, xx, df, qq ], s ); +/* + exterior, dual, vector derivative +*/ extvectdiff(f, x, [k] ):=block ([s:0, n:1, m, es], if emptyp(k) then k:1 else k: k[1], x:expand(x), @@ -340,11 +431,9 @@ extvectdiff(f, x, [k] ):=block ([s:0, n:1, m, es], f:s ), if %divsimp=true then ( - es: sublist( listofvars(x), lambda ([z], not freeof(asymbol, z))), "display(es)", s:trigsimp(s), - if not emptyp(es) then - s:simpfact(s, es) + s:clifact(s) ), s ); @@ -365,7 +454,7 @@ vvectdiff(f, x, [k] ):=block ([ df], df:nscalarpart(df) ), if %divsimp=true then - df:simpfact(df, %elements), + df:clifact(df), df ); @@ -378,11 +467,12 @@ vvectdiff(f, x, [k] ):=block ([ df], EL field Lagrangians */ -ciELfdiff(_F, tt, pvars):=block ([eq:0, p, pv, ee, xx, len, qq, yy:[], ss:[], zz:[], es:[], ez:[], vv, lv ], +ciELfdiff(_F, tt, pvars):=block( +[eq:0, p, pv, ee, qq, ss:[], zz:[], vv, lv ], [p, pv]:pvars, if %clverbose=true then display(p, pv), - [ee, vv]:clicoeff(pv, 'list), + [ee, vv]:clicoeff2(pv, 'list), lv: sublist( listofvars(tt), lambda ([z], freeof(asymbol, z) )), if not mapatom(vv) then vv: substinpart("[",vv, 0) @@ -401,20 +491,18 @@ ciELfdiff(_F, tt, pvars):=block ([eq:0, p, pv, ee, xx, len, qq, yy:[], ss:[], zz display(qq), qq:psubst(ss, qq), eq:parmvectdiff(_F, p)-psubst(zz, mvectdiff(qq , tt)), - es: sublist( listofvars(eq), lambda ([z], not freeof(asymbol, z))), - if not emptyp(es) then - eq:simpfact(eq, es), - eq + clifact(eq) ); alias (EuLagEq2, ciELfdiff); -/* -noether(_F, tt, pvars, aa):=block ([eq:0, p, pv, ee, xx, len, qq, yy:[], ss:[], zz:[], es:[], ez:[], vv, lv ], + +ciELfdiff1(_F, tt, pvars):=block( +[eq:0, p, pv, ee, qq, ss:[], zz:[], vv, lv, u, ei, mm, vi, tc, qd:0, ec, j:1], [p, pv]:pvars, if %clverbose=true then display(p, pv), - [ee, vv]:clicoeff(pv, 'list), + [ee, vv]:clicoeff2(pv, 'list), lv: sublist( listofvars(tt), lambda ([z], freeof(asymbol, z) )), if not mapatom(vv) then vv: substinpart("[",vv, 0) @@ -426,20 +514,72 @@ noether(_F, tt, pvars, aa):=block ([eq:0, p, pv, ee, xx, len, qq, yy:[], ss:[], push(vv[j](lv[i])=vv[j], zz) ) ) - ), + ), - qq:parmvectdiff(_F, pv), - if %clverbose=true then - display(qq), - qq:psubst(ss, qq), - eq: psubst(zz, aa. (p | qq ) ) , - eq:vectorpart(eq), - es: sublist( listofvars(eq), lambda ([z], not freeof(asymbol, z))), - if not emptyp(es) then - eq:simpfact(eq, es), - eq + eq:parmvectdiff(_F, p), + [ee, lv]:clicoeff2(tt, 'list), + ei: map(cinv, ee), + tc: dotconjugate(tt), + for u in lv do ( + vi: totdiff(p, u), + qq: ee[j] .parmvectdiff(_F, vi), + /*qd: qd + (ee[j]. vi) , + display( vi),*/ + qq:psubst(ss, qq), + mm: psubst(zz, totdiff(qq , tc @ei[j])).ei[j] , + if %clverbose=true then + display(qq, mm), + eq:-dotsimpc(expand(mm))+eq , + j:j+1 + ), + clifact(eq) ); -*/ + +compdiff( _F, vi, vj, tt):=block([df, dx], + df: _F @ vi, + dx: tt @ vj, + /*display(tt, dx, df),*/ + pardiff(df, dx) +); + +ciTEM(_F, tt, p):=block( +[ ee, ei, vi, vj, n, ne, vv ], + ee:cons(1, %elements), + ne:length(ee), + n: ndim+1, + ei: map(cinv, ee), + genmatrix( lambda([i,j], vi:totdiff(p, ei[i] @ tt), vj: totdiff(p, ei[j] @ tt), + sum( (vv:ei[a]@ vi, if vv#0 then pardiff( _F, vv )* ( ei[a] @ vj) else 0 ) , a, 1, ne ) ) , + n) +); + + +ciTEM1(_F, tt, p):=block( [ee, ei, n ], + ee:cons(1, vectors()), + n: length(ee), + ei: map(cinv, ee), + genmatrix( + lambda([i,j], vi:totdiff(p, ei[i] @ tt), vj: totdiff(p, ei[j] @ tt), + factor( parmvectdirdiff( _F, vj, vi ) ) + ) , n + ) +); + +ciTEM2(_F, tt, pvars):=block([p, pv ], + [p, pv]:pvars, + parmvectdirdiff( _F, pv, pv ) - ndim*_F +); + +notsubst(expr, xx, yy, v):=block([f1:0], + if listp(xx) and listp(yy) then + for i:1 thru length(xx) do + f1: f1 + notsubst(expr, xx[i], yy[i], v) + else ( + f1:subst(xx=yy, expr), + diff(f1, v) + ) +); + /* EL particle lagrangians */ @@ -459,7 +599,7 @@ convderiv(f, t, xx, [vs]):=block( push(ez[j]=ez[j](t), aa), push(ez[j](t)=ez[j], bb), if not emptyp(vs) then ( - rr:arraymake (vs, [ ez[j]] ), + rr:arraymake (vs, [ ez[j] ] ), push('diff(ez[j](t), t, 1)=rr, cc), push(rr=rr(t) , dd), push(rr(t)=rr , gg) @@ -475,7 +615,7 @@ convderiv(f, t, xx, [vs]):=block( f: psubst(dd, f), display( f) ), - ss:diff(f, t), + ss:pardiff(f, t), n:1, s:0, if mapatom(xx) then xx:[xx], @@ -483,6 +623,7 @@ convderiv(f, t, xx, [vs]):=block( s:s+ nabla[n]. ctotdiff(f, m), n:n+1 ), + disp(nabla), ss:ss+s, if %divsimp=true then ( ss:cliffsimpall(ss), @@ -570,7 +711,7 @@ ciEL(_F, tt, pvars, smat):=block([eq, p, pv, qq, ee, aa:[], bb:[], es:[], ez:[] */ if smat='list then eq:subst(aa, eq) - else if smat='mat then + elseif smat='mat then eq:bdecompose(eq), eq:factorby(eq, ez), eq diff --git a/maxima b/maxima new file mode 100644 index 0000000..d95f0fb --- /dev/null +++ b/maxima @@ -0,0 +1,64 @@ + + + + + + + + 00" 01 02" 03/* 04*/ + + + + + + + + ' '' ! !! # .. : :: ::= := = < > + - * / ^ + & ~ | + ( + + ) + block( + + ) + /* + + */ + and alias array arraymake args allbut block break buildq copy declare do else elseif equal error errcatch ev for go if in is lambda local new step then thru unless while return not or prefix infix postfix nofix mode_declare makelist make_array defstruct from + abs acos acosh acot acoth acsc csch activate addcol addrow adjoint airy larmclock algsys alloc allroots antid antidiff append appendfile apply apply1 apply2 applyb1 apply_nouns apropos arrayapply arrayinfo floor asec asech asin asinh askinteger asksign assoc assoc_legendre_p assoc_legendre_q assume asymp asympa at atan atan2 atanh atom atrig1 atvalue augcoefmatrix backup bashindices batch batchload batcon bern bernpoly bessel bessel_i bessel_j bessel_k bessel_y beta bezout bffac bfloatp bfpsi bfzeta bgzeta bhzeta bindtest binomial bothcoef box bug_report burn bzeta cabs canform canten carg cartan catch cbfac ceiling cf cfdisrep cfexpand cgamma gamma2 changevar charpoly chebyshev_t hebyshev_u check_overlaps chr1 chr2 christof clearscreen closefile closeps coeff coefmatrix col collapse collectterms columnvector combine comp2pui compfile compile compile_file compile_lisp_file concat conjugate cons constantp cont2part content continue contract contract copylist copymatrix cos cosh cot coth covdiff create_list csc csch curvature dblint ddt deactivate debug debugprintmode declare declare_translated declare_weight defcon define define_variable defint defmatch defrule deftaylor del delete delfile delta demo denom depends derivdegree derivlist describe desolve determinant diagmatrix diff dimension direct diskfree disolate disp dispcon dispform dispfun display disprule dispterms distrib divide divsum dotsimp dpart dscalar dummy echelon eigenvalues eigenvectors einstein ele2comp ele2polynome ele2pui elem eliminate elliptic_e elliptic_ec elliptic_eu elliptic_f elliptic_kc elliptic_pI emptyp ematrix endcons entermatrix entier erf errormsg euler evenp every example exp expand expandwrt expandwrt_factored explose express expt extract_linear_equations ezgcd equal facsum factcomb factor actorfacsum factorial factorout factorsum fassave fasttimes fast_central_elements fast_linsolve featurep fft fib fibtophi filedefaults filename_merge file_type fillarray first fix flatten floatdefunk floatnump flush flushd flushnd forget fortmx fortran freeof fullmap fullmapl fullratsimp fullratsubst funcsolve fundef funmake gamma gauss gcd gcdex gcfactor gen_laguerre gendiff genfact genmatrix get getchar gfactor gfactorsum gradef gramschmidt grind grobner_basis hach hermite hipow horner ic1 ident ieqn ift ilt imagpart indices infix innerproduct inpart inrt integerp integrate interpolate intopois intosum intsce inverse_jacobi_cd inverse_jacobi_cn inverse_jacobi_cs inverse_jacobi_dc inverse_jacobi_dn inverse_jacobi_ds inverse_jacobi_nc inverse_jacobi_nd inverse_jacobi_ns inverse_jacobi_sc inverse_jacobi_sd inverse_jacobi_sn invert isolate isqrt jacobi jacobi_cd jacobi_cn jacobi_cs jacobi_dc jacobi_dn jacobi_ds jacobi_nc jacobi_nd jacobi_ns jacobi_p jacobi_sc jacobi_sd jacobi_sn kdelta kill killcontext kostka labels laguerre laplace lambda last lc lcm ldefint ldisp ldisplay legendre_p legendre_q length let letrules letsimp lfreeof lgtreillis lhs limit linsolve lispdebugmode listarray listofvars listp list_nc_monomials load loadfile log logcontract lopow lorentz lpart lratsubst lreduce lriccicom lsum ltreillis makebox makefact makegamma makelist make_array make_transform map mapatom maplist matchdeclare matchfix matrix matrixmap matrixp mattrace max member metric min minfactorial minor mod mode_declare mode_identity mon2schur mono monomial_dimensions motion multinomial multi_elem multi_orbit multi_pui multsym multthru ncexpt ncharpoly nc_degree new_disrep newcontext newdet newton niceindices nonscalarp nostring nounify nroots nterms ntermsg ntermsrci nthroot num numberp numerval numfactor nusum nzeta oddp ode ode2 op openplot_curves operatorp optimize orbit ordergreat ordergreatp orderless orderlessp outchar outofpois pade part part2cont partfrac partition partpol pcoeff permanent permut pickapart playback plog plot2d plot2d plot2d_ps plot3d plot3d poisdiff poisexpt poisint poismap poisplus poissimp poissubst poistimes poistrim polarform polartorect polynome2ele pop potential powers powerseries pred prime primep print printpois printprops prodrac product properties props propvars pscom psdraw_curve psi pui pui2comp pui2ele pui2polynome puireduc pui_direct put push qput qq quanc8 quit qunit quotient radcan radsubstflag raiseriemann random rank rat ratcoef ratdenom ratdiff ratdisrep ratexpand ratnump rationalize ratnumer ratnump ratp ratsimp ratsubst ratvars ratweight read readonly realpart realroots rearray rectform recttopolar rem remainder remarray rembox remcon remfunction remlet remove remrule remtrace remvalue rename reset residue resolvante resolvante_alternee1 resolvante_bipartite resolvante_diedrale resolvante_klein resolvante_klein3 resolvante_produit_sym resolvante_unitaire resolvante_vierer rest restore resultant reveal reverse revert rhs riccicom riemann rinvariant risch rncombine romberg room rootscontract round row save scalarp scalefactors scanmap schur2comp sconcat scsimp scurvature sec sech setelmx setup setup_autoload set_plot_option set_up_dot_simplifications show showratvars sign signum similaritytransform sin sinh solve somrac sort spherical_bessel_j spherical_bessel_y spherical_hankel1 spherical_hankel2 spherical_harmonic splice sprint sqfr sqrt srrat sstatus status string stringout sublis sublist submatrix subst substinpart substpart subvar subvarp sum sumcontract supcontext symbolp system tan tanh taylor taylorinfo taylorp taylor_simplifier taytorat tcl_output tcontract tellrat tellsimp tellsimpafter tex th throw time timer timer_info tldefint tlimit tobreak todd_coxeter toplevel totaldisrep totient to_lisp tpartpol trace trace_options transform translate translate_file transpose treillis treinat triangularize trigexpand trigrat trigreduce trigsimp trunc truncate tr_warnings_get tsetup ttransform ultraspherical undiff uniteigenvectors unitvector unknown unorder unsum untellrat untrace vectorpotential vectorsimp verbify weyl writefile xthru del zeroequiv zeromatrix zeta zrpoly zsolve inargs inop texput unique matrix_size xreduce second list_matrix_entries outermap lmax lmin + all_dotsimp_denoms assume_pos assume_pos_pred change_filedefaults current_let_rule_package default_let_rule_package display_format_internal error_size error_syms expandwrt_denom find_root_error file_search file_string_print in_netmath integration_constant_counter isolate_wrt_times let_rule_packages linsolve_params matrix_element_add matrix_element_mult matrix_element_transpose mode_checkp mode_check_errorp mode_check_warnp plot_options solve_inconsistent_error sublis_apply_lambda taylor_logexpand taylor_order_coefficients taylor_truncate_polynomials timer_devalue tr_array_as_ref tr_bound_function_applyp tr_file_tty_messagesp tr_float_can_branch_complex tr_function_call_default tr_gen_tags tr_numer tr_optimize_max_loop tr_output_file_default tr_predicate_brain_damage tr_semicompile tr_state_vars tr_true_name_of_file_being_translated tr_version tr_warn_bad_function_calls tr_warn_fexpr tr_warn_meval tr_warn_mode tr_warn_undeclared tr_warn_undefined_variable tr_windy use_fast_arrays with_stdout xgraph_curves simp stringdisp subnumsimp + absboxchar activecontexts algebraic algepsilon algexact aliases allsym arrays askexp assumescalar assumescalarp atomgrad backsubst backtrace batchkill batcount berlefact besselexpand bftorat bftrunc bothcases boxchar breakup cauchysum cflength colour_z compgrind context contexts counter cursordisp debugmode declared demoivre dependencies derivabbrev derivsubst detout diagmetric dim direc dispflag display2d doallmxops domain domxexpt domxmxops domxnctimes dontfactor doscmxops doscmxplus dot0nscsimp dot0simp dot1simp dotassoc dotconstrules dotdistrib dotexptsimp dotident dotscrules dskall erfflag errexp errintsce errorfun errormsg evflag evfun exptdispflag expon exponentialize expop exptisolate exptsubst facexpand facsum_combine factlim factorflag filename filenum float2bf fortindent fortspaces fpprec fpprintprec functions gammalim genindex gensumnum geomview globalsolve gnuplot gradefs grid halfangles hashed ibase ieqnprint inchar inflag intfaclim infolists integrate_use_rootsof intpolabs intpolerror intpolrel keepfloat lasttime letrat lhospitallim linechar linedisp linel linenum linsolvewarn listarith listconstvars listdummyvars lmxchar loadprint logabs logarc logconcoeffp logexpand lognegint lognumer logsimp m1pbranch macroexpansion maperror maxapplydepth maxapplyheight maxnegex maxposex maxprime maxtayorder modulus multiplicities myoptions negdistrib negsumdispflag nextlayerfactor newfac niceindicespref nolabels noundisp nticks obase omega openmath opproperties opsubst optimprefix optionset packagefile parsewindow partswitch pfeformat piece plot_format poislim polar_to_xy powerdisp prederror prodhack programmode prompt ps psexpand radexpand radprodexpand ratalgdenom ratdenomdivide ratepsilon rateinstein ratfac ratmx ratprint ratrieman ratriemann ratsimpexpons ratweights ratweyl ratwtlvl realonly refcheck rmxchar rombergabs rombergit rombergmin rombergtol rootsconmode rootsepsilon run_viewer savedef savefactors scalarmatrixp setcheck setcheckbreak setval showtime simpsum solvedecomposes solveexplicit solvefactors solvenullwarn solveradcan solvetrigwarn sparse sqrtdispflag stardisp sumexpand sumhack sumsplitfact taylordepth tlimswitch transbind transcompile transform_xy transrun trigexpandplus trigexpandtimes triginverses trigsign ttyintfun ttyintnum ttyoff undeclaredwarn values vect_cross verbose view_direction zerobern zetapi zunderflow + % %i %e %gamma %phi done %pi del false inf infinity minf zeroa zerob true nil + all any bfloat eval float flonum fixnum ind unknown und nary additive alphabetic antisymmetric commutative symmetric bindtest constant scalar real imaginary complex rational irrational posfun outative noun nonscalar nonarray multiplicative mainvar linear integervalued integer noninteger increasing decreasing feature evfun evflag evenfun oddfun even odd facts + + + 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 + + + + + + + + + + + + + + + + + + + + + + + + + + + + +