View unanswered posts | View active topics It is currently Wed Jul 23, 2014 11:38 am






Reply to topic  [ 1 post ] 
1.40.3: Bug? **FATAL**:Compiler error. Failed to release tem 
Author Message
Guru
User avatar

Joined: Sat Mar 01, 2008 12:52 pm
Posts: 1030
Post 1.40.3: Bug? **FATAL**:Compiler error. Failed to release tem
with this procedure I get two errors:
Code:
void SetInputPattern(int i) // Inputs virtuell generiert
{
   int j, n;

   for (j=0; j<L0;j++)
  {
     for (n=0; n<ni; n++)
    {
       Neuron0[j].in[n]= (((i & (1<<n))>0) ? 1 : 0) ; // <--- Line 285
       
    }
  }
}

285: **FATAL**:Compiler error. Failed to release temporary registers 1(1) to 2. Pass 'Assign Addresses'
285: **FATAL**:Compiler error. Failed to release temporary registers 2(2) to 3. Pass 'Emit Code'




a hint for the develobuggers:
this code is fine:
Code:
void SetInputPattern(int i) // Inputs virtuell generiert
{
   int j, n;

   for (j=0; j<L0;j++)
  {
     for (n=0; n<ni; n++)
    {
       Neuron0[j].in[n]= (i & (1<<n) )/(1<<n)  ;
    }
  }
}


is the code faulty or the compiler?
This is the complete code (killer code :twisted: ):
Code:
// Lernfaehiges 2-schichtiges Neuronales Netz
// Backpropagation Netz mit 3 Sensor-Eingaengen (Touch an S1, S2, S3)
// an 3 verdeckten Neurons
// dann 2 Ausgabe-Neurons mit 2 Outputs (Anzeige auf dem Display)
// (c) H. W. 2008
   string Version="0.435 beta";


#define printXY nxtDisplayStringAt
#define println nxtDisplayTextLine


//**********************************************************************
// Basisdeklarationen fuer Neuronale Netze
//**********************************************************************


const int L0 =  3;    // max. Neurons in Schicht (Layer) 0 (Schicht fuer Inputs)
const int L1 =  2;    // max. Neurons in Schicht (Layer) 1 (Ausgabe Schicht bei 2-schichtigen)
const int L2 =  1;    // max. Neurons in Schicht (Layer) 2
const int L3 =  1;    // max. Neurons in Schicht (Layer) 3


const int ni = 3;      // max. Dendriten-Eingaenge (Zaehler ab 0)
float lf     = 0.6;    // Lern-Faktor

int key;               // gedrueckte NXT-Taste
string MenuText="";    // Menue-Steuerung

float sollOut=0;


//**********************************************************************
// Neuron-Struktur (vereinfachte Version)
//**********************************************************************

typedef struct{
   float in[ni];    // Einzel-Inputs (Dendriten)
   float w[ni];     // Einzel-Wichtungen (jedes Dendriten)
   float net;       // totaler Input
   float th;        // Schwellenwert (threshold)
   float d;         // delta=Fehlersignal
   float out;       // Output (Axon): z.B. 0 oder 1
} tNeuron;

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

tNeuron Neuron0[L0];  // Neurons-Schicht 0  (Schicht fuer Inputs)
tNeuron Neuron1[L1];  // Neurons-Schicht 1  (Ausgabe Schicht bei 2-schichtigen)
tNeuron Neuron2[L2];  // Neurons-Schicht 2
tNeuron Neuron3[L3];  // Neurons-Schicht 3


//**********************************************************************
//  mathematische Hilfsfunktionen
//**********************************************************************


float tanh(float x)  // Tangens hyperbolicus
{
   float e2x;
   e2x=exp(2*x);
   return((e2x-1)/(e2x+1));
}

//**********************************************************************
// Ein-/ Ausgabefunktionen (Tatstatur, Display)
//**********************************************************************

int buttonPressed(){

  TButtons nBtn;
  nNxtExitClicks=4; // gegen versehentliches Druecken

  nBtn = nNxtButtonPressed; // check for button press
   switch (nBtn)     {
      case kLeftButton: {
           return 1;   break;     }

        case kEnterButton: {
             return 2;   break;     }

        case kRightButton: {
             return 3;   break;     }

        case kExitButton: {
             return 4;   break;     }

        default: {
             return 0;   break;     }
   }
   return 0;
}

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

int getkey() {
   int k, buf;

   k=buttonPressed();
   buf=buttonPressed();
  while (buf!=0)
  { buf=buttonPressed(); }
  return k;
}

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

task DisplayValues(){
  int i;  // input number  = Sensoren an verdeckter Schicht
  int j;  // neuron number = Outputs an Ausgabe-Schicht

   while(true) {

    printXY( 0, 55, " out(0) | out(1)");
    printXY(48, 47, "|");
    printXY(48, 39, "|");
    printXY(48, 31, "|");

    printXY( 0, 63, "IN:");                        //  OBEN
    printXY(15, 63, "%2.0f", Neuron0[0].in[0]);    //  Inputs nebeneinander
    printXY(30, 63, "%2.0f", Neuron0[0].in[1]);
    printXY(45, 63, "%2.0f", Neuron0[0].in[2]);
    //printXY(60, 63, "%2.0f", Neuron0[0].in[3]);

                                                   //  LINKER BEREICH
    printXY(00,    47, "%3.1f", Neuron1[0].w[0]);  //  Wichtungen Ausgabe-Schicht
      printXY(12,    39, "%3.1f", Neuron1[0].w[1]);  //  (Neuron 0)
      printXY(24,    47, "%3.1f", Neuron1[0].w[2]);

                                                     //  RECHTER BEREICH
      printXY(00+53, 47, "%3.1f", Neuron1[1].w[0]);  //  Wichtungen Ausgabe-Schicht
      printXY(12+53, 39, "%3.1f", Neuron1[1].w[1]);  //  (Neuron 1)
    printXY(24+53, 47, "%3.1f", Neuron1[1].w[2]);

                                                   //  MITTE-UNTEN LINKS
    printXY(18,    31, "%5.2f", Neuron0[0].th);      //  Schwellwert verdeckte Schicht

    printXY( 0, 31, "th=");                        //  MITTE-UNTEN RECHTS
      printXY(18+53, 31, "%5.2f", Neuron1[0].th);    //  Schwellwert Ausgabe-Schicht

      printXY( 0, 23, "OUT");                        //  UNTEN RECHTS (unter Ausgabeschicht)
      printXY(48,    23, "%3.1f", Neuron1[0].out);   //  1. Output
      printXY(48+25, 23, "%3.1f", Neuron1[1].out);   //  2. Output


                                                   //  GANZ UNTEN
    println(7, "%s", MenuText);                    //  Menue-Zeile fuer Tastatur-Steuerung


  }
  return;
}

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

void Pause() {
   while(true) wait1Msec(50);
}


//**********************************************************************
// File I/O
//**********************************************************************
const string sFileName = "Memory.dat";

TFileIOResult nIoResult;
TFileHandle   fHandle;

int   nFileSize     = (L0 + L1 + L2 + L3 +4 )*100;


void SaveMemory()
{
   int i, j;

   CloseAllHandles(nIoResult);
   println(6,"%s","Save Memory...");
   wait1Msec(500);
   PlaySound(soundBeepBeep);
   wait1Msec(11);

   Delete(sFileName, nIoResult);

  OpenWrite(fHandle, nIoResult, sFileName, nFileSize);
  if (nIoResult==0) {
    eraseDisplay();

    for (j=0;j<L0;j++)   {
      for (i=0; i<ni;i++)
      {   WriteFloat (fHandle, nIoResult, Neuron0[j].w[i]); }
        WriteFloat (fHandle, nIoResult, Neuron0[j].th);     }

    for (j=0;j<L1;j++)   {
      for (i=0; i<ni;i++)
      {   WriteFloat (fHandle, nIoResult, Neuron1[j].w[i]); }
        WriteFloat (fHandle, nIoResult, Neuron1[j].th);     }


    Close(fHandle, nIoResult);
    if (nIoResult==0) {
       PlaySound(soundUpwardTones);
       println(6,"%s","Save Memory: OK"); }
    else {
       PlaySound(soundException);
       println(6,"%s","Save Memory: ERROR"); }
  }
  else PlaySound(soundDownwardTones);

}

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

void RecallMemory()
{
  int i, j;
   println(6,"%s","Recall Memory");
  CloseAllHandles(nIoResult);
   wait1Msec(500);
   PlaySound(soundBeepBeep);
   wait1Msec(11);

   OpenRead(fHandle, nIoResult, sFileName, nFileSize);
  if (nIoResult==0) {

  for (j=0;j<L0;j++) {
     for (i=0; i<ni;i++)
     { ReadFloat (fHandle, nIoResult, Neuron0[j].w[i]); }
       ReadFloat (fHandle, nIoResult, Neuron0[j].th);     }

  for (j=0;j<L1;j++) {
     for (i=0; i<ni;i++)
     { ReadFloat (fHandle, nIoResult, Neuron1[j].w[i]); }
       ReadFloat (fHandle, nIoResult, Neuron1[j].th);     }


    Close(fHandle, nIoResult);
    if (nIoResult==0) PlaySound(soundUpwardTones);
    else {
       PlaySound(soundException);
       println(6,"%s","Recall: ERROR"); }
  }
  else PlaySound(soundDownwardTones);
  eraseDisplay();

}


//**********************************************************************
// Funktionen des neuronalen Netzes
//**********************************************************************




//**********************************************************************
// Inputs
//**********************************************************************

task RefreshInputLayer(){  // Inputs aus Sensorwerten
int i, j;
  while(true){
  for (j=0; j<L0; j++) {   // alle Inputs an alle Eingangs-Neuronen
    for (i=0; i<ni; i++)   {
      Neuron0[j].in[i]=(float)SensorValue(i);
      }
    }
  }
  return;
}

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




void SetInputPattern(int i) // Inputs virtuell generiert
{
   int j, n;

   for (j=0; j<L0;j++)
  {
     for (n=0; n<ni; n++)
    {
       Neuron0[j].in[n]= (((i & (1<<n))>0) ? 1 : 0) ;
       //(i & (1<<n) )/(1<<n)  ;
    }
  }
}




//**********************************************************************
// Propagierungsfunktionen: Eingaenge gewichtet aufsummieren (in -> net)
//**********************************************************************

void netPropag(tNeuron &neur){      // Propagierungsfunktion 1
  int i=0;                          // kalkuliert den Gesamt-Input (net)
  float s=0;

  for(i=0;i<ni;i++){
     s+= (neur.in[i]*neur.w[i]);     // gewichtete Summe
  }
  neur.net=s;
}

void netPropagThr(tNeuron &neur){   // Propagierungsfunktion 2
  int i=0;                          // kalkuliert den Gesamt-Input (net)
  float s=0;                        // und beruecksichtigt Schwellwert

  for(i=0;i<ni;i++){
     s+= (neur.in[i]*neur.w[i]);     // gewichtete Summe
  }
  neur.net=s-neur.th;               // abzueglich Schwellwert
}

//**********************************************************************
// Aktivierungsfunktionen inkl. Ausgabe (net -> act -> out)
//**********************************************************************


void act_01(tNeuron &neur){         // Aktivierungsfunktion 1 T1: x -> [0; +1]
   if (neur.net>=0)                  // 0-1-Schwellwertfunktion
      {neur.out=1;}                  // Fkt.-Wert: 0 oder 1
   else {neur.out=0;}
}

void actIdent(tNeuron &neur){       // Aktivierungsfunktion 2 T2: x -> x
   neur.out=neur.net;                // Identitaets-Funktion
}                                   // Fkt-Wert: Identitaet


void actFermi(tNeuron &neur){       // Aktivierungsfunktion 3 T3: x -> [0; +1]
   float val;                       // Fermi-Fkt. (Logistisch, differenzierbar)
   float c=3.0;                     // c= Steilheit, bei c=1: flach,
  val= (1/(1+(exp(-c*neur.net))));  // c=10: Sprung zwischen x E [-0.1; +0.1]
  neur.out=val;
}

void actTanH(tNeuron &neur){        // Aktivierungsfunktion 4 T4: x -> [-1; +1]
   float val;                       // Tangens Hyperbolicus, differenzierbar
   float c=2.0;                     // c= Steilheit, bei c=1: flach
  val= tanh(c*neur.net);            // c=3: Sprung zwischen x E [-0.1; +0.1]
  neur.out=val;
}



//**********************************************************************
// Reset / Init
//**********************************************************************

void ResetNeuron(tNeuron &neur, int rand){ // alles auf Null bzw. randomisiert
   int i, j;

  for (j=0; j<L0;j++) {
       for (i=0; i<ni;i++)
       {   Neuron0[j].in[i]=0;
    }
  }

   for (i=0; i<ni; i++) {
      neur.in[i]=0;                   // Einzel-Input (Dendrit)
     if (rand==0) {neur.w[i]=0;}     // Einzel-Wichtung (Dendrit)=0
      else
      neur.w[i]=0.0+random(5)*0.2;   // Einzel-Wichtung (Dendrit) randomomisiert

   }
   neur.net=0;                       // totaler Input
   if (rand==0) {neur.th=0;}         // Schwellenwert (threshold)=0
   else
   neur.th=0.0+random(3)*0.2;        // Schwellenwert (threshold) randomomisiert

   neur.out=0;                       // errechneter Aktivierungswert=Output
   }

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

void InitAllNeurons(){             // alle Netz-Neurons resetten
   int j;                           // (0 oder randomisiert)

  for (j=0; j<L0; j++) {           // Neuron-Schicht 0
        ResetNeuron(Neuron0[j],1);}

  for (j=0; j<L1; j++) {           // Neuron-Schicht 1
        ResetNeuron(Neuron1[j],1);}

  for (j=0; j<L2; j++) {           // Neuron-Schicht 2
        ResetNeuron(Neuron2[j],1);}

  for (j=0; j<L3; j++) {           // Neuron-Schicht 3
        ResetNeuron(Neuron3[j],1);}
}

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

void PrepThisNeuralNet()  // for testing
{
   ; // defaults
}


//**********************************************************************
// einzelne Neurons schichtenweise durchrechnen
//**********************************************************************

task RefreshLayers(){
  int j, k;

  while(true){

     for (j=0;j<L0;j++) {
       netPropagThr(Neuron0[j]);    // net-Input Layer 0
      actFermi(Neuron0[j]);        // Aktivierung T: Fermi-Funktion -> out
      for (k=0;k<L1;k++) {
        Neuron1[k].in[j] = Neuron0[j].out; } // Synapse Neuron0->Neuron1
    }

    for (j=0;j<L1;j++) {
      netPropagThr(Neuron1[j]);    // net-Input Layer 1
      actFermi(Neuron1[j]);        // Aktivierung T: Fermi-Funktion -> out
    }

  }
  return;
}

//**********************************************************************
// Lernverfahren
//**********************************************************************


void LearnPerceptronRule() {         // Perceptron-Lern-Modus
  int ErrorCount;
  int m,n,o;  // Sensor-Kombinationen
  int i;      // Anzahl Inputs
  int j;      // Anzahl Ausgabe-Neurons

 do {
  ErrorCount=0;
  PlaySound(soundBeepBeep);
  MenuText="-- <<  ok  >> ++";

  for (m=0; m< (2<<(ni-1)); m++)    {

     SetInputPattern(m);           // virtuelles Muster praesentieren
     wait1Msec(400);

     for (j=0;j<2;j++)
     {

       sollOut=0;
       MenuText="-- <<  ok  >> ++";
       printXY(0,15, "soll:");
       printXY(48+(j*25),15,"%2.0f", sollOut);
      do                        // erzeugten Output berichtigen
      {
         key=getkey();

         if (key==1) {   if (sollOut>0) sollOut-=1;  }
         else
         if (key==3) { if (sollOut< 1) sollOut+=1;  }
        printXY(0,15, "soll:");
         printXY(48+(j*25),15,"%2.0f", sollOut);
        wait1Msec(100);
      } while ((key!=2)&&(key!=4));

      println(5, " ");

      //...................................................
      if (key==4) {                     // Lern-Modus ENDE
         PlaySound(soundException);
         key=0;
         return;
      }
      //....................................................

                                        // Lern-Modus START
      //....................................................
      if (sollOut==Neuron0[j].out    )  // teachOut korrekt
        {
            PlaySound(soundBlip);
         PlaySound(soundBlip);
         wait1Msec(100);
      }
        //....................................................
      if (sollOut!=Neuron0[j].out)      // teachOut falsch
        {
           PlaySound(soundException);
           wait1Msec(100);
        ErrorCount+=1;
           //...................................................
                                        // LERNEN

        for (i=0; i<=L0; i++)           // fuer alle i (Inputs)
           {                               // Wichtungen anpassen (Delta-Regel)
              Neuron0[j].w[i] = Neuron0[j].w[i]+ (lf *Neuron0[j].in[i]*(sollOut-Neuron0[j].out));
           }

           if (sollOut!=Neuron0[j].out)    // Schwelle anpassen (Delta-Regel, erweitert)
           {
              Neuron0[j].th = Neuron0[j].th - (lf *(sollOut-Neuron0[j].out));
           }
        //...................................................
      } // if (sollOut!=Neuron0[j].out)

     } // for j

  } // for m
 } while (ErrorCount>0);

PlaySound(soundUpwardTones);
PlaySound(soundUpwardTones);
}

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

int IOpattern[2<<(ni-1)][L1];

void LearnBackpropagation() {    // Backpropagation-Lern-Modus
                                 // 1 Eingabe-/verdeckte(L0) +  1 Ausgabe-Schicht(L1)
  int ErrorCount;
  int m,n,o;      // Sensor-Kombinationen
  int i;          // Zaehler Inputs
  int j;          // Zaehler Ausgabe-Neurons
  int s;          // Zaehler verdeckte Neurons


  float f_sig1;   // Fehler-Signal Schicht 1 zum Lernen v. Wichtung und Schwelle
  float f_sig0;   // Fehler-Signal Schicht 0 zum Lernen v. Wichtung und Schwelle

  float f_sum=0;  // Fehler verdeckte Schicht (Summe (Wichtung*Fehlersignal))
  float f_out;    // Fehlerwert sollOut-out
  float fehler=0; // Summe der Fehlersignal-Quadrate

  float delta_w;  // Aenderungswert der Wichtung
  float delta_th; // Aenderungswert des Schwellwerts

  bool LearnModeAuto=false; // automat. Lernen oder manuell per Taste


 do {
  ErrorCount=0;
  PlaySound(soundBeepBeep);
  MenuText="-- <<  ok  >> ++";

  for (m=0; m < (2<<(ni-1)); m++)
  {
    printXY(80, 63, "%2d", m);

     SetInputPattern(m);     // virtuelles Muster praesentieren

     wait1Msec(200);             // durch alle Schichten durchrechnen


     for (j=0;j<L1;j++)  // 2 Outputs werden trainiert
     {

       sollOut=0;   // 0
       MenuText="-- <<  ok  >> ++";
       printXY(0,15, "soll:");
       printXY(48+(j*25),15,"%2.0f", sollOut);


                                         // erzeugten Output berichtigen

       if (!LearnModeAuto)               // einlesen per Tastatur
       {
        do
        {

           key=getkey();

            if (key==1) {   if (sollOut==1) sollOut=0;  }
           else
           if (key==3) { if (sollOut==0) sollOut=1;  }

            IOpattern[m][j]=sollOut;      // IO-Muster in IO-array schreiben

           printXY(0,15, "soll:");
           printXY(48+(j*25),15,"%2.0f", sollOut);
          wait1Msec(100);
        } while ((key!=2)&&(key!=4));
      }
      else                              // einlesen per IO-array
      {
        sollOut=ioPattern[m][j];
      }

      println(6, " ");

      //...................................................
      if (key==4) {                     // Lern-Modus ENDE
         PlaySound(soundException);
         key=0;
         return;
      }  // if key
      //....................................................

                                        // Lern-Modus START
      //....................................................
      if (sollOut==Neuron1[j].out  )    // teachOut korrekt
        {
            PlaySound(soundBlip);
         PlaySound(soundBlip);
         wait1Msec(100);
      }  //
        //....................................................
      if (sollOut!=Neuron1[j].out)      // teachOut falsch
        {
           PlaySound(soundException);
           wait1Msec(100);
        ErrorCount+=1;


                                        //                LERNEN
                                        // 1. Schritt: Ausgabeschicht behandeln L1(j)
                                        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        f_out=(sollOut-Neuron1[j].out);                        // Fehlerwert
        f_sig1=Neuron1[j].out*(1-Neuron1[j].out)*f_out;        // Fehler-Signal fuer Ausgabeschicht...

        Neuron1[j].d=f_sig1;             // ...im Neuron1 speichern

        fehler=fehler+(f_out*f_out);    // Gesamtfehler aller Ausgabeneuronen

        delta_w = lf  * Neuron1[j].out * f_sig1;        // Aenderungswert fuer Wichtungen
        for (i=0;i<L0;i++)
        {  Neuron1[j].w[i]=Neuron1[j].w[i] + delta_w;}  // neue Wichtungen in Ausgabe-Schicht L1(j)

        delta_th = lf  * f_sig1;                    //  Aenderungswert delta_th
        Neuron1[j].th  = Neuron1[j].th - delta_th;  // neue Schwellenwerte in Ausgabe-Schicht L1(j)



                                        //                LERNEN
        for (s=0;s<L1;s++)              // 2. Schritt: verdeckte Schicht behandeln L0(s)
                                        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        {

           f_sum=0;
           for (i=0;i<L1;i++)
           { f_sum=f_sum+(Neuron0[s].w[i] * f_sig1);  }       // Summe ueber alle (Wichtungen(L0)*FSignale(L1)*)

           f_sig0 = Neuron0[s].out*(1-Neuron0[s].out)*f_sum;  // neues Fehlersignal (verdeckte Schicht)...

           Neuron0[s].d = f_sig0;                             // ...im Neuron0 speichern

           delta_w = lf  * Neuron0[s].out * f_sig1;       // Aenderungswert mit Nachfolger-Fehlersignal
           for (i=0;i<L1;i++)
           { Neuron0[s].w[i]=Neuron0[s].w[i] + delta_w; } // neue Wichtungen in verdeckter Schicht L0(s)


           delta_th = lf  * f_sig0;                       // Aenderungswert delta_th
           Neuron0[s].th  = Neuron0[s].th  - delta_th;    // neue Schwellenwerte in verdeckter Schicht L0(s)


        } // for (s=0;s<L1;s++)


           //...................................................
      } // if (sollOut!=Neuron1[j].out)

     } // for j

  } // for m
 } while (ErrorCount>0);

PlaySound(soundUpwardTones);
PlaySound(soundUpwardTones);
}






//**********************************************************************
// Programmablauf-Steuerung, Menues
//**********************************************************************

int Menu_Recall() {
  eraseDisplay();
  MenuText="<Recall    Clear>";
  println(7, "%s", MenuText);
  println(0, "%s", " Hal "+Version);
  println(1, "%s", "----------------");
  println(2, "%s", "Reload my brain -");
  println(4, "%s", " Total Recall ?");
  do
  {
     key=getkey();
     if (key==1)    {  return 1;   }
     if (key==2)    {  PlaySound(soundException);   }
     if (key==3)    {  return 3;   }
     if (key==4)    {  PlaySound(soundException); }

     wait1Msec(100);
  }
  while ((key==0)||(key==2)||(key==4));
}



int Menu_LearnSaveRun() {
  eraseDisplay();
  MenuText="<Learn  Sav  Run>";
  do
  {
     key=getkey();
     if (key==1)    {  return 1;   }
     if (key==2)    {  SaveMemory(); }
     if (key==3)    {  return 3;   }
     if (key==4)    {  PlaySound(soundException); }

     wait1Msec(100);
  }
  while ((key==0)||(key==2)||(key==4));
}

//**********************************************************************
// Hauptprogramm
//**********************************************************************
int choice;


task main(){
  SensorType(S1)=sensorTouch;
  SensorType(S2)=sensorTouch;
  SensorType(S3)=sensorTouch;
  SensorType(S4)=sensorTouch;

  nVolume=2;
  InitAllNeurons();
  PrepThisNeuralNet();

  choice=Menu_Recall();
  if (choice==1)  { RecallMemory(); } // altes Gedaechtnis laden

  StartTask (DisplayValues);
  StartTask (RefreshLayers);

  while(true)
  {
    choice=Menu_LearnSaveRun();
    if (choice==1)
    {
       StopTask(RefreshInputLayer);
       LearnBackpropagation();          // Lern-Modus
    }
    MenuText="Menue: [ESC]";
    PlaySound(soundFastUpwardTones);
    StartTask (RefreshInputLayer);    // Run-Modus
    do
    {
       key=getkey();
      wait1Msec(100);
    } while (key!=4);
  }

}

_________________
regards,
HaWe aka Ford
#define S sqrt(t+2*i*i)<2
#define F(a,b) for(a=0;a<b;++a)
float x,y,r,i,s,j,t,n;task main(){F(y,64){F(x,99){r=i=t=0;s=x/33-2;j=y/32-1;F(n,50&S){t=r*r-i*i;i=2*r*i+j;r=t+s;}if(S){PutPixel(x,y);}}}while(1)}


Wed Jul 30, 2008 8:29 am
Profile
Display posts from previous:  Sort by  
Reply to topic   [ 1 post ] 

Who is online

Users browsing this forum: jerrykern and 2 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  



Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group.
Designed by ST Software for PTF.