Seuraa 
Viestejä21
Liittynyt11.5.2016

https://fi.wikipedia.org/wiki/Kunta_%28matematiikka%29

Esimerkiksi kompleksiluvut täyttävät kunnan ehdot. Jos 2D-algebra täyttää kunnan ehdot, nikki Cargon on turha vääntää omia lisäkuntamääritelmiä. Sama koskee nikki JAM:ia. Jos nikki Cagolla tai nikki JAM:illa on jotain lisättävää tähän päivän selvään määrittelyyn, kannattaa kertoa, millaisia kuntalaajennuksia nykyinen kunnan määritelmä tarvitsee?

Jos selvää älämölöä ei kuulu,esittelen sitten 2D-algebran, joka täyttää kaikki kunnan ehdot.

Kommentit (10)

JPI
Seuraa 
Viestejä25914
Liittynyt5.12.2012

Eläskiperse kirjoitti:
https://fi.wikipedia.org/wiki/Kunta_%28matematiikka%29

Esimerkiksi kompleksiluvut täyttävät kunnan ehdot. Jos 2D-algebra täyttää kunnan ehdot, nikki Cargon on turha vääntää omia lisäkuntamääritelmiä. Sama koskee nikki JAM:ia. Jos nikki Cagolla tai nikki JAM:illa on jotain lisättävää tähän päivän selvään määrittelyyn, kannattaa kertoa, millaisia kuntalaajennuksia nykyinen kunnan määritelmä tarvitsee?

Jos selvää älämölöä ei kuulu,esittelen sitten 2D-algebran, joka täyttää kaikki kunnan ehdot.

No paas tuleen!

3³+4³+5³=6³

Eusa
Seuraa 
Viestejä15149
Liittynyt16.2.2011

Kun kompleksisten lukujen sekä reaali- ja imaginääriosat ovat rationaalisia, saadaan mielenkiintoinen kunta:
https://en.m.wikipedia.org/wiki/Gaussian_rational

Liittyy mm. syklotomisiin yksiköihin ja kuntalaajennusrajoituksiin. Ei muuta kun viidennen asteen yhtälölle sarjamuotoista ratkaisukaavaa vääntämään...

Hienorakennevakio suoraan vapausasteista: 1 / (1^0+2^1+3^2+5^3+1^0/2^1*3^2/5^3) = 1 / 137,036

Eläskiperse
Seuraa 
Viestejä21
Liittynyt11.5.2016

Vattu sentään. Koodi on mukamas liian pitkä esitettäväksi yhdellä viestillä, joten yritetään sittem kahdella viestillä. C++ perusteet on hyvä osata, muuten menee ohi. Vittu, jos koodin jakaa real2d- ja complex2d-olioiksi, foorumin käyttöliittymä herjaa liian pitkästä tekstistä?
Jokainen tietää, että tämän foorumin käyttöliittymä on syvältä perseestä. Onkahan tuo merkkien määrä yhdessä viestissä jotain 2^10 = 1024 luokkaa. Jukka Ruukki on vastuussa foorumin softasta, joten haista pitkä paska, ja ole tyytyväinen nykyiseen käyttöliittymään.

Eläskiperse
Seuraa 
Viestejä21
Liittynyt11.5.2016

Lähetetään koodi sitten muutaman funktion paloina.

#include <stdio.h>

class real2d
{
   public:

   double f[2];

   real2d(int);
   real2d(int, int);

   real2d(void);
   real2d(double);
   real2d(double *fe);
   real2d(double, double);

   friend void print(real2d);
   friend double abs(real2d);
   friend double abs(double);
   friend double sgn(real2d);
   friend real2d sqrt(real2d);

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

   friend real2d operator*(real2d, real2d);
   friend real2d operator*(double, real2d);
   friend real2d operator*(real2d, double);

   friend real2d operator/(real2d, real2d);
   friend real2d operator/(double, real2d);
   friend real2d operator/(real2d, double);

   /* mgn = luvun suuruus */
   friend double mgn(real2d);
   friend real2d ln(real2d);
   friend real2d exp(real2d);
   friend real2d sin(real2d);
   friend real2d cos(real2d);
   friend real2d arcsin(real2d);
   friend real2d arccos(real2d);
   friend real2d pow(real2d, int);
   friend real2d pow(real2d, double);
   friend real2d pow(real2d, real2d);
   friend void mem0x0set(void*, int);
};

void mem0x0set(void *ptr, int n)
{
   char *c=(char*)ptr;
   for (--n; n>=0; n--)
   c[n] = (char) 0x00;
}

real2d::real2d(void)
{
   mem0x0set(this, sizeof(real2d));
}

real2d::real2d(int a)
{
   f[0]=a; f[1]=0;
}

real2d::real2d(double a)
{
   f[0]=a; f[1]=0;
}

real2d::real2d(double *fe)
{
   f[0]=fe[0]; f[1]=fe[1];
}

real2d::real2d(int a, int b)
{
   f[0]=a; f[1]=b;
}

real2d::real2d(double a, double b)
{
   f[0]=a; f[1]=b;
}

double abs(double x)
{
   return x<0.0? -x: x;
}

double abs(real2d a)
{
   return abs(a.f[0]-a.f[1]);
}

double sgn(real2d a)
{
   double x=a.f[0];
   double y=a.f[1];

   if (x>=0.0)
   {
      return abs(y)<=x? 1: -1;
   }
   else
   {
      return -1;
   }
}

double mgn(real2d a)
{
   return abs(a.f[0])+abs(a.f[1]);
}

real2d sqrt(real2d c)
{
   real2d x=c;
   for (int i=0; i<64; i++)
   x = x - (x*x-c)/(2.0*x);
   return (x);
}

real2d operator-(real2d a)
{
   for (int i=0; i<2; i++)
   a.f[i]=-a.f[i];
   return a;
}

real2d operator+(real2d a, real2d b)
{
   for (int i=0; i<2; i++)
   a.f[i]+=b.f[i];
   return a;
}

real2d operator-(real2d a, real2d b)
{
   for (int i=0; i<2; i++)
   a.f[i]-=b.f[i];
   return a;
}

Eläskiperse
Seuraa 
Viestejä21
Liittynyt11.5.2016

real2d operator*(real2d a, real2d b)
{
   double x[4];
   double y[4];
   double t[4];

   mem0x0set(x, sizeof(double)*4);
   mem0x0set(y, sizeof(double)*4);
   mem0x0set(t, sizeof(double)*4);

   for (int i=0; i<2; i++)
   {
      x[i*2]=a.f[i];
      y[i*2]=b.f[i];
   }

   for (int i=0; i<4; i++)
   for (int j=0; j<4; j++)
   t[i^j]+=x[i]*y[j];

   for (int i=0; i<2; i++)
   t[i]=t[i*2]-t[i*2+1];
   return real2d( t );
}

real2d operator*(double k, real2d b)
{
   real2d a(k);
   return a*b;
}

real2d operator*(real2d a, double k)
{
   real2d b(k);
   return a*b;
}

Eläskiperse
Seuraa 
Viestejä21
Liittynyt11.5.2016

real2d operator/(double k, real2d b)
{
real2d a(k);
return a/b;
}

real2d operator/(real2d a, double k)
{
real2d b(k);
return a/b;
}

real2d operator/(real2d u, real2d v)
{
double x[4];
double y[4];

mem0x0set(x, sizeof(double)*4);
mem0x0set(y, sizeof(double)*4);

for (int i=0; i<2; i++)
{
x[i*2]=u.f[i];
y[i*2]=v.f[i];
}

double X[4];
double K[4*4+4];

for (int n=0, p=0; n<4; n++)
{
for (int i=0; i<4; i++)
for (int j=0; j<4; j++)
{
if (n == (i^j))
{
K[p]=y[j]; ++p;
}
}
K[p]=x[n]; ++p;
}

// gsolve ratkaisee lineaarisen yhtälöryhmän
// Gaussin eliminointimenetelmällä...
int gsolve(double*, double*, int);
gsolve(X, (double*)K, 0x4);
for (int i=0; i<2; i++)
X[i]=X[i*2]-X[i*2+1];
return real2d( X );
}

Eläskiperse
Seuraa 
Viestejä21
Liittynyt11.5.2016

////////////////////////////////////////////////
// qsolve palautusarvo:                       //
//    1 <=> yhtälöryhmälle oli ratkaisu       //
//    0 <=> yhtälöryhmälle ei ollut ratkaisua //
////////////////////////////////////////////////
int gsolve(double *X, double *f, int n)
{
   double k, J;
   double *max, *mux;
   int i, j, x, M=(int)n+1;
   void swapRows(double*, double*, int);

   for (i=0; i<n-1; i++)
   {
      max=f+i+i*M;
      for (j=i+0x01; j < n; j++)
      if (abs(*(mux=f+i+j*M))>abs(*max)) max=mux;

      if (max!=(mux=f+i+i*M))
      swapRows(max, mux, M-i);

      if (abs(J=f[i+i*M])<(double)1e-15)
      return 0; /* eipä ole ratkaisuva */

      for (j=i+1; j<n; j++)
      {
         if (f[i+j*M])
         {
            k=-f[i+j*M]/J;
            for (x=i+1; x<M; x++)
            f[x+j*M]=f[x+j*M]+k*f[x+i*M];
         }
      }
   }

   for (i=n-1; i>=0; i--)
   {
      k=(double)f[n+i*M];
      for (j=n-1; j > i; j--)
      k=k-(double)(X[j]*f[j+i*M]);

      if (abs(J=f[i+i*M])<(double)1e-15)
      return 0; /* eipä ole ratkaisua */
      else X[i]=k/J; /* onpa ratkaisu */
   }

   return 1;
}

void swapRows(double *a, double *b, int n)
{
   for (int i=0; i<n; i++)
   {
      double tmp=a[i];
      a[i] = b[i];
      b[i]=tmp;
   }
}

void print(real2d a)
{
   char sg0=a.f[0]<0.0? '-': '+';
   char sg1=a.f[1]<0.0? '-': '+';
   printf("(%c%0.10f, %c%0.10f)\n",
   sg0,abs(a.f[0]),sg1,abs(a.f[1]));
}

Eläskiperse
Seuraa 
Viestejä21
Liittynyt11.5.2016

real2d ja complex2d olioiden funktiot ovat toteutettu sarjoilla. Oheiset ln ja exp funktioiden tarkoitus on kaventaa kuilua, ennen kuin esitän samat funktiot real2d ja complex2d olioilla.

Nikki Cargolle ja nikki JAM:lle tiedoksi, että sarjoilla lasketut funktiot ovat paljon tarkempia kuin <math.h> standardifunktiot. Yksi tärkeä seikka omaksua on se, että real2d ja complex2d funktioilla esim. ln / exp funktiot ovat samassa sapluunassa.

=======================================================================

#include <stdio.h>
typedef long double lreal;
#define lr(cx) (lreal)(cx)

lreal gabs(lreal x)
{
   return x<lr(0)? -x: x;
}

lreal ln(lreal c)
{
   lreal fx, dx;
   lreal x=c/99;
   
   for (int i=2; i<256; i++)
   {
      lreal r1, r2=lr(1234e77);
      for (int n=0; n<256; n++)
      {
         fx=lr(1)+x;
         dx=lr(1.0);
         lreal xx=x;
         lreal ex=1;
         for (int k=2; k<=i; k++)
         {
            ex *= k;
            dx += k*xx/ex;
            xx *= x;
            fx += xx/ex;
         }
         x=x-(fx-c)/dx;
         r1=(lreal)r2; r2=lr(x);
         if (gabs(r1-r2)<lr(1e-20)) break;
      }
   }
   return x;
}

lreal exp(lreal x)
{
   lreal t=lr(1);
   lreal sum=lr(1.0);
   lreal xx=x; sum=sum+x;
   
   for (int i=2; i<64; i++)
   {
      xx = xx*x;
      sum=sum+xx/(t*=i);
   }
   return sum;
}

#pragma argsused
int main(int mux, char* none[])
{
   lreal x=lr(2016);
   
   lreal y=ln(1+x);
   
   printf("%25.20f %25.20f\n", (double)x, (double)y);
   
   printf("%25.20f\n", (double)(exp(y)-1));
}

Suosituimmat

Uusimmat

Uusimmat

Suosituimmat