The Museum of HP Calculators

# Complex Functions for the HP-41

This program is Copyright © 2004 by Jean-Marc Baillard and is used here by permission.

This program is supplied without representation or warranty of any kind. Jean-Marc Baillard and The Museum of HP Calculators therefore assume no responsibility and shall have no liability, consequential or otherwise, of any kind arising from the use of this program material or any part thereof.

## Overview

-The following programs calculate the sum, difference, product and quotient of 2 complex numbers,
the square, square root, natural logarithm, natural exponential, inverse of one complex number, trigonometric and hyperbolic functions and their inverses,
raising a complex number to a real power and raising a complex number to a complex power. ( 23 routines in all )
-Then, 4 root-finding programs are listed.

1°) Complex Operations

-The global labels  "Z+"  "Z-"  "Z*"  "Z/"   mean addition, subtraction, multiplication and division.
"Z^2"  "SQRTZ"  "LNZ"  "E^Z"  "1/Z"   -----  square, square root, logarithm, exponential, reciprocal.
"SINZ"  "COSZ"  "TANZ"  "ASINZ"  "ACOSZ"  "ATANZ"  correspond to sine, cosine, tangent and their inverses.
"SHZ"  "CHZ"  "THZ"  "ASHZ"  "ACHZ"  "ATHZ"  correspond to hyperbolic sine, hyperbolic cosine, hyperbolic tangent and their inverses:
-I've used the French notations ( sh z instead of sinh z  ... etc ... ) which have the advantage of saving several bytes and keystrokes.
"Z^X" and "Z^Z"  stand for raising a complex number to a real power and a complex power respectively.

-These programs use no data register, no synthetic register and no external subroutine.
-However, for instance, "TANZ"  calls  "THZ"  as a subroutine since  tan z = i.tanh (-i.z) and similarly for many other complex functions.
-In these cases, local labels have been inserted after the global labels  ( for example,  XEQ 03  LBL 03 instead of  XEQ "THZ",
which saves 1 byte and executes faster ) and so on ...
-Furthermore, some series of instructions are executed several times ( like lines 82 to 90 ), also leading to local subroutines.
-Lines 120 & 139 are only useful te restore the DEG mode: they may be deleted if RAD is your favorite angular mode.

-To get the magnitude of a complex number, simply press  R-P.

Data Registers: /
Flags: /
Subroutines:
/

001  LBL "SINZ"
002  X<>Y
003  CHS
004  XEQ 01
005  CHS
006  X<>Y
007  RTN
008  LBL "TANZ"
009  CHS
010  X<>Y
011  XEQ 03
012  X<>Y
013  CHS
014  RTN
015  LBL "ASINZ"
016  X<>Y
017  CHS
018  XEQ 05
019  CHS
020  X<>Y
021  RTN
022  LBL "ATANZ"
023  CHS
024  X<>Y
025  XEQ 06
026  X<>Y
027  CHS
028  RTN
029  LBL "SHZ"
030  LBL 01
031  XEQ 00
032  XEQ 01
033  GTO 10
034  LBL "COSZ"
035  X<>Y
036  CHS
037  LBL "CHZ"
038  XEQ 00
039  XEQ 02
040  GTO 10
041  LBL "ATHZ"
042  LBL 06
043  RCL X
044  1
045  ST+ Z
046  X<>Y
047  -
048  R^
049  CHS
050  X<>Y
051  XEQ 07
052  XEQ 12
053  LBL 10
054  2
055  ST/ Z
056  /
057  RTN
058  LBL "THZ"
059  LBL 03
060  2
061  ST* Z
062  *
063  XEQ 08
064  RCL X
065  1
066  ST- Z
067  +
068  R^
069  X<>Y
070  LBL "Z/"
071  LBL 07
072  R-P
073  R^
074  R^
075  R-P
076  R^
077  ST- Z
078  X<> T
079  /
080  P-R
081  RTN
082  LBL 00
083  RCL Y
084  RCL Y
085  XEQ 08
086  R^
087  CHS
088  R^
089  CHS
090  GTO 08
091  LBL "ACOSZ"
092  XEQ 04
093  CHS
094  X<>Y
095  GTO 13
096  LBL "ACHZ"
097  LBL 04
098  XEQ 14
099  CHS
100  XEQ 09
101  LBL 13
102  ENTER^
103  SIGN
104  ST* Z
105  *
106  RTN
107  LBL "ASHZ"
108  LBL 05
109  XEQ 14
110  LBL 09
111  ST+ L
112  X<> L
113  XEQ 11
114  XEQ 02
115  LBL "LNZ"
116  LBL 12
118  R-P
119  LN
120  DEG
121  RTN
122  LBL 14
123  RCL Y
124  RCL Y
125  XEQ 05
126  SIGN
127  ST* X
128  RTN
129  LBL "Z^Z"
130  R^
131  R^
132  XEQ 12
133  XEQ 03
134  LBL "E^Z"
135  LBL 08
137  E^X
138  P-R
139  DEG
140  RTN
141  LBL "Z^X"
142  RDN
143  R-P
144  R^
145  ST* Z
146  Y^X
147  P-R
148  RTN
149  LBL "Z-"
150  LBL 01
151  CHS
152  X<>Y
153  CHS
154  X<>Y
155  LBL "Z+"
156  LBL 02
157  ST+ Z
158  X<> T
159  +
160  X<>Y
161  RTN
162  LBL "Z*"
163  LBL 03
164  R-P
165  R^
166  R^
167  R-P
168  X<>Y
169  ST+ T
170  RDN
171  *
172  P-R
173  RTN
174  LBL "1/Z"
175  R-P
176  1/X
177  X<>Y
178  CHS
179  X<>Y
180  P-R
181  RTN
182  LBL "Z^2"
183  LBL 05
184  R-P
185  X^2
186  X<>Y
187  ST+ X
188  X<>Y
189  P-R
190  RTN
191  LBL "SQRTZ"
192  LBL 11
193  R-P
194  SQRT
195  SIGN
196  ST+ X
197  ST/ Y
198  X<> L
199  P-R
200  END

( 420 bytes / SIZE 000 )

1°) First case:  Function of one complex number

 STACK INPUTS OUTPUTS Y y v X x u

where   z = x+i.y  ;  f(z) = u+i.v

Example:       z = 2+3.i

-Calculate  z2 ;  z1/2  ;  1/z  ;  exp(z)  ;  Ln(z)  ;  sin z  ;  cos z  ;  tan z ;  Asin z  ; Acos z ; Atan z ;  Sinh z ; Cosh z ; Tanh z ; Asinh z ; Acosh z  ; Atanh z

3  ENTER^   2   XEQ "Z^2"        >>>      -5      X<>Y      12        whence    (2+3.i)2   =   -5+12.i
3  ENTER^   2   XEQ "SQRTZ"  >>>   1.6741  X<>Y   0.8960   --------    (2+3.i)1/2 =   1.6741+0.8960.i
3  ENTER^   2   XEQ "1/Z"         >>>   0.1538  X<>Y  -0.2308   --------   1/(2+3.i)  =    0.1538-0.2308.i
3  ENTER^   2   XEQ "E^Z"        >>>  -7.3151  X<>Y   1.0427   --------   exp(2+3.i) =  -7.3151+1.0427.i
3  ENTER^   2   XEQ "LNZ"       >>>   1.2825  X<>Y    0.9828   --------   Ln(2+3.i)  =   1.2825+0.9828.i
3  ENTER^   2   XEQ "SINZ"     >>>    9.1545  X<>Y   -4.1689  --------   Sin(2+3.i)  =   9.1545-4.1689.i
3  ENTER^   2   XEQ "COSZ"    >>>   -4.1896  X<>Y  -9.1092  --------   Cos(2+3.i) =  -4.1896-9.1092.i
3  ENTER^   2   XEQ "TANZ"    >>>   -0.0038  X<>Y   1.0032  --------    Tan(2+3.i) =  -0.0038+1.0032.i
3  ENTER^   2   XEQ "ASINZ"   >>>    0.5707  X<>Y   1.9834  --------   Asin(2+3.i) =   0.5707+1.9834.i
3  ENTER^   2   XEQ "ACOSZ"  >>>   1.0001  X<>Y  -1.9834  --------   Acos(2+3.i) =  1.0001-1.9834.i
3  ENTER^   2   XEQ "ATANZ"  >>>   1.4099  X<>Y   0.2291  --------    Atan(2+3.i) =  1.4099+0.2291.i
3  ENTER^   2   XEQ "SHZ"        >>>  -3.5906  X<>Y  0.5309  --------    Sinh(2+3.i)  =  -3.5906+0.5309.i
3  ENTER^   2   XEQ "CHZ"       >>>   -3.7245  X<>Y  0.5118  --------    Cosh(2+3.i) = -3.7245+0.5118.i
3  ENTER^   2   XEQ "THZ"       >>>    0.9654   X<>Y  -0.0099  -------    Tanh(2+3.i)  =  0.9654-0.0099.i
3  ENTER^   2   XEQ "ASHZ"    >>>    1.9686   X<>Y   0.9647  --------   Asinh(2+3.i) =  1.9686+0.9647.i
3  ENTER^   2   XEQ "ACHZ"   >>>     1.9834   X<>Y  1.0001  --------    Acosh(2+3.i) = 1.9834+1.0001.i
3  ENTER^   2   XEQ "ATHZ"    >>>    0.1469   X<>Y   1.3390  --------    Atanh(2+3.i) =  0.1469+1.3390.i

Note:    "Z^2"  "SQRTZ"  "1/Z"  "E^Z"  and  "LNZ"   save registers Z and T ( this feature is important when they are called as subroutines by the other functions ).

2°) Second case:  raising a complex number to a real power

 STACK INPUTS OUTPUTS Z y / Y x v X r u

where   z = x+i.y  ;  zr = u+i.v

Example:   Evaluate  (2+3.i)1/5

3  ENTER^   2  ENTER^   5   1/X   XEQ "Z^X"   >>>  1.2675   X<>Y   0.2524    whence   (2+3.i)1/5 = 1.2675+0.2524.i

Note:   "Z^X"  saves T-register in  registers Z and T.

3°) Third case:  Function of two complex numbers.

 STACK INPUTS OUTPUTS T y / Z x / Y y' v X x' u

where   z = x+i.y  ;  z' = x'+i.y' ; f(z;z') = u+i.v

Example:   z = 2+3.i  ;  z' = 4+7.i  Compute  z+z' ; z-z' ; z.z' ; z/z' ; zz'

3  ENTER^   2  ENTER^   7  ENTER^   4  XEQ "Z+"    gives      6       X<>Y       10      whence    z+z' = 6+10.i
3  ENTER^   2  ENTER^   7  ENTER^   4  XEQ "Z-"     ----      -2       X<>Y       -4      --------    z-z' = -2-4.i
3  ENTER^   2  ENTER^   7  ENTER^   4  XEQ "Z*"     ----    -13       X<>Y       26      --------    z.z' = -13+26.i
3  ENTER^   2  ENTER^   7  ENTER^   4  XEQ "Z/"      ----   0.4462  X<>Y  -0.0308   --------    z/z' = 0.4462-0.0308.i
3  ENTER^   2  ENTER^   7  ENTER^   4  XEQ "Z^Z"   ----  0.1638   X<>Y   0.0583    --------    zz' = 0.1638+0.0583.i

2°) Complex Equations:   f(z) = 0

a) The "Secant" Method

-This program uses an iterative algorithm.
-Starting with 2 distinct initial guesses  z0 = x0+i.y0 ;  z1 = x1+i.y1 ,  it calculates  zk+1 = zk - f(zk).(zk - zk-1) / [ f(zk) - f(zk-1) ]     ( k = 1 ; 2 ; 3 ; ....... )
-The process is repeated until 2 consecutive approximations are equal.

Data Registers:   • R00 = Function name   ( Global label, maximum of 6 characters. This register is to be initialized before executing "ROOTZ" )
R01 = x   R03 = a   R05 = x'
R02 = y   R04 = b   R06 = y'   where  f(z) = f(x+i.y) = a+i.b
Flag: /
Subroutine:  A program which computes  f(z) = a+i.b  assuming  x is in X-register and y is in Y-register upon entry
In other words, the stack must be changed from      Y = y           Y = b
X = x    to    X = a      where z = x+i.y   and   f(z) = f(x+i.y) = a+i.b

01  LBL "ROOTZ"
02  STO 01
03  X<>Y
04  STO 02
05  R^
06  STO 06
07  R^
08  STO 05
09  XEQ IND 00
10  STO 03
11  X<>Y
12  STO 04
13  LBL 01
14  VIEW 01
15  RCL 02
16  RCL 01
17  XEQ IND 00
18  RCL 04
19  RCL 03
20  R^
21  STO 04
22  ST- Z
23  R^
24  STO 03
25  ST- Z
26  R-P
27  R^
28  R^
29  R-P
30  X<>Y
31  ST- T
32  RDN
33  X#0?
34  /
35  RCL 02
36  ENTER^
37  X<> 06
38  -
39  RCL 01
40  STO L
41  X<> 05
42  ST- L
43  X<> L
44  R-P
45  X<>Y
46  ST+ T
47  RDN
48  *
49  P-R
50  ST+ 01
51  X<>Y
52  ST+ 02
53   E-8
54  LASTX
55  X>Y?
56  GTO 01
57  RCL 02
58  RCL 01
59  END

( 86 bytes / SIZE 007 )

 STACK INPUTS OUTPUTS T y0 / Z x0 / Y y1 y X x1 x

Example:   Find a root of      sinh z + z2 + Pi = 0.      First, we load a routine to compute f(z) , for instance:

LBL "T"
STO 07
X<>Y
STO 08
X<>Y
XEQ "SHZ"
RCL 08
RCL 07
XEQ "Z^2"
XEQ "Z+"
PI
+
RTN

And if we choose   z0 = 0  ;  z1 = 1+i

T  ASTO 00
0  ENTER^   ENTER^
1  ENTER^   XEQ "ROOTZ"  the succesive x-values are displayed and we get   -0.278189856                  ( execution time = 77 seconds )
X<>Y      1.812880366

Whence     -0.278189856 + 1.812880366.i    is a solution.   ( There are many other solutions like  4.419361546 + 4.697881722.i  ... etc ... )

Note:  -The iterations stop when  zk+1 =  zk  or when   f(zk+1) =  f(zk)  Therefore, check f(z) in registers R03 & R04

-Starting with 3 initial guesses:    z0 = x0+i.y0 ;  z1 = x1+i.y1 ;  z2 = x2+i.y2 , this program calculates

A = ( z1-z0 ).f(z2) + ( z0-z2 ).f(z1) + ( z2-z1 ).f(z0)
B = ( z1-z0 ).( 2.z2-z1-z0 ).f(z2) - ( z0-z2 )2.f(z1) + ( z2-z1 )2.f(z0)
C = ( z2-z1 ).( z1-z0 ).( z2-z0 ).f(z2)

and   z3 = z2 - 1 / [ B/(2.C) + E.( B2/(4C2) - A/C )1/2 ]      where   E = +1 or -1   ( the sign is choosen to produce the larger denominator )

-The process is repeated until  | zk+1-zk |  is smaller than  10-8  or  C = 0   ( check  f(z) in  R03 & R04 )

Data Registers:   • R00 = Function name   ( Global label, maximum of 6 characters. This register is to be initialized before executing "RTZ2" )
R01 = x   R03 = a   R05 thru R20:  temp
R02 = y   R04 = b   where  f(z) = f(x+i.y) = a+i.b
Flag: /
Subroutines:  "Z+"  "Z*"  "Z^2"  "SQRTZ"
and a program which computes  f(z) = a+i.b  assuming  x is in X-register and y is in Y-register upon entry
The stack must be changed from      Y = y           Y = b      where     z = x+i.y
X = x    to    X = a        and   f(z) = f(x+i.y) = a+i.b
( Registers R03 R04 R13 R14 ... etc ... may be used by this subroutine )

001  LBL "RTZ2"
002  STO 01
003  RDN
004  STO 02
005  X<>Y
006  STO 05
007  STO 06
008  STO 09
009  STO 10
010  ST- T
011  -
012  R^
013  XEQ IND 00
014  STO 07
015  X<>Y
016  STO 08
017  RCL 02
018  RCL 01
019  RCL 05
020  ST+ X
021  ST- Z
022  -
023  XEQ IND 00
024  STO 11
025  X<>Y
026  STO 12
027  LBL 01
028  VIEW 01
029  RCL 02
030  RCL 01
031  XEQ IND 00
032  STO 03
033  X<>Y
034  STO 04
035  X<>Y
036  RCL 10
037  RCL 09
038  XEQ "Z*"
039  STO 13
040  X<>Y
041  STO 14
042  RCL 06
043  RCL 10
044  +
045  STO 20
046  RCL 05
047  RCL 09
048  +
049  STO 19
050  RCL 14
051  RCL 13
052  XEQ "Z*"
053  RCL 06
054  RCL 05
055  XEQ "Z*"
056  R-P
057  X=0?
058  GTO 02        ( a three-byte GTO )
059  CHS
060  STO 15
061  X<>Y
062  STO 16
063  RCL 06
064  RCL 20
065  +
066  RCL 05
067  RCL 19
068  +
069  RCL 14
070  RCL 13
071  XEQ "Z*"
072  STO 17
073  X<>Y
074  STO 18
075  RCL 20
076  RCL 19
077  RCL 08
078  RCL 07
079  XEQ "Z*"
080  ST- 13
081  X<>Y
082  ST- 14
083  X<>Y
084  RCL 20
085  RCL 19
086  XEQ "Z*"
087  ST- 17
088  X<>Y
089  ST- 18
090  RCL 06
091  RCL 05
092  RCL 12
093  RCL 11
094  XEQ "Z*"
095  ST+ 13
096  X<>Y
097  ST+ 14
098  X<>Y
099  RCL 06
100  RCL 05
101  XEQ "Z*"
102  ST+ 17
103  X<>Y
104  ST+ 18
105  RCL 14
106  RCL 13
107  R-P
108  STO 13
109  X<>Y
110  STO 14
111  RCL 18
112  RCL 17
113  R-P
114  RCL 16
115  ST- 14
116  ST- Z
117  X<> 15
118  ST/ 13
119  ST+ X
120  /
121  P-R
122  STO 15
123  X<>Y
124  STO 16
125  X<>Y
126  XEQ "Z^2"
127  RCL 14
128  RCL 13
129  P-R
130  XEQ "Z+"
131  XEQ "SQRTZ"
132  RCL 16
133  RCL Z
134  ST- 16
135  +
136  RCL 15
137  RCL Z
138  ST- 15
139  +
140  R-P
141  X<>Y
142  RCL 16
143  RCL 15
144  R-P
145  R^
146  X<Y?
147  RCL Y
148  X#0?
149  1/X
150  R^
151  CHS
152  X<>Y
153  P-R
154  ST+ 01
155  X<> 05
156  STO 09
157  X<>Y
158  ST+ 02
159  X<> 06
160  STO 10
161  RCL 03
162  X<> 07
163  STO 11
164  RCL 04
165  X<> 08
166  STO 12
167   E-8
168  LASTX
169  X>Y?
170  GTO 01      ( a three-byte GTO )
171  LBL 02
172  RCL 02
173  RCL 01
174  END

( 272 bytes / SIZE 021 )

 STACK INPUTS OUTPUTS Z h / Y y0 y X x0 x

( The 3 initial guesses are actually   z0 = x0+i.y0 ;   z0-(1+i).h ; z0-2.(1+i).h  )

Example:     With the same equation     sinh z + z2 + Pi = 0.     We load a routine to compute f(z)

LBL "T"
STO 03
X<>Y
STO 04
X<>Y
XEQ "SHZ"
RCL 04
RCL 03
XEQ "Z^2"
XEQ "Z+"
PI
+
RTN

And if we choose   z0 = 1+i  and  h = 1

T  ASTO 00
1  ENTER^   ENTER^
XEQ "RTZ2"  the succesive x-values are displayed and we get   -0.278189857                  ( execution time = 156 seconds )
X<>Y      1.812880366

Whence    z = -0.278189857 + 1.812880366.i

Note:     In this example,  "ROOTZ"  is faster than  "RTZ2"   but if  f is a very complicated function, the advantage is clearly with "RTZ2"

c) The Newton's Method

-Only one initial guess  z0 = x0+i.y0  is needed but we have to compute the first derivative f '(z)
-The formula is   zk+1 = zk - f(zk)/f '(zk)

Data Registers:   • R00 = f name       • R03 = f ' name    ( these 2 registers are to be initialized before executing "NWTZ" )
R01 = x
R02 = y   R04 = | f '(z) |   R05: temp
Flag: /
Subroutines:  A program which computes  f(z)   assuming  x is in X-register and y is in Y-register upon entry
and   ----------------------------  f '(z) -----------------------------------------------------------

01  LBL "NWTZ"
02  STO 01
03  X<>Y
04  STO 02
05  LBL 01
06  VIEW 01
07  RCL 02
08  RCL 01
09  XEQ IND 03
10  R-P
11  STO 04
12  X<>Y
13  STO 05
14  RCL 02
15  RCL 01
16  XEQ IND 00
17  R-P
18  ENTER^
19  X<> 04
20  X#0?
21  /
22  X<>Y
23  RCL 05
24  -
25  X<>Y
26  P-R
27  ST- 01
28  X<>Y
29  ST- 02
30   E-8
31  LASTX
32  X>Y?
33  GTO 01
34  RCL 04
35  RCL 02
36  RCL 01
37  END

( 55 bytes / SIZE 006 )

 STACK INPUTS OUTPUTS Z / | f(z) | Y y0 y X x0 x

-The output in Z-register should be a "small" number  if  z = x+i.y  is a "true" root

Example:       sinh z + z2 + Pi = 0.     We have to load 2 routines to compute f(z) and f ' (z) = cosh z + 2.z  for instance:

LBL "T"
STO 07
X<>Y
STO 08
X<>Y
XEQ "SHZ"
RCL 08
RCL 07
XEQ "Z^2"
XEQ "Z+"
PI
+
RTN
LBL "U"
STO 07
X<>Y
STO 08
X<>Y
XEQ "CHZ"
RCL 08
ST+ X
RCL 07
ST+ X
XEQ "Z+"
RTN

Then    T  ASTO 00   U  ASTO 03   and with  z0 = 1+i
1  ENTER^    XEQ "NWTZ"  the successive  x-approximations are displayed
and we get  -0.278189857
RDN    1.812880366     whence  z = -0.278189857 + 1.812880366.i      ( execution time = 54 seconds )

Note:   | f(z) |  in Z-register actually concerns the next to last approximation.

d) Another method

-Starting with one initial guess   z0 = x0+i.y0  , we now use the first and second derivatives   f '(z)  and  f "(z)  ,  the recursion formula is:
zk+1 = zk -  1 / [ f '(zk)/f(zk) + E.( ( f(zk)/(2.f '(zk)) )2 - f "(zk) /(2.f (zk)) )1/2 ]   where   E = +1 or -1   ( the sign is choosen to produce the larger denominator )

Data Registers:   • R00 = f name       • R03 = f ' name     • R04 = f " name  ( these 3 registers are to be initialized before executing "RTZ4" )
R01 = x
R02 = y   R05 = | f '(z) |    R06 thru R09: temp
Flag: /
Subroutines:  A program which computes  f(z)   assuming  x is in X-register and y is in Y-register upon entry
----------------------------  f '(z) -----------------------------------------------------------
and   ----------------------------  f "(z) -----------------------------------------------------------

01  LBL "RTZ4"
02  STO 01
03  X<>Y
04  STO 02
05  LBL 01
06  VIEW 01
07  RCL 02
08  RCL 01
09  XEQ IND 03
10  R-P
11  STO 06
12  X<>Y
13  STO 07
14  RCL 02
15  RCL 01
16  XEQ IND 04
17  R-P
18  STO 08
19  X<>Y
20  STO 09
21  RCL 02
22  RCL 01
23  XEQ IND 00
24  R-P
25  STO 05
26  X=0?
27  GTO 02
28  ST+ X
29  ST/ 06
30  ST/ 08
31  X<>Y
32  ST- 07
33  ST- 09
34  RCL 07
35  ST+ X
36  RCL 06
37  X^2
38  P-R
39  RCL 09
40  RCL 08
41  P-R
42  ST- Z
43  RDN
44  ST- Z
45  RDN
46  R-P
47  SQRT
48  X<>Y
49  2
50  /
51  X<>Y
52  P-R
53  RCL 07
54  RCL 06
55  P-R
56  STO 06
57  RDN
58  STO 07
59  RCL Z
60  ST- 07
61  +
62  RCL 06
63  RCL Z
64  ST- 06
65  +
66  R-P
67  X<>Y
68  RCL 07
69  RCL 06
70  R-P
71  R^
72  X<Y?
73  RCL Y
74  X#0?
75  1/X
76  R^
77  CHS
78  X<>Y
79  P-R
80  ST- 01
81  X<>Y
82  ST- 02
83   E-8
84  LASTX
85  X>Y?
86  GTO 01
87  LBL 02
88  RCL 05
89  RCL 02
90  RCL 01
91  END

( 123 bytes / SIZE 010 )

 STACK INPUTS OUTPUTS Z / | f(z) | Y y0 y X x0 x

-The output in Z-register should be a "small" number  if  z = x+i.y  is a "true" root

Example:       sinh z + z2 + Pi = 0.     We have to load 3 routines to compute f(z) ; f ' (z) = cosh z + 2.z and  f "(z) = sinh z + 2  ,  for instance:

LBL "T"
STO 10
X<>Y
STO 11
X<>Y
XEQ "SHZ"
RCL 11
RCL 10
XEQ "Z^2"
XEQ "Z+"
PI
+
RTN
LBL "U"
STO 10
X<>Y
STO 11
X<>Y
XEQ "CHZ"
RCL 11
ST+ X
RCL 10
ST+ X
XEQ "Z+"
RTN
LBL "V"
XEQ "SHZ"
2
+
RTN

Then    T  ASTO 00   U  ASTO 03   V ASTO 04  and with  z0 = 1+i
1  ENTER^    XEQ "RTZ4"    the successive  x-approximations are displayed
and we get  -0.278189857
RDN    1.812880366     whence  z = -0.278189857 + 1.812880366.i      ( execution time = 70 seconds )

Notes:  1-   | f(z) |  in Z-register actually concerns the next to last approximation.
2- Among these 4 root-finding programs, "RTZ4" has the best rate of convergence.