History

In May 1985, Frans de Vries published his Complex Arithmetic program for the HP-41CX [1]. I am very grateful for his work, and much of this documentation is based on his work. My iteration of this program has been a pet project while in college. Inspired by this program, I wrote a library in Oxford Pascal for the Commodore-64. Internally this library used polar notation because complex multiplication may result in an angle exceeding the branch cut. I designed a RS232 interface for this Commodore-64, and waited for an unsupervised moment and transferred the library to the Pr1me computer on campus. When I acquired my first IBM PC clone, once again this program moved alongside with me.

Now, twenty-five years later, I restored my faithful HP-41 and use the same program once again. This version is also verified to run under Windows using Warren Furlow’s V41 simulator when compiled with Leo Duran’s hp41uc.

Instructions

To start the program use XEQ “CA”. From here you can use the complex operations by pressing COMPLEX (the R/S key on the normal keyboard) followed by the desired operation. The overlay shown below these operation can be recognized by the blue paint splash behind the labels. These same operations are referenced in this article by enclosing them in a blue box.

Note that BCUT is only implemented in “Complex Arithmetic with adjustable branch cut for HP-41cv/cx“.

The table shows the key assignments with their effect on the complex stack.

The prefixes ARC and HYP provide a rich set of trigonometric and hyperbolic functions. In order to squeeze the program (866 bytes) into the x-memory, the operations ATAN, ATANH, ACOT and ACOTH needed to be removed.

Stack

The calculating environment consists of 6 complex stack registers, numbered Z1 thru Z6, and a complex LASTZ1 register. The large complex stack limits the need for store and recall functions.

Entering and displaying complex numbers

Both rectangular coordinates and polar form are supported for data entry and viewing. To switch between modes, use the RECT and POL operations. Flag 0 shown on the LCD display serves as an annunciator for polar mode.

Input to and output of the complex operations is through the normal stack. In rectangular mode, the real part of the complex number in should be placed in X register and the imaginary part in Y. In polar mode, the magnitude should be in X and the phase in Y. After each operations, the result of the operation is stored on the complex stack as Z1, and shown on the display in a condensed format. To see the full accuracy, press XY to see the imaginary part (or phase in Polar mode), and XY again to see the real part (or modulus in Polar mode).

Start

The program consist of two parts. The first part labeled “CA” fits in a mere 5 registers of main memory (after removing the GTO “X”). It handles the initialization and then jumps to the second part labeled “X”. This second part is intended to be placed in extended memory, but can also be used in main memory.

Start the program with XEQ “CA”. This clears the complex stack and initializes relevant flags and angular mode. The program will display the top of the complex stack (Z1), and halt at line 13 in “X” and will also return to this place after each operation. At this point, you have the option of enter an operand.

Operations

Pressing COMPLEX will activate the GETKEY keyboard. The program waits of a keystroke, and uses the key code to call the corresponding operation.

Most operation require one or two operand from the stack. Exceptions to this rule are functions that take a real number argument (Zⁿ, Z^1/n, n^Z, VIEWZn, Z1 Zn) and mode switches (RECT, POL) and prefixes (g, ARC, HYP).

For the function Z^1/n, the above is also valid, but this function does not immediately return to the normal halting point. Also, n must be a positive integer. Instead, this operation shows all the n^th roots of the complex number in Z1. The ALPHA annunciator is used to indicate that more roots are to follow. When the operation is finished displaying the roots, the first root will be available as Z1 on the complex stack (and X,Y on the regular stack).

The use of the prefixes ARC and HYP is similar to the use of the shift key, with flag 03 and 04 acting as the annunciator for ARC and HYP respectively. They can be used in any combination to denote and execute the desired function. The state of these flags only affects trigonometric operations.

Note that operations can anywhere between 1 and take up to 6 seconds to execute.

Entering operands

Depending on the operation, the operand can be a real or complex number. Real numbers must always be in the X register before pressing COMPLEX. Complex numbers can either be entered on the regular stack as an X,Y pair, or taken from the complex stack.

The functions VIEWZn and Z1 Zn require an integer number between 0 and the complex stack size (default 6). The functions RECT and POL will also recall Z1 into the normal stack, so that it can be shown correctly in the new mode.

Error handling

The program has no accommodation (apart from the SF 25) at line 40 in “X” to avoid error halts. This implies that attempts to divide by zero, take the log of zero, etc. will usually cause a DATA ERROR halt. Pressing INIT lets the program return to its normal halting point at line 13 in “X”.

Extended memory

As mentioned earlier, the second part of the program can be placed in extended memory. To do so, save it on 4 magnetic cards and then load it into x-memory. Note that it is not possible to change the program while in extended memory, because once the program executes in x-memory, the bytes near the GTO and XEQ instructions will be changed to match to the corresponding LBL address. This would cause the check sum of the fill to mismatch. For more details on running a program in extended memory, refer to the book “Extend your HP-41″ [6].

Examples

The following examples assume a ENG 3, SF 28, CF 29 display mode.

1. Calculate: (2 + 3j).(7 – 6j) + (4 + 5j)
   

   input	display
   XEQ “CA”	0.00E0+0.00E0J
   3 ENTER	3.000
   2 COMPLEX ENTER	2.00E0+3.00E0J
   6 CHS
   ENTER	-6.000
   7 COMPLEX ENTER	7.00E0-6.00E0J
   5 ENTER	5.000
   4 COMPLEX +	11.0E0-1.00E0J
   COMPLEX *	25.0E0+31.0E0J
   X Y	31.000
   X Y	25.000

   The answer is 25 + 31j

2. Calculate: (3 + 4.5j)^5
   

   input	display
   4.5 ENTER	4.500
   3 COMPLEX ENTER	3.00E0+4.50E0J
   5 COMPLEX ZN	926.E0-4.53E3J
   X Y	-4.533 03
   X Y	926.4 00

   The answer is 926.4 – -4533j:

3. Show what is in LASTZ1
   

   input	display
   COMPLEX LASTZ1	3.00E0+4.50E0J

   Note that the complex number is saved, not the power 5

4. Calculate: 1 / (3, Φ40°)
   

   input	display
   COMPLEX POL	5.41E0<56.3E0
   40 ENTER	40.00 00
   3 COMPLEX 1/Z	333.E-3<-40.0E0

   The answer is 0.3333 Φ -40º
   :

5. Calculate: asinh(8 – 5j)
   

   input	display
   COMPLEX RECT	255.E-3-214.E-3J
   5 CHS
   ENTER	-5.000 00
   8 COMPLEX ARC
   HYP SIN	2.94E0-556.E-3J

   The first answer is still there

   input	display
   5 COMPLEX Z1 Zn	94E0-556.E-3J

   :

6. Calculate the the 3 cube roots of 5 + 3j
   

   input	display
   3 ENTER	3.000 00
   5 COMPLEX VIEW	5.00E0+3.00E0J
   3 COMPLEX Z1/n	1.77E0+322.E-3J (alpha)
   COMPLEX	-1.16E0+1.37E0J (alpha)
   COMPLEX	-606.E-3-1.69E0J (alpha)
   COMPLEX	1.77E0+322.E-3J

   :

7. Calculate: csch(1 + 2j)
   

   input	display
   2 ENTER	2.000 00
   1 COMPLEX HYP CSC	-489.E-3+1.40E0J

   :

8. Calculate: ln(4 + 5j) + (3 – 2j)^{(2 – 3j)}
   

   input	display
   5 ENTER	5.000 00
   4 COMPLEX LN	1.86E0+896.E-3J
   2 CHS
   ENTER	-2.000 00
   3 COMPLEX ENTER	3.00E0-2.00E0J
   3 CHS
   ENTER	-3.000 00
   2 COMPLEX Z2Z1	-1.79E-3-3.19E-3J
   COMPLEX +	1.85E0+893.E-3J

   :

9. Calculate: 2^(3+4j)
   

   input	display
   4 ENTER	4.000 00
   3 COMPLEX ENTER	3.00E0+4.00E0J
   2 COMPLEX NZ	-7.46E0+2.89E0J

   The number N must always be the last one that is entered.
   :

Tweaks

• The size of the complex stack can be adjusted in line 008 of program “CA”.
• If flag 14 is set when calling “CA”, the stack will not be cleared, which may be useful if you left “CA” temporarily and want to continue. This however assumes that the data registers used for the complex stack are left undisturbed.
• The program uses flag 22 “numeric entry” to determine if there is a new entry in X,Y. If there is a numeric entry, the number is first pushed onto the complex stack, respecting stack lift status. This implies that you can clear flag 22 manually if you have made an accidental digit entry and still want the next operation to be performed on the current Z1.
• Operands that require a real number input, will always take that number from the X register, new entry or not. If stack lift is disabled, the stack will first be shifted down, so the function will be performed on Z2. This is done, so that you may have ENTER ‘ed the complex number on which you want the function to be executed, and without the shift down there would be left a superfluous copy of that number on the stack.

Program listing

This program consists of two parts

1. Requires
• X-Functions module on the HP-41cv
2. Part 1 should be placed in main memory and is available as
• source code
• raw code for the V41 emulator
• bar code for the HP Wand (HP82153A)
3. Part 2, can be placed in either main or extended memory. When placed in extended memory, the instruction GTO “X” should be removed. This part is available as
• source code
• raw code for the V41 emulator
• bar code for the HP Wand
4. The keyboard overlay is available as
• image, scaled down by 98% so when printed on 4×6″, it typically comes out as true-size.
• inverted image, scaled down by 98% so when printed on 4×6″, it typically comes out as true-size.

part 1

; The program consists of two parts.  The part listed below should be in main
; memory.  The other part (listed in CA300xm.txt) can be placed in either main
; or extended memory.  When placed in extended memory, THE INSTRUCTION GTO "X"
; SHOULD BE REMOVED.
;
; Before placing the second part in XM, the program should be PACKed
; and run in RAM.  This should be done to compile all the GTO's and
; XEQ's.  If this is not done one will see CHKSUM ERR when trying to
; download this program into RAM. [9]

1	LBL "CA"
2	CF 03		; clear prefix flags (ARC, HYP)
3	CF 04
4	RAD
5	FS? 14		; if the "do not clear stack" flag is set
6	GTO 00		;   then jump to LBL 00,
7	SIZE?		;   else if needed extended the # of data registers
8	6
9	STO 00
10	ST+ X
11	3
12	+
13	X>Y?
14	PSIZE
15	CLX
16	STO 01		; clear LASTZ
17	STO 02
18	LBL 00
19	GTO "X"		 ; REMOVE THIS LINE when LBL "X" in X-memory !!
20	"\8D\BE"
21	RCL M
22	STO b		; jump to "X" in extended memory at address 0x8DBE
22	END

part 2

• Stack and alpha registers:
• The program uses all registers
• Data registers:
• R00, depth of complex stack (default value is 6)
• R01, real part of LASTZ1
• R02, imaginary part of LASTZ1
• R03, real part of complex number Z1
• R04, imaginary part of complex number Z1
• :
• R13, real part of complex number Z6
• R14, imaginary part of complex number Z6
• Note that the internal format of the complex stack is always rectangular.
• Flags:
• flag 00, “POL”, when set indicates Polar notation (POL), otherwise rectangular notation (RECT)
• flag 02, “no stack lift”, when set disables the stack lift
• flag 03, “ARC”, when set indicates inverse trigonometric operation (ARC)
• flag 04, “HYP”, when set indicates hyperbolic operation (HYP)
• flag 10, “alt operation”, allows similar operations to reuse code
• flag 14, “clipped corner”, is used for all but magnetic cards. During initialization it indicates “do not clear stack”; during keyboard fetching it indicates more key strokes need to follow; and during triogonometry operations, indicates inverse operation.
• flag 22, “keyboard input”, set when numeric input is entered from the keyboard, cleared on power cycle. [7]
• flag 25, “ignore error”, when set, ignores improper operations (like div by zero) or range errors.
• flag 30, used for “always false” test. Used to negate prior test. [7]
• flag 47, “shift set”, used internally in shifted operations.
• flag 44-46, cleared as a side effect of showing the “shift” annunciator
• flag 48-55, cleared as a side effect of showing the “shift” annunciator
• Legend:
• (x + y.j), complex number held on the regular stack
• X register holds the real part (x)
• Y register holds the imaginary part (y)
• (M . e^j.phi), complex number in polar notation

; INITIALIZE AND MAIN LOOP
;
; An infinite loop to fetch a keystroke identifying the operation to be
; executed.  The "shift" key causes the "shift" status to be toggled, for all
; other keys the LBL that matches the key code will be called (or keycode+5 if
; "shift" was active).
;
; called      : from "CA" in main memory, or
;               in response to [CINIT] keycode (labeled [ON] on keyboard)
; on entry    : when flag 14 is set, the complex stack will not be cleared
; on exit     : value of Z1 shown.  Also available as X,Y.

1	LBL "X"
2	RDN
3	FC?C 14		; if the "do not clear stack" flag is not set
4	XEQ 48		;   then clear the complex stack

5	LBL 01		; [CINIT] operation
6	CF 10
7	CF 22
8	CF 25
9	FS? 00
10	R-P
11	XEQ 10		; display complex number (x + y.j)
12	STOP
13	ENTER^
14	LBL 02
15	CLX
16	GETKEY		; wait for an operation keycode
17	X=0?
18	GTO 02
19	31
20	X#Y?		; if not the "shift" key
21	GTO 00		;   then handle that operation
22	R^  		;   else update the shift annunciator
23	R^
24	"\01\00"
25	FS? 47
26	CLA
27	RCLFLAG
28	ASTO d
29	STOFLAG
30	AOFF
31	GTO 02

32	LBL 00	   	; handle operation associated with a keycode
31	CLX
34	5
35	FC? 47		; if "shift was active"
36	CLX 		;   then increment key code by 5
37	+
38	RDN
39	CLD
40	SF 25
41	XEQ IND T	; call the corresponding operation
42	FC?C 14
43	GTO 01
44	ENTER^
45	GTO 02

; TOGGLE [ARC] MODIFIER, for ASIN, ACOS, ATAN

46	LBL 11		; [ARC], key label [sigma+]
47	FC?C 03
48	SF 03
49	SF 14		; indicate "more key strokes to follow"
50	RTN

; TOGGLE [HYP] MODIFIER, for SINH, COSH and TANH

51	LBL 16		; [HYP], key label [sigma-]
52	FC?C 04
53	SF 04
54	SF 14		; indicate "more key strokes to follow"
55	RTN

; SWITCH BETWEEN POLAR AND RECTANGULAR NOTATION

56	LBL 68		; [RECT], key label [P>R]
57	CF 00
58	GTO 00
59	LBL 69		; [POL], key label [R>P]
60	SF 00
61	LBL 00
62	RCL 04		; get Z1 from the complex stack as (x + y.j)
63	RCL 03
64	RTN

; COMPLEX RECIPROCAL (1/Z)
;
; on entry : Z in X,Y registers in the form (x + y.j)
; on exit  : the result is stored as Z1 on the complex stack
;    	     the result is stored in X,Y in the form (x + y.j)
;	     LASTZ1 holds a copy of the operation operand Z

65	LBL 12	    	; [1/Z] operation

66	XEQ 09		; push (x + y.j) onto complex stack and update LASTZ1
67	XEQ 31		; compute (x + j.y) = 1 / (x + j.y)
68	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX ENTER^
;
; on entry : Z in X,Y registers in the form (x + y.j)
; on exit  : Z is pushed up the complex stack as Z1 and Z2
;    	     Z is X,Y in the form (x + y.j)
;    	     LASTZ1 is unchanged

69	LBL 41	        ; [CENTER^] operation

70	XEQ 04		; push (x + y.j) onto complex stack
71	XEQ 11		; move complex stack up, Z1 > Z2 > Z3 > Z4 > Z5 > Z6
72	SF 02		; "no stack lift"
73	RTN

; COMPLEX CLEAR STACK
;
; on entry : n/a
; on exit  : Z1..Z6 on the complex stack are set to (0 + 0j)
;    	     LASTZ1 is unchanged

74	LBL 48	        ; [CCLST] operation

75	RCL 00
76	ISG X
77	""
78	ST+ X
79	 E3
80	/
81	3
82	+
83	.
84	LBL 36
85	STO IND Y
86	ISG Y
87	GTO 36
88	CF 02		; no "no stack lift"
89	CLST
90	RTN

; COMPLEX CHANGE SIGN AND COMPLEX CONJUGATE (Complement)
;
;     -(x + y.j) = -x - y.j  (change sign)
;     (x + y.j)* =  x - y.j  (conjugate)
;
; on entry : Z in X,Y registers in the form (x + y.j)
; on exit  : the result is stored as Z1 on the complex stack
;    	     the result is stored in X,Y in the form (x + y.j)
;	     LASTZ1 holds a copy of the operation operand Z

91	LBL 42		; [CHSZ] operation
92	SF 10
93	LBL 47		; [COMPLZ] operation

94	XEQ 04		; push (x + y.j) onto complex stack
95	FS? 10
96	CHS
97	X<>Y
98	CHS
99	X<>Y
100	GTO 03		; copy (x + y.j) to complex stack, and return

; CLEAR Z1
;
; on entry : Z in X,Y registers in the form (x + y.j)
; on exit  : Z is pushed up the complex stack as Z1 and Z2
;    	     Z is X,Y in the form (x + y.j)
;    	     LASTZ1 is unchanged

101	LBL 49	        ; [CLZ1] operation

102	XEQ 04		; push (x + y.j) onto complex stack
103	CLST
104	SF 02		; "no stack lift"
105	GTO 03		; copy (x + y.j) to complex stack, and return

; LAST Z1
;
; on entry : n/a
; on exit  : the operand from the last numeric operation (except CHSZ)
;              is pushed onto the complex stack
;    	     the operand from the last numeric operation (except CHSZ)
;              is stored in X,Y in the form (x + y.j)

106	LBL 88 	  	; [LASTZ1] operation

107	FS? 02
108	FS? 22		; if "no stack lift" or "input from keyboard"
109	XEQ 41		;   then perform ENTER^
110	CF 02
111	RCL 02		; LASTZ1
112	RCL 01
113	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX ADDITION AND SUBTRACTION
;
;     (z + t.j) + (x + y.j) = (x + z) + j.(y + t)
;     (z + t.j) - (x + y.j) = (x - z) + j.(y - t)
;
; on entry : if number was entered on the keyboard,
;              then (x + y.j) as entered in X,Y registers, and
;                   (z + t.j) from Z1 on the complex stack
;              else (x + y.j) from Z1 on the complex stack, and
;                   (z + t.j) from Z2 on the complex stack
; on exit  : the result is stored as Z1 on the complex stack
;    	     the result is stored in X,Y in the form (x + y.j)
;	     LASTZ1 holds a copy of (x + y.j)

114	LBL 51		; [C-] operation
115	SF 10
116	LBL 61		; [C+] operation

117	XEQ 07		; get two operands, as (x + j.y) and (z + j.t)
118	FS? 10
119	CHS
120	X<>Y
121	FS? 10
122	CHS
123	ST+ T
124	RDN
125	+
126	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX MULTIPLICATION AND DIVISION
;
;     Z2 * Z1 = (re1 + j.im1) * (re2 + j.im2) =
;             = (re1.re2 - im1.im2 ) + j.(im1.re1 + re1.im2)
;
;     Z2 / Z1 = Z2 * 1/Z1

127	LBL 81		; [C/] operation
128	SF 10
129	LBL 71		; [C*] operation

130	XEQ 07		; get two operands, as (x + j.y) and (z + j.t)
131	FS? 10		; if division
132	XEQ 31		;   then compute (x + j.y) = 1 / (x + j.y)
133	XEQ 00		; compute (x + j.y) * ( z + j.t)
134	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX POWER OF A COMPLEX NUMBER
;
;           (x+y.j)      z    -t.phi1    j.(z.phi1 + t.ln(r1))
;     (z+t.j)       =  r1  . e        . e
;
;   where:
;         r1   = sqrt(x^2+y^2)
;         phi1 = .... x + y.j ....????

135	LBL 17		; [Z2^Z1] operation

136	XEQ 07		; get two operands, as (x + j.y) and (z + j.t)
137	R^
138	R^
139	RAD
140	R-P
141	LN
142	XEQ 00		; compute (x + j.y) * ( z + j.t)
143	E^X
144	P-R
145	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX PARALLEL CIRCUIT, useful in network theory
;
;            Z1 . Z2
; Z1 // Z2 = -------    {for |Z1+Z2| <> 0}
;            Z1 + Z2

146	LBL 32		; [CPAR] operation
147	XEQ 07		; get two operands, as (x + j.y) and (z + j.t)
148	XEQ 31		; compute 1 / ( x + j.y)
149	R^
150	R^
151	XEQ 31		; compute 1 / ( x + j.y)
152	X<>Y
153	ST+ T
154	RDN
155	+
156	XEQ 31		; compute 1 / ( x + j.y)

; REPLACE Z1 with (x + y.j) ON COMPLEX STACK

157	LBL 03	    	; [PRGM] keycode
158	DEG		; switch to DEG mode
159	STO 03
160	X<>Y
161	STO 04
162	X<>Y
163	RTN

; MULTIPLY TWO COMPLEX NUMBERS subroutine
;
;     (x + y.j) * (z + t.j) = (x + j.y) * (z + j.im2) =
;                           = (x.z - y.t ) + j.(y.x + x.t)

164	LBL 00
165	STO L
166	R^
167	ST* L
168	X<> Z
169	ST* Z
170	R^
171	ST* Y
172	ST* Z
173	X<> L
174	+
175	X<> Z
176	-
177	RTN

; COMPLEX COMMON (base 10) and NATURAL (base e) LOGARITHM
;
;     ln(x + y.j) = ln(r) + j.phi
;
;     Z1
;       log(Z2) = ln(Z2) / ln(Z1)

178	LBL 14		; [LOG(Z)] operation
179	XEQ 08		; get operand, as (x + j.y) and update LASTZ
180	LN  		; x=ln(M1), y=phi1
181	GTO 00

182	LBL 15		; [LN(Z)] operation
183	XEQ 09		; push (x + y.j) onto complex stack and update LASTZ
184	 E		; x=1

185	LBL 00
186	RDN
187	RAD
188	R-P
189	LN
190	R^
191	ST/ Z
192	/
193	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX COMMON (base 10) and NATURAL (base e) EXPONENTIAL
;
;     (x + j.y)    x              x
;    e          = e .sin(y) + j.e .cos(y)

194	LBL 19		; [n^Z] operation
195	XEQ 08		; get operand, as (x + j.y) and update LASTZ
196	LN
197	GTO 00		; reuse part of  [E^Z] operation

198	LBL 20		; [E^Z] operation
199	XEQ 09		; push (x + y.j) onto complex stack and update LASTZ
200	 E

201	LBL 00
202	ST* Z
203	*
204	E^X
205	RAD
206	P-R
207	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX EXPONENTIATION WITH REAL EXPONENT n

208	LBL 18		; [Z^n] operation

209	XEQ 08		; get operand, as (x + j.y) and update LASTZ
210	RDN
211	R-P
212	R^
213	ST* Z
214	Y^X
215	P-R
216	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX ROOT OF REAL NUMBER n
;        __
;     Z1/         1/Z1
;     \/ Z2   = Z2
;        __
;     n /        1/n   j.(phi/n)
;     \/ Z    = M   . e

217	LBL 13		; [Z^1/n] operation

218	XEQ 08		; get operand, as (x + j.y) and update LASTZ
219	RDN
220	R-P
221	R^
222	1/X
223	Y^X
224	360
225	R^
226	ST/ T
227	ST/ Y
228	R^
229	R^
230	LBL 05
231	FC? 00
232	P-R
233	XEQ 10		; display complex number (x + y.j)
234	AON
235	STOP
236	FC? 00
237	R-P
238	R^
239	ST+ Z
240	RDN
241	DSE Z
242	GTO 05		; loop back to LBL 05
243	P-R
244	AOFF
245	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX SINE, COSECANT, COSINE AND SECANT
;
;     sin( x + j.y) = sin(x).cosh(y) + j.cos(x).sinh(y)
;     cos( x + j.y) = cos(x).cosh(y) - j.sin(x).sinh(y)
;     sinh(x + j.y) = cos(y).sinh(x) + j.sin(y).cosh(x)
;     cosh(x + j.y) = cos(y).cosh(x) + j.sin(y).sinh(x)
;     csc(x + j.y)  = 1 / sin( x + j.y)
;     sec(x + j.y)  = 1 / cos( x + j.y)
;     csch(x + j.y) = 1 / sinh(x + j.y)
;     sech(x + j.y) = 1 / cosh(x + j.y)
;
; Flags used:
;     flag 04, indicates [HYP]
;     flag 10, indicates [SIN], otherwise [COS]
;     flag 14, indicates inverse operation (CSC and COS, aka SIN^-1 and COS^-1)
;
; Reference:
;     http://en.wikipedia.org/wiki/Complex_number#Complex_analysis

246	LBL 28		; [CSC(Z)] operation
247	SF 14

248	LBL 23		; [SIN(Z)] operation
249	SF 10

250	LBL 29		; [SEC(Z)] operation
251	FC? 10
252	SF 14

253	LBL 24		; [COS(Z)] operation

254	XEQ 09		; push (x + y.j) onto complex stack and update LASTZ
255	FS?C 03		; ARC?
256	GTO 13
257	XEQ 00		; calculate cos/sin/cosh/sinh
258	ST* T
259	RDN
260	*
261	CHS
262	FC? 04		; HYP?
263	FS? 10		; SIN?
264	CHS
265	FC?C 04		; HYP?
266	FC? 10		; COS?
267	X<>Y
268	FS?C 14		; inverse operation?
269	XEQ 31		;   then compute Z1 = 1 / Z1
270	GTO 03		; copy (x + y.j) to complex stack, and return

; COMPLEX TANGENT AND COTANGENT, doesn't support ARC or HYP variations
;
;     tan(x + j.y) = sin(2.x)  / ( cosh(2.y) + cos(2.x) ) +
;                    sinh(2.y) / ( cosh(2.y) + cos(2.x) ) . j
;     cot(Z) = 1 / tan(Z)
;
; Flags used:
;     F03 indicates [ARC]
;     F04 indicates [HYP]
;     F14 indicates inverse operation (COT aka TAN^-1]

271	LBL 30		; [COT(Z)] operation
272	SF 14
273	LBL 25		; [TAN(Z)] operation
274	FS?C 03		; ARC?
275	GTO 02		;   UNSUPPORTED, jump back to main routine
276	FS?C 04		; HYP?
277	GTO 02		;   UNSUPPORTED, jump back to main routine
278	XEQ 09		; push (x + y.j) onto complex stack and update LASTZ
279	2		; multiply x and y by 2
280	ST* Z
281	*
282	XEQ 00		; calculate cos/sin/cosh/sinh (F04=0, F10=0)
283	R^
284	+
285	ST/ Z
286	/   		; answers is now as (x + y.j)
287	FS?C 14		; inverse operation?
288	XEQ 31		;   then compute Z1 = 1 / Z1
289	GTO 03		; copy (x + y.j) to complex stack, and return

; TRIGONOMIC OPERATIONS HELPER subroutine
;
; Call with:
;   complex number on the stack as (x + y.j).
;   F04 indicates [HYP]
;   F10 indicates [SIN], otherwise [COS]
;
; This operation returns:
;
;           | [HYP]    [HYP]
;	    | [SIN]    [COS]	[SIN]	[COS]
;     ------+----------------------------------
; re  y-reg | sin(y)   sin(y)   sin(x)  sin(x)
; re  z-reg | cosh(x)  sinh(x)  cosh(y) sinh(y)
;     ------+----------------------------------
; im  x-reg | cos(y)   cos(y)   cos(x)  cos(x)
; im  t-reg | sinh(x)  cosh(x)  sinh(y) cosh(y)
;
;            x     -x      2.x
;           e  -  e       e    -  1                    1
; sinh(x) = ---------  =  ---------  ,    csch(x) = -------
;                              x                    sinh(x)
;              2            2.e
;
;            x     -x      2.x
;           e  +  e       e    +  1                   1
; cosh(x) = ---------  =  ---------  ,    sech(x) = -------
;                              x                    cosh(x)
;               2           2.e
; Reference:
;     http://en.wikipedia.org/wiki/Hyperbolic_trig_operations

290	LBL 00
291	FS? 04		; HYP?
292	X<>Y		;
293	2
294	RCL Z
295	ST+ X
296	E^X-1
297	ST+ Y
298	R^
299	E^X
300	ST+ X
301	ST/ Z
302	/
303	FS? 10		; SIN? (not COS)
304	X<>Y		;
305	R^
306	RAD
307	SIN
308	R^
309	COS
310	RTN

; INVERSE TRIGONOMIC OPERATIONS, ARC and HYP-ARC
;
;     arcsin(x + y.j) = arcsin(b) + j.sign(y).ln(a + sqrt(a^2-1)
;     arccos(x + y.j) = arccos(b) - j.sign(y).ln(a + sqrt(a^2-1))
;     arccsc(Z)  =    arcsin(1/Z)
;     arcsec(Z)  =    arccos(1/Z)
;     arcsinh(Z) = -j.arcsin(j.Z)
;     arccosh(Z) =  j.arccos(Z)
;     arccsch(Z) =  j.arccsc(j.Z)
;     arcsech(Z) =  j.arcsec(Z)
;   where
;     a = ( sqrt( (x+1)^2 + y^2 ) + sqrt( (x-1)^2 + y^2) ) / 2
;     b = ( sqrt( (x+1)^2 + y^2 ) - sqrt( (x-1)^2 + y^2) ) / 2
;     sign(y) returns 1 when y>=0, othewise returns -1
;
; Flags used:
;     F04 indicates [HYP]
;     F10 indicates [SIN], otherwise [COS]
;     F14 indicates inverse operation (CSC and COS, aka SIN^-1 and COS^-1]
;
; Reference:
;     http://en.wikipedia.org/wiki/Inverse_trigonometric_operation

311	LBL 13
312	FS?C 14		; inverse operation?
313	XEQ 31		; compute Z1 = 1 / Z1
314	FS? 04		; HYP flag
315	FC? 10
316	GTO 00
317	X<>Y
318	CHS
319	LBL 00		; entered with Z1 as (x + y.j)
320	RCL X
321	 E
322	ST- Z
323	+
324	X^2
325	X<>Y
326	X^2
327	X<> Z
328	X^2
329	ST+ Z
330	+
331	SQRT
332	STO Z
333	X<>Y
334	SQRT
335	ST- Z
336	+
337	2
338	ST/ Z
339	/   		; X holds a;  Y holds b; Z holds y
340	ENTER^
341	X^2
342	SIGN
343	ST- L
344	X<> L
345	SQRT
346	+
347	LN
348	R^
349	SIGN
350	*
351	FC? 10
352	CHS
353	X<>Y
354	RAD
355	FS? 10
356	ASIN
357	FC? 10
358	ACOS		; Z1 (x + y.j) now holds the answer to simple ARCSIN or ARCCOS
359	FC?C 04
360	GTO 03		; we're done for non-HYP operations;
361	FS? 10		; proceed for for HYP or inverse-HYP
362	CHS
363	X<>Y
364	FC? 10
365	CHS
366	GTO 03		; copy (x + y.j) to complex stack, and return

; VIEW COMPLEX NUMBER Zn

367	LBL 89		; [VIEWZn] operation
368	RCL 00
369	X<Y?		; if n > complex stack depth, recall Z1 and return
370	GTO 14		; get (x + y.j) from complex stack, and return
371	SIGN
372	+
373	ST+ X
374	SIGN
375	CLX
376	RCL IND L	; recall imaginary part of Zn
377	DSE L
378	RCL IND L	; recall real part of Zn
379	FS? 00		; if notation selected
380	R-P 		;   then convert to polar notation
381	XEQ 10		; display complex number (x + y.j)
382	PSE 		; pause, but allow number input
383	GTO 14		; get (x + y.j) from complex stack, and return

; EXCHANGE COMPLEX STACK REGISTERS

384	LBL 21		; [Z1<>Z2] operation
385	XEQ 04		; push (x + y.j) onto complex stack
386	2
387	LBL 26		; [Z1<>Zn] operation
388	RCL 00
389	X<Y?
390	GTO 14		; get (x + y.j) from complex stack, and return
391	X<>Y
392	ST+ X
393	1.003002	; X register holds 1.003002; Y register holds 2.n,
394	CF 02		; no "no stack lift"
395	GTO 00		; perform register swap and return

; COMPLEX STACK ROLL, up or down
;
; Does not roll around
; Uses block rotate trick form PPC Journal V10N3p15a

396	LBL 22		; [CR^] operation
397	SF 10
398	LBL 27		; [CRDN] operation

399	XEQ 04		; push (x + y.j) onto complex stack
400	3
401	ENTER^
402	5
403	FS? 10		; CR^?
404	X<>Y
405	RCL 00		; complex stack depth (csdepth)
406	DSE X
407	ST+ X
408	 E3
409	ST/ Z
410	X^2
411	/
412	+		; for CRDN
413	LBL 00
414	+
415	REGSWAP		; register swap for sss.dddnnn

; GET (x + y.j) FROM COMPLEX STACK

416	LBL 14
417	RCL 04		; imaginary part of Z1
418	RCL 03		; real part of Z1
419	RTN

; COMPLEX 1/Z1
;
; Formula:
;      1             x                 y
;    -------  =  ---------  -  j . ---------
;    x + y.j     x^2 + y^2         x^2 + y^2
;
; doesn't disturb Z and T
420	LBL 31
421	X^2
422	X<>Y
423	STO M
424	ST* X
425	ST+ Y
426	X<> M
427	CHS
428	X<>Y
429	ST/ Y
430	ST/ L
431	X<> L
432	RTN

; GET TWO OPERANDS as (x + j.y) and (z + j.t)
; 1st operand is from keyboard, otherwise from Z1
; stack management subroutine for operations with two complex number operands

433	LBL 07
434	XEQ 06		; get one operand (x + y.j) from keyboard input
                        ;  otherwise from Z1 on the complex stack
435	FC?C 02
436	FC? 22		; if "no stack lift" or no "input from keyboard"
437	XEQ 12		;   then move complex stack down
438	RCL 04		; get operand (z + t.j) from Z1 on the complex stack
439	RCL 03
440	R^
441	R^
442	GTO 00

; GET OPERAND, as (x + j.y) and UPDATE LASTZ
; stack management subroutine for operations with one complex and one real number operand

443	LBL 08	   	; called with n in register X
444	FS?C 02		; if "no stack lift"
445	XEQ 12		;   then move complex stack down, Z1 < Z2 < Z3 < Z4 < Z5 < Z6
446	RCL 04		; copy Z1 to LASTZ
447	STO 02
448	RCL 03
449	STO 01
450	RCL Z		; n in register X, complex operand as (y + z.j)
451	RTN

; PUSH (x + y.j) ONTO COMPLEX STACK and UPDATE LASTZ
; stack management subroutine for operations with one complex number operand

452	LBL 09
453	XEQ 04		; push (x + y.j) onto complex stack
454	LBL 00
455	STO 01		; copy to LASTZ1
456	X<>Y
457	STO 02
458	X<>Y
459	RTN

; COMPLEX ALPHA/ALPHA ROUTINE

460	LBL 04	      	; [CVIEW] key code [ALPHA]
461	FC?C 02
462	FC? 22
463	FS? 30		; if both "no stack lift" and "keyboard input"
464	XEQ 11		;   then move complex stack up, Z1 > Z2 > Z3 > Z4 > Z5 > Z6

465	XEQ 06		; get one operand
466	STO 03
467	X<>Y
468	STO 04
469	X<>Y
470	RTN

; GET ONE OPERAND (x + y.j)
; from keyboard input, otherwise from Z1 on the complex stack 

471	LBL 06
472	FS? 00		; if in polar mode, then convert it to Rect
473	FC? 22
474	FS? 30
475	P-R
476	FS? 22		; keyboard input?
477	RTN
478	RCL 04
479	RCL 03
480	RTN

; DISPLAY
; in rectangular mode "x + y.j", or in polar mode "x <y" with the
; angle in degrees
; subroutine that views both parts of the complex number in X and Y in
; condensed format in the display, without disturbing Z, T or the display
; mode.  ENG 2 was chosen because, to display complex numbers in analog
; electronics.

481	LBL 10		; Z1 = x + j.y
482	SIGN		; save X in LASTX
483	RDN
484	CLA
485	RCLFLAG		; save flags
486	ENG 2
487	ARCL L
488	RDN
489	FS? 00		; in Rectangular notation append real part,
490	GTO 00		; and '+' sign if imaginary part is positive
491	X<0?
492	GTO 00
493	>"+"
494	LBL 00
495	R^
496	FS? 00		; for Polar notation, append angle ('<') sign
497	>"<"
498	ARCL Y
499	FC? 00
500	>"J"		; in Rectangular notation append 'J' char
501	AVIEW
502	STOFLAG		; restore flags
503	X<> L		; restore X from LASTX
504	RTN

; ROLL THE COMPLEX STACK, by one position up or down
; subroutine to shift the stack up or down by one complex register
;
; Does not roll around like RDN or R^
; Does not enter or retrieve data.
;
; Example:
;                  | stack lift | stack drop
;    --------------+------------+------------
;    Z6    6 + 6j  |   5 + 5j   |   6 + 6j
;    Z5    5 + 5j  |   4 + 4j   |   6 + 6j
;    Z4    4 + 4j  |   3 + 3j   |   5 + 5j
;    Z3    3 + 3j  |   2 + 2j   |   4 + 4j
;    Z2    2 + 2j  |   1 + 1j   |   3 + 3j
;    Z1    1 + 1j  |   1 + 1j   |   2 + 2j

505	LBL 11		; stack lift, Z1 > Z2 > Z3 > Z4 > Z5 > Z6
506	3.005		;   typically when a new number is moved into Z1
507	GTO 00
508	LBL 12		; stack drop, Z1 < Z2 < Z3 < Z4 < Z5 < Z6
509	5.003		;   typically when a operation combines Z1 and Z2
510	LBL 00
511	SIGN
512	RCL 00		; complex stack depth (csdepth)
513	X<>Y
514	ST- Y
515	RDN
516	ST+ X
517	 E6
518	ST/ Y
519	X<> L
520	+		; register X is in sss.dddnnn format
521	REGMOVE		; copies 2*(csdepth-1) registers from sss to ddd
522	RDN
523	END

References

History

Around 1985, Michiel Niemeijer published a similar program for the HP-41 in the Dutch publication HP User News [1].  I am not sure if that was the source.  My changes were aimed at making the user experience more intuitive. This article lists my version 1.1 from October 12, 1986.

Now, twenty-five years later, I restored my HP-41CV and use the program once again. The HP-41 version is also verified to run under Windows using Warren Furlow’s V41 simulator when compiled with Leo Duran’s hp41uc.

Theory

Consider the monic fourth-order polynomial [3]

A root of polynomial p(z) is a number x_i such that p(x_i)=0.  Each n^th-order polynomial has exactly n roots.  These roots may be real or complex.  Then we have p(z₁)=0, p(z₂)=0, p(z₃)=0, p(z₄)=0, and we can write

This is the factored form of the monic polynomial.  Multiplying out the symbolic factored form gives a nonlinear system of four equations and four unknowns.  Solving it gives

Examples

Assumes FIX 3 and SIZE 15.

1. Calculate the roots for: x⁵ – x⁴ – 101.x³ + 101.x² + 100.x – 100 = 0
   

   entry	display
   XEQ “POL5″	ORDER?
   5 R/S	X^5= ?
   1 R/S	X^4= ?
   1 CHS
   R/S	X^3= ?
   101 CHS
   R/S	X^2= ?
   101 R/S	X^1=?
   100 R/S	CONST?
   100 CHS
   R/S	1.000
   R/S	-1.000
   R/S	10.000
   R/S	1.000
   R/S	-10.000
   R/S	END

2. Calculate the roots for: x⁴ + x³ + x² + 11.x + 10 = 0
   

   entry	display
   R/S	ORDER?
   4 R/S	X^4= ?
   1 R/S	X^3= ?
   1 R/S	X^2= ?
   1 R/S	X^1= ?
   11 R/S	CONST= ?
   10 R/S	-1.000
   R/S	-2.000
   R/S	1.000+2.000J
   R/S	1.000-2.000J
   R/S	END

3. Calculate the roots for: x³ – x² + x – 1 = 0
   

   entry	display
   XEQ “POL5″	ORDER?
   3 R/S	X^3= ?
   1 R/S	X^2= ?
   1 CHS
   R/S	X^1= ?
   1 R/S	CONST?
   1 CHS
   R/S	1.000E-10+1.000J
   R/S	1.000E-10-1.000J
   R/S	1
   R/S	END

Method

The 5^th root is numerically factored, although there are other methods. [3]

Program listing

• Requires
• X-Functions module on the HP-41cv
• Available as
• source code
• raw code for the V41 emulator
• bar code for the HP Wand (HP82153A)
• Size
• The program takes 527 bytes including the END, and fits on 5 magnetic tracks.
• Registers used
• R00, constant
• R01, 1st order coefficient
• :
• R05, 4th order coefficient
• R06, highest order
• R07, loop variable for coefficient input
• R08, subroutine label (highest coefficient + 10)
• R09, display loop variable (dd)
• Flags used
• flag 00, when set R00/R01 holds complex roots (R00+-R01.j), otherwise R00/R01 holds real roots
• flag 02, when set, R02/R03 holds complex roots (R02+-R03.j), otherwise R02/R03 holds real roots

01	LBL "POL5"
02	SF 00		; no complex root in R00/R01
03	FIX 0
04	CF 29
05	"ORDER ?"
06	PROMPT
07	STO 06		; highest order coefficient
08	STO 07		; loop variable for coefficient input
09	 E1
10	+
11	STO 08

12	LBL 21		; coefficients input
13	"X^"
14	ARCL 07
15	>"= ?"
16	PROMPT
17	FS?C 00		; complex root in R00/R01?
18	GTO 20
19	RCL IND 06	; convert to depressed form
20	/
21	LBL 20
22	STO IND 07
23	DSE 07		; decrement loop variable
24	GTO 21
25	"CONST ?"
26	PROMPT
27	RCL IND 06
28	/
29	STO 00

30	SF 29		; "digit grouping"
31	FIX 3
32	 E		; x=1
33	STO IND 06	; highest order coefficient is 1 (because depressed form)
34	-1
35	STO 09		; init dd to -1
36	GTO IND 08	; jump to label matching highest order of polynomial

; SOLVE 2nd ORDER

37	LBL 12
38	XEQ 08		; find two roots
39	XEQ 09		; display two roots
40	GTO 11

; SOLVE 3rd ORDER

41	LBL 13
42	XEQ 10		; Find 3 roots
43	XEQ 09		; display first two roots
44	XEQ 16		; display next root
45	GTO 11

; SOLVE 4th ORDER

46	LBL 14
47	XEQ 18		; find four roots
48	XEQ 09		; display first two roots
49	XEQ 09		; display next two roots
50	GTO 11

; SOLVE 5th ORDER

51	LBL 15
52	XEQ 19		; find five roots
53	XEQ 09		; display first two roots
54	XEQ 09		; display next two roots
55	XEQ 16		; display next root

; FINISH UP, and get ready to do it again

56	LBL 11
57	"END"
58	PROMPT
59	XEQ "POL5"

; DISPLAY TWO ROOTS

60	LBL 09
61	CLA
62	ISG 09		; dd++
63	""              ; NOP
64	FC?C IND 09	; if they are not a complex roots,
65	GTO 17		;   then display two real roots

66	RCL IND 09	; display complex root in rectangular form
67	ISG 09
68	""
69	RCL IND 09
70	ABS
71	ARCL Y
72	>"+"
73	ARCL X
74	>"J"
75	AVIEW
76	STOP
77	CLA		; display conjugate of that root in rectangular form
78	ARCL Y
79	CHS
80	ARCL X
81	>"J"
82	PROMPT
83	RTN

; DISPLAY TWO REAL ROOTS

84	LBL 17
85	DSE 09		; dd
86	""              ; NOP
87	XEQ 16		; display next root, then fall through to show the next one

; DISPLAY ONE REAL ROOT

88	LBL 16
89	CLA
90	ISG 09		; dd points to next root
91	""              ; NOP
92	ARCL IND 09	; display register pointed to by dd
93	PROMPT
94	RTN

; FIND FIVE ROOTS
;
; on entry:
;   depressed form coefficients a0, a1, a2, a3, a4 in R00 .. R04
;
; on exit:
;   if FS?00 then root1 = (R00 + R01.j) and root2 = (R01 - R01.j)
;            else root1 = (R00 +   0.j) and root2 = (R01 -   0.j)
;   if FS?02 then root3 = (R02 + R03.j) and root4 = (R02 - R03.j)
;            else root3 = (R02 +   0.j) and root4 = (R03 -   0.j)
;   root5 = (R04 + 0.j)

95	LBL 19
96	RCL 00
97	STO N		; N = a0
98	 E
99	%
100	STO M		; M = a0 / 100
101	CLST

102	LBL 00		; on entry Z=1
103	RCL Z		; X=Z
104	STO O		; O = starts with 1
105	4   		; fn = a0 + n*(a1 + n*(a2 + n*(a3 + n*(a4 + n))))
106	RCL N
107	LBL 01
108	RCL IND Y
109	+
110	RCL N
111	*
112	DSE Y
113	GTO 01
114	RCL 00
115	+
116	ST* M		; M = M * fn
117	ST- O		; O = O - fn
118	RCL M
119	RCL O
120	X#0?		; if (O <> 0 )
121	/		;   then M = M / O
122	STO M		;   else M = 0

123	X<> N           ; N = N + M
124	ST+ N
125	RCL N
126	X#Y?		; if ( N <> M )
127	GTO 00		;   then next iteration

128	RCL O		; Eliminate 5th root
129	R^  		;   a3' = a4 + root5->re
130	*		;   a2' = a3 + root5->re * a3
131	+		;   a1' = a2 + root5->re * a2
132	X<> 04          ;   a0' = a1 + root5->re * a1
133	3
134	X<>Y            ; root5 = N + O * fn
135	 E
136	LBL 02
137	RCL 04
138	*
139	+
140	ENTER^
141	X<> IND Z
142	X<>Y
143	DSE Z
144	GTO 02
145	RCL 04
146	*
147	+
148	STO 00		; rolls over to "FIND FOUR ROOTS"

; FIND FOUR ROOTS
;
; on entry:
;   depressed form coefficients a0, a1, a2, a3 in R00 .. R03
;
; on exit:
;   if FS?00 then root1 = (R00 + R01.j) and root2 = (R01 - R01.j)
;            else root1 = (R00 +   0.j) and root2 = (R01 -   0.j)
;   if FS?02 then root3 = (R02 + R03.j) and root4 = (R02 - R03.j)
;            else root3 = (R02 +   0.j) and root4 = (R03 -   0.j)

149	LBL 18
150	RCL 01
151	STO N		; N = a1
152	X^2
153	RCL 00
154	STO M		; M = a0
155	RCL 02
156	CHS
157	STO O		; O = -a2
158	STO 02
159	4
160	*
161	RCL 03
162	ST* 01
163	X^2
164	+
165	*
166	+
167	CHS
168	X<> 00          ; Now:
169	4		;   a2' = -a2                  (R02)
170	*		;   a1' = a1*a3-4*a0	       (R01)
171	ST- 01		;   a0' = a0*(4*a2-a3^2)-a1^2  (R00)

172	XEQ 07		; Find 3 roots

173	RCL 02		; Determine largest root
174	FS? 00		;   if complex root in R00/R01, then
175	GTO 06          ;     X = root3->re
176	RCL 01		;   else
177	X<Y?            ;     X = maximum of root1->re, root2->re, root3->re
178	X<>Y
179	RCL 00
180	X<Y?
181	X<>Y            ; X = largestRoot

182	LBL 06 		; Eliminate the largest root
183	STO 00		;   A = a3/2
184	STO 02     	;   B = largestRoot/2
185	RCL O		;   C = sqrt(A*A-a2+largestRoot);
186	+   		;   D = sqrt(B*B-a0);
187	RCL 03		;   S = sign(A*B-a1/2))    (sign returns 1 if >=0, -1 if  02
225	STO 00
226	RCL 01
227	X<> 03
228	STO 01
229	CF 02
230	FS? 00
231	SF 02		; Find the next two roots
232	CLA		;   a1' = A - S.C;
233	GTO 03 		;   a0' = B - D;

; FIND THREE ROOTS
;
; on entry:
;   depressed form coefficients a0, a1, a2 in R00 .. R02
;
; on exit:
;   if FS?00 then root1 = (R00 + R01.j) and root2 = (R01 - R01.j)
;            else root1 = (R00 +   0.j) and root2 = (R01 -   0.j)
;   root3 = (R02 + 0.j)

234	LBL 10		; Find the 3rd root
235	LBL 07
236	XEQ 04
237	RCL 02
238	3
239	/
240	-

241	STO 00		; Eliminate the 3rd root
242	ST+ 02
243	RCL 02
244	*
245	ST+ 01
246	RCL 02
247	X<> 01          ; Find the next two roots (rolls over to LBL 08)
248	X<> 00          ;     a1' = a2 + root3->re                           (R01)
249	STO 02		;     a0' = a1 + root3->re * ( a2 + root3->re)       (R00)

; FIND TWO ROOTS
;
; on entry:
;   depressed for coefficients a0, a1 in R00 .. R01
;
; on exit:
;   if FS?00 then root1 = (R00 + R01.j) and root2 = (R01 - R01.j)
;            else root1 = (R00 +   0.j) and root2 = (R01 -   0.j)

250	LBL 08
251	LBL 03
252	CF 00
253	RCL 00
254	4
255	*
256	RCL 01
257	STO 00
258	X^2
259	-		; discr = (a1^2)/4 - a0;
260	X>0?            ; discr > 0?
261	SF 00
262	ABS
263	SQRT
264	2
265	CHS
266	ST/ 00
267	/
268	CHS
269	STO 01
270	FS? 00		; complex root in R00/R01?
271	RTN 		; X = sqrt(abs(a0-a1^2/4))

272	RCL 00
273	STO 01
274	RDN
275	ST+ 00
276	ST- 01
277	RTN 		; X = sqrt(abs(a0-a1^2/4))

; FIND 3RD ROOT HELPER, returns the real part + a2/3 in X
;
; on entry:
;   depressed form coefficients a0, a1, a2 in R00 .. R02
;
; on exit:
;   Note the ' sign, because to get root3, 2/3 needs to be subtracted
;   X register holds (root3 + a2/3)

278	LBL 04
279	RCL 01	        ; Method:
280	RCL 02	        ;   p = a1/3 - a2^2/9
281	X^2 		;   q = a1*a2/6 - a2^3/27 - a0/2;
282	3		;   tmp = p^3 + q^2
283	/
284	-
285	3
286	/
287	RCL 01
288	RCL 02
289	*
290	6
291	/
292	RCL 02
293	3
294	/
295	LASTX
296	Y^X
297	-
298	RCL 00
299	2
300	/
301	-
302	X=0?		; if (q==0) then
303	RTN		;     X = (0 + 0.j)

304	STO Z  	        ; else
305	X^2
306	X<>Y
307	3
308	Y^X
309	+		;     if (tmp < 0)
310	Xre' = 2*(q^2+sqrt(-tmp)^2)^1/3 *
311	GTO 05		;             cos(phi(q,sqrt(-tmp))/3)

312	SQRT		;     else
313	ST- Z		;         X = sign(q-sqrt(tmp))*abs(q-sqrt(tmp))^1/3 +
314	+   		;             sign(q+sqrt(tmp))*abs(q+sqrt(tmp))^1/3
315	SIGN
316	LASTX
317	ABS
318	3
319	1/X
320	Y^X
321	*
322	X<>Y
323	SIGN
324	LASTX
325	ABS
326	3
327	1/X
328	Y^X
329	*
330	+
331	RTN

332	LBL 05
333	CHS
334	SQRT
335	X<>Y
336	R-P
337	3
338	1/X
339	Y^X
340	X<>Y
341	3
342	/
343	COS
344	*
345	ST+ X
346	RTN

347	END

References

History

I wrote this code in October 1986.  I uses some modified functions to improve accuracy.

Instructions

The labels automatically map to the user keyboard. Note that some hyperbolic operations leave the stack disturbed.

Examples

1. Calculate the sinh(1)
   

   GTO “HYP”
   USER
   1 SIN	1.1752

Listing

• Requires
• X-Functions module on the HP-41cv
• Available as
• source code
• raw code for the V41 emulator
• bar code for the HP Wand (HP82153A)
• Size
• 12 registers; 78 bytes including END; 1 magnetic track (78/112=0.70)

01	LBL "HYP"

02	LBL H	; [sinh]
03	STO M
04	E^X-1
05	LASTX
06	E^X
07	/
08	RCL M
09	E^X-1
10	+
11	LBL 00
12	2
13	/
14	RTN

15	LBL I 	; [cosh]
16	E^X
17	1/X
18	LASTX
19	+
20	GTO 00

21	LBL J	; [tanh]
22	XEQ H
23	RCL M
24	XEQ I
25	/
26	RTN

27	LBL C	; [asinh]
28	X^2
29	LASTX
30	X<>Y
31	 E
32	+
33	GTO 01

34	LBL E	; [atanh]
35	 E
36	+
37	ENTER^
38	ENTER^
39	2
40	-
41	/
42	CHS
43	LN
44	GTO 00

45	LBL D	; [acosh]
46	X^2
47	LASTX
48	X<>Y
49	 E
50	-
51	LBL 01
52	SQRT
53	+
54	LN
55	END

Theory

Multiplying a vector with a square matrix, usually changes both the magnitude (scale) and the direction of the vector.  In the special case where it changes only the magnitude of the vector and leaves the direction unchanged (or switches the vector to the opposite direction), that vector is called an eigenvector of that matrix.

When multiplied by a matrix, each eigenvector of that matrix changes its magnitude by a factor, called the eigenvalue corresponding to that eigenvector.  In other words: vector x is called an eigenvector of the matrix A with eigenvalue λ if the following equation holds [5]

A.x = λ.x

The eigenvalues of A are precisely the solutions λ to the equation det(A – λ.x) = 0. Here det() is the determinant of matrix formed by A – λ.I in which I is a n×n identity matrix. This equation is called the characteristic equation of A.

For a more detailed description including complex eigenvalues, refer to my article “Complex Eigenvalues for HP-41cv/cx“

Method

The program uses the iterative power method to determine the largest eigenvalue. This value is removed from the matrix using the deflation method of Hotelling [1]. The remaining eigenvalues are determined in a similar way. Note that accumulation of rounding errors will affect the accuracy of successive eigenvalues.

The power method is an iterative method for approximating eigenvalues. This method is perhaps not the most respected method, and can only be used when:

• There are no two identical eigenvalues.
• The start vector is not the null vector.
• The matrix does not contain complex eigenvalues. (The method will typically work well with a strongly dominated diagonal).

If desired, the eigenvectors can be calculated from the original matrix A. (The deflation method spoils the eigenvector, but not the eigenvalue.)

Examples

1. Matrix A
   
   

   keystrokes	display
   FIX 3
   XEQ “EW”	DIM?
   2 R/S	INV.MATRIX:
   	1:1=0.000?
   8 R/S	1:2=0.000?
   4 R/S	2:1=0.000?
   3 R/S	2:2=0.000?
   6 R/S	INV.STARTV.:
   	1:1=0.000?
   1 R/S	2:1=0.000?
   1 R/S	EPS=0.001?
   R/S	10.500
   	:
   	10.605
   	EW=10.606
   R/S	INV.STARTV.:
   	1:1=0.838?
   1 R/S	2:1=0.546?
   1 R/S	EPS=0.001?
   R/S	-0.230
   	3.393
   	3.394
   	EW=3.394
   R/S	EINDE

   The computed eigenvalues 10.606 and 3.394 can be verified through:
   

   This is also verified through the characteristic polynomial. The eigenvalues of A are precisely the solutions λ to the equation listed below with I is the n×n identify matrix.
   
   
   Therefore:
   
   The solutions to this equation are the eigenvalues λ_i.
   The JavaScript calculator “Eigenwerte und Eigenvektoren berechnen” provides another verification [7].

Listing

• Requires
• X-Functions module on the HP-41cv
• Advantage ROM
• Available as
• source code
• raw code for the V41 emulator
• bar code for the HP Wand (HP82153A)
• Size
• 39 registers
• Registers:
• alfa, X, Y, Z, T, L
• R00: epsilon
• R01: loop counter
• R02: eigenvalue
• Long jumps:
• 41
• 95

;  /---------------------------------------------------------------------\
;  |                      E i g e n v a l u e s                          |
;  |                                                                     |
;  |                            for the HP-41                            |
;  \---------------------------------------------------------------------/
;
;                                   1.00
;                               Coert Vonk
;
;            http://www.coertvonk.com/technology/hp41/eigenvalues-4606

01      LBL "EW"
02       E-4            ; default eps
03      STO 00
04      CF 08
05      "DIM ?"         ; invoer dimensie
06      PROMPT
07      ABS
08      INT
09      STO 01
10      ENTER^
11      ENTER^
12       E3
13      /
14      +
15      "INP. MATRIX:"
16      AVIEW
17      "B"
18      XROM 22,29      ; MATDIM: creeer B-matrix
19      "A"
20      XROM 22,29      ; MATDIM: creer A-matrix
21      XROM 22,61      ; MEDIT: invoer A-matrix

22      LBL 00
23      "A"
24      XROM 22,18      ; DIM?
25      INT
26      "INP. STARTV.:"
27      AVIEW
28      "W"             ; creer W-vector
29      XROM 22,29      ; MATDIM
30      "V"             ; creer V-vector
31      XROM 22,29      ; MATDIM
32      XROM 22,61      ; MEDIT: invoer V-vector
33      XROM 22,19      ; FNRM
34      "STARTV. ERR"
35      X=0?
36      AVIEW
37      X=0?
38      PSE             ; als startvector
39      X=0?            ; de nulvector is
40	GTO 00		; dan opnieuw
41	XEQ 03
42	RCL 00
43	"EPS="
44	ARCL X
45	>"?"
46	PROMPT		; invoer epsilon
47	STO 00
48	LBL 01
49	"W"
50	XROM 22,57      ; SUM
51	XROM 22,18      ; DIM?
52	INT
53	/
54	VIEW X		; tussenresultaat v/d e.g. laten zien
55	STO 02
56	RCL 00
57	XROM 22,33      ; MIN
58	+
59	XROM 22,30      ; MAX
60	X<=Y?		; test of er aan de nauwkeurigheid eps word voldaan
61	GTO 00		; zo  ja, spring
62	XEQ 03		; zo nee, ga verder
63	GTO 01

; toon de gevonden e.w.

64	LBL 00
65	RCL 02
66	"EV="
67	ARCL X
68	PROMPT
69	DSE 01		; alle ew nog niet gevonden?
70	GTO 04		; dan spring naar 04
71	"V"
72	PURFL		; maak de extended-memory weer schoon
73	"W"
74	PURFL
75	"A"
76	PURFL
77	"B"
78	PURFL
79	"EINDE"		; we're done
80	PROMPT
81	GTO E

; zeef de gevonden eigenwaarde uit de laatst gebruikte matrix (A)

82	LBL 04
83	 E
84	"X,V,W"
85	XROM 22,25      ; MAT*
86	"W"
87	XROM 22,59      ; TRNPS
88	"V,W,B"
89	XROM 22,24      ; M*M
90	RCL 02
91	"X,B"
92	XROM 22,25      ; MAT*
93	"A,B,A"
94	XROM 22,27      ; MAT-
95	GTO 00

; voer een iteratie slag uit volgens de powermethode
; zodat v:=A*v en w:=e.w. vector

96	LBL 03
97	"A,V,W"
98	XROM 22,24      ; M*M
99      "W,V"
100     XROM 22,28      ; MAT/
101     1.001
102     XROM 22,18      ; DIM?
103     RCL Y
104     "V,W"
105     XROM 22,49      ; MSWAP
106     "V"
107     XROM 22,19      ; FNRM
108     1/X
109     "X,V"
110     XROM 22,25      ; MAT*
111	RTN

112	END

References

History

I wrote this in 1987.

Theory

The Fourier Transform of a continuous-time signal x(t) may be defined as

In digital signal processing the input signal is in sampled form.  The Discrete Fourier Transform (DTF) is a numerical approximation to the Fourier Transform. [1]

Method

The sequence of N complex numbers x₀, …, x_N−1 is transformed into another sequence of N complex numbers according to the Discrete Fourier Transform formula listed below [2].

Examples

1. Sampling a sinus function using 8 samples a period.

   01  LBL "FIE"
   02  45
   03	 *
   04  SIN
   05  VIEW X
   06  RTN

   n	An	Bn	Mn	Φn
   1	0.9003	-0.3729	0.975	-0.125*π
   2	0.0000	0.0000	0.000	0.250*π
   3	0.0000	0.0000	0.000	0.000*π
   4	0.0000	0.0000	0.000	0.000*π
   5	0.0000	0.0000	0.000	0.000*π
   6	0.0000	0.0000	0.000	-0.125*π
   7	0.1286	0.0533	0.139	0.125*π
   8	0.0000	0.0000	0.0000	0.000*π

   :

2.  Same example, but with a hamming correction.

   01  LBL "FIE"
   02  45
   03	 *
   04  SIN
   05  XEQ "HC"
   05  VIEW X
   06  RTN

   n	An	Bn	Mn	Φn
   1	0.4505	-0.1865	0.487	-0.125*π
   2	-0.1592	0.1592	0.225	0.750*π
   3	0.0000	0.0000	0.000	-0.687*π
   4	0.0000	0.0000	0.000	0.000*π
   5	0.0000	0.0000	0.000	-0.687*π
   6	-0.0531	-0.531	0.075	-0.750*π
   7	0.0643	0.266	0.070	0.125*π
   8	0.0000	0.0000	0.000	0.000*π

   :

3. Sampling a sinus function using 10 samples with a sample time of 1/8 * T_signal:

   01  LBL "FIE"
   02  360
   03  *
   04  8
   05  /
   06  SIN
   07  VIEW X
   08  RTN

   n	An	Bn	Harm	MODn	Φn
   1	0.7201	0.3802	0.8	0.814	0.155*π
   2	-0.3335	-0.0787	1.6	0.343	-0.926*π
   3	-0.1650	-0.0206	2.4	0.166	-0.961*π
   4	-0.1146	0.0064	3.2	0.115	-0.982*π
   5	-0.0900	0.0000	4.0	0.090	1.000*π
   6	-0.0764	0.0043	4.8	0.077	0.982*π
   7	-0.0707	0.0088	5.6	0.071	0.961*π
   8	-0..0834	0.0197	6.4	0.086	0.926*π
   9	-0.0800	-0.0422	7.2	0.090	-0.155*π
   10	0.0000	0.0000	8.0	0.000	0.000*π

   :

4. Same with the hamming correction

   01	LBL "FIE"
   02	360
   03	*
   04	8
   05	/
   06	SIN
   07	VIEW X
   08	XEQ "HC"
   09	RTN

   n	An	Bn	Harm	MODn	Φn
   0	0.4263	0.2038	0.8	0.472	0.142*π
   1	-0.316	-0.0532	1.6	0.321	-0.947*π
   2	-0.0262	-0.0050	2.4	0.027	-0.060*π
   3	0.0041	-0.0019	3.2	0.005	-0.134*π
   4	0.0017	0.0000	4.0	0.002	0.000*π
   5	0.0028	0.0012	4.8	0.003	0.134*π
   6	0.0112	0.0021	5.6	0.011	0.060*π
   7	-0.0791	0.0133	6.4	0.080	0.947*π
   8	-0.0474	-0.0226	7.2	0.052	-0.0142*π
   9	0.0000	0.000	8.0	0.000	0.000*π

   :

5. Manual

   01  LBL "FIE"
   02  "N"
   03  FIX 0
   04  ARCL X
   05  >"?"
   06  PROMPT
   07  RTN

Listing

• Requires
• X-Functions module on the HP-41cv
• Available as
• source code
• raw code for the V41 emulator
• bar code for the HP Wand (HP82153A)

01	LBL "DFT"
02	DEG
03	sREG 11		; ΣREG
04	CLS  	  	; CLΣ
05	"HARM=?"
06	PROMPT
07	STO 00
08	"M=?"
09	PROMPT
10	"MONSTER:"
11	AVIEW
12	STO 03
13	STO 01
14	/
15	STO 02
16	180
17	ST* 02
18	1
19	ST- 01
20	RCL 01
21	.01
22	+
23	 E3
24	/
25	STO 01
26	LBL 00
27	RCL 01
28	INT
29	ST+ X
30	1
31	+
32	RCL 02
33	*
34	ENTER^
35	SIN
36	X<>Y
37	COS
38	STO 04
39	X<>Y
40	STO 05
41	RCL 01
42	INT
43	XEQ "FIE"
44	RCL 05
45	RCL 04
46	RCL Z
47	*
48	X<>Y
49	LASTX
50	*
51	S+		; Σ+
52	ISG 01
53	GTO 00
54	RCL 02
55	SIN
56	RCL 00
57	/
58	PI
59	/
60	ST+ X
61	ST* 11
62	ST* 13
63	FIX 0
64	"A"
65	ARCL 00
66	>"="
67	FIX 4
68	ARCL 11
69	PROMPT
70	"B"
71	FIX 0
72	ARCL 00
73	>"="
74	FIX 4
75	ARCL 13
76	PROMPT
77	RCL 13
78	RCL 11
79	R-P
80	"AMP="
81	FIX 3
82	ARCL X
83	PROMPT
84	X<>Y
85	180
86	/
87	FIX 3
88	"ARG="
89	ARCL X
90	>"*PI"
91	AVIEW
92	RTN

; Hamming Correction

93	LBL "HC"
94	1
95	RCL 01
96	INT
97	RCL 03
98	/
99	360
100	*
101	COS
102	-
103	2
104	/
105	*
106	END

References

1. Source
• Magnetism is caused by moving charged electrical particles (Faraday, 1830s).  These particles can be the current of electrons through an electric wire, or the movement of charged particles (protons and electrons) within an atom.  These charged particles move much like planets in a solar system:
• nucleus spin around its own axis, causing a very weak magnetic field.
• electrons orbit around the nucleus, causing a weak magnetic field.
• electrons spin around their own axis at the speed of light, causing a significant magnetic field (Goudsmit and Kronig, 1925).
• Spinning electrons generate the bulk of the magnetism in an atom.
• Within each orbit, electrons with opposite spins pair together, resulting in no net magnetic field.
• Electrons in an orbit are filled up first by a + spin.  Once all the orbitals are filled with unpaired + spins, the orbitals are then filled with the – spin. (see Spin direction)
  :
2. Characteristics
• The electron configuration in an atom determines a the magnetic characteristics:
• In diamagnetic material, such as copper (Cu), all electrons are paired together.  There is no net magnetic field from the electrons.
• In paramagnetic material, such as magnesium (Mg), there are unpaired electrons.  The atoms align to an external magnetic field.  It becomes magnetized while the external field is present.
• In ferromagnetic material, such as iron (Fe), there are unpaired electrons also.  In this case, the atoms not only align to an external magnetic field, but also orient parallel to each other.  Thus, even when the applied field is removed, the electrons maintain in a parallel orientation.
• experiment: use a magnet to stroke a ferromagnetic bar, such as iron, several times in the same direction.  The magnetic force from the north pole of the magnet causes the unpaired electrons to align themselves.  The iron will stay magnetic.
• See also Electron spin, Theories of magnetism, How atoms work, and Goudsmit’s lecture.
• added challenge
• MIT lectures 8.02,
• NDT article,
• Relativity tells us that what looks like a pure magnetic ¯eld in one frame of reference looks like an electric ¯eld in another frame of reference.

Properties

1. Magnetics
• The magnetic field (B) is very strong at the poles and weakens as the distance to the poles increases.
• A magnetic field line (Faraday) is a theoretical line that loops through the north pole of a magnet, passing through surrounding space, enter the southing pole and going through the magnet back to the north pole.  A higher density of nearby field lines indicates a stronger magnetic field.  Field lines are a visual and conceptual aid only and are no more real than the contour lines (constant altitude) on a topographic map.
• simulation: move compass and bar magnet using Faraday’s Lab.
• experiment: visualize magnetic field using iron filings on paper/glass with bar magnet underneath.
  :
2. Two magnets
• Interaction
• Opposites attract.
• Same poles repel.
• The force between the two poles is directly proportional to the product of the pole strengths and inversely proportional to the square of the distance between the poles.
• A compass is tiny magnet balanced on a pivot.  It will rotate to point toward the opposite pole of a magnet.
• Experiment: suspend a magnet from a string.  It will align with the earth’s magnetic field, so that its S-pole points to the Earth’s N-pole.
  :
3. Induction
• A material that is attracted by a magnet becomes a magnet itself.
• As an iron nail is brought close to a bar magnet, some flux lines emanating from the north pole of the magnet pass through the iron nail in completing their magnetic path. Since magnetic lines of force travel inside a magnet from the south pole to the north pole, the nail will be magnetized in such a polarity that its south pole will be adjacent to the north pole of the bar magnet. There is now an attraction between the two magnets.
• experiment: move an iron nail to a bar magnet.  Touch another nail to the end of the first nail.  The magnetic field from the bar magnet will align the unpaired spins.  First the ones closest to the bar magnet.  This process can be repeated until the strength of the magnetic field weakens with the distance from the bar magnet.  As soon as the first nail is pulled away from the bar magnet, all the nails will fall. Each nail had become a temporary magnet, but once the magnetizing force was removed, the unpaired spins once again assumed a random distribution
• See also  …..

Electromagnetism

1. Wire
• A moving charge (current) through a wire produces a magnetic field (Ørsted 1819, Ampère 1820).
• The magnetic field lines form concentric circles around the wire.
• The strength of the magnetic field:  |B| = μ₀.|I| /2Πr, where μ₀ is the permeability of free space, I is the current, r is the distance from the wire.
• The direction of the field follows the right-hand rule convention for vectors.  In this case, the corkscrew rule, where the thumb points in the direction of the current, and the fingers point in the direction of the magnetic field lines.
• Experiment, paper with iron filings, wire perpendicular to this paper and few seconds of strong current (100 A) through the wire.
• See also the lecture Magnetic field and Lorentz Force, MIT.
  :
2. Wire in magnetic field experiences force
• A charge moving through a magnetic field experiences a force F_B^→ = q . (v^→ × B^→), where v is the speed of the charge, q is the value of the charge and B^→ is the magnetic field (Lorenz, 1892).
• The direction of F_B^→ is perpendicular to both the direction of the charge and the magnetic field.  The direction is the cross product of v^→ and B^→, and as such defined according to the right-hand rule for vectors.   With the thumb, index, and middle fingers at right angles to each other (with the index finger pointed straight), the first (index) finger represents the first vector in the product (v^→); the second (middle) finger represents the second vector (B^→); and the thumb represents the product (F_B^→).
• Animation, Lorenz force, Univ. of Florida.
• Experiment, current perpendicular to magnetic field.  Thin wire (50 cm) suspended in between strong magnets.  Connect wire to switch and two D-cell batteries.
• Experiment, wire in between two poles demo as part of the lecture Magnetic field and Lorentz Force, MIT.
• Experiment, Homopolar motor.  (see also Homopolar)
  :
3. Coil in magnetic field
• make one, http://science.howstuffworks.com/how-to-make-electromagnet.htm
4. Rotor in magnetic field
• Simple motor, using D-cell battery, magnet, 2 clothes pins, and coil. (video, video2)
5. Eddy currents.  Two equal masses slide down two identical aluminum tubes. Since one of the masses is magnetic it will induce eddy currents according to Lenz’ Law. This damps the motion of the mass causing the magnetic mass to take much longer to fall through the tube

other stuff

How voltage is produced: http://www.tpub.com/neets/book1/chapter1/1k.htm

• very strong at the poles and weakens as the distance to the poles increases;
• goes from the north pole of a magnet, pass through surrounding space, enter the south pole and go through the magnet back to the north pole, thus forming a closed loop.
• experiment: visualize magnetic field using iron filings on paper/glass with bar magnet underneath.

Homopolar motor, Wiki.

1. Book, “Science Explorer – From bacteria to plants, §1″ (Prentice Hall)
   • Grows
   • Uses energy
   • Responds to their surroundings
   • Reproduces

Where does life come from?

1. Life comes from other life, but where did the first life come from?
2. First a little bit of Chemistry
   • Book, “Science Explorer – Chemical Interactions Resources” (Foss Middle School)
     • A molecule is the smallest part of a substance that still has the same properties.  E.g. a water molecule is called H₂O.
     • Molecules are build out of atoms.   E.g. a water molecule consists out of two Hydrogen (H₂) and Oxygen (O₂) atoms.
     • Atoms are build out of protons, electrons and neutrons.  E.g.  a Hydrogen (H₂) atom consists of 1 proton and 1 electron.
   • Web page, “Atoms, Elements and Molecules Q&A” (Jefferson Lab)
   • Web page, “Atoms structure” (chem4kids.com)
3. Birth of our solar system
   • Web page, “Very brief history of the universe” (suite101.com)
   • Web page, “Origin of the chemical elements” (suite101.com)
   • Video, “Origins – Back to the beginning” (NOVA)
     • 13.75 billion years ago, there was a super explosion, from which a cloud of hydrogen (H) and helium (He) formed.
     • From the dust stars were born.  The stars were very big and inside the pressure and temperature extremely high.  H atoms fused together to form He atoms.  This released energy as heat and light.  When it ran out of H, they started to burn He instead.  This He atom fused together to form carbon (C), oxygen (O) and nitrogen (N).  These are the basic ingredients of life.
     • Once no more elements could be fused it stopped and the star exploded.
     • In the middle of a dust cloud, pressure and temperature rose and our Sun was born.
   • Video, “Origins – Earth is born” (NOVA)
     • Dust particles attached to each other and formed our planets.
     • 4.5 billion years ago, Earth was born.
     • Many comets fell into the earth.  These comets were big ice rocks from space that gave us water.
     • 4.4 – 4.1 billion years ago, the crust of the Earth cooled down and and water condensed.
   • Web page, “Abiogenesis” (Wikipedia)
   • Web page, “History of life” (Wikipedia)
   • Interview, “How did life begin” (NOVA)
   • Web site, “Exploring life’s origins” (Museum of science, Boston)
   • Web page, “Organic chemistry, biochemistry” (NY State Uni)
   • Web page, “Timeline of evolution” (Wikipedia)
   • Web page, “A hitchhiker’s guide to early earth” (Lawrence Livermore Lab)
   • Web page, “Miller-Urey experiment” (Wikipedia), “Miller/Urey experiment” (Duke Uni.)
   • Online book, “Amino acids, peptides and proteins” (Oxford Uni.)
   • Web animation, “Protein formation animation” (Montana State Uni.)
   • Web site, “Animating biology” (Carnegie Mellon Uni.)
   • Web page, “The RNA World and the origins of life” (US Nat’l Lib. of Medicine)
   • http://web.visionlearning.com/custom/chemistry/animations/CHE1.3-an-animations.shtml
   • Video, “Where did we come from?” (NOVA)
   • Video, “Origins – How life began” (NOVA)
     • All living things, are made from a small set of chemical elements: hydrogen (H), oxygen (O), carbon (C) and nitrogen (N) — four of the most common elements in the universe.
     • Life requires molecules that can catalyze reactions that lead, directly or indirectly, to the production of more molecules like themselves.  The following steps are might have generated live on Earth:
       1. Atoms of C, H, O and N can fill their outer electron shells by forming covalent bonds.  The resulting molecules include amino acids (Black for 2.16a), sugar alcohols such as ribose (2.11b) and glycerol (2.11c), fatty acids (2.13a), phosphoric acid (2.20b) and nitrogenous bases (2.22).  There are different theories of where these bonds could have formed:
          • in puddles (see “Where did we come from?“)
            • 2BD
            • Experiments show that the building blocks of RNA can assemble themselves naturally.  (John Sutherland)
          • near deep see volcanoes (see “Iron-sulfur world theory“)
            • Hot volcanic gasses (CO, NH₃, H₂S) in the deep ocean pass over a metal catalyst generate catalytic metallo-peptides. Further energy from sulfides of iron in redox reaction.  Energy available for the synthesis of organic molecules but also for the formation of oilomers and polymers.  Such systems may be able to evolve into autocatalytic sets of self-replicating, metabolically active entities that would predate the life forms known today.
            • Organisms collected at deep sea volcanoes are similar to some of the earliest organisms that existed on the Earth.
          • delivered by comets (see “Miller/Urey experiment“)
            • Lightning or UV-light from the sun can help in the creation of certain basic small molecules (monomers) of life, such as amino acids.  Amino acids are the basic building blocks of proteins and cells.
            • The energy from the impact of the comet fused amino acids together to form more complex molecules called peptides (< 50 amino acids linked together).
            • Experiments show that amino acids can assemble themselves naturally. (Miller–Urey)
       2. Covalent bonds between amino acids form long chains called proteins.  Proteins provide structure and control the rate of chemical reactions in cells.
       3. Covalent bonds between glycerol, two fatty acids chains and a phosphoric acid (H₃PO₄) creates a phospolipid.  The number of protons, electrons, energy level of the electrons and place in a molecule determine how much an atom attracts electrons  (see “electronegativity“).  An unequal relationship between atoms creates a polar covalent bond.  In phospholipids, the phosphate group is polar and can interact with water molecules, which are polar too, but the two long, uncharged fatty acid tails cannot.  As a result these molecules in water form lipid bilayers, a main component of the cell membrane.  The membrane provides a stable physical and chemical environment (see “Phospholipid membranes“)
       4. Covalent bonds between a nitrogenous base, ribose and phosphoric acid salt creates a nucleotide.  (see “Abiogenesis“)
          • Long chains of nucleotides form random (pre-)RNA molecules and result in self-replicating ribozymes (see “RNA world“).
          • Selection pressures for catalytic efficiency and diversity might have resulted in ribozymes which catalyse peptidyl transfer (hence formation of small proteins), since oligopeptides complex with RNA to form better catalysts. The first ribosome might have been created by such a process, resulting in more prevalent protein synthesis.
          • Synthesized proteins might then outcompete ribozymes in catalytic ability, and therefore become the dominant biopolymer, relegating nucleic acids to their modern use, predominantly as a carrier of genomic information.
     • Life evolves
       1. Selection pressures for catalytic efficiency and diversity result in ribozymes which catalyse peptidyl transfer (hence formation of small proteins), since oligopeptides complex with RNA to form better catalysts. Thus the first ribosome is born, and protein synthesis becomes more prevalent.
       2. Proteins outcompete ribozymes in catalytic ability, and therefore become the dominant biopolymer. Nucleic acids are restricted to predominantly genomic use.
     • aa
     • 3.9 – 2.5 billion years ago, simple cells “Prokaryotes” appear
       • They use CO₂ as a carbon source and get energy from oxidizing inorganic materials such as H₂S, FeO, H2 or NH₃.
       • Later, they evolve glycolysis, a set of chemical reactions that free the energy of organic molecules such as glucose and store it in the chemical bonds of ATP.  Glycolysis (and ATP) continue to be used in almost all organisms, unchanged, to this day.
     • 3.5 billion years ago, first archaea (3 RNA polymerases)
       • Organisms generate ATP by exploiting a proton gradient.
     • 2.7 billion years ago, photosynthetic cyanobacteria
       • They use water as a reducing agent, thereby producing oxygen as waste product.  The oxygen oxidizes dissolved iron in the oceans creating iron ore.
       • Snottites, single-cell bacteria that burn H₂S (?)
     • 2.5 billion years ago, cyanobacteria, oxygen appears
       • Microbes evolved a green pigment known as chlorophyll.  This allowed them to trap sunlight and use it to drive a chemical reaction that converts carbon dioxide (CO2) and water (H₂O) into food.  This “photosynthesis” enabled some bacteria to grow and reproduce almost without limit.  Life could spread, literally, over the entire planetary surface.  As a byproduct of photosynthesis, the ancient bacteria produced a waste gas: oxygen (O₂).
     • 1.85 billion years ago, first complex cells (Eukaryotes), primitive algae
     • 1.2 billion years ago, sexual reproduction, increasing rate of evolution
     • 1.2 billion years ago, multi-cellular organisms
       • The oxygen (O₂) level raised from 1% to 21% allowing multi-cellular life
     • 600 million years ago, first skeletons
     • 500 million years ago, first fish
     • 475 million years ago, first land plants
     • 400 million years ago, first insects and seeds
     • 360 million years ago, first amphibians
     • 300 million years ago, first reptiles
     • 200 million years ago, first mammals
     • 150 million years ago, first birds
     • 130 million years ago, first flowers
     • 2.5 million years ago, first genus homo
     • 2 million years ago, homo erectus
     • 0.2 million years ago, homo sapiens (similar to how we look today)
     • 0.006 million years ago, sumerians invent civilization
     • 0.002 million years ago, Roman Empire civilizes Europe
     • 0.000007 million years ago, you were born

Book, “Science Explorer – Cells and heredity” (Prentice Hall)

Questions

1. How are they not eaten?
2. What do they eat?
3. How do they get through the fall and winter?
4. How they reproduce?
5. How they live their lives?
6. How they get there food?
7. Differences  between plants and animals?
8. How they attack hungry predators?
9. How they digest their food?
10. How they are different from plants and animals?
11. Are they plants or animals?
12. How they look under a microscope?

Group your questions

1. Introduction (cells)
2. Plants
3. Animals
4. Protists

For each of the 3 groups answer

1. Species
   • Are they plants or animals?
   • How they look under a microscope?
   • Differences between plants and animals?
   • How they are different from plants and animals?
2. Feeding
   • What do they eat?
   • How do they get their food?
   • How do they digest their food?
   • How they live their lives?
3. Survival
   • How are they not eaten?
   • How they attack hungry predators?
   • How do they get through the fall and winter?
   • How do they reproduce?

(Alternate grouping)

1. Plants, protists and animals
2. Food chain
3. Life cycle
4. Under the microscope

Resources

Cells

• Web site “Classification of Living Things” (National Earth Science Teachers Association)
• Web site “Cell structure” (biology4kids.com)
• Web site “Biology course” (Uni. of California)
• Web site “Biology book” (Estrella Mountain CC)
• Web page “Eukayote” (simple Wikipedia)

Plants

• Web page What is the difference between plants and animals? (answers.com)
• Web page “Photosynthesis” and “Chloroplast” (biology4kids.com)
• Web page “Photosynthesis” (howstuffworks.com)
• Video “Photosynthesis” (howstuffworks.com)

Animals

• Web page “How cells obtain energy” (ebiomedia.com)
• Science project “Life is everywhere” (education.com)
• Web page “Cellular respiration” (wikipedia.com)
• Video “Cells, Tissues, Organs, and Systems” (nasa.gov)

Microorganisms

• Book “A world in a drop of water” (Alvin and Virginia Silverstein)
• Web page “Menu of microscopy and microscopes” (Microscopy UK)
• Web page “Photosynthesis, using algae wrapped in jelly balls” (Science and plants for schools)
• Teacher Notes “Pond water survey” (sciencespot.net)
• Web page “Biological specimens, fresh water” (micrographia.com)
• Picture “Algae sex-tape” (nationalgeographic.com)
• Web page “Paramecium” (101science.com)

Moving from CS3 to CS4/CS5

If you were one of the early adapters, you might have followed my guide Editing AVCHD 24p using Adobe Premiere Pro CS3.  If you made the jump to CS4 or CS5, you can not tweak your old projects so that they use the .mts files directly.  The following work flow did the trick for me:

1. Open the .prproj file using a text editor such as GNU Emacs, and search “.avi<” and replace it with “.mts”.  Once you are there, you may as well replace “<FrameBlend>true” with “<FrameBlend>false” to disable frame blending.
2. Move the .avi files (in the odd chance that you still have them) out of the way
3. Open the project in Premiere Pro.  It will automatically port it to the new version.  When it complains about the .mts being missing, just say “offline all”.
4. Once in Premiere, select all the .mts files and right-click.  Select “link media”, then point it to the .mts file.

Premiere Pro makes a fair attempt at removing the pull-down, but on high motion scenes, it misses the boat and doubles frames or leaves interlaced frames.  At first glance, playing with the the Field Options appears to help, but closer inspection of the rendered output will reveal doubled frames giving the video a stuttered look.  Those who shoot “24p wrapped in 60i” and expect a correct pulldown will need additional steps.

Oddly enough the companion product After Effects CS5 (AE) does a better job at removing the pull-down.  Maybe one day, the Premiere Pro developers will decide to reuse the .mts import functionality from After Effects.  Until then, you will need some additional legwork to extract the 24p from the 60i container.  For this, the following approaches come to mind:

1. Import the Premiere Project in After Effects.  Right-click each clip and have it Interpret and “Guess 3:2 pulldown”.  This can be automated by using a script such as ReverseTelicine.jsx.  The only downside is that AE only supports a subset of the Premiere Pro elements.  Titles and most transitions will be rendered as black video.
2. Import the clips in After effects and have it guess the 3:2 pulldown, create compositions and dynamic link those for use in Premiere Pro.  This will only work in the Premium version.
3. Use After Effects to convert the 24p-in-60i .mts files to 24p .mp4 files.  This can be achieved by importing the .mts files; select them all; and run ReverseTelicine.jsx to have it guess the cadence; select them all clips and add them to the Render Queue.  One would then import these 24p .mp4 files in Premiere Pro, or if you have an existing project using .mts files, you would replace the .mts assets with the equivalent .mp4 assets.  Note that AE still makes some mistakes, but beats PP.
4. Stick with the approach outlined in Editing AVCHD 24p using Adobe Premiere Pro CS3.  It takes a lot if disk space, but it is fast and accurate.  This might feel as two steps forward and one step back, but it is correct and the approach that I use myself.

Inconsistent state information

Creating a Blu-ray image is challenging to Encore. More often than not, the BD creation will fail with error messages such as:

• Blu-ray Error: “device not ready”, Code: “3″, Note “File can not open.(…\AuthorScriptHDMVSessions\….ac3.ves)
• Blu-ray Object: “nameoftimeline”, Error: “invalid parameter”, Code: “19″, Note: “Failed in Open of the VES file”
• Blu-ray Object: “nameofmenu”, Export file not found

To work around these errors, either delete the .ves file in question, or take out the big guns and delete the AuthorScriptHDMVSessions (and the Cache subdirectories) from the project directory. This causes Encore to re-analyze all of the assets and clear up the confusion.

Bugs, bugs and nothing but bugs

Authoring dual layer discs may cause problem such as:

• Blu-ray Error: “Not enough free storage”, Code: “25″, Note: “Not enough space on media” on 50G DL BD-R.
• Blu-ray Error: “file already exists”, Code: “6″, Note “10485888 10489952 11826176″

Cache\HDMVProjectExport.log reveals “Not enough space on media, layer 0 size greater than max layer size”. Encore estimated the size of .m2ts files wrong, and as a result it can not fit the content on the first layer. See forums.adobe.com. A closer look at the .log will point you to the file that it has problems placing. Some times adding/deleting some BD-ROM Content, or re-encoding at a different bitrate appears to work around the problem. Alternately one can use “burn to folder” and then create an .iso using imgburn

Subtitle woes

Error messages that fall into this category are

• Timecode overlap found in subtitle script line
• Blu-ray error encore cs5 code 13 errors in some PGs (when you told Encore to ignore the gab requirement)
• Errors in Some PGs: end time of preceding display set is too close to the start time of succeeding display set, see trace log for more information

There should be a gap of about 3 to 5 frames between subtitles. This appears to be a Encore specific “feature”. To work around this, use the scripting engine from Subtitle Workshop 4 to create these gap. Remember to set the correct frame rate in Subtitle Workshop! Note that in some rare circumstances this script truncates subtitles to 0 length when there is no space for them.

(* --------------------------------------------------------------------------
 *               Enforce 5 frame gap for Adobe Encore subtitles
 *                    Subtitle Workshop 4 - Pascal scripts
 *                          http://www.coertvonk.com
 *
 * Adobe Encore is very picky about enforcing a gap between subtitles.
 * This routine will enforce a 222 msec gap.  For 24p that corresponds to
 * about 5 frames.
 *
 * This script prevents errors like "subtitle too close" in Encore
 *
 * Remember to set the correct frame rate (FPS) before calling this script
 *
 * Usage: place this script in the "Subtitle Workshop\PascalScripts"
 *        directory.  Run the script from Subtitle Workshop via
 *        Tools/Pascal scripts menu, Tools > Pascal scripts > BlurayGap.pas
 *)

program BlurayGap;

var
   ii	     : Integer;
   Count     : Integer;
   start     : Integer;
   final     : Integer;
   startNext : Integer;
   gap       : Integer;

begin
   gap := 222; // [msec]
   Count := GetSubtitleCount;<br />

   for ii := 0 to Count-2 do
   begin
      start := GetSubtitleInitialTime(ii);
      final := GetSubtitleFinalTime(ii);
      startNext := GetSubtitleInitialTime(ii+1);

      if final + gap > startNext then
      begin
	 if startNext > start + gap then
	    SetSubtitleFinalTime(ii, startNext - gap)
	 else
	    SetSubtitleFinalTime(ii, start); (* should really delete the subtitle .. *)
      end;
   end;

end.