Magic Cube

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#define PYRAMIX

#define SQ2 1.41421356237f

#define SQ3 1.73205080757f

#define PI  3.14159265358f

#define NUM_QUATS  100

#ifdef PYRAMIX 

#define NUM_AXIS    4

#define BASIC_ANGLE 3

float axis[NUM_AXIS][3] ={ {         0,       1,       0 } ,

                           { SQ2*SQ3/3, -1.0f/3,  -SQ2/3 } ,

                           {-SQ2*SQ3/3, -1.0f/3,  -SQ2/3 } ,

                           {         0, -1.0f/3, 2*SQ2/3 } };

#endif

#ifdef CUBE

#define NUM_AXIS 3

#define BASIC_ANGLE 4

float axis[NUM_AXIS][3] = { { 1,0,0 }, {0,1,0}, {0,0,1} };

#endif

float* quats;

float* table;

int inserted=0;

///////////////////////////////////////////////////////////////////

// q1*q2

void multiply_quats( float* q1, float* q2, float* output)

  {

  output[0] = q2[3]*q1[0] - q2[2]*q1[1] + q2[1]*q1[2] + q2[0]*q1[3];

  output[1] = q2[3]*q1[1] + q2[2]*q1[0] + q2[1]*q1[3] - q2[0]*q1[2];

  output[2] = q2[3]*q1[2] + q2[2]*q1[3] - q2[1]*q1[0] + q2[0]*q1[1];

  output[3] = q2[3]*q1[3] - q2[2]*q1[2] - q2[1]*q1[1] - q2[0]*q1[0];

  }

///////////////////////////////////////////////////////////////////

// sin(A/2)*x, sin(A/2)*y, sin(A/2)*z, cos(A/2)

void create_quat(float* axis, float angle, float* output)

  {

  float cosAngle = cos(angle/2);

  float sinAngle = sin(angle/2);

  output[0] = sinAngle*axis[0];

  output[1] = sinAngle*axis[1];

  output[2] = sinAngle*axis[2];

  output[3] = cosAngle;

  }

///////////////////////////////////////////////////////////////////

// double cover, so q == -q

int is_the_same(float* q1, float* q2)

  {

  const float MAX = 0.01f;

  float d0 = q1[0]-q2[0];

  float d1 = q1[1]-q2[1];

  float d2 = q1[2]-q2[2];

  float d3 = q1[3]-q2[3];

  if( d0<MAX && d0>-MAX &&

      d1<MAX && d1>-MAX &&

      d2<MAX && d2>-MAX &&

      d3<MAX && d3>-MAX  ) return 1;

  d0 = q1[0]+q2[0];

  d1 = q1[1]+q2[1];

  d2 = q1[2]+q2[2];

  d3 = q1[3]+q2[3];

  if( d0<MAX && d0>-MAX &&

      d1<MAX && d1>-MAX &&

      d2<MAX && d2>-MAX &&

      d3<MAX && d3>-MAX  ) return 1;

  return 0;

  }

///////////////////////////////////////////////////////////////////

void insert(float* quat, float* to)

  {

  for(int i=0; i<inserted; i++)

    {

    if( is_the_same(quat,to+4*i)==1 ) return;

    }

  to[4*inserted+0] = quat[0];

  to[4*inserted+1] = quat[1];

  to[4*inserted+2] = quat[2];

  to[4*inserted+3] = quat[3];

  inserted++;

  }

///////////////////////////////////////////////////////////////////

int main(int argc, char** argv)

  {

  float tmp[4];

  int num = 1+NUM_AXIS*(BASIC_ANGLE-1);

  quats = (float*) malloc(4*sizeof(float)*num      );

  table = (float*) malloc(4*sizeof(float)*NUM_QUATS);

  tmp[0] = 0.0f; tmp[1] = 0.0f; tmp[2] = 0.0f; tmp[3] = 1.0f;

  insert(tmp,quats);

  for(int angle=1; angle<BASIC_ANGLE; angle++)

    for( int ax=0; ax<NUM_AXIS; ax++)

      {

      create_quat(axis[ax], 2*PI*angle/BASIC_ANGLE, tmp);

      insert(tmp,quats); 

      }

  inserted=0;

  for(int i=0; i<num; i++)

    for(int j=0; j<num; j++)

      {

      multiply_quats( quats+4*i, quats+4*j, tmp);

      insert(tmp,table);

      }

  printf("inserted: %d\n", inserted);

  for(int i=0; i<inserted; i++)

    {

    printf( "%d %7.4f %7.4f %7.4f %7.4f\n", i, table[4*i], table[4*i+1], table[4*i+2], table[4*i+3] );

    }

return 0;

}