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 |
-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
-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
-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.
-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
• 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
• 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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
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
-"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
"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
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
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
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
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
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 )
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.
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 )
-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.
"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
-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 ....
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
"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
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
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
-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
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
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
"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
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"
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
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.
-"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 )
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
• "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
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
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
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 , ....................
- "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.
"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
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
"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
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
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 )
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
-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.
-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
STACK | INPUT | OUTPUT |
Y | y | Y |
X | x | X |
L | / | x |
Where X + i Y = 1 / ( x + i y )
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' )
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 )
STACK | INPUT | OUTPUT |
Y | y | Y |
X | x | X |
L | / | x |
Where X + i Y = ( x + i y )^2
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
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 )
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
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.
-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.
-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.
-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 !
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