Next: Introduction [Contents][Index]
• Introduction: | Démarrer avec TRIP | |
• Semantique : | ||
• Variables globales : | ||
• Variables : | ||
• Series : | ||
• Constantes : | ||
• Chaines : | ||
• Tableaux : | ||
• Structures : | ||
• Vecteurs numeriques : | ||
• Matrices numeriques : | ||
• Graphiques : | ||
• Communications : | ||
• Macros : | ||
• Boucles et conditions : | ||
• Bibliotheques : | ||
• Traitement numerique : | ||
• Utilitaire : | ||
• Index : |
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 :
Avec des contributions de E. Paviot, F. Thire, D. Acheroff, M. To, A. Ceyrac, G. Rouault, V. Kelsch, F. Darricau, N. Brucy, F. Boschet.
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 (see References).
TRIP version 1.4.120
Copyright © 1988-2021 J.Laskar/ASD/IMCCE/CNRS
Next: Semantique, Previous: Top, Up: Top [Contents][Index]
Pour exécuter TRIP, il faut
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 :
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é :
’$TRIPDIR/etc/trip.ini’ | où $TRIPDIR est le répertoire où est installé TRIP. |
’$HOME/.trip’ | où $HOME est le répertoire racine de l’utilisateur. |
’trip.ini’ | dans le répertoire courant. |
Ces fichiers peuvent contenir n’importe quelles instructions.
Recommendations :
Next: Variables globales, Previous: Introduction, Up: Top [Contents][Index]
• expression: | ||
• identificateur : | ||
• visibilite : |
Next: identificateur, Up: Semantique [Contents][Index]
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++.
> // calcule 1+t et affiche le resultat > s=1+t; s(t) = 1 + 1*t > // calcule 1+t mais n'affiche pas le resultat > s1=(1+x+y)^2$ > // affiche le contenu de s1 > s1; s1(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2 >
Next: visibilite, Previous: expression, Up: Semantique [Contents][Index]
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 :
> 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
La description des fonctions, procédures et variables utilisent les types suivants :
<identificateur> | identificateur |
<entier> | nombre entier naturel ou une opération retournant un entier |
<réel> | nombre réel ou une opération retournant un réel |
<complexe> | nombre complexe ou une opération retournant un complexe |
<variable> | variable |
<constante> | une opération retournant un nombre entier, réel ou complexe |
<série> | série |
<opération> | une opération retournant une série ou un nombre (une constante) |
<tableau> | tableau de série ou de constantes |
<tableau de variables> | tableau de variables |
<(tableau de) variables> | variable ou tableau de variables |
<vec. num.> | vecteur numérique de réels ou de complexes |
<vec. réel> | vecteur numérique de réels |
<vec. complexe> | vecteur numérique de complexes |
<tableau de vec. réel> | tableau de vecteurs numériques de réels |
<tableau de vec. complexe> | tableau de vecteurs numériques de complexes |
<tableau de vec. num.> | tableau de vecteurs numériques |
<(tableau de) vec. réel> | (tableau de) vecteur numérique de réels |
<(tableau de) vec. num.> | (tableau de) vecteur numérique |
<constante ou vec. num.> | constante ou vecteur numérique de réels ou de complexes |
<constante ou matrice> | constante ou matrice numérique de réels ou de complexes |
<réel ou vec. réel> | nombre réel ou vecteur numérique de réels |
<matrice> | matrice numérique |
<matrice reelle> | matrice numérique de réels |
<matrice complexe> | matrice numérique de complexes |
<nom fichier> | nom de fichier |
<fichier> | fichier |
<macro> | macro |
<dimension d’un tableau> | deux entiers séparés par un : |
<liste_dimension> | liste de <dimension d’un tableau> séparée par une virgule |
<2 dimensions d’une matrice> | liste de 2 dimensions séparée par une virgule. Chaque dimension est composée deux entiers séparés par un : |
<condition> | comparaison entre deux opérations |
<chaine> | une opération retournant une chaine de caractères |
<(tableau de) chaine> | une opération retournant un tableau de chaine de caractères ou une seule chaine de caractères |
<liste de variables> | liste de noms de variables ou tableau de variables |
<liste_parametres> | liste de paramètres d’une macro |
<corps> | liste d’expression trip |
<client scscp> | connexion vers un serveur SCSCP |
<objet distant> | objet stocké sur un serveur SCSCP distant |
<session Maple> | connexion vers une session Maple locale |
<session Mathematica> | connexion vers une session Maple locale |
Une série est un polynôme de degré n (n étant un entier). Elle est donc fonction d’une ou plusieurs variables.
> 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
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.
>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]
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.
> ch = "file" + "1"; ch = "file1" > sch = "../" + ch; sch = "../file1" > sch1 = sch + "." + str(12); sch1 = "../file1.12" > ch3="nomsuivide""fin"; ch3 = "nomsuivide"fin"
<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.
> a=2.125E6; a = 2125000 > q=3D2; q = 300 > r=0.123554545; r = 0.123554545
<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.
> x=2+i*3; x = (2+i*3) > y=-5+4*i; y = (-5+i*4)
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
(see file_fullname).
> read("fichier.1.dat",T); > s="ell."+str(10)+".asc"; s = "ell.10.asc" > read(s,T);
C’est un objet désignant un fichier ouvert en lecture ou en écriture.
> f = file_open("fichier.1.dat",read); > file_close(f);
Previous: identificateur, Up: Semantique [Contents][Index]
• private: | ||
• public: |
Next: public, Up: visibilite [Contents][Index]
private
<identificateur> x ,
...;
Cette commande indique que les identificateurs suivants seront locaux à une macro, à une boucle (for, while, sum) ou à un fichier.
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 l’identificateur est local à un fichier, celui-ci est uniquement visible par les macros de ce fichier ou pendant l’exécution de ce fichier.
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’identificateur global.
private _ALL;
Cette commande indique que tous les identificateurs utilisés dans la macro ou dans le fichier seront locaux à cette macro ou à ce fichier.
Le comportement est identique à la déclaration précédente.
Pour accéder à un objet global, il faut utiliser la commande public
(see public).
> // S, SY, SXY, SXX, DEL sont des identificateurs locaux > macro least_ab[TX,TY,a,b] { private S, SY, SXY, SXX, DEL; 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; tx Vecteur de reels double-precision : nb reels =10 > ty=3*tx; ty Vecteur de reels double-precision : nb reels =10 > %least_ab[tx,ty,[a],[b]]; > bilan; SX CONST a CONST b CONST tx VNUMR ty VNUMR > > // T2 est un identificateur local > macro detval[T] { private _ALL; 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 > bilan; SX CONST a CONST b CONST tx VNUMR ty VNUMR >
Previous: private, Up: visibilite [Contents][Index]
public
<identificateur> x ,
...;
Cette commande ne doit être utilisée qu’après la commande private _ALL;
. Elle indique que les identificateurs de cette liste seront globaux alors que tous les autres seront locaux à cette macro ou à ce fichier.
> // w est local et z est global > macro myfunc[T] { private _ALL; public z; w = cos(T); z = T; }; > %myfunc[5]; w = 0.2836621854632262 z = 5 > bilan; z CONST >
Next: Variables, Previous: Semantique, Up: Top [Contents][Index]
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
(see vartrip).
Les variables globales réelles sont stockées sous la forme d’un réel double-précision.
• _affc : | ||
• _affdist : | ||
• _comment : | ||
• _cpu : | ||
• _echo : | ||
• _endian : | ||
• _graph : | ||
• _hist : | ||
• _history : | ||
• _info : | ||
• _integnum : | ||
• _language : | ||
• _mode : | ||
• _modenum : | ||
• _modenum_prec : | ||
• _naf_dtour : | ||
• _naf_icplx : | ||
• _naf_iprt : | ||
• _naf_isec : | ||
• _naf_iw : | ||
• _naf_nulin : | ||
• _naf_tol : | ||
• _path : | ||
• _quiet : | ||
• _read : | ||
• _read_history : | ||
• _time : | ||
• _userlibrary_path : | ||
• I : | ||
• PI : |
Next: _affdist, Up: Variables globales [Contents][Index]
_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.
> _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)]
Next: _comment, Previous: _affc, Up: Variables globales [Contents][Index]
_affdist =
{0, 1, 2, 3, 4, 5, 6, 7, 8};
indique le type d’affichage souhaité pour les séries
Valeur par défaut = 2.
_affvar
.
_affvar
, avec un terme par ligne pour les 2 parties.
_affvar
, avec un terme par ligne pour la partie distribuée et sur une même ligne pour la partie factorisée .
Remarque : Si _affvar
est vide, l’affichage de _affdist
= 6, respectivement 7 ou 8,
est équivalent à _affdist
=1, respectivement 2.
>_affdist = 2; >x = 1+y; x(y) = 1 + 1*y
Next: _cpu, Previous: _affdist, Up: Variables globales [Contents][Index]
_comment
{on
,off
};
Active ou désactive l’affichage des commentaires.
Valeur par défaut = off
.
> _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;
Next: _echo, Previous: _comment, Up: Variables globales [Contents][Index]
_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.
> _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
Next: _endian, Previous: _cpu, Up: Variables globales [Contents][Index]
_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
.
>_echo = 1; >msg "exemple"; exemple cde>> msg "exemple";
Next: _graph, Previous: _echo, Up: Variables globales [Contents][Index]
_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.
> _endian=big; _endian = big > vnumR ieps; > readbin(file1.dat,"%u",ieps);
Next: _hist, Previous: _endian, Up: Variables globales [Contents][Index]
_graph = gnuplot
;
_graph = grace
;
Indique si les commandes plot, replot, plotps, plotf utiliseront les logiciels grace ou gnuplot (see Graphiques) pour réaliser les graphiques.
Valeur par défaut = gnuplot
.
> _graph = grace; _graph = grace > _graph = gnuplot; _graph = gnuplot
Next: _history, Previous: _graph, Up: Variables globales [Contents][Index]
_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
.
>_hist; _hist = ON
Next: _info, Previous: _hist, Up: Variables globales [Contents][Index]
_history =
<chaine> ;
Indique le répertoire où sera stocké le fichier history.trip.
Valeur par défaut = "".
> _history="/users/toto/"; _history = /users/toto/
Next: _integnum, Previous: _history, Up: Variables globales [Contents][Index]
_info
{on
,off
};
Active ou désactive l’affichage de messages d’informations.
Valeur par défaut = on
.
> _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.
Next: _language, Previous: _info, Up: Variables globales [Contents][Index]
_integnum
= {DOPRI8
,ODEX1
,ADAMS
};
D’efinit l’intégrateur utilisée lors de l’intégration numérique par integnum
(see integnum) et integnumfcn
(see integnumfcn).
Valeur par défaut = DOPRI8
.
> _integnum=ODEX1; _integnum = ODEX1 > _integnum=DOPRI8; _integnum = DOPRI8
Next: _mode, Previous: _integnum, Up: Variables globales [Contents][Index]
_language
= {fr, en };
Change la langue utilisee pour les messages.
valeur par défaut =
> _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);'
Next: _modenum, Previous: _language, Up: Variables globales [Contents][Index]
_mode =
{POLY
, POLP
, POLYV
, POLPV
};
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
.
> _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)
Next: _modenum_prec, Previous: _mode, Up: Variables globales [Contents][Index]
_modenum =
{NUMDBL
, NUMRAT
, NUMRATMP
, NUMQUAD
, NUMFPMP
};
Indique le type choisi pour les coefficients numériques, des vecteurs numériques et des matrices 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 :
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.
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.
Le nombre de chiffres significatifs est specifies par la variable globale _modenum_prec
(see _modenum_prec).
Ces coefficients numériques utilisent la librairie MPFR.
Pour les modes NUMRAT, NUMRATMP, les vecteurs ou matrices numériques contiennent toujours des réels ou de complexes double-précision.
> _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
Next: _naf_dtour, Previous: _modenum, Up: Variables globales [Contents][Index]
_modenum_prec =
<entier> ;
Variable utilisée si _modenum = NUMFPMP
(see _modenum).
Elle indique le nombre de chiffres significatifs des nombres réels multi-precision.
Valeur par défaut = 64.
> _modenum=NUMFPMP; _modenum = NUMFPMP > _modenum_prec= 20; _modenum_prec = 20 > pi; 3.14159265358979323846 > _modenum_prec= 40; _modenum_prec = 40 > pi; 3.1415926535897932384626433832795028841975
Next: _naf_icplx, Previous: _modenum_prec, Up: Variables globales [Contents][Index]
_naf_dtour =
<réel> ;
Variable utilisée par naf (see Analyse en frequence).
Elle indique la "longueur d’un tour de cadran".
Valeur par défaut = 2*pi.
> _naf_dtour=360;
Next: _naf_iprt, Previous: _naf_dtour, Up: Variables globales [Contents][Index]
_naf_icplx
= {0, 1};
Variable utilisée par naf (see Analyse en frequence).
Elle indique si la fonction est réelle ou complexe.
Valeur par défaut = 1.
Les valeurs possibles sont :
> _naf_icplx=0;
Next: _naf_isec, Previous: _naf_icplx, Up: Variables globales [Contents][Index]
_naf_iprt =
{-1 , 0, 1, 2};
Variable utilisée par naf (see 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 :
> _naf_iprt = 2;
Next: _naf_iw, Previous: _naf_iprt, Up: Variables globales [Contents][Index]
_naf_isec =
{0, 1};
Variable utilisée par naf (see 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 :
> _naf_isec=1;
Next: _naf_nulin, Previous: _naf_isec, Up: Variables globales [Contents][Index]
_naf_iw =
<entier> ;
Variable utilisée par naf (see Analyse en frequence).
Elle indique la présence de fenêtre.
Valeur par défaut = 1.
Les valeurs possibles sont :
avec CE= 0.22199690808403971891E0
> _naf_iw=-1;
Next: _naf_tol, Previous: _naf_iw, Up: Variables globales [Contents][Index]
_naf_nulin =
<entier> ;
Variable utilisée par naf (see naf).
Elle indique le nombre de lignes à ignorer en début du fichier de données.
Valeur par défaut = 1.
> _naf_nulin=0;
Next: _path, Previous: _naf_nulin, Up: Variables globales [Contents][Index]
_naf_tol =
<réel> ;
Variable utilisée par naf (see Analyse en frequence).
Elle indique la tolérance pour déterminer si deux fréquences sont identiques.
Valeur par défaut = 1E-10.
> _naf_tol=1E-4;
Next: _quiet, Previous: _naf_tol, Up: Variables globales [Contents][Index]
_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 :
_path = "/u/gram/trip/"; /* UNIX */ _path = "\u\gram\trip\"; /* WINDOWS */
Next: _read, Previous: _path, Up: Variables globales [Contents][Index]
_quiet
{on
,off
};
Supprime, respectivement réactive, les affichages ultérieurs pour les instructions suivies de ;
, uniquement dans la macro courante.
Valeur par défaut = off
.
> macro silence{ s=1; _quiet on; s=pi; }; > %silence; s = 1 > stat(s); constante de nom s et de valeur 3.141592653589793
Next: _read_history, Previous: _quiet, Up: Variables globales [Contents][Index]
_read
= ( );
_read
= ( "skipbrokenlines", "skipemptylines"
);
_read
est une liste d’aucune, une ou plusieurs chaines indiquant le comportement des fonctions read
et file_read lorsque des lignes vides ou partielles sont lues dans le fichier.
_read = ()
indique que ces fonctions génèreront une erreur en cas de ligne vide ou incomplète.
Les valeurs possibles sont :
Valeur par défaut = ( )
.
> t1=1,3; t1 Vecteur de reels double-precision : nb reels =3 > t2=11,13; t2 Vecteur de reels double-precision : nb reels =3 > f=file_open(temp001, write); f = fichier "temp001" ouvert en ecriture > file_writemsg(f,"# header line\n"); > file_write(f,t1); > file_writemsg(f,"err...\n"); > file_write(f,t2); > file_close(f); > _read= ( "skipbrokenlines"); _read = ( "skipbrokenlines" ) > vnumR Q; > read(temp001, Q); Information : La ligne 1 est ignoree : elle est incomplete ou vide Information : La ligne 5 est ignoree : elle est incomplete ou vide > writes(Q); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +1.1000000000000000E+01 +1.2000000000000000E+01 +1.3000000000000000E+01
Next: _time, Previous: _read, Up: Variables globales [Contents][Index]
_read_history
= <chaine> ;
_read_history
indique le nom du fichier dans lequel les erreurs ignorées par _read sont enregistrées.
Ce fichier est vidé lors de l’affectation de _read_history
.
Chaque ligne du fichier texte est constituée de deux colonnes: le numéro de la ligne et le nom du fichier où l’erreur s’est produite.
_read_history = ""
indique que les erreurs ignorées par _read ne sont pas enregistrées dans un fichier.
Valeur par défaut = ""
.
> t1=1,3; t1 Vecteur de reels double-precision : nb reels =3 > t2=11,13; t2 Vecteur de reels double-precision : nb reels =3 > f=file_open(temp001, write); f = fichier "temp001" ouvert en ecriture > file_writemsg(f,"# header line\n"); > file_write(f,t1); > file_writemsg(f,"err...\n"); > file_write(f,t2); > file_close(f); > _read=( "skipbrokenlines"); _read = ( "skipbrokenlines" ) > _read_history="errors.dat"; _read_history = "errors.dat" > vnumR Q; > read(temp001, Q); Information : La ligne 1 est ignoree : elle est incomplete ou vide Information : La ligne 5 est ignoree : elle est incomplete ou vide > vnumR lerr; > fmt="%g %s"; fmt = "%g %s" > read("errors.dat", fmt, lerr, ferr); > writes("%g\n",lerr); 1 5 > afftab(ferr); ferr[1] = "temp001" ferr[2] = "temp001"
Next: _userlibrary_path, Previous: _read_history, Up: Variables globales [Contents][Index]
_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
.
> 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 >
Next: I, Previous: _time, Up: Variables globales [Contents][Index]
_userlibrary_path =
<chaine> ;
_userlibrary_path =
"chemin du repertoire des fonctions utilisateurs";
Lors de l’affectation de cette variable, TRIP lit récursivement dans le dossier spécifié tous les fichiers ayant une extension .t.
Il charge toutes les macros de ces fichiers qui sont précédées du commentaire commencant par //!trip extern_function
et les rend visible à l’utilisateur sous forme de fonction.
Le format du commentaire est :
//!trip extern_function nom_de_la_fonction attribute="parametre_attribute" "parametres_inout"
La chaine parametre_attribute
peut contenir les valeurs suivantes séparées par des virgules. Si cette chaine est vide, alors la fonction est publique et visible par l’utilisateur.
parametres_inout
doit contenir autant d’éléments que la fonction. Chaque élément est s’eparé par une virgule. Un élément peut avoir les valeurs suivantes :
Plusieurs macros peuvent partager la même valeur nom_de_la_fonction
si elles ont un nombre différent de paramètres.
Valeur par défaut = ""
.
_userlibrary_path="./myuserlibrary/"; userfunc1(3); userfunc2(3,y);
Le dossier myuserlibrary contient le fichier suivant :
//!trip extern_function userfunc1 "in" macro userfunc1[x] { return 2*x+1; }; //!trip extern_function userfunc2 "in,out" macro userfunc2[x,y] { y=2*x+1; };
Next: PI, Previous: _userlibrary_path, Up: Variables globales [Contents][Index]
i^2 = -1
>z = x + y*i; z(x,y) = (0+i*1)*y+1*x
Previous: I, Up: Variables globales [Contents][Index]
Le symbole mathématique pi
>z = pi; 3.14159265358979
Next: Series, Previous: Variables globales, Up: Top [Contents][Index]
• crevar: | ||
• operateurs : |
Next: operateurs, Up: Variables [Contents][Index]
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 créer des variables avec un nom non standard.
> dimvar t[1:3]; > t[1]:=crevar("t",1); t[1] = t_1 = 1*t_1 > t[3]:=crevar("tab",3,2,1); t[3] = tab_3_2_1 = 1*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] = \bar{X} = 1*\bar{X} > u[1]; u[1] = \bar{X} = 1*\bar{X} >
<identificateur> [...] :=
<variable> ;
Elle crée une référence vers une variable existante.
> // w est une reference vers x > s=(1+x+y)**3$ > w:=x$ > stat(w); Variable x type : 2 ordres : 2 2 2 2 dependances : variables dependant de celle-ci : > deriv(s,w); 3 + 6*y + 3*y**2 + 6*x + 6*x*y + 3*x**2 >
Next: Constantes, Previous: Variables, Up: Top [Contents][Index]
• Operateurs : | ||
• Fonctions usuelles : | ||
• Derivation et integration : | ||
• Division euclidienne : | ||
• Selection : | ||
• Evaluation : |
Next: FoncusSeries, Up: Series [Contents][Index]
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 vecteurs 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.
> 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
<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.
> 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
Next: Derivation et integration, Previous: Operateurs, Up: Series [Contents][Index]
• size : |
Up: FoncusSeries [Contents][Index]
size(
<série> s )
Elle retourne le nombre de termes de la série s.
> 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
Next: Division euclidienne, Previous: FoncusSeries, Up: Series [Contents][Index]
• deriv : | ||
• integ : |
Next: integ, Up: Derivation et integration [Contents][Index]
deriv(
<série> , <variable> )
Elle dérive la série par rapport à une variable .
> 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
Previous: deriv, Up: Derivation et integration [Contents][Index]
integ(
<série> , <variable> )
Elle intègre la série par rapport à une variable .
> 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
Next: Selection, Previous: Derivation et integration, Up: Series [Contents][Index]
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.
> div(x^3+x+1, x^2+x+1, q,r); > q; q(x) = - 1 + 1*x > r; r(x) = 2 + 1*x
Next: Evaluation, Previous: Division euclidienne, Up: Series [Contents][Index]
• 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.
> S= (1+x+y+z)**4 $ > coef_ext(S,(x,1),(y,2)); 12 + 12*z
• coef_num: | ||
• evalnum: |
Next: evalnum, Up: Evaluation [Contents][Index]
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.
> 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
Previous: coef_num, Up: Evaluation [Contents][Index]
evalnum(
<série> ,
{REAL
/COMPLEX
} , (
<variable> ,
<vec. num.> ),
...)
Elle évalue la série en substituant les variables par leur valeur dans le vecteur numérique associé.
La fonction retourne un vecteur numérique de réels si REAL
a été précisé
sinon un vecteur numérique de complexes si COMPLEX
a été précisé.
Les vecteurs numériques doivent être de taille identique.
> serie=sin(x+y)-2*y; serie(y,_EXy1,_EXx1) = ( -0+i* 0.5)*_EXy1**-1*_EXx1**-1 + ( 0-i* 0.5)*_EXy1*_EXx1 - 2*y > TABX=0,pi,pi/6; TABX Vecteur de reels double-precision : nb reels =7 > TABY=-pi,0,pi/6; TABY Vecteur de reels double-precision : nb reels =7 > TABRES=evalnum(serie,REAL,(x,TABX),(y,TABY)); TABRES Vecteur de reels double-precision : nb reels =7 > writes(TABRES); +6.2831853071795862E+00 +4.3699623521985504E+00 +3.3227648010019526E+00 +3.1415926535897931E+00 +2.9604205061776341E+00 +1.9132229549810371E+00 +1.2246467991473532E-16 > writes(TABX); +0.0000000000000000E+00 +5.2359877559829882E-01 +1.0471975511965976E+00 +1.5707963267948966E+00 +2.0943951023931953E+00 +2.6179938779914940E+00 +3.1415926535897931E+00 > TABRES=evalnum(serie,COMPLEX,(x,TABX),(y,TABY)); TABRES Vecteur de complexes double-precision : nb complexes =7 > writes(TABRES); +6.2831853071795862E+00 +1.4997597826618576E-32 +4.3699623521985504E+00 +0.0000000000000000E+00 +3.3227648010019526E+00 +0.0000000000000000E+00 +3.1415926535897931E+00 +0.0000000000000000E+00 +2.9604205061776341E+00 -5.5511151231257827E-17 +1.9132229549810371E+00 +5.5511151231257827E-17 +1.2246467991473532E-16 +0.0000000000000000E+00 >
• Fonctions usuelles : | ||
• Entree/Sortie sur les reels : |
Next: Entree/Sortie sur les reels, Up: Constantes [Contents][Index]
La plupart des routines sont décrites dans (see Vecteurs numeriques).
• fac : | factoriel. |
fac(
<entier> n);
Elle retourne n! (fonction factorielle).
> fac(3); 6 > n=5; n = 5 > fac(n+1); 720 >
Previous: Fonctions usuelles des Constantes, Up: Constantes [Contents][Index]
Ces routines assurent la lecture ou l’écriture séquentielle d’un fichier texte contenant uniquement des réels.
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.
> ecriture("fichier1.dat");
lecture(
<nom fichier> );
Cette fonction ouvre un fichier en lecture dans le répertoire spécifié par _path
.
> lecture("fichier1.dat");
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
).
> ecriture("fichier1.dat"); > print(atan(1)); /* on écrit pi/4 dans fichier1.dat */
read;
Cette fonction lit dans le fichier ouvert en lecture(avec lecture
) et retourne un réel en double-précision.
> ecriture("fichier1.dat"); > print(atan(1)); > close; > lecture("fichier1.dat"); > s=read; s = 0.785398163397448 > close;
close;
Cette fonction ferme le fichier de réels s’il est ouvert (en écriture ou en lecture).
> ecriture("fichier1.dat"); > print(atan(1)); > close;
Next: Tableaux, Previous: Constantes, Up: Top [Contents][Index]
• Declaration et affectation : | ||
• Concatenation : | ||
• Repetition : | ||
• Extraction : | ||
• Comparaison : | ||
• str : | Conversion d’entier ou de reel en chaines. | |
• msg : | Conversion d’une liste d’entiers ou de reels. | |
• coef_num : | Conversion d’une chaine en entier ou en reel. | |
• size : | Longueur de chaines. |
Next: Concatenation, Up: Chaines [Contents][Index]
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> ;
/* L'exemple suivant declare les chaines ch et ch2. */ > ch="file"; ch = "file" > ch2=ch+".txt"; ch2 = "file.txt"
Next: Repetition, Previous: Declaration et affectation, Up: Chaines [Contents][Index]
<nom> = <chaine> +
<chaine> ;
L’opérateur + concatène deux chaines de caractères. La longueur des chaines n’est pas limitée.
> ch = "file" + "1"; ch = "file1" > sch = "../" + ch; sch = "../file1" > sch1 = sch + "." + str(12); sch1 = "../file1.12"
Next: Extractionstring, Previous: Concatenation, Up: Chaines [Contents][Index]
<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.
> 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);
Next: Comparaison, Previous: Repetition, Up: Chaines [Contents][Index]
<chaine> [
<entier> j ]
Elle retourne le caractère ayant cet indice j. Les indices commencent à 1.
<chaine> [
<entier> binf :
<entier> bsup ];
Elle retourne une chaine contenant uniquement les caractères situés entre les bornes inférieures et supérieures.
Si la borne inférieure est omise, alors sa valeur est 1. Si la borne supérieure est omise, alors sa valeur est la longueur de la chaine.
Remarque : toutes les combinaisons d’omissions sont permises.
> s="bonjour"; s = "bonjour" > s1=s[4]; s1 = "j" > s2=s[:3]; s2 = "bon" > s3=s[4:5]; s3 = "jo" >
Next: str, Previous: Extractionstring, Up: Chaines [Contents][Index]
<chaine> ==
<chaine>
L’opérateur == retourne vrai si les chaines de caractères sont identiques sinon elle retourne faux.
> s="monchemin"; s = "monchemin" > if (s=="monchemin") then { msg "true"; } else { msg "false"; }; true >
<chaine> !=
<chaine>
L’opérateur != retourne faux si les chaines de caractères sont identiques sinon elle retourne vrai.
> s="monchemin"; s = "monchemin" > if (s=="MON") then { msg "true"; } else { msg "false"; }; false >
<chaine> s1 <
<chaine> s2
L’opérateur < retourne true si s1 est plus petit que s2 selon l’ordre lexicographique sinon elle retourne faux.
> s="abc"; s = "abc" > if (s<"abd") then { msg "true"; } else { msg "false"; }; true >
<chaine> s1 <=
<chaine> s2
L’opérateur <= retourne true si s1 est plus petit que ou égal à s2 selon l’ordre lexicographique sinon elle retourne faux.
> s="abc"; s = "abc" > if (s<="abe") then { msg "true"; } else { msg "false"; }; true >
<chaine> s1 >
<chaine> s2
L’opérateur > retourne true si s1 est plus grand que s2 selon l’ordre lexicographique sinon elle retourne faux.
> s="abc"; s = "abc" > if (s>"abd") then { msg "true"; } else { msg "false"; }; false >
<chaine> s1 >=
<chaine> s2
L’opérateur >= retourne true si s1 est plus grand que ou égal à s2 selon l’ordre lexicographique sinon elle retourne faux.
> s="abc"; s = "abc" > if (s>="abe") then { msg "true"; } else { msg "false"; }; false >
Next: msgstring, Previous: Comparaison, Up: Chaines [Contents][Index]
str
( <entier> );
str
( <réel> );
str
( <série> );
str
( <chaine> format, <réel> );
Elle convertit un entier, un réel ou un objet 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
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é.
> 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" > s = str(1+x**2); s = " 1 + 1*x**2 " >
Next: coef_numstring, Previous: str, Up: Chaines [Contents][Index]
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 (see str, 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.
> 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"
Next: sizestring, Previous: msgstring, Up: Chaines [Contents][Index]
coef_num
( <chaine> );
Elle convertit une chaine en un entier ou un réel.
> d = coef_num("-42"); d = -42 > r = coef_num("3.14E0"); r = 3.14 >
Previous: coef_numstring, Up: Chaines [Contents][Index]
size
( <chaine> );
Elle retourne la longueur de la chaine, c’est-à-dire le nombre de caractères.
> ch = "1235"; ch = "1235" > size(ch); 4
Next: Structures, Previous: Chaines, Up: Top [Contents][Index]
Il existe quatre sortes de tableaux dans TRIP :
Les matrices sont des tableaux de séries et de constantes. Ce chapitre ne discute pas des vecteurs et matrices numériques.
• dim : | Declaration de tableaux de series. | |
• Initialisation d'un tableau de series : | ||
• dimvar : | Declaration de tableaux de variables. | |
• Initialisation d'un tableau de variables : | ||
• tabvar : | Generation d’un tableau de variables. | |
• Affectation dans un tableau : | ||
• Taille d'un tableau : | ||
• Bornes d'un tableau : | ||
• afftab : | Affichage d’un tableau. | |
• Extraction d'element : | ||
• Operations sur les tableaux de series : | ||
• Conversion : |
Next: Initialisation d'un tableau de series, Up: Tableaux [Contents][Index]
dim
<nom> [ <liste_dimension> ], ...;
Elle déclare un ou plusieurs tableaux de séries en spécifiant le nombre de dimensions.
Chaque dimension est séparée par une virgule.
Une dimension est composée de deux ou trois entiers séparés par des :
qui indiquent l’indice du premier et du dernier élément, ainsi que le pas de cette dimension. Si le troisième entier est absent, alors le pas vaut 1.
Les dimensions d’un tableau peuvent être stockées dans un identificateur.
Ce type de tableaux peut contenir des séries, des constantes, des troncatures, des chaines de caractères, ... mais pas de variables.
> // Ici, on declare un tableau tl a deux dimensions > // de séries ou de constantes > dim tl [1:22,-2:6]; > // on declare 3 tableaux t1, t2 , t3 avec des dimensions differentes > bounds1 = 1:4; bounds1 = bornes [ 1:4 ] > dim t1[bounds1], t2[5:6], t3[-1:3]; > // on declare un tableau avec un pas different de 1 > dim t5[1:5:2]; > t5[:]=7; > afftab(t5); t5[1] = 7 t5[3] = 7 t5[5] = 7 >
<nom> = [<série> ,... : <série> , ...];
<nom> = dim[<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.
> // 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 ] liste des elements du tableau : tab [ 1 , 1 ] = constante de nom tab et de valeur 1 tab [ 1 , 2 ] = serie tab ( x ) nombre de variables : 1 taille du descripteur : 80 octets nombre de termes : 2 taille : 304 octets tab [ 2 , 1 ] = serie tab ( x ) nombre de variables : 1 taille du descripteur : 80 octets nombre de termes : 3 taille : 352 octets tab [ 2 , 2 ] = serie tab ( x ) nombre de variables : 1 taille du descripteur : 80 octets nombre de termes : 3 taille : 352 octets > // 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 >
Next: Initialisation d'un tableau de variables, Previous: Initialisation d'un tableau de series, Up: Tableaux [Contents][Index]
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 :=
.
> // on declare un tableau t2 de variables a une dimension > dimvar t2[1:5]; > // Maintenant, si on fait: > t2[1] := x; t2[1] = x = 1*x > // on aura la derivee de S par rapport a x. > S=1+3*x$ > deriv(S,t2[1]); 3 > > // on declare 2 tableaux de variables tv1 et tv2 > dimvar tv1[1:2], tv2[1:3]; >
<nom> = dimvar[<série> ,... : <série> , ...];
Cette commande crée et initialise un tableau de variables avec les variables 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.
> // on declare un tableau t2 de variables avec les variables x, y et z et u > 1+x+y+z$ > t2 = dimvar[x:y:z:u]; t2 [1:4 ] nb elements = 4 >
Next: Affectation dans un tableau, Previous: Initialisation d'un tableau de variables, Up: Tableaux [Contents][Index]
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
.
> 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 >
Next: Taille d'un tableau, Previous: tabvar, Up: Tableaux [Contents][Index]
<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 vecteur 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 vecteur 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.
Lorsque le nombre de dimensions n’est pas connu ou variable, il est possible de mettre l’ellipsis ... en dernier argument pour indiquer une séquence de longueur quelconque :,:,: .
Remarque : toutes les combinaisons d’omissions sont permises.
> _affc=1$ > 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; > t[2,...]=3; >
<tableau> [...] :=
<variable> ;
Elle affecte une variable à un élément du tableau de variables.
> dimvar X[1:4]; > X[1]:=crevar("e",1,1); X[1] = e_1_1 = 1*e_1_1 > deriv(1+2*e_1_1,X[1]); 2 >
Next: Bornes d'un tableau, Previous: Affectation dans un tableau, Up: Tableaux [Contents][Index]
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.
> dim t[1:4,7:25]; > size(t,2); 19 > size(t); 4 >
num_dim(
<tableau> t)
Elle retourne le nombre de dimensions du tableau t.
> dim t1[1:5]; > size(t1); 5 > dim t2[1:22,-2:6]; > size(t2); 22 >
Next: afftab, Previous: Taille d'un tableau, Up: Tableaux [Contents][Index]
inf
(<tableau> ,<entier> );
Elle retourne la borne inférieure du tableau pour 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.
> dim t[1:2,0:3]; > inf(t,2); 0 > for k=inf(t,2) to sup(t,2) { t[:,k]= k$ }; > afftab(t); t[1,0] = 0 t[1,1] = 1 t[1,2] = 2 t[1,3] = 3 t[2,0] = 0 t[2,1] = 1 t[2,2] = 2 t[2,3] = 3 >
sup
(<tableau> ,<entier> );
Elle retourne la borne supérieure du tableau pour 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.
> dim t[1:2,0:3]; > sup(t,2); 3 > for k=inf(t,1) to sup(t,1) { t[k,:]= k$ }; > afftab(t); t[1,0] = 1 t[1,1] = 1 t[1,2] = 1 t[1,3] = 1 t[2,0] = 2 t[2,1] = 2 t[2,2] = 2 t[2,3] = 2 >
Next: Extraction d'element, Previous: Bornes d'un tableau, Up: Tableaux [Contents][Index]
afftab
(<tableau> );
Elle affiche le contenu du tableau de séries ou de variables.
> _affc=1$ > 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] = ({(y, x), 2}) t[4] = >
Next: Operations sur les tableaux de series, Previous: afftab, Up: Tableaux [Contents][Index]
<tableau> [
<entier> ,...]
;
Elle retourne l’élément ayant ces indices.
<vec. num.> [
<entier> binf :
<entier> bsup :
<entier> pas,... ];
<vec. 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.
Lorsque le nombre de dimensions n’est pas connu ou variable, il est possible de mettre l’ellipsis ... en dernier argument pour indiquer une séquence de longueur quelconque :,:,: .
Remarque : toutes les combinaisons d’omissions sont permises.
> _affc=1$ > 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 > v3=t[4,...]; v3 [5:10 ] nb elements = 6
select (
<condition> ,
<tableau> );
Elle retourne un tableau contenant uniquement les éléments du tableau où la condition est vraie.
Si la condition est toujours fausse, elle retourne la constante 0. Pour tester si la constante 0 a été retournée, le test if (size(resultat)==0) then { ... } else { ... }
peut être utilisé
La condition et le tableau doivent avoir le même nombre d’éléments et une seule dimension.
> // extrait les elements de tm telque t1[j]=1 > _modenum=NUMRATMP; _modenum = NUMRATMP > dim t1[1:5], tm[1:5]$ > for j=1 to 5 { t1[j]=abs(3-j)$ tm[j]=(1+x)**j$ }; > q = select(t1==1, tm); q [1:2 ] nb elements = 2 > if (size(q)!=0) then { afftab(q); }; q[1] = 1 + 2*x + 1*x**2 q[2] = 1 + 4*x + 6*x**2 + 4*x**3 + 1*x**4 >
Next: ConversionTab, Previous: Extraction d'element, Up: Tableaux [Contents][Index]
La plupart des fonctions usuelles sont décrites dans (see Vecteurs numeriques). Les fonctions suivantes peuvent être appliquées aux tableaux de séries (comme sur les séries) pour éviter les boucles for :
• Produit matriciel: | ||
• det: | ||
• inverse d'une matrice: | ||
• eigenvalues: | ||
• eigenvectors: | ||
• Arithmetique: |
Next: det, Up: Operations sur les tableaux de series [Contents][Index]
<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.
> _affc=1$ _affdist=0$ > t=[x,y:x-y,x+y]$ > t2=[x+y,x-y:x,y]$ > r=t&*t2; r [1:2, 1:2 ] nb elements = 4 > afftab(r); r[1,1] = 2*y*x + x**2 r[1,2] = y**2 - y*x + x**2 r[2,1] = - y**2 + y*x + 2*x**2 r[2,2] = 2*y**2 - y*x + x**2 >
Next: inverse d'une matrice, Previous: Produit matriciel, Up: Operations sur les tableaux de series [Contents][Index]
det
( <tableau> M )
det
( <tableau> M,
<chaine> method )
Elle calcule le déterminant d’un tableau à 2 dimensions (matrice carrée).
Si method est spécifié, elle utilise cette méthode pour calculer le déterminant si le contenu de la matrice le permet. Si le contenu ne le permet pas, elle utilise l’algorithme par défaut.
Les valeurs possibles de method sont :
> t=[9,0,7 :1,2,3 :4,5,6]; t [1:3, 1:3 ] nb elements = 9 > det(t); -48 >
Next: eigenvalues, Previous: det, Up: Operations sur les tableaux de series [Contents][Index]
<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é dans tous les cas.
> _modenum=NUMRATMP$ > 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 >
Next: eigenvectors, Previous: inverse d'une matrice, Up: Operations sur les tableaux de series [Contents][Index]
eigenvalues
(<tableau> )
Elle calcule les valeurs propres d’un tableau à 2 dimensions (matrice carrée) en utilisant un algorithme QR ( librairie lapack).
> 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.76915041895731 l[2] = 4.084362034809442 l[3] = -0.8535124537667539
Next: Arithmetique, Previous: eigenvalues, Up: Operations sur les tableaux de series [Contents][Index]
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é.
> 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.8081690381494434 vectp[1,2] = -0.7505769919446202 vectp[1,3] = -0.4846638559537327 vectp[2,1] = -0.209021306608322 vectp[2,2] = 0.3985224414326275 vectp[2,3] = -0.5474094124384613 vectp[3,1] = -0.550611386696964 vectp[3,2] = 0.5270806796287867 vectp[3,3] = 0.6822344772186747 > afftab(valp); valp[1] = 13.76915041895731 valp[2] = 4.084362034809442 valp[3] = -0.8535124537667539 > // 1er vecteur > p=vectp[:,1]$ > afftab(p); p[1] = -0.8081690381494434 p[2] = -0.209021306608322 p[3] = -0.550611386696964
Previous: eigenvectors, Up: Operations sur les tableaux de series [Contents][Index]
Les tableaux doivent avoir le même nombre de dimensions et le même nombre d’éléments par dimension.
<tableau> + <tableau>
Elle retourne l’addition terme à terme de deux tableaux de séries.
<tableau> + <série>
<série> + <tableau>
Elle retourne la somme d’une série et de chaque élément du tableau de séries.
<tableau> * <tableau>
Elle retourne le produit terme à terme de deux tableaux de séries.
<tableau> * <série>
<série> * <tableau>
Elle retourne le produit terme à terme d’une série et d’un tableau de séries.
<tableau> - <tableau>
Elle retourne la soustraction terme à terme de deux tableaux de séries.
<tableau> - <série>
<série> - <tableau>
Elle retourne la différence entre une série et chaque élément du tableau de séries.
<tableau> / <tableau>
Elle retourne la division terme à terme de deux tableaux de séries.
<tableau> / <série>
<série> / <tableau>
Elle retourne la division entre une série et chaque élément du tableau de séries.
> _affc=1$ > 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 >
Previous: Operations sur les tableaux de series, Up: Tableaux [Contents][Index]
Pour la conversion en vecteurs numériques, (see Conversion).
Next: Vecteurs numeriques, Previous: Tableaux, Up: Top [Contents][Index]
• Declaration de structure : | ||
• Declaration des identificateurs : | ||
• Acces aux attributs : | ||
• Affichage : | ||
• Macro constructeur : | ||
• Macros membres : |
Les structures sont composées de champs nommés ayant une visibilité globale ou privée. Des macros globales ou privées peuvent êtres associées aux structures. Celles-ci accèdent à l’ensemble de ces champs.
Next: Declaration des identificateurs, Up: Structures [Contents][Index]
struct
<structtype> { <liste_parametres> ; private
<liste_parametres> ; };
struct
<structtype> { <identificateur> = <valeur> ; ... private
<identificateur> = <valeur> ; private ...
};
Elle déclare un nouveau type de structure dont les champs de la première liste peuvent être accédés de manière globale alors que ceux précédés par le mot-clé private
ne seront visibles que par les macros associées à cette structure.
Les champs peuvent être initialisés à une valeur par défaut.
> // declaration de la structure POINT > struct POINT { x, y; }; > > // declaration de la structure MyData > struct MyData { x = 0; y = 0; z = -1; vnumR v([1:3]); dim armap[1:5]; private name = "NONAME"; private file = "/tmp/myfile"; }; > MyData a; > afftab(a); a@x = 0 a@y = 0 a@z = -1 a@v = a Vecteur de reels double-precision : nb reels =3 a@armap = a [1:5 ] nb elements = 5 a@name = "NONAME" a@file = "/tmp/myfile"
Next: Acces aux attributs, Previous: Declaration de structure, Up: Structures [Contents][Index]
struct
<structtype> <identificateur> p1, <identificateur> p2, ... ;
Elle crée les identificateurs dont les noms sont donnés dans la liste. Ces identificateurs seront des structures du type spécifié. Aucun champ de ces structures n’est initialisé.
> // declaration de la structure POINT > struct POINT { x, y; }; > // declaration des variables de type POINT > struct POINT p1, p2, p3; > p1; p1 = structure POINT > afftab(p1); p1@x = /* NON INITIALISE */ p1@y = /* NON INITIALISE */
Next: Affichage, Previous: Declaration des identificateurs, Up: Structures [Contents][Index]
<structure> @
<nom>
Elle permet d’accéder au champ de la structure. Si le champ est privé, celui-ci ne peut être accéder que depuis une macro associée à la structure.
> struct MyData { x,y,z; name, file; }; > struct MyData s; > > s@x = 3; s@x = 3 > s@y = 1; s@y = 1 > s@z = s@x + 2*s@y; s@z = 5 > s@name = "temp001"; s@name = "temp001" > s@file=file_open(s@name,write); s@file = fichier "temp001" ouvert en ecriture >
Next: Macro constructeur, Previous: Acces aux attributs, Up: Structures [Contents][Index]
afftab(
<structure> x );
Elle affiche la valeur de tous les champs de la structure x.
> struct MyData { x,y,z; name, file; }; > struct MyData s; > > s@x = 3$ > s@y = 1$ > s@z = s@x + 2*s@y$ > s@name = "temp001"$ > s@file=file_open(s@name,write)$ > afftab(s); s@x = 3 s@y = 1 s@z = 5 s@name = "temp001" s@file = fichier "temp001" ouvert en ecriture >
Next: Macros membres, Previous: Affichage, Up: Structures [Contents][Index]
macro
<structtype> @ <structtype> { <corps> };
Elle déclare un constructeur de la structure sans paramètres et un corps de code trip. Cette macro est alors appelée implicitement dès qu’un objet de ce type est instancié.
La macro peut accéder à l’ensemble des champs privés ou non de la structure. L’accès aux champs se fait directement et n’a pas besoin d’être préfixé par @
.
La variable self est automatiquement définie lors de l’exécution pour accéder à la valeur de l’ensemble de la structure qui a généré l’appel.
> struct MyData { t; vnumR v([1:3])$ }; > macro MyData@MyData { private _ALL; t = log(2)$ v[:]=4$ }; > > MyData a; > afftab(a); a@t = 0.6931471805599453 a@v = a Vecteur de reels double-precision : nb reels =3 > >
Previous: Macro constructeur, Up: Structures [Contents][Index]
macro
<structtype> @ <nom> [ <liste_parametres> ] { <corps> };
macro
<structtype> @ <nom> { <corps> };
private macro
<structure> @ <nom> [ <liste_parametres> ] { <corps> };
private macro
<structure> @ <nom> { <corps> };
Elle déclare une macro membre de la structure avec 0 ou plusieurs paramètres et un corps de code trip.
La macro peut accéder à l’ensemble des champs privés ou non de la structure. L’accès aux champs se fait directement et n’a pas besoin d’être préfixé par @
.
La variable self est automatiquement définie lors de l’exécution pour accéder à la valeur de l’ensemble de la structure qui a généré l’appel. Elle est utile pour une affectation ou le passage de paramètres à d’autres macros.
Si la macro est définie comme privée, alors elle ne peut être appelée que par une autre macro associée à la même structure.
> struct MyData { x,y,z; private name, file; }; > > // Declare Init comme macro membre de MyData > macro MyData@Init[vx,vy,vz,vname] { x = vx$ y = vy$ z = vz$ name = vname$ %OpenFile$ afftab(self); }; > > // Declare OpenFile comme une macro privee de MyData > private macro MyData@OpenFile { file = file_open(name,write)$ }; > >
<structure> %
<nom> [ <liste_parametres> ];
<structure> %
<nom> ;
Elle exécute une macro membre de la structure en déclarant l’identificateur self comme valeur la structure pendant son exécution.
> struct MyData { x,y,z; private name, file; }; > > macro MyData@Init[vx,vy,vz,vname] { x = vx$ y = vy$ z = vz$ name = vname$ %OpenFile$ afftab(self); }; > > macro MyData@Clear { %CloseFile; }; > > private macro MyData@OpenFile { file = file_open(name,write)$ }; > > private macro MyData@CloseFile { file_close(file); }; > > struct MyData s; > // execute la macro Init > s%Init[1,2,3,"temp001"]; s@x = 1 s@y = 2 s@z = 3 s@name = "temp001" s@file = fichier "temp001" ouvert en ecriture > > // execute la macro Clear > s%Clear; >
Next: Matrices numeriques, Previous: Structures, Up: Top [Contents][Index]
• Declaration : | ||
• Initialisation : | ||
• writes: | Affichage. | |
• size : | ||
• resize : | ||
• Bornes : | ||
• Extraction : | ||
• Entree/Sortie : | ||
• Entree/Sortie bas niveau : | ||
• Fonctions mathematiques et usuelles : | ||
• Conditions : | ||
• Conversion : |
Les données numériques, stockées dans ces vecteurs, sont toujours des réels ou complexes double-précision, quadruple-précision ou multiprecision suivant le mode numérique courant. Ces vecteurs numériques sont considérés comme des vecteurs colonnes.
Dans le mode numérique NUMRATMP, les nombres rationnels peuvent être stockés dans des vecteurs numériques de type rationnel.
Next: Initialisation, Up: Vecteurs numeriques [Contents][Index]
• vnumR: | ||
• vnumC: | ||
• vnumQ: |
La déclaration explicite de vecteur numérique est nécessaire uniquement avant l’utilisation de la commande read
, readbin
(see Entree/SortieTabNum) et resize
.
Elle est aussi nécessaire pour les tableaux de vecteurs numériques.
Next: vnumC, Up: Declaration [Contents][Index]
vnumR
<nom> ,
... ;
vnumR
<nom> [
<dimension d’un tableau> ] ,
... ;
Elle déclare un vecteur de réels ou un tableau de vecteur numérique de réels.
La taille des vecteurs de réels est dynamique. Apres cette déclaration, les vecteurs de réels sont vides.
Pour spécifier leur taille, il faut utiliser la commande resize
.
La dimension permet de spécifier le nombre d’éléments du tableau de vecteurs de réels.
vnumR
<nom> ([
1: <entier> n ]) ,
... ;
vnumR
<nom> [
<dimension d’un tableau> ] ([
1: <entier> n ]) ,
... ;
Elle déclare un vecteur de n réels ou un tableau de vecteur numérique de n réels.
Après cette déclaration, les vecteurs de réels sont initialisés avec la valeur 0.
> vnumR A, C([1:5]); > stat(A); Vecteur numerique A de 0 reels double-precision. > stat(C); Vecteur numerique C de 5 reels double-precision. taille en octets du tableau: 40 > bounds=1:2; bounds = bornes [ 1:2 ] > vnumR TE[bounds], T0[bounds]([1:6]); > stat(TE); Tableau de series TE [ 1:2 ] liste des elements du tableau : TE [ 1 ] = Vecteur numerique TE de 0 reels double-precision. TE [ 2 ] = Vecteur numerique TE de 0 reels double-precision. > stat(T0); Tableau de series T0 [ 1:2 ] liste des elements du tableau : T0 [ 1 ] = Vecteur numerique T0 de 6 reels double-precision. taille en octets du tableau: 48 T0 [ 2 ] = Vecteur numerique T0 de 6 reels double-precision. taille en octets du tableau: 48 >
Next: vnumQ, Previous: vnumR, Up: Declaration [Contents][Index]
vnumC
<nom> ,
... ;
vnumC
<nom> [
<dimension d’un tableau> ] ,
... ;
Elle déclare un vecteur de complexes ou un tableau de vecteur numérique de complexes.
La taille des vecteurs de complexes est dynamique. Apres cette déclaration, les vecteurs de complexes sont vides.
Pour spécifier leur taille, il faut utiliser la commande resize
.
La dimension permet de spécifier le nombre d’éléments du tableau de vecteurs de complexes.
vnumC
<nom> ([
1: <entier> n ]) ,
... ;
vnumC
<nom> [
<dimension d’un tableau> ] ([
1: <entier> n ]) ,
... ;
Elle déclare un vecteur de n complexes ou un tableau de vecteur numérique de n complexes.
Après cette déclaration, les vecteurs de complexes sont initialisés avec la valeur 0+i*0.
> vnumC A, C([1:5]); > stat(A); Vecteur numerique A de 0 complexes double-precision. > stat(C); Vecteur numerique C de 5 complexes double-precision. taille en octets du tableau: 80 > vnumC TE[1:2], T0[1:2]([1:6]); > stat(TE); Tableau de series TE [ 1:2 ] liste des elements du tableau : TE [ 1 ] = Vecteur numerique TE de 0 complexes double-precision. TE [ 2 ] = Vecteur numerique TE de 0 complexes double-precision. > stat(T0); Tableau de series T0 [ 1:2 ] liste des elements du tableau : T0 [ 1 ] = Vecteur numerique T0 de 6 complexes double-precision. taille en octets du tableau: 96 T0 [ 2 ] = Vecteur numerique T0 de 6 complexes double-precision. taille en octets du tableau: 96 >
Previous: vnumC, Up: Declaration [Contents][Index]
vnumQ
<nom> ,
... ;
vnumQ
<nom> [
<dimension d’un tableau> ] ,
... ;
Elle déclare un vecteur de nombre rationnels ou un tableau de vecteur numérique de rationnels.
La taille des vecteurs de rationnels est dynamique. Apres cette déclaration, les vecteurs de rationnels sont vides.
Pour spécifier leur taille, il faut utiliser la commande resize
.
La dimension permet de spécifier le nombre d’éléments du tableau de vecteurs de rationnels.
vnumQ
<nom> ([
1: <entier> n ]) ,
... ;
vnumQ
<nom> [
<dimension d’un tableau> ] ([
1: <entier> n ]) ,
... ;
Elle déclare un vecteur de n rationnels ou un tableau de vecteur numérique de n rationnels.
Après cette déclaration, les vecteurs de rationnels sont initialisés avec la valeur 0.
> _modenum=NUMRATMP; _modenum = NUMRATMP > vnumQ A, C([1:5]); > stat(A); Vecteur numerique A de 0 rationnels. > stat(C); Vecteur numerique C de 5 rationnels. taille en octets du tableau: 160 > vnumQ TE[1:2], T0[1:2]([1:6]); > stat(TE); Tableau de series TE [ 1:2 ] liste des elements du tableau : TE [ 1 ] = Vecteur numerique TE de 0 rationnels. TE [ 2 ] = Vecteur numerique TE de 0 rationnels. > stat(T0); Tableau de series T0 [ 1:2 ] liste des elements du tableau : T0 [ 1 ] = Vecteur numerique T0 de 6 rationnels. taille en octets du tableau: 192 T0 [ 2 ] = Vecteur numerique T0 de 6 rationnels. taille en octets du tableau: 192 >
Next: writes, Previous: Declaration, Up: Vecteurs numeriques [Contents][Index]
<nom> =
<réel> binf ,
<réel> bsup ,
<réel> step ;
Elle déclare un vecteur 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.
> t=0,10; t Vecteur de reels double-precision : nb reels =11 > writes(t); +0.0000000000000000E+00 +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 > tab=-pi, 6, pi/100; tab Vecteur de reels double-precision : nb reels =291 > writes([::30],tab); -3.1415926535897931E+00 -2.1991148575128552E+00 -1.2566370614359170E+00 -3.1415926535897887E-01 +6.2831853071795907E-01 +1.5707963267948966E+00 +2.5132741228718354E+00 +3.4557519189487733E+00 +4.3982297150257113E+00 +5.3407075111026483E+00 >
<nom> = vnumR
[
<réel> ou <vec. réel> ou <tableau de vec. réel> ,
... :
<réel> ,
... ] ;
Elle déclare et initialise un vecteur de réels ou un tableau de vecteur numérique de réels
avec les réels ou les vecteurs 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.
> // declare un tableau de 3 vecteurs de 2 reels > tab3=vnumR[1,2,3:4,5,6]; tab3 [1:3 ] nb elements = 3 > writes(tab3); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +4.0000000000000000E+00 +5.0000000000000000E+00 +6.0000000000000000E+00 > t=7,8; t Vecteur de reels double-precision : nb reels =2 > tab4=vnumR[t,tab3]; tab4 [1:4 ] nb elements = 4 > // declare un vecteur de 5 reels > t2=vnumR[1:2:4:8:9]; t2 Vecteur de reels double-precision : nb reels =5 > writes(t2); +1.0000000000000000E+00 +2.0000000000000000E+00 +4.0000000000000000E+00 +8.0000000000000000E+00 +9.0000000000000000E+00 >
<nom> = vnumC
[
<complexe> ou <vec. complexe> ou <tableau de vec. complexe> ,
... :
<complexe> ,
... ] ;
Elle déclare et initialise un vecteur de complexes ou un tableau de vecteur numérique de complexes avec les complexes, des vecteurs 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.
> // declare un vecteur de 5 complexes > tab3=vnumC[1:1+i:2+2*i:3+3*i]; tab3 Vecteur de complexes double-precision : nb complexes =4 > writes(tab3); +1.0000000000000000E+00 +0.0000000000000000E+00 +1.0000000000000000E+00 +1.0000000000000000E+00 +2.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +3.0000000000000000E+00 > vnumC ti; > resize(ti,5,3-5*i); > tab4=vnumC[tab3 : 5+7*i : ti]; tab4 Vecteur de complexes double-precision : nb complexes =10 > // declare un tableau de 2 vecteurs 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 >
Next: size, Previous: Initialisation, Up: Vecteurs numeriques [Contents][Index]
writes([
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) vec. num.> ,
...);
writes(
<chaine> ,
<(tableau de) vec. num.> ,
...);
writes(
<(tableau de) vec. num.> ,
...);
équivaut à
writes( { [binf:{bsup}:{step}], } {format,} <(tableau de) vec. num.> ,...).
Elle écrit à l’ecran, les vecteurs numériques ou les tableaux de vecteurs numériques sous la forme de colonnes.
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 vecteur de complexes occupe deux colonnes (la 1ère pour la partie réelle, la 2ème pour la partie complexe).
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); vecteur numérique X de 6 complexes. taille en octets du tableau: 96 > stat(T); vecteur 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
Next: resize, Previous: writes, Up: Vecteurs numeriques [Contents][Index]
size(
<vec. num.> )
Elle retourne le nombre d’éléments du vecteur numérique.
> t=1,10; t Vecteur de reels double-precision : nb reels =10 > size(t); 10 > p=-pi,pi,pi/400; p Vecteur de reels double-precision : nb reels =800 > size(p); 800 >
Next: Bornes, Previous: size, Up: Vecteurs numeriques [Contents][Index]
resize(
<(tableau de) vec. num.> ,
<entier> );
resize(
<(tableau de) vec. num.> ,
<entier> ,
<constante> );
Elle change la taille d’un vecteur numérique ou d’un tableau de vecteurs 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.
> vnumR t; > resize(t,3); > vnumR t2; > resize(t2,3,5); > writes(t,t2); +0.0000000000000000E+00 +5.0000000000000000E+00 +0.0000000000000000E+00 +5.0000000000000000E+00 +0.0000000000000000E+00 +5.0000000000000000E+00 > vnumC t[1:3]; > resize(t[2],2,1-5*i); > writes(t[2]); +1.0000000000000000E+00 -5.0000000000000000E+00 +1.0000000000000000E+00 -5.0000000000000000E+00 >
Next: Extraction, Previous: resize, Up: Vecteurs numeriques [Contents][Index]
inf
(<vec. num.> ,<entier> );
Elle retourne la borne inférieure du vecteur numérique. L’entier fourni doit être égal à 1.
Si la dimension spécifiée n’est pas 1, alors la fonction retourne -1.
> t=3,10; t Vecteur de reels double-precision : nb reels =8 > inf(t,1); 1 >
sup
(<vec. num.> ,<entier> );
Elle retourne la borne supérieure du vecteur numérique. L’entier fourni doit être égal à 1.
Si la dimension spécifiée n’est pas 1, alors la fonction retourne -1.
> t=3,10; t Vecteur de reels double-precision : nb reels =8 > sup(t,1); 8 >
Next: Entree/SortieTabNum, Previous: Bornes, Up: Vecteurs numeriques [Contents][Index]
• select: | ||
• operateurs d'extraction : |
Next: operateurs d'extraction, Up: Extraction [Contents][Index]
select (
<condition> ,
<vec. num.> );
Elle retourne un vecteur numérique contenant uniquement les éléments du vecteur numérique quand la condition est vraie.
La condition et le vecteur numérique doivent avoir le même nombre d’éléments.
> // retourne les éléments qui sont multiples de 3 > t=1,10; t Vecteur de reels double-precision : nb reels =10 > r=select((t mod 3)==0, t); r Vecteur de reels double-precision : nb reels =3 > writes(r); +3.0000000000000000E+00 +6.0000000000000000E+00 +9.0000000000000000E+00 >
Previous: select, Up: Extraction [Contents][Index]
<vec. num.> [
<vec. réel> ];
Elle retourne un vecteur numérique contenant uniquement les éléments situés aux indices contenus dans le vecteur de réels.
Remarque : le vecteur de réels doit toujours être un identificateur et non le resultat d’une opération.
> r=vnumR[1:5:7:9]; r Vecteur de reels double-precision : nb reels =4 > t=20,30; t Vecteur de reels double-precision : nb reels =11 > b=t[r]; b Vecteur de reels double-precision : nb reels =4 > writes("%g\n",b); 20 24 26 28 >
<vec. num.> [
<entier> binf :
<entier> bsup :
<entier> pas ];
<vec. num.> [
<entier> binf :
<entier> bsup ];
Elle retourne un vecteur 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 vecteur.
Si le pas est omis, alors sa valeur est 1.
Remarque : toutes les combinaisons d’omissions sont permises.
> t=1,10; t Vecteur de reels double-precision : nb reels =10 > r=t[::2]; r Vecteur de reels double-precision : nb reels =5 > v=t[7:9]; v Vecteur de reels double-precision : nb reels =3 > y=t[5:10:2]; y Vecteur de reels double-precision : nb reels =3 > writes("%g %g\n",v,y); 7 5 8 7 9 9 >
Next: Entree/SortieTabNumbasniveau, Previous: Extraction, Up: Vecteurs numeriques [Contents][Index]
• read : | ||
• readappend : | ||
• write : | ||
• readbin : | ||
• writebin : |
Next: readappend, Up: Entree/SortieTabNum [Contents][Index]
read(
<nom fichier> ,[
<entier> :
<entier> :
<entier> ],
,
... ,
(
<(tableau de) vec. num.> ,
<entier> ),
...
(
<(tableau de) vec. 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 vecteurs numériques.
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.
Quand une ligne incomplète ou vide est rencontrée, le comportement de la fonction dépend de la valeur de _read
(see _read).
Lecture dans le fichier tessin.out de la ligne 2 à ligne 100 avec un pas de 3. Le vecteur 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 vecteur 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 vecteur 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 vecteur 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 vecteur 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]);
read(
<nom fichier> ,[
<entier> :
<entier> :
<entier> ],
textformat,
,
... ,
(
<(tableau de) vec. num.> ,
<entier> ),
...
(
<(tableau de) vec. num.> ,
<entier> ,
<entier> ),
...);
équivaut à
fmt="..."; read(fichier.dat, [binf:bsup:step], textformat, T, (T1,n1), (T3,n2,n3));
fmt="..."; read(fichier.dat, textformat, T, (T1,n1), (T3,n2,n3));
Elle est identique à la commande read ci-dessus mais permet de spécifier un format de lecture. Elle est capable de lire des colonnes de nombres ou de chaines de caractères. Le type de données de la colonne est spécifié par le format.
Les formats acceptés sont :
Pour le format %s, il ne faut pas déclarer l’identificateur au préalable ; l’identificateur retourné est un tableau de chaines de caractères.
Pour les formats %g, %e, %E, il faut déclarer l’identificateur au préalable comme un (tableau de) vecteur numérique (vnumR); l’identificateur retourné est un (tableau de) vecteur numérique réel.
Par défaut, la commande suppose que les colonnes sont séparées par des espaces ou tabulations. Si une longueur est fournie au format (e.g., %10g ou %10s pour une colonne de 10 caractères), cette longueur indique le nombre de caractères de la colonne. Dans ce cas, elle ne fait plus de distinction entre espaces, tabulations et autres caractères.
Quand une ligne incomplète ou vide est rencontrée, le comportement de la fonction dépend de la valeur de _read
(see _read).
Restriction: il n’est pas possible d’écrire la commande avec la commande suivante : read(file,"....", T1, T2, ...);
.
Il faut écrire : fmt=" ..."$ read(file,fmt, T1, T2, ...);
.
> // genere un fichier avec deux colonnes : numero d'asteroide et nom > f=file_open(data.dat, write)$ > file_writemsg(f, " 1 Ceres \n 2 Pallas\n 3 Juno \n"); > file_close(f); > > > // lit les 2 colonnes comme un vecteur numerique et un tableau de chaines > // en utilisant les separateurs de colonnes (espaces) > vnumR id; > fmt="%g %s"; fmt = "%g %s" > read(data.dat, fmt, id, name); > writes(id); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 > afftab(name); name[1] = "Ceres" name[2] = "Pallas" name[3] = "Juno" > > // lit les 2 colonnes comme un vecteur numerique et un tableau de chaines > // en utilisant une taille fixe pour chaque colonne > vnumR id2; > fmt="%5g %7s"; fmt = "%5g %7s" > read(data.dat, fmt, id2, name2); > writes(id2); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 > afftab(name2); name2[1] = " Ceres " name2[2] = " Pallas" name2[3] = " Juno "
L’exemple suivant permet de lire les fichiers astorb en utilisant les formats.
vnumR number, H, Slope,ColorIndex,v1,v2,v3,v4,v5,v6; vnumR arc,observations, epochyy,epochymm, epochdd; vnumR anomaly,perihelion, ascendingnode,Inclination, Eccentricity,Semimajoraxis,Date; fmt="%7s%19s%16s%6s%5g%5s%6s%6s"+6*"%4g"+2*"%g"+"%4g" +2*"%2g"+5*"%11g"+"%12g%9s"; read(astorb.dat,[:10000], fmt, number,name, computer, H,Slope, ColorIndex,diameter,Taxonomic,v1,v2,v3,v4,v5,v6,arc,observations, epochyy,epochymm, epochdd, anomaly,perihelion, ascendingnode, Inclination,Eccentricity,Semimajoraxis,Date);
Next: write, Previous: read, Up: Entree/SortieTabNum [Contents][Index]
readappend(
<nom fichier> ,[
<entier> :
<entier> :
<entier> ],
,
... ,
(
<(tableau de) vec. num.> ,
<entier> ),
...
(
<(tableau de) vec. 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
(see 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.
> 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
readappend(
<nom fichier> ,[
<entier> :
<entier> :
<entier> ],
textfmt,
,
... ,
(
<(tableau de) vec. num.> ,
<entier> ),
...
(
<(tableau de) vec. num.> ,
<entier> ,
<entier> ),
...);
Cette fonction est identique à la fonction read
(see read) avec un format textfmt.
Mais elle stocke les données lues à la fin des vecteurs numériques en agrandissant automatiquement ceux-ci au lieu d’écraser leur contenu.
Next: readbin, Previous: readappend, Up: Entree/SortieTabNum [Contents][Index]
write(
<nom fichier> , [
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) vec. num.> ,
...);
write(
<nom fichier> ,
<chaine> ,
<(tableau de) vec. num.> ,
...);
write(
<nom fichier> ,
<(tableau de) vec. 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 vecteurs numériques ou les tableaux de vecteurs numériques sous la forme de colonnes.
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 vecteur de complexes occupent deux colonnes (la 1ère pour la partie réelle, la 2ème pour la partie complexe).
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);
Next: writebin, Previous: write, Up: Entree/SortieTabNum [Contents][Index]
readbin(
<nom fichier> ,[
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) vec. réel> ,
...);
readbin(
<nom fichier> ,
<chaine> ,
<(tableau de) vec. 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 vecteurs numériques.
Les formats acceptés pour définir un enregistrement sont :
Il doit y avoir autant de formats que de vecteurs numériques. Si le tableau fourni est un tableau de vecteur 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
(see _endian) est différente de la valeur par défaut.
Lecture dans le fichier binaire test1.dat d'entiers signés sur 4 octets et stockés dans le vecteur 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 vecteur 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 vecteur 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]);
Previous: readbin, Up: Entree/SortieTabNum [Contents][Index]
writebin(
<nom fichier> ,[
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) vec. réel> ,
...);
writebin(
<nom fichier> ,
<chaine> ,
<(tableau de) vec. réel> ,
...);
équivaut à
writebin(fichier.dat, [binf:bsup:step], format, T, T2, T3);
writebin(fichier.dat, format, T, T2, T3);
Elle ecrit les vecteurs numériques dans un fichier binaire avec le format est spécifié.
Les formats acceptés pour définir un enregistrement sont :
Il doit y avoir autant de formats que de vecteurs numériques. Si le tableau fourni est un tableau de vecteur de réels, alors il doit y avoir autant de formats que d’éléments du tableau.
Si les vecteurs 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
(see _endian) est différente de la valeur par défaut.
Ecriture du vecteur 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 vecteur 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 vecteur 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 vecteurs 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]);
Next: Fonctions mathematiques et usuelles, Previous: Entree/SortieTabNum, Up: Vecteurs numeriques [Contents][Index]
• file_open : | ||
• file_close : | ||
• file_write : | ||
• file_read : | ||
• file_readappend : | ||
• file_writemsg : | ||
• file_writebin : |
Next: file_close, Up: Entree/SortieTabNumbasniveau [Contents][Index]
file_open(
<nom fichier> , read);
file_open(
<nom fichier> , write);
file_open(
<nom fichier> , write, append);
Elle ouvre un fichier en lecture seule ou en écriture seule selon le second paramètre. Elle retourne un identificateur de type fichier.
En mode écriture, le fichier existant est conservé et les écritures commencent à la fin de celui-ci si append
est spécifié, sinon le fichier existant est écrasé .
> f=file_open("sim2007.dat",read); f = fichier "sim2007.dat" ouvert en lecture > vnumR t; > file_read(f,t); > file_close(f);
Next: file_write, Previous: file_open, Up: Entree/SortieTabNumbasniveau [Contents][Index]
file_close(
<fichier> );
Elle ferme un fichier précédemment ouvert avec la fonction file_open
.
> 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
Next: file_read, Previous: file_close, Up: Entree/SortieTabNumbasniveau [Contents][Index]
file_write(
<fichier> , [
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) vec. num.> ,
...);
file_write(
<fichier> ,
<chaine> ,
<(tableau de) vec. num.> ,
...);
file_write(
<fichier> ,
<(tableau de) vec. 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
(see 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.
> 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);
Next: file_readappend, Previous: file_write, Up: Entree/SortieTabNumbasniveau [Contents][Index]
file_read(
<fichier> ,[
<entier> :
<entier> :
<entier> ],
,
... ,
(
<(tableau de) vec. num.> ,
<entier> ),
...
(
<(tableau de) vec. 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
(see 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.
> 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);
Next: file_writemsg, Previous: file_read, Up: Entree/SortieTabNumbasniveau [Contents][Index]
file_readappend(
<fichier> ,[
<entier> :
<entier> :
<entier> ],
,
... ,
(
<(tableau de) vec. num.> ,
<entier> ),
...
(
<(tableau de) vec. 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
(see 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.
> 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);
Next: file_writebin, Previous: file_readappend, Up: Entree/SortieTabNumbasniveau [Contents][Index]
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 (see str, 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.
> 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 >
Previous: file_writemsg, Up: Entree/SortieTabNumbasniveau [Contents][Index]
file_writebin(
<fichier> , [
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) vec. num.> ,
...);
file_writebin(
<fichier> ,
<chaine> ,
<(tableau de) vec. num.> ,
...);
équivaut à
file_writebin( fichier, [binf:bsup:step], "format", T, T1, T2).
file_writebin( fichier, "format", T, T1, T2).
Cette fonction est similaire à la fonction writebin
(see writebin) 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.
> f=file_open(sim2007.dat, write); f = fichier "sim2007.dat" ouvert en ecriture > t1=1,10; t1 Vecteur de reels double-precision : nb reels =10 > t2=-t1; t2 Vecteur de reels double-precision : nb reels =10 > file_writebin(f,"%g",t1); > file_writebin(f,"%g",t2); > file_close(f);
Next: Conditions, Previous: Entree/SortieTabNumbasniveau, Up: Vecteurs numeriques [Contents][Index]
• minimum et maximum : | ||
• somme et produit : | ||
• tris : | ||
• transposevnum : | ||
• fonctions math : |
Next: somme et produit, Up: Fonctions mathematiques et usuelles [Contents][Index]
• imin: | ||
• imax: | ||
• min : | ||
• max : | ||
• IMIN : | ||
• IMAX : | ||
• MIN : | ||
• MAX : |
Next: imaxelt, Up: minimum et maximum [Contents][Index]
imin(
<vec. réel> )
Elle retourne l’indice du minimum d’un vecteur de réels. Si plusieurs éléments ont la valeur minimale, alors cette fonction retourne l’indice du permier élément. Si le vecteur est vide, alors la fonction retourne 0.
> t=-5,5; > imin(t); 1
Next: minelt, Previous: iminelt, Up: minimum et maximum [Contents][Index]
imax(
<vec. réel> )
Elle retourne l’indice du maximum d’un vecteur de réels. Si plusieurs éléments ont la valeur maximale, alors cette fonction retourne l’indice du permier élément. Si le vecteur est vide, alors la fonction retourne 0.
> t=-5,5; > imax(t); 10
Next: maxelt, Previous: imaxelt, Up: minimum et maximum [Contents][Index]
min(
<réel ou vec. réel> ,
...);
Elle retourne le minimum des valeurs fournies qui peuvent être des vecteurs de réels ou des constantes réelles.
>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
Next: IMINterme, Previous: minelt, Up: minimum et maximum [Contents][Index]
max(
<réel ou vec. réel> ,
...);
Elle retourne le maximum des valeurs fournies qui peuvent être des vecteurs de réels ou des constantes réelles.
>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
Next: IMAXterme, Previous: maxelt, Up: minimum et maximum [Contents][Index]
IMIN(
<tableau de vec. réel> )
Elle retourne un vecteur de réels tel que ses éléments soient l’indice de la colonne du minimum terme à terme de chaque vecteur de réels du tableau.
Les vecteurs de réels doivent avoir la même taille.
> A=vnumR[1,2,3:6,7,1:9,2,5:13,11,16]$ > writes("%g %g %g\n", A); 1 2 3 6 7 1 9 2 5 13 11 16 > B=IMIN(A); B Vecteur de reels double-precision : nb reels =4 > writes("%g\n", B); 1 3 2 2 >
Next: MINterme, Previous: IMINterme, Up: minimum et maximum [Contents][Index]
IMAX(
<tableau de vec. réel> )
Elle retourne un vecteur de réels tel que ses éléments soient l’indice de la colonne du maximum terme à terme de chaque vecteur de réels du tableau.
Les vecteurs de réels doivent avoir la même taille.
> A=vnumR[1,2,3:6,7,1:9,2,5:13,11,16]$ > writes("%g %g %g\n", A); 1 2 3 6 7 1 9 2 5 13 11 16 > B=IMAX(A); B Vecteur de reels double-precision : nb reels =4 > writes("%g\n", B); 3 2 1 3 >
Next: MAXterme, Previous: IMAXterme, Up: minimum et maximum [Contents][Index]
MIN(
<vec. réel> ,
...)
Elle retourne un vecteur de réels tel que ses éléments soient le minimum terme à terme de chaque vecteur de réels.
Les vecteurs de réels doivent avoir la même taille.
Pour un tableau de vecteurs numériques, l’opération s’effectue sur chaque élément du tableau.
> 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
Previous: MINterme, Up: minimum et maximum [Contents][Index]
MAX(
<vec. réel> ,
...)
Elle retourne un vecteur de réels tel que ses éléments soient le maximum terme à terme de chaque vecteur de réels.
Les vecteurs de réels doivent avoir la même taille.
Pour un tableau de vecteurs numériques, l’opération s’effectue sur chaque élément du tableau.
> 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
Next: tris, Previous: minimum et maximum, Up: Fonctions mathematiques et usuelles [Contents][Index]
• sum : | ||
• prod : | ||
• accum : |
Next: prod, Up: somme et produit [Contents][Index]
sum(
<vec. num.> )
sum(
<vec. num.> , "kahan" )
sum(
<vec. num.> , "sort", "kahan" )
Elle retourne la somme des éléments d’un vecteur numérique.
L’option "sort" effectue un tri du vecteur par valeur absolue croissante avant d’effectuer la sommation.
Si l’option "kahan" est mise, la sommation est effectuée en utilisant la méthode de Kahan (sommation compensée).
Référence : Kahan, William (January 1965), "Further remarks on reducing truncation errors", Communications of the ACM 8 (1): 40, http://dx.doi.org/10.1145%2F363707.363723
> r=0,100$ > sum(r); 5050 > p=-10000,10000$ > p=p*pi/10000$ > sum(p); 3.885780586188048E-13 > // tri puis sommation compensee > sum(p,"sort","kahan"); 0
Next: accum, Previous: sum, Up: somme et produit [Contents][Index]
prod(
<vec. num.> )
Elle retourne le produit des éléments d’un vecteur numérique.
> p=1,10; p Tableau de reels : nb reels =10 > prod(p); 3628800 > c=p+2*i*p; c vecteur de complexes : nb complexes =10 > prod(c); (860025600-i*11307340800)
Previous: prod, Up: somme et produit [Contents][Index]
accum(
<vec. num.> )
Elle retourne la somme partielle des éléments d’un vecteur numérique :
Y=accum(X) alors Y[N] = sum(X[1:N])
> 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
Next: transposevnum, Previous: somme et produit, Up: Fonctions mathematiques et usuelles [Contents][Index]
• intersectvnum: | ||
• unionvnum: | ||
• reversevnum: | ||
• sort: |
intersectvnum(
<vec. num.> A ,
<vec. num.> B)
Elle retourne les valeurs communes aux deux vecteurs numériques A et B. Les valeurs du vecteur retourné sont triées par ordre croissant.
> A = vnumR[7:1:7:5:4:6]$ > B = vnumR[0:7:4:-2:5:3]$ > C = intersectvnum(A,B); C Vecteur de reels double-precision : nb reels =3 > writes(C); +4.0000000000000000E+00 +5.0000000000000000E+00 +7.0000000000000000E+00 >
Next: reversevnum, Previous: intersectvnum, Up: tris [Contents][Index]
unionvnum(
<vec. num.> A ,
<vec. num.> B)
Elle retourne un vecteur numérique contenant les valeurs de A and B sans répétition. Les valeurs du vecteur retourné sont triées par ordre croissant.
> A = vnumR[7:1:7:5:4:6]$ > B = vnumR[0:7:4:-2:5:3]$ > C = unionvnum(A,B); C Vecteur de reels double-precision : nb reels =8 > writes(C); -2.0000000000000000E+00 +0.0000000000000000E+00 +1.0000000000000000E+00 +3.0000000000000000E+00 +4.0000000000000000E+00 +5.0000000000000000E+00 +6.0000000000000000E+00 +7.0000000000000000E+00 >
reversevnum (
<vec. num.> )
Elle inverse l’ordre des éléments d’un vecteur numérique.
> 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
Previous: reversevnum, Up: tris [Contents][Index]
sort (
<vec. réel> )
Elle effectue le tri ascendant des éléments du vecteur de réels.
sort (
<vec. réel> ,
<(tableau de) vec. num.> ,
...);
Elle effectue le tri des éléments des (tableaux de) vecteurs numériques en fonction du tri ascendant du premier vecteur de réels.
Remarque : Si on effectue l’appel ‘sort(TX,TY,TZ);’, les vecteurs TY et TZ sont triés mais pas le vecteur TX.
> 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 vecteur de complexes : nb complexes =6 > vnumR TAB[1:2]; > TAB[1]=abs(T); > TAB[2]=-real(T); > sort(-p,T,TAB);
Next: fonctions math, Previous: tris, Up: Fonctions mathematiques et usuelles [Contents][Index]
transposevnum (
<tableau de vec. num.> )
Elle retourne la transposée d’un tableau de vecteurs numériques.
Le tableau doit avoir une seule dimension et les vecteurs numériques de celui-ci ont une taille identique.
> 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
Previous: transposevnum, Up: Fonctions mathematiques et usuelles [Contents][Index]
• abs : | ||
• acos : | ||
• acosh : | ||
• arg : | ||
• asin : | ||
• asinh : | ||
• atan : | ||
• atanh : | ||
• atan2 : | ||
• conj : | ||
• cos : | ||
• cosh : | ||
• erf : | ||
• erfc : | ||
• exp : | ||
• fac : | ||
• histogram : | ||
• imag : | ||
• int : | ||
• log : | ||
• log10 : | ||
• mod : | ||
• nint : | ||
• real : | ||
• sign : | ||
• sin : | ||
• sinh : | ||
• sqrt : | ||
• tan : | ||
• tanh : |
Next: arg, Up: fonctions math [Contents][Index]
abs(
<constante ou vec. num.> )
Elle retourne la valeur absolue d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur de réels contenant la valeur absolue de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: realtabnum, Previous: abs, Up: fonctions math [Contents][Index]
arg(
<constante ou vec. num.> )
Elle retourne l’argument d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur de réels contenant l’argument de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: imagtabnum, Previous: arg, Up: fonctions math [Contents][Index]
real(
<constante ou vec. num.> )
Elle retourne la partie réelle d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur de réels contenant la partie réelle de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: conj, Previous: realtabnum, Up: fonctions math [Contents][Index]
imag(
<constante ou vec. num.> )
Elle retourne la partie imaginaire d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur de réels contenant la partie imaginaire de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: erf, Previous: imagtabnum, Up: fonctions math [Contents][Index]
conj(
<constante ou vec. num.> )
Elle retourne le conjugué d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le conjugué de chaque élément si la valeur fournie est un vecteur numérique.
> conj(1+i); (1-i*1) > conj(3); 3 > z=vnumC[1+i:3-5*i:i]; z vecteur 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
Next: erfc, Previous: conj, Up: fonctions math [Contents][Index]
erf(
<réel ou vec. réel> )
Elle retourne la fonction d’erreur d’une constante si la valeur fournie est un réel.
Elle retourne un vecteur numérique contenant la fonction d’erreur de chaque élément si la valeur fournie est un vecteur 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
> 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
Next: exptabnum, Previous: erf, Up: fonctions math [Contents][Index]
erfc(
<réel ou vec. 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 vecteur numérique contenant le complémentaire de la fonction d’erreur de chaque élément si la valeur fournie est un vecteur 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)
> 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
Next: factabnum, Previous: erfc, Up: fonctions math [Contents][Index]
exp(
<constante ou vec. num.> )
Elle retourne l’exponentiel d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant l’exponentiel de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: sqrttabnum, Previous: exptabnum, Up: fonctions math [Contents][Index]
fac(
<constante ou vec. num.> )
Elle retourne la factorielle d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant la factorielle de chaque élément si la valeur fournie est un vecteur numérique.
> fac(10); 3628800 > t=1,5; t Vecteur de reels double-precision : nb reels =5 > r=fac(t); r Vecteur de reels double-precision : nb reels =5 > writes(t,r); +1.0000000000000000E+00 +1.0000000000000000E+00 +2.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +6.0000000000000000E+00 +4.0000000000000000E+00 +2.4000000000000000E+01 +5.0000000000000000E+00 +1.2000000000000000E+02 >
Next: costabnum, Previous: factabnum, Up: fonctions math [Contents][Index]
sqrt(
<constante ou vec. num.> )
Elle retourne la racine carrée d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant la racine carrée de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: sintabnum, Previous: sqrttabnum, Up: fonctions math [Contents][Index]
cos(
<constante ou vec. num.> )
Elle retourne le cosinus d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le cosinus de chaque élément si la valeur fournie est un vecteur numérique.
> 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)
Next: tan, Previous: costabnum, Up: fonctions math [Contents][Index]
sin(
<constante ou vec. num.> )
Elle retourne le sinus d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le sinus de chaque élément si la valeur fournie est un vecteur numérique.
> 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)
Next: acos, Previous: sintabnum, Up: fonctions math [Contents][Index]
tan(
<constante ou vec. num.> )
Elle retourne la tangente d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant la tangente de chaque élément si la valeur fournie est un vecteur numérique.
> x = 1.2; > tan(x); 2.57215162212632 > t=-pi,pi,pi/100; > at=tan(t); > tan(-1+i); (-0.271752585319512+i*95227/87854)
Next: asin, Previous: tan, Up: fonctions math [Contents][Index]
acos(
<réel ou vec. réel> )
Elle retourne l’arc cosinus d’un réel si la valeur fournie est un réel.
Elle retourne un vecteur de réels contenant l’arc cosinus de chaque élément si la valeur fournie est un vecteur de réels.
> acos(0.12); 1.4505064440011 > x = 0.12; > acos(x); 1.4505064440011 > t=-pi,pi,pi/100; > at=acos(t);
Next: atan, Previous: acos, Up: fonctions math [Contents][Index]
asin(
<réel ou vec. réel> )
Elle retourne l’arc sinus d’un réel si la valeur fournie est un réel.
Elle retourne un vecteur de réels contenant l’arc sinus de chaque élément si la valeur fournie est un vecteur de réels.
> asin(0.12); 0.120289882394788 > x = 0.12; > asin(x); 0.120289882394788 > t=-pi,pi,pi/100; > at=asin(t);
Next: cosh, Previous: asin, Up: fonctions math [Contents][Index]
atan(
<réel ou vec. réel> )
Elle retourne l’arc tangente d’un réel si la valeur fournie est un réel.
Elle retourne un vecteur de réels contenant l’arc tangente de chaque élément si la valeur fournie est un vecteur de réels.
> atan(2); 1.10714871779409 > x = 2; > atan(x); 1.10714871779409 > t=-pi,pi,pi/100; > at=atan(t);
Next: sinh, Previous: atan, Up: fonctions math [Contents][Index]
cosh(
<constante ou vec. num.> )
Elle retourne le cosinus hyperbolique d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le cosinus hyperbolique de chaque élément si la valeur fournie est un vecteur numérique.
> 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)
Next: tanh, Previous: cosh, Up: fonctions math [Contents][Index]
sinh(
<constante ou vec. num.> )
Elle retourne le sinus hyperbolique d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le sinus hyperbolique de chaque élément si la valeur fournie est un vecteur numérique.
> 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)
Next: acosh, Previous: sinh, Up: fonctions math [Contents][Index]
tanh(
<constante ou vec. num.> )
Elle retourne la tangente hyperbolique d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant la tangente hyperbolique de chaque élément si la valeur fournie est un vecteur numérique.
> 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);
Next: asinh, Previous: tanh, Up: fonctions math [Contents][Index]
acosh(
<constante ou vec. num.> )
Elle retourne l’arc cosinus hyperbolique d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant l’arc cosinus hyperbolique de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: atanh, Previous: acosh, Up: fonctions math [Contents][Index]
asinh(
<constante ou vec. num.> )
Elle retourne l’arc sinus hyperbolique d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant l’arc sinus hyperbolique de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: atan2, Previous: asinh, Up: fonctions math [Contents][Index]
asinh(
<constante ou vec. num.> )
Elle retourne l’arc tangente hyperbolique d’une constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant l’arc tangente hyperbolique de chaque élément si la valeur fournie est un vecteur numérique.
> 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
Next: mod, Previous: atanh, Up: fonctions math [Contents][Index]
atan2(
<réel ou vec. réel> ,
<réel ou vec. 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>).
> y = 11.5; > x = 14; > atan2(y,x); 0.68767125603875
Next: int, Previous: atan2, Up: fonctions math [Contents][Index]
mod(
<réel ou vec. réel> ,
<réel ou vec. réel> )
<réel ou vec. réel> mod
<réel ou vec. 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.
> 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);
Next: logtabnum, Previous: mod, Up: fonctions math [Contents][Index]
int(
<réel ou vec. réel> )
Elle retourne la partie entiere du réel si la valeur fournie est un réel.
Elle retourne un vecteur de réels contenant la partie entiere de chaque élément si la valeur fournie est un vecteur de réels.
>x=1.23; >int(x); 1 > t=-pi,pi,pi/100; > at=int(t);
Next: log10, Previous: int, Up: fonctions math [Contents][Index]
log(
<constante ou vec. num.> )
Elle retourne le logarithme népérien de la constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le logarithme népérien de chaque élément si la valeur fournie est un vecteur numérique.
> log(3); 1.09861228866811 > x = 3; > log(x); 1.09861228866811 > r=1,10; > at=log(r); > log(2+i); (0.80471895621705+i*0.463647609000806)
Next: nint, Previous: logtabnum, Up: fonctions math [Contents][Index]
log10(
<constante ou vec. num.> )
Elle retourne le logarithme décimal (ou à base 10) de la constante si la valeur fournie est une constante.
Elle retourne un vecteur numérique contenant le logarithme décimal de chaque élément si la valeur fournie est un vecteur numérique.
> log(3); 1.09861228866811 > x = 3; > log(x); 1.09861228866811 > r=1,10; > at=log(r); > log(2+i); (0.80471895621705+i*0.463647609000806)
Next: sign, Previous: log10, Up: fonctions math [Contents][Index]
nint(
<réel ou vec. réel> )
Elle retourne l’entier le plus proche du réel si la valeur fournie est un réel.
Elle retourne un vecteur de réels contenant l’entier le plus proche de chaque élément si la valeur fournie est un vecteur de réels.
> 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);
Next: histogram, Previous: nint, Up: fonctions math [Contents][Index]
sign(
<réel ou vec. réel> )
Elle retourne le signe du réel si la valeur fournie est un réel
Elle retourne un vecteur de réels contenant le signe de chaque élément si la valeur fournie est un vecteur de réels.
Elle est définie suivant la règle :
> 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
Previous: sign, Up: fonctions math [Contents][Index]
histogram(
<vec. réel> TY,
<vec. 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]
> 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
Next: Conversion, Previous: Fonctions mathematiques et usuelles, Up: Vecteurs numeriques [Contents][Index]
?(
<condition>)
Elle retourne un vecteur 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 vec. num.> tabvrai :
<constante ou vec. num.> tabfaux
Elle retourne un vecteur 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.
> t=0,5; t Vecteur de reels double-precision : nb reels =6 > r=5-t; r Vecteur de reels double-precision : nb reels =6 > q=?(t<=r); q Vecteur de reels double-precision : nb reels =6 > writes(q); +1.0000000000000000E+00 +1.0000000000000000E+00 +1.0000000000000000E+00 +0.0000000000000000E+00 +0.0000000000000000E+00 +0.0000000000000000E+00 > l= ?(t<=r):i:5; l Vecteur de complexes double-precision : nb complexes =6 > writes(l); +0.0000000000000000E+00 +1.0000000000000000E+00 +0.0000000000000000E+00 +1.0000000000000000E+00 +0.0000000000000000E+00 +1.0000000000000000E+00 +5.0000000000000000E+00 +0.0000000000000000E+00 +5.0000000000000000E+00 +0.0000000000000000E+00 +5.0000000000000000E+00 +0.0000000000000000E+00 > m = ?(t>2):r:t; m Vecteur de reels double-precision : nb reels =6 > writes(m); +0.0000000000000000E+00 +1.0000000000000000E+00 +2.0000000000000000E+00 +2.0000000000000000E+00 +1.0000000000000000E+00 +0.0000000000000000E+00 >
Previous: Conditions, Up: Vecteurs numeriques [Contents][Index]
• dimtovnumR : | ||
• dimtovnumC : | ||
• vnumtodim : | ||
• strtabnum : | str. |
Pour les conversions de vecteurs numériques depuis ou vers les matrices numériques, see ConversionMat.
Next: dimtovnumC, Up: Conversion [Contents][Index]
dimtovnumR
( <tableau> )
Elle retourne un vecteur 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.
> 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
Next: vnumtodim, Previous: dimtovnumR, Up: Conversion [Contents][Index]
dimtovnumC
( <tableau> )
Elle retourne un vecteur 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.
> 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 vecteur de complexes : nb complexes =3
Next: strtabnum, Previous: dimtovnumC, Up: Conversion [Contents][Index]
vnumtodim
( <(tableau de) vec. num.> )
Elle retourne un tableau de séries (de constantes) à partir d’un (tableau de) vecteur numérique.
> 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)
Previous: vnumtodim, Up: Conversion [Contents][Index]
str
( <vec. réel> );
str
( <chaine> format, <vec. réel> );
Elle convertit un vecteur numérique de réels en tableau de chaine de caractères. Si format est spécifié, alors chaque élément du vecteur est convertit suivant celui-ci.
Pour la description des formats, see str.
> t = 8,10; t Vecteur de reels double-precision : nb reels =3 > tabs = str("%04g", t); tabs [1:3 ] nb elements = 3 > afftab(tabs); tabs[1] = "0008" tabs[2] = "0009" tabs[3] = "0010"
Next: Graphiques, Previous: Vecteurs numeriques, Up: Top [Contents][Index]
• Declaration : | ||
• Initialisation : | ||
• writes: | ||
• size : | ||
• Extraction : | ||
• Entree/Sortie : | ||
• Entree/Sortie bas niveau : | ||
• Fonctions mathematiques et usuelles : | ||
• Conditions : | ||
• Conversion : |
Les données numériques, stockées dans ces matrices, sont toujours des réels ou complexes double-précision, quadruple-précision ou multiprecision suivant le mode numérique courant.
Ces matrices numériques sont considérées comme des matrices en deux dimensions.
Elles ne sont pas redimensionnables.
La première dimension correspond aux lignes de la matrice et la seconde dimension correspond aux colonnes de la matrice.
Next: InitialisationMat, Up: Matrices numeriques [Contents][Index]
• matrixR: | ||
• matrixC: |
La déclaration explicite de matrice numérique est nécessaire uniquement avant l’utilisation de la commande read
, readbin
(see Entree/SortieTabNum) et une affectation d’un ou de plusieurs éléments.
Elle est aussi nécessaire pour les tableaux de matrices numériques.
Next: matrixC, Up: DeclarationMat [Contents][Index]
matrixR
<nom> ([
<2 dimensions d’une matrice> MxN ]) ,
... ;
matrixR
<nom> [
<dimension d’un tableau> ] ([
<2 dimensions d’une matrice> MxN ]) ,
... ;
Elle déclare une matrice numérique réelle de dimension MxN ou un tableau de matrices numériques réelles où chaque matrice a une dimension MxN.
Apres cette déclaration, les matrices réelles sont initialisées avec la valeur 0.
> matrixR C([1:3, 1:5]); > stat(C); Matrice reelle double-precision C [ 1:3 , 1:5 ]. taille en octets du tableau: 120 > bounds= 1:3,1:6; bounds = bornes [ 1:3, 1:6 ] > matrixR T0[1:2]([bounds]); > stat(T0); Tableau de series T0 [ 1:2 ] liste des elements du tableau : T0 [ 1 ] = Matrice reelle double-precision T0 [ 1:3 , 1:6 ]. taille en octets du tableau: 144 T0 [ 2 ] = Matrice reelle double-precision T0 [ 1:3 , 1:6 ]. taille en octets du tableau: 144 >
Previous: matrixR, Up: DeclarationMat [Contents][Index]
matrixC
<nom> ([
<2 dimensions d’une matrice> MxN ]) ,
... ;
matrixC
<nom> [
<dimension d’un tableau> ] ([
<2 dimensions d’une matrice> MxN ]) ,
... ;
Elle déclare une matrice complexe de dimension MxN ou un tableau de matrices numériques complexes où chaque matrice a une dimension MxN.
Apres cette déclaration, les matrices complexes sont initialisées avec la valeur 0+i*0.
> matrixC C([1:3, 1:5]); > stat(C); Matrice complexe double-precision C [ 1:3 , 1:5 ]. taille en octets du tableau: 240 > bounds=1:3,1:6; bounds = bornes [ 1:3, 1:6 ] > matrixC T0[1:2]([bounds]); > stat(T0); Tableau de series T0 [ 1:2 ] liste des elements du tableau : T0 [ 1 ] = Matrice complexe double-precision T0 [ 1:3 , 1:6 ]. taille en octets du tableau: 288 T0 [ 2 ] = Matrice complexe double-precision T0 [ 1:3 , 1:6 ]. taille en octets du tableau: 288 >
Next: AffichageMat, Previous: DeclarationMat, Up: Matrices numeriques [Contents][Index]
<nom> = matrixR
[
<réel> ou <vec. réel> ,
... :
<réel> ,
... ] ;
Elle déclare et initialise une matrice réelle avec les réels ou les vecteurs 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.
> // declare une matrice reelle 2x3 > tab3=matrixR[1,2,3:4,5,6]; tab3 matrice reelle double-precision [ 1:2 , 1:3 ] > writes(tab3); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +4.0000000000000000E+00 +5.0000000000000000E+00 +6.0000000000000000E+00 >
<nom> = matrixC
[
<complexe> ou <vec. complexe> ,
... :
<complexe> ,
... ] ;
Elle déclare et initialise une matrice complexe avec les complexes ou les vecteurs de complexes 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.
> // declare une matrice complexes 2x3 > tab3=matrixC[1+2*i,3+4*i,5:2,4*i, -7+2*i]; tab3 matrice complexe double-precision [ 1:2 , 1:3 ] > writes(tab3); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +4.0000000000000000E+00 +5.0000000000000000E+00 +0.0000000000000000E+00 +2.0000000000000000E+00 +0.0000000000000000E+00 +0.0000000000000000E+00 +4.0000000000000000E+00 -7.0000000000000000E+00 +2.0000000000000000E+00 >
Next: sizeMat, Previous: InitialisationMat, Up: Matrices numeriques [Contents][Index]
writes([
<entier> :
<entier> :
<entier> ],
<chaine> ,
<(tableau de) matrice> ,
...);
writes(
<chaine> ,
<(tableau de) matrice> ,
...);
writes(
<(tableau de) matrice> ,
...);
équivaut à
writes( { [binf:{bsup}:{step}], } {format,} <(tableau de) matrice> ,...).
Elle écrit à l’ecran, les matrices numériques ou les tableaux de matrices numériques sous la forme de colonnes.
Le format est optionnel. Ce format est un format au standard C (cf. printf) et est encadré par des guillemets ("). Il faut autant de spécificateurs (e.g., %g) de formats que de colonnes.
Une matrice complexe occupent deux fois plus de colonnes (la 1ère pour la partie réelle, la 2ème pour la partie complexe).
> // affiche une matrice reelle 2x3 > mat3=matrixR[1,2,3:4,5,6]; mat3 matrice reelle double-precision [ 1:2 , 1:3 ] > writes(mat3); +1.0000000000000000E+00 +2.0000000000000000E+00 +3.0000000000000000E+00 +4.0000000000000000E+00 +5.0000000000000000E+00 +6.0000000000000000E+00 > // affiche une matrice complexe 2x3 > mat4=matrixC[1+2*i,3+4*i,5:2,4*i, -7+2*i]; mat4 matrice complexe double-precision [ 1:2 , 1:3 ] > writes(6*"%g "+"\n", mat4); 1 2 3 4 5 0 2 0 0 4 -7 2 >
afftab(
<matrice> );
Elle écrit à l’ecran, une matrice numérique. Chaque ligne de la matrice est encadrée par les caractères [].
> _affc=1$ > // affiche une matrice reelle 2x3 > mat3=matrixR[1,2,3:4,5,6]; mat3 matrice reelle double-precision [ 1:2 , 1:3 ] > afftab(mat3); [ 1 2 3] [ 4 5 6] > // affiche une matrice complexe 2x3 > mat4=matrixC[1+2*i,3+4*i,5:2,4*i, -7+2*i]; mat4 matrice complexe double-precision [ 1:2 , 1:3 ] > afftab(mat4); [(1+i*2) (3+i*4) 5] [ 2 (0+i*4) (-7+i*2)] >
Next: ExtractionMat, Previous: AffichageMat, Up: Matrices numeriques [Contents][Index]
size(
<matrice> ,
<entier> n )
Elle retourne le nombre de lignes de la matrice numérique si n=1.
Elle retourne le nombre de colonnes de la matrice numérique si n=2.
> mat3=matrixR[1,2,3:4,5,6]; mat3 matrice reelle double-precision [ 1:2 , 1:3 ] > size(mat3,1); 2 > size(mat3,2); 3 >
Next: Entree/SortieMat, Previous: sizeMat, Up: Matrices numeriques [Contents][Index]
<matrice> [
<entier> binfli :
<entier> bsupli :
<entier> pasli
,
<entier> binfcol :
<entier> bsupcol :
<entier> pascol ];
Elle retourne une matrice 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.
> M=matrixR[1,2,3:4,5,6:7,8,9]; M matrice reelle double-precision [ 1:3 , 1:3 ] > r=M[::2,::2]; r matrice reelle double-precision [ 1:2 , 1:2 ] > writes(r); +1.0000000000000000E+00 +3.0000000000000000E+00 +7.0000000000000000E+00 +9.0000000000000000E+00 > v=M[1:2,2:3]; v matrice reelle double-precision [ 1:2 , 1:2 ] > writes(v); +2.0000000000000000E+00 +3.0000000000000000E+00 +5.0000000000000000E+00 +6.0000000000000000E+00 >
Next: Entree/SortieMatbasniveau, Previous: ExtractionMat, Up: Matrices numeriques [Contents][Index]
Les fonctions suivantes fonctionnent pour les matrices de la même manière que pour les vecteurs numériques :
• sauve_c : | ||
• sauve_fortran : | ||
• sauve_tex : | ||
• sauve_ml : | ||
• write : | ||
• writebin : |
Next: sauve_fortranMat, Up: Entree/SortieMat [Contents][Index]
sauve_c(
<matrice> ,
<nom fichier> );
Elle sauve la matrice dans le fichier désigné dans le langage C (version C99).
Le fichier est créé dans le répertoire spécifié par _path
.
sauve_c(
<matrice> ,
<fichier> );
Elle sauve la matrice dans le fichier déjà ouvert en écriture dans le langage C (version C99).
> A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > sauve_c(A, "prog.c"); >
Next: sauve_texMat, Previous: sauve_cMat, Up: Entree/SortieMat [Contents][Index]
sauve_fortran(
<matrice> ,
<nom fichier> );
Elle sauve la matrice dans le fichier désigné dans le format fortran.
Le fichier est créé dans le répertoire spécifié par _path
.
Le format généré est compatible avec la syntaxe fixe et libre du Fortran.
sauve_fortran(
<matrice> ,
<fichier> );
Elle sauve la matrice dans le fichier déjà ouvert en écriture dans le format fortran (version 77). Le format généré est compatible avec format fixe et libre du Fortran.
> A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > sauve_fortran(A, "prog.f"); >
Next: sauve_mlMat, Previous: sauve_fortranMat, Up: Entree/SortieMat [Contents][Index]
sauve_tex(
<matrice> ,
<nom fichier> );
Elle sauve la série dans le fichier désigné dans le format TeX .
Le fichier est créé dans le répertoire spécifié par _path
.
sauve_tex(
<série> ,
<fichier> );
Elle sauve la matrice dans le fichier déjà ouvert en écriture dans le format TeX.
> A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > sauve_tex(A, "essai.tex"); >
Next: writeMat, Previous: sauve_texMat, Up: Entree/SortieMat [Contents][Index]
sauve_ml(
<matrice> ,
<nom fichier> );
Elle sauve la matrice dans le fichier désigné dans le format MathML2.0 (concept).
Le fichier est créé dans le répertoire spécifié par _path
.
sauve_ml(
<matrice> ,
<fichier> );
Elle sauve la matrice dans le fichier déjà ouvert en écriture dans le format MathML2.0 (concept).
> A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > sauve_ml(A, "essai.ml"); >
Next: writebinMat, Previous: sauve_mlMat, Up: Entree/SortieMat [Contents][Index]
Cette routine fonctionne pour les matrices de la même manière que pour les vecteurs numériques (see write).
Previous: writeMat, Up: Entree/SortieMat [Contents][Index]
Cette routine fonctionne pour les matrices de la même manière que pour les vecteurs numériques (see writebin).
Next: FonctionsmathematiquesMat, Previous: Entree/SortieMat, Up: Matrices numeriques [Contents][Index]
Les fonctions suivantes fonctionnent pour les matrices de la même manière que pour les vecteurs numériques :
file_write
(see file_write)
Next: ConditionsMat, Previous: Entree/SortieMatbasniveau, Up: Matrices numeriques [Contents][Index]
Les fonctions suivantes fonctionnent pour les matrices de la même manière que pour les vecteurs numériques. Ces opérations s’appliquent à chaque élément de la matrice.
abs
acos
acosh
arg
asin
asinh
atan
atanh
atan2
conj
cos
cosh
erf
erfc
exp
imag
int
log
log10
MAX
MIN
mod
nint
real
sign
sin
sinh
tan
tanh
Les fonctions suivantes fonctionnent pour les matrices de la même manière que pour les vecteurs numériques. Ces opérations s’appliquent à l’ensemble de la matrice.
max
min
sum
Next: KroneckerMat, Up: FonctionsmathematiquesMat [Contents][Index]
<matrice> &*
<matrice>
Elle calcule le produit matriciel de deux matrices numériques.
Remarque: le nombre de colonnes de la première matrice doit être égale au nombre de lignes de la seconde matrice.
> _affc=1$ > A = matrixR[1,3,5 :2,4,6]; A matrice reelle double-precision [ 1:2 , 1:3 ] > B = matrixR[5,8,11 :7,6,8 :4,0,8]; B matrice reelle double-precision [ 1:3 , 1:3 ] > C = A&*B; C matrice reelle double-precision [ 1:2 , 1:3 ] > afftab(C); [ 46 26 75] [ 62 40 102] >
<matrice> &*
<vec. num.>
<vec. num.> &*
<matrice>
Elle calcule le produit matriciel entre une matrice numérique et un vecteur numérique.
Next: detMat, Previous: ProdMat, Up: FonctionsmathematiquesMat [Contents][Index]
kroneckerproduct(
<matrice> A ,
<matrice> B)
Elle retourne le produit de Kronecker de deux matrices numériques A et B.
> _affc=1$ > A = matrixR[1,2,3:4,5,6]$ > B = matrixR[5,0:10,1:7,3]$ > C = kroneckerproduct(A,B)$ > afftab(C); [ 5 0 10 0 15 0] [ 10 1 20 2 30 3] [ 7 3 14 6 21 9] [ 20 0 25 0 30 0] [ 40 4 50 5 60 6] [ 28 12 35 15 42 18] >
Next: InvMat, Previous: KroneckerMat, Up: FonctionsmathematiquesMat [Contents][Index]
det(
<matrice> )
Elle calcule le déterminant d’une matrice carrée.
Remarque: lors de calculs en double-precision, la librairie Lapack est utilisée. Un algorithme LU est utilisé dans tous les modes numeriques.
> t=matrixR[9,0,7 :1,2,3 :4,5,6]; t matrice reelle double-precision [ 1:3 , 1:3 ] > det(t); -48 >
Next: TraceMat, Previous: detMat, Up: FonctionsmathematiquesMat [Contents][Index]
invertmatrix(
<matrice> )
Elle calcule l’inverse d’une matrice carrée.
Remarque : lors de calculs en double-precision, la librairie Lapack est utilisée. Un algorithme LU est utilisé dans tous les cas.
> _affc=2$ > A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > B=invertmatrix(A); B matrice reelle double-precision [ 1:3 , 1:3 ] > afftab(B); [ 0.0625 - 0.72916667 0.29166667] [ - 0.125 - 0.54166667 0.41666667] [ 0.0625 0.9375 - 0.375] >
Next: TransposeMat, Previous: InvMat, Up: FonctionsmathematiquesMat [Contents][Index]
tracematrix(
<matrice> )
Elle calcule la trace d’une matrice carrée.
> A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > t=tracematrix(A); t = 17 >
Next: IdentityMat, Previous: TraceMat, Up: FonctionsmathematiquesMat [Contents][Index]
transposematrix(
<matrice> )
Elle calcule la transposée d’une matrice.
> _affc=1$ > A=matrixR[9,0,7 :1,2,3]; A matrice reelle double-precision [ 1:2 , 1:3 ] > B=transposematrix(A); B matrice reelle double-precision [ 1:3 , 1:2 ] > afftab(B); [ 9 1] [ 0 2] [ 7 3] > >
Next: eigenvaluesMat, Previous: TransposeMat, Up: FonctionsmathematiquesMat [Contents][Index]
identitymatrix(
<opération> n )
Elle calcule la matrice identité de taille nxn. Cette matrice est une matrice carrée avec des 1 sur la diagonale et des 0 partout ailleurs.
> _affc=1$ > I3=identitymatrix(3); I3 matrice reelle double-precision [ 1:3 , 1:3 ] > afftab(I3); [ 1 0 0] [ 0 1 0] [ 0 0 1] >
Next: eigenvectorsMat, Previous: IdentityMat, Up: FonctionsmathematiquesMat [Contents][Index]
eigenvalues
(<matrice> )
Elle calcule les valeurs propres d’une matrice carrée en utilisant un algorithme QR ( librairie lapack).
> A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > B=eigenvalues(A); B Vecteur de complexes double-precision : nb complexes =3 > writes(B); +1.3769150418957313E+01 +0.0000000000000000E+00 +4.0843620348094420E+00 +0.0000000000000000E+00 -8.5351245376675389E-01 +0.0000000000000000E+00
Next: ArithmetiqueMat, Previous: eigenvaluesMat, Up: FonctionsmathematiquesMat [Contents][Index]
eigenvectors
(<matrice> MAT, <matrice> TVECT, <matrice> TVAL)
eigenvectors
(<matrice> MAT, <matrice> TVECT)
Elle calcule les vecteurs propres d’une matrice carrée MAT. Elle stocke les vecteurs propres dans la matrice TVECT et les valeurs propres dans le vecteur TVAL.
Elle utilise un algorithme QR ( librairie lapack).
Chaque colonne de TVECT correspond à un vecteur propre. Chaque vecteur est normalisé.
> _affc=1$ > A=matrixR[9,0,7 :1,2,3 :4,5,6]; A matrice reelle double-precision [ 1:3 , 1:3 ] > eigenvectors(A,vectp,valp); > afftab(vectp); [ - 0.808169 - 0.750577 - 0.484664] [ - 0.209021 0.398522 - 0.547409] [ - 0.550611 0.527081 0.682234] > writes(valp); +1.3769150418957313E+01 +0.0000000000000000E+00 +4.0843620348094420E+00 +0.0000000000000000E+00 -8.5351245376675389E-01 +0.0000000000000000E+00 > // 1er vecteur > p=vectp[:,1]$ > writes(p); -8.0816903814944341E-01 +0.0000000000000000E+00 -2.0902130660832199E-01 +0.0000000000000000E+00 -5.5061138669696397E-01 +0.0000000000000000E+00
Previous: eigenvectorsMat, Up: FonctionsmathematiquesMat [Contents][Index]
Les matrices doivent avoir le même nombre d’éléments par dimension.
<matrice> + <matrice>
Elle retourne l’addition terme à terme de deux matrices.
<matrice> + <constante>
<constante> + <matrice>
Elle retourne la somme d’une constante et de chaque élément d’une matrice.
<matrice> + <vec. num.>
<vec. num.> + <matrice>
Elle retourne l’addition terme à terme du vecteur et de la matrice numérique. La matrice numérique doit avoir une seule colonne.
<matrice> * <matrice>
Elle retourne le produit terme à terme de deux matrices.
<matrice> * <constante>
<constante> * <matrice>
Elle retourne le produit terme à terme d’une constante et d’une matrice.
<matrice> * <vec. num.>
<vec. num.> * <matrice>
Elle retourne le produit terme à terme du vecteur et de la matrice numérique. La matrice numérique doit avoir une seule colonne.
<matrice> - <matrice>
Elle retourne la soustraction terme à terme de deux matrices.
<matrice> - <constante>
<constante> - <matrice>
Elle retourne la différence entre une constante et chaque élément de la matrice.
<matrice> - <vec. num.>
<vec. num.> - <matrice>
Elle retourne la soustraction terme à terme du vecteur et de la matrice numérique. La matrice numérique doit avoir une seule colonne.
<matrice> / <matrice>
Elle retourne la division terme à terme de deux matrices.
<matrice> / <constante>
<constante> / <matrice>
Elle retourne la division entre une constante et chaque élément de la matrice.
<matrice> / <vec. num.>
<vec. num.> / <matrice>
Elle retourne la division terme à terme du vecteur et de la matrice numérique. La matrice numérique doit avoir une seule colonne.
Next: ConversionMat, Previous: FonctionsmathematiquesMat, Up: Matrices numeriques [Contents][Index]
?(
<condition>)
Elle retourne une matrice réelle de 0 ou de 1. Pour tous éléments de la condition : si la condition à l’indice i,j est vraie, alors <nom> [i,j]=1 sinon <nom> [i,j]=0
?(
<condition>):
<constante ou matrice> tabvrai :
<constante ou matrice> tabfaux
Elle retourne une matrice numérique.
Pour tous éléments de la condition : si la condition à l’indice i,j est vraie, alors <nom> [i,j]=tabvrai[j] sinon <nom> [i,j]=tabfaux[j]
Les matrices doivent être de même taille.
> mat1=matrixR[1,2,3:4,5,6:7,8,9]; mat1 matrice reelle double-precision [ 1:3 , 1:3 ] > mat2=matrixR[3,0,6:5,2,7:1,4,11]; mat2 matrice reelle double-precision [ 1:3 , 1:3 ] > q=?(mat1<=5); q matrice reelle double-precision [ 1:3 , 1:3 ] > writes(3*"%g "+"\n",q); 1 1 1 1 1 0 0 0 0 > m = ?(mat1>2):mat2:-1; m matrice reelle double-precision [ 1:3 , 1:3 ] > writes(3*"%g "+"\n",m); -1 -1 6 5 2 7 1 4 11 >
Previous: ConditionsMat, Up: Matrices numeriques [Contents][Index]
matrixR(
<identificateur> )
Elle retourne une matrice numérique réelle à partir de l’identificateur fourni. L’identificateur peut être un tableau de constantes, un vecteur numérique ou un tableau de vecteur numériques. L’objet ne doit contenir que des nombres réels.
> _affc=1$ > // convertit un tableau de constantes en matrice reelle > tab3=[1,2,3 :4,5,6]; tab3 [1:2, 1:3 ] nb elements = 6 > mat3=matrixR(tab3); mat3 matrice reelle double-precision [ 1:2 , 1:3 ] > afftab(mat3); [ 1 2 3] [ 4 5 6] > // convertit un vecteur numerique en matrice reelle > v2= 1,10; v2 Vecteur de reels double-precision : nb reels =10 > mat2=matrixR(v2); mat2 matrice reelle double-precision [ 1:10 , 1:1 ] >
matrixC(
<identificateur> )
Elle retourne une matrice numérique complexes à partir de l’identificateur fourni. L’identificateur peut être un tableau de constantes, un vecteur numérique ou un tableau de vecteur numériques. L’objet ne doit contenir que des nombres complexes.
> _affc=1$ > // convertit un tableau de constantes en matrice complexe > tab3=[1+2*i,3+4*i,5 :2,4*i,-7+2*i]; tab3 [1:2, 1:3 ] nb elements = 6 > mat3=matrixC(tab3); mat3 matrice complexe double-precision [ 1:2 , 1:3 ] > afftab(mat3); [(1+i*2) (3+i*4) 5] [ 2 (0+i*4) (-7+i*2)] > // convertit un vecteur numerique en matrice complexe > v2 = 1,10$ > v2 = exp(I*v2); v2 Vecteur de complexes double-precision : nb complexes =10 > mat2 = matrixC(v2); mat2 matrice complexe double-precision [ 1:10 , 1:1 ] >
vnumR(
<matrice> )
Elle retourne un vecteur numérique de réels à partir de la matrice fournie. La matrice ne doit contenir qu’une seule colonne.
> // convertit une matrice reelle en vecteur numerique > mat1=matrixR[2:3:5]; mat1 matrice reelle double-precision [ 1:3 , 1:1 ] > v1=vnumR(mat1); v1 Vecteur de reels double-precision : nb reels =3 > writes(v1); +2.0000000000000000E+00 +3.0000000000000000E+00 +5.0000000000000000E+00 >
vnumC(
<matrice> )
Elle retourne un vecteur numérique de complexes à partir de la matrice fournie. La matrice ne doit contenir qu’une seule colonne.
> // convertit une matrice complexe en vecteur numerique > mat1=matrixC[1+2*i:4*i:-7+2*i]; mat1 matrice complexe double-precision [ 1:3 , 1:1 ] > v1=vnumC(mat1); v1 Vecteur de complexes double-precision : nb complexes =3 > writes(v1); +1.0000000000000000E+00 +2.0000000000000000E+00 +0.0000000000000000E+00 +4.0000000000000000E+00 -7.0000000000000000E+00 +2.0000000000000000E+00 >
Next: Communications, Previous: Matrices numeriques, Up: Top [Contents][Index]
Les versions requises de gnuplot par TRIP sont :
Les versions requises de grace par TRIP sont :
Les commandes plot, replot, plotf, plotps, plotps_end et plotreset utilisent grace ou gnuplot suivant la valeur de la variable globale _graph (see _graph).
• plot : | ||
• replot : | ||
• plotf : | ||
• plotps : | ||
• plotps_end : | ||
• plotreset : | ||
• gnuplot : | ||
• grace : |
Next: replot, Up: Graphiques [Contents][Index]
plot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY);
plot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. 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.
plot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ);
plot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. 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.
plot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY);
plot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. 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.
plot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ);
plot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. 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.
plot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY), ... );
plot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) chaine> options), ...);
Elle exécute gnuplot ou grace et superpose les courbes de chaque couplet de tableaux en tra
plot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ), ...);
plot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ,
<(tableau de) chaine> options), ...);
Elle exécute gnuplot ou grace et superpose les courbes de chaque triplet de tableaux en tra
plot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY), ...);
plot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. 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.
plot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ), ...);
plot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. 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.
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));
Next: plotf, Previous: plot, Up: Graphiques [Contents][Index]
replot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY);
replot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) chaine> options);
replot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ);
replot(
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ,
<(tableau de) chaine> options);
replot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY);
replot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) chaine> options);
replot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ);
replot(
<chaine> cmd,
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ,
<(tableau de) chaine> options);
replot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY), ... );
replot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) chaine> options), ...);
replot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ), ...);
replot( (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ,
<(tableau de) chaine> options), ...);
replot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY), ...);
replot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) chaine> options), ...);
replot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. réel> TZ), ...);
replot(
<chaine> cmd, (
<(tableau de) vec. réel> TX,
<(tableau de) vec. réel> TY,
<(tableau de) vec. 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
(see plot).
replot;
Elle exécute gnuplot ou grace et envoie un ordre pour retracer les graphiques.
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");
Next: plotps, Previous: replot, Up: Graphiques [Contents][Index]
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.
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 #
.
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);
Next: plotps_end, Previous: plotf, Up: Graphiques [Contents][Index]
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 commande plotps_end
.
Tracer cos(x) pour x=-pi à pi avec un pas de pi/100 et le stocker dans le fichier res.ps. > x=-pi,pi,pi/100; x nb elements réels =200 > y=cos(x); y nb elements réels =200 > plotps res.ps; > plot(x,y); > plotps_end;
Next: plotreset, Previous: plotps, Up: Graphiques [Contents][Index]
plotps_end;
Le fichier créé par plotps
est fermé.
Pour gnuplot, elle met le terminal à sa valeur par défaut.
Remarque :
Tracer cos(x) pour x=-pi à pi avec un pas de pi/100 et le stocker dans le fichier res.ps. > x=-pi,pi,pi/100; x nb elements réels =200 > y=cos(x); y nb elements réels =200 > plotps res.ps; > plot(x,y); > plotps_end;
Next: gnuplot, Previous: plotps_end, Up: Graphiques [Contents][Index]
plotreset;
Elle envoie un ordre de réinitialisation à gnuplot ou grace.
Dans le cas de gnuplot, elle envoie uniquement la commande reset
.
Dans le cas de grace, elle envoie la commande new
suivi de redraw
.
> _graph=grace; _graph = grace > t=0,10; t Tableau de reels : nb reels =11 > plot(t,t); > plotreset;
Next: grace, Previous: plotreset, Up: Graphiques [Contents][Index]
gnuplot;
<commande gnuplot>
<commande gnuplot>@
<chaine> @
<commande gnuplot>
%
<commande trip> \
<commande trip>
end;
Une syntaxe alternative à gnuplot; ... end;
est gnuplot; ... gnuplot_end;
.
TRIP accepte des commandes gnuplot et les transmet à gnuplot (ligne par ligne). Gnuplot est exécuté s’il n’est pas en mémoire. Le prompt devient ‘gnuplot>’ lorsqu’il est possible de saisir des commandes gnuplot.
Lorsque le premier caractère est un %, alors le reste de la ligne est une ou plusieurs commandes trip. Cette commande trip peut se poursuivre sur plusieurs lignes, le dernier caractère doit être un \ pour indiquer que la commande se prolonge sur la ligne suivante.
Il est possible d’envoyer à gnuplot une chaine déclarée dans trip en encadrant son nom par le caractère @ .
> gnuplot; gnuplot> plot 'tftf' using 1:3 gnuplot> set xrange[1:10] gnuplot> replot gnuplot> end$ > > > gnuplot; gnuplot> set terminal macintosh singlewin Terminal type set to 'macintosh' Options are 'nogx singlewin novertical' gnuplot> %plot(t,log(t),"notitle"); gnuplot> %replot(t,exp(t),"notitle \ w points pt 5"); gnuplot> set terminal macintosh multiwin Terminal type set to 'macintosh' Options are 'nogx multiwin novertical' > ch="title 'sinus'"; ch = "title 'sinus'" > gnuplot; gnuplot> plot sin(x) @ch@ gnuplot> end;
Previous: gnuplot, Up: Graphiques [Contents][Index]
grace;
<commande grace>
<commande grace>@
<chaine> @
<commande grace>
%
<commande trip> \
<commande trip>
end;
TRIP accepte des commandes grace et les transmet à grace (ligne par ligne). Grace est exécuté s’il n’est pas en mémoire. Le prompt devient ‘grace>’ lorsqu’il est possible de saisir des commandes grace.
Lorsque le premier caractère est un %, alors le reste de la ligne est une ou plusieurs commandes trip. Cette commande trip peut se poursuivre sur plusieurs lignes, le dernier caractère doit être un \ pour indiquer que la commande se prolonge sur la ligne suivante.
Il est possible d’envoyer à grace une chaine déclarée dans trip en encadrant son nom par le symbole @ .
> grace; grace> grace> with g0 grace> read block "/USER/toto" grace> block xy "1:2" grace> read block "/USER/toto" grace> block xy "1:3" grace> redraw grace> title "2courbes" grace> %t=1,10; t Tableau de reels : nb reels =10 grace> %msg "deux lignes\ fin deligne"; deux lignesfin deligne grace> end; > >
Next: Macros, Previous: Graphiques, Up: Top [Contents][Index]
TRIP offre différents outils de communications :
• Communications avec Maple : | ||
• Communications avec Mathematica : | ||
• Communications avec les autres systemes de calcul formel : | ||
• Librairie dynamique : |
TRIP communique avec d’autres logiciels de calculs formels sur le même ordinateur. Ceux-ci doivent être capable d’importer et d’exporter leurs calculs sous le format MathML 2.0.
Une session globale est disponible pour chaque logiciel de calculs formel. Il est possible de définir plusieurs sessions différentes pour chaque logiciel de calculs formel.
Next: Communications avec Mathematica, Up: Communications [Contents][Index]
TRIP communique avec Maple1 sur tous les systèmes d’exploitation acceptant Maple.
La version requise de maple par TRIP est 11 ou ultérieur.
• maple_put : | ||
• maple_get : | ||
• maple : |
Next: maple_get, Up: Communications avec Maple [Contents][Index]
maple_put(
<identificateur> id);
Elle envoie l’identificateur à la session globale maple. Si celui-ci n’est pas exécuté, il est démarré.
> _affdist=1$ > s=1+x; s(x) = 1 + x > maple_put(s); > maple; > s; 1 + x > end; >
maple_put(
<session Maple> session ,
<identificateur> id);
Elle envoie l’identificateur à la session maple spécifiée par session, qui doit avoir t'é dḿarrée préalablement.
> _affdist=1$ > fm=maple; > z:=1; z := 1 > end; > s=1+x; s(x) = 1 + x > maple_put(fm,s); > maple(fm); > z+s; 2 + x > end; >
Next: maple, Previous: maple_put, Up: Communications avec Maple [Contents][Index]
maple_get(
<identificateur> id);
Elle récupère la valeur de l’identificateur depuis la session globale maple.
> _affdist=1$ > maple; > s:=1+y; s := 1 + y > end; > maple_get(s); > s; s(y) = 1 + y
maple_get(
<session Maple> session ,
<identificateur> id);
Elle récupère la valeur de l’identificateur depuis la session maple spécifiée par session.
> _affdist=1$ > fm=maple; > s:=1+y; s := 1 + y > end; > maple_get(fm, s); > s; s(y) = 1 + y
Previous: maple_get, Up: Communications avec Maple [Contents][Index]
maple;
<commande maple>
%
<commande maple> \
<commande maple>
%
<commande trip> \
<commande trip>
end;
TRIP accepte des commandes maple et les transmet à la session globale de Maple (ligne par ligne). maple est exécuté si la session globale n’a pas encore été démarrée. Le prompt devient ‘maple>’ lorsqu’il est possible de saisir des commandes maple.
Une commande maple peut se poursuivre sur plusieurs lignes, le dernier caractère doit être un \ pour indiquer que la commande se prolonge sur la ligne suivante.
Lorsque le premier caractère est un %, alors le reste de la ligne est une ou plusieurs commandes trip. Cette commande trip peut se poursuivre sur plusieurs lignes, le dernier caractère doit être un \ pour indiquer que la commande se prolonge sur la ligne suivante.
L’envoi et la récupération d’objets (séries, vecteurs, ...) s’effectue avec les fonctions maple_get
et maple_put
.
> maple; > s:=gcd((x+1)*(x-1),(x-1)); s := x - 1 > %maple_get(s); > %s; s(x) = - 1 + 1*x > end; >
<session Maple> = maple;
<commande maple>
end;
Cette commande est identique mais démarre à chaque fois une nouvelle session de Maple.
Elle retourne un identificateur permettant de spécifier la session pour les commandes maple_put
et maple_get
.
Une session existante peut être continuée par la commande maple(
<session Maple> ); ... end;
.
La session peut être arrêtée par la commande delete(
<session Maple> );
.
maple(
<session Maple> );
<commande maple>
end;
Cette commande continue la session existante spécifiée de Maple.
> fm=maple; > f:=gcd((x+1)*(x-1),(x-1)); f := x - 1 > g:=f+2; g := x + 1 > end; > maple_get(fm,g); > delete(fm);
Next: Communications avec les autres systemes de calcul formel, Previous: Communications avec Maple, Up: Communications [Contents][Index]
TRIP communique avec Mathematica2 sur tous les systèmes d’exploitation acceptant Mathematica.
La version requise de mathematica par TRIP est 9 ou ultérieur.
• mathematica_put : | ||
• mathematica_get : | ||
• mathematica : |
Next: mathematica_get, Up: Communications avec Mathematica [Contents][Index]
mathematica_put(
<identificateur> id);
Elle envoie l’identificateur à la session globale Mathematica. Si celui-ci n’est pas exécuté, il est démarré.
> _affdist=1$ > s=1+x; s(x) = 1 + x > mathematica_put(s); > mathematica; > s 1 + x > end; >
mathematica_put(
<session Mathematica> session ,
<identificateur> id);
Elle envoie l’identificateur à la session mathematica spécifiée par session, qui doit avoir t'é dḿarrée préalablement.
> _affdist=1$ > fm=mathematica; > z:=1; > end; > s=1+x; s(x) = 1 + x > mathematica_put(fm,s); > mathematica(fm); > z+s; > end; >
Next: mathematica, Previous: mathematica_put, Up: Communications avec Mathematica [Contents][Index]
mathematica_get(
<identificateur> id);
Elle récupère la valeur de l’identificateur depuis la session globale mathematica.
> _affdist=1$ > mathematica; > s:=1+y; > end; > mathematica_get(s); > s; s(y) = 1 + y >
mathematica_get(
<session Mathematica> session ,
<identificateur> id);
Elle récupère la valeur de l’identificateur depuis la session mathematica spécifiée par session.
> _affdist=1$ > fm=mathematica; > s:=1+y; > end; > mathematica_get(fm, s); > s; s(y) = 1 + y >
Previous: mathematica_get, Up: Communications avec Mathematica [Contents][Index]
mathematica;
<commande mathematica>
%
<commande mathematica> \
<commande mathematica>
%
<commande trip> \
<commande trip>
end;
TRIP accepte des comandes mathematica et les transmet à la session globale de mathematica (ligne par ligne). mathematica est exécuté si la session globale n’a pas été démarrée. Le prompt devient ‘mathematica>’ lorsqu’il est possible de saisir des commandes mathematica.
Une commande mathematica peut se poursuivre sur plusieurs lignes, le dernier caractère doit être un \ pour indiquer que la commande se prolonge sur la ligne suivante.
Lorsque le premier caractère est un %, alors le reste de la ligne est une ou plusieurs commandes trip. Cette commande trip peut se poursuivre sur plusieurs lignes, le dernier caractère doit être un \ pour indiquer que la commande se prolonge sur la ligne suivante.
L’envoi et la récupération d’objets (séries, vecteurs, ...) s’effectue avec les fonctions mathematica_get
et mathematica_put
.
> mathematica; > s=PolynomialGCD[(x+1)*(x-1),(x-1)] -1 + x > %mathematica_get(s); > %s; s(x) = - 1 + 1*x > end; >
<session Mathematica> = mathematica;
<commande mathematica>
end;
Cette commande est identique mais démarre à chaque fois une nouvelle session de Mathematica.
Elle retourne un identificateur permettant de spécifier la session pour les commandes mathematica_put
et mathematica_get
.
Une session existante peut être continuée par la commande mathematica(
<session Mathematica> ); ... end;
.
La session peut être arrêtée par la commande delete(
<session Mathematica> );
.
mathematica(
<session Mathematica> );
<commande mathematica>
end;
Cette commande continue la session existante spécifiée de Mathematica.
> fm=mathematica; > f=PolynomialGCD[(x+1)*(x-1),(x-1)] -1 + x > g=f+2 1 + x > end; > mathematica_get(fm,g); > delete(fm); >
Next: Librairie dynamique, Previous: Communications avec Mathematica, Up: Communications [Contents][Index]
TRIP communique avec d’autres logiciels de calculs formels sur le même ordinateur ou distant. Ceux-ci doivent être compatible avec le protocole SCSCP "Symbolic Computation Software Composability Protocol" version 1.3 (http://www.symcomp.org/). Il supporte notamment les symboles OpenMath définis dans les dictionnaires scscp1 (http://www.win.tue.nl/SCIEnce/cds/scscp1.html) et scscp2 (http://www.win.tue.nl/SCIEnce/cds/scscp2.html). La liste des dictionaires OpenMath supportés par TRIP est donnée en annexe (see Dictionnaires OpenMath).
Plusieurs connexions peuvent être ouverte en même temps. TRIP peut fonctionner en mode client ou serveur.
Avant d’utiliser ce module de communications, vous devez exécuter dans la session trip la commande suivante. Elle définit et exécute un large ensemble de macros contenant la définition de symboles OpenMath.
include libscscpserver.t; |
• serveur SCSCP: | ||
• client SCSCP: |
Le démarrage du serveur SCSCP de TRIP s’effectue en utilisant les instructions suivantes dans une session TRIP :
include libscscpserver.t; port = 26133; %scscp_runserver[port]; |
La valeur de la variable du port peut être changée. La valeur par défaut est 26133 pour les serveurs SCSCP.
Les variables globales de TRIP, telle que _modenum
, peut ainsi être modifiées avant de démarrer le serveur SCSCP.
Le fichier libscscpserver.t
exporte un certain nombre de symboles des dictionnaires OpenMath.
De nouveaux symboles peuvent être exportées pour ajouter des fonctionnalités au serveur SCSCP ou du client SCSCP.
Pour cela, il faut utiliser la fonction scscp_map_macroassymbolcd
qui est défini dans le fichier libscscpserver.t
.
scscp_map_macroassymbolcd(
<chaine> macroname, <chaine> cdname, <chaine> symbolname );
Elle associe au symbole symbolname du dictionnaire cdname à la macro macroname. Lorsque ce symbole sera rencontré par le serveur SCSCP ou le client SCSCP dns un message echangé, alors la macro sera exécutée.
include libscscpserver.t; _modenum=NUMRATMP; macro myscscp_evalmul[P1, P2, value] { t=value,value; q=evalnum(P1*P2,REAL, (x,t)); return q[1]; }; scscp_map_macroassymbolcd("myscscp_evalmul", "SCSCP_transient_1","scscp_muleval"); %scscp_runserver[26133];
see scscp_disable_cd.
Le serveur SCSCP de TRIP propose via le dictionnaire de symboles scscp_transient_1
les opérations suivantes :
Cet exemple est une session maple 16. TRIP est exécuté en mode serveur SCSCP. Les dictionnaires "polyr" et "polyu" sur le serveur sont desactives car le client maple 16 ne les supporte pas. > with(SCSCP): > with(Client): > cookie := StorePersistent("localhost:26133", x*y+1); cookie := "TempOID1@localhost:26133" > Retrieve("localhost:26133", cookie); Error, (in SCSCP:-Client:-ExtractAnswer) unsupported_CD, <OMS cd = 'polyr' name = 'term'/> > CallService("localhost", "scscp_transient_1", "serverdisablecd", ["polyr"]): > CallService("localhost", "scscp_transient_1", "serverdisablecd", ["polyu"]): > Retrieve("localhost:26133", cookie); 1.0000000000000000 + 1.0000000000000000 x y
Previous: serveur SCSCP, Up: Communications avec les autres systemes de calcul formel [Contents][Index]
TRIP peut communiquer avec d’autres logiciels de calculs formels fournissant un serveur SCSCP.
• scscp_connect : | ||
• scscp_close : | ||
• scscp_put : | ||
• scscp_get : | ||
• scscp_delete : | ||
• scscp_execute : | ||
• scscp_disable_cd : |
Next: scscp_close, Up: client SCSCP [Contents][Index]
scscp_connect(
<chaine> computername, <entier> port );
Elle se connecte au calcul formel distant sur le port de la machine spécifiée. Cette fonction retourne un objet gérant cette connexion et à fournir aux autre fonctions.
> include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > scscp_close(sc); > stat(sc); client SCSCP sc : deconnecte
Next: scscp_put, Previous: scscp_connect, Up: client SCSCP [Contents][Index]
scscp_close(
<client scscp> sc );
Elle ferme la connexion au calcul formel distant spécifié par sc.
> include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > scscp_close(sc); > stat(sc); client SCSCP sc : deconnecte
Next: scscp_get, Previous: scscp_close, Up: client SCSCP [Contents][Index]
scscp_put(
<client scscp> sc, <opération> x );
scscp_put(
<client scscp> sc, <opération> x, <chaine> storeoption );
Elle envoie l’identificateur x au calcul formel distant spécifié par le client scscp sc,précédemment ouvert avec scscp_connect
.
Cette fonction retourne un objet distant.
Si storeoption n’est pas spécifié, alors sa valeur est "persistent".
Les valeurs possibles de storeoption sont :
> include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > r=1+x; r(x) = 1 + 1*x > remoter=scscp_put(sc, r); remoter = objet distant "TempOID1@localhost:26133" > scscp_close(sc);
Next: scscp_delete, Previous: scscp_put, Up: client SCSCP [Contents][Index]
scscp_get(
<objet distant> remoteobjectid );
Elle récupère la valeur de l’identificateur remoteobjectid situé sur le système de calcul formel distant précédemment stocké par scscp_put
.
> include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > s=(1+x+y)**2; s(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2 > remoteS = scscp_put(sc, s); remoteS = objet distant "TempOID1@localhost:26133" > q=scscp_get(remoteS); q(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2 > scscp_close(sc);
Next: scscp_execute, Previous: scscp_get, Up: client SCSCP [Contents][Index]
scscp_delete(
<objet distant> remoteobjectid );
Elle détruit la valeur de l’identificateur remoteobjectid situé sur le système de calcul formel distant précédemment stocké par scscp_put
.
> include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > s=(1+x+y)**2; s(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2 > remoteS = scscp_put(sc, s); remoteS = objet distant "TempOID1@localhost:26133" > delete(remoteS); > scscp_close(sc);
Next: scscp_disable_cd, Previous: scscp_delete, Up: client SCSCP [Contents][Index]
scscp_execute(
<client scscp> sc, <chaine> returnoption , <chaine> CDname , <chaine> remotecommand , <opération> , ... );
Elle exécute la commande remotecommand sur le calcul formel distant spécifié par sc. Les arguments de la fonction sont spécifiées après la commande.
Les valeurs possibles de returnoption sont :
> include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > q = scscp_execute(sc,"object", "SCSCP_transcient_1", "SCSCP_MUL", 1+7*x,2+3*x); q(x) = 2 + 17*x + 21*x**2 > qr = scscp_execute(sc,"cookie", "SCSCP_transcient_1", "SCSCP_MUL", 1+7*x,2+3*x); qr = objet distant "TempOID6@localhost:26133" > scscp_close(sc);
Previous: scscp_execute, Up: client SCSCP [Contents][Index]
scscp_disable_cd(
<chaine> CDname , );
Elle indique que le dictionnaire CDname ne pourra pas être utilisé pour l’exportation au format OpenMath, et donc avec le calcul formel distant.
Les dictionnaires "polyr" et "polyu" sont desactives car le serveur ne les supporte pas. > include libscscpserver.t; Loading the SCSCP client/server library... Registering the OpenMath CD... > port=26133; port = 26133 > sc=scscp_connect("localhost", port); sc = client SCSCP connecte au serveur SCSCP localhost > scscp_disable_cd("polyr"); > scscp_disable_cd("polyu"); > s=(1+x+y)**2$ > q=scscp_put(sc, s); q = objet distant "TempOID1@localhost:26133" > scscp_close(sc);
Previous: Communications avec les autres systemes de calcul formel, Up: Communications [Contents][Index]
TRIP peut charger une librairie dynamique et exécuter les fonctions de celle-ci. Les librairies dynamiques ont pour extension .so, .dll, .dylib suivant les systèmes d’exploitation. Cependant, il doit connaitre les synopsis des fonctions à exécuter pour convertir correctement les arguments.
• extern_function : | ||
• extern_lib : | ||
• extern_type : | ||
• extern_display : |
Next: extern_lib, Up: Librairie dynamique [Contents][Index]
extern_function(
<nom fichier> filelib,
<chaine> declfunc);
extern_function(
<nom fichier> filelib,
<chaine> declfunc,
<chaine> declinout);
Elle charge la librairie dynamique filelib en ajoutant l’extension spécifique au système d’exploitation et vérifie la présence de la fonction dans cette librairie. L’appel à la fonction se fait ensuite comme une fonction standard de trip.
Elle vérifie la validité du synopsis de la fonction spécifiée par declfunc. Ce synopsis doit être écrit en langage C. Cette fonction peut très bien codé dans un autre langage (fortran, ...).
Si une librairie dynamique dépend d’autres librairies dynamiques, il faut appeler auparavant la commande extern_lib
pour chacune de ses librairies.
Par défaut, tous les arguments sont en entrée seule. Pour indiquer que des arguments sont en entré-sortie, il faut le spécifier dans la chaine declinout. Elle doit contenir autant d’éléments que la fonction. Chaque élément est s’eparé par une virgule. Un élément peut avoir les valeurs suivantes :
Pour les paramètres en sortie, il faut fournir un identificateur pour récupérer la valeur lors de l’appel.
Remarque : Les fonctions ne doivent pas contenir des structures ou des types dérivés.
> extern_function("libm", "double j0(double);"); > r = j0(0.5); r = 0.9384698072408129
/* Appel de sa propre librairie libtest1 contenant test1.c */ > !"cat test1.c"; #include <math.h> double mylog1p(double x) { return log1p(x); } void mylog1parray(double tabdst[], double tabsrc[], int n) { int i; for(i=0; i<n; i++) tabdst[i]=log1p(tabsrc[i]); } > > extern_function(libtest1,"double mylog1p(double x);"); > mylog1p(10); 2.39789527279837 > log(11); 2.39789527279837 > extern_function(libtest1, "void mylog1parray(double tabdst[], double tabsrc[], int n);", "inout,in,in"); > t=1,10; t Tableau de reels : nb reels =10 > vnumR res; resize(res,10); > mylog1parray(res,t,10); > writes(t,res); +1.0000000000000000E+00 +6.9314718055994529E-01 +2.0000000000000000E+00 +1.0986122886681098E+00 +3.0000000000000000E+00 +1.3862943611198906E+00 +4.0000000000000000E+00 +1.6094379124341003E+00 +5.0000000000000000E+00 +1.7917594692280550E+00 +6.0000000000000000E+00 +1.9459101490553132E+00 +7.0000000000000000E+00 +2.0794415416798357E+00 +8.0000000000000000E+00 +2.1972245773362196E+00 +9.0000000000000000E+00 +2.3025850929940459E+00 +1.0000000000000000E+01 +2.3978952727983707E+00
Next: extern_type, Previous: extern_function, Up: Librairie dynamique [Contents][Index]
extern_lib(
<nom fichier> filelib);
Elle charge la librairie dynamique filelib en ajoutant l’extension spécifique (.dll, .so, .dylib) au système d’exploitation. Cette fonction est utilisée pour charger des librairies qui sont utilisées par d’autres librairies.
> extern_lib("libm"); > extern_function("libm", "double j0(double);"); > r = j0(0.5); r = 0.9384698072408129
Next: extern_display, Previous: extern_lib, Up: Librairie dynamique [Contents][Index]
extern_lib(
<chaine> type);
Elle déclare le type externe type. Les fonctions externes pourront utiliser ou retourner des pointeur des objets de ce type. type peut être une structure C dont la valeur des champs pourra être lue ou modifiée.
> extern_type("t_calcephbin"); > extern_function("libcalceph", "t_calcephbin* calceph_open(const char *filename);"); > eph = calceph_open("inpop06c_m100_p100_littleendian.dat");
Previous: extern_type, Up: Librairie dynamique [Contents][Index]
extern_display;
Elle affiche la liste des types et fonctions externes préalablement déclarées par extern_function
ou extern_type
.
> extern_function("libm", "double j0(double);"); > extern_function("libm", "double j1(double);"); > extern_display; Liste des fonctions externes : double j1(double); double j0(double);
Next: Boucles et conditions, Previous: Communications, Up: Top [Contents][Index]
• Declaration : | ||
• Execution : | ||
• return : | ||
• Liste des macros : | ||
• affmac : | Affichage du code. | |
• Effacement : | ||
• Comment redefinir une macro : | ||
• Comment sauver une macro : |
macro
<nom> [ <liste_parametres> ] { <corps> };
macro
<nom> { <corps> };
MACRO
<nom> [ <liste_parametres> ] { <corps> };
MACRO
<nom> { <corps> };
private macro
<nom> [ <liste_parametres> ] { <corps> };
private macro
<nom> { <corps> };
Elle déclare une macro avec 0 ou plusieurs paramètres et un corps de code trip.
La liste des paramètres est séparée par une virgule. Les paramètres sont des noms. Il n’y a aucune limitation en nombre de paramètres. Les macros admettent la récursivité mais il existe une limite (souvent 70 fois).
Le dernier paramètre peut être ...
qui indique que la macro peut recevoir un ou plusieurs arguments optionnels lors de son appel.
L’accès à chacun de ces arguments optionnels se fait par le mot clé macro_optargs[]
.
Pour accéder a l’argument optionnel d’indice j, il suffit d’écrire : macro_optargs[j]
.
Pour connaitre le nombre d’arguments optionnels fournis, il faut utiliser la fonction size(macro_optargs)
.
Les données correspondant au ...
peuvent être transmises à une autre macro en utilisant macro_optargs
dans les arguments de l’appel.
La macro peut retourner une valeur en utilisant return
.
Une macro peut être arrêtée immédiatement en utilisant la commande stop
(see stop).
La macro peut définir des identificateurs locaux, See private.
La visibilité d’une macro est restreinte au fichier source la contenant si sa déclaration est préfixée du mot-clé private
. Seules les macros de ce fichier pourront l’appeler.
Remarque : Les paramètres sont des identificateurs. Ceci n’est pas autorisé: ‘> macro c[n,t[n]]{....};’
L’exemple suivant presente l’écriture d’une macro a qui affecte à r l’addition de x et de y. x et y sont passés en argument. La macro b affiche le contenu du répertoire courant.
> macro a [x,y] {r = x+y;}; > macro b { ! "ls";}; > macro macvar[x,y,...] { s=x+y; l = size(macro_optargs); msg("number of optional argument %g\n", l); for j=1 to l { msg("The optional argument %g :", j); macro_optargs[j]; }; }; > %macvar[P1,P2]; s(P1,P2) = 1*P2 + 1*P1 l = 0 number of optional argument 0 > %macvar[P1,P2,"arg1", 3,5, 7]; s(P1,P2) = 1*P2 + 1*P1 l = 4 number of optional argument 4 The optional argument 1 :macro_optargs[1] = "arg1" The optional argument 2 :macro_optargs[2] = 3 The optional argument 3 :macro_optargs[3] = 5 The optional argument 4 :macro_optargs[4] = 7 > macro macopt[x,y,...] { %macvar[x, macro_optargs]; };
Next: return, Previous: DeclarationMacro, Up: Macros [Contents][Index]
%
<nom> [ <liste_parametres> ];
%
<nom> ;
Elle exécute une macro. La liste des paramètres est une liste de paramètres séparés par des virgules.
Ces paramètres peuvent être des identificateurs, des séries (resultat de calcul), des chaines, des tableaux, des vecteurs numeriques, ....
Le passage des paramètres s’effectue par valeur ou par référence.
Le passage par valeur est possible uniquement pour le resultat de calcul, de chaine et de tableaux numériques, de tableaux, ... .
Le passage par référence est possible pour tout identificateur ou élément de tableau. Pour cela, il faut l’encadrer par des crochets supplémentaires []. Dans ce cas, l’identificateur peut être modifié pendant l’exécution de la macro.
Elle retourne une valeur si la commande return
a été exécutée dans le corps de cette macro.
L’exécution de la macro continue après la commande return
.
Une macro peut être arrêtée immédiatement en utilisant la commande stop
(see stop).
On veut exécuter notre macro a et b:
> %a[1,5+3*6]; /*ou si S = x + y*/ > %a[S,5]; >%b; >%c[[t],[u[5]],1+x]; Usage des chaines de caractères: > macro nomfichier[name,j] {msg name + str(j);}; > %nomfichier["file_",2]; file_2 > ch="file_1.2."; ch = "file_1.2." > %nomfichier[ch,3]; file_1.2.3 >
Remarque : Il faut noter que les paramètres (x,y,...) gardent leur valeur propre. Pour passer une expression, il ne faut pas l’encadrer par des [].
- Si x vaut z et que l'on applique la macro a, une fois la macro exécutée, x vaudra z. Alors que si x n'est pas défini, sa valeur sera celle qu'il avait à la fin de l'exécution de la macro. Exemple : Si on veut ajouter à 'S' la variable 'x': > %a[S,[x]]; et on aura r(x,y) = 1*y + 2*x - Déclaration d'une matrice. L'identificateur R1 n'existe pas. /*creation d'une matrice */ >macro matrix_create[_nom, _nbligne, _nbcol] { dim _nom[0:_nbligne, 0: _nbcol]; for iligne=1 to _nbligne { for icol=1 to _nbcol {_nom[iligne,icol]=0$};}; /*met le nb de ligne en 0,0 et met le nb de col en 0,1 */ _nom[0, 0]=_nbligne$ _nom[0, 1]=_nbcol$ }; >%matrix_create[[R1],n,3]; Le tableau sera alors crée et initialise. En sortie de la macro, _nom, _nbligne, _nbcol n'existeront plus.
Next: Liste des macros, Previous: Execution, Up: Macros [Contents][Index]
return
(<opération> );
return
<opération> ;
Retourne le resultat d’une opération lorsque la macro est exécutée.
L’exécution de la macro se poursuit, même après la commande return
. Seule la commande stop
arrête l’exécution de la macro.
return
(<opération> , <opération> , ...);
Retourne sous la forme d’un tableau unidimensionnel la liste des opérations comme résultat de l’exécution de la macro. L’indice du tableau retourné commence à 1.
> _affdist=1$ > macro func1 { s=1+y$ return s; }; > b=%func1; b(y) = 1 + y > macro func2 { v=1,10$ ch="file1"$ return (v, ch); }; > (a, s)=%func2; > a; a Vecteur de reels double-precision : nb reels =10 > s; s = "file1" > t=%func2; t [1:2 ] nb elements = 2 > afftab(t); t[1] = t Vecteur de reels double-precision : nb reels =10 t[2] = "file1" >
@
;
Affiche la liste des macros en mémoire
> @; Voici le nom des macros que je connais: a [x ,y ] b
Next: Effacement, Previous: Liste des macros, Up: Macros [Contents][Index]
affmac
<macro>;
Affiche le corps (code trip) de la macro.
> affmac b; mon nom est : b !"ls";
Next: Comment redefinir une macro, Previous: affmac, Up: Macros [Contents][Index]
• effmac : | ||
• effmacros : |
Next: effmacros, Up: Effacement [Contents][Index]
effmac
<macro>;
Efface une macro.
> macro a[x] { return (x*2);}; > @; Voici le nom des macros que je connais : a [ x] > effmac a; > @; je ne connais aucune macro
Previous: effmac, Up: Effacement [Contents][Index]
effmacros
;
Efface toutes les macros en mémoire.
> macro a[x] { return (x*2);}; > macro b {!"ls";}; > @; Voici le nom des macros que je connais : a [ x] b [] > effmacros; > @; je ne connais aucune macro
Next: Comment sauver une macro, Previous: Effacement, Up: Macros [Contents][Index]
On procède comme si on écrivait une nouvelle macro en utilisant la commande
macro
.
> macro a [n] {n;}; > @; Voici le nom des macros que je connais: a [n ] > affmac a; mon nom est : a n;
Previous: Comment redefinir une macro, Up: Macros [Contents][Index]
Pour sauver sur disque des macros, la meilleure façon, pour l’instant, est d’utiliser un editeur de textes du type vi, emacs, nedit. Les fichiers contenant du code trip doivent si possible se terminer par .t .
Next: Bibliotheques, Previous: Macros, Up: Top [Contents][Index]
• boucles : | ||
• condition : |
Next: condition, Up: Boucles et conditions [Contents][Index]
• while : | ||
• for : | ||
• sum : | ||
• prod : | ||
• stop : |
while (
<condition> ) do {
<corps> };
Elle exécute le corps tant que la condition est vraie.
La boucle while
permet d’être plus souple que la boucle for
dans le fait que l’on peut en sortir quand on veut.
Une boucle while
peut être arrêtée immédiatement en utilisant la commande stop
.
Pour la description de la condition, See condition.
La boucle peut contenir des identificateurs locaux qui seront détruits à la fin de chaque itération, See private.
> // On veut afficher tous les nombres de 1 à n: > p=1$ > while(p<=5) do { p; p=p+1$ }; p = 1 p = 2 p = 3 p = 4 p = 5 >
for
<nom> =
<réel> to
<réel> {
<corps> };
for
<nom> =
<réel> to
<réel> step
<réel> {
<corps> };
Elle exécute la boucle "pour jusqu’à" (identique au boucle for du pascal ou du C ou fortran).
L’argument après step
est le pas de la boucle.
Une boucle for
peut être arrêtée immédiatement en utilisant la commande stop
.
La boucle peut contenir des identificateurs locaux qui seront détruits à la fin de chaque itération, See private. Remarque :
> for p = 1 to 5 step 2 {p; }; p = 1 p = 3 p = 5 > for p = 5 to -1 step -2 {p; }; p = 5 p = 3 p = 1 p = -1
La boucle for peut être parallélisée en utilisant une notation OpenMP. TRIP refuse la parallélisation si des variables globales sont modifiées ou si des fonctions modifiant l’état global de trip sont appelées. Dans ce cas, un message d’avertissement est émis.
Si le mot clé distribute
est utilisé à la fin de la notation OpenMP,
la parallélisation s’effectue sur plusieurs noeuds de calculs
si l’application tripcluster exécute ce code.
/*!trip omp parallel for */
<nom>
for=
<réel> to
<réel> {
<corps> };
/*!trip omp parallel for distribute */
<nom>
for=
<réel> to
<réel> {
<corps> };
s=(1+x+y+z+t)**(20)$ dim f[1:8]; n=size(f)$ // execution parallele time_s; /*!trip omp parallel for */ for p = 1 to n { f[p]=s/p$ }; time_t; utilisateur 00.119s - reel 00.023s - systeme 00.019s - (594.73% CPU) // execution sequentielle time_s; for p = 1 to n { f[p]=s/p$ }; time_t; utilisateur 00.118s - reel 00.116s - systeme 00.008s - (109.27% CPU)
sum
<nom> =
<réel> to
<réel> {
<corps> };
sum
<nom> =
<réel> to
<réel> step
<réel> {
<corps> };
Elle exécute la boucle "somme jusqu’à". Elle remplace la boucle for du type "s=0$ for j=1 to n { s=s+...$}".
La valeur retournée par la commande return
est utilisée pour la somme.
L’argument après step
est le pas de la boucle.
Une boucle sum
peut être arrêtée immédiatement en utilisant la commande stop
.
La boucle peut contenir des identificateurs locaux qui seront détruits à la fin de chaque itération, See private.
Remarque :
> s=sum j=1 to 5 { return j; }; s = 15 > s=sum j=1 to 10 step 2 { a=3*j$ if (mod(j,2)==0) then { return a; } else { return -a; }; }; s = -75
prod
<nom> =
<réel> to
<réel> {
<corps> };
prod
<nom> =
<réel> to
<réel> step
<réel> {
<corps> };
Elle exécute la boucle "produit jusqu’à". Elle remplace la boucle for du type "s=1$ for j=1 to n { s=s*...$}".
La valeur retournée par la commande return
est utilisée pour le produit.
L’argument après step
est le pas de la boucle.
Une boucle prod
peut être arrêtée immédiatement en utilisant la commande stop
.
La boucle peut contenir des identificateurs locaux qui seront détruits à la fin de chaque itération, See private.
Remarque :
> p = prod j = 1 to 10 { return j$ }; p = 3628800
stop;
Cette commande arrête l’exécution d’une boucle for
, while
ou d’une macro.
Remarque : si stop se situe en dehors d’une boucle for
, while
ou d’une macro, un message d’avertissement est affiché mais l’exécution continue.
for p = 1 to 5 { if (p>3) then {stop;} fi; p;}; 1 2
Previous: boucles, Up: Boucles et conditions [Contents][Index]
• if : | ||
• operateur de comparaison: | ||
• switch : |
Next: operateur de comparaison, Up: condition [Contents][Index]
if (
<condition>) then {
<corps> };
if (
<condition>) then {
<corps> } else {
<corps> };
if (
<condition>) then {
<corps> } fi;
(obsolete statement)
TRIP exécute le premier corps de programme si la condition est vraie. Le second corps est exécuté si celui-ci est présent et la condition est fausse.
> if (n == 2) then {msg "VRAI";} else {msg"FAUX";}; FAUX > n=2; 2 > if (( n >= 0) && (n < 3)) then {msg "VRAI";} else {msg "FAUX";}; VRAI
Remarque : Il faut faire attention à ce que tous les identificateurs soient initialisées avant de faire un test. Car sinon, il identifie le parametre n à une variable, et le résultat du test est donc FAUX.
<opération> !=
<opération>
Ce test retourne vrai si les deux opérations sont différentes.
Remarque : ce test se fait aussi sur les polynômes.
<vec. réel> !=
<vec. réel>
Ce test peut s’utiliser avec l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Il retourne un tableau numérique de 0 et 1.
Il compare terme à terme les éléments des deux tableaux. Les tableaux de réels doivent être de même taille.
> if (n != 2) then {} else {}; > // Condition entre deux vecteurs > t = 0,10$ > r = 10,0,-1$ > q = ?(t!=r); q Vecteur de reels double-precision : nb reels =11 > q = ?(t!=5); q Vecteur de reels double-precision : nb reels =11 >
<opération> ==
<opération>
Ce test retourne vrai si les deux opérations sont égales.
Si les deux opérandes sont les valeurs NaN
(not a number) , alors le test retourne faux.
Remarque : ce test se fait aussi sur les polynômes.
<vec. réel> ==
<vec. réel>
Ce test peut s’utiliser avec l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Il retourne un tableau numérique de 0 et 1.
Il compare terme à terme les éléments des deux tableaux. Les tableaux de réels doivent être de même taille.
> if (n == 2) then {} else {}; > // Condition entre deux vecteurs > t = 0,10$ > r = 10,0,-1$ > q = ?(t==r); q Vecteur de reels double-precision : nb reels =11 > q = ?(t==5); q Vecteur de reels double-precision : nb reels =11 >
<réel> <
<réel>
Ce test retourne vrai si le premier réel est sctritement inférieur au second réel.
<vec. réel> <
<vec. réel>
Ce test peut s’utiliser avec l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Il retourne un tableau numérique de 0 et 1.
Il compare terme à terme les éléments des deux tableaux. Les tableaux de réels doivent être de même taille.
> n=3$ > if (n < 2) then {} else {}; > > // Condition entre deux vecteurs > t = 0,10$ > r = 10,0,-1$ > q = ?(t<r); q Vecteur de reels double-precision : nb reels =11 > q = ?(t<5); q Vecteur de reels double-precision : nb reels =11 >
<réel> >
<réel>
Ce test retourne vrai si le premier réel est strictement supérieur au second réel.
<vec. réel> >
<vec. réel>
Ce test peut s’utiliser avec l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Il retourne un tableau numérique de 0 et 1.
Il compare terme à terme les éléments des deux tableaux. Les tableaux de réels doivent être de même taille.
> n=3$ > if (n > 2) then {} else {}; > > // Condition entre deux vecteurs > t = 0,10$ > r = 10,0,-1$ > q = ?(t>r); q Vecteur de reels double-precision : nb reels =11 > q = ?(t>5); q Vecteur de reels double-precision : nb reels =11 >
<réel> <=
<réel>
Ce test retourne vrai si le premier réel est inférieur ou égal au second réel.
<vec. réel> <=
<vec. réel>
Ce test peut s’utiliser avec l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Il retourne un tableau numérique de 0 et 1.
Il compare terme à terme les éléments des deux tableaux. Les tableaux de réels doivent être de même taille.
> n=3$ > if (n <= 2) then {} else {}; > > // Condition entre deux vecteurs > t = 0,10$ > r = 10,0,-1$ > q = ?(t<=r); q Vecteur de reels double-precision : nb reels =11 > q = ?(t<=5); q Vecteur de reels double-precision : nb reels =11 >
<réel> >=
<réel>
Ce test retourne vrai si le premier réel est supérieur ou égal au second réel.
<vec. réel> >=
<vec. réel>
Ce test peut s’utiliser avec l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Il retourne un tableau numérique de 0 et 1.
Il compare terme à terme les éléments des deux tableaux. Les tableaux de réels doivent être de même taille.
> n=3$ > if (n >= 2) then {} else {}; > > // Condition entre deux vecteurs > t = 0,10$ > r = 10,0,-1$ > q = ?(t>=r); q Vecteur de reels double-precision : nb reels =11 > q = ?(t>=5); q Vecteur de reels double-precision : nb reels =11 >
<condition> &&
<condition>
Ce test retourne vrai si les deux conditions sont vraies.
Il s’applique au tableau numérique lors de l’utilisation de l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Les tableaux numériques doivent être de même taille.
Les parenthèses autour des conditions sont nécessaires uniquement si la condition incluent une combinaison de &&
et ||
.
> if ((x==2)&&(y==3)) then {} else {}; > > // Exemple sur deux vecteurs > t=0,10; t Vecteur de reels double-precision : nb reels =11 > r=10,0,-1; r Vecteur de reels double-precision : nb reels =11 > q=?((t>r) && (t!=5)); q Vecteur de reels double-precision : nb reels =11 >
<condition> ||
<condition>
Ce test retourne vrai si l’une des deux conditions est vraie.
Il s’applique au tableau numérique lors de l’utilisation de l’opérateur ?::
(see Conditions) ou la commande select
(see Extraction). Les tableaux numériques doivent être de même taille.
Les parenthèses autour des conditions sont nécessaires uniquement si la condition incluent une combinaison de &&
et ||
.
> if ((x==2)||(y==3)) then {} else {}; > > // Exemple sur deux vecteurs > t=0,10; t Vecteur de reels double-precision : nb reels =11 > r=10,0,-1; r Vecteur de reels double-precision : nb reels =11 > q=?((t>r) || (t!=5)); q Vecteur de reels double-precision : nb reels =11 >
Previous: operateur de comparaison, Up: condition [Contents][Index]
switch (
<opération> expr )
{
case <opération> : {
<corps> };
case <opération> , ..., <opération> : {
<corps> };
else {
<corps> }
};
L’instruction switch
permet de faire plusieurs tests de valeurs sur le contenu d’une même opération.
expr peut être une chaine, une série, ou une constante numérique. La valeur de expr est testée successivement avec chacune des valeurs des case
avec l’opérateur ==
.
Lorsque l’expression testée est égale à une des valeurs suivant un case
,
la liste d’instructions qui suit celui-ci est exécutée. Le mot-clé else
précède la liste d’instructions qui sera exécutée
si l’expression n’est jamais égale à une des valeurs. L’expression else {
<corps> };
est optionnel et n’a pas de point-virgule après son corps.
n=0; z=0; j=5; switch( j ) { case -1 : { n=n+1; }; case 0,1 : { z=z+1; }; case "mystring" : { msg "j is a string"; }; else { msg "j is invalid"; } };
Next: Traitement numerique, Previous: Boucles et conditions, Up: Top [Contents][Index]
• Lapack : |
Up: Bibliotheques [Contents][Index]
• Resolution de AX=B: | ||
• Moindres Carres: | ||
• Factorisations: | ||
• Decompositions en Valeurs Singulieres: | ||
• Valeurs Propres et Vecteurs Propres: |
Next: Moindres Carres, Up: Lapack [Contents][Index]
• lapack_dgesv: | ||
• lapack_dgbsv: | ||
• lapack_dgtsv: | ||
• lapack_dsysv: | ||
• lapack_dposv: | ||
• lapack_dpbsv: | ||
• lapack_dptsv: | ||
• lapack_zgesv: | ||
• lapack_zgbsv: | ||
• lapack_zgtsv: | ||
• lapack_zsysv: | ||
• lapack_zhesv: | ||
• lapack_zposv: | ||
• lapack_zpbsv: | ||
• lapack_zptsv: |
Cas réel général, (see lapack_dgesv)
Cas réel des matrices bandes, (see lapack_dgbsv)
Cas réel des matrices tridiagonales, (see lapack_dgtsv)
Cas réel des matrices symétriques, (see lapack_dsysv)
Cas réel des matrices symétriques définies positives, (see lapack_dposv)
Cas réel des matrices bandes symétriques définies positives, (see lapack_dpbsv)
Cas réel des matrices tridiagonales symétriques définies positives, (see lapack_dptsv)
Cas complexe général, (see lapack_zgesv)
Cas complexe des matrices bandes, (see lapack_zgbsv)
Cas complexe des matrices tridiagonales, (see lapack_zgtsv)
Cas complexe des matrices symétriques, (see lapack_zsysv)
Cas complexe des matrices hermitiennes, (see lapack_zhesv)
Cas complexe des matrices hermitiennes définies positives, (see lapack_zposv)
Cas complexe des matrices bandes hermitiennes définies positives, (see lapack_zpbsv)
Cas complexe des matrices tridiagonales hermitiennes définies positives, (see lapack_zptsv)
Next: lapack_dgbsv, Up: Resolution de AX=B [Contents][Index]
lapack_dgesv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice à N lignes et N colonnes, et X et B sont des matrices à N lignes et NRHS colonnes. Elle utilise la décomposition LU.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgesv.f
> // resout un systeme reel d'equations lineaires AX=B avec A matrice carree > _affc=1$ > A = matrixR[ 22.22, -11.11: -35.07, 78.01]$ > B = matrixR[ -88.88: 382.18]$ > S = lapack_dgesv(A, B)$ > afftab(S); [ - 2] [ 4] >
Next: lapack_dgtsv, Previous: lapack_dgesv, Up: Resolution de AX=B [Contents][Index]
lapack_dgbsv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice bande d’ordre N, et X et B sont des matrices à N lignes et NRHS colonnes. Elle utilise la décomposition LU.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgbsv.f
> // resout un systeme reel d'equations lineaires AX=B avec A matrice bande > _affc=1$ > A = matrixR[ -22.22, 0: 15.4, -4.1]; A matrice reelle double-precision [ 1:2 , 1:2 ] > B = matrixR[ -88.88: 69.8]; B matrice reelle double-precision [ 1:2 , 1:1 ] > S = lapack_dgbsv(A, B); S matrice reelle double-precision [ 1:2 , 1:1 ] > afftab(S); [ 4] [ - 2] >
Next: lapack_dsysv, Previous: lapack_dgbsv, Up: Resolution de AX=B [Contents][Index]
lapack_dgtsv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice à N lignes et N colonnes tridiagonale, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgtsv.f
> // exemple de la routine dgtsv > _affc=1$ > A = matrixR[ 3.0, 2.1, 0, 0, 0: 3.4, 2.3, -1.0, 0, 0: 0, 3.6, -5.0, 1.9, 0: 0, 0, 7.0, -0.9, 8.0: 0, 0, 0, -6.0, 7.1]$ > B = matrixR[ 2.7: -0.5: 2.6: 0.6: 2.7]$ > S = lapack_dgtsv(A, B); S matrice reelle double-precision [ 1:5 , 1:1 ] > afftab(S); [ - 4] [ 7] [ 3] [ - 4] [ - 3] >
Next: lapack_dposv, Previous: lapack_dgtsv, Up: Resolution de AX=B [Contents][Index]
lapack_dsysv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice symétrique de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/double/dsysv.f
> // resout un systeme reel d'equations lineaires AX=B > // avec A matrice symetrique > _affc=1$ > A = matrixR[ -1.81, 2 : 2, 1.15]$ > B = matrixR[ 0.19: 3.15]$ > S=lapack_dsysv(A,B)$ > afftab(S); [ 1] [ 1] >
Next: lapack_dpbsv, Previous: lapack_dsysv, Up: Resolution de AX=B [Contents][Index]
lapack_dposv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice symétrique définie positive de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/double/dposv.f
> // resout un systeme reel d'equations lineaires AX=B > // avec A matrice symetrique definie positive > _affc=1$ > A = [ 4.16, -3.12: -3.12, 5.03]$ > B = matrixR[ 10.40: -13.18]$ > S=lapack_dposv(A,B)$ > afftab(S); [ 1] [ - 2] >
Next: lapack_dptsv, Previous: lapack_dposv, Up: Resolution de AX=B [Contents][Index]
lapack_dpbsv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice symétrique définie positive bande de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/double/dpbsv.f
> // exemple de la routine dpbsv > _affc=1$ > A = matrixR[ 5.49, 2.68, 0, 0: 2.68, 5.63, -2.39, 0: 0, -2.39, 2.60, -2.22: 0, 0, -2.22, 5.17]$ > B = matrixR[ 22.09: 9.31: -5.24: 11.83]$ > S = lapack_dpbsv(A, B); AB matrice reelle double-precision [ 1:2 , 1:4 ] S matrice reelle double-precision [ 1:4 , 1:1 ] > afftab(S); [ 5] [ - 2] [ - 3] [ 1] >
Next: lapack_zgesv, Previous: lapack_dpbsv, Up: Resolution de AX=B [Contents][Index]
lapack_dptsv(
<matrice reelle> A ,
<matrice reelle> B)
Cette routine résout le système matriciel réel AX=B, où A est une matrice tridiagonale symétrique définie positive de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/double/dptsv.f
> // exemple de la routine dptsv > _affc=1$ > A = matrixR[ 4.0, -2.0, 0, 0, 0: -2.0, 10.0, -6.0, 0, 0: 0, -6.0, 29.0, 15.0, 0: 0, 0, 15.0, 25.0, 8.0: 0, 0, 0, 8.0, 5.0]$ > B = matrixR[ 6.0: 9.0: 2.0: 14.0: 7.0]$ > S = lapack_dptsv(A, B); S matrice reelle double-precision [ 1:5 , 1:1 ] > afftab(S); [ 2.5] [ 2] [ 1] [ - 1] [ 3] >
Next: lapack_zgbsv, Previous: lapack_dptsv, Up: Resolution de AX=B [Contents][Index]
lapack_zgesv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice à N lignes et N colonnes, et X et B sont des matrices à N lignes et NRHS colonnes. Elle utilise la décomposition LU.
A est une matrice carrée. B est une matrice.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgesv.f
> // resout un systeme complexe d'equations lineaires AX=B > // avec A matrice carree > _affc=1$ > A = matrixC[ 1*i, 0: 0, 2*i]$ > B = matrixC[ 7.37*i: 14.74]$ > S=lapack_zgesv(A,B)$ > afftab(S); [ 7.37] [(0-i*7.37)] >
Next: lapack_zgtsv, Previous: lapack_zgesv, Up: Resolution de AX=B [Contents][Index]
lapack_zgbsv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice bande d’ordre N avec KL diagonales inférieures et KU supérieures, et X et B sont des matrices à N lignes et NRHS colonnes. Elle utilise la décomposition LU.
A est une matrice bande. B est une matrice.
Dans le cas où A est diagonale, l’appel est équivalent à "lapack_zgesv(A,B);"
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgbsv.f
> // resout un systeme complexe d'equations lineaires AX=B > // avec A matrice bande > _affc=1$ > A = matrixC[ -1.65+2.26*i, -2.05-0.85*i, 0.97-2.84*i, 0: 6.30*i, -1.48-1.75*i, -3.99+4.01*i, 0.59-0.48*i: 0, -0.77+2.83*i, -1.06+1.94*i, 3.33-1.04*i: 0, 0, 4.48-1.09*i, -0.46-1.72*i]$ > B = matrixC[ -1.06+21.50*i: -22.72-53.90*i: 28.24-38.60*i: -34.56+16.73*i]$ > S = lapack_zgbsv(A, B); S matrice complexe double-precision [ 1:4 , 1:1 ] > afftab(S); [(-3+i*2)] [(1-i*7)] [(-5+i*4)] [(6-i*8)] >
Next: lapack_zsysv, Previous: lapack_zgbsv, Up: Resolution de AX=B [Contents][Index]
lapack_zgtsv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice à N lignes et N colonnes tridiagonale, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgtsv.f
> // exemple de la routine zgtsv > _affc=1$ > A = matrixC[ -1.3+1.3*i, 2-1*i, 0, 0, 0: 1-2*i, -1.3+1.3*i, 2+1*i, 0, 0: 0, 1+i, -1.3+3.3*i, -1+i, 0: 0, 0, 2-3*i, -0.3+4.3*i, 1-i: 0, 0, 0, 1+i, -3.3+1.3*i]$ > B = matrixC[ 2.4-5*i: 3.4+18.2*i: -14.7+9.7*i: 31.9-7.7*i: -1.0+1.6*i]$ > S = lapack_zgtsv(A, B); S matrice complexe double-precision [ 1:5 , 1:1 ] > afftab(S); [(1+i*1)] [(3-i*1)] [(4+i*5)] [(-1-i*2)] [(1-i*1)] >
Next: lapack_zhesv, Previous: lapack_zgtsv, Up: Resolution de AX=B [Contents][Index]
lapack_zsysv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice symétrique de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zsysv.f
> // exemple de la routine zsysv > _affc=1$ > A = matrixC[ -0.56+0.12*i, -1.54-2.86*i, 5.32-1.59*i, 3.80+0.92*i: -1.54-2.86*i, -2.83-0.03*i, -3.52+0.58*i, -7.86-2.96*i: 5.32-1.59*i, -3.52+0.58*i, 8.86+1.81*i, 5.14-0.64*i: 3.80+0.92*i, -7.86-2.96*i, 5.14-0.64*i, -0.39-0.71*i]$ > B = matrixC[ -6.43+19.24*i: -0.49-1.47*i: -48.18+66*i: -55.64+41.22*i]$ > S = lapack_zsysv(A, B); S matrice complexe double-precision [ 1:4 , 1:1 ] > afftab(S); [(-4+i*3)] [(3-i*2)] [(-2+i*5)] [(1-i*1)] >
Next: lapack_zposv, Previous: lapack_zsysv, Up: Resolution de AX=B [Contents][Index]
lapack_zhesv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice hermitienne de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zhesv.f
> // exemple de la routine zhesv > _affc=1$ > A = matrixC[ -1.84, 0.11-0.11*i, -1.78-1.18*i, 3.91-1.50*i: 0.11+0.11*i, -4.63, -1.84+0.03*i, 2.21+0.21*i: -1.78+1.18*i, -1.84-0.03*i, -8.87, 1.58-0.90*i: 3.91+1.50*i, 2.21-0.21*i, 1.58+0.90*i, -1.36]$ > B = matrixC[ 2.98-10.18*i: -9.58+3.88*i: -0.77-16.05*i: 7.79+5.48*i]$ > S = lapack_zhesv(A, B); S matrice complexe double-precision [ 1:4 , 1:1 ] > afftab(S); [(2+i*1)] [(3-i*2)] [(-1+i*2)] [(1-i*1)] >
Next: lapack_zpbsv, Previous: lapack_zhesv, Up: Resolution de AX=B [Contents][Index]
lapack_zposv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice hermitienne définie positive de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zposv.f
> // exemple de la routine zposv > _affc=1$ > A = matrixC[ 3.23, 1.51-1.92*i, 1.90+0.84*i, 0.42+2.50*i: 1.51+1.92*i, 3.58, -0.23+1.11*i, -1.18+1.37*i: 1.90-0.84*i, -0.23-1.11*i, 4.09, 2.33-0.14*i: 0.42-2.50*i, -1.18-1.37*i, 2.33+0.14*i, 4.29]$ > B = matrixC[ 3.93-6.14*i: 6.17+9.42*i: -7.17-21.83*i: 1.99-14.38*i]$ > S = lapack_zposv(A, B); S matrice complexe double-precision [ 1:4 , 1:1 ] > afftab(S); [(1-i*1)] [(-4.34355E-15+i*3)] [(-4-i*5)] [(2+i*1)] >
Next: lapack_zptsv, Previous: lapack_zposv, Up: Resolution de AX=B [Contents][Index]
lapack_zpbsv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice hermitienne définie positive bande de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zpbsv.f
> // exemple de la routine zpbsv > _affc=1$ > A = matrixC[ 16, 16-16*i, 0, 0: 16+16*i, 41, 18+9*i, 0: 0, 18-9*i, 46, 1+4*i: 0, 0, 1-4*i, 21]$ > B = matrixC[ 64+16*i: 93+62*i: 78-80*i: 14-27*i]$ > S = lapack_zpbsv(A, B); AB matrice complexe double-precision [ 1:2 , 1:4 ] S matrice complexe double-precision [ 1:4 , 1:1 ] > afftab(S); [(2+i*1)] [(1+i*1)] [(1-i*2)] [(1-i*1)] >
Previous: lapack_zpbsv, Up: Resolution de AX=B [Contents][Index]
lapack_zptsv(
<matrice complexe> A ,
<matrice complexe> B)
Cette routine résout le système matriciel complexe AX=B, où A est une matrice tridiagonale hermitienne définie positive de rang N, et X et B sont des matrices à N lignes et NRHS colonnes.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zptsv.f
> // exemple de la routine zptsv > _affc=1$ > A = matrixC[ 9.39, 1.08-1.73*i, 0, 0: 1.08+1.73*i, 1.69, -0.04+0.29*i, 0: 0, -0.04-0.29*i, 2.65, -0.33+2.24*i: 0, 0, -0.33-2.24*i, 2.17]$ > B = matrixC[ -12.42+68.42*i: -9.93+0.88*i: -27.30-0.01*i: 5.31+23.63*i]$ > S = lapack_zptsv(A, B); S matrice complexe double-precision [ 1:4 , 1:1 ] > afftab(S); [(-1+i*8)] [(2-i*3)] [(-4-i*5)] [(7+i*6)] >
Next: Factorisations, Previous: Resolution de AX=B, Up: Lapack [Contents][Index]
• lapack_dgels: | ||
• lapack_dgelss: | ||
• lapack_dgglse: | ||
• lapack_dggglm: | ||
• lapack_zgels: | ||
• lapack_zgelss: | ||
• lapack_zgglse: | ||
• lapack_zggglm: |
Cas réel général, (see lapack_dgels)
Cas réel général, utilisant la décomposition en valeurs singulières (see lapack_dgelss)
Cas réel des problèmes (LSE) des moindres carrés à contraintes d’égalité, (see lapack_dgglse)
Cas réel des modèles de Gauss-Markov (GLM) linéaires, (see lapack_dggglm)
Cas complexe général, (see lapack_zgels)
Cas complexe général, utilisant la décomposition en valeurs singulières (see lapack_zgelss)
Cas complexe des problèmes (LSE) des moindres carrés à contraintes d’égalité, (see lapack_zgglse)
Cas complexe des modèles de Gauss-Markov (GLM) linéaires, (see lapack_zggglm)
Next: lapack_dgelss, Up: Moindres Carres [Contents][Index]
lapack_dgels(
<matrice reelle> A ,
<matrice reelle> B ,
<chaine> TRANS)
Cette routine résout un système surdéterminé ou sous-déterminé, impliquant une matrice à M lignes et N colonnes A, ou sa transposée, en utilisant une factorisation QR ou RQ de A. On doit avoir A de plein rang.
Quatre options sont proposées:
Formats de sortie:
Pour plus d’informations, http://www.netlib.org/lapack/double/dgels.f
> // probleme des moindres carres reel: min ||B-A*X|| > _affc=1$ > A = matrixR[ -3, 1: 1, 1: 4-7, 1: 5, 1]$ > B = matrixR[ 70: 21: 110: -35]$ > S = lapack_dgels(A, B, "N")$ > afftab(S); [ - 15.7727] [ 41.5] [ 28.5243] [ - 4.13405] > > // la somme des carres residuels s'obtient ici en calculant: > // sqrt(S[3]**2+S[4]**2) > resid=sqrt(S[3,1]**2+S[4,1]**2); resid = 28.8223 > > // solution de norme minimale au systeme sousdetermine AX=B > A = matrixR[ 1, 2, 3, 4: 5, 6, 7, 8: 9, 10, 11, 12]$ > B = matrixR[ 30: 70: 110]$ > S = lapack_dgels(A, B, "N")$ > afftab(S); [ 1] [ 2] [ 3] [ 4] > > // attention au nombre de lignes de la solution > size(B); 3 > size(S); 4 > > // solution de norme minimale au systeme non determine A**T*X=B, > // ou A**T est la transposee de A > A = matrixR[ 1, 5, 9: 2, 6, 10: 3, 7, 11: 4, 8, 12]$ > B = matrixR[ 30: 70: 110]$ > S = lapack_dgels(A, B, "T")$ > afftab(S); [ 1] [ 2] [ 3] [ 4] > > // ici aussi, attention au nombre de lignes de la solution > size(B); 3 > size(S); 4 > > // probleme des moindres carres reel: min ||B-A**T*X|| > A = matrixR[ -3, 1, -7, 5: 1, 1, 1, 1]$ > B = matrixR[ 70: 21: 110: -35]$ > S = lapack_dgels(A, B, "T")$ > afftab(S); [ - 12.1] [ 29.4] [ - 6.80331] [ - 4.23261] > > // la somme des carres residuels s'obtient ici en calculant: > // sqrt(S[3]**2+S[4]**2) > resid=sqrt(S[3,1]**2+S[4,1]**2); resid = 8.01249
Next: lapack_dgglse, Previous: lapack_dgels, Up: Moindres Carres [Contents][Index]
lapack_dgelss(
<matrice reelle> A ,
<matrice reelle> B ,
<entier> RCOND)
Cette routine calcule la solution de norme minimale au problème réel des moindres carrés suivant: min || |B-A*X| || en utilisant la décomposition en valeurs singulières de A, matrice à M lignes et N colonnes qu peut être de rang déficient.
B est une matrice à M lignes. RCOND est la précision utilisée. Mettre RCOND à -1 permet de calculer avec la précision machine.
Les lignes 1 à N de la matrice retournée contiennent les vecteurs solution des moindres carrées. Si A est de rang N, et que M>=N, alors les lignes N+1 à M contiennent les carrés résiduels.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgelss.f
> // probleme des moindres carres reel: min ||B-A*X|| > _affc=1$ > > A = [ -0.09, 0.14, -0.46, 0.68, 1.29: -1.56, 0.20, 0.29, 1.09, 0.51: -1.48, -0.43, 0.89, -0.71, -0.96: -1.09, 0.84, 0.77, 2.11, -1.27: 0.08, 0.55, -1.13, 0.14, 1.74: -1.59, -0.72, 1.06, 1.24, 0.34]$ > B = matrixR[ 7.4: 4.2: -8.3: 1.8: 8.6: 2.1]$ > > // on selectionne une precision de 1.E-2 > S = lapack_dgelss(A, B, 1E-2)$ > afftab(S); [ 0.634385] [ 0.969928] [ - 1.44025] [ 3.36777] [ 3.39917] [ - 0.00347521] > > // avec la precision machine > S = lapack_dgelss(A, B, -1)$ > afftab(S); [ - 0.799745] [ - 3.28796] [ - 7.47498] [ 4.93927] [ 0.767833] [ - 0.00347521] > >
Next: lapack_dggglm, Previous: lapack_dgelss, Up: Moindres Carres [Contents][Index]
lapack_dgglse(
<matrice reelle> A ,
<matrice reelle> B ,
<matrice reelle> C ,
<matrice reelle> D)
lapack_dgglse(
<matrice reelle> A ,
<matrice reelle> B ,
<matrice reelle> C ,
<matrice reelle> D ,
<identificateur> T ,
<identificateur> R ,
<identificateur> S)
Cette routine résout le problème linéaire des moindres carrés à contrainte d’égalité:
min || C - A*X ||, contrainte B*X = D
où A est une matrice M-N, B est une matrice P-N, C est un M-vecteur, and D est un P-vecteur.
On suppose P <= N <= M+P, et
rang(B) = P et rang( (A) ) = N. ( (B) )
Elle utilise une factorisation RQ généralisée des matrices (B,A) avec B = (0 R)*Q et A = Z*T*Q.
Dans la version complète de la fonction, vous pouvez récupérer T, R et le vecteur S des carrés résiduels, de taille M-N+P.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgglse.f
> // exemple de la routine dgglse > _affc=1$ > A = matrixR[ 1, 2: 3, 4: 5, 6]$ > B = matrixR[ 2.50, 0.00: 0.00, 2.50]$ > C = matrixR[ -1: -2: -3]$ > D = matrixR[ 3.00: 4.00]$ > S = lapack_dgglse(A,B,C,D)$ > afftab(S); [ 1.2] [ 1.6]
Next: lapack_zgels, Previous: lapack_dgglse, Up: Moindres Carres [Contents][Index]
lapack_dggglm(
<matrice reelle> A ,
<matrice reelle> B ,
<matrice reelle> D ,
<identificateur> X ,
<identificateur> Y)
lapack_dggglm(
<matrice reelle> A ,
<matrice reelle> B ,
<matrice reelle> D ,
<identificateur> X ,
<identificateur> Y ,
<identificateur> T ,
<identificateur> R)
Cette routine résout un problème de modèle Gauss-Markov linéaire généralisé:
min || Y ||_2, contrainte D = A*X + B*Y X où A est une matrice N-M, B est une matrice N-P, and D est un N-vecteur. On suppose M <= N <= M+P, rang(A) = M et rang(AB) = N.
Elle utilise une factorisation QR généralisée des matrices (B,A) avec B = Q*T*Z et A = Q*(R). (0)
En particulier, si B est carrée et inversible, alors le problème GLM est équivalent au problème des moindres carrés pondérés
min || inv(B)*(D-A*X) ||_2 X
avec inv(B), l’inverse de B.
Dans la version complète de la fonction, vous pouvez récupérer T et R.
Pour plus d’informations, http://www.netlib.org/lapack/double/dggglm.f
> // exemple de la routine dggglm > _affc=1$ > A = matrixR[ 7687, 13450.888: 9999, 15499.08: 7594, 12450.12]$ > B = matrixR[ 2.50, 11.77: 7, 7: 12.00, 2.50]$ > D = matrixR[ 20777: 35713: 21777]$ > lapack_dggglm(A, B, D, X, Y)$ > afftab(X); [ 11.8512] [ - 5.31511] > afftab(Y); [ - 200.172] [ 141.898]
Next: lapack_zgelss, Previous: lapack_dggglm, Up: Moindres Carres [Contents][Index]
lapack_zgels(
<matrice complexe> A ,
<matrice complexe> B ,
<chaine> TRANS)
Cette routine résout un système complexe surdéterminé ou sous-déterminé, impliquant une matrice à M lignes et N colonnes A, ou sa transposée conjuguée, en utilisant une factorisation QR ou RQ de A. On doit avoir A de plein rang.
Quatre options sont proposées:
Formats de sortie:
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgels.f
> // resout un probleme des moindres carres complexe: min ||B-A*X|| > _affc=1$ > A = matrixC[ -0.57, -1.28, -0.39, 0.25: -1.93, 1.08, -0.31, -2.14: 2.30, 0.24, 0.40, -0.35: -1.93, 0.64, -0.66, 0.08: 0.15, 0.30, 0.15, -2.13: -0.02, 1.03, -1.43, 0.50]$ > B = matrixC[ -2.67: -0.55: 3.34: -0.77: 0.48: 4.10+i]$ > S = lapack_zgels(A, B, "N")$ > afftab(S); [(1.53387+i*0.158054)] [(1.87075+i*0.0726528)] [(-1.52407-i*0.621165)] [(0.039183-i*0.0141075)] [(-0.0085366-i*0.0685483)] [(0.0204427+i*0.205957)] >
Next: lapack_zgglse, Previous: lapack_zgels, Up: Moindres Carres [Contents][Index]
lapack_zgelss(
<matrice complexe> A ,
<matrice complexe> B ,
<réel> RCOND)
Cette routine calcule la solution de norme minimale au problème complexe des moindres carrés suivant: min || |B-A*X| || en utilisant la décomposition en valeurs singulières de A, matrice à M lignes et N colonnes qu peut être de rang déficient.
B est une matrice à M lignes. RCOND est la précision utilisée. Mettre RCOND à -1 permet de calculer avec la précision machine.
Les lignes 1 à N de la matrice retournée contiennent les vecteurs solution des moindres carrées. Si A est de rang N, et que M>=N, alors les lignes N+1 à M contiennent les carrés résiduels.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgelss.f
> // probleme des moindres carres reel: min ||B-A*X|| > _affc=1$ > > A = [ -0.09, 0.14, -0.46, 0.68, 1.29: -1.56, 0.20, 0.29, 1.09, 0.51: -1.48, -0.43, 0.89, -0.71, -0.96: -1.09, 0.84, 0.77, 2.11, -1.27: 0.08, 0.55, -1.13, 0.14, 1.74: -1.59, -0.72, 1.06, 1.24, 0.34]$ > B = matrixC[ 7.4: 4.2*i: -8.3*i: 1.8*i: 8.6: 2.1*i]$ > > // on sélectionne une précision de 1.E-2 > S = lapack_zgelss(A, B, 1E-2)$ > afftab(S); [(-1.88522+i*2.51961)] [(2.23426-i*1.26433)] [(-2.22465+i*0.784398)] [(-0.257364+i*3.62513)] [(2.36045+i*1.03872)] [(3.35419-i*3.35767)] > > // avec la précision machine > S = lapack_zgelss(A, B, -1)$ > afftab(S); [(307.51-i*308.309)] [(920.819-i*924.107)] [(1299.69-i*1307.17)] [(-339.29+i*344.229)] [(570.037-i*569.27)] [(3.35419-i*3.35767)] > > // résultat faux. Attention au paramétrage de RCOND >
Next: lapack_zggglm, Previous: lapack_zgelss, Up: Moindres Carres [Contents][Index]
lapack_zgglse(
<matrice complexe> A ,
<matrice complexe> B ,
<matrice complexe> C ,
<matrice complexe> D)
lapack_zgglse(
<matrice complexe> A ,
<matrice complexe> B ,
<matrice complexe> C ,
<matrice complexe> D ,
<identificateur> T ,
<identificateur> R ,
<identificateur> S)
Cette routine résout le problème linéaire des moindres carrés à contrainte d’égalité:
min || C - A*X ||, contrainte B*X = D
où A est une matrice M-N, B est une matrice P-N, C est un M-vecteur, and D est un P-vecteur.
On suppose P <= N <= M+P, et
rang(B) = P and rang( (A) ) = N. ( (B) )
Elle utilise une factorisation RQ généralisée des matrices (B,A) avec B = (0 R)*Q et A = Z*T*Q.
Dans la version complète de la fonction, vous pouvez récupérer T, R et le vecteur S des carrés résiduels, de taille M-N+P.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgglse.f
> // exemple de la routine zgglse > _affc=1$ > A = matrixC[ 1, 2: 3, 4: 5, 6]$ > B = matrixC[ 2.50*i, 0.00: 0.00, 2.50]$ > C = matrixC[ -1: -2*i: -3]$ > D = matrixC[ 3.00: 4.00*i]$ > S = lapack_zgglse(A,B,C,D)$ > afftab(S); [(0-i*1.2)] [(0+i*1.6)]
Previous: lapack_zgglse, Up: Moindres Carres [Contents][Index]
lapack_zggglm(
<matrice complexe> A ,
<matrice complexe> B ,
<matrice complexe> D ,
<identificateur> X ,
<identificateur> Y)
lapack_zggglm(
<matrice complexe> A ,
<matrice complexe> B ,
<matrice complexe> D ,
<identificateur> X ,
<identificateur> Y ,
<identificateur> T ,
<identificateur> R)
Cette routine résout un problème de modèle Gauss-Markov linéaire généralisé:
min || Y ||_2, contrainte D = A*X + B*Y X où A est une matrice N-M, B est une matrice N-P, and D est un N-vecteur. On suppose M <= N <= M+P, rang(A) = M et rang(AB) = N.
Elle utilise une factorisation QR généralisée des matrices (B,A) avec B = Q*T*Z et A = Q*(R). (0)
En particulier, si B est carrée et inversible, alors le problème GLM est équivalent au problème des moindres carrés pondérés
min || inv(B)*(D-A*X) ||_2 X
avec inv(B), l’inverse de B.
Dans la version complète de la fonction, vous pouvez récupérer T et R.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zggglm.f
> // exemple de la routine zggglm > _affc=1$ > A = matrixC[ 7687, 13450.888: 9999, 15499.08: 7594, 12450.12]$ > B = matrixC[ 2.50, 11.77*i: 7*i, 7: 12.00, 2.50]$ > D = matrixC[ 20777*i: 35713*i: 21777*i]$ > lapack_zggglm(A, B, D, X, Y)$ > afftab(X); [(-1.49403+i*10.5244)] [(0.851288-i*4.50903)] > afftab(Y); [(45.469-i*168.668)] [(80.5683+i*6.76462)] >
Next: Decompositions en Valeurs Singulieres, Previous: Moindres Carres, Up: Lapack [Contents][Index]
• lapack_dgeqrf: | ||
• lapack_dgeqlf: | ||
• lapack_dpotrf: | ||
• lapack_zgeqrf: | ||
• lapack_zgeqlf: | ||
• lapack_zpotrf: |
Factorisation QR dans le cas général réel, (see lapack_dgeqrf)
Factorisation QL dans le cas général réel, (see lapack_dgeqlf)
Factorisation de Cholesky dans le cas réel, (see lapack_dpotrf)
Factorisation QR dans le cas général complexe, (see lapack_zgeqrf)
Factorisation QL dans le cas général complexe, (see lapack_zgeqlf)
Factorisation de Cholesky dans le cas complexe, (see lapack_zpotrf)
Next: lapack_dgeqlf, Up: Factorisations [Contents][Index]
lapack_dgeqrf(
<matrice reelle> A ,
<identificateur> Q ,
<identificateur> R)
Cette routine calcule une factorisation QR d’une matrice réelle à M lignes et N colonnes A:
A = Q*R.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgeqrf.f
> // calcule une factorisation QR d'une matrice A > _affc=1$ > A = matrixR[ 2, 3, -1, 0, 20: -6, -5, 0, 2, -33: 2, -5, 6, -6, -43: 4, 6, 2, -3, 49]$ > lapack_dgeqrf(A, Q, R)$ > afftab(Q); [ - 0.258199 - 0.182574 0.208237 - 0.925547] [ 0.774597 0 - 0.535468 - 0.336563] [ - 0.258199 0.912871 - 0.267734 - 0.168281] [ - 0.516398 - 0.365148 - 0.773453 0.0420703] > afftab(R); [ - 7.74597 - 6.45497 - 2.32379 4.64758 - 44.9266] [ 0 - 7.30297 4.9295 - 4.38178 - 60.7972] [ 0 0 - 3.36155 2.85583 - 4.55148] [ 0 0 0 0.210352 1.89316]
Next: lapack_dpotrf, Previous: lapack_dgeqrf, Up: Factorisations [Contents][Index]
lapack_dgeqlf(
<matrice reelle> A ,
<identificateur> Q ,
<identificateur> L)
Cette routine calcule une factorisation QL d’une matrice réelle à M lignes et N colonnes A:
A = Q*L.
On suppose M >= N.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgeqlf.f
> // calcule une factorisation QL d'une matrice A > _affc=1$ > A = matrixR[ 2, 3, -1, 0: -6, -5, 0, 2: 2, -5, 6, -6: 4, 6, 2, -3: 20, -33, -43, 49]$ > lapack_dgeqlf(A, Q, L)$ > afftab(Q); [ 0.258503 - 0.0987267 - 0.446322 0] [ - 0.0598575 0.395467 0.782976 - 0.0404061] [ - 0.292516 - 0.875179 0.329003 0.121218] [ - 0.914354 0.236816 - 0.28182 0.0606092] [ - 0.089356 - 0.108807 - 0.00892644 - 0.989949] > afftab(L); [ - 5.15342 0 0 0] [ - 5.54949 7.11392 0 0] [ - 6.2383 - 8.29521 2.24054 0] [ - 19.0717 32.6279 43.4164 - 49.4975]
Next: lapack_zgeqrf, Previous: lapack_dgeqlf, Up: Factorisations [Contents][Index]
lapack_dpotrf(
<matrice reelle> A )
Cette routine calcule la factorisation de Cholesky (L) d’une matrice symétrique réelle A:
A = L*L**T
Pour plus d’informations, http://www.netlib.org/lapack/double/dpotrf.f
> _affc=1$ > > A=matrixR[4.16, -3.12 , 0.56, -0.10: -3.12 , 5.03 , -0.83 , 1.18: 0.56 , -0.83, 0.76 , 0.34 : -0.10 , 1.18 , 0.34 , 1.18 ]; A matrice reelle double-precision [ 1:4 , 1:4 ] > > L=lapack_dpotrf(A); L matrice reelle double-precision [ 1:4 , 1:4 ] > afftab(L); [ 2.03961 0 0 0] [ - 1.52971 1.64012 0 0] [ 0.274563 - 0.249981 0.788749 0] [ - 0.049029 0.67373 0.661658 0.534689]
Next: lapack_zgeqlf, Previous: lapack_dgeqlf, Up: Factorisations [Contents][Index]
lapack_zgeqrf(
<matrice complexe> A ,
<identificateur> Q ,
<identificateur> R)
Cette routine calcule une factorisation QR d’une matrice complexe à M lignes et N colonnes A:
A = Q*R.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgeqrf.f
> // calcule une factorisation QR d'une matrice A > _affc=1$ > A = matrixC[ 1+i, -5-i, 3+5*i: 0, 8*i, 27: 0, 0, 2+3*i]$ > lapack_zgeqrf(A, Q, R)$ > afftab(Q); [(-0.707107-i*0.707107) 0 0] [ 0 (0-i*1) 0] [ 0 0 (-0.5547-i*0.83205)] > afftab(R); [ - 1.41421 (4.24264-i*2.82843) (-5.65685-i*1.41421)] [ 0 - 8 (0+i*27)] [ 0 0 - 3.60555] >
Next: lapack_zpotrf, Previous: lapack_zgeqrf, Up: Factorisations [Contents][Index]
lapack_zgeqlf(
<matrice complexe> A ,
<identificateur> Q ,
<identificateur> L)
Cette routine calcule une factorisation QL d’une matrice complexe à M lignes et N colonnes A:
A = Q*L.
On suppose M >= N.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgeqlf.f
> // calcule une factorisation QL d'une matrice A > _affc=1$ > A = matrixC[ 1+i, 0, 0: -5-i, 8*i, 0: 3+5*i, 27, 2+3*i]$ > lapack_zgeqlf(A, Q, L)$ > afftab(Q); [(-0.707107-i*0.707107) 0 0] [ 0 (0-i*1) 0] [ 0 0 (-0.5547-i*0.83205)] > afftab(L); [ - 1.41421 0 0] [(1-i*5) - 8 0] [(-5.82435-i*0.27735) (-14.9769+i*22.4654) - 3.60555]
Previous: lapack_zgeqlf, Up: Factorisations [Contents][Index]
lapack_zpotrf(
<matrice complexe> A )
Cette routine calcule la factorisation de Cholesky (L) d’une matrice symétrique définie positive A:
A = L*L**H
Pour plus d’informations, http://www.netlib.org/lapack/double/zpotrf.f
> A=matrixC[ 3.23+I* 0.00 , 1.51-I* 1.92 , 1.90-I*-0.84 , 0.42-I*-2.50 : 1.51+I* 1.92 , 3.58+I* 0.00 , -0.23-I*-1.11 , -1.18-I*-1.37 : 1.90+I*-0.84 , -0.23+I*-1.11 , 4.09-I* 0.00 , 2.33-I* 0.14 : 0.42+I*-2.50 , -1.18+I*-1.37 , 2.33+I* 0.14 , 4.29+I* 0.00 ]; A matrice complexe double-precision [ 1:4 , 1:4 ] > > L=lapack_zpotrf(A); L matrice complexe double-precision [ 1:4 , 1:4 ] > afftab(L); [ 1.797220075561143 0 0 0] [( 0.8401864749527325+i* 1.068316577423342) 1.316353439509685 0 0] [( 1.057188279741849-i* 0.467388502622712) ( -0.4701749470106329+i* 0.3130658155999464) 1.560392977137124 0] [( 0.233694251311356-i* 1.391037210186643) ( 0.08335250923944196+i* 0.03676071443037474) ( 0.9359617337923402+i* 0.9899692192815739) 0.6603332973655888]
Next: Valeurs Propres et Vecteurs Propres, Previous: Factorisations, Up: Lapack [Contents][Index]
• lapack_dgesvd: | ||
• lapack_dgesdd: | ||
• lapack_zgesvd: | ||
• lapack_zgesdd: |
Décomposition SVD dans le cas général réel, (see lapack_dgesvd)
Décomposition SVD dans le cas général réel utilisant un algorithme Divide and Conquer, (see lapack_dgesdd)
Décomposition SVD dans le cas général complexe, (see lapack_zgesvd)
Décomposition SVD dans le cas général complexe utilisant un algorithme Divide and Conquer, (see lapack_zgesdd)
Next: lapack_dgesdd, Up: Decompositions en Valeurs Singulieres [Contents][Index]
lapack_dgesvd(
<matrice reelle> A ,
<identificateur> U ,
<identificateur> SIGMA ,
<identificateur> VT)
Cette routine calcule la décomposition en valeurs singulières (SVD) d’une matrice réelle A: A=U*SIGMA*VT où A est une matrice M-N, U la matrice des vecteurs singuliers à gauche, VT la transposée de la matrice des vecteurs singuliers à droite, et SIGMA la matrice contenant sur sa diagonale les valeurs singulières de A.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgesvd.f
> // DGESVD effectue la decomposition en valeurs singulieres de A > _affc=1$ > A = matrixR[ 1, 2: 3, 4]$ > lapack_dgesvd(A, U, SIGMA, VT)$ > afftab(U); [ - 0.404554 - 0.914514] [ - 0.914514 0.404554] > afftab(SIGMA); [ 5.46499 0] [ 0 0.365966] > afftab(VT); [ - 0.576048 - 0.817416] [ 0.817416 - 0.576048] >
Next: lapack_zgesvd, Previous: lapack_dgesvd, Up: Decompositions en Valeurs Singulieres [Contents][Index]
lapack_dgesdd(
<matrice reelle> A ,
<identificateur> U ,
<identificateur> SIGMA ,
<identificateur> VT)
Cette routine calcule la décomposition en valeurs singulières (SVD) d’une matrice réelle A: A=U*SIGMA*VT où A est une matrice M-N, U la matrice des vecteurs singuliers à gauche, VT la transposée de la matrice des vecteurs singuliers à droite, et SIGMA la matrice contenant sur sa diagonale les valeurs singulières de A.
Elle utilise un algorithme divide and conquer.
Pour plus d’informations, http://www.netlib.org/lapack/double/dgesdd.f
> // DGESDD effectue la decomposition en valeurs singulieres de A > _affc=1$ > A = matrixR[ 1, 2: 3, 4]$ > lapack_dgesdd(A, U, SIGMA, VT)$ > afftab(U); [ - 0.404554 - 0.914514] [ - 0.914514 0.404554] > afftab(SIGMA); [ 5.46499 0] [ 0 0.365966] > afftab(VT); [ - 0.576048 - 0.817416] [ 0.817416 - 0.576048] >
Next: lapack_zgesdd, Previous: lapack_dgesdd, Up: Decompositions en Valeurs Singulieres [Contents][Index]
lapack_zgesvd(
<matrice complexe> A ,
<identificateur> U ,
<identificateur> SIGMA ,
<identificateur> VT)
Cette routine calcule la décomposition en valeurs singulières (SVD) d’une matrice complexe A: A=U*SIGMA*VT où A est une matrice M-N, U la matrice des vecteurs singuliers à gauche, VT la matrice adjointe à celle des vecteurs singuliers à droite, et SIGMA la matrice contenant sur sa diagonale les valeurs singulières de A.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgesvd.f
> // ZGESVD effectue la decomposition en valeurs singulieres de A > _affc=1$ > A = matrixC[ 1+i, -2-i: 3, 2*i]$ > lapack_zgesvd(A, U, SIGMA, VT)$ > afftab(U); [(-0.158181-i*0.528862) (0.497893-i*0.668869)] [(-0.824631+i*0.12356) (0.391736+i*0.388921)] > afftab(SIGMA); [ 4.2049 0] [ 0 1.52278] > afftab(VT); [ - 0.751728 (0.259779-i*0.606152)] [ 0.659474 (0.29612-i*0.690947)] >
Previous: lapack_zgesvd, Up: Decompositions en Valeurs Singulieres [Contents][Index]
lapack_zgesdd(
<matrice complexe> A ,
<identificateur> U ,
<identificateur> SIGMA ,
<identificateur> VT)
Cette routine calcule la décomposition en valeurs singulières (SVD) d’une matrice complexe A: A=U*SIGMA*VT où A est une matrice M-N, U la matrice des vecteurs singuliers à gauche, VT la matrice adjointe à celle des vecteurs singuliers à droite, et SIGMA la matrice contenant sur sa diagonale les valeurs singulières de A.
Elle utilise un algorithme divide and conquer.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgesdd.f
Previous: Decompositions en Valeurs Singulieres, Up: Lapack [Contents][Index]
• lapack_dsyev: | ||
• lapack_dsbev: | ||
• lapack_dstev: | ||
• lapack_dgeev: | ||
• lapack_dsygv: | ||
• lapack_dggev: | ||
• lapack_dgges: | ||
• lapack_zheev: | ||
• lapack_zhbev: | ||
• lapack_zgeev: | ||
• lapack_zhegv: |
Cas symétrique réel, (see lapack_dsyev)
Cas réel des matrices bandes symétriques, (see lapack_dsbev)
Cas réel des matrices tridiagonales symétriques, (see lapack_dstev)
Cas non symétrique réel, (see lapack_dgeev)
Valeurs propres généralisées, cas symétrique réel, (see lapack_dsygv)
Valeurs propres généralisées, cas non symétrique réel, (see lapack_dggev)
Valeurs propres généralisées et matrices de Schur, (see lapack_dgges)
Cas hermitien complexe, (see lapack_zheev)
Cas complexe des matrices bandes hermitiennes, (see lapack_zhbev)
Cas non hermitien complexe, (see lapack_zgeev)
Valeurs propres généralisées, cas hermitien complexe, (see lapack_zhegv)
Next: lapack_dsbev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dsyev(
<matrice reelle> A,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice A réelle et symétrique. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
Pour plus d’informations, http://www.netlib.org/lapack/double/dsyev.f
> // exemple de la routine dsyev > _affc=1$ > A = matrixR[ 451.27, 0: 0, 512.75]$ > lapack_dsyev(A, values, vectors); vectors matrice reelle double-precision [ 1:2 , 1:2 ] > writes(values); +4.5126999999999998E+02 +5.1275000000000000E+02 > afftab(vectors); [ 1 0] [ 0 1] >
Next: lapack_dstev, Previous: lapack_dsyev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dsbev(
<matrice reelle> A,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice bande A réelle et symétrique. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
Pour plus d’informations, http://www.netlib.org/lapack/double/dsbev.f
> // exemple de la routine dsbev > _affc=1$ > A = matrixR[ 1, 2, 3, 0, 0: 2, 2, 3, 4, 0: 3, 3, 3, 4, 5: 0, 4, 4, 4, 5: 0, 0, 5, 5, 5]$ > lapack_dsbev(A, Values, Vectors); > writes(Values); -3.2473787952520272E+00 -2.6633015451836046E+00 +1.7511163179896112E+00 +4.1598880678262953E+00 +1.4999675954619729E+01 > afftab(Vectors); [ 0.0393846 0.623795 0.563458 - 0.516534 0.15823] [ 0.572127 - 0.257506 - 0.389612 - 0.595543 0.316058] [ - 0.437179 - 0.590046 0.400815 - 0.147035 0.527682] [ - 0.44235 0.430844 - 0.558098 0.0469667 0.552286] [ 0.533217 0.103873 0.242057 0.595564 0.540002] >
Next: lapack_dgeev, Previous: lapack_dsbev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dstev(
<matrice reelle> A,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice tridiagonale A réelle et symétrique. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
Pour plus d’informations, http://www.netlib.org/lapack/double/dstev.f
> // exemple de la routine dstev > _affc=1$ > A = matrixR[ 1, 1, 0, 0: 1, 4, 2, 0: 0, 2, 9, 3: 0, 0, 3, 16]$ > lapack_dstev(A, Values, Vectors); > writes(Values); +6.4756286546948838E-01 +3.5470024748920901E+00 +8.6577669890059994E+00 +1.7147667670632423E+01 > afftab(Vectors); [ 0.939572 0.338755 - 0.04937 0.00337683] [ - 0.33114 0.86281 - 0.378064 0.0545279] [ 0.0852772 - 0.364803 - 0.855782 0.356769] [ - 0.0166639 0.0878831 0.349668 0.932594] >
Next: lapack_dsygv, Previous: lapack_dstev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dgeev(
<matrice reelle> A ,
<identificateur> VALUES ,
<identificateur> LVECTOR ,
<identificateur> RVECTOR)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice réelle A, qui peut ne pas être symétriques. Les valeurs propres sont stockées dans VALUES, le vecteur propre de gauche dans LVECTOR et le vecteur propre de droite dans RVECTOR.
Il résoud
A*RVECTOR=VALUES*RVECTOR et
LVECTOR**T*A=VALUES*LVECTOR**T
avec LVECTOR**T la matrice adjointe à LVECTOR
Pour plus d’informations, http://www.netlib.org/lapack/double/dgeev.f
> // exemple de la routine dgeev > _affc=1$ > A = matrixR[ 10, 6: 4, 12]$ > lapack_dgeev(A, Values, LVector, RVector)$ > writes(Values); +6.0000000000000000E+00 +1.6000000000000000E+01 > afftab(LVector); [ - 0.707107 - 0.5547] [ 0.707107 - 0.83205] > afftab(RVector); [ - 0.83205 - 0.707107] [ 0.5547 - 0.707107] >
Next: lapack_dggev, Previous: lapack_dgeev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dsygv(
<entier> ITYPE ,
<matrice reelle> A ,
<matrice reelle> B ,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’un problème de valeurs propres généralisées défini positif. A est symétrique, B est symétrique et définie positive. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
3 problèmes différents sont possibles:
Pour plus d’informations, http://www.netlib.org/lapack/double/dsygv.f
> // exemple avec B*A*X = (lambda)*X > _affc=1$ > B = matrixR[ 10, 0: 0, 10]$ > A = matrixR[ 451.27, 0: 0, 512.75]$ > lapack_dsygv(3, A, B, Values, Vectors); Vectors matrice reelle double-precision [ 1:2 , 1:2 ] > writes(Values); +4.5127000000000007E+03 +5.1275000000000009E+03 > afftab(Vectors); [ 3.16228 0] [ 0 3.16228]
Next: lapack_dgges, Previous: lapack_dsygv, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dggev(
<matrice reelle> A ,
<matrice reelle> B ,
<identificateur> VALUES ,
<identificateur> LVECTOR ,
<identificateur> RVECTOR)
Cette routine calcule les valeurs propres et les vecteurs propres d’un problème de valeurs propres généralisées défini positif. A ou B ne sont pas symétriques. Les valeurs propres sont stockées dans VALUES, le vecteur propre de gauche dans LVECTOR et le vecteur propre de droite dans RVECTOR.
Il résoud:
avec LVECTOR**H la matrice adjointe à LVECTOR
Pour plus d’informations, http://www.netlib.org/lapack/double/dggev.f
> // exemple de la routine dggev > _affc=1$ > A = matrixR[ 10, 6: 4, 12]$ > B = matrixR[ 8, 10: 0.3, 12]$ > lapack_dggev(A, B, Values, LVector, RVector)$ > writes(Values); +9.3655913978494620E-01 +3.9384647034270903E-01 +9.3655913978494620E-01 -3.9384647034270914E-01 > afftab(LVector); [(0.629444-i*0.320052) (0.629444+i*0.320052)] [(-0.704921-i*0.295079) (-0.704921+i*0.295079)] > afftab(RVector); [(0.7792-i*0.2208) (0.7792+i*0.2208)] [(-0.283744-i*0.56193) (-0.283744+i*0.56193)] >
Next: lapack_zheev, Previous: lapack_dggev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_dgges(
<matrice reelle> A ,
<matrice reelle> B ,
<identificateur> VALUES ,
<identificateur> S ,
<identificateur> T ,
<identificateur> VSL ,
<identificateur> VSR)
Cette routine calcule les valeurs propres, les formes de Schur et les matrices des vecteurs de Schur d’un système généralisé de matrices réelles A et B, qui peuvent ne pas être symétriques. Les valeurs propres sont stockées dans VALUES, la forme de Schur généralisée de A dans S, celle de B dans T, la matrice des vecteurs de Schur de gauche dans VSL et celle de droite dans VSR.
Il résoud la factorisation de Schur généralisée:
(A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )
avec VSR**T la matrice transposée à VSR
Pour plus d’informations, http://www.netlib.org/lapack/double/dgges.f
> // exemple de la routine dgges > _affc=1$ > A = matrixR[ 10, 6: 4, 12]$ > B = matrixR[ 8, 10: 0.3, 12]$ > lapack_dgges(A, B, Values, S, T, VSL, VSR)$ > writes(Values); +9.3655913978494620E-01 +3.9384647034270903E-01 +9.3655913978494620E-01 -3.9384647034270914E-01 > afftab(S); [ 15.3566 4.77834] [ - 3.02259 5.31087] > afftab(T); [ 16.6388 0] [ 0 5.58935] > afftab(VSL); [ 0.735209 0.677841] [ 0.677841 - 0.735209] > afftab(VSR); [ 0.365713 0.930728] [ 0.930728 - 0.365713] >
Next: lapack_zhbev, Previous: lapack_dgges, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_zheev(
<matrice complexe> A,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice A complexe hermitienne. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zheev.f
> // exemple de la routine zheev > _affc=1$ > A = matrixC[ 8+8*i, 8: 8, 8+8*i]$ > lapack_zheev(A, Values, Vectors); Vectors matrice complexe double-precision [ 1:2 , 1:2 ] > writes(Values); +0.0000000000000000E+00 +1.6000000000000000E+01 > afftab(Vectors); [ - 0.707107 0.707107] [ 0.707107 0.707107]
Next: lapack_zgeev, Previous: lapack_zheev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_zhbev(
<matrice complexe> A,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice bande A complexe hermitienne. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zhbev.f
> // exemple de la routine zhbev > _affc=1$ > A = matrixC[ 8+8*i, 15+i: 15-i, 8+8*i]$ > lapack_zheev(A, Values, Vectors); Vectors matrice complexe double-precision [ 1:2 , 1:2 ] > writes(Values); -7.0332963783729099E+00 +2.3033296378372910E+01 > afftab(Vectors); [(0.705541+i*0.047036) (0.705541+i*0.047036)] [ - 0.707107 0.707107] >
Next: lapack_zhegv, Previous: lapack_zhbev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_zgeev(
<matrice complexe> A ,
<identificateur> VALUES ,
<identificateur> LVECTOR ,
<identificateur> RVECTOR)
Cette routine calcule les valeurs propres et les vecteurs propres d’une matrice complexe A. Les valeurs propres sont stockées dans VALUES, le vecteur propre de gauche dans LVECTOR et le vecteur propre de droite dans RVECTOR.
Il résoud
A*RVECTOR=VALUES*RVECTOR et
LVECTOR**T*A=VALUES*LVECTOR**T
avec LVECTOR**T la matrice transposée (je pense très fortement plutôt adjointe) à LVECTOR
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zgeev.f
> //Fr exemple de la routine zgeev > _affc=1$ > A = matrixC[ 8, 0: 0, 8]$ > lapack_zgeev(A, Values, LV, RV); > writes(Values); +8.0000000000000000E+00 +0.0000000000000000E+00 +8.0000000000000000E+00 +0.0000000000000000E+00 > afftab(LV); [ 1 0] [ 0 1] > afftab(RV); [ 1 0] [ 0 1] >
Previous: lapack_zgeev, Up: Valeurs Propres et Vecteurs Propres [Contents][Index]
lapack_zhegv(
<entier> ITYPE ,
<matrice complexe> A ,
<matrice complexe> B ,
<identificateur> VALUES ,
<identificateur> VECTORS)
Cette routine calcule les valeurs propres et les vecteurs propres d’un problème de valeurs propres généralisées défini positif. A est hermitienne, B est hermitienne et définie positive. Les valeurs propres sont stockées dans VALUES, et les vecteurs propres dans VECTORS.
3 problèmes différents sont possibles:
Pour plus d’informations, http://www.netlib.org/lapack/complex16/zhegv.f
> // exemple de la routine zhegv > _affc=1$ > B = matrixC[ 10,i: -1*i, 10]$ > A = matrixC[ 451.27, 0: 0, 512.75]$ > lapack_zhegv(3, A, B, Values, Vectors); > afftab(Vectors); [(0+i*2.69134) (0+i*1.66033)] [ - 1.38287 2.84388] > writes(Values); +4.2492379742004214E+03 +5.3909620257995803E+03
Next: Utilitaire, Previous: Bibliotheques, Up: Top [Contents][Index]
• Analyse en frequence : | ||
• fft : | Transformee de Fourier. | |
• ifft : | Transformee de Fourier Inverse. | |
• integnum : | Integration numerique. | |
• integnumfcn : | Integration numerique de fonction externe. | |
• integral : | ||
• iternum : | Iteration. | |
• interpol : | Interpolation. | |
• Changement de coordonnees : |
Next: fft, Up: Traitement numerique [Contents][Index]
• naf : | ||
• naftab : | ||
• freqa : | ||
• freqareson : | ||
• sertrig : |
Next: naftab, Up: Analyse en frequence [Contents][Index]
naf(
KTABS,
fichiersource,
fichierresultat,
XH,
T0,
NTERM,
CX,
CY);
avec :
Elle effectue l’analyse en fréquence des données du fichier source et stocke les fréquences dans fichierresultat.sol. Elle utilise KTABS+1 données.
KTABS est arrondi à la plus proche valeur inférieure telle que KTABS = 6n avec n entier naturel positif.
Les paramètres utilisés sont stockés dans fichierresultat.par.
Les resultats intermédiaires sont stockés dans fichierresultat.prt si _naf_iprt
>=0.
Elle emploie les variables globales _naf_nulin
, _naf_iprt
, _naf_isec
, _naf_iw
, _naf_dtour
, _naf_icplx
.
Le fichier fichierresultat.sol contient:
Le fichier "tessin.out" contient des données sur 32996 lignes avec une ligne d'entete. tels que la colonne 2 contient la partie réelle des données. la colonne 3 contient la partie imaginaire des données. la première ligne du fichier est à ignorer. Le temps initial est 0 et le pas est de 0.01. Nous recherchons 10 frequences. Le fichier resultat à pour nom "tesnaf". > _naf_nulin=1; > naf(32996,tessin.out, tesnaf, 0.01, 0, 10, 2, 3); Le premier argument de naf n'est pas multiple de 6. Le premier argument de naf devient 32994. Les frequences trouvees sont sauves dans le fichier :tesnaf.sol Les paramètres employees sont sauves dans le fichier :tesnaf.par Le fichier tesnaf.par contient : NOMFPAR = tesnaf.par NOMFOUT = NOMFDAT = tessin.out NOMFSOL = tesnaf.sol DTOUR = 6. 83185307179586E+00 T0 = 0.000000000000000E+00 XH = 1.000000000000000E-02 KTABS = 32994 DNEPS = 1.000000000000000E+100 NTERM = 10 ICPLX = 1 IW = 1 ISEC = 1 NULIN = 1 ICX = 2 ICY = 3 IPRNAF = -1
Next: freqa, Previous: naf, Up: Analyse en frequence [Contents][Index]
naftab(
TX, TY, A, F, KTABS, XH, T0, NTERM);
naftab(
TX, TY, A, F, KTABS, XH, T0, NTERM, TRESX, TRESY);
naftab(
TX, TY, A, F, KTABS, XH, T0, NTERM, TRESX, TRESY, (
FMIN1, FMAX1, NTERM1)
,...);
avec :
Elle effectue l’analyse en fréquence des données du tableau (TX+i*TY) et stocke les fréquences dans F et les amplitudes complexes dans A.
KTABS est arrondi à la plus proche valeur inférieure telle que KTABS = 6n+1 avec n entier naturel positif.
Elle emploie les variables globales _naf_isec
, _naf_iw
, _naf_dtour
, _naf_icplx
.
elle recherche une approximation de TX+iTY sous la forme somme de l=0 à size(F) { A[l]*exp(i*F[l]*t) }
Dans ce cas, A est un vecteur numérique de complexes ( <vec. complexe> ).
Les triplets (FMINx, FMAXx, NTERMx) définissent une fenêtre. Seules les fréquences dans ces fenêtres sont recherchées.
Le fichier "tessin.out" contient des données sur 32998 lignes avec une ligne d'entete. tels que la colonne 2 contient la partie réelle des données. la colonne 3 contient la partie imaginaire des données. Le temps initial est 0 et le pas est de 0.01. Nous recherchons 10 frequences. > vnumR X,Y,F; vnumC A; read(tessin2.out, [1:32000],(X,2),(Y,3)); naftab(X,Y,A,F,32000,0.01, 0, 10); B=abs(A); Le premier argument de naf n'est pas multiple de 6. Le premier argument de naf devient 31998. CORRECTION DE IFR = 1 AMPLITUDE = 8.72192e-07 B Tableau de reels : nb reels =6 > writes(F,B,A); +9.999993149794888E-02 +1.000000E-01 +1.000E-01 +1.095970178673141E-06 -2.000000944035095E-01 +9.999999E-03 +9.999E-03 +1.312007532388499E-07 +3.000000832689856E-01 +1.000000E-03 +1.000E-03 -1.403292661135361E-08 -4.000000970924361E-01 +9.999995E-05 +9.999E-05 +1.695880029074994E-09 +4.999999805039361E-01 +1.000003E-05 +1.000E-05 +3.216502329016007E-11 -5.999999830866213E-01 +9.999979E-07 +9.999E-07 -1.796078221829677E-12 >
Next: freqareson, Previous: naftab, Up: Analyse en frequence [Contents][Index]
freqa(
TFREQ, TFREQREF, TABCOMBI, TINDIC, ORDREMAX, EPSILON, TFREQRESIDU)
avec :
Elle recherche pour chaque fréquence du tableau TFREQ une combinaison entière des fréquences fondamentales contenues dans TFREQREF avec une précision EPSILON et un ordre maximal de recherche ORDREMAX. Pour chaque fréquence de TFREQ, la recherche s’arrête dès qu’une combinaison est trouvée. La recherche s’effectue par ordre total croissant.
Si la combinaison est trouveé, alors
Si la combinaison n’est pas trouvée, alors
En sortie, TABCOMBI est un tableau de size(
TFREQREF)
tableaux de size(
TFREQ)
entiers,
TINDIC est un tableau de size(
TFREQ)
entiers (0/1),
<=
TFREQRESIDU est un tableau de size(
TFREQ)
réels.
En sortie, tous les éléments de TABCOMBI vérifient
1<=sum(abs(TABCOMBI[i][]))<=ORDREMAX.
> freqfond=1,5; > freqfond[1]=3.1354; > freqfond[2]=5.452; > freqfond[3]=7.888; > freqfond[4]=11.111; > freqfond[5]=19.777; > freq=1,5; > freq=freq*freqfond[1]+freq*freqfond[2]+freq*freqfond[3]+ > freq*freqfond[4]+freq*freqfond[5]; > freqa(freq,freqfond,tabcomb, tabind,20,1E-6, freqres); > %writesfreqa[[freq],[freqfond],[tabcomb],[tabind] , [freqres]]; > freqfond[1] = 15677/5000 > freqfond[2] = 1363/250 > freqfond[3] = 986/125 > freqfond[4] = 11111/1000 > freqfond[5] = 19777/1000 Frequence Frequence residuelle combinaison ------------------------------------------------------------------- 4.736340000000000E+01 +0.000000000000000E+00 1 1 1 1 1 9.472680000000000E+01 +0.000000000000000E+00 2 2 2 2 2 1.420902000000000E+02 +0.000000000000000E+00 3 3 3 3 3 1.894536000000000E+02 +0.000000000000000E+00 4 4 4 4 4 2.368170000000000E+02
Next: sertrig, Previous: freqa, Up: Analyse en frequence [Contents][Index]
freqareson(
FREQ, TFREQREF, TABCOMBI, ORDREMAX, EPSILON, TFREQRESIDU)
avec :
Elle recherche pour la fréquence FREQ toutes les combinaisons entières des fréquences fondamentales contenues dans TFREQREF avec une précision EPSILON et un ordre maximal de recherche ORDREMAX.
En sortie, pour chaque combinaison trouveé,
En sortie, TABCOMBI est un tableau de size(
TFREQREF)
tableaux d’entiers,
En sortie, tous les éléments de TABCOMBI vérifient
sum(abs(TABCOMBI[i][]))<=ORDREMAX.
>vnumR freqfond; >resize(freqfond,5); >freqfond[1]=3.1354; >freqfond[2]=5.452; >freqfond[3]=2*freqfond[3]; >freqfond[4]=11.111; >freqfond[5]=19.777; >freq=2*freqfond[1]+freqfond[2]-freqfond[3]+freqfond[4]-freqfond[5]; >freqareson(freq,freqfond,tabcomb, 8,1E-6, freqres); >writes("%+-g\t%+-g\t%+-g\t%+-g\t%+-g\n",tabcomb); +2 -1 +0 +1 -1 +2 +1 -1 +1 -1 +2 -3 +1 +1 -1
Previous: freqareson, Up: Analyse en frequence [Contents][Index]
sertrig(
<vec. complexe> TAMP, <vec. réel> TFREQ, <variable> VAR)
sertrig(
<vec. complexe> TAMP, <vec. réel> TFREQ, <variable> VAR, <réel> FACT )
avec :
Les tableaux TAMP et TFREQ doivent être de même taille.
Elle réalise la somme de : pour chaque élément j des tableaux : TAMP[j]*exp(i*TFREQ[j]*VARIABLE) ou pour chaque élément j des tableaux : TAMP[j]*exp(i*2*pi*TFREQ[j]*VARIABLE/FACT)
La partie exp(i*...) est représentée sous la forme d’une variable angulaire où l’argument est la fréquence et la phase est nulle. L’amplitude sera le coefficient de cette variable. Ces variables angulaires ont pour radical _Ex. Il y aura autant de variables angulaires créées qu’il y a de fréquences. La série contiendra autant de termes qu’il y a d’élément dans les tableaux.
Le F contient les frequences et le tableau A contient les amplitudes. > writes(F,A); +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 > s=sertrig(A,F,t); s(_EXt1,_EXt2,_EXt3,_EXt4,_EXt5,_EXt6) = (9.99997918710942E-07-i*1.79607822182968E-12)*_EXt6 + (1.00000311738477E-05+i*3.21650232901601E-11)*_EXt5 + (9.99999566953099E-05+i*1.69588002907499E-09)*_EXt4 + (0.00100000031488239-i*1.40329266113536E-08)*_EXt3 + (0.00999999996067906+i*1.3120075323885E-07)*_EXt2 + (0.100000000045618+i*1.09597017867314E-06)*_EXt1
Next: ifft, Previous: Analyse en frequence, Up: Traitement numerique [Contents][Index]
fft (
TX, TY, TAMP, TFREQ, XH, T0, DTOUR, IW)
avec :
Elle effectue la transformée de fourier rapide de TX+i*TY et stocke les amplitudes et fréquences déterminées dans les tableaux TAMP et TFREQ.
Elle ne retient que les "N" permiers éléments de TX et TY tel que "N" soit la plus grande puissance de 2 contenue dans la taille du tableau TX.
Remarque: TX et TY doivent avoir la même taille.
>vnumC z; vnumR freq; xin=vnumR[7.:5.:6.:9.]; yin=vnumR[0:0:0:0]; fft(xin,yin,z,freq,1,0,pi,0); writes(z,freq); > -2.500000000000000E-01 +0.000000000000000E+00 -1.570796326794897E+00 +2.499999999999993E-01 -1.000000000000000E+00 -7.853981633974483E-01 +6.750000000000000E+00 +0.000000000000000E+00 +0.000000000000000E+00 +2.500000000000007E-01 +1.000000000000000E+00 +7.853981633974483E-01 -2.500000000000000E-01 +0.000000000000000E+00 +1.570796326794897E+00
Next: integnum, Previous: fft, Up: Traitement numerique [Contents][Index]
ifft (
TAMP, TX, TY, XH, T0)
avec :
Elle effectue la transformée de fourier rapide inverse de TAMP et stocke le résultat dans TX+i*TY.
TAMP doit etre un tableau à 2**N+1 éléments. En sortie, TX et TY ont 2**N éléments.
>vnumC z; vnumR freq; xin=vnumR[7.:5.:6.:9.]; yin=vnumR[0:0:0:0]; fft(xin,yin,z,freq,1,0,pi,0); ifft(z,xout,yout,1,0); writes(xout,yout); > +7.000000000000000E+00 +0.000000000000000E+00 +5.000000000000000E+00 +0.000000000000000E+00 +6.000000000000000E+00 +0.000000000000000E+00 +9.000000000000000E+00 +0.000000000000000E+00
Next: integnumfcn, Previous: ifft, Up: Traitement numerique [Contents][Index]
integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, FICHIER,
{ REAL ,(
VAR1, SER1, VI1),
...},
{ COMPLEX ,(
VAR2, SER2, VI2),
...});
integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, FICHIER,
{ REAL ,(
VAR1, SER1, VI1),
...},
{ COMPLEX ,(
VAR2, SER2, VI2),
...},
);
avec :
Elle effectue l’intégration numérique des séries stockées dans les listes avec les valeurs initiales et stocke le résultat dans le fichier de résultat.
L’intégrateur utilisé dépend de la variable globale _integnum
(see _integnum).
Les équations sont des triplets de la variable derivée, de la série et de la valeur initiale.
Pour intégrer un système dépendant du temps , noté t
par exemple, il faut ajouter une équation au système sous la forme (t,1,0)
et utiliser la variable t
comme temps dans les autres équations du système.
Si RESTARTSTATE est spécifié mais n’existe pas, les conditions initiales utilisées sont celles du systèmes d’équations. Si RESTARTSTATE existe alors les conditions initiales utilisées sont celles contenues dans PREVSTATE et T0 est ignoré. A la fin de l’intégration, RESTARTSTATE est mis à jour. RESTARTSTATE permet un redémarrage de l’intégration. Il est possible de changer le pas d’intégration, selon l’intégrateur.
<tableau de vec. réel> = integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI,
{ REAL ,(
VAR1, SER1, VI1),
...},
{ COMPLEX ,(
VAR2, SER2, VI2),
...});
Tous les arguments sont identiques à la forme précédente, excepté FICHIER qui n’est pas présent.
Elle effectue l’intégration numérique des séries stockées dans les listes avec les valeurs initiales
et retourne le résultat dans un tableau de vecteurs numériques de réels.
L’intégrateur utilisé dépend de la variable globale _integnum
(see _integnum).
integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, FICHIER,
{ REAL ,(
TVAR1, TSER1, TVI1),
...},
{ COMPLEX ,(
TVAR2, TSER2, TVI2),
...});
avec :
Tous les arguments sont identiques à la première forme, excepté TVAR, TSER et TVI. Les équations sont des triplets de tableau de variables derivées, tableau de séries et tableau de valeurs initiales.
<tableau de vec. réel> = integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI,
{ REAL ,(
TVAR1, TSER1, TVI1),
...},
{ COMPLEX ,(
TVAR2, TSER2, TVI2),
...});
avec :
Tous les arguments sont identiques à la deuxième forme, excepté TVAR, TSER et TVI. Les équations sont des triplets de tableau de variables derivées, tableau de séries et tableau de valeurs initiales.
Nous souhaitons integrer le système : { dx/dt = -y , dy/dt= x } avec les valeurs initiales x=1 et y=0 entre 0 et 2*pi avec un pas de pi/10 et une précision de 1E-12. Le pas de l'integrateur sera pi/20 et le pas maximum sera pi/10. Les resultats seront stockes dans le fichier icossin.out La solution est : x = cos(t) et y = sin(t) >integnum(0,2*pi, pi/10, 1E-12, pi/10, pi/20, icossin.out, REAL, (x, -y, 1),(y,x, 0)); Le fichier icossin.out contient : time x y +0.000000000000000E+00 +1.000000000000000E+00 +0.000000000000000E+00 +3.141592653589793E-01 +9.510565162951542E-01 +3.090169943749471E-01 +6.283185307179586E-01 +8.090169943749489E-01 +5.877852522924729E-01 +9.424777960769379E-01 +5.877852522924752E-01 +8.090169943749478E-01 +1.256637061435917E+00 +3.090169943749500E-01 +9.510565162951550E-01 +1.570796326794897E+00 +2.567125951231441E-15 +1.000000000000003E+00 +1.884955592153876E+00 -3.090169943749455E-01 +9.510565162951576E-01 +2.199114857512855E+00 -5.877852522924724E-01 +8.090169943749527E-01 +2.513274122871834E+00 -8.090169943749485E-01 +5.877852522924791E-01 +2.827433388230814E+00 -9.510565162951568E-01 +3.090169943749536E-01 +3.141592653589793E+00 -1.000000000000005E+00 +5.403107187863445E-15 +3.455751918948772E+00 -9.510565162951610E-01 -3.090169943749436E-01 +3.769911184307752E+00 -8.090169943749564E-01 -5.877852522924716E-01 +4.084070449666731E+00 -5.877852522924830E-01 -8.090169943749488E-01 +4.398229715025710E+00 -3.090169943749571E-01 -9.510565162951583E-01 +4.712388980384690E+00 -8.301722685091165E-15 -1.000000000000008E+00 +5.026548245743669E+00 +3.090169943749417E-01 -9.510565162951644E-01 +5.340707511102648E+00 +5.877852522924709E-01 -8.090169943749602E-01 +5.654866776461628E+00 +8.090169943749494E-01 -5.877852522924867E-01 +5.969026041820607E+00 +9.510565162951601E-01 -3.090169943749604E-01 +6.283185307179586E+00 +1.000000000000011E+00 -1.085302505620242E-14
> // Au lieu de stocker le resultat dans un fichier, > // on stocke le resultat dans un tableau de vecteurs q. > p = pi/10; p = 0.3141592653589793 > q = integnum(0, 2*pi, p, 1E-12, p, p/2,REAL,(x,-y,1),(y,x,0)); q [1:3 ] nb elements = 3 > stat(q); Tableau de series q [ 1:3 ] liste des elements du tableau : q [ 1 ] = Vecteur numerique q de 21 reels double-precision. taille en octets du tableau: 168 q [ 2 ] = Vecteur numerique q de 21 reels double-precision. taille en octets du tableau: 168 q [ 3 ] = Vecteur numerique q de 21 reels double-precision. taille en octets du tableau: 168 > writes(q); +0.0000000000000000E+00 +1.0000000000000000E+00 +0.0000000000000000E+00 +3.1415926535897931E-01 +9.5105651629515420E-01 +3.0901699437494706E-01 +6.2831853071795862E-01 +8.0901699437494889E-01 +5.8778525229247280E-01 +9.4247779607693793E-01 +5.8778525229247525E-01 +8.0901699437494767E-01 +1.2566370614359172E+00 +3.0901699437495000E-01 +9.5105651629515486E-01 +1.5707963267948966E+00 +2.6090241078691179E-15 +1.0000000000000027E+00 +1.8849555921538759E+00 -3.0901699437494545E-01 +9.5105651629515764E-01 +2.1991148575128552E+00 -5.8778525229247236E-01 +8.0901699437495267E-01 +2.5132741228718345E+00 -8.0901699437494845E-01 +5.8778525229247902E-01 +2.8274333882308138E+00 -9.5105651629515675E-01 +3.0901699437495334E-01 +3.1415926535897931E+00 -1.0000000000000053E+00 +5.1625370645069779E-15 +3.4557519189487724E+00 -9.5105651629516097E-01 -3.0901699437494379E-01 +3.7699111843077517E+00 -8.0901699437495633E-01 -5.8778525229247180E-01 +4.0840704496667311E+00 -5.8778525229248280E-01 -8.0901699437494901E-01 +4.3982297150257104E+00 -3.0901699437495678E-01 -9.5105651629515842E-01 +4.7123889803846897E+00 -7.9658502016854982E-15 -1.0000000000000080E+00 +5.0265482457436690E+00 +3.0901699437494201E-01 -9.5105651629516430E-01 +5.3407075111026483E+00 +5.8778525229247114E-01 -8.0901699437496011E-01 +5.6548667764616276E+00 +8.0901699437494945E-01 -5.8778525229248657E-01 +5.9690260418206069E+00 +9.5105651629516008E-01 -3.0901699437496022E-01 +6.2831853071795862E+00 +1.0000000000000107E+00 -1.0685896612017132E-14 >
integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, FICHIER, MACRO, VI );
avec :
Elle effectue l’intégration numérique du système défini par la macro avec le vecteur de valeurs initiales et stocke le résultat dans le fichier de résultat.
L’intégrateur utilisé dépend de la variable globale _integnum
(see _integnum).
La macro doit être définie de la façon suivante : macro nom [N,T,Y,DY] {... }
Elle effectuera l’evaluation de la dérivée de Y au temps T ( DY=dY/dt=f(Y,T) )
Cette macro sera appelée avec les arguments suivants : avec :
La macro peut accéder à des identificateurs globaux.
<tableau de vec. réel> = integnum(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, MACRO, VI );
Tous les arguments sont identiques à la forme précédente, excepté FICHIER qui n’est pas présent.
Elle effectue l’intégration numérique du système défini par la macro avec le vecteur de valeurs initiales et retourne le résultat dans un tableau de vecteurs numériques de réels.
L’intégrateur utilisé dépend de la variable globale _integnum
(see _integnum).
Nous souhaitons integrer le système : { dx/dt = -y , dy/dt= x } avec les valeurs initiales x=1 et y=0 entre 0 et 2*pi avec un pas de pi/10 et une précision de 1E-12. Le pas de l'integrateur sera pi/20 et le pas maximum sera pi/10. Les resultats seront stockes dans le fichier icossin.out La solution est : x = cos(t) et y = sin(t) macro fcn [N,X,Y,DY] { DY[1]=-Y[2]$ DY[2]=Y[1]$ }; vnumR v; resize(v,2); v[1]=1; v[2]=0; integnum(0,2*pi, pi/10, 1E-12, pi/10, pi/20, output.dat, fcn, v); Le fichier icossin.out contient : time x y +0.000000000000000E+00 +1.000000000000000E+00 +0.000000000000000E+00 +3.141592653589793E-01 +9.510565162951542E-01 +3.090169943749471E-01 +6.283185307179586E-01 +8.090169943749489E-01 +5.877852522924729E-01 +9.424777960769379E-01 +5.877852522924752E-01 +8.090169943749478E-01 +1.256637061435917E+00 +3.090169943749500E-01 +9.510565162951550E-01 +1.570796326794897E+00 +2.567125951231441E-15 +1.000000000000003E+00 +1.884955592153876E+00 -3.090169943749455E-01 +9.510565162951576E-01 +2.199114857512855E+00 -5.877852522924724E-01 +8.090169943749527E-01 +2.513274122871834E+00 -8.090169943749485E-01 +5.877852522924791E-01 +2.827433388230814E+00 -9.510565162951568E-01 +3.090169943749536E-01 +3.141592653589793E+00 -1.000000000000005E+00 +5.403107187863445E-15 +3.455751918948772E+00 -9.510565162951610E-01 -3.090169943749436E-01 +3.769911184307752E+00 -8.090169943749564E-01 -5.877852522924716E-01 +4.084070449666731E+00 -5.877852522924830E-01 -8.090169943749488E-01 +4.398229715025710E+00 -3.090169943749571E-01 -9.510565162951583E-01 +4.712388980384690E+00 -8.301722685091165E-15 -1.000000000000008E+00 +5.026548245743669E+00 +3.090169943749417E-01 -9.510565162951644E-01 +5.340707511102648E+00 +5.877852522924709E-01 -8.090169943749602E-01 +5.654866776461628E+00 +8.090169943749494E-01 -5.877852522924867E-01 +5.969026041820607E+00 +9.510565162951601E-01 -3.090169943749604E-01 +6.283185307179586E+00 +1.000000000000011E+00 -1.085302505620242E-14 Au lieu de stocker le resultat dans un fichier, on stocke le resultat dans un tableau de vecteurs q. q = integnum(0,2*pi, pi/10, 1E-12, pi/10, pi/20, fcn, v);
Next: integral, Previous: integnum, Up: Traitement numerique [Contents][Index]
integnumfcn(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, FICHIER, LIBRAIRIE,
{ REAL ,(
VAR1, VI1),
...},
{ COMPLEX ,(
VAR2, VI2),
...});
avec :
Elle effectue l’intégration numérique de la fonction integfcn localisée dans la librairie dynamique externe LIBRAIRIE en utilisant les valeurs initiales et stocke le résultat dans le fichier de résultat.
L’intégrateur utilisé dépend de la variable globale _integnum
(see _integnum).
La variable derivée ne sert qu’à mettre un nom dans le fichier de résultat.
<tableau de vec. réel> = integnumfcn(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, LIBRAIRIE,
{ REAL ,(
VAR1, VI1),
...},
{ COMPLEX ,(
VAR2, VI2),
...});
Tous les arguments sont identiques à la forme précédente, excepté FICHIER qui n’est pas présent.
Elle effectue l’intégration numérique de la fonction integfcn localisée dans la librairie dynamique externe LIBRAIRIE en utilisant les valeurs initiales
et retourne le résultat dans un tableau de vecteurs numériques de réels.
L’intégrateur utilisé dépend de la variable globale _integnum
(see _integnum).
Le nom des variables est ignorée par cette fonction.
Les fonctions de la librairie dynamique doivent avoir le prototype suivant :
Cette fonction est appelée avant le démarrage de l’intégration.
Cette fonction doit initialiser dy tel que dy/dt=f(y,t) et doit retourner 1.
Cette fonction est appelée à la fin de l’intégration.
Pour créer une librairie dynamique à partir d’un fichier source écrit en langage C, il faut généralement le compiler de la façon suivante :
La librairie libfcn.(so,dylib,dll) contient le résultat de la compilation du fichier source fcn.c suivant : #include <math.h> void integfcnbegin(const int * neq, void **data) { } int integfcn(const int * neq, const double *x, const double *y, double *yp, void* data) { yp[0] = sqrt(1.E0+cos(y[1])); yp[1] = y[0]+y[1]; return 1; } void integfcnend(void *data) { } Pour intégrer le système { dx/dt = sqrt(1+cos(y)) , dy/dt = x+y } avec comme condition initiale x=1 et y=0 et pour stocker le résultat dans le fichier output.dat : > integnumfcn(0,2*pi, pi/10, 1E-12, pi/10, pi/20, output.dat, libfcn, REAL, (x, 1),(y,0)); Pour intégrer le même système en stockant le resultat dans le tableau de tableaux numériques q : > q = integnumfcn(0,2*pi, pi/10, 1E-12, pi/10, pi/20, libfcn, REAL, (x, 1),(y,0));
integnumfcn(
T0, TF, PAS, PREC, DOPRIMAX, PASDOPRI, FICHIER, LIBRAIRIE,
{ REAL ,(
VAR1, VI1),
...},
{ COMPLEX ,(
VAR2, VI2),
...}
,
evalnum, REAL
,TB, TB_0, TB_PAS,TF, TF_0, TF_PAS )
avec :
Elle effectue l’intégration numérique de la fonction integfcn localisée dans la librairie dynamique externe LIBRAIRIE en utilisant les valeurs initiales et les données tabulées. Elle stocke le résultat dans le fichier de résultat.
Elle fournit à la fonction integfcn les données tabulées TB ou TF pour le temps auquel est évalué le second membre. Par exemple, si le second membre doit être évalué au temps t, alors elle extrait de TB ou TF les données corespondantes au temps t. Pour le démarrage de la méthode d’ADAMS, elle interpole les données de TB et fournit ces valeurs interpolées à la fonction integfcn. Pour les temps entre T0 et TF, elle extrait directement les données sans interpolation. Par exemple, si TB et TF sont des tableaux de 4 vecteurs de 1000 réels, la fonction integfcn sera appelée avec un vecteur de 4 nombres réels.
L’intégrateur requiert que la variable globale _integnum
doit être égale à ADAMS (see _integnum) .
Elle requiert que TB_0 et TF_0 doivent être égaux à T0.
De plus, PAS doit être un multiple de TB_PAS et TF_PAS.
La variable derivée ne sert qu’à mettre un nom dans le fichier de résultat.
Les fonctions de la librairie dynamique doivent avoir le prototype suivant :
Cette fonction est appelée avant le démarrage de l’intégration.
Cette fonction doit initialiser dy tel que dy/dt=f(y,tabdata(t),t) et doit retourner 1.
Cette fonction est appelée à la fin de l’intégration.
Pour créer une librairie dynamique à partir d’un fichier source écrit en langage C, il faut généralement le compiler de la façon suivante :
La librairie libfcn.(so,dylib,dll) contient le résultat de la compilation du fichier source fcn.c suivant : #include <math.h> void integfcnbegin(const int * neq, void **data) { } int integfcn(const int * neq, const double *x, const double *y, double *yp, const double *tabdata) { yp[0] = sqrt(1.E0+cos(y[1])*tabdata[0]); yp[1] = y[0]*tabdata[1]+y[1]; return 1; } void integfcnend(void *data) { } Pour intégrer le système { dx/dt = sqrt(1+cos(y)*sin(a*t)) , dy/dt = cos(b*t)*x+y } avec a=0.5, b=0.9 et comme condition initiale x=1 et y=0 et pour stocker le résultat dans le fichier output.dat : > t0 = 0; > tf = 2*pi; > pas=pi/10; > vnumR tabb[1:2], tabf[1:2]; > t=-30*pas,t0,pas; > a=0.5; b=0.9; > tb[1]=sin(a*t); tb[2]=cos(b*t); > t=t0, tf+2*pas,pas; > tf[1]=sin(a*t); tf[2]=cos(b*t); > > integnumfcn(t0,tf, pas, 1E-12,pas, pas/2, output.dat, libfcn, REAL, (x, 1),(y,0), evalnum, REAL, tb, t0, -pas, tf, t0, pas);
Next: iternum, Previous: integnumfcn, Up: Traitement numerique [Contents][Index]
integral(
<vec. num.> TY, <réel> XH, <entier> ORDRE, <identificateur> N)
integral(
<vec. num.> TY, <réel> XH, <entier> ORDRE, <identificateur> N, "kahan" )
avec :
Elle calcule et retourne l’intégrale, en utilisant la formule de Newton-Cotes, d’ordre ORDRE, du vecteur numérique TY dont les éléments sont espacés de XH.
Elle retourne dans N l’indice du dernier élément utilisé pour calculer l’intégrale. La valeur de N est donnée par : N=int((size(TY)-1)/ORDRE)*ORDRE+1
Si l’option "kahan" est mise, la sommation est effectuée en utilisant la méthode de Kahan (sommation compensée).
Référence : Pour les formules de Newton-Cotes, voir le livre "Introduction to Numerical Analysis", chapitre integration, de Stoer et Burlisch.
Kahan, William (January 1965), "Further remarks on reducing truncation errors", Communications of the ACM 8 (1): 40, http://dx.doi.org/10.1145%2F363707.363723
> t=0,10000; t Tableau de reels : nb reels =10001 > t=t*pi/10000; > X=-cos(t)+1; > for j=1 to 6 { s=integral(sin(t),pi/10000,j,N); delta=s-X[N];}; s = 1.99999998355066 delta = -1.64493392240672E-08 s = 1.99999999999999 delta = -7.54951656745106E-15 s = 1.99999995065198 delta = 5.55111512312578E-15 s = 2 delta = -4.44089209850063E-16 s = 2 delta = 8.88178419700125E-16 s = 1.99999921043176 delta = 5.77315972805081E-15
Next: interpol, Previous: integral, Up: Traitement numerique [Contents][Index]
iternum(
nbiteration, passortie, fichierresultat ,
REAL ,(
variable1, serie1, valeurinitiale1),...
},
COMPLEX ,(
variable2, serie2, valeurinitiale2),...
});
avec :
Elle effectue nbiteration iterations sur les équations spécifiées dans les listes. Elle écrit dans le fichier de résultat tous les passortie itérations.
Les équations sont des triplets de la variable itérée, de la série et de sa valeur initiale.
La valeur initiale peut être un nombre complexe ou réel.
> iternum(10,1,sortie.txt,REAL,(un,un+2,3)); Le fichier "sortie.txt" contient : time un +0.000000000000000E+00 +3.000000000000000E+00 1 +5.000000000000000E+00 2 +7.000000000000000E+00 3 +9.000000000000000E+00 4 +1.100000000000000E+01 5 +1.300000000000000E+01 6 +1.500000000000000E+01 7 +1.700000000000000E+01 8 +1.900000000000000E+01 9 +2.100000000000000E+01 10 +2.300000000000000E+01 > iternum(5,1,sortie.txt,REAL,(vn,un-1,3),(un,vn+un,2)); Le fichier "sortie2.txt" contient : time vn un +0.000000000000000E+00 +3.000000000000000E+00 +2.000000000000000E+00 1 +1.000000000000000E+00 +5.000000000000000E+00 2 +4.000000000000000E+00 +6.000000000000000E+00 3 +5.000000000000000E+00 +1.000000000000000E+01 4 +9.000000000000000E+00 +1.500000000000000E+01 5 +1.400000000000000E+01 +2.400000000000000E+01
Next: Changement de coordonnees, Previous: iternum, Up: Traitement numerique [Contents][Index]
interpol(LINEAR ,
TX, DTX, TY)
interpol(QUADRATIC ,
TX, DTX, TY)
interpol(SPLINE ,
TX, DTX, TY)
interpol(HERMITE ,
TX, DTX, TY, DEG)
avec :
Elle effectue l’interpolation linéaire, spline, ou quadratique ou d’hermite. Elle retourne un vecteur de réels des valeurs interpolées aux temps TY à partir des données (TX, DTX).
Remarque : Elle suppose que TX et TY sont triés par ordre croissant ou décroissant.
Si TY[i] n’appartient pas à l’intervalle [ TX[0], TX[size(TX)] ], alors DTY[i] est extrapolé.
L’algorithme de l’interpolation d’hermite est décrite dans le livre de Stoer et Burlish, 1993, "Introduction to Numerical Analysis, Chap 2, pages 52-57".
> x1=0,2*pi,2*pi/59; > x2=0,3,0.5; > sl=interpol(LINEAR,x1,cos(x1),x2); > writes("%.2E %.4E %.4E\n",x2, cos(x2), sl); 0.00E+00 1.0000E+00 1.0000E+00 5.00E-01 8.7758E-01 8.7652E-01 1.00E+00 5.4030E-01 5.3958E-01 1.50E+00 7.0737E-02 7.0719E-02 2.00E+00 -4.1615E-01 -4.1576E-01 2.50E+00 -8.0114E-01 -8.0001E-01 3.00E+00 -9.8999E-01 -9.8920E-01
Previous: interpol, Up: Traitement numerique [Contents][Index]
• ell_to_xyz : | ||
• xyz_to_ell : |
Next: xyz_to_ell, Up: Changement de coordonnees [Contents][Index]
ell_to_xyz(
ELL, MU, X, XP );
avec :
Elle convertit les éléments elliptiques ELL en positions X et vitesses XP.
/* calcul d'une seule valeur */ GM= 0.2959122082855911d-03; mu = GM*1.05; n=2*pi/221.6; varpi = 138*pi/180; vnumR ell[1:6]; resize(ell,1); ell[1][1] = (mu/n**2)**(1./3.); ell[2][1] = varpi; ell[3][1] = 0.54*cos(varpi); ell[4][1] = 0.54*sin(varpi); ell[5][1] = 0.0; ell[6][1] = 0.0; ell_to_xyz(ell,mu,x,xp); writes(x); writes(xp);
/* calcul de plusieurs valeurs contenues dans un fichier */ mu = 1; vnumR ell[1:6]; read(file1,ell); ell_to_xyz(ell,mu,x,xp); writes(x); writes(xp);
Previous: ell_to_xyz, Up: Changement de coordonnees [Contents][Index]
xyz_to_ell(
X, XP, MU, ELL );
avec :
Elle convertit les positions X et vitesses XP en éléments elliptiques ELL.
mu = 1; vnumR x[1:3],xp[1:3]; read(file2,x,xp); xyz_to_ell(x,xp,mu,ell); writes(ell);
Next: Index, Previous: Traitement numerique, Up: Top [Contents][Index]
• aide : | ||
• sortie : | ||
• cls : | ||
• msg : | ||
• error : | ||
• try : | ||
• pause : | ||
• delete : | ||
• include : | ||
• reset : | ||
• @@ : | ||
• vartrip : | ||
• bilan : | ||
• stat : | ||
• save_env : | ||
• rest_env : | ||
• random : | ||
• nameof : | ||
• typeof : | ||
• file_fullname : | ||
• Temps d execution : | ||
• Appel au shell : |
Next: sortie, Up: Utilitaire [Contents][Index]
help;
?;
Elle affiche une aide.
Sous Unix et MacOS X, le programmes d’aide utilise le logiciel info (fourni en particulier avec Texinfo) pour afficher l’aide. Sous Windows, le fichier d’aide au format chm est affiché.
help <motreserve>;
? <motreserve>;
Elle affiche l’aide du manuel de référence pour le mot réservé de TRIP. Cette fonction appelle le programme info (fourni en particulier avec Texinfo) sous Unix et MacOS X.
> ? vartrip;
Next: cls, Previous: aide, Up: Utilitaire [Contents][Index]
quit;
exit;
Cette commande arrête l’exécution de trip.
Next: pause, Previous: sortie, Up: Utilitaire [Contents][Index]
cls;
Elle efface l’écran en cours (identique à la commande clear sous UNIX).
Next: msg, Previous: cls, Up: Utilitaire [Contents][Index]
pause;
Cette commande affiche un message et attend la frappe de la touche d’une touche. Si l’utilisateur tape RET alors l’exécution continue. Si l’utilisateur tape q+RET ou e+RET alors l’exécution s’arrete immédiatemment pour retourner au prompt.
pause(
<entier> x);
Cette commande suspend l’excécution de TRIP pendant x secondes.
> for j=1 to 3 { j; pause; time_s; pause(2); time_t; }; 1 Appuyez sur la touche 'return' pour continuer ou la touche 'q' ou 'e' pour revenir au prompt ... 02.000s 2 Appuyez sur la touche 'return' pour continuer ou la touche 'q' ou 'e' pour revenir au prompt ... 02.000s 3 Appuyez sur la touche 'return' pour continuer ou la touche 'q' ou 'e' pour revenir au prompt ... 02.000s
Next: error, Previous: pause, Up: Utilitaire [Contents][Index]
msg
<chaine> ;
msg(
<chaine> textformat);
Elle affiche le texte sans aucun formatage fourni à l’ecran, ce qui est utile pour les commentaires.
Le texte doit être une chaine ou un texte entre guillemets. Le texte peut être sur plusieurs lignes.
msg(
<chaine> textformat,
<réel> x,
... );
Elle affiche à l’ecran le texte formaté 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 (see str, 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.
En mode numérique NUMRATMP seulement, les entiers ou les rationnels sont d’abord convertis en nombres réels double-précision avant l’affichage si le format est ’%g’, ’%e’ ou ’%f’. Si le format est ’%d’ ou ’%i’, les entiers ou les rationnels sont écrits sans conversion.
La fonction msg
(see msg) a un comportement similaire mais écrit le résultat dans une chaine de caract ‘eres.
> file="fichier1.dat"$ > msg"écriture du fichier "+file; écriture du fichier fichier1.dat > msg "je vais faire un guillemet : ""cette chaine est encadre par des guillemets""."; je vais faire un guillemet : "cette chaine est encadre par des guillemets". > msg("pi=%g pi=%.8E\n",pi,pi); pi=3.14159 pi=3.14159265E+00
Next: try, Previous: msg, Up: Utilitaire [Contents][Index]
error(
<chaine> textformat);
Elle génère une erreur en affichant le texte sans aucun formatage fourni à l’ecran.
Le texte doit être une chaine ou un texte entre guillemets. Le texte peut être sur plusieurs lignes.
> x=2; x = 2 > if (x==2) then { error("erreur : x=2"); }; TRIP[ 3 ] : erreur : x=2 Commande :'if (x==2) then { error("erreur : x=2"); };' ^^^^^^^^^^^^^^^^^^^^^^
Next: delete, Previous: error, Up: Utilitaire [Contents][Index]
try
{
<corps> bodytry }
catch {
<corps> bodycatch };
Normalement, elle exécute toutes les instructions de bodytry. Si une erreur se produit pendant cette exécution, alors elle ignore les instructions restantes de bodytry puis elle exécute les instructions de bodycatch.
Si la variable _info est égale à on
, alors un message d’avertissement s’affiche lorsqu’une erreur se produit pendant l’exécution de bodytry.
Si la variable _info est égale à off
, alors aucun message d’avertissement ne s’affiche lorsqu’une erreur se produit pendant l’exécution de bodytry.
Si une erreur se produit pendant l’exécution des instructions de bodycatch alors une erreur est générée. Cette erreur peut être interceptée si la section try-catch est contenue dans une autre section try-catch.
Il est possible d’imbriquer une section try-catch au sein des instructions bodytry ou de bodycatch.
> // affiche un message mais poursuit l'execution > _info on; _info on > b = 0; b = 0 > q = 2; q = 2 > try { s = "invalid"+q; b = 2; } catch { b = 1; }; TRIP[ 1 ] : Addition impossible Commande :'try { s = "invalid"+q; b = 2; } catch { b = 1; };' ^^^^^^^^^^^ Information : Poursuite de l'execution (instruction catch) b = 1 > > // n'affiche pas de message mais poursuit l'execution > _info off; _info off > b = 0; b = 0 > q = 2; q = 2 > try { s = "invalid"+q; b = 2; } catch { b = 1; }; b = 1 >
Next: reset, Previous: try, Up: Utilitaire [Contents][Index]
delete(
<identificateur> );
Elle supprime tout identificateur (série, variable, troncature, tableau, ...).
Remarque :
> file="fichier1.dat"; file = "fichier1.dat" > X=expi(x,1,0); 1*X > delete(file); > delete(x); La variable angulaire X est convertie en variable polynomiale.
Next: include, Previous: delete, Up: Utilitaire [Contents][Index]
reset;
Elle réinitialise complètement TRIP en remettant toutes les variables globales aux valeurs par défaut et elle supprime tous les identificateurs de la mémoire.
Next: resetinclude, Previous: reset, Up: Utilitaire [Contents][Index]
include
<nom fichier> ;
include
<chaine> ;
Elle charge le fichier TRIP "fichier" et l’exécute.
Ce fichier doit se trouver dans le répertoire courant ou dans le répertoire spécifié par la variable _path
.
Le fichier peut posséder une extension quelconque. L’extension recommandée étant .t
.
Remarque : si le fichier est un identificateur de type chaine, alors elle charge le fichier dont le nom est le contenu de cette chaine.
>include ellip; >include fct.t; > file="fperplanumH"; file = "fperplanumH" > include file; /*exécute le fichier "fperplanumH" */
Next: vartrip, Previous: include, Up: Utilitaire [Contents][Index]
@@;
Elle réinitialise TRIP puis charge et réexécute le dernier fichier exécuté par la commande include
.
Next: bilan, Previous: resetinclude, Up: Utilitaire [Contents][Index]
vartrip;
Elle affiche l’etat des variables globales de TRIP.
> vartrip; Etat des variables globales de Trip : _affc = 6 _affdist = 0 _affhomog = 0 _echo = 0 _path = /exemples/ _history = /unixfiles/ _hist = ON _naf_iprt = -1 _naf_icplx = 1 _naf_iw = 1 _naf_isec = 1 _naf_dtour = 6.283185307179586E+00 _naf_nulin = 1 _naf_tol = 1.000000000000000E-10 _time = OFF _comment = OFF _affvar = ( )
Next: stat, Previous: vartrip, Up: Utilitaire [Contents][Index]
bilan;
Elle liste toutes les identificateurs présents en mémoire en indiquant leur type:
SERIE | l’identificateur représente une série. |
VARIABLE | l’identificateur est une variable. |
CONST | l’identificateur est une constante. |
MATRIXR | l’identificateur est une matrice numérique de réels. |
MATRIXC | l’identificateur est une matrice numérique de complexes. |
TAB | l’identificateur est un tableau. |
TABVAR | l’identificateur est un tableau de variables. |
VNUMR | l’identificateur est un vecteur numérique de réels. |
VNUMC | l’identificateur est un vecteur numérique de complexes. |
STRING | l’identificateur est une chaine de caractères. |
EXTERNAL STRUCTURE | l’identificateur est une structure externe. |
FILE | l’identificateur est un fichier. |
REMOTE OBJECT | l’identificateur est un objet distant stocké sur un serveur SCSCP. |
SCSCP CLIENT | l’identificateur est une connexion à un serveur SCSCP. |
bilan mem;
Elle liste pour chaque série ou tableau de série la place occupée en mémoire et le nombre de termes.
Le nombre total de termes et la mémoire totale occupée par ces séries sont également affichés.
> bilan; A VAR ASR SERIE ASRp SERIE RSA SERIE X VAR _AsR SERIE _CosE SERIE _Expiv SERIE _RsA SERIE _RsASinv SERIE _SinE SERIE e VAR ep VAR g VAR ga VAR lp VAR x VAR > bilan mem; Nom Memoire (octets) Nb de termes -------------------- -------------------- -------------------- ASR 1704 64 ASRp 1704 64 RSA 2136 81 _AsR 1704 64 _CosE 2112 80 _Expiv 1728 64 _RsA 2136 81 _RsACosv 2112 80 _RsAExpiv 1728 64 _RsASinv 2112 80 _SinE 2112 80 -------------------- -------------------- -------------------- 21288 802
Next: save_env, Previous: bilan, Up: Utilitaire [Contents][Index]
stat;
Elle liste tous les identificateurs présents en mémoire. Elle les ordonne par leur type. Pour chaque identificateur, elle affiche une brv`e information. Pour les séries, elle affiche leur contenue.
> S = (1+x+y)**2$ > vnumR R$ > vnumC C$ > dim T[1:2]$ > stat; Bilan des operations : Series : S(x,y) = 1 + 2*y + 1*y**2 + 2*x + 2*x*y + 1*x**2 Variables : Variable x type : 2 ordres : 2 2 2 2 dependances : variables dependant de celle-ci : Variable y type : 2 ordres : 3 3 3 3 dependances : variables dependant de celle-ci : Tableaux de series : T [1:2 ] nb elements = 2 Tableaux de reels double-precision : Vecteur numerique R de 0 reels double-precision. Tableaux de complexes double-precision : Vecteur numerique C de 0 complexes double-precision. >
stat(
<identificateur> );
stat(
<identificateur> , "puismin" );
stat(
<identificateur> , "puismax" );
stat(
<identificateur> , "puismin" , "puismax" );
Suivant le type d’identificateur, elle donne les informations sur le nombre de termes et l’espace occupé par l’identificateur.
Si l’option "puismin" est mise, elle donne le degré le plus bas d’une série par rapport à chaque variable.
Si l’option "puismax" est mise, elle donne le degré le plus élevé d’une série par rapport à chaque variable.
> s = (1+x+y)**2$ > stat(s); serie s ( x , y ) nombre de variables : 2 taille du descripteur : 96 octets nombre de termes : 6 taille : 608 octets > stat(s,"puismin","puismax"); serie s ( x , y ) nombre de variables : 2 taille du descripteur : 96 octets nombre de termes : 6 taille : 608 octets puismin : x ^ 0 , y ^ 0 puismax : x ^ 2 , y ^ 2
Next: rest_env, Previous: stat, Up: Utilitaire [Contents][Index]
save_env;
Elle sauvegarde l’état des variables globales TRIP en utilisant un mécanisme de pile.
> _mode; _mode = POLP > save_env; > _mode=POLH; _mode = POLH > rest_env; > _mode; _mode = POLP
Next: random, Previous: save_env, Up: Utilitaire [Contents][Index]
rest_env;
Elle restaure l’état des variables globales TRIP sauvegardées par save_env
en utilisant un mécanisme de pile.
> _path="/users/"; _path = /users/ > save_env; > _path="/users/toto/"; _path = /users/toto/ > /*instructions utilisant le chemin specifique */; > rest_env; > _path; _path = /users/
Next: nameof, Previous: rest_env, Up: Utilitaire [Contents][Index]
random(
<entier> x)
Elle retourne un nombre entier aléatoire compris entre 0 et x-1.
> random(10); 1 > random(10); 7 > random(10); 0 > random(10); 9 > random(10); 8
Next: typeof, Previous: random, Up: Utilitaire [Contents][Index]
nameof(
<identificateur> x)
Elle retourne sous la forme d’une chaine le nom de l’objet.
Si l’objet est une expression, alors la chaine vide "" est retournée.
> c=3$ > n1= nameof(c); n1 = "c" > s="abcde"$ > n2 = nameof(s); n2 = "s" >
Next: file_fullname, Previous: nameof, Up: Utilitaire [Contents][Index]
typeof(
<identificateur> x)
Elle retourne sous la forme d’une chaine le type de l’objet.
Les chaines retournees sont decrites dans la commande bilan
(see bilan).
Si l’objet n’existe pas, alors la chaine vide "" est retournée.
> typeof(2); "CONST" > typeof(1+x); "SERIE" > t=1,10; t Vecteur de reels double-precision : nb reels =10 > if (typeof(t)=="VNUMR") then { stat(t); }; Vecteur numerique t de 10 reels double-precision. taille en octets du tableau: 80 >
Next: Temps d execution, Previous: typeof, Up: Utilitaire [Contents][Index]
file_fullname(
<chaine> name)
Elle construit un nom de fichier avec un chemin absolu. Toutes les utilisations ultérieures de la chaine retournée vont ignorer la variable _path.
> _path; _path = /users/guest/data/ > vnumR t; > fn=file_fullname("/tmp/mydata.txt"); fn = nom de fichier '/tmp/mydata.txt' > read(fn,t);
Next: Appel au shell, Previous: file_fullname, Up: Utilitaire [Contents][Index]
• time_s: | ||
• time_t: | ||
• time_l: |
Next: time_l, Up: Temps d execution [Contents][Index]
time_s;
Elle initialise le temps de départ pour le calcul des fonctions time_l
et time_t
.
Next: time_t, Previous: time_s, Up: Temps d execution [Contents][Index]
time_l;
Elle affiche le temps CPU total en mode utilisateur consommé, le temps total écoulé et le temps CPU total en mode système consommé, depuis le dernier appel à time_l
.
Si aucun appel à time_l
n’a été effectué, alors c’est le temps écoulé depuis le dernier appel de time_s
.
> time_s; for j=1 to 3 { (1+x+y+z+t+u+v)**18$ time_l; }; utilisateur 00.313s - reel 00.183s - systeme 00.057s - (202.43% CPU) utilisateur 00.307s - reel 00.170s - systeme 00.055s - (213.11% CPU) utilisateur 00.311s - reel 00.173s - systeme 00.055s - (211.93% CPU)
Previous: time_l, Up: Temps d execution [Contents][Index]
time_t;
Elle affiche le temps CPU total en mode utilisateur consommé, le temps total écoulé et le temps CPU total en mode système consommé, depuis le dernier appel à time_s
.
time_t(
<identificateur> usertime ,
<identificateur> realtime );
Elle affiche le temps CPU total en mode utilisateur consommé, le temps total écoulé et le temps CPU total en mode système consommé, depuis le dernier appel à time_s
.
usertime contiendra la somme du temps CPU en mode utilisateur et système écoulé et realtime contient le temps réel écoulé.
> time_s; for j=1 to 3 { (1+x+y+z+t+u+v)**18$ time_t; }; time_t(usertime, realtime); utilisateur 00.310s - reel 00.178s - systeme 00.055s - (205.29% CPU) utilisateur 00.615s - reel 00.347s - systeme 00.111s - (209.44% CPU) utilisateur 00.928s - reel 00.519s - systeme 00.168s - (211.23% CPU) utilisateur 00.928s - reel 00.519s - systeme 00.168s - (211.20% CPU) > usertime; usertime = 1.097452 > realtime; realtime = 0.5196029999999999
Previous: Temps d execution, Up: Utilitaire [Contents][Index]
!
<chaine> ;
Elle exécute la commande shell contenue dans la chaine.
> dir ="ls -al"; dir = "ls -al" > ! dir; total 8136 drwxr-sr-x 20 xxxx ttt 1536 Sep 27 17:16 . drwxr-sr-x 22 xxxx ttt 512 Sep 06 12:16 .. -rw-r----- 1 xxxx ttt 281 Sep 08 1998 .Guidefaults -rw------- 1 xxxx ttt 204 Sep 27 10:46 .Xauthority
str(!
<chaine> );
Elle exécute la commande shell contenue dans la chaine et retourne la sortie standard dans une chaine. Si la sortie d’erreur n’est pas vide, une erreur est générée.
> s=str(!"uname"); s = "Darwin "
Previous: Utilitaire, Up: Top [Contents][Index]
• References : | ||
• Dictionnaires OpenMath : | ||
• Index des Variables globales : | ||
• Index des commandes : | ||
• Index complet : |
Next: Dictionnaires OpenMath, Up: Index [Contents][Index]
version 6.0.0, 2014
Torbjorn Granlund et al.
version 2.4.6, 2014
2007, ACM Trans. Math. Softw. 33, 2 (Jun. 2007) 13.
Fousse, L., Hanrot, G., Lefèvre, V., Pélissier, P., and Zimmermann, P.
Version 1.0.3, February 2015
Andreas Enge and Mickaël Gastineau and Philippe Théveny and Paul Zimmermann
Version 1.3, 2009
S.Freundt, P.Horn, A.Konovalov, S.Linton, D.Roozemond.
D. Roozemond
D. Roozemond
Version 1.0.2, May 2016
M. Gastineau
Next: Index des Variables globales, Previous: References, Up: Index [Contents][Index]
Voici la liste des symboles OpenMath supportés par le serveur SCSCP et le client SCSCP.
CD | Symbol |
---|---|
arith1 | abs, divide, minus, plus, power, times, unary_minus |
alg1 | one, zero |
bigfloat1 | bigflat |
arith1 | abs, divide, minus, plus, power, times, unary_minus |
complex1 | argument, complex_cartesian, complex_polar, conjugate, imaginary, real |
fieldname1 | C, Q, R |
interval1 | interval_cc, integer_interval, interval |
linalg2 | matrix, matrixrow, vector |
list1 | list |
logic1 | not, and, xor, or, true, false |
nums1 | e,i, infinity, NaN, pi, rational |
polyd1 | poly_ring_d_named, SDMP, DMP, term |
polyu | poly_u_rep, term |
polyr | poly_r_rep, term |
setname1 | C, N, P, Q, R, Z |
transc1 | arccos, arccosh, arcsin, arcsinh, arctan, arctanh, cos, cosh, exp, ln, log, sin, sinh, tan, tanh |
Voici la liste des symboles OpenMath supportés seulement par le serveur SCSCP.
CD | Symbol |
---|---|
scscp2 | get_allowed_heads, get_transient_cd, get_signature, store, retrieve, unbind |
Voici la liste des symboles OpenMath supportés seulement par le client SCSCP.
CD | Symbol |
---|---|
scscp2 | symbol_set, signature, service_description, |
Next: Index des commandes, Previous: Dictionnaires OpenMath, Up: Index [Contents][Index]
Jump to: | _
I P |
---|
Jump to: | _
I P |
---|
Next: Index complet, Previous: Index des Variables globales, Up: Index [Contents][Index]
Jump to: | !
%
&
(
*
+
,
-
/
:
<
=
>
?
@
[
\
^
A C D E F G H I K L M N O P Q R S T U V W X |
---|
Jump to: | !
%
&
(
*
+
,
-
/
:
<
=
>
?
@
[
\
^
A C D E F G H I K L M N O P Q R S T U V W X |
---|
Previous: Index des commandes, Up: Index [Contents][Index]
Maple est une marque déposée de Waterloo Maple Inc.
Mathematica est une marque de Wolfram Research