3D kompleksiluvut

Seuraa 
Viestejä45973
Liittynyt3.9.2015

Taisi olla joskus vuosituhannen alussa NMP:llä, jossa talon tapana tietoa plarattiin netistä. Etsiessäni jotain pakkaukseen liittyvää, linkki osoitti TIEDE.fi -sivustolle. Koska käytin muutoinkin nettiä ensimmäisen kerran vasta silloin, luulin, että TIEDE.fi sivustolla omilla julkaisuilla olisi jotain arvoa.

Voikin jälkiviisaana sanoa, että elämäni suurin virhe oli netti ja TIEDE.fi -sivusto, koska foorumi on täynnä itseään täynnä olevia noviiseja, jotka eivät kuuna päivänä ole laittaneet tikkuakaan ristiin tutkiakseen esimerkiksi matematiikkaa. Pieneksi esipuheeksi sopii aiemmin kirjoittamani mielipiteeni:

"Mä en oikein osaa lukea sellaista monimutkaiselta näyttävää matemaattista formaattia, koska jossain vaiheessa, kun niitä merkintäkoukeroita alkaa olemaan liikaa, niin tuun sokeaksi.

C-kielen formaattia ymmärrän aika pitkälle, mutta sen suhteen olen vieläkin syvemmällä umpikujassa. Jos siinä C-funktiossa on enemmän kuin 10 riviä, niin tulen taas sokeaksi. Viimeisenä, muttei vähäisimpänä puutteena, en ymmärrä toisten kirjoittamaa koodia ollenkaan, ellei se ole äärimmäisen efektiivistä bittien, lukujen, logiikan ja arvojen pyörittelyä.

Siksi mä en oo sopinut vielä yhteenkään ohjelmointifirmaan. 2-3 vuotta, ja sitten mulla palaa päreet siihen saatanan lässyttämiseen, jaaritteluun, paskan tuottamiseen ja siihen loputtomaan epäjärjestykseen, jota tämä saatanan IT-sukupolvi suoltaa.

Mä oon saanut vain kerran potkut tuolla elektroniikkatiellä. Muista firmoista mä oon lähtenyt pää savuten tasan silloin, kun ne päreet palaa joskus yleensä toisena tai kolmantena työvuotena, harvemmin vasta neljäntenä työvuotena.

Siis mitenkä tämä nyt liittyi tähän yhteyteen? Meinaan sitä vain, että vaikka oon noin näennäisesti varustettu vähemmillä lahjoilla, niin kuitenkin tämä sun juttusikin pitäisi toimia, kun sen vain runnoo ja takoo siihen 3D-muottiin.

Ja taas pitää alustaa, jotta voin sanoa, mitä tarkoitan...

Hamilton aikanaan fundeerasi tätä 3D-kompleksiavaruutta. Mutta vuosista huolimatta hän ei vain löytänyt sitä, vaikka etsi, tutki ja taas fundeerasi. No sitten hän lopulta löysi symmetrian kvaternioista. Mutta ne ei oo vaihdannaisia. Määkin tutkin niitä tuloksia joskus viimevuosituhannella, ja petyin, kun niissä ei ollu kaikkien akseleiden välillä kaunista fraktaalirakennetta.

Sitten määkin aloin tutkimaan, etsimään, fundeeraamaan. Sain aikaan jonkun omasta mielestä koko matematiikan tulevaisuuden mullistavan 3D-pläjäyksen, jonka kaikkien akseleiden välille piirtyi ensin jotakin sotkua, ja sitten se varsinainen 3D-fraktaalirakenne ei ollu sellainen kauneuden vangitsema maisema, jollainen se oli mielessäni.

Mää jouduin kuitenkin elämään sen rumuuden kanssa ja runnoin teoriani finaaliin. Joku neliöjuuri oli jossain vähän samanlainen kuin joku toinen neliöjuuri jossain muualla. Siitä sitten piti repiä se todistus ja osoitus, että näin on, niin kuin joku ainstain.

Matkasin sitten ylpeänä raahesta vaasaan mukanani valtava teoria. Vaasassa oli vain yks aika kova matematiikan taitaja, ja ajattelin, että hänen kauttaan teoriani menisi suoraan Sience-lehden painoon, joka jouduttaisi kieli pitkällä odottamaani varmaa noobelin palkintoa.

Toisin kävi. Hän polki se saman tien maan rakoon, ja totesi, että lukuteoriassa on osoitettu niin ja näin, jolloin tämä j-laajennus on mahdotonta. Katkerana ja hyvin pettyneenä palasin takaisin raaheen.

Sitten meni jokin aika, ja purin hampaani yhteen. Saatana, minä näytän. Joku 12-13 vuotta piti tutkia, etsiä, fundeerata. Löysin lopulta jonkun vaihdannaisen a+bi+cj+... pläjäyksen. Koska mun algebratieto ja C-taito kehittyi siinä ohessa, niin olin matkassa vahvemmilla eväillä, sarjoilla.

Sitten mun tartti ohjelmoida vain brute-force, joka plarasi kaikki mahdolliset ja mahdottomat kantavektoreiden tulotaulukot. Taulukon myötä alkeisoperaatiot on määritelty, joilla päästään suoraan kiinni sarjoihin, ja sitä kautta metodin mielekkyyteen. Kun siellä lopulta oli vain yksi mielekäs kombinaatio, joka toteutti vaaditun harmonian, niin siinä se sitten oli.

Sillä sun e, i, pii -kaavan pyöritelyllä sain siihen myös kaikki logaritmit valideiksi. Eli sen iterointi ei enää lähde miinus reaalisella värähtelemään ja siten räjähtäämään pillan päreiksi äärettömyyteen.

Vieläkin joutuu alustamaan vähän lisää, jotta voin sanoa sulle sen yhden pointin liittyen nimenomaan aitoihin 3D-kompleksilukuihin.

Niin, siis nyt voi kyhätä jonkinlaisia lukuteoreettisia ominaisuuksia kantavektoritaulukoiden päälävistäjien olioille. Luulisin, että puoli A4:sta riittää ja muun paskanjauhannan voi jättää omaan arvoonsa.

Nyt päästään lopulta tähän sun juttuus.

Mun pläjäyksessä on odd, even ja plus ja miinus. Sen vuoksi ne kuplat ilmentyvät 2^n:ssä.

Sun pläjäyksessä on odd, even ja joku muu vielä tuntematon parillisuusparittomuusominaisuus sekä plus, miinus ja joku muu vielä tuntematon plusmiinusjokuominaisuus.

Jos nuo alkeisoperaatiot muodostavat sitten keskinäisen yhdenvertaisuuden vaihdannaisuudella, niin kompleksiolioiden ilmentymä 3^n:ssä voi olla konkreettinen.

Alkeisoperaatioiden sommitelussa ensimmäinen täydellinen luku 6, jolla voidaan lausua myös kaikki alkuluvut, voi myös olla keskeisessä roolissa, jos alkeisoperaatioiden määrittely joudutaan lausumaan kahdella arvolla kolmella akselilla, siis joku (a, b) ? (c, d) ? (e, f)

En minä tiedä.

3D-fraktaalien uskomaton kauneus on olemassa jossain.

Vain etsivä voi sen löytää."
´
*** *** *** *** *** ***

Että niin. Matematiikan ja minkä tahansa tieteen oma-aloitteinen tutkiminen on raskasta, koska pitää pystyä kestämään epäonnistumisia vuosikymmenestä toiseen, ja aina löydettävä jostain uusia voimia aloittaa tutkiminen uudelleen jostain toisenlaisesta perspektiivistä.

Mitä ****** Te sellaisesta voimien koettelemisista tiedätte hevon paskaakaan. 30 päivää ja yötä tehokas pöytäkone etsi todellista kauneutta. Se löysi sen lopulta sieltä, minne vajavaisen ihmisen mielikuvitus ei voisi koskaan omin avuin löytää.

Että siinä teille kaikkitietäville esimerkkiä. Virheistä viisastuneena kuvat ja niiden matematiikan kontra logiikan esitän jossain muussa yhteydessä.

Hyvästi sontiaiset.

_jone_

Sivut

Kommentit (33)

abskissa
Seuraa 
Viestejä3654
Liittynyt9.10.2008
_jone_

Että siinä teille kaikkitietäville esimerkkiä. Virheistä viisastuneena kuvat ja niiden matematiikan kontra logiikan esitän jossain muussa yhteydessä.

Siinä teille esimerkkiä? Missä? Laita vaan kuvia näkyviin.

We're all mad here.

Vierailija

Kuule abskissa, kaikilla algebrallisilla olioilla on ominaisuus:

a * b = |a| * |b|

Ellei näin ole, oliolla ei ole alkeisoperaatioita, eikä sitä myötä myöskään sarjoja, ja vielä vähemmän fraktaalista kauneutta.

Plus ja miinus luovat selkeän symmetrisen tarpeen i:lle. Algebrallinen olio on aina symmetrinen, joka voi toteutua vain ja ainoastaan täydellisellä vaihdannaisuudella.

Merkitään plus ja miinusoperaation lisäksi uusi ja yhdenvertainen Þ-operaatio Nyt vaihdannaisuuden perusteella on oltava:

+ A - B Þ C = + A Þ C - B = Þ C - B + A, etc.

abskissa, heti kohta on kysymys, miten uusi Þ-operaatio suoritetaan ruohonjuuritasolla?

Plus, miinus ja Þ -operaatioista tiedetään ainakin se, että samanmerkkiset alkiot voidaan aina laskea yhteen. Edelleen tiedetään se, että;

A * B = C <=> C / B = A <=> C / A = B

plaap, plaap, plaap. Omassa päässä on jossain vaiheessa syttynyt algebran värinen lamppu. Yhtä kaikki, nimiä on vaikea keksiä. r_olio, i_olio, j_olio, k_olio, l_olio, m_olio, jne.

Kuka päätti, että on vain plus- ja miinusoperaatio, ja i. Niinkö? Entäs Þ-operaatio? Nyt j-olion tarve on konkreettinen. Vai onko se fraktaalikauneus vain häivähdys jostain mielettömästä?

Huoh. Jakolasku on kertolaskun käänteisoperaatio ja päinvastoin. Operaatio, jonka sisässä on operaatioita, joiden sisässä on edelleen operaatioita. Niistä muodostuu algebrallisen olion alkeisoperaatiot, joista oleelliset on jo mainittu. On aivan turhaa paskanjauhantaa, että meillä on:

A + 0 = A

Ihanko totta? Että joku algebrallinen olio plus ei mitään on edelleen sama alkuperäinen algebrallinen olio. Kyllä algebran määrittelyissäkin olisi kirveelle töitä. Vain oleellisesta syntyy konkreettisia tuloksia, muu paskanjauhanta voi jäädä omaan tunkioarvoonsa.

Että väännä näistä lähtökohdista itse, jos kiinnostaa. Minulla ei sen enempään esittelyyn ole intressejä tässä foorumissa.

ja nyt tämä tunkio saa jäädä. Koh Lanta Yai kutsuu.

Vierailija

Itsellä tosiaan pyöriny myös mielessä jonkinlaiset 3d luvut ja paperillekin kirjoitellut jotain. Selitä jone ihmeessä tuo perusajatus ymmärrettävästi. Olen rehellisen kiinnostunut.

abskissa
Seuraa 
Viestejä3654
Liittynyt9.10.2008
_jone_
Kuule abskissa, kaikilla algebrallisilla olioilla on ominaisuus:

a * b = |a| * |b|


Mitä? Siis -1 = 1:

-1 = (-1) * 1 = |-1| * |1| = 1 * 1 = 1

_jone_

abskissa, heti kohta on kysymys, miten uusi Þ-operaatio suoritetaan ruohonjuuritasolla?

Määrittele Þ. Missä avaruudessa operoidaan? Jos Þ on laskutoimitus, niin mitä tarkoitat ÞC:llä? 0 Þ C?

_jone_
On aivan turhaa paskanjauhantaa, että meillä on:

A + 0 = A


Ei ole. Tuo on aika oleellinen tieto 0:ta. Voi kun tietäisit millainen määrä tuota "paskanjauhantaa" on tarvittu siihen, että sinulla on käytössäsi tietokone ja C++ -kääntäjä.

Mutta minä olisin vaan halunnut nähdä niitä kuvia.

We're all mad here.

Vierailija
peippo
Itsellä tosiaan pyöriny myös mielessä jonkinlaiset 3d luvut ja paperillekin kirjoitellut jotain. Selitä jone ihmeessä tuo perusajatus ymmärrettävästi. Olen rehellisen kiinnostunut.



Hmm,‘,‘, asiallisiin kysymyksiin pitää kaiketi vastata, koska kolme vuosikymmentä olisin toivonut itselleni vastauksia. Mutta joutui tarpomaan raskainta polkua pitkin.

3D-kompleksilukujen ongelmaksi fokusoitui useampien kuin yhden kompleksiolion konkreettinen tarpeettomuus.

Niin matematiikassa kuin muissakin yhteyksissä, ensin pitää olla konkreettinen tarve. Sen jälkeen tarvetta voi ruveta tutkimaan, ja mahdollisesti joskus löytää sille ratkaisu.

Ratkaisut ovat kiven alla. Minulla on ollut 35 vuotta jääräpäistä etsimistä, ja vasta muutamalle kysymykselle on löytynyt vastaukset. Ne ovatkin sitten niin vahvoissa kantimissa, että väittelen fläppitaululla jokaisen epäilijän maanrakoon.

Algebra sisältää ainakin reaalimaailman ja imaginaarimaailman, joiden rotaation mielekkyys yhdistyy sarjoilla. Algebra onkin itsessään yleistys, milloin sen oliot ovat järkeviä ja milloin eivät.

Jotta sarjojen mielekkyyttä voi tarkastella, algebralliselle oliolle pitää ensin määritellä alkeisoperaatiot. Minkä tahansa olion alkeisoperaatioina on ainakin itseisarvo, kertolasku, jakolasku ja yhteenlaskuoperaatiot. Sen jälkeen pitää olla olioiden arvosta riippumatta:

| x | * | y | = | x * y | (abskissa ei osannut kuvitella pölkkyjä ympärille)

x * y = y * x

x / y = z <=> z * y = x <=> x * z = y

a + b = b + a

sin^2 x + cos^2 x = 1

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

Kokonaan tai osittain redusoimattomassa yhteenlaskussa on kysymys alkioiden järjestyksen vaihtamisesta. Tai voisihan sen suorittaa redusoituna, vähän kuin vektori. Tällä tiellä yhteen ja vähennyslaskun lisäksi on loputon määrä samanarvoisia operaatioita.

Periaatteessa voidaan sanoa, että yhtä vähän kuin teknistä laskentaa rustaavaa ohjelmoijaa kiinnostaa liukulukujen formaatit, niin yhtä vähän häntä kiinnostaa, miten joku kompleksiolio suorittaa yhteenlasku- tai jonkin muun operaation.

Asetelma muuttuu kiinnostavaksi vasta sitten, kun ohjelmoija itse tippuu ruohonjuuritasolle tutkimaan liukuluvuissa käytettyjä formaatteja, tai miten kompleksilukujen jakolaskuoperaatio suoritetaan.

Sinua pitää kiinnostaa, mitä ruohonjuuritasolla tapahtuu. Käytä muiden tekemää vain auttavana referenssinä tarvittaessa, ja kulje se polku omin voimin.

Niin, ja sitten laajemmassa testaamisessa mukaan tulee muun muassa approksimaatiot ja iterointimenetelmät. Voin kait kuvia ja koodinpaskankin joskus tänne heittää, kun on juonut kassillisen sixpäkkejä.

Vierailija
_jone_
Käytä muiden tekemää vain auttavana referenssinä tarvittaessa, ja kulje se polku omin voimin.

Argumenttisi perusteella tarkoitat kaiketi enemmän "käyttää mallina". Referenssin suora kopioiminen paperilta A paperille B ei ilmeisesti johda parempaan lopputulokseen.

Vierailija

Tjaa, onkohan niin. että kauan on luultu, ettei vektoreilla ole operaatioita, kuin rajoitetusti.

Itse olen 35 vuoden tutkimisen jälkeen vähän eri mieltä. Oheinen pläjäys osoittaa, että vektoreilla on reaalimaailmassa kaikki operaatiot käytössä.

Hyvä niin. Kompleksisessa tarpeessa on muutama kandidaatti, jotka antavat yhtä mielekkäitä tuloksia ja samanlaista harmoniaa. Kompleksiolioiden kannalta seulaa pitää vielä kiristää, jotta jäljelle jää vain yksi ratkaisu.

Jokainen vektoreista kiinnostunut voi syventyä main-funktioon. Siinä vektoreilla on kaikki operaatiot ja funktiot, joskin kaikkia funktioita ei ole vielä sarjoilla vääntänyt.

Mutta yhtä kaikki. Mäyräkoiria kuluu ja työ jatkuu.

[code:3g7iw0b3]#include
#include
#include

class reaali
{
public:

#define KOKO 4
double e[KOKO];

reaali(void);
~reaali(void);

reaali(double);
reaali(double, double);
reaali(double, double, double);
reaali(double, double, double, double);
};

reaali::~reaali(void)
{
}

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

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

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

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

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

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

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

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

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

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

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

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

for (int i=0, j=0; i
t[i]=(double)(t[j]-t[j+1]);
return *(reaali*)t;
}

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

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

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

return x/y.e[0];
}

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

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

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

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

reaali asin(reaali x)
{
reaali sum=x;
reaali 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;
}

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

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

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

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

for (int k=2; k<160; k++)
for (int j=0; j<256; j++)
{
reaali 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-10))
{
r2=3141592653589793238462643383279;
break;
}
}
return x;
}

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

sum=sum+xx;

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

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

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

/////////////////////////////////////
// reaali_rnd palautaa satunnaisen //
// reaaliluvun funktioiden //
// testaamiseen. //
/////////////////////////////////////
reaali reaali_rnd(void)
{
reaali x;
for (int i=0; i
x.e[i]=drand();
return x;
}

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

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

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

print(x*y-y*x);

reaali 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));
}
return 0;
}
[/code:3g7iw0b3]

abskissa
Seuraa 
Viestejä3654
Liittynyt9.10.2008
_jone_
Tjaa, onkohan niin. että kauan on luultu, ettei vektoreilla ole operaatioita, kuin rajoitetusti.

Ei kai sellaista luuloa kenelläkään ole. Ovathan reaalilukusuora ja kompleksitasokin vektoriavaruuksia.

Ks. http://mathworld.wolfram.com/VectorSpace.html

_jone_
Niin matematiikassa kuin muissakin yhteyksissä, ensin pitää olla konkreettinen tarve. Sen jälkeen tarvetta voi ruveta tutkimaan, ja mahdollisesti joskus löytää sille ratkaisu.

Usein ne hommat tietenkin etenee noin päin, muttei suinkaan aina. Esim. lukuteorialle ei kai paljon käytännön sovelluksia ollut ennen tietokoneita. Joidenkin matemaattisten havaintojen hyödyllisyys saatetaan huomata vasta satoja vuosien kuluttua niiden keksimisestä.

Koodissa putosin kärryiltä kertolaskun kohdalla. Tuo XOR indekseillä näyttää todella oudolta:
[code:2ytkib04]
for (int i=0; i
for (int j=0; j
t[i^j]+=x[i]*y[j];
[/code:2ytkib04]

Miten tuo kertolasku käyttäytyy ihan esim. 1 tai 2-ulotteisessa tapauksessa?

We're all mad here.

Vierailija

[

abskissa

Koodissa putosin kärryiltä kertolaskun kohdalla. Tuo XOR indekseillä näyttää todella oudolta...

Konkreettisen algoritmin (yksinkertaisen sellaisen) paras anti on, että nimenomaan esimerkiksi sinä pysyit kärryillä paljon pitempään kuin uskoitkaan.

Tuo xor generoi ns. Latinalaisen neliön, jolla on paljon mielenkiintoisia ominaisuuksia. Jos peilaat sen logiikkaa redusoimattomasti suoritettuihin alkeisoperaatioihin, niin algebran reaalikuplat asettuvat aidoiksi osajoukoiksi, jolloin suuremmassa osajoukossa useampien kompleksiolioiden tarve on konkreettinen.

KOKO pitää olla jokin 2^n. 1-ulaotteisessa avaruudessa pläjäys generoi Tammertekniikan reaaliluvut.

abskissa
Seuraa 
Viestejä3654
Liittynyt9.10.2008
_jone_

Konkreettisen algoritmin (yksinkertaisen sellaisen) paras anti on, että nimenomaan esimerkiksi sinä pysyit kärryillä paljon pitempään kuin uskoitkaan.

No pitää myöntää, että kommentoimaton koodi ei koskaan herätä luottamusta ymmärrettävyydestä.

_jone_
Jos peilaat sen logiikkaa redusoimattomasti suoritettuihin alkeisoperaatioihin, niin algebran reaalikuplat asettuvat aidoiksi osajoukoiksi, jolloin suuremmassa osajoukossa useampien kompleksiolioiden tarve on konkreettinen.

Hmmm... Kaiken mitä voi sanoa, voi sanoa selvästi -- jos niin haluaa.

Pitää varmaan sitten itse noita laskutoimituksia pyöritellä, kun on niin salamyhkäistä.

We're all mad here.

Vierailija

No kyllä tuo omasta mielestä on melko selvästi sanottu. Matematiikassa plus ja miinus ovat vain niin parkkiintuneita käsitteitä.

Kyllä ne oikein ovat, mutta luvut esitetään aina redusoituina. Kun ihminen ynnää ja vähentää suu vaahdossa, hän huomaa vasta kompleksitason tienoilla, että esitystä on väljennettävä, esim.:

+3 - 3i

Nythän on päivänselvää, ettei noita voi enää laskea yhteen, eli suu vaahdoten jatkaa:

+3 - 3i = 0

Yhtä lailla kysyit, että mitä tarkoittaa Þ -operaatio. Ei vähempää eikä enempää, kuin kolmatta suuntaa. Voidaan siis parta huurussa sanoa, että kolmannen suunnan operaatiot olkoot risuaita ja miukumauku, siis joku:

+ a - b # c

Tuossa latinalaisessa neliössä on sellainen reaalinen ominaisuus, että kertolaskun lävistäjässä plus, miinus, risuaita ja miukumauku -arvot tippuvat aina plus-karsinaan.

Nyt on luotu konkreettinen tarve j-kompleksioliolle. Asian ainut mutta on, että kertolaskun kommutatiivisuus vaatii 2^n alkioisen pläjäyksen. Mutta 3D voi olla 4D:n aitona osajoukkona. Siten 3D-kompleksivektori on raa'asti:

+ a - bi # cj , joka vektoriolio täyttää algebrallisen mielekkyyden vaatimukset.

jk. Jos kommentteja kaipaat, laita paperit NPL:lle . Kommenttia pitää olla, ja aivan sama, vaikka puhuisi paskaa. Kommentointi on jokin viimeinen oljenkorsi sille (NMP:lle), mitä sillisalaattia 700 riviä pitkässä funktiossa on yrittänyt tuottaa. Se on joissakin tapauksissa suorastaan monumentaalista;

[code:nzsgeudg]/* *** Template of NMP codes *** */
/* Make up: Panis Jos Vain Sais alias _jone_ */
/* Check in: mako, Englich presidents of NMP */
/* Statuuc: Denied

int i; // tässä mulla on int luku, jota hetken perästä aion käyttää
// laskurina n:stä 0:aan. koska luupin pitäisi käsitellä vielä
// nolla-alkiokin, niin sen vuoksi valitsin etumerkillisen
// kokonaisluvun, vaikka yleensä laskureina käytetäänkin
// etumerkittömiä kokonaislukuja, kuten seuraavasta esiteltävästä
// parametrista voidaankin jo havainnoida tämä
// seikka.

unsigned j; // no tämä parametri on nyt sitten
// etumerkitön laaskuri, jota aion myös käyttää joskus 500
// rivin perästä.
plaap plaap plaap
[/code:nzsgeudg]

Koodin kommentoinnissa mittani tuli täyteen jo vuosituhannen alussa. Kun päreet paloivat ainaiseen lässyttämiseen, haistatin pitkät paskat koko firmalle.

Sen koomin en ole koodia kommentoinut muutoin, kuin poikkeustapauksissa, eli jos kommentti oikeasti antaa joitain oleellista lisäinformaatiota.

Vierailija

Hmm...kuvia ette saa. Mutta pöytäkone saa laskea vaikka viisi vuotta 3D-Newtonin sumua, joka lento 3D-teatterissa katsottuna antaa kauneudelle ja harmonialle sen lopullisen pisteen iin päälle.

Sinä päivänä heristän nyrkkiäni koko vetelälle ja saamattomalle IT-sukupolvelle, jossa itse algoritmit hukkuvat loputtomaan paskanjauhantaan ja lässyttämiseen.

64:lla ei paljon lässytetty. Koodin joutui ensin kirjoittamaan kynällä ja paperilla sata kertaa, ennen kuin sitä edes kannatti tarjota konekielimonitorille. Ei siinä konekielimonitorissa mitään kommenttien mahdollisuutta ollut. Ainut selkeytysmahdollisuus oli pyrkiä kirjoittamaan entistä efektiivisempää koodia. NOP (NO Operation) oli erotin funktioille ja toiminnoille.

Itse asiassa olisi melko mielenkiintoinen projekti kaivaa jostain 64:n konekielimonitorin manuaalit, ja koodata siitä simulaatio 1: 1 nykyisille raudoille. Silloin veltto IT-sukupolvi joutuisi kaivamaan kynän ja A4:sen, ja vääntämään koodinsa tasan siihen paperille.

Mutta tuolle reaalisen kompleksivastineelle on kaksi validia ratkaisua. Toisessa vain operaatioiden tulkinta on vastakkainen.

Eipä siitä paljon ole sanomista. Kompleksiset kantavektorit generoituvat rekursiivisesti arvosta nolla. Hyvä niin, alussa pitääkin olla pelkkä origo, jolla ei ole lainkaan ulottuvuuksia.

[code:31oacfn8]class kompleksi
{
public:

reaali e[KOKO];
kompleksi(void);
~kompleksi(void);
kompleksi(double);

kompleksi(reaali);
kompleksi(reaali, reaali);
kompleksi(reaali, reaali, reaali);
kompleksi(reaali, reaali, reaali, reaali);
};

.
.
.

kompleksi operator*(kompleksi a, kompleksi b)
{
int *KantavektoreidenTulot(void);
int *R=KantavektoreidenTulot();
int i, j, n=(int)KOKO*(int)2;

reaali e00(0.00);
reaali x[KOKO*2];
reaali y[KOKO*2];
reaali t[KOKO*2];

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

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

for (i=j=0; i
t[i]=(reaali)(t[j]-t[j+1]);
return *(kompleksi*) t;
}

void RekursioKantavektoreidenTulot(int *R, int n)
{
int I=0, J=n-1, i;
int X=n, Y=J+n, j;
int k=KOKO*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 < KOKO*2)
{
RekursioKantavektoreidenTulot(R, n+n);
}
}

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

.
.
.

kompleksi operator/(kompleksi x, kompleksi y)
{
kompleksi z;
void print(kompleksi);
for (int i, n=KOKO; n>=2; n/=2)
{
for (z=y, i=n/2; i
z.e[i] = -z.e[i];
x=x*z; y=y*z;
}

return x/y.e[0];
}

.
.
.

////////////////////////////////////////
// kompleksi_rnd palautaa satunnaisen //
// kompleksiluvun funktioiden //
// testaamiseen. //
////////////////////////////////////////
kompleksi kompleksi_rnd(void)
{
kompleksi x;
for (int i=0; i
x.e[i]=reaali_rnd();
return x;
}

void print(kompleksi x)
{
for (int i=0; i
{
printf("{");
for (int j=0; j
printf("%0.7f ", x.e[i].e[j]);
printf("}\n");
}
printf("\n");
}

.
.
.

int main(void)
{
for (;;)
{
reaali e1(-1.0, 0.0, 0.0, 0.0);
reaali e2(0.0, 2.0, 0.0, 0.0);
reaali e3(0.0, 0.0, -3.0, 0.0);
reaali e4(0.0, 0.0, 0.0, 4.0);
kompleksi c(e1, e2, e3, e4);
kompleksi x=kompleksi_rnd();
kompleksi y=kompleksi_rnd();
kompleksi e(2.71828182845904523536);

.
.
.
}
}
[/code:31oacfn8]

Vierailija

Hmm...haluan lopuksi haistattaa pitkät paskat suurimmalle osalle matematiikan professoreista. Väittelisin jokaisen alta aika yksikön maanrakoon. Sama koskee myös IT-alan pioneereja.

Tasan sen vuoksi, että alalla paloi loppuun vuosikymmenessä. Ei asioiden vaikeuden vuoksi, vaan ainaisen paskanjauhannan ja lässyttämisen vuoksi.

Yksi paljon algoritmien ja matematiikan kiinnostukseeni vaikuttanut lehtori oli hänkin "vain" alkujaan laivalevyseppä. Siellä IT-alalla jokainen on omasta mielestään tarpeeksi erinomainen aliarvioimaan hitsarin ATK-taitoja, mutta pelkää kuitenkin sisimmässään sitä idiootin roolia, jota olen elämäni vetänyt.

Aikaa myöten aloin oikeasti arvostamaan idioottia, ja aloin etsimään kysymyksiin vastauksia entistä yksinkertaisemmista ja efektiivisemmistä faktoista. Yhtä äkkiä huomaa, että rälläkällä ja tietokoneella on yhteistä se, että molemmat ovat työkaluja.

Eräs mako NMP:llä väitti, ettei se niin ole, vaan se on suurta luovuutta, sellaista ikään kuin modernia taidetta, jossa maalipurkkeja heitetään ensin lattialle, ja kuovitaan se mopon takarenkaalla suoraan kankaalle, jota teosta sitten asiantuntijat haukkovat henkeään pidättäen, että on niin viimeisen päälle kaunista.

Paskat, se on valetta. Todellinen kauneus on piste, jolla ei ole lainkaan ulottuvuuksia. Sitten joku antaa pisteelle merkityksen, ja se räjähtää luoden energian, kirkkauden, aineen ja paikan, jossa on hyvä elää.

Ei se ole niinkään, vaan koko yhteiskunta on rakennettu aikojen saatossa palvelemaan pientä valehtelijoidenklubia, jotka pyrkivät repimään rajattomat rikkaudet luonnon riistolla.

Jos logiikkaa halutaan, asioilla on prioriteetit. Joku hawking voi pohtia höyrystyviä aukkojaan tasan niin paljon, kuin haluaa, mutta laitospaikkoja pitää rakentaa lisää. Siellä voi sitten suu vaahdossa esitellä toinen toistaan kummallisempia skenaarioita universumista.

Huoh. Kukaan ei kiellä sitä, etteikö luonnonvaroja olisi pitänyt käyttää harkiten ja säästeliäästi ylimenokauteen, jolloin Auringosta pystytään saamaan se loputon energiantarve, joka loppupeleissä hyvinvointia jokaiselle olennolle antaa. Toisekseen talous, jos sellaista haluaa, sen konkreettisena perustana pitäisi nimenomaan olla pyrkimys Aurinkoenergiaan. Nythän talous on rakennettu luonnon riistoa silmällä pitäen, jossa rikkaat rikastuvat, ja köyhät köyhtyvät.

Yhtä kaikki, tavalliset maajussit jatkaa kyntötöitään. Arkhimedes, Newton, Gauss. Joskus vuonna 3000 kyntöhommat saadaan valmiiksi, ja silloin köyhät ja rikkaat vaihtavat näkemykset kerralla. Köyhillä on rajaton energia, eikä siihen rikkaita tarvita.

Niin, että köyhälle riittää kynä ja paperi, jolla voi luoda sellaisen kauneuden, johon kaikki rikkaat ja huippuoppineet yhdessä eivät pystyisi kuuna päivänä. Eivät, koska he ovat valehtelijoita. Minun unelmat ovat aina olleet minun todellisuus.

[code:3bkruk89]#include
#include
#include

class reaali
{
public:

#define KOKO 4
double e[KOKO];

reaali(void);
~reaali(void);

reaali(double);
reaali(double, double);
reaali(double, double, double);
reaali(double, double, double, double);
};

reaali::~reaali(void)
{
}

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

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

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

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

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

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

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

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

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

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

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

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

for (int i=0, j=0; i
t[i]=(double)(t[j]-t[j+1]);
return *(reaali*)t;
}

reaali operator*(double k, reaali b)
{
for (int i=0; i
b.e[i]*=(double)k;
return b;
}

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

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

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

return x/y.e[0];
}

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

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

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

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

reaali asin(reaali x)
{
reaali sum=x;
reaali 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;
}

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

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

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

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

for (int k=2; k<160; k++)
for (int j=0; j<256; j++)
{
reaali 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-10))
{
r2=3141592653589793238462643383279;
break;
}
}
return x;
}

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

sum=sum+xx;

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

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

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

/////////////////////////////////////
// reaali_rnd palautaa satunnaisen //
// reaaliluvun funktioiden //
// testaamiseen. //
/////////////////////////////////////
reaali reaali_rnd(void)
{
reaali x;
for (int i=0; i
x.e[i]=drand();
return x;
}

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

class kompleksi
{
public:

reaali e[KOKO];
kompleksi(void);
~kompleksi(void);
kompleksi(double);

kompleksi(reaali);
kompleksi(reaali, reaali);
kompleksi(reaali, reaali, reaali);
kompleksi(reaali, reaali, reaali, reaali);
};

kompleksi::~kompleksi(void)
{
}

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

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

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

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

kompleksi::kompleksi(reaali a, reaali b, reaali c)
{
memset(this, 0, sizeof(kompleksi));
e[0]=a, e[1]=b, e[2]=c;
}

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

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

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

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

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

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

kompleksi operator*(reaali k, kompleksi x)
{
for (int i=0; i
x.e[i]=x.e[i]*k;
return x;
}

kompleksi operator*(kompleksi x, reaali k)
{
return k*x;
}

kompleksi operator*(kompleksi a, kompleksi b)
{
int *KantavektoreidenTulot(void);
int *R=KantavektoreidenTulot();
int i, j, n=(int)KOKO*(int)2;

reaali e00(0.00);
reaali x[KOKO*2];
reaali y[KOKO*2];
reaali t[KOKO*2];

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

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

for (i=j=0; i
t[i]=(reaali)(t[j]-t[j+1]);
return *(kompleksi*) t;
}

void RekursioKantavektoreidenTulot(int *R, int n)
{
int I=0, J=n-1, i;
int X=n, Y=J+n, j;
int k=KOKO*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 < KOKO*2)
{
RekursioKantavektoreidenTulot(R, n+n);
}
}

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

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

kompleksi operator/(kompleksi x, reaali k)
{
for (int i=0; i
x.e[i]=x.e[i]/k;
return x;
}

kompleksi operator/(kompleksi x, kompleksi y)
{
kompleksi z;
void print(kompleksi);
for (int i, n=KOKO; n>=2; n/=2)
{
for (z=y, i=n/2; i
z.e[i] = -z.e[i];
x=x*z; y=y*z;
}

return x/y.e[0];
}

kompleksi operator/(double k, kompleksi x)
{
return kompleksi(k)/x;
}

kompleksi operator/(reaali k, kompleksi x)
{
return kompleksi(k)/x;
}

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

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

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

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

kompleksi asin(kompleksi x)
{
kompleksi sum=x;
kompleksi 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;
}

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

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

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

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

for (int k=2; k<160; k++)
for (int j=0; j<256; j++)
{
kompleksi 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-10))
{
r2=3141592653589793238462643383279;
break;
}
}
return x;
}

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

sum=sum+xx;

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

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

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

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

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

////////////////////////////////////////
// kompleksi_rnd palautaa satunnaisen //
// kompleksiluvun funktioiden //
// testaamiseen. //
////////////////////////////////////////
kompleksi kompleksi_rnd(void)
{
kompleksi x;
for (int i=0; i
x.e[i]=reaali_rnd();
return x;
}

void print(kompleksi x)
{
for (int i=0; i
{
printf("{");
for (int j=0; j
printf("%0.7f ", x.e[i].e[j]);
printf("}\n");
}
printf("\n");
}

int main(void)
{
for (int testi=0; testi<256; testi++)
{
kompleksi x=kompleksi_rnd();
kompleksi y=kompleksi_rnd();
kompleksi e(2.71828182845904523536);

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

print(x*y-y*x);

kompleksi 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));

x.e[0]=reaali(0.0);
z=pow(e, x);
printf("%25.20f\n", abs(z));

printf("**************************************\n");
}
return 0;
}

[/code:3bkruk89]

Vierailija

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

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

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

for (int i=0, j=0; i
t[i]=(double)(t[j]-t[j+1]);
return *(reaali*)t;
[/code:23z3w1zm]

x,y ja t talukoiden parittomat jäsenet alustetaan ensimmäisesä for-lausekkeessa nollaksi. Tämä johtaa siihen että lausekeen t[i^j]+=x*y[j]; suorittisen jälkeen kaikilla i ja j kombinaatioilla jättää parittomat t taulukon jäsenet nollaksi (pariton i tai j on 0). Tämä taas johtaa siihen että vähennyslaskulla lausekkeessa t=(double)(t[j]-t[j+1]); on hyvin vähän merkitystä koska t[j+1] on aina nolla. Miksi ei alunperin jo käytetä KOKO kokoisia talukoita, miksi KOKO*2?

En ole vielä tarkistanut onko kompleksi lukujen kertolaskussa samanlainen omituisuus. Siinä pistää silmään miksi kantavektoritulo talukko R lasketaan rekursiivisesti jokaisessa kertolaskussa uudelleen, miksei vain kerran koska se on vakiotaulukko käytetylle KOKO vakiolle.

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

eli

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

R on oikeastaan vain indeksointitaulukko.

Voisiko R:n tulostaa auki, sisältääkö numerot 0...63 "maagisessa" järjestyksessä?

Sivut

Uusimmat

Suosituimmat