home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / bigcalc / bigmisc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-02-04  |  65.2 KB  |  2,191 lines
  1. /*
  2.  *    **************************************************
  3.  *    *                                                *
  4.  *    *                   BIGMISC.C                    *
  5.  *    *                                                *
  6.  *    *          Extended Precision Calculator         *
  7.  *    *                                                *
  8.  *    *        Extended Precision Misc Routines        *
  9.  *    *                                                *
  10.  *    *              Version 4.3 02-04-89              *
  11.  *    *                                                *
  12.  *    *              Judson D. McClendon               *
  13.  *    *              329 37th Court N.E.               *
  14.  *    *              Birmingham, AL 35215              *
  15.  *    *                 205-853-8440                   *
  16.  *    *            Compuserve [74415,1003]             *
  17.  *    *                                                *
  18.  *    **************************************************
  19.  */
  20.  
  21.  
  22.  
  23. /*
  24.  *    **************************************************
  25.  *    *                                                *
  26.  *    *                   Includes                     *
  27.  *    *                                                *
  28.  *    **************************************************
  29.  */
  30.  
  31. #include <ctype.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  35. #include "bigcalc.h"
  36. #include "biggvar.h"
  37.  
  38.  
  39.  
  40. /*
  41.  *    **************************************************
  42.  *    *                                                *
  43.  *    *             Source Local Variables             *
  44.  *    *                                                *
  45.  *    **************************************************
  46.  */
  47.  
  48.                      /* pi to 1100 digits */
  49.  
  50. static char far piA[] = {   /* digits 1 - 500 */         /* Max string 512 */
  51.    "31415926535897932384626433832795028841971693993751"
  52.    "05820974944592307816406286208998628034825342117067"
  53.    "98214808651328230664709384460955058223172535940812"
  54.    "84811174502841027019385211055596446229489549303819"
  55.    "64428810975665933446128475648233786783165271201909"
  56.    "14564856692346034861045432664821339360726024914127"
  57.    "37245870066063155881748815209209628292540917153643"
  58.    "67892590360011330530548820466521384146951941511609"
  59.    "43305727036575959195309218611738193261179310511854"
  60.    "80744623799627495673518857527248912279381830119491"};
  61.  
  62. static char far piB[] = {   /* digits 501 - 1000 */
  63.    "29833673362440656643086021394946395224737190702179"
  64.    "86094370277053921717629317675238467481846766940513"
  65.    "20005681271452635608277857713427577896091736371787"
  66.    "21468440901224953430146549585371050792279689258923"
  67.    "54201995611212902196086403441815981362977477130996"
  68.    "05187072113499999983729780499510597317328160963185"
  69.    "95024459455346908302642522308253344685035261931188"
  70.    "17101000313783875288658753320838142061717766914730"
  71.    "35982534904287554687311595628638823537875937519577"
  72.    "81857780532171226806613001927876611195909216420198"};
  73.  
  74. static char far piC[] = {   /* digits 1001 - 1100 */
  75.    "93809525720106548586327886593615338182796823030195"
  76.    "20353018529689957736225994138912497217752834791315"};
  77.  
  78.  
  79.                      /* pi/2 to 1100 digits */
  80.  
  81. static char far halfpiA[] = {   /* digits 1 - 500 */         /* Max string 512 */
  82.    "15707963267948966192313216916397514420985846996875"
  83.    "52910487472296153908203143104499314017412671058533"
  84.    "99107404325664115332354692230477529111586267970406"
  85.    "42405587251420513509692605527798223114744774651909"
  86.    "82214405487832966723064237824116893391582635600954"
  87.    "57282428346173017430522716332410669680363012457063"
  88.    "68622935033031577940874407604604814146270458576821"
  89.    "83946295180005665265274410233260692073475970755804"
  90.    "71652863518287979597654609305869096630589655255927"
  91.    "40372311899813747836759428763624456139690915059745"};
  92.  
  93. static char far halfpiB[] = {   /* digits 501 - 1000 */
  94.    "64916836681220328321543010697473197612368595351089"
  95.    "93047185138526960858814658837619233740923383470256"
  96.    "60002840635726317804138928856713788948045868185893"
  97.    "60734220450612476715073274792685525396139844629461"
  98.    "77100997805606451098043201720907990681488738565498"
  99.    "02593536056749999991864890249755298658664080481592"
  100.    "97512229727673454151321261154126672342517630965594"
  101.    "08550500156891937644329376660419071030858883457365"
  102.    "17991267452143777343655797814319411768937968759788"
  103.    "90928890266085613403306500963938305597954608210099"};
  104.  
  105. static char far halfpiC[] = {   /* digits 1001 - 1100 */
  106.    "46904762860053274293163943296807669091398411515097"
  107.    "60176509264844978868112997069456248608876417395657"};
  108.  
  109.  
  110.                      /* e to 1100 digits */
  111.  
  112. static char far eA[] = {    /* digits 1 - 500 */         /* Max string 512 */
  113.    "27182818284590452353602874713526624977572470936999"
  114.    "59574966967627724076630353547594571382178525166427"
  115.    "42746639193200305992181741359662904357290033429526"
  116.    "05956307381323286279434907632338298807531952510190"
  117.    "11573834187930702154089149934884167509244761460668"
  118.    "08226480016847741185374234544243710753907774499206"
  119.    "95517027618386062613313845830007520449338265602976"
  120.    "06737113200709328709127443747047230696977209310141"
  121.    "69283681902551510865746377211125238978442505695369"
  122.    "67707854499699679468644549059879316368892300987931"};
  123.  
  124. static char far eB[] = {   /* digits 501 - 1000 */
  125.    "27736178215424999229576351482208269895193668033182"
  126.    "52886939849646510582093923982948879332036250944311"
  127.    "73012381970684161403970198376793206832823764648042"
  128.    "95311802328782509819455815301756717361332069811250"
  129.    "99618188159304169035159888851934580727386673858942"
  130.    "28792284998920868058257492796104841984443634632449"
  131.    "68487560233624827041978623209002160990235304369941"
  132.    "84914631409343173814364054625315209618369088870701"
  133.    "67683964243781405927145635490613031072085103837505"
  134.    "10115747704171898610687396965521267154688957035035"};
  135.  
  136. static char far eC[] = {   /* digits 1001 - 1100 */
  137.    "40212340784981933432106817012100562788023519303322"
  138.    "47450158539047304199577770935036604169973297250886"};
  139.  
  140.  
  141.                      /* LN(10) to 1100 digits */
  142.  
  143. static char far ln10A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  144.    "23025850929940456840179914546843642076011014886287"
  145.    "72976033327900967572609677352480235997205089598298"
  146.    "34196778404228624863340952546508280675666628736909"
  147.    "87816894829072083255546808437998948262331985283935"
  148.    "05308965377732628846163366222287698219886746543667"
  149.    "47440424327436515504893431493939147961940440022210"
  150.    "51017141748003688084012647080685567743216228355220"
  151.    "11480466371565912137345074785694768346361679210180"
  152.    "64450706480002775026849167465505868569356734206705"
  153.    "81136429224554405758925724208241314695689016758940"};
  154.  
  155. static char far ln10B[] = {   /* digits 501 - 1000 */
  156.    "25677631135691929203337658714166023010570308963457"
  157.    "20754403708474699401682692828084811842893148485249"
  158.    "48644871927809676271275775397027668605952496716674"
  159.    "18348570442250719796500471495105049221477656763693"
  160.    "86629769795221107182645497347726624257094293225827"
  161.    "98502585509785265383207606726317164309505995087807"
  162.    "52371033310119785754733154142180842754386359177811"
  163.    "70543098274823850456480190956102992918243182375253"
  164.    "57709750539565187697510374970888692180205189339507"
  165.    "23853920514463419726528728696511086257149219884997"};
  166.  
  167. static char far ln10C[] = {   /* digits 1001 - 1100 */
  168.    "87488737713456862091670584980782805975119385444500"
  169.    "99781311469159346662410718466923101075984383191912"};
  170.  
  171.  
  172.                      /* LN(.9) to 1100 digits */
  173.  
  174. static char far lnP9A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  175.    "10536051565782630122750098083931279830612037298327"
  176.    "40725639392336925840232401345464887656954621341207"
  177.    "66027725910370517148673517013221767114560683627564"
  178.    "22686827658166995879194648505249713751127872090836"
  179.    "46753735546903376623278648795935883395531953832230"
  180.    "68063737380570033668721271928105743343331765475507"
  181.    "94614944081705922413762841002849656667436259102470"
  182.    "59840699195837172323632818695878343286697490386837"
  183.    "56269027085852455278757515428887026870363009824690"
  184.    "11082327142665667835478506112527101842259460995695"};
  185.  
  186. static char far lnP9B[] = {   /* digits 501 - 1000 */
  187.    "66185808438491539044004722016071396991819933089951"
  188.    "36510263864323300038738939668220467371784191475929"
  189.    "86685982822084079834542016105247557309320878134190"
  190.    "59615756458273314793523644227532690264532100041464"
  191.    "72360147081252044683858538073749994146472651096247"
  192.    "19576543319107662533692362403955709410367009490530"
  193.    "49205022937133700879475429636102133797673326565200"
  194.    "43594103248874058499648816054367564578501968701015"
  195.    "94453148368584072225444462918836000317135394701735"
  196.    "06295442271581066406201751744099906980646330903331"};
  197.  
  198. static char far lnP9C[] = {   /* digits 1001 - 1100 */
  199.    "94652628495773704947302137898129247855523065676807"
  200.    "85754499445748903999957398542340330254289178206586"};
  201.  
  202.  
  203.                      /* LN(.99) to 1100 digits */
  204.  
  205. static char far lnP99A[] = {    /* digits 1 - 500 */     /* Max string 512 */
  206.    "10050335853501441183548857558547706085515007674629"
  207.    "87337869942552958300900425031364970819254909762769"
  208.    "32797840645187672598274733197087864758716686058619"
  209.    "00492707846971603671530739391724025806230580247206"
  210.    "17865164542756934233059819918112542243687424360292"
  211.    "94359501230410485470793917231588591444383104701161"
  212.    "20194111146550799330396389404157201875299396788203"
  213.    "91242742232546836953230479552424940087259011291507"
  214.    "11097329723568570319116949818306487594953146830538"
  215.    "58949466184487933084960707117093071364092020898927"};
  216.  
  217. static char far lnP99B[] = {   /* digits 501 - 1000 */
  218.    "46571581749210222077326391470369579846414072584662"
  219.    "70622135437767791553808614377634738280145680995701"
  220.    "14098531940607556356640812036549296319388571598176"
  221.    "34914522270033364757602563930318393165484920865699"
  222.    "57938163983079446395136128626914344078280087657471"
  223.    "70813368990741450398620050723168375717304208495706"
  224.    "12244300402114761596088119720156643590742443931854"
  225.    "51292371472186701728655428637782051386601321849323"
  226.    "40826115991832347875890716515729766415949966245448"
  227.    "45650342903775968860019267495936954354893354067924"};
  228.  
  229. static char far lnP99C[] = {   /* digits 1001 - 1100 */
  230.    "90160703930353459813638976965902058951405992684709"
  231.    "70214207155550604221069402972934195305038224526597"};
  232.  
  233.  
  234.                      /* LN(.999) to 1100 digits */
  235.  
  236. static char far lnP999A[] = {    /* digits 1 - 500 */    /* Max string 512 */
  237.    "10005003335835335001429822540683449607552052504344"
  238.    "09250988020797245202385869474688122817155429967880"
  239.    "18431263808948128734298441901290606033024442610348"
  240.    "67216410916952622895602909696647828915385026162729"
  241.    "90966857436107999633073875363731189280341360848092"
  242.    "42861809767373852152072711712258171935667719010311"
  243.    "98785227466688711970147707618953119200323582469506"
  244.    "80702121129678403553115532120870325308900430876320"
  245.    "36205135523160659495542184955853957659625541740971"
  246.    "16120644478003085119176624680867508202764157106383"};
  247.  
  248. static char far lnP999B[] = {   /* digits 501 - 1000 */
  249.    "85806603642277780720840689168603147843996398837817"
  250.    "74033196613802472806044088160895550885582268739289"
  251.    "46594689634546711578683599263658391173169865869075"
  252.    "50975886539322579431218324124582670086518357002365"
  253.    "98571467710848536080216559412771105222673205056669"
  254.    "27928455781691616659095238819620795448199291152372"
  255.    "05177936726180624823074512391052022279042533170246"
  256.    "35226700182848502595292825433935019822407282109016"
  257.    "63090431863480335220764664263842447084219339864518"
  258.    "00157591216447352592671370111115695904518548209425"};
  259.  
  260. static char far lnP999C[] = {   /* digits 1001 - 1100 */
  261.    "80038344213262124282867835305335884269597591230726"
  262.    "24180091824496360668174730633777881065863110897552"};
  263.  
  264.  
  265.                      /* LN(.9999) to 1100 digits */
  266.  
  267. static char far lnP9999A[] = {    /* digits 1 - 500 */   /* Max string 512 */
  268.    "10000500033335833533350001428696439683539773457107"
  269.    "55140898657627163447566114026170224959863374665287"
  270.    "54178890672282471756725796221085164623132615895337"
  271.    "63624630010418454030532657958553284926717668097503"
  272.    "66453704508673105225036878099574184881241574306996"
  273.    "02479139727577905513361598848420107930824747441437"
  274.    "54400830277810747707877495945779058901263690675134"
  275.    "98037695644449900901115316744551606509966123071296"
  276.    "88068855412833938665195041607396824594548669758181"
  277.    "47650673879414850807705004282597804431695048336440"};
  278.  
  279. static char far lnP9999B[] = {   /* digits 501 - 1000 */
  280.    "51341669719446708287045980753336064953371154124525"
  281.    "43969544144000509695980555748266241648312175993302"
  282.    "86004286961351471338434468807142558675846853433592"
  283.    "01133468589300135711332289741845605445324420769019"
  284.    "89660962248719449094195827815660278178392895843357"
  285.    "11749457489199186888625740989474588482868154035234"
  286.    "27611235084119816869945805045377327611916374688516"
  287.    "75793669600645841920312034875470307723048715146253"
  288.    "04916169286326959921025986124168216800441039763139"
  289.    "99052892492800418297405135618198065311253654270327"};
  290.  
  291. static char far lnP9999C[] = {   /* digits 1001 - 1100 */
  292.    "84547932637240272006485629251179632981627821688537"
  293.    "75442316425794682879847792138524769351974240715952"};
  294.  
  295.  
  296.                      /* LN(.99999) to 1100 digits */
  297.  
  298. static char far lnP99999A[] = {    /* digits 1 - 500 */  /* Max string 512 */
  299.    "10000050000333335833353333500001428583928682540682"
  300.    "54877353210755134469426136148636674376935861920829"
  301.    "41735142472586415616762000865651052083312464588495"
  302.    "54495151203930299334874604081394054793288978304832"
  303.    "92521621950356253006582459265972679520764316774273"
  304.    "22016519281453471095402151993532105172989789744976"
  305.    "22066402850096243627773688938481873580069130249068"
  306.    "29733169971932568868127449780969482064148415835627"
  307.    "37747483172270701211278092878513458138924701406988"
  308.    "52929332960599165101293873794775769729589078945746"};
  309.  
  310. static char far lnP99999B[] = {   /* digits 501 - 1000 */
  311.    "22419600304886879697329204816604909174563763403423"
  312.    "97441084700412699714514592514059896896548737860637"
  313.    "09985729928698697924025859747180251198268924078728"
  314.    "80474829830423420241822171568268742976929128204744"
  315.    "52944263357764317258624477956959906520290017627071"
  316.    "02008975585191243248194559453916515458753605714095"
  317.    "91073779167380196157384165762672909062692499458545"
  318.    "49690097410815917984692554283693231564346999225481"
  319.    "84027863823665494586561466897465546086698230819997"
  320.    "64609854924845515597109326152706205350599560259781"};
  321.  
  322. static char far lnP99999C[] = {   /* digits 1001 - 1100 */
  323.    "98189548976873118670610057556227124517542175868536"
  324.    "10727083087527560328597909809459043940209712870752"};
  325.  
  326.  
  327.                      /* SIN(.1) to 1100 digits */
  328.  
  329. static char far sinP1A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  330.    "99833416646828152306814198410622026989915388017982"
  331.    "25999276686156165174428329242760966244380406303626"
  332.    "78325031809359890354508072374704593788733561019849"
  333.    "18410496834773050632832494359789005222424086081422"
  334.    "72966743717361429690723851578245480827955359733878"
  335.    "53463387923233361678867424907329845348005814497396"
  336.    "04751862203867889743928811306547167725769195052793"
  337.    "92262607481083336918563790338248847268301618655568"
  338.    "89346698245411612735032192221340049562846009665223"
  339.    "32207461112790826388892485997626004867369921168342"};
  340.  
  341. static char far sinP1B[] = {   /* digits 501 - 1000 */
  342.    "25822007849594489662342102170190915305175072701438"
  343.    "37487428538739455042219898916646878947958333218732"
  344.    "14892824314744574417630614483190418835012604416772"
  345.    "12938344509031562810353361999685976614314713635237"
  346.    "64713327576072485320419858982114221706486033745284"
  347.    "22580789056073829983391226983813224628397600812369"
  348.    "46677420279490476881259137535692930734542900571839"
  349.    "93496383084481238029370793073519896487416427411495"
  350.    "84626654721689231998075453149763755566049310161914"
  351.    "74334017680553444002723416260117444319296284058354"};
  352.  
  353. static char far sinP1C[] = {   /* digits 1001 - 1100 */
  354.    "93872130849632187431309907771896446078938126363160"
  355.    "25302131030949984668064192296841269237431597178125"};
  356.  
  357.  
  358.                      /* SIN(.01) to 1100 digits */
  359.  
  360. static char far sinP01A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  361.    "99998333341666646825424382690997290389643853601691"
  362.    "51033879112479409734509063915965942636792961498990"
  363.    "15251825689376067380711439147810183436799250452237"
  364.    "48779233463339566295770428847517522816055835711010"
  365.    "50774395187168606155330709987206369875092696688424"
  366.    "90541364204623753507681641521959391575397060962515"
  367.    "50071497343436501401260107564729605078738729840429"
  368.    "87441343463278494770994371567032171767528027135974"
  369.    "43546195233602035011214651999637411734890519279205"
  370.    "51271878089079939686142777005076491985889067867722"};
  371.  
  372. static char far sinP01B[] = {   /* digits 501 - 1000 */
  373.    "05719520903185961474603095939933973363416265221714"
  374.    "52145068273393341771117937273335459009509995988896"
  375.    "19642913891756006434429991163737255940473661874082"
  376.    "63088683497634340598889406453290876806826352554400"
  377.    "42113324598097733014879809073704311558595748511922"
  378.    "35000645606400377343263883770265172440601125789584"
  379.    "28359074103973263511493912142496450758739296953977"
  380.    "92073094118840236450685817485260602109928276704622"
  381.    "51142999073649170506864819471418128310313128822546"
  382.    "60611456524573907422800164140884130285721050703575"};
  383.  
  384. static char far sinP01C[] = {   /* digits 1001 - 1100 */
  385.    "01704080647353880794074342640290256620194547926244"
  386.    "32167051360577584360724962828391639445978410560370"};
  387.  
  388.  
  389.                      /* SIN(.001) to 1100 digits */
  390.  
  391. static char far sinP001A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  392.    "99999983333334166666646825397100970015131473480865"
  393.    "84190048145102714673516376365515440749327845858917"
  394.    "04474712856562550569392029872924855755789892276667"
  395.    "97704298110290998087807641517064252910574631431748"
  396.    "50936016773958856266451298761230731759749305717989"
  397.    "10550235392610771541261279604759660199348173407365"
  398.    "78865897288333921120991800160521891039126169054427"
  399.    "18873604879508582086968301228229164797145805071732"
  400.    "32965551300106206405990035941144707201082513739520"
  401.    "99779861547109162678316534591085861322505841086473"};
  402.  
  403. static char far sinP001B[] = {   /* digits 501 - 1000 */
  404.    "56906685531600061984773110968070961480863492393604"
  405.    "72293539702984411547089341142580671593896263957801"
  406.    "22101863893450590685505103137730021243817064332684"
  407.    "05431094335900793630598856176174172417575590465793"
  408.    "43221377047160432487483154447711767284980805828786"
  409.    "52431950713139688921450934014473432877421098049187"
  410.    "32029087150791132360397908105695331673661315874270"
  411.    "94877607403626956830788134769606457740114267480351"
  412.    "27361426130714955664817492955350563166004646658493"
  413.    "24336279044509294780785285016881545351633507219491"};
  414.  
  415. static char far sinP001C[] = {   /* digits 1001 - 1100 */
  416.    "89915724145085050507523026051516345665181332046011"
  417.    "69766743396337932246485484128386582874965066465440"};
  418.  
  419.  
  420.                      /* COS(.1) to 1100 digits */
  421.  
  422. static char far cosP1A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  423.    "99500416527802576609556198780387029483857622541508"
  424.    "40359593527446852659102182404665296636185282629279"
  425.    "10723685880836871860394139703522120459932582277765"
  426.    "00233434126606061055341012689340392816994046794830"
  427.    "27200020718214024442001160621592092042879890578727"
  428.    "32689654637347621801752111388276881384838349480423"
  429.    "27352219507885759748877880657414373095799340911315"
  430.    "62646887269220290882659459060389392748252911983208"
  431.    "12406203434702533302181978058808006060645784695402"
  432.    "71540051162673225582298306135155856782760981045191"};
  433.  
  434. static char far cosP1B[] = {   /* digits 501 - 1000 */
  435.    "24203173805729717623413015685802692277952963048196"
  436.    "95581708516886329798393454090838147538580719507353"
  437.    "13037892361905672825085458775049615611448809472866"
  438.    "51444413797913099178779125485426718947353264138239"
  439.    "83422957335548076407296212010538573742696707806432"
  440.    "60823341438366608860758765805498800986051276520656"
  441.    "29924448402660404844961705157284628032560262233808"
  442.    "28186943192824678771527190172705574611019968372833"
  443.    "12566832594648414562425094985051732771234883152945"
  444.    "22559346346243309348290864439511452419756927497513"};
  445.  
  446. static char far cosP1C[] = {   /* digits 1001 - 1100 */
  447.    "10676179622308536285252492870485071281885521678162"
  448.    "67671288288109196720249973012691907856008716728411"};
  449.  
  450.  
  451.                      /* COS(.01) to 1100 digits */
  452.  
  453. static char far cosP01A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  454.    "99995000041666527778025793375220667321247058398027"
  455.    "71111222757686464600881296434916351255437612973726"
  456.    "56230561941513041834582815792993754862629509448536"
  457.    "97292970784647512006914462382928612539466441550354"
  458.    "57728832357826385724224649308096742936829445083538"
  459.    "21781577471965569249697689958734005837731211373574"
  460.    "85440439994355796196334951328177702604116145694127"
  461.    "77336706911719098301564097003497342506438297965173"
  462.    "28645325451458151717946847802184718372450569655622"
  463.    "94195929079226212048522789105590903088120484847138"};
  464.  
  465. static char far cosP01B[] = {   /* digits 501 - 1000 */
  466.    "63004428493379141767370577843821480598708855134609"
  467.    "79719812757116434617171373175337815552442269723199"
  468.    "64508407408278929107116776376155434135436356633941"
  469.    "04394842072117950771805396158667707823886239953368"
  470.    "16615279174372882038310905003913887439032841067328"
  471.    "90633020510872425101633363501039131638739757401409"
  472.    "47370566536586394830489728404482917699629638057431"
  473.    "76970309397338418277344406921271069049407460221888"
  474.    "82531404254516877147340665076026618342561313147348"
  475.    "04565874027443210391025721851648531160591697947530"};
  476.  
  477. static char far cosP01C[] = {   /* digits 1001 - 1100 */
  478.    "74187809011492744588254659713760991403095506170861"
  479.    "52453206389454214684364014710510381215807269952331"};
  480.  
  481.  
  482.                      /* COS(.001) to 1100 digits */
  483.  
  484. static char far cosP001A[] = {    /* digits 1 - 500 */      /* Max string 512 */
  485.    "99999950000004166666527777780257936480379188921289"
  486.    "61458698562351112779445040208392490288883237630819"
  487.    "53753587256368091915064737486642441428960104047064"
  488.    "14575541558200886886668325062711490527942294855805"
  489.    "61309935194598368152180098217664359538071378723338"
  490.    "48724657137763505429298381693899720849748347295033"
  491.    "33851881159120363391976978301914217279962544324209"
  492.    "20919226144917975951951624931344012451863074884072"
  493.    "30519808024456644721427335334399889159691389661476"
  494.    "13914737488728908041758774390583877706135494129017"};
  495.  
  496. static char far cosP001B[] = {   /* digits 501 - 1000 */
  497.    "80709933688089544713267497493364039864297043637250"
  498.    "99419648927857948970763793295781977802881003783415"
  499.    "93094020198488385311496652735002947572963379425232"
  500.    "68170074707686253042988700770409652389603430028247"
  501.    "14914415029406845579741788550580044688554342445144"
  502.    "68381776832965554654138249210759958048135186871432"
  503.    "61591290025975006100421285272523991369898316685958"
  504.    "10292144029551510454328611951654099003028564671852"
  505.    "78937833540314882686099870223050547927445043052351"
  506.    "91181631090880884648623855543982693629368409486485"};
  507.  
  508. static char far cosP001C[] = {   /* digits 1001 - 1100 */
  509.    "51270934105012682396774558823974435796721473943028"
  510.    "10495338833331883272210005264468059211235493020749"};
  511.  
  512.  
  513.  
  514.  
  515. /*
  516.  *    **************************************************
  517.  *    *                                                *
  518.  *    *               Extended Routines                *
  519.  *    *                                                *
  520.  *    **************************************************
  521.  */
  522.  
  523.  
  524.  
  525.  
  526. /*
  527.  *    **************************************************
  528.  *    *                                                *
  529.  *    *          Normalize Work Register [w]           *
  530.  *    *                                                *
  531.  *    **************************************************
  532.  */
  533.  
  534. extern int Normalize(int w)
  535.  
  536. {
  537.  
  538.    int digits, shift;
  539.    WORKDIGIT *wl, *wr;          /* Work left & right pointers */
  540.  
  541.    if (! work[w].digits) {             /* No digits, return zero */
  542.       work[w].exp = 0L;
  543.       work[w].sign = ' ';
  544.       work[w].digits = 0;
  545.       memset(work[w].man, 0, (workprec * sizeof(WORKDIGIT)));
  546.       return(TRUE);
  547.       }
  548.  
  549.    wl = &work[w].man[0] - 1;
  550.    wr = &work[w].man[work[w].digits];
  551.                                        /* Non significant digit to */
  552.    *(wr + 1) = 1;                      /*  simplify next statement */
  553.  
  554.    while (! *(++wl))                   /* Find leftmost non zero digit */
  555.       ;
  556.  
  557.    if (wl >= wr) {                     /* All digits zero, return zero */
  558.       work[w].exp = 0L;
  559.       work[w].sign = ' ';
  560.       work[w].digits = 0;
  561.       memset(work[w].man, 0, (workprec * sizeof(WORKDIGIT)));
  562.       return(TRUE);
  563.       }
  564.  
  565.    if (wr > wl + compprec)             /* Truncate to max precision */
  566.       wr = wl + compprec;
  567.  
  568.    while (! *(--wr))                   /* Find rightmost non zero digit */
  569.       ;
  570.  
  571.    digits = (wr - wl) + 1;             /* Number of significant digits */
  572.    work[w].digits = digits;
  573.  
  574.    shift = wl - &work[w].man[0];       /* Normalize mantissa if needed */
  575.    if (shift) {
  576.       memmove(work[w].man, wl, (digits * sizeof(WORKDIGIT)) );
  577.       work[w].exp -= (long)shift;
  578.       }
  579.                                        /* Zero digits beyond mantissa */
  580.  
  581.    memset(&work[w].man[digits], 0, ((workprec - digits) * sizeof(WORKDIGIT)) );
  582.  
  583.    if(work[w].exp > (MAXEXP + 1L)) {
  584.       Overflow();
  585.       return(FALSE);
  586.       }
  587.  
  588.    if (work[w].exp < (MINEXP + 1L)) {
  589.       ClearWork(w);
  590.       }
  591.  
  592.    return(TRUE);
  593.  
  594. }
  595.  
  596.  
  597.  
  598.  
  599. /*
  600.  *    **************************************************
  601.  *    *                                                *
  602.  *    *                Flip Sign (+/-)                 *
  603.  *    *                                                *
  604.  *    **************************************************
  605.  */
  606.  
  607. extern int FlipSign(int sign)
  608.  
  609. {
  610.  
  611.    if (sign == '-')
  612.       return('+');
  613.  
  614.    if (sign == '+')
  615.       return('-');
  616.  
  617.    return(' ');
  618.  
  619. }
  620.  
  621.  
  622.  
  623.  
  624. /*
  625.  *    **************************************************
  626.  *    *                                                *
  627.  *    *               Extended Rounding                *
  628.  *    *                                                *
  629.  *    *            work[2] = round(work[w])            *
  630.  *    *                                                *
  631.  *    **************************************************
  632.  */
  633.  
  634. extern int ExtendedRound(int w)
  635.  
  636. {
  637.  
  638.    if ( (work[w].digits > normprec)
  639.          &&
  640.         (work[w].man[normprec] >= 5) ) {
  641.       if (w) {
  642.          MoveWorkWork(w, 0);
  643.          }
  644.       ClearWork(1);
  645.       work[1].exp = work[0].exp - normprec;
  646.       work[1].sign = work[0].sign;
  647.       work[1].digits = 1;
  648.       work[1].man[0] = 5;
  649.       if (! ExtendedAdd()) {
  650.          return(FALSE);
  651.          }
  652.       work[2].digits = normprec;
  653.       }
  654.  
  655.    if (w != 2) {
  656.       MoveWorkWork(2, w);
  657.       }
  658.  
  659.    return(TRUE);
  660.  
  661. }
  662.  
  663.  
  664.  
  665.  
  666. /*
  667.  *    **************************************************
  668.  *    *                                                *
  669.  *    *             Extended Integer Part              *
  670.  *    *                                                *
  671.  *    *             work[0] = int(work[0])             *
  672.  *    *                                                *
  673.  *    **************************************************
  674.  */
  675.  
  676. extern int ExtendedIntegerPart(void)
  677.  
  678. {
  679.  
  680.    int digits;
  681.  
  682.    digits = work[0].digits;
  683.  
  684.    if ( (! digits)                           /* If it's zero,       */
  685.          ||
  686.         (work[0].exp >= (long)digits) ) {    /*  or already integer */
  687.       return(TRUE);                          /*  nothing to do      */
  688.       }
  689.  
  690.    if (work[0].exp <= 0L) {                  /* All decimal,  */
  691.       ClearWork(0);                          /*  return zero  */
  692.       return(TRUE);
  693.       }
  694.                                              /* Zero decimal part */
  695.    digits = (int)work[0].exp;
  696.    memset(&work[0].man[digits], 0, ((workprec - digits) * sizeof(WORKDIGIT)));
  697.    work[0].digits = digits;
  698.  
  699.    return(Normalize(0));
  700.  
  701. }
  702.  
  703.  
  704.  
  705.  
  706. /*
  707.  *    **************************************************
  708.  *    *                                                *
  709.  *    *            Extended Fraction Part              *
  710.  *    *                                                *
  711.  *    *            work[0] = frac(work[0])             *
  712.  *    *                                                *
  713.  *    **************************************************
  714.  */
  715.  
  716. extern int ExtendedFractionPart(void)
  717.  
  718. {
  719.  
  720.    int digits;
  721.  
  722.    digits = work[0].digits;
  723.  
  724.    if ( (! digits)                           /* If it's zero,   */
  725.          ||
  726.         (work[0].exp <= 0L) ) {              /*  or all decimal */
  727.       return(TRUE);                          /*  nothing to do  */
  728.       }
  729.  
  730.    if (work[0].exp >= (long)digits) {        /* All integer,  */
  731.       ClearWork(0);                          /*  return zero  */
  732.       return(TRUE);
  733.       }
  734.                                              /* Zero integer part */
  735.    digits = (int)work[0].exp;
  736.    memset(&work[0].man[0], 0, (digits * sizeof(WORKDIGIT)));
  737.  
  738.    return(Normalize(0));
  739.  
  740. }
  741.  
  742.  
  743.  
  744.  
  745. /*
  746.  *    **************************************************
  747.  *    *                                                *
  748.  *    *           Extended Get X from KBD              *
  749.  *    *                                                *
  750.  *    **************************************************
  751.  */
  752.  
  753. extern int ExtendedGetX(void)
  754.  
  755. {
  756.  
  757.    long exponent;
  758.    int sign, expsign;
  759.    int row, col, exprow, expcol;
  760.    int digits, intdigits, decdigits, exdigits, digitval;
  761.    enum {ININT, INDEC, INEX} mode;
  762.    BOOLEAN decimal;
  763.  
  764.  
  765. /*  ******  I N I T I A L I Z E   V A R I A B L E S  ******  */
  766.  
  767.    sign = '+';                      /* Default to positive numbers */
  768.    expsign = '+';
  769.  
  770.    row = entrysignrow;              /* Starting point for entry */
  771.    col = MINDISPCOL;
  772.    CurPos(row, col);
  773.  
  774.    exponent = 0L;                   /* Initialize digit work areas */
  775.    digits = 0;
  776.    intdigits = 0;
  777.    decdigits = 0;
  778.    exdigits = 0;
  779.    digitval = 0;
  780.  
  781.    mode = ININT;                    /* Begin in integer mode */
  782.  
  783.    decimal = FALSE;                 /* No decimal point entered */
  784.  
  785.    ClearWork(0);
  786.  
  787.  
  788. /*  ******  C H A R A C T E R   W A I T   L O O P  ******  */
  789.  
  790.    do {  /* while (TRUE) */
  791.  
  792.       /* First digit already entered on first pass */
  793.  
  794.       switch (chr) {             /* Test for number terminating operations */
  795.          case (ADD):
  796.          case (SUBTRACT):
  797.          case (MULTIPLY):
  798.          case (DIVIDE):
  799.          case (HELP):
  800.          case (POWER):
  801.          case (SQUAREROOT):
  802.          case (SQUARE):
  803.          case (RECIPROCAL):
  804.          case (FACTORIAL):
  805.          case (INTEGER):
  806.          case (FRACTION):
  807.          case (RECALLPI):
  808.          case (RECALLE):
  809.          case (SIN):
  810.          case (ARCSIN):
  811.          case (COS):
  812.          case (ARCCOS):
  813.          case (TAN):
  814.          case (ARCTAN):
  815.          case (LOG):
  816.          case (EXP10):
  817.          case (LN):
  818.          case (EXPE):
  819.          case (LASTX):
  820.          case (PRINTDISK):
  821.          case (GROUPSIZE):
  822.          case (VIEWREG):
  823.          case (ENTER):
  824.          case (SCINOT):
  825.          case (CLEAR):
  826.          case (PRINT):
  827.          case (STOREX):
  828.          case (RECALLREG):
  829.          case (XCHGXY1):
  830.          case (XCHGXY2):
  831.          case (XCHGXREG):
  832.          case (ROLLDOWN):
  833.          case (ROLLUP):
  834.             charpresent = TRUE;  /* Pass terminating operator */
  835.          }  /* switch */
  836.  
  837.       if (charpresent)           /* Break from while */
  838.          break;
  839.  
  840.       if (! isascii(chr))        /* Ignore non ASCII characters */
  841.          continue;
  842.  
  843. /*  ******  I N T E G E R   M O D E  ******  */
  844.  
  845.       if (mode == ININT) {
  846.  
  847.          if (isdigit(chr)) {                    /* Numeric digit */
  848.             if (digits < normprec) {
  849.                DisplayChar(&row, &col, chr);
  850.                work[0].man[digits] = chr - '0';
  851.                digitval += work[0].man[digits];
  852.                intdigits++;
  853.                digits++;
  854.                }
  855.             else
  856.                Beep();
  857.             }
  858.  
  859.          else if (chr == '.') {                 /* . invokes decimal mode */
  860.             DisplayChar(&row, &col, chr);
  861.             decimal = TRUE;
  862.             mode = INDEC;
  863.             }
  864.  
  865.          else if (chr == 'E') {                 /* E invokes exponent mode, */
  866.             if (! digits) {
  867.                DisplayChar(&row, &col, '1');    /*  if no digits, make it 1, */
  868.                work[0].man[digits] = 1;
  869.                digitval += 1;
  870.                intdigits++;
  871.                digits++;
  872.                DisplayExpChar(&row, &col, ' ');
  873.                DisplayExpChar(&row, &col, 'e');
  874.                CurGet(&exprow, &expcol);
  875.                mode = INEX;
  876.                }
  877.             else if (digitval > 0) {            /*  or if non zero already */
  878.                DisplayExpChar(&row, &col, ' ');
  879.                DisplayExpChar(&row, &col, 'e');
  880.                CurGet(&exprow, &expcol);
  881.                mode = INEX;
  882.                }
  883.             else
  884.                Beep();
  885.             }
  886.  
  887.          else if (chr == CHGSIGN) {             /* Reverse mantissa sign */
  888.             sign = FlipSign(sign);
  889.             CurPos(entrysignrow, SIGNDISPCOL);
  890.             if (sign == '+')
  891.                WChar(' ');
  892.             else
  893.                WChar('-');
  894.             CurPos(row, col);
  895.             }
  896.  
  897.          else if (chr == BACKSPACE) {           /* Backspace backs up char */
  898.             if (digits) {
  899.                BackSpace(&row, &col);
  900.                digits--;
  901.                intdigits--;
  902.                digitval -= work[0].man[digits];
  903.                work[0].man[digits] = 0;
  904.                }
  905.             else
  906.                Beep();
  907.             }
  908.  
  909.          else if (chr == ESCAPE)                /* Changed his/her mind */
  910.             return(FALSE);
  911.  
  912.          else                                   /* Bad keystroke */
  913.             Beep();
  914.  
  915.          }  /* End integer part */
  916.  
  917.  
  918. /*  ******  D E C I M A L   M O D E  ******  */
  919.  
  920.       else if (mode == INDEC) {
  921.  
  922.          if (isdigit(chr)) {                    /* Numeric digit */
  923.             if (digits < normprec) {
  924.                DisplayChar(&row, &col, chr);
  925.                work[0].man[digits] = chr - '0';
  926.                digitval += work[0].man[digits];
  927.                decdigits++;
  928.                digits++;
  929.                }
  930.             else {
  931.                Beep();
  932.                }
  933.             }
  934.  
  935.          else if (chr == 'E') {                 /* E invokes exponent mode     */
  936.             if (digitval > 0) {                 /*  if non zero digits entered */
  937.                DisplayExpChar(&row, &col, ' ');
  938.                DisplayExpChar(&row, &col, 'e');
  939.                CurGet(&exprow, &expcol);
  940.                mode = INEX;
  941.                }
  942.             else
  943.                Beep();
  944.             }
  945.  
  946.          else if (chr == CHGSIGN) {             /* Reverse mantissa sign */
  947.             sign = FlipSign(sign);
  948.             CurPos(entrysignrow, SIGNDISPCOL);
  949.             if (sign == '+')
  950.                WChar(' ');
  951.             else
  952.                WChar('-');
  953.             CurPos(row, col);
  954.             }
  955.  
  956.          else if (chr == BACKSPACE) {           /* Backspace backs up char */
  957.             BackSpace(&row, &col);
  958.  
  959.             if (decdigits) {           /* Decimal digits, stay decimal mode */
  960.                digits--;
  961.                decdigits--;
  962.                digitval -= work[0].man[digits];
  963.                work[0].man[digits] = 0;
  964.                }
  965.  
  966.             else {
  967.                decimal = FALSE;        /* Wiped out decimal point */
  968.                mode = ININT;           /* No digits, back in integer mode */
  969.                }
  970.             }
  971.  
  972.          else if (chr == ESCAPE)                /* Changed his/her mind */
  973.             return(FALSE);
  974.  
  975.          else                                   /* Bad keystroke */
  976.             Beep();
  977.  
  978.          }  /* End decimal part  */
  979.  
  980.  
  981. /*  ******  E X P O N E N T   M O D E  ******  */
  982.  
  983.       else {   /* mode == INEXP */
  984.  
  985.          if (isdigit(chr)) {                    /* numeric digit */
  986.             if (exdigits < MAXEXDIGITS) {
  987.                exponent = (exponent * 10L) + (long)(chr - '0');
  988.                DisplayExpChar(&row, &col, chr);
  989.                exdigits++;
  990.                }
  991.             else {
  992.                 Beep();
  993.                }
  994.             }
  995.  
  996.          else if (chr == CHGSIGN) {             /* Sign ok if first char */
  997.                expsign = FlipSign(expsign);
  998.                DisplayExp(&row, &col, exprow, expcol, expsign, exponent);
  999.                }
  1000.  
  1001.          else if (chr == BACKSPACE) {           /* Backspace backs up char */
  1002.             BackSpaceExp(&row, &col);
  1003.  
  1004.             if (exdigits) {            /* Exdigits means more exp to left */
  1005.                exdigits--;             /* Back out latest digits */
  1006.                exponent /= 10L;
  1007.                }
  1008.  
  1009.             else if (expsign == '-')    /* If sign entered, its gone now */
  1010.                expsign = '+';
  1011.  
  1012.             else {
  1013.                BackSpaceExp(&row, &col);  /* Must have been " e", dump space */
  1014.  
  1015.                if (decdigits || decimal)  /* If decimal digits or decimal */
  1016.                   mode = INDEC;           /*  point entered, decimal mode */
  1017.                else
  1018.                   mode = ININT;           /*  else must be integer part */
  1019.                }
  1020.             }
  1021.  
  1022.          else if (chr == ESCAPE)                /* Changed his/her mind */
  1023.             return(FALSE);
  1024.  
  1025.          else                                   /* Bad keystroke */
  1026.             Beep();
  1027.  
  1028.          }  /* mode == INEX */
  1029.  
  1030.       chr = GetChar();                    /* Get next char from kbd */
  1031.  
  1032.       } while (TRUE);
  1033.  
  1034.    if (expsign == '-')                 /* Invert exponent if neg sign */
  1035.       exponent = - exponent;
  1036.  
  1037.    if (digitval) {                     /* Number not zero */
  1038.       work[0].exp    = exponent + (long)intdigits;
  1039.       work[0].sign   = sign;
  1040.       work[0].digits = digits;
  1041.       return(Normalize(0));
  1042.       }
  1043.    else {                              /* Null number == 0 */
  1044.       work[0].exp    = 0L;
  1045.       work[0].sign   = ' ';
  1046.       work[0].digits = 0;
  1047.       return(TRUE);
  1048.       }
  1049.  
  1050. }
  1051.  
  1052.  
  1053.  
  1054.  
  1055.  
  1056. /*
  1057.  *    **************************************************
  1058.  *    *                                                *
  1059.  *    *                 Data Movement                  *
  1060.  *    *                                                *
  1061.  *    **************************************************
  1062.  */
  1063.  
  1064.  
  1065.  
  1066.  
  1067. /*
  1068.  *    **************************************************
  1069.  *    *                                                *
  1070.  *    *              Extended Recall Pi                *
  1071.  *    *                                                *
  1072.  *    *                work[dest] = pi                 *
  1073.  *    *                                                *
  1074.  *    **************************************************
  1075.  */
  1076.  
  1077. extern void ExtendedRecallPi(int dest)
  1078.  
  1079. {
  1080.  
  1081.    WORKDIGIT *workx, *workend;
  1082.    char far *pix;
  1083.  
  1084.  
  1085.    work[dest].exp = 1L;
  1086.    work[dest].sign = '+';
  1087.    work[dest].digits = compprec;
  1088.  
  1089.    workx = work[dest].man;
  1090.    workend = &work[dest].man[compprec];
  1091.  
  1092.    pix = piA;
  1093.    while ((*pix) && (workx < workend))
  1094.       *(workx++) = (int) *(pix++) - '0';
  1095.  
  1096.    pix = piB;
  1097.    while ((*pix) && (workx < workend))
  1098.       *(workx++) = (int) *(pix++) - '0';
  1099.  
  1100.    pix = piC;
  1101.    while ((*pix) && (workx < workend))
  1102.       *(workx++) = (int) *(pix++) - '0';
  1103.  
  1104.    Normalize(0);
  1105.  
  1106. }
  1107.  
  1108.  
  1109.  
  1110.  
  1111. /*
  1112.  *    **************************************************
  1113.  *    *                                                *
  1114.  *    *             Extended Recall Pi/2               *
  1115.  *    *                                                *
  1116.  *    *               work[dest] = pi/2                *
  1117.  *    *                                                *
  1118.  *    **************************************************
  1119.  */
  1120.  
  1121. extern void ExtendedRecallHalfPi(int dest)
  1122.  
  1123. {
  1124.  
  1125.    WORKDIGIT *workx, *workend;
  1126.    char far *halfpix;
  1127.  
  1128.  
  1129.    work[dest].exp = 1L;
  1130.    work[dest].sign = '+';
  1131.    work[dest].digits = compprec;
  1132.  
  1133.    workx = work[dest].man;
  1134.    workend = &work[dest].man[compprec];
  1135.  
  1136.    halfpix = halfpiA;
  1137.    while ((*halfpix) && (workx < workend))
  1138.       *(workx++) = (int) *(halfpix++) - '0';
  1139.  
  1140.    halfpix = halfpiB;
  1141.    while ((*halfpix) && (workx < workend))
  1142.       *(workx++) = (int) *(halfpix++) - '0';
  1143.  
  1144.    halfpix = halfpiC;
  1145.    while ((*halfpix) && (workx < workend))
  1146.       *(workx++) = (int) *(halfpix++) - '0';
  1147.  
  1148.    Normalize(0);
  1149.  
  1150. }
  1151.  
  1152.  
  1153.  
  1154.  
  1155. /*
  1156.  *    **************************************************
  1157.  *    *                                                *
  1158.  *    *              Extended Recall e                 *
  1159.  *    *                                                *
  1160.  *    *                work[dest] = e                  *
  1161.  *    *                                                *
  1162.  *    **************************************************
  1163.  */
  1164.  
  1165. extern void ExtendedRecallE(int dest)
  1166.  
  1167. {
  1168.  
  1169.    WORKDIGIT *workx, *workend;
  1170.    char far *ex;
  1171.  
  1172.  
  1173.    work[dest].exp = 1L;
  1174.    work[dest].sign = '+';
  1175.    work[dest].digits = compprec;
  1176.  
  1177.    workx = work[dest].man;
  1178.    workend = &work[dest].man[compprec];
  1179.  
  1180.    ex = eA;
  1181.    while ((*ex) && (workx < workend))
  1182.       *(workx++) = (int) *(ex++) - '0';
  1183.  
  1184.    ex = eB;
  1185.    while ((*ex) && (workx < workend))
  1186.       *(workx++) = (int) *(ex++) - '0';
  1187.  
  1188.    ex = eC;
  1189.    while ((*ex) && (workx < workend))
  1190.       *(workx++) = (int) *(ex++) - '0';
  1191.  
  1192.    Normalize(0);
  1193.  
  1194. }
  1195.  
  1196.  
  1197.  
  1198.  
  1199. /*
  1200.  *    **************************************************
  1201.  *    *                                                *
  1202.  *    *             Extended Recall ln10               *
  1203.  *    *                                                *
  1204.  *    *               work[dest] = ln10                *
  1205.  *    *                                                *
  1206.  *    **************************************************
  1207.  */
  1208.  
  1209. extern void ExtendedRecallLn10(int dest)
  1210.  
  1211. {
  1212.  
  1213.    WORKDIGIT *workx, *workend;
  1214.    char far *ln10x;
  1215.  
  1216.  
  1217.    work[dest].exp = 1L;
  1218.    work[dest].sign = '+';
  1219.    work[dest].digits = compprec;
  1220.  
  1221.    workx = work[dest].man;
  1222.    workend = &work[dest].man[compprec];
  1223.  
  1224.    ln10x = ln10A;
  1225.    while ((*ln10x) && (workx < workend))
  1226.       *(workx++) = (int) *(ln10x++) - '0';
  1227.  
  1228.    ln10x = ln10B;
  1229.    while ((*ln10x) && (workx < workend))
  1230.       *(workx++) = (int) *(ln10x++) - '0';
  1231.  
  1232.    ln10x = ln10C;
  1233.    while ((*ln10x) && (workx < workend))
  1234.       *(workx++) = (int) *(ln10x++) - '0';
  1235.  
  1236.    Normalize(0);
  1237.  
  1238. }
  1239.  
  1240.  
  1241.  
  1242.  
  1243. /*
  1244.  *    **************************************************
  1245.  *    *                                                *
  1246.  *    *             Extended Recall ln(.9)             *
  1247.  *    *                                                *
  1248.  *    *               work[dest] = ln(.9)              *
  1249.  *    *                                                *
  1250.  *    **************************************************
  1251.  */
  1252.  
  1253. extern void ExtendedRecallLnP9(int dest)
  1254.  
  1255. {
  1256.  
  1257.    WORKDIGIT *workx, *workend;
  1258.    char far *lnP9x;
  1259.  
  1260.  
  1261.    work[dest].exp = 0L;
  1262.    work[dest].sign = '-';
  1263.    work[dest].digits = compprec;
  1264.  
  1265.    workx = work[dest].man;
  1266.    workend = &work[dest].man[compprec];
  1267.  
  1268.    lnP9x = lnP9A;
  1269.    while ((*lnP9x) && (workx < workend))
  1270.       *(workx++) = (int) *(lnP9x++) - '0';
  1271.  
  1272.    lnP9x = lnP9B;
  1273.    while ((*lnP9x) && (workx < workend))
  1274.       *(workx++) = (int) *(lnP9x++) - '0';
  1275.  
  1276.    lnP9x = lnP9C;
  1277.    while ((*lnP9x) && (workx < workend))
  1278.       *(workx++) = (int) *(lnP9x++) - '0';
  1279.  
  1280.    Normalize(0);
  1281.  
  1282. }
  1283.  
  1284.  
  1285.  
  1286.  
  1287. /*
  1288.  *    **************************************************
  1289.  *    *                                                *
  1290.  *    *            Extended Recall ln(.99)             *
  1291.  *    *                                                *
  1292.  *    *              work[dest] = ln(.99)              *
  1293.  *    *                                                *
  1294.  *    **************************************************
  1295.  */
  1296.  
  1297. extern void ExtendedRecallLnP99(int dest)
  1298.  
  1299. {
  1300.  
  1301.    WORKDIGIT *workx, *workend;
  1302.    char far *lnP99x;
  1303.  
  1304.  
  1305.    work[dest].exp = -1L;
  1306.    work[dest].sign = '-';
  1307.    work[dest].digits = compprec;
  1308.  
  1309.    workx = work[dest].man;
  1310.    workend = &work[dest].man[compprec];
  1311.  
  1312.    lnP99x = lnP99A;
  1313.    while ((*lnP99x) && (workx < workend))
  1314.       *(workx++) = (int) *(lnP99x++) - '0';
  1315.  
  1316.    lnP99x = lnP99B;
  1317.    while ((*lnP99x) && (workx < workend))
  1318.       *(workx++) = (int) *(lnP99x++) - '0';
  1319.  
  1320.    lnP99x = lnP99C;
  1321.    while ((*lnP99x) && (workx < workend))
  1322.       *(workx++) = (int) *(lnP99x++) - '0';
  1323.  
  1324.    Normalize(0);
  1325.  
  1326. }
  1327.  
  1328.  
  1329.  
  1330.  
  1331. /*
  1332.  *    **************************************************
  1333.  *    *                                                *
  1334.  *    *            Extended Recall ln(.999)            *
  1335.  *    *                                                *
  1336.  *    *              work[dest] = ln(.999)             *
  1337.  *    *                                                *
  1338.  *    **************************************************
  1339.  */
  1340.  
  1341. extern void ExtendedRecallLnP999(int dest)
  1342.  
  1343. {
  1344.  
  1345.    WORKDIGIT *workx, *workend;
  1346.    char far *lnP999x;
  1347.  
  1348.  
  1349.    work[dest].exp = -2L;
  1350.    work[dest].sign = '-';
  1351.    work[dest].digits = compprec;
  1352.  
  1353.    workx = work[dest].man;
  1354.    workend = &work[dest].man[compprec];
  1355.  
  1356.    lnP999x = lnP999A;
  1357.    while ((*lnP999x) && (workx < workend))
  1358.       *(workx++) = (int) *(lnP999x++) - '0';
  1359.  
  1360.    lnP999x = lnP999B;
  1361.    while ((*lnP999x) && (workx < workend))
  1362.       *(workx++) = (int) *(lnP999x++) - '0';
  1363.  
  1364.    lnP999x = lnP999C;
  1365.    while ((*lnP999x) && (workx < workend))
  1366.       *(workx++) = (int) *(lnP999x++) - '0';
  1367.  
  1368.    Normalize(0);
  1369.  
  1370. }
  1371.  
  1372.  
  1373.  
  1374.  
  1375. /*
  1376.  *    **************************************************
  1377.  *    *                                                *
  1378.  *    *           Extended Recall ln(.9999)            *
  1379.  *    *                                                *
  1380.  *    *             work[dest] = ln(.9999)             *
  1381.  *    *                                                *
  1382.  *    **************************************************
  1383.  */
  1384.  
  1385. extern void ExtendedRecallLnP9999(int dest)
  1386.  
  1387. {
  1388.  
  1389.    WORKDIGIT *workx, *workend;
  1390.    char far *lnP9999x;
  1391.  
  1392.  
  1393.    work[dest].exp = -3L;
  1394.    work[dest].sign = '-';
  1395.    work[dest].digits = compprec;
  1396.  
  1397.    workx = work[dest].man;
  1398.    workend = &work[dest].man[compprec];
  1399.  
  1400.    lnP9999x = lnP9999A;
  1401.    while ((*lnP9999x) && (workx < workend))
  1402.       *(workx++) = (int) *(lnP9999x++) - '0';
  1403.  
  1404.    lnP9999x = lnP9999B;
  1405.    while ((*lnP9999x) && (workx < workend))
  1406.       *(workx++) = (int) *(lnP9999x++) - '0';
  1407.  
  1408.    lnP9999x = lnP9999C;
  1409.    while ((*lnP9999x) && (workx < workend))
  1410.       *(workx++) = (int) *(lnP9999x++) - '0';
  1411.  
  1412.    Normalize(0);
  1413.  
  1414. }
  1415.  
  1416.  
  1417.  
  1418.  
  1419. /*
  1420.  *    **************************************************
  1421.  *    *                                                *
  1422.  *    *           Extended Recall ln(.99999)           *
  1423.  *    *                                                *
  1424.  *    *             work[dest] = ln(.99999)            *
  1425.  *    *                                                *
  1426.  *    **************************************************
  1427.  */
  1428.  
  1429. extern void ExtendedRecallLnP99999(int dest)
  1430.  
  1431. {
  1432.  
  1433.    WORKDIGIT *workx, *workend;
  1434.    char far *lnP99999x;
  1435.  
  1436.  
  1437.    work[dest].exp = -4L;
  1438.    work[dest].sign = '-';
  1439.    work[dest].digits = compprec;
  1440.  
  1441.    workx = work[dest].man;
  1442.    workend = &work[dest].man[compprec];
  1443.  
  1444.    lnP99999x = lnP99999A;
  1445.    while ((*lnP99999x) && (workx < workend))
  1446.       *(workx++) = (int) *(lnP99999x++) - '0';
  1447.  
  1448.    lnP99999x = lnP99999B;
  1449.    while ((*lnP99999x) && (workx < workend))
  1450.       *(workx++) = (int) *(lnP99999x++) - '0';
  1451.  
  1452.    lnP99999x = lnP99999C;
  1453.    while ((*lnP99999x) && (workx < workend))
  1454.       *(workx++) = (int) *(lnP99999x++) - '0';
  1455.  
  1456.    Normalize(0);
  1457.  
  1458. }
  1459.  
  1460.  
  1461.  
  1462.  
  1463. /*
  1464.  *    **************************************************
  1465.  *    *                                                *
  1466.  *    *            Extended Recall sin(.1)             *
  1467.  *    *                                                *
  1468.  *    *              work[dest] = sin(.1)              *
  1469.  *    *                                                *
  1470.  *    **************************************************
  1471.  */
  1472.  
  1473. extern void ExtendedRecallSinP1(int dest)
  1474.  
  1475. {
  1476.  
  1477.    WORKDIGIT *workx, *workend;
  1478.    char far *sinP1x;
  1479.  
  1480.  
  1481.    work[dest].exp = -1L;
  1482.    work[dest].sign = '+';
  1483.    work[dest].digits = compprec;
  1484.  
  1485.    workx = work[dest].man;
  1486.    workend = &work[dest].man[compprec];
  1487.  
  1488.    sinP1x = sinP1A;
  1489.    while ((*sinP1x) && (workx < workend))
  1490.       *(workx++) = (int) *(sinP1x++) - '0';
  1491.  
  1492.    sinP1x = sinP1B;
  1493.    while ((*sinP1x) && (workx < workend))
  1494.       *(workx++) = (int) *(sinP1x++) - '0';
  1495.  
  1496.    sinP1x = sinP1C;
  1497.    while ((*sinP1x) && (workx < workend))
  1498.       *(workx++) = (int) *(sinP1x++) - '0';
  1499.  
  1500.    Normalize(0);
  1501.  
  1502. }
  1503.  
  1504.  
  1505.  
  1506.  
  1507. /*
  1508.  *    **************************************************
  1509.  *    *                                                *
  1510.  *    *            Extended Recall sin(.01)            *
  1511.  *    *                                                *
  1512.  *    *              work[dest] = sin(.01)             *
  1513.  *    *                                                *
  1514.  *    **************************************************
  1515.  */
  1516.  
  1517. extern void ExtendedRecallSinP01(int dest)
  1518.  
  1519. {
  1520.  
  1521.    WORKDIGIT *workx, *workend;
  1522.    char far *sinP01x;
  1523.  
  1524.  
  1525.    work[dest].exp = -2L;
  1526.    work[dest].sign = '+';
  1527.    work[dest].digits = compprec;
  1528.  
  1529.    workx = work[dest].man;
  1530.    workend = &work[dest].man[compprec];
  1531.  
  1532.    sinP01x = sinP01A;
  1533.    while ((*sinP01x) && (workx < workend))
  1534.       *(workx++) = (int) *(sinP01x++) - '0';
  1535.  
  1536.    sinP01x = sinP01B;
  1537.    while ((*sinP01x) && (workx < workend))
  1538.       *(workx++) = (int) *(sinP01x++) - '0';
  1539.  
  1540.    sinP01x = sinP01C;
  1541.    while ((*sinP01x) && (workx < workend))
  1542.       *(workx++) = (int) *(sinP01x++) - '0';
  1543.  
  1544.    Normalize(0);
  1545.  
  1546. }
  1547.  
  1548.  
  1549.  
  1550.  
  1551. /*
  1552.  *    **************************************************
  1553.  *    *                                                *
  1554.  *    *           Extended Recall sin(.001)            *
  1555.  *    *                                                *
  1556.  *    *             work[dest] = sin(.001)             *
  1557.  *    *                                                *
  1558.  *    **************************************************
  1559.  */
  1560.  
  1561. extern void ExtendedRecallSinP001(int dest)
  1562.  
  1563. {
  1564.  
  1565.    WORKDIGIT *workx, *workend;
  1566.    char far *sinP001x;
  1567.  
  1568.  
  1569.    work[dest].exp = -3L;
  1570.    work[dest].sign = '+';
  1571.    work[dest].digits = compprec;
  1572.  
  1573.    workx = work[dest].man;
  1574.    workend = &work[dest].man[compprec];
  1575.  
  1576.    sinP001x = sinP001A;
  1577.    while ((*sinP001x) && (workx < workend))
  1578.       *(workx++) = (int) *(sinP001x++) - '0';
  1579.  
  1580.    sinP001x = sinP001B;
  1581.    while ((*sinP001x) && (workx < workend))
  1582.       *(workx++) = (int) *(sinP001x++) - '0';
  1583.  
  1584.    sinP001x = sinP001C;
  1585.    while ((*sinP001x) && (workx < workend))
  1586.       *(workx++) = (int) *(sinP001x++) - '0';
  1587.  
  1588.    Normalize(0);
  1589.  
  1590. }
  1591.  
  1592.  
  1593.  
  1594.  
  1595. /*
  1596.  *    **************************************************
  1597.  *    *                                                *
  1598.  *    *            Extended Recall cos(.1)             *
  1599.  *    *                                                *
  1600.  *    *              work[dest] = cos(.1)              *
  1601.  *    *                                                *
  1602.  *    **************************************************
  1603.  */
  1604.  
  1605. extern void ExtendedRecallCosP1(int dest)
  1606.  
  1607. {
  1608.  
  1609.    WORKDIGIT *workx, *workend;
  1610.    char far *cosP1x;
  1611.  
  1612.  
  1613.    work[dest].exp = 0L;
  1614.    work[dest].sign = '+';
  1615.    work[dest].digits = compprec;
  1616.  
  1617.    workx = work[dest].man;
  1618.    workend = &work[dest].man[compprec];
  1619.  
  1620.    cosP1x = cosP1A;
  1621.    while ((*cosP1x) && (workx < workend))
  1622.       *(workx++) = (int) *(cosP1x++) - '0';
  1623.  
  1624.    cosP1x = cosP1B;
  1625.    while ((*cosP1x) && (workx < workend))
  1626.       *(workx++) = (int) *(cosP1x++) - '0';
  1627.  
  1628.    cosP1x = cosP1C;
  1629.    while ((*cosP1x) && (workx < workend))
  1630.       *(workx++) = (int) *(cosP1x++) - '0';
  1631.  
  1632.    Normalize(0);
  1633.  
  1634. }
  1635.  
  1636.  
  1637.  
  1638.  
  1639. /*
  1640.  *    **************************************************
  1641.  *    *                                                *
  1642.  *    *            Extended Recall cos(.01)            *
  1643.  *    *                                                *
  1644.  *    *              work[dest] = cos(.01)             *
  1645.  *    *                                                *
  1646.  *    **************************************************
  1647.  */
  1648.  
  1649. extern void ExtendedRecallCosP01(int dest)
  1650.  
  1651. {
  1652.  
  1653.    WORKDIGIT *workx, *workend;
  1654.    char far *cosP01x;
  1655.  
  1656.  
  1657.    work[dest].exp = 0L;
  1658.    work[dest].sign = '+';
  1659.    work[dest].digits = compprec;
  1660.  
  1661.    workx = work[dest].man;
  1662.    workend = &work[dest].man[compprec];
  1663.  
  1664.    cosP01x = cosP01A;
  1665.    while ((*cosP01x) && (workx < workend))
  1666.       *(workx++) = (int) *(cosP01x++) - '0';
  1667.  
  1668.    cosP01x = cosP01B;
  1669.    while ((*cosP01x) && (workx < workend))
  1670.       *(workx++) = (int) *(cosP01x++) - '0';
  1671.  
  1672.    cosP01x = cosP01C;
  1673.    while ((*cosP01x) && (workx < workend))
  1674.       *(workx++) = (int) *(cosP01x++) - '0';
  1675.  
  1676.    Normalize(0);
  1677.  
  1678. }
  1679.  
  1680.  
  1681.  
  1682.  
  1683. /*
  1684.  *    **************************************************
  1685.  *    *                                                *
  1686.  *    *           Extended Recall cos(.001)            *
  1687.  *    *                                                *
  1688.  *    *             work[dest] = cos(.001)             *
  1689.  *    *                                                *
  1690.  *    **************************************************
  1691.  */
  1692.  
  1693. extern void ExtendedRecallCosP001(int dest)
  1694.  
  1695. {
  1696.  
  1697.    WORKDIGIT *workx, *workend;
  1698.    char far *cosP001x;
  1699.  
  1700.  
  1701.    work[dest].exp = 0L;
  1702.    work[dest].sign = '+';
  1703.    work[dest].digits = compprec;
  1704.  
  1705.    workx = work[dest].man;
  1706.    workend = &work[dest].man[compprec];
  1707.  
  1708.    cosP001x = cosP001A;
  1709.    while ((*cosP001x) && (workx < workend))
  1710.       *(workx++) = (int) *(cosP001x++) - '0';
  1711.  
  1712.    cosP001x = cosP001B;
  1713.    while ((*cosP001x) && (workx < workend))
  1714.       *(workx++) = (int) *(cosP001x++) - '0';
  1715.  
  1716.    cosP001x = cosP001C;
  1717.    while ((*cosP001x) && (workx < workend))
  1718.       *(workx++) = (int) *(cosP001x++) - '0';
  1719.  
  1720.    Normalize(0);
  1721.  
  1722. }
  1723.  
  1724.  
  1725.  
  1726.  
  1727. /*
  1728.  *    **************************************************
  1729.  *    *                                                *
  1730.  *    *       Clear Stack Registers [lo to hi]         *
  1731.  *    *                                                *
  1732.  *    **************************************************
  1733.  */
  1734.  
  1735. extern void ClearStack(int lo, int hi)
  1736.  
  1737. {
  1738.  
  1739.    int s;
  1740.  
  1741.    for (s = lo; s <= hi; s++) {
  1742.       stack[s].exp = 0L;
  1743.       stack[s].sign = ' ';
  1744.       stack[s].digits = 0;
  1745.       memset(stack[s].man, 0, (normprec * sizeof(NORMDIGIT)));
  1746.       }
  1747.  
  1748. }
  1749.  
  1750.  
  1751.  
  1752.  
  1753. /*
  1754.  *    **************************************************
  1755.  *    *                                                *
  1756.  *    *          Clear Registers [lo to hi]            *
  1757.  *    *                                                *
  1758.  *    **************************************************
  1759.  */
  1760.  
  1761. extern void ClearReg(int lo, int hi)
  1762.  
  1763. {
  1764.  
  1765.    int r;
  1766.  
  1767.    for (r = lo; r <= hi; r++) {
  1768.       reg[r].exp = 0L;
  1769.       reg[r].sign = ' ';
  1770.       reg[r].digits = 0;
  1771.       memset(reg[r].man, 0, (normprec * sizeof(NORMDIGIT)));
  1772.       }
  1773.  
  1774. }
  1775.  
  1776.  
  1777.  
  1778.  
  1779. /*
  1780.  *    **************************************************
  1781.  *    *                                                *
  1782.  *    *        Clear Work Registers [lo to hi]         *
  1783.  *    *                                                *
  1784.  *    **************************************************
  1785.  */
  1786.  
  1787. extern void ClearWork(int w)
  1788.  
  1789. {
  1790.  
  1791.    work[w].exp = 0L;
  1792.    work[w].sign = ' ';
  1793.    work[w].digits = 0;
  1794.    memset(work[w].man, 0, (workprec * sizeof(WORKDIGIT)));
  1795.  
  1796. }
  1797.  
  1798.  
  1799.  
  1800.  
  1801. /*
  1802.  *    **************************************************
  1803.  *    *                                                *
  1804.  *    *          Clear Temp Register [*temp]           *
  1805.  *    *                                                *
  1806.  *    **************************************************
  1807.  */
  1808.  
  1809. extern void ClearTemp(COMPTYPE *temp)
  1810.  
  1811. {
  1812.  
  1813.    temp->exp = 0L;
  1814.    temp->sign = ' ';
  1815.    temp->digits = 0;
  1816.    memset(temp->man, 0, (compprec * sizeof(WORKDIGIT)));
  1817.  
  1818. }
  1819.  
  1820.  
  1821.  
  1822.  
  1823. /*
  1824.  *    **************************************************
  1825.  *    *                                                *
  1826.  *    *        Move Stack[source] to Work[dest]        *
  1827.  *    *                                                *
  1828.  *    **************************************************
  1829.  */
  1830.  
  1831. extern void MoveStackWork(int source, int dest)
  1832.  
  1833. {
  1834.  
  1835.    int size, i;
  1836.  
  1837.    if (size = stack[source].digits) {
  1838.       if (size > workprec)
  1839.          size = workprec;
  1840.       work[dest].exp    = stack[source].exp;
  1841.       work[dest].sign   = stack[source].sign;
  1842.       work[dest].digits = size;
  1843.  
  1844.       for (i = 0; i < size; i++)
  1845.          work[dest].man[i] = (WORKDIGIT)stack[source].man[i];
  1846.  
  1847.       if (size < workprec)
  1848.          memset(&work[dest].man[size], 0, ((workprec - size) * sizeof(WORKDIGIT)));
  1849.       }
  1850.    else
  1851.       ClearWork(dest);
  1852.  
  1853. }
  1854.  
  1855.  
  1856.  
  1857.  
  1858. /*
  1859.  *    **************************************************
  1860.  *    *                                                *
  1861.  *    *      Move Register[source] to Work[dest]       *
  1862.  *    *                                                *
  1863.  *    **************************************************
  1864.  */
  1865.  
  1866. extern void MoveRegWork(int source, int dest)
  1867.  
  1868. {
  1869.  
  1870.    int size, i;
  1871.  
  1872.    if (size = reg[source].digits) {
  1873.       if (size > workprec)
  1874.          size = workprec;
  1875.       work[dest].exp    = reg[source].exp;
  1876.       work[dest].sign   = reg[source].sign;
  1877.       work[dest].digits = size;
  1878.  
  1879.       for (i = 0; i < size; i++)
  1880.          work[dest].man[i] = (WORKDIGIT)reg[source].man[i];
  1881.  
  1882.       if (size < workprec)
  1883.          memset(&work[dest].man[size], 0, ((workprec - size) * sizeof(WORKDIGIT)));
  1884.       }
  1885.    else
  1886.       ClearWork(dest);
  1887.  
  1888. }
  1889.  
  1890.  
  1891.  
  1892.  
  1893. /*
  1894.  *    **************************************************
  1895.  *    *                                                *
  1896.  *    *        Move Work[source] to Stack[dest]        *
  1897.  *    *                                                *
  1898.  *    **************************************************
  1899.  */
  1900.  
  1901. extern void MoveWorkStack(int source, int dest)
  1902.  
  1903. {
  1904.  
  1905.    int size, i;
  1906.  
  1907.    if (size = work[source].digits) {
  1908.       if (size > normprec)
  1909.          size = normprec;
  1910.       stack[dest].exp  = work[source].exp;
  1911.       stack[dest].sign = work[source].sign;
  1912.  
  1913.       for (i = 0; i < size; i++)
  1914.          stack[dest].man[i] = (NORMDIGIT)work[source].man[i];
  1915.  
  1916.       if (size < normprec)
  1917.          memset(&stack[dest].man[size], 0, ((normprec - size) * sizeof(NORMDIGIT)));
  1918.  
  1919.       while (!stack[dest].man[size - 1])
  1920.          size--;
  1921.       stack[dest].digits = size;
  1922.       }
  1923.    else
  1924.       ClearStack(dest, dest);
  1925.  
  1926. }
  1927.  
  1928.  
  1929.  
  1930.  
  1931. /*
  1932.  *    **************************************************
  1933.  *    *                                                *
  1934.  *    *         Move Work[source] to Reg[dest]         *
  1935.  *    *                                                *
  1936.  *    **************************************************
  1937.  */
  1938.  
  1939. extern void MoveWorkReg(int source, int dest)
  1940.  
  1941. {
  1942.  
  1943.    int size, i;
  1944.  
  1945.    if (size = work[source].digits) {
  1946.       if (size > normprec)
  1947.          size = normprec;
  1948.       reg[dest].exp  = work[source].exp;
  1949.       reg[dest].sign = work[source].sign;
  1950.  
  1951.       for (i = 0; i < size; i++)
  1952.          reg[dest].man[i] = (NORMDIGIT)work[source].man[i];
  1953.  
  1954.       if (size < normprec)
  1955.          memset(®[dest].man[size], 0, ((normprec - size) * sizeof(NORMDIGIT)));
  1956.  
  1957.       while (!reg[dest].man[size - 1])
  1958.          size--;
  1959.       reg[dest].digits = size;
  1960.       }
  1961.    else
  1962.       ClearReg(dest, dest);
  1963.  
  1964. }
  1965.  
  1966.  
  1967.  
  1968.  
  1969. /*
  1970.  *    **************************************************
  1971.  *    *                                                *
  1972.  *    *        Move Work[source] to Work[*dest]        *
  1973.  *    *                                                *
  1974.  *    **************************************************
  1975.  */
  1976.  
  1977. extern void MoveWorkWork(int source, int dest)
  1978.  
  1979. {
  1980.  
  1981.    int size;
  1982.  
  1983.    if (size = work[source].digits) {
  1984.       if (size > compprec)
  1985.          size = compprec;
  1986.       work[dest].exp    = work[source].exp;
  1987.       work[dest].sign   = work[source].sign;
  1988.       work[dest].digits = size;
  1989.  
  1990.       memcpy(work[dest].man, work[source].man, (size * sizeof(WORKDIGIT)));
  1991.  
  1992.       if (size < compprec)
  1993.          memset(&work[dest].man[size], 0, ((compprec - size) * sizeof(WORKDIGIT)));
  1994.       }
  1995.    else
  1996.       ClearWork(dest);
  1997.  
  1998. }
  1999.  
  2000.  
  2001.  
  2002.  
  2003. /*
  2004.  *    **************************************************
  2005.  *    *                                                *
  2006.  *    *        Move Work[source] to Temp[*dest]        *
  2007.  *    *                                                *
  2008.  *    **************************************************
  2009.  */
  2010.  
  2011. extern void MoveWorkTemp(int source, COMPTYPE *dest)
  2012.  
  2013. {
  2014.  
  2015.    int size;
  2016.  
  2017.    if (size = work[source].digits) {
  2018.       if (size > compprec)
  2019.          size = compprec;
  2020.       dest->exp    = work[source].exp;
  2021.       dest->sign   = work[source].sign;
  2022.       dest->digits = size;
  2023.  
  2024.       memcpy(dest->man, work[source].man, (size * sizeof(WORKDIGIT)));
  2025.  
  2026.       if (size < compprec)
  2027.          memset(&dest->man[size], 0, ((compprec - size) * sizeof(WORKDIGIT)));
  2028.       }
  2029.    else
  2030.       ClearTemp(dest);
  2031.  
  2032. }
  2033.  
  2034.  
  2035.  
  2036.  
  2037. /*
  2038.  *    **************************************************
  2039.  *    *                                                *
  2040.  *    *        Move Temp[*source] to Work[dest]        *
  2041.  *    *                                                *
  2042.  *    **************************************************
  2043.  */
  2044.  
  2045. extern void MoveTempWork(COMPTYPE *source, int dest)
  2046.  
  2047. {
  2048.  
  2049.    int size;
  2050.  
  2051.    if (size = source->digits) {
  2052.       if (size > workprec)
  2053.          size = workprec;
  2054.       work[dest].exp    = source->exp;
  2055.       work[dest].sign   = source->sign;
  2056.       work[dest].digits = size;
  2057.  
  2058.       memcpy(work[dest].man, source->man, (size * sizeof(WORKDIGIT)));
  2059.  
  2060.       if (size < workprec)
  2061.          memset(&work[dest].man[size], 0, ((workprec - size) * sizeof(WORKDIGIT)));
  2062.       }
  2063.    else
  2064.       ClearWork(dest);
  2065.  
  2066. }
  2067.  
  2068.  
  2069.  
  2070.  
  2071. /*
  2072.  *    **************************************************
  2073.  *    *                                                *
  2074.  *    *       Move Temp[*source] to Temp[*dest]        *
  2075.  *    *                                                *
  2076.  *    **************************************************
  2077.  */
  2078.  
  2079. extern void MoveTempTemp(COMPTYPE *source, COMPTYPE *dest)
  2080.  
  2081. {
  2082.  
  2083.    int size;
  2084.  
  2085.    if (size = source->digits) {
  2086.       if (size > compprec)
  2087.          size = compprec;
  2088.       dest->exp    = source->exp;
  2089.       dest->sign   = source->sign;
  2090.       dest->digits = size;
  2091.  
  2092.       memcpy(dest->man, source->man, (size * sizeof(WORKDIGIT)));
  2093.  
  2094.       if (size < compprec)
  2095.          memset(&dest->man[size], 0, ((compprec - size) * sizeof(WORKDIGIT)));
  2096.       }
  2097.    else
  2098.       ClearTemp(dest);
  2099.  
  2100. }
  2101.  
  2102.  
  2103.  
  2104.  
  2105. /*
  2106.  *    **************************************************
  2107.  *    *                                                *
  2108.  *    *           Set Work[dest] to Integer            *
  2109.  *    *                                                *
  2110.  *    **************************************************
  2111.  */
  2112.  
  2113. extern void SetWorkInteger(int dest, long integer)
  2114.  
  2115. {
  2116.  
  2117.    int i;
  2118.    long order;
  2119.  
  2120.    if (integer < 0L) {
  2121.       work[dest].sign = '-';
  2122.       integer = -integer;
  2123.       }
  2124.    else if (integer > 0L) {
  2125.       work[dest].sign = '+';
  2126.       }
  2127.    else {
  2128.       return;
  2129.       }
  2130.  
  2131.    order = 1000000000L;
  2132.    while (order > integer)
  2133.       order /= 10L;
  2134.    i = 0;
  2135.    while (order) {
  2136.       work[dest].man[i] = (WORKDIGIT) (integer / order);
  2137.       integer %= order;
  2138.       order /= 10L;
  2139.       i++;
  2140.       }
  2141.    memset(&work[dest].man[i], 0, ((workprec - i) * sizeof(WORKDIGIT)));
  2142.    work[dest].digits = i;
  2143.    work[dest].exp = (long) i;
  2144.  
  2145. }
  2146.  
  2147.  
  2148.  
  2149.  
  2150. /*
  2151.  *    **************************************************
  2152.  *    *                                                *
  2153.  *    *           Set Temp[*dest] to Integer           *
  2154.  *    *                                                *
  2155.  *    **************************************************
  2156.  */
  2157.  
  2158. extern void SetTempInteger(COMPTYPE *dest, long integer)
  2159.  
  2160. {
  2161.  
  2162.    int i;
  2163.    long order;
  2164.  
  2165.    if (integer < 0L) {
  2166.       dest->sign = '-';
  2167.       integer = -integer;
  2168.       }
  2169.    else if (integer > 0L) {
  2170.       dest->sign = '+';
  2171.       }
  2172.    else {
  2173.       return;
  2174.       }
  2175.  
  2176.    order = 1000000000L;
  2177.    while (order > integer)
  2178.       order /= 10L;
  2179.    i = 0;
  2180.    while (order) {
  2181.       dest->man[i] = (WORKDIGIT) (integer / order);
  2182.       integer %= order;
  2183.       order /= 10L;
  2184.       i++;
  2185.       }
  2186.    memset(&dest->man[i], 0, ((compprec - i) * sizeof(WORKDIGIT)));
  2187.    dest->digits = i;
  2188.    dest->exp = (long) i;
  2189.  
  2190. }
  2191.