Seuraa 
Viestejä950

tämän numerologiikan tutkimiseen kului yli kaksivuosikymmentä. Kysymyksessä on kompleksilukujen laajennus äärettömyyteen saakka.

DIM voi olla 1, 2, 4, ..., 2^n

DIM arvolla 1 olio toimii reaalilikuna.
DIM arvolla 2 olio toimii kompleksilukuna.
DIM arvolla 4 olio ottaa mukaan kompleksilukujen laajennuksen.
jne.

olion kasvaessa se antaa kantavektoreille samanarvoisen symmetrian, mutta palaan asiaan myöhemmin.

olio on pelkistetty, ja sen viimeinen main-funktio tulostaa algebrallisen kunnan ehdot.

olio suorittaa kerto- ja jakolaskun redusoimattomana, ja redusointi suoritetaan ko. funktioiden viimeisissä luupeissa.

lisään ajan kanssa esimerkiksi oliolla piirrettyjä fraktaaleja.

jos tulee kysymyksiä, niihin on helpompi vastata seikkaperäisesti, kun on kysymys, mihin vastata.

[code:3cwua6qt]
#include
#include

class recomplex
{
public:

#define DIM 4
double f[DIM];

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

recomplex(int re);
recomplex(double re);
recomplex(int re, int im);
recomplex(double re, double im);

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*(double, recomplex);
friend recomplex operator*(recomplex, double);

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

/* mgn = luvun suuruus */
friend double mgn(recomplex);
friend void mem0x00set(void*, int);
friend recomplex pow(recomplex x, int n);
};

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

recomplex::recomplex(void)
{
mem0x00set(this, sizeof(recomplex));
}

recomplex::recomplex(int re)
{
mem0x00set(this, sizeof(recomplex));
f[0]=re;
}

recomplex::recomplex(double re)
{
mem0x00set(this, sizeof(recomplex));
f[0]=re;
}

recomplex::recomplex(double *a)
{
for (int i=0; i
f[i]=a[i];
}

recomplex::recomplex(int re, int im)
{
mem0x00set(this, sizeof(recomplex));
f[0]=re; f[1]=im;
}

recomplex::recomplex(double re, double im)
{
mem0x00set(this, sizeof(recomplex));
f[0]=re; f[1]=im;
}

////////////////////////////////////////////////////////////////
// Muodostin recomplex(char*, ...) //
// //
// Esim. //
// //
// recomplex x("2d", 2, 3), x saa arvon (2.00000, 3.00000) //
// recomplex y("2f", 1.23, 4.56), y saa arvon (1.23, 4.56) //
// //
// - formaatissa annetaan ensin lukujen määrä, esim 4. //
// - d tarkoittaa, että luvut annetaan kokonaislukuina. //
// - f tarkoittaa, että luvut annetaan liukulukumuodossa. //
////////////////////////////////////////////////////////////////
recomplex::recomplex(char *m, ...)
{
int strToInt(char *m);
int sizeofint=sizeof(int);
int i, j, kpl=strToInt(m), step;
mem0x00set((void*)this, sizeof(recomplex));
unsigned long P=(unsigned long)&m+sizeof(char*);

for (j=0; m[j]; j++)
{
if (m[j]=='d') step=sizeof(int);
if (m[j]=='f') step=sizeof(double);
}

step=step==sizeofint? sizeofint: sizeof(double);
for (i=j=0x00; i
f[i] = step == sizeof(int)?
*(int*)P: *(double*)P;
}

int strToInt(char *m)
{
int x[8]; // max=2^16
int sum=0x00, i, j, k=1;
mem0x00set(x, sizeof(int)*8);

for (i=0, j=0; m[i]; i++)
if (m[i]>='0'&&m[i]<='9')
{
x[j]=(int)(m[i]-'0');
k*=(int)10;
++j;
}

for (i=0, k/=10; k; i++, k/=10)
sum+=(int)(x[i]*k);
return sum;
}

double mgn(recomplex a)
{
double sum=0.00;
for (int i=0; i
sum+=a.f[i]*a.f[i];
return sum;
}

recomplex operator-(recomplex a)
{
for (int i=0; i
a.f[i]=-a.f[i];
return a;
}

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

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

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

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

for (i=j=0; i
x[j+1]=y[j+1]=t[j]=t[j+1]=0,
x[j]=a.f[i], y[j]=b.f[+i];

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

for (i=j=0x00; i
t[i]=(double)(t[j]-t[j+1]);
return recomplex( t );
}

void GeneroiKantavektoreidenTulot(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)
{
GeneroiKantavektoreidenTulot(R, n+n);
}
}

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

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

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

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

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

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

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

for (int i=0; i
x.f[i]/=y.f[0];
return 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
z.f[i]=-z.f[i];
x=x*z;
}

r=fabs(x.f[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);
}
}

////////////////////////////////////////////////////////////////////////
// 20-alkion kohdalla, kun kantavektorin tunnus on suurempi kuin 'z', //
// tunnus on jokin kirjaimesta poikkeava merkki. Laskuissa kantavek- //
// toreiden symbolisiin tunnuksiin ei oteta kantaa. //
////////////////////////////////////////////////////////////////////////
void print(recomplex a)
{
printf("%0.7f ", a.f[0]);
for (int n=1; n
printf("%c %0.7f%c ", a.f[n]<0?
'-': '+', fabs(a.f[n]), 'h'+n);
printf("\n");
}

/* ** *** *** ** DEBUG ** *** *** ** DEBUG ** *** *** ** DEBUG ** *** *** ** */
/* ** *** *** ** DEBUG ** *** *** ** DEBUG ** *** *** ** DEBUG ** *** *** ** */
/* ** *** *** ** DEBUG ** *** *** ** DEBUG ** *** *** ** DEBUG ** *** *** ** */

// tuotetaan satunnaiskokonaisluku
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;
}

// tuotetaan satunnaisliukuluku
double drand(void)
{
unsigned long jak=0xfffffffb;
double sg=rnd(0x02)? -1: 1;
double x=(double)rnd(jak);
return sg * x/(double)jak;
}

// tuotetaan satunnaisolio
recomplex recomplex_rnd(void)
{
double x[DIM];
for (int i=0; i
x[i]=drand();
return recomplex(x);
}

#pragma argsused
int main(int noname, char* none[])
{
recomplex x=recomplex_rnd();
recomplex y=recomplex_rnd();
recomplex z=recomplex_rnd();

printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
printf("1) Kaikilla x, y on x+(y+z)=(x+y)+z (summan liitäntälaki)\n");
print(x+(y+z));
print((x+y)+z);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("2) K:ssa on nolla-alkio 0 niin, että kaikilla x on x+0=x\n");
printf(" (summan neutraalialkio)\n");
print(x+recomplex(0));
print(x);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("3) Kaikilla x on K:ssa vasta-alkio -x siten, että x+(-x)=0\n");
print(x+(-x));
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("4) Kaikilla x, y on x + y = y + x (summan vaihdantalaki)\n");
print(x+y);
print(y+x);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("5) Kaikilla x, y on x*(y+z) = x*y + x*z (osittelulaki 1)\n");
print(x * (y + z));
print(x * y + x * z);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("6) Kaikilla x, y, z on x * (y * z) = (x * y) * z\n");
printf(" (tulon liitäntälaki)\n");
print(x * (y * z));
print((x * y) * z);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("7) K:ssa on ykkösalkio 1 siten, että kaikilla x on 1 * x = x\n");
printf(" (tulon neutraalialkio)\n");
print(recomplex(1)*x);
print(x);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("8) Kaikilla x paitsi 0:lla on K:ssa käänteisalkio x^(-1) siten,\n");
printf(" että x * x^(-1) = 1 (tulon käänteisalkio)\n");
print(x * pow(x, -1));
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

printf("9) Kaikilla x, y on x * y = y * x (tulon vaihdantalaki)\n");
print(x * y);
print(y * x);
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

return 0;
}
[/code:3cwua6qt]

Sivut

Kommentit (60)

Läskiperse
olio suorittaa kerto- ja jakolaskun redusoimattomana, ja redusointi suoritetaan ko. funktioiden viimeisissä luupeissa.

[code:t5l0qo1w]
recomplex operator/(recomplex x, recomplex y)
{
recomplex z;

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

for (int i=0; i
x.f[i]/=y.f[0];
return x;
}
[/code:t5l0qo1w]


Jakolaskussa jakaja lavennetaan reaaliseksi, jolla arvolla sitten jaettavan alkiot jaetaan. Jakolaskua ei suoriteta redusoimattona, vaan redusoituna.

Rautalankamalli jakolaskun kulusta voisi olla paikallaan. Vasta sen jälkeen ottaa härkää sarvista, ja avata kryptisen kertolaskun logiikka.

Sisältö jatkuu mainoksen alla
Sisältö jatkuu mainoksen alla
Läskiperse
Seuraa 
Viestejä950
Spock
Jakolaskussa jakaja lavennetaan reaaliseksi,

oikein.

jolla arvolla sitten jaettavan alkiot jaetaan.

oikein

Jakolaskua ei suoriteta redusoimattona, vaan redusoituna.

väärin. jakolasku kutsuu kertolaskua, joka suoritetaan redusoimattomana.

Rautalankamalli jakolaskun kulusta voisi olla paikallaan.

jakolaskussa jakajalle tuotetaan liittoluku, jolla kerrotaan jaettava ja jakaja. jokaisen silmukka-askeleen lopussa jakajan akseliarvoja on puolet vähemmän (loput summautuvat nolliksi). kun jakajan arvo on reaalinen, arvolla jaetaan jaettavan elementit. Esimerkiksi 2 + 3i + 5j + 7k liittoluku on 2 + 3i - 5j - 7k.

Vasta sen jälkeen ottaa härkää sarvista, ja avata kryptisen kertolaskun logiikka.

kertolaskusta voin yrittää kertoa yleisellä tasolla:

kertolasku vaatii ensin kantavektoreiden tulomäärittelyn. tulon silmukointi ei ota kantaa muodollisiin positiivisen, negatiivisen, reaalisen, imaginaarisen, jne. määrittelyihin. kertolaskun tulos redusoidaan vasta viimeisessä silmukassa.

Läskiperse
Seuraa 
Viestejä950

Ja samat sanat tännekin, ja vielä lisää:

Algebra on ikään kuin hahlo tai muotti, joka tarjoaa algebrallisille olioille alkeisoperaatiot. Alkeisoperaatioilla voidaan sitten sarjojen avulla kehittää kaikki matemaattiset funktiot.

Kuitenkin nykyinen koulumatematiikka ei ymmärrä algebran kirkkainta ydintä. Algebran pointti on, että se kuvaa luontoa. Esimerkiksi pienimmän neliösumman polynomiapproksimaatio, dft/idft, jne.

Kun piirtää aamulla hiirellä jonkinlaisen käppyrän käsi vapisten krapulassa näytölle, niin algebra approksimoi sen juohevaksi ja monotoniseksi funktioksi.

Yksi algebran pointti on vielä se, että kaikki arvot ovat yhdenvertaisissa asetelmissa suhteessa funktioihin sin, cos, arc sin, ln, exp, jne...

Nyt itse pirukaan ei voi väittää, että kompleksitaso olisi viimeinen ja totaalinen loppu muille algebrallisille olioille. i^2 = -1. Kyllä.

Mutta yhdenvertaisuuden perusteella täytyy symmetria täydentää i ja -i. Edelleen, että tämä kompleksikonstruktio olisi symmetrinen, pitää lisätä j, -j, k, -k, jne...

Läskiperse
Seuraa 
Viestejä950

ohessa fraktaali, joka piirtyy j- ja k-akselilta. kuvassa on iteroitu:

Xn+1 = Xn^2 + C

https://kotisivukone.fi/files/xxiv.koti ... /kuva1.png

Mandelbrotin fraktaalissa on yksi symmetria-akseli. tässä on kaksi. otan vielä joitakin zoomattuja kuvia.

miksi muuten tulee aina herja: "kuvan koon määrittäminen epäonnistui", jos siihen yrittää Img-tageja?

voisiko joku, Phony, tmv. kertoa, että miten se kuva on määriteltävä, että se näkyisi suoraan, niin kuin ennenvanhaan.

Ohman
Seuraa 
Viestejä1637

Todettakoon nyt kuitenkin seuraavaa:

Hurewitz todisti vuonna 1898, että reaaliluvut, kompleksiluvut,kvaterniot ja Cayleyn luvut (octonions) ovat ainoita ns. kompositioalgebroita ( joissa tulon normi on normien tulo).

J.F.Adams todisti vuonna 1956 että ainoastaan arvoilla n =1,2,4 ja 8 voidaan n-ulotteisista vektoreista nuodostaa algebra, jossa jakolasku (paitsi nollalla) on aina mahdollista.

Ohman

Läskiperse
Seuraa 
Viestejä950
Ohman
J.F.Adams todisti vuonna 1956 että ainoastaan arvoilla n =1,2,4 ja 8 voidaan n-ulotteisista vektoreista nuodostaa algebra, jossa jakolasku (paitsi nollalla) on aina mahdollista

Tuosta saa sellaisen käsityksen, ettei 16-ulottuvuudella enää toimisi. Ainakin ne algebralliset oliot, jotka täyttävät algebrallisen kunnan ehdot, ilmentyvät kaikissa 2^n-dimensioissa (jossa n = 0, 1, 2, ...).

Ohman
Seuraa 
Viestejä1637
Läskiperse
Ohman
J.F.Adams todisti vuonna 1956 että ainoastaan arvoilla n =1,2,4 ja 8 voidaan n-ulotteisista vektoreista nuodostaa algebra, jossa jakolasku (paitsi nollalla) on aina mahdollista

Tuosta saa sellaisen käsityksen, ettei 16-ulottuvuudella enää toimisi. Ainakin ne algebralliset oliot, jotka täyttävät algebrallisen kunnan ehdot, ilmentyvät kaikissa 2^n-dimensioissa (jossa n = 0, 1, 2, ...).
author="" kirjoitti:



Enpä nyt nähnyt tuossa vastauksessasi mitään itua.

Kunnissa tiettävästi jakolasku o n mahdollinen. Mutta Adams osoitti, että ainoastaan 1-,2-,4- ja 8- vektoreista voidaan muodostaa algebra, jossa jakolasku on mahdollinen!Niinpä ihmettelen, mitä nuo sinun "ilmentymäsi" ovat.

Enpä nyt taida jatkaa tällaisista ilmentymistä keskustelua tämän enempää.

Ohman

Läskiperse
Seuraa 
Viestejä950

Ihmettele pois. Jos perus C taittuu, voit kokeilla itse. Muutoin voit osoittaa, että milloin DIM on suurempi tai yhtäsuuri kuin 16, algebrallisen kunnan ehdot eivät ole voimassa. Niiden ehtojen perään voi vielä lisätä:

10) a/b=c <=> a=b*c
11) abs(a)*abs(b) = abs(a*b)
12) abs(a)/abs(b) = abs(a/b)

Ohman
Seuraa 
Viestejä1637
Läskiperse
Ihmettele pois. Jos perus C taittuu, voit kokeilla itse. Muutoin voit osoittaa, että milloin DIM on suurempi tai yhtäsuuri kuin 16, algebrallisen kunnan ehdot eivät ole voimassa. Niiden ehtojen perään voi vielä lisätä:

10) a/b=c <=> a=b*c
11) abs(a)*abs(b) = abs(a*b)
12) abs(a)/abs(b) = abs(a/b)
author="" kirjoitti:



Jos tuo abs nyt tarkoittaa itseisarvoa eli kuten minä sanoin normia, niin tuo Hurewitz todisti, että ainoat tapaukset, joissa tuo abs(a) * abs(b) = abs(a*b) on mahdollista ovat nuo 1-,2,4- ja 8-tapaukset (ainoat kompositioalgebrat). Muulloin se e i siis toimi.

Puhut myös aiemmissa viesteissä jakolaskusta. Mutta Adams todisti, ettei jakolasku ole mahdollinen muulloin kuin samoissa tapauksissa 1,2,4 ja 8.

Puhut siis ihan puuta heinää. Luultavasti tarkoituksella puhut myös niin epäselvästi, että luulet aina kiemurtelevasi irti vastasi sinulle mitä hyvänsä.

Ei C-kielellä voi osoittaa vääriksi selvästi todistettuja matemaattisia tosiasioita.

Joko sinä tosissaan et ymmärrä tai sitten nuo juttusi ovat jonkinlaista pilailua. Mutta vitsi on huono,jos siihen sisältyy sivukaupalla ohjelmakoodia. Lyhyestä virsi kaunis!

Ohman

Läskiperse
Seuraa 
Viestejä950

Aloitusviestin koodi on kylläkin niin yksinkertaista, ettei sen lukeminen ja ajaminen pitäisi tuottaa ongelmia, jos on edes jonkinlaiset perusteet C:stä.

Aikoinaan oli todistettu, että Maa on pannukakku. Sittemmin todistuksesta on luovuttu. Sinä et ota lainkaan kantaa itse substansiin, vaan jauhat Hurewitzin ja Adamsin todistuksista, joilla ei ole mitään tekemistä tämän asian kanssa.

Usko ketä huvittaa. Jos C perustaitosi eivät riitä recompleksin tutkimiseen, se on sinun ongelmasi. Minä esitän asiat sovellusvalmiudessa, enkä rupea pähkäilemään, että minkälaisia matemaattisia koukeroita tarvitaan asian esittämiseen, kun kysymyksessä on vaikka 256-dimensioinen algebrallinen olio.

Lopetan omalta osaltani jaarittelun kanssasi. Ellet pysty osoittamaan, että algebrallisen kunnan ehdot eivät ole voimassa tietyssä 2^n-dimensiossa, heität turhaa sananhelinää.

Sivut

Suosituimmat

Uusimmat

Sisältö jatkuu mainoksen alla

Uusimmat

Suosituimmat