Reference manual TRIP

TRIP is a general computer algebra system dedicated to celestial mechanics.

Authors :

• J. Laskar
• Astronomie et Systèmes Dynamiques
• Institut de Mécanique Céleste
• 77 avenue Denfert-Rochereau
• 75014 PARIS
• email : laskar@imcce.fr

• M. Gastineau
• Astronomie et Systèmes Dynamiques
• Institut de Mécanique Céleste
• 77 avenue Denfert-Rochereau
• 75014 PARIS
• email : gastineau@imcce.fr

With the contributions of E. Paviot, F. Thire, D. Acheroff, M. To, A. Ceyrac, G. Rouault, V. Kelsch.

This software includes a library developped by the NetBSD fundation and its contributors.

This software includes the libraries LAPACK and 'SCSCP C Library'.

This software is dynamically linked to the libraries LTDL, GMP, MPFR et MPC. The source of these libraries could be downloaded from the web site specified in the Chapter References (see section References).

TRIP version 1.1.18

Copyright ©TRIP 1988-2011 J.Laskar/ASD/IMCCE/CNRS

1. Introduction

In order to execute TRIP, you must

• - Under Unix or MacOs X, enter trip in a shell window.
• - Under Windows, click on trip icon for the console version.
• - Under Windows, click on tripstudio icon for the graphic version.

You will see on screen :

              **** BIENVENUE SUR TRIP v1.0.0 ****

Taper 'help;' ou '?;' pour obtenir de l'aide

> 

TRIP is ready to receive your commands. TRIP has a case sensitive interpreter.

In order to compute S=(X+Y)^2, you must just enter :

              **** BIENVENUE SUR TRIP v1.0.0 ****

Taper 'help;' ou '?;' pour obtenir de l'aide

> S=(X+Y)^2;
S(X,Y) = 1*Y**2 + 2*Y*X + 1*X**2

Use the up-arrow key, you could bring back the previous command. Command-line input can be edited using arrow keys.

To exit TRIP, you enter quit or exit.

The reserved keywords for TRIP language are specified in the Annexes. TRIP contains several keyword categories :

• - TRIP global variables, TRIP constants and mathematic symbol.
• - Functions : command returns a value
• - Procedures : command doesn't return a value.

When TRIP starts or the commands reset or @@ are executed, it reads these files in the following order :

These file may contain any valid instructions.

Recommendations :

• - The following environment variables should be set and exported:
  • TMPDIR : pathname of a directory in which temporary files may be written.
  • LC_MESSAGES : language used to display messages.

2. Semantic

2.1 expression

An expression can contain all defined operators on object identifiers and can call functions or commands. An expression must be always ended with ; or $ . The character ; implies the execution of the expression and displays the result. The character$ implies only the execution of the expression. Several instructions separated with the character ; or $ could follow. They will be executed sequentially.

A comment on one or more lines is defined as /* .... */, like in the C language. A single-line comment starts with the characters //, like in the C++ language.

 Example :
> s=1+t; /* calcule 1+t et affiche le resultat */
s(t) = 1 + 1*t
> s1=(1+x+y)^2$ /*calcule mais n'affiche pas le resultat. */
> s1; // affiche le contenu de s1 
s1(x,y) = 
                         1
 +                       2*y
 +                       1*y**2
 +                       2*x
 +                       2*x*y
 +                       1*x**2

2.2 object identifier

An object identifier must begin with a letter and must contain only letters (lower-case or upper-case) and/or number (09) and the characters _ or ' .

By default, an object identifier is global, so it will be viewed by any instruction. An object identifier could be local to a macro, so it will be only viewed from this macro and it will be destroy each time the execution of this macro finished. A TRIP reserved keyword can't be used as the name of an object identifier.

The object identifier can have the following type :

• - variable
• - serie
• - constant
• - array of series
• - array of variables
• - numerical vector
• - string of characters

 Example :
> ch="file1"$
> s=1+x$
> dim t[1:2];
> z=1+2*i;
z = (1+i*2)
> bilan;
ch  CHAINE
s   SERIE
t   TAB
x   VAR

2.2.1 Visibility

Commande: private

private <object identifier> x ,...;

The specified object identifiers will be locals to the macro or to the loop (for, while, sum) or at the end of each iteration of loop (for, while, sum).

If a local object identifier has the same name as a global object identifier, then the local object identifier will be used. In this case, the local object identifier hides the global object identifier during the execution of the macro.

 Example :
> macro least_ab[TX,TY,a,b] {
 private S, SY, SXY, SXX, DEL; /* identificateurs locaux */
 S=size(TX)$
 SX=sum(TX)$
 SY=sum(TY)$
 SXY=sum(TX*TY)$
 SXX=sum(TX*TX)$
 DEL=S*SXX-SX*SX$
 a = (S*SXY-SX*SY)/DEL$
 b = (SXX*SY-SX*SXY)/DEL$
};


tx=1,10;
ty=3*tx;
%least_ab[tx,ty,[a],[b]];
bilan;

> tx     Tableau de reels : nb reels =10
> ty     Tableau de reels : nb reels =10
> > SX  CONST
a   CONST
b   CONST
tx  TABNUMREEL
ty  TABNUMREEL
> 

> 
macro detval[T] 
{
 private T2; /* identificateurs locaux */
 dim T2[1:3,1:3]$
 T2[:,::]=0$
 T2[1,1]=T**2$
 T2[2,2]=1-T$
 T2[3,3]=T$
 return det(T2);
};
> %detval[5];
 -500

2.3 serie

A serie is a polynomial of degree n (n is an integer). It depends on one or more variables.

 Example :
> s=1+x;
s(x) = 1 + 1*x
> s2=(1+x+y);
s2(x,y) = 1 + 1*y + 1*x
> bilan;
s   SERIE
s2  SERIE
x   VAR
y   VAR

2.4 constant

A constant is an integer, a real, a complex, a rational number or an interval. In rational numerical mode (_modenum = NUMRAT or _modenum = NUMRATMP), the input of 0.5 creates a floating-point number and not the rational number 1/2.

 Example :
>x = 2;
2
>y = 2.25;
9/4
>z = 1+2*i;
(1+i*2)
>bilan;
x     CONST
y     CONST
z     CONST
> _modenum=NUMDBLINT;
        _modenum   =    NUMDBLINT
> s = <1|2>;
 s = [+1.00000000000000E+00,+2.00000000000000E+00]

2.5 string

It's a list of characters surrounded with " ". It's used to specify the _path, to define the name of the files, to display messages, ... . There is no limit on the size. But, for the global variable _path, it's length is truncated to 256 (this value depends on the system). To produce a double-quotes (") in a string, two double-quotes must be used.

 Example :
>vi "toto";
> ch = "file" + "1";
ch = "file1"
> sch = "../" + ch;
sch = "../file1"
> sch1 = sch + "." + str(12);
sch1 = "../file1.12"
> ch3="nomsuivide""fin";
ch3 = "nomsuivide"fin"

2.6 real

<nom> = <real> ;

A real floating-point number is always displayed or inputed in base 10. The symbol d, e, E or D is the exponentiation symbol.

 Example :
> a=2.125E6;
a = 2125000
> q=3D2;
q = 300
> r=0.123554545;
r = 0.123554545

2.7 complex

<nom> = <real> + i * <real> ;

A complex number is allowed. The lower-case i or upper-case I specifies the imaginary part of the complex number.

 Example :
>  x=2+i*3;
x = (2+i*3)
> y=-5+4*i;
y = (-5+i*4)

2.8 filename

It's a string of characters. This string must be surrounded with " " if the string contains the character space " [ ] { } () or more than one points. A file name could be the content of an object identifier of type string. These file names are relative to the variable _path, excepted for the file names build with the function file_fullname (see section file_fullname).

 Example :
> read("fichier.1.dat",T);
> s="ell."+str(10)+".asc";
s = "ell.10.asc"
> read(s,T);

2.9 file

It's an object identifier which specifies a file, which is opened in reading or writing mode.

 Example :
> f = file_open("fichier.1.dat",read);
> file_close(f);

The definition of the function, subroutines and variables use the following types :

3. Global variables

The content of a global variable is performed by entering its name followed with ; . The content of all global variables is displayed with the command vartrip (see section vartrip). All global variables, containing a real number, are stored in a double-precision real number.

3.1 _affc

Variable: integer _affc

_affc = {1, 2, 3, 4, 5, 6, 7, 8, 9};

Set the format to display the numerical coefficients of series or constants.

Default value = 4.

• = 1 : %G (default short format)
• = 2 : %.8G (8 digits after the decimal points)
• = 3 : %.10G (10 digits after the decimal points)
• = 4 : %20.15G (15 digits or more after the decimal points)
• = 5 : rational approximation (double-precision real numbers are converted to rationals number using the continued fraction, else %.8G)
• = 6 : same as 5 but %.15G (15 digits after the decimal points)
• = 7 : rational approximation (fixed length format)
• = 8 : %15.6E (6 digits after the decimal points)
• = 9 : same as 8 but displays the diameter of intervals

 Example :
> _affc=1;
    _affc = 1
> 1/3;
    0.333333
> _affc=2;
    _affc = 2
> 1/3;
    0.33333333
> _affc=3;
    _affc = 3
> 1/3;
    0.3333333333
> _affc=4;
    _affc = 4
> 1/3;
       0.333333333333333
> _affc=5;
    _affc = 5
> 1/3;
    1/3
> _affc=6;
    _affc = 6
> 1/3;
    1/3
> _affc=7;
    _affc = 7
> 1/3;
         1/3     
> _affc=8;
    _affc = 8
> 1/3;
       3.333333E-01
> _affc=9; _modenum=NUMDBLINT;
    _affc = 9
    _modenum   =    NUMDBLINT
> 1/3;
    [+3.333333333333333E-1,+3.333333333333334E-1 (   5.551115E-17)]

3.2 _affdist

Variable: integer _affdist

_affdist = {0, 1, 2, 3, 4, 5, 6, 7};

Set the format to display the series

Default value = 2.

• = 0 : recursive.
• = 1 : distributed.
• = 2 : distributed with one term by line.
• = 3 : distributed with (co)sinus .
• = 4 : distributed with (co)sinus and one term by line.
• = 5 : distributed and aligned with (co)sinus and one term by line.
• = 6 : distributed and factorized for variables specified in _affvar.
• = 7 : distributed with one term by line and factorized for variables specified in_affvar.

Remarks : if _affvar is empty, then the format of _affdist = 6, respectively 7, is the same as _affdist=1, respectively 2.

 Example :
>_affdist = 2;
>x = 1+y;
x(y) = 
1
+ 1*y

3.3 _comment

Variable: boolean _comment

_comment {on,off};

Enable or disable the display of comments.

Default value = off.

 Example :
> _comment;
_comment OFF
> /* série à deriver : /* s=1+x */  : */;
> _comment on;
> /* série à deriver : /* s=1+x */  : */;
série à deriver :  s=1+x   : 
> _comment off;

3.4 _cpu

Variable: integer _cpu

_cpu = <integer> ;

Specify the number of processors which will be used for later computations.

The specified value can't be greater than the number of available processors or cores on the computer.

Default value : number of active processors or cores on the computer.

 Example :
> _mode=POLP;
		_mode      =    POLP
> _cpu=1;
	_cpu = 1
> time_s; s=(1+x+y+z+t+u)^30$ time_t(usertime, realtime);
03.321s  -  ( 99.44% CPU)
> msg("the real time is %g\n", realtime);
the real time is 3.33976
> _cpu=4;
	_cpu = 4
> time_s; s=(1+x+y+z+t+u)^30$ time_t(usertime, realtime);
03.339s  -  (322.89% CPU)
> msg("the real time is %g\n", realtime);
the real time is 1.03414

3.5 _echo

Variable: boolean _echo

_echo = {0, 1};

_echo {on,off};

Enable or disable the display of the echo of the executed commands.

Default value = off.

• = 1 : Display the echo of the commands (same as on).
• = 0 : Don't Display the echo of the commands (same as off)

 Example :
>_echo = 1;
>msg "exemple";
exemple
cde>>
msg "exemple"; 

3.6 _endian

Variable: name _endian

_endian = {little , big};

Specify the byte order (big-endian or little-endian) in binary files.

Default value = endianness in the computer.

• = big : big-endian
• = little : little-endian

 Example :
> _endian=big;
                _endian    =    big
> vnumR ieps;
> readbin(file1.dat,"%u",ieps);

3.7 _graph

Variable: name _graph

_graph = gnuplot;

_graph = grace;

Specify if the plot, replot, plotps, plotf commands will use the grace or gnuplot (see section Graphics) software to display graphics.

Default value = gnuplot.

• = gnuplot : gnuplot will display the graphics.
• = grace : grace will display the graphics.

 Example :
> _graph = grace;
                _graph      = grace
> _graph = gnuplot;
                _graph      = gnuplot

3.8 _hist

Variable: boolean _hist

_hist {on,off};

Specify if the file ‘history.trip’ is opened or not.

If the file is opened, all commands are stored in this file.

Default value = on.

 Example :
>_hist;
_hist = ON

3.9 _history

Variable: string _history

_history = <string> ;

Specify the folder where the file ‘history.trip’ will be written.

Default value = "".

 Example :
> _history="/users/toto/";       
        _history = /users/toto/

3.10 _info

Variable: booleen _info

_info {on,off};

Enable or disable the display of the message information.

Default value = on.

 Example :
> _modenum=NUMQUAD;
                _modenum   =    NUMQUAD
> x1=0,2*pi,2*pi/59$
> x2=0,3,0.5$
> _info off;
        _info off
> sl=interpol(LINEAR,x1,cos(x1),x2)$
> _info on;
        _info on
> sl=interpol(LINEAR,x1,cos(x1),x2)$
 Information : interpol effectue l'interpolation numerique en double-precision.
 

3.11 _language

Variable: _language

_language = {fr, en };

Select the language to display messages.

Default value =

• - On Unix, Linux and MacOS X, depends on the environment variable LC_MESSAGES. If it doesn't exist, the french language is used.
• - On Windows, depends on the system preferences.

 Example :
> _language = en ;
                _language    =    en
> Exp(x, y);
TRIP[ 3 ] : This parameter must be an integer  
        Command :' Exp(x, y);'
                          ^
> _language = fr;
                _language    =    fr
> Exp(x, y);
TRIP[ 3 ] : Cet argument doit etre un entier
        Commande :'Exp(x, y);'

3.12 _mode

Variable: _mode

_mode = {POLY, POLP };

Specify the internal representation of the series for their storage in the memory and during the computations.

The internal representation could be changed during the computations.

Default value = POLY.

• - POLY : series are stored using a recursive list (recursive sparse representation). This is the default mode. The leaf nodes use generic containers. This mode is efficient for the very degree.
• - POLP : series are stored using a recursive vector (recursive dense representation). The leaf nodes use generic containers. It should be used if the degree of series are low.
• - POLYV : series are stored using a recursive list (recursive leaf sparse representation). The leaf nodes use optimized containers. This mode is efficient for the very degree.
• - POLPV : series are stored using a recursive vector (recursive leaf dense representation). The leaf nodes use optimized containers. It should be used if the degree of series are low.

 Example :
> _mode=POLY;
		_mode      =    POLY
> s1=(1+x)^100$
> s2=1+x^100$
> bilan mem;
          Nom       		    Memoire (octets)		        Nb de termes
--------------------		--------------------		--------------------
                  s1		                4848		                 101
                  s2		                  96		                   2
--------------------		--------------------		--------------------
                    		                4944		                 103

Memoire physique utilisee =	7118848 octets
Memoire maximale utilisee =	2783817728 octets
> _mode=POLP;
		_mode      =    POLP
> s1=(1+x)^100$
> s2=1+x^100$
> bilan mem;
          Nom       		    Memoire (octets)		        Nb de termes
--------------------		--------------------		--------------------
                  s1		                3232		                 101
                  s2		                3232		                   2
--------------------		--------------------		--------------------
                    		                6464		                 103

Memoire physique utilisee =	7208960 octets
Memoire maximale utilisee =	2784210944 octets

> _mode=POLY$ time_s; s1=(1+x)^100$ time_t;
00.240s  -  ( 47.74% CPU)
> _mode=POLP$ time_s; s1=(1+x)^100$ time_t;
00.013s  -  ( 40.57% CPU)

3.13 _modenum

Variable: _modenum

_modenum = {NUMDBL, NUMRAT, NUMRATMP, NUMQUAD, NUMFPMP};

Specify the representation of the numerical coefficients in the series and the precision of the floating point numbers in the numerical vectors.

This mode could be changed during the session.

Default value = NUMDBL.

The numerical coefficients are encoded as followed :

• - NUMDBL : double precision floating-point. (default)
• - NUMQUAD : quadruple precision floating-point. This representation isn't supported on Windows operating system.
• - NUMRAT : integer or rational number, otherwise double precision floating-point.

  The absolute value for the numerator and denomiator is between 0 et 2**62 on most computers. If the numerator or denomiator becomes too large, rational number is converted in a double precision floating-point.

  The real numbers are stored in double precision format. For example, the coefficient "2.0" will be stored as a double precision floating-point while the coefficient "2" is stored as a rational number.

• - NUMRATMP : multiprecision rational, otherwise double precision real.

  The absolute value for the numerator and denomiator don't have any limits.

  The real numbers are stored in double precision format. For example, the coefficient "2.0" will be stored as a double precision floating-point while the coefficient "2" is stored as a rational number.

  This numerical representation uses the GMP library (type mpz_t or mpq_t). On the 64 bit operating systems, integers smaller than 2^63-1 (in absolute value) use the hardware instructions instead of the GMP library.

• - NUMFPMP : multiprecision floating-point.

  The number of number of digits of precision is specified by the global variable _modenum_prec (see section _modenum_prec). This numerical representation uses the MPFR and the MPC library.

In the mode NUMRAT and NUMRATMP, numerical vectors contain always double precision floating-points (real or complex numbers).

 Example :
> _affc=4;
    _affc = 4
> _modenum=NUMDBL;
        _modenum   =    NUMDBL
> s=1/11;
s =   0.0909090909090909
> _modenum=NUMRAT;
        _modenum   =    NUMRAT
> s=1/11;
s =          1/11       
> _modenum=NUMFPMP;
                _modenum   =    NUMFPMP
> pi;
        3.1415926535897932384626433832795028841971693993751058209749445924

3.14 _modenum_prec

Variable: integer _modenum_prec

_modenum_prec = <integer> ;

Variable used if _modenum = NUMFPMP (see section _modenum).

Specify the number of significant decimal digits for the multiprecision real numbers.

Default value = 64.

 Example :
> _modenum=NUMFPMP;
		_modenum   =    NUMFPMP
> _modenum_prec= 20;
	_modenum_prec = 20
> pi;
	3.14159265358979323846
> _modenum_prec= 40;
	_modenum_prec = 40
> pi;
	3.1415926535897932384626433832795028841975

3.15 _naf_dtour

Variable: real _naf_dtour

_naf_dtour = <real> ;

Variable used by naf (see section Frequency analysis).

Specify the "length of the dial turn ".

Default value = 2*pi.

 Example :
> _naf_dtour=360;

3.16 _naf_icplx

Variable: integer _naf_icplx

_naf_icplx = {0, 1};

Variable used by naf (see section Frequency analysis).

Specify if the function is real or complex.

Default value = 1.

The available values are :

• = 0 : real function
• = 1 : complex function

 Example :
> _naf_icplx=0;

3.17 _naf_iprt

Variable: integer _naf_iprt

_naf_iprt = {-1 , 0, 1, 2};

Variable used by naf (see section Frequency analysis).

Specify the verbosity to display messages in the commands naf and naftab. Intermediate results are stored in a file.

Default value = -1.

The available values are :

• = -1 : No display.
• = 0 : Few messages are displayed.
• = 1 : More messages are displayed.
• = 2 : Many messages are displayed.

 Example :
> _naf_iprt  = 2;

3.18 _naf_isec

Variable: integer _naf_isec

_naf_isec = {0, 1};

Variable used by naf (see section Frequency analysis).

Specify if the algorithm "secantes" is used or not in the commands naf and naftab.

Default value = 1.

The available values are :

• = 0 : algorithm "secantes" is not used.
• = 1 : algorithm "secantes" is used.

 Example :
> _naf_isec=1;

3.19 _naf_iw

Variable: integer _naf_iw

_naf_iw = <integer> ;

Variable used by naf (see section Frequency analysis).

Specify if a window filter is set.

Default value = 1.

The available values are :

• = -1 : eponential window PHI(T) = 1/CE*EXP(-1/(1-T^2))

  avec CE= 0.22199690808403971891E0

• = 0 : no window
• = N > 0 : PHI(T) = CN*(1+COS(PI*T))**N avec CN = 2^N(N!)^2/(2N)!

 Example :
> _naf_iw=-1;

3.20 _naf_nulin

Variable: integer _naf_nulin

_naf_nulin = <integer> ;

Variable used by naf (see section Frequency analysis).

Specify the number of lines to be ignored at the beginning of the data file.

Default value = 1.

 Example :
> _naf_nulin=0;

3.21 _naf_tol

Variable: real _naf_tol

_naf_tol = <real> ;

Variable used by naf (see section Frequency analysis).

Specify the tolerance to check if two frencuencies are equal.

Default value = 1E-10.

 Example :
> _naf_tol=1E-4;

3.22 _path

Variable: string _path

_path = <string> ;

_path = "chemin du repertoire";

Specify the folder used to save or load files. All TRIP commands or functions writing or reading files will prepend the filename with this path. loading trip programs (include), creating psotscript files(plotps) and plotting files (plotf) will use this path.

Default value = "" (current folder).

Remarque :

• - Don't miss the character "/" at the end of the path on UNIX or MACOS X.
• - Don't miss the character "\" at the end of the path on WINDOWS.

 Example :
_path = "/u/gram/trip/"; /* UNIX */
_path = "\u\gram\trip\"; /* WINDOWS */

3.23 _time

Variable: boolean _time

_time {on, off};

enable or disable display of partial time after each executed command.

When the command _time on is performed, an implicit call to time_s and the time 0.00s is always displayed after it.

Default value = off.

 Example :
> macro temps
{
s=(1+x+y+z)**20$
_time on;
s=(1+x+y+z)**20$
q=s$
_time off;
};
> %temps;
00.0s
08.10s
00.12s
>

3.24 I

constant: complex i

constant: complex I

i^2 = -1

 Example :
>z = x + y*i;
z(x,y) = (0+i*1)*y+1*x

3.25 PI

constant: real pi

constant: real PI

The mathematical symbol pi

 Example :
>z = pi; 
 3.14159265358979

4. Variables

4.1 crevar

Function : crevar

crevar (<chaine ou nom> radical, <integer> indice1, <integer> indice2,...);

Create and return a variable with the name radical+"_"+ indice1 + ... + "_" + indicen.

crevar (<chaine ou nom> radical);

Create and return a variable with the name radical. This function allow to create variables with a non-standard name.

 Example :
>dimvar t[1:3];
>t[1]:=crevar("t",1);
>t[3]:=crevar("tab",3,2,1);
>afftab(t);
t[1] =  t_1 = 1*t_1
t[2] = 
t[3] =  tab_3_2_1 = 1*tab_3_2_1
> dimvar u[1:2];
>  u[1]:=crevar("\bar{X}");
> u[1];
u[1] =  \bar{X} = 1*\bar{X}

5. Series

5.1 Operators

Operator : + - * /

TRIP performs the addition (or unary plus), the subtraction (or unary minus), multiplication, or division between series, , variables, numbers and expressions.

To perform the addition, multiplication, subtraction and division of the arrays, the operators are +, *, - and /.

The operators +, *, -, / could be applied on numerical vectors.

The unary + or - could be applied to any type.

Remark : The division by a serie isn't available. You should use the function div to perform the euclidian division.

 Example :
> s=1+x-y*z+t/2;
s(x,y,z,t) = 1 + 1/2*t - 1*y*z + 1*x
> _modenum=NUMRATMP;
		_modenum   =    NUMRATMP
> p=5/3;
p = 5/3
> _modenum=NUMQUAD;
		_modenum   =    NUMQUAD
> p=5/3;
p =   1.6666666666666666666666666666666667

Operator : ** ^

<serie> **<real>

It performs the exponentiation.

It supports integer powers.

The exponentation **-1 on an array, with 2 same dimensions, performs the matrix inversion.

Remarks : The exponentiation, term by term, on arrays isn't available.

 Example :
> u=2**3;
8
> z=(1+i)**3;
(-2+i*2)

> s=(1+x+y)**2;
s(y,x) = 1 + 2*x + 1*x**2 + 2*y + 2*y*x + 1*y**2

5.2 Standard functions

Function : size

size(<serie> s )

It returns the number of terms in the serie s.

 Example :
> s=1+x*y+z*t-i*p;
s(x,y,z,t,p) = 1 + (-0-i*1)*p + 1*t*z + 1*y*x
> size(s);
    4

5.3 Differentiation and integration

Function : deriv

deriv(<serie> , <variable> )

It computes the total derivative of the serie with respect to one variable .

 Example :
> s=(1+x+y)**2;
s(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2
> deriv(s,x);
    2 + 2*y + 2*x

Function : integ

integ(<serie> , <variable> )

It integrates the serie with respect to one variable .

 Example :
>  s=(1+x+y)**2;
s(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2
> integ(s,x);
    1*x + 2*x*y + 1*x*y**2 + 1*x**2 + 1*x**2*y + 1/3*x**3

5.4 Euclidian division

Procedure: div

div(<serie> f, <serie> g, <object identifier> q, <object identifier> r )

It computes the quotient and the remainder of f divided by g such that f=q\times g +r and degree(r)<degree(g). The quotient is stored in q and the remainder in r.

 Example :
> div(x^3+x+1, x^2+x+1, q,r);
 > q;
q(x) = 
 -                       1
 +                       1*x

> r;
r(x) = 
                         2
 +                       1*x

5.5 Selection

5.5.1 coef_ext

Function : coef_ext

coef_ext(<serie> , (<variable> ,<integer> ),...)

Return the coefficient of the variable raised to the specified value from the serie.

coef_ext(S,(X,n),(Y,m)) returns the coefficient of X^n*Y^m in the serie S.

 Example :
>  S= (1+x+y+z)**4 $
> coef_ext(S,(x,1),(y,2));
  12 + 12*z

5.6 Evaluation

5.6.1 coef_num

Function : coef_num

coef_num(<serie> , (<variable> ,<constant> ),...)

Substitute in a serie one (or more) variable(s) by one (or more) numerical value(s).

 Example :
> S= (1+x+y+z)**4 $
> coef_num(S,(x,0.1),(y,2));
    923521/10000 + 29791/250*z + 2883/50*z**2 + 62/5*z**3 + 1*z**4

5.6.2 evalnum

Function : evalnum

evalnum(<serie> , {REAL/COMPLEX} , (<variable> ,<num. vec.> ),...)

Evaluates the serie with substituting all variables by their value in the associated numerical vectors.

The function returns a numerical vector of real numbers if REAL is specified or else a numerical vector of complex numbers COMPLEX is specified.

All numerical vectors must have the same size.

 Example :
> serie=sin(x+y)-2*y;
serie(y,_EXy1,_EXx1) = (-0+i*1/2)*_EXy1**-1*_EXx1**-1 
+ (0-i*1/2)*_EXy1*_EXx1 - 2*y
> TABX=0,pi,pi/6;
TABX     Tableau de reels : nb reels =7
> TABY=-pi,0,pi/6;
TABY     Tableau de reels : nb reels =7
> TABRES=evalnum(serie,REAL,(x,TABX),(y,TABY));
TABRES   Tableau de reels : nb reels =7
> writes(TABRES);
+6.283185307179586E+00  
+4.369962352198550E+00  
+3.322764801001953E+00  
+3.141592653589793E+00  
+2.960420506177634E+00  
+1.913222954981037E+00  
+1.224646799147353E-16  
> writes(TABX);
+0.000000000000000E+00  
+5.235987755982988E-01  
+1.047197551196598E+00  
+1.570796326794897E+00  
+2.094395102393195E+00  
+2.617993877991494E+00  
+3.141592653589793E+00  
> TABRES=evalnum(serie,COMPLEX,(x,TABX),(y,TABY));
> writes(TABRES);
+6.283185307179586E+00  +0.000000000000000E+00  
+4.369962352198550E+00  +0.000000000000000E+00  
+3.322764801001953E+00  -5.551115123125783E-17  
+3.141592653589793E+00  +0.000000000000000E+00  
+2.960420506177634E+00  +0.000000000000000E+00  
+1.913222954981037E+00  +0.000000000000000E+00  
+1.224646799147353E-16  +0.000000000000000E+00  

6. Constants

6.1 Standard functions

Most of the functions are described in (see section Numerical vectors).

6.1.1 factorial

Function : fac

fac( <integer> n);

Return n! (factorial function).

 Example : :
> fac(3);
    6
> n=5;
n = 5
> fac(n+1);
    720

6.2 Input/output on real numbers

These functions perform the sequential writing and reading of a text file containing only real values.

Procedure: ecriture

ecriture(<filename> );

Open a file in writing mode in the folder specified by _path. If the file doesn't exist, it will be automatically created.

 Example : :
> ecriture("fichier1.dat");

Procedure: lecture

lecture(<filename> );

Open a file in reading mode in the folder specified by _path.

 Example : :
> lecture("fichier1.dat");

Procedure: print

print(<real> );

Write a double-precision floating-point number in the file opened (with the command ecriture).

 Example : :
> ecriture("fichier1.dat");
> print(atan(1)); /* on écrit pi/4 dans fichier1.dat */

Function : read

read;

Read a floating-point number in the file opened (with the command lecture) and return a double-precision floating-point number.

 Example : :
> ecriture("fichier1.dat");
> print(atan(1));
> close;
> lecture("fichier1.dat");
>  s=read;
s = 0.785398163397448
>  close;

Procedure: close

close;

Close the file of real numbers if it has been opened (for reading or writing).

 Example : :
> ecriture("fichier1.dat");
> print(atan(1));
> close;

7. Strings

7.1 Declaration and assignment

Character string's declaration is implicit. It will be realized when assignment are performed. To produce double-quote (") in a string, you must double it.

<nom> = <string> ;

 Example :
/* L'exemple suivant declare les chaines ch et ch2. */
> ch="file";
ch = "file"
> ch2=ch+".txt";
ch2 = "file.txt"

7.2 Concatenation

<nom> = <string> + <string> ;

Operator + concatenates two character strings. Length of string isn't limited.

 Example :
> ch = "file" + "1";
ch = "file1"
> sch = "../" + ch;
sch = "../file1"
> sch1 = sch + "." + str(12);
sch1 = "../file1.12"

7.3 Repetition

Operator : *

<string> * <integer>

<integer> * <string>

Operator * takes an character string and duplicate it as many times as specified by the integer. The integer must be positive or nul. If the integer is 0, then an empty string is returned.

 Example :
> s=" %g";
s = " %g"
> format=4*s+"\n";
format = " %g %g %g %g\n"
> t=1,10$
> writes(format, t,t**2, t**3, t**4);

7.4 Comparaison

Operator : ==

<string> == <string>

The Operator == returns true if the strings of characters are equal else it returns false.

 Example :
> s="monchemin";
s = "monchemin"
> if (s=="monchemin") then { msg "true"; } else { msg "false"; };
true

Operator : !=

<string> != <string>

The Operator != returns false if the strings of characters are equal else it returns true.

 Example :
> s="monchemin";
s = "monchemin"
> if (s=="MON") then { msg "true"; } else { msg "false"; };
false

7.5 Conversion from an integer or a real to a string

Function : str

str( <integer> );

str( <real> );

str( <string> format, <real> );

Convert an integer or a real number in a character string. If format is specified, then the integer or real number is converted to this format. The format specification is similar to that for the printf function of the C-language.

The conversion specifiers are

• - g,G The number is converted as a real (style [-]dddd.dddd or scientific style [-]d.dddE+-dd if exponent is too large).
• - e,E The number is converted as a real (scientific style [-]d.dddE+-dd).
• - f,F The number is converted as a real (style [-]d.dddE+-dd).
• - d,i The number is converted as an integer. If the argument is a real number, only its integer part is converted. If the numerical mode NUMRAT or NUMRATMP is selected, then the rational numbers as written as "numerator/denominator".

The length modifier aren't supported. For example, the format "%lg" will be rejected and produce an error.

If the numerical mode NUMRAT or NUMRATMP is selected, then the rational numbers as written as "numerator/denominator" if no format are specified.

 Example :
> ch= str(1235);
ch = "1235"
> ch=str(int(2*pi));
ch = "6"
> s=str(2E3);
s = "2000"
> s=str("%.4g",pi);
s = "3.142"
> _modenum=NUMRATMP;
                _modenum   =    NUMRATMP
> s=str("%d", 3/2);
s = "3/2"
> s=str("%g", 3/2);
s = "1.5"

7.6 Conversion from a list of integers or reals to a string

Function : msg

msg(<string> textformat, <real> x, ... );

Create a string using the format with the real constants.

The format is the same as the command printf in language C (see section Conversion from an integer or a real to a string, for the valid conversion specifiers). This format must be a string and could be on several lines.

To create a double-quotes, two double-quotes must be used.

 Example :
> ch = msg("pi=%g pi=%.8E",pi,pi);
ch = "pi=3.14159 pi=3.14159265E+00"
> _modenum=NUMRATMP;
		_modenum   =    NUMRATMP
> s=msg("%d %g", 1/11, 1/11);
s = "1/11 0.0909091"

7.7 Length of a string

Function : size

size( <string> );

it computes the length of the string, that is to compute the number of characters.

 Example :
> ch = "1235";
ch = "1235"
> size(ch);
	 4

8. Arrays

TRIP has 3 types of arrays :

• - arrays of series and constants.
• - array of variables.
• - numerical vectors.

Matrix are arrays of series and constants. For the numerical vectors, see the appropriate chapter.

8.1 Declaration of array of series

Procedure: dim

dim <name> [ <list of dimension> ], ...;

Define one or more array of series with the specified dimensions.

Each dimension is separated with a comma. A dimension is defined with two integers which specifiy the index of the first element and the index of the last element for this dimension.

This type of array can contain series, constants, truncatures, strings of characters... but no variables.

 Example :
/*Ici, on déclare un tableau tl à deux dimensions
de séries ou de constantes*/
> dim tl [1:22,-2:6];        
/* on déclare 3 tableaux t1, t2 , t3 avec des dimensions différentes */
> dim t1[1:4], t2[5:6], t3[-1:3];

8.2 Initialization of an array of series

<name> = [<serie> ,... : <serie> , ...];

Create and intialize an array of series with the specified series and constants.

The symbol : specifies a new line and the symbol , separates the colmuns. It must have the same number of columns on each line.

 Example :
/*declare un tableau de series a 2 dimensions contenant des series*/
> tab=[1,2+2*x:(1+x)**2,(2+2*x)**2];
tab [1:2, 1:2]  nb elements = 4

> stat(tab);
   Tableau de series
tab [ 1:2 , 1:2 ]
...
                 
/*declare un tableau de series a 2 dimensions contenant des constantes*/
> tab2=[1,2,3:4,5,6];
tab2 [1:2, 1:3] nb elements = 6

8.3 Declaration of array of variables

Procedure: dimvar

dimvar <name> [ <list of dimension> ], ...;

Define one or more array of variables with the specified dimensions.

Each dimension is separated with a comma. A dimension is defined with two integers which specifiy the index of the first element and the index of the last element for this dimension.

To assign a existing variable to an array of variables, you should the symbol := instead of = .

 Example :
/*Ici, on declare un tableau t2 de variables a  une dimension */
>dimvar t2[1:5]; 
/* Maintenant, si on fait:*/
>t2[1,0] := x;
> deriv(S,t[1,0]); /* on aura la derivee de S par rapport a x. */

/* on declare 2 tableaux de variables tv1 et tv2 */
> dimvar tv1[1:2], tv2[1:3];

8.4 Generation of an array of variables

Procedure: tabvar

tabvar( <array of variables> );

Generate automatically the variables inside the specified array. The name of variables use the name of the array as radical and its indice.

 Example :
> dimvar t[0:3];
> tabvar(t);
> afftab(t);
t[0] =  t_0 = 1*t_0

t[1] =  t_1 = 1*t_1

t[2] =  t_2 = 1*t_2

t[3] =  t_3 = 1*t_3

8.5 Assignment to an array

Operator : =

<name> = <array> ;

Assign the array (operation between arrays) to the specified object identifier.

<array> [<integer> , ...] = <operation> ;

Assign a value to an element of an array. This operation can be a serie, a constant, a numerical vector, a truncature but not an array.

<array> [ <integer> binf : <integer> bsup : <integer> pas ,...]= <operation> ;

<array> [ <integer> binf : <integer> bsup ,...]= <operation> ;

Assign a value to a part of an array.

If the operation is a serie, a constant, a numerical vector, a truncature then the value is copied to each element of this part of array. If the operation is an array then each element of this array will be assigned to the corresponding element. In this case, it verifies that the number of elements and dimension is compatible.

If the lower bound is omitted then its value is assumed to be 1. If the upper bound is omitted then its value is assumed to be the size of the array. If the step is omitted then its value is assumed to be 1.

Remarks : any combination of omission are permitted.

 Example :
> dim t[1:4,7:25];
> t[1,7]=1+x;
t[1,7] = 1 + 1*x
> r=t;
r [1:4, 7:25]   nb elements = 76
> dim t[1:4,7:25];
>  dim t2[1:4];
> t2[:]=5;
> t[:,8]=t2;
> t[:,::2]=1+x;

Operator : :=

<array> [...] := <variable> ;

Assign a variable to an array of variables.

 Example :
> dimvar X[1:4];
> X[1]:=crevar(e,1,1);
> X[1];
X[1] =  e_1_1 = 1*e_1_1
>  deriv(1+2*e_1_1,X[1]);
    2

8.6 Size of an array

Function : size

size(<array> );

size(<array> ,<integer> );

Return the number of elements in the first dimension of the array or in the specified dimension by the integer.

If the specified dimension doesn't exist in the array then the function returns -1.

 Example :
> dim t[1:4,7:25];
> size(t,2);
    19
> size(t);
    4

8.7 Display an array

Procedure: afftab

afftab(<array> );

Display the content of the arrays of series or variables.

 Example :
> dim t[1:4];
> t[1]=1+x$
> t[2]=2*i$
> t[3]=({(x,y),2})$
> afftab(t);
t[1] = 1 + 1*x
t[2] = (0+i*2)
t[3] = ( { (x,y), 2 } )

t[4] = 

8.8 Extract an element

Operator : []

<array> [<integer> ,...];

Return the value of the element specified by the indexes.

<num. vec.> [ <integer> binf : <integer> bsup : <integer> pas,.. ];

<num. vec.> [ <integer> binf : <integer> bsup, .. ];

Return an array containing only the elements located between the lower and uper bounds with the specified step.

If the lower bound is omitted then its value is assumed to be 1. If the upper bound is omitted then its value is assumed to be the size of the array. If the step is omitted then its value is assumed to be 1.

Remarks : any combination of omission are permitted.

 Example :
> dim t[1:4];
> t[1]=1+x$
> s=t[1];
s(x) = 1 + 1*x
> t1=t[3:];
t1 [3:4]    nb elements = 2

> dim t[1:4,5:10];
> v2=t[:,6:];
v2 [1:4, 6:10]  nb elements = 20

8.9 Operations on array of series

Most of the functions are described in (see section Numerical vectors). The following functions could be applied on the arrays of series (as on the series) to avoid the loops for :

• coef_ext see section coef_ext
• coef_num see section coef_num

8.9.1 Matrix product

Operator : &*

<array> &* <array>

Compute the matrix product of the arrays (with 1 or 2 dimensions).

If the array has only one dimension then it's considered as an column-vector.

Remark : the number of columns of the first array must be same as the number of lines of the second array.

 Example :
> t=[x,y:x-y,x+y];
> t2=[x+y,x-y:x,y];
> r=t&*t2;
> afftab(r);
r[1,1] = 2*y*x + 1*x**2
r[1,2] = 1*y**2 - 1*y*x + 1*x**2
r[2,1] = -1*y**2 + 1*y*x + 2*x**2
r[2,2] = 2*y**2 - 1*y*x + 1*x**2

8.9.2 Matrix determinant

Function : det

det( <array> )

Computes the determinant of a matrix. The array must have two dimensions.

Remarks : When computations are performed in double precision, the Lapack Library is used. The LU algorithm is used in all numerical precision.

 Example :
> t=[9,0,7
     :1,2,3
     :4,5,6];
t [1:3, 1:3]    nb elements = 9
> det(t);
 -48

8.9.3 Matrix inversion

Function : **-1

<array> **-1

Computes the inverse of a matrix. The array must have two dimensions.

Remarks : When computations are performed in double precision, the Lapack Library is used. The LU algorithm is used in all numerical precision.

 Example :
> t=[9,0,7:1,2,3:4,5,6];

t [1:3, 1:3]    nb elements = 9

> r=t**-1;  

r [1:3, 1:3]    nb elements = 9

> afftab(r);
r[1,1] = 1/16
r[1,2] = -35/48
r[1,3] = 7/24
r[2,1] = -1/8
r[2,2] = -13/24
r[2,3] = 5/12
r[3,1] = 1/16
r[3,2] = 15/16
r[3,3] = -3/8

8.9.4 Eigenvalues

Function : eigenvalues

eigenvalues(<array> )

Compute the eigenvalues of the 2-dimensional array (square matrix) using a QR algorithm (lapack library).

 Example :
> t=[9,0,7:1,2,3:4,5,6];

t [1:3, 1:3]    nb elements = 9

> l=eigenvalues(t);

l [1:3] nb elements = 3

> afftab(l);
l[1] = 13.7691504189573
l[2] = 4.08436203480944
l[3] = -0.853512453766754

8.9.5 Eigenvectors

Procedure: eigenvectors

eigenvectors(<array> MAT, <array> TVECT, <array> TVAL)

eigenvectors(<array> MAT, <array> TVECT)

Compute the eigenvectors of the 2-dimensional array MAT (square matrix) using a QR algorithm (lapack library). It stores the eigenvectors in the array TVECT and the eigenvalues in the array TVAL.

 Example :
> t=[9,0,7:1,2,3:4,5,6];

t [1:3, 1:3]    nb elements = 9

> eigenvectors(t,vectp,valp);
> afftab(vectp); 
vectp[1,1] = -0.808169038149443
vectp[1,2] = -0.75057699194462
vectp[1,3] = -0.484663855953733
vectp[2,1] = -0.209021306608322
vectp[2,2] = 0.398522441432627
vectp[2,3] = -0.547409412438461
vectp[3,1] = -0.550611386696964
vectp[3,2] = 0.527080679628786
vectp[3,3] = 0.682234477218675
> afftab(valp);
valp[1] = 13.7691504189573
valp[2] = 4.08436203480944
valp[3] = -0.853512453766754
> /* 1er vecteur */ p=vectp[:,1];

p [1:3] nb elements = 3

> afftab(p);
p[1] = -0.808169038149443
p[2] = -0.209021306608322
p[3] = -0.550611386696964

8.9.6 Arithmetic

The arrays must have the same number of elements on each dimension and the number of dimension must be the same.

Operator : +

<array> + <array>

Add term by term two arrays of series.

Operator : +

<array> + <serie>

<serie> + <array>

Add a serie with each element of the array of series.

Operator : *

<array> * <array>

Multiply term by term two arrays of series.

Operator : *

<array> * <serie>

<serie> * <array>

Multiply a serie with each element of the array of series.

Operator : -

<array> - <array>

Substract term by term two arrays of series.

Operator : -

<array> - <serie>

<serie> - <array>

Subtract a serie with each element of the array of series.

Operator : /

<array> / <array>

Divide term by term two arrays of series.

Operator : /

<array> / <serie>

<serie> / <array>

Divide a serie with each element of the array of series.

 Example :
>  t2=[x+y,x-y:x,y];

t2 [1:2, 1:2]   nb elements = 4

> t=[x,y:x-y,x+y];

t [1:2, 1:2]    nb elements = 4

> r=t*t2*i-t*x;

r [1:2, 1:2]    nb elements = 4

> afftab(r);
r[1,1] = (0+i*1)*x*y + (-1+i*1)*x**2
r[1,2] = (-0-i*1)*y**2 + (-1+i*1)*x*y
r[2,1] = (1-i*1)*x*y + (-1+i*1)*x**2
r[2,2] = (0+i*1)*y**2 + (-1+i*1)*x*y - 1*x**2

8.10 Conversion

For the convertion to numerical vectors, (see section Conversion).

9. Numerical vectors

The numerical values stored in vectors are always real or complex double-precision, quadruple-precision or multiprecision numbers depending on the current numerical mode.

9.1 Declaration

Explicit declaration for numerical vectors are only required before call to read , readbin (see section Input/Output) and resize . Explicit declaration for array of numerical vectors are always required.

Procedure: vnumR

vnumR <name> , ... ;

vnumR <name> [ <dimension of an array> ] , ... ;

It declares a real vector or an array of real vectors.

The dimension specifies the number of elements in the array of real vectors. The real vector's size is dynamic. After the declaration, the real vectors are empty. To set their sizes, the command resize must be used.

 Example :
> vnumR T;
> vnumR TAB[1:10];
> vnumR A, C, T[1:10];

Procedure: vnumC

vnumC <name> , ... ;

vnumC <name> [ <dimension of an array> ] , ... ;

It declares a complex vector or an array of complex vectors.

The dimension specifies the number of elements in the array of complex vectors. The complex vector's size is dynamic. After the declaration, the complex vectors are empty. To set their sizes, the command resize must be used.

 Example :
> vnumC T;
> vnumC TABZ[2:10];
> vnumC A, C, T[1:10];

9.2 Initialization

Procedure: ,,,

<name> = <real> binf , <real> bsup , <real> step ;

It declares and initializes a real vectors such that all elements are initialized by a loop (from binf to bsup with the step bstep):

for (j=1, valeur=binf) to valeur<=bsup step (j=j+1, valeur=valeur+bstep) <name> [j]=valeur

The step bstep is optional; By default, its value is 1.

 Example :
> tab=-pi, 6, pi/100;
tab  Tableau de reels : nb reels =291
> writes([::30],tab);
-3.141592653589793E+00  
-2.199114857512855E+00  
-1.256637061435917E+00  
-3.141592653589789E-01  
+6.283185307179591E-01  
+1.570796326794897E+00  
+2.513274122871835E+00  
+3.455751918948773E+00  
+4.398229715025711E+00  
+5.340707511102648E+00  
> t=0,10;
t    Tableau de reels : nb reels =11
> writes(t);
+0.000000000000000E+00  
+1.000000000000000E+00  
+2.000000000000000E+00  
+3.000000000000000E+00  
+4.000000000000000E+00  
+5.000000000000000E+00  
+6.000000000000000E+00  
+7.000000000000000E+00  
+8.000000000000000E+00  
+9.000000000000000E+00  
+1.000000000000000E+01  
> 

Procedure: vnumR[,,:,,]

<name> = vnumR [ <real> ou <real vec.> ou <array of real vec.> , ... : <real> ,... ] ;

It declares and initializes a real vector or an array of real vectors with the specified reals or real vectors.

The character : separates the lines and the character , separates the columns. All columns must have the same line counts.

 Example :
> /*declare un tableau de 3 tableaux de 2 reels */
tab3=vnumR[1,2,3:4,5,6];

tab3 [1:3]  nb elements = 3

> writes(tab3);
+1.000000000000000E+00  +2.000000000000000E+00  +3.000000000000000E+00  
+4.000000000000000E+00  +5.000000000000000E+00  +6.000000000000000E+00  

> t=7,8;
t        Tableau de reels : nb reels =2
> tab4=vnumR[t,tab3];

tab4 [1:4]      nb elements = 4

/*declare un tableau de 5 reels */
> t2=vnumR[1:2:4:8:9];
t2   Tableau de reels : nb reels =5
> writes(t2);
+1.000000000000000E+00  
+2.000000000000000E+00  
+4.000000000000000E+00  
+8.000000000000000E+00  
+9.000000000000000E+00  

Procedure: vnumC[,,:,,]

<name> = vnumC [ <complex> ou <complex vec.> ou <array of complex vec.> , ... : <complex> ,... ] ;

It declares and initializes a complex vector or an array of complex vectors with the specified complexs or complex vectors.

The character : separates the lines and the character , separates the columns . All columns must have the same line counts.

 Example :
/*declare un tableau de 4 complexes*/
> tab3=vnumC[1:1+i:2+2*i:3+3*i];
tab3     Tableau de complexes : nb complexes =4
> writes(tab3);
+1.000000000000000E+00  +0.000000000000000E+00  
+1.000000000000000E+00  +1.000000000000000E+00  
+2.000000000000000E+00  +2.000000000000000E+00  
+3.000000000000000E+00  +3.000000000000000E+00  

> vnumC ti;
> resize(ti,5,3-5*i);
> tab4=vnumC[tab3 : 5+7*i : ti];
tab4     Tableau de complexes : nb complexes =10

/*declare un tableau de 2 tableaux de 2 complexes*/
> z4=vnumC[5,2+i:4,9+3*i];

z4 [1:2]    nb elements = 2

> writes("%g %g %g %g\n",z4[1],z4[2]);
5 0 2 1
4 0 9 3

9.3 Display

Procedure: writes

writes([ <integer> : <integer> : <integer> ], <string> , <(array of) num. vec.> , ...);

writes( <string> , <(array of) num. vec.> , ...);

writes( <(array of) num. vec.> , ...);

equivalent to

writes( { [binf:{bsup}:{step}], } {format,} <(array of) num. vec.> ,...).

It prints, to the screen, numerical vectors or the array of numerical vectors in columns form.

• From the binfth element of each numerical vector (if binf isn't specified, it starts from the first element).
• To the bsupth element of each numerical vector (if bsup isn't specified, it stops to the last element of the biggest vector).
• Every step elements (if step isn't specified, the step is 1).

format is optional. This format is similar to the C format (cf. printf) and must be between double quotes ("). To display a double quote (") as a character, you must double it :

For example, if the C format is " %g \"titi\" %g", you must write " %g\""titi\"" %g"

A complex vector will be printed on two columns (the first for the real part and the second for the imaginary part).

 Example :
Ecriture de tous les éléments de T et de X.
La première colonne correspondra à T.
La deuxième colonne correspondra à la partie réelle de X.
La troisième colonne correspondra à la partie imaginaire de X.
...
> stat(X);
Tableau numérique X de 6 complexes.
  taille en octets du tableau: 96
> stat(T);
Tableau numérique T de 6 réels.
   taille en octets du tableau: 48
> writes(T,X);
+9.999993149794888E-02  +1.000000000456180E-01  +1.095970178673141E-06  
-2.000000944035095E-01  +9.999999960679056E-03  +1.312007532388499E-07  
+3.000000832689856E-01  +1.000000314882390E-03  -1.403292661135361E-08  
-4.000000970924361E-01  +9.999995669530993E-05  +1.695880029074994E-09  
+4.999999805039361E-01  +1.000003117384769E-05  +3.216502329016007E-11  
-5.999999830866213E-01  +9.999979187109419E-07  -1.796078221829677E-12  
>               
      
Ecriture du 2 au 4 elements de T et de X 
avec un format "%.1g\t(%.5g+i*%.5E)\n".
> writes([2:4],"%.1g\t(%.5g+i*%.5E)\n",T,X);
-0.2    (0.01+i*1.31201e-07)
0.3     (0.001+i*-1.40329e-08)
-0.4    (0.0001+i*1.69588e-09)

Ecriture du 1 au 5 elements de T et de X avec un pas de 2 sans format.
> writes([1:5:2],T,X);
+9.999993149794888E-02  +1.000000000456180E-01  +1.095970178673141E-06  
+3.000000832689856E-01  +1.000000314882390E-03  -1.403292661135361E-08  
+4.999999805039361E-01  +1.000003117384769E-05  +3.216502329016007E-11  
      
Ecriture des elements de T et de X avec un pas de 5 sans format.
> writes([::5],T,X);
+9.999993149794888E-02  +1.000000000456180E-01  +1.095970178673141E-06  
-5.999999830866213E-01  +9.999979187109419E-07  -1.796078221829677E-12  

9.4 Size

Function : size

size( <num. vec.> )

Return the number of elements in the numerical vector.

 Example :
> t=1,10;
t    Tableau de reels : nb reels =10
> size(t);
    10
> p=-pi,pi,pi/400;
p    Tableau de reels : nb reels =800
> size(p);
    800

9.5 Resize

Procedure: resize

resize(<(array of) num. vec.> , <integer> );

resize(<(array of) num. vec.> , <integer> , <constant> );

Change the size of the numerical vector or of the array of numerical vectors.

If a constant isn't specified then all elements will be initialized to 0 else all elements will initialized with this constant.

 Example :
> vnumR t;
> resize(t,3);
> vnumR t2;
>  resize(t2,3,5);
> writes(t,t2);
+0.000000000000000E+00  +5.000000000000000E+00  
+0.000000000000000E+00  +5.000000000000000E+00  
+0.000000000000000E+00  +5.000000000000000E+00  
> vnumC t[1:3];
> resize(t[2],2,1-5*i);
> writes(t[2]);
+1.000000000000000E+00  -5.000000000000000E+00  
+1.000000000000000E+00  -5.000000000000000E+00  

9.6 Data retrieval

Function : select

select ( <condition> , <num. vec.> );

Return a numerical vector which only contains the elements of the numerical vector where the condition is true.

The condition and the numerical vector must have the same number of elements.

 Example :
/*retourne les éléments qui sont multiples de  3*/
> t=1,10;
t    Tableau de reels : nb reels =10
> r=select((t mod 3)==0, t);
r    Tableau de reels : nb reels =3
> writes(r);
+3.000000000000000E+00  
+6.000000000000000E+00  
+9.000000000000000E+00  

Operator : []

<num. vec.> [ <real vec.> ];

Return a numerical vector which only contains the elements of the numerical vector located at the indexes stored in the real vector.

Remark : The real vector must be an object identifier and not be a operation result.

 Example :
> r=vnumR[1:5:7:9];
> t=20,30;
> b=t[r];
b    Tableau de reels : nb reels =4
> writes("%g\n",b);
20
24
26
28

Operator : [::]

<num. vec.> [ <integer> binf : <integer> bsup : <integer> pas ];

<num. vec.> [ <integer> binf : <integer> bsup ];

Return a numerical vector which contains only the elements located between the lower bound and the upper bound with the specified step.

If the lower bound isn't specified, then the lower bound is assumed to be 1. If the upper bound isn't specified, then the upper bound is assumed to be the size of the numerical vector. If the step isn't specified, then the step is assumed to be 1.

Remark : All missing combinations are allowed.

 Example :
> t=1,10;
t    Tableau de reels : nb reels =10
>  r=t[::2];
r    Tableau de reels : nb reels =5
> v=t[7:9];
v    Tableau de reels : nb reels =3
> y=t[5:10:2];
y    Tableau de reels : nb reels =3
> writes("%g %g\n",v,y);
7 5
8 7
9 9

9.7 Input/Output

9.7.1 read

Procedure: read

read(<filename> ,[ <integer> : <integer> : <integer> ],

• <(tableau de) tab. num.>,... ,
• (<(tableau de) tab. num.>, <integer> ), ...
• (<(tableau de) tab. num.>, <integer> , <integer> ), ...);

equivalent to

read(fichier.dat, [binf:bsup:step], T, (T1,n1), (T3,n2,n3));

read(fichier.dat, T, (T1,n1), (T3,n2,n3));

Read in a text file the specified columns and store them to numerical vectors.

• starting at the the line binf (if binf isn't specified, then it will start at the first line of the file)
• to the line bsup (if bsup isn't specified, then it will read to the end of file)
• every bstep lines (if bstep isn't specified, then the step is assumed to 1)

• - If the index of the column for a numerical vector of real numbers is specified, then the column for this vector will be the index of the last column +1.
• - If the index of the column for the real part of a numerical vector of complex numbers is specified, then the column for this vector will be the index of the last column +1.
• - If the index of the column for the imaginary part of a numerical vector of complex numbers isn't specified and the column for the real part is specified, then the imaginary part is initialized to 0.

If the file contains the strings NAN or NANQ, then it assumes to be the value "Not A Number". If the file contains the strings INF, Inf ou Infinity, then it assumes to be the value "infinite".

 Example :
Lecture dans le fichier tessin.out de la ligne 2 à ligne 100
avec un pas de 3.
Le tableau T contiendra la première colonne,
la partie réelle de X contiendra la deuxième colonne,
la partie imaginaire de X contiendra la troisième colonne,
TAB[1] contiendra la 4eme colonne, 
TAB[2] contiendra la 5eme colonne, 
TAB[3] contiendra la 6eme colonne.      
> vnumR T;
vnumC X;
vnumR TAB[1:3];
read(tessin.out,[2:100:3],T,X,TAB);
stat(T);
stat(X);
stat(TAB);
T    nb elements reels =0
> 
X    nb elements complexes =0
> 
TAB [1:3]   nb elements = 3

> > Tableau numerique T de 33 reels.
    taille en octets du tableau: 264
> Tableau numerique X de 33 complexes.
    taille en octets du tableau: 528
>   Tableau de series
 TAB [ 1:3 ]
 liste des elements du tableau : 
    TAB [ 1 ] = 
Tableau numerique  de 33 reels.
    taille en octets du tableau: 264
    TAB [ 2 ] = 
Tableau numerique  de 33 reels.
    taille en octets du tableau: 264
    TAB [ 3 ] = 
Tableau numerique  de 33 reels.
    taille en octets du tableau: 264
> 

Lecture dans le fichier tessin.out de la ligne 2 a ligne 100.
Le tableau T contiendra la premiere colonne,
la partie reelle de X contiendra la 4eme colonne,
la partie imaginaire de X sera nulle,
TAB[3] contiendra la 5eme colonne.     
> read(tessin.out,[2:100],T,(X,4),(TAB[3],5));


Lecture dans le fichier tessin.out de l'ensemble des lignes.
Le tableau T contiendra la 2eme colonne,
la partie reelle de X contiendra la 3eme colonne,
la partie imaginaire de X contiendra la 4eme colonne,
TAB[3] contiendra la 5eme colonne.     
> read(tessin.out,(T,2),(X,3,4),(TAB[3],5));

Lecture dans le fichier tessin.out a partir de la ligne 1000.
Le tableau T contiendra la 2eme colonne,
la partie reelle de X contiendra la 3eme colonne,
la partie imaginaire de X contiendra la 4eme colonne,
TAB[3] contiendra la 5eme colonne.     
> read(tessin.out,[1000:],(T,2),(X,3,4),(TAB[3],5));

Lecture dans le fichier tessin.out avec un pas de 50 lignes.
Le tableau T contiendra la 2eme colonne,
la partie reelle de X contiendra la 3eme colonne,
la partie imaginaire de X contiendra la 4eme colonne,
TAB[3] contiendra la 5eme colonne.     
> read(tessin.out,[::50],(T,2),(X,3,4),TAB[3]);

9.7.2 readappend

Procedure: readappend

readappend(<filename> ,[ <integer> : <integer> : <integer> ],

• <(tableau de) tab. num.>,... ,
• (<(tableau de) tab. num.>, <integer> ), ...
• (<(tableau de) tab. num.>, <integer> , <integer> ), ...);

equivalent to

readappend(fichier.dat, [binf:bsup:step], T, (T1,n1), (T3,n2,n3));

readappend(fichier.dat, T, (T1,n1), (T3,n2,n3));

This function is similar to the function read (see section read) but it stores read data to the end of the numerical vectors (with an automatic growing step) instead of overwriting their contents.

 Example :
>  t1=1,5;
t1       Tableau de reels double-precision : nb reels =5
> write(temp001, t1);
> write(temp002, t1**2);
> vnumR w;
> readappend(temp001,w);
> readappend(temp002,w);
> writes(w);
+1.0000000000000000E+00
+2.0000000000000000E+00
+3.0000000000000000E+00
+4.0000000000000000E+00
+5.0000000000000000E+00
+1.0000000000000000E+00
+4.0000000000000000E+00
+9.0000000000000000E+00
+1.6000000000000000E+01
+2.5000000000000000E+01

9.7.3 write

Procedure: write

write( <filename> , [ <integer> : <integer> : <integer> ], <string> , <(array of) num. vec.> , ...);

write( <filename> , <string> , <(array of) num. vec.> , ...);

write( <filename> , <(array of) num. vec.> , ...);

equivalent to

write( fichier.dat, [binf:bsup:step], "format", T, T1, T2).

write( fichier.dat, "format", T, T1, T2).

write( fichier.dat, T, T1, T2).

write( fichier.dat, [binf:bsup:step], T, T1, T2).

Write to a file the numerical vector or the arrays of numerical vectors as columns of numbers.

• from the element binf of each numerical vector (if binf isn't specified, then it's assumed to be the first one).
• to the element bsup of each numerical vector (if bsup isn't specified, then it's assumed to be the last one of the largest vector).
• every step element (if step isn't specified, then it's assumed to be 1).

The format is optional. The format is the format of C language (See printf) and surrounded with double-quotes ("). To obtain a double-quotes, two double-quotes must be used :

For example : if the C format is " %g \"titi\" %E", it must be written as, " %g \""titi\"" %E"

A numerical vector of complex numbers uses two columns (the first one for the real part and the second one for the imaginary part).

 Example :
Ecriture de tous les elements de T et de X dans le fichier tx.out.
La pemiere colonne correspondra a T.
la deuxieme colonne correspondra a la partie reelle de X.
la troisieme colonne correspondra a la partie imaginaire de X.
> vnumR T;
vnumC X;
...
stat(T);
stat(X);

> Tableau numerique T de 33 reels.
    taille en octets du tableau: 264
> Tableau numerique X de 33 complexes.
    taille en octets du tableau: 528
> write(tx.out,T,X);
>      

Ecriture de 10 au 20 éléments de T et de X dans le fichier tx.out avec 
un format "%g\t(%8.4E+i*%e)\n".
La pemiere colonne correspondra à T.
la deuxième colonne correspondra à la partie réelle de X.
la troisieme colonne correspondra à la partie imaginaire de X.
> write(tx.out,[10:20],"%g\t(%8.4E+i*%e)\n",T,X);

Ecriture de 1 au 20 éléments de T et de X avec un pas de 2 dans le 
fichier tx.out sans format.
La pemiere colonne correspondra à T.
la deuxième colonne correspondra à la partie réelle de X.
la troisieme colonne correspondra à la partie imaginaire de X.
> write(tx.out,[1:20:2],T,X);

Ecriture des éléments de T et de X avec un pas de 5 dans le fichier 
tx.out sans format.
La pemiere colonne correspondra à T.
la deuxième colonne correspondra à la partie réelle de X.
la troisieme colonne correspondra à la partie imaginaire de X.
> write(tx.out,[::5],T,X);

9.7.4 readbin

Procedure: readbin

readbin(<filename> ,[ <integer> : <integer> : <integer> ], <string> , <(array of) real vec.> , ...);

readbin(<filename> , <string> , <(array of) real vec.> , ...);

equivalent to

readbin(fichier.dat, [binf:bsup:step], format, T, T2, T3);

readbin(fichier.dat, format, T, T2, T3);

Read in a binary file the data with the specified format and store them to numerical vectors.

• beginning at the record binf (if binf isn't specified, then it's assumed to be first record).
• to the record bsup (if bsup isn't specified, then it's assumed to be the end of file)
• every bstep records (if bstep isn't specified, then it's assumed to be 1)

The allowed format to define a record are :

• - %2d signed integer on 2 bytes.
• - %4d signed integer on 4 bytes.
• - %8d signed integer on 8 bytes.
• - %d signed integer on (default size of the system for an integer).
• - %2u unsigned integer on 2 bytes.
• - %4u unsigned integer on 4 bytes.
• - %8u unsigned integer on 8 bytes.
• - %u unsigned integer (default size of the system for an integer).
• - %E double-precision floating-point number.
• - %e double-precision floating-point number.
• - %g double-precision floating-point number.
• - %8g double-precision floating-point number on 8 bytes.
• - %hE simple precision floating-point number.
• - %he simple precision floating-point number.
• - %hg simple precision floating-point number.
• - %4g simple precision floating-point number on 4 bytes.

The number of format must be the same as the number of vectors. If the provided object identifier is an array of real vectors, then it must have the same number of format as the number of elements in the array.

The data are previously converted if the global variable _endian (see section _endian) isn't the same as its default value.

 Example :
Lecture dans le fichier binaire test1.dat 
d'entiers signés sur 4 octets 
et stockés dans le tableau de réels T1.
vnumR T1;
readbin(test1.dat,"%4d",T1);

Lecture dans le fichier binaire test1.dat 
des 30 premiers entiers signés sur 4 octets 
et stockés dans le tableau de réels T1.
vnumR T1;
readbin(test1.dat,[:30],"%4d",T1);

Lecture dans le fichier binaire test2.dat 
dont chaque enregistrement est composé de 2 réels 
et stockés dans le tableau de réels T1 et T2.
vnumR T1,T2;
readbin(test2.dat,[:30],"%g%g",T1,T2);

Lecture dans le fichier binaire test3.dat 
dont chaque enregistrement est composé de 4 réels 
et stockés dans le tableau T3.
vnumR T3[1:4];
readbin(test3.dat,"%g%g%g%g",T3);

est équivalent à 

readbin(test3.dat,"%g%g%g%g",T3[1],T3[2],T3[3],T3[4]);

9.7.5 writebin

Procedure: writebin

writebin(<filename> ,[ <integer> : <integer> : <integer> ], <string> , <(array of) real vec.> , ...);

writebin(<filename> , <string> , <(array of) real vec.> , ...);

equivalent to

writebin(fichier.dat, [binf:bsup:step], format, T, T2, T3);

writebin(fichier.dat, format, T, T2, T3);

Write the numerical vectors to a binary file the data with the specified format.

• beginning at the index binf (if binf isn't specified, then it's assumed to be first element of the numerical vectors).
• to the index bsup (if bsup isn't specified, then it's assumed to be the size of the largest numerical vector)
• every bstep elements (if bstep isn't specified, then it's assumed to be 1)

The allowed format to define a record are :

• - %2d signed integer on 2 bytes.
• - %4d signed integer on 4 bytes.
• - %8d signed integer on 8 bytes.
• - %d signed integer on (default size of the system for an integer).
• - %2u unsigned integer on 2 bytes.
• - %4u unsigned integer on 4 bytes.
• - %8u unsigned integer on 8 bytes.
• - %u unsigned integer (default size of the system for an integer).
• - %E double-precision floating-point number.
• - %e double-precision floating-point number.
• - %g double-precision floating-point number.
• - %8g double-precision floating-point number on 8 bytes.
• - %hE simple precision floating-point number.
• - %he simple precision floating-point number.
• - %hg simple precision floating-point number.
• - %4g simple precision floating-point number on 4 bytes.

The number of format must be the same as the number of vectors. If the provided object identifier is an array of real vectors, then it must have the same number of format as the number of elements in the array.

If the numerical vectors doesn't have the same size, then the missing data are completed with 0.

The data are previously converted if the global variable _endian (see section _endian) isn't the same as its default value.

 Example :
Ecriture du tableau de réels T1 dans le fichier binaire test1.dat 
sosu la forme d'entiers signés sur 4 octets.
vnumR T1;
T1=1,10;
writebin(test1.dat,"%4d",T1);

Ecriture des 30 premiers éléments du tableau de réels T1 
dans le fichier binaire test1.dat sous la forme d'entiers 
signés sur 4 octets. 
vnumR T1;
T1=1,100;
writebin(test1.dat,[:30],"%4d",T1);

Ecriture des 30 premiers éléments du tableau de réels T1 et de T2 
dans le fichier binaire test2.dat dont chaque enregistrement 
est composé de 2 réels.
vnumR T1,T2;
T1=1,100;
T2=-100,-1;
writebin(test2.dat,[:30],"%g%g",T1,T2);

Ecriture des tableaux de réels de T3 dans le fichier binaire test3.dat 
dont chaque enregistrement est composé de 4 réels.
vnumR T3[1:4];
T3[:]=1,10;
writebin(test3.dat,"%g%g%g%g",T3);

est équivalent à 

writebin(test3.dat,"%g%g%g%g",T3[1],T3[2],T3[3],T3[4]);

9.8 Input/Output low level

9.8.1 file_open

Function : <file> file_open

file_open(<filename> , read);

file_open(<filename> , write);

It opens a file in reading or writing mode depending on the value of the secund parameter. It returns an object identifier of type file.

 Example :
> f=file_open("sim2007.dat",read);
f  = fichier "sim2007.dat" ouvert en lecture
> vnumR t;
> file_read(f,t);
> file_close(f);

9.8.2 file_close

Procedure: file_close

file_close(<file> );

It closes a file previously opened with the function file_open.

 Example :
> f=file_open("sim2007.dat",read);
f  = fichier "sim2007.dat" ouvert en lecture
> vnumR t;
> file_read(f,t);
> file_close(f);
> stat(f);
 fichier f = "sim2007.dat" ferme
         Aucune erreur en lecture/ecriture

9.8.3 file_write

Procedure: file_write

file_write( <file> , [ <integer> : <integer> : <integer> ], <string> , <(array of) num. vec.> , ...);

file_write( <file> , <string> , <(array of) num. vec.> , ...);

file_write( <file> , <(array of) num. vec.> , ...);

equivalent to

file_write( fichier, [binf:bsup:step], "format", T, T1, T2).

file_write( fichier, "format", T, T1, T2).

file_write( fichier, T, T1, T2).

file_write( fichier, [binf:bsup:step], T, T1, T2).

This function is similar as the function write (see section write) but this function requires an object identifier of type file instead of a filename. The function writes data in the file from the current position.

 Example :
> f=file_open(sim2007.dat, write);
f  = fichier "sim2007.dat" ouvert en ecriture
> t1=1,10;
t1       Tableau de reels double-precision : nb reels =10
> t2=-t1;
t2       Tableau de reels double-precision : nb reels =10
> file_write(f,t1);
> file_write(f,t2);
> file_close(f);

9.8.4 file_read

Procedure: file_read

file_read(<file> ,[ <integer> : <integer> : <integer> ],

• <(tableau de) tab. num.>,... ,
• (<(tableau de) tab. num.>, <integer> ), ...
• (<(tableau de) tab. num.>, <integer> , <integer> ), ...);

equivalent to

file_read(fichier, [binf:bsup:step], T, (T1,n1), (T3,n2,n3));

file_read(fichier, T, (T1,n1), (T3,n2,n3));

This function is similar as the function read (see section read) but this function requires an object identifier of type file instead of a filename. The function reads data from the file from the current position.

 Example :
> f=file_open(sim2007.dat, read);
f  = fichier "sim2007.dat" ouvert en lecture
> vnumR t;
> file_read(f,[:5],t);
> vnumR t2;
> file_read(f,t2);
> writes(t);
+1.0000000000000000E+00
+2.0000000000000000E+00
+3.0000000000000000E+00
+4.0000000000000000E+00
+5.0000000000000000E+00
> writes(t2);
+6.0000000000000000E+00
+7.0000000000000000E+00
+8.0000000000000000E+00
+9.0000000000000000E+00
+1.0000000000000000E+01
-1.0000000000000000E+00
-2.0000000000000000E+00
-3.0000000000000000E+00
-4.0000000000000000E+00
-5.0000000000000000E+00
-6.0000000000000000E+00
-7.0000000000000000E+00
-8.0000000000000000E+00
-9.0000000000000000E+00
-1.0000000000000000E+01
> file_close(f);

9.8.5 file_readappend

Procedure: file_readappend

file_readappend(<file> ,[ <integer> : <integer> : <integer> ],

• <(tableau de) tab. num.>,... ,
• (<(tableau de) tab. num.>, <integer> ), ...
• (<(tableau de) tab. num.>, <integer> , <integer> ), ...);

equivalent to

file_readappend(fichier, [binf:bsup:step], T, (T1,n1), (T3,n2,n3));

file_readappend(fichier, T, (T1,n1), (T3,n2,n3));

This function is similar as the function readappend (see section readappend) but this function requires an object identifier of type file instead of a filename. The function reads data from the file from the current position.

 Example :
> f=file_open(sim2007.dat, read);
f  = fichier "sim2007.dat" ouvert en lecture
> vnumR t;
>  file_readappend(f,[:5],t);
>  file_readappend(f,[10:15],t);
> writes(t);
+1.0000000000000000E+00
+2.0000000000000000E+00
+3.0000000000000000E+00
+4.0000000000000000E+00
+5.0000000000000000E+00
-5.0000000000000000E+00
-6.0000000000000000E+00
-7.0000000000000000E+00
-8.0000000000000000E+00
-9.0000000000000000E+00
-1.0000000000000000E+01
> file_close(f);

9.8.6 file_writemsg

Procedure: file_writemsg

file_writemsg(<file> , <string> textformat);

file_writemsg(<file> , <string> textformat, <real> x, ... );

Write formatted messages to a file with(out) real constants.

The real constants must be formatted. The format is the same as the command printf in language C (see section Conversion from an integer or a real to a string, for the valid conversion specifiers). This message must a be string or a text between double-quotes. The messages could be on several lines.

To display double-quotes, two double-quotes must be used.

 Example :
> f=file_open("temp001", write);
f  = fichier "temp001" ouvert en ecriture
> x=4;
x =                       4
> file_writemsg(f," resultat=%g\n", x);
> file_writemsg(f," termine\n");
> file_close(f);
> !"cat temp001";
 resultat=4
 termine
> f=file_open("data1.txt",write);
f  = fichier "data1.txt" ouvert en ecriture
> file_writemsg(f,"%d\n",3/2);
> file_writemsg(f,"%4.2E\n",3/2);
> file_close(f);
> !"cat data1.txt";
3/2
1.50E+00
> 

9.9 Standard functions

9.9.1 minimum and maximum

Function : imin

imin( <real vec.> )

Return the index of the minimal value of the numerical vector of real numbers. If more than one elements have the minimal value, then this function returns the index of the first element. If the numercial vector is empty then it returns 0.

 Example :
> t=-5,5;
> imin(t);
    1

Function : imax

imax( <real vec.> )

Return the index of the maximal value of the numerical vector of real numbers. If more than one elements have the maximal value, then this function returns the index of the first element. If the numercial vector is empty then it returns 0.

 Example :
> t=-5,5;
> imax(t);
     10

Function : MIN

MIN( <real vec.> , ...)

Return a numerical vector of real numbers such that its elements have the minimal value term by term of each numerical vector.

The numerical vectors must have the same size.

For an array of numerical vector of real numbers, the operation is performed on each oelement.

 Example :
> t=0,pi,pi/6$
> a=MIN(cos(t),sin(t))$
> c=MAX(t,cos(t),sin(t))$
> writes(a,c)$
+0.0000000000000000E+00	+1.0000000000000000E+00	
+4.9999999999999994E-01	+8.6602540378443871E-01	
+5.0000000000000011E-01	+1.0471975511965976E+00	
+6.1232339957367660E-17	+1.5707963267948966E+00	
-4.9999999999999978E-01	+2.0943951023931953E+00	
-8.6602540378443849E-01	+2.6179938779914940E+00	
-1.0000000000000000E+00	+3.1415926535897931E+00	
> vnumR cs[1:2]$
> cs[1]=cos(t)$
> cs[2]=sin(t)$
> b=MIN(cs)$
> d=MAX(t,cs)$
> writes(b,d);
+0.0000000000000000E+00	+1.0000000000000000E+00	
+4.9999999999999994E-01	+8.6602540378443871E-01	
+5.0000000000000011E-01	+1.0471975511965976E+00	
+6.1232339957367660E-17	+1.5707963267948966E+00	
-4.9999999999999978E-01	+2.0943951023931953E+00	
-8.6602540378443849E-01	+2.6179938779914940E+00	
-1.0000000000000000E+00	+3.1415926535897931E+00	

Function : MAX

MAX( <real vec.> , ...)

Return a numerical vector of real numbers such that its elements have the maximal value term by term of each numerical vector.

The numerical vectors must have the same size.

For an array of numerical vector of real numbers, the operation is performed on each oelement.

 Example :
> t=0,pi,pi/6$
> a=MIN(cos(t),sin(t))$
> c=MAX(t,cos(t),sin(t))$
> writes(a,c)$
+0.0000000000000000E+00	+1.0000000000000000E+00	
+4.9999999999999994E-01	+8.6602540378443871E-01	
+5.0000000000000011E-01	+1.0471975511965976E+00	
+6.1232339957367660E-17	+1.5707963267948966E+00	
-4.9999999999999978E-01	+2.0943951023931953E+00	
-8.6602540378443849E-01	+2.6179938779914940E+00	
-1.0000000000000000E+00	+3.1415926535897931E+00	
> vnumR cs[1:2]$
> cs[1]=cos(t)$
> cs[2]=sin(t)$
> b=MIN(cs)$
> d=MAX(t,cs)$
> writes(b,d);
+0.0000000000000000E+00	+1.0000000000000000E+00	
+4.9999999999999994E-01	+8.6602540378443871E-01	
+5.0000000000000011E-01	+1.0471975511965976E+00	
+6.1232339957367660E-17	+1.5707963267948966E+00	
-4.9999999999999978E-01	+2.0943951023931953E+00	
-8.6602540378443849E-01	+2.6179938779914940E+00	
-1.0000000000000000E+00	+3.1415926535897931E+00	

Function : min

min( <real or real vec.> , ...);

Return the minimum value of the parameters which could be real constants or real vectors.

 Example :
>min(1.5,2.5);
3/2
>x=1.5;
>y=2.5;
>min(x,y);
3/2
> t=-10,10;
> p=abs(t);
> min(-5,t,p,20);
    -10

Function : max

max( <real or real vec.> , ...);

Return the maximum value of the parameters which could be real constants or real vectors.

 Example :
>max(1.5,2.5);
5/2
>x=1.5;
>y=2.5;
>max(x,y);
5/2
> t=-10,10;
> p=abs(t);
> max(p,t,8);
    10

9.9.2 addition and product

Function : sum

sum( <num. vec.> )

Return the sum of elements in the numerical vector.

 Example :
> r=-10,10;
> sum(r);
    0
> p=0,100;
> sum(p);
    5050
> sum(abs(r)+i*p);
    (110+i*5050)

Function : prod

prod( <num. vec.> )

Return the product of elements in the numerical vector.

 Example :
> p=1,10;
p    Tableau de reels : nb reels =10
> prod(p);
    3628800
> c=p+2*i*p;
c    Tableau de complexes : nb complexes =10
> prod(c);
     (860025600-i*11307340800)

Function : accum

accum( <num. vec.> )

Return the partial sum of elements in the numerical vector. Y=accum(X) alors Y[N] = sum(X[1:N])

 Example :
> tx=1,10;
tx   Tableau de reels : nb reels =10
> ty=accum(tx);
ty   Tableau de reels : nb reels =10
> writes(accum(tx));
+1.000000000000000E+00  
+3.000000000000000E+00  
+6.000000000000000E+00  
+1.000000000000000E+01  
+1.500000000000000E+01  
+2.100000000000000E+01  
+2.800000000000000E+01  
+3.600000000000000E+01  
+4.500000000000000E+01  
+5.500000000000000E+01  

9.9.3 sort

Function : reversevnum

reversevnum (<num. vec.> )

Reverse the order of elements in the numerical vector.

 Example :
> p=1,10;
p    Tableau de reels : nb reels =10
>  writes(p, reversevnum(p));
+1.000000000000000E+00  +1.000000000000000E+01  
+2.000000000000000E+00  +9.000000000000000E+00  
+3.000000000000000E+00  +8.000000000000000E+00  
+4.000000000000000E+00  +7.000000000000000E+00  
+5.000000000000000E+00  +6.000000000000000E+00  
+6.000000000000000E+00  +5.000000000000000E+00  
+7.000000000000000E+00  +4.000000000000000E+00  
+8.000000000000000E+00  +3.000000000000000E+00  
+9.000000000000000E+00  +2.000000000000000E+00  
+1.000000000000000E+01  +1.000000000000000E+00  

Procedure: sort

sort ( <real vec.> )

Sort in ascending order the elements in the real vector.

sort ( <real vec.> , <(array of) num. vec.> , ...);

Sort the elements in the (array of) numerical vectors according to the ascending sort of the first real vector.

Remarks : If you call ‘sort(TX,TY,TZ);’, the vector TY et TZ are sorted but TX isn't sorted.

 Example :
> p=vnumR[5:2:-3:7:1:6];
p    Tableau de reels : nb reels =6
> sort(p);
> writes(p);
-3.000000000000000E+00  
+1.000000000000000E+00  
+2.000000000000000E+00  
+5.000000000000000E+00  
+6.000000000000000E+00  
+7.000000000000000E+00  
> T=vnumC[1+i:2+2*i:3+3*i:4+4*i:5+5*i:7+7*i];
T    Tableau de complexes : nb complexes =6
> vnumR TAB[1:2];
> TAB[1]=abs(T);
> TAB[2]=-real(T);
> sort(-p,T,TAB);

9.9.4 transposevnum

Function : transposevnum

transposevnum ( <array of num. vec.> )

Transpose the array of numerical vectors.

The array must have only one dimension and its numerical vectors must have the same size.

 Example :
> t=1,5; 
t        Tableau de reels : nb reels =5
> vnumR TSRC[1:2];
> TSRC[1]=t;
> TSRC[2]=reversevnum(t);
> writes("%g %g\n",TSRC);
1 5
2 4
3 3
4 2
5 1
> TRES=transposevnum(TSRC);

TRES [1:5]      nb elements = 5

> writes("%g %g %g %g %g\n",TRES);
1 2 3 4 5
5 4 3 2 1

9.9.5 standard math function

Function : abs

abs( <constant or num. vec.> )

Return the absolute value of the constant if the value is a constant.

Return a numerical vector containing the absolute value of each element if the value is a numerical vector.

 Example :
> abs(-2.3);
2.3
> x = 2.3;
> abs(x);
2.3
> t=-pi,pi,pi/100;
> at=abs(t);
at   Tableau de reels : nb reels =200
> abs(1+i);
    1.4142135623731

Function : arg

arg( <constant or num. vec.> )

Return the argument (also called phase angle) of the constant if the value is a constant.

Return a numerical vector containing the argument (also called phase angle) of each element if the value is a numerical vector.

 Example :
> arg(i);
    1.5707963267949
> arg(1+i);
    0.785398163397448
> t=0,pi,pi/6;
t    Tableau de reels : nb reels =7
>  writes(arg(exp(i*t)));
+0.000000000000000E+00  
+5.235987755982987E-01  
+1.047197551196598E+00  
+1.570796326794897E+00  
+2.094395102393195E+00  
+2.617993877991494E+00  
+3.141592653589793E+00  

Function : real

real( <constant or num. vec.> )

Return the real part of the constant if the value is a constant.

Return a numerical vector containing the real part of each element if the value is a numerical vector.

 Example :
> real(i);
    0
> real(2+3*i);
    2
> t=0,pi,pi/6;
t    Tableau de reels : nb reels =7
> writes(real(exp(i*t)));
+1.000000000000000E+00  
+8.660254037844387E-01  
+5.000000000000000E-01  
-0.000000000000000E+00  
-4.999999999999998E-01  
-8.660254037844385E-01  
-1.000000000000000E+00  
> real(4);
    4

Function : imag

imag( <constant or num. vec.> )

Return the imaginary part of the constant if the value is a constant.

Return a numerical vector containing the imaginary part of each element if the value is a numerical vector.

 Example :
> imag(i);
    1
> imag(2+3*i);
    3
> t=0,pi,pi/6;
> writes(real(exp(i*t)));
+1.000000000000000E+00  
+8.660254037844387E-01  
+5.000000000000000E-01  
-0.000000000000000E+00  
-4.999999999999998E-01  
-8.660254037844385E-01  
-1.000000000000000E+00  
> imag(4);
    0

Function : conj

conj( <constant or num. vec.> )

Return the conjugate of the constant if the value is a constant.

Return a numerical vector containing the conjugate of each element if the value is a numerical vector.

 Example :
> conj(1+i);
    (1-i*1)
> conj(3);
    3
> z=vnumC[1+i:3-5*i:i];
z    Tableau de complexes : nb complexes =3
> writes(conj(z));
+1.000000000000000E+00  -1.000000000000000E+00  
+3.000000000000000E+00  +5.000000000000000E+00  
+0.000000000000000E+00  -1.000000000000000E+00  

Function : erf

erf( <real or real vec.> )

Return the error function of the constant if the value is a real.

Return a numerical vector containing the error function of each element if the value is a numerical vector of real numbers.

The error function is defined by : erf(x) = (2/sqrt(pi) * integral from 0 to x of exp(-t*t) dt)

 Example :
> erf(1);
        0.842700792949715
> erf(0.5);
        0.520499877813047
> t=-2,2;
t        Tableau de reels : nb reels =5
> r=erf(t);
r        Tableau de reels : nb reels =5
> writes(t,r);
-2.0000000000000000E+00 -9.9532226501895271E-01
-1.0000000000000000E+00 -8.4270079294971478E-01
+0.0000000000000000E+00 +0.0000000000000000E+00
+1.0000000000000000E+00 +8.4270079294971478E-01
+2.0000000000000000E+00 +9.9532226501895271E-01

Function : erfc

erfc( <real or real vec.> )

Return the complementary error function of the constant if the value is a real.

Return a numerical vector containing the complementary error function of each element if the value is a numerical vector of real numbers.

The complementary error function is defined by : erfc(x) = 1 - (2/sqrt(pi) * integral from 0 to x of exp(-t*t) dt)

 Example :
> erf(1);
           0.842700792949715
> erf(0.5);
           0.520499877813047
> t=-2,2;
t    Tableau de reels : nb reels =5
> r=erf(t);
r        Tableau de reels : nb reels =5
> writes(t,r);
-2.0000000000000000E+00 -9.9532226501895271E-01
-1.0000000000000000E+00 -8.4270079294971478E-01
+0.0000000000000000E+00 +0.0000000000000000E+00
+1.0000000000000000E+00 +8.4270079294971478E-01
+2.0000000000000000E+00 +9.9532226501895271E-01

Function : exp

exp( <constant or num. vec.> )

Return the base-e exponential of the constant if the value is a constant.

Return a numerical vector containing the base-e exponential of each element if the value is a numerical vector.

 Example :
> exp(1.2);
3.32011692273655  
> x = 1.2;
> exp(x);
3.32011692273655 
> exp(2*i);
    (-0.416146836547142+i*0.909297426825682)
> t=-2,2;
t    Tableau de reels : nb reels =5
> r=exp(t);
r    Tableau de reels : nb reels =5
> writes(t,r);
-2.000000000000000E+00  +1.353352832366127E-01  
-1.000000000000000E+00  +3.678794411714423E-01  
+0.000000000000000E+00  +1.000000000000000E+00  
+1.000000000000000E+00  +2.718281828459045E+00  
+2.000000000000000E+00  +7.389056098930650E+00  

Function : sqrt

sqrt( <constant or num. vec.> )

Return the square root of the constant if the value is a constant.

Return a numerical vector containing the square root of each element if the value is a numerical vector.

 Example :
> x = 4;
> sqrt(x);
2
> sqrt(1+i);
(1.09868411346781+i*0.455089860562227)
> t=0,5;
t    Tableau de reels : nb reels =6
> ts=sqrt(t);
ts   Tableau de reels : nb reels =6
> writes(t,ts);
+0.000000000000000E+00  +0.000000000000000E+00  
+1.000000000000000E+00  +1.000000000000000E+00  
+2.000000000000000E+00  +1.414213562373095E+00  
+3.000000000000000E+00  +1.732050807568877E+00  
+4.000000000000000E+00  +2.000000000000000E+00  
+5.000000000000000E+00  +2.236067977499790E+00  

Function : cos

cos( <constant or num. vec.> )

Return the cosine of the constant if the value is a constant.

Return a numerical vector containing the cosine of each element if the value is a numerical vector.

 Example :
> cos(0.12);
 0.992808635853866 
> x=0;
x = 0
> cos(x);
>t=-pi,pi,pi/100;
> at=cos(t);
> cos(1+i);
 (0.833730025131149-i*0.988897705762865)

Function : sin

sin( <constant or num. vec.> )

Return the sine of the constant if the value is a constant.

Return a numerical vector containing the sine of each element if the value is a numerical vector.

 Example :
> sin(0.12);
0.119712207288912
> x = 0.12;
> sin(x);
0.119712207288912
> t=-pi,pi,pi/100;
> s=sin(t);
> sin(4*i);
(0+i*27.2899171971277)

Function : tan

tan( <constant or num. vec.> )

Return the tangent of the constant if the value is a constant.

Return a numerical vector containing the tangent of each element if the value is a numerical vector.

 Example :
> x = 1.2;
> tan(x);
2.57215162212632 
> t=-pi,pi,pi/100;
> at=tan(t);
> tan(-1+i);
(-0.271752585319512+i*95227/87854)

Function : acos

acos( <real or real vec.> )

Return the principal value of the arc cosine of the real number if the value is a real number.

Return a real vector containing the principal value of the arc cosine of each element if the value is a real vector.

 Example :
> acos(0.12);
1.4505064440011 
> x = 0.12;
> acos(x);
1.4505064440011
> t=-pi,pi,pi/100;
> at=acos(t);

Function : asin

asin( <real or real vec.> )

Return the principal value of the arc sine of the real number if the value is a real number.

Return a real vector containing the principal value of the arc sine of each element if the value is a real vector.

 Example :
> asin(0.12);
0.120289882394788 
> x = 0.12;
> asin(x);
0.120289882394788  
> t=-pi,pi,pi/100;
> at=asin(t);

Function : atan

atan( <real or real vec.> )

Return the principal value of the arc tangent of the real number if the value is a real number.

Return a real vector containing the principal value of the arc tangent of each element if the value is a real vector.

 Example :
> atan(2);
1.10714871779409
> x = 2;
> atan(x);
1.10714871779409
> t=-pi,pi,pi/100;
> at=atan(t);

Function : cosh

cosh( <constant or num. vec.> )

Return the hyperbolic cosine of the constant if the value is a constant.

Return a numerical vector containing the hyperbolic cosine of each element if the value is a numerical vector.

 Example :
> cosh(0.12);
1.0072086414827
> x = 0.12;
> cosh(x);
1.0072086414827
> t=-pi,pi,pi/100;
> at=cosh(t);
> cosh(1+i);
(0.833730025131149+i*0.988897705762865)

Function : sinh

sinh( <constant or num. vec.> )

Return the hyperbolic sine of the constant if the value is a constant.

Return a numerical vector containing the hyperbolic sine of each element if the value is a numerical vector.

 Example :
> sinh(1.2);
1.50946135541217 
> x = 1.2;
> sinh(x);
1.50946135541217 
> t=-pi,pi,pi/100;
> s=sinh(t);
> sinh(-1+3*i);
(1.16344036370325+i*0.217759551622152)

Function : tanh

tanh( <constant or num. vec.> )

Return the hyperbolic tangent of the constant if the value is a constant.

Return a numerical vector containing the hyperbolic tangent of each element if the value is a numerical vector.

 Example :
> x = 1.2;
> tanh(x);
0.833654607012155 
> tanh(1+i);
(95227/87854+i*0.271752585319512)
> t=0,10;
t    Tableau de reels : nb reels =11
> tanh(t);

Function : acosh

acosh( <constant or num. vec.> )

Return the inverse of the hyperbolic cosine of the constant if the value is a constant.

Return a numerical vector containing the inverse of the hyperbolic cosine of each element if the value is a numerical vector.

 Example :
> acosh(1.2);
             0.6223625037147786
> t=1,2,0.1;
t        Tableau de reels double-precision : nb reels =11
> acosh(t);
         Tableau de reels  double-precision : nb reels =11

Function : asinh

asinh( <constant or num. vec.> )

Return the inverse of the hyperbolic sine of the constant if the value is a constant.

Return a numerical vector containing the inverse of the hyperbolic sine of each element if the value is a numerical vector.

 Example :
> asinh(1.2);
              1.015973134179692
> t=1,2,0.1;
t        Tableau de reels double-precision : nb reels =11
> asinh(t);
         Tableau de reels  double-precision : nb reels =11

Function : asinh

asinh( <constant or num. vec.> )

Return the inverse of the hyperbolic tangent of the constant if the value is a constant.

Return a numerical vector containing the inverse of the hyperbolic tangent of each element if the value is a numerical vector.

 Example :
> atanh(0.2);
             0.2027325540540822
> t=0,1,0.1;
t        Tableau de reels double-precision : nb reels =11
> atanh(t);
         Tableau de reels  double-precision : nb reels =11

Function : atan2

atan2( <real or real vec.> , <real or real vec.> )

Return the principal value of the arc tangent of the first argument divided by the second argument using the signs of both arguments to determine the quadrant of the return value.

 Example :
> y = 11.5;
> x = 14;
> atan2(y,x); 
0.68767125603875

Function : mod

mod( <real or real vec.> , <real or real vec.> )

<real or real vec.> mod <real or real vec.>

Return the modulo of the first and second value. The result has the same sign as the first argument nd magnitude less than the magnitude of the second argument.

 Example :
> mod(4,2);
0
> x=4$
> y=2$
> mod(x,y);
0
> t=21,30;
> r=1,10;
> f=mod(t,r);
> g=mod(t,3);

Function : int

int( <real or real vec.> )

Return the integer part of the real number if the value is a real.

Return a real vector containing the integer part of each element if the value is a real vector.

 Example :
>x=1.23;
>int(x);
1
> t=-pi,pi,pi/100;
> at=int(t);

Function : log

log( <constant or num. vec.> )

Return the neperian logarithm of the constant if the value is a constant.

Return a numerical vector containing the neperian logarithm of each element if the value is a numerical vector.

 Example :
> log(3);
1.09861228866811
> x = 3;
> log(x);
1.09861228866811
> r=1,10;
> at=log(r);
> log(2+i);
(0.80471895621705+i*0.463647609000806)

Function : log10

log10( <constant or num. vec.> )

Return the decimal logarithm (base 10) of the constant if the value is a constant.

Return a numerical vector containing the decimal logarithm of each element if the value is a numerical vector.

 Example :
> log(3);
1.09861228866811
> x = 3;
> log(x);
1.09861228866811
> r=1,10;
> at=log(r);
> log(2+i);
(0.80471895621705+i*0.463647609000806)

Function : nint

nint( <real or real vec.> )

Return the nearest integer of the real number if the value is a real.

Return a real vector containing the nearest integer of each element if the value is a real vector.

 Example :
>  x=1.23;
x =                 1.23
> nint(x);
                       1
> nint(1.78);
                       2
> t=-1,1,0.1;
t    Tableau de reels : nb reels =21
> nint(t);

Function : sign

sign( <real or real vec.> )

Return the sign of the real number if the value is a real.

Return a real vector containing the sign of each element if the value is a real vector.

The function is defined with the following rules :

• sign(x) = +1 if x > 0
• sign(x) = 0 if x = 0
• sign(x) = -1 if x < 0

 Example :
> sign(3);
        1
> sign(-3);
        -1
> sign(0);
        0
> t=-3,3;
t        Tableau de reels : nb reels =7
> writes(t,sign(t));
-3.0000000000000000E+00 -1.0000000000000000E+00
-2.0000000000000000E+00 -1.0000000000000000E+00
-1.0000000000000000E+00 -1.0000000000000000E+00
+0.0000000000000000E+00 +0.0000000000000000E+00
+1.0000000000000000E+00 +1.0000000000000000E+00
+2.0000000000000000E+00 +1.0000000000000000E+00
+3.0000000000000000E+00 +1.0000000000000000E+00

Function : histogram

histogram(<real vec.> TY, <real vec.> TX)

Return the histogram of TY with the specified ranges TX :

TZ=histogram(TY,TX) : TZ[N] contains the number of elements in TY such that TX[N]<=TY[j]<TX[N+1].

For the last range TX, the relation is : TX[N]<=TY[j]<=TX[N+1]

 Example :
> TY=vnumR[0:1:4:5:6:9:10:11:-1:-2:-5]$
> TX=-3,9,2$
> writes("%g\n",TX);
-3
-1
1
3
5
7
9
> TZ=histogram(TY,TX)$
>  writes("%g\n",TZ);
1
2
1
1
2
1

9.10 Conditions

Operator : ?()::

?(<condition>)

Return a numerical vector which contains only the numbers 0 or 1. For each element of the array : if the condition at index j is true then <name> [j]=1 else <name> [j]=0

?(<condition>): <constant or num. vec.> tabvrai : <constant or num. vec.> tabfaux

Return a numerical vector which contains only the numbers 0 or 1. For each element of the array : if the condition at index j is true then <name> [j]=tabvrai[j] else <name> [j]=tabfaux[j]

All vectors must have the same size.

 Example :
> t=0,5;
t    Tableau de reels : nb reels =6
> r=5-t;
r    Tableau de reels : nb reels =6
> q=?(t<=r);
q    Tableau de reels : nb reels =6
> writes(q);
+1.000000000000000E+00  
+1.000000000000000E+00  
+1.000000000000000E+00  
+0.000000000000000E+00  
+0.000000000000000E+00  
+0.000000000000000E+00  
> l= ?(t<=r):i:5;
l    Tableau de complexes : nb complexes =6
> writes(l);
+0.000000000000000E+00  +1.000000000000000E+00  
+0.000000000000000E+00  +1.000000000000000E+00  
+0.000000000000000E+00  +1.000000000000000E+00  
+5.000000000000000E+00  +0.000000000000000E+00  
+5.000000000000000E+00  +0.000000000000000E+00  
+5.000000000000000E+00  +0.000000000000000E+00  
> m = ?(t>2):r:t;
m    Tableau de reels : nb reels =6
> writes(m);
+0.000000000000000E+00  
+1.000000000000000E+00  
+2.000000000000000E+00  
+2.000000000000000E+00  
+1.000000000000000E+00  
+0.000000000000000E+00  

9.11 Conversion

Function : dimtovnumR

dimtovnumR( <array> )

Return a numerical vector of real numbers from the array of series.

The array of series must contain only real numbers. The array must have only one dimension.

 Example :
> dim ts[1:3];
> ts[1]=1$
> ts[2]=4$
> ts[3]=6$
> tr=dimtovnumR(ts)$
> writes(tr);
+1.000000000000000E+00  
+4.000000000000000E+00  
+6.000000000000000E+00  
> ltr=log(dimtovnumR(ts));
ltr  Tableau de reels : nb reels =3

Function : dimtovnumC

dimtovnumC( <array> )

Return a numerical vector of complex numbers from the array of series.

The array of series must contain only complex numbers. The array must have only one dimension.

 Example :
> dim ts[1:3];
> ts[1]=1+i$
> ts[2]=3*i$
> ts[3]=-5+i$
> tc=dimtovnumC(ts)$
> writes(tc);
+1.000000000000000E+00  +1.000000000000000E+00  
+0.000000000000000E+00  +3.000000000000000E+00  
-5.000000000000000E+00  +1.000000000000000E+00  
> ltc=exp(dimtovnumC(ts));
ltc  Tableau de complexes : nb complexes =3

Function : vnumtodim

vnumtodim( <(array of) num. vec.> )

Return an array of series (constants) from the array of numerical vectors or from the numerical vector.

 Example :
> tr=1,4;
tr   Tableau de reels : nb reels =4
> tsr=vnumtodim(tr);

tsr [1:4]   nb elements = 4

> afftab(tsr);
tsr[1] = 1
tsr[2] = 2
tsr[3] = 3
tsr[4] = 4
> vnumC tc[1:2];
> tc[1]=i*tr$
> tc[2]=tr+i*tr**2$
> tsc=vnumtodim(tc);

tsc [1:4, 1:2]  nb elements = 8

> afftab(tsc);
tsc[1,1] = (0+i*1)
tsc[1,2] = (1+i*1)
tsc[2,1] = (0+i*2)
tsc[2,2] = (2+i*4)
tsc[3,1] = (0+i*3)
tsc[3,2] = (3+i*9)
tsc[4,1] = (0+i*4)
tsc[4,2] = (4+i*16)

10. Graphics

TRIP requires the following versions of gnuplot to work :

• - on MacOS, version 3.6 or later (require to be installed on the same volume).
• - on Windows, version 3.7.3 or later.
• - on UNIX or MacOS X, version 3.7.0 or later.

TRIP requires the following versions of grace to work :

• - On UNIX, MacOS X or Windows, version 5.1.8 or later.

The commands plot, replot, plotf, plotps, plotps_end and plotreset use grace or gnuplot depending on the global variable _graph (see section _graph).

10.1 plot

Procedure: plot

plot(<(array of) real vec.> TX, <(array of) real vec.> TY);

plot(<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options);

Executes gnuplot or grace and plots the contents of the numerical vector TY function of TX.

The string options is directly sent to gnuplot or grace as an argument of the command plot.

If the string options contains double-quotes, two double-quotes must be used.

Remarks : Temporary files are created and will be destroyed at the end of the session.

Procedure: plot

plot(<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ);

plot(<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options);

Executes gnuplot or grace and plots in 3D the contents of the numerical vector TZ function of TY and TX.

Procedure: plot

plot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY);

plot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options);

It executes gnuplot or grace if necessary. It sends to gnuplot or grace the command cmd and plots the contents of the numerical vector TY function of TX.

Procedure: plot

plot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ);

plot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options);

It executes gnuplot or grace if necessary. It sends to gnuplot or grace the command cmd and plots in 3D the contents of the numerical vector TZ function of TY and TX.

Procedure: plot

plot( (<(array of) real vec.> TX, <(array of) real vec.> TY), ... );

plot( (<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options), ...);

Executes gnuplot or grace and overlays all draws of each couplet with plotting the contents of the numerical vector TY function of TX.

Procedure: plot

plot( (<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ), ...);

plot( (<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options), ...);

Executes gnuplot or grace and overlays all draws of each triplet with plotting in 3D the contents of the numerical vector TZ function of TY and TX. session.

Procedure: plot

plot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY), ...);

plot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options), ...);

It executes gnuplot or grace if necessary. It sends to gnuplot or grace the command cmd and plots the contents of each couplet of the numerical vector TY function of TX.

Procedure: plot

plot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ), ...);

plot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options), ...);

It executes gnuplot or grace if necessary. It sends to gnuplot or grace the command cmd and plots in 3D the contents of each triplet of the vectors TZ function of TY and TX.

 Example :
Tracer cos(x) pour x=-pi à pi avec un pas de pi/100.
> x=-pi,pi,pi/100;
x    Tableau de reels : nb reels =200
> y=cos(x);
y    Tableau de reels : nb reels =200
> plot(x,y);
> plot(x,y,cos(x));
> plot(x,y,"notitle w points pt 5");
> plot(x,y,"title ""x,cos(x)"" ");
> t=1,10;
t        Tableau de reels : nb reels =10
>  plot("set xrange[2:5]",t,log(t));


> t=0,pi,pi/100;
> vnumR ta[1:3];
> ta[1]=cos(t);
> ta[2]=sin(t);
> ta[3]=cosh(t);
> dim nom[1:3];
> nom[1]="title 'cos' w l";
> nom[2]="title 'sin' w l";
> nom[3]="title 'cosh' w l";
> plot((t,ta,nom));

10.2 replot

Procedure: replot

replot(<(array of) real vec.> TX, <(array of) real vec.> TY);

replot(<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options);

replot(<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ);

replot(<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options);

replot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY);

replot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options);

replot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ);

replot(<string> cmd, <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options);

replot( (<(array of) real vec.> TX, <(array of) real vec.> TY), ... );

replot( (<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options), ...);

replot( (<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ), ...);

replot( (<(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options), ...);

replot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY), ...);

replot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) string> options), ...);

replot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ), ...);

replot(<string> cmd, ( <(array of) real vec.> TX, <(array of) real vec.> TY, <(array of) real vec.> TZ, <(array of) string> options), ...);

This command is very similar to the command plot but it overlays the draws on the previous draws.

It uses the same arguments as the command plot (see section plot).

Procedure: replot

replot;

Executes gnuplot or grace and send a command to redraw all graphics.

 Example :
Tracer cos(x) et sin(x) pour x=-pi à pi avec un pas de pi/100
dans la même fenêtre.               
> x=-pi,pi,pi/100;
x    Tableau de reels : nb reels =200
> y=cos(x);
y    Tableau de reels : nb reels =200
> y1=sin(x);
y1   Tableau de reels : nb reels =200
> plot(x,y);
> replot(x,y1);
> plot(x,y,y1);
> replot(x,y,sin(2.*x));
> replot(x,sin(x),"notitle");
> replot(x,y,"w points pt 5");

10.3 plotf

Procedure: plotf

plotf(<filename> filename, <integer> ncolTX, <integer> ncolTY);

It executes gnuplot or grace and plots the contents of the column ncolTY function of ncolTX in the file filename.

Procedure: plotf

plotf(<filename> filename, <integer> ncolTX, <integer> ncolTY, <integer> ncolTZ);

It executes gnuplot or grace and plots the contents of the column ncolTZ function of ncolTY and ncolTX in the file filename.

gnuplot will ignore lines beginning by the character #.

 Example :
Afficher la troisieme colonne en fonction de la première colonne du
fichier tab.out
> plotf(tab.out,1,3);
Afficher la troisieme colonne en fonction de la première et deuxième
colonne du fichier tab.out
> plotf(tab.out,1,2,3);