{VERSION 3 0 "IBM INTEL NT" "3.0" } {USTYLETAB {CSTYLE "Maple Input" -1 0 "Courier" 0 1 255 0 0 1 0 1 0 0 1 0 0 0 0 }{PSTYLE "Normal" -1 0 1 {CSTYLE "" -1 -1 "" 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 }0 0 0 -1 -1 -1 0 0 0 0 0 0 -1 0 }} {SECT 0 {EXCHG {PARA 0 "" 0 "" {TEXT -1 531 "Additional procedures to \+ accompany Cliff5.m.\n\nThis version of the package contains revised pr ocedures which can take extra parameter or index: \n\ncliexpand(p,K); \nclimul[K](p1,p2,...,pn)\nclirev(p,K);\nmakeclialiases[K](n);\nclibas is[K](n);\ndwedge(p1,p2,...,pn);\ndwedge[K1,K2](p1,p2,...,pn);\n`&dw`( p1,p2,...,pn);\n\nProcedure 'clieval' doesn't require an extra paramet er since it converts Clifford polynomials expressed in Clifford bases \+ such as `&C`[X] for various forms X and converts to Grassmann basis.\n \nLast revised: January 4, 2002\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 8 "restart:" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1470 "Cli5plus[makeclialiases]:=proc(a1::posint,a2::\{sym bol,string\}) \n local K,L,i,k,l,makeclibasmo n,s,lname,flagindexed;\noptions `Copyright (c) 1995-2002 by Rafal Abla mowicz and Bertfried Fauser. All rights reserved.`;\nif not a1>1 then \+ ERROR(`first parameter must be a positive integer larger than one`) fi ;\nif nargs=2 and not member(a2,\{'ordered',\"ordered\"\}) then\n ER ROR(`second optional parameter, when used, must be 'ordered' or \"orde red\"`) fi;\n#######################################\nif type(op(procn ame),procedure) then\n lname:=`B`;\n flagindexed:=false:\n else \n lname:=op(procname);\n flagindexed:=true:\nfi;\n############# ##########################\nL:=[seq(op(combinat[choose]([seq(i,i=1..a1 )],k)),k=2..a1)];\nmakeclibasmon:=proc(a1) local s,i;\n \+ if nops(a1)=1 then RETURN(cat(e,op(a1))) fi:\n if nargs= 1 then \n s:=`&C`(e.(op(a1)));\n else \n s:=`&C`[args[2]](e.(op(a1)));\n fi;\n RETURN(s)\nend:\nif nargs=1 then \n K:=[seq(op(combina t[permute](l)),l=L)];\n if not flagindexed then\n s:=seq(cat(e, op(K[i]))=makeclibasmon(K[i]),i=1..nops(K))\n else\n s:=seq(cat (e,op(K[i]))=makeclibasmon(K[i],lname),i=1..nops(K))\n fi;\nelse\n \+ if not flagindexed then\n s:=seq(cat(e,op(L[i]))=makeclibasmon(L [i]),i=1..nops(L))\n else\n s:=seq(cat(e,op(L[i]))=makeclibasmo n(L[i],lname),i=1..nops(L))\n fi;\nfi;\nRETURN('alias'(s)):\nend:\n " }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1366 "Cli5plus[clibasis]:=proc(n::n onnegint,a2::\{posint,symbol,string\}) \n local lna me,k,fk,eL,L,newbasis,Lsort,l,feven,flagindexed;\noptions `Copyright ( c) 1995-2002 by Rafal Ablamowicz and Bertfried Fauser. All rights rese rved.`;\nif n=0 then RETURN([Id]) fi;\n############################### ########\nif type(op(procname),procedure) then\n lname:=`B`;\n f lagindexed:=false:\n else\n lname:=op(procname);\n flagindexed: =true:\nfi;\n#######################################\neL:=[e.(1..n)]; \nL:=map(sort,combinat[powerset](eL));\nLsort:=proc(l1::list,l2::list) if nops(l1)>nops(l2) then false else true fi end;\nL:=sort(L,Lsort); \nif nargs=2 then\n if args[2]='even' then\nfeven:=proc(l::list) if \+ type(nops(l),even) then true else false fi end;\nL:=select(feven,L);\n elif type(args[2],nonnegint) and args[2]<=args[1] then\nk:=args[2]; \nfk:=proc(l::list,k::nonnegint) if nops(l)=k then true else false fi \+ end;\nL:=select(fk,L,k)\n else ERROR(`second argument must be 'even' or a non negative integer less than or equal to the first argument`) \nfi;\nfi;\nnewbasis:=[]:\nfor l in L do\nif nops(l)=0 then newbasis:= [op(newbasis),Id] elif\n nops(l)=1 then newbasis:=[op(newbasis),op(l )] else\n if flagindexed then \n newbasis:=[op(newbasis),eval(` &C`[lname](op(l)))]\n else\n newbasis:=[op(newbasis),eval(`&C`( op(l)))]fi;\n fi; \nod;\nRETURN(newbasis);\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 2116 "Cli5plus[cliexpand]:=proc(a::\{function,clisca lar,clibasmon,climon,clipolynom\}) global B;\n \+ local ind,sol,s,eq,lname,flagindexed;\noptions `Copyright (c) 19 95-2002 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved. `;\n################################################################## ###############\n### This revised procedure can take now optional para meter of type name, symbol,#\n### matrix, or array so that it could be passed on to cmul[K]. It will return #\n### indexed cliprods like & C[K]. Without the extra parameter, default form B is #\n### used. Thus , &C[B] means the same thing as &C but is of indexed type while #\n# ## &C is not. \+ # ################# ################################################################\nif t ype(a,\{cliscalar,function\}) then RETURN(a) fi;\n#################### ###################\n#######################################\nif nargs =1 then\n lname:=`B`;\n flagindexed:=false:\nelif nargs=2 and\nt ype(args[2],\{symbol,name,array,matrix,`&*`(numeric,\{name,symbol,matr ix,array\})\}) then\n lname:=args[2];\n flagindexed:=true:\nelse ERROR(`only one or two arguments are expected`);\nfi;\n############## #########################\nif not type(a,clibasmon) then \n if not f lagindexed then \n RETURN(expand(map(procname,a)));\n else\n \+ RETURN(expand(map(cliexpand,a,lname)));\n fi; \nfi;\n########### ############################\nind:=Cliff5[extract](a,'integers'):\nif \+ member(nops(ind),\{0,1\}) then RETURN(a) fi;\nif not reorder(a)=a then \n if not flagindexed then \n RETURN(expand(map(procname,reord er(a)))) \n else\n RETURN(expand(map(cliexpand,reorder(a),lname ))) \n fi;\nfi;\ns:=op(Cliff5[extract](a,'integers'));\nif not flagi ndexed then \n eq:=`&C`(e.s)=cmul(e.(s));\nelse \n eq:=`&C`[lname] (e.s)=cmul[lname](e.(s));\nfi;\nsol:=solve(eq,a);\nif maxgrade(a)<4 th en RETURN(sol) \n else \n if not flagindexed then \n RETURN(e xpand(map(procname,sol))) \n else\n RETURN(expand(map(cliexpand ,sol,lname))) \n fi;\nfi;\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 2163 "Cli5plus[LCbig]:=proc(x::\{cliscalar,clibasmon,climon,clipolynom ,cliprod\},\n y::\{cliscalar,clibasmon,climon,cli polynom,cliprod\}) \n local a1,a2,flag,out,lname,flagi ndexed,S1,S2,f,L;global B:\noptions `Copyright (c) 1995-2002 by Rafal \+ Ablamowicz and Bertfried Fauser. All rights reserved.`;\n############# ##########################\nif nargs=2 then\n lname:=`B`;\n flag indexed:=false:\nelif nargs=3 and \ntype(args[3],\{symbol,name,array,m atrix,`&*`(numeric,\{symbol,name,array,matrix\})\}) then\n lname:=a rgs[3];\n flagindexed:=true:\nelse ERROR(`only two or three argumen ts are expected`);\nfi;\n############################################# ############################################\n### Since many different indices to `&C`[K] are allowed, we must check if the optional # \n## # parameter X, whose default value is B, is the same in all arguments. # \n################################################## #######################################\nS2:=\{lname\}:\nS1:=\{\}:\nL: =select(hastype,\{args[1],args[2]\},cliprod);\nif L<>\{\} then\n whi le L<>\{\} do\n S1:=S1 union select(type,L,cliprod);\n L:=remo ve(type,L,cliprod);\n if L<>\{\} and not evalb(map(type,L,\{`+`,`* `\})=\{true\}) then\n ERROR(`expected '+' or '*' type only in a rguments of LCbig but received`,L) \n fi;\n L:=select(hastype, map(op,L),cliprod);\n od;\n if not evalb(map(type,S1,cliprod)=\{tr ue\}) then\n ERROR(`encountered unexpected type among arguments o f LCbig`);\n fi;\n S1:=\{seq(op(0,f),f=S1)\};\n for f in S1 do\n if type(f,indexed) then S2:=S2 union \{op(f)\} else S2:=S2 unio n \{`B`\} fi;\n od;\nfi;\nif nops(S2)>1 then\n ERROR(`optional (or default B) parameter in LCbig differs from indices encountered in its cliprod arguments. Found these names as indices of &C:`,S2);\nfi;\n## ###################################\nflag:=false:\nif hastype(x,clipro d) then a1:=Cli5plus[clieval](x); flag:=true; else a1:=x fi;\nif hasty pe(y,cliprod) then a2:=Cli5plus[clieval](y); flag:=true; else a2:=y fi ;\n#####################################\nout:=Cliff5[LC](a1,a2,lname) ;\nif flag then \n RETURN(cliexpand(out,lname))\nelse\n RETURN(out) ;\nfi;\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 2142 "Cli5plus[RCbig] :=proc(x::\{cliscalar,clibasmon,climon,clipolynom,cliprod\},\n \+ y::\{cliscalar,clibasmon,climon,clipolynom,cliprod\}) \n local a1,a2,flag,out,lname,flagindexed,S1,S2,f,L;glob al B:\noptions `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfr ied Fauser. All rights reserved.`;\n################################## #####\nif nargs=2 then\n lname:=`B`;\n flagindexed:=false:\nelif nargs=3 and type(args[3],\{symbol,name,array,matrix,`&*`(numeric,\{sy mbol,name,array,matrix\})\}) then\n lname:=args[3];\n flagindexe d:=true:\nelse ERROR(`only two or three arguments are expected`);\nfi; \n#################################################################### ################\n### Since many different indices to &C are allowed, \+ we must check if the optional # \n### parameter X, whose default valu e is B, is the same in all arguments. # \n################## ##################################################################\nS2 :=\{lname\}:\nS1:=\{\}:\nL:=select(hastype,\{args[1],args[2]\},cliprod );\nif L<>\{\} then\n while L<>\{\} do\n S1:=S1 union select(typ e,L,cliprod);\n L:=remove(type,L,cliprod);\n if L<>\{\} and no t evalb(map(type,L,\{`+`,`*`\})=\{true\}) then\n ERROR(`expecte d '+' or '*' type only in arguments of RCbig but received`,L) \n f i;\n L:=select(hastype,map(op,L),cliprod);\n od;\n if not eval b(map(type,S1,cliprod)=\{true\}) then\n ERROR(`encountered unexpe cted type among arguments of RCbig`);\n fi;\n S1:=\{seq(op(0,f),f= S1)\};\n for f in S1 do\n if type(f,indexed) then S2:=S2 union \{op(f)\} else S2:=S2 union \{`B`\} fi;\n od;\nfi;\nif nops(S2)>1 t hen\n ERROR(`optional (or default B) parameter in RCbig differs from indices encountered in its cliprod arguments. Found these names as in dices of &C:`,S2);\nfi;\n#####################################\nflag:= false:\nif hastype(x,cliprod) then a1:=Cli5plus[clieval](x); flag:=tru e; else a1:=x fi;\nif hastype(y,cliprod) then a2:=Cli5plus[clieval](y) ; flag:=true; else a2:=y fi;\n#####################################\no ut:=Cliff5[RC](a1,a2,lname);\nif flag then \n RETURN(cliexpand(out,l name))\nelse\n RETURN(out);\nfi;\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 304 "Cli5plus[clieval]:=proc(a::algebraic) local p; \nopt ions `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfried Fauser . All rights reserved.`;\n##################\n### Works with `&C` and \+ with `&C`[K]\n##################\np:=eval(eval(subs(`&C`=`&c`,a)));\nR ETURN(Cliff5[displayid](expand(eval(p)))) \nend:\n" }}{PARA 0 "> " 0 " " {MPLTEXT 1 0 2097 "Cli5plus[climul]:=proc() local p,lname,flagindexe d,S1,S2,L,f,args2,args3,coB;\noptions `Copyright (c) 1995-2002 by Rafa l Ablamowicz and Bertfried Fauser. All rights reserved.`;\n########### ############################\nif type([args],listlist) then\n if eva lb(op(0,op(args))=`*`) then\n coB,args3:=op(op(args));\n lna me:=coB*op(0,args3);\n args2:=op(args3);\n flagindexed:=true :\n else\n lname:=op(0,op(args));\n args2:=op(op(args));\n flagindexed:=true:\n fi;\nelif type(op(procname),procedure) th en\n lname:=`B`;\n flagindexed:=false:\n args2:=args:\nels e\n lname:=op(procname);\n flagindexed:=true:\n args2:=args: \nfi;\n############################################################### #####################\n### Since many different indices to &C are allo wed, we must check if the optional # \n### parameter X, whose default value is B, is the same in all arguments. # \n############# ###################################################################### #\nS2:=\{lname\}:\nS1:=\{\}:\nL:=select(hastype,\{args2\},cliprod);\ni f L<>\{\} then\n while L<>\{\} do\n S1:=S1 union select(type,L,c liprod);\n L:=remove(type,L,cliprod);\n if L<>\{\} and not eva lb(map(type,L,\{`+`,`*`\})=\{true\}) then\n ERROR(`expected '+' or '*' type only in arguments of climul but received`,L) \n fi;\n L:=select(hastype,map(op,L),cliprod);\n od;\n if not evalb(ma p(type,S1,cliprod)=\{true\}) then\n ERROR(`encountered unexpected type among arguments of climul`);\n fi;\n S1:=\{seq(op(0,f),f=S1) \};\n for f in S1 do\n if type(f,indexed) then S2:=S2 union \{ op(f)\} else S2:=S2 union \{`B`\} fi;\n od;\nfi;\nif nops(S2)>1 then \n ERROR(`optional (or default B) parameter in climul differs from i ndices encountered in its cliprod arguments. Found these names as indi ces of &C:`,S2);\nfi;\n########################################\nif no t flagindexed then\n p:=map(clieval,[args2]);\n p:=cmul(op(p));\ne lse \n p:=map(clieval[lname],[args2]);\n p:=cmul[lname](op(p));\nf i;\nif not has([args2],`&C`) then RETURN(Cliff5[clisort](p)) else\n \+ p:=cliexpand(p,lname);\nfi;\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 2918 "Cli5plus[clirev]:=proc(a1) local p,lname,flagindexed,S1,S2,L,f; \noptions `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfried F auser. All rights reserved.`;\n####################################### \nif type(a1,cliscalar) then RETURN(a1) fi;\n######################### ##############\nif nargs=1 then\n lname:=`B`;\n flagindexed:=fal se:\nelif nargs=2 and\ntype(args[2],\{symbol,name,array,matrix,`&*`(nu meric,\{name,symbol,matrix,array\})\}) then\n lname:=args[2];\n \+ flagindexed:=true:\nelse ERROR(`only one or two arguments are expected `);\nfi;\n############################################################ ########################\n### Since many different indices to &C are a llowed, we must check if the optional # \n### parameter X, whose defa ult value is B, is the same in all arguments. # \n########## ###################################################################### ####\nS2:=\{lname\}:\nS1:=\{\}:\nL:=select(hastype,\{args\},cliprod); \nif L<>\{\} then\n while L<>\{\} do\n S1:=S1 union select(type, L,cliprod);\n L:=remove(type,L,cliprod);\n if L<>\{\} and not \+ evalb(map(type,L,\{`+`,`*`\})=\{true\}) then\n ERROR(`expected \+ '+' or '*' type only in arguments of clirev but received`,L) \n fi ;\n L:=select(hastype,map(op,L),cliprod);\n od;\n if not evalb (map(type,S1,cliprod)=\{true\}) then\n ERROR(`encountered unexpec ted type among arguments of clirev`);\n fi;\n S1:=\{seq(op(0,f),f= S1)\};\n for f in S1 do\n if type(f,indexed) then S2:=S2 union \{op(f)\} else S2:=S2 union \{`B`\} fi;\n od;\nfi;\nif nops(S2)>1 t hen\n ERROR(`optional (or default B) parameter in clirev differs fro m indices encountered in its cliprod arguments. Found these names as i ndices of &C:`,S2);\nfi;\n########################################\nif not has([args[1]],`&C`) then RETURN(reversion(args[1],lname)) fi;\n## ######################################\nif type(args[1],\{`+`,`*`\}) t hen RETURN(map(clirev,args[1],lname)) fi;\n########################### #############\nif not type(args[1],cliprod) then RETURN(args[1]) fi;\n ########################################\nL:=[op(args[1])];\nwhile has type(L,cliprod) do L:=map(op,L) od: #Needed for ((e1 &C e2) &C e3)\n## ######################################\n#### Checking if elements like `&C`(e1we2,e1),that is, unevaluated Clifford products\n#### of Grassm ann elements are present. That is, when mixed bases are used. Then, we \n#### apply clieval (to convert to pure Grassmann basis), then apply \+ cliexpand (to\n#### convert back to Clifford basis only) and then re-e nter clirev with the revised\n#### argument. \n####################### #################\nif not evalb( map(nops,map(extract, convert(L,set) \+ ))=\{1\}) then\n p:=cliexpand(clieval(args[1]),lname):## convert arg s[1] to Clifford basis only\n RETURN(clirev(p,lname)); \nfi;\nif lna me='B' then \n RETURN(`&C`(op([seq(L[nops(L)-i+1],i=1..nops(L))]))); \nelse \n RETURN(`&C`[lname](op([seq(L[nops(L)-i+1],i=1..nops(L))])) );\nfi;\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 652 "Cli5plus[`conve rt/wedge_to_dwedge`]:=\n proc(x::\{cliscalar,clibasmon,climon,c lipolynom\},\n lname::\{symbol,name,array,matrix,`&*`(numeric, \{name,symbol,matrix,array\})\}) \n local r1,r2;global B;\noptions ` Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfried Fauser. All \+ rights reserved.`;\nif type(lname,\{array,matrix\}) then\n r1,r2:=op (2,eval(lname)):\n if not evalb(r1=r2) then \n ERROR(`second ar gument must be a square matrix or array`)\n fi;\n if not type(lnam e,antisymmatrix) then\n ERROR(`second argument must be an antisym metric matrix or array`)\n fi; \nfi;\nRETURN(clieval(subs(`&C`=`&w`, cliexpand(x,-lname))));\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 650 "Cli5plus[`convert/dwedge_to_wedge`]:=\n proc(x::\{cliscalar,cl ibasmon,climon,clipolynom\},\n lname::\{symbol,name,array,matr ix,`&*`(numeric,\{name,symbol,matrix,array\})\}) \nlocal r1,r2;global \+ B;\noptions `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\nif type(lname,\{array,matrix\}) then \n r1,r2:=op(2,eval(args[2])):\n if not evalb(r1=r2) then \n \+ ERROR(`second argument must be a square matrix or array`)\n fi;\n \+ if not type(lname,antisymmatrix) then\n ERROR(`second argument mu st be an antisymmetric matrix or array`)\n fi;\nfi;\nRETURN(clieval( subs(`&C`=`&w`,cliexpand(x,-lname))));\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 953 "Cli5plus[dwedge]:=proc(x::\{cliscalar,clibasmon,clim on,clipolynom\},\n y::\{cliscalar,clibasmon,clim on,clipolynom\}) \n local L,MatF,MatFT,out;\noptions \+ `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\nL:=[op(procname)];\nif type(L,list(procedure)) th en\n ERROR(`index is expected of type name, symbol, or antisymmatrix , e.g., dwedge[K](p1,p2), try ?dwedge for help`)\nfi;\nif not type(L,l ist(\{matrix,array,name,symbol,`&*`(numeric,\{matrix,array,name,symbol \})\})) \nthen\nERROR(`index must be matrix, array, name, symbol, or ` &*`(numeric,\{matrix,array,name,symbol\}`)\nfi;\nif type(L,list(\{matr ix,array\})) then\n if not type(L,list(antisymmatrix)) then\n E RROR(`matrix or array used for index must be antisymmetric`)\n fi;\n fi;\nMatF:=op(L):\nMatFT:=-MatF:\nL:=map(convert,[args],wedge_to_dwedg e,-MatF);\nout:=convert(wedge(op(L)),dwedge_to_wedge,-MatFT);\nRETURN( clicollect(out));\nend: \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 2334 "Cli 5plus[`&dw`]:=proc() local coB,nameB,lname,NP,decindex,ARGS,flagdec;gl obal F:\noptions `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bert fried Fauser. All rights reserved.`;\n################################ ####################################################\n### Works when & dw[''F''] or &dw[''-F''] is entered and F is an antisymmetric matrix\n ###################################################################### ##############\nflagdec:=true:\nif type(op(procname),procedure) then\n if type([args],listlist) then\n if type(op(args),array) then\n WARNING(`enclose index in double quotes as in &dw[''F''] or & c[''-F''] when F has been assigned an antisymmetric matrix to avoid th e following:`);\n RETURN('procname(args)');\n fi;\n else c oB:=1:\n nameB:=`F`:\n lname:=`F`:\n ARGS:=[args]:\n flagdec:=false:\n fi;\nelse lname:=op(procname);\n ARGS:=[ args];\n if type(lname,`&*`(numeric,name)) then\n coB:=op( select(type,\{op(lname)\},numeric));\n nameB:=op(select(type, \{op(lname)\},name));\n else\n coB:=1:\n nameB:=ln ame:\n fi;\n flagdec:=false:\nfi;\n########################### ############\ndecindex:=proc() local ARGS,coB,nameB;global F;\nif type ([args],listlist) then\n if type(op(args),function) then\n ARGS :=op(op(args));\n coB:=1:\n nameB:=eval(op(0,op(args)));\n \+ if type(nameB,`&*`(numeric,name)) then\n coB:=op(select(ty pe,\{op(nameB)\},numeric));\n nameB:=op(select(type,\{op(nameB )\},name));\n fi;\n elif type(op(args),`&*`(numeric,function)) \+ then\n nameB:=\{op(op(args))\}:\n coB:=op(select(type,nameB, numeric));\n nameB:=op(select(type,nameB,function));\n ARGS: =op(nameB);\n nameB:=op(0,nameB);\n else\n ERROR(`unable t o determine index from or wrong index, use name in double quotes as in &dw[''F''] or &dw[''-F'']`)\n fi;\nelif\n type([args],list) then \n ARGS:=args;\n coB:=1:\n nameB:=`F`; #default name \nelse\n \+ ERROR(`cannot determine arguments and/or index from:`,args)\nfi;\nRETU RN(coB,nameB,[ARGS]);\nend:\n#####################################\nif flagdec then \n coB,nameB,ARGS:=decindex(args);\n lname:=coB*name B;\nfi;\n#RETURN(coB,nameB,lname,ARGS);\nNP:=nops(ARGS);\nif member(0, ARGS) then RETURN(0) fi;\nif NP <=1 then RETURN(op(ARGS)) fi;\nRETURN( dwedge[lname](op(ARGS)));\nend:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 621 "Cli5plus[dottedcbasis]:=proc() local lname,L;\noptions `Copyright (c) 1995-2002 by Rafal Ablamowicz and Bertfried Fauser. All rights re served.`;\n if not type(op(procname),procedure) then \n lname:= op(procname);\n else\n ERROR(`this procedure requires an index \+ of type name, symbol, matrix, array`);\n fi;\n if type(lname,\{mat rix,array\}) then\n if not type(lname, antisymmatrix) then\n \+ ERROR(`index is expected to be an antisymmetric matrix or array, o r, name or symbol`)\n fi fi;\n L:=cbasis(args); #assign standard u ndotted Grassmann basis to L\n L:=map(convert,L,wedge_to_dwedge,lnam e);\nend:\n\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 746 "Cli5plus[init]:=p roc() local x,y,i,j;\noptions `Copyright (c) 1995-2002 by Rafal Ablamo wicz and Bertfried Fauser. All rights reserved.`;\nmacro(cmul=climul); #'cmul' is now extended by 'climul' \nmacro(cmulQ=climul); \+ #'cmulQ' is now extended by 'climul'\nmacro(`&c`=climul); \+ #`&c` is now extended by 'climul'\nmacro(`&cQ`=climul); #`&cQ` is now extended by 'climul'\nmacro(reversion=clirev); #'reversion' is now extended by 'clirev'\nmacro(LC=LCbig); #'LC' is now extended by 'LCbig'\nmacro(RC=RCbig); #'RC' is now extende d by 'RCbig'\nlprint(`Warning, definitions for type/climon and type/cl ipolynom now include &C and &C[K]. Type ?cliprod for help.`);\nprotect (op(map(op,[indices(Cli5plus)])));\nend:" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}{PARA 0 "> \+ " 0 "" {MPLTEXT 1 0 260 "#save Cli5plus, `c:/maplev51/lib/Cli5plus.m`; \n#save Cli5plus, `a:/Cli5plus.m`;\n#save Cli5plus, `c:/maplev51/cliff ord/www5/Cli5plus.m`;\n#save Cli5plus, `c:/maplev51/clifford/cli5plus/ Cli5plus.m`;\n#save Cli5plus, `c:/www/htdocs/rafal/cliff5/cli5plus/Cli 5plus.m`;" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 33 "savelib('Cli5plus',\"Cli5plus.m\"):" }}{PARA 0 "" 0 " " {TEXT -1 14 "Revised 1-4-02" }}{PARA 0 "" 0 "" {TEXT -1 0 "" } {MPLTEXT 1 0 0 "" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}}} {MARK "0 13 0" 914 }{VIEWOPTS 1 1 0 1 1 1803 }