Hadamard-Matrices

[Annette.Warlich at t-online.de]

Hi -

 the method is not completely bounded to small n.

 With partitioniting I could find the following matrices:
 r0: no partitioning
 r1: partitioned in 2^1 partitions
 r2: partitioned in 2^2 partitions
 r3: partitioned in 2^3 partitions

n=4
macroexec r0  //success

n=8
macroexec r0  //success

n=12
macroexec r0  //success

//----------- R1 -----------------------

n=16
macroexec r1 //success

n=20
macroexec r1  //success

n=24
macroexec r1 //success

n=28
macroexec r1  // failed

//----------- R2 -----------------------
n=32
macroexec r2  //success

n=36
macroexec r2  // failed

n=40
macroexec r2  //success

n=44
macroexec r2  // failed

n=48
macroexec r2  //success

n=52
macroexec r2  // failed

n=56
macroexec r2  // failed

n=60
macroexec r2  // failed


//------------------ R3 -----------------
n=64
macroexec r3  //success

n=68
macroexec r3  // failed

n=72
macroexec r3  // failed

n=76
macroexec r3  // failed

n=80
macroexec r3  //success

(This pattern looks familiar)


----------------------------------------------------

The procedures are very simple besides the "canned" -varimax-rotation
of columns.



The most simple  routine is R0


> st = "-varimax"   // set the maximizing-criterion to "varimax-minimizing"
> 
> 
> macrodef r0           // usable for n=4,8,12
> A = sqrt(n)*einh(n)   // multiple of unit-matrix
> B = A
> 
> B = rot(B,st)         // rotation performed on a copy of A
> macroend


With one partitioning it is R1:

> macrodef r1          // for n=16,20,24
> a = sqrt(n)*einh(n)
> b = a 
> 
> // preconditioning the two diagonal blockmatrices 
> r = n/2                       // do a rotation first on the upper left block diagonal
> ba = seq(1,r)                 // create an appropriate index 1..n/2 to partition the work-matrix
> b = rot(b,st,    ba,    ba)   // rotate only on indicated colums using only indicated rows as criterion
> b = rot(b,st,1*r+ba,1*r+ba)   // rotate only on indicated colums using only indicated rows as criterion
> 
> b = rot(b,st)        // now rotate it using all columns
> macroend


This is simply extended to higher n: R2

> macrodef r2          // for n=32,40,48
> a = sqrt(n)*einh(n)
> b = a 
> 
> // preconditioning the four diagonal blockmatrices 
> r = n/4
> ba = seq(1,r)
> b = rot(b,st,    ba,    ba)
> b = rot(b,st,1*r+ba,1*r+ba)
> b = rot(b,st,2*r+ba,2*r+ba)
> b = rot(b,st,3*r+ba,3*r+ba)
> 
> // preconditioning the two diagonal blockmatrices 
> r = r*2
> ba = seq(1,r)
> b = rot(b,st,    ba,    ba)
> b = rot(b,st,1*r+ba,1*r+ba)
> 
> // using the preconditioned complete matrix
> b = rot(b,st)
> macroend

Analoguously this works for R3 with N=64, N=80

But increasing n requires exponential cpu-time, since the
rotation-process is not optimized for this special type
of matrices.

Gottfried Helms