Instructions : (1 per line)
A line is a comment, a rule, an affection, a target or an expression.
Comments begin with //
============================================================================
Rules:
A rule begins with a point  ('.')

Title of the exercise : .title=...
Description of the exercise : .descr=...
Number of Rows to build : .rows=...
Number of Columns to build : .cols=...
Textsize : .size=...
Start Numbering of exercices : .nr=... (without numbering : .nr=)
Views : .view=... (each letter of ... in ('S' (solution), 'Q' (question), 'F' (form), 'N' (none))
Hide the lines from this line on to end : .hide
============================================================================
Affection: a variable gets its value from an expression.
A variable is defined when it is used for the first time.
The variable ix is the number of the current exercice and is allways defined.

<var>=<expr>

A standalone expression will be a part of the final result.
<expr>

An expresssion can be a constant value, a variable or a function.
============================================================================
Targets:
a target begins with ':'
you can jump to a target with instruction goto (e.g. if(gt(a,3),goto("targ4"))
============================================================================
Constant values:
a numeric constant value begins with a digit or '-'
a string constant value begins with '"' or "'"
============================================================================
Functions:

absolute value : abs(<expr>)
division : div(<expr1>, <expr2>)
greatest commun divisor : gcd(<expr1>[,...]) or gcd(list(<expr1>[,...]))
						  gcd0(...) like gcd, but 0-values ignored
integer value : int(<expr>)
inverted value (1/x) : inv(<expr>)
logaritme base 10 : log10(<expr>)
logaritme (default base=e) : log(<expr>[,<base>])
maximum value : max(<expr>[,...])
minimum value : min(<expr>[,...])
modulo : mod(<expr1>,<expr1>)
multiplication : mult(<expr>[,...])
negated value (-x) : neg(<expr>)
power : pow(<expr1>, <expr2>)
quotient : dive(<expr1>, <expr2>)
round : round(<expr1> [, <decimals>])
sign (-1,0 or 1) : sign(<expr>)
square root : sqrt(<expr>)
substraction : sub(<expr>[,...])
sum : sum(<expr>[,...])
sumprod : sumprod(<list1>,<list2>)
------------------------
concatenation : cc(<expr>[,...])
coefx(<li>)
	coefx(list('+x','+y','-z','w')) =>  x+y-z+w
coefx(<val>)
	0=>'' 1=>1 -1=>-1
coefx(<val>, '+')
	0=>'' 1=>+1 -1=>-1
coefx(<val>, <var>)
	0x=>'' -1x=>-x 1x=>x 2x=>2x
coefx(<val>, <var>, <plus>)
	1x''=>x 1x'+'=>+x 2x''=>2x 2x'+'=>+2x -2x'+'=>-2x
	example : coefx(a,"x","+")
im(<file>, [list(item1, value1,...)])
	example : im("http://example.com/image.jpg", list("width","50%", "border","0", "alt","schema"))
formatting : ft(<expr>,<format>) <format> may contain letters 'b'(bold),'i'(italic),'u'(underline),'r'(red),'e'(exponent),'x'(index), or 'h1'-'h7'
result(<expr> [,<width>])
	output is considered as result and will be hidden or shown (by click on question mark image on top of page)
------------------------
Random number : rnd(<expr1>, <expr2> [,<decimals> [,<list>] )
	Random number between <expr1> and <expr2>
	<decimals> is the number of decimals (default=0)
	<list> : list of items that are not accepted as result (may be simple element if there is only one)
	example : rnd(1, 2, 1, list(1.2, 1.5)) or rnd(-5, 5, 0, 0)
Random prime number : rndprim(<expr1>, <expr2> [, <list>] )
	Random number between <expr1> and <expr2>
	<list> : list of items that are not accepted as result
	example : rnd(2, 11, list(5))
Random item from list : rnditem(<list1> [,<list2>]) 
	but item must not be in list <list2>
	if <list2> is not an array, item must be different from <list2>
------------------------
List contains given element ? : contains(<item>, <list>)
Build a list : list(<expr>[,...])
Permute a list : perm(<list>)
Search element in list : index(<item>, <list>) (-1 if not found)
Give element at index : item(<list>, <index>)
Remove an element of rmitem(<list>, <index>)
------------------------
logical - greater than : gt(<expr1>, <expr2>) 
logical - greater or equal : ge(<expr1>, <expr2>) 
logical - equal : eq(<expr1>, <expr2>) 
logical - not equal : ne(<expr1>, <expr2>) 
logical - less than : lt(<expr1>, <expr2>) 
logical - less than or equal: le(<expr1>, <expr2>) 
logical - and: and(<expr>[, ...]) 
logical - or: or(<expr>[, ...]) 
logical - not: not(<expr>) 
alternative : cond(<condition>, <value_if_true>, <value_if_false>)
              if(<condition>, <cmd1>[, ...])
------------------------
special - crela - crela(<number_of_terms>) : create random expression (variable not used)
special - crela - crelaJava : get Java expression based on last created expression
special - crela - crelaLatex : get Latex expression based on last created expression
special - crela - crelaImg : get Image based on latex expression from site http://latex.codecogs.com/gif.latex
				  crelaImg(<dpi>,<size>,<latex>) 
				  crelaImg(150,"LARGE","//vec{u}") (// replaced by '\')
------------------------
special - crepq - crepqEval(<expression>,<language>) : evaluate expression
					crepqEval("3x+5(x-10/4)", "java") => 3x+5(x-2)
					crepqEval("3x+5(x-10/4)", "") => 3x+5(x-2.5)
					crepqEval("!(a>5)", "java") => a<=5
------------------------
special - creta - creta(<rows>,<cols>,<minval>,<maxval>) : create table (variable not used)
special - creta - cretaOut(<mode>) : get Java Methode to solve table. 
				mode : STD : only 1 if-structure, only 1 return, without complex conditions, without initialisation of result
				       STI : only 1 if-structure, only 1 return, without complex conditions, with initialisation of result
				       RET : without complex conditions, without else, without initialisation of result
				       CPX : with complex conditions, with minimum of conditions, without initialisation of result
============================================================================
Loops:
repeat(<loops>,<sta1>[,<sta2>...]) - repeat instructions <loops> times
until(<cond>,<sta1>[,<sta2>...])   - repeat instructions until condition is verified (loop is executed at least once)
while(<cond>,<sta1>[,<sta2>...])   - while condition is verified repeat instructions  (loop may be not executed)
Alternative:
if(<condition>, <cmd1>[, ...])
Jumps:
goto(<taget>) - jump to target (only forward, not backward, targets are defined by ':')
============================================================================