hp41programs

Sedenions Sedenions for the HP-41

Overview

1°) Multiplication

a) Program#1
b) Program#2

2°) Reciprocal
3°) Exponential

a) Program#1
b) Program#2

4°) Logarithm
5°) Raising an Sedenion to a Power

a) Real Exponent
b) Sedenion Exponent

6°) Hyperbolic Functions

a)   Sinh S
b)   Cosh S
c)   Tanh S

7°) Inverse Hyperbolic Functions

a)   ArcSinh S
b)   ArcCosh S
c)   ArcTanh S

8°) Trigonometric Functions

a)    Sin S
b)    Cos S
c)    Tan S

9°) Inverse Trigonometric Functions

a)    ArcSin S
b)    ArcCos S
c)    ArcTan S

10°) Sedenionic Equations

1°) Multiplication of 2 Sedenions

a) Program#1

-An sedenion is an element x₀ + x₁ e₁ + ..... + x₁₅ e₁₅ of S = R¹⁶ where ( 1 , e₁ , ............. , e₁₅ ) is the standard basis.

-Addition and subtraction are defined like ordinary vectors, but the multiplication is much more complex:
-Sedenions may be regarded as pairs of octonions and the product is defined by

( a , b ) ( c , d ) = ( a c - d* b , d a + b c* ) "Cayley-Dickson doubling" where * = conjugate

Data Registers: R00 is unused ( Registers R17 thru R48 are to be initialized before executing "SS1" )

>>>> When the program stops, R01 to R16 = the 16 components of S.S'

• R17 to R32 = the 16 components of the first sedenion S
• R33 to R48 = the 16 components of the second sedenion S' R49 to R72: temp
Flags: /
Subroutine: "O*O" ( cf "Octonions for the HP-41" )

01 LBL "SS1"
02 17.009008
03 REGMOVE
04 .056
05 +
06 REGMOVE
07 33.017008
08 REGMOVE
09 XEQ "O*O"
10 1.049008
11 REGMOVE
12 24.017
13 SIGN

14 CHS
15 LBL 01
16 ST* IND L
17 DSE L
18 GTO 01
19 25.009008
20 REGMOVE
21 XEQ "O*O"
22 1.057008
23 REGMOVE
24 41.009008
25 REGMOVE
26 65.017008

27 REGMOVE
28 XEQ "O*O"
29 64
30 8
31 LBL 02
32 RCL IND X
33 ST+ IND Z
34 RDN
35 DSE Y
36 DSE X
37 GTO 02
38 25.017008
39 REGMOVE

40 SIGN
41 CHS
42 ST* 09
43 XEQ "O*O"
44 56
45 8
46 LBL 03
47 RCL IND X
48 ST+ IND Z
49 RDN
50 DSE Y
51 DSE X
52 GTO 03

53 49.001016
54 REGMOVE
55 65.017008
56 REGMOVE
57 RCL 04
58 RCL 03
59 RCL 02
60 RCL 01
61 END

( 200 bytes / SIZE 073 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 2 + 4 e₁ + 9 e₂ + 3 e₃ + 5 e₄ + 7 e₅ + 8 e₆ + 2 e₇ + 6 e₈ + 4 e₉ + 3 e₁₀ + 2 e₁₁ + 9 e₁₂ + 7 e₁₃ + 6 e₁₄ + 8 e₁₅
S' = 9 + 2 e₁ + 4 e₂ + 7 e₃ + 3 e₄ + 2 e₅ + 6 e₆ + 5 e₇ + 4 e₈ + 2 e₉ + 6 e₁₀ + 9 e₁₁ + 3 e₁₂ + 6 e₁₃ + 5 e₁₄ + 7 e₁₅

    2   STO 17         5   STO 21          6   STO 25        9   STO 29                 9   STO 33      3   STO 37      4   STO 41     3   STO 45
    4   STO 18         7   STO 22          4   STO 26        7   STO 30                 2   STO 34      2   STO 38      2   STO 42     6   STO 46
    9   STO 19         8   STO 23          3   STO 27        6   STO 31                 4   STO 35      6   STO 39      6   STO 43     5   STO 47
    3   STO 20         2   STO 24          2   STO 28        8   STO 32                 7   STO 36      5   STO 40      9   STO 44     7   STO 48

   XEQ "SS1" >>>>   -357 = R01                                                            ---Execution time = 42s---
                       RDN       2    = R02
                       RDN     132 = R03
                       RDN      20   = R04    and

R05 = -53 , R06 = 25 , R07 = 138 , R08 = 101 , R09 = 13 , R10 = -10 , R11 = 12 , R12 = -43 , R13 = 41 , R14 = 216 , R15 = -28 , R16 = 183

whence

S.S' = - 357 + 2 e₁ + 132 e₂ + 20 e₃ - 53 e₄ + 25 e₅ + 138 e₆ + 101 e₇ + 13 e₈ - 10 e₉ + 12 e₁₀ - 43 e₁₁ + 41 e₁₂ + 216 e₁₃ - 28 e₁₄ + 183 e₁₅

Notes:

-"SS1" uses registers R49 thru R72 which may be avoided with the following program.
-But "S*S" is unfortunately much longer !

b) Program#2

-This variant calculates directly the 16 components of the product.
-"S*S" employs the following multiplication table:

S \ S'

e₁

e₂

e₃

e₄

e₅

e₆

e₇

e₈

e₉

e₁₀

e₁₁

e₁₂

e₁₃

e₁₄

e₁₅

e₁

e₂

e₃

e₄

e₅

e₆

e₇

e₈

e₉

e₁₀

e₁₁

e₁₂

e₁₃

e₁₄

e₁₅

e₁

-1

e₃

-e₂

e₅

-e₄

-e₇

e₆

e₉

-e₈

-e₁₁

e₁₀

-e₁₃

e₁₂

e₁₅

-e₁₄

e₂

-e₃

-1

e₁

e₆

e₇

-e₄

-e₅

e₁₀

e₁₁

-e₈

-e₉

-e₁₄

-e₁₅

e₁₂

e₁₃

e₃

e₂

-e₁

-1

e₇

-e₆

e₅

-e₄

e₁₁

-e₁₀

e₉

-e₈

-e₁₅

e₁₄

-e₁₃

e₁₂

e₄

-e₅

-e₆

-e₇

-1

e₁

e₂

e₃

e₁₂

e₁₃

e₁₄

e₁₅

-e₈

-e₉

-e₁₀

-e₁₁

e₅

e₄

-e₇

e₆

-e₁

-1

-e₃

e₂

e₁₃

-e₁₂

e₁₅

-e₁₄

e₉

-e₈

e₁₁

-e₁₀

e₆

e₇

e₄

-e₅

-e₂

e₃

-1

-e₁

e₁₄

-e₁₅

-e₁₂

e₁₃

e₁₀

-e₁₁

-e₈

e₉

e₇

-e₆

e₅

e₄

-e₃

-e₂

e₁

-1

e₁₅

e₁₄

-e₁₃

-e₁₂

e₁₁

e₁₀

-e₉

-e₈

e₈

-e₉

-e₁₀

-e₁₁

-e₁₂

-e₁₃

-e₁₄

-e₁₅

-1

e₁

e₂

e₃

e₄

e₅

e₆

e₇

e₉

e₈

-e₁₁

e₁₀

-e₁₃

e₁₂

e₁₅

-e₁₄

-e₁

-1

-e₃

e₂

-e₅

e₄

e₇

-e₆

e₁₀

e₁₁

e₈

-e₉

-e₁₄

-e₁₅

e₁₂

e₁₃

-e₂

e₃

-1

-e₁

-e₆

-e₇

e₄

e₅

e₁₁

-e₁₀

e₉

e₈

-e₁₅

e₁₄

-e₁₃

e₁₂

-e₃

-e₂

e₁

-1

-e₇

e₆

-e₅

e₄

e₁₂

e₁₃

e₁₄

e₁₅

e₈

-e₉

-e₁₀

-e₁₁

-e₄

e₅

e₆

e₇

-1

-e₁

-e₂

-e₃

e₁₃

-e₁₂

e₁₅

-e₁₄

e₉

e₈

e₁₁

-e₁₀

-e₅

-e₄

e₇

-e₆

e₁

-1

e₃

-e₂

e₁₄

-e₁₅

-e₁₂

e₁₃

e₁₀

-e₁₁

e₈

e₉

-e₆

-e₇

-e₄

e₅

e₂

-e₃

-1

e₁

e₁₅

e₁₄

-e₁₃

-e₁₂

e₁₁

e₁₀

-e₉

e₈

-e₇

e₆

-e₅

-e₄

e₃

e₂

-e₁

-1

Data Registers: R00 is unused ( Registers R17 thru R48 are to be initialized before executing "S*S" )

>>>> When the program stops, R01 to R16 = the 16 components of S.S'

• R17 to R32 = the 16 components of the first sedenion S
• R33 to R48 = the 16 components of the second sedenion S'
Flags: /
Subroutines: /

01 LBL "S*S"
02 RCL 17
03 RCL 48
04 *
05 RCL 18
06 RCL 47
07 *
08 +
09 RCL 19
10 RCL 46
11 *
12 -
13 RCL 20
14 RCL 45
15 *
16 -
17 RCL 21
18 RCL 44
19 *
20 +
21 RCL 22
22 RCL 43
23 *
24 +
25 RCL 23
26 RCL 42
27 *
28 -
29 RCL 24
30 RCL 41
31 *
32 +
33 RCL 25
34 RCL 40
35 *
36 -
37 RCL 26
38 RCL 39
39 *
40 +
41 RCL 27
42 RCL 38
43 *
44 -
45 RCL 28
46 RCL 37
47 *
48 -
49 RCL 29
50 RCL 36
51 *
52 +
53 RCL 30
54 RCL 35
55 *
56 +
57 RCL 31
58 RCL 34
59 *
60 -
61 RCL 32
62 RCL 33
63 *
64 +
65 STO 16
66 RCL 17
67 RCL 47
68 *
69 RCL 18
70 RCL 48
71 *
72 -
73 RCL 19
74 RCL 45
75 *
76 -
77 RCL 20
78 RCL 46
79 *
80 +
81 RCL 21
82 RCL 43
83 *
84 +
85 RCL 22
86 RCL 44
87 *
88 -
89 RCL 23
90 RCL 41
91 *
92 +
93 RCL 24
94 RCL 42
95 *
96 +
97 RCL 25
98 RCL 39
99 *
100 -
101 RCL 26
102 RCL 40
103 *
104 -
105 RCL 27
106 RCL 37
107 *
108 -
109 RCL 28
110 RCL 38
111 *
112 +
113 RCL 29
114 RCL 35
115 *
116 +
117 RCL 30
118 RCL 36
119 *
120 -
121 RCL 31
122 RCL 33
123 *
124 +
125 RCL 32
126 RCL 34
127 *
128 +
129 STO 15
130 RCL 17
131 RCL 46
132 *
133 RCL 18
134 RCL 45
135 *
136 -
137 RCL 19
138 RCL 48
139 *
140 +
141 RCL 20
142 RCL 47
143 *
144 -
145 RCL 21
146 RCL 42
147 *
148 +
149 RCL 22
150 RCL 41
151 *
152 +
153 RCL 23
154 RCL 44
155 *
156 +
157 RCL 24
158 RCL 43
159 *
160 -
161 RCL 25
162 RCL 38
163 *
164 -
165 RCL 26
166 RCL 37
167 *
168 -
169 RCL 27
170 RCL 40
171 *
172 +

173 RCL 28
174 RCL 39
175 *
176 -
177 RCL 29
178 RCL 34
179 *
180 +
181 RCL 30
182 RCL 33
183 *
184 +
185 RCL 31
186 RCL 36
187 *
188 +
189 RCL 32
190 RCL 35
191 *
192 -
193 STO 14
194 RCL 17
195 RCL 45
196 *
197 RCL 18
198 RCL 46
199 *
200 +
201 RCL 19
202 RCL 47
203 *
204 +
205 RCL 20
206 RCL 48
207 *
208 +
209 RCL 21
210 RCL 41
211 *
212 +
213 RCL 22
214 RCL 42
215 *
216 -
217 RCL 23
218 RCL 43
219 *
220 -
221 RCL 24
222 RCL 44
223 *
224 -
225 RCL 25
226 RCL 37
227 *
228 -
229 RCL 26
230 RCL 38
231 *
232 +
233 RCL 27
234 RCL 39
235 *
236 +
237 RCL 28
238 RCL 40
239 *
240 +
241 RCL 29
242 RCL 33
243 *
244 +
245 RCL 30
246 RCL 34
247 *
248 -
249 RCL 31
250 RCL 35
251 *
252 -
253 RCL 32
254 RCL 36
255 *
256 -
257 STO 13
258 RCL 17
259 RCL 44
260 *
261 RCL 18
262 RCL 43
263 *
264 -
265 RCL 19
266 RCL 42
267 *
268 +
269 RCL 20
270 RCL 41
271 *
272 +
273 RCL 21
274 RCL 48
275 *
276 -
277 RCL 22
278 RCL 47
279 *
280 +
281 RCL 23
282 RCL 46
283 *
284 -
285 RCL 24
286 RCL 45
287 *
288 +
289 RCL 25
290 RCL 36
291 *
292 -
293 RCL 26
294 RCL 35
295 *
296 -
297 RCL 27
298 RCL 34
299 *
300 +
301 RCL 28
302 RCL 33
303 *
304 +
305 RCL 29
306 RCL 40
307 *
308 -
309 RCL 30
310 RCL 39
311 *
312 +
313 RCL 31
314 RCL 38
315 *
316 -
317 RCL 32
318 RCL 37
319 *
320 +
321 STO 12
322 RCL 17
323 RCL 43
324 *
325 RCL 18
326 RCL 44
327 *
328 +
329 RCL 19
330 RCL 41
331 *
332 +
333 RCL 20
334 RCL 42
335 *
336 -
337 RCL 21
338 RCL 47
339 *
340 -
341 RCL 22
342 RCL 48
343 *
344 -

345 RCL 23
346 RCL 45
347 *
348 +
349 RCL 24
350 RCL 46
351 *
352 +
353 RCL 25
354 RCL 35
355 *
356 -
357 RCL 26
358 RCL 36
359 *
360 +
361 RCL 27
362 RCL 33
363 *
364 +
365 RCL 28
366 RCL 34
367 *
368 -
369 RCL 29
370 RCL 39
371 *
372 -
373 RCL 30
374 RCL 40
375 *
376 -
377 RCL 31
378 RCL 37
379 *
380 +
381 RCL 32
382 RCL 38
383 *
384 +
385 STO 11
386 RCL 17
387 RCL 42
388 *
389 RCL 18
390 RCL 41
391 *
392 +
393 RCL 19
394 RCL 44
395 *
396 -
397 RCL 20
398 RCL 43
399 *
400 +
401 RCL 21
402 RCL 46
403 *
404 -
405 RCL 22
406 RCL 45
407 *
408 +
409 RCL 23
410 RCL 48
411 *
412 +
413 RCL 24
414 RCL 47
415 *
416 -
417 RCL 25
418 RCL 34
419 *
420 -
421 RCL 26
422 RCL 33
423 *
424 +
425 RCL 27
426 RCL 36
427 *
428 -
429 RCL 28
430 RCL 35
431 *
432 +
433 RCL 29
434 RCL 38
435 *
436 -
437 RCL 30
438 RCL 37
439 *
440 +
441 RCL 31
442 RCL 40
443 *
444 +
445 RCL 32
446 RCL 39
447 *
448 -
449 STO 10
450 RCL 17
451 RCL 41
452 *
453 RCL 18
454 RCL 42
455 *
456 -
457 RCL 19
458 RCL 43
459 *
460 -
461 RCL 20
462 RCL 44
463 *
464 -
465 RCL 21
466 RCL 45
467 *
468 -
469 RCL 22
470 RCL 46
471 *
472 -
473 RCL 23
474 RCL 47
475 *
476 -
477 RCL 24
478 RCL 48
479 *
480 -
481 RCL 25
482 RCL 33
483 *
484 +
485 RCL 26
486 RCL 34
487 *
488 +
489 RCL 27
490 RCL 35
491 *
492 +
493 RCL 28
494 RCL 36
495 *
496 +
497 RCL 29
498 RCL 37
499 *
500 +
501 RCL 30
502 RCL 38
503 *
504 +
505 RCL 31
506 RCL 39
507 *
508 +
509 RCL 32
510 RCL 40
511 *
512 +
513 STO 09
514 RCL 17
515 RCL 40
516 *

517 RCL 18
518 RCL 39
519 *
520 -
521 RCL 19
522 RCL 38
523 *
524 +
525 RCL 20
526 RCL 37
527 *
528 +
529 RCL 21
530 RCL 36
531 *
532 -
533 RCL 22
534 RCL 35
535 *
536 -
537 RCL 23
538 RCL 34
539 *
540 +
541 RCL 24
542 RCL 33
543 *
544 +
545 RCL 25
546 RCL 48
547 *
548 +
549 RCL 26
550 RCL 47
551 *
552 +
553 RCL 27
554 RCL 46
555 *
556 -
557 RCL 28
558 RCL 45
559 *
560 -
561 RCL 29
562 RCL 44
563 *
564 +
565 RCL 30
566 RCL 43
567 *
568 +
569 RCL 31
570 RCL 42
571 *
572 -
573 RCL 32
574 RCL 41
575 *
576 -
577 STO 08
578 RCL 17
579 RCL 39
580 *
581 RCL 18
582 RCL 40
583 *
584 +
585 RCL 19
586 RCL 37
587 *
588 +
589 RCL 20
590 RCL 38
591 *
592 -
593 RCL 21
594 RCL 35
595 *
596 -
597 RCL 22
598 RCL 36
599 *
600 +
601 RCL 23
602 RCL 33
603 *
604 +
605 RCL 24
606 RCL 34
607 *
608 -
609 RCL 25
610 RCL 47
611 *
612 +
613 RCL 26
614 RCL 48
615 *
616 -
617 RCL 27
618 RCL 45
619 *
620 -
621 RCL 28
622 RCL 46
623 *
624 +
625 RCL 29
626 RCL 43
627 *
628 +
629 RCL 30
630 RCL 44
631 *
632 -
633 RCL 31
634 RCL 41
635 *
636 -
637 RCL 32
638 RCL 42
639 *
640 +
641 STO 07
642 RCL 17
643 RCL 38
644 *
645 RCL 18
646 RCL 37
647 *
648 +
649 RCL 19
650 RCL 40
651 *
652 -
653 RCL 20
654 RCL 39
655 *
656 +
657 RCL 21
658 RCL 34
659 *
660 -
661 RCL 22
662 RCL 33
663 *
664 +
665 RCL 23
666 RCL 36
667 *
668 -
669 RCL 24
670 RCL 35
671 *
672 +
673 RCL 25
674 RCL 46
675 *
676 +
677 RCL 26
678 RCL 45
679 *
680 -
681 RCL 27
682 RCL 48
683 *
684 +
685 RCL 28
686 RCL 47
687 *
688 -

689 RCL 29
690 RCL 42
691 *
692 +
693 RCL 30
694 RCL 41
695 *
696 -
697 RCL 31
698 RCL 44
699 *
700 +
701 RCL 32
702 RCL 43
703 *
704 -
705 STO 06
706 RCL 17
707 RCL 37
708 *
709 RCL 18
710 RCL 38
711 *
712 -
713 RCL 19
714 RCL 39
715 *
716 -
717 RCL 20
718 RCL 40
719 *
720 -
721 RCL 21
722 RCL 33
723 *
724 +
725 RCL 22
726 RCL 34
727 *
728 +
729 RCL 23
730 RCL 35
731 *
732 +
733 RCL 24
734 RCL 36
735 *
736 +
737 RCL 25
738 RCL 45
739 *
740 +
741 RCL 26
742 RCL 46
743 *
744 +
745 RCL 27
746 RCL 47
747 *
748 +
749 RCL 28
750 RCL 48
751 *
752 +
753 RCL 29
754 RCL 41
755 *
756 -
757 RCL 30
758 RCL 42
759 *
760 -
761 RCL 31
762 RCL 43
763 *
764 -
765 RCL 32
766 RCL 44
767 *
768 -
769 STO 05
770 RCL 17
771 RCL 34
772 *
773 RCL 18
774 RCL 33
775 *
776 +
777 RCL 19
778 RCL 36
779 *
780 +
781 RCL 20
782 RCL 35
783 *
784 -
785 RCL 21
786 RCL 38
787 *
788 +
789 RCL 22
790 RCL 37
791 *
792 -
793 RCL 23
794 RCL 40
795 *
796 -
797 RCL 24
798 RCL 39
799 *
800 +
801 RCL 25
802 RCL 42
803 *
804 +
805 RCL 26
806 RCL 41
807 *
808 -
809 RCL 27
810 RCL 44
811 *
812 -
813 RCL 28
814 RCL 43
815 *
816 +
817 RCL 29
818 RCL 46
819 *
820 -
821 RCL 30
822 RCL 45
823 *
824 +
825 RCL 31
826 RCL 48
827 *
828 +
829 RCL 32
830 RCL 47
831 *
832 -
833 STO 02
834 RCL 17
835 RCL 33
836 *
837 RCL 18
838 RCL 34
839 *
840 -
841 RCL 19
842 RCL 35
843 *
844 -
845 RCL 20
846 RCL 36
847 *
848 -
849 RCL 21
850 RCL 37
851 *
852 -
853 RCL 22
854 RCL 38
855 *
856 -
857 RCL 23
858 RCL 39
859 *
860 -

861 RCL 24
862 RCL 40
863 *
864 -
865 RCL 25
866 RCL 41
867 *
868 -
869 RCL 26
870 RCL 42
871 *
872 -
873 RCL 27
874 RCL 43
875 *
876 -
877 RCL 28
878 RCL 44
879 *
880 -
881 RCL 29
882 RCL 45
883 *
884 -
885 RCL 30
886 RCL 46
887 *
888 -
889 RCL 31
890 RCL 47
891 *
892 -
893 RCL 32
894 RCL 48
895 *
896 -
897 STO 01
898 RCL 17
899 RCL 36
900 *
901 RCL 18
902 RCL 35
903 *
904 +
905 RCL 19
906 RCL 34
907 *
908 -
909 RCL 20
910 RCL 33
911 *
912 +
913 RCL 21
914 RCL 40
915 *
916 +
917 RCL 22
918 RCL 39
919 *
920 -
921 RCL 23
922 RCL 38
923 *
924 +
925 RCL 24
926 RCL 37
927 *
928 -
929 RCL 25
930 RCL 44
931 *
932 +
933 RCL 26
934 RCL 43
935 *
936 -
937 RCL 27
938 RCL 42
939 *
940 +
941 RCL 28
942 RCL 41
943 *
944 -
945 RCL 29
946 RCL 48
947 *
948 -
949 RCL 30
950 RCL 47
951 *
952 +
953 RCL 31
954 RCL 46
955 *
956 -
957 RCL 32
958 RCL 45
959 *
960 +
961 STO 04
962 RCL 17
963 RCL 35
964 *
965 RCL 18
966 RCL 36
967 *
968 -
969 RCL 19
970 RCL 33
971 *
972 +
973 RCL 20
974 RCL 34
975 *
976 +
977 RCL 21
978 RCL 39
979 *
980 +
981 RCL 22
982 RCL 40
983 *
984 +
985 RCL 23
986 RCL 37
987 *
988 -
989 RCL 24
990 RCL 38
991 *
992 -
993 RCL 25
994 RCL 43
995 *
996 +
997 RCL 26
998 RCL 44
999 *
1000 +
1001 RCL 27
1002 RCL 41
1003 *
1004 -
1005 RCL 28
1006 RCL 42
1007 *
1008 -
1009 RCL 29
1010 RCL 47
1011 *
1012 -
1013 RCL 30
1014 RCL 48
1015 *
1016 -
1017 RCL 31
1018 RCL 45
1019 *
1020 +
1021 RCL 32
1022 RCL 46
1023 *
1024 +
1025 STO 03
1026 RCL 02
1027 RCL 01
1028 END

( 1549 bytes / SIZE 049 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

   XEQ "S*S"   >>>>   -357 = R01                                                            ---Execution time = 31s---
                        RDN       2    = R02
                        RDN     132 = R03
                        RDN      20   = R04    and

R05 = -53 , R06 = 25 , R07 = 138 , R08 = 101 , R09 = 13 , R10 = -10 , R11 = 12 , R12 = -43 , R13 = 41 , R14 = 216 , R15 = -28 , R16 = 183

whence

S.S' = - 357 + 2 e₁ + 132 e₂ + 20 e₃ - 53 e₄ + 25 e₅ + 138 e₆ + 101 e₇ + 13 e₈ - 10 e₉ + 12 e₁₀ - 43 e₁₁ + 41 e₁₂ + 216 e₁₃ - 28 e₁₄ + 183 e₁₅

Notes:

-Registers R17 thru R48 are undisturbed.
-Execution time can reach 36 seconds.

2°) Reciprocal of a Sedenion

-The reciprocal of a sedenion S # 0 is given by

S^-1 = S* / | S |² where S* is the conjugate of S and | S |² = x₀² + x₁² + ................. + x₁₅²

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "1/S" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of 1/S which has replaced S

Flags: /
Subroutines: /

01 LBL "1/S"
02 16
03 ENTER^
04 ENTER^
05 CLX
06 LBL 00
07 RCL IND Y
08 X^2
09 +
10 DSE Y
11 GTO 00
12 CHS
13 LBL 01
14 ST/ IND Z
15 DSE Z
16 GTO 01
17 RCL 04
18 RCL 03
19 RCL 02
20 RCL 01
21 CHS
22 STO 01
23 END

( 38 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example: S = 2 + 4 e₁ + 5 e₂ + 10 e₃ + 3 e₄ + 7 e₅ + 6 e₆ + 9 e₇ + 8 e₈ + 4 e₉ + 7 e₁₀ + 3 e₁₁ + 6 e₁₂ + 7 e₁₃ + 4 e₁₄ + 2 e₁₅

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

   XEQ "1/S" >>>>   2/563 = R01                                                            ---Execution time = 6s---
                       RDN -4/563 = R02
                       RDN -5/563 = R03
                       RDN -10/563 = R04

and R05 = -3/563 , ........................... , R16 = -2/563 ( approximately )

whence 1 / S = ( 2 - 4 e₁ - 5 e₂ - 10 e₃ - 3 e₄ - 7 e₅ - 6 e₆ - 9 e₇ - 8 e₈ - 4 e₉ - 7 e₁₀ - 3 e₁₁ - 6 e₁₂ - 7 e₁₃ - 4 e₁₄ - 2 e₁₅ ) / 563

3°) Exponential of a Sedenion

a) Program#1

-The exponential of a sedenion S is defined by the series exp ( S ) = 1 + S + S²/2! + S³/3! + ....... + Sⁿ/n! + ........
-Though the product is not associative, the power associativity still holds.

-A much faster method is used in the next paragraph...

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "EXPS" )

• R01 to R16 = the 16 components of the sedenion S

R17 thru R64: temp

>>>> When the program stops, R01 to R16 = the 16 components of exp ( S ) which has replaced S

Flags: /
Subroutine: "S*S" ( cf paragraph 1-b )

01 LBL "EXPS"
02 17.064
03 CLRGX
04 1.033016
05 REGMOVE
06 SIGN
07 STO 01
08 STO 17
09 STO 49
10 CLX

11 STO 00
12 LBL 01
13 XEQ "S*S"
14 16
15 STO M
16 ISG 00
17 CLX
18 RCL 00
19 LBL 02
20 ST/ IND Y

21 DSE Y
22 GTO 02
23 1.017016
24 REGMOVE
25 64
26 0
27 LBL 03
28 RCL IND M
29 RCL IND Z
30 +

31 STO IND Z
32 LASTX
33 -
34 ABS
35 +
36 DSE Y
37 DSE M
38 GTO 03
39 X#0?
40 GTO 01

41 49.001016
42 REGMOVE
43 RCL 04
44 RCL 03
45 RCL 02
46 RCL 01
47 END

( 108 bytes / SIZE 065 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    1     STO 01         0.8    STO 05         0.6    STO 09       0.4    STO 13
0.95 STO 02        0.75   STO 06        0.55   STO 10      0.35   STO 14
   0.9   STO 03         0.7    STO 07         0.5    STO 11       0.3    STO 15
0.85 STO 04        0.65   STO 08        0.45   STO 12      0.25   STO 16

    XEQ "EXPS"   >>>>     -2.127648871 = R01
                             RDN      0.650737938 = R02
                             RDN      0.616488572 = R03
                             RDN      0.582239207 = R04

and R05 = 0.547989843 ....................................... R16 = 0.171246826

-So, exp S = - 2.127648871 + 0.650737938 e₁ + 0.616488572 e₂ + 0.582239207 e₃
                      + 0.547989843 e₄ + 0.513740477 e₅ + 0.479491112 e₆ + 0.445241747 e₇
                      + 0.410992382 e₈ + 0.376743016 e₉ + 0.342493652 e₁₀ + 0.308244286 e₁₁
                      + 0.273994921 e₁₂ + 0.239745556 e₁₃ + 0.205496191 e₁₄ + 0.171246826 e₁₅

Notes:

-This program is of course very slow and it would not give accurate results in all cases.
-The following variant is much better:

b) Program#2

-We can also use the following formula to compute exp S

exp( x₀ + x₁ e₁ + .... + x₁₅ e₁₅ ) = e^x0 [ cos µ + ( sin µ ).( x₁ e₁ + .... + x₁₅ e₁₅ ) / µ ]

where µ = ( x₁² + .............. + x₁₅²)^1/2

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "E^S" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of exp S which has replaced S

Flags: /
Subroutines: /

01 LBL "E^S"
02 16.001
03 DEG
04 0
05 LBL 01
06 RCL IND Y
07 X^2

08 +
09 DSE Y
10 GTO 01
11 SQRT
12 ENTER^
13 R-D
14 RCL 01

15 E^X
16 P-R
17 STO 01
18 X<> Z
19 X=0?
20 SIGN
21 /

22 R^
23 15
24 +
25 X<>Y
26 LBL 02
27 ST* IND Y
28 DSE Y

29 GTO 02
30 RCL 04
31 RCL 03
32 RCL 02
33 RCL 01
34 END

( 55 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    XEQ "E^S"   >>>>    -2.127648869 = R01                                              ---Execution time = 7s---
                         RDN      0.650737937 = R02
                         RDN      0.616488572 = R03
                         RDN      0.582239207 = R04

and R05 = 0.547989842 ....................................... R16 = 0.171246826

-So, exp S = - 2.127648869 + 0.650737937 e₁ + 0.616488572 e₂ + 0.582239207 e₃
                      + 0.547989842 e₄ + 0.513740477 e₅ + 0.479491112 e₆ + 0.445241747 e₇
                      + 0.410992381 e₈ + 0.376743016 e₉ + 0.342493651 e₁₀ + 0.308244286 e₁₁
                      + 0.273994921 e₁₂ + 0.239745556 e₁₃ + 0.205496191 e₁₄ + 0.171246826 e₁₅

-So, we get the same results, with small differences in the last places due to roundoff-errors.

4°) Logarithm of a Sedenion

-"LNS" uses the formula: Ln( x₀ + x₁ e₁ + ......................... + x₁₅ e₁₅ )

= Ln ( x₀² + x₁² + ......................... + x₁₅² )^1/2 + Atan2(µ,x₀). ( x₁ e₁ + ......................... + x₁₅ e₁₅ ) / µ

where µ = ( x₁² + .................... + x₁₅² )^1/2

-If µ = 0 , ( x₁ e₁ + ......................... + x₁₅ e₁₅ ) / µ is replaced by e₁

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "LNS" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of Ln S which has replaced S

Flags: /
Subroutines: /

01 LBL "LNS"
02 16.001
03 DEG
04 0
05 LBL 01
06 RCL IND Y
07 X^2
08 +

09 DSE Y
10 GTO 01
11 SQRT
12 STO Y
13 LASTX
14 RCL 01
15 X^2
16 +

17 SQRT
18 LN
19 X<> 01
20 R-P
21 RDN
22 D-R
23 X<>Y
24 X#0?

25 GTO 00
26 SIGN
27 STO 02
28 LBL 00
29 /
30 16.001
31 X<>Y
32 LBL 02

33 STO IND Y
34 DSE Y
35 GTO 02
36 RCL 04
37 RCL 03
38 RCL 02
39 RCL 01
40 END

( 67 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    XEQ "LNS"   >>>>     0.980047392 = R01                               ---Execution time = 4s---
                          RDN      0.456219471 = R02
                          RDN      0.432207920 = R03
                          RDN      0.408196369 = R04

and R05 = 0.384184818 ................................... R16 = 0.120057756

-So, Ln S = 0.980047392 + 0.456219471 e₁ + 0.432207920 e₂ + 0.408196369 e₃
                   + 0.384184818 e₄ + 0.360173267 e₅ + 0.336161716 e₆ + 0.312150164 e₇
                   + 0.288138613 e₈ + 0.264127062 e₉ + 0.240115511 e₁₀ + 0.216103960 e₁₁
                   + 0.192092409 e₁₂ + 0.168080858 e₁₃ + 0.144069307 e₁₄ + 0.120057756 e₁₅

5°) Raising a Sedenion to a power

a) Real exponent

"S^R" calculates S^r = exp ( r Ln S ) where r is a real number and S is a sedenion

Data Registers: • R00 = r ( Registers R00 thru R08 are to be initialized before executing "S^R" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of S^r which has replaced S

Flags: /
Subroutines: "LNS" & "E^S"

01 LBL "S^R"
02 XEQ "LNS"
03 16
04 RCL 00
05 LBL 00
06 ST* IND Y
07 DSE Y
08 GTO 00
09 XEQ "E^S"
10 END

( 30 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example: r = PI and

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    1     STO 01         0.8    STO 05         0.6    STO 09       0.4    STO 13              PI STO 00
0.95 STO 02        0.75   STO 06        0.55   STO 10      0.35   STO 14
   0.9   STO 03         0.7    STO 07         0.5    STO 11       0.3    STO 15
0.85 STO 04        0.65   STO 08        0.45   STO 12      0.25   STO 16

    XEQ "S^R"   >>>>    -18.12530584 = R01                               ---Execution time = 19s---
                         RDN     -4.613643036 = R02
                         RDN     -4.370819717 = R03
                         RDN     -4.127996401 = R04

and R05 = -3.885173082 .................................. R16 = -1.214116589

-So, S^r = -18.12530584 - 4.613643036 e₁ - 4.370819717 e₂ - 4.127996401 e₃
                - 3.885173082 e₄ - 3.642349766 e₅ - 3.399526447 e₆ - 3.156703130 e₇
                - 2.913879812 e₈ - 2.671056494 e₉ - 2.428233177 e₁₀ - 2.185409859 e₁₁
                - 1.942586542 e₁₂ - 1.699763224 e₁₃ - 1.456939907 e₁₄ - 1.214116589 e₁₅

b) Sedenion exponent

"S^S" computes S^S' = exp [ ( Ln S ) S' ] where S and S' are 2 sedenions

Data Registers: R00: temp ( Registers R17 thru R48 are to be initialized before executing "S^S" )

>>>> When the program stops, R01 to R16 = the 16 components of S^S'

• R17 to R32 = the 16 components of the first sedenion S
• R33 to R48 = the 16 components of the second sedenion S'
Flags: /
Subroutines: "LNS" "S*S" and "E^S"

01 LBL "S^S"
02 17.001016
03 STO 00
04 REGMOVE
05 XEQ "LNS"
06 RCL 00
07 REGSWAP
08 XEQ "S*S"
09 XEQ "E^S"
10 END

( 40 bytes / SIZE 049 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅
S' = 0.25 + 0.3 e₁ + 0.35 e₂ + 0.4 e₃ + 0.45 e₄ + 0.5 e₅ + 0.55 e₆ + 0.6 e₇ + 0.65 e₈ + 0.7 e₉ + 0.75 e₁₀ + 0.8 e₁₁ + 0.85 e₁₂ + 0.9 e₁₃ + 0.95 e₁₄ + e₁₅

    1     STO 17         0.8    STO 21         0.6    STO 25       0.4    STO 29           0.25   STO 33   0.45   STO 37    0.65   STO 41    0.85 STO 45
0.95 STO 18        0.75   STO 22        0.55   STO 26      0.35   STO 30            0.3    STO 34    0.5    STO 38     0.7    STO 42     0.9   STO 46
   0.9   STO 19         0.7    STO 23         0.5    STO 27       0.3    STO 31           0.35   STO 35   0.55   STO 39    0.75   STO 43    0.95 STO 47
0.85 STO 20        0.65   STO 24        0.45   STO 28      0.25   STO 32            0.4    STO 36    0.6    STO 40     0.8    STO 44      1     STO 48

   XEQ "S^S" >>>> -0.102920602 = R01                          ---Execution time = 53s---
                       RDN   -0.004049497 = R02
                       RDN   -0.004724413 = R03
                       RDN   -0.005399329 = R04

and R05 = -0.006074245 ................................... R16 = -0.010169002

-So, S^S' = -0.102920602 - 0.004049497 e₁ - 0.004724413 e₂ - 0.005399329 e₃
                  - 0.006074245 e₄ - 0.006749161 e₅ - 0.007424077 e₆ - 0.008098994 e₇
                  + 0.008982467 e₈ - 0.008339052 e₉ - 0.007904195 e₁₀ - 0.007469337 e₁₁
                  - 0.015912668 e₁₂ - 0.008819170 e₁₃ - 0.006164765 e₁₄ - 0.010169002 e₁₅

Notes:

-Another definition is possible: S^S' = exp [ S' ( Ln S ) ]
-Simply add .032 + REGSWAP after line 07

6°) Hyperbolic Functions

a) Sinh S

-We have: Sinh ( x₀ + x₁ e₁ + ....................... + x₁₅ e₁₅ )

= Sinh x₀ Cos µ + ( Cosh x₀ ) ( Sin µ ) / µ ( x₁ e₁ + ....................... + x₁₅ e₁₅ )

where µ = ( x₁² + ....................... + x₁₅² )^1/2

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "SHS" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of Sinh S which has replaced S

Flags: /
Subroutines: /

01 LBL "SHS"
02 16.001
03 DEG
04 0
05 LBL 00
06 RCL IND Y
07 X^2
08 +
09 DSE Y
10 GTO 00

11 SQRT
12 STO Y
13 RCL 01
14 E^X-1
15 LASTX
16 CHS
17 E^X-1
18 -
19 X<>Y
20 R-D

21 1
22 P-R
23 X<>Y
24 X<> Z
25 *
26 X<> 01
27 E^X
28 LASTX
29 CHS
30 E^X

31 +
32 *
33 2
34 ST/ 01
35 /
36 X<>Y
37 X=0?
38 SIGN
39 /
40 16.001

41 X<>Y
42 LBL 02
43 ST* IND Y
44 DSE Y
45 GTO 02
46 RCL 04
47 RCL 03
48 RCL 02
49 RCL 01
50 END

( 78 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    XEQ "SHS"   >>>>    -0.919851454 = R01                                                   ---Execution time = 9s---
                          RDN      0.369402870 = R02
                          RDN      0.349960614 = R03
                          RDN      0.330518358 = R04

and R05 = 0.311076101 .................................... R16 = 0.097211282

-Whence, Sinh S = - 0.919851454 + 0.369402870 e₁ + 0.349960614 e₂ + 0.330518358 e₃
                               + 0.311076101 e₄ + 0.291633845 e₅ + 0.272191589 e₆ + 0.252749332 e₇
                               + 0.233307076 e₈ + 0.213864820 e₉ + 0.194422563 e₁₀ + 0.174980307 e₁₁
                               + 0.155538051 e₁₂ + 0.136095794 e₁₃ + 0.116653538 e₁₄ + 0.097211282 e₁₅

Notes:

-Of course, this program may be simplified if you have M-Code routines SINH & COSH
-Delete lines 33 to 35
-Replace lines 27 to 31 by COSH
-Replace lines 12 to 24 with ENTER^ R-D 1 P-R RCL 01 SINH

b) Cosh S

-A similar formula gives: Cosh ( x₀ + x₁ e₁ + .......................... + x₁₅ e₁₅ )

= Cosh x₀ Cos µ + ( Sinh x₀ ) ( Sin µ ) / µ ( x₁ e₁ + .......................... + x₁₅ e₁₅ )

where µ = ( x₁² + ........................ + x₁₅² )^1/2

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "CHS" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R08 = the 16 components of Cosh S which has replaced S

Flags: /
Subroutines: /

01 LBL "CHS"
02 16.001
03 DEG
04 0
05 LBL 00
06 RCL IND Y
07 X^2
08 +
09 DSE Y
10 GTO 00

11 SQRT
12 STO Y
13 RCL 01
14 E^X
15 LASTX
16 CHS
17 E^X
18 +
19 X<>Y
20 R-D

21 1
22 P-R
23 X<>Y
24 X<> Z
25 *
26 X<> 01
27 E^X-1
28 LASTX
29 CHS
30 E^X-1

31 -
32 *
33 2
34 ST/ 01
35 /
36 X<>Y
37 X=0?
38 SIGN
39 /
40 16.001

41 X<>Y
42 LBL 02
43 ST* IND Y
44 DSE Y
45 GTO 02
46 RCL 04
47 RCL 03
48 RCL 02
49 RCL 01
50 END

( 78 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    XEQ "CHS"   >>>>    -1.207797416 = R01                                                      ---Execution time = 9s---
                          RDN      0.281335067 = R02
                          RDN      0.266527958 = R03
                          RDN      0.251720850 = R04

and R05 = 0.236913741 .................................... R16 = 0.074035544

-Whence, Cosh S = - 1.207797416 + 0.281335067 e₁ + 0.266527958 e₂ + 0.251720850 e₃
                               + 0.236913741 e₄ + 0.222106632 e₅ + 0.207299523 e₆ + 0.192492414 e₇
                               + 0.177685306 e₈ + 0.162878197 e₉ + 0.148071088 e₁₀ + 0.133263979 e₁₁
                               + 0.118456870 e₁₂ + 0.103649762 e₁₃ + 0.088842653 e₁₄ + 0.074035544 e₁₅

Notes:

-This program may also be simplified if you have M-Code routines SINH & COSH
-Delete lines 33 to 35
-Replace lines 27 to 31 by SINH
-Replace lines 12 to 24 with ENTER^ R-D 1 P-R RCL 01 COSH

c) Tanh S

-"THS" calculates Tanh S = ( Sinh S ) ( Cosh S )^-1

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "THS" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of Tanh S which has replaced S

Flags: /
Subroutines: "CHS" "1/S" "SHS" "S*S"

01 LBL "THS"
02 1.017016
03 STO 00
04 REGMOVE
05 XEQ "CHS"
06 XEQ "1/S"
07 RCL 00
08 REGSWAP
09 XEQ "SHS"
10 1.017032
11 REGMOVE
12 XEQ "S*S"
13 END

( 54 bytes / SIZE 049 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

    XEQ "CHS"   >>>>     0.909559410 = R01                                                      ---Execution time = 56s---
                          RDN     -0.093982576 = R02
                          RDN     -0.089036125 = R03
                          RDN     -0.084089673 = R04

and R05 = -0.079143222 .................................... R16 = -0.024732257

-Whence, Cosh S = 0.909559410 - 0.093982576 e₁ - 0.089036125 e₂ - 0.084089673 e₃
                               - 0.079143222 e₄ - 0.074196771 e₅ - 0.069250319 e₆ - 0.064303868 e₇
                               - 0.059357417 e₈ - 0.054410965 e₉ - 0.049464514 e₁₀ - 0.044518062 e₁₁
                               - 0.039571611 e₁₂ - 0.034625160 e₁₃ - 0.029678708 e₁₄ - 0.024732257 e₁₅

7°) Inverse Hyperbolic Functions

a) ArcSinh S

Formula: ArcSinh S = Ln [ S + ( S² + 1 )^1/2 ]

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "ASHS" )

• R01 to R16 = the 16 components of the sedenion S R09 thru R24: temp

>>>> When the program stops, R01 to R16 = the 16 components of ArcSinh S which has replaced S

Flags: /
Subroutines: "S^R" "LNS"

01 LBL "ASHS"
02 1.017016
03 REGMOVE
04 2
05 STO 00
06 XEQ "S^R"
07 1
08 ST+ 01
09 RCL 00
10 1/X
11 STO 00
12 XEQ "S^R"
13 16
14 ENTER^
15 ST+ Y
16 LBL 00
17 RCL IND Y
18 ST+ IND Y
19 RDN
20 DSE Y
21 DSE X
22 GTO 00
23 XEQ "LNS"
24 END

( 61 bytes / SIZE 033 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "ASHS"   >>>>     1.647954890 = R01                                                      ---Execution time = 51s---
                          RDN      0.446040403 = R02
                          RDN      0.422564592 = R03
                          RDN      0.399088782 = R04

and R05 = 0.375612971 .................................... R16 = 0.117379053

-Whence, Arc Sinh S = 1.647954890 + 0.446040403 e₁ + 0.422564592 e₂ + 0.399088782 e₃
                                  + 0.375612971 e₄ + 0.352137160 e₅ + 0.328661350 e₆ + 0.305185539 e₇
                                  + 0.281709728 e₈ + 0.258233918 e₉ + 0.234758107 e₁₀ + 0.211282296 e₁₁
                                  + 0.187806485 e₁₂ + 0.164330675 e₁₃ + 0.140854864 e₁₄ + 0.117379053 e₁₅

b) ArcCosh S

Formula: ArcCosh S = Ln [ S + ( S + 1 )^1/2 ( S - 1 )^1/2 ]

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "ACHS" )

• R01 to R16 = the 16 components of the sedenion S R17 thru R64: temp

>>>> When the program stops, R01 to R16 = the 16 components of ArcCosh S which has replaced S

Flags: /
Subroutines: "S^R" "S*S" "LNS"

01 LBL "ACHS"
02 1.049016
03 REGMOVE
04 SIGN
05 ST+ 01
06 .5

07 STO 00
08 XEQ "S^R"
09 1.017016
10 REGMOVE
11 49.001016
12 REGMOVE

13 SIGN
14 ST- 01
15 XEQ "S^R"
16 1.033016
17 REGMOVE
18 XEQ "S*S"

19 64
20 16
21 LBL 00
22 RCL IND Y
23 ST+ IND Y
24 RDN

25 DSE Y
26 DSE X
27 GTO 00
28 XEQ "LNS"
29 END

( 98 bytes / SIZE 065 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "ACHS"   >>>>     1.698342332 = R01                                                      ---Execution time = 70s---
                         RDN      0.464968039 = R02
                          RDN      0.440496037 = R03
                          RDN      0.416024035 = R04

and R05 = 0.391552033 .................................... R16 = 0.122360010

-Whence, Arc Cosh S = 1.698342332 + 0.464968039 e₁ + 0.440496037 e₂ + 0.416024035 e₃
                                    + 0.391552033 e₄ + 0.367080031 e₅ + 0.342608029 e₆ + 0.318136027 e₇
                                    + 0.293664025 e₈ + 0.269192022 e₉ + 0.244720021 e₁₀ + 0.220248018 e₁₁
                                    + 0.195776016 e₁₂ + 0.171304014 e₁₃ + 0.146832012 e₁₄ + 0.122360010 e₁₅

c) ArcTanh S

Formula: ArcTanh S = (1/2) [ Ln ( 1 +S ) - Ln ( 1 - S ) ]

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "ATHS" )

• R01 to R16 = the 16 components of the sedenion S R17 thru R32: temp

>>>> When the program stops, R01 to R16 = the 16 components of ArcTanh S which has replaced S

Flags: /
Subroutine: "LNS"

01 LBL "ATHS"
02 1.017016
03 STO 00
04 REGMOVE
05 SIGN
06 ST- 01
07 ST+ 17
08 16

09 X<>Y
10 CHS
11 LBL 00
12 ST* IND Y
13 DSE Y
14 GTO 00
15 XEQ "LNS"
16 RCL 00

17 REGSWAP
18 XEQ "LNS"
19 32
20 16
21 LBL 01
22 RCL IND X
23 RCL IND Z
24 -

25 2
26 /
27 STO IND Y
28 RDN
29 DSE Y
30 DSE X
31 GTO 01
32 RCL 04

33 RCL 03
34 RCL 02
35 RCL 01
36 END

( 77 bytes / SIZE 033 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "ATHS"   >>>>     0.126061663 = R01                                                      ---Execution time = 26s---
                          RDN      0.473288545 = R02
                          RDN      0.448378622 = R03
                          RDN      0.423468698 = R04

and R05 = 0.391552033 .................................... R16 = 0.124549617

-Whence, Arc Tanh S = 0.126061663 + 0.473288545 e₁ + 0.448378622 e₂ + 0.423468698 e₃
                                    + 0.398558775 e₄ + 0.373648851 e₅ + 0.348738928 e₆ + 0.323829005 e₇
                                    + 0.298919081 e₈ + 0.274009158 e₉ + 0.249099234 e₁₀ + 0.224189311 e₁₁
                                    + 0.199279387 e₁₂ + 0.174369464 e₁₃ + 0.149459541 e₁₄ + 0.124549617 e₁₅

9°) Trigonometric Functions

a) Sin S

Formula: Sin ( x₀ + x₁ e₁ + ................. + x₁₅ e₁₅ )

= Sin x₀ Cosh µ + ( Cos x₀ ) ( Sinh µ ) / µ ( x₁ e₁ + ........................... + x₁₅ e₁₅ )

where µ = ( x₁² + ................... + x₁₅² )^1/2

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "SINS" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of Sin S which has replaced S

Flags: /
Subroutines: /

01 LBL "SINS"
02 16.001
03 DEG
04 0
05 LBL 01
06 RCL IND Y
07 X^2
08 +
09 DSE Y
10 GTO 01

11 SQRT
12 RCL 01
13 R-D
14 COS
15 RCL Y
16 E^X-1
17 LASTX
18 CHS
19 E^X-1
20 -

21 *
22 X<>Y
23 X=0?
24 SIGN
25 ST+ X
26 /
27 16.001
28 X<>Y
29 LBL 02
30 ST* IND Y

31 DSE Y
32 GTO 02
33 R^
34 E^X
35 LASTX
36 CHS
37 E^X
38 +
39 RCL 01
40 R-D

41 SIN
42 *
43 2
44 /
45 STO 01
46 RCL 04
47 RCL 03
48 RCL 02
49 R^
50 END

( 77 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "SINS"   >>>>     5.008811165 = R01                                                      ---Execution time = 9s---
                         RDN      1.219478777 = R02
                         RDN      1.155295683 = R03
                         RDN      1.091112590 = R04

and R05 = 1.026929496 .................................... R16 = 0.320915468

-Whence,      Sin S = 5.008811165 + 1.219478777 e₁ + 1.155295683 e₂ + 1.091112590 e₃
                              + 1.026929496 e₄ + 0.962746403 e₅ + 0.898563309 e₆ + 0.834380216 e₇
                              + 0.770197122 e₈ + 0.706014029 e₉ + 0.641830935 e₁₀ + 0.577647842 e₁₁
                              + 0.513464748 e₁₂ + 0.449281655 e₁₃ + 0.385098561 e₁₄ + 0.320915468 e₁₅

b) Cos S

Formula: Cos ( x₀ + x₁ e₁ + ........................ + x₁₅ e₁₅ )

= Cos x₀ Cosh µ + ( Sin x₀ ) ( Sinh µ ) / µ ( x₁ e₁ + ........................ + x₁₅ e₁₅ )

where µ = ( x₁² + ........................ + x₁₅² )^1/2

Data Registers: R00 is unused ( Registers R01 thru R16 are to be initialized before executing "COSS" )

• R01 to R16 = the 16 components of the sedenion S

>>>> When the program stops, R01 to R16 = the 16 components of Cos S which has replaced S

Flags: /
Subroutines: /

01 LBL "COSS"
02 16.001
03 DEG
04 0
05 LBL 01
06 RCL IND Y
07 X^2
08 +
09 DSE Y
10 GTO 01

11 SQRT
12 RCL 01
13 R-D
14 COS
15 RCL Y
16 E^X
17 LASTX
18 CHS
19 E^X
20 +

21 *
22 2
23 /
24 X<> 01
25 R-D
26 SIN
27 X<>Y
28 E^X-1
29 LASTX
30 CHS

31 E^X-1
32 -
33 *
34 X<>Y
35 X=0?
36 SIGN
37 ST+ X
38 /
39 CHS
40 16.001

41 X<>Y
42 LBL 02
43 ST* IND Y
44 DSE Y
45 GTO 02
46 RCL 04
47 RCL 03
48 RCL 02
49 RCL 01
50 END

( 78 bytes / SIZE 017 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "COSS"   >>>>     3.216120664 = R01                                                      ---Execution time = 9s---
                           RDN    -1.899225665 = R02
                           RDN    -1.799266420 = R03
                           RDN    -1.699307174 = R04

and R05 = -1.599347929 .................................... R16 = -0.499796228

-Whence,      Cos S = 3.216120664 - 1.899225665 e₁ - 1.799266420 e₂ - 1.699307174 e₃
                               - 1.599347929 e₄ - 1.499388683 e₅ - 1.399429438 e₆ - 1.299470192 e₇
                               - 1.199510947 e₈ - 1.099551701 e₉ - 0.999592456 e₁₀ - 0.899633210 e₁₁
                               - 0.799673964 e₁₂ - 0.699714719 e₁₃ - 0.599755473 e₁₄ - 0.499796228 e₁₅

c) Tan S

Formula: Tan S = ( Sin S ) ( Cos S )^-1

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "TANS" )

• R01 to R16 = the 16 components of the sedenion S R17 to R48: temp

>>>> When the program stops, R01 to R16 = the 16 components of Tan S which has replaced S

Flags: /
Subroutines: "SINS" "COSS" "1/S" "S*S"

01 LBL "TANS"
02 1.017016
03 STO 00
04 REGMOVE
05 XEQ "SINS"
06 RCL 00
07 REGSWAP
08 XEQ "COSS"
09 XEQ "1/S"
10 RCL 00
11 .016
12 +
13 REGMOVE
14 XEQ "S*S"
15 END

( 55 bytes / SIZE 049 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "TANS"   >>>>     0.013093383 = R01                                                      ---Execution time = 60s---
                           RDN     0.386909011 = R02
                           RDN     0.366545379 = R03
                           RDN     0.346181747 = R04

and R05 = 0.325818114 .................................... R16 = 0.101818161

-Whence,      Tan S = 0.013093383 + 0.386909011 e₁ + 0.366545379 e₂ + 0.346181747 e₃
                               + 0.325818114 e₄ + 0.305454482 e₅ + 0.285090850 e₆ + 0.264727218 e₇
                               + 0.244363586 e₈ + 0.223999954 e₉ + 0.203636322 e₁₀ + 0.183272689 e₁₁
                               + 0.162909057 e₁₂ + 0.142545425 e₁₃ + 0.122181793 e₁₄ + 0.101818161 e₁₅

9°) Inverse Trigonometric Functions

a) Arc Sin S

Formula: If S = x₀ + x₁ e₁ + .................. + x₁₅ e₁₅

Arc Sin S = - I Arc Sinh ( S I )

where I = ( x₁ e₁ + ....................... + x₁₅ e₁₅ ) / µ and µ = ( x₁² + ..................... + x₁₅² )^1/2

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "ASINS" )

• R01 to R16 = the 16 components of the sedenion S R17 to R49: temp

>>>> When the program stops, R01 to R16 = the 16 components of Arc Sin S which has replaced S

Flags: /
Subroutines: "S*S" "ASHS"

01 LBL ASINS
02 16.001
03 ENTER^
04 CLX
05 LBL 00
06 RCL IND Y
07 X^2
08 +
09 DSE Y

10 GTO 00
11 SQRT
12 X=0?
13 SIGN
14 1.017016
15 REGMOVE
16 .016
17 +
18 STO 49

19 REGMOVE
20 CLX
21 STO 33
22 48.033
23 RCL Z
24 LBL 01
25 ST/ IND Y
26 DSE Y
27 GTO 01

28 XEQ "S*S"
29 XEQ "ASHS"
30 48
31 32.016
32 LBL 02
33 RCL IND Y
34 CHS
35 STO IND Y
36 RDN

37 DSE Y
38 DSE X
39 GTO 02
40 RCL 49
41 REGMOVE
42 XEQ "S*S"
43 END

( 111 bytes / SIZE 050 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "ASINS"   >>>>     0.361968604 = R01                                                      ---Execution time = 123s---
                            RDN      0.653256773 = R02
                            RDN      0.618874836 = R03
                            RDN      0.584492901 = R04

and R05 = 0.550110965 .................................... R16 = 0.171909676

-Whence, Arc Sin S = 0.361968604 + 0.653256773 e₁ + 0.618874836 e₂ + 0.584492901 e₃
                                  + 0.550110965 e₄ + 0.515729030 e₅ + 0.481347095 e₆ + 0.446965159 e₇
                                  + 0.412583224 e₈ + 0.378201289 e₉ + 0.343819354 e₁₀ + 0.309437418 e₁₁
                                  + 0.275055483 e₁₂ + 0.240673547 e₁₃ + 0.206291612 e₁₄ + 0.171909676 e₁₅

b) Arc Cos S

Formula: Arc Cos S = PI/2 - Arc Sin S

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "ACOSS" )

• R01 to R16 = the 16 components of the sedenion S R17 to R49: temp

>>>> When the program stops, R01 to R16 = the 16 components of Arc Cos S which has replaced S

Flags: /
Subroutine: "ASINS"

01 LBL "ACOSS"
02 XEQ "ASINS"
03 16
04 PI
05 2
06 /
07 ST- 01
08 SIGN
09 CHS
10 LBL 00
11 ST* IND Y
12 DSE Y
13 GTO 00
14 RCL 04
15 RCL 03
16 RCL 02
17 RCL 01
18 END

( 39 bytes / SIZE 050 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "ACOSS"   >>>>      1.208827723 = R01                                                      ---Execution time = 125s---
                              RDN     -0.653256773 = R02
                              RDN     -0.618874836 = R03
                              RDN     -0.584492901 = R04

and R05 = -0.550110965 .................................... R16 = -0.171909676

-Whence, Arc Cos S = 1.208827723 - 0.653256773 e₁ - 0.618874836 e₂ - 0.584492901 e₃
                                   - 0.550110965 e₄ - 0.515729030 e₅ - 0.481347095 e₆ - 0.446965159 e₇
                                   - 0.412583224 e₈ - 0.378201289 e₉ - 0.343819354 e₁₀ - 0.309437418 e₁₁
                                   - 0.275055483 e₁₂ - 0.240673547 e₁₃ - 0.206291612 e₁₄ - 0.171909676 e₁₅

c) Arc Tan S

Formula: If S = x₀ + x₁ e₁ + ........................... + x₁₅ e₁₅

Arc Tan S = - S Arc Tanh ( S I )

where I = ( x₁ e₁ + ............................... + x₁₅ e₁₅ ) / µ and µ = ( x₁² + ...................... + x₁₅² )^1/2

Data Registers: R00: temp ( Registers R01 thru R16 are to be initialized before executing "ATANS" )

• R01 to R16 = the 16 components of the sedenion S R17 to R49: temp

>>>> When the program stops, R01 to R16 = the 16 components of Arc Tan S which has replaced S

Flags: /
Subroutines: "S*S" "ATHS"

01 LBL ATANS
02 16.001
03 ENTER^
04 CLX
05 LBL 00
06 RCL IND Y
07 X^2
08 +
09 DSE Y

10 GTO 00
11 SQRT
12 X=0?
13 SIGN
14 1.017016
15 REGMOVE
16 .016
17 +
18 STO 49

19 REGMOVE
20 CLX
21 STO 33
22 48.033
23 RCL Z
24 LBL 01
25 ST/ IND Y
26 DSE Y
27 GTO 01

28 XEQ "S*S"
29 XEQ "ATHS"
30 48
31 32.016
32 LBL 02
33 RCL IND Y
34 CHS
35 STO IND Y
36 RDN

37 DSE Y
38 DSE X
39 GTO 02
40 RCL 49
41 REGMOVE
42 XEQ "S*S"
43 END

( 111 bytes / SIZE 050 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example:

S = 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆ + 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅

XEQ "ATANS"   >>>>     1.412384085 = R01                                                      ---Execution time = 98s---
                             RDN      0.136289503 = R02
                             RDN      0.129116371 = R03
                             RDN      0.121943240 = R04

and R05 = 0.114770108 .................................... R16 = 0.035865659

-Whence, Arc Tan S = 1.412384085 + 0.136289503 e₁ + 0.129116371 e₂ + 0.121943240 e₃
                                  + 0.114770108 e₄ + 0.107596976 e₅ + 0.100423844 e₆ + 0.093250712 e₇
                                  + 0.086077581 e₈ + 0.078904449 e₉ + 0.071731317 e₁₀ + 0.064558186 e₁₁
                                  + 0.057385054 e₁₂ + 0.050211922 e₁₃ + 0.043038791 e₁₄ + 0.035865659 e₁₅

Notes:

-The unique difference between "ASINS" & "ATANS" is line 29
-So, you could use a flag to save several bytes...

10°) Sedenionic Equations

-The following program uses the iterative method also used for quaternionic equations:
-The equation must be rewritten in the form: f ( S ) = S
and if f satisfies a Lipschitz condition | f(S) - f(S') | < h | S - S' | with h < 1 , provided S and S' are close to a solution,
then the sequence S_n+1 = f ( S_n ) converges to a root.

Data Registers: • R00 = function name ( Registers R00 thru R16 are to be initialized before executing "SEQ" )

• R01 to R16 = the 16 components of the sedenion S R50 to R65 = S , R66 = fname

>>>> When the program stops, R01 to R16 = the 16 components of a solution S

Flags: /
Subroutine: A program that takes the sedenion S in R01 thru R16 , calculates and stores f ( S ) in R01 thru R16
without disturbing R50 to R66

01 LBL "SEQ"
02 RCL 00
03 STO 66
04 LBL 01
05 VIEW 01
06 1.050016
07 REGMOVE
08 XEQ IND 66
09 65
10 16
11 0
12 LBL 02
13 RCL IND Y
14 ST- IND T
15 CLX
16 RCL IND T
17 ABS
18 +
19 DSE Z
20 DSE Y
21 GTO 02
22 X#0?
23 GTO 01
24 RCL 66
25 STO 00
26 RCL 04
27 RCL 03
28 RCL 02
29 RCL 01
30 END

( 61 bytes / SIZE 067 )

STACK	INPUTS	OUTPUTS
T	/	x₃
Z	/	x₂
Y	/	x₁
X	/	x₀

Example: Find a solution of the equation

S² - Ln S + 1 + 0.95 e₁ + 0.9 e₂ + 0.85 e₃ + 0.8 e₄ + 0.75 e₅ + 0.7 e₆
+ 0.65 e₇ + 0.6 e₈ + 0.55 e₉ + 0.5 e₁₀ + 0.45 e₁₁ + 0.4 e₁₂ + 0.35 e₁₃ + 0.3 e₁₄ + 0.25 e₁₅ = 0

near 1 + e₁ + e₂ + e₃ + e₄ + e₅ + e₆ + e₇ + e₈ + e₉ + e₁₀ + e₁₁ + e₁₂ + e₁₃ + e₁₄ + e₁₅

-First, we re-write this equation:

S = ( Ln S - 1 - 0.95 e₁ - 0.9 e₂ - 0.85 e₃ - 0.8 e₄ - 0.75 e₅ - 0.7 e₆
- 0.65 e₇ - 0.6 e₈ - 0.55 e₉ - 0.5 e₁₀ - 0.45 e₁₁ - 0.4 e₁₂ - 0.35 e₁₃ - 0.3 e₁₄ - 0.25 e₁₅ )^1/2 = f ( S )

-The short routine "T" hereunder computes f ( S )

01 LBL "T"
02 XEQ "LNS"
03 1
04 ST- 01
05 .95
06 ST- 02
07 .9
08 ST- 03

09 .85
10 ST- 04
11 .8
12 ST- 05
13 .75
14 ST- 06
15 .7
16 ST- 07

17 .65
18 ST- 08
19 .6
20 ST- 09
21 .55
22 ST- 10
23 .5
24 STO 00

25 ST- 11
26 .45
27 ST- 12
28 .4
29 ST- 13
30 .35
31 ST- 14
32 .3

33 ST- 15
34 .25
35 ST- 16
36 XEQ "S^R"
37 RTN
38 END

-Then, "T" ASTO 00

1 STO 01 STO 02 ...................... STO 16

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

                                         1.212710721 = R01
                           RDN    -0.525696561 = R02
                           RDN    -0.498028321 = R03
                           RDN    -0.470360081 = R04

and R05 = -0.442691841 , .......................... , R16 = -0.138341200

-Whence:

        S = 1.212710721 - 0.525696561 e₁ - 0.498028321 e₂ - 0.470360081 e₃
               - 0.442691841 e₄ - 0.415023601 e₅ - 0.387355361 e₆ - 0.359687121 e₇
               - 0.332018881 e₈ - 0.304350641 e₉ - 0.276682401 e₁₀ - 0.249014161 e₁₁
               - 0.221345920 e₁₂ - 0.193677680 e₁₃ - 0.166009440 e₁₄ - 0.138341200 e₁₅    is a solution of this equation.

Notes:

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

-Instead of displaying the real parts of the successive approximations, you could display the difference between 2 successive approximations:
-Add VIEW X after line 18 ( + ) and delete line 05 VIEW 01
-If the algorithm converges, these differences tend to 0.

-The termination criterion X#0? ( line 22 ) may lead to an infinite loop.
-Line 22 may be replaced by

E-8 ( or another "small" number )
X<Y?