TwistyPuzzleLib

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#define SQUARE

#define SQ2 1.41421356237f

#define SQ3 1.73205080757f

#define SQ5 2.23606797750f

#define PI  3.14159265358f

#define NUM_QUATS  200

#ifdef PYRA 

int basic[] = { 3,3,3,3 };

float axis[][3] = { { SQ2*SQ3/3,   SQ3/3,          0 } ,

                    {-SQ2*SQ3/3,   SQ3/3,          0 } ,

                    {         0,  -SQ3/3, -SQ2*SQ3/3 } ,

                    {         0,  -SQ3/3,  SQ2*SQ3/3 } };

#endif

#ifdef CUBE

int basic[] = { 4,4,4 };

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

                    { 0,1,0 } , 

                    { 0,0,1 } };

#endif

#ifdef DINO

int basic[] = { 3,3,3,3 };

float axis[][3] = { {+SQ3/3,+SQ3/3,+SQ3/3} , 

                    {+SQ3/3,+SQ3/3,-SQ3/3} , 

                    {+SQ3/3,-SQ3/3,+SQ3/3} , 

                    {+SQ3/3,-SQ3/3,-SQ3/3} };

#endif

#ifdef DIAM

int basic[] = { 3,3,3,3 };

float axis[][3] = { {+SQ3*SQ2/3,+SQ3/3,         0} ,

                    {-SQ3*SQ2/3,+SQ3/3,         0} ,

                    {         0,+SQ3/3,+SQ3*SQ2/3} ,

                    {         0,+SQ3/3,-SQ3*SQ2/3} };

#endif

#ifdef HELI

int basic[] = { 2,2,2,2,2,2 };

float axis[][3] = { {     0, +SQ2/2, -SQ2/2} ,

                    {     0, -SQ2/2, -SQ2/2} ,

                    {+SQ2/2,      0, -SQ2/2} ,

                    {-SQ2/2,      0, -SQ2/2} ,

                    {+SQ2/2, -SQ2/2,      0} ,

                    {-SQ2/2, -SQ2/2,      0} };

#endif

#ifdef ULTI

int basic[] = { 3,3,3,3 };

float axis[][3] = { { 5*SQ5/16 + 11.0f/16,              0.0f   ,    SQ5/8  + 1.0f/4 } ,

                    {   SQ5/8  +  1.0f/4 ,  5*SQ5/16 + 11.0f/16,             0.0f   } ,

                    {-3*SQ5/16 -  7.0f/16,  3*SQ5/16 +  7.0f/16,  3*SQ5/16 + 7.0f/16} ,

                    {             0.0f   ,    SQ5/4  +  1.0f/2 , -5*SQ5/8  -11.0f/8 } };

#endif

#ifdef SQUARE

#define COS15 (0.25f*SQ2*(SQ3+1))

#define SIN15 (0.25f*SQ2*(SQ3-1))

int basic[] = { 12, 2 };

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

                    { COS15, 0, SIN15 } };

#endif

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;

  }

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

int getIndexInTable(float* quat, float* table)

  {

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

    {

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

    }

  return -1;

  }

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

void insert(float* quat, float* table)

  {

  if( getIndexInTable(quat,table)<0 )

    {

    if( inserted<NUM_QUATS )

      {

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

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

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

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

      inserted++;

      }

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

    }

  }

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

void normalize(int index)

  {

  float* a = axis[index];

  float len = (float)(sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]));

  a[0] /= len;  

  a[1] /= len;  

  a[2] /= len;  

  }

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

int main(int argc, char** argv)

  {

  float tmp[4];

  float table[4*NUM_QUATS];

  int num,NUM_AXIS = sizeof(axis) / sizeof(axis[0]);

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

  insert(tmp,table);

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

    {

    normalize(ax);

    }

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

    for(int angle=1; angle<basic[ax]; angle++)

      {

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

      insert(tmp,table); 

      }

  do

    {

    num = inserted;

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

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

        {

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

        insert(tmp,table);

        }

    }

  while( num < inserted );

  printf("\n");

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

    {

    printf( "%2d %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] );

    }

  printf("\n");

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

    {

    printf("{");

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

      {

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

      num = getIndexInTable(tmp,table);

      printf("%3d," , num);

      }

    printf("},\n");

    }

return 0;

}