Extcalc - wissenschaftlicher Taschenrechner

  readfile( Dateiname );
  

  writefile(Dateiname , Inhalt);
  

  appendfile(Dateiname , Inhalt);
  

  removefile("count.txt");             //Datei löschen, falls sie existiert
  for(C=0; C<100; C++)              //Schleife von 0 bis 99
{
    apendfile("count.txt",C);          //Nummern von 0 bis 99 in Datei schreiben
    appendfile("count.txt","\n");       //Jede Zahl in einer neuen Zeile
}
  

  removefile(Dateiname);
  

  glshow;
  

  glclear;
  

  glbegin( typ );
  

  glend;
  

  glbeginlist;
  

  glendlist;
  

  glcalllist;
  

  glbeginlist;          //Display-List starten
  glbegin(lines)        //Linen zeichnen starten
  glpoint(-5,-5,-5);    //Linien-Koordinaten eingeben
  glpoint(5,5,5);
  glend;                //Zeichnen beenden
  glbegin(triangles);   //Dreiecke zeichnen starten
  glpoint(-5,-5,0);     //Koordinaten setzen
  glpoint(5,-5,0);
  glpoint(0,5,0);
  glend;                //Zeichnen beenden
  L=glendlist;          //Liste abschließen und Listen-ID abspeichern

  glclear;
  glmove(0,0,1);        //Objekte verschieben
  glcalllist(L);        //Liste aufrufen
  glmove(0,0,-2);       //Objekte nochmal verschieben
  glcalllist(L);        //Liste noch einmal aufrufen
  glshow;               //Alles anzeigen
  

  glpoint(x,y,z);
  

  glcolor(r,g,b);
  

  glmove(x,y,z);
  

  glrotate(Winkel,x,y,z);
  

  glscale(x,y,z);
  

#config gl              //GL initialisierung
#config axesoff
#config rasteroff
#config labelsoff

glstartlist;            //Dislplay-Liste für einen Würfel erzeugen
glbegin(quads);
glpoint(-1,-1,-1);
glpoint(1,-1,-1);
glpoint(1,1,-1);
glpoint(-1,1,-1);

glpoint(-1,-1,1);
glpoint(1,-1,1);
glpoint(1,1,1);
glpoint(-1,1,1);

glpoint(-1,-1,-1);
glpoint(-1,-1,1);
glpoint(-1,1,1);
glpoint(-1,1,-1);


glpoint(1,-1,-1);
glpoint(1,-1,1);
glpoint(1,1,1);
glpoint(1,1,-1);

glpoint(-1,-1,-1);
glpoint(-1,-1,1);
glpoint(1,-1,1);
glpoint(1,-1,-1);

glpoint(-1,1,-1);
glpoint(-1,1,1);
glpoint(1,1,1);
glpoint(1,1,-1);
glend;
L=glendlist;             //Liste beenden und ID abspeichern

R=0;                     //Drehwinkel
while(1)
{
  R=R+1;
  glclear;              //Fenster löschen
                        //In dieser Befehlsreihenfolge rotiert der Würfel um seine eigen Y-Achse, die Kantenlänge ist 4,
                        //die Drehachse ist bei 12-0-0
  glscale(4,4,4);       //vergrößern
  glmove(3,0,0);        //verschieben
  glrotate(R,0,1,0);    //drehen
  glcolor(30,30,200);
  glcalllist(L);
  
  glloadidentity;
                        //In diser Reihenfolge dreht sich der Würfel um den Koordinatenursprung, hat die Kantenlänge 3 und
                        //den Drehradius 9
  glscale(3,3,3);       //vergrößern
  glrotate(R,0,1,0);    //drehen
  glmove(3,0,0);        //verschieben
  glcolor(200,30,20);
  glcalllist(L);
  glshow;
  sleep(30000);
}

  glloadidentity;
  

  glstring(x,y,Text);
  

  drawpoint(x,y);
  

  drawline(xstart,ystart,xend,yend);
  

  drawrect(xstart,ystart,xend,yend);
  

  drawcircle(xstart,ystart,xend,yend);
  

  drawstring(x,y,text);
  

  drawcolor(r,g,b);
  

  drawclear;
  

  run("Script-Pfad");
  

  run("subprogram");    //Program heißt subprogram und befindet sich direkt im Code-Hauptverzeichnis
  run("myprog/subroutine2"); //Programm heißt subroutine2 und befindet sich im Unterverzeichnis myprog
  

  Variable[index];                               //Normales Array
  Variable[1. Index][2. Index];                  //2-Dimensionales Array
  

  A="          ";
  for(C=9; C>=0; C=C-1)             //liest 10 Zeichen ein
     A[C]=getkey;
  print(A);                            //gibt die Zeichen invertiert aus
  

  In Scriptinterpreter integrierte Operatoren (funktionieren mit allen Datentypen)
  + Addititon
  - Subtraktion
  == Vergleich
  != Ungleich
  > Größer
  < Kleiner
  >= Größer gleich
  <= Kleiner gleich
  && Logisches Und
  || Logisches Oder
  ! Logisches Nicht
  = Zuweisung (wie in C)
  -> Zuweisung (wie im Taschenrechner)
  [] Index-Operator
  [][] 2-Dimensionaler Index-Operator

  Alle anderen Operatoren funktionieren wie im Taschenrechner
  Diese geben dann aber immer eine float-Zahl zurück
  

  12.3545->A;
  (int)A->A; // A ist jetzt 12

  print((int)"abc");  //hallo kann nicht als Zahl interpretiert werden, es wird 97 (ASCII-Code von a) ausgegeben

  "234.45"->C;
  (float)C->D;   //Text kann als Zahl interpretiert werden, D wird auf Zahlenwert gesetzt
  print(D+1);    //Gibt 235.45 aus
  

Script Einstellungen

#config EINSTELLUNG

#config complexon             //Komplexe Zahlen einschalten
#config complexoff            //Komplexe Zahlen ausschalten

#config angledeg              //Grad als Winkel-Format benutzen
#config anglerad              //Radiant als Winkel-Format benutzen
#config anglegra              //Neugrad als Winkel-Format benutzen

#config modebase              //In Logik-Modus schalten
#config modescientific        //Wissenschaftlichen Modus benutzen (Standard)

#config outputlengthXX        //Stellenzahl für Ausgabe von Gleitpunktzahlen festlegen. XX ist eine Zahl zwischen 2 und der max. Stellenzahl
                              //Die Stellenzahl wird ohne Leerschritt direkt hinter outputlength geschrieben

#config clearmemory           //Array-Speicher vor dem Start löschen

#config gl                    //Aktiviert den GL-Modus für 3D-Grafik
                              //Diese Option muss aktiviert sein, um 3D-Grafikbefehle verwenden zu können

#config graphics              //Aktiviert den 2D-Grafikmodus
                              //Diese Option muss aktiviert sein, um 2D-Grafikbefehle verwenden zu können

#config axeson                //Aktiviert oder deaktiviert die Koordinatenachsen im 3D-Modus
#config axesoff

#config rasteron              //Aktiviert oder deaktiviert das Koordinatenraster im 3D-Modus
#config rasteroff

#config labelson              //Aktiviert oder deaktiviert die Achsenbeschriftung im 3D-Modus
#config labelsoff

Beispielprogramme:

  //loop starts at 3 (so it can add 2 instead of 1 per step)
  print("2 ");
  for(3->A;;A+2->A)
  {
    0->C;
    sqrtA->D;
    //prime number check with modulo
    for(2->B; C==0 && B<=D; B+1->B)
    {
      if((A%B)==0)
      1->C;
    }
    if(C==0)
    {
      print(A);
      print("\t");
    }
  }
 

  //initialization
  //variables for ball movement
  4->A;
  1->B;
  1->C;
  1->D;
  
  //variable for player movement
  10->E;
  
  //stop variable
  0->S;
  
  //counter for ball movement
  //the ball moves only ervery fifth run
  0->I;
  
  //variables to store old drawing coordinates
  //needed that it redraws only if needed
  //and that the screen can be cleared without
  //flickering
  4->G;
  4->H;
  9->J;
  0->X;
  
  clear;
  
  for(;S==0;I+1->I)
  {
  
    //move ball every fith time
    E->J;
    if(I==5)
    {
      0->I;
      A->G;
      B->H;
      A+C->A;
      B+D->B;
      if(A>50)
        -1->C;
      else if(A<1)
        1->C;
      if(B<1)
        1->D;
      else if(B>12)
      {
        if(A>E-3 && A<E+3)
        {
          -1->D;
          X+1->X;
        }
        else 1->S;
      }
      //long break for ball movement
      sleep(30000);
    }
  
    //read keystate and move player
    keystate->K;
    1+K-1->K;
    if(K==100 && E<48)
      E+1->E;
    if(K==97 && E>2)
      E-1->E;
    
    //short break
    //needed that player can move fast
    sleep(5000);
  
    //print ball if needed
    if(A!=G || B!=H)
    {
      setcursor(G,H);
      print(" ");
      setcursor(A,B);
      print("*");
    }
  
    //print payer if needed
    if(E!=J)
    {
        if(E>J)
        {
          setcursor(J-2,14);
          print(" ");
          setcursor(E-2,14);
          print("#####");
        }
        else 
        {
          setcursor(J+2,14);
          print(" ");
          setcursor(E-2,14);
          print("#####");
        }
    }
  
    //print score
    setcursor(51,1);
    print(X);
  }
  
  //loop finished
  //because player didn't get the ball
  //print score
  sleep(300000);
  clear;
  print("\n\n\n***********Ende***********\n");
  print("********Punkte: **********");
  setcursor(16,4);
  print(X);
  print("\n\n");
  

Module

Rechner

Lineares Gleichungssystem

  4x - 2y  =  9
 -2x + 5y  = -2
  

   4 -2  9
  -2  5 -2
  

   4 -2
  -2  5
  

   9
  -2
  

  2.25
  0.75
  

Erstellen

Analysieren

Inverse Matrix

Approximation

Interpolation

Linien-Graph anzeigen

Normalverteilungskurve berechnen

Verteilungs-Graph anzeigen

Rechner-Einstellungen

Graphik-Einstellungen

Koordinatensystem

Parameter T,A,Z

Rechenleistung/Genauigkeit

Tabellen Einstellungen

Script-Einstellungen

Version

Rechengenauigkeit:

benötigte Software

Getestete Distributionen:

Debian 3.1 Sarge:

FreeBSD 6.2:

Hardwareanforderungen:

Fertige Funktionen

noch zu Tun