Hypercomplex  Manual


OVERVIEW
 

-An "anion" is an element of Rn where n is an integer power of 2,
 the addition is defined as the usual vector addition,
 and the multiplication is defined by Cayley-Dickson formula ( see below )

-The standard basis is denoted  1 , e1 , e2 , e3 , e4 , ..............
-The usual imaginary unit i ( for the complexes ) may be identified with e1

-A complexified anion ( or "bi-on" )  is an element of  Cn where n is also an integer power of 2
-Here again, the standard basis is denoted  1 , e1 , e2 , e3 , e4 , ..............
-But the imaginary unit i of the complexes cannot be identified with e1
 

-The following programs compute elementary functions of hypercomplex numbers ( anions & bions ).
-They also generalize several special functions to hypercomplex variables,
  but the order and/or degrees must remain real ( for anions ) or complex ( for bions ).

-Identical series expansions are employed for real and hypercomplex variables.
-Though the product of 2 hypercomplexes is not commutative, the results are unambiguous ( cf  A*A1  &  B*B1 )

-The product is defined by Cayley-Dickson formulae.

         ( a , b ) ( c , d ) = ( a c - d* b , d a + b c* )       where   * = conjugate

 It may be used to construct the complexes from the real numbers, regarding a complex as a pair of real numbers,
 and then the quaternions from the complexes, the octonions from the quaternions, the sedenions from the octonions,
 the 32-ons from the sedenions, the 64-ons from the 32-ons ... and so on ... for the 2^n-ons

-But if we start with the complexes, we gradually get the bi-complexes, bi-quaternions, bi-octonions, bi-sedenions ...

-( I'm not sure that the words "anions" & "bions" are really "official" )
 

Usage:
 

1-With Anions, always store n in register R00 ( n = 2 for complexes, n = 4 for quaternions, n = 8 for octonions , n = 16 for sedenions ... and so on ... )

    Store the real components of the 1st anion into R01 thru Rnn
    Store the real components of the 2nd anion - if any - into Rn+1 thru R2n

>>>>  The result is in registers R01 thru Rnn and it overwrites the 1st anion.

2-With Bions, always store 2n in R00 ( n = 4 for bicomplexes, n = 8 for biquaternions, n = 16 for bioctonions ... and so on ... )

    Store the complex components of the 1st bion into R01 thru R2n
    Store the complex components of the 2nd bion - if any - into R2n+1 thru R4n

>>>>  The result is in registers R01 thru R2n and it overwrites the 1st bion.
 
 

Notes:

-Routines names between "..." are focal programs.
-The other ones are M-Code routines.
 
 
XROM  Function  Desciption
 10,00
 10,01
 10,02
 10,03
 10,04
 10,05
 10,06
 10,07
 10,08
 10,09
 10,10
 10,11
 10,12
 10,13
 10,14
 10,15
 10,16
 10,17
 10,18
 10,19
 10,20
 10,21
 10,22
 10,23
 10,24
 10,25
 10,26
 10,27
 10,28
 10,29
 10,30
 10,31
 10,32
 10,33
 10,34
 10,35
 10,36
 10,37
 10,38
 10,39
 10,40
 10,41
 10,42
 10,43
 10,44
 10,45
 10,46
 10,47
 10,48
 10,49
 10,50
 10,51
 10,52
 10,53
 10,54
 10,55
 10,56
 10,57
 10,58
 10,59
 10,60
 10,61
 10,62
 10,63
 -HYPERCPLX
 "1/A"
 A+A
 A-A
 A*A
 A*A1
 "ABEQ"
 "AGDA"
 "APVAL"
 "A^A"
 "A^X"
 "GDA"
 "ACHA"
 "ACOSA"
 "ASHA"
 "ASINA"
 "ATANA"
 "ATHA"
 "CHA"
 "COSA"
 "E^A"
 "LNA"
 "SHA"
 "SINA"
 "TANA"
 "THA"
 "X^A"
 -BIONS
 "1/B"
 "B*B"
 B*B1
 "B^X"
 "B^Z"
 "B^B"
 "BPVAL"
 "ACHB"
 "ACOSB"
 "ASHB"
 "ASINB"
 "ATANB"
 "ATHB"
 "CHB"
 "COSB"
 "E^B"
 "LNB"
 "SHB"
 "SINB"
 "TANB"
 "THB"
 "X^B"
 "Z^B"
 -ORTHOPOL
 "CHBA"
 "LAGA"
 "LEGA"
 "HMTA"
 "JCPA"
 "PMNA"
 "USPA"
 -SPEC FNS
 "AIRYA"
 "ALFB"
 "BSLA"
 "CATA"
 Section Header
 Inverse of an anion
 Sum of 2 anions or 2 bions
 Difference between 2 anions or 2 bions
 Product of 2 anions ( general case )
 Product of 2 anions ( special case )
 Anionic / Bionic Equations
 Inverse Gudermannian Function
 Evaluation of an anionic Polynomial ( real coeff )
 Anionic Self-Power Function
 Raising an anion to a real exponent
 Gudermannian Function
 Anionic Inverse Hyperbolic Cosine
 Anionic Inverse Cosine
 Anionic Inverse Hyperbolic Sine
 Anionic Inverse Sine
 Anionic Inverse Tangent
 Anionic Inverse Hyperbolic Tangent
 Anionic Hyperbolic Cosine
 Anionic Cosine
 Exponential of an anion
 Logarithm of an anion
 Anionic Hyperbolic Sine
 Anionic Sine
 Anionic Tangent
 Anionic Hyperbolic Tangenyt
 Anionic power of a real
 Section Header
 Inverse of an bion
 Product of 2 bions ( general case )
 Product of 2 bions ( special case )
 Raising a bion to a real exponent
 Raising a bion to a real exponent
 Bionic Self-Power Funtion
 Evaluation of a bionic Polynomial ( complex coefficients )
 Bionic Inverse Hyperbolic Cosine
 Bionic Inverse Cosine
 Bionic Inverse Hyperbolic Sine
 Bionic Inverse Sine
 Bionic Inverse Tangent
 Bionic Inverse Hyperbolic Tangent
 Bionic Hyperbolic Cosine
 Bionic Cosine
 Exponential of a bion
 Logarithm of a bion
 Bionic Hyperbolic Sine
 Bionic Sine
 Bionic Tangent
 Bionic Hyperbolic Tangenyt
 Bionic power of a real
 Bionic Power of a complex
 Section Header
 Anionic Chebyshev Polynomials
 Anionic Laguerre's Polynomials
 Anionic Legendre Polynomials
 Anionic Hermite Polynomials
 Anionic Jacobi Polynomials
 Associated Legendre Functions ( Integer Order & Deg. )
 Anionic UltraSpherical Polynomials
 Section Header
 Anionic Airy Functions Ai & Bi
 Bionic Associated Legendre Functions
 Anionic Bessel Functions
 Anionic Catalan Numbers
 20,00
 20,01
 20,02
 20,03
 20,04
 20,05
 20,06
 20,07
 20,08
 20,09
 20,10
 20,11
 20,12
 20,13
 20,14
 20,15
 20,16
 20,17
 20,18
 20,19
 20,20
 20,21
 20,22
 20,23
 20,24
 20,25
 20,26
 20,27
 20,28
 20,29
 20,30
 20,31
 20,32
 20,33
 20,34
 20,35
 20,36
 20,37
 20,38
 20,39
 20,40
 20,41
 20,42
 20,43
 20,44
 20,45
 20,46
 20,47
 20,48
 20,49
 20,50
 20,51
 20,52
 20,53
 20,54
 20,55
 20,56
 20,57
 20,58
 20,59
 20,60
 20,61
 20,62
 20,63
 "CIA"
 "CIB"
 "DNA"
 "EIA"
 "EIB"
 "ENA"
 "GAMA"
 "GAMB"
 "GERFA"
 "HGFA"
 "HGFA3"
 "HMTA+"
 "HRMA"
 "IBFA"
 "IGFA"
 "JCFA"
 "JEFA"
 "LANA"
 "LBWA"
 "PSIA"
 "PSINA"
 "RCWFA"
 "SIA"
 "SIB"
 "STRA"
 "SWFA"
 "USFA"
 "WEBA"
 "WEFA"
 "WF2A"
 "WHIMA"
 "WHIWA"
 "ZETAA"
 -UTILITIES
 @HG
 1/G
 1/Z
 ASH
 ATH
 DSA
 DS*A
 CH
 GEU
 RCLIX
 SH
 ST<>A
 ST*A
 ST/A
 MOVE
 MU
 MUZ
 Q*Q
 SWAP
 X+1
 X-1
 X/2
 X/E3
 Y^X
 Z*IMB
 Z*B
 Z*Z
 Z/Z
 Z^2
 SQRTZ
 Anionic Cosine Integral ( Ci & Chi )
 Bionic Cosine Integral ( Ci & Chi )
 Anionic Parabolic Cylinder Functions
 Anionic Exponential Integral Ei
 Bionic Exponential Integral Ei
 Anionic Exponential Integral En
 Anionic Gamma Function
 Bionic Gamma Function
 Anionic Generalized Error Functions
 Anionic Generalized Hypergeometric Functions
 Anionic Generalized Hypergeometric Func ( p+q < 4 )
 Anionic Hermite Functions
 Anionic Harmonic Numbers
 Anionic Incomplete Beta Functions
 Anionic Incomplete Gamma Functions
 Anionic Jacobi Functions
 Anionic Jacobian Elliptic Functions
 Anionic Laguerre's Functions
 Anionic Lambert-W Function
 Anionic Digamma Function
 Anionic Polygamma Functions
 Anionic Regular Coulomb Wave Functions
 Anionic Sine Integral ( Si & Shi )
 Bionic Sine Integral ( Si & Shi )
 Anionic Struve Function
 Anionic Spheroidal Wave Functions
 Anionic UltraSpherical Functions
 Anionic Weber & Anger Functions
 Anionic Weierstrass Functions
 Anionic Weierstrass Duplication Formula
 Anionic Whittaker's M-Functions
 Anionic Whittaker's W-Functions
 Anionic Riemann Zeta Function
 Section Header
 A Subroutine used by HGFA3
 Inverse of the Gamma Function ( real arguments )
 Inverse of a complex
 Arc Sinh of a real
 Arc Tanh of a real
 M-code routine for a termination criterion of a sum
 Similar routine
 Hyperbolic Cosine of a real
 Euler Gamma Constant
 A special RCL IND function, only used by HGFA3
 Hyperbolic Sine of a real
 Exchange X Y Z <> Alpha registers M N O
 Multiplication of an hypercomplex by a real
 Division of an hypercomplex by a real
 Variant of REGMOVE function
 Calculates µ = (x1^2+...+xn^2)^(1/2) for an anion
 Calculates µ = (z1^2+...+zn^2)^(1/2) for a bion
 Product of 2 quaternions
 Variant of REGSWAP function
 Adds one to X-register
 Subtracts one to X-register
 Divides X by 2
 Divides X by 1000
 Equivalent to the built-in Y^X except that 0^0 = 1
 Multiplies IM(bion) by x+i.y
 Multiplies a bion by x+i.y
 Product of 2 complexes
 Quotient of 2 complexes
 Square of a complex
 Square-root of a complex
 21,00
 21,01
 21,02
 21,03
 21,04
 21,05
 21,06
 21,07
 21,08
 21,09
 21,10
 21,11
 21,12
 21,13
 21,14
 21,15
 21,16
 21,17
 21,18
 21,19
 21,20
-EXTRA FNS
 "ERFB"
 "GAMZ"
 "BSLB"
 "LANB"
 "LBWB"
 "LEGB"
 "PMNB"
 "PSIB" 
 "PSINB"
 RCLU
 RCLV
 RCLW
 STOU
 STOV
 STOW
 RCLR
 STOR
 RCLS
 STOS
 "VREG"
 Section Header
 Bionic Error Function
 Gamma Function of a Complex
 Bionic Bessel Functions
 Bionic Laguerre's Polynomials
 Bionic Lambert-W Function
 Bionic Legendre Polynomials
 Bionic Ass Legendre Functions ( Integ Order & Deg. )
 Bionic Digamma Function
 Bionic Polygamma Functions
 RCL a number from an extra-register U
 RCL a number from an extra-register V
 RCL a number from an extra-register W
 STO a number in X-Register  into U
 STO a number in X-Register  into V
 STO a number in X-Register  into W
 RCL a number from an extra-register R
 STO a number in X-Register  into R
 RCL a number from an extra-register S
 STO a number in X-Register  into S
 VIEW the registers specified by X = bbb.eee

 

Inverse of An Anion
 
 

-The reciprocal of an anion A # 0  is given by
 

        A-1 = A* / | A |2    where A* is the conjugate of  A   and   | A |2 = x02 + x12 + ................. + xN-12
 

Data Registers:             R00 = n ( 2 , 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru Rnn are to be initialized before executing "1/A" )

                                        R01   ......    Rnn = the n components of the anion
 

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
Subroutines:  /
 
 
      STACK        INPUT      OUTPUT
           X            /          1.nnn

   Where  1.nnn   is the control number of the result

Example:     Inverse of the octonion  A = 2 + 4 e1 + 5 e2 + 10 e3 + 3 e4 + 7 e5 + 6 e6 + 9 e7

   Octonion ->  8  STO 00

   2  STO 01      3  STO 05
   4  STO 02      7  STO 06
   5  STO 03      6  STO 07
  10 STO 04      9  STO 08     XEQ "1/A"   >>>>   1.008

And we get in registers R01 thru R08   2/320  -4/320  -5/320  -10/320  -3/320  -7/320  -6/320  -9/320  respectively    ( approximately )

     whence    1 / A  = 1/160 - 1/80 e1 - 1/64 e2 - 1/32 e3 - 3/320 e4 - 7/320 e5 - 3/160 e6 - 9/320 e7
 
 

Sum of 2 Anions
 

-The sum is the usual sum of 2 n-vectors
 

Data Registers:             R00 = n ( 2 , 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru Rnn are to be initialized before executing "A+A" )

                                        R01   ......    Rnn = the n components of the 1st anion
                                        Rn+1 ......    R2n = the n components of the 2nd anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            /          1.nnn

   Where  1.nnn   is the control number of the result
 

Difference of 2 Anions
 

-Same specifications as A+A
 
 

Product of 2 Anions ( general case )
 

 A*A employs the Cayley-Dickson Formula:

      ( a , b ) ( c , d ) = ( a c - d* b , d a + b c* )       where   * = conjugate

 It may be used to construct the complexes from the real numbers, regarding a complex as a pair of real numbers.

-Likewise, the quaternions from the complexes, the octonions from the quaternions, the sedenions from the octonions,
 the 32-ons from the sedenions, the 64-ons from the 32-ons ... and so on ... for the 2^n-ons
 
 

Data Registers:             R00 = n ( 4 , 8 , 16 , 32 or 64 )     ( Registers R00 thru R2n are to be initialized before executing "A*A" )

                                        R01   ......    Rnn = the n components of the 1st anion
                                        Rn+1 ......    R2n = the n components of the 2nd anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the product

-During the calculations,

    R01 to R04 = quaternion1    R09 to R16 = octonion1  R25 to R40 = sedenion1  R57 to R88 = 32-on1     R121 to R184 = 64-on1
    R05 to R08 = quaternion2    R17 to R24 = octonion2  R41 to R56 = sedenion2  R89 to R120 = 32-on2   R185 to R248 = 64-on2

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the product.

Example:    Product of 2 octonions.    8  STO 00

    w = 2 + 4 e1 + 5 e2 + 10 e3 + 3 e4 + 7 e5 + 6 e6 + 9 e7
   w' =  3 + 5 e1 + 6 e2 + 2 e3 + 7 e4 + 4 e5 + 9 e6 + 8 e7

    2   STO 01         3   STO 05                    3   STO 09        7   STO 13
    4   STO 02         7   STO 06                    5   STO 10        4   STO 14
    5   STO 03         6   STO 07                    6   STO 11        9   STO 15
   10  STO 04         9   STO 08                    2   STO 12        8   STO 16

            XEQ "A*A"  >>>>   1.008                                                            ---Execution time = 52s---

-The result is in registers R01 thru R08

  R01 = -239  ,  R02 = -32  ,  R03 = 74  ,  R04 = -45  ,   R05 = -29  ,  R06 = 134  ,  R07 = 14  ,  R08 = 79

   whence     w.w' = - 239 - 32 e1 + 74 e2 - 45 e3 - 29 e4 + 134 e5 + 14 e6 + 79 e7
 

Note:

-This program does not work with 2 complexes: Simply use Z*Z in this case
 

Product of 2 Anions ( special case )
 

-The Cayley-Dickson formula is not very easy to handle with an HP-41 and it employs many registers.
-But fortunately, there is a much easier case when the anions have the same "imaginary direction",
  it's often the case to compute elementary or special functions of an anion.

-In this case, the product is commutative.
 
 

Data Registers:             R00 = n ( 2 , 4 , 8 , 16 , 32 , 64 or 128 )    ( Registers R00 thru R2n are to be initialized before executing "A*A1" )

                                        R01   ......    Rnn = the n components of the 1st anion
                                        Rn+1 ......    R2n = the n components of the 2nd anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the product

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the product.

Example:    a = 8 + 3 i + 4 j + 7 k   ;   a' = 5 - 6 i - 8 j - 14 k

-These are quaternions so    4  STO 00

   8  STO 01          5  STO 05
   3  STO 02         -6  STO 06
   4  STO 03         -8  STO 07
   7  STO 04        -14 STO 08

   XEQ "A*A1"  >>>>  1.004    and we get in registers R01 thru R04

   R01 = 188  ,   R02 = -33  ,  R03 = -44  ,  R04 = -77

-Therefore,   a.a' = 188 - 33 i - 44 j - 77 k

Note:

-A*A1 does not check that the imaginary parts are proportional.
 

Anionic Self-Power Function
 

-The "self-power function" is defined unambiguously by   a^a = exp ( ( Ln a ) a )
 

Data Registers:             R00 = n ( 2 , 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru Rnn are to be initialized before executing "A^A" )

                                        R01   ......    Rnn = the n components of the 1st anion
                                         Rn+1 ..........  R2n:   temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            /          1.nnn

   Where  1.nnn   is the control number of the result

Example:     With the octonion w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7

-Calculate   w^w

  8  STO 00

    1     STO 01         0.6   STO 05
   0.9   STO 02         0.5   STO 06
   0.8   STO 03         0.4   STO 07
   0.7   STO 04         0.3   STO 08

   XEQ "A^A"  >>>>   1.008                              ---Execution time = 6s---

  and   we find in registers  R01 thru R08

-So,  ww = -0.189444948 + 0.156108188 e1 + 0.138762834 e2 +  0.121417480 e3
                  + 0.104072125 e4 + 0.086726771 e5 + 0.069381417 e6 + 0.052036063 e7

Notes:

-We can also calculate  a^a'  = exp ( a' Ln a )  or  exp ( ( Ln a ) a' )     ( the 2 results are usually different )
-But in both cases, the product  a' ( Ln a )  must be computed with  "A*A"  instead of  A*A1
 

Anionic Real Power
 

        A^X = exp ( X Ln A )
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "A^X" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            x         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7   and    x = PI

    8    STO 00    ( octonion )

    1    STO 01        0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    PI  XEQ "A^X"   >>>>    1.008                                         ---Execution time = 7s---

-The components of  wx  are stored in  R01 thru R08

             R01 = -8.100378663     R02 = -0.441313112     R03 = -0.392278322    R04 = -0.343243532
             R05 = -0.294208741     R06 = -0.245173951     R07 = -0.196139161    R08 = -0.147104371

-So,  wPI =  -8.100378663 - 0.441313112  e1 - 0.392278322 e2 - 0.343243532 e3
                  - 0.294208741 e4 - 0.245173951 e5 - 0.196139161 e6 - 0.147104371 e7
 

Anionic Power of a Real
 

         X^A = exp ( A Ln X )
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "X^A" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            x         1.nnn

   Where  1.nnn   is the control number of the result

Example:      X = PI  and   A = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7

    8    STO 00    ( octonion )

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    PI  XEQ "X^A"   >>>>    1.008                                         ---Execution time = 7s---

-The components of  X^A  are stored in  R01 thru R08

             R01 = -1.061598511     R02 = 1.590318536     R03 = 1.413616477    R04 = 1.236914417
             R05 = 1.060212358      R06 = 0.883510298     R07 = 0.706808239    R08 = 0.530106179
 

-So,  PI^A =  -1.061598511 + 1.590318536  e1 + 1.413616477 e2 + 1.236914417 e3
                      + 1.060212358 e4 + 0.883510298 e5 + 0.706808239 e6 + 0.530106179 e7
 

Exponential of an Anion
 

      "E^A"   exponential

        exp( x0 + x1 e1 + .... + xN-1 eN-1 ) = ex0 [ cos µ + ( sin µ ). I ]

       where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ

-It could be defined by the usual series   exp (a) = 1 + a / 1! + a2 / 2! + ............. + an / n! + ......
-It gives the same results but the above formulas are much easier and faster to compute.
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "E^A" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7     Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "E^A"   >>>>    1.008                                                ---Execution time = 3s---

 and we get in R01 thru R08

-So,  exp w = - 0.278200417 + 1.454358610  e1 + 1.292763209 e2 + 1.131167808 e3
                      + 0.969572407 e4 + 0.807977006 e5 + 0.646381604 e6 + 0.484786203 e7
 

Logarithm of an Anion
 

      "LNA"  natural logarithm

       Ln( x0 + x1 e1 + .................+ xN-1 eN-1 )   = Ln ( x02 + x12 + .................. + xN-12 )1/2 + Atan2(µ,x0). I

       where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ

-If  µ = 0  ,    I  is replaced by  e1
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "LNA" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7          Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "LNA"   >>>>   1.008                                                ---Execution time = 4s---

-And we have in registers  R01 thru R08:

-So,  Ln w =  0.667500533 + 0.555135626  e1 + 0.493453890 e2 + 0.431772154 e3
                   + 0.370090417 e4 + 0.308408681 e5 + 0.246726945 e6 + 0.185045209 e7
 

Hyperbolic Sine of an Anion
 

      "SHA"  hyperbolic sine

        Sinh ( x0 + x1 e1 + .... + xN-1 eN-1 )  =  Sinh x0 Cos µ  + I ( Cosh x0 ) ( Sin µ )

        where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ
 

Data Registers:             R00 = n > 1                   ( Registers R00 thru Rnn are to be initialized before executing "SHA" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7             Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "SHA"   >>>>   1.008                                                          ---Execution time = 4s---
 

-Whence,  Sinh w = - 0.120275043 + 0.825592322  e1 + 0.733859842 e2 + 0.642127362 e3
                               + 0.550394881 e4 + 0.458662401 e5 + 0.366929921 e6 + 0.275197441 e7
 

Hyperbolic Cosine of an Anion
 

     "CHA"  hyperbolic cosine

        Cosh ( x0 + x1 e1 + .... + xN-1 eN-1 )  =  Cosh x0 Cos µ  + I ( Sinh x0 ) ( Sin µ )

       where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "CHA" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7            Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "ACHA"   >>>>   1.008                                                          ---Execution time = 4s---
 

-Whence,  Cosh w = - 0.157925375 + 0.628766288  e1 + 0.558903367 e2 + 0.489040446 e3
                               + 0.419177525 e4 + 0.349314605 e5 + 0.279451684 e6 + 0.209588763 e7
 

Hyperbolic Tangent of an Anion
 

      "THA"  hyperbolic tangent

          Tanh a = ( Sinh a ) ( Cosh a ) -1
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ATHA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7            Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08
 

    XEQ "THA"   >>>>   1.008                                                          ---Execution time = 5s---
 

-Whence,  Tanh w =  1.303152094 - 0.039349080  e1 - 0.034976960 e2 - 0.030604840 e3
                               - 0.026232720 e4 - 0.021860600 e5 - 0.017488480 e6 - 0.013116360 e7
 
 

Inverse Hyperbolic Sine of an Anion
 

      "ASHA"     arc sinh a = Ln [ a + ( a2 + 1 )1/2 ]         with a slight modification if  Re(a) = 0
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ASHA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  F01-F02
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7            Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "ASHA"   >>>>   1.008                                                       ---Execution time = 25s---
 

-Whence,  ArcSinh w =  1.334047106 + 0.521197577  e1 + 0.463286736 e2 + 0.405375894 e3
                                   + 0.347465051 e4 + 0.289554210 e5 + 0.231643368 e6 + 0.173732526 e7
 

Inverse Hyperbolic Cosine of an Anion
 

      "ACHA"  arc cosh a = Ln [ a + ( a2 - 1 )1/2 ]    with a slight modification if  Re(a) = 0
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ACHA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  F01-F02
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7            Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "ACHA"   >>>>   1.008                                                          ---Execution time = 35s---
 

-Whence,  ArcCosh w =  1.394522837 + 0.583407502  e1 + 0.518584447 e2 + 0.453761391 e3
                                   + 0.388938335 e4 + 0.324115279 e5 + 0.259292223 e6 + 0.194469168 e7
 

Remark:

-I've used     arc cosh a = Ln [ a + ( a2 - 1 )1/2 ]

  instead of the standard definition    Arc Cosh a  = Ln [ a + ( a + 1 )1/2 ( a - 1 )1/2 ]

-So, "ACHA" may give a result that requires a sign change to get the principal value of  Arc Cosh a.
 

Inverse Hyperbolic Tangent of an Anion
 
 

      "ATHA"   arc tanh a = 1/2) [ Ln ( 1 + a ) - Ln ( 1 - a ) ]
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ATHA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7            Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "ATHA"   >>>>  1.008                                                          ---Execution time = 13s---
 

-Whence,  ArcTanh w =  0.221825799 + 0.609789268  e1 + 0.542034905 e2 + 0.474280542 e3
                                    + 0.406526179 e4 + 0.338771815 e5 + 0.271017452 e6 + 0.203263089 e7
 

Sine of an Anion
 

      "SINA"   sine

          Sin ( x0 + x1 e1 + .... + xN-1 eN-1 )  =  Sin x0 Cosh µ  + I ( Cos x0 ) ( Sinh µ )

         where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "SINA" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 0.3 + 0.4 e1 + 0.5 e2 + 0.6 e3 + 0.7 e4 + 0.8 e5 + 0.9 e6 +  e7            Octonion ->  8  STO 00

   0.3  STO 01         0.7   STO 05
   0.4  STO 02         0.8   STO 06
   0.5  STO 03         0.9   STO 07
   0.6  STO 04           1    STO 08

    XEQ "SINA"   >>>> 1.008                                                          ---Execution time = 5s---
 

-Whence,  Sin w = 1.035598976 + 0.666330457  e1 + 0.832913071 e2 + 0.999495685 e3
                           + 1.166078299 e4 + 1.332660914 e5 + 1.499243528 e6 + 1.665826142 e7
 

Cosine of an Anion
 

      "COSA"  cosine

          Cos ( x0 + x1 e1 + .... + xN-1 eN-1 )  =  Cos x0 Cosh µ  + I ( Sin x0 ) ( Sinh µ )

          where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "COSA" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 0.3 + 0.4 e1 + 0.5 e2 + 0.6 e3 + 0.7 e4 + 0.8 e5 + 0.9 e6 +  e7            Octonion ->  8  STO 00

   0.3  STO 01         0.7   STO 05
   0.4  STO 02         0.8   STO 06
   0.5  STO 03         0.9   STO 07
   0.6  STO 04           1    STO 08

    XEQ "COSA"   >>>>   1.008                                                          ---Execution time = 5s---
 

-Whence,  Cos w = 3.347809955 - 0.206120165  e1 - 0.257650206 e2 - 0.309180247 e3
                               - 0.360710288 e4 - 0.412240329 e5 - 0.463770370 e6 - 0.515300411 e7
 

Tangent of an Anion
 

     "TANA"    Tan a = ( Sin a ) ( Cos a ) -1
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "TANA" )

                                        R01   ......    Rnn = the n components of the anion

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 0.3 + 0.4 e1 + 0.5 e2 + 0.6 e3 + 0.7 e4 + 0.8 e5 + 0.9 e6 +  e7            Octonion ->  8  STO 00

   0.3  STO 01         0.7   STO 05
   0.4  STO 02         0.8   STO 06
   0.5  STO 03         0.9   STO 07
   0.6  STO 04           1    STO 08

    XEQ "TANA"   >>>>   1.008                                                          ---Execution time = 4s---
 

-Whence,  Tan w = 0.023154438 + 0.200460320  e1 + 0.250575400 e2 + 0.300690479 e3
                            + 0.350805559 e4 + 0.400920639 e5 + 0.451035719 e6 + 0.501150799 e7
 

Inverse Sine of an Anion
 

      "ASINA"    arc sin a

           If   a  =  x0 + x1 e1 + .... + xN-1 eN-1       ,       Arc Sin a     = - I  Arc Sinh ( a  I )     with a slight modification if  Re(a) = 0

          where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ASINA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  F01-F02
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:         w = 0.3 + 0.4 e1 + 0.5 e2 + 0.6 e3 + 0.7 e4 + 0.8 e5 + 0.9 e6 +  e7            Octonion ->  8  STO 00

   0.3  STO 01         0.7   STO 05
   0.4  STO 02         0.8   STO 06
   0.5  STO 03         0.9   STO 07
   0.6  STO 04           1    STO 08

    XEQ "ASINA"   >>>>    1.008                                                           ---Execution time = 17s---
 

-Whence,  Arc Sin w = 0.137634053 + 0.294589222  e1 + 0.368236528 e2 + 0.441883833 e3
                                 + 0.515531139 e4 + 0.589178444 e5 + 0.662825750 e6 + 0.736473054 e7
 

Inverse Cosine of an Anion
 

      "ACOSA"  arcCos a  = PI/2 - ArcSin a
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ACOSA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  F01-F02
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:         w = 0.3 + 0.4 e1 + 0.5 e2 + 0.6 e3 + 0.7 e4 + 0.8 e5 + 0.9 e6 +  e7            Octonion ->  8  STO 00

   0.3  STO 01         0.7   STO 05
   0.4  STO 02         0.8   STO 06
   0.5  STO 03         0.9   STO 07
   0.6  STO 04           1    STO 08

    XEQ "ACOSA"   >>>>    1.008                                                           ---Execution time = 18s---
 

-Whence,  Arc Cos w = 1.433162274 - 0.294589221  e1 - 0.368236527 e2 - 0.441883833 e3
                                 - 0.515531138 e4 - 0.589178444 e5 - 0.662825750 e6 - 0.736473054 e7
 

Inverse Tangent of an Anion
 

      "ATANA"  arc tan a

           If   a  =  x0 + x1 e1 + .... + xN-1 eN-1        ,           Arc Tan a     = - I  Arc Tanh ( a  I )     with a slight modification if  Re(a) = 0

           where  µ = ( x12 + ............... + xN-12 )1/2    and    I = ( x1 e1 + ............. + xN-1 eN-1 ) / µ
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "ATANA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /         1.nnn

   Where  1.nnn   is the control number of the result

Example:        w = 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7            Octonion ->  8  STO 00

    1    STO 01         0.6   STO 05
   0.9  STO 02         0.5   STO 06
   0.8  STO 03         0.4   STO 07
   0.7  STO 04         0.3   STO 08

    XEQ "ATANA"   >>>>  1.008                                                          ---Execution time = 16s---
 

-Whence,  Arc Tan w = 1.260671584 + 0.231777953  e1 + 0.206024847 e2 + 0.180271741 e3
                                  + 0.154518635 e4 + 0.128765529 e5 + 0.103012424 e6 + 0.077259318 e7
 

Anionic Inverse Gudermannian Function
 
 

Formulae:   Agd(a) = 2 ArcTanh [ Tan(a/2) ]
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "AGDA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /          1.nnn

Example:           a = 1 + 2 i + 3 j + 4 k         ( quaternion  ->  4  STO 00 )

   1  STO 01
   2  STO 02
   3  STO 03
   4  STO 04      XEQ "AGDA"   >>>>   1.004                 ---Execution time = 10s---
 

Whence   Agd( 1 + 2 i + 3 j + 4 k ) = 0.007714740 + 0.581539372 i + 0.872309058 j + 1.163078744 k
 
 
 

Anionic Gudermannian Function
 
 

Formulae:    Gd(a) = 2 ArcTan [ Tanh (a/2) ]
 

Data Registers:             R00 = n > 1    ( Registers R00 thru Rnn are to be initialized before executing "GDA" )

                                        R01   ......    Rnn = the n components of the anion
                                         Rn+1 ..........  R2n  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /          1.nnn

Example:           a = 1 + 2 i + 3 j + 4 k         ( quaternion  ->  4  STO 00 )

   1  STO 01
   2  STO 02
   3  STO 03
   4  STO 04      XEQ "GDA"   >>>>   1.004                 ---Execution time = 15s---
 

-So,  Gd( 1 + 2 i + 3 j + 4 k ) = 1.083236673 - 0.207409846 i - 0.311114768 j - 0.414819691 k
 

Anionic / Bionic Equations
 

-"ABEQ" uses the iterative method:

-The equation must be rewritten in the form:    f ( a ) = a
  and if  f  satisfies a Lipschitz condition   | f(a) - f(a') | < h | a - a' |   with  h < 1  ,   provided a and a' are close to a solution,
  then the sequence  an+1 = f ( an )  converges to a root.
 

Data Registers:             R00 =  n  ( 2 , 4 , 8 , .... )               ( Registers R00 thru Rnn are to be initialized before executing "ABEQ" )

                                        R01 to Rnn = the n components of the anion  a          R2n+1 to R3n: temp  ,  R3n+1 = fname

                                          Rnn+1 to R2n  may be used by the subroutine.

     >>>>     When the program stops,        R01 to Rnn = the n components of  a solution  a

Flags: /
Subroutine:  A program that takes the anion a   in R01 thru Rnn , calculates and stores  f ( a )  in R01 thru Rnn
                       without disturbing R2n+1 to R3n+1
 
 
      STACK        INPUTS      OUTPUTS
        Alpha         f name         f name
           X             /          1.nnn

    where  1.nnn  = control number of the solution

Example:     Find a solution of the octonionic equation    w2  - Ln w  + 1 + 0.9 e1 + 0.8 e2 + 0.7 e3 + 0.6 e4 + 0.5 e5 + 0.4 e6 + 0.3 e7 = 0

   near   1 + e1 + e2 + e3 + e4 + e5 + e6 + e7
 

-First, we re-write this equation:    w  =  ( Ln w  - 1 - 0.9 e1 - 0.8 e2 - 0.7 e3 - 0.6 e4 - 0.5 e5 - 0.4 e6 - 0.3 e7 ) 1/2  =  f ( w )

-The short routine "T" hereunder computes  f ( w )
-Note that here, the exponent 1/2 must be in X-register before calling "A^X"
 
 
 01  LBL "T"
 02  XEQ "LNA"
 03  1
 04  ST- 01
 05  .9
 06  ST- 02
 07  .8
 08  ST- 03
 09  .7
 10  ST- 04
 11  .6
 12  ST- 05
 13  .4
 14  ST- 07
 15  .3
 16  ST- 08
 17  .5
 18  ST- 06
 19  XEQ "A^X"
 20  RTN
 21  END

-Then,  n = 8  ASTO 00

-Initial approximation:     1  STO 01  STO 02  STO 03  STO 04  STO 05  STO 06  STO 07  STO 08

-Place the subroutine name in the alpha register:  alpha  "T"  alpha

    XEQ "ABEQ"   >>>>    the successive approximations of the real part of the solution are displayed, and eventually, we get:

                                       X =  1.008 = control number of the solution.
 

            R01 = 1.022547760  ,  R02 = -0.673000418 ,  R03 =  -0.598222594  ,   R04 =  -0.523444770
            R05 = -0.448666946  ,  R06 = -0.373889122  ,  R07 = -0.299111297  ,  R08 = -0.224333473

-Whence:

        w  =  1.022547760 - 0.673000418  e1 - 0.598222594 e2 - 0.523444770 e3
               - 0.448666946 e4 - 0.373889122 e5 - 0.299111297 e6 - 0.224333473 e7      is a solution of this equation.

Notes:

-The convergence is very slow.
-If  f doesn't satisfy the required Lipschitz condition or if we choose a bad initial guess, the algorithm may be divergent.
-Rewriting the equation in a proper form is often very difficult.
 

-The instructions are quite similar for bionic equations:
 
 
      STACK        INPUTS      OUTPUTS
        Alpha         f name         f name
           X             /          1.2n

    where  1.2n  = control number of the solution

Example:     Find a solution of the biquaternionic equation

   b2  - Ln b  + ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3 = 0      near   b = 1

-First, we re-write this equation:    b  =  [ Ln b  - {  ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3} ] 1/2  =  f ( b )

-The short routine "T" hereunder computes  f ( b )
 
 
 01  LBL "T"
 02  XEQ "LNB"
 03  .1
 04  ST- 01
 05  .2
 06  ST- 02
 07  .3
 08  ST- 03
 09  .4
 10  ST- 04
 11  .6
 12  ST- 06
 13  .7
 14  ST- 07
 15  .8
 16  ST- 08
 17  .5
 18  ST- 05
 19  XEQ "B^X"
 20  RTN
 21  END

-Then,  2n = 8    STO 00

-Initial approximation:     1  STO 01  CLX  STO 02  STO 03  STO 04  STO 05  STO 06  STO 07  STO 08

-Place the subroutine name in the alpha register:  alpha  "T"  alpha

    XEQ "ABEQ"   >>>>    the successive approximations of the real part of the 1st component of the solution are displayed, and after several minutes, we get:

    X =  1.008 = control number of the solution.

-We find in registers R01 thru R08

  b = ( 1.014983107 + 0.292115635 i )  +  ( -0.307551610 - 0.118387777 i )  e1
                                                               + ( -0.489251534 - 0.160080803 i )  e2 + ( -0.670951458 - 0.201773829 i )  e3
 

Anionic Polynomial
 

 "APVAL"  evaluates  p(a) = cm am + cm-1 am-1 + ................ + c1 a + c0    for  a given anion a  and  (m+1) real numbers  cm , .............. , c1 , c0
 

-Store the anion a in registers  R01 trhu Rnn  as usual, and the coefficients of the polynomial in Rbb thru Ree  with  bb > 2n
 

Data Registers:             R00 = n > 1            ( Registers R00 thru Rnn & Rbb thru Ree are to be initialized before executing "APVAL" )

                                        R01   ......    Rnn = a
                                         Rn+1 ........   R2n = a   ( a is saved in Rn+1 thru R2n )

                                        Rbb = cm ,    Rb+1 = cm-1 , ................. ,   Ree = c0

  >>>  When the program stops:     R01   ......  Rnn = the n components of p(a)

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X        bbb.eee         1.nnn

   where  bbb.eee  is the control number of the polynomial    ( bbb > 2n )

Example:           a = 1 + 2 i + 3 j + 4 k         ( quaternion  ->  4  STO 00 )          p(a) = 6 a5 + 2 a4 + 3 a3 + 7 a2 + 4 a + 1

    1  STO 01       and if you choose  bb = 9       6  STO 09          7  STO 12        control number   9.014
    2  STO 02                                                     2  STO 10          4  STO 13
    3  STO 03                                                     3  STO 11          1  STO 14
    4  STO 04

    9.014   XEQ "APVAL"  >>>>   1.004                                   ---Execution time = 4s---

    R01 = 24383
    R02 = 6104
    R03 = 9156
    R04 = 12208

-Whence,              p(a) = 24383 + 8104 i + 9156 j + 12208 k
 

Anionic Chebyshev Polynomial
 

Formulae:

      CF 02          Tm(a) = 2a.Tm-1(a) - Tm-2(a)   ;  T0(a) = 1  ;   T1(a) = a        ( first kind )
      SF 02          Um(a) = 2a.Um-1(a) - Um-2(a)  ;  U0(a) = 1  ;  U1(a) = 2a    ( second kind )
 

Data Registers:            R00 = n > 1                     ( Registers R00 thru Rnn are to be initialized before executing "CHBA" )

                                        R01   ......    Rnn = the n components of the anion a which are saved in registers  Rn+1 to R2n

                                         Rn+1 ..........  R3n =  Tm(a)  or  Um(a)
                                         R2n+1 ........  R4n = Tm-1(a) or Um-1(a)

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag: F02               if F02 is clear, "CHBA" calculates the Chebyshev polynomials of the first kind:   Tm(a)
                               if F02 is set,    "CHBA" calculates the Chebyshev polynomials of the second kind:   Um(a)
 
 
      STACK        INPUTS      OUTPUTS
           Y             /            m
           X             m         1.nnn

   where      1.nnn  is the control number of the result  and  m is an integer    ( 0 <= m < 1000 )

Example:         m = 7     a = 1 + 2 i + 3 j + 4 k                             ( Quaternion ->  4  STO 00 )

      CF 02      Chebyshev Polynomials 1st kind

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   7    XEQ "CHBA"   >>>>      1.004                                          ---Execution time = 21s---

  R01 = -9524759
  R02 = -1117678
  R03 = -1676517
  R04 = -2235356

        T7( 1 + 2 i + 3 j + 4 k ) =  -9524759 - 1117678 i - 1676517 j - 2235356 k

      SF 02      Chebyshev Polynomials 2nd kind

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   7    XEQ "CHBA"   >>>>      1.004                                          ---Execution time = 21s---

  R01 = -18921448
  R02 =  -2198096
  R03 =  -3297144
  R04 =  -4396192

        U7( 1 + 2 i + 3 j + 4 k ) =  -18921448 - 2198096 i - 3297144 j - 4396192 k
 

Anionic Laguerre Polynomial
 

Formulae:      L0(b) (a) = 1  ,   L1(b) (a) = b+1-a   ,    m Lm(b) (a) = (2.m+b-1-a) Lm-1(b) (a) - (m+b-1) Lm-2(b) (a)
 

Data Registers:             R00 = n > 1                    ( Registers R00 thru Rnn are to be initialized before executing "LAGA" )

                                        R01   ......    Rnn = the n components of the anion a which are saved in registers  Rn+1 to R2n

                                         Rn+1 ..........  R3n =  Lm(b) (a)
                                         R2n+1 ........  R4n = Lm-1(b) (a)

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags: /
 
 
      STACK       INPUTS      OUTPUTS
           Y             b            /
           X             m         1.nnn

   where      1.nnn  is the control number of the result  and  m is an integer    ( 0 <= m < 1000 )

Example:        b = sqrt(2)     m = 7     a = 1 + 2 i + 3 j + 4 k                             ( Quaternion ->  4  STO 00 )

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   2   SQRT
   7    XEQ "LAGA"   >>>>  1.004                                          ---Execution time = 33s---

  R01 = 872.2661283
  R02 =  47.12527421
  R03 =  70.68791129
  R04 =  94.25054843

        L7sqrt(2) ( 1 + 2 i + 3 j + 4 k ) =  872.2661283 + 47.12527421 i + 70.68791129 j + 94.25054843 k

 and in registers R13 thru R16:

       L6sqrt(2) ( 1 + 2 i + 3 j + 4 k ) =   335.6848017 + 123.7427960 i + 185.6141940 j + 247.4855920 k
 

Anionic Legendre Polynomial
 

Formulae:      m.Pm(a) = (2m-1).a.Pm-1(a) - (m-1).Pm-2(a)  ,  P0(a) = 1  ,  P1(a) = a
 

Data Registers:             R00 = n > 1                ( Registers R00 thru Rnn are to be initialized before executing "LEGA" )

                                        R01   ......    Rnn = the n components of the anion a which are saved in registers  Rn+1 to R2n

                                         Rn+1 ..........  R3n =  Pm(a)
                                         R2n+1 ........  R4n = Pm-1(a)

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             m         1.nnn

   where      1.nnn  is the control number of the result  and  m is an integer    ( 0 <= m < 1000 )

Example:         m = 7     a = 1 + i/2 + j/3 + k/4                             ( Quaternion ->  4  STO 00 )

   1   STO 01
   2   1/X  STO 02
   3   1/X  STO 03
   4   1/X  STO 04

   7   XEQ "LEGA"   >>>>  1.004                                          ---Execution time = 28s---

  R01 =  36.20819586
  R02 = -51.58337291
  R03 = -34.38891526
  R04 = -25.79168644

        P7( 1 + i/2 + j/3 + k/4 ) =  36.20819586 - 51.58337291 i - 34.38891526 j - 25.79168644 k

 and in registers R13 thru R16:

       P6( 1 + i/2 + j/3 + k/4 ) =  -9.248135373 - 26.20689563 i - 17.47126375 j - 13.10344781 k
 

Anionic Hermite Polynomial
 

Formulae:        H0(a) = 1  ,  H1(a) = 2 a
                         Hm(a) = 2.a Hm-1(a) - 2 (m-1) Hm-2(a)
 

Data Registers:             R00 = n > 1                ( Registers R00 thru Rnn are to be initialized before executing "HMTA" )

                                        R01   ......    Rnn = the n components of the anion a which are saved in registers  Rn+1 to R2n

                                         Rn+1 ..........  R3n =  Hm(a)
                                         R2n+1 ........  R4n = Hm-1(a)

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             m         1.nnn

   where      1.nnn  is the control number of the result  and  m is an integer    ( 0 <= m < 1000 )

Example:         m = 7     a = 1 + 2 i + 3 j + 4 k                             ( Quaternion ->  4  STO 00 )

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   7    XEQ "HMTA"   >>>>  1.004                                          ---Execution time = 25s---

  R01 = -23716432
  R02 =  -3653024
  R03 =  -5479536
  R04 =  -7306048

        H7( 1 + 2 i + 3 j + 4 k ) =  -23716432 - 3653024 i - 5479536 j - 7306048 k

 and in registers R13 thru R16:

       H6( 1 + 2 i + 3 j + 4 k ) =  -1122232 + 682816 i + 1024224 j + 1365632 k
 

Anionic Jacobi Polynomial
 

Formulae:      P0(b;c) (a) = 1  ;   P1(b;c) (a) = (b-c)/2 + a (b+c+2)/2

        2m(m+b+c)(2m+b+c-2) Pm(b;c) (a) = [ (2m+b+c-1).(b2-c2) + a (2m+b+c-2)(2m+b+c-1)(2m+b+c) ] Pm-1(b;c) (a)
                                                              - 2(m+b-1)(m+c-1)(2m+b+c) Pm-2(b;c) (a)
 

Data Registers:             R00 = n > 1                ( Registers R00 thru Rnn are to be initialized before executing "JCPA" )

                                        R01   ......    Rnn = the n components of the anion a which are saved in registers  Rn+1 to R2n

                                         Rn+1 ..........  R3n =  Pm(b;c) (a)
                                         R2n+1 ........  R4n = Pm-1(b;c) (a)

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags: /
 
 
      STACK        INPUTS      OUTPUTS
           Z             b            /
           Y             c            /
           X             m         1.nnn

    where      1.nnn  is the control number of the result  and  m is an integer    ( 0 <= m < 1000 )

Example:        b = sqrt(2)     c = sqrt(3)    m = 7      a = 1 + i/2 + j/3 + k/4                            ( Quaternion ->  4  STO 00 )

   1   STO 01
   2   1/X  STO 02
   3   1/X  STO 03
   4   1/X  STO 04

   2   SQRT
   3   SQRT
   7   XEQ "JCPA"   >>>>      1.004                                          ---Execution time = 52s---

  R01 =  143.5304513
  R02 = -310.8681605
  R03 = -207.2454399
  R04 = -155.4340802

-Whence,        P7sqrt(2);sqrt(3) ( 1 + i/2 + j/3 + k/4 ) =  143.5304513 - 310.8681601 i - 207.2454399 j - 155.4340801 k
 

Anionic Associated Legendre Functions ( Integer order & degree )
 

 "PMNA" compute the functions of type 2 - if CF 03 - or the functions of type 3 - if  SF 03.
 

Formulae:      (n-m) Pnm(a) = a (2n-1) Pn-1m(a) - (n+m-1) Pn-2m(a)

     Type 2                Pmm(a) = (-1)m (2m-1)!!  ( 1-a )m/2  ( 1+a )m/2                   where (2m-1)!! = (2m-1)(2m-3)(2m-5).......5.3.1
     Type 3                Pmm(a) =   (2m-1)!!  ( a-1 )m/2  ( 1+a )m/2
 

Data Registers:             R00 = n > 1              ( Registers R00 thru Rnn are to be initialized before executing "PMNA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flag:  F03
 
 
      STACK        INPUTS      OUTPUTS
           Y            m            /
           X            n         1.nnn

   where   1.nnn   is the control number of the result.

Example:      m = 3  ,  n = 7  ,  a = 1 + i / 2 + j / 3 + k / 4             ( quaternion ->  4  STO 00 )

    CF 03   Legendre Function of type 2

    1   STO 01
    2   1/X   STO 02
    3   1/X   STO 03
    4   1/X   STO 04

    3   ENTER^
    7   XEQ "PMNA"  >>>>  1.004                               ---Execution time = 20s---

   R01 = -12188.53940
   R02 = -8670.127580
   R03 = -5780.085053
   R04 = -4335.063790

     P37 ( 1 + i/2 + j/3 + k/4 ) = -12188.53940 - 8670.127580 i - 5780.085053 j - 4335.063790 k
 

    SF 03   Legendre Function of type 3

    1   STO 01
    2   1/X   STO 02
    3   1/X   STO 03
    4   1/X   STO 04

    3   ENTER^
    7   XEQ "PMNA"  >>>>  1.004                               ---Execution time = 20s---

   R01 = 11285.97688
   R02 = -9363.495330
   R03 = -6242.330218
   R04 = -4681.747665

     P37 ( 1 + i/2 + j/3 + k/4 ) = 11285.97688 - 9363.495330 i - 6242.330218 j - 4681.747665 k

Notes:

-This program doesn't check if m & n are integers that satisfy 0 <= m <= n
  Pn-1m(a) is in registers R3n+1 thru R4n.
 

Anionic UltraSpherical Polynomial
 

Formulae:      C0(b) (a) = 1  ;   C1(b) (q) = 2.b.a   ;    (m+1).Cm+1(b) (a) = 2.(m+b).x.Cm(b) (a) - (m+2b-1).Cm-1(b) (a)      if  b # 0

                      Cm(0) (a) = (2/m).Tm(a)
 

Data Registers:             R00 = n > 1                                   ( Registers R00 thru Rnn are to be initialized before executing "USPA" )

                                        R01   ......    Rnn = the n components of the anion a which are saved in registers  Rn+1 to R2n

                                         Rn+1 ..........  R3n =  Cm(b) (a)
                                         R2n+1 ........  R4n = Cm-1(b) (a)

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags: /
 
 
      STACK        INPUTS      OUTPUTS
           Y             b            /
           X             m         1.nnn

   where      1.nnn  is the control number of the result  and  m is an integer    ( 0 <= m < 1000 )

Example:        b = sqrt(2)     m = 7     a = 1 + i/2 + j/3 + k/4                             ( Quaternion ->  4  STO 00 )

   1   STO 01
   2   1/X  STO 02
   3   1/X  STO 03
   4   1/X  STO 04

   2   SQRT
   7   XEQ "USPA"   >>>>      1.004                                          ---Execution time = 32s---

  R01 =  324.5443969
  R02 = -689.5883616
  R03 = -459.7255740
  R04 = -344.7941807

        C7sqrt(2) ( 1 + i/2 + j/3 + k/4 ) =  324.5443967 - 689.5883616 i - 459.7255740 j - 344.7941807 k

-Likewise,   C7(0) ( 1 + i/2 + j/3 + k/4 ) =  29.24554797 - 33.27910360 i - 22.18606908 j - 16.63955181 k    ( in 22 seconds )
 

Anionic Airy Functions
 

Formulae:

    Ai(a) =   f(a) - g(a)                             with            f(a) = [ 3 -2/3 / Gamma(2/3) ]  0F1( 2/3 ; a3/9 )
    Bi(a) = [ f(a) + g(a) ] sqrt(3)               and            g(a) = [ 3 -1/3 / Gamma(1/3) ]  0F1( 4/3 ; a3/9 )   a
 

Data Registers:             R00 = n > 1                  ( Registers R00 thru Rnn are to be initialized before executing "AIRYA" )

                                        R01   ......    Rnn = the n components of the anion a

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of  Ai(a)
                                         and       Rn+1.......  R2n = --------------------  Bi(a)

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           X            m         1.nnn

   where   1.nnn   is the control number of  Ai(a)     [  Bi(a)  is in registers  Rn+1 ..... R2n ]

Example:             a = 1 + i/2 + j/3 + k/4                                                  ( Quaternion ->   4   STO 00 )

   1    STO 01
   2   1/X   STO 02
   3   1/X   STO 03
   4   1/X   STO 04    XEQ "AIRYA"    >>>>  1.004                                      ---Execution time = 27s---

  R01 =  0.105299445
  R02 = -0.078442074
  R03 = -0.052294716
  R04 = -0.039221037

Thus,    Ai ( 1 + i/2 + j/3 + k/4 ) = 0.105299445 - 0.078442074 i - 0.052294716 j - 0.039221037 k

 and     Bi ( 1 + i/2 + j/3 + k/4 ) = 0.973463977 + 0.394832415 i + 0.263221610 j + 0.197416207 k    in   R05 to R08
 

Note:

-This program returns accurate results for "small" arguments only.
 

Anionic Bessel Functions
 

Formulae:
 

  Bessel Functions of the 1st kind

       Jm(a) = (a/2)m [ 1/Gam(m+1)  +  (-a2/4)1/ (1! Gam(m+2) )  + .... + (-a2/4)k/ (k! Gam(m+k+1) ) + ....  ]      m # -1 ; -2 ; -3 ; ....

  Modified Bessel Functions of the 1st kind

       Im(a) = (a/2)m [ 1/Gam(m+1)  +  (a2/4)1/ (1! Gam(m+2) )  + .... + (a2/4)k/ (k! Gam(m+k+1) ) + ....  ]          m # -1 ; -2 ; -3 ; ....

  Bessel Functions & Modified Bessel Functions of the 2nd kind - non-integer order

        Ym(a) = ( Jm(a) cos(m(pi)) - J-m(a) ) / sin(m(pi))      ;      Km(a) = (pi/2) ( I-m(a) - Im(a) ) / sin(m(pi))           m # .... -3 ; -2 ; -1 ; 0 ; 1 ; 2 ; 3 ....

  Bessel Functions & Modified Bessel Functions of the 2nd kind - non-negative integer order

         Ym(a) = -(1/pi) (a/2)-m SUMk=0,1,....,m-1  (m-k-1)!/(k!) (a2/4)k + (2/pi) ln(a/2) Jm(a)
                       - (1/pi) (a/2)m SUMk=0,1,.....  ( psi(k+1) + psi(m+k+1) ) (-a2/4)k / (k!(m+k)!)                         where   psi = the digamma function

         Km(a) = (1/2) (a/2)-m SUMk=0,1,..,m-1  (m-k-1)!/(k!) (-a2/4)k - (-1)m ln(a/2) Im(a)
                    + (1/2) (-1)m (a/2)m SUMk=0,1,...( psi(k+1) + psi(m+k+1) ) (a2/4)k / (k!(m+k)!)
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "BSLA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp    ( R3n+1 to R4n are also used for the functions of the second kind )

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flags:  F02-F03
 
 
      STACK        INPUT      OUTPUT
           X             m         1.nnn

   where   1.nnn   is the control number of the result.

Example1:         m = PI     a = 1 + 2 i + 3 j + 4 k        ( quaternion ->  4  STO 00 )

      CF 02  CF 03  Bessel Functions of the 1st kind    J

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   PI   XEQ "BSLA"   >>>>   1.004                                            ---Execution time = 20s---

   R01 = -11.22987514
   R02 =  -3.570801501
   R03 =  -5.356202256
   R04 =  -7.141603008

-So,   JPI( 1 + 2 i + 3 j + 4 k ) = -11.22987513 - 3.570801496 i - 5.356202251 j - 7.141602999 k

      CF 02  SF 03  Modified  Bessel Functions of the 1st kind    I

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   PI   XEQ "BSLA"   >>>>   1.004                                            ---Execution time = 22s---

   R01 =  0.315197913
   R02 = -0.129988660
   R03 = -0.194982989
   R04 = -0.259977320

-Whence,   IPI( 1 + 2 i + 3 j + 4 k ) = 0.315197913 - 0.129988660 i - 0.194982989 j - 0.259977320 k
 

Example2:         m = PI     a = 1 + 2 i + 3 j + 4 k

      SF 02  CF 03  Bessel Functions of the 2nd kind   Y

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   PI   XEQ "BSLA"   >>>>   1.004                                            ---Execution time = 50s---

   R01 =   9.617564021
   R02 = -4.171358834
   R03 = -6.257038267
   R04 = -8.342717698

   So,   YPI( 1 + 2 i + 3 j + 4 k ) = 9.617564067 - 4.171358820 i - 6.257038246 j - 8.342717677 k

      SF 02  SF 03  Modified Bessel Functions of the 2nd kind   K

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   PI   XEQ "BSLA"   >>>>   1.004                                            ---Execution time = 51s---

   R01 =  0.203067071
   R02 = -0.055030894
   R03 = -0.082546339
   R04 = -0.110061787

-Whence,   KPI( 1 + 2 i + 3 j + 4 k ) = 0.203067069 - 0.055030894 i - 0.082546341 j - 0.110061786 k
 

Example3:         m = 3     a = 1 + 2 i + 3 j + 4 k

      SF 02  CF 03  Bessel Functions of the 2nd kind   Y

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   3   XEQ "BSLA"   >>>>   1.004                                            ---Execution time = 80s---

   R01 =  7.690027219
   R02 = -5.224812672
   R03 = -7.837219001
   R04 = -10.44962534

   So,   Y3( 1 + 2 i + 3 j + 4 k ) = 7.690027219 - 5.224812672 i - 7.837219001 j - 10.44962534 k

      SF 02  SF 03  Modified Bessel Functions of the 2nd kind   K

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   3   XEQ "BSLA"   >>>>   1.004                                            ---Execution time = 84s---

   R01 =  0.208767801
   R02 = -0.047983196
   R03 = -0.071974795
   R04 = -0.095966394

-Whence,   K3( 1 + 2 i + 3 j + 4 k ) = 0.208767802 - 0.047983197 i - 0.071974795 j - 0.095966394 k

-Likewise, we find:

   Y0( 1 + 2 i + 3 j + 4 k ) = 29.92977302 + 8.767829491 i + 13.15174422 j + 17.53565898 k    ( in 55 seconds )
   K0( 1 + 2 i + 3 j + 4 k ) = 0.190884048 + 0.016289912 i + 0.024434868 j + 0.032579827 k    ( in 65 seconds )
 

Anionic Catalan Numbers
 

-The Catalan numbers may be defined by  C(n) = 4n Gam(n+1/2) / [ sqrt(PI) Gam(n+2) ]
-This formula is used hereunder after replacing n by the anion a
 

Data Registers:             R00 = n > 1           ( Registers R00 thru Rnn are to be initialized before executing "CATA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R6n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           X            m         1.nnn

   where   1.nnn   is the control number of the result

Example:               a = 1 + i/2 + j/3 + k/4                            ( Quaternion ->   4   STO 00 )

  1   STO 01
  2   STO 02
  3   STO 03
  4   STO 04   XEQ "CATA"     >>>>    1.004                       ---Execution time = 54s---

 R01 = 0.844036224
 R02 = 0.239299403
 R03 = 0.159532935
 R04 = 0.119649702

-Thus,     C ( 1 + i/2 + j/3 + k/4 ) =  0.844036225 + 0.239299403 i + 0.159532936 j + 0.119649702 k

Note:

-Since SIZE = 6n+1 , the argument cannot be a 64-on.
 

Anionic Cosine Integral
 

  "CIA"   calculates    Ci(a)  = C + Ln(a) + Summ=1,2,..... (-1)m a2m/(2m.(2m)!)        if  flag  F01  is clear
                                Chi(a) = C + Ln(a) + Summ=1,2,.....  a2m/(2m.(2m)!)                 if  flag  F01  is set
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "CIA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the result.

Examples:               a = 1 + 2 i + 3 j + 4 k                      4  STO 00    ( quaternions )
 

a) Cosine Integral  Ci(a):
 

  1   STO 01
  2   STO 02
  3   STO 03
  4   STO 04      CF 01    XEQ "CIA"   >>>>   1.004

                     R01 =  19.04999179
                     R02 =  -6.098016771
                     R03 =  -9.147025156
                     R04 =  -12.19603355

   So,   Ci ( 1 + 2 i + 3 j + 4 k ) =  19.04999179 - 6.098016771 i - 9.147025156 j - 12.19603355 k
 

b) Hyperbolic Cosine Integral  Chi(a):
 

  1   STO 01
  2   STO 02
  3   STO 03
  4   STO 04      SF 01    XEQ "CIA"   >>>>   1.004

                     R01 =  -0.220285752
                     R02 =   0.529901612
                     R03 =   0.794852420
                     R04 =   1.059803224

   So,   Chi ( 1 + 2 i + 3 j + 4 k ) =  -0.220285752 + 0.529901612 i + 0.794852419 j + 1.059803225 k
 

Anionic Parabolic Cylinder Functions
 

Formula:         Dm(a) = 2m/2 Pi1/2 exp(-a2/4) [ 1/Gam((1-m)/2) M( -m/2 , 1/2 , a2/2 ) - 21/2 ( a / Gam(-m/2) ) M [ (1-m)/2 , 3/2 , a2/2 ]
 

Data Registers:             R00 = n > 1                          ( Registers R00 thru Rnn are to be initialized before executing "DNA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp    R4n+1 = m

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             m         1.nnn

   where   1.nnn   is the control number of the result.

Example:       m = 0.4      a = 1 + 1.1 i + 1.2 j + 1.3 k

    4    STO 00

    1    STO 01
   1.1  STO 02
   1.2  STO 03
   1.3  STO 04

   0.4  XEQ "DNA"   >>>>    1.004                           ---Execution time = 68s---

             R01 =  2.606105102
             R02 = -0.969116886
             R03 = -1.057218421
             R04 = -1.145319956

   D0.4( 1 + 1.1 i + 1.2 j + 1.3 k ) = 2.606105106 - 0.969116886 i - 1.057218422 j - 1.145319956 k
 

Note:

-This program gives accurate results for small arguments only.
 

Anionic Exponential Integral Ei
 

  "EIA"   computes    Ei(a)  = C + Ln(a) + Sumn=1,2,.....  an/(a.a!)                where  C = 0.5772156649... = Euler's constant.
 

Data Registers:             R00 = n > 1                 ( Registers R00 thru Rnn are to be initialized before executing "EIA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the result.

Examples:               a = 1 + 2 i + 3 j + 4 k                      4  STO 00    ( quaternions )

  1   STO 01
  2   STO 02
  3   STO 03
  4   STO 04      XEQ "EIA"   >>>>   1.004

                     R01 =  -0.381065061
                     R02 =   1.052055476
                     R03 =   1.578083216
                     R04 =   2.104110953

Whence,   Ei ( 1 + 2 i + 3 j + 4 k ) =  -0.381065063 + 1.052055476 i + 1.578083215 j + 2.104110953 k
 

Anionic Exponential Integral En
 

Formulae:   Em(a) = am-1 Gam(1-m) - [1/(1-m)] M( 1-m , 2-m ; -a )      where    M = Kummer's function        if   m # 1 , 2 , 3 , ................

 Otherwise:        Em(a) = (-a)m-1 ( -Ln a - gamma + Sumk=1,...,m-1 1/k ) / (m-1)!  - Sumk#m-1 (-a)k / (k-m+1) / k!    if  m = 1 , 2 , 3 , .....

                                                                   where  gamma = Euler's Constant = 0.5772156649...

     and   E0(a) = (1/a).exp(-a)
 

Data Registers:             R00 = n > 1                       ( Registers R00 thru Rnn are to be initialized before executing "ENA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            m         1.nnn

   where   1.nnn   is the control number of the result.

Example1:           m = PI   ,    a = 1 + i/2 + j/3 + k/4                          ( quaternion ->  4  STO 00 )

   1   STO 01
   2   1/X  STO 02
   3   1/X  STO 03
   4   1/X  STO 04

   PI   XEQ "ENA"  >>>>  1.004                                    ---Execution time = 24s---
 

            R01 =  0.066444329
            R02 = -0.059916132
            R03 = -0.039944088
            R04 = -0.029958065

   EPI( 1 + i/2 + j/3 + k/4 ) = 0.066444330 - 0.059916129 i - 0.039944087 j - 0.029958064 k

Example2:          m = 2   ,    a = 1 + i/2 + j/3 + k/4                          ( quaternion ->  4  STO 00 )

   1   STO 01
   2   1/X  STO 02
   3   1/X  STO 03
   4   1/X  STO 04

   2   XEQ "ENA"  >>>>  1.004                                    ---Execution time = 28s---
 

            R01 =  0.082262051
            R02 = -0.087391298
            R03 = -0.058260865
            R04 = -0.043695649

   E2( 1 + i/2 + j/3 + k/4 ) = 0.082262051 - 0.087391298 i - 0.058260865 j - 0.043695649 k
 

Anionic Gamma Function
 

-Here, the Gamma function is computed by a continued fraction:

    Gam(a) =  exp [ (a-1/2) Ln a + Ln (2.PI)1/2  - a + ( 1/12 )/( a + ( 1/30 )/( a + ( 53/210)/( a + (195/371)/( a + ...  )))) ]
 

-The relation   Gam(a+1) = a Gam(a)  is used recursively if Re(a) < 5  until   Re(a+1+.......+1)  > 5
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "GAMA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flag:  F10
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the result.

Example:     With the quaternion         q = 4 + 3 i + 2 j + k

-For quaternions,  n = 4  STO 00

      4  STO 01
      3  STO 02
      2  STO 03
      1  STO 04

      XEQ "GAMA"   >>>>    1.004                     ---Execution time = 22s---

            R01 =  0.541968820
            R02 = -0.740334196
            R03 = -0.493556131
            R04 = -0.246778065

     Gam ( 4 + 3 i + 2 j + k ) =  0.541968820 - 0.740334196 i - 0.493556131 j - 0.246778065 k
 

Anionic Generalized Error Functions
 

"GERFA" calculates  erfm (a) = a  exp ( -am )  M ( 1 ; 1+1/m ; am )          where   M = Kummer's function
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "GERFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           X             m         1.nnn

   Where  1.nnn   is the control number of  the result

Example:      m = sqrt(2)    a = 1.1 + 1.2 i + 1.3 j + 1.4 k               ( quaternion ->  4  STO 00 )

    1.1   STO 01
    1.2   STO 02
    1.3   STO 03
    1.4   STO 04

     2  SQRT   XEQ "GERFA"  >>>>   1.004                                           ---Execution time = 37s---

    R01 =  1.205349648
    R02 = -0.208378333
    R03 = -0.225743195
    R04 = -0.243108056

 Whence    erfm(a) = 1.205349651 - 0.208378333 i - 0.225743195 j - 0.243108055 k

Notes:

-The anion a must remains "small"
-If m = 2, we get "the" error-function divided by  2/sqrt(pi)
-To get the "normalized" generalized error-function, multiply the result by  Gamma(m+1) / sqrt(PI)
 

Anionic Generalized Hypergeometric Functions
 

-"HGFA" computes   pFq( b1,b2,....,bp ; c1,c2,....,cq ; a ) =  SUMk=0,1,2,.....    [(b1)k(b2)k.....(bp)k] / [(c1)k(c2)k.....(cq)k] . ak/k!           if   X > 0

           where (bi)k = bi(bi+1)(bi+2) ...... (bi+k-1)   &  (bi)0 = 1    ,    likewise for  (cj)k    ( Pochhammer's symbol )

 or the regularized function F tilde:

           pF~q( b1,b2,....,bp ; c1,c2,....,cq ; a ) =  SUMk=0,1,2,.....    [ (b1)k(b2)k.....(bp)k ] / [Gam(k+c1) Gam(k+c2).....Gam(k+cq)] . ak/k!      if  X < 0

    where Gam = Euler's Gamma function.
 
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn & R3n+1 ......  are to be initialized before executing "HGFA" )

                                        R01   ......    Rnn = the n components of the anion a

                                         Rn+1 ..........  R3n:  temp           R3n+1 = b1 ......    R3n+p = bp    R3n+p+1 = c1  ...........    R3n+p+q = cq

  >>>  When the program stops:     R01   ......  Rnn = the n components of  f(a)

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Y            /       +/- p.qqq
           X      +/- p.qqq         1.nnn

   where   1.nnn   is the control number of the result.

    + p.qqq   for the hypergeometric function
    - p.qqq   for the regularized hypergeometric function

Example1:             b1 = PI  ,   b2 = e  ;  c1 = 1 ,  c2 = 2 ,   c3 = 4  ;   a = 1 + 2 i + 3 j + 4 k              ( Quaternion ->   4   STO 00 )

-Since n = 4 , the parameters must be stored into  R13  R14  R15  ................

   PI   STO 13    1  E^X  STO 14  ,   1  STO 15   2  STO 16   4  STO 17

     1  STO 01   2  STO 02   3  STO 03   4  STO 04

   2.003   XEQ "HGFA"  >>>>      1.004                       ---Execution Time= 45s---

  R01 = -6.691126901
  R02 =  1.302530584
  R03 =  1.953795876
  R04 =  2.605061166

        2F3( PI , e ; 1 , 2 , 4 ;  1 + 2 i + 3 j + 4 k ) = -6.691126901 + 1.302530584 i + 1.953795876 j + 2.605061166 k

     1  STO 01   2  STO 02   3  STO 03   4  STO 04

   2.003  CHS   XEQ "HGFA"  >>>>      1.004                       ---Execution Time= 53s---

  R01 = -1.115187818
  R02 =  0.217088431
  R03 =  0.325632646
  R04 =  0.434176861

        2F~3( PI , e ; 1 , 2 , 4 ;  1 + 2 i + 3 j + 4 k ) = -1.115187818 + 0.217088431 i + 0.325632646 j + 0.434176861 k

-The first result has been simply divided by  Gam(1) Gam(2) Gam(4) = 6
 

Example2:             b1 = PI  ,   b2 = e  ;  c1 = 1 ,  c2 = -2 ,   c3 = -4  ;   a = 1 + 2 i + 3 j + 4 k

   PI   STO 13    1  E^X  STO 14  ,   1  STO 15   -2  STO 16  -4  STO 17

  ( the non-regularized hypergeometric function does not exist for these parameters )

      1  STO 01   2  STO 02   3  STO 03   4  STO 04

   2.003  CHS   XEQ "HGFA"  >>>>      1.004                       ---Execution Time= 67s---

 R01 = -2910223.711
 R02 =  192140.2259
 R03 =  288210.3384
 R04 =  384280.4514

         2F~3( PI , e ; 1 , -2 , -4 ;  1 + 2 i + 3 j + 4 k ) = -2910223.711 + 192140.2260 i + 288210.3385 j + 384280.4514 k
 

Anionic Hypergeometric Functions ( p+q < 4 )
 
 

-If p+q < 4 , the parameters bi & cj may be entered in the stack without using registers R3n+1 ... and so on ...
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "HGFA3" )

                                        R01   ......    Rnn = the n components of the anion a  which are saved in  Rn+1 .... R2n

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of  f(a)

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           T        bi or cj        bi or cj
           Z        bi or cj        bi or cj
           Y        bi or cj        bi or cj
           X      +/- p.qqq         1.nnn

   where   1.nnn   is the control number of the result.

    + p.qqq   for the hypergeometric function
    - p.qqq   for the regularized hypergeometric function

>>> Enter the bi first, then the cj and finally  +/- p.qqq

Example1:       2F1       a = 0.1 + 0.2 i + 0.3 j + 0.4 k           p = 1.1   q = 1.2   s = 1.3              ( Quaternion ->   4   STO 00 )

     0.1  STO 01
     0.2  STO 02
     0.3  STO 03
     0.4  STO 04

     1.1  ENTER^
     1.2  ENTER^
     1.3  ENTER^
   2.001  XEQ "HGFA3"   >>>>   1.004                           ---Execution time = 42s---

            R01 =  0.814236592
            R02 =  0.184421233
            R03 =  0.276631850
            R04 =  0.368842467

    2F1 ( 1.1 , 1.2 ; 1.3 ;  0.1 + 0.2 i + 0.3 j + 0.4 k ) = 0.814236592 + 0.184421233 i + 0.276631850 j + 0.368842467 k
 

Example2:      2F~1        a = 0.1 + 0.2 i + 0.3 j + 0.4 k           p = 1   q = 2   s = -4                        ( Quaternion ->   4   STO 00 )

     0.1  STO 01
     0.2  STO 02
     0.3  STO 03
     0.4  STO 04

     1     ENTER^
     2     ENTER^
    -4    ENTER^
  2.001  CHS   XEQ "HGFA3"   >>>>   1.004                          ---Execution time = 92s---

            R01 =  -7.152496297
            R02 =  -9.061272756
            R03 =  -13.59190873
            R04 =  -18.12254510

    2F~1 ( 1 , 2 ; -4 ;  0.1 + 0.2 i + 0.3 j + 0.4 k ) = -7.152496237 - 9.061272609 i - 13.59190870 j - 18.12254514 k
 

Example3:     1F2         a = 0.1 + 0.2 i + 0.3 j + 0.4 k           p = 1.1   q = 1.2   s = 1.3              ( Quaternion ->   4   STO 00 )

     0.1  STO 01
     0.2  STO 02
     0.3  STO 03
     0.4  STO 04

     1.1  ENTER^
     1.2  ENTER^
     1.3  ENTER^
   1.002  XEQ "HGFA3"   >>>>   1.004                           ---Execution time = 10s---

            R01 =  1.028367021
            R02 =  0.146116085
            R03 =  0.219174127
            R04 =  0.292232170

-Whence,       1F2 ( 1.1 ; 1.2 , 1.3 ;  0.1 + 0.2 i + 0.3 j + 0.4 k ) = 1.028367021 + 0.146116085 i + 0.219174127 j + 0.292232170 k

Note:

-Likewise, for the Kummer's Function 1F1  ,  place  1.001  in X-register
  and  -1.001  in X-register for the regularized Kummer's Function  1F~1  and so on ....
 

Anionic Hermite Functions
 

Formula:       Hm(a) = 2m sqrt(PI) [ (1/Gam((1-m)/2))  M(-m/2,1/2,a2) - ( 2.a / Gam(-m/2) ) M((1-m)/2,3/2,a2) ]

     where  Gam = Gamma function
       and      M  = Kummer's function = 1F1
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "HMTA+" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp   R4n+1 = -m/2

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           X            m         1.nnn

   where   1.nnn   is the control number of the result

Example:             a = 1 + i/2 + j/3 + k/4       m = PI                                           ( Quaternion ->   4   STO 00 )

   1    STO 01
   2   1/X   STO 02
   3   1/X   STO 03
   4   1/X   STO 04

  PI   XEQ "HMTA+"    >>>>  1.004                                      ---Execution time = 45s---

  R01 = -17.81760490
  R02 =   2.845496135
  R03 =   1.896997426
  R04 =   1.422748067

-Whence,     Hpi( 1 + i/2 + j/3 + k/4 ) =  -17.81760491 + 2.845496135 i + 1.896997424 j + 1.422748068 k
 

Anionic Harmonic Numbers
 

 "HRMA" calculates the generalized harmonic numbers defined as  Hm(a) = 1 + 2 -a + 3 -a + ............ + m -a
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "HRMA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            m         1.nnn

   where  m is a positive integer and 1.nnn   is the control number of  the result

Example:    Calculate  H12( 1 + 2 e1 + 3 e2 + 4 e3 + 5 e4 + 6 e5 + 7 e6 + 8 e7 )                ( octonion ->  8  STO 00 )

     1   STO 01
     2   STO 02
     3   STO 03
     4   STO 04
     5   STO 05
     6   STO 06
     7   STO 07
     8   STO 08

    12  XEQ "HRMA"  >>>>  1.008                                ---Execution time = 44s---

   R01 = 0.248285998     R05 = 0.031438213
   R02 = 0.012575285     R06 = 0.037725855
   R03 = 0.018862927     R07 = 0.044013498
   R04 = 0.025150570     R08 = 0.050301140     whence

   H12( 1 + 2 e1 + 3 e2 + 4 e3 + 5 e4 + 6 e5 + 7 e6 + 8 e7 )  =  0.248285998 + 0.012575285 e1 + 0.018862927 e2 + 0.025150570 e3
                                                                                           + 0.031438213 e4 + 0.037725855 e5 + 0.044013498 e6 + 0.050301140 e7
 

Anionic Incomplete Beta Functions
 

Formula:    Ba(p,q) = ( ap / p )  F(p,1-q;p+1;a)   where  F = the hypergeometric function
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "IBFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Y            p            p
           X            q         1.nnn

   where   1.nnn   is the control number of  the result

Example:    Compute  B0.1+0.2i+0.3j+0.4k ( 0.7 , 1.8 )               ( quaternion ->  4  STO 00 )

   0.1  STO 01
   0.2  STO 02
   0.3  STO 03
   0.4  STO 04

   0.7  ENTER^
   1.8  XEQ "IBFA"  >>>>    1.004                                           ---Execution time = 32s---

   R01 = 0.653131938
   R02 = 0.244542459
   R03 = 0.366813688
   R04 = 0.489084918

-Whence,    B0.1+0.2i+0.3j+0.4k ( 0.7 , 1.8 ) = 0.653131938 + 0.244542459 i + 0.366813688 j + 0.489084918 k

Note:

-In general, the hypergeometric series converge if  | a | < 1
 

Anionic Incomplete Gamma Functions
 

Formula:      g(m,a) = ( am / m ) exp(-a)  M(1,m+1;a)   where  M = Kummer's function
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "IGFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp     R3n+1 = m

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            m         1.nnn

   where   1.nnn   is the control number of  the result

Example:    Compute   g( 1.6 , 1 + 2 i + 3 j + 4 k )               ( quaternion ->  4  STO 00 )

     1   STO 01
     2   STO 02
     3   STO 03
     4   STO 04

    1.6   XEQ "IGFA"  >>>>    1.004                                           ---Execution time = 38s---

   R01 =  0.955358734
   R02 = -0.390239936
   R03 = -0.585359904
   R04 = -0.780479873

-So,     g( 1.6 , 1 + 2 i + 3 j + 4 k ) = 0.955358734 - 0.390239936 i - 0.585359904 j - 0.780479873 k
 

Anionic Jacobi Functions
 

Formula:           Pm(a;b) (a) = [ Gam(a+m+1) / Gam(m+1) ]  2F~1 ( -m , a+b+m+1 , a+1 , (1-a)/2 )

                            where  2F1 tilde is the regularized hypergeometric function
 

Data Registers:             R00 = n > 1                   ( Registers R00 thru Rnn are to be initialized before executing "JCFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:
 
 
      STACK        INPUTS      OUTPUTS
           Z            a            /
           Y            b            /
           X            m         1.nnn

   where   1.nnn   is the control number of the result.

Example:      a = sqrt(2)    b = sqrt(3) m = PI                 a = 1 + i / 2 + j / 3 + k / 4             ( quaternion ->  4  STO 00 )

    1   STO 01
    2   1/X   STO 02
    3   1/X   STO 03
    4   1/X   STO 04

    2   SQRT
    3   SQRT
   PI   XEQ "JCFA"  >>>>  1.004                               ---Execution time = 33s---

    R01 = -10.14397527
    R02 =  11.74139999
    R03 =   7.827599996
    R04 =   5.870699997

-So,        PPIsqrt(2);sqrt(3) ( 1 + i/2 + j/3 + k/4 ) =  -10.14397526 + 11.74139997 i + 7.827599998 j + 5.870699987 k
 

-Likewise,   PPI(-4;+4) ( 1 + i/2 + j/3 + k/4 ) =  0.360213558 - 0.125970281 i - 0.083980187 j - 0.062985140 k    ( in 48 seconds )

Note:

-Unless the function is a polynomial, the series is convergent if  | 1 - a | < 2
 

Anionic Jacobian Elliptic Functions
 

"JEFA" employs Gauss' transformation to calculate  sn ( a | m )  ,  cn ( a | m )  &  dn ( a | m )

-If   m < 1 , we have:

-With  m' = 1-m ,  let be  µ = [ ( 1-sqrt(m') / ( 1+sqrt(m') ]2   and   v = a / ( 1+sqrt(µ) ]  , then:

   sn ( a | m ) = [ ( 1 + sqrt(µ) ) sn ( v | µ ) ] / [ 1 + sqrt(µ) sn2 ( v | µ ) ]
   cn ( a | m ) = [ cn ( v | µ ) dn ( v | µ ) ] / [ 1 + sqrt(µ) sn2 ( v | µ ) ]
   dn ( a | m ) = [ 1 - sqrt(µ) sn2 ( v | µ ) ] / [ 1 + sqrt(µ) sn2 ( v | µ ) ]

-These formulas are applied recursively until µ is small enough to use

   sn ( v | 0 ) = Sin v
   cn ( v | 0 ) = Cos v
   dn ( v | 0 ) = 1

-If m > 1, the program uses the relations:

      sn ( a | m ) = sn ( a m1/2 | 1/m ) / m1/2
      cn ( a | m ) = dn ( a m1/2 | 1/m )
      dn ( a | m ) = cn ( a m1/2 | 1/m )

-If m = 1:      sn ( a | m ) = tanh a ; cn ( a | m ) = dn ( a | m ) = sech a
 
 

Data Registers:             R00 = n > 1                                 ( Registers R00 thru Rnn are to be initialized before executing "JEFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp   R4n+1 = m ,  R4n+2 ..... temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of sn ( a | m )
                                                      Rn+1 ......  R2n = --------------------  cn ( a | m )
                                                      R2n+1 ....  R3n = --------------------  dn ( a | m )

Flags:  F01-F10
 
 
      STACK        INPUTS      OUTPUTS
           X            m         1.nnn

   where   1.nnn   is the control number of  sn ( a | m )

Example1:      m = 1/PI   q = 1 + 2 i + 3 j + 4 k      ( Quaternion ->   4   STO 00 )

     1  STO 01
     2  STO 02
     3  STO 03
     4  STO 04

    PI  1/X   XEQ "JEFA"   >>>> 1.004                    ---Execution time = 70s---

    R01 =  1.498262248
    R02 =  0.205407205
    R03 =  0.308110807
    R04 =  0.410814410

     sn ( 1 + 2 i + 3 j + 4 k | 1/PI ) = 1.498262249 + 0.205407205 i + 0.308110807 j + 0.410814409 k    and

     cn ( 1 + 2 i + 3 j + 4 k | 1/PI ) = -0.694940081 + 0.442849491 i + 0.664274236 j + 0.885698982 k   in  R05 to 508

     dn ( 1 + 2 i + 3 j + 4 k | 1/PI ) = -0.719248900 + 0.136199161 i + 0.204298741 j + 0.272398321 k    in R09 to R12
 

Example2:      m = PI   a = 1 + 2 i + 3 j + 4 k      ( Quaternion ->   4   STO 00 )

     1  STO 01
     2  STO 02
     3  STO 03
     4  STO 04

    PI   XEQ "JEFA"   >>>>  1.004                    ---Execution time = 72s---

    R01 =  0.860242322
    R02 = -0.005873618
    R03 = -0.008810427
    R04 = -0.011747237

     sn ( 1 + 2 i + 3 j + 4 k | PI ) = 0.860242322 - 0.005873618 i - 0.008810427 j - 0.011747237 k    and

     cn ( 1 + 2 i + 3 j + 4 k | PI ) = 0.510825404 + 0.009891315 i + 0.014836973 j + 0.019782630 k   in  R05 to 508

     dn ( 1 + 2 i + 3 j + 4 k | PI ) = -0.037125130 - 0.427571169 i - 0.645356753 j - 0.855142337 k    in R09 to R12
 

Example3:      m = -PI   q = 1 + 2 i + 3 j + 4 k      ( Quaternion ->   4   STO 00 )

     1  STO 01
     2  STO 02
     3  STO 03
     4  STO 04

    PI  CHS   XEQ "JEFA"   >>>>  1.004                    ---Execution time = 81s---

    R01 = -1.473447237
    R02 = -0.079007894
    R03 = -0.118511841
    R04 = -0.158015787

     sn ( 1 + 2 i + 3 j + 4 k | -PI ) = -1.473447239 - 0.079007894 i - 0.118511841 j - 0.158015787 k    and

     cn ( 1 + 2 i + 3 j + 4 k | -PI ) = 0.285290836 - 0.408053637 i - 0.612080455 j - 0.816107274 k   in  R05 to 508

     dn ( 1 + 2 i + 3 j + 4 k | -PI ) = -2.793322224 - 0.130928415 i - 0.196392622 j - 0.261856829 k    in R09 to R12
 

Anionic Laguerre's Functions
 

Formula:      Lm(b)(q) = [ Gam(m+b+1) / Gam(m+1) / Gam(b+1) ]  M ( -n , a+1 , q )           m , b # -1 , -2 , -3 , ....

   where  Gam = Gamma function
     and      M   = Kummer's function
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "LANA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp    R4n+1 = m

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Y             b            /
           X             m         1.nnn

   where   1.nnn   is the control number of the result.

Example:        b = sqrt(3)     m = PI     a = 1 + 2 i + 3 j + 4 k

   4  STO 00

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   3   SQRT
  PI  XEQ "LANA"   >>>>  1.004                          ---Execution time = 28s---

           R01 = -59.37663947
           R02 =   3.135355698
           R03 =   4.703033534
           R04 =   6.270711379

        Lpisqrt(3) ( 1 + 2 i + 3 j + 4 k ) =  -59.37663947 + 3.135355686 i + 4.703033554 j + 6.270711371 k
 

Anionic Lambert W-Function
 

-We have to solve  x = w(x) exp [ w(x) ]
-"LBWA" employs Newton's method.
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "LBWA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           X            /         1.nnn

   where   1.nnn   is the control number of the result

Example:                a = 1 + 2 i + 3 j + 4 k                            ( Quaternion ->   4   STO 00 )

  1  STO 01
  2  STO 02
  3  STO 03
  4  STO 04  XEQ "LBWA"   >>>>      1.004                       ---Execution time = 52s---

 R01 =  1.281459811
 R02 =  0.304051227
 R03 =  0.456076840
 R04 =  0.608102453

 Whence,    W(1 + 2 i + 3 j + 4 k) =  1.281459811 + 0.304051227 i + 0.456076840 j + 0.608102453 k

Note:

-This routine doesn't work if a = -1  but   W(-1) =   -0.318131505 + 1.337235701 i
 

Anionic Digamma Function
 

Formula:             Psi(a) ~ Ln a - 1/(2a) -1/(12a2) + 1/(120a4) - 1/(252a6) + 1/(240a8)    is used if  Re(a) > 8

                        Psi(a+1) = Psi(a) + 1/a    is used recursively until  Re(a+1+....+1) > 8
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "PSIA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the result.

Example:              a = 1 + 2 i + 3 j + 4 k

     n = 4  STO 00

      1  STO 01
      2  STO 02
      3  STO 03
      4  STO 04

      XEQ "PSIA"   >>>>     1.004                     ---Execution time = 31s---

            R01 =  1.686531557
            R02 =  0.548896352
            R03 =  0.823344528
            R04 =  1.097792703

     Psi ( 1 + 2 i + 3 j + 4 k ) =  1.686531557 + 0.548896352 i + 0.823344528 j + 1.097792703 k
 

Anionic Polygamma Functions
 

Formulae:     "PSINA" employs the asymptotic expansions:

     If m > 0  ,  y(m) (a)  ~  (-1)m-1 [ (m-1)! / am + m! / (2.am+1) + SUMk=1,2,.... B2k (2k+m-1)! / (2k)! / a2k+m       where  B2k are Bernoulli numbers

     If m = 0  ,  y (a)  ~  Ln a - 1/(2a) - SUMk=1,2,.... B2k / (2k) / a2k              ( digamma function )
 

 and the recurrence relation:   y(m) (a+p) = y(m) (a) + (-1)m m! [ 1/am+1 + ....... + 1/(a+p-1)m+1 ]           where  p  is a positive integer
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "PSINA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X            m         1.nnn

   where  m  is a non-negative integer  <  61  and  1.nnn   is the control number of  the result

Example1:    Calculate  y(3) ( 1 + 0.9 i + 0.8 j + 0.7 k )                        ( quaternion ->  4  STO 00 )

     1   STO 01
   0.9  STO 02
   0.8  STO 03
   0.7  STO 04

    3    XEQ "PSINA"   >>>>   1.004                                           ---Execution time = 61s---

   R01 = -0.673649101
   R02 =  0.147195368
   R03 =  0.130840327
   R04 =  0.114485286

  whence    y(3) ( 1 + 0.9 i + 0.8 j + 0.7 k ) =  -0.673649101 + 0.147195368 i + 0.130840327 j + 0.114485286 k
 

Example2:    Calculate  y ( 1 + 0.9 i + 0.8 j + 0.7 k )       digamma function    i-e   m = 0              ( quaternion ->  4  STO 00 )

     1   STO 01
   0.9  STO 02
   0.8  STO 03
   0.7  STO 04

    0    XEQ "PSINA"   >>>>   1.004                                           ---Execution time = 47s---

   R01 = 0.377339972
   R02 = 0.783351925
   R03 = 0.696312822
   R04 = 0.609273719

  whence    y ( 1 + 0.9 i + 0.8 j + 0.7 k ) =  0.377339972 + 0.783351925 i + 0.696312822 j + 0.609273719 k
 

Note:

-"PSINA" computes  (m+9)!  - line 66 - so m cannot exceed 60.
 

Anionic Regular Coulomb Wave Functions
 

Formulae:         FL(h,a) = CL(h) a L+1 Sum k>L AkL (h) a k-L-1

    with   CL(h) = (1/Gam(2L+2)) 2L e -pi.h/2 | Gam(L+1+i.h) |
    and    AL+1L = 1 ;  AL+2L = h/(L+1)  ;  (k+L)(k-L-1) AkL = 2.h Ak-1L - Ak-2L   ( k > L+2 )
 

-"RCWFA" also uses   | Gam( 1+i y ) |2 = (Pi.y) / Sinh (Pi y)

      and    | Gam( 1+L+i y ) |2 = [ L2 + y2 ] [ (L-1)2 + y2 ] .................. [ 1 + y2 ]  (Pi.y) / Sinh (Pi y)
 
 

Data Registers:             R00 = n > 1                             ( Registers R00 thru Rnn are to be initialized before executing "RCWFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n+1:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F10
 
 
      STACK        INPUTS      OUTPUTS
           Y            L            /
           X            h         1.nnn

   where   1.nnn   is the control number of the result.

Example:         L = 2  ,   h = 0.75  ;   a = 1 + 1.2 i + 1.4 j + 1.6 k        ( quaternion ->  4  STO 00 )

   1    STO 01
  1.2  STO 02
  1.4  STO 03
  1.6  STO 04

   2     ENTER^
0.75   XEQ "RCWFA"   >>>>  1.004                                              ---Execution time = 39s---

  R01 =  -0.478767860
  R02 =  -0.179694771
  R03 =  -0.209643900
  R04 =  -0.239593028

-So,   F2( 0.75 ;  1 + 1.2 i + 1.4 j + 1.6 k ) = -0.478767860 - 0.179694771 i - 0.209643900 j - 0.239593028 k

Note:

  L must be a non-negative integer.

An example with an octonion:

        L = 3  ,  h = 0.75  ;   a = 1 + 1.1 e1 + 1.2 e2 + 1.3 e3  + 1.4 e4 + 1.5 e5 + 1.6 e6  + 1.7 e7

   8   STO 00

   1   STO 01   1.1  STO 02  .........................  1.7  STO 08

   3     ENTER^
0.75   XEQ "RCWFA"   >>>>  1.008                                              ---Execution time = 60s---      ( with DS*A )

  R01 =   1.025562455
  R02 =  -0.294428914
  R03 =  -0.321195179
  R04 =  -0.347961444
  R05 =  -0.374727708
  R06 =  -0.401493973
  R07 =  -0.428260238
  R08 =  -0.455026503

-So,   F3( 0.75 ;  1 + 1.1 e1 + 1.2 e2 + 1.3 e3  + 1.4 e4 + 1.5 e5 + 1.6 e6  + 1.7 e7 ) =

   1.025562455 - 0.294428914 e1 - 0.321195178 e2 - 0.347961443 e3 - 0.374727708 e4 - 0.401493973 e5 - 0.428260238 e6 - 0.455026503 e7
 

Anionic Sine Integral
 

  "SIA"       Si(a)  = Summ=0,1,2,..... (-1)m a2m+1/((2m+1).(2m+1)!)    if  flag  F01  is clear
                 Shi(a) = Summ=0,1,2,.....  a2m+1/((2m+1).(2m+1)!)            if  flag  F01  is set

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "SIA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the result.

Examples:               a = 1 + 2 i + 3 j + 4 k                      4  STO 00    ( quaternions )
 

a) Sine Integral  Si(a):

  1   STO 01
  2   STO 02
  3   STO 03
  4   STO 04      CF 01    XEQ "SIA"   >>>>   1.004

                     R01 =  17.98954626
                     R02 =   7.075096290
                     R03 =  10.61264444
                     R04 =  14.15019258

   So,   Si ( 1 + 2 i + 3 j + 4 k ) =  17.98954624 + 7.075096290 i + 10.61264443 j + 14.15019258 k
 

b) Hyperbolic Sine Integral  Shi(a):
 

  1   STO 01
  2   STO 02
  3   STO 03
  4   STO 04      SF 01    XEQ "SIA"   >>>>   1.004

                     R01 =  -0.160779308
                     R02 =   0.522153864
                     R03 =   0.783230796
                     R04 =   1.044307726

  Whence:   Shi ( 1 + 2 i + 3 j + 4 k ) =  -0.160779308 + 0.522153864 i + 0.783230794 j + 1.044307728 k
 

Anionic Struve Function
 

Formulae:

  CF 01        Hm(q) = (a/2)m+1 1F2( 1 ; 3/2 , m + 3/2 ; - a2/4 ) / Gam( m+3/2 )                with    m+3/2 # 0 , -1 , -2 , ...................
  SF 01         Lm(q) = (a/2)m+1 1F2( 1 ; 3/2 , m + 3/2 ;  a2/4 ) / Gam(m+3/2)
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "STRA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             m         1.nnn

   where   1.nnn   is the control number of the result.

Example:        m = PI     a = 1 + 2 i + 3 j + 4 k

      CF 01

    1   STO 01
    2   STO 02
    3   STO 03
    4   STO 04

   PI   XEQ "STRA"   >>>>  1.004                                         ---Execution time = 29s---

    R01 =  8.546633232
    R02 = -4.085079933
    R03 = -6.127619898
    R04 =  -8.170159864

   So,   Hpi( 1 + 2 i + 3 j + 4 k ) = 8.546633230 - 4.085079932 i - 6.127619898 j - 8.170159863 k

      SF 01

    1   STO 01
    2   STO 02
    3   STO 03
    4   STO 04

   PI   XEQ "STRA"   >>>>  1.004                                         ---Execution time = 30s---

   R01 =  1.864582784
   R02 = -0.116220198
   R03 = -0.174330297
   R04 = -0.232440397

-Whence,   Lpi( 1 + 2 i + 3 j + 4 k ) = 1.864582785 - 0.116220199 i - 0.174330298 j - 0.232440398 k
 

Anionic Spheroidal Wave Functions
 

-"SWFA" computes the angular spheroidal wave function of the first kind.
-Given  m , n  and c2 , the corresponding eigenvalue  l  may be calculated by a program listed in "Spheroidal Harmonics for the HP-41"

-We assume that  | a | <= 1  and  Smn(a) is computed by      Smn(a) = ( 1 - a2 ) m/2   Sumk=0,1,.... dk ak

     with     (k+1)(k+2) dk+2 - [ k ( k + 2m + 1 ) - l + m ( m + 1 ) ] dk  - c2  dk-2 = 0
 

 Flammer's Scheme:           the coefficients are normalized as follows:

      d0 = Pnm(0)  =  2m sqrt(PI) / [ Gam((1-m-n)/2) Gam((2-m+n)/2 ]
      d1 = P'nm(0) = ( m + n ) 2m sqrt(PI) / [ Gam((2-m-n)/2) Gam((1-m+n)/2 ]
 
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "SWFA" )

                                       R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp   R3n+1 = m ,  R3n+2 = n ,  R3n+3 = c2 ,  R3n+4 = l

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flag:  F01
 
 
      STACK        INPUTS      OUTPUTS
           T            m            /
           Z            n            /
           Y            c2            /
           X            l         1.nnn

   where   1.nnn   is the control number of the result.

Example:    m = 0.2  ,  n = 0.6 ,  c2 = 1.7 ,  l = 2.246866651     a = 0.1 + 0.2 i + 0.3 j + 0.4 k                 ( Quaternion ->   4   STO 00 )

   0.1  STO 01
   0.2  STO 02
   0.3  STO 03
   0.4  STO 04

  0.2   ENTER^
  0.6   ENTER^
  1.7   ENTER^
  2.246866651   XEQ "SWFA"  >>>>   1.004                             ---Execution time = 86s---            ( with  DS*A )

  R01 = 0.391049684
  R02 = 0.161100168
  R03 = 0.241650252
  R04 = 0.322200335

-Whence     S( 0.1 + 0.2 i + 0.3 j + 0.4 k ) = 0.391049684 + 0.161100168 i + 0.241650253 j + 0.322200336 k
 

Anionic UltraSpherical Functions
 

 Formula:    Assuming  l # 0

          Cm(l)(q) = [ Gam(m+2l) / Gam(m+1) / Gam(2.l) ]  2F1( -m , m+2l , m+1/2 , (1-a)/2 )

                     where  2F1 is the hypergeometric function and Gam = Gamma function
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "USFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Y            l            /
           X            m         1.nnn

   where   1.nnn   is the control number of the result.

Example:      l = sqrt(2)    m = sqrt(3)    a = 1 + i / 2 + j / 3 + k / 4             ( quaternion ->  4  STO 00 )

    1   STO 01
    2   1/X   STO 02
    3   1/X   STO 03
    4   1/X   STO 04

    2   SQRT
    3   SQRT   XEQ "USFA"  >>>>  1.004                               ---Execution time = 34s---

    R01 = 3.241115513
    R02 = 4.848277899
    R03 = 3.232185264
    R04 = 2.424138948

-Whence      Csqrt(3)sqrt(2) ( 1 + i/2 + j/3 + k/4 ) =  3.241115514 + 4.848277901 i + 3.232185266 j + 2.424138949 k
 

Anionic Weber & Anger Functions
 

 "WEBA" calculates Weber functions if flag F01 is clear and Anger's functions if flag F01 is set
 

Formulae:
 

   Em(a) = - (a/2) cos ( 90°m )  1F~2( 1 ; (3-m)/2 , (3+m)/2 ; -a2/4 )         Weber's functions

                    + sin ( 90°m ) 1F~2( 1 ; (2-m)/2 , (2+m)/2 ; -a2/4 )

  Jm(a) = + (a/2) sin ( 90°m ) 1F~2( 1 ; (3-m)/2 , (3+m)/2 ; -a2/4 )     Anger's functions

                  + cos ( 90°m ) 1F~2( 1 ; (2-m)/2 , (2+m)/2 ; -a2/4 )
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "WEBA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result
 

Flags:  F00-F01                 CF 01 for Weber's function
                                            SF 01 for Anger's function
 
 
      STACK        INPUT      OUTPUT
           X             m         1.nnn

   where   1.nnn   is the control number of the result.

Example:         m = PI     a = 1 + 2 i + 3 j + 4 k        ( quaternion ->  4  STO 00 )

      CF 01  Weber's function

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   PI   XEQ "WEBA"   >>>>   1.004                                            ---Execution time = 58s---

   R01 = -9.566817335
   R02 =  4.177204885
   R03 =  6.265807323
   R04 =  8.354409766

-So,     EPi( 1 + 2 i + 3 j + 4 k ) = -9.566817369 + 4.177204897 i + 6.265807346 j + 8.354409796 k

      SF 01  Anger's function

   1   STO 01
   2   STO 02
   3   STO 03
   4   STO 04

   PI   XEQ "WEBA"   >>>>   1.004                                            ---Execution time = 58s---

   R01 = -11.24234891
   R02 = -3.564968423
   R03 = -5.347452633
   R04 = -7.129936844

-Whence,   JPi( 1 + 2 i + 3 j + 4 k ) = -11.24234895 - 3.564968431 i - 5.347452647 j - 7.129936863 k
 

Anionic Weierstrass Elliptic Functions
 

-The Weierstrass Elliptic Function  P(a;g2,g3) may be calculated by a Laurent series:

      P(a;g2;g3) = a -2 + c2.a2 + c3.a4 + ...... + ck.a2k-2 + ....

  where   c2 = g2/20  ;   c3 = g3/28  and   ck =  3 ( c2. ck-2 + c3. ck-3 + ....... + ck-2. c2 ) / (( 2k+1 )( k-3 ))      ( k > 3 )

-The successive  ck  are computed and stored into registers  R3n+1  R3n+2  ......
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "WEFA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags: /
 
 
      STACK        INPUTS      OUTPUTS
           Y            g2            /
           X            g3         1.nnn

   where   1.nnn   is the control number of the result

Example:         a = 0.2 + 0.3 i + 0.4 j + 0.5 k  ;   g2 = 0.9  ,   g3 = 1.4                            ( Quaternion ->   4   STO 00 )

   0.2   STO 01
   0.3   STO 02
   0.4   STO 03
   0.5   STO 05

   0.9   ENTER^
   1.4   XEQ "WEFA"   >>>>      1.004                       ---Execution time = 41s---    ( With  "DS*A" )

   R01 =  -1.591637275
   R02 =  -0.411614082
   R03 =  -0.548818776
   R04 =  -0.686023470

   P( 0.2 + 0.3 i + 0.4 j + 0.5 k  ;  0.9 ,  1.4 ) = -1.591637275 - 0.411614082 i - 0.548818776 j - 0.686023470 k
 

Anionic Weierstrass Duplication Formula
 

-The argument a may be "large" and the Laurent series doesn't converge.
-The duplication formula may be used one or several times in this case.

-"WF2A" takes P(a) in registers R01 .......... Rnn  and returns P(2a) in the same registers
 

-We have:      P(2a) = -2 P(a) + ( 6 P2(a) - g2/2 )2 / ( 4 ( 4 P3(a) - g2 P(a) - g3 ) )
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "WF2A" )

                                        R01   ......    Rnn = the n components of P(a)

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of  P(2a)

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Z            /            g2
           Y            g2            g3
           X            g3         1.nnn

   where   1.nnn   is the control number of the result

Example:     We have found  P( 0.2 + 0.3 i + 0.4 j + 0.5 k  ;  0.9 ,  1.4 ) = -1.591637275 - 0.411614082 i - 0.548818776 j - 0.686023470 k

-If the result is still in registers  R01 thru Rnn

   0.9   ENTER^
   1.4   XEQ "WF2A"   >>>>      1.004                       ---Execution time = 9s---

  R01 = -0.370892103
  R02 = -0.169841922
  R03 = -0.226455893
  R04 = -0.283069868

-So,   P( 0.4 + 0.6 i + 0.8 j + k  ;  0.9 ,  1.4 ) = -0.370892102 - 0.169841921 i - 0.226455894 j - 0.283069868 k
 

Notes:

-In fact, the Laurent series still converges for 2a   and a direct evaluation of P(2a) with "WEFA"  yields

   P( 0.4 + 0.6 i + 0.8 j + k  ;  0.9 ,  1.4 ) = -0.370892103 - 0.169841920 i - 0.226455894 j - 0.283069867 k

-If you have to execute "WF2A" several times, simply press  R/S  instead of XEQ "WF2A"
 

Anionic Whittaker M-Function
 

Formula:

    Mq,p(a) = exp(-a/2)  ap+1/2  M( p-q+1/2 , 1+2p , a )               where  M = Kummer's functions
 

Data Registers:             R00 = n > 1             ( Registers R00 thru Rnn are to be initialized before executing "WHIMA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R3n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Y            q            /
           X            p         1.nnn

   where   1.nnn   is the control number of  the result

Example:      q = sqrt(2)   p = sqrt(3)    a = 0.4 + 0.5 i + 0.6 j + 0.7 k               ( quaternion ->  4  STO 00 )

    0.4  STO 01
    0.5  STO 02
    0.6  STO 03
    0.7  STO 04

     2   SQRT
     3   SQRT   XEQ "WHIMA"  >>>>  1.004                                           ---Execution time = 21s---

    R01 = -0.807065423
    R02 =  0.373202939
    R03 =  0.447843527
    R04 =  0.522484115

-So,  Mq,p(a) = -0.807065423 + 0.373202939 i + 0.447843527 j + 0.522484115 k
 

Anionic Whittaker W-Function
 

Formula:

  Wq,p(a) = [ Gam(2p) / Gam(p-q+1/2) ]  Mq,-p(a) + [ Gam(-2p) / Gam(-p-q+1/2) ]  Mq,p(a)   assuming  2p is not an integer.
 

Data Registers:             R00 = n > 1         ( Registers R00 thru Rnn are to be initialized before executing "WHIWA" )

                                        R01   ......    Rnn = the n components of the anion

                                         Rn+1 ..........  R4n:  temp      R4n+1 = p  ,  R4n+2 = q

  >>>  When the program stops:     R01   ......  Rnn = the n components of the result

Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           Y            q            /
           X            p         1.nnn

   where   2.p  is not an integer  &  1.nnn   is the control number of  the result

Example:      q = sqrt(2)    p = sqrt(3)    a = 0.4 + 0.5 i + 0.6 j + 0.7 k               ( quaternion ->  4  STO 00 )

    0.4  STO 01
    0.5  STO 02
    0.6  STO 03
    0.7  STO 04

     2   SQRT
     3   SQRT   XEQ "WHIWA"  >>>>  1.004                                           ---Execution time = 56s---

    R01 =  2.275449624
    R02 = -1.129250840
    R03 = -1.355101007
    R04 = -1.580951175

Whence,        Wq,p(a)  = 2.275449625 - 1.129250840 i - 1.355101008 j - 1.580951176 k

Note:

-"WHIWA" does not work if 2.p is an integer.
 

Anionic Riemann Zeta Function
 

-"ZETAA" employs the method given by P. Borwein in  "An Efficient Algorithm for the Riemann Zeta Function"  if  Re(a) >= 1/2
-If  Re(a) < 1/2, it uses:     Zeta(a) = Zeta(1-a)  Pi  a-1/2  Gamma((1-a)/2) / Gamma(a/2)
 
 

Data Registers:             R00 = n > 1                  ( Registers R00 thru Rnn are to be initialized before executing "ZETAA" )

                                        R01   ......    Rnn = the n components of the anion a

                                         Rn+1 ..........  R6n:  temp

  >>>  When the program stops:     R01   ......  Rnn = the n components of  f(a)

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.nnn

   where   1.nnn   is the control number of the result

Examples:                               a = -7.6 + 7.7 i + 7.8 j + 7.9 k                          ( Quaternion ->   4   STO 00 )

   7.6   CHS  STO 01
   7.7   STO 02
   7.8   STO 03
   7.9   STO 04

   XEQ "ZETAA"    >>>>    1.004                                      ---Execution time = 3m00s---

  R01 =  762.9852915
  R02 = -14.26823052
  R03 = -14.45353222
  R04 = -14.63883391

-Whence,      Zeta ( -7.6 + 7.7 i + 7.8 j + 7.9 k ) = 762.9852915 - 14.26823052 i - 14.45353222 j - 14.63883391 k
 

-Likewise,  Zeta( 1.1 + 7 i + 8 j + 9 k ) = 0.389296028 - 0.027737071 i - 0.031699509 j - 0.035661948 k          ( in 2m08s )
 

Inverse of a Bion
 
 

      "1/B"    inverse

         B-1 = B* / | B |2    where B* is the conjugate of  B   and   | B |2 = b02 + b12 + ................. + bN-12

-Note that here  | B |  may equal 0 even if b # 0 since the components bj are complexes !
-So, b # 0 may not have an inverse !
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "1/B" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:   With the biquaternion  b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08

      XEQ "1/B"  >>>  1.008    and we find in registers  R01 thru  R08:

       1/b = ( 0.2710 - 0.2285 i ) + ( -0.2115 + 0.1835 i ) e1 + ( -0.1521 + 0.1385 i ) e2 + ( -0.0927 + 0.0936 i ) e3             rounded to 4 decimals
 

Product of 2 Bions ( general case )
 

-This program employs the Cayley-Dickson formula recursively.
-Unfortunately, there are not enough registers for bi-64-ons.

-The 2n components of the 1st bion are to be sored into R01-R02 , R03-R04 , ............... , R2n-1-R2n   ( 2 real numbers for each bj )
-Likewise for the 2n components of the 2nd bion into  R2n+1-R2n+2 , ............................ , R4n-1-R4n   ( 2 real numbers for each b'j )

     b = b0 + b1 e1 + ............... + bn-1 en-1
    b' = b'0 + b'1 e1 + ............... + b'n-1 en-1
 

Data Registers:             R00 = 2n ( 4 , 8 , 16 , 32 or 64 )           ( Registers R00 thru R4n are to be initialized before executing "B*B" )

                                        R01   ......    R2n = the components of the 1st bi-ion
                                        R2n+1 ....    R4n = the components of the 2nd bi-ion

  >>>  When the program stops:     R01   ......  R2n = the 2n components of the product

-During the calculations,

    R01 to R04 = bicomplex1    R09 to R16 = biquaternion1  R25 to R40 = bioctonion1  R57 to R88 = bisedenion1     R121 to R184 = bi-32-on1
    R05 to R08 = bicomplex2    R17 to R24 = biquaternion2  R41 to R56 = bioctonion2  R89 to R120 = bisedenion2   R185 to R248 = bi-32-on2

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the result.

Example:   Find the product of the bisedenions:

  b = ( 25 + 108 i ) + ( 105 + 113 i ) e1 + ( 48 + 3 i ) e2 + ( 123 + 65 i ) e3 + ( 45 + 11 i ) e4 + ( 58 + 20 i ) e5 + ( 34 + 84 i ) e6 + ( 38 + 117 i ) e7
    + ( 81 + 46 i ) e8 + ( 52 + 36 i ) e9 + ( 35 + 125 i ) e10 + ( 16 + i ) e11 + ( 41 + 109 i ) e12 + ( 15 + 91 i ) e13 + ( 63 + 94 i ) e14 + ( 55 + 28 i ) e15

  b' = ( 100 + 39 i ) + ( 27 + 59 i ) e1 + ( 61 + 12 i ) e2 + ( 99 + 129 i ) e3 + ( 49 + 44 i ) e4 + ( 101 + 80 i ) e5 + ( 5 + 74 i ) e6 + ( 21 + 75 i ) e7
     + ( 62 + 53 i ) e8  + ( 77 + 13 i ) e9 + ( 9 + 107 i ) e10 + ( 64 + 4 i ) e11 + ( 33 + 43 i ) e12 + ( 60 + 102 i ) e13 + ( 121 + 114 i ) e14 + ( 89 + 112 i ) e15

-You can use the short routine below to store these coefficients into R01 thru R64
 
 
 01  1.064
 02  7
 03  LBL 01
 04  41 
 05  *
 06  131
 07  MOD
 08  STO IND Y
 09  ISG Y
 10  GTO 01
 11  RTN

-Bisedenions so n = 16 and 2n = 32  STO 00

-SIZE 121 at least

  XEQ "B*B"  >>>>  1.032             in about 6 minutes

-And we get   R01 = 22450  R02 = -93103  .......................  R31 = -14895  R32 = 36483

-Thus,

   b.b' = ( 22450 - 93103 i ) + ( -3665 + 12974 i ) e1 + ( 32291 - 31812 i ) e2 + ( 18482 + 29668 i ) e3 + ( -7840 + 8985 i ) e4 + ( 1001 + 48348 i ) e5
          + ( -10494 + 6090 i ) e6 + ( -1657 + 25709 i ) e7 + ( -14243 - 595 i ) e8  + ( 9295 + 1562 i ) e9 + ( -19125 + 35197 i ) e10 + ( 18449 - 20036 i ) e11
          + ( -3315 + 35478 i ) e12 + ( -22176 + 9676 i ) e13 + ( 11818 + 23190 i ) e14 + ( -14895 + 36483 i ) e15

Note:

-The product of 2 bi-32-ons should last about 24 minutes.
 

Product of 2 Bions ( special case )
 

-Fortunately, the formulas are much simpler if the 2 bi-ons have the same imaginary direction, I mean if, given  b & b'

     b = b0 + b1 e1 + ............... + bn-1 en-1
    b' = b'0 + b'1 e1 + ............... + b'n-1 en-1

  there exist a complex number c such that, for all  i > 0 ,  b'i = c bi  or  bi = c b'i

  B*B1 is useful in this case, it uses only 4n+1 registers and more important, the product is commutative.
 

Data Registers:             R00 = 2n > 3                           ( Registers R00 thru R4n are to be initialized before executing "B*B1" )

                                        R01   ......    R2n = the n components of the 1st bi-on
                                        R2n+1 ....    R4n = the n components of the 2nd bi-on

  >>>  When the program stops:     R01   ......  R2n = the n components of the product,   R2n+1  ........ R4n  are unchanged.

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the product.

Example:   Find the product of the biquaternions

  b = ( 6 - 9 i ) + ( -4 + 2 i ) e1 + ( -3 + i ) e2 + ( -4 + 7 i ) e3                            here,   Im(b') = ( 2 + 3i ) Im(b)
  b' = ( 4 + 7 i ) + ( -14 - 8 i ) e1 + ( -9 - 7 i ) e2 + ( -29 + 2 i ) e3

-> biquaternions, so  8  STO 00

-Store the coefficients into R01 thru R16

    6  STO 01   -9  STO 02   -4  STO 03   2  STO 04  ..........................  -29  STO 15    2  STO 16

    XEQ "B*B1"  >>>>  1.008

  R01 = -121    R02 = 201
  R03 = -186    R04 =  58
  R05 = -136    R06 =  22
  R07 = -221    R08 = 273

-Thus,  b b' = ( -121 + 201 i ) + ( -186 + 58 i ) e1 + ( -136 + 22 i ) e2 + ( -221 + 273 i ) e3

Notes:

-B*B1 does not check that the "imaginary parts" are proportional.
-The product of 2 bisedenions ( 2n = 32 ) lasts about 7 seconds
 

Bionic Real Power
 

      "B^X"  raising a bion to a real power         B^X = exp ( X Ln B )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "B^X" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             x         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3        x = 3.14

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      3.14  XEQ "B^X"  yields

      b^x = ( 4.0377 - 5.3510 i ) + ( -2.4135 + 2.5059 i ) e1 + ( -1.7284 + 1.8833 i ) e2 + ( -1.0433 + 1.2608 i ) e3          rounded to 4D
 

Bionic Complex Power
 

      "B^Z"  raising a bion to a complex power         B^Z = exp ( Z Ln B )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "B^Z" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           Y             y           /
           X             x         1.2n

   where   1.2n   is the control number of the result &  z = x + i.y

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3        z = 2 + 3 i

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

       3  ENTER^
       2  XEQ "B^Z"   gives:

     b^z = ( -0.4735 + 2.3593 i ) + ( -1.8006 - 0.3988 i ) e1 + ( -1.3296 - 0.2611 i ) e2 + ( -0.8587 - 0.1233 i ) e3          rounded to 4 D
 

Bionic Power of a Real
 

      "X^B         X^B = exp ( B Ln X )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "X^B" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             x         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3        x = 3.14

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8 STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      3.14  XEQ "X^B"  returns:

      x^b = ( 4.0060 - 0.4653 i ) + ( 0.9349 + 3.5690 i ) e1 + ( 0.7498 + 2.6050 i ) e2 + ( 0.5648 + 1.6409 i ) e3                rounded to 4 D
 

Bionic Power of a Complex
 

      "Z^B"  raising a bion to a complex power         Z^B = exp ( B Ln Z )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "Z^B" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           Y             y           /
           X             x         1.2n

   where   1.2n   is the control number of the result &  z = x + i.y

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3        z = 2 + 3 i

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

       3  ENTER^
       2  XEQ "Z^B"   gives:

     z^b = ( -0,6233 + 6,9092 i ) + ( -5,1426 - 0,4513 i ) e1 + ( -3,7853 - 0,2404 i ) e2 + ( -2,4280 - 0,0296 i ) e3          rounded to 4 D
 

Bionic Self-Power Function
 

      "B^"B         B^B = exp ( B Ln B )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "B^B" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "B^B"  returns:

      b^b = ( 1,6384 - 0,4640 i ) + ( 0,3682 + 1,2384 i ) e1 + ( 0,2924 + 0,9031 i ) e2 + ( 0,2165 + 0,5678 i ) e3                rounded to 4 D

Notes:

-We can also calculate  b^b'  = exp ( b' Ln b )  or  exp ( ( Ln b ) b' )     ( the 2 results are usually different )
-But in both cases, the product  b' ( Ln b )  must be computed with  "B*B"  instead of  B*B1
 

Exponential of a Bion
 

      "E^B"   exponential

        exp( b0 + b1 e1 + .... + bN-1 bN-1 ) = eb0 [ cos µ + ( sin µ ). I ]

       where  µ = ( b12 + ............... + bN-12 )1/2    and    I = ( b1 e1 + ............. + bN-1 eN-1 ) / µ
 
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "E^B" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

       XEQ "E^B"   gives

       exp(b) = ( 3.1095 - 0.0905 i ) + ( 0.7810 + 2.6836 i ) e1 + ( 0.6211 + 1.9573 i ) e2 + ( 0.4613 + 1.2310 i ) e3             rounded to 4 D
 

Logarithm of a Bion
 

      "LNB"  natural logarithm

       Ln( b0 + b1 e1 + .... + bN-1 bN-1 )   = Ln ( b02 + b12 + ................. + bN-12 )1/2 + A(µ,b0). I

       where  µ = ( b12 + ............... + bN-12 )1/2    and    I = ( b1 e1 + ............. + bN-1 eN-1 ) / µ

>>> Here,  A(µ,b0) generalizes the ATAN2 function to complexes:

-We have to solve  Sin Z = µ / ( µ2 + b02 )1/2  ,  Cos Z = b0 / ( µ2 + b02 )1/2

  it yields  Z = A(µ,b0) = - i Ln ( b0 + i µ ) / ( µ2 + b02 )1/2

>>>  If µ = 0  and  Im(b) # 0 ,  Ln b = Ln b0 + ( b1 e1 + ............. + bN-1 eN-1 ) / b0    ( if  b0 = 0 , Ln b  does not exist )
>>>  If µ = 0  and  Im(b) = 0 ,  Ln b = Ln b0
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 or 256 )    ( Registers R00 thru R2n are to be initialized before executing "LNB" )

                                        R01   ......    R2n = the components of the bi-on

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

       XEQ "LNB"   returns

       Ln (b) = ( 0.6669 + 0.7167 i ) + ( 0.6100 - 0.0013 i ) e1 + ( 0.4480 - 0.0118 i ) e2 + ( 0.2860 - 0.0222 i ) e3              rounded to 4 D
 

Hyperbolic Sine of a Bion
 

      "SHB"  hyperbolic sine

        Sinh b = ( exp(b) - exp(-b) ) / 2
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "SHB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "SHB"   returns

      Sinh b = ( 1.6085 + 0.1583 i ) + ( 0.5553 + 1.2491 i ) e1 + ( 0.4300 + 0.9076 i ) e2 + ( 0.3047 + 0.5662 i ) e3             rounded to 4 D
 

Hyperbolic Cosine of a Bion
 

      "CHB"  hyperbolic cosine

        Cosh b = ( exp(b) + exp(-b) ) / 2
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "CHB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05  0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "CHB"   yields

      Cosh b = ( 1.5010 - 0.2488 i ) + ( 0.2256 + 1.4345 i ) e1 + ( 0.1911 + 1.0497 i ) e2 + ( 0.1566 + 0.6648 i ) e3             rounded to 4 D
 

Hyperbolic Tangent of a Bion
 

      "THB"  hyperbolic tangent

          Tanh b = ( exp(2b) - 1 ) ( exp(2b) + 1 ) -1
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "THB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "THB"   yields

      Tanh b = ( 0.7548 - 1.1142 i ) + ( -0.8316 + 0.1404 i ) e1 + ( -0.6083 + 0.1179 i ) e2 + ( -0.3851 + 0.0953 i ) e3          rounded to 4 D
 

Inverse Hyperbolic Sine of a Bion
 

      "ASHB"  arc sinh b = Ln [ b + ( b2 + 1 )1/2 ]
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "ASHB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "ASHB"   yields

      Asinh b = ( 1.3553 + 0.7183 i ) + ( 0.6025 + 0.0482 i ) e1 + ( 0.4434 + 0.0247 i ) e2 + ( 0.2843 + 0.0013 i ) e3          rounded to 4 D
 

Inverse Hyperbolic Cosine of a Bion
 

      "ACHB"  arc cosh b = Ln [ b + ( b2 - 1 )1/2 ]
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "ACHB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "ACHB"   yields

      Acosh b = ( 1.3521 + 0.7113 i ) + ( 0.6185 - 0.0512 i ) e1 + ( 0.4534 - 0.0485 i ) e2 + ( 0.2883 - 0.0459 i ) e3          rounded to 4 D

Note:

-The standard definition of  Arc Cosh b is  Ln [ b + ( b + 1 )1/2 ( b - 1 )1/2 ]
-So the results given by ACHB may require a sign change to get the principal value
 

Inverse Hyperbolic Tangent of a Bion
 

      "ATHB"   arc tanh b = (1/2) [ Ln ( 1 + b ) - Ln ( 1 - b ) ]
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "ATHB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "ATHB"   yields

      Atanh b = ( 0.2955 - 0.2011 i ) + ( 0.9797 + 0.2256 i ) e1 + ( 0.7236 + 0.1484 i ) e2 + ( 0.4675 + 0.0711 i ) e3          rounded to 4 D
 

Sine of a Bion
 

      "SINB"   sine

          Sin b = ( exp(i.b) - exp(-i.b) ) / 2.i
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "SINB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "SINB"   yields

      Sin b = ( 0.6434 + 1.7921 i ) + ( 1.3025 + 0.2589 i ) e1 + ( 0.9613 + 0.1671 i ) e2 + ( 0.6201 + 0.0753 i ) e3             rounded to 4 D
 

Cosine of a Bion
 

      "COSB"  cosine

          Cos b = ( exp(i.b) + exp(-i.b) ) / 2
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "COSB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "COSB"   yields

      Cos b = ( 1.6624 - 0.0748 i ) + ( -0.1571 - 1.5114 i ) e1 + ( -0.1421 - 1.1074 i ) e2 + ( -0.1272 - 0.7033 i ) e3          rounded to 4 D
 
 

Tangent of a Bion
 

      "TANB"    Tan b = - i Tanh ( i.b )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "TANB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "TANB"   returns

      Tan b = ( -1.0993 - 0.1510 i ) + ( 0.8538 - 0.8196 i ) e1 + ( 0.6127 - 0.6171 i ) e2 + ( 0.3715 - 0.4146 i ) e3             rounded to 4 D
 

Inverse Sine of a Bion
 

      "ASINB"    arc sin b

          Arc Sin b     = - i  Arc Sinh ( i.b )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "ASINB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "ASINB"   returns

      Asin b = ( 0.7517 + 0.0817 i ) + ( 1.0103 + 0.5534 i ) e1 + ( 0.7519 + 0.3886 i ) e2 + ( 0.4935 + 0.2238 i ) e3          rounded to 4 D
 

Inverse Cosine of a Bion
 

      "ACOSB"  arc cos b

          Arc Cos b = PI/2 - Arc Sin b
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "ACOSB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "ACOSB"   returns

      Acos b = ( 0.8191 - 0.0817 i ) + ( -1.0103 - 0.5534 i ) e1 + ( -0.7519 - 0.3886 i ) e2 + ( -0.4935 - 0.2238 i ) e3          rounded to 4 D
 

Inverse Tangent of a Bion
 

      "ATANB"  arc tan b

          Arc Tan b     = - i  Arc Tanh ( i.b )
 

Data Registers:             R00 = 2n ( 4 , 8 , .... , 128 )      ( Registers R00 thru R2n are to be initialized before executing "ATANB" )

                                        R01   ......    R2n = the components of the bi-on
                                         R2n+1 ......    R4n:  temp

  >>>  When the program stops:     R01   ......  R2n = the components of the result

Flags:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /         1.2n

   where   1.2n   is the control number of the result.

Example:    b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3

>>>  Biquaternion, so   2n = 8  STO 00

>>>  1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08
 

      XEQ "ATANB"   returns

      Atan b = ( -0.2551 + 0.2588 i ) + ( 0.2065 + 1.0188 i ) e1 + ( 0.1697 + 0.7447 i ) e2 + ( 0.1329 + 0.4705 i ) e3          rounded to 4 D
 

Bionic Polynomials
 

BPVAL  evaluates  p(b) = cm bm + cm-1 bm-1 + ................ + c1 b + c0    for  a given bion b  and  (m+1) complex numbers  cm , .............. , c1 , c0
 

-Store the bion b in registers  R01 thru R2n  as usual, and the coefficients of the polynomial in Rbb thru Ree  with  bb > 4n
 

Data Registers:             R00 = 2n > 3            ( Registers R00 thru R2n & Rbb thru Ree are to be initialized before executing "BPVAL" )

                                        R01   ......    R2n = b
                                         Rn+1 ........   R4n = b   ( b is saved in R2n+1 thru R4n )

                                        Rbb = Re(cm) ,    Rb+1 = Im(cm) , ................. ,   Ree-1 = Re(c0)     Ree = Im(c0)

  >>>  When the program stops:     R01   ......  R2n = the n components of p(b)

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X        bbb.eee         1.2n

   where  bbb.eee  is the control number of the polynomial    ( bbb > 4n )

Example:     b = ( 1 + 2 i ) + ( 3 + 4 i ) e1 + ( 5 + 6 i ) e2 + ( 7 + 8 i ) e3                        ( biquaternion  ->  8  STO 00 )

  and     p(b) = ( 2 + 3 i ) b4 + ( 4 - 7 i ) b3 + ( 3 - 5 i ) a2 + ( 1 + 4 i ) a + ( 6 + 2 i )

   1  STO 01   2  STO 02   3  STO 03  ...............................  8  STO 08

-If you choose  bb = 21

   2  STO 21  3  STO 22   4  STO 23   -7  STO 24   3  STO 25   -5  STO 26   1  STO 27   4  STO 28   6  STO 29   2  STO 30

-Control number =  21.030

    21.030   XEQ "BPVAL"  >>>>   1.008                                    ---Execution time = 11s---

    and you get in registers R01 thru R08

  p(b) = ( -39087 - 128086 i ) + ( -863 + 23966 i ) e1 + ( 571 + 37456 i ) e2 + ( 2005 + 50946 i ) e3
 

Bionic Legendre Polynomials
 

Formulae:

    m.Pm(b) = (2m-1).b.Pm-1(b) - (m-1).Pm-2(b)  ,  P0(b) = 1  ,  P1(b) = b
 
 

Data Registers:             R00 = 2n > 3                          ( Registers R00 thru R2n are to be initialized before executing "LEGB" )

                                        R01   ......    R2n = the n components of the bion b which are saved in registers  R2n+1 to R4n

                                         R4n+1 ........  R6n =  Pm(b)
                                         R6n+1 ........  R8n = Pm-1(b)

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flags: /
 
 
      STACK        INPUT      OUTPUT
           X             m         1.2n

   where      m is an integer    ( 0 <= m < 1000 )
     and       1.2n  is the control number of the result

Example:         m = 7       b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

       7   XEQ "LEGB"  >>>>   1.008                                    ---Execution time = 37s---

And we get in registers R01 thru R08

      P7(b) =  ( -240.8232644 + 180.2220151 i )  +  ( -8.4974508 + 82.1615056 i ) e1
                                                                            + ( -6.6831028 + 128.8517448 i ) e2 + ( -4.8687548 + 175.541984 i ) e3
 

Bionic Laguerre's Polynomials
 

Formulae:

      L0(a) (b) = 1  ,   L1(a) (b) = a+1-b   ,    m Lm(a) (b) = (2.m+a-1-b) Lm-1(a) (b) - (m+a-1) Lm-2(a) (b)
 

Data Registers:             R00 = 2n > 3                ( Registers R00 thru R2n are to be initialized before executing "LANB" )

                                        R01   ......    R2n = the n components of the bion b which are saved in registers  R2n+1 to R4n

                                         R4n+1 ........  R6n = Lm(b)
                                         R6n+1 ........  R8n = Lm-1(b)

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flags: /
 
 
      STACK        INPUT      OUTPUT
           Y             a           /
           X             m         1.2n

   where      m is an integer    ( 0 <= m < 1000 ) ,  a  is a real number
     and        1.2n  is the control number of the result

Example:     a = sqrt(2)    m = 7       b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3           ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

       2   SQRT
       7   XEQ "LANB"  >>>>   1.008                                    ---Execution time = 39s---

And we get in registers R01 thru R08

      L7sqrt(2) (b) =  ( -5.035303539 - 80.93462041 i )  + ( -27.58137526 - 1.567289524 i ) e1
                                                                                   + ( -43.15232859 - 0.238461640 i ) e2 + ( -58.72328181 + 1.090366269 i ) e3
 

Bionic Associated Legendre Functions ( Integer order & degree )
 

"PMNB" compute the functions of type 2 - if CF 03 - or the functions of type 3 - if  SF 03.
 

Formulae:        (n-m) Pnm(b) = b (2n-1) Pn-1m(b) - (n+m-1) Pn-2m(b)

     Type 2                Pmm(b) = (-1)m (2m-1)!!  ( 1-b2 )m/2                    where (2m-1)!! = (2m-1)(2m-3)(2m-5).......5.3.1
     Type 3                Pmm(b) =   (2m-1)!!  ( b2-1 )m/2
 

Data Registers:             R00 = 2n > 3                                    ( Registers R00 thru R2n are to be initialized before executing "PMNB" )

                                        R01   ......    R2n = the n components of the bion b which are saved in registers  R2n+1 to R4n

                                         R4n+1 ........  R6n =  Pnm (b)
                                         R6n+1 ........  R8n = Pn-1m (b)

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flags: /
 
 
      STACK        INPUTS      OUTPUTS
           Y            m            /
           X            n          1.2n

   where     m & n are integers with   0 <= m <= n
     and      1.2n   is the control number of the result.

Example:      m = 3  ,  n = 7  ,   b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3            ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

    CF 03   Legendre Function of type 2

    3   ENTER^
    7   XEQ "PMNB"  >>>>  1.008                               ---Execution time = 48s---

And we have in R01 thru R08

     P37 ( b ) = ( 6071.566263 + 53115.31993 i )  + ( 17513.35572 - 15006.54081 i ) e1
                                                                            + ( 26120.31168 - 24811.27212 i ) e2 + ( 34727.26763 - 34016.00343 i ) e3

    SF 03   Legendre Function of type 3

-Store again        0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

    3   ENTER^
    7   XEQ "PMNB"  >>>>  1.008                               ---Execution time = 48s---

And we have in R01 thru R08

     P37 ( b ) = ( -46823.11240 + 45127.54828 i )  + ( 1048.341587 + 18931.32096 i ) e1
                                                                            + ( -3149.918553 + 29448.99338 i ) e2 + ( 5251.495520 + 39966.66578 i ) e3

Note:

-This program does not check if m & n are integers that satisfy 0 <= m <= n
 
 

Bionic Associated Legendre Functions
 

 "ALFB" computes 4 kinds of associated Legendre functions:

-If  CF 02  &  CF 03   we get the associated Legendre function of the 1st kind, type 2
-If  CF 02  &  SF 03    -------------------------------------------------------, type 3

-If  SF 02   &  CF 03   we get the associated Legendre function of the 2nd kind, type 2
-If  SF 02   &  SF 03    --------------------------------------------------------, type 3
 

Formulae:    1st Kind
 

  Type 2      Prm(b) = [ (b+1)/(1-b) ]m/2  2F1(-r , r+1 ; 1-m ; (1-b)/2 ) / Gamma(1-m)        (  b # 1 )

  Type 3      Prm(a) = [ (b+1)/(b-1) ]m/2  2F1(-r , r+1 ; 1-m ; (1-b)/2 ) / Gamma(1-m)        (  b # 1 )
 

Formulae:    2nd Kind
 

  Type 2      Qrm(b) = 2m pi1/2  (1-b2)-m/2 [ -Gam((1+m+r)/2)/(2.Gam((2-m+r)/2)) . sin pi(m+r)/2 .  2F1(-r/2-m/2 ; 1/2+r/2-m/2 ; 1/2 ; b2 )
                                                                + b  Gam((2+r+m)/2) / Gam((1+r-m)/2) . cos pi(m+r)/2 . 2F1((1-m-r)/2 ; (2+r-m)/2 ; 3/2 ; b2 )  ]

  Type 3        Qrm(b) =  exp( i (m.PI) ) 2 -r-1 sqrt(PI) Gam(m+r+1) b -m-r-1 (b2-1)m/2  2F~1( (2+m+r)/2 , (1+m+r)/2 ; r+3/2 ; 1/b2 )
 
 

Data Registers:             R00 = 2n > 3                          ( Registers R00 thru R2n are to be initialized before executing "ALFB" )

                                        R01   ......    R2n = the n components of the bion

                                         R2n+1 ..........  R8n+1:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result
 

Flags:  F00-F02-F03-F04
 
 
      STACK        INPUTS      OUTPUTS
           T             m2            /
           Z             m1            /
           Y             r2            /
           X             r1          1.2n

   where        m = m1 + i m2  ,   r = r1 + i r2
     and         1.2n   is the control number of the result.

Example1:     Associated Legendre functions of the 1st kind     CF 02
 

    CF 02   CF 03   Legendre Function 1st kind - type 2

      m = 1 + 2 i  ,  r = 3 + 4 i   ,     b = ( 1.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( -0.1 - 0.2 i ) e2 + ( -0.3 - 0.4 i ) e3                 ( biquaternion ->  8  STO 00 )

      1.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   -0.1  STO 05   -0.2  STO6   -0.3  STO 07   -0.4  STO 08

       2  ENTER^
       1  ENTER^
       4  ENTER^
       3  XEQ "ALFB"   >>>>   1.008                               ---Execution time = 3m20s---

And we get in R01 thru R08:

>>>     Prm(b) = ( 93.10375827 - 105.0475329 i )  + ( 75.56897030 + 91.98871978 i ) e1
                                                                                + ( -25.89125060 - 46.52055450 i ) e2 + ( -75.56897030 - 91.98871978 i ) e3

  m # 1 , 2 , 3 , ..........  &  b # 1
 

    CF 02  SF 03   Legendre Function 1st kind - type 3

      m = 1 + 2 i  ,  r = 3 + 4 i   ,    b = ( 1.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( -0.1 - 0.2 i ) e2 + ( -0.3 - 0.4 i ) e3                 ( biquaternion ->  8  STO 00 )

      1.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   -0.1  STO 05   -0.2  STO 06   -0.3  STO 07   -0.4  STO 08

       2  ENTER^
       1  ENTER^
       4  ENTER^
       3  XEQ "ALFB"   >>>>   1.008                               ---Execution time = 3m20s---

And we get in R01 thru R08:

>>>     Prm(b) = ( 57.14529218 + 522.8336887 i )  + ( 346.1203815 - 37.93305238 i ) e1
                                                                              + ( -155.3276123 - 10.99908747 i ) e2 + ( -346.1203815 + 37.93305238 i ) e3
 

  m # 1 , 2 , 3 , ..........  &  b # 1
 

Example2:        Associated Legendre functions of the 2nd kind    SF 02

    SF 02   CF 03   Legendre Function 2nd kind - type 2

    m = 0.2 + 0.3 i  ,  r = 1.4 + 1.6 i   ,    b = ( 0.05 + 0.1 i ) + ( 0.15 + 0.2 i ) e1 + ( 0.25 + 0.3 i ) e2 + ( 0.35 + 0.4 i ) e3          ( biquaternion ->  8  STO 00 )

      0.05  STO 01   0.1  STO 02   0.15  STO 03   0.2  STO 04   0.25  STO 05   0.3  STO6   0.35  STO 07   0.4  STO 08

      0.3   ENTER^
      0.2   ENTER^
      1.6   ENTER^
      1.4   XEQ "ALFB"   >>>>   1.008                               ---Execution time = 8m06s---

And we get in R01 thru R08:

    Qrm(b) = ( -0.537350197 - 1.483228607 i )  + ( 1.318605388 - 1.639974390 i ) e1
                                                                          + ( 1.925826457 - 2.663848476 i ) e2 + ( 2.533047525 - 3.687722566 i ) e3

    SF 02   SF 03   Legendre Function 2nd kind - type 3

   m = 1.2 + 1.3 i  ,  r = 1.4 + 1.5  ,     b = ( 1.1 + 1.2 i ) + ( 1.3 + 1.4 i ) e1 + ( 1.5 + 1.6 i ) e2 + ( 1.7 + 1.8 i ) e3               ( biquaternion ->  8  STO 00 )

      1.1  STO 01   1.2  STO 02   1.3  STO 03   1.4  STO 04   1.5  STO 05   1.6  STO 06   1.7  STO 07   1.8  STO 08

    1.3  ENTER^
    1.2  ENTER^
    1.5  ENTER^
    1.4  XEQ "ALFB"  >>>>     1.008                               ---Execution time = 2m03s---

And we get in R01 thru R08:

    Qrm(b) = ( 0.094724134 + 0.042366477 i )  + ( 0.021457752 - 0.047321593 i ) e1
                                                                          + ( 0.024373027 - 0.054440173 i ) e2 + ( 0.027288302 - 0.061558753 i ) e3

>>>  We must have  r + 3/2 # 0 , 1 , 2 , ....................
 

Bionic Bessel Functions
 

- "BSLB" computes the Bessel functions of the 1st kind if flag  F02 is clear and the Bessel functions of the 2nd kind if flag  F02  is set.

-Set flag  F03  to get the modified  Bessel functions .
 

Formulae:
 

  Bessel Functions of the 1st kind

       Jm(b) = (b/2)m [ 1/Gam(m+1)  +  (-b2/4)1/ (1! Gam(m+2) )  + .... + (-b2/4)k/ (k! Gam(m+k+1) ) + ....  ]      m # -1 ; -2 ; -3 ; ....

  Modified Bessel Functions of the 1st kind

       Im(b) = (b/2)m [ 1/Gam(m+1)  +  (b2/4)1/ (1! Gam(m+2) )  + .... + (b2/4)k/ (k! Gam(m+k+1) ) + ....  ]          m # -1 ; -2 ; -3 ; ....

  Bessel Functions & Modified Bessel Functions of the 2nd kind - non-integer order

        Ym(b) = ( Jm(b) cos(m(pi)) - J-m(b) ) / sin(m(pi))      ;      Km(b) = (pi/2) ( I-m(b) - Im(b) ) / sin(m(pi))           m # .... -3 ; -2 ; -1 ; 0 ; 1 ; 2 ; 3 ....
 

>>> Here, m may be a complex number p + i.q.
 
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "BSLB" )

                                        R01   ......    R2n = the n components of the anion

                                         R2n+1 ..........  R6n:  temp    ( R6n+1 to R8n are also used for the functions of the second kind )

  >>>  When the program stops:     R01   ......  R2n = the n components of the result
 

Flags:  F02-F03
 
 
      STACK        INPUT      OUTPUT
           Y            q            /
           X             p          1.2n

   where  1.2n  is the control number of  Bp+i.q (b)

   B = J   if  CF 03   CF 02        B = Y   if  CF 03   SF 02
   B = I   if  SF 03    CF 02        B = K  if   SF 03   SF 02

Example:           b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

    With  m = 2 + 3.i     CF 03   CF 02    JNB

      3  ENTER^
      2  XEQ "BSLB"  >>>>   1.008                                             ---Execution time = 56s---

-And we get in R01 thru R08:

    J2+3.i (b) = ( 1.761978801 + 2.178620406 i ) + ( -0.807601648 + 0.577907527 i )  e1
                                                                            + ( -1.213625969 + 0.966143875 i ) e2 + ( -1.619650291 + 1.354380222 ) e3

    With  m = 2 + 3.i     SF 03   SF 02    KNB

      3  ENTER^
      2  XEQ "BSLB"  >>>>   1.008                                             ---Execution time = 121s---

-And we get in R01 thru R08:

    K2+3.i (b) = ( 14.38068939 - 63.26852081 i ) + ( -22.09224564 - 6.403916002 i )  e1
                                                                            + ( -34.97621648 - 8.222729323 i ) e2 + ( -47.86018735 - 10.04154263 ) e3
 

-Likewise,  SF 03  CF 02  to calculate the modified Bessel functions of the 1st kind  INB
 

Notes:

-For the functions of the second kind  ( Y & K ) , m must not be an integer.
-"BSLB"  does not work if m is a negative integer, but we can employ the relations:

      Jm  =  (-1)m  J-m                         Im  =  I-m

-SIZE 6n+1 is enough for the functions of the 1st kind.
-The functions of the 2nd kind require SIZE 8n+1.
 

Bionic Cosine Integral
 

  "CIB"      Ci(b)  = C + Ln(b) + Summ=1,2,..... (-1)m b2m/(2m.(2m)!)         if  flag  F01  is clear                where  C = 0.5772156649... = Euler's constant.
                 Chi(b)= C + Ln(b) + Summ=1,2,.....         b2m/(2m.(2m)!)           if  flag  F01  is set
 
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "CIB" )

                                        R01   ......    R2n = the n components of the anion

                                         Rn+1 ..........  R6n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result
 

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X            /          1.2n

   where  1.2n  is the control number of the result.

Example:           b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08
 

    CF 01   XEQ "CIB"  >>>>   1.008                                  ---Execution time = 36s---

     Ci(b) = ( 0.822497127 + 1.344232914 i ) + ( 0.534656969 - 0.027912750 i )  e1
                                                                         + ( 0.831831852 - 0.086316448 i ) e2 + ( 1.129006736 - 0.144720145 ) e3
 

    SF 01   XEQ "CIB"  >>>>   1.008                                  ---Execution time = 36s---

     Chi(b) = ( 0.971855407 + 0.386658442 i ) + ( 0.485436524 + 0.071260700 i )  e1
                                                                         + ( 0.762981834 + 0.072331770 i ) e2 + ( 1.040527144 + 0.073402840 ) e3
 

Bionic Exponential Integral Ei
 

  "EIB"       Ei(b)  = C + Ln(b) + Sumn=1,2,.....  bn/(n.n!)                where  C = 0.5772156649... = Euler's constant.
 
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "EIB" )

                                       R01   ......    R2n = the n components of the anion

                                         Rn+1 ..........  R6n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result
 

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the result.

Example:           b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

    XEQ "EIB"  >>>>   1.008                                               ---Execution time = 52s---

     Ei(b) = ( 1.140687091 + 0.557945078 i ) + ( 0.829134747 + 0.443634358 i )  e1
                                                                         + ( 1.328940953 + 0.625738819 i ) e2 + ( 1.828747160 + 0.808843279 ) e3
 

Bionic Gamma Function
 

Formula:
 

    Gam(b) =  exp [ (b-1/2) Ln b + Ln (2.PI)1/2  - b + ( 1/12 )/( b + ( 1/30 )/( b + ( 53/210)/( b + (195/371)/( b + ...  )))) ]
 

-The relation   Gam(b+1) = b Gam(b)  is used recursively if Re(b) < 5  until   Re(b+1+.......+1)  > 5
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "GAMB" )

                                        R01   ......    R2n = the n components of the bion

                                         R2n+1 ..........  R8n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flag:  F10
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the result.

Example:         b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08
 

    XEQ "GAMB"  >>>>   1.008                                 ---Execution time = 70s---

And we find in registers R01 thru R08

   Gam(b) = ( 0.258452256 + 0.166123162 i ) + ( 0.014416808 + 0.150189863 i )  e1
                                                                         + ( 0.034505408 + 0.233142842 i ) e2 + ( 0.054594009 + 0.316095822 ) e3
 

Bionic Sine Integral
 

 "SIB"  calculates
 

  "SIB"       Si(b)  = Summ=0,1,2,..... (-1)m b2m+1/((2m+1).(2m+1)!)           if  flag  F01  is clear
                 Shi(b) = Summ=0,1,2,.....  b2m+1/((2m+1).(2m+1)!)                   if  flag  F01  is set
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "SIB" )

                                        R01   ......    R2n = the n components of the anion

                                         Rn+1 ..........  R6n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flag:  F01
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the result.

Example:           b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08
 

    CF 01   XEQ "SIB"  >>>>   1.008                                  ---Execution time = 25s---

     Si(b) = ( 0.029007647 + 0.214825821 i ) + ( 0.254033031 + 0.422973668 i )  e1
                                                                         + ( 0.430129422 + 0.639516280 i ) e2 + ( 0.606225812 + 0.856058892 ) e3
 

    SF 01   XEQ "SIB"  >>>>   1.008                                   ---Execution time = 25s---

     Shi(b) = ( 0.168831684 + 0.171286637 i ) + ( 0.343698222 + 0.372373658 i )  e1
                                                                         + ( 0.565959119 + 0.553407049 i ) e2 + ( 0.788220016 + 0.734440440 ) e3
 

Bionic Digamma Function
 

Formula:                 Psi(b) ~ Ln b - 1/(2b) -1/(12b2) + 1/(120b4) - 1/(252b6) + 1/(240b8)    is used if  Re(b) > 8

                                 Psi(b+1) = Psi(b) + 1/b    is used recursively until  Re(b+1+....+1) > 8
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "PSIB" )

                                        R01   ......    R2n = the n components of the bion

                                         R2n+1 ..........  R8n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flag:  F10
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the result.

Example:         b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08
 

   XEQ "PSIB"  >>>>   1.008                                 ---Execution time = 82s---

And the result is in registers R01 thru R08

   Psi(b) = ( 0.300919280 + 0.872730291 i ) + ( 0.587618165 - 0.077794679 i )  e1
                                                                       + ( 0.910460763 - 0.168369153 i ) e2 + ( 1.233303362 - 0.258943626 ) e3
 

Bionic Polygamma Functions
 

Formulae:
 

     If m > 0  ,  y(m)(b)  ~  (-1)m-1 [ (m-1)! / bm + m! / (2.bm+1) + SUMk=1,2,.... B2k (2k+m-1)! / (2k)! / b2k+m       where  B2k are Bernoulli numbers

     If m = 0  ,  y (b)  ~  Ln b - 1/(2b) - SUMk=1,2,.... B2k / (2k) / b2k              ( digamma function )

-So, the digamma function may be computed with "PSINB" too.
 

 and the recurrence relation:   y(m) (a+p) = y(m) (a) + (-1)m m! [ 1/am+1 + ....... + 1/(a+p-1)m+1 ]          where  p  is a positive integer
 

Data Registers:             R00 = 2n > 3         ( Registers R00 thru R2n are to be initialized before executing "PSINB" )

                                        R01   ......    R2n = the n components of the bion

                                         R2n+1 ..........  R8n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flag:  F10
 
 
      STACK        INPUT      OUTPUT
           X             m          1.2n

   where  m is a non-negative integer &  1.2n  is the control number of the result.

Example:         b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       and  m = 3

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

       3  XEQ "PSINB"  >>>>   1.008                 ---Execution time = 4m15s---

  R01 thru R08 give:

  Psi(3) (b) = ( 0.349772968 + 0.790426124 i ) + ( -0.281836208 - 0.432414490 i )  e1
                                                                         + ( -0.474257644 - 0.652019709 i ) e2 + ( -0.666679081 - 0.871624929 ) e3

Note:

  0  XEQ "PSINB"  is another way to calculate the digamma function, though it will be slower ( 3m04s instead of 82 seconds in the example above )
 

Bionic Error Function
 

Formula:     erf b  = (2/pi1/2)  SUMn=0,1,2,.....  (-1)n b2n+1 / (n! (2n+1))
 

Data Registers:             R00 = 2n > 3                  ( Registers R00 thru R2n are to be initialized before executing "ERFB" )

                                        R01   ......    R2n = the n components of the bion

                                         Rn+1 ..........  R6n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flags:  /
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of the result.

Example:         b = ( 1 + 0.9 i ) + ( 0.8 + 0.7 i ) e1 + ( 0.6 + 0.5 i ) e2 + ( 0.4 + 0.3 i ) e3                 ( biquaternion ->  8  STO 00 )

      1  STO 01   0.9  STO 02   0.8  STO 03   0.7  STO 04   0.6  STO 05   0.5  STO 06   0.4  STO 07   0.3  STO 08

      XEQ "ERFB"  >>>>   1.008                              ---Execution time = 79s---

      R01 thru R08  yields:

      Erf(b) = ( 2.952728868 + 8.149265562 i ) + ( 6.172244022 - 1.372589195 i )  e1
                                                                         + ( 4.509301553 - 1.117428240 i ) e2 + ( 2.846359083 - 0.862267287 ) e3
 

Bionic Lambert W-Function
 

-We solve  b = w(b) exp [ w(b) ]
-"LBWB" employs Newton's method.
 
 

Data Registers:             R00 = 2n > 3              ( Registers R00 thru R2n are to be initialized before executing "LBWB" )

                                        R01   ......    R2n = the n components of the bion

                                         R2n+1 ..........  R8n:  temp

  >>>  When the program stops:     R01   ......  R2n = the n components of the result

Flag:  /
 
 
      STACK        INPUT      OUTPUT
           X             /          1.2n

   where  1.2n  is the control number of  the result

Example:           b = ( 0.1 + 0.2 i ) + ( 0.3 + 0.4 i ) e1 + ( 0.5 + 0.6 i ) e2 + ( 0.7 + 0.8 i ) e3                 ( biquaternion ->  8  STO 00 )

       0.1  STO 01   0.2  STO 02   0.3  STO 03   0.4  STO 04   0.5  STO 05   0.6  STO 06   0.7  STO 07   0.8  STO 08

      XEQ "LBWB"  >>>>   1.008                                             ---Execution time = 121s---

And in registers R01 thru R08:

     W (b) = ( 0.494380927 + 0.401088979 i ) + ( 0.217079229 + 0.074534310 i ) e1
                                                                        + ( 0.344606343 + 0.098907186 i ) e2 + ( 0.472133456 + 0.123280061 i ) e3
 

Notes:

-This routine does not work for b = -1, we have  W(-1) = -0.3181315052 + 1.337235701 i
-Even in the neighborhood of -1 , the 1st approximation ( Ln(1+b) , cf line 06 ) is not a very good one !
-COPY this program and change lines 04-05-06 if you prefer a better guess.
 

Euler's Gamma Constant
 
 

-GEU is an M-code routine that simply returns  0.5772156649  in register X.
 
 

Inverse of the Gamma Function ( real arguments )
 

-The following asymptotic expansion is used:

    Gam(x) = [ x^(x-1/2) ] sqrt(2.Pi) exp [ -x + ( 1/12 )/( x + ( 1/30 )/( x + ( 53/210)/( x + (195/371)/( x + ...  )))) ]

  with the relation:  Gam(x+n) = (x+n-1) (x+n-2) ...... (x+1) x Gam(x)   until  x+n > 5
 
 
      STACK        INPUT      OUTPUT
           X             x       1/Gam(x)
           L             /            x

  PI   XEQ "1/G"  >>>  1/Gam(Pi) = 0.437055717
 

Inverse of a Complex
 
 
 
      STACK        INPUT      OUTPUT
           Y             y            Y
           X             x            X
           L             /            x

  Where  X + i Y = 1 / ( x + i y )
 

Product of 2 Complexes
 
 
 
      STACK        INPUT      OUTPUT
           T             y'            y'
           Z             x'            x'
           Y             y            Y
           X             x            X
           L             /            x

  Where  X + i Y = ( x + i y ) ( x' + i y' )
 

Quotient of 2 Complexes
 
 
 
      STACK        INPUT      OUTPUT
           T             y'            y'
           Z             x'            x'
           Y             y            Y
           X             x            X
           L             /            x

  Where  X + i Y = ( x' + i y' ) / ( x + i y )
 

Square of a Complex
 
 
 
      STACK        INPUT      OUTPUT
           Y             y            Y
           X             x            X
           L             /            x

  Where  X + i Y = ( x + i y )^2
 

Square-Root of a Complex
 
 
 
      STACK        INPUT      OUTPUT
           Y             y            Y
           X             x            X
           L             /            x

  Where  X + i Y = ( x + i y )^(1/2)
 

Gamma Function in the Complex Plane
 

Data Registers: /
Flags: /
 
 
      STACK        INPUTS      OUTPUTS
           Y             y             B
           X             x             A

      where  Gam(x+iy) = A + iB

Example:

    -1.6   ENTER^
     2.4   XEQ "GAMZ"   >>>>     0.248941260                         ---Execution time = 8s---
                                      X<>Y    -0.633220122

Whence,    Gam ( 2.4 - 1.6 i ) = 0.248941260 - 0.633220122 i
 

Product of 2 Quaternions
 

Q*Q calculates the product of  q = a + b i + c j + d k  &  q' = a' + b' i + c' j + d' k  by the rules:

    i.j = -j.i = k
   j.k = -k.j = i       and     i2 = j2 = k2 = -1         Therefore, the product of 2 quaternions is not commutative. But it has the associative and distributive properties.
   k.i =  -i.k = j
 

Data Registers:           R00:  unused

                               R01 = a          R05 = a'
                               R02 = b          R06 = b'       with    q  =  a + b.i + c.j + d.k            R01 thru R08 are to be initialized
                               R03 = c          R07 = c'        and    q' = a' + b'.i + c'.j + d'.k
                               R04 = d          R08 = d'
Flags:  /
 
 
      STACK        INPUTS      OUTPUTS
           T             /             t
           Z             /             z
           Y             /             y
           X             /             x

       with      q.q'  =  x + y.i + z.j + t.k

Example:      q = 2 - 3i + 4j - 7k  and  q' = 1 - 4i + 2j + 5k       calculate  q.q'

  2   STO 01     1  STO 05            XEQ "Q*Q"      yields    17
 -3  STO 02    -4  STO 06                                      RDN    23
  4  STO 03      2  STO 07                                      RDN    51
 -7  STO 04     5  STO 08                                      RDN    13

Thus    q.q' = 17 + 23i + 51j + 13k                      ( remark:    q'.q = 17 - 45i -35j - 7k )
 

Hyperbolic Cosine of a Real
 

    Ch x = Cosh x = ( ex + e -x )/2
 
 
      STACK         INPUT      OUTPUT
           X             x        Cosh (x)
           L              /             x

Example:

  2  XEQ "CH"  >>>>  Cosh 2 =  3.762195691
 

Hyperbolic Sine of a Real
 

    Sh x = Sinh x = [ ( ex - 1 ) - ( e -x - 1 ) ]/2
 
 
      STACK         INPUT      OUTPUT
           X             x        Sinh (x)
           L              /             x

Example:

  2  XEQ "SH"   >>>>  Sinh 2  =  3.626860408
 

Inverse Hyperbolic Sine of a Real
 

     Ash x = Asinh x = Ln [ 1 + x + x2 / ( 1 + ( 1 + x2 )1/2 ) ]
 
 
      STACK         INPUT      OUTPUT
           X             x       Asinh (x)
           L              /            x

Example:

 14   XEQ "ASH"  >>>>  Asinh 14  = 3.333477587
 

Inverse Hyperbolic Tangent of a Real
 

     Ath x = Atanh x = (1/2).Ln ( 1 + 2x/( 1 - x ) )
 
 
      STACK         INPUT      OUTPUT
           X             x       Atanh (x)
           L              /            x

Example:

 0.7  XEQ "ATH"  >>>>  Atanh 0.7 = 0.867300528
 

Difference between 2 consecutive  Sums
 
 

-"DSA"   adds registers  R01 thru Rnn  to the registers  R2n+1 thru R3n
               and returns in X the difference between the previous and the new contents of registers R2n+1 thru R3n

-If it returns zero, we stop computing "infinte" sums.

-It's often useful to multiply the numbers in registers R01 thru Rnn ( without modifying these registers ) by a real number x
  before adding them to the partial sum in registers R2n+1 thru R3n
-DS*A does this job.
 

Moving an Anion
 

-To copy an anion from registers R01 thru Rnn to registers Rn+1 thru R2n, we can use the following instructions, assuming R00 = n:

   RCL 00     +        +
   .1               E3     REGMOVE
   %              /
   ISG X       1

-MOVE  can be used instead.
-In the above example, simply key in  12  AMOVE
 
 
      STACK        INPUTS      OUTPUTS
           X           pq     bbb.eeennn
           L            /            pq

   where the control number  bbb.eeennn  ( needed for REGMOVE & REGSWAP ) is calculated by

  bbb = n ( p-1 ) + 1  ,   eee = n ( q-1 ) + 1 assuming that  R00 = n

Note:

-In fact, only the first 2 digits of the mantissa are taken into account.
 

Swapping 2 Anions
 

-To swap 2 anions between registers R01 thru Rnn and registers Rn+1 thru R2n, we can use the following instructions, assuming R00 = n:

   RCL 00     +        +
   .1               E3    REGSWAP
   %              /
   ISG X       1

-SWAP  can be used instead.
-In the above example, simply key in  12  SWAP
-To swap 2 anions between registers Rn+1 thru R2n & R2n+1 thru R3n,  key in  23   SWAP  ( or 32  SWAP )
 
 
      STACK        INPUTS      OUTPUTS
           X           pq     bbb.eeennn
           L            /            pq

   where the control number  bbb.eeennn  ( needed for REGMOVE & REGSWAP ) is calculated by

  bbb = n ( p-1 ) + 1  ,   eee = n ( q-1 ) + 1 assuming that  R00 = n

Note:

-In fact, only the first 2 digits of the mantissa are taken into account.
 

Extra-Registers
 

-These 10 functions ( RCL / STO U V W R S ) provide 5 additional registers to store & recall numbers without disturbing data registers.
-Ángel Martin - great expert in M-Code programming - employs the buffer to create these extra-registers.
-Unlike the versions I wrote, they do not use the M-Code instructions 040 WRIT S&X or 330 FETCH S&X which would not be adequate for such a module.

-Many thanks to Ángel !
 

VIEW Registers
 

 bbb.eee  XEQ "VREG" displays the contents of registers  Rbb thru Ree  in FIX 4
 
 
      STACK        INPUT      OUTPUT
           X       bbb.eee     1+eee.eee

   where  Rbbb = first register & Reee = last register

Example:

-If you want to display registers R01 to R04  and if  R01 = 4.56789   R02 = 3.14  R03 = 2.718  R04 = 7

     1.004  XEQ "VREG"   >>>   R01:  4.5679
                                                   R02:  3.1400
                                                   R03:  2.7180
                                                   R04:  7.0000
 
 

References:

[1]   Abramowitz and Stegun - "Handbook of Mathematical Functions" -  Dover Publications -  ISBN  0-486-61272-4
[2]   http://functions.wolfram.com/
[3]   Warren D. Smith - Quaternions, Octonions, 16-ons & 2^n-ons, new kinds of numbers