The Museum of HP Calculators

Determinants for the HP-41

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

1°) Determinants of order 3
2°) Determinants of order 4
3°) Determinants of order 5 ( X-Functions Module required )
4°) Determinants of order n ( n < 18 )

-Determinants of order n may be computed by the programs "LS" or "LS2" which are listed in "Linear and non-linear systems for the HP-41"
-However, all the following programs are faster and give more accurate results.

( For n = 2 , writing a subroutine like LBL "D2" RCL 01 RCL 04 * RCL 02 RCL 03 * - END would be probably wasteful )

1°) Deteminants of order 3

Data Registers: R00 = unused ( Registers R01 thru R09 are to be initialized before executing "D3" )

                                • R01 = a₁₁   • R04 = a₁₂   • R07 = a₁₃
                                • R02 = a₂₁   • R05 = a₂₂   • R08 = a₂₃
                                • R03 = a₃₁   • R06 = a₃₂   • R09 = a₃₃
Flags: /
Subroutines: /

01 LBL "D3"
02 RCL 05
03 RCL 09
04 *
05 RCL 06
06 RCL 08
07 *
08 -
09 RCL 01
10 *
11 RCL 02
12 RCL 09
13 *
14 RCL 03
15 RCL 08
16 *
17 -
18 RCL 04
19 *
20 -
21 RCL 02
22 RCL 06
23 *
24 RCL 03
25 RCL 05
26 *
27 -
28 RCL 07
29 *
30 +
31 END

( 38 bytes / SIZE 010 )

STACK INPUT OUTPUT

X / Deteminant

                                            | 4 9 2 |                                                 R01 R04 R07
Example:    Calculate D = | 3 5 7 |     Store these 9 numbers into    R02 R05 R08      respectively
                                            | 8 1 6 |                                                 R03 R06 R09

and XEQ "D3" >>>> Det = 360 ( in 1 second )

2°) Deteminants of order 4

-Determinants of order 4 are computed by a sum of products of determinants of order 2.

Data Registers: R00 = determinant at the end ( Registers R01 thru R16 are to be initialized before executing "D4" )

                                • R01 = a₁₁   • R05 = a₁₂   • R09 = a₁₃   • R13 = a₁₄
                                • R02 = a₂₁   • R06 = a₂₂   • R10 = a₂₃   • R14 = a₂₄
                                • R03 = a₃₁   • R07 = a₃₂   • R11 = a₃₃   • R15 = a₃₄
                                • R04 = a₄₁   • R08 = a₄₂   • R12 = a₄₃   • R16 = a₄₄
Flags: /
Subroutines: /

01 LBL "D4"
02 RCL 02
03 RCL 07
04 *
05 RCL 03
06 RCL 06
07 *
08 -
09 RCL 09
10 RCL 16
11 *
12 RCL 12
13 RCL 13
14 *
15 -
16 *
17 STO 00
18 RCL 01
19 RCL 07
20 *
21 RCL 03
22 RCL 05
23 *
24 -
25 RCL 10
26 RCL 16
27 *
28 RCL 12
29 RCL 14
30 *
31 -
32 *
33 ST- 00
34 RCL 01
35 RCL 06
36 *
37 RCL 02
38 RCL 05
39 *
40 -
41 RCL 11
42 RCL 16
43 *
44 RCL 12
45 RCL 15
46 *
47 -
48 *
49 ST+ 00
50 RCL 01
51 RCL 08
52 *
53 RCL 04
54 RCL 05
55 *
56 -
57 RCL 10
58 RCL 15
59 *
60 RCL 11
61 RCL 14
62 *
63 -
64 *
65 ST+ 00
66 RCL 02
67 RCL 08
68 *
69 RCL 04
70 RCL 06
71 *
72 -
73 RCL 09
74 RCL 15
75 *
76 RCL 11
77 RCL 13
78 *
79 -
80 *
81 ST- 00
82 RCL 03
83 RCL 08
84 *
85 RCL 04
86 RCL 07
87 *
88 -
89 RCL 09
90 RCL 14
91 *
92 RCL 10
93 RCL 13
94 *
95 -
96 *
97 ST+ 00
98 RCL 00
99 END

( 114 bytes / SIZE 017 )

STACK INPUT OUTPUT

X / Deteminant

                                            |   1    8   13 12 |                                                         R01   R05   R09   R13
Example:    Calculate D = | 14 11   2    7   |       Store these 16 numbers into        R02   R06   R10   R14      respectively
                                            |   4    5   16   9   |                                                         R03   R07   R11   R15
                                            | 15 10   3    6   |                                                         R04   R08   R12   R16

XEQ "D4" >>>> Det = 0 ( in 3 seconds )

3°) Deteminants of order 5

-Determinants of order 5 are computed by a sum of products of determinants of order 2 by determinants of order 3.
-Registers R00 to R25 are temporarily disturbed during the calculations, but their contents are finally restored.

Data Registers: R00 = det A at the end ( Registers R01 thru R25 are to be initialized before executing "D5" )

                                • R01 = a₁₁   • R06 = a₁₂   • R11 = a₁₃   • R16 = a₁₄   • R21 = a₁₅
                                • R02 = a₂₁   • R07 = a₂₂   • R12 = a₂₃   • R17 = a₂₄   • R22 = a₂₅
                                • R03 = a₃₁   • R08 = a₃₂   • R13 = a₃₃   • R18 = a₃₄   • R23 = a₃₅
                                • R04 = a₄₁   • R09 = a₄₂   • R14 = a₄₃   • R19 = a₄₄   • R24 = a₄₅
                                • R05 = a₅₁   • R10 = a₅₂   • R15 = a₅₃   • R20 = a₅₄   • R25 = a₅₅
Flags: /
Subroutines: /

01 LBL "D5"
02 CLX
03 STO 00
04 10.005
05 XEQ 01
06 ST- 00
07 5.005
08 XEQ 01
09 ST+ 00
10 5
11 XEQ 01
12 ST- 00
13 CLX
14 XEQ 01
15 ST+ 00
16 .005
17 XEQ 01
18 ST- 00
19 5.005
20 XEQ 01
21 ST+ 00
22 10.005
23 XEQ 01
24 ST- 00
25 CLX
26 XEQ 01
27 ST+ 00
28 5
29 XEQ 01
30 ST- 00
31 10
32 XEQ 01
33 ST+ 00
34 RCL 00
35 RTN
36 LBL 01
37 1.016005
38 +
39 REGSWAP
40 RCL 07
41 RCL 13
42 *
43 RCL 08
44 RCL 12
45 *
46 -
47 RCL 01
48 *
49 RCL 06
50 RCL 13
51 *
52 RCL 08
53 RCL 11
54 *
55 -
56 RCL 02
57 *
58 -
59 RCL 06
60 RCL 12
61 *
62 RCL 07
63 RCL 11
64 *
65 -
66 RCL 03
67 *
68 +
69 RCL 19
70 RCL 25
71 *
72 RCL 20
73 RCL 24
74 *
75 -
76 *
77 END

( 148 bytes / SIZE 026 )

STACK INPUT OUTPUT

X / Deteminant

                                            |   1    7   13   19   25 |                                                         R01   R06   R11   R16   R21
                                            | 14 20 21    2     8   |                                                         R02   R07   R12   R17   R22
Example:    Calculate D = | 22   3    9    15   16 |       Store these 25 numbers into        R03   R08   R13   R18   R23       respectively
                                            | 10 11 17   23    4   |                                                         R04   R09   R14   R19   R24
                                            | 18 24   5     6    12 |                                                         R05   R10   R15   R20   R25

XEQ "D5" >>>> Det = -4680000 ( in 19 seconds )

Notes:

-When these first 3 programs stop, registers R01 thru Rn² are unchanged.
-All the examples are determinants of magic squares.
( those of "D4" & "D5" are panmagic squares )

4°) Deteminants of order n ( n < 18 )

-This program tries to triangularize the matrix A by Gaussian elimination.
-The following listing is very similar to "LS2" ( cf "Linear and non-linear Systems for the HP-41" )
-When a pivot equals zero, 0 is stored in register R00 and the algorithm stops.

Data Registers: R00 = det A at the end ( Registers R01 thru Rn² are to be initialized before executing "DET" )

                                • R01 = a₁₁   • Rn+1 = a₁₂ ..................... • Rn²-n+1 = a_1n
                                • R02 = a₂₁   • Rn+2 = a₂₂ ..................... • Rn²-n+2 = a_2n
                                    ........................................................................................

• Rnn = a_n1 • R2n = a_n2 ..................... • Rn² = a_nn

Flags: CF 00 = a pivot p is regarded as zero if | p | < 10^-7 ( line 60 ) CF 01 = partial pivoting
SF 00 = ---------------------------- if p = 0 SF 01 = no pivoting

Subroutines: /

01 LBL "DET"
02 STO Y
03 .1
04 %
05 +
06 STO N
07 FRC
08 STO O
09 *
10 1
11 STO 00
12 ST+ O
13 LASTX
14 %
15 +
16 +
17 LBL 01
18 STO M
19 FS? 01
20 GTO 04
21 INT
22 RCL O
23 FRC
24 +
25 ENTER^
26 ENTER^
27 CLX
28 LBL 02
29 RCL IND Z
30 ABS
31 X>Y?
32 STO Z
33 X>Y?
34 +
35 RDN
36 ISG Z
37 GTO 02
38 RCL M
39 ENTER^
40 FRC
41 R^
42 INT
43 +
44 X=Y?
45 GTO 04
46 LBL 03
47 RCL IND X
48 X<> IND Z
49 STO IND Y
50 ISG Y
51 RDN
52 ISG Y
53 GTO 03
54 RCL 00
55 CHS
56 STO 00
57 LBL 04
58 CLX
59 FC? 00
60   E-7                          ( or another "small" number to identify the "tiny" elements )
61 RCL IND M
62 ST* 00
63 ABS
64 X<=Y?
65 GTO 07
66 ISG O
67 X<0?
68 GTO 08
69 RCL O
70 STO P                       ( synthetic )
71 LBL 05
72 RCL M
73 ENTER^
74 FRC
75 RCL P
76 INT
77 +
78 RCL IND X
79 RCL IND Z
80 /
81 SIGN
82 ISG Y                        Delete lines 82 to 84 if you want to zero the sub-diagonal elements.
83 CLX
84 ISG Z
85 LBL 06
86 CLX
87 RCL IND Z
88 LASTX
89 *
90 ST- IND Y
91 ISG Y
92 CLX
93 ISG Z
94 GTO 06
95 ISG P
96 GTO 05
97 RCL N
98 ST+ O
99 SIGN
100 RCL M
101 +
102 ISG X
103 GTO 01                     ( a three-byte GTO )
104 LBL 07
105 CLX
106 STO 00
107 LBL 08
108 RCL 00
109 CLA
110 END

( 168 bytes / SIZE n²+1 )

STACK INPUT OUTPUT

X n Deteminant

where n is the order of the square matrix.

3 XEQ "DET" >>>> Det = 360 ( in 9 seconds )

                                                      8     1     6
-The triangularized matrix is now     0   8.5   -1                however, registers R02             do not contain 0
                                                      0     0   90/17                                         R03   R06

-If you want to zero these sub-diagonal elements, delete lines 82-83-84 ( but it will slow execution )

Notes:

-"DET" is approximately 35% faster than "LS2"
-Execution time t depends of course on the number of rows exchanges when pivoting,
but if n = 7 , t is of the order of 1 minute
if n = 17 , ------------------ 11 minutes

-If you prefer to choose the "small" number p that identifies tiny elements by yourself:

-Replace register M by register Q
-Replace lines 58 to 60 by RCL M
-Replace line 02 by STO M X<> Y

-In this case, the inputs must be:

       STACK         INPUTS         OUTPUTS

            Y              n              /

            X              p          det A

where n is the order of the matrix,
and p is the "small" number you have choosen.

Go back to the HP-41 software library
Go back to the general software library
Go back to the main exhibit hall