home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / dev / lang / umbscheme / src / number.c < prev    next >
C/C++ Source or Header  |  1993-11-29  |  63KB  |  2,453 lines
  1. /* number.c - UMB Scheme, numbers package 
  2.  
  3. UMB Scheme Interpreter                  $Revision: 2.12 $
  4. Copyright (C) 1988, 1991 William R Campbell
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20. UMB Scheme was written by Bill Campbell with help from Karl Berry,
  21. Barbara Dixey, Ira Gerstein, Mary Glaser, Kathy Hargreaves, Bill McCabe,
  22. Long Nguyen, Susan Quina, Jeyashree Sivasubram, Bela Sohoni and Thang Quoc Tran.
  23.  
  24. For additional information about UMB Scheme, contact the author:
  25.  
  26.     Bill Campbell
  27.     Department of Mathematics and Computer Science
  28.     University of Massachusetts at Boston
  29.     Harbor Campus
  30.     Boston, MA 02125
  31.  
  32.     Telephone: 617-287-6449        Internet: bill@cs.umb.edu
  33.  
  34. */
  35.  
  36. #include "portable.h"
  37. #include "eval.h"
  38. #include "object.h"
  39. #include "architecture.h"
  40. #include "number.h"
  41. #include "fixnum.h"
  42. #include "bignum.h"
  43. #include "rational.h"
  44. #include "real.h"
  45. #include "complex.h"
  46. #include "steering.h"
  47. #include "io.h"
  48. #include <math.h>
  49.  
  50. /* Conversions used in promotion */
  51.  
  52. Private void Coerce_Args();
  53. Private void Coerce_Relational_Args();
  54.  
  55. /* Conversions used in demotion */
  56.  
  57. Private void Demote_Complex_To_Real();
  58. Private void Demote_Rational_To_Integer();
  59. Private void Demote_Bignum_To_Fixnum();
  60.  
  61. /* All the number operations. */
  62.  
  63. typedef void (*Procedure_Pointer)();
  64. typedef Procedure_Pointer Procedure_Array[ TOWER_LEVEL_COUNT ];
  65.  
  66. typedef Boolean (*Boolean_Function_Pointer)();
  67. typedef Boolean_Function_Pointer Boolean_Function_Array[ TOWER_LEVEL_COUNT ];
  68.  
  69. Private struct 
  70. {
  71.                     /* Predicates */
  72.     Boolean_Function_Array Is_Number_Zero;
  73.     Boolean_Function_Array Is_Number_Positive;
  74.     Boolean_Function_Array Is_Number_Negative;
  75.     Boolean_Function_Array Is_Number_Even;
  76.     Boolean_Function_Array Is_Number_Odd;
  77.     Boolean_Function_Array Is_Number_Exact;
  78.     Boolean_Function_Array Is_Number_Inexact;
  79.  
  80.                     /* Comparisons */
  81.     Boolean_Function_Array Number_Equal;
  82.     Boolean_Function_Array Number_Less_Than;
  83.     Boolean_Function_Array Number_Greater_Than;
  84.     Boolean_Function_Array Number_Less_Than_Or_Equal;
  85.     Boolean_Function_Array Number_Greater_Than_Or_Equal;
  86.  
  87.                     /* Arithmetic. */
  88.     Procedure_Array Number_Add;
  89.     Procedure_Array Number_Subtract;
  90.     Procedure_Array Number_Multiply;
  91.     Procedure_Array Number_Divide;
  92.     Procedure_Array Number_Quotient;
  93.     Procedure_Array Number_Remainder;
  94.     Procedure_Array Number_Modulo;
  95.     Procedure_Array Number_Negate;
  96.     Procedure_Array Number_Abs;
  97.     Procedure_Array Number_Numerator;
  98.     Procedure_Array Number_Denominator;
  99.     Procedure_Array Number_Rationalize;
  100.  
  101.                     /* Others. */
  102.     Procedure_Array Number_Max;
  103.     Procedure_Array Number_Min;
  104.     Procedure_Array Number_GCD;
  105.     Procedure_Array Number_LCM;
  106.  
  107.  
  108.     Procedure_Array Number_Floor;
  109.     Procedure_Array Number_Ceiling;
  110.     Procedure_Array Number_Truncate;
  111.     Procedure_Array Number_Round;
  112.  
  113.  
  114.     Procedure_Array Number_Sqrt;
  115.     Procedure_Array Number_Exp;
  116.     Procedure_Array Number_Log;
  117.     Procedure_Array Number_Expt;
  118.  
  119.  
  120.     Procedure_Array Number_Sin;
  121.     Procedure_Array Number_Cos;
  122.     Procedure_Array Number_Tan;
  123.     Procedure_Array Number_Asin;
  124.     Procedure_Array Number_Acos;
  125.     Procedure_Array Number_Atan;
  126.     Procedure_Array Number_Atan2;
  127.  
  128.     Procedure_Array Number_Exact_To_Inexact;
  129.     Procedure_Array Number_Inexact_To_Exact;
  130.     Procedure_Array Number_To_String;
  131.  
  132.     Procedure_Array Number_Make_Rectangular;
  133.     Procedure_Array Number_Make_Polar;
  134.     Procedure_Array Number_Real_Part;
  135.     Procedure_Array Number_Imaginary_Part;
  136.     Procedure_Array Number_Magnitude;
  137.     Procedure_Array Number_Angle;
  138.  
  139. } Num_Ops;
  140.  
  141. /* Basic Predicates on Numbers */
  142.  
  143. /* (number? object) */
  144.  
  145. Private void Number_Predicate()
  146. {
  147.    Value_Register = Is_Number(Top(1)) ? The_True_Object
  148.                                       : The_False_Object;
  149. }
  150.  
  151.  
  152. /* (integer? object) */
  153.  
  154. Private void Integer_Predicate()
  155. {
  156.     if ( Is_Number( Top(1) ) )
  157.     {
  158.         Integer p1 = Get_Number_Tower_Position( Top(1) );
  159.  
  160.         if ( p1 <= BIGNUM_LEVEL )
  161.             Value_Register = The_True_Object;
  162.         else if ( p1 == REAL_LEVEL )
  163.         {
  164.             Push( Top(1) );
  165.             Number_Round();
  166.             Replace( 1 , Value_Register );
  167.             Number_Equal(); Pop(1); /* just the rounded one */
  168.         }
  169.         else Value_Register = The_False_Object;
  170.     }
  171.     else Value_Register = The_False_Object;
  172. }
  173.  
  174.  
  175. /* (rational? object) */
  176.  
  177. Private void Rational_Predicate()
  178. {
  179.     if ( Is_Number( Top(1) ) )
  180.     {
  181.         Integer p1 = Get_Number_Tower_Position( Top(1) );
  182.  
  183.         if ( p1 <= RATIONAL_LEVEL )
  184.             Value_Register = The_True_Object;
  185.         else if ( p1 == REAL_LEVEL )
  186.         {
  187.             Push( Top(1) );
  188.             Number_Round();
  189.             Replace( 1 , Value_Register );
  190.             Number_Equal(); Pop(1); /* just the rounded one */
  191.         }
  192.         else Value_Register = The_False_Object;
  193.     }
  194.     else Value_Register = The_False_Object;
  195. }
  196.  
  197. /* (real? object) */
  198.  
  199. Private void Real_Predicate()
  200. {
  201.    Value_Register = Is_Number(Top(1)) &&
  202.                     Get_Number_Tower_Position(Top(1)) <= REAL_LEVEL
  203.                     ? The_True_Object
  204.                     : The_False_Object;
  205. }
  206.  
  207. /* (complex? object) */
  208.  
  209. Private void Complex_Predicate()
  210. {
  211.    Value_Register = Is_Number(Top(1)) &&
  212.                     Get_Number_Tower_Position(Top(1)) <= COMPLEX_LEVEL
  213.                     ? The_True_Object
  214.                     : The_False_Object;
  215. }
  216.  
  217.  
  218.  
  219.  
  220. /* Generic Number Procedures - invoke more specific procedures via Num_Ops */
  221.  
  222.  
  223. Public void Is_Number_Zero()
  224. {
  225.     Value_Register =
  226.     (*(Num_Ops.Is_Number_Zero[Get_Number_Tower_Position( Top(1) )]))()
  227.             ? The_True_Object
  228.             : The_False_Object;
  229. }
  230.  
  231.                     
  232.  
  233.  
  234. Public void Is_Number_Positive()
  235. {
  236.         
  237.     Value_Register =
  238.     (*(Num_Ops.Is_Number_Positive[Get_Number_Tower_Position( Top(1) )]))()
  239.         ? The_True_Object
  240.         : The_False_Object;
  241. }
  242.  
  243.                     
  244.  
  245.  
  246. Public void Is_Number_Negative()
  247. {
  248.     Value_Register =
  249.     (*(Num_Ops.Is_Number_Negative[Get_Number_Tower_Position( Top(1) )]))()
  250.         ? The_True_Object
  251.         : The_False_Object;
  252. }
  253.  
  254.                     
  255.  
  256.  
  257. Public void Is_Number_Odd()
  258. {
  259.     Value_Register =
  260.     (*(Num_Ops.Is_Number_Odd[Get_Number_Tower_Position( Top(1) )]))()
  261.         ? The_True_Object
  262.         : The_False_Object;
  263. }
  264.  
  265.                     
  266.  
  267.  
  268. Public void Is_Number_Even()
  269. {
  270.     Value_Register =
  271.     (*(Num_Ops.Is_Number_Even[Get_Number_Tower_Position( Top(1) )]))()
  272.         ? The_True_Object
  273.         : The_False_Object;
  274. }
  275.  
  276.                     
  277.  
  278.  
  279. Public void Is_Number_Exact()
  280. {
  281.     Value_Register =
  282.     (*(Num_Ops.Is_Number_Exact[Get_Number_Tower_Position( Top(1) )]))()
  283.         ? The_True_Object
  284.         : The_False_Object;
  285. }
  286.  
  287.                     
  288.  
  289.  
  290. Public void Is_Number_Inexact()
  291. {
  292.     Value_Register =
  293.     (*(Num_Ops.Is_Number_Inexact[Get_Number_Tower_Position( Top(1) )]))()
  294.         ? The_True_Object
  295.         : The_False_Object;
  296. }
  297.  
  298. /* Relations of the form (rel obj obj obj ...) */
  299.  
  300. Private Object Iterate_Over_Relations( Relation_Tower )
  301.         
  302.     Boolean_Function_Array Relation_Tower;
  303. {
  304.     /* In (rel obj obj ...) apply rel to successive obj pairs;
  305.        thus eg (> x y z) is the same as (and (> x y) (> y z)). */
  306.  
  307.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  308.  
  309.     if (arg_count < 2 )
  310.     {
  311.         Display_Error( "Fewer than 2 arguments to a relation: " ,
  312.                    Expression_Register );
  313.     }
  314.     
  315.     while ( arg_count > 1 )
  316.     {
  317.                   Push( Top( arg_count ) );
  318.            Push( Top( arg_count ) );
  319.            Coerce_Relational_Args();
  320.            
  321.            if ( (*(Relation_Tower[Get_Number_Tower_Position(Top(1))]))() )
  322.            {
  323.                Pop( 2 );
  324.                arg_count--;
  325.            }
  326.            else
  327.            {
  328.                Pop( 2 );
  329.                return( The_False_Object );
  330.            }
  331.        }
  332.     return( The_True_Object );
  333. }
  334.  
  335.  
  336.  
  337. Private void Varying_Number_Equal()
  338. {
  339.     Value_Register = Iterate_Over_Relations( Num_Ops.Number_Equal );
  340. }
  341.  
  342.  
  343.  
  344. Private void Varying_Number_Greater_Than()
  345. {
  346.     Value_Register = Iterate_Over_Relations( Num_Ops.Number_Greater_Than );
  347. }
  348.  
  349.  
  350.  
  351. Private void Varying_Number_Less_Than()
  352. {
  353.     Value_Register = Iterate_Over_Relations( Num_Ops.Number_Less_Than );
  354. }
  355.  
  356.  
  357.  
  358. Private void Varying_Number_Greater_Than_Or_Equal()
  359. {
  360.     Value_Register =
  361.     Iterate_Over_Relations( Num_Ops.Number_Greater_Than_Or_Equal );
  362. }
  363.  
  364.  
  365.  
  366. Private void Varying_Number_Less_Than_Or_Equal()
  367. {
  368.     Value_Register =
  369.     Iterate_Over_Relations( Num_Ops.Number_Less_Than_Or_Equal );
  370. }
  371.  
  372.  
  373.  
  374.  
  375. Public void Number_Equal()
  376. {
  377.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  378.  
  379.     Value_Register =
  380.     (*(Num_Ops.Number_Equal[Get_Number_Tower_Position( Top(1) )]))()
  381.         ? The_True_Object
  382.         : The_False_Object;
  383. }
  384.  
  385.                     
  386.  
  387.  
  388.  
  389. Public void Number_Less_Than()
  390. {
  391.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  392.  
  393.     Value_Register =
  394.     (*(Num_Ops.Number_Less_Than[Get_Number_Tower_Position( Top(1) )]))()
  395.         ? The_True_Object
  396.         : The_False_Object;
  397. }
  398.  
  399.                     
  400.  
  401.  
  402.  
  403. Public void Number_Greater_Than()
  404. {
  405.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  406.  
  407.     Value_Register =
  408.     (*(Num_Ops.Number_Greater_Than[Get_Number_Tower_Position( Top(1) )]))()
  409.         ? The_True_Object
  410.         : The_False_Object;
  411. }
  412.  
  413.                     
  414.  
  415.  
  416.  
  417. Public void Number_Less_Than_Or_Equal()
  418. {
  419.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  420.  
  421.     Value_Register =
  422.     (*(Num_Ops.Number_Less_Than_Or_Equal[
  423.                 Get_Number_Tower_Position( Top(1) )]))()
  424.         ? The_True_Object
  425.         : The_False_Object;
  426. }
  427.  
  428.                     
  429.  
  430.  
  431.  
  432. Public void Number_Greater_Than_Or_Equal()
  433. {
  434.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  435.  
  436.     Value_Register =
  437.     (*(Num_Ops.Number_Greater_Than_Or_Equal[
  438.                 Get_Number_Tower_Position( Top(1) )]))()
  439.         ? The_True_Object
  440.         : The_False_Object;
  441. }
  442.  
  443. /* Numerical operations with varying numbers of arguments */
  444.  
  445.  
  446. Private void Iterate_Over_Operands( Arg_Count , Op_Tower )
  447.  
  448.     Integer Arg_Count;
  449.     Procedure_Array Op_Tower;
  450. {
  451.     while ( Arg_Count > 1 )
  452.     {
  453.         Push( Value_Register );
  454.         Push( Top( Arg_Count ) );
  455.         Coerce_Args();
  456.         (*(Op_Tower[Get_Number_Tower_Position( Top(1) )]))();
  457.         Pop(2);
  458.         Arg_Count--;
  459.     }
  460.     Demote();
  461. }
  462.  
  463.  
  464.  
  465. Private void Varying_Number_Add()
  466. {
  467.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  468.     
  469.     if ( arg_count >= 2 )
  470.     {
  471.         Value_Register = Top(arg_count);
  472.         Iterate_Over_Operands( arg_count, Num_Ops.Number_Add );
  473.     }
  474.     else if ( arg_count == 1 )
  475.         Value_Register = Top( 1 );
  476.     else
  477.         Make_Fixnum_Number( 0 );
  478. }
  479.  
  480.  
  481.  
  482. Private void Varying_Number_Subtract()
  483. {
  484.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  485.     
  486.     if ( arg_count >= 2 )
  487.     {
  488.         Value_Register = Top(arg_count);
  489.         Iterate_Over_Operands( arg_count , Num_Ops.Number_Subtract);
  490.     }
  491.     else if (arg_count == 1 )
  492.     {
  493.         Make_Fixnum_Number( 0 );  /* treat as (- 0 arg) */
  494.         Iterate_Over_Operands( 2 , Num_Ops.Number_Subtract);
  495.     }
  496.     else 
  497.         Display_Error( "At least 1 argument required in: " ,
  498.                    Expression_Register );
  499. }
  500.  
  501.  
  502.  
  503. Private void Varying_Number_Multiply()
  504. {
  505.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  506.     
  507.     if ( arg_count >= 2 )
  508.     {
  509.         Value_Register = Top(arg_count);
  510.         Iterate_Over_Operands( arg_count, Num_Ops.Number_Multiply );
  511.     }
  512.     else if ( arg_count == 1 )
  513.         Value_Register = Top( 1 );
  514.     else
  515.         Make_Fixnum_Number( 1 );
  516. }
  517.  
  518.  
  519.  
  520. Private void Varying_Number_Divide()
  521. {
  522.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  523.     
  524.     if ( arg_count >= 2 )
  525.     {
  526.         Value_Register = Top(arg_count);
  527.         Iterate_Over_Operands( arg_count , Num_Ops.Number_Divide );
  528.     }
  529.     else if (arg_count == 1 )
  530.     {
  531.         Make_Fixnum_Number( 1 );  /* treat as (/ 1 arg) */
  532.         Iterate_Over_Operands( 2 , Num_Ops.Number_Divide );
  533.     }
  534.     else 
  535.         Display_Error( "At least 1 argument required in: " ,
  536.                    Expression_Register );
  537. }
  538.  
  539.  
  540.  
  541. Private void Varying_Number_Min()
  542. {
  543.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  544.     
  545.     if ( arg_count >= 2 )
  546.     {
  547.         Value_Register = Top(arg_count);
  548.         Iterate_Over_Operands( arg_count , Num_Ops.Number_Min );
  549.     }
  550.     else if (arg_count == 1 )
  551.     {
  552.         Value_Register = Top(arg_count);
  553.     }
  554.     else 
  555.         Display_Error( "At least 1 argument required in: " ,
  556.                    Expression_Register );
  557. }
  558.  
  559.  
  560.  
  561. Private void Varying_Number_Max()
  562. {
  563.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  564.     
  565.     if ( arg_count >= 2 )
  566.     {
  567.         Value_Register = Top(arg_count);
  568.         Iterate_Over_Operands( arg_count , Num_Ops.Number_Max );
  569.     }
  570.     else if (arg_count == 1 )
  571.     {
  572.         Value_Register = Top(1);
  573.     }
  574.     else 
  575.         Display_Error( "At least 1 argument required in: " ,
  576.                    Expression_Register );
  577. }
  578.  
  579.  
  580.  
  581. Private void Varying_Number_GCD()
  582. {
  583.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  584.     
  585.     if ( arg_count >= 2 )
  586.     {
  587.         Value_Register = Top(arg_count);
  588.         Iterate_Over_Operands( arg_count, Num_Ops.Number_GCD );
  589.     }
  590.     else if ( arg_count == 1 )
  591.     {
  592.         Make_Fixnum_Number( 0 );
  593.         Iterate_Over_Operands( 2 , Num_Ops.Number_GCD );
  594.     }
  595.     else
  596.         Make_Fixnum_Number( 0 );
  597. }
  598.  
  599.  
  600.  
  601. Private void Varying_Number_LCM()
  602. {
  603.     Integer arg_count = Get_Apply_Numargs( Expression_Register );
  604.     
  605.     if ( arg_count >= 2 )
  606.     {
  607.         Value_Register = Top(arg_count);
  608.         Iterate_Over_Operands( arg_count, Num_Ops.Number_LCM );
  609.     }
  610.     else if ( arg_count == 1 )
  611.     {
  612.         Make_Fixnum_Number( 0 );
  613.         Iterate_Over_Operands( 2 , Num_Ops.Number_LCM );
  614.     }
  615.     else
  616.         Make_Fixnum_Number( 1 );
  617. }
  618.  
  619.  
  620.  
  621. Public void Number_Add()
  622. {
  623.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  624.  
  625.     (*(Num_Ops.Number_Add[Get_Number_Tower_Position( Top(1) )]))();
  626.  
  627.     Demote() ;        /* To lowest possible position (in Value_Register) */
  628. }
  629.  
  630.                     
  631.  
  632.  
  633. Public void Number_Subtract()
  634. {
  635.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  636.  
  637.     (*(Num_Ops.Number_Subtract[Get_Number_Tower_Position( Top(1) )]))();
  638.  
  639.     Demote() ;        /* To lowest possible position (in Value_Register) */
  640. }
  641.  
  642.                     
  643.  
  644.  
  645. Public void Number_Multiply()
  646. {
  647.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  648.  
  649.     (*(Num_Ops.Number_Multiply[Get_Number_Tower_Position( Top(1) )]))();
  650.  
  651.     Demote() ;        /* To lowest possible position (in Value_Register) */
  652. }
  653.  
  654.                     
  655.  
  656.  
  657. Public void Number_Divide()
  658. {
  659.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  660.  
  661.     (*(Num_Ops.Number_Divide[Get_Number_Tower_Position( Top(1) )]))();
  662.  
  663.     Demote() ;        /* To lowest possible position (in Value_Register) */
  664. }
  665.  
  666.                     
  667.  
  668.  
  669. Public void Number_Quotient()
  670. {
  671.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  672.  
  673.     (*(Num_Ops.Number_Quotient[Get_Number_Tower_Position( Top(1) )]))();
  674.  
  675.     Demote() ;        /* To lowest possible position (in Value_Register) */
  676. }
  677.  
  678.                     
  679.  
  680.  
  681. Public void Number_Remainder()
  682. {
  683.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  684.  
  685.     (*(Num_Ops.Number_Remainder[Get_Number_Tower_Position( Top(1) )]))();
  686.  
  687.     Demote() ;        /* To lowest possible position (in Value_Register) */
  688. }
  689.  
  690.                     
  691.  
  692.  
  693. Public void Number_Modulo()
  694. {
  695.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  696.  
  697.     (*(Num_Ops.Number_Modulo[Get_Number_Tower_Position( Top(1) )]))();
  698.  
  699.     Demote() ;        /* To lowest possible position (in Value_Register) */
  700. }
  701.  
  702.  
  703.  
  704. Public void Number_Negate()
  705. {
  706.     (*(Num_Ops.Number_Negate[Get_Number_Tower_Position( Top(1) )]))();
  707.  
  708.     Demote() ;    /* To lowest possible position (in Value_Register) */
  709. }
  710.  
  711.  
  712.  
  713. Public void Number_Abs()
  714. {
  715.     (*(Num_Ops.Number_Abs[Get_Number_Tower_Position( Top(1) )]))();
  716.  
  717.     Demote() ;    /* To lowest possible position (in Value_Register) */
  718. }
  719.  
  720.                     
  721.  
  722.  
  723. Public void Number_Numerator()
  724. {
  725.     (*(Num_Ops.Number_Numerator[Get_Number_Tower_Position( Top(1) )]))();
  726.  
  727.     Demote() ;    /* To lowest possible position (in Value_Register) */
  728. }
  729.  
  730.  
  731.  
  732. Public void Number_Denominator()
  733. {
  734.     (*(Num_Ops.Number_Denominator[Get_Number_Tower_Position( Top(1) )]))();
  735.  
  736.     Demote() ;    /* To lowest possible position (in Value_Register) */
  737. }
  738.  
  739.  
  740. /*
  741. Private void SS( label )
  742.  
  743.     String    label;
  744. {
  745.     Integer    i;
  746.     Output( "\n" );
  747.     Output( label );
  748.     Output( ": " );
  749.     for ( i = 1 ; i <= 10 && i <= Arg_Stack_Ptr; i++ )
  750.     {
  751.         Show_Object( Top(i) , 12 );
  752.         Output( ", " );
  753.     }
  754. }
  755. */
  756.  
  757.  
  758.  
  759. Private void Real_To_Integer( real )
  760.  
  761.     Double real;
  762. {
  763.     Double  quotient;
  764.     Integer remainder;
  765.     quotient = floor( real / RADIX );
  766.     remainder = real - (quotient * RADIX);
  767.  
  768.     Integer_To_Number( remainder );
  769.  
  770.     if ( quotient > 0.0 )
  771.     {
  772.         Push( Value_Register );
  773.         Real_To_Integer( quotient );
  774.         Push( Value_Register );
  775.         Integer_To_Number( RADIX );
  776.         Push( Value_Register );
  777.         Number_Multiply(); 
  778.         Pop( 2 );
  779.         Push( Value_Register );
  780.         Number_Add(); 
  781.         Pop( 2 );
  782.     }
  783. }
  784.     
  785.  
  786. Public void SS( label )
  787.     String    label;
  788. {
  789.     Integer i;
  790.     Output( "\n" ); Output( label ); Output( ": " );
  791.     for ( i = 1; i <= 8 && i <= Arg_Stack_Ptr; i++ );
  792.     {
  793.         Show_Object( Top(i), 1 ); 
  794.         if ( i < 8 && i < Arg_Stack_Ptr ) Output( ", " );
  795.     }
  796.  
  797. }
  798.  
  799.  
  800. Public void Number_Rationalize()    /* (rationalize x eps) */
  801. {
  802.     Boolean negative_input = FALSE;
  803.     Boolean exact = Is_Exact_Number( Top(1) ) && Is_Exact_Number( Top(2) );
  804.  
  805.     /* Check Domains of Inputs */
  806.  
  807.     if  ( Is_Complex(Top(1)) )
  808.     {
  809.         Display_Error( "Complex argument to rationalize: " , Top(1) );
  810.     }
  811.     else if  ( Is_Complex(Top(2)) )
  812.     {
  813.         Display_Error( "Complex argument to rationalize: " , Top(2) );
  814.     }
  815.  
  816.     /* Work with absolute values */
  817.  
  818.     Push( Top( 1 ) );
  819.     Number_Abs(); Pop(1);
  820.     Replace( 1 , Value_Register );    /* |eps| */
  821.     Push( Top(2) );
  822.     Is_Number_Negative(); Pop(1);
  823.     negative_input = (Value_Register == The_True_Object);
  824.     Push( Top( 2 ) );
  825.     Number_Abs(); Pop(1);
  826.     Replace( 2 , Value_Register );    /* |x| */
  827.  
  828.     /* Construct the continued fraction */
  829.  
  830.     Push( Value_Register );        /* y = x */
  831.     Push( Value_Register );
  832.     Number_Truncate(); Pop(1);
  833.     if ( Is_Real( Value_Register ) )
  834.     {
  835.         Real_To_Integer( Get_Number_Real_Value( Value_Register ) );
  836.     }
  837.     Push( Value_Register );        /* a = truncate( |x| */
  838.     Push( Value_Register );        /* num = truncate( |x| ) */
  839.     Integer_To_Number( 1 );
  840.     Push( Value_Register );        /* den = 1 */
  841.     Push( Value_Register );        /* oldnum = 1 */
  842.     Integer_To_Number( 0 );    
  843.     Push( Value_Register );        /* oldden = 0 */
  844.  
  845.     /* Stack =  oldden, oldnum, den, num, a, y, |epsilon|, |x| */
  846.  
  847.     while ( TRUE )
  848.     {
  849.         /* Rational found when |x - num/den| <= |epsilon| */
  850.  
  851.         Push( Top(3) );
  852.         Is_Number_Zero(); Pop(1);
  853.         if ( Value_Register == The_False_Object )
  854.         {
  855.             /* den != 0  */
  856.  
  857.             Push( Top(8) );    /* x */
  858.             Push( Top(5) );    /* num */
  859.             Push( Top(5) );    /* den */
  860.             Make_Rational_Number(); Pop(2);
  861.             Push( Value_Register );
  862.             Number_Subtract();  Pop(2);
  863.             Push( Value_Register );
  864.             Number_Abs(); Pop(1);
  865.             Push( Value_Register );    /* |x - num/den| */
  866.             Push( Top(8) );        /* |epsilon| */
  867.             Number_Less_Than_Or_Equal(); Pop(2);
  868.  
  869.             if ( Value_Register == The_True_Object )
  870.             {
  871.                 /* |x - num/den| <= |epsilon| */
  872.  
  873.                 Push( Top(4) );    /* num */
  874.                 Push( Top(4) );    /* den */
  875.                 Make_Rational_Number();    /* num/den */
  876.                 Pop(2);
  877.  
  878.                 /* Negate if necessary */
  879.         
  880.                 if ( negative_input )
  881.                 {
  882.                     Push( Value_Register );
  883.                     Number_Negate(); Pop(1);
  884.                 }
  885.                 Is_Exact_Number( Value_Register ) = exact;
  886.                 Pop(6);
  887.                 return;
  888.             }
  889.         }
  890.  
  891.         /* Otherwise, compute the next fraction */
  892.  
  893.         /* Stack =  oldden, oldnum, den, num, a, y, |epsilon|, |x| */
  894.  
  895.         Integer_To_Number( 1 );
  896.         Push( Value_Register );    /* 1 */
  897.         Push( Top(7) );        /* y */
  898.         Push( Top(7) );        /* a */
  899.         Number_Subtract(); Pop(2);
  900.         Push( Value_Register );
  901.         Number_Divide(); Pop(2);
  902.         Replace( 6 , Value_Register );    /* y = 1/(y - a)  */
  903.  
  904.         Push( Value_Register );
  905.         Number_Truncate(); Pop(1);
  906.         if ( Is_Real( Value_Register ) )
  907.         {
  908.             Real_To_Integer( Get_Number_Real_Value( Value_Register ) );
  909.         }
  910.         Replace( 5 , Value_Register );    /* a = truncate( y )  */
  911.  
  912.         Push( Top(2) );    /* oldnum */
  913.         Push( Top(6) );    /* a */
  914.         Push( Top(6) ); /* num */
  915.         Number_Multiply(); Pop(2);
  916.         Push( Value_Register );
  917.         Number_Add(); Pop(2);        /* newnum = oldnum + a * num  */
  918.  
  919.         Replace( 2 , Top(4) );        /* oldnum = num  */
  920.         Replace( 4 , Value_Register );    /* num = newnum  */
  921.  
  922.         Push( Top(1) );    /* oldden */
  923.         Push( Top(6) );    /* a */
  924.         Push( Top(5) ); /* den */
  925.         Number_Multiply(); Pop(2);
  926.         Push( Value_Register );
  927.         Number_Add(); Pop(2);        /* newden = oldden + a * den  */
  928.  
  929.         Replace( 1 , Top(3) );        /* oldden = den  */
  930.         Replace( 3 , Value_Register );    /* den = newden  */
  931.     }
  932. }
  933.  
  934.  
  935.  
  936. Public void Number_Max()
  937. {
  938.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  939.  
  940.     (*(Num_Ops.Number_Max[Get_Number_Tower_Position( Top(1) )]))();
  941.  
  942.     Demote() ;        /* To lowest possible position (in Value_Register) */
  943. }
  944.  
  945.                     
  946.  
  947.  
  948. Public void Number_Min()
  949. {
  950.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  951.  
  952.     (*(Num_Ops.Number_Min[Get_Number_Tower_Position( Top(1) )]))();
  953.  
  954.     Demote() ;        /* To lowest possible position (in Value_Register) */
  955. }
  956.  
  957.                     
  958.  
  959.  
  960. Public void Number_GCD()
  961. {
  962.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  963.  
  964.     (*(Num_Ops.Number_GCD[Get_Number_Tower_Position( Top(1) )]))();
  965.  
  966.     Demote() ;        /* To lowest possible position (in Value_Register) */
  967. }
  968.  
  969.  
  970.  
  971. Public void Number_LCM()
  972. {
  973.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  974.  
  975.     (*(Num_Ops.Number_LCM[Get_Number_Tower_Position( Top(1) )]))();
  976.  
  977.     Demote() ;        /* To lowest possible position (in Value_Register) */
  978. }
  979.  
  980.  
  981.  
  982.  
  983. Public void Number_Floor()
  984. {
  985.     (*(Num_Ops.Number_Floor[Get_Number_Tower_Position( Top(1) )]))();
  986.  
  987.     Demote() ;    /* To lowest possible position (in Value_Register) */
  988. }
  989.  
  990.  
  991.  
  992. Public void Number_Ceiling()
  993. {
  994.     (*(Num_Ops.Number_Ceiling[Get_Number_Tower_Position( Top(1) )]))();
  995.  
  996.     Demote() ;    /* To lowest possible position (in Value_Register) */
  997. }
  998.  
  999.  
  1000.  
  1001. Public void Number_Truncate()
  1002. {
  1003.     (*(Num_Ops.Number_Truncate[Get_Number_Tower_Position( Top(1) )]))();
  1004.  
  1005.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1006. }
  1007.  
  1008.  
  1009.  
  1010. Public void Number_Round()
  1011. {
  1012.     (*(Num_Ops.Number_Round[Get_Number_Tower_Position( Top(1) )]))();
  1013.  
  1014.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1015. }
  1016.  
  1017.  
  1018.  
  1019.  
  1020. Public void Number_Sqrt()
  1021. {
  1022.     (*(Num_Ops.Number_Sqrt[Get_Number_Tower_Position( Top(1) )]))();
  1023.  
  1024.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1025. }
  1026.  
  1027.  
  1028.  
  1029. Public void Number_Exp()
  1030. {
  1031.     (*(Num_Ops.Number_Exp[Get_Number_Tower_Position( Top(1) )]))();
  1032.  
  1033.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1034. }
  1035.  
  1036.  
  1037.  
  1038. Public void Number_Log()
  1039. {
  1040.     (*(Num_Ops.Number_Log[Get_Number_Tower_Position( Top(1) )]))();
  1041.  
  1042.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1043. }
  1044.  
  1045.  
  1046.  
  1047. Public void Number_Expt()
  1048. {
  1049.     /* Must check one domain restriction here before coercion occurs */
  1050.  
  1051.     if(Get_Number_Tower_Position(Top(1)) > BIGNUM_LEVEL)
  1052.     {
  1053.         Push(Top(2));
  1054.         Is_Number_Negative();
  1055.         if(Value_Register == The_True_Object)
  1056.         {
  1057.             Pop(1);
  1058.         Error("Domain error for expt");
  1059.         }
  1060.         Pop(1);
  1061.     }
  1062.  
  1063.     /* Don't coerce args.  Pick specific routine based only on exponent */
  1064.  
  1065.     (*(Num_Ops.Number_Expt[Get_Number_Tower_Position( Top(1) )]))();
  1066.  
  1067.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1068. }
  1069.  
  1070.  
  1071.  
  1072. Public void Number_Sin()
  1073. {
  1074.     (*(Num_Ops.Number_Sin[Get_Number_Tower_Position( Top(1) )]))();
  1075.  
  1076.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1077. }
  1078.  
  1079.  
  1080.  
  1081.  
  1082. Public void Number_Cos()
  1083. {
  1084.     (*(Num_Ops.Number_Cos[Get_Number_Tower_Position( Top(1) )]))();
  1085.  
  1086.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1087. }
  1088.  
  1089.  
  1090.  
  1091. Public void Number_Tan()
  1092. {
  1093.     (*(Num_Ops.Number_Tan[Get_Number_Tower_Position( Top(1) )]))();
  1094.  
  1095.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1096. }
  1097.  
  1098.  
  1099.  
  1100. Public void Number_Asin()
  1101. {
  1102.     (*(Num_Ops.Number_Asin[Get_Number_Tower_Position( Top(1) )]))();
  1103.  
  1104.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1105. }
  1106.  
  1107.  
  1108.  
  1109. Public void Number_Acos()
  1110. {
  1111.     (*(Num_Ops.Number_Acos[Get_Number_Tower_Position( Top(1) )]))();
  1112.  
  1113.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1114. }
  1115.  
  1116.  
  1117.  
  1118. Public void Number_Atan()
  1119. {
  1120.     (*(Num_Ops.Number_Atan[Get_Number_Tower_Position( Top(1) )]))();
  1121.  
  1122.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1123. }
  1124.  
  1125.  
  1126.  
  1127. Public void Number_Atan2()
  1128. {
  1129.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  1130.  
  1131.     (*(Num_Ops.Number_Atan2[Get_Number_Tower_Position( Top(1) )]))();
  1132.  
  1133.     Demote() ;        /* To lowest possible position (in Value_Register) */
  1134. }
  1135.  
  1136.  
  1137.  
  1138. Public void Number_Exact_To_Inexact()
  1139. {
  1140.     (*(Num_Ops.Number_Exact_To_Inexact[Get_Number_Tower_Position( Top(1) )]))();
  1141.  
  1142.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1143. }
  1144.  
  1145.  
  1146.  
  1147. Public void Number_Inexact_To_Exact()
  1148. {
  1149.     (*(Num_Ops.Number_Inexact_To_Exact[Get_Number_Tower_Position( Top(1) )]))();
  1150.  
  1151.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1152. }
  1153.  
  1154.  
  1155.  
  1156. Public void Number_To_String()
  1157. {
  1158.     (*(Num_Ops.Number_To_String[Get_Number_Tower_Position( Top(2) )]))();
  1159. }
  1160.  
  1161.                     
  1162.  
  1163. Public void Number_Make_Rectangular()
  1164. {
  1165.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  1166.  
  1167.     (*(Num_Ops.Number_Make_Rectangular[Get_Number_Tower_Position( Top(1) )]))();
  1168.  
  1169.     Demote() ;        /* To lowest possible position (in Value_Register) */
  1170. }
  1171.  
  1172.  
  1173.  
  1174. Public void Number_Make_Polar()
  1175. {
  1176.     Coerce_Args();    /* Promote arg of lower tower posn to posn of other. */
  1177.  
  1178.     (*(Num_Ops.Number_Make_Polar[Get_Number_Tower_Position( Top(1) )]))();
  1179.  
  1180.     Demote() ;        /* To lowest possible position (in Value_Register) */
  1181. }
  1182.  
  1183.  
  1184.  
  1185. Public void Number_Real_Part()
  1186. {
  1187.     (*(Num_Ops.Number_Real_Part[Get_Number_Tower_Position( Top(1) )]))();
  1188.  
  1189.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1190. }
  1191.  
  1192.  
  1193.  
  1194. Public void Number_Imaginary_Part()
  1195. {
  1196.     (*(Num_Ops.Number_Imaginary_Part[Get_Number_Tower_Position( Top(1) )]))();
  1197.  
  1198.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1199. }
  1200.  
  1201.  
  1202.  
  1203. Public void Number_Magnitude()
  1204. {
  1205.     (*(Num_Ops.Number_Magnitude[Get_Number_Tower_Position( Top(1) )]))();
  1206.  
  1207.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1208. }
  1209.  
  1210.  
  1211.  
  1212. Public void Number_Angle()
  1213. {
  1214.     (*(Num_Ops.Number_Angle[Get_Number_Tower_Position( Top(1) )]))();
  1215.  
  1216.     Demote() ;    /* To lowest possible position (in Value_Register) */
  1217. }
  1218.  
  1219.  
  1220.  
  1221. Public Integer Number_Sign(num)
  1222.     Object num;
  1223.  
  1224. {
  1225.     Tower_Position argtype = Get_Number_Tower_Position(num);
  1226.  
  1227.     if( argtype == FIXNUM_LEVEL )
  1228.     {
  1229.         return ((Integer) (Get_Number_Fixnum_Value(num)) );
  1230.     }
  1231.  
  1232.     else if (argtype == BIGNUM_LEVEL)
  1233.     {
  1234.         return (Get_Number_Digit((num), Get_Number_Length(num) -1));
  1235.     }
  1236.  
  1237.     else
  1238.     {
  1239.         Panic("Incorrect argument for Number_Sign");
  1240.         return 0;
  1241.     }
  1242.  
  1243. }
  1244.  
  1245. /* PROMOTION */
  1246.  
  1247. Private void Coerce_Args()
  1248. {
  1249.     /* Coerce Argument of lower tower position to the (higher) position
  1250.        of the other argument.
  1251.     */
  1252.  
  1253.     Tower_Position    p1 = Get_Number_Tower_Position( Top(1) ),
  1254.             p2 = Get_Number_Tower_Position( Top(2) );
  1255.     if (p1 != p2)
  1256.     {
  1257.         if (p1 < p2)
  1258.             Promote( 1 , p2 );
  1259.         else
  1260.             Promote( 2 , p1 );
  1261.     }
  1262. }
  1263.  
  1264. Private void Coerce_Relational_Args()
  1265. {
  1266.     /* Coerce Argument of lower tower position to the (higher) position
  1267.        of the other argument.
  1268.     */
  1269.  
  1270.     Tower_Position    p1 = Get_Number_Tower_Position( Top(1) ),
  1271.             p2 = Get_Number_Tower_Position( Top(2) );
  1272.  
  1273.     if (p1 != p2)
  1274.     {
  1275.         /* If comparing inexacts to exacts then we want to 
  1276.            force the inexacts to be exacts */
  1277.  
  1278.         if (p1 == REAL_LEVEL && p2 <= RATIONAL_LEVEL)
  1279.         {
  1280.             Number_Inexact_To_Exact();
  1281.             Replace( 1 , Value_Register );
  1282.         }
  1283.         else if (p2 == REAL_LEVEL && p1 <= RATIONAL_LEVEL)
  1284.         {
  1285.             Push( Top(2) );
  1286.             Number_Inexact_To_Exact(); Pop(1);
  1287.             Replace( 2 , Value_Register );
  1288.         }
  1289.  
  1290.         p1 = Get_Number_Tower_Position( Top(1) );
  1291.                p2 = Get_Number_Tower_Position( Top(2) );
  1292.  
  1293.         if (p1 < p2)
  1294.             Promote( 1 , p2 );
  1295.         else if (p2 < p1)
  1296.             Promote( 2 , p1 );
  1297.     }
  1298. }
  1299.  
  1300.  
  1301. /* Promote a number to the indicated tower_position |level|. */
  1302.  
  1303. Public void Promote( stkpos, level)
  1304.     
  1305.     Integer     stkpos;
  1306.         Tower_Position level;
  1307.         
  1308. {
  1309.  
  1310.     switch (Get_Number_Tower_Position(Top(stkpos)))                
  1311.     {
  1312.             case FIXNUM_LEVEL:
  1313.                 {
  1314.                     if (level == FIXNUM_LEVEL) break;
  1315.  
  1316.  
  1317.             else if (level == REAL_LEVEL)
  1318.             {
  1319.                 Short val ;
  1320.                 val = Get_Number_Fixnum_Value(Top(stkpos));
  1321.                 Make_Real_Number( (Double) val);
  1322.                 Replace( stkpos , Value_Register );
  1323.                 break;
  1324.             }
  1325.             else
  1326.             {
  1327.                 Make_Bignum_Number(1);
  1328.                 Get_Number_Digit(Value_Register,0) = 
  1329.                     Get_Number_Fixnum_Value( Top(stkpos) );
  1330.                 Replace( stkpos , Value_Register );
  1331.             }
  1332.                 }
  1333.  
  1334.             case BIGNUM_LEVEL:
  1335.                 {
  1336.                     if (level == BIGNUM_LEVEL) break;
  1337.  
  1338.             else if (level == REAL_LEVEL)
  1339.             {
  1340.                 Double temp_real = 0;
  1341.                 Integer this_digit;
  1342.                 Double    cumulative_radix = 1.0;
  1343.                 Object    num = Top(stkpos);
  1344.  
  1345.                 for (this_digit = 0; 
  1346.                     this_digit < Get_Number_Length(num); 
  1347.                     this_digit++)
  1348.                 {
  1349.                     temp_real += 
  1350.                     cumulative_radix *
  1351.                       ((Get_Number_Digit(num,this_digit)>=0)
  1352.                            ?  Get_Number_Digit(num,this_digit)
  1353.                            : -Get_Number_Digit(num,this_digit));
  1354.                     cumulative_radix *= RADIX;
  1355.                 }
  1356.  
  1357.                 if (Number_Sign(num) < 0)
  1358.                     temp_real = - temp_real;
  1359.  
  1360.                 Make_Real_Number(temp_real);
  1361.                 Replace( stkpos , Value_Register );
  1362.                 break;
  1363.             }
  1364.             else
  1365.             {
  1366.                 Push( Top(stkpos) );
  1367.                 Make_Small_Bignum( 1 );
  1368.                 Push( Value_Register );
  1369.                 Make_Rational_Number();
  1370.                 Pop( 2 );
  1371.                 Replace( stkpos , Value_Register );
  1372.             }
  1373.                 }
  1374.  
  1375.         case RATIONAL_LEVEL:
  1376.                 {
  1377.                     if (level == RATIONAL_LEVEL) break;
  1378.  
  1379.             Push( Get_Number_Rational_Numerator( Top(stkpos) ) );
  1380.             Push( Get_Number_Rational_Denominator( Top(stkpos+1) ) );
  1381.             Promote( 1 , REAL_LEVEL );
  1382.             Promote( 2 , REAL_LEVEL );
  1383.             Real_Divide();
  1384.             Pop( 2 );
  1385.             Replace( stkpos , Value_Register );
  1386.                 }
  1387.  
  1388.             case REAL_LEVEL:
  1389.                 {
  1390.                     if (level == REAL_LEVEL) break;
  1391.  
  1392.             Make_Complex_Number(Get_Number_Real_Value(Top(stkpos)),
  1393.                             0.0 );
  1394.             Replace( stkpos , Value_Register );
  1395.                 }
  1396.             case COMPLEX_LEVEL:
  1397.                 {
  1398.                     if (level == COMPLEX_LEVEL) break;
  1399.  
  1400.                 Panic("Unknown level to promote in promoting routine.");
  1401.                 }
  1402.  
  1403.         default: 
  1404.             Panic("Unknown tower position in promoting routine");
  1405.                 
  1406.     }
  1407.         
  1408. }        
  1409.  
  1410.  
  1411. /* DEMOTION */
  1412.  
  1413. /* Demote a number to the lowest tower position such that its value
  1414. does not lose anything, i.e., that if you promoted it again to the same level,
  1415. it would be the same value. */
  1416.  
  1417. Public void Demote()
  1418. {
  1419.  
  1420.     switch (Get_Number_Tower_Position( Value_Register ))
  1421.         {
  1422.         case COMPLEX_LEVEL:             
  1423.                         Demote_Complex_To_Real();
  1424.             break;
  1425.  
  1426.         case REAL_LEVEL:             
  1427.             break;    /* Retaining inexactness */
  1428.  
  1429.         case RATIONAL_LEVEL:
  1430.                         Demote_Rational_To_Integer();
  1431.             break;
  1432.  
  1433.             case BIGNUM_LEVEL:
  1434.                         Demote_Bignum_To_Fixnum();
  1435.             break;
  1436.  
  1437.                 case FIXNUM_LEVEL: 
  1438.             break;
  1439.  
  1440.                 default: Panic("Unknown tower position in demote routine");
  1441.         }
  1442. }
  1443.  
  1444.  
  1445.  
  1446.  
  1447. Private void Demote_Complex_To_Real()
  1448. {
  1449.  
  1450.     if (Get_Number_Complex_Imaginary_Part(Value_Register) == 0.0)
  1451.     {
  1452.         Make_Real_Number(Get_Number_Complex_Real_Part(Value_Register));
  1453.     }
  1454. }        
  1455.  
  1456.  
  1457.  
  1458.  
  1459. Private void Demote_Rational_To_Integer()
  1460. {
  1461.     Object    denominator = Get_Number_Rational_Denominator( Value_Register );
  1462.     
  1463.     if ( Get_Number_Tower_Position( denominator ) == FIXNUM_LEVEL
  1464.         && Get_Number_Fixnum_Value( denominator ) == 1 )
  1465.     {
  1466.         Value_Register = Get_Number_Rational_Numerator(Value_Register);
  1467.     }
  1468. }
  1469.  
  1470.  
  1471.  
  1472. Private void Demote_Bignum_To_Fixnum()
  1473. {
  1474.     if (Get_Number_Length(Value_Register) == 1)
  1475.     {
  1476.         Make_Fixnum_Number(
  1477.             (Short) Get_Number_Digit(Value_Register, 0));
  1478.     }
  1479. }
  1480.  
  1481.  
  1482.  
  1483. /* MISC TRANSFER FUNCTIONS */
  1484.  
  1485. Public void Integer_To_Number(n)
  1486.  
  1487.     Integer n;
  1488. {
  1489.     if ( abs( n ) >= RADIX )
  1490.         Integer_To_Bignum( n );
  1491.     else 
  1492.         Make_Fixnum_Number( n );
  1493. }
  1494.  
  1495.  
  1496.  
  1497. Public Integer Number_To_Integer(num)
  1498.  
  1499.    Object num;
  1500.  
  1501. {
  1502.     if ( Get_Number_Tower_Position( num ) == FIXNUM_LEVEL )
  1503.     {
  1504.         return( (Integer) Get_Number_Fixnum_Value( num ));
  1505.     }
  1506.     else if ( Get_Number_Tower_Position( num ) == BIGNUM_LEVEL )
  1507.     {
  1508.         return Bignum_To_Integer(num);
  1509.     }
  1510.     else
  1511.     {
  1512.         Display_Error("Integer wanted where non-integer supplied:",num);
  1513.         return( 0 );
  1514.     }
  1515. }   
  1516.  
  1517.  
  1518.  
  1519. Public    String    Integer_To_Cstring( N , S , Radix , Zero_Padding )
  1520.  
  1521.     Integer    N;
  1522.     String    S;
  1523.     Integer    Radix;
  1524.     Integer    Zero_Padding;
  1525. {
  1526.     Boolean    negative = ( N < 0 );
  1527.     Integer    integral = (N < 0) ? -N : N;
  1528.     Integer    quotient = 0;
  1529.     Integer    digit;
  1530.     Integer digits = 0;
  1531.     Integer    index = MAX_CHARS_PER_INT;
  1532.  
  1533.     S[--index] = '\0';
  1534.  
  1535.     do
  1536.     {
  1537.         quotient = integral / Radix ;
  1538.         digit = integral - (quotient * Radix);
  1539.         integral = quotient;
  1540.         S[--index] = (Character) (digit<=9 ? digit+'0' : digit-10+'a');
  1541.         digits++;
  1542.     } while ( integral );
  1543.     if ( negative ) S[--index] = '-';
  1544.  
  1545.     if ( Zero_Padding )
  1546.     {
  1547.         /* We want to pad the number to the left with 0's  */
  1548.  
  1549.         while ( digits++ < Zero_Padding )
  1550.             S[--index] = '0';
  1551.     }
  1552.  
  1553.     return( &S[index] );
  1554. }
  1555.  
  1556. /* STRING-TO-NUMBER CONVERSION */
  1557.  
  1558. Private    String    String_To_Complex();
  1559. Private    String    String_To_Ureal();
  1560. Private    String    String_To_Uinteger();
  1561. Private    String    String_To_Ufractional();
  1562. Private Boolean    Legal_Digit();
  1563. Private    Integer    Digit_Value();
  1564.  
  1565. typedef    enum
  1566. {
  1567.     EXACT, INEXACT, UNDEFINED
  1568. } Exacttype;
  1569.  
  1570.  
  1571. Private void String_To_Number()
  1572. {
  1573.     String    S = Get_String_Value( Top(2) );
  1574.     Integer    Radix = Number_To_Integer( Top(1) );
  1575.  
  1576.     Cstring_To_Number( S , Radix );
  1577. }
  1578.  
  1579.  
  1580. Public    void Cstring_To_Number( S , Radix )
  1581.  
  1582.     String    S;
  1583.     Integer Radix;
  1584. {
  1585.     /* <num R>    ->  <prefix R> <complex R> */
  1586.  
  1587.     String    original;
  1588.     Integer precision = 0;
  1589.     Exacttype exactness = UNDEFINED;
  1590.     original = S;
  1591.  
  1592.     /* Look for <prefix> */
  1593.  
  1594.     while ( *S == '#' )
  1595.     {
  1596.         S++;
  1597.         switch( *S++ )
  1598.         {
  1599.         case  'b':
  1600.             if ( ! Radix ) Radix = 2;
  1601.             else Error1( "Inconsistent radix in: %s", original );
  1602.             break;
  1603.  
  1604.         case  'o':
  1605.             if ( ! Radix ) Radix = 8;
  1606.             else Error1( "Inconsistent radix in: %s", original );
  1607.             break;
  1608.  
  1609.         case  'd':
  1610.             if ( ! Radix ) Radix = 10;
  1611.             else Error1( "Inconsistent radix in: %s", original );
  1612.             break;
  1613.  
  1614.         case  'x':
  1615.             if ( ! Radix ) Radix = 16;
  1616.             else Error1( "Inconsistent radix in: %s", original );
  1617.             break;
  1618.  
  1619.         case  'i':
  1620.             if ( exactness  != UNDEFINED ) exactness = INEXACT;
  1621.             else Error1( "Inconsistent exactness in: %s", original );
  1622.             break;
  1623.  
  1624.         case  'e':
  1625.             if ( exactness != UNDEFINED ) exactness = EXACT;
  1626.             else Error1( "Inconsistent exactness in: %s", original );
  1627.             break;
  1628.  
  1629.         case  's':
  1630.             if ( ! precision ) precision = 1;
  1631.             else Error1( "Inconsistent precision in: %s", original );
  1632.             break;
  1633.  
  1634.         case  'l':
  1635.             if ( ! precision ) precision = 2;
  1636.             else Error1( "Inconsistent precision in: %s", original );
  1637.             break;
  1638.  
  1639.         default:
  1640.             Error1( "Unknown prefix in: %s", original );
  1641.             break;
  1642.         }
  1643.     }
  1644.     if ( ! Radix ) Radix = 10;    /* by default */
  1645.  
  1646.     S = String_To_Complex( original , S , Radix );
  1647.     Demote();
  1648.  
  1649.     if ( *S )
  1650.     {
  1651.         Error1( "Ill-formed numeric constant: <%s>", original );
  1652.     }
  1653.  
  1654.     /* Finally, take account of any #e/#i prefix */
  1655.  
  1656.     if ( exactness == INEXACT && Is_Exact_Number( Value_Register ) )
  1657.     {
  1658.         Push( Value_Register );
  1659.         Number_Exact_To_Inexact(); Pop(1);
  1660.     }
  1661.     else if ( exactness == EXACT && !Is_Exact_Number( Value_Register ) )
  1662.     {
  1663.         Push( Value_Register );
  1664.         Number_Inexact_To_Exact(); Pop(1);
  1665.     }
  1666. }
  1667.  
  1668.  
  1669.  
  1670. Private    String String_To_Complex( Original ,  S , Radix )
  1671.  
  1672.     String    Original;
  1673.     String    S;
  1674.     Integer    Radix;
  1675. {
  1676.     /*  <complex R>    ->  +i  |  -i  |  <real R>  |  <real R> @ <real R>   
  1677.             |   <real R> [+|-] <ureal R> i  |  <real R> [+|-] i
  1678.             |   <real R> i
  1679.  
  1680.         <real R>    ->  {+|-} <ureal R>
  1681.     */
  1682.  
  1683.     Boolean    negative1 = FALSE;
  1684.     Boolean negative2 = FALSE;
  1685.  
  1686.     /* Possible sign */
  1687.  
  1688.     if ( *S == '+' ) 
  1689.     {
  1690.         S++ ;
  1691.         /* Simple imaginary? */
  1692.         if ( *S == 'i' )
  1693.         {
  1694.             S++;
  1695.             Make_Complex_Number( 0.0 , 1.0 );
  1696.             return( S );
  1697.         }
  1698.     }
  1699.     else if ( *S == '-' )
  1700.     {
  1701.         S++;
  1702.         negative1 = TRUE;
  1703.         /* Simple imaginary? */
  1704.         if ( *S == 'i' )
  1705.         {
  1706.             S++;
  1707.             Make_Complex_Number( 0.0 , -1.0 );
  1708.             return( S );
  1709.         }
  1710.     }
  1711.  
  1712.     S = String_To_Ureal( Original , S , Radix );
  1713.  
  1714.     if ( negative1 )
  1715.     {
  1716.         Push( Value_Register );
  1717.         Number_Negate(); Pop(1);
  1718.     }
  1719.  
  1720.     if ( *S )
  1721.     {
  1722.         Push( Value_Register );
  1723.         switch( *S++ )
  1724.         {
  1725.         case  '@':
  1726.             /* Possible sign */
  1727.  
  1728.             if ( *S == '+' ) 
  1729.                 S++ ;
  1730.             else if ( *S == '-' )
  1731.             {
  1732.                 S++;
  1733.                 negative2 = TRUE;
  1734.             }
  1735.  
  1736.             S = String_To_Ureal( Original , S , Radix );
  1737.             if ( negative2 )
  1738.             {
  1739.                 Push( Value_Register );
  1740.                 Number_Negate(); Pop(1);
  1741.             }
  1742.             Push( Value_Register );
  1743.             Promote( 1 , REAL_LEVEL );
  1744.             Promote( 2 , REAL_LEVEL );
  1745.             Make_Complex_Number(
  1746.                 cos( Get_Number_Real_Value( Top(1) ) )
  1747.                 * Get_Number_Real_Value( Top(2) ),
  1748.                 sin( Get_Number_Real_Value( Top(1) ) )
  1749.                 * Get_Number_Real_Value( Top(2) ) );
  1750.             Pop(2) ;
  1751.             return( S );
  1752.         case  '-':
  1753.             negative2 = TRUE;
  1754.         case  '+':
  1755.             if ( *S == 'i' )
  1756.             {
  1757.                 Make_Real_Number( negative2 ? -1.0 : 1.0 );
  1758.                 Push( Value_Register );
  1759.             }
  1760.             else
  1761.             {
  1762.                 S = String_To_Ureal( Original , S , Radix );
  1763.                 if ( negative2 )
  1764.                 {
  1765.                     Push( Value_Register );
  1766.                     Number_Negate(); Pop(1);
  1767.                 }
  1768.                 Push( Value_Register );
  1769.             }
  1770.             Promote( 1 , REAL_LEVEL );
  1771.             Promote( 2 , REAL_LEVEL );
  1772.             Make_Complex_Number( Get_Number_Real_Value( Top(2) ),
  1773.                          Get_Number_Real_Value( Top(1) ) );
  1774.             Pop(2);
  1775.             if ( *S++ != 'i') 
  1776.             {
  1777.                 Error1( "Ill-formed numeric constant: %s" , 
  1778.                     Original );
  1779.             }
  1780.             return( S );
  1781.  
  1782.         case 'i':
  1783.             Promote( 1 , REAL_LEVEL );
  1784.             Make_Complex_Number(0.0, Get_Number_Real_Value(Top(1)));
  1785.             Pop(1);
  1786.             return( S );
  1787.  
  1788.         default:
  1789.             Error1( "Ill-formed constant: <%s>", Original );
  1790.         }
  1791.     }
  1792.     return( S );
  1793. }
  1794.  
  1795.  
  1796. Private    String    String_To_Ureal( Original , S , Radix )
  1797.  
  1798.     String    Original;
  1799.     String    S;
  1800.     Integer    Radix;
  1801. {
  1802.     /*  <ureal R>    ->  <uinteger R>  |  <uinteger R> / <uinteger R>  
  1803.             |   <float R>
  1804.  
  1805.         <float R>    ->  <uinteger R> <suffix>  |  . <ufractional R> <suffix>
  1806.             |   <uinteger R> . <ufractional R> <suffix>
  1807.             |   . #* <suffix>
  1808.  
  1809.         <suffix>    ->  <empty>  |  <exp mark> {+|-} <digit R>+
  1810.  
  1811.         <exp mark>    ->  e  |  s  |  f  |  d  |  l
  1812.     */
  1813.  
  1814.     /* Scan first part of number */
  1815.  
  1816.     if ( *S  == '.' )
  1817.     {
  1818.         Make_Real_Number( 0.0 );
  1819.     }
  1820.     else
  1821.     {
  1822.         S = String_To_Uinteger( Original , S , Radix );
  1823.     }
  1824.  
  1825.     /* Is there more ? */
  1826.  
  1827.     if ( *S == '.' )
  1828.     {
  1829.         Push( Value_Register );
  1830.         if ( Radix != 10 )
  1831.         {
  1832.             Error1( "Non-decimal real: %s" , Original );
  1833.         }
  1834.         S++;
  1835.         S = String_To_Ufractional( Original , S , Radix );
  1836.         Push( Value_Register );
  1837.         Number_Add(); Pop(2);
  1838.     }
  1839.     else if ( *S == '/' )
  1840.     {
  1841.         Push( Value_Register );
  1842.         S++;
  1843.         S = String_To_Uinteger( Original , S , Radix );
  1844.         Push( Value_Register );
  1845.         Make_Rational_Number(); Pop(2);
  1846.         return( S );
  1847.     }
  1848.  
  1849.     if ( *S=='e' || *S=='s' || *S=='f' || *S=='d' || *S=='l' )
  1850.     {
  1851.         /* all exponent marks map to e in UMB Scheme */
  1852.  
  1853.         Boolean negative = FALSE;
  1854.  
  1855.         Push( Value_Register );
  1856.         Promote( 1 , REAL_LEVEL );
  1857.         if ( Radix != 10 ) 
  1858.         {
  1859.             Error1( "Non-decimal real: %s" , Original );
  1860.         }
  1861.  
  1862.         S++;
  1863.         Integer_To_Number( Radix );
  1864.         Push( Value_Register );            /* Radix */
  1865.  
  1866.         /* Possible sign */
  1867.  
  1868.         if ( *S == '+' ) 
  1869.             S++ ;
  1870.         else if ( *S == '-' )
  1871.         {
  1872.             S++;
  1873.             negative = TRUE;
  1874.         }
  1875.         S = String_To_Uinteger( Original , S , Radix );
  1876.         Push( Value_Register );
  1877.         if ( negative )
  1878.         {
  1879.             Number_Negate(); Pop(1);
  1880.             Push( Value_Register );
  1881.         }                    /* Exponent */
  1882.         
  1883.         Number_Expt(); Pop(2);
  1884.         Push( Value_Register );
  1885.         Number_Multiply(); Pop(2);
  1886.     }
  1887.     return( S );
  1888. }
  1889.  
  1890.  
  1891.  
  1892.  
  1893. Private    String    String_To_Uinteger( Original , S , Radix )
  1894.  
  1895.     String    Original;
  1896.     String    S;
  1897.     Integer    Radix;
  1898. {
  1899.     /*   <uinteger R>  ->  <digit R>+ #*   */
  1900.  
  1901.     if ( ! Legal_Digit( *S , Radix ) )
  1902.     {
  1903.         Error1( "Ill-formed numeric constant: <%s>" , Original );
  1904.     }
  1905.  
  1906.     Integer_To_Number( Digit_Value( *S++ ) );
  1907.     while ( Legal_Digit( *S , Radix ) )
  1908.     {
  1909.         Push( Value_Register );
  1910.         Integer_To_Number( Radix );
  1911.         Push( Value_Register );
  1912.         Number_Multiply(); Pop(2);
  1913.         Push( Value_Register );
  1914.         Integer_To_Number( Digit_Value( *S ) );
  1915.         Push( Value_Register );
  1916.         Number_Add(); Pop(2);
  1917.         S++;
  1918.     }
  1919.     while ( *S == '#' )
  1920.     {
  1921.         Push( Value_Register );
  1922.         Make_Real_Number( (Double) Radix );
  1923.         Push( Value_Register );
  1924.         Number_Multiply(); Pop(2);
  1925.         S++;
  1926.     }
  1927.     return( S );
  1928. }
  1929.  
  1930.  
  1931.  
  1932. Private    String    String_To_Ufractional( Original , S , Radix )
  1933.  
  1934.     String    Original;
  1935.     String    S;
  1936.     Integer    Radix;
  1937. {
  1938.     Double    fraction = 0.0;
  1939.     Double    factor = 1.0;
  1940.  
  1941.     while ( Legal_Digit( *S , Radix ) )
  1942.     {
  1943.         factor = factor / Radix;
  1944.         fraction += factor * Digit_Value( *S );
  1945.         S++;
  1946.     }
  1947.     while ( *S == '#' ) S++;
  1948.     Make_Real_Number( fraction );
  1949.     return( S );
  1950. }
  1951.  
  1952.  
  1953.  
  1954. Private    Boolean    Legal_Digit( Char , Radix )
  1955.  
  1956.     Character Char;
  1957.     Integer      Radix;
  1958. {
  1959.     Integer    val = Digit_Value( Char );
  1960.     return( val >= 0 && val < Radix );
  1961. }
  1962.  
  1963.  
  1964. Private    Boolean    Digit_Value( Char )
  1965.  
  1966.     Character Char;
  1967. {
  1968.     return(    isdigit( Char ) ? Char - '0' : Char - 'a' + 10 );
  1969. }
  1970.  
  1971. Public void Initialize_Number()
  1972. {
  1973.  
  1974.    Num_Ops.Is_Number_Zero[FIXNUM_LEVEL] = Is_Fixnum_Zero;
  1975.    Num_Ops.Is_Number_Zero[BIGNUM_LEVEL] = Is_Bignum_Zero;
  1976.    Num_Ops.Is_Number_Zero[RATIONAL_LEVEL] = Is_Rational_Zero;
  1977.    Num_Ops.Is_Number_Zero[REAL_LEVEL] = Is_Real_Zero;
  1978.    Num_Ops.Is_Number_Zero[COMPLEX_LEVEL] = Is_Complex_Zero;
  1979.    
  1980.    Num_Ops.Is_Number_Positive[FIXNUM_LEVEL] = Is_Fixnum_Positive;
  1981.    Num_Ops.Is_Number_Positive[BIGNUM_LEVEL] = Is_Bignum_Positive;
  1982.    Num_Ops.Is_Number_Positive[RATIONAL_LEVEL] = Is_Rational_Positive;
  1983.    Num_Ops.Is_Number_Positive[REAL_LEVEL] = Is_Real_Positive;
  1984.    Num_Ops.Is_Number_Positive[COMPLEX_LEVEL] = Is_Complex_Positive;
  1985.    
  1986.    Num_Ops.Is_Number_Negative[FIXNUM_LEVEL] = Is_Fixnum_Negative;
  1987.    Num_Ops.Is_Number_Negative[BIGNUM_LEVEL] = Is_Bignum_Negative;
  1988.    Num_Ops.Is_Number_Negative[RATIONAL_LEVEL] = Is_Rational_Negative;
  1989.    Num_Ops.Is_Number_Negative[REAL_LEVEL] = Is_Real_Negative;
  1990.    Num_Ops.Is_Number_Negative[COMPLEX_LEVEL] = Is_Complex_Negative;
  1991.    
  1992.    Num_Ops.Is_Number_Odd[FIXNUM_LEVEL] = Is_Fixnum_Odd;
  1993.    Num_Ops.Is_Number_Odd[BIGNUM_LEVEL] = Is_Bignum_Odd;
  1994.    Num_Ops.Is_Number_Odd[RATIONAL_LEVEL] = Is_Rational_Odd;
  1995.    Num_Ops.Is_Number_Odd[REAL_LEVEL] = Is_Real_Odd;
  1996.    Num_Ops.Is_Number_Odd[COMPLEX_LEVEL] = Is_Complex_Odd;
  1997.    
  1998.    Num_Ops.Is_Number_Even[FIXNUM_LEVEL] = Is_Fixnum_Even;
  1999.    Num_Ops.Is_Number_Even[BIGNUM_LEVEL] = Is_Bignum_Even;
  2000.    Num_Ops.Is_Number_Even[RATIONAL_LEVEL] = Is_Rational_Even;
  2001.    Num_Ops.Is_Number_Even[REAL_LEVEL] = Is_Real_Even;
  2002.    Num_Ops.Is_Number_Even[COMPLEX_LEVEL] = Is_Complex_Even;
  2003.    
  2004.    Num_Ops.Is_Number_Exact[FIXNUM_LEVEL] = Is_Fixnum_Exact;
  2005.    Num_Ops.Is_Number_Exact[BIGNUM_LEVEL] = Is_Bignum_Exact;
  2006.    Num_Ops.Is_Number_Exact[RATIONAL_LEVEL] = Is_Rational_Exact;
  2007.    Num_Ops.Is_Number_Exact[REAL_LEVEL] = Is_Real_Exact;
  2008.    Num_Ops.Is_Number_Exact[COMPLEX_LEVEL] = Is_Complex_Exact;
  2009.    
  2010.    Num_Ops.Is_Number_Inexact[FIXNUM_LEVEL] = Is_Fixnum_Inexact;
  2011.    Num_Ops.Is_Number_Inexact[BIGNUM_LEVEL] = Is_Bignum_Inexact;
  2012.    Num_Ops.Is_Number_Inexact[RATIONAL_LEVEL] = Is_Rational_Inexact;
  2013.    Num_Ops.Is_Number_Inexact[REAL_LEVEL] = Is_Real_Inexact;
  2014.    Num_Ops.Is_Number_Inexact[COMPLEX_LEVEL] = Is_Complex_Inexact;
  2015.    
  2016.    Num_Ops.Number_Equal[FIXNUM_LEVEL] = Fixnum_Equal;
  2017.    Num_Ops.Number_Equal[BIGNUM_LEVEL] = Bignum_Equal;
  2018.    Num_Ops.Number_Equal[RATIONAL_LEVEL] = Rational_Equal;
  2019.    Num_Ops.Number_Equal[REAL_LEVEL] = Real_Equal;
  2020.    Num_Ops.Number_Equal[COMPLEX_LEVEL] = Complex_Equal;
  2021.    
  2022.    Num_Ops.Number_Less_Than[FIXNUM_LEVEL] = Fixnum_Less_Than;
  2023.    Num_Ops.Number_Less_Than[BIGNUM_LEVEL] = Bignum_Less_Than;
  2024.    Num_Ops.Number_Less_Than[RATIONAL_LEVEL] = Rational_Less_Than;
  2025.    Num_Ops.Number_Less_Than[REAL_LEVEL] = Real_Less_Than;
  2026.    Num_Ops.Number_Less_Than[COMPLEX_LEVEL] = Complex_Less_Than;
  2027.    
  2028.    Num_Ops.Number_Greater_Than[FIXNUM_LEVEL] = Fixnum_Greater_Than;
  2029.    Num_Ops.Number_Greater_Than[BIGNUM_LEVEL] = Bignum_Greater_Than;
  2030.    Num_Ops.Number_Greater_Than[RATIONAL_LEVEL] = Rational_Greater_Than;
  2031.    Num_Ops.Number_Greater_Than[REAL_LEVEL] = Real_Greater_Than;
  2032.    Num_Ops.Number_Greater_Than[COMPLEX_LEVEL] = Complex_Greater_Than;
  2033.    
  2034.    Num_Ops.Number_Less_Than_Or_Equal[FIXNUM_LEVEL] = Fixnum_Less_Than_Or_Equal;
  2035.    Num_Ops.Number_Less_Than_Or_Equal[BIGNUM_LEVEL] = Bignum_Less_Than_Or_Equal;
  2036.    Num_Ops.Number_Less_Than_Or_Equal[RATIONAL_LEVEL] = Rational_Less_Than_Or_Equal;
  2037.    Num_Ops.Number_Less_Than_Or_Equal[REAL_LEVEL] = Real_Less_Than_Or_Equal;
  2038.    Num_Ops.Number_Less_Than_Or_Equal[COMPLEX_LEVEL] = Complex_Less_Than_Or_Equal;
  2039.    
  2040.    Num_Ops.Number_Greater_Than_Or_Equal[FIXNUM_LEVEL] = Fixnum_Greater_Than_Or_Equal;
  2041.    Num_Ops.Number_Greater_Than_Or_Equal[BIGNUM_LEVEL] = Bignum_Greater_Than_Or_Equal;
  2042.    Num_Ops.Number_Greater_Than_Or_Equal[RATIONAL_LEVEL] = Rational_Greater_Than_Or_Equal;
  2043.    Num_Ops.Number_Greater_Than_Or_Equal[REAL_LEVEL] = Real_Greater_Than_Or_Equal;
  2044.    Num_Ops.Number_Greater_Than_Or_Equal[COMPLEX_LEVEL] = Complex_Greater_Than_Or_Equal;
  2045.    
  2046.    Num_Ops.Number_Max[FIXNUM_LEVEL] = Fixnum_Max;
  2047.    Num_Ops.Number_Max[BIGNUM_LEVEL] = Bignum_Max;
  2048.    Num_Ops.Number_Max[RATIONAL_LEVEL] = Rational_Max;
  2049.    Num_Ops.Number_Max[REAL_LEVEL] = Real_Max;
  2050.    Num_Ops.Number_Max[COMPLEX_LEVEL] = Complex_Max;
  2051.    
  2052.    Num_Ops.Number_Min[FIXNUM_LEVEL] = Fixnum_Min;
  2053.    Num_Ops.Number_Min[BIGNUM_LEVEL] = Bignum_Min;
  2054.    Num_Ops.Number_Min[RATIONAL_LEVEL] = Rational_Min;
  2055.    Num_Ops.Number_Min[REAL_LEVEL] = Real_Min;
  2056.    Num_Ops.Number_Min[COMPLEX_LEVEL] = Complex_Min;
  2057.    
  2058.    Num_Ops.Number_Add[FIXNUM_LEVEL] = Fixnum_Add;
  2059.    Num_Ops.Number_Add[BIGNUM_LEVEL] = Bignum_Add;
  2060.    Num_Ops.Number_Add[RATIONAL_LEVEL] = Rational_Add;
  2061.    Num_Ops.Number_Add[REAL_LEVEL] = Real_Add;
  2062.    Num_Ops.Number_Add[COMPLEX_LEVEL] = Complex_Add;
  2063.    
  2064.    Num_Ops.Number_Subtract[FIXNUM_LEVEL] = Fixnum_Subtract;
  2065.    Num_Ops.Number_Subtract[BIGNUM_LEVEL] = Bignum_Subtract;
  2066.    Num_Ops.Number_Subtract[RATIONAL_LEVEL] = Rational_Subtract;
  2067.    Num_Ops.Number_Subtract[REAL_LEVEL] = Real_Subtract;
  2068.    Num_Ops.Number_Subtract[COMPLEX_LEVEL] = Complex_Subtract;
  2069.    
  2070.    Num_Ops.Number_Multiply[FIXNUM_LEVEL] = Fixnum_Multiply;
  2071.    Num_Ops.Number_Multiply[BIGNUM_LEVEL] = Bignum_Multiply;
  2072.    Num_Ops.Number_Multiply[RATIONAL_LEVEL] = Rational_Multiply;
  2073.    Num_Ops.Number_Multiply[REAL_LEVEL] = Real_Multiply;
  2074.    Num_Ops.Number_Multiply[COMPLEX_LEVEL] = Complex_Multiply;
  2075.    
  2076.    Num_Ops.Number_Divide[FIXNUM_LEVEL] = Fixnum_Divide;
  2077.    Num_Ops.Number_Divide[BIGNUM_LEVEL] = Bignum_Divide;
  2078.    Num_Ops.Number_Divide[RATIONAL_LEVEL] = Rational_Divide;
  2079.    Num_Ops.Number_Divide[REAL_LEVEL] = Real_Divide;
  2080.    Num_Ops.Number_Divide[COMPLEX_LEVEL] = Complex_Divide;
  2081.    
  2082.    Num_Ops.Number_Quotient[FIXNUM_LEVEL] = Fixnum_Quotient;
  2083.    Num_Ops.Number_Quotient[BIGNUM_LEVEL] = Bignum_Quotient;
  2084.    Num_Ops.Number_Quotient[RATIONAL_LEVEL] = Rational_Quotient;
  2085.    Num_Ops.Number_Quotient[REAL_LEVEL] = Real_Quotient;
  2086.    Num_Ops.Number_Quotient[COMPLEX_LEVEL] = Complex_Quotient;
  2087.    
  2088.    Num_Ops.Number_Remainder[FIXNUM_LEVEL] = Fixnum_Remainder;
  2089.    Num_Ops.Number_Remainder[BIGNUM_LEVEL] = Bignum_Remainder;
  2090.    Num_Ops.Number_Remainder[RATIONAL_LEVEL] = Rational_Remainder;
  2091.    Num_Ops.Number_Remainder[REAL_LEVEL] = Real_Remainder;
  2092.    Num_Ops.Number_Remainder[COMPLEX_LEVEL] = Complex_Remainder;
  2093.    
  2094.    Num_Ops.Number_Modulo[FIXNUM_LEVEL] = Fixnum_Modulo;
  2095.    Num_Ops.Number_Modulo[BIGNUM_LEVEL] = Bignum_Modulo;
  2096.    Num_Ops.Number_Modulo[RATIONAL_LEVEL] = Rational_Modulo;
  2097.    Num_Ops.Number_Modulo[REAL_LEVEL] = Real_Modulo;
  2098.    Num_Ops.Number_Modulo[COMPLEX_LEVEL] = Complex_Modulo;
  2099.  
  2100.    Num_Ops.Number_Negate[FIXNUM_LEVEL] = Fixnum_Negate;
  2101.    Num_Ops.Number_Negate[BIGNUM_LEVEL] = Bignum_Negate;
  2102.    Num_Ops.Number_Negate[RATIONAL_LEVEL] = Rational_Negate;  
  2103.    Num_Ops.Number_Negate[REAL_LEVEL] = Real_Negate;
  2104.    Num_Ops.Number_Negate[COMPLEX_LEVEL] = Complex_Negate; 
  2105.  
  2106.    Num_Ops.Number_Abs[FIXNUM_LEVEL] = Fixnum_Abs;
  2107.    Num_Ops.Number_Abs[BIGNUM_LEVEL] = Bignum_Abs;
  2108.    Num_Ops.Number_Abs[RATIONAL_LEVEL] = Rational_Abs;
  2109.    Num_Ops.Number_Abs[REAL_LEVEL] = Real_Abs;
  2110.    Num_Ops.Number_Abs[COMPLEX_LEVEL] = Complex_Abs;
  2111.    
  2112.    Num_Ops.Number_Numerator[FIXNUM_LEVEL] = Fixnum_Numerator;
  2113.    Num_Ops.Number_Numerator[BIGNUM_LEVEL] = Bignum_Numerator;
  2114.    Num_Ops.Number_Numerator[RATIONAL_LEVEL] = Rational_Numerator;
  2115.    Num_Ops.Number_Numerator[REAL_LEVEL] = Real_Numerator;
  2116.    Num_Ops.Number_Numerator[COMPLEX_LEVEL] = Complex_Numerator;
  2117.  
  2118.    Num_Ops.Number_Denominator[FIXNUM_LEVEL] = Fixnum_Denominator;
  2119.    Num_Ops.Number_Denominator[BIGNUM_LEVEL] = Bignum_Denominator;
  2120.    Num_Ops.Number_Denominator[RATIONAL_LEVEL] = Rational_Denominator;
  2121.    Num_Ops.Number_Denominator[REAL_LEVEL] = Real_Denominator;
  2122.    Num_Ops.Number_Denominator[COMPLEX_LEVEL] = Complex_Denominator;
  2123.  
  2124.    Num_Ops.Number_Rationalize[FIXNUM_LEVEL] = Fixnum_Rationalize;
  2125.    Num_Ops.Number_Rationalize[BIGNUM_LEVEL] = Bignum_Rationalize;
  2126.    Num_Ops.Number_Rationalize[RATIONAL_LEVEL] = Rational_Rationalize;
  2127.    Num_Ops.Number_Rationalize[REAL_LEVEL] = Real_Rationalize; 
  2128.    Num_Ops.Number_Rationalize[COMPLEX_LEVEL] = Complex_Rationalize;
  2129.  
  2130.    Num_Ops.Number_GCD[FIXNUM_LEVEL] = Fixnum_GCD;
  2131.    Num_Ops.Number_GCD[BIGNUM_LEVEL] = Bignum_GCD;
  2132.    Num_Ops.Number_GCD[RATIONAL_LEVEL] = Rational_GCD;
  2133.    Num_Ops.Number_GCD[REAL_LEVEL] = Real_GCD;
  2134.    Num_Ops.Number_GCD[COMPLEX_LEVEL] = Complex_GCD;
  2135.  
  2136.    Num_Ops.Number_LCM[FIXNUM_LEVEL] = Fixnum_LCM;
  2137.    Num_Ops.Number_LCM[BIGNUM_LEVEL] = Bignum_LCM;
  2138.    Num_Ops.Number_LCM[RATIONAL_LEVEL] = Rational_LCM;
  2139.    Num_Ops.Number_LCM[REAL_LEVEL] = Real_LCM;
  2140.    Num_Ops.Number_LCM[COMPLEX_LEVEL] = Complex_LCM;
  2141.  
  2142.    Num_Ops.Number_Floor[FIXNUM_LEVEL] = Fixnum_Floor;
  2143.    Num_Ops.Number_Floor[BIGNUM_LEVEL] = Bignum_Floor;
  2144.    Num_Ops.Number_Floor[RATIONAL_LEVEL] = Rational_Floor;
  2145.    Num_Ops.Number_Floor[REAL_LEVEL] = Real_Floor;
  2146.    Num_Ops.Number_Floor[COMPLEX_LEVEL] = Complex_Floor;
  2147.  
  2148.    Num_Ops.Number_Ceiling[FIXNUM_LEVEL] = Fixnum_Ceiling;
  2149.    Num_Ops.Number_Ceiling[BIGNUM_LEVEL] = Bignum_Ceiling;
  2150.    Num_Ops.Number_Ceiling[RATIONAL_LEVEL] = Rational_Ceiling;
  2151.    Num_Ops.Number_Ceiling[REAL_LEVEL] = Real_Ceiling;
  2152.    Num_Ops.Number_Ceiling[COMPLEX_LEVEL] = Complex_Ceiling;
  2153.  
  2154.    Num_Ops.Number_Truncate[FIXNUM_LEVEL] = Fixnum_Truncate;
  2155.    Num_Ops.Number_Truncate[BIGNUM_LEVEL] = Bignum_Truncate;
  2156.    Num_Ops.Number_Truncate[RATIONAL_LEVEL] = Rational_Truncate;
  2157.    Num_Ops.Number_Truncate[REAL_LEVEL] = Real_Truncate;
  2158.    Num_Ops.Number_Truncate[COMPLEX_LEVEL] = Complex_Truncate;
  2159.  
  2160.    Num_Ops.Number_Round[FIXNUM_LEVEL] = Fixnum_Round;
  2161.    Num_Ops.Number_Round[BIGNUM_LEVEL] = Bignum_Round;
  2162.    Num_Ops.Number_Round[RATIONAL_LEVEL] = Rational_Round;
  2163.    Num_Ops.Number_Round[REAL_LEVEL] = Real_Round;
  2164.    Num_Ops.Number_Round[COMPLEX_LEVEL] = Complex_Round;
  2165.  
  2166.    Num_Ops.Number_Sqrt[FIXNUM_LEVEL] = Fixnum_Sqrt;
  2167.    Num_Ops.Number_Sqrt[BIGNUM_LEVEL] = Bignum_Sqrt;
  2168.    Num_Ops.Number_Sqrt[RATIONAL_LEVEL] = Rational_Sqrt;
  2169.    Num_Ops.Number_Sqrt[REAL_LEVEL] = Real_Sqrt;
  2170.    Num_Ops.Number_Sqrt[COMPLEX_LEVEL] = Complex_Sqrt;
  2171.  
  2172.    Num_Ops.Number_Exp[FIXNUM_LEVEL] = Fixnum_Exp;
  2173.    Num_Ops.Number_Exp[BIGNUM_LEVEL] = Bignum_Exp;
  2174.    Num_Ops.Number_Exp[RATIONAL_LEVEL] = Rational_Exp;
  2175.    Num_Ops.Number_Exp[REAL_LEVEL] = Real_Exp;
  2176.    Num_Ops.Number_Exp[COMPLEX_LEVEL] = Complex_Exp;
  2177.  
  2178.    Num_Ops.Number_Log[FIXNUM_LEVEL] = Fixnum_Log;
  2179.    Num_Ops.Number_Log[BIGNUM_LEVEL] = Bignum_Log;
  2180.    Num_Ops.Number_Log[RATIONAL_LEVEL] = Rational_Log;
  2181.    Num_Ops.Number_Log[REAL_LEVEL] = Real_Log;
  2182.    Num_Ops.Number_Log[COMPLEX_LEVEL] = Complex_Log;
  2183.  
  2184.    Num_Ops.Number_Expt[FIXNUM_LEVEL] = Fixnum_Expt;
  2185.    Num_Ops.Number_Expt[BIGNUM_LEVEL] = Bignum_Expt;
  2186.    Num_Ops.Number_Expt[RATIONAL_LEVEL] = Rational_Expt;
  2187.    Num_Ops.Number_Expt[REAL_LEVEL] = Real_Expt;
  2188.    Num_Ops.Number_Expt[COMPLEX_LEVEL] = Complex_Expt;
  2189.  
  2190.    Num_Ops.Number_Sin[FIXNUM_LEVEL] = Fixnum_Sin;
  2191.    Num_Ops.Number_Sin[BIGNUM_LEVEL] = Bignum_Sin;
  2192.    Num_Ops.Number_Sin[RATIONAL_LEVEL] = Rational_Sin;
  2193.    Num_Ops.Number_Sin[REAL_LEVEL] = Real_Sin;
  2194.    Num_Ops.Number_Sin[COMPLEX_LEVEL] = Complex_Sin;
  2195.  
  2196.    Num_Ops.Number_Cos[FIXNUM_LEVEL] = Fixnum_Cos;
  2197.    Num_Ops.Number_Cos[BIGNUM_LEVEL] = Bignum_Cos;
  2198.    Num_Ops.Number_Cos[RATIONAL_LEVEL] = Rational_Cos;
  2199.    Num_Ops.Number_Cos[REAL_LEVEL] = Real_Cos;
  2200.    Num_Ops.Number_Cos[COMPLEX_LEVEL] = Complex_Cos;
  2201.  
  2202.    Num_Ops.Number_Tan[FIXNUM_LEVEL] = Fixnum_Tan;
  2203.    Num_Ops.Number_Tan[BIGNUM_LEVEL] = Bignum_Tan;
  2204.    Num_Ops.Number_Tan[RATIONAL_LEVEL] = Rational_Tan;
  2205.    Num_Ops.Number_Tan[REAL_LEVEL] = Real_Tan;
  2206.    Num_Ops.Number_Tan[COMPLEX_LEVEL] = Complex_Tan;
  2207.  
  2208.    Num_Ops.Number_Asin[FIXNUM_LEVEL] = Fixnum_Asin;
  2209.    Num_Ops.Number_Asin[BIGNUM_LEVEL] = Bignum_Asin;
  2210.    Num_Ops.Number_Asin[RATIONAL_LEVEL] = Rational_Asin;
  2211.    Num_Ops.Number_Asin[REAL_LEVEL] = Real_Asin;
  2212.    Num_Ops.Number_Asin[COMPLEX_LEVEL] = Complex_Asin;
  2213.  
  2214.    Num_Ops.Number_Acos[FIXNUM_LEVEL] = Fixnum_Acos;
  2215.    Num_Ops.Number_Acos[BIGNUM_LEVEL] = Bignum_Acos;
  2216.    Num_Ops.Number_Acos[RATIONAL_LEVEL] = Rational_Acos;
  2217.    Num_Ops.Number_Acos[REAL_LEVEL] = Real_Acos;
  2218.    Num_Ops.Number_Acos[COMPLEX_LEVEL] = Complex_Acos;
  2219.  
  2220.    Num_Ops.Number_Atan[FIXNUM_LEVEL] = Fixnum_Atan;
  2221.    Num_Ops.Number_Atan[BIGNUM_LEVEL] = Bignum_Atan;
  2222.    Num_Ops.Number_Atan[RATIONAL_LEVEL] = Rational_Atan;
  2223.    Num_Ops.Number_Atan[REAL_LEVEL] = Real_Atan;
  2224.    Num_Ops.Number_Atan[COMPLEX_LEVEL] = Complex_Atan;
  2225.  
  2226.    Num_Ops.Number_Atan2[FIXNUM_LEVEL] = Fixnum_Atan2;
  2227.    Num_Ops.Number_Atan2[BIGNUM_LEVEL] = Bignum_Atan2;
  2228.    Num_Ops.Number_Atan2[RATIONAL_LEVEL] = Rational_Atan2;
  2229.    Num_Ops.Number_Atan2[REAL_LEVEL] = Real_Atan2;
  2230.    Num_Ops.Number_Atan2[COMPLEX_LEVEL] = Complex_Atan2;
  2231.  
  2232.    Num_Ops.Number_Exact_To_Inexact[FIXNUM_LEVEL] = Fixnum_Exact_To_Inexact;
  2233.    Num_Ops.Number_Exact_To_Inexact[BIGNUM_LEVEL] = Bignum_Exact_To_Inexact;
  2234.    Num_Ops.Number_Exact_To_Inexact[RATIONAL_LEVEL] = Rational_Exact_To_Inexact;
  2235.    Num_Ops.Number_Exact_To_Inexact[REAL_LEVEL] = Real_Exact_To_Inexact;
  2236.    Num_Ops.Number_Exact_To_Inexact[COMPLEX_LEVEL] = Complex_Exact_To_Inexact;
  2237.  
  2238.    Num_Ops.Number_Inexact_To_Exact[FIXNUM_LEVEL] = Fixnum_Inexact_To_Exact;
  2239.    Num_Ops.Number_Inexact_To_Exact[BIGNUM_LEVEL] = Bignum_Inexact_To_Exact;
  2240.    Num_Ops.Number_Inexact_To_Exact[RATIONAL_LEVEL] = Rational_Inexact_To_Exact;
  2241.    Num_Ops.Number_Inexact_To_Exact[REAL_LEVEL] = Real_Inexact_To_Exact;
  2242.    Num_Ops.Number_Inexact_To_Exact[COMPLEX_LEVEL] = Complex_Inexact_To_Exact;
  2243.  
  2244.    Num_Ops.Number_To_String[FIXNUM_LEVEL] = Fixnum_To_String;
  2245.    Num_Ops.Number_To_String[BIGNUM_LEVEL] = Bignum_To_String;
  2246.    Num_Ops.Number_To_String[RATIONAL_LEVEL] = Rational_To_String;
  2247.    Num_Ops.Number_To_String[REAL_LEVEL] = Real_To_String;
  2248.    Num_Ops.Number_To_String[COMPLEX_LEVEL] = Complex_To_String;
  2249.    
  2250.    Num_Ops.Number_Make_Rectangular[FIXNUM_LEVEL] = Fixnum_Make_Rectangular;
  2251.    Num_Ops.Number_Make_Rectangular[BIGNUM_LEVEL] = Bignum_Make_Rectangular;
  2252.    Num_Ops.Number_Make_Rectangular[RATIONAL_LEVEL] = Rational_Make_Rectangular;
  2253.    Num_Ops.Number_Make_Rectangular[REAL_LEVEL] = Real_Make_Rectangular;
  2254.    Num_Ops.Number_Make_Rectangular[COMPLEX_LEVEL] = Complex_Make_Rectangular;
  2255.  
  2256.    Num_Ops.Number_Make_Polar[FIXNUM_LEVEL] = Fixnum_Make_Polar;
  2257.    Num_Ops.Number_Make_Polar[BIGNUM_LEVEL] = Bignum_Make_Polar;
  2258.    Num_Ops.Number_Make_Polar[RATIONAL_LEVEL] = Rational_Make_Polar;
  2259.    Num_Ops.Number_Make_Polar[REAL_LEVEL] = Real_Make_Polar;
  2260.    Num_Ops.Number_Make_Polar[COMPLEX_LEVEL] = Complex_Make_Polar;
  2261.  
  2262.    Num_Ops.Number_Real_Part[FIXNUM_LEVEL] = Fixnum_Real_Part;
  2263.    Num_Ops.Number_Real_Part[BIGNUM_LEVEL] = Bignum_Real_Part;
  2264.    Num_Ops.Number_Real_Part[RATIONAL_LEVEL] = Rational_Real_Part;
  2265.    Num_Ops.Number_Real_Part[REAL_LEVEL] = Real_Real_Part;
  2266.    Num_Ops.Number_Real_Part[COMPLEX_LEVEL] = Complex_Real_Part;
  2267.  
  2268.    Num_Ops.Number_Imaginary_Part[FIXNUM_LEVEL] = Fixnum_Imaginary_Part;
  2269.    Num_Ops.Number_Imaginary_Part[BIGNUM_LEVEL] = Bignum_Imaginary_Part;
  2270.    Num_Ops.Number_Imaginary_Part[RATIONAL_LEVEL] = Rational_Imaginary_Part;
  2271.    Num_Ops.Number_Imaginary_Part[REAL_LEVEL] = Real_Imaginary_Part;
  2272.    Num_Ops.Number_Imaginary_Part[COMPLEX_LEVEL] = Complex_Imaginary_Part;
  2273.  
  2274.    Num_Ops.Number_Magnitude[FIXNUM_LEVEL] = Fixnum_Magnitude;
  2275.    Num_Ops.Number_Magnitude[BIGNUM_LEVEL] = Bignum_Magnitude;
  2276.    Num_Ops.Number_Magnitude[RATIONAL_LEVEL] = Rational_Magnitude;
  2277.    Num_Ops.Number_Magnitude[REAL_LEVEL] = Real_Magnitude;
  2278.    Num_Ops.Number_Magnitude[COMPLEX_LEVEL] = Complex_Magnitude;
  2279.  
  2280.    Num_Ops.Number_Angle[FIXNUM_LEVEL] = Fixnum_Angle;
  2281.    Num_Ops.Number_Angle[BIGNUM_LEVEL] = Bignum_Angle;
  2282.    Num_Ops.Number_Angle[RATIONAL_LEVEL] = Rational_Angle;
  2283.    Num_Ops.Number_Angle[REAL_LEVEL] = Real_Angle;
  2284.    Num_Ops.Number_Angle[COMPLEX_LEVEL] = Complex_Angle;
  2285.  
  2286.    Make_Primitive("number?", Number_Predicate, 1, Any_Type, The_Undefined_Type,
  2287.                                                         The_Undefined_Type);
  2288.  
  2289.    Make_Primitive("integer?", Integer_Predicate, 1, Any_Type, The_Undefined_Type,
  2290.                                                         The_Undefined_Type);
  2291.  
  2292.    Make_Primitive("rational?", Rational_Predicate, 1, Any_Type, The_Undefined_Type,
  2293.                                                         The_Undefined_Type);
  2294.  
  2295.    Make_Primitive("real?", Real_Predicate, 1, Any_Type, The_Undefined_Type,
  2296.                                                         The_Undefined_Type);
  2297.  
  2298.    Make_Primitive("complex?", Complex_Predicate, 1, Any_Type, The_Undefined_Type,
  2299.                                                         The_Undefined_Type);
  2300.  
  2301.    Make_Primitive("zero?", Is_Number_Zero, 1, Number_Type, The_Undefined_Type,
  2302.                            The_Undefined_Type);
  2303.    Make_Primitive("positive?", Is_Number_Positive, 1, Number_Type,
  2304.                        The_Undefined_Type, The_Undefined_Type);
  2305.    Make_Primitive("negative?", Is_Number_Negative, 1, Number_Type,
  2306.                        The_Undefined_Type, The_Undefined_Type);
  2307.    Make_Primitive("odd?", Is_Number_Odd, 1, Number_Type, The_Undefined_Type, 
  2308.                            The_Undefined_Type);
  2309.    Make_Primitive("even?", Is_Number_Even, 1, Number_Type, The_Undefined_Type, 
  2310.                            The_Undefined_Type);
  2311.    Make_Primitive("exact?", Is_Number_Exact, 1, Number_Type, The_Undefined_Type,
  2312.                            The_Undefined_Type);
  2313.    Make_Primitive("inexact?", Is_Number_Inexact, 1, Number_Type,
  2314.                                    The_Undefined_Type, The_Undefined_Type);
  2315.  
  2316.    Make_Primitive("=", Varying_Number_Equal, VARYING, Number_Type, 
  2317.           The_Undefined_Type , The_Undefined_Type );
  2318.  
  2319.    Make_Primitive(">", Varying_Number_Greater_Than, VARYING, Number_Type, 
  2320.           The_Undefined_Type , The_Undefined_Type );
  2321.  
  2322.    Make_Primitive("<", Varying_Number_Less_Than, VARYING, Number_Type, 
  2323.           The_Undefined_Type , The_Undefined_Type );
  2324.  
  2325.    Make_Primitive(">=", Varying_Number_Greater_Than_Or_Equal, VARYING, 
  2326.           Number_Type, The_Undefined_Type , The_Undefined_Type );
  2327.  
  2328.    Make_Primitive("<=", Varying_Number_Less_Than_Or_Equal, VARYING,
  2329.           Number_Type, The_Undefined_Type , The_Undefined_Type );
  2330.  
  2331.    Make_Primitive("+", Varying_Number_Add, VARYING, Number_Type, 
  2332.           The_Undefined_Type, The_Undefined_Type );
  2333.  
  2334.    Make_Primitive("-", Varying_Number_Subtract, VARYING, Number_Type, 
  2335.           The_Undefined_Type, The_Undefined_Type );
  2336.  
  2337.    Make_Primitive("*", Varying_Number_Multiply, VARYING, Number_Type, 
  2338.           The_Undefined_Type, The_Undefined_Type );
  2339.  
  2340.    Make_Primitive("/", Varying_Number_Divide, VARYING, Number_Type, 
  2341.           The_Undefined_Type, The_Undefined_Type );
  2342.  
  2343.    Make_Primitive( "min", Varying_Number_Min, VARYING, Number_Type, 
  2344.           The_Undefined_Type, The_Undefined_Type );
  2345.  
  2346.    Make_Primitive( "max", Varying_Number_Max, VARYING, Number_Type, 
  2347.           The_Undefined_Type, The_Undefined_Type );
  2348.  
  2349.    Make_Primitive("gcd", Varying_Number_GCD, VARYING, Number_Type, 
  2350.           The_Undefined_Type, The_Undefined_Type );
  2351.  
  2352.    Make_Primitive("lcm", Varying_Number_LCM, VARYING, Number_Type, 
  2353.           The_Undefined_Type, The_Undefined_Type );
  2354.  
  2355.    Make_Primitive("quotient", Number_Quotient, 2, Number_Type, Number_Type,
  2356.                           The_Undefined_Type);
  2357.    Make_Primitive("remainder", Number_Remainder, 2, Number_Type, Number_Type, 
  2358.                         The_Undefined_Type);  
  2359.  
  2360.    Make_Primitive("modulo", Number_Modulo, 2, Number_Type, Number_Type, 
  2361.                         The_Undefined_Type);  
  2362.  
  2363.    Make_Primitive("negate", Number_Negate, 1, Number_Type, The_Undefined_Type,
  2364.                           The_Undefined_Type);
  2365.  
  2366.    Make_Primitive("abs", Number_Abs, 1, Number_Type, The_Undefined_Type,
  2367.                           The_Undefined_Type); 
  2368.  
  2369.    Make_Primitive("numerator", Number_Numerator, 1, Number_Type, 
  2370.                          The_Undefined_Type,The_Undefined_Type); 
  2371.  
  2372.    Make_Primitive("denominator", Number_Denominator,1, Number_Type,
  2373.                     The_Undefined_Type, The_Undefined_Type);
  2374.  
  2375.    Make_Primitive("rationalize", Number_Rationalize, 2, Number_Type, 
  2376.                     Number_Type, The_Undefined_Type);
  2377.  
  2378.    Make_Primitive("floor", Number_Floor, 1, Number_Type, The_Undefined_Type,
  2379.                         The_Undefined_Type );
  2380.  
  2381.    Make_Primitive("ceiling", Number_Ceiling, 1, Number_Type, The_Undefined_Type,
  2382.                         The_Undefined_Type );
  2383.  
  2384.    Make_Primitive("truncate", Number_Truncate, 1, Number_Type,
  2385.                     The_Undefined_Type,The_Undefined_Type );
  2386.  
  2387.    Make_Primitive("round", Number_Round, 1, Number_Type, The_Undefined_Type,
  2388.                         The_Undefined_Type );
  2389.  
  2390.    Make_Primitive("sqrt", Number_Sqrt, 1, Number_Type, The_Undefined_Type,
  2391.                         The_Undefined_Type );
  2392.    
  2393.    Make_Primitive("exp", Number_Exp, 1, Number_Type, The_Undefined_Type,
  2394.                         The_Undefined_Type );
  2395.  
  2396.    Make_Primitive("log", Number_Log, 1, Number_Type, The_Undefined_Type,
  2397.                         The_Undefined_Type );
  2398.  
  2399.    Make_Primitive("expt", Number_Expt, 2, Number_Type, Number_Type,
  2400.                         The_Undefined_Type );
  2401.  
  2402.    Make_Primitive("sin", Number_Sin, 1, Number_Type, The_Undefined_Type,
  2403.                         The_Undefined_Type );
  2404.    Make_Primitive("cos", Number_Cos, 1, Number_Type, The_Undefined_Type,
  2405.                         The_Undefined_Type );
  2406.    Make_Primitive("tan", Number_Tan, 1, Number_Type, The_Undefined_Type,
  2407.                         The_Undefined_Type );
  2408.  
  2409.    Make_Primitive("acos", Number_Acos, 1, Number_Type, The_Undefined_Type,
  2410.                         The_Undefined_Type );
  2411.    Make_Primitive("asin", Number_Asin, 1, Number_Type, The_Undefined_Type,
  2412.                         The_Undefined_Type );
  2413.    Make_Primitive("#_atan1", Number_Atan, 1, Number_Type, The_Undefined_Type,
  2414.                         The_Undefined_Type );
  2415.    Make_Primitive("#_atan2", Number_Atan2, 2, Number_Type, Number_Type,
  2416.                         The_Undefined_Type );
  2417.    Make_Primitive("atan", Number_Atan, 1, Number_Type, The_Undefined_Type,
  2418.                         The_Undefined_Type );
  2419.    Make_Primitive("atan2", Number_Atan2, 2, Number_Type, Number_Type,
  2420.                         The_Undefined_Type );
  2421.    
  2422.    Make_Primitive("exact->inexact", Number_Exact_To_Inexact, 1, Number_Type,
  2423.                            The_Undefined_Type, The_Undefined_Type);
  2424.    Make_Primitive("inexact->exact", Number_Inexact_To_Exact, 1, Number_Type,
  2425.                            The_Undefined_Type, The_Undefined_Type);
  2426.  
  2427.    Make_Primitive("#_number->string", Number_To_String, 2, Number_Type,
  2428.                     Number_Type , The_Undefined_Type); 
  2429.  
  2430.    Make_Primitive("#_string->number", String_To_Number, 2, String_Type,
  2431.         Number_Type, The_Undefined_Type);
  2432.  
  2433.    Make_Primitive("make-rectangular", Number_Make_Rectangular, 2, Number_Type,
  2434.                     Number_Type, The_Undefined_Type );
  2435.    
  2436.    Make_Primitive("make-polar", Number_Make_Polar, 2, Number_Type,
  2437.                     Number_Type, The_Undefined_Type );
  2438.    
  2439.    Make_Primitive("real-part", Number_Real_Part, 1, Number_Type,
  2440.                 The_Undefined_Type, The_Undefined_Type );
  2441.    
  2442.    Make_Primitive("imag-part", Number_Imaginary_Part, 1, Number_Type,
  2443.                 The_Undefined_Type, The_Undefined_Type );
  2444.  
  2445.    Make_Primitive("magnitude", Number_Magnitude, 1, Number_Type,
  2446.                 The_Undefined_Type, The_Undefined_Type );
  2447.  
  2448.    Make_Primitive("angle", Number_Angle, 1, Number_Type,
  2449.                 The_Undefined_Type, The_Undefined_Type );
  2450.  
  2451.  
  2452. }
  2453.