Manuel utilisateur de TRIP

TRIP est un programme de manipulation algébrique orienté vers les calculs de méthodes de perturbations et plus particulièrement vers la mécanique celeste.

Auteurs :

• 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

Avec des contributions de E. Paviot, F. Thire, D. Acheroff, M. To, A. Ceyrac, G. Rouault, V. Kelsch.

Ce logiciel inclut une librairie développée par la fondation NetBSD et ses contributeurs.

Ce logiciel inclut les librairies LAPACK et 'SCSCP C Library'.

Ce logiciel est lié dynamiquement aux librairies LTDL, GMP, MPFR et MPC. Le code source de ces librairies peut être téléchargé depuis les sites internet indiqués dans le chapitre References (voir la section References).

TRIP version 1.1.18

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

1. Introduction

Pour exécuter TRIP, il faut

• - Sous Unix et MacOs X, taper trip dans un shell.
• - Sous Windows, cliquer sur l'icone de trip pour la version console.
• - Sous Windows, cliquer sur l'icone de tripstudio pour la version graphique.

Vous verrez à l'écran :

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

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

> 

TRIP est prêt à recevoir vos ordres. TRIP dispose d'un interpréteur sensible aux minuscules et majuscules.

Pour calculer S=(X+Y)^2, il suffit de faire :

              **** 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

Les touches de curseur permettent de modifier la ligne courante ou de rappeler les commandes précédentes.

Pour quitter TRIP, il suffit de taper quit ou exit.

Les mots réservés du langage TRIP sont spécifiés dans les annexes. Ces mots se répartissent en trois catégories :

• - Variables globales, constantes de TRIP et symboles mathématiques.
• - Fonctions : commande retournant une valeur
• - Procédures : commande ne retournant jamais de valeur.

Au démarrage de TRIP ou lors de l'exécution des commandes reset ou @@ , celui-ci lit les fichiers suivants dans l'ordre indiqué :

Ces fichiers peuvent contenir n'importe quelles instructions.

Recommendations :

• - Il est souhaitable de configurer les variables d'environnements suivantes :
  • TMPDIR : répertoire où seront stockés les fichiers temporaires.
  • LC_MESSAGES : langue utilisée pour les messages affichés.

2. Semantique

2.1 expression

Une expression peut faire intervenir tous les opérateurs définis sur les identificateurs, ainsi que des appels de fonctions ou de commandes. Une expression doit se terminer par le caractère ; ou $ . Le ; entraine le calcul et l'impression du resultat, alors que le caractère $ n'effectue que le calcul. Plusieurs instructions séparées par ; ou $ peuvent se trouver à la suite. Elle seront effectuées en séquence.

Un commentaire sur une ou plusieurs lignes est défini par /* .... */, comme dans le langage C. Un commentaire de fin de lignes est défini par les caractères // , comme dans le langage C++.

 Exemple :
> 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 identificateur

Un identificateur doit commencer par une lettre et se composer de lettres (majuscules ou minuscules) et/ou de chiffres (09), ainsi que du caractere _ ou ' . Par défaut, un identificateur est global, c'est-à-dire qu'il est visible depuis n'importe quelle instruction. Un identificateur peut être local à une macro, c'est-à-dire qu'il est visible uniquement depuis cette macro et sera détruit à chaque fois que l'exécution de cette macro se terminera. Un mot réservé de TRIP ne peut pas être utilisé comme identificateur. Un identificateur peut être de type :

• - variable
• - série
• - constante
• - tableau de séries
• - tableau de variables
• - tableau numérique
• - chaine de caractères

 Exemple :
> 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 Visibilite

Commande: private

private <identificateur> x ,...;

Cette commande indique que les identificateurs suivants seront locaux à une macro ou à une boucle (for, while, sum).

Les identificateurs locaux sont détruits à la fin de l'exécution d'une macro ou à la fin de chaque itération de la boucle (for, while, sum).

Si un identificateur local porte le même nom qu'un identificateur global, l'identificateur local sera alors utilisé automatiquement. Dans ce cas, on dit que l'identificateur local cache l'identifiateur global.

 Exemple :
> 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

Une série est un polynôme de degré n (n étant un entier). Elle est donc fonction d'une ou plusieurs variables.

 Exemple :
> 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 constante

Une constante est un nombre entier, réel, complexe, rationnel ou un intervalle . En mode numérique rationnel (_modenum = NUMRAT ou _modenum = NUMRATMP), la saisie de 0.5 crée un réel et non le rationnel 1/2.

 Exemple :
>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 chaine de caracteres

C'est une suite de caractères entre " ". Elle est utilisée pour définir le _path, donner des commentaires, définir des noms de fichiers, etc... Elles ne sont pas limitées en taille. Par contre, pour le _path, sa longueur est tronquée à 256 (valeur dépendant du système). Pour produire un guillemet (") dans une chaine, il suffit de le doubler.

 Exemple :
>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 reel

<nom> = <réel> ;

Un nombre réel est toujours affiché ou saisi en base 10. Le symbole d, e, E ou D est l'opérateur d'exponentiation.

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

2.7 complexe

<nom> = <réel> + i * <réel> ;

Les nombres complexes sont reconnus. Il suffit de les écrire avec un i minuscule ou avec un I majuscule.

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

2.8 nom de fichier

C'est une chaine de caractères . Cette chaine doit etre encadrée par des " " si la chaine contient les caractères espaces " [ ] { } ( ) ou plusieurs points. Un nom de fichier peut être le contenu d'un identificateur de type chaine de caractères.

Ces noms de fichiers sont toujours relatifs à la variable globale _path, excepté ceux construits à l'aide de la fonction file_fullname (voir la section file_fullname).

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

2.9 fichier

C'est un objet désignant un fichier ouvert en lecture ou en écriture.

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

La description des fonctions, procédures et variables utilisent les types suivants :

3. Variables globales

L'affichage de la valeur d'une variable globale est realisée en donnant le nom de la variable suivi de ; . L'affichage de la valeur de l'ensemble des variables globales s'effectue avec la commande vartrip (voir la section vartrip). Les variables globales réelles sont stockées sous la forme d'un réel double-précision.

3.1 _affc

Variable: entier _affc

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

Elle indique le format souhaité pour l'affichage des coefficients numériques dans les séries ou constantes.

Valeur par défaut = 4.

• = 1 : %G (format court standard)
• = 2 : %.8G (8 chiffres après la virgule)
• = 3 : %.10G (10 chiffres après la virgule)
• = 4 : %20.15G (15 chiffres ou plus après la virgule)
• = 5 : pseudo rationnel (les doubles sont convertis en rationnels par fractions continues quand c'est possible, sinon %.8G)
• = 6 : même chose que 5 mais %.15G (15 chiffres après la virgule)
• = 7 : pseudo rationnel (format de longueur fixe)
• = 8 : %15.6E (6 chiffres après la virgule)
• = 9 : même chose que 4 avec diamètre de l'intervalle

 Exemple :
> _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: entier _affdist

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

indique le type d'affichage souhaité pour les séries

Valeur par défaut = 2.

• = 0 : récursif.
• = 1 : distribué.
• = 2 : distribué avec un terme par ligne.
• = 3 : distribué sous forme de (co)sinus.
• = 4 : distribué sous forme de (co)sinus avec un terme par ligne.
• = 5 : distribué et aligné sous forme de (co)sinus avec un terme par ligne.
• = 6 : distribué et factorisé par rapport aux variables de _affvar.
• = 7 : distribué avec un terme par ligne et factorisé par rapport aux variables de _affvar.

Remarque : Si _affvar est vide, l'affichage de _affdist = 6, respectivement 7, est équivalent à _affdist=1, respectivement 2.

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

3.3 _comment

Variable: booleen _comment

_comment {on,off};

Active ou désactive l'affichage des commentaires.

Valeur par défaut = off.

 Exemple :
> _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: entier _cpu

_cpu = <entier> ;

Spécifie le nombre de processeurs utilisables pour les calculs suivants.

Il est impossible de spécifier un nombre supérieur au nombre de processeurs ou coeurs utilisables.

Valeur par défaut : nombre de processeurs ou coeurs disponibles sur la machine.

 Exemple :
> _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: booleen _echo

_echo = {0, 1};

_echo {on,off};

Active ou désactive l'affichage de l'écho des commandes exécutées.

Valeur par défaut = off.

• = 1 : Affiche l'écho des commandes (similaire à on)
• = 0 : N'affiche pas l'écho des commandes (similaire à off)

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

3.6 _endian

Variable: nom _endian

_endian = {little , big};

Indique l'ordre des octets (big-endian ou little-endian) dans les fichiers binaires.

Valeur par défaut = endianness de la machine.

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

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

3.7 _graph

Variable: nom _graph

_graph = gnuplot;

_graph = grace;

Indique si les commandes plot, replot, plotps, plotf utiliseront les logiciels grace ou gnuplot (voir la section Graphiques) pour réaliser les graphiques.

Valeur par défaut = gnuplot.

• = gnuplot : gnuplot réalise les graphiques
• = grace : grace réalise les graphiques

 Exemple :
> _graph = grace;
                _graph      = grace
> _graph = gnuplot;
                _graph      = gnuplot

3.8 _hist

Variable: booleen _hist

_hist {on,off};

Indique si le fichier ‘history.trip’ est ouvert ou non.

Si le fichier est ouvert, les commandes sont alors enregistrées dans ce fichier.

Valeur par défaut = on.

 Exemple :
>_hist;
_hist = ON

3.9 _history

Variable: chaine _history

_history = <chaine> ;

Indique le répertoire où sera stocké le fichier ‘history.trip’.

Valeur par défaut = "".

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

3.10 _info

Variable: booleen _info

_info {on,off};

Active ou désactive l'affichage de messages d'informations.

Valeur par défaut = on.

 Exemple :
> _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 };

Change la langue utilisee pour les messages.

valeur par défaut =

• - Sous Unix, Linux et MacOS X, depend de la variable d'environnement LC_MESSAGES. Si elle n'existe pas, la languge francaise est utilisee.
• - Sous Windows, depend des préférences du système.

 Exemple :
> _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 };

Indique la représentation utilisée pour le stockage séries et pendant les calculs sur les séries.

Ce mode peut être changé en cours de route.

Valeur par défaut = POLY.

• - POLY : Séries sous forme récursive creuse. Ce mode est le mode par défaut. Il est efficace pour les degrés très élevés.
• - POLP : Séries sous forme récursive pleine. Souvent le plus rapide. A utiliser dès que les degrés partiels des séries sont peu élevés.
• - POLYV : Séries sous forme récursive creuse. Ce mode est le mode par défaut. Les listes terminales sont optimisées pour le mode numérique courant. Il est efficace pour les degrés très élevés.
• - POLPV : Séries sous forme récursive pleine. Souvent le plus rapide. Les vecteurs terminaux sont optimisés pour le mode numérique courant. A utiliser dès que les degrés partiels des séries sont peu élevés.

 Exemple :
> _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};

Indique le type choisi pour les coefficients numériques et des tableaux numériques.

Ce mode peut être changé en cours de route.

Valeur par défaut = NUMDBL.

Les coefficients sont codés sous les formes suivantes :

• - NUMDBL : réel double-précision. (par défaut)
• - NUMQUAD : réel quadruple-précision. Ce mode n'est pas supporté sous Windows.
• - NUMRAT : rationnel si possible, sinon d'un réel double-précision.

  La valeur absolue du numérateur et du dénominateur est comprise entre 0 et 2**62 sur la plupart des machines. Si le numérateur ou le dénominateur devient trop grand, le rationnel est compris en réel double-précision.

  Les nombres réels sont toujours stockés en double-précision. Par exemple, le coefficient "2.0" sera stocké sous la forme réel double-précision alors que le coefficient "2" sera stocké sous la forme d'un rationnel.

• - NUMRATMP : entier ou rationnel multi-précision, sinon d'un réel double-précision.

  La valeur absolue du numérateur et du dénominateur ne sont pas limités.

  Les nombres réels sont toujours stockés en double-précision. Par exemple, le coefficient "2.0" sera stocké sous la forme réel double-précision alors que le coefficient "2" sera stocké sous la forme d'un rationnel.

  Ces coefficients numériques utilisent la librairie GMP. (type mpz_t ou mpq_t). Sur les systèmes d'exploitation 64 bits, les entiers inférieurs à 2^63-1 en valeur absolue utilisent directement les instructions du processeur au lieu de la librairie GMP.

• - NUMFPMP : réel multiprécision.

  Le nombre de chiffres significatifs est specifies par la variable globale _modenum_prec (voir la section _modenum_prec).

  Ces coefficients numériques utilisent la librairie MPFR.

Pour les modes NUMRAT, NUMRATMP, les tableaux numériques contiennent toujours des réels ou de complexes double-précision.

 Exemple :
> _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: entier _modenum_prec

_modenum_prec = <entier> ;

Variable utilisée si _modenum = NUMFPMP (voir la section _modenum).

Elle indique le nombre de chiffres significatifs des nombres réels multi-precision.

Valeur par défaut = 64.

 Exemple :
> _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: réel _naf_dtour

_naf_dtour = <réel> ;

Variable utilisée par naf (voir la section Analyse en frequence).

Elle indique la "longueur d'un tour de cadran".

Valeur par défaut = 2*pi.

 Exemple :
> _naf_dtour=360;

3.16 _naf_icplx

Variable: entier _naf_icplx

_naf_icplx = {0, 1};

Variable utilisée par naf (voir la section Analyse en frequence).

Elle indique si la fonction est réelle ou complexe.

Valeur par défaut = 1.

Les valeurs possibles sont :

• = 0 : fonction réelle
• = 1 : fonction complexe

 Exemple :
> _naf_icplx=0;

3.17 _naf_iprt

Variable: entier _naf_iprt

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

Variable utilisée par naf (voir la section Analyse en frequence).

Elle indique le niveau d'affichage pour naf et naftab. L'affichage des resultats intermédiaires sera stocké dans un fichier.

Valeur par défaut = -1.

Les valeurs possibles sont :

• = -1 : aucun affichage.
• = 0 : affichage très succint.
• = 1 : affichage détaillé.
• = 2 : affichage très détaillé.

 Exemple :
> _naf_iprt  = 2;

3.18 _naf_isec

Variable: entier _naf_isec

_naf_isec = {0, 1};

Variable utilisée par naf (voir la section Analyse en frequence).

Elle indique l'utilisation ou non de la méthode des sécantes.

Valeur par défaut = 1.

Les valeurs possibles sont :

• = 0 : la méthode des sécantes n'est pas utilisée.
• = 1 : la méthode des sécantes est utilisée.

 Exemple :
> _naf_isec=1;

3.19 _naf_iw

Variable: entier _naf_iw

_naf_iw = <entier> ;

Variable utilisée par naf (voir la section Analyse en frequence).

Elle indique la présence de fenêtre.

Valeur par défaut = 1.

Les valeurs possibles sont :

• = -1 : fenêtre exponentielle PHI(T) = 1/CE*EXP(-1/(1-T^2))

  avec CE= 0.22199690808403971891E0

• = 0 : pas de fenêtre
• = N > 0 : PHI(T) = CN*(1+COS(PI*T))**N avec CN = 2^N(N!)^2/(2N)!

 Exemple :
> _naf_iw=-1;

3.20 _naf_nulin

Variable: entier _naf_nulin

_naf_nulin = <entier> ;

Variable utilisée par naf (voir la section naf).

Elle indique le nombre de lignes à ignorer en début du fichier de données.

Valeur par défaut = 1.

 Exemple :
> _naf_nulin=0;

3.21 _naf_tol

Variable: réel _naf_tol

_naf_tol = <réel> ;

Variable utilisée par naf (voir la section Analyse en frequence).

Elle indique la tolérance pour déterminer si deux fréquences sont identiques.

Valeur par défaut = 1E-10.

 Exemple :
> _naf_tol=1E-4;

3.22 _path

Variable: chaine _path

_path = <chaine> ;

_path = "chemin du repertoire";

Indique le répertoire utilisé pour la sauvegarde ou le chargement de fichiers. Toutes les commandes ou fonctions TRIP sauvegardant ou lisant des fichiers utilisent ce radical. Ce chemin est notamment utilisé pour le chargement de programme trip (include), la création de fichier postscript (plotps) et le tracé de fichier (plotf).

Valeur par défaut = "" (le répertoire courant).

Remarque :

• - Ne pas oublier le "/" à la fin du path sous UNIX ou MACOS X.
• - Ne pas oublier le ":" à la fin du path sous MACOS 9.x .
• - Ne pas oublier le "\" à la fin du path sous WINDOWS.

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

3.23 _time

Variable: booleen _time

_time {on, off};

active ou désactive l'affichage du temps partiel après chaque commande exécutée.

Lors de la commande _time on, un appel implicite à time_s est effectué et au retour de la commande, le temps 0.00s est affiché.

Valeur par défaut = off.

 Exemple :
> 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

constante : complexe i

constante : complexe I

i^2 = -1

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

3.25 PI

constante : réel pi

constante : réel PI

Le symbole mathématique pi

 Exemple :
>z = pi; 
 3.14159265358979

4. Variables

4.1 crevar

Fonction : crevar

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

Elle crée et retourne une variable de nom radical+"_"+ indice1 + ... + "_" + indicen.

crevar (<chaine ou nom> radical);

Elle crée et retourne une variable de nom radical. Cette fonction permet de creer des variables avec nom non standard.

 Exemple :
>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 Operateurs

Operateur : + - * /

TRIP effectue l'addition (ou le plus unaire), la multiplication, la soustraction (ou moins unaire) et la division entre les séries, variables, constantes ou expressions.

Pour additionner, multiplier, soustraire et diviser terme à terme des tableaux, il existe l'opérateur +, *, - et /.

Les opérateurs +, *, -, / s'appliquent aux tableaux numériques.

Le + ou - unaire s'applique à tous les types.

Remarque: La division par une série n'est pas supportée. Il faut utiliser la fonction div pour une division euclidienne.

 Exemple :
> 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

Operateur : ** ^

<série> **<réel>

Elle effectue l'élevation à la puissance.

Elle accepte des exposants à valeurs entières.

La puissance **-1 sur un tableau à 2 dimensions égales effectue l'inversion matricielle.

Remarque : Par contre, la puissance terme à terme ** n'existe pas pour les tableaux.

 Exemple :
> 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 Fonctions usuelles

Fonction : size

size(<série> s )

Elle retourne le nombre de termes de la série s.

 Exemple :
> 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 Derivation et integration

Fonction : deriv

deriv(<série> , <variable> )

Elle dérive la série par rapport à une variable .

 Exemple :
> 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

Fonction : integ

integ(<série> , <variable> )

Elle intègre la série par rapport à une variable .

 Exemple :
>  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 Division euclidienne

Commande : div

div(<série> f, <série> g, <identificateur> q, <identificateur> r )

Elle calcule le quotient et le reste de la division de f par g tel que f=q\times g +r et degre(r)<degre(g). Le quotient est stocké dans q et le reste dans r.

 Exemple :
> 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

Fonction : coef_ext

coef_ext(<série> , (<variable> ,<entier> ),...)

Elle récupère le coefficient de la variable à la puissance désirée dans la série.

coef_ext(S,(X,n),(Y,m)) retourne le coefficient de X^n*Y^m dans la série S.

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

5.6 Evaluation

5.6.1 coef_num

Fonction : coef_num

coef_num(<série> , (<variable> ,<constante> ),...)

Elle substitue rapidement dans une série une (ou des) variable(s) par une (ou des) constantes numériques.

 Exemple :
> 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

Fonction : evalnum

evalnum(<série> , {REAL/COMPLEX} , (<variable> ,<tab. num.> ),...)

Elle évalue la série en substituant les variables par leur valeur dans le tableau numérique associé.

La fonction retourne un tableau numérique de réels si REAL a été précisé sinon un tableau numérique de complexes si COMPLEX a été précisé.

Les tableaux numériques doivent être de taille identique.

 Exemple :
> 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. Constantes

6.1 Fonctions usuelles

La plupart des routines sont décrites dans (voir la section Tableaux numeriques).

6.1.1 factoriel

Fonction : fac

fac( <entier> n);

Elle retourne n! (fonction factorielle).

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

6.2 Entree/Sortie sur les reels

Ces routines assurent la lecture ou l'écriture séquentielle d'un fichier texte contenant uniquement des réels.

Commande : ecriture

ecriture(<nom fichier> );

Cette fonction ouvre un fichier en écriture dans le répertoire spécifié par _path. Si le fichier n'existe pas, il est crée automatiquement.

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

Commande : lecture

lecture(<nom fichier> );

Cette fonction ouvre un fichier en lecture dans le répertoire spécifié par _path.

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

Commande : print

print(<réel> );

Cette fonction écrit dans le fichier ouvert en écriture(avec ecriture) un réel en double-précision. Write a double-precision floating-point number in the file opened (with the command ecriture).

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

Fonction : read

read;

Cette fonction lit dans le fichier ouvert en lecture(avec lecture) et retourne un réel en double-précision.

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

Commande : close

close;

Cette fonction ferme le fichier de réels s'il est ouvert (en écriture ou en lecture).

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

7. Chaines de caracteres

7.1 Declaration et affectation

La déclaration de chaine de caractères est implicite. Elle est automatiquement effectuée lors d'une affectation. Pour produire un guillemet (") dans une chaine, il suffit de le doubler.

<nom> = <chaine> ;

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

7.2 Concatenation

<nom> = <chaine> + <chaine> ;

L'opérateur + concatène deux chaines de caractères. La longueur des chaines n'est pas limitée.

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

7.3 Repetition

Operateur : *

<chaine> * <entier>

<entier> * <chaine>

L'opérateur * répète, le nombre de fois spécifié par l'entier, la chaine de caractères. L'entier doit être positif ou nul. Si l'entier est 0, la chaîne retournée est vide.

 Exemple :
> 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

Operateur : ==

<chaine> == <chaine>

L'opérateur == retourne vrai si les chaines de caractères sont identiques sinon elle retourne faux.

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

Operateur : !=

<chaine> != <chaine>

L'opérateur != retourne faux si les chaines de caractères sont identiques sinon elle retourne vrai.

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

7.5 Conversion d'entier ou de reel en chaines

Fonction : str

str( <entier> );

str( <réel> );

str( <chaine> format, <réel> );

Elle convertit un entier ou un réel en chaine de caractères. Si format est spécifié, alors l'entier ou le réel est convertit suivant celui-ci. Le format est similaire à celui-ci de la fonction printf du langage C.

Les indicateurs de conversion sont

• - g,G le nombre est converti sous forme de réel (notation xxxx.xxxx ou notation scientifique [-]d.dddE+-dd) si exposant trop grand).
• - e,E le nombre est converti sous forme de réel (notation scientifique [-]d.dddE+-dd).
• - f,F le nombre est converti sous forme de réel (notation [-]ddddd.ddddd).
• - d,i le nombre est converti sous forme d'entier. Si l'argument est un réel, alors seule sa partie entière est convertit. En mode numérique NUMRAT ou NUMRATMP, les rationnels sont écrits sous la forme "numérateur/dénominateur".

Les modificateurs de longueur ne sont pas acceptées. Par exemple, le format "%lg" est refusé.

En mode numérique NUMRAT ou NUMRATMP, les rationnels sont écrits sous la forme "numérateur/dénominateur" si aucun format n'est spécifié.

 Exemple :
> 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 d'une liste d'entiers ou de reels en chaines

Fonction : msg

msg(<chaine> textformat, <réel> x, ... );

Elle génère une chaine contenant le texte formaté accompagné de constantes réelles.

Le formatage est identique à celui de de la commande printf du langage C (voir la section Conversion d'entier ou de reel en chaines, pour les formats acceptés). Le format doit être une chaine et peut être sur plusieurs lignes.

Pour écrire un guillemet, il faut le doubler.

 Exemple :
> 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 Longueur de chaines

Fonction : size

size( <chaine> );

Elle retourne la longueur de la chaine, c'est-à-dire le nombre de caractères.

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

8. Tableaux

Il existe trois sortes de tableaux dans TRIP :

• - Les tableaux de séries et constantes.
• - Les tableaux de variables.
• - Les tableaux numériques.

Les matrices sont des tableaux de séries et de constantes. Ce chapitre ne discute pas des tableaux numériques.

8.1 Declaration de tableaux de series

Commande : dim

dim <nom> [ <liste_dimension> ], ...;

Elle déclare un ou plusieurs tableaux de séries en spécifiant le nombre de dimension.

Chaque dimension est séparée par une virgule. Une dimension est composée de deux entiers qui indiquent l'indice du premier et du dernier élément de cette dimension.

Ce type de tableaux peut contenir des séries, des constantes, des troncatures, des chaines de caractères, ... mais pas de variables.

 Exemple :
/*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 Initialisation d'un tableau de series

<nom> = [<série> ,... : <série> , ...];

Cette commande crée et initialise un tableau de séries avec les séries ou constantes fournies.

Les : indiquent une nouvelle ligne et les , séparent les colonnes. Il doit y avoir le même nombre de colonne pour chaque ligne.

 Exemple :
/*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

Commande : dimvar

dimvar <nom> [ <liste_dimension> ], ...;

Elle déclare un ou plusieurs tableaux de variables en spécifiant le nombre de dimension.

Chaque dimension est séparée par une virgule. Une dimension est composée de deux entiers qui indiquent l'indice du premier et du dernier élément de cette dimension.

Ce type de tableaux ne peut contenir que des variables. Pour affecter une variable existante à un tableau de variables, on remplace le symbole = par := .

 Exemple :
/*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.3 Generation d'un tableau de variables

Commande : tabvar

tabvar( <tableau de variables> );

Elle génère automatiquement les variables dans le tableau spécifié en utilisant comme nom des variables, le nom du tableau et leur indice.

Avant d'utiliser tabvar, il faut créer un tableau de variables à l'aide de dimvar.

 Exemple :
> 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.4 Affectation dans un tableau

Operateur : =

<nom> = <tableau> ;

Elle affecte le tableau (opérations entre des tableaux) au nom de l'identificateur fourni.

<tableau> [<entier> , ...] = <opération> ;

Elle affecte à un élément du tableau l'opération. Cette opération peut être une série, une constante, un tableau numérique, une troncature mais pas un tableau.

<tableau> [ <entier> binf : <entier> bsup : <entier> pas ,...]= <operation> ;

<tableau> [ <entier> binf : <entier> bsup ,...]= <operation> ;

Elle affecte une opération à une partie de tableau. Si cette opération est une série, une constante, un tableau numérique, une troncature alors cette opération est copiée pour chaque élément du tableau. Si cette opération est un tableau, alors chaque élément de celui-ci est affecté dans l'élément correspondant. Dans ce cas, elle vérifie que le nombre d'éléments et de dimensions est cohérent.

Si la borne inférieure est omise, alors sa valeur est 1. Si la borne supérieure est omise, alors sa valeur est la taille du tableau. Si le pas est omis, alors sa valeur est 1.

Remarque : toutes les combinaisons d'omissions sont permises.

 Exemple :
> 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;

Operateur : :=

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

Elle affecte une variable à un élément du tableau de variables.

 Exemple :
> 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.5 Taille d'un tableau

Fonction : size

size(<tableau> );

size(<tableau> ,<entier> );

Elle retourne le nombre d'éléments du tableau contenu dans la première dimension ou dans la dimension spécifiée par l'entier.

Si la dimension spécifiée n'existe pas dans le tableau, alors la fonction retourne -1.

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

8.6 Affichage d'un tableau

Commande : afftab

afftab(<tableau> );

Elle affiche le contenu du tableau de séries ou de variables.

 Exemple :
> 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.7 Extraction d'element

Operateur : []

<tableau> [<entier> ,...];

Elle retourne l'élément ayant ces indices.

<tab. num.> [ <entier> binf : <entier> bsup : <entier> pas,.. ];

<tab. num.> [ <entier> binf : <entier> bsup, .. ];

Elle retourne un tableau contenant uniquement les éléments situés entre les bornes inférieures et supérieures avec le pas spécifié.

Si la borne inférieure est omise, alors sa valeur est la borne inférieure de la dimension correspondante. Si la borne supérieure est omise, alors sa valeur est borne supérieure de la dimension correspondante. Si le pas est omis, alors sa valeur est 1.

Remarque : toutes les combinaisons d'omissions sont permises.

 Exemple :
> 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.8 Operations sur les tableaux de series

La plupart des fonctions usuelles sont décrites dans (voir la section Tableaux numeriques). Les fonctions suivantes peuvent être appliquées aux tableaux de séries (comme sur les séries) pour éviter les boucles for :

• coef_ext voir la section coef_ext
• coef_num voir la section coef_num

8.8.1 Produit matriciel

Operateur : &*

<tableau> &* <tableau>

Elle calcule le produit matriciel de deux tableaux à 1 ou 2 dimensions.

Si le tableau a une seule dimension, alors il est considéré comme un vecteur-colonne.

Remarque: le nombre de colonnes du premier tableau doit être égal au nombre de lignes du second tableau.

 Exemple :
> 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.8.2 Determinant

Fonction : det

det( <tableau> )

Elle calcule le déterminant d'un tableau à 2 dimensions (matrice carrée).

Remarque: lors de calculs en double-precision, la librairie Lapack est utilisée. Un algorithme LU est utilisée dans tous les modes numeriques.

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

8.8.3 Inverse

Fonction : **-1

<tableau> **-1

Elle calcule l'inverse d'un tableau à 2 dimensions (matrice carrée).

Remarque : lors de calculs en double-precision, la librairie Lapack est utilisée. Un algorithme LU est utilisée dans tous les cas.

 Exemple :
> 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.8.4 Valeurs propres

Fonction : eigenvalues

eigenvalues(<tableau> )

Elle calcule les valeurs propres d'un tableau à 2 dimensions (matrice carrée) en utilisant un algorithme QR ( librairie lapack).

 Exemple :
> 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.8.5 Vecteurs propres

Commande : eigenvectors

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

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

Elle calcule les vecteurs propres d'un tableau MAT à 2 dimensions (matrice carrée). Elle stocke les vecteurs propres dans le tableau TVECT et les valeurs propres dans le tableau TVAL.

Elle utilise un algorithme QR ( librairie lapack).

Chaque colonne de TVECT correspond à un vecteur propre. Chaque vecteur est normalisé.

 Exemple :
> 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.8.6 Arithmetique

Les tableaux doivent avoir le même nombre de dimensions et le même nombre d'éléments par dimension.

Operateur : +

<tableau> + <tableau>

Elle retourne l'addition terme à terme de deux tableaux de séries.

Operateur : +

<tableau> + <série>

<série> + <tableau>

Elle retourne la somme d'une série et de chaque élément du tableau de séries.

Operateur : *

<tableau> * <tableau>

Elle retourne le produit terme à terme de deux tableaux de séries.

Operateur : *

<tableau> * <série>

<série> * <tableau>

Elle retourne le produit terme à terme d'une série et d'un tableau de séries.

Operateur : -

<tableau> - <tableau>

Elle retourne la soustraction terme à terme de deux tableaux de séries.

Operateur : -

<tableau> - <série>

<série> - <tableau>

Elle retourne la diffŽrence entre une série et chaque élément du tableau de séries.

Operateur : /

<tableau> / <tableau>

Elle retourne la division terme à terme de deux tableaux de séries.

Operateur : /

<tableau> / <série>

<série> / <tableau>

Elle retourne la division entre une série et chaque élément du tableau de séries.

 Exemple :
>  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.9 Conversion

Pour la conversion en tableaux numériques, (voir la section Conversion).

9. Tableaux numeriques

Les données numériques, stockées dans ces tableaux, sont toujours des réels ou complexes double-précision, quadruple-précision ou multiprecision suivant le mode numérique courant.

9.1 Declaration

La déclaration explicite de tableau numérique est nécessaire uniquement avant l'utilisation de la commande read , readbin (voir la section Entree/Sortie) et resize . Elle est aussi nécessaire pour les tableaux de tableaux numériques.

Commande : vnumR

vnumR <nom> , ... ;

vnumR <nom> [ <dimension d'un tableau> ] , ... ;

Elle déclare un tableau de réels ou un tableau de tableau numérique de réels.

La dimension permet de spécifier le nombre d'éléments du tableau de tableaux de réels. La taille des tableaux de réels est dynamique. Apres cette déclaration, les tableaux de réels sont vides. Pour spécifier leur taille, il faut utiliser la commande resize.

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

Commande : vnumC

vnumC <nom> , ... ;

vnumC <nom> [ <dimension d'un tableau> ] , ... ;

Elle déclare un tableau de complexes ou un tableau de tableau numérique de complexes.

La dimension permet de spécifier le nombre d'éléments du tableau de tableaux de complexes. La taille des tableaux de complexes est dynamique. Apres cette déclaration, les tableaux de complexes sont vides. Pour spécifier leur taille, il faut utiliser la commande resize.

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

9.2 Initialisation

Commande : ,,,

<nom> = <réel> binf , <réel> bsup , <réel> step ;

Elle déclare un tableau de réels tel que les éléments soient initialisés par une boucle (de binf à bsup avec un pas bstep):

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

Le pas bstep est optionnel; par défaut, sa valeur est 1.

 Exemple :
> 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  
> 

Commande : vnumR[,,:,,]

<nom> = vnumR [ <réel> ou <tab. réel> ou <tableau de tab. réel> , ... : <réel> ,... ] ;

Elle déclare et initialise un tableau de réels ou un tableau de tableau numérique de réels avec les réels ou les tableaux de réels fournis.

Les caractères : séparent les lignes et les caractères , séparent les colonnes.

Il doit y avoir le même nombre de lignes pour chaque colonne.

 Exemple :
> /*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  

Commande : vnumC[,,:,,]

<nom> = vnumC [ <complexe> ou <tab. complexe> ou <tableau de tab. complexe> , ... : <complexe> ,... ] ;

Elle déclare et initialise un tableau de complexes ou un tableau de tableau numérique de complexes avec les complexes, des tableaux numériques de complexes fournis.

Les : séparent les lignes et les , séparent les colonnes.

Il doit y avoir le même nombre de lignes pour chaque colonne.

 Exemple :
/*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 Affichage

Commande : writes

writes([ <entier> : <entier> : <entier> ], <chaine> , <(tableau de) tab. num.> , ...);

writes( <chaine> , <(tableau de) tab. num.> , ...);

writes( <(tableau de) tab. num.> , ...);

équivaut à

writes( { [binf:{bsup}:{step}], } {format,} <(tableau de) tab. num.> ,...).

Elle écrit à l'ecran, les tableaux numériques ou les tableaux de tableaux numériques sous la forme de colonnes.

• A partir du binfème élément de chaque tableau numérique (si binf n'est pas spécifié, à partir du 1er élément).
• Jusqu'au bsupème élément de chaque tableau numérique (si bsup n'est pas spécifié, jusqu'au dernier élément du plus grand tableau).
• Tous les stepèmes éléments (si step n'est pas spécifié, avec un pas de 1).

Le format est optionnel. Ce format est un format au standard C (cf. printf) et est encadré par des guillemets ("). Pour faire un guillemet, il faut le doubler :

Par exemple : si le format C est " %g \"titi\" %g", il faut écrire, " %g\""titi\"" %g"

Un tableau de complexes occupent deux colonnes (la 1ère pour la partie réelle, la 2ème pour la partie complexe).

 Exemple :
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 Taille

Fonction : size

size( <tab. num.> )

Elle retourne le nombre d'éléments du tableau numérique.

 Exemple :
> 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 Changement de la taille

Commande : resize

resize(<(tableau de) tab. num.> , <entier> );

resize(<(tableau de) tab. num.> , <entier> , <constante> );

Elle change la taille d'un tableau numérique ou d'un tableau de tableaux numériques.

Tous les éléments sont initialisés à 0 si aucune constante n'est fournie, sinon les éléments sont initialisés avec la constante fournie.

 Exemple :
> 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 Extraction

Fonction : select

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

Elle retourne un tableau numérique contenant uniquement les éléments du tableau numérique quand la condition est vraie.

La condition et le tableau numérique doivent avoir le même nombre d'éléments.

 Exemple :
/*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  

Operateur : []

<tab. num.> [ <tab. réel> ];

Elle retourne un tableau numérique contenant uniquement les éléments situés aux indices contenus dans le tableau de réels.

Remarque : le tableau de réels doit toujours être un identificateur et non le resultat d'une opération.

 Exemple :
> 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

Operateur : [::]

<tab. num.> [ <entier> binf : <entier> bsup : <entier> pas ];

<tab. num.> [ <entier> binf : <entier> bsup ];

Elle retourne un tableau numérique contenant uniquement les éléments situés entre les bornes inférieures et supérieures avec le pas spécifié.

Si la borne inférieure est omise, alors sa valeur est 1. Si la borne supérieure est omise, alors sa valeur est la taille du tableau. Si le pas est omis, alors sa valeur est 1.

Remarque : toutes les combinaisons d'omissions sont permises.

 Exemple :
> 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 Entree/Sortie

9.7.1 read

Commande : read

read(<nom fichier> ,[ <entier> : <entier> : <entier> ],

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

équivaut à

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

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

Elle lit dans un fichier ascii les colonnes specifiées et les stocke dans les tableaux numériques.

• à partir de la ligne binf (si binf n'est pas spécifié, alors à partir de la première ligne)
• jusqu'à la ligne bsup (si bsup n'est pas spécifié, alors jusqu'à la fin)
• toutes les bstep lignes (si bstep n'est pas spécifié, alors le pas est de 1 )

• - Si le numéro de colonnes n'est pas précisé pour un tableau de réels, alors la colonne pour ce tableau sera la dernière colonne +1.
• - Si le numéro de colonnes de la partie réelle n'est pas précisé pour un tableau de complexe, alors la colonne pour ce tableau sera la dernière colonne +1.
• - Si le numéro de colonnes de la partie imaginaire n'est pas précisé pour un tableau de complexe et la partie réelle précisée, alors la partie imaginaire du tableau est mise à 0.

Si le fichier contient les expressions NAN ou NANQ, ceux-ci sont interprétés comme des "Not A Number". Si le fichier contient les expressions INF, Inf ou Infinity, ceux-ci sont interprétés comme des infinis.

 Exemple :
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

Commande : readappend

readappend(<nom fichier> ,[ <entier> : <entier> : <entier> ],

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

équivaut à

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

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

Cette fonction est identique à la fonction read (voir la section read) mais elle stocke les données lues à la fin des vecteurs numériques en agrandissant automatiquement ceux-ci au lieu d'écraser leur contenu.

 Exemple :
>  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

Commande : write

write( <nom fichier> , [ <entier> : <entier> : <entier> ], <chaine> , <(tableau de) tab. num.> , ...);

write( <nom fichier> , <chaine> , <(tableau de) tab. num.> , ...);

write( <nom fichier> , <(tableau de) tab. num.> , ...);

équivaut à

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).

Elle écrit dans le fichier les tableaux numériques ou les tableaux de tableaux numériques sous la forme de colonnes.

• A partir du binf élément de chaque tableau numérique (si binf n'est pas spécifié, à partir du 1er élément).
• Jusqu'au bsupeme élément de chaque tableau numérique (si bsup n'est pas spécifié, jusqu'au dernier élément du plus grand tableau).
• Tous les stepemes éléments (si step n'est pas spécifié, avec un pas de 1).

Le format est optionnel. Ce format est un format au standard C (cf. printf) et est encadre par des guillemets ("). Pour faire un guillemet, il faut le doubler :

Par exemple : si le format C est " %g \"titi\" %E", il faut écrire, " %g \""titi\"" %E"

Un tableau de complexes occupent deux colonnes (la 1ère pour la partie réelle, la 2ème pour la partie complexe).

 Exemple :
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

Commande : readbin

readbin(<nom fichier> ,[ <entier> : <entier> : <entier> ], <chaine> , <(tableau de) tab. réel> , ...);

readbin(<nom fichier> , <chaine> , <(tableau de) tab. réel> , ...);

équivaut à

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

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

Elle lit dans un fichier binaire les données dont le format est spécifié et les stocke dans les tableaux numériques.

• à partir de l'enregistrement binf (si binf n'est pas spécifié, alors à partir du premier enregistrement)
• jusqu'à l'enregistrement bsup (si bsup n'est pas spécifié, alors jusqu'à la fin)
• toutes les bstep enregistrements (si bstep n'est pas spécifié, alors le pas est de 1 )

Les formats acceptés pour définir un enregistrement sont :

• - %2d entier signé sur 2 octets.
• - %4d entier signé sur 4 octets.
• - %8d entier signé sur 8 octets.
• - %d entier signé (taille par défaut du système pour un entier).
• - %2u entier non signé sur 2 octets.
• - %4u entier non signé sur 4 octets.
• - %8u entier non signé sur 8 octets.
• - %u entier non signé (taille par défaut du système pour un entier).
• - %E réel double-précision.
• - %e réel double-précision.
• - %g réel double-précision.
• - %8g réel double-précision sur 8 octets.
• - %hE réel simple précision.
• - %he réel simple précision.
• - %hg réel simple précision.
• - %4g réel simple précision sur 4 octets.

Il doit y avoir autant de formats que de tableaux numériques. Si le tableau fourni est un tableau de tableau de réels, alors il doit y avoir autant de formats que d'éléments du tableau.

Les données sont préalablement converties si la variable globale _endian (voir la section _endian) est différente de la valeur par défaut.

 Exemple :
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

Commande : writebin

writebin(<nom fichier> ,[ <entier> : <entier> : <entier> ], <chaine> , <(tableau de) tab. réel> , ...);

writebin(<nom fichier> , <chaine> , <(tableau de) tab. réel> , ...);

équivaut à

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

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

Elle ecrit les tableaux numériques dans un fichier binaire avec le format est spécifié.

• à partir de l'indice binf (si binf n'est pas spécifié, alors à partir du premier élément des tableaux numeriques)
• jusqu'à l'indice bsup (si bsup n'est pas spécifié, alors jusqu'à la fin)
• toutes les bstep éléments (si bstep n'est pas spécifié, alors le pas est de 1 )

Les formats acceptés pour définir un enregistrement sont :

• - %2d entier signé sur 2 octets.
• - %4d entier signé sur 4 octets.
• - %8d entier signé sur 8 octets.
• - %d entier signé (taille par défaut du système pour un entier).
• - %2u entier non signé sur 2 octets.
• - %4u entier non signé sur 4 octets.
• - %8u entier non signé sur 8 octets.
• - %u entier non signé (taille par défaut du système pour un entier).
• - %E réel double-précision.
• - %e réel double-précision.
• - %g réel double-précision.
• - %8g réel double-précision sur 8 octets.
• - %hE réel simple précision.
• - %he réel simple précision.
• - %hg réel simple précision.
• - %4g réel simple précision sur 4 octets.

Il doit y avoir autant de formats que de tableaux numériques. Si le tableau fourni est un tableau de tableau de réels, alors il doit y avoir autant de formats que d'éléments du tableau.

Si les tableaux numériques ont des longueurs différentes, les données manquantes sont complétés par des 0.

Les données sont préalablement converties si la variable globale _endian (voir la section _endian) est différente de la valeur par défaut.

 Exemple :
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 Entree/Sortie bas niveau

9.8.1 file_open

Fonction : <fichier> file_open

file_open(<nom fichier> , read);

file_open(<nom fichier> , write);

Elle ouvre un fichier en lecture seule ou en écriture seule selon le second paramètre. Elle retourne un identificateur de type fichier.

 Exemple :
> 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

Commande : file_close

file_close(<fichier> );

Elle ferme un fichier précédemment ouvert avec la fonction file_open.

 Exemple :
> 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

Commande : file_write

file_write( <fichier> , [ <entier> : <entier> : <entier> ], <chaine> , <(tableau de) tab. num.> , ...);

file_write( <fichier> , <chaine> , <(tableau de) tab. num.> , ...);

file_write( <fichier> , <(tableau de) tab. num.> , ...);

équivaut à

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).

Cette fonction est similaire à la fonction write (voir la section write) mais elle accepte un identificateur de type fichier au lieu d'un nom de fichier. Elle écrit les données dans le fichier à partir de la position courante.

 Exemple :
> 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

Commande : file_read

file_read(<fichier> ,[ <entier> : <entier> : <entier> ],

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

équivaut à

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

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

Cette fonction est similaire à la fonction read (voir la section read) mais elle accepte un identificateur de type fichier au lieu d'un nom de fichier. Elle lit les données depuis le fichier à partir de la position courante.

 Exemple :
> 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

Commande : file_readappend

file_readappend(<fichier> ,[ <entier> : <entier> : <entier> ],

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

équivaut à

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

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

Cette fonction est similaire à la fonction readappend (voir la section readappend) mais elle accepte un identificateur de type fichier au lieu d'un nom de fichier. Elle lit les données depuis le fichier à partir de la position courante.

 Exemple :
> 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

Commande : file_writemsg

file_writemsg(<fichier> , <chaine> textformat);

file_writemsg(<fichier> , <chaine> textformat, <réel> x, ... );

Elle écrit dans le fichier le texte formaté et accompagné ou non de constantes réelles.

Les constantes réelles sont formatées. Le formatage est identique à celui de de la commande printf du langage C (voir la section Conversion d'entier ou de reel en chaines, pour les formats acceptés). Le texte doit être une chaine ou un texte entre guillemets. Le texte peut être sur plusieurs lignes.

Pour écrire un guillemet, il faut le doubler.

 Exemple :
> 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 Fonctions mathematiques et usuelles

9.9.1 minimum et maximum

Fonction : imin

imin( <tab. réel> )

Elle retourne l'indice du minimum d'un tableau de réels. Si plusieurs éléments ont la valeur minimale, alors cette fonction retourne l'indice du permier élément. Si le tableau est vide, alors la fonction retourne 0.

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

Fonction : imax

imax( <tab. réel> )

Elle retourne l'indice du maximum d'un tableau de réels. Si plusieurs éléments ont la valeur maximale, alors cette fonction retourne l'indice du permier élément. Si le tableau est vide, alors la fonction retourne 0.

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

Fonction : MIN

MIN( <tab. réel> , ...)

Elle retourne un tableau de réels tel que ses éléments soient le minimum terme à terme de chaque tableau de réels.

Les tableaux de réels doivent avoir la même taille.

Pour un tableau de tableaux numériques, l'opération s'effectue sur chaque él'ement du tableau.

 Exemple :
> 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	

Fonction : MAX

MAX( <tab. réel> , ...)

Elle retourne un tableau de réels tel que ses éléments soient le maximum terme à terme de chaque tableau de réels.

Les tableaux de réels doivent avoir la même taille.

Pour un tableau de tableaux numériques, l'opération s'effectue sur chaque él'ement du tableau.

 Exemple :
> 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	

Fonction : min

min( <réel ou tab. réel> , ...);

Elle retourne le minimum des valeurs fournies qui peuvent être des tableaux de réels ou des constantes réelles.

 Exemple :
>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

Fonction : max

max( <réel ou tab. réel> , ...);

Elle retourne le maximum des valeurs fournies qui peuvent être des tableaux de réels ou des constantes réelles.

 Exemple :
>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 somme et produit

Fonction : sum

sum( <tab. num.> )

Elle retourne la somme des éléments d'un tableau numérique.

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

Fonction : prod

prod( <tab. num.> )

Elle retourne le produit des éléments d'un tableau numérique.

 Exemple :
> 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)

Fonction : accum

accum( <tab. num.> )

Elle retourne la somme partielle des éléments d'un tableau numérique :

Y=accum(X) alors Y[N] = sum(X[1:N])

 Exemple :
> 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 tris

Fonction : reversevnum

reversevnum (<tab. num.> )

Elle inverse l'ordre des éléments d'un tableau numérique.

 Exemple :
> 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  

Commande : sort

sort ( <tab. réel> )

Elle effectue le tri ascendant des éléments du tableau de réels.

sort ( <tab. réel> , <(tableau de) tab. num.> , ...);

Elle effectue le tri des éléments des (tableaux de) tableaux numériques en fonction du tri ascendant du premier tableau de réels.

Remarque : Si on effectue l'appel ‘sort(TX,TY,TZ);’, les tableaux TY et TZ sont triés mais pas le tableau TX.

 Exemple :
> 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

Fonction : transposevnum

transposevnum ( <tableau de tab. num.> )

Elle retourne la transposée d'un tableau de tableaux numériques.

Le tableau doit avoir une seule dimension et les tableaux numériques de celui-ci ont une taille identique.

 Exemple :
> 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 fonctions mathematiques

Fonction : abs

abs( <constante ou tab. num.> )

Elle retourne la valeur absolue d'une constante si la valeur fournie est une constante.

Elle retourne un tableau de réels contenant la valeur absolue de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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

Fonction : arg

arg( <constante ou tab. num.> )

Elle retourne l'argument d'une constante si la valeur fournie est une constante.

Elle retourne un tableau de réels contenant l'argument de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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  

Fonction : real

real( <constante ou tab. num.> )

Elle retourne la partie réelle d'une constante si la valeur fournie est une constante.

Elle retourne un tableau de réels contenant la partie réelle de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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

Fonction : imag

imag( <constante ou tab. num.> )

Elle retourne la partie imaginaire d'une constante si la valeur fournie est une constante.

Elle retourne un tableau de réels contenant la partie imaginaire de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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

Fonction : conj

conj( <constante ou tab. num.> )

Elle retourne le conjugué d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le conjugué de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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  

Fonction : erf

erf( <réel ou tab. réel> )

Elle retourne la fonction d'erreur d'une constante si la valeur fournie est un réel.

Elle retourne un tableau numérique contenant la fonction d'erreur de chaque élément si la valeur fournie est un tableau numérique de réels.

La fonction d'erreur est définie par : erf(x) = 2/sqrt(pi) * intégral de 0 à x de exp(-t*t) dt

 Exemple :
> 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

Fonction : erfc

erfc( <réel ou tab. réel> )

Elle retourne le complémentaire de la fonction d'erreur d'une constante si la valeur fournie est un réel.

Elle retourne un tableau numérique contenant le complémentaire de la fonction d'erreur de chaque élément si la valeur fournie est un tableau numérique de réels.

Le complémntaire de la fonction d'erreur est définie par : erfc(x) = 1 - (2/sqrt(pi) * intégrale de 0 à x de exp(-t*t) dt)

 Exemple :
> 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

Fonction : exp

exp( <constante ou tab. num.> )

Elle retourne l'exponentiel d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant l'exponentiel de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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  

Fonction : sqrt

sqrt( <constante ou tab. num.> )

Elle retourne la racine carrée d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant la racine carrée de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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  

Fonction : cos

cos( <constante ou tab. num.> )

Elle retourne le cosinus d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le cosinus de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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)

Fonction : sin

sin( <constante ou tab. num.> )

Elle retourne le sinus d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le sinus de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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)

Fonction : tan

tan( <constante ou tab. num.> )

Elle retourne la tangente d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant la tangente de chaque élément si la valeur fournie est un tableau numérique.

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

Fonction : acos

acos( <réel ou tab. réel> )

Elle retourne l'arc cosinus d'un réel si la valeur fournie est un réel.

Elle retourne un tableau de réels contenant l'arc cosinus de chaque élément si la valeur fournie est un tableau de réels.

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

Fonction : asin

asin( <réel ou tab. réel> )

Elle retourne l'arc sinus d'un réel si la valeur fournie est un réel.

Elle retourne un tableau de réels contenant l'arc sinus de chaque élément si la valeur fournie est un tableau de réels.

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

Fonction : atan

atan( <réel ou tab. réel> )

Elle retourne l'arc tangente d'un réel si la valeur fournie est un réel.

Elle retourne un tableau de réels contenant l'arc tangente de chaque élément si la valeur fournie est un tableau de réels.

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

Fonction : cosh

cosh( <constante ou tab. num.> )

Elle retourne le cosinus hyperbolique d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le cosinus hyperbolique de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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)

Fonction : sinh

sinh( <constante ou tab. num.> )

Elle retourne le sinus hyperbolique d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le sinus hyperbolique de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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)

Fonction : tanh

tanh( <constante ou tab. num.> )

Elle retourne la tangente hyperbolique d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant la tangente hyperbolique de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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);

Fonction : acosh

acosh( <constante ou tab. num.> )

Elle retourne l'arc cosinus hyperbolique d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant l'arc cosinus hyperbolique de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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

Fonction : asinh

asinh( <constante ou tab. num.> )

Elle retourne l'arc sinus hyperbolique d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant l'arc sinus hyperbolique de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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

Fonction : asinh

asinh( <constante ou tab. num.> )

Elle retourne l'arc tangente hyperbolique d'une constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant l'arc tangente hyperbolique de chaque élément si la valeur fournie est un tableau numérique.

 Exemple :
> 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

Fonction : atan2

atan2( <réel ou tab. réel> , <réel ou tab. réel> )

Elle retourne l'arc tangente du premier terme divisé par le deuxième terme en tenant compte du signe des arguments.

Cette notation équivaut à réaliser atan(<constante ou tab. réel> / <constante ou tab. réel>).

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

Fonction : mod

mod( <réel ou tab. réel> , <réel ou tab. réel> )

<réel ou tab. réel> mod <réel ou tab. réel>

Elle retourne le modulo du premier terme divisé par le deuxième terme. Le résultat a le même signe que le premier argument.

 Exemple :
> 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);

Fonction : int

int( <réel ou tab. réel> )

Elle retourne la partie entiere du réel si la valeur fournie est un réel.

Elle retourne un tableau de réels contenant la partie entiere de chaque élément si la valeur fournie est un tableau de réels.

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

Fonction : log

log( <constante ou tab. num.> )

Elle retourne le logarithme népérien de la constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le logarithme népérien de chaque élément si la valeur fournie est un tableau numérique.

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

Fonction : log10

log10( <constante ou tab. num.> )

Elle retourne le logarithme décimal (ou à base 10) de la constante si la valeur fournie est une constante.

Elle retourne un tableau numérique contenant le logarithme décimal de chaque élément si la valeur fournie est un tableau numérique.

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

Fonction : nint

nint( <réel ou tab. réel> )

Elle retourne l'entier le plus proche du réel si la valeur fournie est un réel.

Elle retourne un tableau de réels contenant l'entier le plus proche de chaque élément si la valeur fournie est un tableau de réels.

 Exemple :
>  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);

Fonction : sign

sign( <réel ou tab. réel> )

Elle retourne le signe du réel si la valeur fournie est un réel

Elle retourne un tableau de réels contenant le signe de chaque élément si la valeur fournie est un tableau de réels.

Elle est définie suivant la règle :

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

 Exemple :
> 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

Fonction : histogram

histogram(<tab. réel> TY, <tab. réel> TX)

Elle retourne l'histogramme de TY à partir des intervalles fournis dans TX :

TZ=histogram(TY,TX) : TZ[N] contient le nombre d'éléments de TY tel que TX[N]<=TY[j]<TX[N+1].

Pour le dernier intervalle de TX, la relation est : TX[N]<=TY[j]<=TX[N+1]

 Exemple :
> 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

Operateur : ?()::

?(<condition>)

Elle retourne un tableau numérique de 0 ou de 1. Pour tous éléments de la condition : si la condition à l'indice j est vraie, alors <nom> [j]=1 sinon <nom> [j]=0

?(<condition>): <constante ou tab. num.> tabvrai : <constante ou tab. num.> tabfaux

Elle retourne un tableau numérique. Pour tous éléments de la condition : si la condition à l'indice j est vraie, alors <nom> [j]=tabvrai[j] sinon <nom> [j]=tabfaux[j]

Les tableaux doivent être de même taille.

 Exemple :
> 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

Fonction : dimtovnumR

dimtovnumR( <tableau> )

Elle retourne un tableau numérique de réels à partir d'un tableau de séries.

Le tableau de séries doit contenir uniquement des nombres réels. Le tableau doit avoir une seule dimension.

 Exemple :
> 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

Fonction : dimtovnumC

dimtovnumC( <tableau> )

Elle retourne un tableau numérique de complexes à partir d'un tableau de séries.

Le tableau de séries doit contenir uniquement des nombres complexes. Le tableau doit avoir une seule dimension.

 Exemple :
> 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

Fonction : vnumtodim

vnumtodim( <(tableau de) tab. num.> )

Elle retourne un tableau de séries (de constantes) à partir d'un (tableau de) tableau numérique.

 Exemple :
> 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. Graphiques

Les versions requises de gnuplot par TRIP sont :

• - Sous MacOS, version beta 3.6 ou ultérieur (doit être sur le même volume).
• - Sous Windows, version 3.7.3 ou ultérieur.
• - Sous UNIX ou MacOS X, version 3.7.0 ou ultérieur.

Les versions requises de grace par TRIP sont :

• - Sous UNIX, MacOS X ou Windows, version 5.1.8 ou ultérieur.

Les commandes plot, replot, plotf, plotps, plotps_end et plotreset utilisent grace ou gnuplot suivant la valeur de la variable globale _graph (voir la section _graph).

10.1 plot

Commande : plot

plot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY);

plot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options);

Elle exécute gnuplot ou grace et trace le contenu du tableau numérique TY en fonction de TX.

La chaine ou le tableau de chaines options est directement passée à gnuplot ou à grace en argument de la commande plot.

Si la chaine options doit contenir des guillemets, il faut les doubler.

Remarque : Des fichiers temporaires sont crées mais détruits à la fin de la session.

Commande : plot

plot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ);

plot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options);

Elle exécute gnuplot ou grace et trace en 3D le contenu du tableau TZ en fonction de TY et de TX.

Commande : plot

plot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY);

plot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options);

Elle exécute gnuplot ou grace si nécessaire. Elle envoie à gnuplot ou à grace la commande cmd puis trace le contenu du tableau TY en fonction de TX.

Commande : plot

plot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ);

plot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options);

Elle exécute gnuplot ou grace si nécessaire. Elle envoie à gnuplot ou à grace la commande cmd puis trace en 3D le contenu du tableau TZ en fonction de TY et de TX.

Commande : plot

plot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY), ... );

plot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options), ...);

Elle exécute gnuplot ou grace et superpose les courbes de chaque couplet de tableaux en tra

Commande : plot

plot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ), ...);

plot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options), ...);

Elle exécute gnuplot ou grace et superpose les courbes de chaque triplet de tableaux en tra

Commande : plot

plot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY), ...);

plot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options), ...);

Elle exécute gnuplot ou grace si nécessaire. Elle envoie à gnuplot ou à grace la commande cmd puis trace le contenu de chaque couplet des tableaux TY en fonction de TX.

Commande : plot

plot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ), ...);

plot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options), ...);

Elle exécute gnuplot ou grace si nécessaire. Elle envoie à gnuplot ou à grace la commande cmd puis trace en 3D le contenu de chaque triplet des tableaux TZ en fonction de TY et de TX.

 Exemple :
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

Commande : replot

replot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY);

replot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options);

replot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ);

replot(<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options);

replot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY);

replot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options);

replot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ);

replot(<chaine> cmd, <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options);

replot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY), ... );

replot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options), ...);

replot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ), ...);

replot( (<(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options), ...);

replot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY), ...);

replot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) chaine> options), ...);

replot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ), ...);

replot(<chaine> cmd, ( <(tableau de) tab. réel> TX, <(tableau de) tab. réel> TY, <(tableau de) tab. réel> TZ, <(tableau de) chaine> options), ...);

Cette commande est similaire à la commande plot mais elle superpose les nouvelles courbes aux anciens tracés.

Elle utilise les mêmes arguments que la commande plot (voir la section plot).

Commande : replot

replot;

Elle exécute gnuplot ou grace et envoie un ordre pour retracer les graphiques.

 Exemple :
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

Commande : plotf

plotf(<nom fichier> filename, <entier> ncolTX, <entier> ncolTY);

Elle exécute gnuplot ou grace et trace le contenu de la colonne ncolTY en fonction de ncolTX du fichier filename.

Commande : plotf

plotf(<nom fichier> filename, <entier> ncolTX, <entier> ncolTY, <entier> ncolTZ);

Elle exécute gnuplot ou grace et trace le contenu de la colonne ncolTZ en fonction de ncolTY et de ncolTX du fichier filename.

Les lignes à ignorer par gnuplot doivent commencer par un #.

 Exemple :
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);

10.4 plotps

Commande : plotps

plotps <nom fichier> ;

Elle exécute gnuplot ou grace et met le terminal de gnuplot ou de grace en postscript.

Les tracés seront alors stockés dans le fichier postscript spécifié. Le fichier sera dans le répertoire indiqué par _path.

Pour fermer le fichier postscript, il faut exécuter la comande plotps_end.