' JJJJ ?\>' L-=l>  ԠéԠˠ#~?  xDIR ERA TYPESAVEREN USERY!yO#< Ty#O 3ǯ21y_͸2y2ͽ:ķ˜1͘A͌>>͌92^ :˷¥.!_~#fow]ɭʎʥ!v"!çREAD ERRORçNO FILE^:˷#͘*~ "Ʒ"͌#>?͌͘ =_.:;<> Oƅo$>!Y2*O"ʉ@G:ʐ:wÖx2p0ʹ#*©6?ëw˜0ï#6 ¹.0#*6?w0#6 #6"  Ň!˶2:2a{_:˷ʖ:˷>Ľʖ:=2–!B!6#5ʖ:˷Ľ!ͬʧ )!F#xʺ~0wëw!" !~6ͽ:ý(!\X COPYRIGHT (C) 1979, DIGITAL RESEARCH _͌> ͒> Ò> Ò͘~#͌ì _2<į2: :):>:(y2E!|"*wɍ`JX)^>EE??++ ԩ  [\ ĭ ?  JL ``LLL $Lq<`ΧԠĠڸčԠԠ͠Ԡ؍2>o:= gw8H<8H=` }Hx / hJ Leh<> > @A @A>i =<>+ LeÍڍh@(L>*// -П( ( $8` %  ZNx`. }x$50x.$50xL JJJJ`Hjf5 }h $50x`  Ȍ` Hx  -(hL(h8֩`Lx (`H݌hHhHh݌>?F؅G(jf5(  ;  R( FGj 0x j $xxH` ( Rh RL.xxH h  !"#$%&'()*+,-./0123456789:;<=>?x&& 8 , P ; ' / \ ; & ; x)*++`FGG8`0($ p,&" cI꽌ɪVɭ&Y & &Y &   꽌ɪ\8`&&꽌ɪɖ'*&%&,E'зЮ꽌ɪФ`V0 ^ *^ *>`+*xS&x'8*3IxiU ,>J>V J>V `8'x0| &HhHh V Y V '&Y V x ꪽV ' `Hh` ! ~ 3#0 Wx x ƀ Ƃ G ~ # 3x~#B!Y~ɯ2:˷=!˾ý:˷=!˾:ý^T!~  6?#ˆ:`O> K{͘A͒>:͒͢>:͒͢xK > K > ͒x  ͢ØÆ^ BRͧ9!5‚#~Y‚#"T<ÆALL (Y/N)?^ Tʧ͘!6!~ڇ ɯw4!Y~ʆ͌†t=ʆf ^ T ɯ2o&)|+!<ͧЯ2*C!!~~#~O~G#n,-.‹! w! yG!x͢.:E<ʄ! q!pQ:E<. ʄ$.:E<ʄi6}2ExN! ~态O>G~G!~G} *C!r#r#r ^ͥ_y#x#{2>2T*CGͻ:ẅ́n>2;O ^DM;}H>"*C :ٷ:ddslO s#r:EϷ͊:==»y==»*Ww#*"͸*:G#š"͸:!پw4!iw:Z!E~=26 w ~>2!E5T*C!"C"C!w# F! w͌xѯ2͢*C ~<wʃG:٠!٦ʎì 4~ʶ¬:<ʶ$ʶïZͻЯx>2>2ͻ:!پZկ2:EϷẅ́͊Ͳ> *C ^OT *C~wD -'  -@ͦ~^*C Ox! N!Fwyxʋ>ڋ>*Cw~#+w#w+ɯ2E22i^ *C :ٷ~w~͔͔# # ::/GyO>2!q*C"͡ʔ*JҔ^:Oyʃ?|x | sӖ-|N-# S:2E!~Яw>T D^6k-äPYy 5*{zBK5:AϾ#~$=2Ek͌ ):BO!yoxg*:BO}!N#F "*#*s#r^ ~!J! J*:مo$*C~i6iw**{#zr+s{ozg**͕** Ѿ,w͜͸Ͳ!!N#F$**O!~#O: \зSЀ*C :ٷqn& ^#V>O^"*}:*)=":O:١o"*C *C!ͮ~2~2ͦ:٦2ͮ:ЯO:فw:w |g}o*ٯ# 2E>! ^#V w#P:BO|^#V#"##"##"##"!O*!O*|!6ʝ6>گ*w#w*w#w'û*ڷ! J*""!N#F*^#V*~#foyx*{_zW+*x: 2 p&x~+é7ͯ2 H! >w_: ! Ͼ5ͤNkͱ¦ͱxʊ#Nx: Ϸ! ϖ2 ͤ! 5™#wO~x½p Hy<< ڷʑ :!qMD# O͐  :ϷE B 2>: Ϸb# : Ϸy! 4 5~yy5 6yҐ^H@Oy H H: –ͬ  #H: ! Ͼ Hù H H $O͐: 2 *CN# ʽY̙̥̫̱"C{2!"E9"1Aϯ22!ty)K!G_^#V*Cΐ~؃E؜إث ,&-AGMSϛ!!ô!ô!Bdos Err On : $Bad Sector$Select$File R/O$:BA2!~6=qf^!~2>`~2˯2\!!B!~> >#0~O#Cx2͘1)ͽÂf zͧÆBAD LOADCOMf^: !˶ Â$$$ SUBÆNO SPACE^ :Ty!B*O=?_s#"^sG!~Yʸpsp2mÆÆf ͧÆFILE EXISTS _: É: :˷ʉ=2)ͽÉ T!@k!}|qs+p+q-*C ͥ!!q#p#w*:BOYG}*MD "ã:!BϾw!>2*C~=2u:B2~2wE:A*C϶w>"!""ٯ2B!"!rQQQâ~?ͦ~?rQ*"CQ-Q͜QüQrQ$Q*):B"*)*)Q;*"E:;:A2AQÓQÜQ*C}/_|/*٤W}_*"}o|g":ٷʑ*C6:ٷʑw:2E**E}DQ>2C0T"I !>"H>2J: !͢:d::d!s~B#1!P!J߇o~,foɷp:BB Apple ][ CP/M 56K Ver. 2.20B (C) 1980 Microsoft ;ۯ2>EE??++B#1!P!J߇o~,foɷp;ۯ2:޷;ۯ2e ]~6(*} *:޽ y(3:޷s:2G<2x/a2:oa":޷zޯ2{![:޷ <2:>sɯ2>!>2!;:*     1>2>2*"?ۯ2:08 !"Y"BT"->2:8Y"/:8Y"F~!xq!;`~0,~!M;!x~1.~8[q>:޷ 2y2!!{o!:=8 ~y!3w.y2Cɯ2>!w#w#wOa."y .:g"*"!~((5:# :*޽ :޼ $| 8g,"ޯ2!"_!ޅoN!޷((+! ~O#O:x >2ޯ2:޷*(*D*:wk*(:$_"~28 ?@wx( !;!܅ony 2$8!2E!y>>?22!ɯog"$2E!.B...X&*}(8.|8&"$պ`~(,qy2E[22G: 2:O*:P!O#~#'۹~y/:02?"2O: K*:*(0**:8'(*:08* *: 8(*7!w˹#~(=5:!( +_ywɷ+ͱ*:]lc_O{- OMG!~_ :( 6>83! ~èCfuÇKmVÉÎÓãݯ`iޓښ:ޓڦJޓڲZޓھjޓzޓߊ / !~ `66= !; !{g1:Q!͢گ22>2!"2!"͎>2MUSIMP COMt CONTINUECOMTRACE MUSARITH MUS !"#$%ARITH MUS&ALGEBRA ARIX'()*+,-./01EQN ALG 23ARRAY ARI(45678$BT]#####~+ngk&E ^#V#!&ͭ5!&ͭd^#V#k ü 5!&ͭX!&ͭd5 `i':$ 5:$ 4DM:$ `iN#F:$DM5:$bk#####~+ng &E ^#V#!&ͭ,^#V#͝ ü 4!&ͭO5# : !&&" &!8&"8&}|&:$:$?͍7{7!7$?Zah0:?A[?a{?ɧ"%͍().[], Z?O:$0Gyz{xy{#zͭ>>>=G+>:$514j~# j҄ʄDM#%&+~*$w#61ͳ-jb-:$Tn>2$2$á:$ڄ:$ҙͮ BK`i"%ïͦî:$ڄڄB:$ڄBͭʄ|&DMڡ:$^#V#~ڄ^#V#:$+5:$MATRIX ARR09:;<=>SIGMA ALG?@ALOG ALGBCTRGPOS ALGDEFTRGNEG ALG GHIJDIF ALGKLMINT DIF2NOPQRSTINTMORE INT:UVWXYZ[\&bk*$ͭ####s#rs#rs#r+:$DM##^#V=p+q>҄~=z+~Á:$z!&.z!&:$ڄ!&'z!&>҄„~=Ü>҄ʄz*$ÁÁ..ڄͭl.z>҄>҄„>҄zlOww# ʄ5##~#fo##~#fo~#fo##~#fo##~#fo##~#fo^#V#~#fo.##~##~#fo7:$####->?~=7+~ɯ2$N?>:$2$~=ʵ*$ 5:$ҙ _ GKt:$q ? 7 7Î>~+=´!=¼n&~+fo:$5:$:$s#r*$++++++&:  1O$!ͱ! muSIMP-80 2.02 COPYRIGHT (C) 1980 MICROSOFT LICENSED FROM THE SOFT WAREHOUSEÒ~# m~+ v}o|gɯ|g}o†!" %!$w* %&!N#F#zͳ¬.$"$"$"$͓##"$"$$++"$#6s#r#"%"%$"%"%* %!`&TAYLOR DIF]LIM DIFH^_`abcdefCLES1 ARI6ghijklmCLES2 ARI,nopqrsw:$Ҳz55'4Äz:$X:$҄4@mDM:$5z[{[!&BK:$ڙ:$5:${{{7:$5:$ҙPY™7-r--r-Ä*$6DM:$ k :$ 5͓:$ 4͓:$ `i5͓N ++~#fo!&ͭd ^#V# ü `i:$DM^#V#:$ bk#####~+ng &!$5!^#V#!&ͭN ^#V# !&T ã ~ ^#V#k  ^#V#k  կZ?҄>ʏ2$N*$v>҄«>҄>¸2$%>҄>҄>ʸ÷FNyHFy*$qO 7?93ͭ*%*%ͭ3*$*$ͭ####ͬ%N#F#:$*%ͳ+:$w#r*%*%jr*%*%!%*$!&ͩͬ##ͭy* %!9ͬͭ*%*%ͭͩßͬN#F#*%ͳ:%EBK:$W]+~ͳBK:$W]~#ͳ!<='2#V### ~\ :$7 'K <| ~n K ^#V#k - ^#V#k ~ڄK :$s '!&| ڄn | ~X :$ ^#V###~#fo{ ~X :$ ^#V#k ##~#fo͠ :$A ^#V# ^#V#N#F^q#Vp#~#fos#r~ :$r ^#Ͱ""X&!&"X&*X&'#0[͐ZCJG[CÄZ__GhX:$Þ:$͞Z 2$:$͞Z%2$j>(r5͐'ʿh:$ڞ>.e͐>)r:*P&'~-#~o-#~+Z:$#~+$"$"$"$2$D|G|G|o&)):$|2$O:$|2$O:$|2$O2$mYͮ >2$2$2$2$ʋ3ËҶ#2$ʩҝéҶʹ2$M]M]ʹ#/<2$*$*$:$*$*$:`i^#V#k T !&&&:$҄ 5!&ͭ< 5͠ !&ͭd5{ 33` T #́ ^#V#:$Ґ ^#V[ #Қ ^#V#h T ` ~#foc +u '` PY33ͻ ï +͝:$N#F#^#V`i #Ҷ V+^# ͯ û +DM͝'ʻ  _ W7N#fiaO0G:$OO2$x*$N*$q+ 6>)C*$4w#4++*$"$"0&n͍bw#%%tnͷG*(&'x˜hژ ͱ! End-Of-File Read 4:$5R"2$ͫ!})!÷4:$5͜"ʜ2$* &':$r6$l""@&!&"@&b(M{*$ wG"Al00bvʄ.eMbvP)n͐y͜ڨ>*$9G"ʢlÑÑ>2$͜0O͡"0&*$w#61"0&""w#*$"$6+"$6nZV# ^#V#N#F#~#foq#p~ 5N#F^q#Vp#~#fos#r:$ 'N#F##~#for+sq#p5N#F#~#foq#p:$Y 'N#Fq#p %DMá*$*$$$ͭڮ *$:$!$4L*$ "$L *$ "$L*$ "$L*$ "$*$DM!&cc####ͳ~"9-#+~+-"+#>"G:$xr>2$2$:$o& #z[:$> r> rr> r[!$ ʕʌ4 ʗ җ~ʗ5×6:$m*H&'±aڰ *X&'¿!f#* &'!NN'N~a [?@$*%*%:$*%!9:$R*$*$@R*$*$!$*$*$*$!&͚͚ͭY* %!9ͭ͝m*%*%ͭʉ͚}*%*%ͭ͝Ð͝#F#:$:$++#:$w#*$#*%*%*$#!$#:$w#*$!&####3##ͭ* %! :$[ v 5##~#fo :$[ Ҩ 5͓##~#fo# 5͔:$҄E :$d ##^#V[ | :$\ ڎ '&:$n ڄ5##͂ :$\ 'E '| :$n E 5͓Ͷ ~\ :$ ':$| | ~n ڄ^*@&'!$#͜>2$n-7?>2$n͜>-&c E#I7s*$ͭ4*$z͗ ######N#F#*$ɾ!͓q#p#s#r#"$~#‰"$u#t#6#6&#O>2$x*$ʷ6+q+py6+q6*$~=*$+r+s+6&+:$w+t+u"$w"$͗ *$'*$DM!&ͅ####ͳ * %DM!9ͬԌͳ*$*$|||!$>*%6*%^#V#m*$ͭ45mm͈^#V#*$ͭ*%ͭN#Fq#p#^#V#:$*%ͭu#t#####ͭ¾!9:%<T!ALL Spaces Exhausted!" * %DM!9ͬmͳ *$*$++++++~wͭ *$ͭʣDM++++++~K54`iBw"$*$ͭʞZ5*$ | } ###~ +~##~#foNv"$ +p+qW`i"$*%6*%~ͭ####~ұ5++++~54ͭ~s#~r#~#~#ì"%*%DMͅͳw++ >+ 6*$4FNxWLww# ʍ:xHWAO:$2$*$qyO 7?jw++f ʁw+ w*$5Å*$6> >>«2$7͕҄ڄ"$*$6Nw #~2$>=*$N7? +~w +6*(&(&V(&(& (&<((&R0(&[8(&@(& H(&8 P(&j X(& `(& h(&0,p(&,(& ,(&,(&,(&,(&,(&,&& ,(&4%,(&/-,:&4,8)&8,(&<,(&A,(&/R,(&Z,(&^,(&`,!!!> !+5!/" 2"ͱ! 2" !*8&'"+6x [6!#~G4#> 7"x#o|g~!\z#!"*$\!"*$\>7**$ͭʃ"~#"*$7?!.$z#.${"#!7$F6B#N6A#~6K.$>$!.$m!7$p#q#w.$#!.$z#.$*$5*$p}_|W5O*$6+"$v:$ʾO*$F}o|gl #^zW{e_zSS/wM z*$5}o|gFALSETRUEFUNCTIONSUBROUTINEECHOREADySCANREADCHARRDS)PRINTLINE0PRINTWRS DRIVERFIRST-REST&&&&&&r/&&X/&&/(&&8)&y8&&&&H&&)P&&0&&`&&1h&&p&&-x&&&&' &&&&!&&"&&)+&&.6&&4A&&$L&&qU&&]&&c&&9i&&r&&qy&&&& ~L ^#V#k ' !&:$L 5͓'  P ~ ^#V#k '8 !&:$ 5͓'P L ~ ^#V#:$ҁ ~ڔ ^#Vk s#r&Ï 5~#fo͔Í ~ ~#fo:$ ~#fo5s#r!& ~ ^#V#~ ~#fo:$ k ~#fo$5$4:$2$F*$F*$N7?+ (Jw<>+*$4)F6*$4>w+ J=͕"$"$Jxʪ*$~ʪ*$N7+ ʊ~wҐ{6*$4*$*$"$*$"$%*$"$*$"$2$ͱ! ZERO Divide Error !&͕"$"$Jx*$~=*$N{$PARSE SYSFsyz{|F{$PARSE SYSFsyz{|F{$PAO  lyl. ;$$ p*+++,-..!O$",$.$}">f#P$*,$ͭ#O$.$!O$",$.$e#ͱ! No Disk Space $*,$ͭ5#w#",$w#͓#͓#q#Œ# ʌ#[ڢ# Kړ#w#“#RDS(PARSE MUS) SAVE(PARSE);SECOND'RRESTTHIRD!RRRESTADJOIN)REPLACEF.REPLACER4CONCATEN$ASSIGNqASSOCPUTGET9MEMBERMOVDqPUTDGETDCOMPRESSEXPLODEKLENGTHREVERSEOBLISTsATOM^NAME~EMPTY~NOTORDERPORDEREDEQ=APPLYEVAL R'&'&K'&'& '&s('&^0'&~8'&~@'&H'&P'&X'&`'&h'&p'& +&6 '&M'&e'&y)'&+1'&L8'&}?'&iH'&R'&\'&e'&p'&{'&L'&'&'&' ~#fo:$ ͓ 62!""ͫ!T!*** INTERRUPT: To Continue Type: RET;ͤ!ͷ!ͱ! Executive: ESC, ALT; System: Ctrl-C? " ʤ!ͫ!>?!É!ͱ! }ͷ!~!#÷!SYS*"0"!$~/w/w:$! _ 7+ ~w6*$4͕ů2$"$"$Jx*$"$~=*$%*$Nyʾ*$~#*$G<҄ʄz*$ÁÁ..ڄͭl.z>҄>҄„>҄zlOww# ʄw:$#foͭT] ++^#V#Ebk~#foͭ `i:$5͓''~ ^#V#k <~#fo~ ^#V#:$[^#V#k 'Q 33[:$54͓'¬ 33Â` R !$5!àͻ ڭ !$5!ô~ ^#V#k ^#V#k 5͓:$4͓ECLAIM6NEWLINEMSPACESeLINELENGTHyRADIX+LOADLSAVE}SYSTEMiINTEGERGREATERLESSERPOSITIVENEGATIVEZEROLEVENMINUSPLUSDIFFERENCETIMESVDIVIDEQUOTIENTMOD<LISTR'[CONDLOOP AND8 ORj : POP PUSHbk~:&0p,)&z,)&,)&, )&,()&,0)&0,8)&,@)&,H)&.0,P)&,X)&|2,`)&,h)8,p):,x):,)&,) 8,)&,)&,)&,)&,&&-)&-)& -&& -)&-)&2$-)&2--)&H36-)&?-)&3A-7&0(80*8890*+L888$8X)&8& 8&0(8)&488*88<8&h(D8+&H8@80&&P'P80&T8X8&((\8)&*d8h8&h(p8+&0&l80&&)t8x8&*|88&&088&H)88&((,80&&):x(&(88(&88)(8)88889P(+0&&)888)`88&*88<9P(9*+8P:8x9&8&8&$9i'(Q&P(Q& 2)()#222?/2y'Q()2Q'((12.22Y)I()629',0=2?/1Q((F2i(h0+Q((S2?/f2X2a2\2Q&)A( /(Q&)Q()Q(X&Q(@&(((&(222222222Q(@&&9(2229&-022Q&0&2A( &@&9(221Q&2Y((2!'(Q&)Q()&2i')&22Z0k0h0((P)&F333h02(32)PARSEMUSRPAR)LPAR(COMMA,BELLPRTMATHMAKDEFEX1EX2LEX1 *** REDEFINED: PUTPROPEX3$ *** REDEFINED:DELIMITEREXITENDLOOPENDBLOCKENDFUNENDSUBTERMINATOR;&MATCHDELIMSYNTAXNOT FOUNDINFIXLBPRBPUSED ASPREFIXOPERATORPROPERTYWHENBL(3h4(x)p)P*`*(!>6"n͆BͲ )N6@Y/6>N!qp$$7REPLACE\(Y/N): *p~$:$*n:p6N6+ e&26nez6KҜ6͞"Ck#?­6q' bO7Bʷ6-½6>2AkG6>2Jk2GkN62BkW6>2HkU6>2Ik> QO ???7:Ak7&&0I(0/0Q'0&@)Q'0&8)&& 0I(,0&0&0&)1)&0|0609(p0b0V0@0Q((F0&(L0!(P0i(0&+a0Z0Y)P)`))k0h0(1&Q'0&P)s0w0h0Q'0&(Q((Q)(&1112109(,11h000000Y)()h))00Q((0!(((&0()(p)00000Q((0!(((0i(0&0&0()(x)&0(&0(10Q(*&3J-*&3T-*&3[-*&e- *&g-(*&i-0*&&4k-8*&m-@*&@4o-H*&q-P*&L4s-X*&Z4|-`*&-h*&4-v*~=2m=2m=2mO`i"m "m:0ڽ*yҽ*!iԶ*:1@ڽ*Խ*~!cr"m>6++++++9r;r=r?rAr+CrEr++GrIrKrMrOrQr++[r+ ++UrWrYr444!((((P09(4h049'v0A(3"4)'(&x244.4'((=484'(1'(&x2F4(((&&T41W49'P*&F34b4{4l4h4Q&(o4*x)t4&0`*&0`*44444h44*x)4&0`*&0`*4h4!*p)4&0`*&0`*&444444Q&x(9(44444Q((2Q*Q&(2((++Q&(Q&`*a*((&6650&Q'(( 3.2Q'(x(A303$33&2 3)0&+3h0&Q'0&x(9(43739':3Q'h0(Q'(((&F3z3\3R3&X3 3)(u3j3d3.2+3h0(Q((p3)h0Q'() 3h0&&F3(&F333&(3I)3)()33&33I)3!(3()()!'(&F333&/3&(3I)3)( )33&/3&(3&23I)3A(3()'(&x24.2OCKERR? @ *** SYNTAX ERROR: MATCHNOPREADLISTREADREST.IDENTITYWHENPARSEDEFINEPUTPROPER<>+-*/^PRTSPACEPRTPARENLOP1PRTLIST.ͥ-"mkMkD|-*m####:m=NN.OM1*mM1O ͭ-v-!m5+L:g!q-:mN:mO L*!q'7*q97!q'7*qa7 7 GyOxG͈7_7 ^7#F7+Ͳ7#F797#͝7_7 #ʁ7p7Ͳ7p7ѷe7 Ó7IJ7# 777 è7+IJ7 ¢7¢77ɮ»7 7(9P(7(&'7(&'77&77770*&((777(& (77&77(1i'1&1()(h)&1(1(9' 1'x)&1&0(Q((0&o1Z181U1<1Q((B1!((H1i((N1&0(&0(i1^1Y)()))&0(1r1Q((x1i'|1&1()()&1(Q((h0a01Y)()('(x)(&x2r2n2119(j2P2L2@2,1:21)222211111y'x'y'+11Q&)11()++&Q'(8)'+Q()2 ERROR NOT ENOUGH MEMORY Srr+***  Er+*** IR+***   FR+***  FI,&' ,' #Y ѯx+, 1O' ,'  > *** HIT Esc KEY +&.+&.+&.+&.+&.+&.+&.+&.+&.+&.+&.+&.+&.+&.+&.5555555i*`*((q5l5^545&5"5Y*x(((.5+&0`*9(X5444V5B5((P5J5&0`*&0`*2Q((2((+f5&0`*Y*(A(|5v5&0`*&0`*2l55555544"5((+5&0`*&0`*5445"5((5+&0`*&0`*Q((2244445a'55!((&5`*)((Q((5q&(Q(`*5i&&&/I( / &9'@&&R/D/(//(&("/&((+/9/4/0/I&(Q&(A(@/>/!&&(I/(Y'N/(q&@/(((&(^/(n/j/f/q&()(&i&(&(x/(n//f/)(&&/////(&(((//(&/(&((/&/!(((Q'//i&(///Q&(/Q'0&(/9'/&((/(I(//Y'/(&/Y'/((((m++++~:m!m|-4L?.:n!qO L)|%Q.MkD?.J1ýNYMͽNM E?.Og?<)|%Q. N EO 9.͕MkDm.̓M–.*m~~w>#-x11kMͮ.7Ü. ͎9+`M͎.9.7qM.9.#x*xdF2<P (9P(9( 99&h(90&9+& 9&(+(9&&,90&0949&&89t9D9@9&(:H9&H)L9X9P9T9&0&&((p9((8)&((`9d9&H)h9()&(&&|99&8*+9: *+98 *+99(9+&h(9(*99:(*+99(*+99899&)80*+998*+998*+999&h(9+&(9(&(9l9&\99$ SUBROUTINE TRACE# (FUNC, ARGS, FUNC#, LEX#), PRTARGS# (FUNC, ARGS), PRTRSLT# (FUNC, #APPLY (FUNC#, MKARGS# (ARGS))), ENDSUB $ FUNCTION MKARGS# (ARGS), WHEN #EMPTY (ARGS), FALSE EXIT, WHEN #ATOM (ARGS), #EVAL (ARGS) EXIT, #ADJOIN (APPLY, #APPLY) $ MOVD (PLUS, #PLUS) $ MOVD (LIST, #LIST) $ FUNCTION TRACE LEX1, LOOP WHEN #ATOM (LEX1) EXIT, TRACE1 (POP (LEX1)), ENDLOOP, ENDFUN $ FUNCTION TRACE1 (FUNC, % Local: % BODY, FUNC#), BODY: GETD (FUNC), WHENINTLINE (FUNC), ENDFUN $ FUNCTION SUBR (FUNC), WHEN INTEGER (GETD (FUNC)), #EMPTY (FSUBR (FUNC)) EXIT, ENDFUN $ FUNCTION FSUBR (FUNC), #MEMBER (FUNC, '(LIST, COND, AND, OR, LOOP, PUSH, POP)), ENDFUN $ FUNCTION UNTRACE LEX1, LOOP&9::H(+::H(+:$:@(+ :,:@(+(:4:P'+0:<:P'+8:8X'+@:&X'+H:88(:8'+L: :(&('T:X:t:(l:x(&H)d:h:&&`:p:&\::X)&|:&:&0(x:8D::8h(:+&(:((:0&&):):): ):():(:(&)::& (:((:::::H*+::H*+:9@*+:9@*+h(&':ION, 'ARG1, #LIST (TRACE#, FUNC, 'ARG1, FUNC#))) EXIT, WHEN FSUBR (FUNC), PUTD (FUNC, #LIST ('SUBROUTINE, 'ARG1, #LIST (TRACE#, FUNC, 'ARG1, FUNC#))) EXIT, WHEN #FIRST (BODY) = 'FUNCTION, PUTD (FUNC, #LIST ('FUNCTION, #SECOND #EMPTY (BODY), PRINT ("UNDEFINED FUNCTION: "), PRINTLINE (FUNC) EXIT, WHEN FUNC EQ ':, PRINTLINE ("CANNOT TRACE ':'") EXIT, FUNC#: COMPRESS (#LIST (FUNC, ##)), MOVD (FUNC, FUNC#), WHEN SUBR (FUNC), PUTD (FUNC, #LIST ('FUNCT`~# …*\\ !Fp# 5Ão|gɯ|g}o†!" %!$w* %&!N#F#zͳ¬.$"$"$"$͓##"$"$$++"$#6s#r#"%"%$"%"%* %!`t WHEN #ATOM (LEX1) EXIT, UNTRACE1 (POP (LEX1)), ENDLOOP, ENDFUN $ FUNCTION UNTRACE1 (FUNC, % Local: % FUNC#), FUNC#: COMPRESS (#LIST (FUNC, ##)), WHEN GETD (FUNC#), MOVD (FUNC#, FUNC), MOVD (FALSE, FUNC#) EXIT, ENDFUN % File TRACE.MUS (c) 10/01/80 The Soft Warehouse % MOVD (FIRST, #FIRST) $ MOVD (SECOND, #SECOND) $ MOVD (REST, #REST) $ MOVD (ADJOIN, #ADJOIN) $ MOVD (EMPTY, #EMPTY) $ MOVD (ATOM, #ATOM) $ MOVD (MEMBER, #MEMBER) $ MOVD (EVAL, #EVAL) $ MOVD ((BODY), #LIST (TRACE#, FUNC, #SECOND (BODY), FUNC#))) EXIT, WHEN #FIRST (BODY) = 'SUBROUTINE, PUTD (FUNC, #LIST ('SUBROUTINE, #SECOND (BODY), #LIST (TRACE#, FUNC, #SECOND (BODY), FUNC#))) EXIT, PRINT ("UNDEFINED FUNCTION: "), PR#EVAL (POP (ARGS)), MKARGS# (ARGS)), ENDFUN $ FUNCTION PRTARGS# (FUNC, ARGS), SPACES (INDENT), INDENT: #PLUS (INDENT, 1), PRINT (FUNC), PRINT (" ["), WHEN #EMPTY (ARGS), PRINTLINE (']) EXIT, WHEN #ATOM (ARGS), ARGS: #EVAL (AEXIT, WHEN POWER (EX1), WHEN NEGCOEF(THIRD(EX1)), SECOND(EX1)^-THIRD(EX1) EXIT, 1 EXIT, WHEN PRODUCT (EX1), MKPROD (DEN1 (REST(EX1))) EXIT, 1, ENDFUN $ FUNCTION DEN1 (LEX1), WHEN ATOM (LEX1), LEX1 EXIT, WHEN POWER (EX1:POP(LEXEX1) AND ZERO (MOD (EX1, EX2)), ENDFUN $ FUNCTION SUB (EX1, EX2, EX3), WHEN EX1 = EX2, EX3 EXIT, WHEN ATOM (EX1), EX1 EXIT, ADJOIN (SUB (POP(EX1), EX2, EX3), SUB (EX1, EX2, EX3)), ENDFUN $ FUNCTION EVSUB (EX1, EX2, EX3), EVAL (SUB ( LOOP PRTMATH (POP(LEX#), 0, 0), WHEN #EMPTY (LEX#), PRINT (RPAR) EXIT, PRINT (", "), ENDLOOP EXIT, PRINT (#EVAL (POP (ARGS))), ENDBLOCK, WHEN FALSLST (ARGS) EXIT, PRINT (", "), ENDLOOP, PRINTLINE (']), ENDFUN $LEX1), 1 EXIT, WHEN ATOM (REST(LEX1)), FIRST (LEX1) EXIT, ADJOIN ('*, LEX1), ENDFUN $ FUNCTION NUM (EX1), WHEN ATOM (EX1), EX1 EXIT, WHEN POWER (EX1), WHEN NEGCOEF (THIRD(EX1)), 1 EXIT, EX1 EXIT, WHEN PRODUCT (EX1), MKPROD (NRGS), LOOP BLOCK WHEN NOT MATHTRACE, PRINT (POP (ARGS)) EXIT, PRTMATH (POP (ARGS), 0, 0), ENDBLOCK, WHEN #ATOM (ARGS) EXIT, PRINT (", "), ENDLOOP, PRINTLINE (']) EXIT, LOOP BLOCK WHEN NOT MAECOND(EX1)), THIRD(EX1) EQ -1 EXIT, ENDFUN $ FUNCTION NUMBER (EX1), WHEN INTEGER (EX1) OR RECIP (EX1) EXIT, WHEN PRODUCT (EX1) AND ATOM (RRREST(EX1)), RECIP (THIRD(EX1)) EXIT, ENDFUN $ FUNCTION NEGCOEF (EX1), WHEN INTEGER (EX1), NEGEX1, EX2, EX3)), ENDFUN $ FUNCTION SUM (EX1), FIRST(EX1) EQ '+, ENDFUN $ FUNCTION PRODUCT (EX1), FIRST(EX1) EQ '*, ENDFUN $ FUNCTION POWER (EX1), FIRST(EX1) EQ '^, ENDFUN $ FUNCTION RECIP (EX1), WHEN POWER(EX1) AND INTEGER(S FUNCTION FALSLST (ARGS), LOOP WHEN #EMPTY (ARGS) EXIT, WHEN #ATOM (ARGS), FALSE EXIT, WHEN #EVAL (POP (ARGS)), FALSE EXIT, ENDLOOP, ENDFUN $ FUNCTION EXARG (ARGS), #MEMBER (ARGS, '(EX1, EX2, EX3, EX4, EX5)), ENDFUN $ FUNUM1 (REST(EX1))) EXIT, EX1, ENDFUN $ FUNCTION NUM1 (LEX1), WHEN ATOM (LEX1), LEX1 EXIT, WHEN POWER(EX1:POP(LEX1)) AND NEGCOEF(THIRD(EX1)), NUM1(LEX1) EXIT, ADJOIN (EX1, NUM1 (LEX1)), ENDFUN $ FUNCTION DEN (EX1), WHEN ATOM (EX1), 1 % File ARITH.MUS (c) 8/24/80 The Soft Warehouse % FUNCTION MULTIPLE (EX1, EX2), ZERO (MOD (EX1, EX2)), ENDFUN $ FUNCTION POSMULT (EX1, EX2), POSITIVE (EX1) AND ZERO (MOD (EX1, EX2)), ENDFUN $ FUNCTION NEGMULT (EX1, EX2), NEGATIVE (THTRACE, PRINT (#EVAL (POP (ARGS))) EXIT, WHEN EXARG (#FIRST (ARGS)), PRTMATH (#EVAL (POP (ARGS)), 0, 0) EXIT, WHEN LEXARG (#FIRST (ARGS)), PRINT (LPAR), LEX#: #EVAL (POP (ARGS)), WHEN #EMPTY (LEX#), PRINT (RPAR) EXIT,ATIVE (EX1) EXIT, WHEN PRODUCT (EX1), NEGATIVE (SECOND(EX1)) EXIT, ENDFUN $ FUNCTION MKSUM (LEX1), WHEN ATOM (LEX1), 0 EXIT, WHEN ATOM (REST(LEX1)), FIRST (LEX1) EXIT, ADJOIN ('+, LEX1), ENDFUN $ FUNCTION MKPROD (LEX1), WHEN ATOM (ATH (RSLT, 0, 0, TRUE), NEWLINE(), RSLT, ENDFUN $ INDENT: 0 $ MATHTRACE: TRUE $ RDS () $ CTION LEXARG (ARGS), #MEMBER (ARGS, '(LEX1, LEX2, LEX3, LEX4)), ENDFUN $ FUNCTION PRTRSLT# (FUNC, RSLT), INDENT: #PLUS (INDENT, -1), SPACES (INDENT), PRINT (FUNC), PRINT (" = "), WHEN NOT MATHTRACE, PRINTLINE (RSLT) EXIT, PRTM1)) AND NEGCOEF (THIRD(EX1)), ADJOIN (SECOND(EX1)^-THIRD(EX1), DEN1(LEX1)) EXIT, DEN1 (LEX1), ENDFUN $ FUNCTION < (EX1, EX2), WHEN INTEGER(EX1) AND INTEGER(EX2), LESSER (EX1, EX2) EXIT, WHEN NUMBER (EX1) AND NUMBER (EX2), LESSER LY (GET('+,FIRST(EX2)), ADJOIN(EX1,ARGLIST(EX2))), ENDFUN $ FUNCTION INJECTERM (LEX1), % Fluid vars from MERGETERM: EX1, EX2=CODIV(EX1), EX3 % WHEN ATOM (LEX1), LIST (EX1) EXIT, EX3: CODIV (FIRST(LEX1)), WHEN EX2 = EX3, EX1: ADDTERMS ( ENDFUN $ FUNCTION ARGLIST (EX1), WHEN PRODUCT (EX1) OR SUM (EX1), LIST (REST(EX1)) EXIT, REST (EX1), ENDFUN $ FUNCTION MKRAT (EX1, EX2), WHEN EX1 EQ 1, LIST ('^, EX2, -1) EXIT, LIST ('*, EX1, LIST ('^, EX2, -1)), ENDFUN $ FUNCTI, EX1 EXIT, -EX1 EXIT, SIMPU ('ABS, EX1), ENDFUN $ FUNCTION GCD (EX1, EX2, % Local: % EX3), WHEN INTEGER (EX1) AND INTEGER (EX2), LOOP WHEN ZERO (EX2), WHEN POSITIVE (EX1), EX1 EXIT, MINUS (EX1) EXIT, X2), WHEN ZERO (EX2), EX1 EXIT, WHEN NUMBER (EX1), MKRAT (PLUS(NUM(EX1),TIMES(EX2,DEN(EX1))), DEN(EX1)) EXIT, APPLY (GET('+,FIRST(EX1)), ADJOIN(EX2,ARGLIST(EX1))) EXIT, APPLY (GET('+,FIRST(EX1)), ADJOIN(EX2,ARGLIST(EX1))) EXIT, IT, 1 EXIT, WHEN RECIP (EX1), EX1 EXIT, 1, ENDFUN $ FUNCTION BASE (EX1), WHEN POWER (EX1), WHEN RECIP (EX1), EX1 EXIT, SECOND (EX1) EXIT, EX1, ENDFUN $ FUNCTION EXPON (EX1), WHEN POWER (EX1), WHEN RECIP (EX1), 1(NUM(EX1)*DEN(EX2), NUM(EX2)*DEN(EX1)) EXIT, ENDFUN $ FUNCTION > (EX1, EX2), EX2 < EX1, ENDFUN $ FUNCTION MIN (EX1, EX2), WHEN EX1 = EX2, EX1 EXIT, WHEN NUMBER (EX1) AND NUMBER (EX2), WHEN EX1 < EX2, EX1 EXIT, EX2 EXIT, LIST, ENDFUN $ FUNCTION ADDTERMS (EX1, EX2), WHEN ATOM (EX1), WHEN INTEGER (EX1), WHEN PLUS (EX1, EX2) EXIT, WHEN ZERO (EX1), EX2 EXIT, WHEN ATOM (EX2), FALSE EXIT, WHEN NUMBER (EX2), MKRAT (PLUS(NUM(EX2),TIMES(EX1,DENON RATSUM (EX1, EX2, EX3), WHEN EX3 EQ 1, MKRAT (EX1, EX2) EXIT, EX1: QUOTIENT (EX1, EX3), EX2: QUOTIENT (EX2, EX3), EX3: GCD (EX1, EX3), EX2: QUOTIENT (EX2, EX3), WHEN EX2 EQ 1, QUOTIENT (EX1, EX3) EXIT, MKRAT (QUOTIENT(EX1,EX3), EX2) EX3: EX2, EX2: MOD (EX1, EX2), EX1: EX3, ENDLOOP EXIT, LIST ('GCD, EX1, EX2), ENDFUN $ FUNCTION LCM (EX1, EX2), ABS (EX2*(EX1/GCD(EX1,EX2))), ENDFUN $ FUNCTION CODIV (EX1), WHEN INTEGER (EX1), 1 EXIT, WHEN PRODUC WHEN NUMBER (EX1) AND NUMBER (EX2), RATSUM ( PLUS (TIMES(NUM(EX1),DEN(EX2)), TIMES(NUM(EX2),DEN(EX1))), TIMES (EX1:DEN(EX1), EX2:DEN(EX2)), GCD (EX1, EX2) ) EXIT, WHEN APPLY (GET('+,FIRST(EX1)), ADJOIN(EX2,ARGLIST(EX1))) EXIT, APP EXIT, THIRD (EX1) EXIT, 1, ENDFUN $ FUNCTION DENOM (EX1), POWER (EX1) AND NEGCOEF (THIRD(EX1)), ENDFUN $ FUNCTION ARGEX (EX1), WHEN ATOM (RRREST (EX1)), REST (EX1) EXIT, LIST (SECOND (EX1), ADJOIN (FIRST(EX1), RREST(EX1))), ('MIN, EX1, EX2), ENDFUN $ FUNCTION SIMPU (LOP1, EX1), WHEN NAME (EX1), LIST (LOP1, EX1) EXIT, WHEN APPLY (GET (LOP1, FIRST(EX1)), ARGEX (EX1)) EXIT, LIST (LOP1, EX1), ENDFUN $ FUNCTION ABS (EX1), WHEN NUMBER (EX1), WHEN 0 < EX1(EX2))), DEN(EX2)) EXIT, APPLY (GET('+,FIRST(EX2)), ADJOIN(EX1,ARGLIST(EX2))) EXIT, WHEN ATOM (EX2), WHEN ZERO (EX2), EX1 EXIT EXIT, APPLY (GET('+,FIRST(EX2)), ADJOIN(EX1,ARGLIST(EX2))) EXIT, WHEN ATOM (EX2), WHEN INTEGER (EFUNCTION COEFF (EX1), WHEN INTEGER (EX1), EX1 EXIT, WHEN PRODUCT (EX1), WHEN INTEGER (SECOND(EX1)), WHEN RECIP (THIRD(EX1)), LIST ('*, SECOND(EX1), THIRD(EX1)) EXIT, SECOND (EX1) EXIT, WHEN RECIP (SECOND(EX1)), SECOND (EX1) EXT (EX1), WHEN INTEGER (SECOND(EX1)), WHEN RECIP (THIRD(EX1)), MKPROD (RRREST(EX1)) EXIT, MKPROD (RREST(EX1)) EXIT, WHEN RECIP (SECOND(EX1)), MKPROD (RREST(EX1)) EXIT, EX1 EXIT, WHEN RECIP (EX1), 1 EXIT, EX1, ENDFUN $ COEFF(EX1), COEFF(POP(LEX1))), WHEN ZERO (EX1), LEX1 EXIT, ADJOIN (EX1*EX2, LEX1) EXIT, WHEN ORDERED (EX2, EX3), ADJOIN (EX1, LEX1) EXIT, ADJOIN (POP(LEX1), INJECTERM (LEX1)), ENDFUN $ FUNCTION MERGETERM (EX1, LEX1, % Local: % Nary product function. % PRODLEX (LEX1), ENDFUN $ FUNCTION ? (EX1), PRINT (" *** WARNING: "), PRTMATH (EX1, 0, 0, TRUE), NEWLINE (), LIST ('?, EX1), ENDFUN $ FUNCTION / (EX1, EX2), WHEN ZERO (EX2), ?(LIST('/, EX1, EX2)) EX(EX1), WHEN INTEGER (EX3:FIRST(LEX1)), ADJOIN (EX3, ADJOIN (EX1, REST(LEX1))) EXIT, ADJOIN (EX1, LEX1) EXIT, LEX3: FALSE, % of EX1 in LEX1 found, insert EX1 % EX2: BASE (EX1), LOOP % in LEX1 in the proper order. % WHEX2), LEX1 EXIT, ENDLOOP EXIT, MERGETERM (EX1, LEX1), ENDFUN $ FUNCTION SUMLEX (LEX1, % Local: % LEX2), LOOP LEX2: MERGESUM (POP(LEX1), LEX2), WHEN ATOM (LEX1), % When the end of LEX1 is reached, % MKSUM (LEX2) EXIT, %EX1), WHEN PRODUCT (EX1), REST (EX1) EXIT, LIST (EX1) EXIT, WHEN PRODUCT (EX1), LEX2: REST (EX1), LOOP LEX1: MERGEFACT (POP(LEX2), LEX1), WHEN ATOM (LEX2), LEX1 EXIT, ENDLOOP EXIT, MERGEFACT (EX1, LEX1), ENDFUN EQ 1, EX1 EXIT, APPLY (GET('*,FIRST(EX1)), ADJOIN(EX2,ARGLIST(EX1))) EXIT, APPLY (GET('*,FIRST(EX1)), ADJOIN(EX2,ARGLIST(EX1))) EXIT, WHEN APPLY (GET('*,FIRST(EX1)), ADJOIN(EX2,ARGLIST(EX1))) EXIT, APPLY (GET('*,FIRST(EX2)), ADJOIN(EX1,AEX2, EX3, LEX2, LEX3), LEX2: LEX1, LOOP WHEN ATOM (LEX2), EX2: CODIV (EX1), INJECTERM (LEX1) EXIT, WHEN EX3: ADDTERMS (EX1, EX2:POP(LEX2)), MERGESUM (EX3, REVERSE(LEX3,LEX2)) EXIT, PUSH (EX2, LEX3), ENDLOOP, ENXIT, WHEN ORDERED (EX4, EX3), REVERSE (LEX3, ADJOIN(EX1, LEX1)) EXIT, REVERSE (LEX3, ADJOIN (POP(LEX1), ADJOIN(EX1,LEX1))) EXIT, WHEN ORDERED (EX2, EX4) AND NOT RECIP (EX3), REVERSE (LEX3, ADJOIN (EX1, LEX1)) EXIT, PUSH (EX3, LEX3)EN ATOM(LEX1), REVERSE (LEX3, LIST(EX1)) EXIT, WHEN EX2 = (EX4: BASE(EX3:FIRST(LEX1))), EX3: EXPON (EX3), WHEN NUMBER (EX4:EXPON(EX1)) AND NUMBER (EX3), EX1: EX2 ^ ADDTERMS (EX4, EX3), MERGEPROD (EX1, REVERSE (LEX3, REST(LEX1))) E make a sum of LEX2 and return. % ENDLOOP, ENDFUN $ FUNCTION + LEX1, % Nary plus function % SUMLEX (LEX1), ENDFUN $ FUNCTION - (EX1, % Optional: % EX2), WHEN EMPTY (EX2), -1*EX1 EXIT, EX1 + -EX2, ENDFUN $ FUNCTION MUL $ FUNCTION PRODLEX (LEX1, LEX2), LOOP LEX2: MERGEPROD (POP(LEX1), LEX2), WHEN ATOM (LEX1), % When the end of LEX1 is reached, % MKPROD (LEX2) EXIT, % make a product of LEX2 and return.% ENDLOOP, ENDFUN $ FUNCTION * LEX1, %RGLIST(EX2))), ENDFUN $ FUNCTION MERGEFACT (EX1, LEX1, % Local: % EX2, EX3, EX4, LEX2, LEX3), LEX2: LEX1, LOOP WHEN ATOM (LEX2), % If no common BASE or combination % WHEN INTEGER(EX1), ADJOIN(EX1,LEX1) EXIT, WHEN RECIP DFUN $ FUNCTION MERGESUM (EX1, LEX1, % Local: % LEX2), WHEN ATOM (LEX1), WHEN SUM (EX1), REST (EX1) EXIT, LIST (EX1) EXIT, WHEN SUM (EX1), LEX2: REST (EX1), LOOP LEX1: MERGETERM (POP(LEX2), LEX1), WHEN ATOM (L, LEX1: REST (LEX1), ENDLOOP EXIT, WHEN EX3: MULTFACTS (EX1, EX2:POP(LEX2)), MERGEPROD (EX3, REVERSE(LEX3,LEX2)) EXIT, PUSH (EX2, LEX3), ENDLOOP, ENDFUN $ FUNCTION MERGEPROD (EX1, LEX1, % Local: % LEX2), WHEN ATOM (L)) EXIT, WHEN ATOM (EX2), WHEN ZERO (EX2), 0 EXIT, WHEN EX2 EQ 1, EX1 EXIT EXIT, APPLY (GET('*,FIRST(EX2)), ADJOIN(EX1,ARGLIST(EX2))) EXIT, WHEN ATOM (EX2), WHEN INTEGER (EX2), WHEN ZERO (EX2), 0 EXIT, WHEN EX2TFACTS (EX1, EX2), WHEN ATOM (EX1), WHEN INTEGER (EX1), WHEN TIMES (EX1, EX2) EXIT, WHEN ZERO (EX1), 0 EXIT, WHEN EX1 EQ 1, EX2 EXIT, WHEN ATOM (EX2), FALSE EXIT, APPLY (GET('*,FIRST(EX2)), ADJOIN(EX1,ARGLIST(EX2)IT, EX1 * EX2^-1, ENDFUN $ FUNCTION SQUARE (EX1), EX1*EX1, ENDFUN $ FUNCTION EXPT (EX1, EX2, % Local: % EX3), EX3: 1, LOOP BLOCK WHEN REST(EX2:DIVIDE(EX2,2)) EQ 1, EX3: EX1*EX3 EXIT, ENDBLOCK, WHEN ZERO (EX (RPAR), TRUE EXIT, FALSE EXIT, PRTMATH (LIST ('/, MKPROD(REVERSE(LEX2)), MKPROD(REVERSE(LEX3))), RBP, LBP, PRTSPACE), TRUE, ENDFUN $ PROPERTY PRTMATH, ^, FUNCTION (LEX1, % Local: % EX1, EX2), EX1: FIRST (LEX1), WHEN 3), WHEN EX3 EQ -1, WHEN INTEGER (EX2), WHEN INTEGER (EX1), EX3: GCD (EX1, EX2), WHEN EX3 EQ 1, FALSE EXIT, EX1: QUOTIENT (EX1, EX3), EX2: QUOTIENT (EX2, EX3), WHEN EX2 EQ 1, EX1 EXIT, EX2: LIST ('^, EX2, -1), WHEN EX1 EQ 1, EXWHEN NEGATIVE (EX1), -((-EX1)^-1) EXIT, WHEN EX1 EQ 1, EX1 EXIT, LIST ('^, EX1, -1) EXIT, EXPT (EX1, EX2) EXIT, WHEN EX2 EQ 1, EX1 EXIT, WHEN ZERO (EX2) AND ZEROEXPT, 1 EXIT, WHEN EX1 EQ #I, EX2: MOD (EX2, 4), ST (LEX2:REVERSE(LEX2)), LEX1: REST (LEX2), WHEN EX1 EQ -1, PRTPAREN (LPAR), PRINT ('-), EX1: POP (LEX1), PRTSPACE (), WHEN ATOM (LEX1), PRTMATH (EX1, 130, 0), PRTPAREN (RPAR), TRUE EXIT, PRTMATH (ELT(LOGEXPD,7) AND NOT(EX1=LOGBAS OR NUMBER(EX2) OR EX1<0), LOGBAS ^ (EX2*LOG(EX1,LOGBAS)) EXIT, LIST ('^, EX1, EX2) EXIT, WHEN APPLY (GET('BASE,FIRST(EX1)), ADJOIN(EX2,ARGEX(EX1))) EXIT, WHEN POSMULT(LOGEXPD,7) AND NOT(EX1=LOGBAS OR NU2:FIRST(EX2)), EX3 EXIT, EX1: SQUARE(EX1), ENDLOOP, ENDFUN $ ZEROBASE: FALSE $ ZEROEXPT: TRUE $ TRGEXPD: 0 $ LOGEXPD: 0 $ LOGBAS: #E $ FLAGS: '(TRGEXPD LOGEXPD LOGBAS ZEROBASE ZEROEXPT) $ FUNCTION ^ (EX1, EX2), WHEN IN EX2^(EX1*EX3) EXIT, ENDFUN $ PROPERTY BASE, *, FUNCTION (EX1, EX2, EX3), EX2^EX1 * EX3^EX1, ENDFUN $ PROPERTY PRTMATH, *, FUNCTION (LEX1, % Local: % EX1, LEX2, LEX3), LOOP BLOCK WHEN DENOM (EX1:POP(LEX1)), BLOCK 2 EXIT, LIST ('*, EX1, EX2) EXIT, WHEN RECIP(EX1), LIST ('^, TIMES(EX2,SECOND(EX1)), -1) EXIT, EXIT EXIT, ENDFUN $ PBRCH: TRUE $ PUSH ('PBRCH, FLAGS) $ PROPERTY BASE, ^, FUNCTION (EX1, EX2, EX3), WHEN INTEGER (EX1) OR PBRCH, WHEN EX2 EQ 2, -1 EXIT, WHEN EX2 EQ 3, -#I EXIT, EX1^EX2 EXIT, WHEN ATOM (EX1), LIST ('^, EX1, EX2) EXIT, WHEN APPLY (GET('BASE,FIRST(EX1)), ADJOIN(EX2,ARGEX(EX1))) EXIT, LIST ('^, EX1, EX2) EXIT, WHEN ATOM (EX1), WHENX1, 130, GET ('LBP, LOP1)), LOOP EX1: POP(LEX1), PRTSPACE (), PRINT (LOP1), PRTSPACE (), WHEN ATOM (LEX1) EXIT, PRTMATH (EX1, GET ('RBP, LOP1), GET ('LBP, LOP1)), ENDLOOP, PRTMATH (EX1, GET ('RBP, LOP1), 0), PRTPARENMBER(EX2) OR EX1<0), LOGBAS ^ (EX2*LOG(EX1,LOGBAS)) EXIT, WHEN ATOM(EX2), LIST ('^, EX1, EX2) EXIT, WHEN APPLY (GET('EXPON,FIRST(EX2)), ADJOIN(EX1,ARGEX(EX2))) EXIT, LIST ('^, EX1, EX2), ENDFUN $ PROPERTY *, ^, FUNCTION (EX1, EX2, EXTEGER (EX2), WHEN INTEGER (EX1), WHEN EX1 EQ 1, 1 EXIT, WHEN ZERO(EX1) AND ZERO(EX2), ?(LIST('^, EX1, EX2)) EXIT, WHEN NEGATIVE (EX2), WHEN ZERO (EX1), ?(LIST('^, EX1, EX2)) EXIT, EX1: EXPT (EX1, -EX2), WHEN THIRD(EX1) EQ -1, EX1: SECOND(EX1) EXIT, EX1: LIST ('^, SECOND(EX1), -THIRD(EX1)), ENDBLOCK, PUSH (EX1, LEX3) EXIT, PUSH (EX1, LEX2), ENDBLOCK, WHEN ATOM (LEX1) EXIT, ENDLOOP, WHEN ATOM (LEX3), EX1: FIR COS(1) + #I*SIN(1) EXIT, WHEN POSMULT(LOGEXPD,7) AND NOT(EX1=LOGBAS OR EX1<0), LOGBAS ^ (EX2*LOG(EX1,LOGBAS)) EXIT, LIST ('^, EX1, EX2) EXIT, WHEN APPLY (GET('EXPON,FIRST(EX2)), ADJOIN(EX1,ARGEX(EX2))) EXIT, WHEN POSMU EX1 EQ 1, 1 EXIT, WHEN ZERO (EX1), WHEN EX2 < 0, ? (LIST('^, EX1, EX2)) EXIT, WHEN EX2 > 0 OR ZEROBASE, 0, EXIT, LIST ('^, EX1, EX2) EXIT, WHEN ATOM (EX2), WHEN EX1 EQ #E AND EX2 EQ #I AND NEGMULT(TRGEXPD,7), NEGCOEF (EX2:SECOND(LEX1)), WHEN EX2 EQ -1, PRTMATH (LIST ('/, 1, EX1), RBP, LBP, PRTSPACE) EXIT, PRTMATH (LIST ('/, 1, LIST('^,EX1,-EX2)), RBP, LBP, PRTSPACE) EXIT, ENDFUN $ %************* optional fractional-power package **OP LEX2: MERGESUM (EX1*POP(LEX3), LEX2), WHEN ATOM (LEX3) EXIT, ENDLOOP, ENDLOOP EXIT, EX1*EX1, ENDFUN $ NUMNUM: 6 $ PUSH ('NUMNUM, FLAGS) $ FUNCTION NUMNUM (EX1), WHEN INTEGER (EX1), MULTIPLE (NUMNUM, 2) EXIT, ** optional factorial package********************% FUNCTION ! (EX1, % Local: % EX2), WHEN ZERO (EX1) OR POSITIVE (EX1), EX2: 1, LOOP WHEN ZERO(EX1), EX2 EXIT, EX2: TIMES (EX1, EX2), EX1: DIFFERENCE (EX1, 1), X6+EX7*LEX1*EX5,EX3*EX5)) < LEX1) EXIT, LEX1: EX5 ENDLOOP, WHEN LEX1^EX3 EQ EX6, EX4: EX4*LEX1, EX6: 1 EXIT, EX6: 1 EXIT, ENDBLOCK, WHEN EX6 EQ 1, EX1: EX1/(EX4^EX3), EX4: EX4^EX2, WHEN EX1 E PRINT ('-), EX1: -EX1 EXIT, PRINT (LOP1), ENDBLOCK, PRTSPACE (), WHEN ATOM (LEX1) EXIT, PRTMATH (EX1, GET ('RBP, LOP1), GET ('LBP, LOP1)), ENDLOOP, PRTMATH (EX1, GET ('RBP, LOP1), 0), PRTPAREN (RPAR), ,PRIMES,1,0,-EX1) EXIT, (-1)^EX2 * ROOT(-EX1, EX2, EX3, PRIMES, 1, 0, -EX1) EXIT EXIT EXIT, ENDFUN $ PROPERTY EXPON, ^, FUNCTION (EX1, EX2, EX3), WHEN INTEGER(EX1), WHEN INTEGER(EX2), WHEN PBRCH AND EX3 EQ -1, ****************% PRIMES: '(2, 3, 5) $ FUNCTION ROOT (EX1, EX2, EX3, LEX1, EX4, EX5, EX6, % Local: % EX7), LOOP BLOCK WHEN ZERO (REST (EX7: DIVIDE(EX6,FIRST(LEX1)))), EX6: FIRST(EX7), WHEN (EX5:EX5+1) EQ EX3, E ENDLOOP EXIT, SIMPU ('!, EX1), ENDFUN $ PROPERTY LBP, !, 160 $ STOP $ RDS () $ :::::::::::::::::::::::::::::::Q 1, EX4 EXIT, EX4 * LIST ('^, EX1, EX2/EX3) EXIT ENDLOOP, ENDFUN $ FUNCTION FREE (EX1, EX2), WHEN EX1 = EX2, FALSE EXIT, WHEN ATOM(EX1) EXIT, LOOP WHEN NOT FREE(POP(EX1),EX2), FALSE EXIT, WHEN ATOM(EX1), EXIT ENDLOO ENDFUN $ FUNCTION SQUARE (EX1, % Local: % LEX1, LEX2, LEX3), WHEN SUM (EX1), LEX1: REVERSE (REST(EX1)), LOOP LEX2: MERGESUM ((EX1:POP(LEX1))^2, LEX2), WHEN ATOM (LEX3:LEX1), MKSUM (LEX2) EXIT, EX1: 2*EX1, LOWHEN EX1 > 0, ROOT (EX1, 1, EX2, PRIMES, 1, 0, EX1) EXIT, WHEN ZERO(MOD(EX2,2)), #I^(2/EX2) * ROOT(-EX1, 1, EX2, PRIMES, 1, 0, -EX1) EXIT, -ROOT(-EX1, 1, EX2, PRIMES, 1, 0, -EX1) EXIT EXIT EXIT, ENDFUN $ %****************X4: EX4*FIRST(LEX1), EX5: 0, EXIT EXIT, EX5: 0, WHEN NOT (POP(LEX1) < FIRST(EX7)), EX6: 1 EXIT, WHEN ATOM(LEX1), EX7: EX3 - 1, LEX1: EX6, LOOP EX5: LEX1^EX7, WHEN NOT ((EX5:QUOTIENT(E% File ALGEBRA.ARI (c) 09/16/80 The Soft Warehouse % PROPERTY PRTMATH, +, FUNCTION (LEX1, % Local: % EX1), PRTPAREN (LPAR), PRTMATH (POP(LEX1), 0, GET ('LBP, LOP1)), LOOP PRTSPACE (), BLOCK WHEN NEGCOEF (EX1:POP(LEX1)),T EXIT EXIT, WHEN INTEGER(EX1), WHEN PBRCH AND INTEGER(EX2), WHEN INTEGER(EX3:1/EX3), WHEN EX1 > 0, ROOT(EX1, EX2, EX3, PRIMES, 1, 0, EX1) EXIT, WHEN ZERO(MOD(EX3,2)), #I^(2*EX2/EX3)*ROOT(-EX1,EX2,EX3P, ENDFUN $ PION2: #PI/2 $ PROPERTY EXPON, *, FUNCTION (EX1, EX2, EX3), WHEN EX1 EQ #E, WHEN INTEGER(EX2: EX2*EX3/PION2/#I), #I^EX2 EXIT, WHEN NEGMULT(TRGEXPD,7), WHEN FREE (EX2: EX2*PION2, #I), COS(EX2) + #I*SIN(EX2) EXI WHEN SUM (EX1), MULTIPLE (NUMNUM, 5) EXIT, MULTIPLE (NUMNUM, 3), ENDFUN $ DENNUM: 6 $ PUSH ('DENNUM, FLAGS) $ FUNCTION DENNUM (EX1), WHEN INTEGER (EX1), MULTIPLE (DENNUM, 2) EXIT, WHEN SUM (EX1), MULTIPLE (DENNUM, 5) EXIT, MULTIPLE (TY BASE, *, FUNCTION (EX1, EX2, EX3), WHEN POSITIVE (EXPBAS) AND EXPBAS (EX1), EX2^EX1 * EX3^EX1 EXIT, ENDFUN $ BASEXP: -30 $ PUSH ('BASEXP, FLAGS) $ FUNCTION BASEXP (EX1), WHEN NUMBER (EX1), MULTIPLE (BASEXP, 2) EXIT, WHEN PRODUC WHEN EX1 EQ 1, EX2 EXIT, LIST ('*, EX1, EX2) EXIT, WHEN RECIP (EX1), LIST ('^, TIMES (EX2, SECOND(EX1)), -1) EXIT EXIT, WHEN SUM (EX2), WHEN POSITIVE (DENDEN) OR POSITIVE (NUMDEN), EX2: REST (EX2), WHEN PRODUCT (EX PUSH (EX1, LEX2) EXIT, PUSH (EX1, LEX3) EXIT, WHEN POSITIVE (NUMNUM) AND NUMNUM (EX1), PUSH (EX1, LEX2) EXIT, PUSH (EX1, LEX3), ENDBLOCK, WHEN ATOM (LEX1) EXIT, ENDLOOP, EN) AND DENDEN (EX3), LIST ('^, MKSUM (DISTRIB (EX3, EX2, DENDEN, NUMDEN)), -1) EXIT, EXIT, WHEN POSITIVE (NUMDEN) AND NUMDEN (EX1), LIST ('^, MKSUM ( DISTRIB (EX1^-1, EX2, DENDEN, NUMDEN)), -1) EXIUN $ PROPERTY *, ^, FUNCTION (EX1, EX2, EX3, % Local: % LEX1, LEX2, LEX3), WHEN NEGATIVE(BASEXP) AND BASEXP(EX2) AND BASE(EX1) = EX2, EX2 ^ (EXPON(EX1) + EX3) EXIT, WHEN NEGATIVE(EXPBAS) AND EXPBAS(EX3) AND EXPON(EX1) = EX3, (BASE(EXDENNUM, 3), ENDFUN $ FUNCTION DISTRIB (EX1, LEX1, % Local: % NUMNUM, DENNUM, LEX2), LOOP LEX2: MERGESUM (EX1*POP(LEX1), LEX2), WHEN ATOM (LEX1), LEX2 EXIT, ENDLOOP, ENDFUN $ PROPERTY *, +, FUNCTION (EX1, LEX4, % Local: % LEXLEX2) EXIT, LEX3: ADJOIN (EX1, LEX3) EXIT, WHEN POSITIVE (NUMDEN) AND NUMDEN (EX1), LEX2: ADJOIN (EX1^-1, LEX2) EXIT, LEX3: ADJOIN (EX1, LEX3), ENDBLOCK, WHEN ATOM (L1), LEX1: REST (EX1), LOOP EX1: POP(LEX1), BLOCK WHEN DENOM (EX1), EX3: EX1^-1, WHEN POSITIVE (DENDEN) AND DENDEN (EX3), LEX2: ADJOIN (EX3, MERGEFACT (MKSUM (DISTRIB (MKPROD (REVERSE(LEX2)), LEX4, NUMNUM, DENNUM)), REVERSE (LEX3)) EXIT, WHEN DENOM (EX1), WHEN POSITIVE (DENNUM) AND DENNUM (EX1^-1), MKSUM (DISTRIB (EX1, LEX4, NUMNUM, DENNUM)) EXIT, EXIT, T, EXIT, EXIT, EXIT, ENDFUN $ EXPBAS: 30 $ PUSH ('EXPBAS, FLAGS) $ FUNCTION EXPBAS (EX1), WHEN NUMBER (EX1), MULTIPLE (EXPBAS, 2) EXIT, WHEN SUM (EX1), MULTIPLE (EXPBAS, 5) EXIT, MULTIPLE (EXPBAS, 3), ENDFUN $ PROPER1) * EX2) ^ EX3 EXIT, WHEN EX3 EQ -1, WHEN INTEGER (EX2), WHEN INTEGER (EX1), EX3: GCD (EX1, EX2), WHEN EX3 EQ 1, FALSE EXIT, EX1: QUOTIENT (EX1, EX3), EX2: QUOTIENT (EX2, EX3), WHEN EX2 EQ 1, EX1 EXIT, EX2: LIST ('^, EX2, -1), 1, LEX2, LEX3), WHEN POSITIVE (NUMNUM) OR POSITIVE (DENNUM), WHEN PRODUCT (EX1), LEX1: REST (EX1), LOOP EX1: POP(LEX1), BLOCK WHEN DENOM (EX1), WHEN POSITIVE (DENNUM) AND DENNUM (EX1^-1), EX1) EXIT, ENDLOOP, MERGEFACT (LIST ('^, MKSUM ( DISTRIB (MKPROD(REVERSE(LEX2)), EX2, DENDEN, NUMDEN)), -1), REVERSE (LEX3)) EXIT, WHEN DENOM (EX1), EX3: EX1^-1, WHEN POSITIVE (DENDMULTIPLE (DENDEN, 5) EXIT, MULTIPLE (DENDEN, 3), ENDFUN $ NUMDEN: 0 $ PUSH ('NUMDEN, FLAGS) $ FUNCTION NUMDEN (EX1), WHEN INTEGER (EX1), MULTIPLE (NUMDEN, 2) EXIT, WHEN SUM (EX1), MULTIPLE (NUMDEN, 5) EXIT, MULTIPLE (NUMDEN, 3), ENDFWHEN POSITIVE (NUMNUM) AND NUMNUM (EX1), MKSUM (DISTRIB (EX1, LEX4, NUMNUM, DENNUM)) EXIT, EXIT, ENDFUN $ DENDEN: 6 $ PUSH ('DENDEN, FLAGS) $ FUNCTION DENDEN (EX1), WHEN INTEGER (EX1), MULTIPLE (DENDEN, 2) EXIT, WHEN SUM (EX1), T (EX1), MULTIPLE (BASEXP, 5) EXIT, MULTIPLE (BASEXP, 3), ENDFUN $ PROPERTY EXPON, +, FUNCTION (EX1, EX2, EX3), WHEN POSITIVE (BASEXP) AND BASEXP (EX1), EX1^EX2 * EX1^EX3 EXIT, ENDFUN $ PWREXPD: 0 $ PUSH ('PWREXPD, FLAGS) $ PROPESECOND(FIRST(LEX1))), EX1: EX1 * LCM (SECOND(FIRST(LEX1)), SECOND(FIRST(LEX2)))^-1 EXIT, ENDBLOCK, LEX1: REST (LEX1), LEX2: REST (LEX2) EXIT, BLOCK WHEN NEGATIVE (DENNUM) AND DENNUM ( CONTENT1 (EX2, LEX2, LEX1) EXIT, EX2: POP(LEX2), WHEN DENOM (EX2) AND NEGATIVE (DENNUM) AND DENNUM (EX2^-1), ADJOIN (EX2, CONTENT1 (EX1, LEX1, LEX2)) EXIT, CONTENT1 (EX1, LEX1, LEX2), ENDFUN $ FUNCTION CANCEL (LEX1, LEX2), WHEN A WHEN POSITIVE (EX1), WHEN MULTIPLE (PWREXPD, 2), EXPT (EX2, EX1) EXIT, EXIT, WHEN MULTIPLE (PWREXPD, 3), EXPT (EX2, -EX1) ^ -1 EXIT, EXIT, EXIT, ENDFUN $ FUNCTION EXPAND (EX1, % Local: % PWREXPD, NUMNUM, DNEGATIVE (NUMNUM) AND NUMNUM (FIRST(LEX1)), EX1: GCD (FIRST(LEX1), FIRST(LEX2)), WHEN NEGATIVE (FIRST (LEX1)) AND NEGATIVE (FIRST (LEX2)), EX1: MINUS(EX1) EXIT EXIT, ENDBLOCK, LEX1: REST (LEX1), LEX2(EX1) EQ 'MIN, CONTENT (LEX1, LEX2) EXIT, EX2: EX2^EX1, WHEN DENOM (EX2), WHEN NEGATIVE (DENNUM) AND DENNUM (EX2^-1), ADJOIN (EX2, CONTENT (LEX1, LEX2)) EXIT, CONTENT (LEX1, LEX2) EXIT, WHEN NEGATIVE (NUMNUM) AND NUMNURTY BASE, +, FUNCTION (EX1, EX2, EX3, % Local: % NUMNUM, DENNUM), WHEN INTEGER (EX1), BLOCK WHEN SUM (EX3), EX2: ADJOIN ('+, ADJOIN (EX2, REST(EX3))) EXIT, EX2: LIST ('+, EX2, EX3), ENDBLOCK, WHEN EX1 EQ -1, )), WHEN ZERO (EX1: EXPON (POP(LEX2)) - EXPON (POP(LEX1))), CANCEL (LEX1, LEX2) EXIT, ADJOIN (EX2^EX1, CANCEL (LEX1, LEX2)) EXIT, WHEN ORDERED (EX1, EX2), ADJOIN (EX1^-EXPON(POP(LEX1)), CANCEL (LEX1, LEX2)) EXIT, ADJOIN (POP(LEXTOM (LEX1), LEX2 EXIT, CANCEL1 (BASE(FIRST(LEX1)), LEX1, LEX2), ENDFUN $ FUNCTION CANCEL1 (EX1, LEX1, LEX2, % Local: % EX2), WHEN ATOM (LEX2), ADJOIN (EX1^-EXPON(POP(LEX1)), CANCEL (LEX1, LEX2)) EXIT, WHEN EX1 = (EX2:BASE(FIRST(LEX2)ENDEN, DENNUM, NUMDEN, BASEXP, EXPBAS), PWREXPD: 6, NUMNUM: DENDEN: DENNUM: BASEXP: EXPBAS: 30, NUMDEN: 0, EVAL (EX1), ENDFUN $ %**** optional content factorization & common denominator pkg. ****% FUNCTION CONTENT (LEX1, LEX2), WH: REST (LEX2) EXIT, LEX1: REST (LEX1) EXIT, WHEN INTEGER (FIRST(LEX2)), LEX2: REST (LEX2) EXIT, ENDBLOCK, BLOCK WHEN RECIP (FIRST(LEX1)), WHEN RECIP (FIRST(LEX2)), BLOCK WHEN NEGATIVE (DENNUM) AND DENNUM (M (EX2), ADJOIN (EX2, CONTENT (LEX1, LEX2)) EXIT, CONTENT (LEX1, LEX2) EXIT, WHEN ORDERED (EX1, EX2), EX1: POP(LEX1), WHEN DENOM (EX1) AND NEGATIVE (DENNUM) AND DENNUM (EX1^-1), ADJOIN (EX1, CONTENT1 (EX2, LEX2, LEX1)) EXIT, WHEN NEGATIVE (DENDEN) OR NEGATIVE (NUMDEN), NUMNUM: DENDEN, DENNUM: NUMDEN, EX2: EVAL (EX2), WHEN SUM (EX2), FALSE EXIT, EX2^-1 EXIT EXIT, WHEN POSITIVE (PWREXPD), NUMNUM: 30, DENNUM: 30,2), CANCEL1 (EX1, LEX1, LEX2)), ENDFUN $ FUNCTION FACTOR (LEX1, LEX2, % Local: % LEX3, LEX4, EX1), EX1: 1, LEX3: LEX1, LEX4: LEX2, BLOCK WHEN INTEGER (FIRST(LEX1)), WHEN INTEGER (FIRST(LEX2)), BLOCK WHEN ST(LEX1)), LEX1, LEX2), ENDFUN $ FUNCTION CONTENT1 (EX1, LEX1, LEX2, % Local: % EX2), WHEN ATOM (LEX2), CONTENT (LEX2, LEX1) EXIT, EX2: BASE (FIRST(LEX2)), WHEN EX1 = EX2, EX1: MIN (EXPON(POP(LEX1)), EXPON(POP(LEX2))), WHEN FIRSTEN ATOM (LEX1), WHEN ATOM (LEX2), FALSE EXIT, WHEN DENOM (FIRST(LEX2)) AND NEGATIVE (DENNUM) AND DENNUM (FIRST(LEX2)^-1), ADJOIN (POP(LEX2), CONTENT (FALSE, LEX2)) EXIT, CONTENT (FALSE, REST(LEX2)) EXIT, CONTENT1 (BASE(FIRSECOND(FIRST(LEX1))), EX1: EX1 * FIRST(LEX1) EXIT, ENDBLOCK, LEX1: REST (LEX1) EXIT, WHEN RECIP (FIRST(LEX2)), BLOCK WHEN NEGATIVE (DENNUM) AND DENNUM (SECOND(FIRST(LEX2))), EX1: EX1 * FIRST(LEX2) WHEN APPLY (GET(LOP1,FIRST(EX1)), ARGEX(EX1)) EXIT, WHEN FIRST(EX1) EQ '"==" OR FIRST(EX1) EQ '[ OR FIRST(EX1) EQ '{, ADJOIN (POP(EX1), MAPFUN(LOP1,EX1)) EXIT, LIST (LOP1, EX1), ENDFUN $ PROPERTY RBP, "==", 80 $ PROPERTY LBP, "==", 80 $, LIST(EX1)) EXIT, ENDFUN $ PROPERTY +, ^, FUNCTION (EX1, EX2, EX3), WHEN NEGATIVE (NUMNUM) OR NEGATIVE (DENNUM), EX2: LIST ('^, EX2, EX3), WHEN EX1 EQ 1, FACTOR (LIST(EX2)) EXIT, WHEN PRODUCT (EX1), FACTOR (LIST(EX2), REST(EX1)) LIST ('"==", EX1, PARSE (SCAN(), 80)) EXIT, LIST ('=, EX1, PARSE (SCAN, 80)), ENDFUN $ STOP $ RDS () $ (LEX1), LEX2), WHEN ATOM (LEX1), LEX2 EXIT, ENDLOOP, ENDFUN $ PROPERTY *, +, FUNCTION (EX1, LEX4, % Local: % LEX PRINT (FIRST(LEX1)), PRINT (" = "), PRINT (EVAL(POP(LEX1))), SPACES (18 - MOD(SPACES(),18)), ENDLOOP, NEWLINE (), "", ENDFUN $ STOP $ RDS () $  EXIT, ENDBLOCK, LEX2: REST (LEX2) EXIT, ENDBLOCK, LEX1: CONTENT (LEX1, LEX2), WHEN EX1 EQ 1 AND ATOM (LEX1), FALSE EXIT, MKPROD (MERGEPROD (EX1, MERGEPROD (PRODLEX (ADJOIN (EX1^-1, CANCEL(LEX1,LEX3))) + PRODLEX (ADJX1) * EX2 "==" THIRD(EX1) * EX3, EXIT, EX1 * EX2 "==" EX1 * EX3, ENDFUN $ PROPERTY BASE, "==", FUNCTION (EX1, EX2, EX3), WHEN FIRST(EX1)='"==", EX2^SECOND(EX1) "==" EX3^THIRD(EX1) EXIT, EX2 ^ EX1 "==" EX3 ^ EX1, ENDFUN $ PROPERTY EX PROPERTY +, "==", FUNCTION (EX1, EX2, EX3), WHEN FIRST(EX1) = '"==", SECOND(EX1) + EX2 "==" THIRD(EX1) + EX3, EXIT, EX1 + EX2 "==" EX1 + EX3, ENDFUN $ PROPERTY *, "==", FUNCTION (EX1, EX2, EX3), WHEN FIRST(EX1) = '"==", SECOND(EEXIT, FACTOR (LIST(EX2), LIST(EX1)) EXIT, ENDFUN $ FUNCTION EXPD (EX1, % Local: % PWREXPD, NUMNUM, DENDEN, DENNUM, NUMDEN, BASEXP, EXPBAS), PWREXPD: 6, NUMNUM: DENDEN: EXPBAS: 30, DENNUM: BASEXP: -30, NUMDEN: 0, EVAL (EX1), E% File EQN.ALG (c) 8/23/80 The Soft Warehouse % FUNCTION MAPFUN (LOP1, LEX1), WHEN ATOM(LEX1), FALSE EXIT, ADJOIN (LOP1(POP(LEX1)), MAPFUN(LOP1,LEX1)), ENDFUN $ FUNCTION SIMPU (LOP1, EX1), WHEN NAME(EX1), LIST(LOP1,EX1) EXIT, OIN (EX1^-1, CANCEL(LEX1,LEX4))), LEX1))), ENDFUN $ PROPERTY +, *, FUNCTION (EX1, LEX1), WHEN NEGATIVE (NUMNUM) OR NEGATIVE (DENNUM), WHEN EX1 EQ 1, FACTOR(LEX1) EXIT, WHEN PRODUCT(EX1), FACTOR (LEX1, REST(EX1)) EXIT, FACTOR (LEX1PON, "==", FUNCTION (EX1, EX2, EX3), EX1 ^ EX2 "==" EX1 ^ EX3, ENDFUN $ PROPERTY LOG, "==", FUNCTION (EX1, EX2, EX3), LOG (EX2,EX1) "==" LOG (EX3,EX1), ENDFUN $ PROPERTY INFIX, =, EQPARSE (SCAN) $ FUNCTION EQPARSE (EX2), WHEN EX2 EQ '=,ckage ***************************% FUNCTION FLAGS ( % Local: % LEX1, EX1), EX1: LINELENGTH()-18, LEX1: FLAGS, NEWLINE (), LOOP WHEN ATOM (LEX1) EXIT, BLOCK WHEN GREATER (SPACES(), EX1), NEWLINE () EXIT, ENDBLOCK,NDFUN $ FUNCTION FCTR (EX1, % Local: % PWREXPD, NUMNUM, DENDEN, DENNUM, NUMDEN, BASEXP, EXPBAS), NUMNUM: DENDEN: -6, PWREXPD: NUMDEN: 0, DENNUM: BASEXP: -30, EXPBAS: 30, EVAL (EX1), ENDFUN $ %****************** optional flags pa% File: ARRAY.ARI (c) 09/16/80 The Soft Warehouse % PROPERTY PREFIX, [, ADJOIN ('[, MATCH('])) $ PUSH ('], DELIMITER) $ PROPERTY PRTMATH, [, FUNCTION (LEX1), PRINT ('[), WHEN ATOM (LEX1), PRINT (']) EXIT, LOOP PRTMATH (POP(LEX(LEX1)) EXIT, SUBSCR2 (REST(LEX2), EX1 - 1), ENDFUN $ PROPERTY PRTMATH, SUBSCR, FUNCTION (LEX1), PRTMATH (POP(LEX1), 0, 0), PRTMATH (ADJOIN ('[, LEX1), 0, 0), ENDFUN $ %************* Optional Subscripted Assignment Package ************GET(LOP1,FIRST(EX1)), ARGEX(EX1)) EXIT, WHEN MEMBER (FIRST(EX1), '("==" [ {)), APPLY (POP(EX1), MAPFUN(LOP1,EX1)) EXIT, LIST (LOP1, EX1), ENDFUN $ %******************** Optional Column Package *****************% PROPERTY PREFIX, {, AEX1)) EXIT, ENDFUN $ FUNCTION MAPMULT1 (LEX1), % Fluid var from property "*[" or "*{": EX1 % WHEN ATOM (LEX1), FALSE EXIT, ADJOIN (EX1*POP(LEX1), MAPMULT1(LEX1)), ENDFUN $ FUNCTION MAPMULT2 (LEX1, LEX2), WHEN ATOM (LEX1), FALSE EXIT, nal Subscript Package **************% PROPERTY INFIX, [, ADJOIN (SUBSCR, ADJOIN(EX1, MATCH(']))) $ PROPERTY LBP, [, 200 $ FUNCTION SUBSCR LEX1, SUBSCR1 (FIRST(LEX1), REST(LEX1)), ENDFUN $ FUNCTION SUBSCR1 (EX1, LEX1), WHEN ATOM(LEX1), EX ADJOIN ('[, MAPEXPON(LEX1)), ENDFUN $ FUNCTION MAPBASE (LEX1), % Fluid var from property "EXPON[" or "EXPON{": EX1 % WHEN ATOM (LEX1), FALSE EXIT, ADJOIN (EX1^POP(LEX1), MAPBASE(LEX1)), ENDFUN $ PROPERTY EXPON, [, FUNCTION (EX1, LEX1), 1), 0, 0), WHEN ATOM (LEX1), PRINT (']) EXIT, PRINT (", "), ENDLOOP, ENDFUN $ FUNCTION ROW (EX1), FIRST (EX1) EQ '[, ENDFUN $ FUNCTION ARGLIST(EX1), WHEN MEMBER (POP(EX1), '(+ * [ {)), LIST (EX1) EXIT, EX1, ENDFUN $ (EX1), LEX1)) EXIT, ADJOIN ('{, MAPMULT1(LEX1)), ENDFUN $ PROPERTY BASE, {, FUNCTION (EX1, LEX1), ADJOIN ('{, MAPEXPON(LEX1)), ENDFUN $ PROPERTY EXPON, {, FUNCTION (EX1, LEX1), ADJOIN ('{, MAPBASE(LEX1)), ENDFUN $ PROPERTY PRTMATH, {,DJOIN ('{, MATCH('})) $ PUSH ('}, DELIMITER) $ PROPERTY +, {, FUNCTION (EX1, LEX1), WHEN COL (EX1), ADJOIN('{, MAPADD2(REST(EX1), LEX1)) EXIT, ENDFUN $ PROPERTY *, {, FUNCTION (EX1, LEX1), WHEN COL (EX1), ADJOIN('{, MAPMULT2(REST WHEN ATOM (LEX2), FALSE EXIT, ADJOIN (POP(LEX1)*POP(LEX2), MAPMULT2(LEX1,LEX2)), ENDFUN $ PROPERTY *, [, FUNCTION (EX1, LEX1), WHEN ROW (EX1), ADJOIN ('[, MAPMULT2(REST(EX1),LEX1)) EXIT, ADJOIN ('[, MAPMULT1(LEX1)), ENDFUN $ FUNCT1 EXIT, WHEN ARRAY(EX1) AND POSITIVE(FIRST(LEX1)), SUBSCR2(REST(EX1), FIRST(LEX1)) EXIT, ADJOIN (SUBSCR, ADJOIN(EX1,LEX1)), ENDFUN $ FUNCTION SUBSCR2 (LEX2, EX1), WHEN ATOM(LEX2), 0 EXIT, WHEN EX1 EQ 1, SUBSCR1 (FIRST(LEX2), REST ADJOIN ('[, MAPBASE(LEX1)), ENDFUN $ FUNCTION MAPFUN(LOP1, LEX1), WHEN ATOM (LEX1), FALSE EXIT, ADJOIN (LOP1(POP(LEX1)), MAPFUN(LOP1, LEX1)), ENDFUN $ FUNCTION SIMPU (LOP1, EX1), WHEN NAME (EX1), LIST(LOP1,EX1) EXIT, WHEN APPLY ( FUNCTION MAPADD2 (LEX1, LEX2), WHEN ATOM (LEX1), LEX2 EXIT, WHEN ATOM (LEX2), LEX1 EXIT, ADJOIN (POP(LEX1)+POP(LEX2), MAPADD2(LEX1,LEX2)), ENDFUN $ PROPERTY +, [, FUNCTION (EX1, LEX1), WHEN ROW (EX1), ADJOIN('[, MAPADD2(REST(EX1),L FUNCTION (LEX1), PRINT('{), WHEN ATOM (LEX1), PRINT ('}) EXIT, LOOP PRTMATH (POP(LEX1), 0, 0, TRUE), WHEN ATOM (LEX1) EXIT, PRINTLINE (COMMA), SPACES (4), ENDLOOP, PRINT ('}), ENDFUN $ %******************** Optio OR COL (EX1), ENDFUN $ FUNCTION ARGEX(EX1), WHEN ARRAY (EX1), LIST(REST(EX1)) EXIT, WHEN ATOM (RRREST(EX1)), REST(EX1) EXIT, LIST(SECOND(EX1), ADJOIN(FIRST(EX1), RREST(EX1))), ENDFUN $ PROPERTY BASE, [, FUNCTION (EX1, LEX1), ION MAPEXPON (LEX1), % Fluid var from property "BASE[" or "BASE{": EX1 % WHEN ATOM (LEX1), FALSE EXIT, ADJOIN (POP(LEX1)^EX1, MAPEXPON(LEX1)), ENDFUN $ FUNCTION COL (EX1), FIRST (EX1) EQ '{, ENDFUN $ FUNCTION ARRAY (EX1), ROW (EX1) % PROPERTY INFIX, :, COND ( WHEN NAME (EX1), LIST (':, EX1, PARSE (SCAN,20)) EXIT, WHEN FIRST(EX1) EQ 'SUBSCR, LIST (UPDATE, SECOND(EX1), RREST(EX1), PARSE(SCAN,20)) EXIT, WHEN SYNTAX () EXIT) $ SUBROUTINE UPDATE (EX1, LEX1, EX2), XIT ENDLOOP EXIT ENDFUN $ FUNCTION \ (EX1, EX2, % Local: % EX3, EX4, LEX1, LEX2, LEX3, LEX4), WHEN (COLMAT(EX1) OR ROW(EX1) AND COLMAT(EX1: EX1.IDMAT(LENGTH(REST(EX1))))) AND (COL(EX2) OR ROW(EX2) AND COL(EX2: EX2.IDMAT(LENGTH(REST(EXTY LBP, `, 170 $ FUNCTION ` (EX1), WHEN ATOM (EX1), EX1 EXIT, WHEN APPLY (GET('`, FIRST(EX1)), ARGEX(EX1)) EXIT, EX1, ENDFUN $ PROPERTY `, {, FUNCTION (LEX1), ADJOIN ('[, MAPFUN('`, LEX1)), ENDFUN $ PROPERTY `, [, FUNCTION (LEX1), EX4-1)), ENDFUN $ STOP $ RDS () $ SEXP: -30 $ PUSH ('BASEXP, FLAGS) $ FUNCTION BASEXP (EX1), WHEN NUMBER (EX1), MULTIPLE (BASEXP, 2) EXIT, WHEN PRODUC ARRAY (EX1), ADJOIN (APPLY (FIRST(EX1), STARTBACK (REST(EX1))), STARTBACK(LEX1)) EXIT, ADJOIN (? (LIST ('/, EX1, 0)), STARTBACK(LEX1)), ENDFUN $ FUNCTION BACKSUB(LEX3), % Fluid vars from \: LEX1 & LEX2 % LOOP WHEN ATOM (LEX1X1)), ENDFUN $ FUNCTION . (EX1, EX2), WHEN ROW (EX1), WHEN COL (EX2), INPROD (REST(EX1), REST(EX2)) EXIT, WHEN ROW (EX2), ADJOIN ('[, MAPDOTRT(REST(EX2))) EXIT, EX1 * EX2 EXIT, WHEN COL(EX1), WHEN ROW (EX2), ASSIGN (EX1, UPDATE1 (EVAL(EX1), LEX1)), ENDSUB $ FUNCTION UPDATE1 (EX3, LEX1), WHEN ATOM (LEX1), EVAL (EX2) EXIT, WHEN ARRAY (EX3) AND POSITIVE (FIRST(LEX1)), ADJOIN (FIRST(EX3), UPDATE2(REST(EX3),FIRST(LEX1))) EXIT, ? (LIST ('EX1, % Local: % EX2), EX2: LIST (1), LOOP WHEN ZERO (EX1:EX1-1) EXIT, PUSH (0, EX2), ENDLOOP, EX1: FALSE, LOOP PUSH (ADJOIN ('[, EX2), EX1), WHEN ATOM (EX2:REST(EX2)), ADJOIN ('{, EX1) EXIT, ENDLOOP, ENDFUN $ ADJOIN ('{, MAPFUN('`, LEX1)), ENDFUN $ %***************** Optional Matrix Division Package **************% FUNCTION APPEND (LEX1, LEX2), WHEN ATOM (LEX1), LEX2 EXIT, ADJOIN (POP(LEX1), APPEND(LEX1,LEX2)), ENDFUN $ FUNCTION IDMAT (% File MATRIX.ARR (c) 08/23/80 The Soft Warehouse % PROPERTY RBP, ., 125 $ PROPERTY LBP, ., 125 $ FUNCTION INPROD (LEX1, LEX2, % Local: % EX1), EX1: 0, LOOP WHEN ATOM (LEX1) OR ATOM (LEX2), EX1 EXIT, EX1: EX1 + POP(), ADJOIN ('{, LEX3) EXIT, PUSH (POP(LEX2) - POP(LEX1).ADJOIN('{,LEX3), LEX3), ENDLOOP, ENDFUN $ FUNCTION COLMAT(EX1), WHEN FIRST(EX1) EQ '{, LOOP WHEN ATOM (EX1:REST(EX1)) EXIT, WHEN NOT ROW(FIRST(EX1)), FALSE E ADJOIN ('{, OUTPROD (REST(EX1), REST(EX2))) EXIT, WHEN COL (EX2), ADJOIN ('{, MAPDOTLFT(REST(EX1))) EXIT, EX1 * EX2 EXIT, EX1 * EX2, ENDFUN $ %******************* Optional Transpose Package ******************% PROPER_, EX1, EX2)), ENDFUN $ FUNCTION UPDATE2 (LEX2, EX4), BLOCK WHEN ATOM (LEX2), LEX2: LIST(0) EXIT, ENDBLOCK, WHEN EX4 EQ 1, ADJOIN (UPDATE1(FIRST(LEX2),REST(LEX1)), REST(LEX2)) EXIT, ADJOIN (FIRST(LEX2), UPDATE2 (REST(LEX2), PROPERTY RBP, \, 125 $ PROPERTY LBP, \, 125 $ #ARB: 0 $ FUNCTION STARTBACK (LEX1, % Local: % EX1), % Global: #ARB % WHEN ATOM (LEX1), FALSE EXIT, WHEN ZERO (EX1:POP(LEX1)), ADJOIN (ARB(#ARB:#ARB+1), STARTBACK(LEX1)) EXIT, WHENN ATOM (LEX1), LEX1 EXIT, EX1: POP(LEX1), ADJOIN (ADJOIN ('[, MAPDOTRT(LEX2)), OUTPROD(LEX1, LEX2)), ENDFUN $ FUNCTION MAPDOTLFT (LEX1), % Fluid var from ".": EX2 % WHEN ATOM (LEX1), FALSE EXIT, ADJOIN (POP(LEX1) . EX2, MAPDOTLFT(LELEX1).POP(LEX2), ENDLOOP, ENDFUN $ FUNCTION MAPDOTRT (LEX1), % Fluid var from OUTPROD or ".": EX1 % WHEN ATOM (LEX1), LEX1 EXIT, ADJOIN (EX1.POP(LEX1), MAPDOTRT(LEX1)), ENDFUN $ FUNCTION OUTPROD (LEX1, LEX2, % Local: % EX1), WHE2))))), EX1: REST(EX1), EX2: REST(EX2), LOOP % make EX1 unit upper triangular, then back substitute % LOOP % make implied unit diagonal above a column of zeros % WHEN (EX4:REST(FIRST(EX1))) AND NOT ZERO(EX4:FIRST(EX4)),('SIGMA, EX1,INDET,EX2,EX3), ENDFUN $ FUNCTION ANTIDF (EX1), WHEN EX1 = INDET, EX1*(-1+EX1)/2 EXIT, WHEN FREE(EX1,INDET), INDET*EX1 EXIT, SIMPU(ANTIDF,EX1) ENDFUN $ PROPERTY ANTIDF, +, FUNCTION (EX1, EX2), WHEN ZERO (EVSUB(EX1,INDET,INDND COLMAT(EX1:EX1.IDMAT(LENGTH(REST(EX1)))), EX1: REST(EX1), EX2: EX3: 1, LOOP LOOP WHEN (EX4:REST(FIRST(EX1))) AND NOT ZERO(EX4:FIRST(EX4)), EX2: EX2.EX4, EX4: EX4 \ ADJOIN('[,RREST(POP(EX1))), LEX4), WHEN ATOM(EX1), EXIT % Singular matrix: % EX2: REST(EX2), ENDLOOP, WHEN ATOM(EX1), % do back substitution: % WHEN ATOM(LEX3), BACKSUB(ADJOIN(EX4,STARTBACK(EX2))) EXIT, EX3: LEX3, MDEN, PWREXPD, LOGEXPD), WHEN INTEGER(EX2) AND INTEGER(EX3), EX4: 0, LOOP WHEN EX2 > EX3, EX4 EXIT, EX4: EX4 + EVSUB(EX1,INDET,EX2), EX2: EX2 + 1, ENDLOOP EXIT, NUMNUM: DENDEN: 30, DENNUM: -30, NUMDEN: 0, ZERO(EX1), IDMAT (LENGTH(LEX1)) EXIT, WHEN COLMAT(EX2:ADJOIN('{,LEX1)) OR COLMAT(EX2.IDMAT(LENGTH(LEX1))), WHEN POSITIVE (EX1), WHEN EX1 EQ 1, EX2 EXIT, EX2 . EX2^(EX1-1) EXIT, WHEN NEGATIVE (EX1), WHEN EX1 EQ -1, EX2 EX3: EX4 \ ADJOIN('[, RREST(POP(EX1))), EX4: EX4 \ POP(EX2), LOOP % update remainder of EX1: % WHEN ATOM(EX1), EX1: LEX3, EX2: APPEND(LEX4,EX2), EXIT, PUSH TOM(EX1), EX2: 0 EXIT ENDLOOP, WHEN ATOM(EX1) WHEN (MOD(EX3,4) EQ 3) EQ EX5, EX2 EXIT, -EX2 EXIT, EX3: EX3+1, LEX3: FALSE ENDLOOP EXIT ENDFUN $ STOP $ RDS () $ OOP WHEN ATOM(EX1), EX1: LEX3 EXIT, PUSH (ADJOIN('[,RREST(FIRST(EX1))) - SECOND(POP(EX1)).EX4, LEX3) ENDLOOP EXIT, PUSH (ADJOIN('[,RREST(POP(EX1))), LEX3), EX5: NOT EX5, WHEN A % have singular matrix: % LOOP WHEN ATOM(EX3), BACKSUB(STARTBACK(EX2)) EXIT, WHEN REST(POP(EX3)), % maybe a nonzero in next col % EX2: REST (ADJOIN ('{,LEX3) \ ADJOIN('{,LEX4)), PWREXPD: LOGEXPD: 6, WHEN FREE (EX4:ANTIDF(EX1), ANTIDF), WHEN INTEGER(#LIM), LIM(EX4,INDET,EX3+1) - LIM(EX4,INDET,EX2) EXIT, EVSUB(EX4,INDET,EX3+1) - EVSUB(EX4,INDET,EX2) EXIT, WHEN APPLY(GET('SIGMA,FIRST(EX1)), ARGEX(EX1)) EXIT, LIST \ IDMAT (LENGTH(LEX1)) EXIT, (EX2 ^ -1) ^ -EX1 EXIT EXIT, ENDFUN $ %***************** Optional Determinant Package *****************% FUNCTION DET (EX1, % Local: % EX2, EX3, EX4, EX5, LEX3), WHEN COLMAT(EX1) OR ROW(EX1) A(ADJOIN ('[, RREST(FIRST(EX1))) - SECOND(FIRST(EX1)).EX3, LEX3), PUSH (POP(EX2) - SECOND(POP(EX1)).EX4, LEX4), ENDLOOP EXIT, PUSH (ADJOIN ('[, RREST(POP(EX1))), LEX3), PUSH (FIRST(EX2), L% File: SIGMA.ALG (c) 08/26/80 The Soft Warehouse % FUNCTION LINCF (EX1, INDET), WHEN FREE (EX1:(EX1-EVSUB(EX1,INDET,0))/INDET, INDET), EX1 EXIT, ENDFUN$ FUNCTION SIGMA (EX1, INDET, EX2, EX3, % Local: % EX4, NUMNUM, DENDEN, DENNUM, NUatrix Power & Inverse Package ****************% PROPERTY BASE, [, FUNCTION (EX1, LEX1), WHEN COLMAT (LEX1: ADJOIN('[,LEX1).IDMAT(LENGTH(LEX1))), LEX1 ^ EX1 EXIT ENDFUN $ PROPERTY BASE, {, FUNCTION (EX1, LEX1, % Local: % EX2), WHEN BACKSUB(ADJOIN(POP(EX2:REVERSE(EX2)),REVERSE(EX2))) EXIT, ENDLOOP EXIT, LEX3: LEX4: FALSE, PUSH (EX3, LEX1), PUSH (EX4, LEX2), ENDLOOP EXIT, EX2 / EX1, ENDFUN $ %********* Optional MET+1) + EX2), -EX1 EXIT, WHEN ZERO (EVSUB(EX2,INDET,INDET+1) + EX1), -EX2 EXIT, ANTIDF(EX1) + ANTIDF(EX2), ENDFUN $ PROPERTY ANTIDF, *, FUNCTION (EX1, EX2), WHEN FREE(EX1,INDET), EX1*ANTIDF(EX2) EXIT, WHEN FREE(EX2,INDET), EX2*ANTIDF(EX1 STOP $ RDS() $ X4,INDET,EX2) EXIT, EVSUB(EX4,INDET,EX3+1) / EVSUB(EX4,INDET,EX2) EXIT, WHEN APPLY(GET('PROD,FIRST(EX1)), ARGEX(EX1)) N EX2 EQ 1, ?(LIST('LOG, EX1, EX2)) EXIT, WHEN PBRCH AND EX1 EQ 1, 0 EXIT, WHEN PBRCH AND EX1=EX2, 1 EXIT, WHEN NOT(EX2 EQ LOGBAS) AND POSMULT(LOGEXPD,2), LOG(EX1,LOGBAS) / LOG(EX2,LOGBAS) EXIT, WHEN ATOM(EX1), LIST('LOG, EX1, EX2) EXIT EX2: EX2 + 1, ENDLOOP EXIT, WHEN FREE (EX4:ANTIDV(EX1), ANTIDV), WHEN INTEGER(#LIM), LIM(EX4,INDET,EX3+1) / LIM(EX4,INDET,EX2) EXIT, EVSUB(EX4,INDET,EX3+1) / EVSUB(EX4,INDET,EX2) EXIT, WHEN APPLY(GET('PROD,FIRST(EX1)), ARGEX(EX1)) 1)) AND THIRD(EX1) EQ -1 AND THIRD(SECOND(EX1))=EX3, LOG (EX2, SECOND(SECOND(EX1))) EXIT, WHEN NEGMULT(LOGEXPD,3), LOG (EX2^EX1, EX3) EXIT, ENDFUN $ FUNCTION LOGARITHM (EX1), FIRST(EX1) EQ 'LOG, ENDFUN $ PROPERTY +, LOG, FUNCTN FREE(EX1,INDET), EX1^SIGMA(EVSUB(EX2,INDET,INDET2-1),INDET2,1,INDET) EXIT, ENDFUN $ STOP $ RDS () $  OR ROW(EX1) AND COLMAT(EX1: EX1.IDMAT(LENGTH(REST(EX1))))) AND (COL(EX2) OR ROW(EX2) AND COL(EX2: EX2.IDMAT(LENGTH(REST(EX) EXIT, ENDFUN $ PROPERTY ANTIDF, ^, FUNCTION (EX1, EX2, EX3), WHEN EX1 = INDET AND POSITIVE(EX2), (EX3:PROD(INDET-'##,'##,0,EX2-1)) * (INDET-EX2)/(1+EX2) + ANTIDF(EX1^EX2-EX3) EXIT, WHEN FREE(EX1,INDET) AND (EX3: LINCF(EX2,INDET)),, WHEN LEX1 = LOGBAS, PRTLIST ('LOG, EX1) EXIT, ENDFUN $ FUNCTION LN (EX1), LOG(EX1, #E), ENDFUN $ PROPERTY LOG, *, FUNCTION (EX1, EX2, EX3), WHEN POSMULT(LOGEXPD,5), LOG(EX2,EX1) + LOG(EX3,EX1) EXIT, ENDFUN $ PROPERTY LOG, ^, F, WHEN APPLY(GET('LOG,FIRST(EX1)), ADJOIN(EX2,ARGEX(EX1))) EXIT, LIST('LOG, EX1, EX2), ENDFUN $ PROPERTY PRTMATH, LOG, FUNCTION (LEX1, % Local: % EX1), EX1 : POP(LEX1), LEX1: FIRST(LEX1), WHEN LEX1 EQ #E, PRTLIST ('LN, EX1) EXIT EXIT, LIST ('PROD, EX1, INDET, EX2, EX3), ENDFUN $ %************** Optional ANTIDV (PROD) Package ****************% FUNCTION ANTIDV (EX1), WHEN EX1=INDET, (EX1-1)! EXIT, WHEN FREE(EX1,INDET), EX1^INDET EXIT, SIMPU (ANTIDV, EX1) ENDION (EX1, EX2, EX3), WHEN LOGARITHM(EX1), WHEN NEGMULT(LOGEXPD,5), WHEN THIRD(EX1)=EX3, LOG (SECOND(EX1)*EX2, EX3) EXIT EXIT EXIT, ENDFUN $ PROPERTY EXPON, LOG, FUNCTION (EX1, EX2, EX3), WHEN EX1 = EX3, EX2 EXIT, ENDFUN $% File LOG.ALG (c) 8/25/79 The Soft Warehouse % FUNCTION LOGEXPD (EX1, LOGEXPD), EVAL (EX1), ENDFUN $ FUNCTION LOG (EX1, % Optional: % EX2), WHEN EMPTY(EX2), LOG (EX1, LOGBAS) EXIT, WHEN ZERO(EX1), ?(LIST('LOG, EX1, EX2)) EXIT, WHE EX1^EX2/(EX1^EX3 - 1) EXIT, ENDFUN $ FUNCTION PROD (EX1, INDET, EX2, EX3, % Local: % EX4, LOGEXPD), WHEN INTEGER(EX2) AND INTEGER(EX3), EX4: 1, LOOP WHEN EX2 > EX3, EX4 EXIT, EX4: EX4 * EVSUB(EX1,INDET,EX2), UNCTION (EX1, EX2, EX3), WHEN POSMULT(LOGEXPD,3), EX3*LOG(EX2,EX1) EXIT, WHEN PBRCH AND EX1=EX2, EX3*LOG(EX2,EX1) EXIT, ENDFUN $ PROPERTY *, LOG, FUNCTION (EX1, EX2, EX3), WHEN NEGMULT(LOGEXPD,2) AND POWER(EX1) AND LOGARITHM(SECOND(EX+1)*EX2) EQ 1, 1/EX1 EXIT, WHEN EXPD(EVSUB(EX2,INDET,INDET+1)*EX1) EQ 1, 1/EX2 EXIT, ANTIDV(EX1) * ANTIDV(EX2), ENDFUN $ PROPERTY ANTIDV, ^, FUNCTION (EX1, EX2, INDET2), WHEN FREE(EX2,INDET), ANTIDV(EX1)^EX2 EXIT, INDET2: 'INDET2, WHEFUN $ PROPERTY ANTIDV, +, FUNCTION (EX1, EX2), WHEN EX1=INDET AND FREE(EX2,INDET), (EX1-1+EX2)! EXIT, WHEN EX2=INDET AND FREE(EX1,INDET), (EX2-1+EX1)! EXIT, ENDFUN $ PROPERTY ANTIDV, *, FUNCTION (EX1, EX2), WHEN EXPD(EVSUB(EX1,INDET,INDET% File TRGPOS.ALG (c) 8/29/80 The Soft Warehouse % FUNCTION NEGLT(EX1), WHEN SUM(EX1), WHEN POSMULT(NUMNUM,2), NEGCOEF(SECOND(EX1)) EXIT EXIT, NEGCOEF(EX1), ENDFUN $ FUNCTION SIN (EX1), WHEN ZERO(EX1), EX1 EXIT, WHEN NEGLT (EX1), 7), #I * (1/(EX2:#E^(#I*EX1)) - EX2) * HALF EXIT, SIMPU ('SIN, EX1), ENDFUN $ FUNCTION COS (EX1, % Local: % EX2), WHEN NEGLT (EX1), COS(-EX1) EXIT, WHEN NUMBER(EX2:EX1*FOURONPI), SINCOS EX1: DIVIDE (NUM(EX2), EX2:DEN(EX2)), T(EX1) EQ 'COS, EX1: SECOND (EX1), HALF*SIN(EX1+EX2) - HALF*SIN(EX1-EX2) EXIT EXIT, ENDFUN $ PROPERTY *, COS, FUNCTION (EX1, EX2), WHEN POSMULT (TRGEXPD, 5), WHEN FIRST(EX1) EQ 'SIN, EX1: SECOND (EX1), HALF*SIN(EX1+EX1)^-1 EXIT, SIMPU ('CSC, EX1), ENDFUN $ FUNCTION SEC (EX1), WHEN POSMULT(TRGEXPD,2), COS(EX1)^-1 EXIT, SIMPU ('SEC, EX1), ENDFUN $ HALF: 1/2 $ TRGSQ: 0 $ PUSH ('TRGSQ, FLAGS) $ PROPERTY BASE, SIN, FUNCTION (EX1, EX2), WHE WHEN ZERO(EX1), EX4 EXIT, WHEN POSITIVE (EX1), MULTANGLE1 (EX1, EX3, EX4) EXIT, ENDFUN $ FUNCTION MULTANGLE1 (EX1, EX3, EX4), % Fluid var from MULTANGLE: EX2 % WHEN EX1 EQ 1, EX3 EXIT, MULTANGLE1 (EX1 - 1, EX2*EX3 - EX4, EX3), ENDFUN $ 0 AND NEGMULT (TRGEXPD, 2), SEC(EX2) ^ -EX1 EXIT, WHEN POSITIVE (EX1) AND POSITIVE (TRGSQ), (1-SIN(EX2)^2)^QUOTIENT(EX1,2) * COS(EX2)^MOD(EX1,2) EXIT, WHEN LESSER (EX1, -1) AND POSITIVE (TRGSQ), EX1: -EX1, ((1-SIN(EX2)^2)^Q, -SIN(-EX1) EXIT, SIMPU ('SIN, EX1), ENDFUN $ FUNCTION COS (EX1), WHEN ZERO(EX1), 1 EXIT, WHEN NEGLT (EX1), COS(-EX1) EXIT, SIMPU ('COS, EX1), ENDFUN $ FUNCTION TAN (EX1), WHEN NEGLT(EX1), -TAN(-EX1) EXIT, WHEN POSMULT(TRGEXPD,EX2) + HALF*SIN(EX1-EX2) EXIT, WHEN FIRST(EX1) EQ 'COS, EX1: SECOND (EX1), HALF*COS(EX1-EX2) + HALF*COS(EX1+EX2) EXIT EXIT, ENDFUN $ STOP $ RDS() $ N POSITIVE (EX1) AND POSMULT (TRGEXPD, 3), SIN(EX2)^(EX1-2) * (HALF - COS(2*EX2)*HALF) EXIT, WHEN LESSER (EX1, -1) AND POSMULT (TRGEXPD, 3), (SIN(EX2)^-EX1) ^ -1 EXIT, WHEN EX1 < 0 AND NEGMULT (TRGEXPD, 2), CSC(EX2) ^ -EX1 EXIT FOURONPI: 4 / #PI $ FUNCTION SIN (EX1, % Local: % EX2), WHEN NEGLT (EX1), -SIN(-EX1) EXIT, WHEN NUMBER(EX2:EX1*FOURONPI), SINCOS EX1: DIVIDE (NUM(EX2), EX2:DEN(EX2)), SINCOS (MOD(POP(EX1),8), EX1/EX2) EXIT, WHEN POSMULT (TRGEXPDUOTIENT(EX1,2) * COS(EX2)^MOD(EX1,2))^-1, EXIT, ENDFUN $ PROPERTY *, SIN, FUNCTION (EX1, EX2), WHEN POSMULT (TRGEXPD, 5), WHEN FIRST(EX1) EQ 'SIN, EX1: SECOND (EX1), HALF*COS(EX1-EX2) - HALF*COS(EX1+EX2) EXIT, WHEN FIRS2), SIN(EX1)/COS(EX1) EXIT, SIMPU('TAN EX1), ENDFUN $ FUNCTION COT (EX1), WHEN NEGLT(EX1), -COT(-EX1) EXIT, WHEN POSMULT(TRGEXPD,2), COS(EX1)/SIN(EX1) EXIT, SIMPU('COT EX1), ENDFUN $ FUNCTION CSC (EX1), WHEN POSMULT(TRGEXPD,2), SIN(% File TRGNEG.ALG (c) 9/10/80 The Soft Warehouse % HALF: 1/2 $ FUNCTION NEGLT (EX1), WHEN SUM (EX1), WHEN POSMULT (NUMNUM, 2), NEGCOEF (SECOND(EX1)) EXIT EXIT, NEGCOEF (EX1), ENDFUN $ FUNCTION MULTANGLE (EX1, EX2, EX3, EX4), FUN $ PROPERTY BASE, COS, FUNCTION (EX1, EX2), WHEN POSITIVE (EX1) AND POSMULT (TRGEXPD, 3), COS(EX2)^(EX1-2) * (HALF + COS(2*EX2)*HALF) EXIT, WHEN LESSER (EX1, -1) AND POSMULT (TRGEXPD, 3), (COS(EX2)^-EX1) ^ -1 EXIT, WHEN EX1 <, WHEN POSITIVE (EX1) AND NEGATIVE (TRGSQ), (1-COS(EX2)^2)^QUOTIENT(EX1,2) * SIN(EX2)^MOD(EX1,2) EXIT, WHEN LESSER (EX1, -1) AND NEGATIVE (TRGSQ), EX1: -EX1, ((1-COS(EX2)^2)^QUOTIENT(EX1,2) * SIN(EX2)^MOD(EX1,2))^-1 EXIT, END SINCOS (MOD(2+POP(EX1),8), EX1/EX2) EXIT, WHEN POSMULT (TRGEXPD, 7), (1/(EX2:#E^(#I*EX1)) + EX2) * HALF EXIT, SIMPU ('COS, EX1), ENDFUN $ FUNCTION SINCOS (EX1, EX2), WHEN LESSER(3,EX1), -SINCOS(EX1-4, EX2) EXIT, WHEN ZERO(EX1), SACSC, FUNCTION (EX1), -(EX1^-1) * (EX1^2-1)^MINUSHALF * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, ASEC, FUNCTION (EX1), EX1^-1 * (EX1^2-1)^MINUSHALF * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, ACOT, FUNCTION (EX1), -(1+EX1^2)^-1 * DIF(EX1,INDET) PROPERTY *, CSC, FUNCTION (EX1, EX2), WHEN NOT ATOM(EX1), WHEN SECOND(EX1)=EX2, WHEN (EX1:FIRST(EX1)) EQ 'SIN, 1 EXIT, WHEN EX1 EQ 'COS, COT(EX2) EXIT, WHEN EX1 EQ 'TAN, SEC(EX2) EXIT EXIT EXIT, ENDFUN $ PROPERTY TAN PROPERTY SIN, *, FUNCTION (EX1, EX2), WHEN NEGMULT (TRGEXPD, 3), MULTANGLE (EX1, 2*COS(EX2), SIN(EX2), 0) EXIT, ENDFUN $ PROPERTY COS, *, FUNCTION (EX1, EX2), WHEN NEGMULT (TRGEXPD, 3), MULTANGLE (EX1, 2*COS(EX2), COS(EX2), 1) EXIT, FUN $ PROPERTY DIF, DEFINT, FUNCTION (EX1, EX2, EX3, EX4), EX4: THIRD(EX2:REST(EX2)), EX3: SECOND(EX2), DEFINT (DIF(EX1,INDET), EX2:FIRST(EX2), EX3, EX4) + DIF(EX4,INDET) * EVSUB(EX1,EX2,EX4) - DIF(EX3,INDET) * EVSUB(EX1,EX3,EX3), ENIT, ENDFUN $ PROPERTY *, TAN, FUNCTION (EX1, EX2), WHEN FIRST(EX1) EQ 'COS, WHEN SECOND(EX1)=EX2, SIN(EX2) EXIT EXIT, ENDFUN $ PROPERTY *, COT, FUNCTION (EX1, EX2), WHEN FIRST(EX1) EQ 'SIN, WHEN SECOND(EX1)=EX2, COS(EX2) EXIT EXIN1(EX2) EXIT, WHEN EX1 EQ 1, COS1(1-EX2) EXIT, WHEN EX1 EQ 2, COS1(EX2) EXIT, SIN1(1-EX2), ENDFUN $ PION4: 1/FOURONPI $ ONRT2: 2^-HALF $ TWO3RDS: 2/3 $ FUNCTION SIN1 (EX1), WHEN ZERO(EX1), EX1 EXIT, WHEN EX1 EQ 1, ONRT2 EXIT, DS() $ M(EX1), % do back substitution: % WHEN ATOM(LEX3), BACKSUB(ADJOIN(EX4,STARTBACK(EX2))) EXIT, EX3: LEX3, , ATAN, IDENTITY $ PROPERTY SIN, ASIN, IDENTITY $ PROPERTY COS, ACOS, IDENTITY $ PROPERTY COT, ACOT, IDENTITY $ PROPERTY CSC, ACSC, IDENTITY $ PROPERTY SEC, ASEC, IDENTITY $ FUNCTION TRGEXPD (EX1, TRGEXPD), EVAL (EX1), ENDFUN $ STOP $ R ENDFUN $ PROPERTY SIN, +, FUNCTION (EX1, EX2), WHEN NEGMULT (TRGEXPD, 5), SIN(EX1)*COS(EX2) + COS(EX1)*SIN(EX2) EXIT, ENDFUN $ PROPERTY COS, +, FUNCTION (EX1, EX2), WHEN NEGMULT (TRGEXPD, 5), COS(EX1)*COS(EX2) - SIN(EX1)*SIN(EX2) EXDFUN $ PROPERTY DIF, INT, FUNCTION (EX1, EX2), WHEN INDET=EX2, EX1 EXIT, INT(DIF(EX1,INDET),EX2), ENDFUN $ MINUSHALF: -1/2 $ PROPERTY DIF, ERF, FUNCTION (EX1), 2 * #PI^MINUSHALF * #E^-(EX1^2) * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, IT, ENDFUN $ PROPERTY *, SEC, FUNCTION (EX1, EX2), WHEN NOT ATOM(EX1), WHEN SECOND(EX1)=EX2, WHEN (EX1:FIRST(EX1)) EQ 'COS, 1 EXIT, WHEN EX1 EQ 'SIN, TAN(EX2) EXIT , WHEN EX1 EQ 'COT, CSC(EX2) EXIT EXIT EXIT, ENDFUN $ WHEN EX1 = TWO3RDS, HALF EXIT, LIST ('SIN, EX1*PION4), ENDFUN $ RT3ON2: 3^HALF * HALF $ FUNCTION COS1 (EX1), WHEN ZERO(EX1), 1 EXIT, WHEN EX1 EQ 1, ONRT2 EXIT, WHEN EX1 = TWO3RDS, RT3ON2 EXIT, LIST ('COS, EX1*PION4), ENDFUN $ % File DIF.ALG (c) 8/29/80 The Soft Warehouse % FUNCTION DIF (EX1, INDET), WHEN EX1=INDET, 1 EXIT, WHEN ATOM(EX1), 0 EXIT, WHEN APPLY (GET(DIF,FIRST(EX1)), ARGEX(EX1)) EXIT, WHEN FREE(EX1,INDET), 0 EXIT, LIST ('DIF, EX1, INDET), ENDIT, ENDFUN $ PROPERTY BASE, SEC, FUNCTION (EX1, EX2), WHEN EX1<0, WHEN NEGMULT(TRGEXPD,2), COS(EX2) ^ -EX1 EXIT EXIT, ENDFUN $ PROPERTY BASE, CSC, FUNCTION (EX1, EX2), WHEN EX1<0, WHEN NEGMULT(TRGEXPD,2), SIN(EX2) ^ -EX1 EXIT EXIT, ENDFUN $ PROPERTY BASE, TAN, FUNCTION (EX1, EX2), WHEN EX1<0, WHEN NEGMULT(TRGEXPD,2), COT(EX2) ^ -EX1 EXIT EXIT, ENDFUN $ PROPERTY BASE, COT, FUNCTION (EX1, EX2), WHEN EX1<0, WHEN NEGMULT(TRGEXPD,2), TAN(EX2) ^ -EX1 EXIT EX, ENDFUN $ PROPERTY DIF, ACOS, FUNCTION (EX1), -(1-EX1^2)^MINUSHALF * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, ASIN, FUNCTION (EX1), (1-EX1^2)^MINUSHALF * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, ATAN, FUNCTION (EX1), (1+EX1^2)^-1 * DIF(EX) EXIT, DRVDIV(LEX1) EXIT, DRVDIV(LEX1) EXIT, WHEN FREE (RREST(EX4), INDET), WHEN FREE (EX3:EXPD(EX5/EX3), INDET), WHEN EX5: APPLY(GET('INT,FIRST(EX4)), ADJOIN(INDET,RREST(EX4))), EX3 * EVSUB(EX5,INDET,SECOND(EX4)) E "), PRTMATH(EX1,0,0,TRUE), SPACES(3), LEX2: LEX1, LOOP WHEN ATOM(REST(LEX2)), PRINT("or "), PRTMATH(FIRST(LEX2),0,0,TRUE), PRINT("; ? ") EXIT, PRTMATH(POP(LEX2),0,0,TRUE), PRINT("; "), ENDLOOP, WHEN MEUN $ PROPERTY DIF, LOG, FUNCTION (EX1, EX2), WHEN EX2 EQ #E, DIF(EX1,INDET) / EX1 EXIT, DIF (LOG(EX1,#E)/LOG(EX2,#E), INDET), ENDFUN $ PROPERTY DIF, ^, FUNCTION (EX1, EX2), EX1^EX2 * (LOG(EX1,#E)*DIF(EX2,INDET) + EX2*DIF(EX1,INDET)/EX1), DRVDIV(LEX1) EXIT, EX5: EX1 / EX4, WHEN ZERO (EX3:DIF(EX4,INDET)), EX2: EX2*EX4, EX1: EX5, DRVDIV(REST(LEX1)) EXIT, WHEN FREE (EX3:EXPD(EX5/EX3), INDET), HALF*EX3*EX4^2 EXIT, WHEN SUM(EX4), DRVDIV(LEX1) EXIT, WHEN ZERO (EX3: D1,INDET), ENDFUN $ PROPERTY DIF, CSC FUNCTION (EX1), -COT(EX1) * CSC(EX1) * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, SEC FUNCTION (EX1), TAN(EX1) * SEC(EX1) * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, COT, FUNCTION (EX1), -CSC(EX1)^2 * DIF EXIT, WHEN EX1 EQ PINF, 1 EXIT, WHEN EX1 EQ MINF, -1 EXIT, WHEN EX1 = PINF-MINF, 1 EXIT, QUERY (LIST('SIGN, EX1), M101), ENDFUN $ HALF: 1/2 $ FUNCTION INT3 (), % Global var HALF=1/2 & fluid vars INDET from INT & EX1 from INT1 % MBER (LEX2:PARSE(SCAN(),0), LEX1), PUSH (ADJOIN (ADJOIN(EX1,LEX1), LEX2), QUERY), LEX2 EXIT, ENDLOOP, ENDFUN $ M101: LIST (-1, 0, 1) $ FUNCTION SIGN(EX1), WHEN ZERO(EX1), EX1 EXIT, WHEN EX1 > 0, 1 EXIT, WHEN EX1 < 0, -1 ENDFUN $ PROPERTY DIF, *, FUNCTION (EX1, EX2), EX1*DIF(EX2,INDET) + EX2*DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, +, FUNCTION (EX1, EX2), DIF(EX1,INDET) + DIF(EX2,INDET), ENDFUN $ STOP $ RDS() $ IF(SECOND(EX4), INDET)), WHEN ZERO(EX3:DIF(THIRD(EX4),INDET)), DRVDIV(LEX1) EXIT, WHEN FREE(EX3:EXPD(EX5/EX3), INDET), WHEN EX5: APPLY (GET('INT, FIRST(EX4)), LIST (SECOND(EX4), INDET)), EX3 * EVSUB(EX5,INDET,THIRD(EX4)% File INT.DIF (c) 8/25/80 The Soft Warehouse % FUNCTION QUERY (EX1, LEX1, % Local: % LEX2), % Uses fluid var QUERY to hold previous questions & answers % WHEN LEX2: ASSOC(ADJOIN(EX1,LEX1),QUERY), REST(LEX2) EXIT, LOOP PRINT(" Is(EX1,INDET), ENDFUN $ PROPERTY DIF, TAN, FUNCTION (EX1), SEC(EX1)^2 * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, COS, FUNCTION (EX1), -SIN(EX1) * DIF(EX1,INDET), ENDFUN $ PROPERTY DIF, SIN, FUNCTION (EX1), COS(EX1) * DIF(EX1,INDET), ENDF WHEN EX1 = INDET, HALF*EX1^2 EXIT, APPLY (GET('INT,FIRST(EX1)), ARGEX(EX1)), ENDFUN $ FUNCTION DRVDIV (LEX1), % Fluid vars, from INT & INT1: INDET, EX1, EX2, EX3, EX4, EX5 % WHEN ATOM(LEX1), INT3() EXIT, WHEN (EX4:POP(LEX1)) = INDET,XIT, DRVDIV(LEX1) EXIT, DRVDIV(LEX1) EXIT, DRVDIV(LEX1), ENDFUN $ FUNCTION INT2 (), % Fluid vars, from INT & INT1: INDET, EX1 % WHEN PRODUCT(EX1), DRVDIV(REST(EX1)) EXIT, WHEN FREE(EX1,INDET), EX1*INDET EXIT, INT3(), ENNT1(EX2^(EX3+1)) - EX6*EX2^(EX3+1)) / (EX3+1) / EX5 EXIT, WHEN EX3 = HALF, HALF * (EX1*EX6 + HALF*EX5*INT1(EX2^MINUSHALF)) / EX7 EXIT, WHEN POSITIVE(2*EX3), HALF * (EX1*EX6 + EX3*EX5*INT1(EX2^(EX3-1))) / (HALF+EX WHEN EX2 = INDET, WHEN EX3 EQ -1, LN(INDET) EXIT, INDET^(EX3+1) / (EX3+1) EXIT, APPLY (GET(INTPWR, FIRST(EX2)), ARGEX(EX2)) EXIT, WHEN FREE (EX2, INDET), WHEN FREE (EX4:DIF(EX3,INDET), INDET), LIST('^, EX2, EX3) / EX4UERY), PWREXPD: NUMDEN: LOGEXPD: TRGEXPD: 0, NUMNUM: DENNUM: 6, DENDEN: 2, BASEXP: -30, EXPBAS: 30, INT1 (EX1), ENDFUN $ PROPERTY INT, COS, FUNCTION (EX1, % Local: % EX2), WHEN FREE (EX2:DIF(EX1,INDET), INDET), SIN(EX1) / EX2 INUSHALF * LN (((-EX5)^HALF-EX6) / ((-EX5)^HALF+EX6)) EXIT, WHEN NEGATIVE(EX3), ((2*EX3+3)*EX7*INT1(EX2^(EX3+1)) - EX6*EX2^(EX3+1)) / (EX3+1) / EX5 EXIT, WHEN EX3 = MINUSHALF, WHEN ZERO (EX4:SIGN(EX7)), ) EXIT, WHEN FREE (EX4:SECOND(EX2), INDET), WHEN FREE (EX5:DIF(THIRD(EX2),INDET), INDET), APPLY (GET(INTEXPTMS,FIRST(EX3)), ARGEX(EX3)) EXIT EXIT EXIT, ENDFUN $ PROPERTY INT, *, FUNCTION (EX2, EX3), WHEN PRODUCT(EX3), FALSE EXIDFUN $ FUNCTION INT1 (EX1, % Local: % EX2, EX3, EX4, EX5), EX2: 1, WHEN EX3:INT2(), EX2*EX3 EXIT, TRGEXPD: LOGEXPD: NUMNUM: DENDEN: DENNUM: 30, PWREXPD: 6, EX1: EVAL(EX1), WHEN EX3:INT2(), EX2*EX3 EXIT, NUMNUM: DENDEN: DENNUM:7), % Fluid vars from INT, INT1 & property INT ^: INDET, EX1, EX2, EX3, EX4 % WHEN FREE (EX6:DIF(EX2,INDET), INDET), WHEN EX3 EQ -1, LN(EX2)/EX6 EXIT, EX2^(EX3+1) / (EX3+1) / EX6 EXIT, WHEN POSITIVE(EX3), FALSE EXIT, WHEN / LN(EX2) EXIT, WHEN FREE (EX5:DIF(EX4,INDET), INDET), (MINUSHALF*#PI/EX5/LN(EX2))^HALF * EX2^(EX3-HALF*EX4^2/EX5) * ERF (-EX4*(MINUSHALF*LN(EX2)/EX5)^HALF) EXIT EXIT, ENDFUN $ PROPERTY INTPWR, +, FUNCTION ( % Local: % EX6, EX EXIT, ENDFUN $ PROPERTY INT, SIN, FUNCTION (EX1, % Local: % EX2), WHEN FREE (EX2:DIF(EX1,INDET), INDET), -COS(EX1) / EX2 EXIT, ENDFUN $ PROPERTY INT, LOG, FUNCTION (EX2, EX3), WHEN EX3 EQ #E, WHEN FREE (EX3:DIF(EX2,INDET), INDET),INT1 (EXPD ((EX2-HALF*EX7*INDET)^MINUSHALF)) EXIT, WHEN EX4 EQ 1, (HALF*EX7)^MINUSHALF * LN((2*EX2*EX7)^HALF+EX6) EXIT, -(MINUSHALF*EX7)^MINUSHALF * ASIN(EX6*(-EX5)^MINUSHALF) EXIT WHEN NEGATIVE(2*EX3), ((2*EX3+3)*EX7*IT, WHEN INTPROD(EX2,EX3) EXIT, INTPROD(EX3,EX2), ENDFUN $ MINUSHALF: -HALF $ PROPERTY INT, ^, FUNCTION (EX2, EX3, % Local: % EX4, EX5), % Globals HALF=1/2, MINUSHALF=-1/2 % % Fluid var INDET from INT % WHEN FREE (EX3, INDET), -30, TRGEXPD: 7, EX1: EVAL(EX1), WHEN EX3:INT2(), TRGEXPD:-7, EX2*EVAL(EX3) EXIT, LIST ('INT, EX1, INDET), ENDFUN $ FUNCTION INT (EX1, INDET, % Local: % PWREXPD, NUMNUM, DENDEN, DENNUM, NUMDEN, BASEXP, EXPBAS, LOGEXPD, TRGEXPD, Q FREE (EX7:DIF(EX6,INDET), INDET), WHEN ZERO (EX4: SIGN(EX5: EXPD(2*EX2*EX7-EX6^2))), (2*EX7)^-EX3 * INT1(EX6^(2*EX3)) EXIT, WHEN EX3 EQ -1, WHEN EX4 EQ 1, 2 * EX5^MINUSHALF * ATAN(EX6*EX5^MINUSHALF) EXIT, (-EX5)^M WHEN FREE (THIRD(EX2), INDET), WHEN SECOND(EX2)=INDET, APPLY (GET(INTMONTMS,FIRST(EX3)), ADJOIN (THIRD(EX2), ARGEX(EX3))) EXIT, APPLY (GET(INTPWRTMS,FIRST(SECOND(EX2))), ADJOIN (THIRD(EX2), ARGEX(SECOND(EX2))) EX2 * (LN(EX2)-1) / EX3 EXIT EXIT, ENDFUN $ FUNCTION INTPROD (EX2, EX3, % Local: % EX4, EX5), % Fluid var from INT: INDET % WHEN EX2 = INDET, APPLY (GET(INTMONTMS,FIRST(EX3)), ADJOIN(1,ARGEX(EX3))) EXIT, WHEN POWER(EX2), 3) / EX7 EXIT EXIT, ENDFUN $ PROPERTY INT, +, FUNCTION (EX1, EX2), INT1(EX1) + INT1(EX2), ENDFUN $ STOP $ RDS() $ D: INDET, EX1, EX2, EX3, EX4, EX5 % WHEN NEGATIVE (EX8), WHEN FREE (EX4:DIF(EX7,INDET), INDET), WHEN POSITIVE (EX6), EX4^(-1-EX6) * EVSUB (INT1((INDET-EX7+EX4*INDET)^EX6 * INDET^EX8), INDET, EX7) EXIT, WHEN NNDET), INDET), WHEN EX3 EQ -1, LN (TAN(HALF*EX4)) / EX5 EXIT, WHEN NEGATIVE(EX3), ((EX3+2)*INT1(EX2^(EX3+2)) + COS(EX4)*EX2^(EX3+1)/EX5) / (EX3+1) EXIT EXIT, ENDFUN $ PROPERTY INTPWR, LOG, FUNCTION (EX4, EX5), % Fluid varOPERTY INTMONTMS, LOG, FUNCTION (EX5, EX6, EX7), % Fluid vars from INT and INTPROD: INDET, EX1, EX2 % WHEN EX7 EQ #E, WHEN FREE (EX7:DIF(EX6,INDET), INDET), WHEN ZERO (EX4: EXPD(EX6-INDET*EX7)), INDET * (EX1 - EX2/(EX5+1)) / (EX HALF*LN(EX2^2+1)) / EX3 EXIT, ENDFUN $ PION4: #PI/4 $ PROPERTY INTPWR, COS, FUNCTION (EX4), % Fluid vars from property "INT^": EX2, EX3, EX5 % WHEN FREE (EX5:DIF(EX4,INDET), INDET), WHEN EX3 EQ -1, LN (TAN (PION4 + HALF*EX4)) / EX5 E, % Fluid vars, from INT and INTPROD: INDET, EX1, EX2, EX3, EX4 % WHEN FREE (EX7:DIF(EX6,INDET), INDET), EX2 * EX4^(INDET-EX6/EX7) * (EX3*EX5*LN(EX4) + EX7*SIN(EX6)) / ((EX5*LN(EX4))^2 + EX7^2) EXIT, ENDFUN $ PROPERTY INTEXPTMS, SINs from INT1 & property "INT^": EX1, EX2, EX3 % WHEN EX5 EQ #E, WHEN POSITIVE(EX3), WHEN FREE (EX5:DIF(EX4,INDET), INDET), EX1*EX4/EX5 - EX3*INT1(EX2^(EX3-1)) EXIT EXIT EXIT, ENDFUN $ PROPERTY INTEXPTMS, COS, FUNCTION (EX6,EX7)% File INTMORE.INT (c) 08/26/80 The Soft Warehouse % FUNCTION DEFINT (EX1, EX2, EX3, EX4, % Local: % EX5), WHEN FREE (EX5:INT(EX1,EX2), 'INT), WHEN INTEGER(#LIM), WHEN POSITIVE(SIGN(EX4-EX3)), LIM(EX5,EX2,EX4,TRUE) - LIM(EX5+1) EXIT, WHEN POSITIVE (EX5), EVSUB (INT1(EXPAND(((INDET-EX4)/EX7)^EX5*LN(INDET))), INDET, EX6) / EX7 EXIT EXIT EXIT, ENDFUN $ PROPERTY INTMONTMS, ^, FUNCTION (EX6, EX7, EX8, EX9), % Fluid vars from INT, INT1, & INTPROXIT, WHEN NEGATIVE(EX3), ((EX3+2)*INT1(EX2^(EX3+2)) - SIN(EX4)*EX2^(EX3+1)/EX5) / (EX3+1) EXIT EXIT, ENDFUN $ PROPERTY INTPWR, SIN, FUNCTION (EX4), % Fluid vars from property "INT^": EX2, EX3, EX5 % WHEN FREE (EX5:DIF(EX4,I, FUNCTION (EX6, EX7), % Fluid vars, from INT and INTPROD: INDET, EX1, EX2, EX3, EX4 % WHEN FREE (EX7:DIF(EX6,INDET), INDET), EX2 * EX4^(INDET-EX6/EX7) * (EX3*EX5*LN(EX4) - EX7*COS(EX6)) / ((EX5*LN(EX4))^2 + EX7^2) EXIT, ENDFUN $ PR1: EX1 % WHEN FREE (EX3:DIF(EX2,INDET), INDET), (EX1*EX2 + (1-EX2^2)^HALF) / EX3 EXIT, ENDFUN $ PROPERTY INT, ATAN, FUNCTION (EX2, % Local: % EX3), % Fluid var from INT1: EX1 % WHEN FREE (EX3:DIF(EX2,INDET), INDET), (EX1*EX2 -5,EX2,EX3) EXIT, LIM(EX5,EX2,EX4) - LIM(EX5,EX2,EX3,TRUE) EXIT, EVSUB(EX5,EX2,EX4) - EVSUB(EX5,EX2,EX3) EXIT, LIST ('DEFINT, EX1, EX2, EX3, EX4), ENDFUN $ PROPERTY INT, ASIN, FUNCTION (EX2, % Local: % EX3), % Fluid var from INTEGATIVE (EX6), -(EX7-EX4*INDET)^(1+EX6+EX8) * EVSUB (INT1( (INDET-EX4)^(-2-EX6-EX8)*INDET^EX8), INDET, EX7/INDET) EXIT EXIT, WHEN FREE (EX5:DIF(EX4,INDET), INDET), EX9: EX4 - EX5*INDET, WHEN NEGATIVE (EX6), WHEN NEGATIVE (EX6), WHEN NEGATIVE(EX5), ((EX5+EX6+2)*INT1(SECOND(EX2)^(EX6+2)*EX3) + SECOND(EX2)^(EX6+1)*SECOND(EX3)^(EX5+1)/EX4) / (EX6+1) EXIT EXIT EXIT EXIT EXIT EXIT, ENDFUN $ STN FREE (EX4:DIF(EX6,INDET), INDET), EVSUB (INT1(EXPAND((INDET+INDET*EX4-EX6)^EX5*SIN(INDET))), INDET, EX6) / EX4^(EX5+1) EXIT EXIT, ENDFUN $ PROPERTY INTPWRTMS, SIN, FUNCTION (EX6, EX7), % Fluid vars from INT & INTPROD: EX2, EX3, EWHEN ZERO (EX6+1+2*EX8), WHEN EX6 EQ 1, (LN(EX7) - EX9*INT1(EX3)) / EX5 EXIT EXIT, 2 * (INDET^(EX6-1)*EX7^(EX8+1) + (1-EX6)*(EX7-HALF*INDET*(EX4+EX9)) * INT1(INDET^(EX6-2)*EX3) - (EX6+EX8)* / (EX5+EX6) EXIT, WHEN NEGATIVE (EX5), ((EX6-1)*INT1(SECOND(EX2)^(EX6-2)*SECOND(EX3)^(EX5+2)) - SECOND(EX2)^(EX6-1)*SECOND(EX3)^(EX5+1)/EX4) / (EX5+1) EXIT EXIT, WHEROD: EX2, EX4, INDET % WHEN POSITIVE (EX5), WHEN EX6 = INDET, EX2*SIN(EX6) - EX5*INT1(EX2/INDET*SIN(EX6)) EXIT, WHEN FREE (EX4:DIF(EX6,INDET), INDET), EVSUB (INT1(EXPAND((INDET+INDET*EX4-EX6)^EX5*COS(INDET))), INDET, EX WHEN EX6 EQ -1, WHEN EX8 EQ -1, (LN(INDET^2*EX3) - EX9*INT1(EX3)) / (2*EX7 - INDET*(EX4+EX9)) EXIT, (EX7^(EX8+1)/(EX8+1) - EX9*INT1(EX3) + 2*INT1(EX2*EX7^(EX8+1))) / (2*EX7-INDET*(EX4+INT1(EX2*SECOND(EX3)^(EX5-2)) + SECOND(EX2)^(EX6+1)*SECOND(EX3)^(EX5-1)/EX4) / (EX5+EX6) EXIT, WHEN NEGATIVE(EX6), (SECOND(EX2)^(EX6+1)*SECOND(EX3)^(EX5-1)/EX4 + (EX5-1)*INT1(SECX4, EX5, INDET % WHEN POWER(EX3), WHEN FIRST(SECOND(EX3)) EQ 'COS, WHEN SECOND(SECOND(EX3))=EX7, WHEN FREE (EX4:DIF(EX7,INDET), INDET), WHEN POSITIVE (EX5:THIRD(EX3)), WHEN EX6 EQ -1, ((EX5-1)*EX9*INT1(INDET^(EX6-1)*EX3)) / EX5 / (EX6 + 2*EX8 + 1) EXIT EXIT EXIT, WHEN FREE (EX7,INDET), WHEN POSITIVE(EX6), WHEN FREE (EX4:DIF(EX8,INDET), INDET), (EX1 - EX6*INT1(EX1/INDET)) / EX4 / LN(EX7) EXIT EXIT EXIT, WHEN EX6 EQ -1, WHEN EX5 EQ -1, FALSE EXIT, WHEN NEGATIVE (EX5), ((EX5+EX6+2)*INT1(EX2*SECOND(EX3)^(EX5+2)) - SECOND(EX2)^(EX6+1)*SECOND(EX3)^(EX5+1)/EX4) / (EX5+1) EXIT EXIT, 6) / EX4^(EX5+1) EXIT EXIT, ENDFUN $ PROPERTY INTMONTMS, SIN, FUNCTION (EX5, EX6), % Fluid vars from INT & INTPROD: EX2, EX4, INDET % WHEN POSITIVE (EX5), WHEN EX6 = INDET, EX5*INT1(EX2/INDET*COS(EX6)) - EX2*COS(EX6) EXIT, WHEEX9)) EXIT, (2*(INDET^(EX6+1)*EX7^(EX8+1) - 2*(2+EX6+EX8)*EX9*INT1(INDET^(EX6+1)*EX3)) - EX5*(3+EX6+2*EX8)*INT1(INDET^(EX6+2)*EX3)) / (EX6+1) / (2*EX7 - INDET*(EX4+EX9)) EXIT, WHEN POSITIVE (EX6), OND(EX2)^(EX6+2)*SECOND(EX3)^(EX5-2))) / (EX6+1) EXIT EXIT, WHEN POSITIVE (EX6), WHEN EX5 EQ -1, ((EX6-1)*INT1(SECOND(EX2)^(EX6-2)*EX3) - SECOND(EX2)^(EX6-1)*SECOND(EX3)^(EX5+1)/EX4) EVSUB (INT1((INDET-SECOND(EX7)+EX5*INDET)^EX6 * LN(INDET)^EX8), INDET, SECOND(EX7)) / EX5^(EX6+1) EXIT EXIT EXIT EXIT EXIT, ENDFUN $ PROPERTY INTMONTMS, COS, FUNCTION (EX5, EX6), % Fluid vars from INT & INTPN POSITIVE (EX8), WHEN LOGARITHM (EX7), WHEN THIRD(EX7) EQ #E, WHEN SECOND(EX7) = INDET, (INDET*EX1 - EX8*INT1(EX1/EX7)) / (EX6+1) EXIT, WHEN FREE (EX5:DIF(SECOND(EX7),INDET), INDET), WHEN POSITIVE(EX6),OP $ RDS () $ OP(LEX1), WHEN DENOM (EX1) AND NEGATIVE (DENNUM) AND DENNUM (EX1^-1), ADJOIN (EX1, CONTENT1 (EX2, LEX2, LEX1)) EXIT,OCK, WHEN EX2 EQ PINF, LIM1 (EVSUB(EX1,INDET,1/INDET), #LIM) EXIT, WHEN EX2 EQ MINF, LIM1 (EVSUB(EX1,INDET,-1/INDET), #LIM) EXIT, WHEN EX3, LIM1 (EVSUB(EX1,INDET,EX2-INDET), #LIM) EXIT, LIM1 (EVSUB(EX1,INDET,EX2+INDET), #LIM), ENDFUN $ s "), PRTMATH(EX1,0,0,TRUE), SPACES(3), LEX2: LEX1, LOOP WHEN ATOM(REST(LEX2)), PRINT("or "), PRTMATH(FIRST(LEX2),0,0,TRUE), PRINT("; ? ") EXIT, PRTMATH(POP(LEX2),0,0,TRUE), PRINT("; "), ENDLOOP, WHEN M LIM: INDET % WHEN EX1=INDET, PZERO EXIT, WHEN ATOM(EX1), EX1 EXIT, WHEN APPLY (GET('LIM,FIRST(EX1)), ARGEX(EX1)), EXIT, LIST ('LIM, EX1, INDET, 0), ENDFUN $ FUNCTION LIM (EX1, % Optional: % INDET, EX2, EX3, % Local: % LOGBAS, PWREXP-1 EXIT, WHEN EX1 EQ PINF, 1 EXIT, WHEN EX1 EQ MINF, -1 EXIT, WHEN EX1 = PINF-MINF, 1 EXIT, QUERY (LIST ('SIGN, EX1), M101), ENDFUN $ FUNCTION ODDEVEN(EX1), WHEN NUMBER(EX1), WHEN INTEGER(EX1), WHEN ZERO(MOD(EX1,2)), EVENEMBER (LEX2:PARSE(SCAN(),0), LEX1), PUSH (ADJOIN (ADJOIN(EX1,LEX1), LEX2), QUERY), LEX2 EXIT, ENDLOOP, ENDFUN $ M101: LIST (-1, 0, 1) $ FUNCTION SIGN(EX1), WHEN ZERO(EX1), EX1 EXIT, WHEN EX1 > 0, 1 EXIT, WHEN EX1 < 0, % File: TAYLOR.DIF (c) 10/01/80 The Soft Warehouse % FUNCTION TAYLOR (EXPN, X, A, N, % Local % J, C, ANS, NUMNUM, DENNUM), NUMNUM: DENNUM: 30, J: ANS: 0, C: 1, LOOP ANS: ANS + C * EVSUB (EXPN, X, A), WHEN J=N, ANS EXIT, D, NUMNUM, DENDEN, DENNUM, NUMDEN, BASEXP, EXPBAS, LOGEXPD, TRGEXPD, QUERY), LOGBAS: #E, PWREXPD: NUMDEN: 0, NUMNUM: DENDEN: EXPBAS: 30, DENNUM: BASEXP: -30, LOGEXPD: 70, TRGEXPD: 2, BLOCK WHEN EX2, EXIT, EX2: 0 ENDBL% File LIM.DIF (c) 08/29/80 The Soft Warehouse % FUNCTION QUERY (EX1, LEX1, % Local: % LEX2), % Uses fluid var QUERY to hold previous questions & answers % WHEN LEX2: ASSOC(ADJOIN(EX1,LEX1),QUERY), REST(LEX2) EXIT, LOOP PRINT(" I EXIT, ODD EXIT, NONINTEGER EXIT, QUERY (EX1, '(ODD EVEN NONINTEGER)), ENDFUN $ FUNCTION SIZE (EX1), WHEN ATOM(EX1), 1 EXIT, SIZE(POP(EX1)) + SIZE(EX1), ENDFUN $ #LIM: 3 $ FUNCTION LIM1 (EX1, #LIM), % Fluid var from EXPN: DIF (EXPN, X), J: J + 1 C: C * (X-A) / J, ENDLOOP, ENDFUN $ STOP $ RDS () $  FUNCTION INDET (EX1, EX2, % Local: % EX3), % Fluid vars from LIM & LIM1: #LIM, INDET % WHEN ZERO(#LIM), LIST ('LIM, EX1*EX2, INDET, 0) EXIT, WHEN ATOM (EX3:DIF(EX1,INDET)/DIF(1/EX2,INDET)), LIM1 (EX3, #LIM-1) EXIT, WHEN SIZE (EX1:D)), CINF EXIT, WHEN MEMBER (EX1, '(PINF PZERO)), EX1 EXIT, WHEN EX1 EQ MZERO, 0 EXIT, WHEN EX1 EQ #E OR POSITIVE(EX2:SIGN(EX1-1)), PINF EXIT, WHEN ZERO(EX2), 1 EXIT, WHEN POSITIVE(EX2:SIGN(EX1)), PZERO EXIT WHEN ZERO(EXEQ ?, ? EXIT, WHEN MEMBER (EX6, '(CINF PINF PZERO MZERO MINF)), EX5: SIGN(EX4), WHEN EX6 EQ CINF, WHEN ZERO(EX5), ? EXIT, CINF EXIT, WHEN EX6 EQ PINF, WHEN POSITIVE(EX5), PINF EXIT, EX5 EXIT, WHEN EX5 EQ PZERO, WHEN EX4 EQ MZERO, 0 EXIT, WHEN EX4, EXIT, PZERO EXIT, WHEN EX5 EQ MZERO, WHEN EX4 EQ PZERO, 0 EXIT, WHEN EX4, EXIT, MZERO EXIT, WHEN MEMBER ( EX2: EX2*FIRST(EX1), EX5:-EX5 EXIT, WHEN ZERO(EX6), EX3: EX3*FIRST(EX1), EX5:0 EXIT, EX4: EX4*EX6 ENDBLOCK ENDLOOP, ENDFUN $ PROPERTY LIM, ^, FUNCTION (EX1, EX2), % Fluid vars from LIM & LIM1: #LIM, INDET % WHEN (EX1:LIMFUNCTION ( % Local: % EX2, EX3, EX4, EX5, EX6), % Fluid from LIM & LIM1: EX1, #LIM, INDET % EX2: EX3: EX4: EX5: 1, LOOP WHEN ATOM (EX1:REST(EX1)), WHEN EX2 EQ 1, WHEN EX3 EQ 1, EX4 EXIT, WHEN POSITIVE (EX5:EX5*SIIF(EX2,INDET)/DIF(1/EX1,INDET)) < SIZE(EX3), LIM1 (EX1, #LIM-1) EXIT, LIM1 (EX3, #LIM-1), ENDFUN $ PROPERTY LIM, +, FUNCTION ( % Local: % EX2, EX3, EX4, EX5, DENNUM), % Fluid vars from LIM & LIM1: EX1, #LIM, INDET % DENNUM: -30, ZERO EXIT, WHEN NEGATIVE(EX5), PZERO EXIT, 0 EXIT, WHEN POSITIVE(EX5), MINF EXIT, WHEN NEGATIVE(EX5), PINF EXIT, ? EXIT, EX4*EX6 EXIT, WHEN (EX6:LIM1(FIRST(EX1),#LIM)) EQ ?, ? EXIT, B WHEN NEGATIVE(EX5), MINF EXIT, ? EXIT, WHEN EX6 EQ PZERO, WHEN POSITIVE(EX5), PZERO EXIT, WHEN NEGATIVE(EX5), MZERO EXIT, 0 EXIT, WHEN EX6 EQ MZERO, WHEN POSITIVE(EX5), MEX4, '(FALSE PZERO MZERO)), EX5 EXIT, DENNUM: -30, EX4+EX5 EXIT, WHEN (EX5:LIM1(FIRST(EX1),#LIM)) EQ ? OR EX4 EQ CINF AND MEMBER(EX5,'(CINF,PINF,MINF)) OR EX5 EQ CINF AND NOT(ZERO(EX2) AND ZERO(EX3)), ? EXIT, B1(EX1,#LIM)) EQ 1, 1 EXIT, WHEN EX1 EQ ? OR MEMBER (EX2:LIM1(EX2,#LIM), '(? CINF)), ? EXIT, WHEN MEMBER (EX2, '(PZERO 0 MZERO)), WHEN MEMBER (EX1, '(PZERO 0 MZERO)), ? EXIT, 1 EXIT, WHEN EX2 EQ PINF, WHEN MEMBER (EX1, '(CINF MINFGN(EX4)), PZERO EXIT, WHEN NEGATIVE(EX5), MZERO EXIT, 0 EXIT, WHEN EX3 EQ 1, WHEN POSITIVE (EX5:EX5*SIGN(EX4)), PINF EXIT, WHEN NEGATIVE(EX5), MINF EXIT, CINF EXIT, WHEN (EX6:INDET(EX3,EX2)) EX2: EX3: 0, LOOP WHEN ATOM (EX1:REST(EX1)), WHEN ZERO(EX2), WHEN ZERO(EX3), EX4 EXIT, MINF EXIT, WHEN ZERO(EX3), PINF EXIT, DENNUM: 0, WHEN MEMBER (EX5:INDET(1+EX3/EX2,EX2), '(? PINF MINF)), LOCK WHEN EX6 EQ CINF, EX2: EX2*FIRST(EX1), EX5:0 EXIT, WHEN EX6 EQ PINF, EX2: EX2*FIRST(EX1) EXIT, WHEN EX6 EQ PZERO, EX3: EX3*FIRST(EX1) EXIT, WHEN EX6 EQ MZERO, EX3: EX3*FIRST(EX1), EX5:-EX5 EXIT, WHEN EX6 EQ MINF, PZERO, EX4:0 EXIT, WHEN NOT EX4, EX4:MZERO EXIT EXIT, WHEN EX5 EQ MINF, EX3: EX3+FIRST(EX1) EXIT, WHEN MEMBER(EX4,'(FALSE PZERO MZERO)), EX4:EX5 EXIT, EX4: EX4+EX5 ENDBLOCK ENDLOOP, ENDFUN $ PROPERTY LIM, *, LOCK WHEN EX5 EQ CINF, EX4:CINF EXIT, WHEN EX5 EQ PINF, EX2: EX2+FIRST(EX1) EXIT, WHEN EX5 EQ PZERO, WHEN EX4 EQ MZERO, EX4:0 EXIT, WHEN NOT EX4, EX4:PZERO EXIT EXIT, WHEN EX5 EQ MZERO, WHEN EX4 EQ2), 0 EXIT, WHEN POSITIVE (EX2:SIGN(EX1+1)), 0 EXIT, WHEN NEGATIVE(EX2), CINF EXIT, ? EXIT, WHEN EX2 EQ MINF, WHEN EX1 EQ PZERO, PINF EXIT, WHEN EX1 EQ MZERO, CINF EXIT, WHEN MEMBER (EX1, '(CINF MINF)), 0 EXIT, WH comment which has not yet been terminated. Comments do not cause computation; they are merely used to explain programs and examples to human readers. Here is an example of an actual computation% 1/2 + 1/6 ; % Note how muMATH uses exact rT, WHEN EX1 EQ PINF OR EX1 EQ MINF, ? EXIT, ASIN(EX1), ENDFUN $ PROPERTY LIM, ATAN, FUNCTION (EX1), WHEN (EX1:LIM1(EX1,#LIM)) EQ PINF, #PI/2 EXIT, WHEN EX1 EQ MINF, -#PI/2 EXIT, WHEN EX1 EQ CINF, ? EXIT, WHEN MEMBER (EX1, '(? PZEXIT, WHEN EX1 EQ PZERO, WHEN POSITIVE (EX2:SIGN(EX2)), PZERO EXIT, WHEN NEGATIVE(EX2), PINF EXIT, ? EXIT, WHEN EX1 EQ MZERO, WHEN POSITIVE(EX1:SIGN(EX2)), WHEN (EX2:ODDEVEN(EX2)) EQ EVEN, PZERO EXIT, WHEN EX2 EQ while depressing the CTRL key). Then type it again when you are ready to resume. It is advisable to read sections 4 through 6 and 8 of the muMATH Reference Manual before beginning these lessons. This lesson can be aborted at any tim WHEN MEMBER (EX1:LIM(EX1,#LIM), '(? PZERO PINF)), EX1 EXIT, WHEN EX1 EQ MINF OR EX1 EQ MZERO, ? EXIT, EX1 !, ENDFUN $ PROPERTY LIM, LOG, FUNCTION (EX1 % Local: % EX2), WHEN (EX1:LIM1(EX1,#LIM)) EQ PZERO, MINF EXIT, WHEN EX1 EQ PINEN EX1 EQ PINF OR EX1 EQ #E OR POSITIVE(EX2:SIGN(EX1-1)), PZERO EXIT, WHEN ZERO(EX2), 1 EXIT, WHEN POSITIVE (EX2:SIGN(EX1)), PINF EXIT, WHEN ZERO(EX2), CINF EXIT, WHEN NEGATIVE (EX2:SIGN(EX1+1)), 0 EXIT, WHEN POSITIVE(EX2), CINEX1), WHEN MEMBER (EX1:LIM1(EX1,#LIM), '(? CINF PINF MINF)), ? EXIT, WHEN MEMBER (EX1, '(PZERO, MZERO)), 1 EXIT, COS(EX1), ENDFUN $ STOP $ RDS() $ RO MZERO)), EX1 EXIT, ATAN(EX1), ENDFUN $ PROPERTY LIM, SIN, FUNCTION (EX1), WHEN MEMBER (EX1:LIM1(EX1,#LIM), '(? CINF PINF MINF)), ? EXIT, WHEN MEMBER (EX1, '(PZERO, MZERO)), EX1 EXIT, SIN(EX1), ENDFUN$ PROPERTY LIM, COS, FUNCTION (ODD, MZERO EXIT, 0 EXIT, WHEN NEGATIVE(EX1), WHEN (EX2:ODDEVEN(EX2)) EQ EVEN, PINF EXIT, WHEN EX2 EQ ODD, MINF EXIT, CINF EXIT, ? EXIT, WHEN EX1 EQ MINF, WHEN POSITIVE (EX1:SIGN(EX2)), WHEN (EX2:ODe by typing the ESCape key or the ALTmode key on your console followed by a CTRL-C. In muMATH a "comment" is a percent sign followed by any number of other characters terminated by a matching percent sign. Thus, this explanation is aF, PINF EXIT, WHEN MEMBER (EX1, '(CINF MZERO MINF)) OR ZERO(EX2:SIGN(EX1)), CINF EXIT, WHEN NEGATIVE(EX2), ? EXIT, LN(EX1), ENDFUN $ PROPERTY LIM, ASIN, FUNCTION (EX1), WHEN MEMBER (EX1:LIM1(EX1,#LIM), '(? PZERO MZERO)), EX1 EXIF EXIT, ? EXIT, WHEN EX1 EQ CINF, WHEN POSITIVE (EX2:SIGN(EX2)), CINF EXIT, WHEN NEGATIVE(EX2), 0 EXIT, 1 EXIT, WHEN EX1 EQ PINF, WHEN POSITIVE (EX2:SIGN(EX2)), PINF EXIT, WHEN NEGATIVE(EX2), PZERO EXIT, 1 E%File: CLES1.ARI (c) 08/10/80 The Soft Warehouse % LINELENGTH (78)$ #ECHO: ECHO$ ECHO: TRUE$ % If this lesson is being displayed too fast, it can be temporarily stopped by typing a CTRL-S (i.e. typing the letter "S" WHEN POSITIVE(EX1:SIGN(EX2)), WHEN ODDEVEN(EX2) EQ EVEN, PZERO EXIT, 0 EXIT, WHEN NEGATIVE(EX1), WHEN ODDEVEN(EX2) EQ EVEN, PINF EXIT, CINF EXIT, ? EXIT, EX1^EX2, ENDFUN $ PROPERTY LIM, !, FUNCTION (EX1),DEVEN(EX2)) EQ EVEN, PINF EXIT, WHEN EX2 EQ ODD, MINF EXIT, CINF EXIT, WHEN NEGATIVE(EX1), WHEN (EX2:ODDEVEN(EX2)) EQ EVEN, PZERO EXIT, WHEN EX2 EQ ODD, MZERO EXIT, 0 EXIT, 1 EXIT, WHEN ZERO(EX1), ational arithmetic, reducing fractions to lowest terms. In muMATH, arithmetic expressions can be formed in the usual manner, using parentheses together with the operators "+", "-", "*", "/", and "^" respectively for addition,next input expression. The colon ASSIGNMENT operator provides a means of doing so. The name on the left side of the assignment operator is BOUND or SET to the value of the expression on its right. This value is saved as the value of tatically saved as the value of a variable named "@", which can be used in the next expression. For example: % 3 ;@ ^ @ ;@ ^ @; % As this example illustrates, muMATH can treat very large numbers exactly and quickly. In fact, muMATH caion crosses distinct from the letter X. To prevent certain ambiguities, multiplication cannot be implied by mere juxtaposition. One of the most frequent mistakes of beginners is to omit asterisks. Later, in order to give you an usted!) Often one performs an intermediate computation or a trivial assignment for which there is no need to display the result. When this is the case, the display of the result can be suppressed by using a dollar sign rather te containing a "grammatical" or "syntax" error such as "(;". Now we are going to turn control over to you by setting RDS to FALSE. Try some examples of your own similar to the above. Also we suggest that you make a few inte subtraction or negation, multiplication, division, and raising to a power. For example: % (3*4 - 5) ^ 2 ; % On some terminals, "^" looks like an upward-pointing arrow; on others it looks like a shallow upside-down letter V; and somen centimeters without starting all over. (In case you forgot, the speed of light is 186,000 miles/second or 300,000,000 meters/second.) % RDS: FALSE ; % Our answers are about 123,883,499,520,000,000 feet or 1,486,601,994,240,000n accomodate numbers up to about 611 digits. To partially appreciate how large this is, compute the distance in feet or in meters to the star Alpha Centauri, which is 4 light years away, then use "@" to compute the distance in inches or iopportunity to try some examples, we will "assign" the value FALSE to the variable named RDS. When you are ready to resume the lesson, type the "assignment" RDS: TRUE ; including the semicolon and carriage return. This revises the vahan a semicolon as a terminator. For example, type RDS: TRUE $ and note the difference from when you previously typed RDS:TRUE ; % RDS: FALSE $ % It is often convenient to save values longer than "@" saves them, for use beyond the ntional errors in order to become familiar with how they are treated. For example, try 5 7; 5+ /7; 5/0; and 0/0; Have fun!: % RDS: FALSE ; % The value resulting from the last input expression is autom terminals may employ an utterly different looking character which you may have to determine by experimentation. The reason for using ^ and * is that standard terminals do not provide superscripts or centered dots or special multiplicat,000 inches or 37,843,200,000,000,000 meters or 3,784,320,000,000,000,000 centimeters. Another dramatic comparison with 10^611 is that there are thought to be about 10^72 electrons in the entire universe. (Whoever counted them must be exhamarked RUBout or DELete cancels the last character typed on the line, and typing a CTRL-U cancels the current line. There is no way to modify a line after striking the RETurn key, but an expression can always be flushed by typing a final linlue of the variable named RDS to the value TRUE. We will explain assignment in more detail later. Don't forget that you can use local editing to correct mistypings on the current line. For example, on many operating systems, the key he name until the name is bound subsequently to some other value. The name can be used as a variable in subsequent expressions, as we have used "@", in which case the name contributes its value to the expression. For example: % RATE: 55 $ % Why don't you now see what ninety-nine raised to the ninety-nine power looks like in base two and in base thirty-six, then return to base ten: % RDS: FALSE $ % As you may have discovered, it is easy to become confused and have a hard the muMATH files through ARITH.MUS have been loaded. For positive integer N, N factorial is the product of the first N integers. The "postfix" factorial operator is "!", which returns the factorial of its operand. For example, 3! ythe number of seconds in 1 day and 1 week: % RDS: FALSE $ % Congratulations on completing CLES1.ARI. To execute the next lesson, merely enter the muMATH command RDS (CLES2, ARI, drive); where drive is the name of the drive on whi in base sixteen: % RADIX (20) ; THIRTY ; % As you can see, the letters A, B, ... are used to represent the digits ten, eleven, ... for bases exceeding ten. Now can you guess why we limit the base to thirty six? In input expressi TIME: 2 $ DISTANCE: RATE * TIME ; % Alphabetic characters include the letters A through Z, both upper and lower case, and the character "#". Note that the upper and lower case version of a letter are entirely distinct. Names can be through thirty-six. For example, to see what thirty looks like in base two: % THIRTY: 30 $ RADIX (2) ; THIRTY ; % As you can see, the radix function returns the previous base, which is, of course, displayed in the new number base. This infields 6, which is 1*2*3. Use this operator to determine the product of the first 100 integers: % RDS: FALSE $ % The number base used for input and output is initially ten, but the RADIX function can be used to change it to any base from two ch that lesson is mounted. Alternatively, it may be advisable to repeat this lesson, perhaps another day, if this lesson was not perfectly clear. The use of any computer program tends to become much clearer the second time. In ons, integers beginning with a letter as the most significant digit must begin with a leading zero so as not to be interpreted as a name. For example, in base sixteen, ten is the letter- digit A, so to return to base ten: % RADIX (0A) ; %File: CLES2.ARI (c) 08/10/80 The Soft Warehouse % LINELENGTH (78)$ #ECHO: ECHO$ ECHO: TRUE$ % This file is the second of a sequence of interactive lessons on how to use the muMATH symbolic math system. This lesson presumes thatany sequence of alphabetic characters or digits, provided the first character is alphabetic. Thus X, #9, and ABC3 are valid names. Make an assignment of 3600 to a variable named SECPERHOUR, then use this variable to help compute oration helps to get back to a previous base. In base two, eight is written as 1000, so to see what thirty looks like in base eight: % RADIX (1000) ; THIRTY ; % In base eight, sixteen is written as 20, so to see what thirty looks likeere. Also, you are encouraged to experiment further with the techniques learned in this lesson: % ECHO: #ECHO $ RDS () $ order to experience the decisive learning reinforcement afforded by meaningful personal examples that are not arbitrarily contrived, we urge you to bring to subsequent lessons appropriate examples from textbooks, tables, articles, or elsewhtime returning to base ten. Two is represented as 2 in any base exceeding 1, so a foolproof way to get from any base to any other is to first get to base two, then express the desired new base in base two. For example: % RADIX (2) ; RADIXl computation, picking a branch of a multiply-branched function is hazardous, so answers thereby obtained should be verified by substitution into the original problem or by physical reasoning. For this reason, there is a CONTROL VARIABLE named ) ; 1000 ^ (1/2) ; % Try simplifying the square roots of increasingly large integers to gain a feel for how the computation time increases with the complexity of the input and answer: % RDS: FALSE $ % An input of the form (m/n)^(p/q) i but want to learn how to program using muSIMP, then proceed to lesson PLES1.ARI. % ECHO: #ECHO$ PBRCH: TRUE$ RDS () $  (-1)^(1/2), and expresses the answer in terms of #I, using the branch having smallest positive argument. For example: % (-4) ^ (1/2) ; % Decent simplification of expressions containing imaginary numbers, as described in lesson CLES4. (1010) ; % Now we are guaranteeably in base ten, no matter how badly you got lost. Now consider irrational arithmetic: Did you know that (5 + 2*6^(1/2))^(1/2) - 2^(1/2) - (3/2)^(1/2) can be simplified to 0, provided wee end of CLES2.ARI. Though arithmetic, some of the features illustrated in this lesson may be foreign to you, because sometimes they are taught during algebra rather than before. Thus, if you have any algebra background whatsoever, we urge yoPBRCH, initially TRUE, which suppresses Picking a BRanCH if FALSE. For example: % PBRCH: FALSE $ 4 ^ (1/2); % Users having a conservative temperament might prefer to do most of their computation with PBRCH FALSE. This brings us to ths treated in the usual manner as (m^(1/q))^p / (n^(1/q))^p . For example: % (4/9) ^ (3/2) ; % For geometrically similar people, surface area increases as the 2/3 power of the mass. Veronica wears a 1 square-meter bikini, and she is 50,6ALG, requires that file ALGEBRA.ARI be loaded. Meanwhile if you believe in imaginary numbers and you can't contain your curiosity, why don't you experiment with them to see what muMATH knows about them: % RDS: FALSE $ % As with manua make certain reasonable choices of branches for the square roots? In general, simplification of arithmetic expressions containing fractional powers is quite difficult, but muMATH makes a valiant attempt. For example: % 4 ^ (1/2) ; 12 ^ (1/2u to proceed to lesson CLES3.ALG even if some of CLES2.ARI was intimidating. Naturally, as implied by its type, file CLES3.ALG requires a muMATH system containing files through ALGEBRA.ARI. If you decide not to proceed to algebra,s. Otherwise, muMATH picks the negative real branch if one exists, as illustrated by the example: % (-8) ^ (1/3) ; % What if no real branch exits? Then muMATH uses the unbound variable named #I to represent the IMAGINARY number 53 grams, whereas her look-alike mother is 132,651 grams. Use muMATH to determine the area of her mother's similar bikini: % RDS: FALSE $ % 4^(1/2) could simplify to either -2 or +2, but muMATH picks the positive real branch if one exist