home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / basic / qlib / solve.doc < prev    next >
Text File  |  1993-06-04  |  17KB  |  453 lines
  1. QLIB's SOLVE subroutines and functions provide quick solutions for common
  2. mathematical equations.  Many require a math coprocessor.  As with many of
  3. QLIB's DATA subroutines, a function or subroutine with INT, LNG, SNG or DBL
  4. in its name is to be used with INTEGER, LONG, SINGLE, or DOUBLE data types,
  5. respectively.
  6.  
  7. SINGLE and DOUBLE data in SOLVE subroutines and functions must be in IEEE
  8. format.  Since this is the default format for QuickBASIC beginning with
  9. version 4.0, and for BC beginning with BC6, this will not be a problem in
  10. most cases.
  11.  
  12.  
  13.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  14.  
  15.     Function: f! = C2F(c!)
  16.     Function: c! = F2C(f!)
  17.     object code: degrees.obj
  18.  
  19.          C2F calculates degrees Farenheit f! from degrees Celcius c!.
  20.     F2C calculates degrees Celcius c! from degrees Farenheit f!.  C2F
  21.     and F2C use the 8087 if available, or use BASIC's 8087 emulator
  22.     if no 8087 is in the computer.
  23.  
  24.     Example:
  25.         REM $INCLUDE: 'qlib.bi'
  26.         f! = 100!
  27.         c! = C2F(f!)          ' 100 degrees Celcius
  28.                               ' converted to degrees Farenheit
  29.  
  30.  
  31.  
  32.  
  33.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  34.  
  35.     Subroutine: CubeFitF4(s%, o%, n%, a!, b!, c!, d!)
  36.     Subroutine: CubeFitF8(s%, o%, n%, a!, b!, c!, d!)
  37.     Subroutine: CubeFitI2(s%, o%, n%, a!, b!, c!, d!)
  38.     Subroutine: CubeFitI4(s%, o%, n%, a!, b!, c!, d!)
  39.     object file: cubefit.obj
  40.  
  41.         CubeFit subroutines use the Least Squares method to determine
  42.     the coefficients of a cubic equation to fit n sets of coordinate data.
  43.     The formula is of the form
  44.  
  45.          y = a! + b!x + c!x^2 +d!x^3
  46.  
  47.     CubeFitF4 requires coordinate data as SINGLE data.
  48.     CubeFitF8 requires coordinate data as DOUBLE data.
  49.     CubeFitI2 requires coordinate data as INTEGER data.
  50.     CubeFitI4 requires coordinate data as LONG data.
  51.  
  52.     The CubeFit subroutines use the 8087 extensively; QuickBASIC's 8087
  53.     emulator works properly when compiled with the /o switch; if you do
  54.     not have a math coprocessor, CubeFit may not work within the
  55.     QuickBASIC development environment.  Hint: if the computer locks up,
  56.     it's not working properly.  Save your work before trying CubeFit if
  57.     you don't have an 8087.
  58.  
  59.     Example 1:
  60.         REM  I have 5 data points, and I want a cubic equation
  61.         REM  that best describes the points
  62.         REM  I'll use a 2-dimensional array for the first example
  63.  
  64.         DIM points(1,4) AS INTEGER
  65.         points(0,0) = x0: points(1,0) = y0
  66.         points(0,1) = x1: points(1,1) = y1
  67.         points(0,2) = x2: points(1,2) = y2
  68.         points(0,3) = x3: points(1,3) = y3
  69.         points(0,4) = x4: points(1,4) = y4
  70.         s% = VARSEG(points(0,0)): o% = VARPTR(points(0,0)): n% = 5
  71.         CALL CubeFitI2(s%, o%, n%, a!, b!, c!, d!)
  72.         REM  CubeFit returns the formula  y = a! + b!x + c!x^2 + d!x^3
  73.  
  74.     Example 2:
  75.         REM  this time I'll use a one-dimensional integer array
  76.  
  77.         DIM points(9) AS INTEGER
  78.         points(0) = x0: points(1) = y0
  79.         points(2) = x1: points(3) = y1
  80.         points(4) = x2: points(5) = y2
  81.         points(6) = x3: points(7) = y3
  82.         points(8) = x4: points(9) = y4
  83.         s% = VARSEG(points(0)): o% = VARPTR(points(0)): n% = 5
  84.         CALL CubeFitI2(s%, o%, n%, a!, b!, c!, d!)
  85.  
  86.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  87.  
  88.     Function: fact# = Factorial(n%)
  89.     object code: factori.obj
  90.  
  91.          Factorials, often used in statistics, may be easily calculated
  92.     with this subroutine.  fact# is a DOUBLE real number returned as
  93.     the factorial of the INTEGER n%.  Factorial uses the 8087 if available,
  94.     or uses BASIC's 8087 emulator if no 8087 is in the computer.
  95.  
  96.     Example:
  97.         REM $INCLUDE 'qlib.bi'
  98.         n% = 12: fact# = Factorial(n%)
  99.  
  100.  
  101.  
  102.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  103.  
  104.     Subroutine: FPrimeF4(s, p, n)
  105.     object file: fprimef4.obj
  106.  
  107.     80x87 required
  108.  
  109.  
  110.     Subroutine: FPrimeI2(s, p, n)
  111.     object file: fprimei2.obj
  112.  
  113.     80x87 not required
  114.  
  115.          Given a polynomial function f(x), FPrime calculates the first
  116.     derivative of the function, f'(x).  The coefficients of f(x) must all
  117.     be INT data for FPrimeI2, or SINGLE data for FPrimeF4.
  118.  
  119.     Example:
  120.         DEFINT A-Z
  121.         REM I want to calculate the first derivative of the function
  122.         REM   y = 2 + 3*(x**2) + 2*(x**3) + (x**5)
  123.         REM also called a fifth-order polynomial
  124.  
  125.         DIM f(5)
  126.         f(0) = 2     ' load the coefficients into the array
  127.         f(1) = 0     ' there is no x term
  128.         f(2) = 3     ' this is for the 3*(x**2) term
  129.         f(3) = 2     ' this is for the 2*(x**3) term
  130.         f(4) = 0     ' this is a place holder for the (x**4) term
  131.         f(5) = 1     ' this is for the (x**5) term
  132.         s = VARSEG(f(0)): p = VARPTR(f(0)): n = 6
  133.         call   fprimeI2(s, p, n)
  134.  
  135.         REM  result is
  136.         REM   f(0) = 0, f(1) = 6, f(2) = 6, f(3) = 0, f(4) = 5, f(5) = 0
  137.  
  138.  
  139.  
  140.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  141.  
  142.     Function: fv! = FValue(n%, i!, pmt!, pv!)
  143.     object files: fvalue.obj (xtothey.obj)
  144.  
  145.     Requires 80x87
  146.  
  147.          FValue calculates the future value of a constant cash flow
  148.     given n% periods, i! periodic interest rate (i! <> 0), pmt! constant
  149.     periodic payments and pv! present value.  i! interest rate must not
  150.     be zero or your program will come to a flying stop.
  151.  
  152.     Example:
  153.         REM $INCLUDE: 'qlib.bi'
  154.         REM  my daughter has $100 in her savings account, which accumulates
  155.         REM  interest at a 5.25% interest rate, compounded monthly.  If I
  156.         REM  add $25 to her account at the end of each month, what will she
  157.         REM  have at the end of one year?
  158.         i! = .0525 / 12          ' monthly interest rate
  159.         n% = 12                  ' 12 months
  160.         pmt! = 25!               ' $25 payment
  161.         pv! = 100!               ' starting with $100.00
  162.         fv! = FValue(n%, i!, pmt!, pv!)
  163.                                  ' fv! is the balance in the account
  164.  
  165.  
  166.  
  167.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  168.  
  169.     Subroutine: LineFitF4(s%, o%, n%, a!, b!)
  170.     Subroutine: LineFitF8(s%, o%, n%, a!, b!)
  171.     Subroutine: LineFitI2(s%, o%, n%, a!, b!)
  172.     Subroutine: LineFitI4(s%, o%, n%, a!, b!)
  173.     object file: linefit.obj
  174.  
  175.         LineFit subroutines use the Least Squares method to determine
  176.     the coefficients of a formula to fit n sets of coordinate data.
  177.     The formula is of the form
  178.  
  179.          y = a! + b!x
  180.  
  181.     LineFitF4 requires coordinate data as SINGLE data.
  182.     LineFitF8 requires coordinate data as DOUBLE data.
  183.     LineFitI2 requires coordinate data as INTEGER data.
  184.     LineFitI4 requires coordinate data as LONG data.
  185.  
  186.     The LineFit subroutines use the 8087 extensively; QuickBASIC's 8087
  187.     emulator works properly when compiled with the /o switch; if you do
  188.     not have a math coprocessor, LineFit may not work within the
  189.     QuickBASIC development environment.  Hint: if the computer locks up,
  190.     it's not working properly.  Save your work before trying LineFit if
  191.     you don't have an 8087.
  192.  
  193.     Example 1:
  194.         REM  I have 5 data points, and I want the equation of the line
  195.         REM  that best describes the points
  196.         REM  I'll use a 2-dimensional array for the first example
  197.  
  198.         DIM points(1,4) AS INTEGER
  199.         points(0,0) = x0: points(1,0) = y0
  200.         points(0,1) = x1: points(1,1) = y1
  201.         points(0,2) = x2: points(1,2) = y2
  202.         points(0,3) = x3: points(1,3) = y3
  203.         points(0,4) = x4: points(1,4) = y4
  204.         s% = VARSEG(points(0,0)): o% = VARPTR(points(0,0)): n% = 5
  205.         CALL LineFitI2(s%, o%, n%, a!, b!)
  206.         REM  LineFit returns the formula  y = a! + b!x
  207.  
  208.     Example 2:
  209.         REM  this time I'll use a one-dimensional integer array
  210.  
  211.         DIM points(9) AS INTEGER
  212.         points(0) = x0: points(1) = y0
  213.         points(2) = x1: points(3) = y1
  214.         points(4) = x2: points(5) = y2
  215.         points(6) = x3: points(7) = y3
  216.         points(8) = x4: points(9) = y4
  217.         s% = VARSEG(points(0)): o% = VARPTR(points(0)): n% = 5
  218.         CALL LineFitI2(s%, o%, n%, a!, b!)
  219.  
  220.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  221.  
  222.     Function: npv! = NetPValue(s%, o%, n%, i!)
  223.     object files: npvalue.obj (xtothey.obj)
  224.  
  225.     Requires 80x87
  226.  
  227.         NetPValue calculates the net present value of a series of uneven
  228.     cash flows in the array a!().  Note that the array is of SINGLE data
  229.     type.  If you are interested, I can make this work with other data
  230.     types.  i! interest rate must not be zero or your program will come
  231.     to a flying stop.  This subroutine is for ordinary cash flows, with
  232.     payment at the end of each period.
  233.  
  234.     Example:
  235.         REM $INCLUDE: 'qlib.bi'
  236.         DIM a!(99)               ' 100 payments on a loan
  237.         i! = .08
  238.         REM  program establishes values for each payment
  239.         s% = VARSEG(a!(0)): o% = VARPTR(a!(0))
  240.         npv! = NetPValue(s%, o%, n%, i!)
  241.  
  242.  
  243.  
  244.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  245.  
  246.     Function: pmt! = Payment(n%, i!, pv!, fv!)
  247.     object files: payment.obj (xtothey.obj)
  248.  
  249.     Requires 80x87
  250.  
  251.         Payment calculates equal periodic payments required given pv!, i!,
  252.     fv! and n%.  This pmt! is an ordinary annuity, for example, mortgages,
  253.     discounted notes (with or without balloon), direct reduction loans
  254.     (with or without balloon).  Note that fv! = 0 with no balloon.
  255.  
  256.     Example:
  257.         REM $INCLUDE: 'qlib.bi'
  258.         REM  a modest home in the flatlands of San Leandro, California
  259.         REM  sells for $200,000.  With an annual interest rate of 10%
  260.         REM  and a 20% down payment, what is the monthly loan payment
  261.         REM  (principle and interest) on a 30-year loan?
  262.  
  263.         pv! = 200000 * .80       ' loan amount
  264.         fv! = 0                  ' loan paid off in 30 years
  265.         n% = 30 * 12             ' payments are monthly
  266.         i! = .1 / 12             ' monthly interest rate
  267.         pmt! = Payment(n%, i!, pv!, fv!)
  268.  
  269.  
  270.  
  271.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  272.  
  273.     Function: y# = PSolveF4(s%, p%, n%, x!)
  274.     Function: y# = PSolveF8(s%, p%, n%, x!)
  275.     Function: y# = PSolveI2(s%, p%, n%, x!)
  276.     Function: y# = PSolveI4(s%, p%, n%, x!)
  277.     object file: psolve.obj
  278.  
  279.     Requires 80x87
  280.  
  281.          Solves an n-order polynomial function for y! given x!.
  282.     The PSolve functions can be twice as fast as equivalent BASIC code.
  283.  
  284.     For PSolveI2, the coefficients in the equations must be INTEGERs.
  285.     For PSolveI4, the coefficients in the equations must be LONG integers.
  286.     For PSolveF4, the coefficients in the equations must be SINGLE.
  287.     For PSolveF8, the coefficients in the equations must be DOUBLE.
  288.  
  289.     Examples of polynomial functions:
  290.  
  291.     y! = 3 + 2*x! + 7*(x!^2)       ' a quadratic function, where n = 2
  292.  
  293.     y! = -48 + x! + 3*(x!^2) - x!^3  ' a cubic equation, where n = 3
  294.  
  295.     Example:
  296.         DEFINT A-Z
  297.         REM  I'll use the second polynomial function above to calculate
  298.         REM  401 y! values for x! = .5 to 200
  299.  
  300.         DIM c(3) AS INTEGER
  301.         DIM y!(400)
  302.         c(0) = -48: c(1) = 1: c(2) = 3: c(3) = -1
  303.         n = 3
  304.         x! = .5
  305.         s% = VARSEG(c(0)): p% = VARPTR(c(0))
  306.         FOR I = 0 to 400
  307.         y!(i) = PSolveI2(s%, p%, n%, x!)
  308.         x! = x! +.5
  309.         NEXT I
  310.  
  311.  
  312.  
  313.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  314.  
  315.     Function: pv! = PValue(n%, i!, pmt!, fv!)
  316.     object files: pvalue.obj (xtothey.obj)
  317.  
  318.     Requires 80x87
  319.  
  320.          PValue calculates the present value of a constant cash flow
  321.     given n% periods, i! periodic interest rate (i! <> 0), pmt! constant
  322.     periodic payments and fv! future value.  i! interest rate must not
  323.     be zero or your program will come to a flying stop.
  324.  
  325.     Example:
  326.         REM $INCLUDE: 'qlib.bi'
  327.         REM  In this case, my goal is to have $10,000 in savings in 10
  328.         REM  years.  If I only want to make an initial deposit, then let
  329.         REM  the interest accumulate, what deposit should I make to reach
  330.         REM  that goal?
  331.  
  332.         i! = .08 / 12            ' 8.00% annual interest rate
  333.         n% = 120                 ' 120 months = 10 years
  334.         fv! = 10000.0            ' that's what I want
  335.         pmt! = 0.0
  336.         pv! = PValue(n%, i!, pmt!, fv!)
  337.  
  338.  
  339.  
  340.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  341.  
  342.     Subroutine: QuadFitF4(s%, o%, n%, a!, b!, c!)
  343.     Subroutine: QuadFitF8(s%, o%, n%, a!, b!, c!)
  344.     Subroutine: QuadFitI2(s%, o%, n%, a!, b!, c!)
  345.     Subroutine: QuadFitI4(s%, o%, n%, a!, b!, c!)
  346.     object file: quadfit.obj
  347.  
  348.         QuadFit subroutines use the Least Squares method to determine
  349.     the coefficients of a formula to fit n sets of coordinate data.
  350.     The formula is of the form
  351.  
  352.          y = a! + b!x + c!x^2
  353.  
  354.     QuadFitF4 requires coordinate data as SINGLE data.
  355.     QuadFitF8 requires coordinate data as DOUBLE data.
  356.     QuadFitI2 requires coordinate data as INTEGER data.
  357.     QuadFitI4 requires coordinate data as LONG data.
  358.  
  359.     The QuadFit subroutines use the 8087 extensively; QuickBASIC's 8087
  360.     emulator works properly when compiled with the /o switch; if you do
  361.     not have a math coprocessor, QuadFit may not work within the
  362.     QuickBASIC development environment.  Hint: if the computer locks up,
  363.     it's not working properly.  Save your work before trying QuadFit if
  364.     you don't have an 8087.
  365.  
  366.     Example 1:
  367.         REM  I have 5 data points, and I want the equation of the line
  368.         REM  that best describes the points
  369.         REM  I'll use a 2-dimensional array for the first example
  370.  
  371.         DIM points(1,4) AS INTEGER
  372.         points(0,0) = x0: points(1,0) = y0
  373.         points(0,1) = x1: points(1,1) = y1
  374.         points(0,2) = x2: points(1,2) = y2
  375.         points(0,3) = x3: points(1,3) = y3
  376.         points(0,4) = x4: points(1,4) = y4
  377.         s% = VARSEG(points(0,0)): o% = VARPTR(points(0,0)): n% = 5
  378.         CALL QuadFitI2(s%, o%, n%, a!, b!, c!)
  379.         REM  QuadFit returns the formula  y = a! + b!x + c!x^2
  380.  
  381.     Example 2:
  382.         REM  this time I'll use a one-dimensional integer array
  383.  
  384.         DIM points(9) AS INTEGER
  385.         points(0) = x0: points(1) = y0
  386.         points(2) = x1: points(3) = y1
  387.         points(4) = x2: points(5) = y2
  388.         points(6) = x3: points(7) = y3
  389.         points(8) = x4: points(9) = y4
  390.         s% = VARSEG(points(0)): o% = VARPTR(points(0)): n% = 5
  391.         CALL QuadFitI2(s%, o%, n%, a!, b!, c!)
  392.  
  393.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  394.  
  395.     Subroutine: Quadratic(a!, b!, c!, x1!, x2!, isquared%)
  396.     object file: quad.obj
  397.  
  398.     Requires 80x87
  399.  
  400.          This subroutine solves a quadratic equation for its roots
  401.     x1! and x2!.  A quadratic equation is of the form
  402.  
  403.     a!*x^2 + b!*x! + c! = 0
  404.  
  405.     where a!, b! and c! are known and a! <> 0.  The two solutions of the
  406.     equation are found with the formulas
  407.  
  408.     x1! = (-b! + SQRT(b! ^ 2 - 4 * a! * c!)) / (2 * a!)
  409.     x2! = (-b! - SQRT(b! ^ 2 - 4 * a! * c!)) / (2 * a!)
  410.  
  411.     The solutions of the equation may be either real or imaginary.  Quadratic
  412.     returns isquared% = 1 if x1! and x2! are real, and isquared = -1 if the
  413.     solutions are imaginary.
  414.  
  415.     Example:
  416.         a! = 3.5: b! = 7!: c! = 12!
  417.         CALL Quadratic(a!, b!, c!, x1!, x2!, isquared%)
  418.  
  419.  
  420.  
  421.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  422.  
  423.     Function: s! = StdDevINT(s%, p%, n%)
  424.     Function: s! = StdDevLNG(s%, p%, n%)
  425.     Function: s! = StdDevSNG(s%, p%, n%)
  426.     Function: s! = StdDevDBL(s%, p%, n%)
  427.     object file: stddev.obj
  428.  
  429.          StdDev subroutines calculate the standard deviation s! of an array
  430.     from the array's average value x!.  Note that in all StdDev subroutines
  431.     s! is a single-precision value.  s! is the sample standard deviation;
  432.     population standard deviation is calculated from s! with this formula:
  433.  
  434.     sp! = s! * SQRT((n - 1) / n)
  435.  
  436.     StdDev subroutines use the 8087 if available, or use the 8087 emulator
  437.     if no 8087 is in the computer.
  438.  
  439.     Example:
  440.         REM $INCLUDE: 'qlib.bi'
  441.         DIM a(99)              ' an integer array of 100 elements
  442.            .                   ' values of each array element established
  443.            .                   ' somewhere in program
  444.            .
  445.         n% = 100               ' now I want the average and standard
  446.                                ' deviation of the array
  447.         s% = VARSEG(a(0)): p% = VARPTR(a(0))
  448.         total! = SumINTArray(s%, p%, n%)
  449.         x! = CSNG(total! / n%) ' x! = average value of the array
  450.  
  451.         s% = VARSEG(a(0)): p% = VARPTR(a(0))
  452.         s! = StdDevINT(s%, p%, n%)
  453.