Seuraa 
Viestejä954

#pragma hdrstop

#include
#include
#include
#include
#include

class recomplex
{
public:

#define DIM 4
double e[DIM];

recomplex(void);
~recomplex( void );
recomplex(char*, ...);

recomplex(int);
recomplex(int, int);
recomplex(int, int, int, int);

friend void print(recomplex);
friend double abs(recomplex);

friend recomplex operator-(recomplex);
friend recomplex operator+(recomplex, recomplex);
friend recomplex operator-(recomplex, recomplex);

friend recomplex operator*(recomplex, recomplex);
friend recomplex operator/(recomplex, recomplex);

friend recomplex operator*(recomplex, double);
friend recomplex operator/(recomplex, double);

friend recomplex operator*(double, recomplex);
friend recomplex operator/(double, recomplex);

friend recomplex pow(recomplex, int);
};

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Kommentit (10)

Veli Ponteva
Seuraa 
Viestejä954

recomplex::recomplex(void)
{
   memset(this, 0, sizeof(recomplex));
}

recomplex::~recomplex(void)
{
}

/*
Muodostin recomplex(char*, ...)

Esim.

recomplex x("2d", 2, 3), x saa arvon 2.0000 + 3.0000i
recomplex y("2f", 1.2345, 6.7891), y saa arvon 1.2345 + 6.7891i

- formaatissa annetaan ensin lukujen m  r , esim 2.
- d tarkoittaa, että luvut annetaan kokonaislukuina.
- f tarkoittaa, että luvut annetaan liukulukumuodossa.
*/
recomplex::recomplex(char *f, ...)
{
   int i, j, kpl=atoi(f), step;
   memset(this, 0x00, sizeof(recomplex));
   unsigned long P=(unsigned long)&f+sizeof(char*);

   for (j=0; f[j]; j++)
   {
      if (f[j]=='d') step=4;
      if (f[j]=='f') step=8;
   }

   step=step==4? sizeof(int): sizeof(double);
   for (i=j=0; i<kpl; i++, P+=step)
   e[i] = step == sizeof(int)?
   *(int*)P: *(double*)P;
}

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Veli Ponteva
Seuraa 
Viestejä954

/*
Jossain 20-alkion kohdalla, kun kantavektorin tunnus on suurempi
kuin 'z', kantavektorin tunnus saattaa olla jokin kirjaimesta
poikkeava merkki. Itse laskuoperaatioissa kantavektoreiden
symbolisiin tunnuksiin ei oteta kantaa.
*/
void print(recomplex a)
{
   printf("%0.9f ", a.e[0]);
   for (int n=1; n<DIM; n++)
   printf("%c %0.9f%c ", a.e[n]<0?
   '-': '+', fabs(a.e[n]), 'h'+n);
   printf("\n");
}

recomplex::recomplex(int a)
{
   memset(this, 0, sizeof(recomplex));
   e[0]=a;
}

recomplex::recomplex(int a, int b)
{
   memset(this, 0, sizeof(recomplex));
   e[0]=a; e[1]=b;
}

recomplex::recomplex(int a, int b, int c, int d)
{
   memset(this, 0, sizeof(recomplex));
   e[0]=a; e[1]=b; e[2]=c; e[3]=d;
}

recomplex operator-(recomplex a)
{
   for (int n=0; n<DIM; n++)
   a.e[n]=-a.e[n];
   return a;
}

recomplex operator+(recomplex a, recomplex b)
{
   for (int n=0; n<DIM; n++)
   a.e[n]+=b.e[n];
   return a;
}

recomplex operator-(recomplex a, recomplex b)
{
   for (int n=0; n<DIM; n++)
   a.e[n]-=b.e[n];
   return a;
}

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Sisältö jatkuu mainoksen alla
Sisältö jatkuu mainoksen alla
Veli Ponteva
Seuraa 
Viestejä954

recomplex operator*(recomplex a, recomplex b)
{
   int *KantaolioidenTulot(void);
   int *R=KantaolioidenTulot();
   int i, j, n=(int)DIM*0x02;

   double x[DIM*2];
   double y[DIM*2];
   double t[DIM*2];

   for (i=j=0x00; i<DIM; i++, j+=0x02)
   x[j+1]=y[j+1]=t[j]=t[j+1]=0.0,
   x[j]=a.e[i], y[j]=b.e[i];

   for (i=0; i<n; i++)
   for (j=0; j<n; j++)
   t[R[i*n+j]]+=x[i]*y[j];

   for (i=j=0x00; i<DIM; i++, j+=0x02)
   t[i]=(double)(t[j] - t[j+1]);
   return *(recomplex*) t;
}

void GeneroiKantaolioidenTulot(int *R, int n)
{
   int I=0, J=n-1, i;
   int X=n, Y=J+n, j;
   int k=DIM*2;

   for (i=I; i<=J; i++)
   for (j=I; j<=J; j++)
   {
      R[i*k+X+j]=R[i*k+j]+X;
      R[(X+j)*k+i]=R[i*k+j]+X;
      R[(Y-i)*k+Y-j]=J-R[i*k+j];
   }

   if (n+n < DIM*2)
   {
      GeneroiKantaolioidenTulot(R, n+n);
   }
}

int* KantaolioidenTulot(void)
{
   static int R[DIM*DIM*4]={-1};
   if (R[0] == -1)
   {
      int EnsinOliNolla=0x00;
      R[0]=(double)EnsinOliNolla;
      GeneroiKantaolioidenTulot(R, 1);
   }
   return R;
}

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Veli Ponteva
Seuraa 
Viestejä954

recomplex operator/(recomplex x, recomplex y)
{
   recomplex z;

   for (int i, n=DIM; n>=2; n/=2)
   {
      for (z=y, i=n/2; i<n; i++)
      z.e[i]=-z.e[i];
      x=x*z; y=y*z;
   }

   return x/y.e[0];
}

recomplex operator/(recomplex x, double k)
{
   for (int i=0; i<DIM; i++)
   x.e[i]/=(double)k;
   return x;
}

recomplex operator*(double k, recomplex x)
{
   for (int i=0; i<DIM; i++)
   x.e[i]*=(double)k;
   return x;
}

recomplex operator*(recomplex x, double k)
{
   return k*x;
}

recomplex operator/(double k, recomplex x)
{
   recomplex y("1f", k);
   return (recomplex)y/x;
}

double abs(recomplex x)
{
   recomplex z;
   double r, c;
   int i, j=1, n;

   for (n=DIM; n>=2; n/=2, j+=j)
   {
      for (z=x, i=n/2; i<n; i++)
      z.e[i]=-z.e[i];
      x=x*z;
   }

   r=fabs(x.e[0]);
   c=1.0/(double)j;
   return pow(r, c);
}

recomplex pow(recomplex x, int n)
{
   if (n)
   {
      recomplex t=x;
      int i=n<0? -n: n;
      for (--i; i; i--) t=t*x;
      return n>0? t: recomplex(1.0)/t;
   }
   else
   {
      return recomplex(1.0);
   }
}

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Veli Ponteva
Seuraa 
Viestejä954

//////////////////////////////////
// jrnd palautaa satunnaisluvun //
// väliltä [0, max-1]           //
//////////////////////////////////
unsigned long jrnd(unsigned long max)
{
   static unsigned long R16A=time(NULL);
   static unsigned long R16B=2L;
   R16A -= 0x012357bfL;
   R16B += 0xfedca201L;
   R16A += (R16A>>16)^(R16B<<16);
   R16B -= (R16A<<16)^(R16B>>16);
   return (R16A^R16B)%max;
}

///////////////////////////////////
// drand palautaa satunnaisluvun //
// väliltä [-1.0, +1.0]          //
///////////////////////////////////
double drand(void)
{
   double x=jrnd(0xfffffffb);
   unsigned long jak=0xfffffffb;
   return jrnd(0x02)? -x/jak: x/jak;
}

////////////////////////////////////////
// recomplex_rnd palautaa satunnaisen //
// recomplex luvun funktioiden        //
// testaamiseen.                      //
////////////////////////////////////////
recomplex recomplex_rnd(void)
{
   recomplex x;
   for (int i=0; i<DIM; i++)
   x.e[i]=drand();
   return x;
}

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Veli Ponteva
Seuraa 
Viestejä954

void main(void)
{
   recomplex x, y, z, a, b;
   printf("Yhteenlaskun vaihdantalaki\n");
   printf("x + y = y + x\n");
   printf("x=recomplex_rnd()\n"); x=recomplex_rnd();
   printf("y=recomplex_rnd()\n"); y=recomplex_rnd();
   printf("x+y = "); print(x+y);
   printf("y+x = "); print(y+x);
   printf("\n");

   printf("Yhteenlaskun liitantalaki\n");
   printf("x + (y + z) = (x + y) + z\n");
   printf("z=recomplex_rnd()\n"); z=recomplex_rnd();
   printf("x+(y+z) = "); print(x+(y+z));
   printf("(x+y)+z = "); print((x+y)+z);
   printf("\n");

   printf("Yhteenlaskun neutraalialkio\n");
   printf("x + 0 = 0 + x = x\n");
   printf("x+recomplex(0) = "); print(x+recomplex(0));
   printf("recomplex(0)+x = "); print(recomplex(0)+x);
   printf("             x = "); print(x);
   printf("\n");

   printf("Vastaluku\n");
   printf("x + y = y + x = 0\n");
   printf("  y = -x\n"); y=-x;
   printf("x+y = "); print(x+y);
   printf("y+x = "); print(y+x);
   printf("\n");

   printf("Kertolaskun vaihdantalaki\n");
   printf("x*y = y*x\n");
   printf("y=recomplex_rnd()\n"); y=recomplex_rnd();
   printf("x*y = "); print(x*y);
   printf("y*x = "); print(y*x);
   printf("\n");

   printf("Kertolaskun liitantalaki\n");
   printf("x*(y*z) = (x*y)*z\n");
   printf("x*(y*z) = "); print(x*(y*z));
   printf("(x*y)*z = "); print((x*y)*z);
   printf("\n");

   printf("Osittelulaki\n");
   printf("x*(y + z) = x*y + x*z\n");
   printf("x*(y + z) = "); print(x*(y + z));
   printf("x*y + x*z = "); print(x*y + x*z);
   printf("\n");

   printf("Kertolaskun neutraalialkio\n");
   printf("x*1 = 1*x = x\n");
   printf("x=recomplex_rnd()\n"); x=recomplex_rnd();
   printf("x*recomplex(1) = "); print(x*recomplex(1));
   printf("recomplex(1)*x = "); print(recomplex(1)*x);
   printf("             x = "); print(x);
   printf("\n");

   printf("Kaanteisalkio\n");
   printf("b=1/a, jolle a*b = a*1/a = 1\n");
   printf("a=recomplex_rnd()\n"); a=recomplex_rnd();
   printf("b=recomplex(1)/a\n"); b=recomplex(1)/a;
   printf("             a*b = "); print(a*b);
   printf("a*recomplex(1)/a = "); print(a*recomplex(1)/a);
}

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

Veli Ponteva
Seuraa 
Viestejä954

käyttäjä-7929 kirjoitti:
Voisit aloittaa lukemalla Wikipediaa kohdasta "Hypercomplex number"...

Hyperkompleksiluvut eivät kuitenkaan ole kunta.

Selkärankaisten laskupää on yhtä hyvä kuin pikkulasten – jotkin osaavat jopa yhteen- ja vähennyslaskua

käyttäjä-7929
Seuraa 
Viestejä465

Rasvaperse kirjoitti:
käyttäjä-7929 kirjoitti:
Voisit aloittaa lukemalla Wikipediaa kohdasta "Hypercomplex number"...

Hyperkompleksiluvut eivät kuitenkaan ole kunta.

Ajattelin vain, että perehtyisit ensin  siihen mitä asiasta jo tiedetään. Kvaterniot ja oktoniot  ovat tiettyjä  kompleksilukujen yleistyksiä.. Jos olet viisaampi kuin Frobenius, Hurwitz  ja kumppanit niin mikäpäs siinä.

Suosituimmat

Uusimmat

Sisältö jatkuu mainoksen alla

Uusimmat

Suosituimmat