Extcalc - Scientific Calculator

Contents

• extract packet (tar -xzf extcalc-0.9.3.tar.gz)
  
• switch to directory (cd extcalc-0.9.3)
  
• run cmake (cmake .)
  
• compile (make)
  
• become root (su)
  
• install (make install)
  

1. Using the keyboard

2. Using the integrated buttons

3. Function catalog

4. Constants and Conversation

Special keys:

DEL

This is the same as Backspace-key on the keyboard.

AC

This key removes the complete history.

Shift

Press this button to use additional operations

Alpha

Press this button to use variables

hyp

Use this button for hyperbolic functions.

ANS

This is the answer-memory. Use this key to recall the last result.

Calculation Priority:

1. Brackets
   
2. Special operations: integration, differentiation
   
3. Binary operators 1: root, power, ...
   
4. Unary operators: sin, cos, log, ...
   
5. Bit operations: &, |, ...
   
6. Binary operators 2: *, /
   
7. Binary operators 3: +, -
   
8. Compare operations: ==, !=, ...
   
9. Set operations: ->, =
   
10. Logic operations: &&, ||, ...
    

Syntax - How to input calculation formulas

Operation	Key	Usage	Example
Square Root		expression	Use brackets for calculations under a root To use the square root operation first press the square root button and then insert the argument
Cubic root	+	+expression
Other Roots		expressionexpression	To use this operation, first type the degree of the root and then type the argument.
Random Number Generator		random number key	(Number between 0 and 10) The number after the "rnd" is the maximum value of the random number.
Differentiation		(function,x-value)	The function parameter must be X. Example: 2X^3-3X+3 The result is the is the gradient of the function at the given x-value. The program can only calculate an approximated value of the differentiation. The precision is about +/-1e-8
Integration:		(function, start value, end value)	The function parameter must be X. Example: sin(X)*3 The area below the graph of "function" between "start value" and "end value" is calculated. An integral calculation will fail if there is a vertical asymptote between start and end point. The precision is about +/-1e-9.
Usage of Variables		+ any letter.	You can use 26 variables to store values. To use the variables by the integrated buttons, press
Store/Recall Values			store a value use stored value A stored value can be used like any other number. Unused variables are set to 0.

Function Catalog

Complex Numbers

In base mode, the letters A - F are reserved for hexadecimal numbers, so they can't be used as variables. But you can use the variables from G to Z to store results in base mode.
This mode is mainly used for logic functions and transformations between the different numeral systems.
If you want to input a number of a numeral system different to the default one, which you can choose with the quick preferences box, you have to write a special prefix before the number:
Examples:

Hexadecimal	hex0FA46B The letters in hexadecimal numbers must be uppercase.
Decimal	dec4575
Octal	oct01243
Binary	bin1000101111010

You can see all logic functions, which you can use in base mode, on the calculator keys. You can press shift key to use additional logic functions.
The following functions can be used:

Logic functions	These functions return only true or false as a result. 0 is false and everything different from 0 is true. && (and), || (or), ! (not)
Binary functions	These functions modify every single bit of a number. & (and), | (or), ~ (not), << (left shift), >> (right shift), xor

3.2 Graphic

Graph Types

Standard Graphs y(x)=X

Polar Graphs r(x)=X

Parameter Graphs x(T)=T; y(T)=T

Inequality Graphs y(X) > X, y(X) < X, y(X) >=X, y(X) <=X

3D Graphs y(x,z)=XZ

Nyquist plots and 3D-Nyquist plots Y=Zi+Z

Dynamic graphs

Logic expressions

Coordinate Systems

Standard Coordinate System

Polar Coordinate System

3D Coordinate System

Function Table

Output Window

Examples

The described functions are not available in v0.9.3

	standard	polar	parameter	inequality	3D-graph	Nyquist plot
Calculate Y-value	x	x	x	x	x	x
Calculate roots	x	x	x	x		x
Newton's Method	x	x		x
Calculate X-values	x	x	x	x	x	x
Points of Intersection	x	x		x
Maximum and minimum values	x	x		x
Calculate Integral	x	x		x	x
Calculate Differential	x	x	x	x	x
Calculate Z-value					x

Function	Procedure
Calculate y-value	Insert a x-value into the input line or click into the graphics output window where you want to calculate the y-value. Then press the calculate button. The y-value of all displayed graphs will be shown in a table. Parameter graphs may have more than one y-value with the same x-value. For 3D-Graphs you have to insert x-value and z-value to calculate the y-value
Calculate Roots	Choose a function from the function box and press the calculate button to calculate the roots of a function.
Newton's Method	This is a special method of calculating roots. You can set a start value for the calculation and the number of steps to calculate. All results will be shown in the table. The first item in the last line is your result.
Calculate x-values	Choose a function from the box and type the y-value you want into the input line. When you press the calculate button, the x-values are shown in the output table. For 3D-graphs, the y-value is also needed for calculation.
Points of intersection	Choose two graphs from the boxes and press the calculate button. Then the points of intersection of the two graphs are shown. Don't choose two times the same function.
Maximum and Minimum values	Choose a graph and press the calculate button and then all extreme values will be calculated.
Integral Calculation	Just set a start point and an end point, then you can integrate the cosine function. The size of the area between the graph and the x-Axis is calculated. In 3D-Mode, you have to set X-Start, X-End, Z-Start and Z-End points for integration. The volume between the X-Z-Plane and the graph is calculated.
Differential Calculation	For a differential calculation, you must choose a function and the point to calculate, then press the calculate button. It is also possible to calculate the Cartesian differentiation of a parameter function. For 3D-Functions, you have to set a X- and a Z-Value. All partial differentials at the given point were calculated.
Calculate z-values	Choose a function from the box and type the x-value and the y-value into the input fields. Pressing the calculate-button will show you the results.

3.2.4 Screen shots

Saving a screenshot

Drawing

Text drawing: If you press the text button, you will see an input dialog where you can set the text to draw. When you hold down the left mouse button, you can also see a preview. If you press the mouse button again, the text will be inserted again. To change the text, text size or color, you have to press the Text-button again.

Rubber: If you want to erase a part of the drawn things, you can use this tool. It makes the erased areas transparent. In preview mode, it is shown white.

Furthermore, you have an undo button and a button to clear the complete draw area.

3.3 Tables

Create a New Script:

Load and Save Scripts:

Import and Export Scripts

Managing files:

Subdirectories:

You can create subdirectories in your script directory to save your scripts there.

Renaming:

You may also rename your scripts, but drag and drop for moving files is currently not available.

Removing:

You can also remove your code files and subdirectories, but you can remove directories only if they are empty.

Changes without Extcalc:

You can also modify your script files and directories without Extcalc. If is running while you change something, you can press the right mouse button at the file list and choose "Update" to see your changes in Extcalc.

Running Scripts:

Problems:

1. Speed
   The extcalc scripts were ran by an Interpreter and so they run not as fast as compiled programms, but it will be optimized in later versions.
   
   
2. Variables:
   You can use the uppercase letters from A to Z as variables. Every variable can also be used as an array or a matrix.
   
   
3. Features
   Most of the planned features is available, now, but this is only a calculator script interpreter that can be used to solve simple mathematical problems. It will never have the flexibility and power of a complex programming language like C.
   
   

   Syntax:

   The syntax of the Extcalc Script interpreter is similar to the C syntax.
   Main Rules:
   
   • Every command ends with a ; semicolon
     
   • Behind loops and conditions directly follows the command to run, and no semicolon
     
   • If you want to run more than one command in a loop or a condition, you have to write this commands in braces {}.
     
   • It is possible to use mathematical operations in the code. They are also finished with the semicolon.
     
   • You can insert newlines, tabs and spaces everywhere in your code.
     
   • The whitespace will be removed before running the script.
     
   • It is possible to use C++-like comments // or C-comments. Everything in this line after the slash signs will be ignored.
     
   • You can also use the C-Comments /* ... */ in your scripts. Everything inside the comment will be ignored
     
   • The compare operator is written like in C with ==, the single = operator is the set-operator
     
   • If you want to use a Variable as an Array, use the Index-Operator with it. Example: A[3]=5;
     
   • It is not possible to define and functions. The commands are written directly into the code file.
     
   • It is possible to execute another script file by the run() command.
     
   • You can define macros with a #define line like in C, but only without arguments
     

Error Messages:

Variables:

float:

floating point number of type long double (size depends on the system, normally 10 Bytes)

int:

integer number of type long long int (8 Byte)

bool:

boolean value of type bool (can be true or false)

string:

Text of type char* (length is variable, allocating and freeing is made by the interpreter)

Arrays:

Matrices and Vectors:

• Matrices and vectors can be copied from one variable to another. You write for example B=A[][] to copy the complete matrix A into B.
• If you want to copy a single element of a Matrix A into B, write for example B=A[3][2].
• When you write B=A, and A is a matrix, ONLY the first element of the matrix is copied. This is equal to B=A[0][0].
• If you want to use the result Vector or result Matrix from the last operation, you can writ ans[] or ans[][].
• The only way to make a matrix or a vector smaller, is to copy another, smaller vector or matrix into it.
• When you want to erase all matrix an vector data, you must press th AC button.

Commands:

1. If
   Syntax:
   

    if( condition )
       command for condition true;
     else 
       command for condition false;
     

   If you want to run more commands, they must be written in braces (without semicolon at the end).
   Example:
   

     if(A==5)
      A=7;
     else 
     {
       A=A+1;
       if(A>10)
         A=0;
     }
     

2. While
   Syntax:
   

    while( condition )
       command that is ran while condition true;
     

   If you want to run more commands, they must be written in braces (without semicolon at the end).
   If the loop should run all time, you can write while(1), but you always have to set a condition
   Example:
   

     F=0;
     while(F==0)
     {
       F=keystate;
       sleep(10000);
     }
     

3. For
   Syntax:
   

    for(initialization; condition; count-command)
       command that is ran while condition true;
     

   If you want to run more commands, they must be written in braces (without semicolon at the end).
   At initialization, you can set the counter variable to the start value.
   The loop runs, as long as the condition is true.
   The printf-command is executed in every run. It can be any command.
   If you don't need the initialization or the condition, you can only type a semicolon. If you don't need the count-command you can leave it out.
   Example:
   

     for(A=-4;A<0;A+1->A)
        print(A);
   
     for(;;)
       print("this runs always");
     

4. Print
   Syntax:
   

    print( Output );
     

   Output can be a variable, a command or a constant (like text).
   You can only set one input.
   Example:
   

     A=12;
     print(A+3);  //Output: 15
   
     print("Hello World!\n");    // Text with newline at the end
   
     print(3>5);  //prints out false
     

5. getline
   Syntax:
   

     getline;
     

   This command does only make sense, if you use the return value.
   Example:
   

     X=getline;
     print(X);
     //or:
     print(getline);
     

6. getkey
   Syntax:
   

     getkey;
     

   This command does only make sense, if you use the return value.
   It blocks the program until you press any button.
   The return value is a string and you may need to convert it.
   Example:
   

     F=0;
     while(F!=97)  //loop runs, until you press a
     {
       F=getkey;
       F=(int)F;
     }
     

7. Keystate
   Syntax:
   

     keystate;
     

   This command does only make sense, if you use the return value.
   It doesn't block the program.
   If no button was currently pressed, it returns 0.
   The return value is a string and you may need to convert it.
   Example:
   

     F=0;
     while(F!=97)  //Loop runs, until you press a
     {
      F= keystate;
       F=(int)F;
       sleep(10000);                         //break
       if(F==0)    
         print("Press a to stop\n");    //This text is always printed
     }
     

8. Sleep
   Syntax:
   

     sleep( Time in microseconds );
     

   The script is stopped for the given time.
   If you want to make a program run slower, you should use this command and no empty loop.
   A program that interacts with the user or a program that prints very much should use this command because otherwise the script console may not have enough cpu time to show to show its content on time.
   An example can be found at the keystate command.
   
   
   
9. readfile
   Syntax:
   

     readfile( filename );
     

   Reads the file with the name filename and returns its content as string.
   The files to read and write must be located in the script data directory. Subdirectories were not supported.
   filename must be a string. if filename is no string, or the file could not be read, an empty string is returned.
   
   
   
10. writefile
    Syntax:
    

      writefile(filename , content);
      

    Writes the content ans string into a file named filename.
    If the file doesn't exsit, it will be created. If it exists, it will be cleared.
    The filename must be a string. As at readfile, subdirectories and absolute paths were not supported.
    
    
    
    
11. appendfile
    Syntax:
    

      appendfile(filename , content);
      

    The same as writefile, but if a file still exists, the content will be appended.
    Example:

      removefile("count.txt");             //remove file, if it exists
      for(C=0; C<100; C++)              //loop from 0 to 99
      {
        apendfile("count.txt",C);          //write numbers from 0 to 99 into a file
        appendfile("count.txt","\n");       //seperated by a newline
      }
      

    
    
    
    
12. removefile
    Syntax:
    

      removefile(filename);
      

    This command removes the file filename from the script data directory.
    
    
    
13. glshow
    Syntax:
    

      glshow;
      

    This command updates the GL window.
    
    
    
14. glclear
    Syntax:
    

      glclear;
      

    This command clears the GL window.
    
    
    
15. glbegin
    Syntax:
    

      glbegin( type );
      

    This commands must be called to start drawing. It must also be called to draw into a dislplay list.
    The draw type is also set by this command. The command is just written inside the brackets.
    The following types can be set:
    points
    lines
    linestrip
    lineloop
    triangles
    trianglestrip
    trianglefan
    quads
    quadstrip
    polygon
    
    
    
    
    
16. glend
    Syntax:
    

      glend;
      

    This command must be called after glbegin(), when drawing is done.
    
    
    
17. glbeginlist
    Syntax:
    

      glbeginlist;
      

    This command starts a display list. After this command, all gl commands expect text drawing were stored in the display list.
    
    
    
18. glendlist
    Syntax:
    

      glendlist;
      

    This command ends the display list and returns the list ID.
    The returned ID is an integer and must be stored to call the list.
    
    
    
    
19. glcalllist
    Syntax:
    

      glcalllist;
      

    With this command, you can call a display list, so that it is drawn.
    Using display lists instead of calling GL commands directly is much faster.
    
    Example:
    

      glbeginlist;          //start list
      glbegin(lines)        //start drawing lines
      glpoint(-5,-5,-5);    //set coordinates
      glpoint(5,5,5);
      glend;                //end drawing lines
      glbegin(triangles);   //start drawing triangles
      glpoint(-5,-5,0);     //set coordinates
      glpoint(5,-5,0);
      glpoint(0,5,0);
      glend;                //end drawing triangles
      L=glendlist;          //end list, store ID
    
      glclear;
      glmove(0,0,1);        //set transformation matrix
      glcalllist(L);        //call list
      glmove(0,0,-2);       //change transformation matrix settings
      glcalllist(L);        //call list again
      glshow;               //show scene
      

    
    
    
    
20. glpoint
    Syntax:
    

      glpoint(x,y,z);
      

    This command must be called to set object coodinates after calling glbegin().
    Parameters are three floating point values for x-, y-, and z-coordinate.
    
    
    
21. glcolor
    Syntax:
    

      glcolor(r,g,b);
      

    With this command, you can set the draw color.
    The parameters are integer values for red, green and blue. They must be in a range between 0 and 255.
    
    
    
22. glmove
    Syntax:
    

      glmove(x,y,z);
      

    This command moves a GL object.
    The paramters are float values for the coordinates.
    GL transformations were always multiplied to a single transformation matrix. This means, that the transformation command that has been called first, will be done as last.
    
    
    
23. glrotate
    Syntax:
    

      glrotate(angle,x,y,z);
      

    GL objects can be rotated by this command. The rotation is described by the angle in degrees (angle) and by a vector (x,y,z), which represents the rotation axes. All parameters are of type float.
    GL transformations were always multiplied to a single transformation matrix. This means, that the transformation command that has been called first, will be done as last.
    
    
    
24. glscale
    Syntax:
    

      glscale(x,y,z);
      

    With this command, a GL object can be scaled. All parameters are of type float.
    GL transformations were always multiplied to a single transformation matrix. This means, that the transformation command that has been called first, will be done as last.
    Example:
    

    #config gl              //gl initialisation
    #config axesoff
    #config rasteroff
    #config labelsoff
    
    glstartlist;            //generate gl list for a cube
    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;             //end list and store list
    
    R=0;                     //rotation angle
    while(1)
    {
      R=R+1;
      glclear;              //draw scene
                            //int this order, the cube rotates around its y-axes, has a size of 4x4x4, and
                            //its rotatione axes is located at 12,0,0
      glscale(4,4,4);       //resize
      glmove(3,0,0);        //move
      glrotate(R,0,1,0);    //rotate
      glcolor(30,30,200);
      glcalllist(L);
      
      glloadidentity;
                            //int this order, the cube rotates around the coordinate systems y-axes, has a size of 3x3x3, and
                            //rotatis with radius of 9
      glscale(3,3,3);       //resize
      glrotate(R,0,1,0);    //rotate
      glmove(3,0,0);        //move
      glcolor(200,30,20);
      glcalllist(L);
      glshow;
      sleep(30000);
    }
    

    
    
    
    
25. glloadidentity
    Syntax:
    

      glloadidentity;
      

    This command resets all transformations.
    
    
    
26. glstring
    Syntax:
    

      glstring(x,y,text);
      

    This command shows a text at the 2D-position x,y. The start point is the upper left edge. The coordinates are in pixels. x and y are integer values. Text can be a string or a number (float or int).
    
    
    
27. drawpoint
    Syntax:
    

      drawpoint(x,y);
      

    This command draws a point of the currently set color into the 2D-graphics window of the script interpreter. The origin of the coordinate system is the upper left corner of the window and x and y are integer values.
    
    
    
28. drawline
    Syntax:
    

      drawline(xstart,ystart,xend,yend);
      

    This command draws a line of the currently set color from the given start point to the given end point. All coordinates are integer values.
    
    
    
29. drawrect
    Syntax:
    

      drawrect(xstart,ystart,xend,yend);
      

    Draws a rectangle with the given coordinates. All coordinate values are of integer type.
    
    
    
30. drawcircle
    Syntax:
    

      drawcircle(xstart,ystart,xend,yend);
      

    Draws an ellipse into the rectangle defined by the given coordinates. The coordinates are integer values.
    
    
    
31. drawstring
    Syntax:
    

      drawstring(x,y,text);
      

    This command shows a text at the position x,y. The coordinates are integer values. Text can be a string or a number (float or int).
    
    
    
32. drawcolor
    Syntax:
    

      drawcolor(r,g,b);
      

    Sets the draw color for all 2D-drawing commands. The color is set by red, green and blue component which can have values from 0 to 255.
    
    
    
33. drawclear
    Syntax:
    

      drawclear;
      

    This command clears the 2D-graphics window of the script interpreter.
    
    
    
34. type converting
    Syntax:
    

      (target type)variable;
      

    target type must be one of (int) (float) (string) (bool).
    You can also use them with constants.
    Example:
    

      A=12.3545;
      A=(int)A; // A is now 12
    
      print((int)"abc");  //abc can not be converted to a number, so it is set to 97 (ASCII-Code of a)
    
      C="234.45";
      D=(float)C;   //text can be interpreted as number, so it is set to the value
      print(D+1);    //prints 235.45
      

35. Running subprograms
    Syntax:
    

      run("script path");
      

    With this command, you can execute another code file from your script.
    The script path must be relative to the script code directory.
    The script path must be hard coded in your script code
    With this command, it is also possible to program a recursive algorithm. But you should not do that, because this may lead to a stack overflow and the program will crash. The script interpreter can not prevent this crash.
    Example:
    

      run("subprogram");       //runs a subprogram with the name subprogram that is in the script code directory
      runt("prog/routine4");   //runs a subprogram with the name routine4 which is in the directory prog
      

36. Arrays
    Syntax:
    

      Variable[index];                               //1-dimesional array
      Variable[1. index][2. index];                 //2-dimensional array
      

    Every variable can also be an array, if you use the index-operator on it
    Without index-operator, you always access the element with index 0.
    If you want to access a single character of a string, you use the same syntax. If you write one index, and the variable contains only a string at index 0, you access a character inside the string.
    If you write two indices and the element at the first index is a character, you also access a character inside the string.
    Example:
    

      A="          ";
      for(C=9; C>=0; C=C-1)             //reads 10 characters
         A[C]=getkey;
      print(A);                            //prints the characters inverted
      

37. Possible Operators
    Operator List
    

      In script interpreter integrated operators (can be used with every variable type)
      + add
      - sub
      == compare
      != unequal
      > greater
      < less
      >= greater or equal
      <= less or equal
      && logic and
      || logic or
      ! logic not
      = set (like in C)
      -> set (like in Calculator)
      [] index operator
      [][] index operator matrix
    
      All other operators can be used like in the calculator.
      

    The operators can also be used together.
    

      12.3545->A;
      (int)A->A; // A is now 12
    
      print((int)"abc");  //abc can not be converted to a number, so it is set to 97 (ASCII-Code of a)
    
      "234.45"->C;
      (float)C->D;   //Text can be converted do a number, so D is set to this value
      print(D+1);    //prints 235.45
      

Script Preferences

#config PREFERENCE

#config complexon             //switch complex numbers on
#config complexoff            //switch complex numbers off

#config angledeg              //set angle type to degrees
#config anglerad              //set angle type to radian
#config anglegra              //set angle type to grade

#config modebase              //set base mode
#config modescientific        //set scientific mode (default)

#config outputlengthXX        //set length of floating point output; XX must be a number between 2 and the max. output length
                              //the number is written directly behind outputlength without space

#config clearmemory           //always clear array memory before starting

#config gl                    //switch to 3D-GL window
                              //this MUST be set to use 3D-graphics

#config graphics              //switch to 2D-graphics window
                              //this MUST be set to use 2D-graphics

#config axeson                //enable or disable 3D-coodinate system axis
#config axesoff

#config rasteron              //enable or disable 3D-coodinate system raser
#config rasteroff

#config labelson              //enable or disable 3D-coodinate system labels
#config labelsoff

Macros

  #define macro replacement
  

Example codes:

  //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 every 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 fifth 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***********End************\n");
  print("********Points: **********");
  setcursor(16,4);
  print(X);
  print("\n\n");
  

The described functions are not available in v0.9.3

Modules

Calculator

Linear System of Equations

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

   4 -2  9
  -2  5 -2
  

   4 -2
  -2  5
  

   9
  -2
  

  2.25
  0.75
  

Generate Matrix

Analyse Matrix/Vector

Inverse Matrix

Approximate

Interpolate

Show Line-Graph

Normal Distribution Graph

Distribution Graph

Calculator Preferences Dialog

Graphics Preferences Dialog

Coordinate Systems

Parameter Range

Precision/Performance

Table Preferences

Scripting Preferences

Version

Precision

enabled features

To-do-list

Tested Distributions:

FreeBSD 6.2

Needed software:

Needed hardware: