Kompleksiavaruudet

Seuraa 
Viestejä45973
Liittynyt3.9.2015

Saatanalla on hyvä aloittaa, koska helvettiä ei ole olemassa. Tai Maanpäällinen helvetti on vanhan hiililaivan vakaussäiliön ruosteisten palkkien korjaushitsauksessa lakiasennossa. Kun sula rauta roiskuu päälle, ei voi tehdä mitään, koska on roikuttava toisella kädellä palkista, ja toisessa räpylässä on hitsauspuikko. Kivunsietokyky kasvaa hetkessä saatanallisiin mittoihin.

Tähän verrattuna oli helppo istua puolivuotta kirjastossa, ja opetella 12 tuntia päivässä laskemaan analyyttistä avaruusgeometriaa. Totuus on kuitenkin, että kaiken uuden oppiminen on tuskallista.

Hyvä. Ensimmäinen harrastustyöni oli näköaistin mallintaminen, ja sitä myötä ihmismäisen konenäön perustutkimus. Vaikka lopulta vain piirsin näytölle kolmiulotteisia täydellisiä tilailluusioita, niin se oli kova ponnistus levyseppähitsarin tutkinnolla. Saatanan nörttien kanssa en ole tullut koskaan toimeen, ja siksi olen irtisanoutunut joka paikasta 3-4 työvuoden jälkeen. Palasin vuodeksi takaisin hitsaushommien pariin, koska vaihtelu virkistää. Kun vaihtaa helvetinmoiseen kauhaan huulilevyn, tietää tehneensä jotain konkreettista, kun kaivuri seuraavat vuodet jälleen maata kaivaa.

*** *** ***

Sain mallinnettua aitoa 3D-fraktaalimaisemaa, ja sen kauneus on häkellyttävää. Koska olen jo melko vanha pieru, kerron kaikki pieni pala kerrallaan. Jos mielenkiintosi riittää, opit perusteet C ja C++ kielistä, ja kuinka niillä mallinnetaan matemaattisia olioita. Sitten perehdytään kompleksiavaruuksien olemassaolon faktoihin ja siihen, kuinka saman asian voi tehdä itse tietokoneen kanssa puhtaalta pöydältä. Tietokone on ollut minulle aina työkalu, jatke sille, mitä itse ei osaa päässä laskea.

Lähitulevaisuuden matematiikka luodaan tietokoneella. Ajattelen lähinnä alle parikymppisiä, jotka saattaisivat kiinnostua algebran uusista ja tuntemattomista mahdollisuuksista sovelletussa matematiikassa.

Eväiksi ei tarvita muuta, kuin sietää tuskaa ja uusien asioiden oppimista.

Sivut

Kommentit (153)

Vierailija

C-kieli ja C++ sopivat erityisen hyvin sovelletun matematiikan ohjelmointiin.

Kovin pointti on C:n joustavuus ja hyvä strukturointi. Esimerkiksi kompleksiluku on matemaattinen olio, joka C++:ssa ohjelmoidaan ns. luokaksi, eli olioksi.

Olion järkevyys on siinä, että ex. laskutoimitusten suorituksen aikana kukaan ei ole kiinnostunut, mitä reaali- ja imaginääriarvot ovat. Seuraavassa esimerkki kompleksioliosta:

[code:trtjjkf3]// _jone_ 27.10.09
// kompleksilukufunktioiden
// ln, exp, sin, cos, asin, acos toteutus sarjoilla

#include

class complex
{
public:

double x; // real
double y; // imag

complex(void) {};
~complex(void) {};

complex(int a) {x=a; y=0;}
complex(double a) {x=a; y=0;}
complex(int a, int b) {x=a; y=b;}
complex(double a, double b) {x=a; y=b;}
};

complex operator-(complex a)
{
return complex(-a.x, -a.y);
}

complex operator+(complex a, complex b)
{
return complex(a.x+b.x, a.y+b.y);
}

complex operator-(complex a, complex b)
{
return complex(a.x-b.x, a.y-b.y);
}

complex operator*(complex a, complex b)
{
return complex(a.x*b.x-a.y*b.y, a.x*b.y+a.y*b.x);
}

complex operator*(double a, complex b)
{
return complex(a*b.x, a*b.y);
}

complex operator*(int a, complex b)
{
return complex(a*b.x, a*b.y);
}

complex operator/(complex a, double b)
{
return complex(a.x/b, a.y/b);
}

complex operator/(complex a, int b)
{
return complex(a.x/b, a.y/b);
}

complex operator/(complex a, complex b)
{
complex z(b.x, -b.y);
a=a*z; b=b*z;
return a/b.x;
}

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

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

complex sin(complex x)
{
double t=1.0;
complex sum(0.0);
complex 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;
}

complex cos(complex x)
{
double t=2.0;
complex sum(1.0);
complex 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;
}

complex asin(complex x)
{
complex sum=x;
complex xx=x*x;

for (int i=3; i<160; i+=2)
{
double ylos=1.0;
double alas=1.0;

for (int j=1; j
{
ylos*=j;
alas*=(j+=1);
}
sum=sum+ylos*(x=x*xx)/(alas*i);
}
return sum;
}

complex acos(complex x)
{
return complex(1.57079632679489661923)-asin(x);
}

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

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

double abs(complex a)
{
double c=a.x*a.x+a.y*a.y;
double x=c;

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

double arg(complex a)
{
if (abs(a.x)<1e-15)
{
return 1.57079632679489661923*sgn(a.y);
}
else if (abs(a.y)<1e-15)
{
return a.x<0.0? 3.14159265358979323846: 0.0;
}
else
{
double r=abs(a);
complex k(a.x/r);
k=acos(k)*sgn(a.y);
return (double) k.x;
}
}

complex ln(double c)
{
double x=1.0;
double z=1.0;
double t, xx;
double fx, dx;

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

for (int i=2; i<=k; i++)
{
dx=dx+i*xx/(t*=i);
xx=xx*x; fx=fx+xx/t;
}
x=x-(fx-abs(c))/dx;
}
return complex(x, c<0.0? 3.14159265358979323846: 0.0);
}

complex ln(complex c)
{
return ln(abs(c))+complex(0.0, arg(c));
}

void eksponentin_arvo(complex a, complex b)
{
complex x=ln(b)/ln(a);
printf("%0.10f %c %0.10fi\n",
x.x, x.y < 0.0? '-': '+', abs(x.y));
}

void main(void)
{
#define e 2.71828182845904523536

eksponentin_arvo(complex(+e, 0.0), complex(+e, 0.0));
eksponentin_arvo(complex(-e, 0.0), complex(+e, 0.0));
eksponentin_arvo(complex(-e, 0.0), complex(-e, 0.0));
eksponentin_arvo(complex(+e, 0.0), complex(-e, 0.0));
}
[/code:trtjjkf3]

Vierailija

Ohessa oikeasta työstä konkreettinen esimerkki matemaattisen struktuurin oliosta. public -osioon kootaan kaikki oleellinen. private -osioon kerätään kaikki käyttäjän kannalta epäoleellinen koodin ja parametrien paska.

KÄYTTÖOHJE

Oheisessa polynomiluokassa seuraavat funktiot ovat käytössä:

[code:3iv8ix0h] polynomi(float*, float*, int, int);
polynomi(double*, double*, int, int);
polynomi(Ldouble*, Ldouble*, int, int);

float fx(float x);
double fx(double x);
Ldouble fx(Ldouble x);

float nopeus(float);
double nopeus(double);
Ldouble nopeus(Ldouble);

float integraali(float);
double integraali(double);
Ldouble integraali(Ldouble);
[/code:3iv8ix0h]
Eli rajapinta tukee float (32-bittinen), double (64-bittinen) ja Ldouble (80-bittinen long double) tietotyyppejä.

Polynomiluokka ei sinällään ota kantaa sen käyttötarkoitukseen. Esimerkiksi kohinan poisto liukuvalla ikkunalla on toisinaan tarpeellista, etc.

Kun luokka on käännetty pyyttonin ymmärtämään muotoon, sen käyttö on melko yksinkertaista.

Ex.

P = polynomi(aika, nopeus, näytepisteiden lukumäärä, polynomin asteluku)

aika on taulukko: aika[0.0, 1.0, 2.0, ..., n]
nopeus on taulukko nopeus[0.0, 3.0, 7.0, ..., n]
näytepisteiden lukumäärä on yhtä kuin n
polynomin asteluku voi olla joku 1, 2, 3, ..., 2000, eli ovat muotoa:

1. aste: ax + b
2. aste: ax^2 + bx + c
3. aste: ax^3 + bx^2 + cx + d
jne?

P.fx(x) palauttaa funktion arvon arvolla x. y=P.fx(x)

P.nopeus(x) palauttaa absoluuttisen nopeuden kohdassa x.

P.integraali(x) palauttaa absoluuttisen kuljetun matkan kohdassa x.

Kuta enemmän näytepisteitä tarkasteltavalta väliltä on, sen paremmin laskettu polynomi pistejoukkoa kuvaa.

Kysymyksiä jos tulee, niihin on helpompi vastata, kun on kysymys, johon vastata. Ollaan yhteyksissä.

t. jounk

[code:3iv8ix0h]/*
JA 27.4.2010
*/

#ifndef __POLYNOMI_HPP
#define __POLYNOMI_HPP

typedef long double Ldouble;

class polynomi
{
public:

~polynomi(void);

polynomi(float*, float*, int, int);
polynomi(double*, double*, int, int);
polynomi(Ldouble*, Ldouble*, int, int);

float fx(float x);
double fx(double x);
Ldouble fx(Ldouble x);

float nopeus(float);
double nopeus(double);
Ldouble nopeus(Ldouble);

float integraali(float);
double integraali(double);
Ldouble integraali(Ldouble);

private: /* olion sisäiset parametrit ja funktiot */

int p_aste;
Ldouble *K;

Ldouble gabs(Ldouble);
void mem00set(void*, int);
Ldouble getSumX(Ldouble*, int);
Ldouble getSumXY(Ldouble*, Ldouble*, int);

Ldouble fxn(Ldouble*, int, Ldouble);
int ratkaise(Ldouble*, Ldouble*, int);
void swap_rows(Ldouble*, Ldouble*, int);

void mk_next_pow(Ldouble*, Ldouble*, int);
void mk_poly(Ldouble*, Ldouble*, int, int);
void copyMatrixLeft(Ldouble*, Ldouble, int, int);
void copyMatrixDown(Ldouble*, Ldouble, int, int);
};

polynomi::polynomi(Ldouble *x, Ldouble *y, int n, int a)
{
p_aste=a;
K=new Ldouble[a+1];
mk_poly(x, y, n, p_aste);
}

polynomi::~polynomi(void)
{
delete[] K;
}

Ldouble polynomi::fx(Ldouble x)
{
return fxn(K, p_aste, x);
}

Ldouble polynomi::nopeus(Ldouble x)
{
Ldouble xxx=(Ldouble)1;
Ldouble sum=(Ldouble)0;
for (int i=1; i<=p_aste; i++)
{
sum+=K[i]*(Ldouble)i*xxx;
xxx*=x;
}
return sum;
}

Ldouble polynomi::integraali(Ldouble x)
{
Ldouble xxx=x*x;
Ldouble sum=(Ldouble)0;
for (int i=1; i<=p_aste; i++)
{
Ldouble z=(Ldouble)1/(Ldouble)(i+1);
sum+=z*K[i]*xxx;
xxx*=x;
}
return sum;
}

float polynomi::fx(float x)
{
return (float)fx((Ldouble)x);
}

double polynomi::fx(double x)
{
return (double)fx((Ldouble)x);
}

float polynomi::nopeus(float x)
{
return (float)nopeus((Ldouble)x);
}

double polynomi::nopeus(double x)
{
return (double)nopeus((Ldouble)x);
}

float polynomi::integraali(float x)
{
return (float)integraali((Ldouble)x);
}

double polynomi::integraali(double x)
{
return (double)integraali((Ldouble)x);
}

polynomi::polynomi(float *x, float *y, int n, int a)
{
p_aste=a;
K=new Ldouble[a+1];
Ldouble *X=new Ldouble[n];
Ldouble *Y=new Ldouble[n];
for (int i=0; i
{
X[i]=(Ldouble)x[i];
Y[i]=(Ldouble)y[i];
}
mk_poly(X, Y, n, a);
delete[] Y;
delete[] X;
}

polynomi::polynomi(double *x, double *y, int n, int a)
{
p_aste=a;
K=new Ldouble[a+1];
Ldouble *X=new Ldouble[n];
Ldouble *Y=new Ldouble[n];
for (int i=0; i
{
X[i]=(Ldouble)x[i];
Y[i]=(Ldouble)y[i];
}
mk_poly(X, Y, n, a);
delete[] Y;
delete[] X;
}

Ldouble polynomi::gabs(Ldouble x)
{
return x<(Ldouble)0? -x: x;
}

void polynomi::mem00set(void *x, int kpl)
{
char *c=(char*)x;
for (int i=0; i
c[i]=(char)0;
}

void polynomi::swap_rows(Ldouble *a, Ldouble *b, int n)
{
for (int i=0; i
{
Ldouble tmp=a[i];
a[i]=b[i];
b[i]=tmp;
}
}

int polynomi::ratkaise(Ldouble *X, Ldouble *f, int n)
{
Ldouble k, J;
Ldouble *max, *mux;
int i, j, x, M=(int)n+1;

for (i=0; i
{
max=f+i+i*M;
for (j=i+1; j
if (gabs(*(mux=f+i+j*M))>gabs(*max)) max=mux;

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

if (gabs(J=f[i+i*M])<(Ldouble)1e-20)
return 0; /* eipä ole ratkaisua */

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

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

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

return 1;
}

Ldouble polynomi::fxn(Ldouble *k, int n, Ldouble x)
{
Ldouble sum=k[0];
Ldouble y=(Ldouble)1;
for (int i=1; i<=n; i++)
{
y=y*x;
sum=sum+k[i]*y;
}
return sum;
}

Ldouble polynomi::getSumX(Ldouble *x, int n)
{
Ldouble sum=(Ldouble)0;
for (int i=0; i
sum=sum+x[i]; return sum;
}

Ldouble polynomi::getSumXY(Ldouble *x, Ldouble *y, int n)
{
Ldouble sum=(Ldouble)0;
for (int i=0; i
sum=sum+x[i]*y[i]; return sum;
}

void polynomi::mk_next_pow(Ldouble *x, Ldouble *y, int n)
{
for (int i=0; i
}

void polynomi::copyMatrixLeft(Ldouble *L, Ldouble value, int i, int N)
{
for (--i; i>=0; i--) {L+=N; *L=value;}
}

void polynomi::copyMatrixDown(Ldouble *L, Ldouble value, int i, int N)
{
for (i+=1; i
}

void polynomi::mk_poly(Ldouble *X, Ldouble *Y, int kpl, int aste)
{
int N=aste+1, i;
int M=aste+2, j;
int upa = N*N+N;

Ldouble *x=new Ldouble[kpl];
Ldouble *L=new Ldouble[upa];

mem00set(x, sizeof(Ldouble)*kpl);
mem00set(L, sizeof(Ldouble)*upa);

for (i=0; i
L[N]=getSumXY(x, Y, (int)kpl);
L[0]=getSumX(x, kpl);

for (i=1; i
{
mk_next_pow(x, X, kpl);
L[i]=getSumX(x, (int)kpl);
L[M*i+N]=getSumXY(x, Y, kpl);
copyMatrixLeft(L+i, L[i], i, N);
}

for (i=1; i
{
j=(int)(i*M+N-0x01);
mk_next_pow(x, X, kpl);
L[j]=getSumX(x, (int)kpl);
copyMatrixDown(L+j, L[j], i, N);
}

if (!ratkaise(K, L, N))
{
/* eipä ollut ratkaisua */
mem00set(K, sizeof(Ldouble)*N);
}

delete[] L;
delete[] x;
}

#endif /* __POLYNOMI_HPP */
[/code:3iv8ix0h]

Vierailija

Tuokin on helpommin sanottu kuin toteutettu. Keskiverto-ohjelmoijaksi kasvaminen vaatii valtavasti harjoittelua, yrittämistä, erehtymistä.

Mutta rutiini kasvaa selkärankaan vähitellen. Spesialisoituminen sovellettuun matematiikkaan on vain yksi mahdollisuus monista.

Kuten avauksessasi totesit, et tule toimeen pesunkestävien nörttien kanssa. Suurin kuilu lienee lässyttämisen vähyydessä, eli sinun koodisi on alusta loppuun efektiivinen pieni paketti ilman paskanjauhantaa. Toinen puute on englanninkielen osaamattomuus, jolla ne funktiot ja rivit pitäisi kommentoida.

Omasta puolestani voin todeta, että koodausrutiinisi on tähtitieteellinen verrattuna omiin räpellyksiini. Mutta se riittää minulle.

Kompleksiavaruuksien suhteen olet jo vahvat kortit pöytään lyönyt. Jos vielä avaat sen maallikoillekin, niin suunta on parempi, kuin että kirjoitetaan jossain homeisessa yliopistossa sellaista munkkilatinaa, josta ei ymmärrä erkkikään hevon paskaa.

Vierailija

Miten se voi olla niin vaikeaa mennä suorinta tietä asian ytimeen?

Otetaan shakkilauta. Päälävistäjälle luodaan avaimet symmetriaan ja harmoniaan, koska epäsymmetriset tapaukset eivät koskaan voi olla vaihdannaisia.

Vaihdannaisuus. Päälävistäjälle arvot +1, +1, -1, -1, +i, +i, -i, -i. Nyt ala- ja pystyriville voidaan täydentää symmetrisesti +1, -1, +i, -i, +j, -j, +k, -k.

Havaitaan heti, että ainakin:

[code:38u6qd00](+1)*(+1) = +1
(+1)*(-1) = -1
(-1)*(+1) = -1
(-1)*(-1) = +1

(+i)*(+i) = -1
(+i)*(-i) = +1
(-i)*(+i) = +1
(-i)*(-i) = -1

(+j)*(+j) = +i
(+j)*(-j) = -i
(-j)*(+j) = -i
(-j)*(-j) = +i

(+k)*(+k) = -i
(+k)*(-k) = +i
(-k)*(+k) = +i
(-k)*(-k) = -i
[/code:38u6qd00]
(En tulostanut em. taulukkoa tietokoneella, joten oikeudet muutoksiin pidetään.) Pääpiirteissään kuitenkin noin.

Nyt vain ohjelmoidaan tietokone plaraamaan kaikki vaihtoehdot, ja tulostamaan mielekkäät vaihtoehdot. Koska mielekkäitä vaihtoehtoja on vain yksi (tai kaksi, jos reaali- ja imaginääriakselit vaihtaisivat paikkaa), sen on oltava se oikea valinta, koska muut ovat perseestä.

Vierailija

Lopullinen tietokoneen plaraama kommutatiivinen (kantavektorikerto)taulukko on:

[code:26lvta0n]~~ # +1 | -1 | +i | -i | +j | -j | +k | -k |
############################################
+1 # 1 | -1 | i | -i | j | -j | k | -k |
---#----|----|----|----|----|----|----|----|
-1 # -1 | 1 | -i | i | -j | j | -k | k |
---#----|----|----|----|----|----|----|----|
+i # i | -i | -1 | 1 | k | -k | -j | j |
---#----|----|----|----|----|----|----|----|
-i # -i | i | 1 | -1 | -k | k | j | -j |
---#----|----|----|----|----|----|----|----|
+j # j | -j | k | -k | i | -i | -1 | 1 |
---#----|----|----|----|----|----|----|----|
-j # -j | j | -k | k | -i | i | 1 | -1 |
---#----|----|----|----|----|----|----|----|
+k # k | -k | -j | j | -1 | 1 | -i | i |
---#----|----|----|----|----|----|----|----|
-k # -k | k | j | -j | 1 | -1 | i | -i |
---#----|----|----|----|----|----|----|----|
[/code:26lvta0n]

Algebran kupla asettuu vasempaan yläneljännekseen. Muu luo kompleksiolioille peilikuvan, jolloin kompleksiluvut ovat periaatteessa positiivisia ja negatiivisia.

Jos tämä taulukko herättää kysymyksiä, kysykää.

Cargo
Seuraa 
Viestejä979
Liittynyt27.8.2007
_jone_
Miten se voi olla niin vaikeaa mennä suorinta tietä asian ytimeen?

Ei voi kuin ihmetellä, etenkin kun maailmasta löytyy lahjakkaita matemaatikoita....

_jone_

Jos tämä taulukko herättää kysymyksiä, kysykää.





Olen sanonut tämän monasti ennenkin, mutta sanon sen taas: ANNA NYT HYVÄ MIES JO OLLA!

Nuo sinun "oliot" ovat edelleen tavallisessa kompleksitasossa [size=120:2oix7lgl]C[/size:2oix7lgl]

Otetaan nyt esimerkki

Siispä tuo j kuuluu joukkoon [size=120:2oix7lgl]C[/size:2oix7lgl]
Et pääse noilla laskusäännöilläsi tasosta ulos!

Jos korkeampiuloitteinen algebra kiinnostaa, kuiten ilmeisesti tuntuu tekevän, niin tutustu ensin kvaternioihin ja sen jälkeen yleisemmin Cliffordin algebroihin.

[size=150:2oix7lgl]Kvaterniot[/size:2oix7lgl]

" sähkö (se sähkö, jota tuotetaan mm. voimalaitoksissa) ei ole energiaa "
- Vastaaja_s24fi

“Jos et ole kaksikymppisenä vihreä, sinulla ei ole sydäntä. Mutta jos et ole nelikymppisenä perussuomalainen, sinulla ei ole aivoja.”
- Cargo

Vierailija

Ei puhuta vielä redusoinnista, mutta selittäpä kompleksitasolla esim:

(+i)*(-k) = +j

Ei taida onnistua?

Juuri niin. Päälävistäjä on selviö, mutta muut arvot eivät kuulu C:hen!

PS: Kvaterniot eivät ole kommutatiivisia, eikä niihin sisälly 3D-fraktaalirakennetta.

Cargo
Seuraa 
Viestejä979
Liittynyt27.8.2007

Täh!

j = (+/-)[ 1/√2 + i/√2]
k = (+/-)i[ 1/√2 + i/√2]

-> i*(-k) = (+/-)*(i*(-i))[1/√2 + i/√2] = (+/-)*(1) [1/√2 + i/√2] = (+/-)[ 1/√2 + i/√2] = j

Jos kato lopetetaan näistä korkeammista ulottuvuuksista keskustelu, kun kerta se on ajat sitten todettu mahdottomaksi. Kompleksiluvut ovat laajin mahdollinen kunta; sitä ei voi enää laajentaa jos halutaan säilyttää kaikki kunnan ominaisuudet KUNTA

" sähkö (se sähkö, jota tuotetaan mm. voimalaitoksissa) ei ole energiaa "
- Vastaaja_s24fi

“Jos et ole kaksikymppisenä vihreä, sinulla ei ole sydäntä. Mutta jos et ole nelikymppisenä perussuomalainen, sinulla ei ole aivoja.”
- Cargo

Vierailija

Vastauksesi on suunnilleen plus tahi miinus j? Oikea vastaus on tasan plus j. En kyllä ymmärrä muutoinkaan tuota kaavanpyörittelyäsi, jota jollain valmisohjelmalla väännät. Toisekseen minulla ei ole erityisiä intressejä ruveta inttämään sellaisilla arvoilla, joita on vaikea hahmottaa.

3D-fraktaalirakennetta et voi kumota, vaikka vääntäisit ohjelmallasi kuinka hienoja kaavanmössöjä tahansa.

Lopuksi, kun tuon taulukon arvot redusoidaan, niin suosittelen sinua vain pysymään C:ssä. Voithan näennäisesti elää siinä uskossa, että kertolaskun voi suorittaa myös noilla sinun plus tahi miinus x+yi arvoilla. Menestystä.

Cargo
Seuraa 
Viestejä979
Liittynyt27.8.2007

Ei jumalauta!

Kerroppas jone, että miten erotat plus ja miinus j:n keskenään???

[+j]^2 = [+(1/√2 + i/√2)]^2 = i

[-j]^2 = [-(1/√2 + i/√2)]^2 = i

Ja sitten: En. En tarvi mitään vitunaikaista ohjelmistoa lukiotason kompleksilukualgebraan! Ota nyt helvetti selvää kvaterinoista, jos haluat liikkua korkeammissa sfääreissä - pääsi tuntuu siellä jo olevankin. Eikö sua ittee ollenkaan vituta kinata kun jo tiedät olevas väärässä? Tätä samaa oot jankannu pitkän aikaa, mutta millään ei tunnu menevän oppi perille, vaikka kuinka isolla lekalla kumauttaisi. Ja et kai nyt vittu luule, etteikö noin saatanan yksinkertaista taulukkoa oltaisi jo keksitty, jos siittä jotain hyvätyä olisi, vittu!

" sähkö (se sähkö, jota tuotetaan mm. voimalaitoksissa) ei ole energiaa "
- Vastaaja_s24fi

“Jos et ole kaksikymppisenä vihreä, sinulla ei ole sydäntä. Mutta jos et ole nelikymppisenä perussuomalainen, sinulla ei ole aivoja.”
- Cargo

Vierailija

No ollaan nyt kaikki rehellisiä ja todetaan että nuo jonen luvut ovat uudelleen nimettyjä kompleksitason parillisia neliöjuuria. Mutta olisi kiva nähdä mitä hän tarkoittaa 3D-fraktaalirakenteella.

Cargo
Seuraa 
Viestejä979
Liittynyt27.8.2007

[size=130:kf6jzb1h]Hyperkompleksiluvuilla [/size:kf6jzb1h]voisi saada jotain fraktaalirakennetta aikaan...

Muuten nuo laskusäännöt toimivat hyvin, mutta käänteislukua v ei välttämättä kaikille hyperkompleksiluvuille löydy, ja se on toki huono juttu - huonompi kuin kommutaation puute kvaternioilla:

Jonekin olisi voinut saada aikaan tuon lukujärjestelmän, jos olisi asettanut taulukkonsa hieman eri tavalla.

Tuolta löytyy lisää erilaisia "hyperlukuja", ja kertolasku on yleisesti aina kierto+venytys.
http://www.bugman123.com/Hypercomplex/

Mutta olivatpa ne kertolaskun säännöt mitkä vain, niin kaksiulotteiset kompleksiluvut muodostavat edelleen suurimman kunnan ja siten kelpaavat kunnolliseen matemaattiseen analyysiin (differentiaali & integraali nje.) ilman, että matemaatikko repii kaikkia hiuksia päästään ja ratkee ryyppäämään.

" sähkö (se sähkö, jota tuotetaan mm. voimalaitoksissa) ei ole energiaa "
- Vastaaja_s24fi

“Jos et ole kaksikymppisenä vihreä, sinulla ei ole sydäntä. Mutta jos et ole nelikymppisenä perussuomalainen, sinulla ei ole aivoja.”
- Cargo

Vierailija

En ratkea ryyppäämään, joskin olen perso viinalle ja oluelle.

Tuossa mun systeemissä yhdistin kaikki sarjateorioiden kautta. Käytössä on siis kaikki matemaattiset funktiot sin, cos, ln, exp, etc.

Ellei olisi, jatkaisin vieläkin kompleksiavaruuksien etsimistä. Joillakin jonkin asian tutkimiseen voi mennä koko elämä, eikä sekään vielä riitä probleeman ratkaisuun.

Mun ura sovelletun matematiikan kanssa on kestänyt melko tarkalleen 35 vuotta, joten luulisin, että ne omatkin jauhot päässä ovat aika kypsyneitä.

Kvaterniot, hyperkompleksiluvut, jne., niitä ei voi osoittaa ehyiksi sarjoilla, jonka vuoksi niiden tekijöiltä on loppunut eväät.

Vierailija
half-life
No ollaan nyt kaikki rehellisiä ja todetaan että nuo jonen luvut ovat uudelleen nimettyjä kompleksitason parillisia neliöjuuria. Mutta olisi kiva nähdä mitä hän tarkoittaa 3D-fraktaalirakenteella.

Lopetan tämän ketjun 3D-fraktaaliin. Lopuksi on lapsellista puhua rehellisyydestä, koska olen elämäni epäonnistunut, umpikujia, logiikkavirheitä, mutta olen aina jaksanut aloittaa alusta.

Vierailija

Ja kuule Cargo. Kerro, mitä vitun järkeä on siinä, että kaikki oliot toiseen ovat yhtä kuin -1. Mikä saatanan maaginen luku tuo -1 on?

Toisekseen tutkin kvaternioita, yms. jo viimevuosituhannella, jolloin sinä olit vielä luultavasti margariinipurkissa.

Minulla alkaa olemaan niin paljon ikää, että tuollaista katkeruutta on raskasta lukea rivien välistä.

Newtonin 3D-fraktaalisumu on tärkeä. Sitä ei kuitenkaan kukaan ole vielä nähnyt, koska sen aritmetiikka on vasta vasta löydetty.

Sivut

Uusimmat

Suosituimmat