home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / dev / lang / umbscheme / src / rational.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-29  |  14.8 KB  |  809 lines
  1. /* rational.c -- UMB Scheme, specific rational number procedures.
  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.  
  37. #include "portable.h"
  38. #include "eval.h"
  39. #include "object.h"
  40. #include "architecture.h"
  41. #include "number.h"
  42. #include "fixnum.h"
  43. #include "bignum.h"
  44. #include "rational.h"
  45. #include "real.h"
  46. #include "complex.h"
  47. #include "steering.h"
  48. #include "io.h"
  49. #include <math.h>
  50. #include <errno.h>
  51.  
  52. Private Short Rational_Compare();
  53.  
  54.  
  55.  
  56. /* Predicates. */
  57.  
  58. Public Boolean Is_Rational_Zero()
  59. {
  60.       return (Number_Sign(Get_Number_Rational_Numerator(Top(1))) == 0);;
  61. }
  62.  
  63. Public Boolean Is_Rational_Positive()
  64. {
  65.     return (Number_Sign(Get_Number_Rational_Numerator(Top(1))) > 0);
  66. }
  67.  
  68. Public Boolean Is_Rational_Negative()
  69. {
  70.     return(Number_Sign(Get_Number_Rational_Numerator(Top(1))) < 0);
  71. }
  72.  
  73. Public Boolean Is_Rational_Odd()
  74. {
  75.     Error("Rationals aren't odd or even");
  76.     return FALSE;
  77. }
  78.  
  79. Public Boolean Is_Rational_Even()
  80. {
  81.     Error("Rationals aren't odd or even");
  82.     return FALSE;
  83. }
  84.  
  85. Public Boolean Is_Rational_Exact()
  86. {
  87.     return (Is_Exact_Number(Top(1)));
  88. }
  89.  
  90. Public Boolean Is_Rational_Inexact()
  91. {
  92.     return (! Is_Exact_Number(Top(1)));
  93. }
  94.  
  95.  
  96.  
  97. /* Comparisons. */
  98.  
  99. Public Boolean Rational_Less_Than()
  100. {
  101.     return Rational_Compare() < 0;
  102. }
  103.  
  104. Public Boolean Rational_Greater_Than()
  105. {
  106.     return Rational_Compare() > 0;
  107. }
  108.  
  109. Public Boolean Rational_Equal()
  110. {
  111.     return Rational_Compare() == 0;
  112. }
  113.  
  114. Public Boolean Rational_Less_Than_Or_Equal()
  115. {
  116.     return Rational_Compare() <= 0;
  117. }
  118.  
  119. Public Boolean Rational_Greater_Than_Or_Equal()
  120. {
  121.     return Rational_Compare() >= 0;
  122. }
  123.  
  124. Private Short Rational_Compare()
  125. {
  126.     Rational_Subtract();
  127.     return Number_Sign( Get_Number_Rational_Numerator( Value_Register ));
  128. }
  129.  
  130.  
  131.  
  132.  
  133. /* Arithmetic. */
  134.  
  135. Public void Rational_Add()
  136. {
  137.     /* rat 1 = a/b, rat 2 = c/d, result = (a*d + b*c)/b*d     */
  138.  
  139.     Push(Get_Number_Rational_Numerator(Top( 2 )));    /* numer rat 1 */
  140.     Push(Get_Number_Rational_Denominator(Top( 2 )));  /* denom rat 2 */
  141.     Number_Multiply();
  142.     Pop( 2 );
  143.     Push( Value_Register );
  144.  
  145.     Push(Get_Number_Rational_Denominator(Top( 3 )));  /* denom rat 1 */
  146.     Push(Get_Number_Rational_Numerator(Top( 3 )));    /* numer rat 2 */
  147.     Number_Multiply();
  148.     Pop( 2 );
  149.     Push( Value_Register );
  150.  
  151.     /* add 2 new numerators */
  152.     Number_Add();
  153.     Pop( 2 );
  154.     Push( Value_Register );
  155.  
  156.     Push(Get_Number_Rational_Denominator(Top( 3 )));  /* denom rat 1 */
  157.     Push(Get_Number_Rational_Denominator(Top( 3 ))); /* denom rat 2 */
  158.     Number_Multiply();
  159.     Pop( 2 );
  160.     Push( Value_Register );    /* denominator */
  161.  
  162.     Make_Rational_Number();
  163.     Pop( 2 );
  164.  
  165.     if ( ! Is_Exact_Number( Top(1) ) || ! Is_Exact_Number( Top(2) ) )
  166.     {
  167.         Push( Value_Register );
  168.         Number_Exact_To_Inexact(); Pop(1);
  169.     }
  170. }
  171.  
  172.  
  173.  
  174. Public void Rational_Subtract()
  175. {
  176.     /* rat 1 = a/b, rat 2 = c/d, result = (a*d - b*c)/b*d     */
  177.  
  178.     Push(Get_Number_Rational_Numerator(Top( 2 )));    /* numer rat 1 */
  179.     Push(Get_Number_Rational_Denominator(Top( 2 )));  /* denom rat 2 */
  180.     Number_Multiply();
  181.     Pop( 2 );
  182.     Push( Value_Register );
  183.  
  184.     Push(Get_Number_Rational_Denominator(Top( 3 )));  /* denom rat 1 */
  185.     Push(Get_Number_Rational_Numerator(Top( 3 )));    /* numer rat 2 */
  186.     Number_Multiply();
  187.     Pop( 2 );
  188.     Push( Value_Register );
  189.  
  190.     /* subtract 2 new numerators */
  191.     Number_Subtract();
  192.     Pop( 2 );
  193.     Push( Value_Register );
  194.  
  195.     Push(Get_Number_Rational_Denominator(Top( 3 )));  /* denom rat 1 */
  196.     Push(Get_Number_Rational_Denominator(Top( 3 ))); /* denom rat 2 */
  197.     Number_Multiply();
  198.     Pop( 2 );
  199.     Push( Value_Register );    /* denominator */
  200.  
  201.     Make_Rational_Number();
  202.     Pop( 2 );
  203.  
  204.     if ( ! Is_Exact_Number( Top(1) ) || ! Is_Exact_Number( Top(2) ) )
  205.     {
  206.         Push( Value_Register );
  207.         Number_Exact_To_Inexact(); Pop(1);
  208.     }
  209. }
  210.  
  211.  
  212.  
  213. Public void Rational_Multiply()
  214. {
  215.     /* rat 1 = a/b, rat 2 = c/d, result = a*c/b*d    */
  216.  
  217.     Push(Get_Number_Rational_Numerator(Top( 2 )));    /* numer rat 1 */
  218.     Push(Get_Number_Rational_Numerator(Top( 2 )));    /* numer rat 2 */
  219.     Number_Multiply();
  220.     Pop( 2 );
  221.     Push( Value_Register );    /* new numer of result rat */
  222.  
  223.     Push(Get_Number_Rational_Denominator(Top( 2 ))); /* denom rat 2 */
  224.     Push(Get_Number_Rational_Denominator(Top( 4 ))); /* denom rat 1 */
  225.     Number_Multiply();
  226.     Pop( 2 );
  227.     Push( Value_Register );    /* new denom of result rat */
  228.  
  229.     Make_Rational_Number();
  230.     Pop( 2 );
  231.  
  232.     if ( ! Is_Exact_Number( Top(1) ) || ! Is_Exact_Number( Top(2) ) )
  233.     {
  234.         Push( Value_Register );
  235.         Number_Exact_To_Inexact(); Pop(1);
  236.     }
  237. }
  238.  
  239.  
  240. Public void Rational_Divide()
  241. {
  242.     /* rat 1 = a/b, rat 2 = c/d, result = a*d/c*b    */
  243.  
  244.     Push(Get_Number_Rational_Numerator(Top( 2 )));    /* numer rat 1 */
  245.     Push(Get_Number_Rational_Denominator(Top( 2 ))); /* denom rat 2 */
  246.     Number_Multiply();
  247.     Pop( 2 );
  248.     Push( Value_Register );    /* new numer of result rat */
  249.  
  250.     Push(Get_Number_Rational_Denominator(Top( 3 ))); /* denom rat 1 */
  251.     Push(Get_Number_Rational_Numerator(Top( 3 )));    /* numer rat 2 */
  252.     Number_Multiply();
  253.     Pop( 2 );
  254.     Push( Value_Register );    /* new denom of result rat */
  255.  
  256.     Make_Rational_Number();
  257.     Pop( 2 );
  258.  
  259.     if ( ! Is_Exact_Number( Top(1) ) || ! Is_Exact_Number( Top(2) ) )
  260.     {
  261.         Push( Value_Register );
  262.         Number_Exact_To_Inexact(); Pop(1);
  263.     }
  264. }
  265.  
  266.  
  267. Public void Rational_Quotient()
  268. {
  269.     Error("Quotient makes no sense on rationals");
  270. }
  271.  
  272. Public void Rational_Remainder()
  273. {
  274.     Error("Remainder makes no sense on rationals");
  275. }
  276.  
  277.  
  278. Public void Rational_Modulo()
  279. {
  280.     Error("Modulo makes no sense on rationals");
  281. }
  282.  
  283.  
  284. Public void Rational_Negate()
  285. {
  286.     Push(Get_Number_Rational_Numerator(Top(1)));
  287.     Number_Negate();
  288.     Replace(1, Value_Register);
  289.     Push(Get_Number_Rational_Denominator(Top(2)));
  290.     Make_Rational_Number();
  291.     Pop(2);    
  292.  
  293.     if ( ! Is_Exact_Number( Top(1) ) )
  294.     {
  295.         Push( Value_Register );
  296.         Number_Exact_To_Inexact(); Pop(1);
  297.     }
  298. }
  299.  
  300.  
  301. Public void Rational_Abs()
  302. {
  303.     if (Is_Rational_Negative())
  304.     {
  305.         Rational_Negate();
  306.     }
  307.     else
  308.     {
  309.         Value_Register = Top(1);
  310.     }
  311. }
  312.  
  313. Public void Rational_Numerator()
  314. {
  315.     
  316.     Value_Register = Get_Number_Rational_Numerator(Top( 1 ));
  317.  
  318.     if ( ! Is_Exact_Number( Top(1) ) )
  319.     {
  320.         Push( Value_Register );
  321.         Number_Exact_To_Inexact(); Pop(1);
  322.     }
  323. }
  324.  
  325.  
  326. Public void Rational_Denominator()
  327. {
  328.     
  329.     Value_Register = Get_Number_Rational_Denominator(Top( 1 ));
  330.  
  331.     if ( ! Is_Exact_Number( Top(1) ) )
  332.     {
  333.         Push( Value_Register );
  334.         Number_Exact_To_Inexact(); Pop(1);
  335.     }
  336. }
  337.  
  338.  
  339. Public void Rational_Rationalize()
  340. {
  341.     Error("Rational_Rationalize is not yet implemented");
  342. }
  343.  
  344.  
  345.  
  346. Public void Rational_Max()
  347. {
  348.     Value_Register = Rational_Greater_Than() ? Top(2) : Top(1);
  349.  
  350.     if ( ! Is_Exact_Number( Top(1) ) || ! Is_Exact_Number( Top(2) ) )
  351.     {
  352.         Push( Value_Register );
  353.         Number_Exact_To_Inexact(); Pop(1);
  354.     }
  355. }
  356.  
  357. Public void Rational_Min()
  358. {
  359.     Value_Register = Rational_Less_Than() ? Top(2) : Top(1);
  360.  
  361.     if ( ! Is_Exact_Number( Top(1) ) || ! Is_Exact_Number( Top(2) ) )
  362.     {
  363.         Push( Value_Register );
  364.         Number_Exact_To_Inexact(); Pop(1);
  365.     }
  366. }
  367.  
  368. Public void Rational_GCD()
  369. {
  370.     Error("GCD makes no sense on rationals");
  371. }
  372.  
  373.  
  374. Public void Rational_LCM()
  375. {
  376.     Error("LCM makes no sense on rationals");
  377. }
  378.  
  379. Public void Rational_Floor()
  380. {
  381.     Value_Register = Copy_Object(Top(1), Rational_Size);
  382.  
  383.     Push(Get_Number_Rational_Numerator(Value_Register));
  384.     Push(Get_Number_Rational_Denominator(Value_Register));
  385.     Push(Top(2));
  386.  
  387.     Is_Number_Negative();
  388.     Pop(1);
  389.  
  390.     if (Value_Register == The_True_Object )
  391.     {
  392.         Number_Quotient();
  393.         Push(Value_Register);
  394.         Make_Fixnum_Number(1);
  395.         Push(Value_Register);
  396.         Number_Subtract();
  397.         Pop(4);
  398.     }
  399.     else
  400.     {
  401.         Number_Quotient();
  402.         Pop(2);
  403.     }
  404.  
  405.     if ( ! Is_Exact_Number( Top(1) ) )
  406.     {
  407.         Push( Value_Register );
  408.         Number_Exact_To_Inexact(); Pop(1);
  409.     }
  410. }
  411.  
  412. Public void Rational_Ceiling()
  413. {
  414.     Value_Register = Copy_Object(Top(1), Rational_Size);
  415.  
  416.     Push(Get_Number_Rational_Numerator(Value_Register));
  417.     Push(Get_Number_Rational_Denominator(Value_Register));
  418.  
  419.     Number_Remainder();
  420.     Push(Value_Register);
  421.     Is_Number_Zero();
  422.     Pop(1);
  423.  
  424.     if (Value_Register == The_True_Object)
  425.     {
  426.         Push(Top(3));
  427.         Rational_Floor();    
  428.         Pop(3);
  429.     }
  430.     else
  431.     {
  432.         Push(Top(3));
  433.         Rational_Floor();
  434.         Push(Value_Register);
  435.         Make_Fixnum_Number(1);
  436.         Push(Value_Register);
  437.         Number_Add();
  438.         Pop(5);
  439.     }
  440.  
  441.     if ( ! Is_Exact_Number( Top(1) ) )
  442.     {
  443.         Push( Value_Register );
  444.         Number_Exact_To_Inexact(); Pop(1);
  445.     }
  446. }
  447.  
  448.  
  449.  
  450. Public void Rational_Truncate()
  451. {
  452.     if (Number_Sign(Get_Number_Rational_Numerator(Top(1))) > 0)
  453.     {
  454.         Rational_Floor();
  455.     }
  456.     else
  457.     {
  458.         Rational_Ceiling();
  459.     }
  460.  
  461.     if ( ! Is_Exact_Number( Top(1) ) )
  462.     {
  463.         Push( Value_Register );
  464.         Number_Exact_To_Inexact(); Pop(1);
  465.     }
  466. }
  467.  
  468.  
  469.  
  470. Public void Rational_Round()
  471. {
  472.     /* Compare the given rat to average of floor and ceiling and choose
  473.        either floor or ceiling depending on result and sign of the rat;
  474.        Numbers halfway between two integers round to even. */
  475.  
  476.     
  477.     Rational_Floor();
  478.     Push(Value_Register);
  479.     Push(Top(2));
  480.     Rational_Ceiling();
  481.     Push(Value_Register);
  482.     Push(Top(3));
  483.     Number_Add();
  484.     Push(Value_Register);
  485.     Make_Fixnum_Number(2);
  486.     Push(Value_Register);
  487.     Number_Divide();
  488.     Push(Value_Register);
  489.     Push(Top(6));
  490.     Number_Less_Than();
  491.  
  492.     if (Value_Register == The_True_Object)
  493.     {
  494.         Push(Top(7));
  495.         Rational_Ceiling();
  496.         Pop(9);
  497.     }
  498.     else 
  499.     {
  500.         Number_Greater_Than();
  501.         if(Value_Register == The_True_Object)
  502.         {
  503.             Push(Top(7));
  504.             Rational_Floor();
  505.             Pop(9);
  506.         }
  507.         else
  508.         {
  509.             Push(Top(7));
  510.             Rational_Floor();
  511.             Push(Value_Register);
  512.             Is_Number_Even();
  513.             if(Value_Register == The_True_Object)
  514.             {
  515.                 Value_Register = Top(1);
  516.                 Pop(10);
  517.             }
  518.             else
  519.             {
  520.                 Pop(1);
  521.                 Rational_Ceiling();
  522.                 Pop(9);
  523.             }
  524.         }
  525.     }
  526.  
  527.     if ( ! Is_Exact_Number( Top(1) ) )
  528.     {
  529.         Push( Value_Register );
  530.         Number_Exact_To_Inexact(); Pop(1);
  531.     }
  532. }
  533.  
  534.  
  535.  
  536.  
  537. Public void Rational_Sqrt()
  538. {
  539.     Promote(1, REAL_LEVEL);
  540.     
  541.     if( Get_Number_Real_Value(Top(1)) < 0 )
  542.     {
  543.         Make_Complex_Number( (Double) 0.0 ,
  544.                      sqrt( - Get_Number_Real_Value(Top(1))) );
  545.         }
  546.     else
  547.     {
  548.         Make_Real_Number( sqrt (Get_Number_Real_Value(Top(1))) );
  549.     }
  550. }
  551.  
  552.  
  553.  
  554. Public void Rational_Exp()
  555. {
  556.     Promote(1, REAL_LEVEL);
  557.  
  558.     Make_Real_Number( exp (Get_Number_Real_Value(Top(1))) );
  559. }
  560.  
  561.  
  562.  
  563. Public void Rational_Log()
  564. {
  565.     if(Number_Sign(Get_Number_Rational_Numerator(Top(1))) < 0)
  566.     {
  567.         Error("Argument of log must be nonnegative");
  568.     }
  569.  
  570.     Promote(1, REAL_LEVEL);
  571.  
  572.     Make_Real_Number( log (Get_Number_Real_Value(Top(1))) );
  573. }
  574.  
  575.  
  576.  
  577. Public void Rational_Expt()
  578. {
  579.     Promote(1, REAL_LEVEL);
  580.     Promote(2, REAL_LEVEL);
  581.  
  582.     Make_Real_Number( pow ((Get_Number_Real_Value(Top(2))),
  583.                 (Get_Number_Real_Value(Top(1))) ) );
  584. }
  585.  
  586.  
  587.  
  588.  
  589. Public void Rational_Sin()
  590. {
  591.     Promote(1, REAL_LEVEL);
  592.  
  593.     Make_Real_Number( sin (Get_Number_Real_Value(Top(1))) );
  594. }
  595.  
  596.  
  597.  
  598. Public void Rational_Cos()
  599. {
  600.     Promote(1, REAL_LEVEL);
  601.  
  602.     Make_Real_Number( cos (Get_Number_Real_Value(Top(1))) );
  603. }
  604.  
  605.  
  606.  
  607. Public void Rational_Tan()
  608. {
  609.     Promote(1, REAL_LEVEL);
  610.  
  611.     Make_Real_Number( tan (Get_Number_Real_Value(Top(1))) );
  612. }
  613.  
  614.  
  615.  
  616. Public void Rational_Asin()
  617. {
  618.     Promote(1, REAL_LEVEL);
  619.  
  620.     if(((Get_Number_Real_Value(Top(1))) < -1) ||
  621.         ((Get_Number_Real_Value(Top(1))) > 1))
  622.     {
  623.         Error("Argument of asin must lie between -1 and 1, inclusive");
  624.     }
  625.  
  626.     Make_Real_Number( asin (Get_Number_Real_Value(Top(1))) );
  627. }
  628.  
  629.  
  630.  
  631. Public void Rational_Acos()
  632. {
  633.     Promote(1, REAL_LEVEL);
  634.  
  635.     if(((Get_Number_Real_Value(Top(1))) < -1) ||
  636.         ((Get_Number_Real_Value(Top(1))) > 1))
  637.     {
  638.         Error("Argument of acos must lie between -1 and 1, inclusive");
  639.     }
  640.  
  641.     Make_Real_Number( acos (Get_Number_Real_Value(Top(1))) );
  642. }
  643.  
  644.  
  645.  
  646. Public void Rational_Atan()
  647. {
  648.     Promote(1, REAL_LEVEL);
  649.  
  650.     Make_Real_Number( atan (Get_Number_Real_Value(Top(1))) );
  651. }
  652.  
  653.  
  654.  
  655. Public void Rational_Atan2()
  656. {
  657.     Promote(1, REAL_LEVEL);
  658.     Promote(2, REAL_LEVEL);
  659.  
  660.     Make_Real_Number( atan2 (Get_Number_Real_Value(Top(2)),   
  661.                 Get_Number_Real_Value(Top(1))) );
  662.  
  663. }
  664.  
  665.  
  666.  
  667.  
  668. /* Transfer functions */
  669.  
  670.  
  671. Public void Rational_Exact_To_Inexact()
  672. {
  673.     Value_Register = Copy_Object(Top(1), Rational_Size);
  674.     Is_Exact_Number( Value_Register ) = FALSE;
  675. }
  676.  
  677.  
  678.  
  679. Public void Rational_Inexact_To_Exact()
  680. {
  681.     Value_Register = Copy_Object(Top(1), Rational_Size);
  682.     Is_Exact_Number( Value_Register ) = TRUE;
  683. }
  684.  
  685.  
  686. Public void Rational_To_String()
  687. {
  688.     Import    void String_Append();
  689.  
  690.     Integer radix = Number_To_Integer( Top(1) );
  691.  
  692.     Make_Constant_String( Is_Exact_Number( Top(2) ) ? "" : "#i" );
  693.     Push( Value_Register );
  694.  
  695.     Push(Get_Number_Rational_Numerator(Top(3)));
  696.     Push( Top(3) );
  697.     Number_To_String(); Pop(2);
  698.     Push( Value_Register );
  699.     String_Append(); Pop(2);
  700.     Push( Value_Register );
  701.  
  702.     Make_Constant_String( "/" );
  703.     Push( Value_Register );
  704.     String_Append(); Pop(2);
  705.     Push( Value_Register );
  706.  
  707.     Push(Get_Number_Rational_Denominator(Top(3)));
  708.     Push( Top(3) );
  709.     Number_To_String(); Pop(2);
  710.     Push( Value_Register );
  711.     if ( radix != 10)
  712.     {
  713.         /* Remove radix prefix from denominator */
  714.  
  715.         Make_Constant_String( Get_String_Value( Top(1) ) + 2 ); Pop(1);
  716.         Push( Value_Register );
  717.     }
  718.     String_Append(); Pop(2);
  719. }
  720.  
  721. Public void Rational_Make_Rectangular()
  722. {
  723.     Promote(1, REAL_LEVEL);
  724.     Promote(2, REAL_LEVEL);
  725.  
  726.     Make_Complex_Number( Get_Number_Real_Value(Top(2)),
  727.                 Get_Number_Real_Value(Top(1)));
  728. }
  729.  
  730.  
  731.  
  732. Public void Rational_Make_Polar()
  733.  
  734. #define MAG Get_Number_Real_Value(Top(2))
  735. #define ANG Get_Number_Real_Value(Top(1))
  736.  
  737. {
  738.     Promote( 2, REAL_LEVEL);
  739.     Promote( 1, REAL_LEVEL);
  740.  
  741.     Make_Complex_Number( (MAG) * cos(ANG) , (MAG) * sin(ANG) );
  742.  
  743. }
  744.  
  745. #undef MAG
  746. #undef ANG
  747.  
  748.  
  749.  
  750.  
  751. Public void Rational_Real_Part()
  752. {
  753.     Promote(1, REAL_LEVEL);
  754.     Value_Register = Top(1);
  755. }
  756.  
  757.  
  758.  
  759. Public void Rational_Imaginary_Part()
  760. {
  761.     Make_Real_Number(0.0);
  762. }
  763.  
  764.  
  765.  
  766. Public void Rational_Magnitude()
  767. {
  768.     Rational_Abs();
  769. }
  770.  
  771.  
  772.  
  773. Public void Rational_Angle()
  774. {
  775.     Make_Real_Number(0.0);
  776. }
  777.  
  778.  
  779.  
  780. Public    void Reduce_Rational()
  781. {
  782.     /* To reduce a rational you divide the numerator and
  783.        denominator by their GCD */
  784.  
  785.  
  786.     Push( Value_Register ); /* The rational */
  787.  
  788.     Push(Get_Number_Rational_Numerator(Value_Register));
  789.     Push(Get_Number_Rational_Denominator(Value_Register));
  790.     Number_GCD(); 
  791.     Pop(2);
  792.     Push( Value_Register );    /* The gcd */
  793.  
  794.     Push( Get_Number_Rational_Numerator(Top(2)) )
  795.     Push(Top(2));
  796.     Number_Quotient();
  797.     Pop(2);
  798.     Get_Number_Rational_Numerator(Top(2)) = Value_Register;
  799.  
  800.     Push( Get_Number_Rational_Denominator( Top(2) ) );
  801.     Push(Top(2));
  802.     Number_Quotient();
  803.     Pop(2);
  804.     Get_Number_Rational_Denominator(Top(2)) = Value_Register;
  805.  
  806.     Value_Register = Top(2);
  807.     Pop(2);
  808. }    
  809.