Magic

# Magic Squares & Magic Cubes for the HP-41

Overview

1°)  Magic Squares

a)  Magic & Panmagic Squares
b)  More Panmagic-Squares ( prime order > 4 )
c)  Panmagic Squares of order n = 4m
d)  Magic Squares of order n = 4m
e)  Magic Squares of order n = 4m+2
f)  Bimagic Squares

2°)  Magic Cubes

a)  Magic & Panmagic Cubes
b)  More Panmagic-Cubes ( prime order > 10 )
c)  Magic Cubes of order n = 4 m
d)  Magic Cubes of order n = 6 , 10 , 14 , ....

3°)  Magic Squares and Cubes

4°)  A few Tests

a)  Magic Square ?
b)  Panmagic Square ?
c)  Magic Cube ?

5°)  4D Magic HyperCubes

-A few programs are listed in "Creating a Matrix" & "Creating a Hypermatrix" to make magic squares and magic cubes.
-They have been re-written to save bytes and to deal with larger order: they work provided the calculations do not exceed 10^10.
-Several routines have also been added to create more magic arrays.

1°)  Magic Squares

a)  Magic & Panmagic Squares

-The elements of a normal magic square are  1 , 2 , ............. , n2  and it has the following property:
All its row sums, column sums and both diagonal sums are equal to the magic constant   M = n.(n2 + 1)/2

-A panmagic square ( also called pandiagonal square ) is a magic square
where all the broken diagonal sums are also equal to the magic constant  M = n.(n2 + 1)/2

Formulae:

-The element ai,j of a magic square of odd order n  is calculated by  ai,j = 1 + ( i + 2 j - 2 ) mod n + n [ ( i + j - 1 + Int(n/2) ) mod n ]

-The element ai,j of a panmagic square of order n where n is neither a mutiple of 2 nor a multiple of 3 is calculated by

ai,j = 1 + [ ( i - 1 ) + 3 ( j - 1 ) ] mod n + n { [ ( i - 1 ) + 2 ( j - 1 ) ] mod n }

Data Registers:        R00 = n

>>>     R01 thru Rn2 = the elements of the square  if flag F00 is clear

Flags:   F00-F01

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  .............

CF 01 = Magic squares of order n where n is odd.
SF 01 = Panmagic squares of order n provided n mod 2 # 0 and n mod 3 # 0

Subroutines: /

 01  LBL "MGSQ"  02  STO 00  03  X^2  04  STO M  05  LBL 01  06  RCL M  07  1  08  -  09  STO Y  10  RCL 00 11  /  12  INT  13  ENTER^  14  ST+ X  15  FS? 01  16  GTO 01          17  RCL Z  18  +  19  X<> Z  20  + 21  RCL 00          22  2  23  /  24  INT  25  +  26  1  27  GTO 02  28  LBL 01  29  ST+ Y  30  RCL Z 31  LBL 02  32  ST+ Z  33  +  34  RCL 00          35  MOD  36  LASTX  37  *  38  X<>Y  39  LASTX  40  MOD 41  +  42  1  43  +  44  FC? 00  45  STO IND M   46  FS? 00  47  VIEW X  48  DSE M  49  GTO 01  50  END

( 77 bytes / SIZE 001 or 1+n^2 )

 STACK INPUTS OUTPUTS X n /

n mod 2 # 0                         if CF 01 - magic square
n mod 2 # 0 & n mod 3 # 0 if  SF 01 - Panmagic square

Examples:

•  CF 01   n = 3

3   XEQ "MGSQ"   the HP-41 displays   2   7   6   9   5   1   4   3   8    if  SF 00

-The magic square is

8   1   6
3   5   7
4   9   2

-Magic Constant = 15

•  SF 01   n = 5

5   XEQ "MGSQ"   the HP-41 displays   12   6   5   24   18  ....................   25   19   13   7   1    if  SF 00

-The panmagic square is

01   14   22   10   18
07   20   03   11   24
13   21   09   17   05
19   02   15   23   06
25   08   16   04   12

-Magic Constant = 65

Note:

-If flag F00 is set, the elements are displayed from the last one to the first.
-Lines 06-07 may be replaced by   RCL 00   X^2   RCL M
but in this case, the elements will be stored in the reverse order if  CF 00

b)  More Panmagic-Squares ( prime order > 4 )

-Here, we assume that the order is a prime p > 3

-Panmagic Squares may be created by the following formulae:

ai,j = 1 + [ b ( i - 1 ) + d ( j - 1 ) ] mod p + p { [ a ( i - 1 ) + c ( j - 1 ) ] mod p }

provided  a , b , c , d  verify the properties:

a , b , c , d  # 0  mod p
a + c , a - c # 0 mod p
b + d , b - d # 0 mod p
a.d - b.c # 0 mod p

Data Registers:        R00 = p           R01 to R12  are also used for temporary data storage.

>>>     R01 thru Rp2 = the elements of the panmagic square  if flag F00 is clear

Flag:   F00

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  ............

Subroutines: /

 01  LBL "PMAG+"  02  "ORDER?"  03  PROMPT  04  STO 00  05  LBL 00  06  "A^B^C^D"  07  PROMPT  08  STO 04  09  STO 08  10  STO 09  11  RDN  12  STO 03  13  STO 06  14  STO 07  15  RDN  16  STO 02  17  ST+ 08  18  ST- 09  19  X<>Y 20  STO 01  21  ST+ 06  22  ST- 07  23  RCL 04  24  *  25  RCL 02  26  RCL 03  27  *  28  -  29  STO 05  30  9  31  STO 10  32  LBL 01  33  RCL IND 10     34  RCL 00  35  MOD  36  X=0?  37  GTO 00  38  DSE 10 39  GTO 01  40  LASTX  41  X^2  42  STO 10             43  LBL 02  44  RCL 10  45  1  46  -  47  STO 11  48  RCL 00  49  /  50  INT  51  STO 12  52  RCL 03  53  *  54  RCL 01  55  RCL 11  56  *  57  + 58  RCL 00  59  MOD  60  LASTX  61  *  62  RCL 02             63  RCL 11  64  *  65  RCL 04  66  RCL 12  67  *  68  +  69  RCL 00  70  MOD  71  +  72  1  73  +  74  FS? 00  75  VIEW X  76  FS? 00 77  GTO 02  78  RCL 10             79  12  80  +  81  X<>Y  82  STO IND Y  83  LBL 02  84  DSE 10  85  GTO 02  86  RCL 00  87  X^2  88   E6  89  /  90  13.001  91  +  92  FS? 00  93  CLX  94  REGMOVE  95  END

( 142 bytes / SIZE 013 or 13+n^2 )

 STACK INPUTS OUTPUTS X / /

Example:    You want to create a panmagic square of order 5 with a = 1 , b = 2 , c = 3 , d = 4

XEQ "PMAG+"  >>>>    "ORDER?"
5        R/S        >>>>     "A^B^C^D"
1    ENTER^
2    ENTER^
3    ENTER^
4        R/S        >>>>     HP-41 displays   10   3   21   19   12   .......................   24   17   15   8   1     if  SF 00

-If flag  F00  is clear, you get:

R01   R06   R11   R16   R21          01   20   09   23   12
R02   R07   R12   R17   R22          08   22   11   05   19
R03   R08   R13   R18   R23   =     15   04   18   07   21
R04   R09   R14   R19   R24          17   06   25   14   03
R05   R10   R15   R20   R25          24   13   02   16   10

Notes:

-With n = 5, if you choose  (a,b,c,d) = (1,1,2,3) , you'll get the same panmagic square as in the above paragraph.
-If you choose a b c d  values that don't satisfy the required properties, the HP-41 displays "A^B^C^D" again.
-This routine does not check if p is a prime > 3, so line 02 may be replaced by a more explicit "PRIMEORDER>3"

-If you never want to store the elements, replace lines 74 to 94 by  VIEW X   DSE 10   GTO 02

-Instead of placing the keys a , b , c , d in the stack, you can also let your HP-41 choose these numbers at your place:

Data Registers:        R00 = p                            R05 to R08: temp   ( R08 = random numbers )

R01 = a    R03 = c
R02 = b    R04 = d
Flags:  /
Subroutines:  /

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

( 122 bytes / SIZE 009 )

 STACK INPUTS OUTPUTS Y r / X p /

where   r = random seed  and  p is a prime > 3

Example:         p = 5  ,  random seed = sqrt(2)

2   SQRT
5   XEQ "PMAG+"   >>>>    1   17   8   24  15  ......................................   16   7

-The panmagic square is

01   09   12   20   23
17   25   03   06   14
08   11   19   22   05
24   02   10   13   16
15   18   21   04   07

-Here, the keys are  3  1  1  3  in registers  R01 thru R04

Notes:

-Press  XEQ 10  to view the elements again ( otherwise, line 61 LBL 10 may be deleted )
-Set F21 and the program will stop at each VIEW X
-Press  XEQ 00  to search another magic square with the same order and the random seed in R08

-You can replace line 97 by SAVEX if you have created a DATA file in X-memory.

-It may take some time before the HP-41 finds valid keys, especially for small p-values.
-If you have an M-Code function RAND, lines 03 to 12 may be replaced by

LBL 00   4   STO 05   LBL 11   RAND

c)  Panmagic Squares of order  n = 4 m

-The method is more complicated !

Formula:

-We calculate

[ ( i - 1 ) + ( n/2 ) ( j - 1 ) ] mod n = x       if   x >= n/2   x' = 3n/2 - x - 1  &  if  x < n/2 ,  x' = x
[ ( n/2 ) ( i - 1 ) + ( i - 1 ) ] mod n = y       if   y >= n/2   y' = 3n/2 - y - 1  &  if  y < n/2 ,  y' = y

-Then,  ai,j = 1 + n x' + y'

Data Registers:        R00 = n

>>>     R01 thru Rn2 = the elements of the square  if flag F00 is clear

Flags:   F00

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  .............

Subroutines: /

 01  LBL "PMAG4"  02  STO 00  03  X^2  04  STO O  05  LBL 01  06  RCL O  07  1  08  -  09  STO N  10  RCL 00  11  /  12  INT 13  X<> N  14  RCL 00             15  MOD  16  STO M  17  LASTX  18  2  19  /  20  STO Z  21  ST* M  22  RCL N  23  ST+ M  24  * 25  +  26  RCL 00             27  MOD  28  X M  38  LASTX  39  MOD  40  X

( 88 bytes / SIZE 001 or 1+n^2 )

 STACK INPUTS OUTPUTS X n 1

where  n is a multiple of 4

Example:     n = 4

4   XEQ "PMAG4"   the HP-41 displays successively   6  3  10  15  ..............  12  13  8  1   if  SF 00

-The whole panmagic square is:

01   14   04   15
08   11   05   10
13   02   16   03
12   07   09   06

-The magic constant = 34

Note:

-There is no normal panmagic squares of order  2 , 6 , 10 , ....

d)  Magic Squares of order n = 4m

Formulae:

-Let  x' = 0  if  1 <= x <= n/2
and  x' = 1  if  n/2 < x <= n

-Let  x" = n + 1 - x

-If  ( i + j + i' + j' ) mod 2 = 1  then   ai,j =  n ( i - 1 ) + j
-If  ( i + j + i' + j' ) mod 2 = 0  then   ai,j =  n ( i" - 1 ) +  j"

Data Registers:        R00 = n

>>>     R01 thru Rn2 = the elements of the square  if flag F00 is clear

Flags:   F00

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  .............

Subroutines: /

 01  LBL "MGSQ4"  02  STO 00  03  X^2  04  STO N  05  LBL 01  06  RCL N  07  1  08  -  09  STO M  10  RCL 00  11  ST/ M  12  MOD  13  X<> M 14  INT  15  RCL M  16  RCL 00             17  2  18  /  19  -  20  X=0?  21  ISG X  22  ""  23  X<0?  24  CLX  25  X>0?  26  ST/ X 27  ST+ Z  28  X<> L  29  -  30  X<0?  31  FS? 30  32  SIGN  33  X<0?  34  CLX  35  +  36  RCL M             37  +  38  2  39  MOD 40  X=0?  41  GTO 01  42  X<> M  43  GTO 00  44  LBL 01  45  X<>Y  46  CHS  47  RCL M  48  CHS  49  RCL 00             50  DSE X  51  ST+ Z  52  + 53  LBL 00  54  RCL 00             55  *  56  +  57  1  58  +  59  FC? 00  60  STO IND N  61  FS? 00  62  VIEW X  63  DSE N  64  GTO 01  65  END

( 99 bytes / SIZE 001 or 1+n^2 )

 STACK INPUTS OUTPUTS X n 1

where  n is a multiple of 4

Example:     n = 4

4   XEQ "MGSQ4"   the HP-41 displays successively   1   12   8   13   .................   4   9   5   16   if  SF 00

-The whole magic square is:

16   02   03   13
05   11   10   08
09   07   06   12
04   14   15   01

-The magic constant = 34

e)  Magic Squares of order n = 4m+2

-Singly-even order magic squares exist, but the formulas are complicated.
-"MGSQ6" uses the following ones:

Let   t = n/2

u = ( i' - j' ) mod t                  where           x' = min { x , n+1-x }
v = 2 i" + j"                              and            x" = 0  if  0 < x <= n/2  &  x" = 1  if  n/2 < x <= n

Then,  d(u,v) is defined by the table ( in the last 2 rows, x > 0 so that u > 2 ):

 d(u,0) d(u,1) d(u,2) d(u,3) d(0,v) 3 1 2 0 d(1,v) 1 3 0 2 d(2,v) 0 1 3 2 d(2x+1,v) 0 1 2 3 d(2x+2,v) 3 2 1 0

Finally,  ai,j =  t2 d(u,v)  +  t  [  ( i' - j' + (t-1)/2 )  mod t ]  +  [  ( i' + j' - (t+1)/2 )  mod t ] + 1

Data Registers:    R00 = n       R01 thru R08: temp
Flags:  /
Subroutines:  /

-Line 147 is a three-byte  GTO 01

 01  LBL "MGSQ6"   02  STO 00   03  X^2   04  STO 03   05  LBL 01   06  RCL 03   07  1   08  STO 04   09  STO 05   10  -   11  STO 01   12  RCL 00   13  MOD   14  X<> 01   15  LASTX   16  /   17  INT   18  STO 02   19  RCL 00   20  2   21  /   22  STO 06   23  X>Y?   24  DSE 05   25  CLX   26  RCL 01   27  RCL 06   28  X>Y?   29  DSE 04   30  CLX 31  RCL 00   32  RCL 01   33  ST- Y   34  1   35  +   36  X>Y?   37  X<>Y   38  STO 07   39  RCL 00              40  RCL 02   41  ST- Y   42  LASTX   43  +   44  X>Y?   45  X<>Y   46  STO 08   47  RCL 07   48  -   49  RCL 06   50  MOD   51  X<> 04   52  ST+ X   53  RCL 05   54  +   55  STO 05   56  2   57  MOD   58  STO 01   59  LASTX   60  RCL 04 61  X>Y?   62  GTO 01   63  X=Y?   64  GTO 03   65  X=0?   66  GTO 05   67  RCL 01              68  5   69  *   70  2   71  +   72  RCL 05   73  -   74  2   75  /   76  GTO 06   77  LBL 01   78  X<>Y   79  MOD   80  X=0?   81  GTO 02   82  RCL 05   83  GTO 06   84  LBL 02   85  3   86  RCL 05   87  -   88  GTO 06   89  LBL 03   90  RCL 01 91  X=0?   92  GTO 04   93  RCL 05   94  +   95  2   96  /   97  GTO 06   98  LBL 04   99  RCL 05            100  3 101  * 102  2 103  / 104  GTO 06 105  LBL 05 106  6 107  RCL 01 108  3 109  * 110  - 111  RCL 05 112  - 113  2 114  / 115  LBL 06 116  RCL 06 117  X^2 118  * 119  RCL 06 120  2 121  / 122  INT 123  STO 01 124  RCL 07 125  + 126  RCL 08 127  - 128  RCL 06            129  MOD 130  LASTX 131  * 132  RCL 07 133  RCL 08 134  + 135  RCL 01 136  - 137  1 138  - 139  RCL 06 140  MOD 141  + 142  + 143  1 144  + 145  VIEW X 146  DSE 03 147  GTO 01 148  END

( 179 bytes / SIZE 009 )

 STACK INPUTS OUTPUTS X n /

where  n > 2 is a multiple of 2 but not a multiple of 4

Example:     n = 6

6   XEQ "MGSQ6"   the HP-41 displays successively   4   26   21   30   17   13   ..............   22   35   3   12   8   31

-So, we get an example of sixth-order magic square is

04   26   21   30   17   13
20   06   25   16   15   29
27   19   05   14   28   18
36   01   23   32   10   09
02   24   34   07   33   11
22   35   03   12   08   31

Notes:

-You may of course change the order of the elements.
-If you want to store these numbers,

add   RCL 00   X^2    E6   /    9.001   +   REGMOVE   after line 147
and  replace line 145 by   RCL 03   8   +   X<>Y   STO IND Y

-I found these formulae - after some trial and error - by analogy with those given in reference [4] for creating singly-even order magic cubes.
-They work well for magic squares of order  6  10  14  18  22 ( I've checked )
but I cannot guarantee they are valid in all cases ( though I would be surprised if they were not ! )

f)  Bimagic Squares

"BMAG"  constructs a bimagic square ( a magic square that remains magic after squaring all its elements ) of order p2 provided  p is a prime  p > 2

If p > 3 , the bimagic square is also panmagic.

-The method uses 4 key-numbers:  r = ( a b c d )p  r' = ( a' b' c' d' )p  r" = ( a" b" c" d" )p  r''' = ( a''' b''' c''' d''' )p  witten in base p
-The element ai,j  is given by

ai,j =  p3 [  { a [ ( i - 1 ) mod p ]  + a' int [ ( i - 1 ) / p ] + a" [ ( j - 1 ) mod p ] + a''' int [ ( j - 1 ) / p ] } mod p ]
+  p2 [  { b [ ( i - 1 ) mod p ]  + b' int [ ( i - 1 ) / p ] + b" [ ( j - 1 ) mod p ] + b''' int [ ( j - 1 ) / p ] } mod p ]
+  p  [  { c [ ( i - 1 ) mod p ]  + c' int [ ( i - 1 ) / p ] + c" [ ( j - 1 ) mod p ] + c''' int [ ( j - 1 ) / p ] } mod p ]
+     [  { d [ ( i - 1 ) mod p ]   + d' int [ ( i - 1 ) / p ] + d" [ ( j - 1 ) mod p ] + d''' int [ ( j - 1 ) / p ] } mod p ] + 1

-This formula will give a bimagic square if the following determinant is different from 0  ( mod p )

a   b   c   d
a'  b'  c'  d'
a"  b"  c"  d"
a''' b''' c''' d'''

and if   a b' - a' b # 0 ,  a c' - a' c # 0 , a d' - a' d # 0 , b c' - b' c # 0 , ...... , c d' - c' d # 0    ( mod p )
and similar relations with the keys  r" & r'''

-The square will be panmagic if the keys

r + r" &  r' + r'''  and
r - r"  &  r' - r'''  satisfy the same similar relations too.

-In the following program,  the 4 keys are:

( 2 1 0 1 )   ( 0 1 1 2 )  ( 1 0 2 1 )  ( 2 1 2 0 )    if p = 3
( 0 1 1 1 )   ( 1 0 1 2 )  ( 3 3 2 1 )  ( 2 1 0 1 )    if p > 3 , p # 11
( 0 1 1 1 )   ( 1 0 1 2 )  ( 3 3 2 0 )  ( 2 1 0 1 )    if p = 11

-But other choices are clearly posible.

Data Registers:    R00 = p2                                R05 = p         R06 = k = p4 , p4 - 1 , ..... , 2 , 1

R01 = ( i - 1 ) mod p               R03 = ( j - 1 ) mod p              with       i - 1 = ( k - 1 ) mod p2
R02 = int [ ( i - 1 ) / p ]            R04 = int [ ( j - 1 ) / p ]           and       j - 1 = int [ ( k - 1 ) / p2 ]

Flags:  F09-F10
Subroutines: /

-Line 119 is a three-byte  GTO 01

 01  LBL "BMAG"   02  STO 05   03  X^2   04  STO 00   05  X^2   06  STO 06   07  CF 09   08  CF 10   09  3   10  RCL 05   11  X=Y?   12  SF 09   13  11   14  X=Y?   15  SF 10   16  LBL 01   17  RCL 06   18  1   19  -   20  STO 04   21  RCL 00   22  MOD   23  STO 02   24  RCL 05   25  MOD 26  STO 01            27  ST+ X   28  FC? 09   29  CLST   30  RCL 02   31  RCL 05   32  /   33  INT   34  STO 02   35  FS? 09   36  CLX   37  +   38  RCL 04   39  RCL 00   40  /   41  INT   42  STO 04   43  RCL 05   44  MOD   45  STO 03   46  3   47  FS? 09   48  SIGN   49  *   50  + 51  RCL 04   52  RCL 05            53  /   54  INT   55  STO 04   56  ST+ X   57  +   58  RCL 05   59  MOD   60  LASTX   61  *   62  RCL 01   63  RCL 02   64  FC? 09   65  CLX   66  +   67  RCL 03   68  3   69  FS? 09   70  CLX   71  *   72  +   73  RCL 04   74  +   75  RCL 05 76  MOD   77  +   78  RCL 05            79  *   80  RCL 02   81  RCL 01   82  FS? 09   83  CLX   84  +   85  RCL 03   86  ST+ X   87  +   88  RCL 04   89  ST+ X   90  FC? 09   91  CLX   92  +   93  RCL 05   94  MOD   95  +   96  RCL 05   97  *   98  RCL 01   99  RCL 02 100  ST+ X 101  + 102  RCL 03          103  FC? 09 104  FS? 10 105  X<0? 106  CLX 107  + 108  RCL 04 109  FS? 09 110  CLX 111  + 112  RCL 05 113  MOD 114  + 115  1 116  + 117  VIEW X 118  DSE 06 119  GTO 01 120  CF 09 121  CF 10 122  END

( 157 bytes / SIZE 007 )

 STACK INPUTS OUTPUTS X p 1

where  p is a prime,  p > 2

Example:     p = 3    We'll have a bimagic square of order 9

3   XEQ "BMAG"   the HP-41 displays successively    33  77  13  46  .....................  15  48  65  1

-The whole bimagic square is:

01   35   60   70   14   39   49   74   27
65   18   40   53   78   19   05   30   61
48   79   23   09   31   56   69   10   44               Magic Constant = 369
15   37   71   75   25   50   36   58   02
76   20   54   28   62   06   16   41   66               Magic Constant of the squared elements = 20049
32   57   07   11   45   67   80   24   46
26   51   73   59   03   34   38   72   13
63   04   29   42   64   17   21   52   77
43   68   12   22   47   81   55   08   33

-The elements are actually displayed from the last one to the first one, but it's only a convention.
-If you prefer the reverse order, replace lines 17-18 by  RCL 00   X^2   RCL 06

2°)  Magic Cubes

a)  Magic & Panmagic Cubes

-The following programs create normal magic cubes, i-e their elements are  1  2  3  ...............  n3

-An Andrews magic cube is a cubic array where the sums of the elements equal the magic constant n(n3+1)/2  in the 3 directions and the 4 space diagonals.
-The cube is perfect pandiagonal if all the orthogonal sections are panmagic squares.
-In a panmagic cube , all the orthogonal or diagonal sections - broken or unbroken - are panmagic squares.

"MGCB" builds:

Andrews magic cubes if n = 3 or 5 and - more generally - if n is odd and flag F01 is clear.
Perfect pandiagonal magic cube if n = 7 & SF 01
Panmagic cubes if n is a prime > 7 & SF 01

Formulae:

ai,j,k =  n2  { [ a ( i - 1 ) + a' ( j - 1 ) + a" ( k - 1 ) ] mod n }
+  n  { [ b ( i - 1 ) + b' ( j - 1 ) + b" ( k - 1 ) ] mod n }
+  [  c ( i - 1 ) + c' ( j - 1 ) + c" ( k - 1 ) ] mod n + 1

with

( a b c )   =  ( 1 -1  1 )
( a' b' c' )  =  ( -1  1  1 )      to create Andrews Magic Cubes of odd orders
( a" b" c" ) =  ( 1  1  -1 )

( a b c )   =  ( 6  5  4 )
( a' b' c' )  =  ( 5  4  5 )       if  n = 7 & SF 01
( a" b" c" ) =  ( 4  6  6 )

( a b c )   =  ( 1  1  1 )
( a' b' c' )  =  ( 3  2  2 )       if  n is a prime > 7  &  SF 01
( a" b" c" ) =  ( 5  5  4 )

Data Registers:        R00 = n is an odd integer

>>>     R01 thru Rn3 = the elements of the cube      if flag F00 is clear

Flags:    F00-F01

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  .............

Subroutines: /

-Line 107 is a three-byte  GTO 01

 01  LBL "MGCB"   02  STO 00   03  3   04  Y^X   05  STO O   06  LBL 01   07  RCL O   08  1   09  -   10  ENTER^   11  STO N   12  RCL 00   13  MOD   14  STO M   15  X<> L   16  X^2   17  MOD   18  RCL 00   19  /   20  INT   21  X<> N   22  RCL 00 23  X^2   24  /   25  INT   26  STO Y   27  RCL 00            28  7   29  -   30  FS? 01   31  X<0?   32  GTO 01   33  X=0?   34  GTO 02   35  RDN   36  ST+ X   37  RCL N   38  +   39  ST+ X   40  RCL M   41  +   42  ENTER^   43  R^   44  + 45  RCL X   46  RCL N   47  GTO 03   48  LBL 01            49  RDN   50  CHS   51  RCL M   52  +   53  RCL N   54  +   55  ENTER^   56  CHS   57  RCL X   58  LASTX   59  ST+ X   60  +   61  X<>Y   62  RCL M   63  ST+ X   64  GTO 03   65  LBL 02   66  CLX 67  RCL M   68  RCL N   69  +   70  ST+ X   71  +   72  CHS   73  RCL M   74  CHS   75  X<>Y   76  ST+ Y   77  RCL N   78  CHS   79  X<>Y   80  ST+ Y   81  R^   82  ST+ X   83  -   84  RCL M   85  LBL 03   86  +   87  RCL 00            88  MOD 89  LASTX   90  *   91  X<>Y   92  LASTX   93  MOD   94  +   95  RCL 00            96  *   97  X<>Y   98  LASTX   99  MOD 100  + 101  1 102  + 103  FC? 00 104  STO IND O 105  FS? 00 106  VIEW X 107  DSE O 108  GTO 01 109  END

( 158 bytes / SIZE 001 or 1+n^3 )

 STACK INPUTS OUTPUTS X n 1

Example:      With n = 3

3   XEQ "MGCB"  the HP-41 displays  27   11   4   ...................   24   17   1          if   SF 00

-If  CF 00, we get in registers R01 thru R27

R01   R04   R07       01   23   18
R02   R05   R08  =   17   03   22
R03   R06   R09       24   16   02

R10   R13   R16       15   07   20
R11   R14   R17  =   19   14   09
R12   R15   R18       08   21   13

R19   R22   R25      26   12   04
R20   R23   R26  =  06   25   11
R21   R24   R27      10   05   27

-The magic constant = 42

Note:

-Clearing or setting F01 has no effect if n = 3 or n = 5.

b)  More Panmagic-Cubes ( prime order > 10 )

-The formula

ai,j,k =  n2  { [ a ( i - 1 ) + a' ( j - 1 ) + a" ( k - 1 ) ] mod n }
+  n  { [ b ( i - 1 ) + b' ( j - 1 ) + b" ( k - 1 ) ] mod n }
+  [  c ( i - 1 ) + c' ( j - 1 ) + c" ( k - 1 ) ] mod n + 1

will produce a panmagic cube provided the following relations are satisfied:

|  a   a'   a"  |
Det |  b   b'   b"  |   #  0   mod p
|  c   c'   c"  |

a , a' , a" ,  a + a' ,   a - a'  ,  a + a"  ,  a - a"  ,  a' + a"  ,  a' - a"  ,  a + a' + a"  ,  -a + a' + a"  ,  a - a' + a"  ,  a + a' - a"  #  0  mod  p

and similar relations with  b  and  c

-"PMGC+"  choose 9 numbers at random between  1 & p-1  and tests if these properties are satisfied.
-Otherwise, 9 other numbers are created and so on ...

-When valid keys are found, the successive elements of the panmagic cube are displayed.

Data Registers:        R00 = p                            R10 to R15: temp   ( R15 = random numbers )

R01 = a    R04 = a'    R07 = a"
R02 = b    R05 = b'   R08 = b"
R03 = c    R06 = c'    R09 = c"
Flags:  /
Subroutines:  /

-Lines 99-106-141 are three-byte  GTO 00
-Lines 109 to 137 may be replaced by  XEQ "D3"  ( cf "Determinants for the HP-41" )

 01  LBL "PMGC+"   02  STO 00   03  X<>Y   04  STO 15   05  LBL 00   06  9   07  STO 10   08  LBL 11   09  RCL 15   10  R-D   11  FRC   12  STO 15   13  RCL 00   14  DSE X   15  *   16  INT   17  1   18  +   19  STO IND 10   20  DSE 10   21  GTO 11   22  3   23  STO 10   24  LBL 12   25  RCL 07   26  X<> 08   27  X<> 09   28  STO 07   29  RCL 04   30  X<> 05   31  X<> 06   32  STO 04   33  RCL 01   34  X<> 02   35  X<> 03   36  STO 01   37  + 38  STO 11   39  RCL 00              40  MOD   41  X=0?   42  GTO 00   43  RCL 01   44  RCL 04   45  -   46  STO 12   47  RCL 00   48  MOD   49  X=0?   50  GTO 00   51  RCL 01   52  RCL 07   53  +   54  RCL 00   55  MOD   56  X=0?   57  GTO 00   58  RCL 01   59  RCL 07   60  -   61  RCL 00   62  MOD   63  X=0?   64  GTO 00   65  RCL 04   66  RCL 07   67  +   68  RCL 00   69  MOD   70  X=0?   71  GTO 00   72  RCL 04   73  RCL 07   74  - 75  RCL 00              76  MOD   77  X=0?   78  GTO 00   79  RCL 07   80  RCL 11   81  +   82  RCL 00   83  MOD   84  X=0?   85  GTO 00   86  RCL 07   87  RCL 11   88  -   89  RCL 00   90  MOD   91  X=0?   92  GTO 00   93  RCL 07   94  RCL 12   95  +   96  RCL 00   97  MOD   98  X=0?   99  GTO 00 100  RCL 07 101  RCL 12 102  - 103  RCL 00 104  MOD 105  X=0? 106  GTO 00 107  DSE 10 108  GTO 12 109  RCL 05 110  RCL 09 111  * 112  RCL 06 113  RCL 08            114  * 115  - 116  RCL 01 117  * 118  RCL 02 119  RCL 09 120  * 121  RCL 03 122  RCL 08 123  * 124  - 125  RCL 04 126  * 127  - 128  RCL 02 129  RCL 06 130  * 131  RCL 03 132  RCL 05 133  * 134  - 135  RCL 07 136  * 137  + 138  RCL 00 139  MOD 140  X=0? 141  GTO 00 142  LBL 10 143  RCL 00 144  3 145  Y^X 146  STO 10 147  STO 14 148  LBL 13 149  RCL 14 150  RCL 10            151  - 152  STO 12 153  RCL 00 154  X^2 155  / 156  INT 157  STO 13 158  RCL 12 159  RCL 00 160  X^2 161  MOD 162  RCL 00 163  / 164  INT 165  X<> 12 166  RCL 00 167  MOD 168  STO 11 169  RCL 01 170  * 171  RCL 04 172  RCL 12 173  * 174  + 175  RCL 07 176  RCL 13 177  * 178  + 179  RCL 00 180  MOD 181  LASTX 182  * 183  RCL 02 184  RCL 11 185  * 186  RCL 05 187  RCL 12            188  * 189  + 190  RCL 08 191  RCL 13 192  * 193  + 194  RCL 00 195  MOD 196  + 197  RCL 00 198  * 199  RCL 03 200  RCL 11 201  * 202  RCL 06 203  RCL 12 204  * 205  + 206  RCL 09 207  RCL 13 208  * 209  + 210  RCL 00 211  MOD 212  + 213  1 214  + 215  VIEW X 216  DSE 10 217  GTO 13 218  END

( 258 bytes / SIZE 016 )

 STACK INPUTS OUTPUTS Y r / X p /

where   r = random seed  and  p is a prime > 10

Example:         p = 41  ,  random seed = 1

1    ENTER^
41   XEQ "PMGC+"   >>>>    1   8485   16928   25371   33814  ......................................  30339   38782   47225   55668   64111.

-The keys are in registers  R01 thru R09

(a,b,c)  =  (  5    1  38 )  =  R01  R02  R03
(a',b',c') =  ( 26  14 13 )  =  R04  R05  R06
(a",b",c") =  ( 13  21  4 )   =  R07  R08  R09

Notes:

-Press  XEQ 10  to view the elements again ( otherwise, line 142 LBL 10 may be deleted )
-Set F21 and the program will stop at each VIEW X
-Press  XEQ 00  to search another magic square with the same order and the random seed already in R15

-You can replace line 215 by HSAVEX if you have created an HEPAX  DATA file - and if n is not too large...

-It may take a long time before the HP-41 finds valid keys, especially if p = 11 or 13.
-If you have an M-Code function RAND, lines 03 to 12 may be replaced by

LBL 00   9   STO 10   LBL 11   RAND

-If you want to use your own keys, initialize  R00 thru R09, add  LBL 09  after line 21
and  press  XEQ 09  to check the keys or directly  XEQ 10  to display the elements of the panmagic cube.
( Change the first lines according to your preferences to get more explicit PROMPTs )

c)  Magic Cubes of order n = 4 m

Formulae:

-Let  x' = 0  if  1 <= x <= n/2
and  x' = 1  if  n/2 < x <= n

-Let  x" = n + 1 - x

-If  ( i + j + k + i' + j' + k' ) mod 2 = 1  then   ai,j,k =  n2 ( i - 1 ) + n ( j - 1 ) + k
-If  ( i + j + k + i' + j' + k' ) mod 2 = 0  then   ai,j,k =  n2 ( i" - 1 ) + n ( j" - 1 ) + k"

Data Registers:        R00 = n

>>>     R01 thru Rn3 = the elements of the cube      if flag F00 is clear

Flag:    F00

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  .............

Subroutines: /

 01  LBL "MGCB4"  02  STO 00  03  3  04  Y^X  05  STO O  06  LBL 01  07  RCL O  08  1  09  -  10  ENTER^  11  STO N  12  RCL 00  13  MOD  14  STO M  15  X<> L  16  X^2  17  MOD  18  RCL 00  19  /  20  INT 21  X<> N  22  RCL 00  23  X^2  24  /  25  INT  26  RCL M  27  RCL 00             28  2  29  /  30  -  31  X=0?  32  ISG X  33  ""  34  X<0?  35  CLX  36  X>0?  37  ST/ X  38  ST+ Z  39  X<> L  40  - 41  X=0?  42  ISG X  43  ""  44  X<0?  45  CLX  46  X>0?  47  ST/ X  48  ST+ Y  49  CLX  50  RCL N  51  LASTX  52  -  53  X<0?  54  FS? 30  55  SIGN  56  X<0?  57  CLX  58  +  59  RCL M             60  + 61  RCL N  62  +  63  2  64  MOD  65  X=0?  66  GTO 00  67  X<>Y  68  CHS  69  RCL N  70  CHS  71  RCL M  72  CHS  73  RCL 00             74  DSE X  75  ST+ T  76  ST+ Z  77  +  78  GTO 01  79  LBL 00  80  X<> N 81  RCL M  82  LBL 01  83  RCL 00  84  *  85  +  86  RCL 00             87  *  88  +  89  1  90  +  91  FC? 00  92  STO IND O  93  FS? 00  94  VIEW X  95  DSE O  96  GTO 01  97  END

( 141 bytes / SIZE 001 or 1+n^3 )

 STACK INPUTS OUTPUTS X n /

Example:    With n = 4

4  XEQ "MGCB4"  the HP-41 displays  64   17   33   16   ...................   49   32   48   1     if  SF 00

-If  CF 00  we get:

R01 = 1  R02 = 48  R03 = 32  R04 = 49  ........................  R63 = 17  R64 = 64

d)  Magic Cubes of order n = 6 , 10 , 14 , ....

-Now we assume that the order n = 2 ( mod 4 ) ,  n > 2
-The formulas are more complex. They may be found in reference [4]

-"MGCB6"  displays the successive elements.

Data Registers:        R00 = n                            R01 to R08: temp
Flags:  /
Subroutines:  /

-Line 187 is a three-byte  GTO 01

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

( 225 bytes / SIZE 009 )

 STACK INPUTS OUTPUTS X n /

Example:    With n = 6

6  XEQ "MGCB6"  the HP-41 displays   116   201   22   76   66   170   ...........................   35   147   157   211   12   89.

-The magic sum = 651

3°)  Magic Squares and Cubes

-This routine combines the programs listed in §1-a) & §2-a)

Data Registers:        R00 = n

>>>     R01 thru Rn2 or Rn3 = the elements of the square or the cube  if flag F00 is clear

Flags:   F00-F01-F03

SF 00 = The elements are successively displayed
CF 00 = The elements are stored into R01  R02  .............

CF 03 = Magic Squares

CF 01 = Magic squares of order n where n is odd.
SF 01 = Panmagic squares of order n where n mod 2 # 0 and n mod 3 # 0

SF 03 = Magic Cubes

CF 01 = Andrews Magic cubes of order n where n is odd.
SF 01 =

Andrews magic cube if n = 3 or 5
perfect pandiagonal magic cube if n = 7
Panmagic cube if n is a prime > 7

Subroutines: /

-Line 139 is a three-byte GTO 01

 01  LBL "MAGIC"   02  STO 00   03  ENTER^   04  X^2   05  FS? 03   06  *   07  STO O   08  LBL 01   09  RCL O   10  1   11  -   12  ENTER^   13  STO N   14  RCL 00   15  MOD   16  FS? 03   17  GTO 02   18  X<>Y   19  LASTX   20  /   21  INT   22  ENTER^   23  ST+ X   24  FS? 01   25  GTO 01   26  RCL Z   27  +   28  X<> Z 29  +   30  1   31  ST+ Z   32  +   33  RCL 00              34  2   35  /   36  INT   37  GTO 05   38  LBL 01   39  ST+ Y   40  RCL Z   41  ST+ Z   42  GTO 05   43  LBL 02   44  STO M   45  X<> L   46  X^2   47  MOD   48  RCL 00   49  /   50  INT   51  X<> N   52  RCL 00   53  X^2   54  /   55  INT   56  STO Y 57  RCL 00              58  7   59  -   60  FS? 01   61  X<0?   62  GTO 03   63  X=0?   64  GTO 04   65  RDN   66  ST+ X   67  RCL N   68  +   69  ST+ X   70  RCL M   71  +   72  ENTER^   73  R^   74  +   75  RCL X   76  RCL N   77  GTO 05   78  LBL 03   79  RCL M   80  R^   81  -   82  RCL N   83  +   84  ENTER^ 85  CHS   86  RCL X   87  LASTX   88  ST+ X   89  +   90  X<>Y   91  RCL M   92  ST+ X   93  GTO 05   94  LBL 04   95  CLX   96  RCL M   97  RCL N   98  +   99  ST+ X 100  + 101  CHS 102  RCL M            103  CHS 104  X<>Y 105  ST+ Y 106  RCL N 107  CHS 108  X<>Y 109  ST+ Y 110  R^ 111  ST+ X 112  - 113  RCL M 114  LBL 05 115  + 116  RCL 00            117  MOD 118  LASTX 119  * 120  X<>Y 121  LASTX 122  MOD 123  + 124  FC? 03 125  GTO 06 126  X<>Y 127  RCL 00 128  ST* Z 129  MOD 130  + 131  LBL 06 132  1 133  + 134  FC? 00 135  STO IND O 136  FS? 00 137  VIEW X 138  DSE O 139  GTO 01 140  END

( 207 bytes / SIZE 001 or 1+n^2 or 1+n^3 )

 STACK INPUTS OUTPUTS X n 1

Examples:     See §1-a) & §2-a)

4°)  A few Tests

a)  Magic Square ?

-This program checks if a given square matrix is a magic square.
-The coefficients are to be stored in registers R01 thru Rn2

-The magic constant is returned in register X if the answer is YES

Data Registers:              R00 = n                ( Registers R01 thru Rn^2 are to be initialized before executing "MGSQ?" )

•  R01 thru Rn2 = the elements ai,j
Flags: /
Subroutines: /

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

( 144 bytes / SIZE 1+n^2 )

 STACK INPUTS OUTPUTS X n Magic Cste*

* If the HP-41 displays YES at the end

Example:   Store the following 6x6 array into R01 to R36 ( column order or raw order )

06  32  03  34  35  01
07  11  27  28  08  30
19  14  16  15  23  24
18  20  22  21  17  13
25  29  10  09  26  12
36  05  33  04  02  31

6  XEQ "MGSQ?"  >>>>   "YES"                     ---Execution time = 24s---

and  X = magic constant = 111

b)  Panmagic Square ?

-This program checks if a given square matrix is a panmagic square.
-The coefficients must be stored in registers R01 thru Rn2

-The magic constant is returned in register X if the answer is YES

Data Registers:              R00 = n                  ( Registers R01 thru Rn^2 are to be initialized before executing "MGSQ?" )

•  R01 thru Rn2 = the elements ai,j
Flag:   F10
Subroutines: /

-Line 31 is a three-byte  GTO 06  but it's not really important.

 01  LBL "PMAG?"   02  STO 00   03  STO M   04  X^2   05  STO N   06  SF 10   07  LBL 00   08  0   09  LBL 01   10  RCL IND Y   11  +   12  RCL Y   13  RCL 00   14  MOD   15  1   16  ST- T   17  -   18  X=0?   19  GTO 01   20  CLX   21  RCL 00   22  ST- Z   23  LBL 01   24  RDN   25  DSE M   26  GTO 01 27  FS?C 10   28  STO O   29  RCL O   30  X#Y?   31  GTO 06   32  RCL 00             33  STO M   34  X^2   35  LASTX   36  -   37  DSE N   38  RCL N   39  X>Y?   40  GTO 00   41  RCL 00   42  X^2   43  STO N   44  LBL 02   45  0   46  LBL 03   47  RCL IND Y   48  +   49  RCL Y   50  RCL 00   51  ST- T   52  ISG T 53  CLX   54  MOD   55  X#0?   56  GTO 03   57  X<> L   58  ST- Z   59  LBL 03   60  RDN   61  DSE M   62  GTO 03   63  RCL O   64  X#Y?   65  GTO 06   66  RCL 00             67  STO M   68  X^2   69  LASTX   70  -   71  DSE N   72  RCL N   73  X>Y?   74  GTO 02   75  RCL 00   76  X^2   77  LASTX   78  STO N 79  0   80  LBL 04   81  RCL IND Z   82  +   83  DSE Z   84  ""   85  DSE Y   86  GTO 04   87  RCL O   88  X#Y?   89  GTO 06   90  R^   91  RCL 00             92  0   93  DSE N   94  GTO 04   95  RCL 00   96  STO N   97  X^2   98  LASTX   99   E5 100  / 101  + 102  STO M 103  RCL 00 104  0 105  LBL 05 106  RCL IND Z 107  + 108  DSE Z 109  "" 110  DSE Y 111  GTO 05 112  RCL O 113  X#Y? 114  GTO 06 115  RCL M 116  1 117  - 118  STO M 119  RCL 00           120  0 121  DSE N 122  GTO 05 123  RCL O 124  "YES" 125  GTO 07 126  LBL 06 127  "NO" 128  LBL 07 129  AVIEW 130  END

( 204 bytes / SIZE 1+n^2 )

 STACK INPUTS OUTPUTS X n Magic Cste*

* If the HP-41 displays YES at the end

Example:   Store the following matrix into R01 to R36 ( column order or raw order )

067   193   071   251   109   239
139   233   113   181   157   107
241   097   191   089   163   149
073   167   131   229   151   179
199   103   227   101   127   173
211   137   197   079   223   083

6  XEQ "PMAG?"  >>>>   "YES"                     ---Execution time = 58s---

and  X = magic constant = 930

-This panmagic square contains all the consecutive primes between 67 and 251
-It was found by Allan W. Johnson

c)  Magic Cube ?

-This program checks if a given cubic array is an Andrews magic cube.
-The coefficients must be stored in registers R01 thru Rn3

-The magic constant is returned in register X if the answer is YES

Data Registers:              R00 = n           ( Registers R01 thru Rn^3 are to be initialized before executing "MGCB?" )

•  R01 thru Rn3 = the elements ai,j,k
Flags: /
Subroutines: /

-Lines 25-41-51 are three-byte GTO 04, but it doesn't really matter.

 01  LBL "MGCB?"   02  STO 00   03  ENTER^   04  X^2   05  *   06  STO M   07  LASTX   08  RCL 00   09  +   10  STO N   11  1   12  +   13  XEQ 00   14  STO O   15  RCL M   16  RCL 00   17  -   18  RCL N   19  1   20  ST+ Z   21  -   22  XEQ 00   23  RCL O   24  X#Y?   25  GTO 04   26  RCL M   27  RCL 00   28  X^2   29  -   30  STO M   31  LASTX 32  RCL 00              33  -   34  STO N   35  1   36  ST+ Z   37  -   38  XEQ 00   39  RCL O   40  X#Y?   41  GTO 04   42  RCL M   43  RCL 00   44  +   45  RCL N   46  1   47  +   48  XEQ 00   49  RCL O   50  X#Y?   51  GTO 04   52  RCL 00   53  STO M   54  ENTER^   55  X^2   56  STO N   57  *   58  GTO 01   59  LBL 00   60   E5   61  /   62  + 63  RCL 00              64  0   65  LBL 09   66  RCL IND Z   67  +   68  DSE Z   69  ""   70  DSE Y   71  GTO 09   72  RTN   73  LBL 10   74  ENTER^   75  CLX   76  LBL 12   77  RCL IND Y   78  +   79  DSE Y   80  ""   81  DSE M   82  GTO 12   83  RTN   84  LBL 01   85  XEQ 10   86  RCL O   87  X#Y?   88  GTO 04   89  RCL 00   90  STO M   91  R^   92  DSE N   93  GTO 01 94  X<>Y   95  ENTER^   96  X^2   97  STO N   98  ST* Y   99   E5 100  / 101  + 102  STO P 103  LBL 02 104  XEQ 10 105  RCL O 106  X#Y? 107  GTO 04 108  RCL 00            109  STO M 110  RCL P 111  1 112  - 113  STO P 114  DSE N 115  GTO 02 116  X<>Y 117  STO N 118  X^2 119  LASTX 120  ST* Y 121   E5 122  / 123  + 124  STO P 125  LBL 03 126  XEQ 10 127  RCL O 128  X#Y? 129  GTO 04 130  RCL 00 131  STO M 132  RCL P 133  1 134  - 135  STO P 136  DSE N 137  GTO 03 138  RCL 00            139  ST+ Y 140  STO N 141  X^2 142  - 143  STO P 144  INT 145  X>0? 146  GTO 03 147  RCL O 148  "YES" 149  GTO 05 150  LBL 04 151  "NO" 152  LBL 05 153  AVIEW 154  END

( 249 bytes / SIZE 1+n^3 )

 STACK INPUTS OUTPUTS X n Magic Cste*

* If the HP-41 displays YES at the end

Example:   After storing the following numbers into R01 thru R27

R01   R04   R07       01   23   18
R02   R05   R08  =   17   03   22
R03   R06   R09       24   16   02

R10   R13   R16       15   07   20
R11   R14   R17  =   19   14   09
R12   R15   R18       08   21   13

R19   R22   R25      26   12   04
R20   R23   R26  =  06   25   11
R21   R24   R27      10   05   27

3  XEQ "MGCB?"  >>>>   "YES"                     ---Execution time = 35s---

and  X = magic constant = 42

Note:

-This version cannot work if n > 6 - not enough registers !
-The following variant overcomes this limitation by calling a subroutine that calculates the required elements ai,j,k.

Data Registers:       R00 = n      •  R08 = subroutine name                    ( Register R08 is to be initialized before executing "MGCB?" )

R01 = Magic Constant  ,   R02 thru R07:  temp
Flags: /
Subroutine:   A program that takes a positive integer m in X-register & in R03 and returns the m-th element  ai,j,k  of the cube.

-Lines 31-46-61 are three-byte  GTO 05

 01  LBL "MGCB?"   02  STO 00   03  3   04  Y^X   05  STO 06   06  RCL 00   07  X^2   08  LASTX   09  +   10  1   11  +   12  STO 04   13  +   14  STO 03   15  XEQ 00   16  STO 01   17  RCL 06   18  RCL 00   19  X^2   20  LASTX   21  1   22  -   23  ST- Z   24  +   25  STO 04   26  +   27  STO 03   28  XEQ 00   29  RCL 01   30  X#Y? 31  GTO 05   32  RCL 06   33  RCL 00              34  X^2   35  1   36  -   37  ST- Y   38  RCL 00   39  -   40  STO 04   41  +   42  STO 03   43  XEQ 00   44  RCL 01   45  X#Y?   46  GTO 05   47  RCL 06   48  RCL 00   49  X^2   50  LASTX   51  -   52  ST- Y   53  1   54  +   55  STO 04   56  +   57  STO 03   58  XEQ 00   59  RCL 01   60  X#Y? 61  GTO 05   62  RCL 00              63  ENTER^   64  X^2   65  STO 06   66  *   67  1   68  STO 04   69  +   70  STO 03   71  GTO 02   72  LBL 00   73  RCL 00   74  STO 02   75  CLX   76  STO 05   77  LBL 01   78  RCL 03   79  RCL 04   80  -   81  STO 03   82  XEQ IND 08   83  ST+ 05   84  DSE 02   85  GTO 01   86  RCL 05   87  RTN   88  LBL 02   89  XEQ 00   90  DSE 06 91  GTO 02   92  RCL 00              93  ENTER   94  X^2   95  STO 06   96  ST* Y   97  STO 04   98  +   99  STO 03 100  STO 07 101  LBL 03 102  XEQ 00 103  RCL 01 104  X#Y? 105  GTO 05 106  DSE 07 107  RCL 07 108  STO 03 109  DSE 06 110  GTO 03 111  RCL 00 112  STO 06 113  X^2 114  LASTX 115  ST* Y 116  STO 04 117  + 118  STO 03 119  STO 07 120  LBL 04 121  XEQ 00 122  RCL 01 123  X#Y? 124  GTO 05 125  RCL 03 126  DSE 07 127  RCL 07            128  STO 03 129  DSE 06 130  GTO 04 131  RCL 00 132  ST+ Y 133  STO 06 134  X^2 135  - 136  STO 07 137  STO 03 138  DSE Y 139  GTO 04 140  RCL 01 141  "YES" 142  GTO 06 143  LBL 05 144  "NO" 145  LBL 06 146  AVIEW 147  END

( 206 bytes / SIZE 009 )

 STACK INPUTS OUTPUTS X n Magic Cste*

* If the HP-41 displays YES at the end

Example:         You want to check that "MAGIC" really creates a magic cube for n = 3

Add   RTN  after line 133 and add  LBL "T"  after line 09  in "MAGIC"
"T"  ASTO 08
SF 03

3  XEQ "MGCB?"    >>>>   "YES"                     ---Execution time = 3m18s---

and  X = magic constant = 42

Notes:

-Thus you can check if a formula does create an Andrews magic cube.
-This formula is a function that computes the m-th element of a hypermatrix:  ai,j,k = f(i,j,k)
-You can use:

i - 1 = ( m - 1 ) mod n
j - 1 = int [ ( q - 1 ) / n ]              where    q = ( m -1 ) mod n2
k - 1 = int [ ( m - 1 ) / n2 ]

-Use a good emulator like V41 in turbo mode for large n-values...
-Even then, it can take several minutes !

5°)  4-Dimensional Magic Cubes

"4DMGC" displays the elements of 4-D magic (hyper-) cubes of odd orders  n > 1

Formula:          cf reference [5]

ai,j,k,q = n3 [ ( i - j + k - q + (n-1)/2 )  mod n ]
+ n2 [ ( i - j + k + q - (n+3)/2 )  mod n ]
+ n  [ ( i - j - k - q + (n+1)/2 )  mod n ]
+   [ ( i + j + k + q - (n-1)/2 )  mod n ] + 1

-The magic constant =  n ( n4+1 )/2

Data Registers:       R00 = n        R01 thru R06:  temp
Flags: /
Subroutines:  /

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

( 114 bytes / SIZE 007 )

 STACK INPUTS OUTPUTS X n /

Where n is an odd integer > 2

Example:         3   XEQ "4DMGC"   >>>>     36   23   64   ...........................   18   59   46

The whole hypercube is:

36   23   64        20   70   33        67   30   26
65   34   24        31   21   71        27   68   28                   1st layer = cube n°1
22   66   35        72   32   19        29   25   69

74   43   06        40   03   80        09   77   37
04   75   44        81   41   01        38   07   78                   2nd layer = cube n°2
45   05   73        02   79   42        76   39   08

13   57   53        63   50   10        47   16   60
54   14   55        11   61   51        58   48   17                   3rd layer = cube n°3
56   52   15        49   12   62        18   59   46

-Here the magic constant is 123 and the central element is 41.

-There are 8 great diagonals:

36 + 41 + 46 = 123           67 + 41 + 15 = 123
22 + 41 + 60 = 123           29 + 41 + 53 = 123
35 + 41 + 47 = 123           26 + 41 + 56 = 123
64 + 41 + 18 = 123           69 + 41 + 13 = 123

Note:

-Other formulas are given in reference [5] to create 4D-magic hypercubes
of order n = 4 m & of order n = 4 m + 2.

References:

[1]  Pierre Tougne - "Pour la Science" - pages 121 to 127 - Issue#46 - Aout 1981  ( in French )
[2]  http://mathworld.wolfram.com/MagicSquare.html
[3]  http://mathworld.wolfram.com/MagicCube.html
[4]  Marian Trenkler - "An Algorithm for making Magic Cubes"
[5]  Marian Trenkler - "An Algorithm for Magic Tesseracts"
[6]  W. S. Andrews - "Magic Squares and Cubes"
[7]  Harm Derksen, Christian Eggermont, Arno van den Essen - "Multimagic Squares"
[8]  W. H. Benson & O. Jacoby - "Magic Cubes, New Recreations" - Dover - ISBN 0-486-24140-8
[9]  http://www.multimagie.com

>>>  "Pour la Science" is the French edition of "Scientific American"

-References [4] [5] [6] [7] may be dowloaded freely !