home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / l / l180 / 2.ddi / QCALMATH.BAS < prev    next >
Encoding:
BASIC Source File  |  1989-02-07  |  24.5 KB  |  694 lines
  1.   ' ************************************************
  2.   ' **  Name:          QCALMATH                   **
  3.   ' **  Type:          Toolbox                    **
  4.   ' **  Module:        QCALMATH.BAS               **
  5.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  6.   ' ************************************************
  7.   '
  8.   ' Collection of math functions and subprograms for
  9.   ' the QCAL program.
  10.   '
  11.   ' USAGE:         (loaded by the QCAL program)
  12.   '.MAK FILE:      (none)
  13.   ' PARAMETERS:    (none)
  14.   ' VARIABLES:     (none)
  15.   ' Constants
  16.     CONST PI = 3.141592653589793#
  17.     CONST L10 = 2.302585092994046#
  18.   
  19.   ' Functions
  20.     DECLARE FUNCTION AbsoluteX# (x#)
  21.     DECLARE FUNCTION Add# (y#, x#)
  22.     DECLARE FUNCTION ArcCosine# (x#)
  23.     DECLARE FUNCTION ArcHypCosine# (x#)
  24.     DECLARE FUNCTION ArcHypSine# (x#)
  25.     DECLARE FUNCTION ArcHypTangent# (x#)
  26.     DECLARE FUNCTION ArcSine# (x#)
  27.     DECLARE FUNCTION ArcTangent# (x#)
  28.     DECLARE FUNCTION Ceil# (x#)
  29.     DECLARE FUNCTION ChangeSign# (x#)
  30.     DECLARE FUNCTION Cosine# (x#)
  31.     DECLARE FUNCTION Divide# (y#, x#)
  32.     DECLARE FUNCTION Exponential# (x#)
  33.     DECLARE FUNCTION FractionalPart# (x#)
  34.     DECLARE FUNCTION HypCosine# (x#)
  35.     DECLARE FUNCTION HypSine# (x#)
  36.     DECLARE FUNCTION HypTangent# (x#)
  37.     DECLARE FUNCTION IntegerPart# (x#)
  38.     DECLARE FUNCTION LogBase10# (x#)
  39.     DECLARE FUNCTION LogBaseN# (y#, x#)
  40.     DECLARE FUNCTION LogE# (x#)
  41.     DECLARE FUNCTION Modulus# (y#, x#)
  42.     DECLARE FUNCTION Multiply# (y#, x#)
  43.     DECLARE FUNCTION OneOverX# (x#)
  44.     DECLARE FUNCTION Sign# (x#)
  45.     DECLARE FUNCTION Sine# (x#)
  46.     DECLARE FUNCTION SquareRoot# (x#)
  47.     DECLARE FUNCTION Subtract# (y#, x#)
  48.     DECLARE FUNCTION Tangent# (x#)
  49.     DECLARE FUNCTION Xsquared# (x#)
  50.     DECLARE FUNCTION YRaisedToX# (y#, x#)
  51.   
  52.   ' ************************************************
  53.   ' **  Name:          AbsoluteX#                 **
  54.   ' **  Type:          Function                   **
  55.   ' **  Module:        QCALMATH.BAS               **
  56.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  57.   ' ************************************************
  58.   '
  59.   ' EXAMPLE OF USE:  y# = AbsoluteX#(x#)
  60.   ' PARAMETERS:      x#         Double-precision value to be evaluated
  61.   ' VARIABLES:       (none)
  62.   ' MODULE LEVEL
  63.   '   DECLARATIONS:  DECLARE FUNCTION AbsoluteX# (x#)
  64.   '
  65.     FUNCTION AbsoluteX# (x#) STATIC
  66.         AbsoluteX# = ABS(x#)
  67.     END FUNCTION
  68.   
  69.   ' ************************************************
  70.   ' **  Name:          Add#                       **
  71.   ' **  Type:          Function                   **
  72.   ' **  Module:        QCALMATH.BAS               **
  73.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  74.   ' ************************************************
  75.   '
  76.   ' EXAMPLE OF USE:  z# = Add#(y#, x#)
  77.   ' PARAMETERS:      y#         First number
  78.   '                  x#         Second number
  79.   ' VARIABLES:       (none)
  80.   ' MODULE LEVEL
  81.   '   DECLARATIONS:  DECLARE FUNCTION Add# (y#, x#)
  82.   '
  83.     FUNCTION Add# (y#, x#) STATIC
  84.         Add# = y# + x#
  85.     END FUNCTION
  86.   
  87.   ' ************************************************
  88.   ' **  Name:          ArcCosine#                 **
  89.   ' **  Type:          Function                   **
  90.   ' **  Module:        QCALMATH.BAS               **
  91.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  92.   ' ************************************************
  93.   '
  94.   ' EXAMPLE OF USE:  y# = ArcCosine#(x#)
  95.   ' PARAMETERS:      x#         Number to be evaluated
  96.   ' VARIABLES:       (none)
  97.   ' MODULE LEVEL
  98.   '   DECLARATIONS:  DECLARE FUNCTION ArcCosine# (x#)
  99.   '
  100.     FUNCTION ArcCosine# (x#) STATIC
  101.         x2# = x# * x#
  102.         IF x2# < 1# THEN
  103.             ArcCosine# = PI / 2# - ATN(x# / SQR(1# - x# * x#))
  104.         ELSE
  105.             PRINT "Error: ACS(x#) where x# < 1"
  106.             SYSTEM
  107.         END IF
  108.     END FUNCTION
  109.   
  110.   ' ************************************************
  111.   ' **  Name:          ArcHypCosine#              **
  112.   ' **  Type:          Function                   **
  113.   ' **  Module:        QCALMATH.BAS               **
  114.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  115.   ' ************************************************
  116.   '
  117.   ' EXAMPLE OF USE:  y# = ArcHypCosine#(x#)
  118.   ' PARAMETERS:      x#         Number to be evaluated
  119.   ' VARIABLES:       (none)
  120.   ' MODULE LEVEL
  121.   '   DECLARATIONS:  DECLARE FUNCTION ArcHypCosine# (x#)
  122.   '
  123.     FUNCTION ArcHypCosine# (x#) STATIC
  124.         IF ABS(x#) > 1# THEN
  125.             ArcHypCosine# = LOG(x# + SQR(x# * x# - 1#))
  126.         ELSE
  127.             PRINT "Error: AHS(x#) where -1 <= x# <= +1"
  128.             SYSTEM
  129.         END IF
  130.     END FUNCTION
  131.   
  132.   ' ************************************************
  133.   ' **  Name:          ArcHypSine#                **
  134.   ' **  Type:          Function                   **
  135.   ' **  Module:        QCALMATH.BAS               **
  136.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  137.   ' ************************************************
  138.   '
  139.   ' EXAMPLE OF USE:  y# = ArcHypSine#(x#)
  140.   ' PARAMETERS:      x#    Number to be evaluated
  141.   ' VARIABLES:       (none)
  142.   ' MODULE LEVEL
  143.   '   DECLARATIONS:  DECLARE FUNCTION AryHypSine# (x#)
  144.   '
  145.     FUNCTION ArcHypSine# (x#) STATIC
  146.         ArcHypSine# = LOG(x# + SQR(1# + x# * x#))
  147.     END FUNCTION
  148.   
  149.   ' ************************************************
  150.   ' **  Name:          ArcHypTangent#             **
  151.   ' **  Type:          Function                   **
  152.   ' **  Module:        QCALMATH.BAS               **
  153.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  154.   ' ************************************************
  155.   '
  156.   ' EXAMPLE OF USE:  y# = ArcHypTangent#(x#)
  157.   ' PARAMETERS:      x#         Number to be evaluated
  158.   ' VARIABLES:       (none)
  159.   ' MODULE LEVEL
  160.   '   DECLARATIONS:  DECLARE FUNCTION ArcHypTangent# (x#)
  161.   '
  162.     FUNCTION ArcHypTangent# (x#) STATIC
  163.         IF ABS(x#) < 1 THEN
  164.             ArcHypTangent# = LOG((1# + x#) / (1# - x#)) / 2#
  165.         ELSE
  166.             PRINT "Error: AHT(x#) where x# <= -1 or x# >= +1"
  167.             SYSTEM
  168.         END IF
  169.     END FUNCTION
  170.   
  171.   ' ************************************************
  172.   ' **  Name:          ArcSine#                   **
  173.   ' **  Type:          Function                   **
  174.   ' **  Module:        QCALMATH.BAS               **
  175.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  176.   ' ************************************************
  177.   '
  178.   ' EXAMPLE OF USE:  y# = ArcSine#(x#)
  179.   ' PARAMETERS:      x#         Number to be evaluated
  180.   ' VARIABLES:       (none)
  181.   ' MODULE LEVEL
  182.   '   DECLARATIONS:  DECLARE FUNCTION ArcSine# (x#)
  183.   '
  184.     FUNCTION ArcSine# (x#) STATIC
  185.         x2# = x# * x#
  186.         IF x2# < 1# THEN
  187.             ArcSine# = ATN(x# / SQR(1# - x# * x#))
  188.         ELSE
  189.             PRINT "Error: ASN(x#) where x# >= 1"
  190.             SYSTEM
  191.         END IF
  192.     END FUNCTION
  193.   
  194.   ' ************************************************
  195.   ' **  Name:          ArcTangent#                **
  196.   ' **  Type:          Function                   **
  197.   ' **  Module:        QCALMATH.BAS               **
  198.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  199.   ' ************************************************
  200.   '
  201.   ' EXAMPLE OF USE:  y# = ArcTangent#(x#)
  202.   ' PARAMETERS:      x#         Number to be evaluated
  203.   ' VARIABLES:       (none)
  204.   ' MODULE LEVEL
  205.   '   DECLARATIONS:  DECLARE FUNCTION ArcTangent# (x#)
  206.   '
  207.     FUNCTION ArcTangent# (x#) STATIC
  208.         ArcTangent# = ATN(x#)
  209.     END FUNCTION
  210.   
  211.   ' ************************************************
  212.   ' **  Name:          Ceil#                      **
  213.   ' **  Type:          Function                   **
  214.   ' **  Module:        QCALMATH.BAS               **
  215.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  216.   ' ************************************************
  217.   '
  218.   ' EXAMPLE OF USE:  y# = Ceil#(x#)
  219.   ' PARAMETERS:      x#         Number to be evaluated
  220.   ' VARIABLES:       (none)
  221.   ' MODULE LEVEL
  222.   '   DECLARATIONS:  DECLARE FUNCTION Ceil# (x#)
  223.   '
  224.     FUNCTION Ceil# (x#) STATIC
  225.         Ceil# = -INT(-x#)
  226.     END FUNCTION
  227.   
  228.   ' ************************************************
  229.   ' **  Name:          ChangeSign#                **
  230.   ' **  Type:          Function                   **
  231.   ' **  Module:        QCALMATH.BAS               **
  232.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  233.   ' ************************************************
  234.   '
  235.   ' EXAMPLE OF USE:  y# = ChangeSign#(x#)
  236.   ' PARAMETERS:      x#         Number to be evaluated
  237.   ' VARIABLES:       (none)
  238.   ' MODULE LEVEL
  239.   '   DECLARATIONS:  DECLARE FUNCTION ChangeSign# (x#)
  240.   '
  241.     FUNCTION ChangeSign# (x#) STATIC
  242.         ChangeSign# = -x#
  243.     END FUNCTION
  244.   
  245.   ' ************************************************
  246.   ' **  Name:          Cosine#                    **
  247.   ' **  Type:          Function                   **
  248.   ' **  Module:        QCALMATH.BAS               **
  249.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  250.   ' ************************************************
  251.   '
  252.   ' EXAMPLE OF USE:  y# = Cosine#(x#)
  253.   ' PARAMETERS:      x#         Angle to be evaluated
  254.   ' VARIABLES:       (none)
  255.   ' MODULE LEVEL
  256.   '   DECLARATIONS:  DECLARE FUNCTION Cosine# (x#)
  257.   '
  258.     FUNCTION Cosine# (x#) STATIC
  259.         Cosine# = COS(x#)
  260.     END FUNCTION
  261.   
  262.   ' ************************************************
  263.   ' **  Name:          Divide#                    **
  264.   ' **  Type:          Function                   **
  265.   ' **  Module:        QCALMATH.BAS               **
  266.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  267.   ' ************************************************
  268.   '
  269.   ' EXAMPLE OF USE:  y# = Divide#(y#, x#)
  270.   ' PARAMETERS:      y#         Number to be processed
  271.   '                  x#         Number to be processed
  272.   ' VARIABLES:       (none)
  273.   ' MODULE LEVEL
  274.   '   DECLARATIONS:  DECLARE FUNCTION Divide# (y#, x#)
  275.   '
  276.     FUNCTION Divide# (y#, x#) STATIC
  277.         IF x# <> 0 THEN
  278.             Divide# = y# / x#
  279.         ELSE
  280.             PRINT "Error: Division by zero"
  281.             SYSTEM
  282.         END IF
  283.     END FUNCTION
  284.   
  285.   ' ************************************************
  286.   ' **  Name:          Dup                        **
  287.   ' **  Type:          Subprogram                 **
  288.   ' **  Module:        QCALMATH.BAS               **
  289.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  290.   ' ************************************************
  291.   '
  292.   ' EXAMPLE OF USE:  Dup stack#(), ptr%
  293.   ' PARAMETERS:      stack#()   Numeric stack
  294.   '                  ptr%       Index to last entry on stack
  295.   ' VARIABLES:       (none)
  296.   ' MODULE LEVEL
  297.   '   DECLARATIONS:  DECLARE SUB Dup (Stack#(), ptr%)
  298.   '
  299.     SUB Dup (stack#(), ptr%) STATIC
  300.         IF ptr% THEN
  301.             ptr% = ptr% + 1
  302.             stack#(ptr%) = stack#(ptr% - 1)
  303.         END IF
  304.     END SUB
  305.   
  306.   ' ************************************************
  307.   ' **  Name:          Exponential#               **
  308.   ' **  Type:          Function                   **
  309.   ' **  Module:        QCALMATH.BAS               **
  310.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  311.   ' ************************************************
  312.   '
  313.   ' EXAMPLE OF USE:  y# = Exponential#(x#)
  314.   ' PARAMETERS:      x#         Number to be processed
  315.   ' VARIABLES:       (none)
  316.   ' MODULE LEVEL
  317.   '   DECLARATIONS:  DECLARE FUNCTION Exponential# (x#)
  318.   '
  319.     FUNCTION Exponential# (x#) STATIC
  320.         Exponential# = EXP(x#)
  321.     END FUNCTION
  322.   
  323.   ' ************************************************
  324.   ' **  Name:          FractionalPart#            **
  325.   ' **  Type:          Function                   **
  326.   ' **  Module:        QCALMATH.BAS               **
  327.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  328.   ' ************************************************
  329.   '
  330.   ' EXAMPLE OF USE:  y# = FractionalPart#(x#)
  331.   ' PARAMETERS:      x#         Number to be processed
  332.   ' VARIABLES:       (none)
  333.   ' MODULE LEVEL
  334.   '   DECLARATIONS:  DECLARE FUNCTION FractionalPart# (x#)
  335.   '
  336.     FUNCTION FractionalPart# (x#) STATIC
  337.         IF x# >= 0 THEN
  338.             FractionalPart# = x# - INT(x#)
  339.         ELSE
  340.             FractionalPart# = x# - INT(x#) - 1#
  341.         END IF
  342.     END FUNCTION
  343.   
  344.   ' ************************************************
  345.   ' **  Name:          HypCosine#                 **
  346.   ' **  Type:          Function                   **
  347.   ' **  Module:        QCALMATH.BAS               **
  348.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  349.   ' ************************************************
  350.   '
  351.   ' EXAMPLE OF USE:  y# = HypCosine#(x#)
  352.   ' PARAMETERS:      x#         Number to be processed
  353.   ' VARIABLES:       (none)
  354.   ' MODULE LEVEL
  355.   '   DECLARATIONS:  DECLARE FUNCTION HypCosine# (x#)
  356.   '
  357.     FUNCTION HypCosine# (x#) STATIC
  358.         HypCosine# = (EXP(x#) + EXP(-x#)) / 2#
  359.     END FUNCTION
  360.   
  361.   ' ************************************************
  362.   ' **  Name:          HypSine#                   **
  363.   ' **  Type:          Function                   **
  364.   ' **  Module:        QCALMATH.BAS               **
  365.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  366.   ' ************************************************
  367.   '
  368.   ' EXAMPLE OF USE:  y# = HypSine#(x#)
  369.   ' PARAMETERS:      x#         Number to be processed
  370.   ' VARIABLES:       (none)
  371.   ' MODULE LEVEL
  372.   '   DECLARATIONS:  DECLARE FUNCTION HypSine# (x#)
  373.   '
  374.     FUNCTION HypSine# (x#) STATIC
  375.         HypSine# = (EXP(x#) - EXP(-x#)) / 2#
  376.     END FUNCTION
  377.   
  378.   ' ************************************************
  379.   ' **  Name:          HypTangent#                **
  380.   ' **  Type:          Function                   **
  381.   ' **  Module:        QCALMATH.BAS               **
  382.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  383.   ' ************************************************
  384.   '
  385.   ' EXAMPLE OF USE:  y# = HypTangent#(x#)
  386.   ' PARAMETERS:      x#         Number to be processed
  387.   ' VARIABLES:       (none)
  388.   ' MODULE LEVEL
  389.   '   DECLARATIONS:  DECLARE FUNCTION HypTangent# (x#)
  390.   '
  391.     FUNCTION HypTangent# (x#) STATIC
  392.         HypTangent# = (EXP(x#) - EXP(-x#)) / (EXP(x#) + EXP(-x#))
  393.     END FUNCTION
  394.   
  395.   ' ************************************************
  396.   ' **  Name:          IntegerPart#               **
  397.   ' **  Type:          Function                   **
  398.   ' **  Module:        QCALMATH.BAS               **
  399.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  400.   ' ************************************************
  401.   '
  402.   ' EXAMPLE OF USE:  y# = IntegerPart#(x#)
  403.   ' PARAMETERS:      x#         Number to be processed
  404.   ' VARIABLES:       (none)
  405.   ' MODULE LEVEL
  406.   '   DECLARATIONS:  DECLARE FUNCTION IntegerPart# (x#)
  407.   '
  408.     FUNCTION IntegerPart# (x#) STATIC
  409.         IntegerPart# = INT(x#)
  410.     END FUNCTION
  411.   
  412.   ' ************************************************
  413.   ' **  Name:          LogBase10#                 **
  414.   ' **  Type:          Function                   **
  415.   ' **  Module:        QCALMATH.BAS               **
  416.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  417.   ' ************************************************
  418.   '
  419.   ' EXAMPLE OF USE:  y# = Log10#(x#)
  420.   ' PARAMETERS:      x#         Number to be processed
  421.   ' VARIABLES:       (none)
  422.   ' MODULE LEVEL
  423.   '   DECLARATIONS:  DECLARE FUNCTION LogBase10# (x#)
  424.   '
  425.     FUNCTION LogBase10# (x#) STATIC
  426.         IF x# > 0 THEN
  427.             LogBase10# = LOG(x#) / L10
  428.         ELSE
  429.             PRINT "Error: LOG10(x#) where x# <= 0"
  430.             SYSTEM
  431.         END IF
  432.     END FUNCTION
  433.   
  434.   ' ************************************************
  435.   ' **  Name:          LogBaseN#                  **
  436.   ' **  Type:          Function                   **
  437.   ' **  Module:        QCALMATH.BAS               **
  438.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  439.   ' ************************************************
  440.   '
  441.   ' EXAMPLE OF USE:  y# = LogBaseN#(y#, x#)
  442.   ' PARAMETERS:      y#         Number to be processed
  443.   '                  x#         The base for finding the logarithm
  444.   ' VARIABLES:       (none)
  445.   ' MODULE LEVEL
  446.   '   DECLARATIONS:  DECLARE FUNCTION LogBaseN# (y#, x#)
  447.   '
  448.     FUNCTION LogBaseN# (y#, x#) STATIC
  449.         IF x# <= 0 THEN
  450.             PRINT "Error: LOGN(y#, x#) where x# <= 0"
  451.             SYSTEM
  452.         ELSEIF x# = 1# THEN
  453.             PRINT "Error: LOGN(y#, x#) where x# = 1"
  454.             SYSTEM
  455.         ELSEIF y# <= 0 THEN
  456.             PRINT "Error: LOGN(y#, x#) where y# is <= 0"
  457.             SYSTEM
  458.         ELSE
  459.             LogBaseN# = LOG(y#) / LOG(x#)
  460.         END IF
  461.     END FUNCTION
  462.   
  463.   ' ************************************************
  464.   ' **  Name:          LogE#                      **
  465.   ' **  Type:          Function                   **
  466.   ' **  Module:        QCALMATH.BAS               **
  467.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  468.   ' ************************************************
  469.   '
  470.   ' EXAMPLE OF USE:  y# = LogE#(x#)
  471.   ' PARAMETERS:      x#         Number to be processed
  472.   ' VARIABLES:       (none)
  473.   ' MODULE LEVEL
  474.   '   DECLARATIONS:  DECLARE FUNCTION LogE# (x#)
  475.   '
  476.     FUNCTION LogE# (x#) STATIC
  477.         IF x# > 0 THEN
  478.             LogE# = LOG(x#)
  479.         ELSE
  480.             PRINT "Error: LOGE(x#) where x# <= 0"
  481.             SYSTEM
  482.         END IF
  483.     END FUNCTION
  484.   
  485.   ' ************************************************
  486.   ' **  Name:          Modulus#                   **
  487.   ' **  Type:          Function                   **
  488.   ' **  Module:        QCALMATH.BAS               **
  489.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  490.   ' ************************************************
  491.   '
  492.   ' EXAMPLE OF USE:  y# = Modulus#(y#, x#)
  493.   ' PARAMETERS:      y#         Number to be divided
  494.   '                  x#         Number for dividing by
  495.   ' VARIABLES:       (none)
  496.   ' MODULE LEVEL
  497.   '   DECLARATIONS:  DECLARE FUNCTION Modulus# (y#, x#)
  498.   '
  499.     FUNCTION Modulus# (y#, x#) STATIC
  500.         IF x# <> 0 THEN
  501.             Modulus# = y# - INT(y# / x#) * x#
  502.         ELSE
  503.             PRINT "Error: MOD(y#, x#) where x# = 0"
  504.             SYSTEM
  505.         END IF
  506.     END FUNCTION
  507.   
  508.   ' ************************************************
  509.   ' **  Name:          Multiply#                  **
  510.   ' **  Type:          Function                   **
  511.   ' **  Module:        QCALMATH.BAS               **
  512.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  513.   ' ************************************************
  514.   '
  515.   ' EXAMPLE OF USE:  y# = Multiply#(y#, x#)
  516.   ' PARAMETERS:      y#         First number to be processed
  517.   '                  x#         Second number to be processed
  518.   ' VARIABLES:       (none)
  519.   ' MODULE LEVEL
  520.   '   DECLARATIONS:  DECLARE FUNCTION Multiply# (y#, x#)
  521.   '
  522.     FUNCTION Multiply# (y#, x#) STATIC
  523.         Multiply# = y# * x#
  524.     END FUNCTION
  525.   
  526.   ' ************************************************
  527.   ' **  Name:          OneOverX#                  **
  528.   ' **  Type:          Function                   **
  529.   ' **  Module:        QCALMATH.BAS               **
  530.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  531.   ' ************************************************
  532.   '
  533.   ' EXAMPLE OF USE:  y# = OneOverX#(x#)
  534.   ' PARAMETERS:      x#         Number to be processed
  535.   ' VARIABLES:       (none)
  536.   ' MODULE LEVEL
  537.   '   DECLARATIONS:  DECLARE FUNCTION OneOverX# (x#)
  538.   '
  539.     FUNCTION OneOverX# (x#) STATIC
  540.         IF x# <> 0 THEN
  541.             OneOverX# = 1# / x#
  542.         ELSE
  543.             PRINT "Error: 1/x where x = 0"
  544.             SYSTEM
  545.         END IF
  546.     END FUNCTION
  547.   
  548.   ' ************************************************
  549.   ' **  Name:          Sign#                      **
  550.   ' **  Type:          Function                   **
  551.   ' **  Module:        QCALMATH.BAS               **
  552.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  553.   ' ************************************************
  554.   '
  555.   ' EXAMPLE OF USE:  y# = Sign#(x#)
  556.   ' PARAMETERS:      x#         Number to be processed
  557.   ' VARIABLES:       (none)
  558.   ' MODULE LEVEL
  559.   '   DECLARATIONS:  DECLARE FUNCTION Sign# (x#)
  560.   '
  561.     FUNCTION Sign# (x#) STATIC
  562.         Sign# = SGN(x#)
  563.     END FUNCTION
  564.   
  565.   ' ************************************************
  566.   ' **  Name:          Sine#                      **
  567.   ' **  Type:          Function                   **
  568.   ' **  Module:        QCALMATH.BAS               **
  569.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  570.   ' ************************************************
  571.   '
  572.   ' EXAMPLE OF USE:  y# = Sine#(x#)
  573.   ' PARAMETERS:      x#         Angle, expressed in radians
  574.   ' VARIABLES:       (none)
  575.   ' MODULE LEVEL
  576.   '   DECLARATIONS:  DECLARE FUNCTION Sine# (x#)
  577.   '
  578.     FUNCTION Sine# (x#) STATIC
  579.         Sine# = SIN(x#)
  580.     END FUNCTION
  581.   
  582.   ' ************************************************
  583.   ' **  Name:          SquareRoot#                **
  584.   ' **  Type:          Function                   **
  585.   ' **  Module:        QCALMATH.BAS               **
  586.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  587.   ' ************************************************
  588.   '
  589.   ' EXAMPLE OF USE:  y# = SquareRoot#(x#)
  590.   ' PARAMETERS:      x#         Number to be processed
  591.   ' VARIABLES:       (none)
  592.   ' MODULE LEVEL
  593.   '   DECLARATIONS:  DECLARE FUNCTION SquareRoot# (x#)
  594.   '
  595.     FUNCTION SquareRoot# (x#) STATIC
  596.         IF x# >= 0 THEN
  597.             SquareRoot# = SQR(x#)
  598.         ELSE
  599.             PRINT "Error: SQR(x#) where x# < 0"
  600.             SYSTEM
  601.         END IF
  602.     END FUNCTION
  603.   
  604.   ' ************************************************
  605.   ' **  Name:          Subtract#                  **
  606.   ' **  Type:          Function                   **
  607.   ' **  Module:        QCALMATH.BAS               **
  608.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  609.   ' ************************************************
  610.   '
  611.   ' EXAMPLE OF USE:   y# = Subtract#(y#, x#)
  612.   ' PARAMETERS:       y#         Number to be processed
  613.   '                   x#         Number to be processed
  614.   ' VARIABLES:        (none)
  615.   ' MODULE LEVEL
  616.   '   DECLARATIONS:   DECLARE FUNCTION Subtract# (y#, x#)
  617.   '
  618.     FUNCTION Subtract# (y#, x#) STATIC
  619.         Subtract# = y# - x#
  620.     END FUNCTION
  621.   
  622.   ' ************************************************
  623.   ' **  Name:          SwapXY                     **
  624.   ' **  Type:          Subprogram                 **
  625.   ' **  Module:        QCALMATH.BAS               **
  626.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  627.   ' ************************************************
  628.   '
  629.   ' EXAMPLE OF USE:  SwapXY stack#(), ptr%
  630.   ' PARAMETERS:      stack#()   Numeric stack
  631.   '                  ptr%       Pointer to top of stack
  632.   ' VARIABLES:       (none)
  633.   ' MODULE LEVEL
  634.   '   DECLARATIONS:  DECLARE SUB SwapXY (stack#(), ptr%
  635.   '
  636.     SUB SwapXY (stack#(), ptr%) STATIC
  637.         IF ptr% > 1 THEN
  638.             SWAP stack#(ptr%), stack#(ptr% - 1)
  639.         END IF
  640.     END SUB
  641.   
  642.   ' ************************************************
  643.   ' **  Name:          Tangent#                   **
  644.   ' **  Type:          Function                   **
  645.   ' **  Module:        QCALMATH.BAS               **
  646.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  647.   ' ************************************************
  648.   '
  649.   ' EXAMPLE OF USE:  y# = Tangent#(x#)
  650.   ' PARAMETERS:      x#         Angle, expressed in radians
  651.   ' VARIABLES:       (none)
  652.   ' MODULE LEVEL
  653.   '   DECLARATIONS:  DECLARE FUNCTION Tangent# (x#)
  654.   '
  655.     FUNCTION Tangent# (x#) STATIC
  656.         Tangent# = TAN(x#)
  657.     END FUNCTION
  658.   
  659.   ' ************************************************
  660.   ' **  Name:          Xsquared#                  **
  661.   ' **  Type:          Function                   **
  662.   ' **  Module:        QCALMATH.BAS               **
  663.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  664.   ' ************************************************
  665.   '
  666.   ' EXAMPLE OF USE:  y# = Xsquared#(x#)
  667.   ' PARAMETERS:      x#         Number to be processed
  668.   ' VARIABLES:       (none)
  669.   ' MODULE LEVEL
  670.   '   DECLARATIONS:  DECLARE FUNCTION Xsquared# (x#)
  671.   '
  672.     FUNCTION Xsquared# (x#) STATIC
  673.         Xsquared# = x# * x#
  674.     END FUNCTION
  675.   
  676.   ' ************************************************
  677.   ' **  Name:          YRaisedToX#                **
  678.   ' **  Type:          Function                   **
  679.   ' **  Module:        QCALMATH.BAS               **
  680.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  681.   ' ************************************************
  682.   '
  683.   ' EXAMPLE OF USE:  z# = YRaisedToX#(y#, x#)
  684.   ' PARAMETERS:      y#         Number to be raised to a power
  685.   '                  x#         Power to raise the other number to
  686.   ' VARIABLES:       (none)
  687.   ' MODULE LEVEL
  688.   '   DECLARATIONS:  DECLARE FUNCTION YRaisedToX# (y#, x#)
  689.   '
  690.     FUNCTION YRaisedToX# (y#, x#) STATIC
  691.         YRaisedToX# = y# ^ x#
  692.     END FUNCTION
  693.   
  694.