Seuraa 
Viestejä447
Liittynyt4.1.2016

No niin, aloitetaan alusta puhtaalta sivulta. Tuli mieleen, että joillakin voi olla heikkoa ymmärtää C:n kompaktisuutta ja C++ -olioita. Käyn ne läpi perustasolla, jolloin jokainen voi ymmärtää C++ -olioita ja C:tä

C++ -oliot sopivat matemaattisten struktuurien esittämiseen paremmin kuin hyvin. C:n vahvuus on siinä, että se on ensinnäkin strukturoitu, ja funktiot voivat palauttaa kaikkea maan ja taivaan väliltä. Myös funktioiden input voi olla täysin mielivaltainen.

C:ssä on mukana erittäin tarkka liukuluku, long double, joka on 10 tavua pitkä. Tälle voidaan luoda lyhemmin kirjoitettava alias:

typedef long double lreal;

Nyt lreal <=> long double

Koodissa voi nyt kirjoittaa esim:

1) lreal a=7;

2) lreal b[70];

a saa arvon 7.0000000000000000000000000000000000000000000000

kohdassa (2) b on 70 alkiota sisältävä yksiulotteinen taulukko.

RGB-värit mahtuvat kolmeulotteiseen taulukkoon:

3) rgb[256][256][256]

Joskus voi olla tarvetta esim. liu'uttaa värejä.

Se siitä. C:n koodausohjeet mahtuvat kahdelle A4:lle, mutta ohjeitten klaaraaminen tarvitsee C:n perustiedot. C ei sinällään sisällä kovinkaan montaa funktiota (käytännössä ei yhtään). Mutta C sisältää lukemattomia kirjastoja, joista löytyy tarpeellinen funktio melkein kaikkeen. Kirjasto esitellään seuraavasti:

#include

#include

Em. kirjastoilla pääsee jo pitkälle. math.h sisältää kaikki funktiot sinistä logaritmiin. stdio.h pitää sisällään mm. kaikki printtaamiseen liittyvät funktiot.

Mutta summa summarum: Laitan complex2d -olion koodin pieninä paloina, ja kerron jokaisesta lyhyestä funktiosta, mitä se tekee.

Sivut

Kommentit (37)

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Öläskiperse kirjoitti:

#include

#include

Jaa, foorumin käyttöliittymä bugittaa siinäkin, jos < ja > -merkkien väliin on kirjoitettu jotain, käyttöliittymä poistaa merkit ja tekstin sen välillä. Sovitaan, että < korvataan merkillä v_ ja > korvataan merkillä _u, siis:

#include v_math.h_u

#include v_stdio.h_u

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Olen joskus koodannut koodinsiivoajan, jolla koodin formaattia voi helposti muokata. Ainakin oma Borland C++ 5.02 antaa laittaa rivinumerot, eikä heitä herjaa niistä. Rivinumeroiden perusteella on helppo kommentoida, mitä jossain kohdassa koodia tapahtuu.

Mutta mitä riviä/rivejä pitäisi kommentoida, jos ei ole kysymyksiä? No, rivillä 35-37 real2d-olion data on laitettu privaatiksi, vaikka se voisi olla yleiselläkin puolella. Yleisessä osiossa on olion muodostimet sekä alkeisoperaatiot.

Rivillä 5 long double saa aliaksen lreal. Rivillä 6 on makro, joka kastaa annetun luvun lreal:iksi. Esim. 7 on int luku, mutta makro lr(7) antaa luvun arvoksi 7.000000000000000000000000000000000000000000000000

/*0001*/
/*0002*/ #include <stdio.h>
/*0003*/ #include <conio.h>
/*0004*/
/*0005*/ typedef long double lreal;
/*0006*/ #define lr(cx) (lreal)(cx)
/*0007*/
/*0008*/ class real2d
/*0009*/ {
/*0010*/    public:
/*0011*/
/*0012*/    real2d(void);
/*0013*/
/*0014*/    real2d(int);
/*0015*/    real2d(int, int);
/*0016*/
/*0017*/    real2d(lreal);
/*0018*/    real2d(lreal, lreal);
/*0019*/
/*0020*/    real2d(double);
/*0021*/    real2d(double, double);
/*0022*/
/*0023*/    friend real2d operator-(real2d);
/*0024*/    friend real2d operator+(real2d, real2d);
/*0025*/    friend real2d operator-(real2d, real2d);
/*0026*/
/*0027*/    friend real2d operator*(real2d, real2d);
/*0028*/    friend real2d operator*(double, real2d);
/*0029*/    friend real2d operator*(real2d, double);
/*0030*/
/*0031*/    friend real2d operator/(real2d, real2d);
/*0032*/    friend real2d operator/(double, real2d);
/*0033*/    friend real2d operator/(real2d, double);
/*0034*/
/*0035*/    private:
/*0036*/
/*0037*/    lreal f[2];
/*0038*/ };
/*0039*/
/*0040*/ void mem0x00set(void *ptr, int n)
/*0041*/ {
/*0042*/    char *c=(char*)ptr;
/*0043*/    for (--n; n>=0; n--)
/*0044*/    c[n] = (char) 0x00;
/*0045*/ }
/*0046*/
/*0047*/ real2d::real2d(void)
/*0048*/ {
/*0049*/    mem0x00set(this, sizeof(real2d));
/*0050*/ }
/*0051*/
/*0052*/ real2d::real2d(int a)
/*0053*/ {
/*0054*/    f[0]=a; f[1]=0;
/*0055*/ }
/*0056*/
/*0057*/ real2d::real2d(lreal a)
/*0058*/ {
/*0059*/    f[0]=a; f[1]=0;
/*0060*/ }
/*0061*/
/*0062*/ real2d::real2d(double a)
/*0063*/ {
/*0064*/    f[0]=a; f[1]=0;
/*0065*/ }
/*0066*/
/*0067*/ real2d::real2d(int a, int b)
/*0068*/ {
/*0069*/    f[0]=a; f[1]=b;
/*0070*/ }
/*0071*/
/*0072*/ real2d::real2d(lreal a, lreal b)
/*0073*/ {
/*0074*/    f[0]=a; f[1]=b;
/*0075*/ }
/*0076*/
/*0077*/ real2d::real2d(double a, double b)
/*0078*/ {
/*0079*/    f[0]=a; f[1]=b;
/*0080*/ }
/*0081*/
/*0082*/ #pragma argsused
/*0083*/ int main(int mux, char* none[])
/*0084*/ {
/*0085*/    return 1;
/*0086*/ }
/*0087*/

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Tulee luettavammaksi, jos rivinumeroiden ja koodin väliin lykkää yhden tabulaattorin.

Alkeisoperaatioissa ei ole paljon sanomista. Vaikein on jakolasku, jossa tarvitaan yhtälöryhmän ratkaisua - laitan sen koodin seuraavaan viestiin.

No voi perse, viestissä liian monta merkkiä. Kyllä on vituksi väännetty tämä foorumin käyttöliittymä. Koodia ei voi viestittää, kuin parin funktion / rivin erissä. Aloitetaan siis alusta. Niin, että uusi koodinpätkä tulee aina edellisen koodin lopun ja mainin välille.

Ehkäpä tämä nyt kolmannella aloituksella alkaa wörkkimään... EI SITTENKÄÄN, edelleen liikaa merkkejä. Jos Jukka Ruukki lukee tämän viestiin, niin oletko tyytyväinen, kun foorumilaiset eivät ole tyytyväisiä?

TÄMÄ FOORUMIKÄYTTÖLIITTYMÄ ON SEKAISIN, JA KAIKKI VERSIOT OVAT LIIAN PITKIÄ/LIIAN PALJON MERKKEJÄ. HAISTAKAA PITKÄ PASKA NE, JOTKA TÄMÄN PASKAN OVAT VÄÄNTÄNEET!

/*0001*/
/*0002*/    #include <stdio.h>
/*0003*/    #include <conio.h>
/*0004*/
/*0005*/    typedef long double lreal;
/*0006*/    #define lr(cx) (lreal)(cx)
/*0007*/
/*0008*/    class real2d
/*0009*/    {
/*0010*/       public:
/*0011*/
/*0012*/       real2d(void);
/*0013*/
/*0014*/       real2d(int);
/*0015*/       real2d(int, int);
/*0016*/
/*0017*/       real2d(lreal);
/*0018*/       real2d(lreal, lreal);
/*0019*/
/*0020*/       real2d(double);
/*0021*/       real2d(double, double);
/*0022*/
/*0023*/       friend double abs(real2d);
/*0024*/       friend double abs(double);
/*0025*/       friend  lreal abs( lreal);
/*0026*/
/*0027*/       friend void print(real2d);
/*0028*/       friend double sgn(real2d);
/*0029*/       friend real2d sqrt(real2d);
/*0030*/
/*0031*/       friend real2d operator-(real2d);
/*0032*/       friend real2d operator+(real2d, real2d);
/*0033*/       friend real2d operator-(real2d, real2d);
/*0034*/
/*0035*/       friend real2d operator*(real2d, real2d);
/*0036*/       friend real2d operator*(double, real2d);
/*0037*/       friend real2d operator*(real2d, double);
/*0038*/
/*0039*/       friend real2d operator/(real2d, real2d);
/*0040*/       friend real2d operator/(double, real2d);
/*0041*/       friend real2d operator/(real2d, double);
/*0042*/
/*0043*/       /* mgn = luvun suuruus */
/*0044*/       friend double mgn(real2d);
/*0045*/    &n

JPI
Seuraa 
Viestejä24813
Liittynyt5.12.2012

Eikö ideaasi voi esittää ilman koodia? Sinähän puhuit keksimästäsi uudenlaisesta kunnasta va mitä?
Laita siis matikkaa näkyviin, ei siihen koodia tarvii.

3³+4³+5³=6³

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

JPI kirjoitti:

Eikö ideaasi voi esittää ilman koodia? Sinähän puhuit keksimästäsi uudenlaisesta kunnasta va mitä?
Laita siis matikkaa näkyviin, ei siihen koodia tarvii.

No ei se idea ole. Enemmänkin vahva intuitio (fraktaaleista), että sarjat on pakko olla yhtenäisiä sapluunoita. Jos jokin algebrallinen struktuuri toimii loogisesti sarjoissa, struktuuri on tosi. Matemaattisten funktioiden generoiminen onnistuu sarjoilla, jotka puolestaan generoituvat alkeisoperaatioilla.

Alkeisoperaatioiden esittäminen vaatii koodia. C++:lla alkeisoperaatioiden esittäminen on simppeliä. Yhteen- ja vähennyslaskun voi esittää ilman koodia, esim:

(a, b) + (c, d) = (a+c, b+d)

Mutta kertolasku, ja varsinkin jakolasku on sellainen kompleksi, ettei sitä voi simppelisti esittää muuta kuin koodilla mitä tapahtuu, esim:

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

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

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

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

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

Koodi joka tutkii algebrallisia struktuureja soveltaen niitä ensin sarjoihin - löytää ohjelman tehosta riippuen ratkaisun. Tällainen ohjelma sisältää paljon kovakoodattua informaatiota sarjoista ja yleensä algebrasta. Minulta kului ohjelman tekoon 13 vuotta.

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Ja tuossa ruudun vasemmassa yläkulmassa pelaavat venäjä vs. saksa. Plaah, pitää laittaa volyymit mahdollisimman pieniksi, koska pelin tulos on venäjälle voitto. Vittuako sellaista selvää tapausta niin silmät tapilla jaksaisi kyylätä.

NytRiitti
Seuraa 
Viestejä2540
Liittynyt12.9.2012

Totta, en minäkään muista mitä mun 13 vuotta sitten koodaamat ohelmanpätkät tekee, ei oo edes heikkoa intuutiota. Kerran mun koodaaman pätkän kesäheikki koodas täysin uusiks modernimmalla kielellä (sekin kieli on jo nyt antiikkia).

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Tuossa on vielä jakolasku, joka on kertolaskun käänteisoperaatio ja päinvastoin:

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

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

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

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

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

   // gsolve ratkaisee lineaarisen yhtaloryhman
   // Gaussin eliminointimenetelmalla...
   int gsolve(lreal*, lreal*, int);
   gsolve(X, (lreal*)K, 0x04);
   for (int i=0; i<2; i++)
   X[i]=X[i*2]-X[i*2+1];
   return real2d(X);
}

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

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

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

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

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

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

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

   return 1;
}

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

o_turunen
Seuraa 
Viestejä11852
Liittynyt16.3.2005

Paljon selvempää ja havainnollisempaa olisi, jos esittäisit asiasi assemblerilla, niin saisi edes jotain tolkkua.

Korant: Oikea fysiikka on oikeampaa kuin sinun klassinen mekaniikkasi. Jos olet eri mieltä kanssani olet ilman muuta väärässä.

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

o_turunen kirjoitti:

Paljon selvempää ja havainnollisempaa olisi, jos esittäisit asiasi assemblerilla, niin saisi edes jotain tolkkua.

Assembler ei enää kiinnosta, koska läppäriin saa Borland C++ 5.02 ilmaiseksi. Kääntäjä tuottaa paljon tehokkaampaa koodia C:llä kuin että alkaisi itse vääntämään rautalangasta. Kääntäjä tuottaa myös *.asm -tekstitiedoston, jota voi tarvittaessa muokata, paitsi että optimoitavaa ei löydy.

Eri asia on sulautetut järjestelmät, joiden ohessa toimitetaan poikkeuksetta aivan paska kääntäjä, jolloin suoraan assemblerilla kirjoitettu koodi voi olla satakertaa nopeampaa. Olen törmännyt tähän silloin, kun tein koodia puhelimiin ja YTV:n koodiin - joka yllätys yllätys on rankattu Tiede-lehdessä maailman monimutkaisimmaksi hiotuksi timantiksi.

(Syy on vähän YTV:säkin. Joka päivä haluttiin kymmentä uutta ominaisuutta, ja niitä koodattiin. Lopulta koodia ei hallinut enää erkkikään. BIOS oli annettu yhden seniorin toimeksi, ja se oli kirjoitettu kokonaan assemblerilla. BIOS:sista löytyi sylttytehdas tosi harvoin.)

C on pitänyt pintansa yli 13 vuotta, C modifioitiin B-kielestä, mutta en ole niin tarkasti perehtynyt C:n historiaan. Minulla on ollut sama kääntäjä käytössä pian täydet 30 vuosikymmentä, eikä mikään ole muuttunut, paitsi jotain pieniä trimmauksia C:hen on tehty. Mm. C++ käännetään ensin C:lle, ja vasta sitten ajettavaksi ohjelmaksi. Jotkin tahot eivät pidä C++ kääntäjää aitona olio-kielenä.

Mutta minulle on tärkeää, että C++:lla voi pyöritellä algebrallisia struktuureita helposti ja vaivattomasti.

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Jokohan nyt mahtuisi, kun rivejä tiivisti. real2d -olion data (f[2]) on siirretty yleiseen osastoon. Nyt dataan voi osoittaa samoin, kuin C:n struct määrittelyyn. Eipä tuosta oliosta ole paljon sanomista, koska C kommentoi itse itsensä. Vastaan kyllä mielelläni myös kysymyksiin.

/*0001*/
/*0002*/    #include <stdio.h>
/*0003*/    #include <conio.h>
/*0004*/
/*0005*/    typedef long double lreal;
/*0006*/    #define lr(cx) (lreal)(cx)
/*0007*/
/*0008*/    class real2d
/*0009*/    {
/*0010*/       public:
/*0011*/
/*0012*/       lreal f[2];
/*0013*/
/*0014*/       real2d(void);
/*0015*/       ~real2d(void);
/*0016*/
/*0017*/       real2d(int);
/*0018*/       real2d(int *);
/*0019*/       real2d(int, int);
/*0020*/
/*0021*/       real2d(lreal);
/*0022*/       real2d(lreal *);
/*0023*/       real2d(lreal, lreal);
/*0024*/
/*0025*/       real2d(double);
/*0026*/       real2d(double *);
/*0027*/       real2d(double, double);
/*0028*/
/*0029*/       friend void print(real2d);
/*0030*/       friend double abs(real2d);
/*0031*/       friend  lreal abs( lreal);
/*0032*/       friend double abs(double);
/*0033*/       friend double sgn(real2d);
/*0034*/       friend real2d sqrt(real2d);
/*0035*/
/*0036*/       friend real2d operator-(real2d);
/*0037*/       friend real2d operator+(real2d, real2d);
/*0038*/       friend real2d operator-(real2d, real2d);
/*0039*/
/*0040*/       friend real2d operator*(real2d, real2d);
/*0041*/       friend real2d operator*(double, real2d);
/*0042*/       friend real2d operator*(real2d, double);
/*0043*/
/*0044*/       friend real2d operator/(real2d, real2d);
/*0045*/       friend real2d operator/(double, real2d);
/*0046*/       friend real2d operator/(real2d, double);
/*0047*/
/*0048*/       /* mgn = luvun suuruus */
/*0049*/       friend double mgn(real2d);
/*0050*/       friend real2d ln(real2d);
/*0051*/       friend real2d exp(real2d);
/*0052*/       friend real2d sin(real2d);
/*0053*/       friend real2d cos(real2d);
/*0054*/       friend real2d arcsin(real2d);
/*0055*/       friend real2d arccos(real2d);
/*0056*/       friend real2d pow(real2d, int);
/*0057*/       friend real2d pow(real2d, double);
/*0058*/       friend real2d pow(real2d, real2d);
/*0059*/       friend void mem0x0set(void*, int);
/*0060*/    };
/*0061*/

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

real2d -olion muistin nollaus ja muodostimet:

/*0062*/    void mem0x0set(void *ptr, int n)
/*0063*/    {
/*0064*/       char *c=(char*)ptr;
/*0065*/       for (--n; n>=0; n--)
/*0066*/       c[n] = (char) 0x00;
/*0067*/    }
/*0068*/
/*0069*/    real2d::real2d(void)
/*0070*/    {
/*0071*/       mem0x0set(this, sizeof(real2d));
/*0072*/    }
/*0073*/
/*0074*/    real2d::~real2d(void)
/*0075*/    {
/*0076*/    }
/*0077*/
/*0078*/    real2d::real2d(int a)
/*0079*/    {
/*0080*/       f[0]=a; f[1]=0;
/*0081*/    }
/*0082*/
/*0083*/    real2d::real2d(lreal a)
/*0084*/    {
/*0085*/       f[0]=a; f[1]=0;
/*0086*/    }
/*0087*/
/*0088*/    real2d::real2d(double a)
/*0089*/    {
/*0090*/       f[0]=a; f[1]=0;
/*0091*/    }
/*0092*/
/*0093*/    real2d::real2d(int *a)
/*0094*/    {
/*0095*/       f[0]=a[0]; f[1]=a[1];
/*0096*/    }
/*0097*/
/*0098*/    real2d::real2d(lreal *a)
/*0099*/    {
/*0100*/       f[0]=a[0]; f[1]=a[1];
/*0101*/    }
/*0102*/
/*0103*/    real2d::real2d(double *a)
/*0104*/    {
/*0105*/       f[0]=a[0]; f[1]=a[1];
/*0106*/    }
/*0107*/
/*0108*/    real2d::real2d(int a, int b)
/*0109*/    {
/*0110*/       f[0]=a; f[1]=b;
/*0111*/    }
/*0112*/
/*0113*/    real2d::real2d(lreal a, lreal b)
/*0114*/    {
/*0115*/       f[0]=a; f[1]=b;
/*0116*/    }
/*0117*/
/*0118*/    real2d::real2d(double a, double b)
/*0119*/    {
/*0120*/       f[0]=a; f[1]=b;
/*0121*/    }
/*0122*/

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Alkeisoperaatioita:

/*0123*/    lreal abs(lreal x)
/*0124*/    {
/*0125*/       return x<lr(0)? -x: x;
/*0126*/    }
/*0127*/
/*0128*/    real2d sqrt(real2d c)
/*0129*/    {
/*0130*/       real2d x=c;
/*0131*/       for (int i=0; i<64; i++)
/*0132*/       x = x - (x*x-c)/(2.0*x);
/*0133*/       return (x);
/*0134*/    }
/*0135*/
/*0136*/    real2d operator-(real2d a)
/*0137*/    {
/*0138*/       for (int i=0; i<2; i++)
/*0139*/       a.f[i]=-a.f[i];
/*0140*/       return a;
/*0141*/    }
/*0142*/
/*0143*/    real2d operator+(real2d a, real2d b)
/*0144*/    {
/*0145*/       for (int i=0; i<2; i++)
/*0146*/       a.f[i]+=b.f[i];
/*0147*/       return a;
/*0148*/    }
/*0149*/
/*0150*/    real2d operator-(real2d a, real2d b)
/*0151*/    {
/*0152*/       for (int i=0; i<2; i++)
/*0153*/       a.f[i]-=b.f[i];
/*0154*/       return a;
/*0155*/    }
/*0156*/

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Kertolasku suoritetaan kaksinkertaisessa taulukossa. Sijoitus toimitetaan riveillä 167-171. Seuraavana on kertolaskun suoritus riveillä 173-175. Hattu eli merkki ^ tarkoittaa C:ssä ehdoton tai eli xor-operaatio. Se määrää, mihin akselille ko. kertolasku sijoitetaan. Riveillä 177-179 suoritetaan redusointi:

/*0157*/    real2d operator*(real2d a, real2d b)
/*0158*/    {
/*0159*/       lreal x[4];
/*0160*/       lreal y[4];
/*0161*/       lreal t[4];
/*0162*/
/*0163*/       mem0x0set(x, sizeof(lreal)*4);
-/*0164*/       mem0x0set(y, sizeof(lreal)*4);
/*0165*/       mem0x0set(t, sizeof(lreal)*4);
/*0166*/
/*0167*/       for (int i=0; i<2; i++)
/*0168*/       {
/*0169*/          x[i*2]=a.f[i];
/*0170*/          y[i*2]=b.f[i];
/*0171*/       }
/*0172*/
/*0173*/       for (int i=0; i<4; i++)
/*0174*/       for (int j=0; j<4; j++)
/*0175*/       t[i^j]+=x[i]*y[j];
/*0176*/
/*0177*/       for (int i=0; i<2; i++)
/*0178*/       t[i]=t[i*2]-t[i*2+1];
/*0179*/       return real2d( t );
/*0180*/    }
/*0181*/
/*0182*/    real2d operator*(double k, real2d b)
/*0183*/    {
/*0184*/       real2d a(k);
/*0185*/       return a*b;
/*0186*/    }
/*0187*/
/*0188*/    real2d operator*(real2d a, double k)
/*0189*/    {
/*0190*/       real2d b(k);
/*0191*/       return a*b;
/*0192*/    }

Kyttääjä
Seuraa 
Viestejä447
Liittynyt4.1.2016

Edellisessä kertolaskukoodissa rivillä 164 on bugi. Kommentin eteen on jostain tullut - merkki.

Helppoa, kun viestejä ei tarvitse muokata enää lähettämisen jälkeen. Kun foorumikäyttöliittymän tekijät ovat näin idearikkaita ja taitavia, kannattaisi jo miettiä suurempia projekteja.

Sivut

Suosituimmat

Uusimmat

Uusimmat

Suosituimmat