Seuraa 
Viestejä950
Liittynyt11.12.2010

Esipuhe

Eräs minun elämänkäänteisiin suuresti vaikuttanut henkilö totesi: Matematiikka ei oikeastaan enää kovin paljon kiinnosta, koska se on vieraantunut niin voimakkaasti arkipäiväisistä tarpeista.

Tämän voin allekirjoittaa myös omalta osaltani, joskin saan jokapäiväisessä työssäni mallintaa muun muassa robotiikkaan liittyviä liikeratoja, yms. puhtaasti arkipäiväisiä probleemoja.

Kuitenkin, sovelletun matematiikan mahdollisuudet (ja myös lukuteoreettiset kysymykset) ovat toisinaan enemmän mielenkiinnon kohteena, kuin työhöni liittyvät asiat. Silloin on ikään kuin työn touhussa, vaikka algoritmi etsiikin/tutkiikin esimerkiksi kahden yhteyttä suhteessa muihin alkulukuihin.

Kompleksiluvuista saattoi lopulta havaita, että ne yleistyvät käsittämään myös ns. kompleksiavaruudet. Kenties niiden lukuteoreettisesti mielenkiintoisin yhteys on:

|e^(ai+bj+ck+...)|=1

Kompleksiluvut asettuvat tuon takaisinkytkennän osajoukoksi edelleen symmetrialla:

|e^ai|=1

Mutta, reaaliluvut voi myös laajentaa 2^n dimensioon, jolloin puhdas 2^n-reaaliluku on paikka lukuoliossa (x, y, z, ...). Ristiriidat kaikkoavat, kun laskutoimitukset suoritetaan redusoimattomana ottamatta kantaa symbolisiin tulkintoihin positiivisesta, negatiivisesta ja x-tiivisistä suunnista.

Edelleen 2^n-reaaliluvut ovat yhtä epätäydellisiä, kuin reaaliluvutkin. 2^n-reaaliluvut tarvitsevat rinnalleen 2^n-imaginaariluvut, jolloin symmetria täydentyy, kuten kompleksiluvuillakin. Jälleen osajoukko. 2^n-kompleksilukujen osajoukkona on kompleksiluvut ja niihin liittyvät algebran aksioomat.

Mikään estä laajentamasta symmetriaa vaikka 32D:ksi, tai vieläkin etäisemmäksi. Luonto on kuitenkin vastakohtia. Siksi myös lukuteoriassa on vielä joskus pakko löytyä se syy-seuraus, jossa vaa’an toisella puolella on 2 ja toisella puolella loput muut äärettömän monta paritonta alkulukua.

Mene ja tiedä. Mutta se on yksinkertainen. Miksi niin yksinkertainen. Monimutkaisuus on ehkä vain illuusio, joka on verhoutunut (pseudo-)kaaokseen.

Kommentit (15)

Eusa
Seuraa 
Viestejä14392
Liittynyt16.2.2011

Jos et ole minulta aiemmin lukenut, tässä kosmisen nosteen numerologista puolta:

Alkeishiukkanen 5-ulotteisessa fysiikassa muodostuu:

1^0 ... perusyksikkö, jota toistetaan ja johon palaaminen (mittaaminen) tuottaa johdonmukaisen muutoksen, kausaliteetin

2^1 ... kahdentunut dualiteetti kantayksikön lisäksi (kausaliteetista vapaat kvanttitilat)

: 1+2=3, muodostuu hiukkassukupolvien energiajakoperuste

3^2 ... seuraavan alkuluvun vapausasteen yksikkömäärä (1. metrinen ulottuvuus)

: 9 yksikön rypäs voi toistua samalla hierarkialla protonirakenteessa

5^3 ... seuraavan alkuluvun vapausasteen yksikkömäärä (2. metrinen ulottuvuus)

3. metrinen ulottuvuus syntyy perusyksiköiden tilaa vasten "paisumisesta" gravitaatiosta.

Sähkömagnetismi toimii siten 2-ulotteisena dualistisena "optisena" koordinaatistona, joka on pakotettu dualiteetin kautta 3-ulotteiseen metriikkaan aiheuttaen näennäistä kiihtyvyyttä gravitaatiokentässä.

Alkeishiukkasen rakenne sitoo energiaa suhteessa sähkömagneettiseen absorptiotehoon 1+2+9+125 yksikköä + 9/(2*125) murto-osaa = 137 + 9/250. Nuo murto-osat tulevat siitä, että absorptiossa keskeisen 9 yksikön rypäs vaatii tasapainottuakseen jakautumislisän dualiteetin ja 125 yksikön pallokuoren väliin muodostuville kytkennöille (minimitopologia).

Luonnosta löytyy siis hienorakennevakiosta 1/137,036 dualiteetti ja vastapainona muita alkulukuja, aina pidemmälle mitä enemmän sidosrakennetta tarvitaan.

Kannattaa tutustua myös Riemannin zeta-funktioon, jossa kompleksiluvut avaavat kuvion systeeminä.

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

JPI
Seuraa 
Viestejä24834
Liittynyt5.12.2012
Eusa

Jos et ole minulta aiemmin lukenut, tässä kosmisen nosteen numerologista puolta:

Alkeishiukkanen 5-ulotteisessa fysiikassa muodostuu:

1^0 ... perusyksikkö, jota toistetaan ja johon palaaminen (mittaaminen) tuottaa johdonmukaisen muutoksen, kausaliteetin

2^1 ... kahdentunut dualiteetti kantayksikön lisäksi (kausaliteetista vapaat kvanttitilat)

: 1+2=3, muodostuu hiukkassukupolvien energiajakoperuste

3^2 ... seuraavan alkuluvun vapausasteen yksikkömäärä (1. metrinen ulottuvuus)

: 9 yksikön rypäs voi toistua samalla hierarkialla protonirakenteessa

5^3 ... seuraavan alkuluvun vapausasteen yksikkömäärä (2. metrinen ulottuvuus)

3. metrinen ulottuvuus syntyy perusyksiköiden tilaa vasten "paisumisesta" gravitaatiosta.

Sähkömagnetismi toimii siten 2-ulotteisena dualistisena "optisena" koordinaatistona, joka on pakotettu dualiteetin kautta 3-ulotteiseen metriikkaan aiheuttaen näennäistä kiihtyvyyttä gravitaatiokentässä.

Alkeishiukkasen rakenne sitoo energiaa suhteessa sähkömagneettiseen absorptiotehoon 1+2+9+125 yksikköä + 9/(2*125) murto-osaa = 137 + 9/250. Nuo murto-osat tulevat siitä, että absorptiossa keskeisen 9 yksikön rypäs vaatii tasapainottuakseen jakautumislisän dualiteetin ja 125 yksikön pallokuoren väliin muodostuville kytkennöille (minimitopologia).

Luonnosta löytyy siis hienorakennevakiosta 1/137,036 dualiteetti ja vastapainona muita alkulukuja, aina pidemmälle mitä enemmän sidosrakennetta tarvitaan.

Kannattaa tutustua myös Riemannin zeta-funktioon, jossa kompleksiluvut avaavat kuvion systeeminä.

Voi taivas sentään!

3³+4³+5³=6³

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

Kertolaskussa suoritetaan ensin arvojen alustus ja unreduce.

Tämän jälkeen suoritetaan varsinainen kertolasku, jossa xor-operaatio määrää akselin, johon kertolasku-alkio lisätään.

Lopuksi suoritetaan redusointi, ja palautetaan kertolaskun tulos.

 

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

Luokkamäärittely "real" pitää sisällään akseliarvot e[0], e[1], e[2], ..., jossa DIMensio voi olla mikä tahansa 2^n ulottuvuus.

Lisäksi luokkamääritelyssä on perusmuodostimet sekä alkeisoperaatiot.

 

 

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

Ohessa koko real-olio. Viimeisessä main-funktiossa suoritetaan muutamia testejä.

Foorumi bugittaa yhä, ja pienempi kuin -merkin jälkeen ei saa olla merkkiä, muutoin foorumiohjelma katkaisee rivin, ja nostaa seuraavan rivin sen jatkeeksi.

Täytyy muutenkin moittia foorumia, koska esim. tasavälinen fontti on poistettu jonkun johtavan elimen toimesta.

ed: muista poistaa seuraavilla riveillä välimerkit kirjastokutsuista, niin sitten pitäisi kääntyä.

#include < string.h>
#include < stdlib.h>
#include < stdio.h>
#include < math.h>

class real
{
   public:

   #define DIM 4
   double e[DIM];

   real(void);
   ~real(void);

   real(double*);
   real(char*, ...);

   real(int);
   real(int, int);
   real(int, int, int, int);

   real(double);
   real(double, double);
   real(double, double, double, double);

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

   friend real operator-(real);
   friend real operator+(real);

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

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

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

   friend real operator*(real, double);
   friend real operator/(double, real);
};

real::~real(void)
{
}

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

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

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

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

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

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

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

real::real(double *a)
{
   int n=sizeof(double);
   memcpy(e, a, n*DIM);
}

////////////////////////////////////////////////////////////
// Muodostin real(char*, ...)                             //
//                                                        //
// Esim.                                                  //
//                                                        //
//    real x("2d", 2, 3), x saa arvon                     //
//    x.e[0]=2.0000, x.e[1]=3.0000                        //
//                                                        //
//    real y("3f", 1.2345, 6.7891, 2.3571), y saa arvon:  //
//    y.e[0]=1.2345, y.e[1]=6.7891, y.e[2]=2.3571         //
//                                                        //
// - formaatissa annetaan ensin lukujen määrä, esim 2.    //
// - d tarkoittaa, että luvut annetaan kokonaislukuina.   //
// - f tarkoittaa, että luvut annetaan liukulukumuodossa. //
////////////////////////////////////////////////////////////
real::real(char *f, ...)
{
   int i, j, kpl=atoi(f), step;
   memset(this, 0x00, (int)sizeof(real));
   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;
}

double abs(real a)
{
   double c=0;
   for (int i=0; i < DIM; i++)
   c+=a.e[i];
   return c < 0? -c: c;
}

void print(real x)
{
   for (int i=0x00; i < DIM; i++)
   printf("%0.7f ", x.e[i]);
   printf("\n\n");
}

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

real operator+(real a)
{
   return a;
}

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

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

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

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

real operator*(real a, real b)
{
   int n=(int)DIM*2;
   double x[DIM*2];
   double y[DIM*2];
   double t[DIM*2];

   /* unreduce */
   for (int i=0, j=0; i < DIM; i++, j+=2)
   x[j+1]=y[j+1]=t[j]=t[j+1]=0.0,
   x[j]=a.e[i], y[j]=b.e[i];

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

   /* reduce */
   for (int i=0, j=0; i < DIM; i++, j+=2)
   t[i]=(double)(t[j]-t[j+1]);
   return *(real*)t;
}

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

real operator/(double k, real y)
{
   real x(+k);
   return x/y;
}

real operator/(real x, real y)
{
   real 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];
}

/* *** *** *** *** *** *** *** *** *** *** *** *** */
/* *** *** *** *** *** *** *** *** *** *** *** *** */
/* *** *** *** *** *** *** *** *** *** *** *** *** */

real exp(real x)
{
   double t=1.0;
   real sum(1.0);
   real xx=x;
   sum=sum+x;

   for (int i=2; i < 160; i++)
   {
      xx = xx*x;
      sum=sum+xx/(t*=i);
   }
   return sum;
}

real sin(real x)
{
   double t=1.0;
   real sum(0.00);
   real y=x*x, xx=x;

   for (int i=1, sg=0; i < 160; i+=2, sg++)
   {
      if (sg&1) sum=sum-xx/t;
      else /**/ sum=sum+xx/t;
      xx=xx*y; t*=(i+1)*(i+2);
   }
   return sum;
}

real cos(real x)
{
   double t=2.0;
   real sum(1.00);
   real y=x*x, xx=y;

   for (int i=2, sg=1; i < 160; i+=2, sg++)
   {
      if (sg&1) sum=sum-xx/t;
      else /**/ sum=sum+xx/t;
      xx=xx*y; t*=(i+1)*(i+2);
   }
   return sum;
}

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

double gabs(real c)
{
   double sum=0;
   for (int i=0; i < DIM; i++)
   sum+=c.e[i]*c.e[i];
   return sum;
}

real ln(real c)
{
   real fx, dx;
   real z(1.0);
   real x(1.0);
   double t, r1, r2;
   r2=3141592653589;

   for (int k=2; k < 160; k++)
   for (int j=0; j < 256; j++)
   {
      real xx=x;
      fx=z+x; dx=z;
      t=(double)1;

      for (int i=2; i <= k; i++)
      {
         dx=dx+i*xx/(t*=i);
         xx=xx*x; fx=fx+xx/t;
      }

      r1=r2;
      x=x-(fx-c)/dx;
      r2=gabs(x);

      if ((k < 159) && (j > 4) && (fabs(r1-r2) < 1e-15))
      {
         r2=3141592653589793238462643383279;
         break;
      }
   }
   return x;
}

real pow(real a, real x)
{
   double t=1.0;
   real sum(1.0);
   real ln(real);
   real y=x*ln(a);
   real xx=(real)y;

   sum=sum+xx;

   for (int i=2; i < 160; i++)
   {
      xx = xx*y;
      sum=sum+xx/(t*=i);
   }
   return sum;
}

real pow(real x, double n)
{
   real pow(real, real);
   return pow(x, real(n));
}

//////////////////////////////////
// rnd palautaa satunnaisluvun  //
// väliltä [0, max-1]           //
//////////////////////////////////
unsigned long rnd(unsigned long max)
{
   static unsigned long R16A=1L;
   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=rnd(0xfffffffb);
   unsigned long jak=0xfffffffb;
   return rnd(0x02)? -x/jak: x/jak;
}

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

int main(void)
{
   for (int testi=0; testi < 256; testi++)
   {
      real x=real_rnd();
      real y=real_rnd();

      printf("%25.20f\n", abs(x*y));
      printf("%25.20f\n", abs(x)*abs(y));
      printf("\n");

      print(x*y-y*x);

      real z=x/y;
      print(z*y-x);
      print(x/z-y);

      print(x+y);
      print(y+x);

      print(sin(x)*sin(x)+cos(x)*cos(x));
      printf("\n--------------------------------------\n");
   }
   return 0;
}

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

Symboliset merkit '+' ja '-' olivat viimeinen niitti algebran arkkuun, ettei muunlaisia algebroita ole olemassa.

Periaatteessa redusoimaton reaaliluku koostuu kahdesta alkiosta r=(a, b), jossa a edustaa positiivista ja b negatiivista arvoa.

Tietokone joutuu suorittamaan kertolaskun redusoimattomana, jolloin algebran mahdollisuudet moninkertaistuvat.

Esimerkkinä redusoimaton kertolasku:

(1, 2) * (4, 8)

= (1*4+2*8, 1*8+2*4)

= (20, 16)

Kun tulos redusoidaan saadaan +4.

Samaan tulokseen päästään, jos kertolaskualkiot ensin redusoidaan:

(1, 2) * (4, 8)

= (1-2) * (4-8)

= (-1) * (-4)

= +4

Mutta tietokoneen on suoritettava kertolaskut redusoimattomana, jolloin harmonia yhtyy mm. sarjoihin. Algebran algoritmit ovat tyhjiä hahloja, ennen kuin jokin olio antaa algebran sapluunoille merkityksen.

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

abs-funktio on helppo. Akseliarvot lasketaan yhteen, ja saadusta summasta palautetaan itseisarvo. Kaikissa DIMensioissa on voimassa:

abs(ab) = abs(ba) = abs(a)*abs(b) = abs(b)*abs(a)

Myös kolmioepäyhtälö on voimassa, mikä tuntuu olevan joilekin hyvin tärkeää ja oleellista.

 

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

ed: "Kaikissa DIMensioissa on voimassa:" pitää tietenkin olla "Kaikissa 2^n DIMensioissa on voimassa:"

Jakolaskussa jakajalle y toimitetaan liittoluku z, jolla kerrotaan jaettava ja jakaja. Kertolaskun jälkeen y:n akseliarvoja on puolet vähemmän. Esim:

real y(2, 3, 5, 7) liittoluku on real z(2, 3, -5, -7)

Kun jakaja on kokonaan reaalinen, sillä jaetaan jaettavan alkiot:

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

Ohessa kantaolioiden tulotaulukko 4D:ssä. A, B, ..., H edustavat akseleita. Risuaidan ulkopuolelta otetaan arvot esim. H * F = C.

4D-real ensin toimitetaan unreduce. Sitten arvot kerrotaan keskenään ja kantaolioiden tulotaulukko osoittaa, mille akselille kertolaskualkio ynnätään.

Lopuksi täytyy suorittaa redusointi, jolloin jää jokin aA+bB+cC+dD (pienet kirjaimet ovat redusoituja arvoja, ja isot kirjaimet näyttää kantaolion laadun).

 

Läskiperse
Seuraa 
Viestejä950
Liittynyt11.12.2010

2^n-algebralla voidaan myos kuvata rinnakkaisia polynomiapproksimaatioita, DCT/IDCT, ..., FEM.

Eräässä 60 sekunnin mittaisessa ilmiössä mitattiin seuraavat mittausvastinarvot:

 

Suosituimmat

Uusimmat

Uusimmat

Suosituimmat