                    ALGB 2.3.

Bernard Parisse Institut Fourier (CNRS UMR 5582) Université de Grenoble I F-38402 St Martin d’Hères Cédex Tél. (33) 04 76 51 43 14

                    Bernard.Parisse@ujf-grenoble.fr

7 Novembre 1996

Table des matières

1 Licence. 3

2 Installation. 3

2.1 Installation depuis un ordinateur avec Kermit. . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.1.1 Première phase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.1.2 Installation minimale (pour HP48 S et G). . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.1.3 Installation complète. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 Installation avec un autre de logiciel de communication. . . . . . . . . . . . . . . . . . . . . . 4 2.3 Installation depuis une autre HP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Introduction. 4 3.1 Présentation du logiciel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 3.2 Présentation de la documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3.3 Autres programmes et calculateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4 Interface utilisateur. 6 4.1 Représentation interne des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 4.2 Le menu CST. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4.3 Les touches en mode USER. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4.4 Drapeaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 4.5 Passage de la représentation interne à la représentation utilisateur. . . . . . . . . . . . . . . . 12

5 Intégration, transformée de Laplace inverse. 14 5.1 Le programme risch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 5.2 Utilisation normale de INT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 5.3 Fractions trigonométriques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 5.4 Racines de trinômes du second degré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 5.5 Transformée de Laplace inverse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 5.6 Systèmes d’équations différentielles linéaires à coeffcients constants . . . . . . . . . . . . . . . 17 5.7 Linéarisations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 5.8 Changement de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 5.9 Entrée pour programmeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 6 Réduction et diagonalisation des matrices. 19

6.1 Réduction des matrices par l’algorithme du pivot partiel. . . . . . . . . . . . . . . . . . . . . . 19 6.2 Diagonalisation (algorithme de Laguerre-Souriau-Faddeev). . . . . . . . . . . . . . . . . . . . 22 6.3 Déterminant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 6.4 Produit vectoriel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

7 Fonctions 26 7.1 Développements limités. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 7.2 Transformation de cos nx et sin nx en polynômes de cos x et sin x. . . . . . . . . . . . . . . . 26 7.3 Dérivée et gradient. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

8 Arithmétique. 28

9 Forme quadratiques. 29

10 Les utilitaires de la bibliothèque. 31 10.1 Transformations de types et simplifications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 10.2 Factorisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 10.3 Opérations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 10.4 Objets symboliques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 10.5 Programmation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 10.6 Arithmétique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 10.7 Matrices et vecteurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 10.8 VER. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

A Les indicateurs utilisateurs. 36

B Liste des fonctions par ordre alphabétique. 37

1 Licence.

\begin{matrix}c \\ ◯ \end{matrix} 11/1996 Bernard Parisse, HORN%%ext et BAIRSText, \begin{matrix}c \\ ◯ \end{matrix} 06/1995 Ram Naresh Gudavalli.

La licence d’utilisation d’ALGB est la license GNU version 2.0 ou une version ultérieure à votre

convenance, elle se trouve dans le fichier copying.gnu (lui-même compressé dans le fichier algb.zip). En deux mots, vous pouvez utiliser ce logiciel gratuitement, vous pouvez également télécharger le code source de ALGB si vous souhaitez modifier ALGB ou créér de nouveaux modules (ou simplement si vous êtes curieux). Vous pouvez également vendre ALGB, mais vous devez alors fournir le moyen d’accéder au code source d’ALGB et vous ne pouvez pas changer la licence d’utilisation d’ALGB ou de ces dérivés.

L’adresse Internet du serveur ftp anonyme de l’Institut Fourier est:

puccini.ujf-grenoble.fr (IP 193.254.244.1)

vous y trouverez dans le répertoire pub/hp48, les fichiers

algb.zip         Executables de ALGB
algbtest.zip     Version test de ALGB
algbunix.zip     Code source de ALGB (utilisable sous Linux ou a adapter)
algbdoc.zip      Documentation
Vous pouvez également consulter ma homepage WWW : http://www-fourier.ujf-grenoble.fr/~parisse

Pour utiliser les codes sources de ALGB, il vous faudra également les utilitaires de développement GNU gtools ([10]) de Mikocevic, ou TOOLS.EXE ([1]) de HP Corvallis (pour développer sur PC) ou jazz ([9] le successeur de [11]) de Mika Heiskanen (pour développer sur la HP, à condition d’avoir suffisament de mémoire). Les trois sont gratuits, on les trouve sur les serveurs suivants: hplyot.obspm.fr, ftp.cis.com, hpcvbbs.cv.hp.com, ftp.funet.fi, et d’autres sites miroirs.

2 Installation.

Il faut au minimum 26K de libre pour installer ALGB, mais en fait il est nécessaire d’avoir au

moins 28K de libre pour utiliser la librairie seule.

2.1 Installation depuis un ordinateur avec Kermit.

L’utilisation du logiciel Kermit est gratuite, la dernière version en date pour PC est la version

3.14 (Janvier 1995) que l’on peut télécharger sur le serveur ftp anonyme kermit.columbia.edu ou l’un de ses sites miroirs.

2.1.1 Première phase.

Commencez par télécharger le répertoire ALGB (sur une 48SX) ou ALGBG (sur une 48S ou G/GX).

Mettez l’ordinateur en mode serveur. Placez-vous maintenant dans ALGB (ou ALGBG) et tapez INIT. Ce qui charge la librairie et l’installe dans le port 0 de la calculatrice. Vous pouvez installer la librairie dans un autre port si vous préférez, mais sur une GX, si vous l’installez dans un port couvert (2-33), vous ralentirez l’exécution des programmes (au point qu’ils s’exécuteront un peu moins vite que sur une 48S!)

Ensuite, retournez dans ALGB (ou ALGBG) et tapez à nouveau INIT. Ceci crée un menu CST et

affecte certaines touches utilisateurs pour une utilisation plus confortable de ALGB. Tapez enfin SETFR ce qui met les flags utilisateurs au format européen, place en mode radian (qui devrait être le mode par défaut sur une calculatrice scientifique!) et met en mode USER.

2.1.2 Installation minimale (pour HP48 S et G).

Si vous ne disposez que de 30K de libre, je vous conseille de purger le répertoire ALGBG en tapant

PURG (vous éliminez ainsi le menu CST mais vous conservez l’interface des touches en mode USER).

La librairie et l’interface USER consomment un peu plus de 24K. Il vous reste donc environ 6K

de libre, ce qui devrait suffire! Vous pouvez même rajouter un programme des modules, par exemple le programme DIAG du répertoire MATR, ou LIN de INTG, ...

Dernière remarque: sur une 48S, la factorisation ne posera pas de problèmes tant que l’extracteur

numérique de racines n’est pas appelé. Si vous utilisez ALGB dans vos études, l’extracteur numérique ne devrait être appelé que dans les cas suivants:

• factorisation d’une équation bicarrée,

• factorisation d’un polynôme en utilisant des racines n-ième de l’unité.

Dans les autres cas, le module de recherche de racines rationnelles, de résolution d’équation du second degré, ou de recherche de racines multiples saura factoriser le polynôme.

2.1.3 Installation complète.

Si vous avez une HP48GX ou une HP48SX avec une carte d’extension, tapez GETALL ce qui

télécharge tous les modules de ALGB.

2.2 Installation avec un autre de logiciel de communication.

Téléchargez la librairie 'ALGB.LIB' ou ALGBG.LIB (pour les séries G) et installez-la: 'ALGB.LIB' RCL

'ALGB.LIB' PURGE
0 STO

Puis téléchargez ALGB sur une 48SX ou ALGBG sur une 48S/G/GX, tapez INIT, et installez les modules qui vous intéressent. Tapez enfin SETFR ce qui met les flags utilisateurs au format européen, place en mode radian et met en mode USER. Purgez ALGB ou ALGBG si vous voulez économiser de la place et téléchargez les répertoires de votre choix.

2.3 Installation depuis une autre HP.

Placez la HP qui va recevoir ALGB en mode infrarouge puis en mode serveur. Sur la HP qui contient

ALGB, vérifiez que vous êtes en mode infrarouge. Si vous avez conservé le programme SENDIR du répertoire

ALGB, tapez simplement SENDIR, sinon tapez: « :0:788  RCL -> 'ALGB.LIB' « 'ALGB.LIB' SEND » »

Vous pouvez alors installer la bibliothèque comme ci-dessus (section 2.2).

3 Introduction.

3.1 Présentation du logiciel.

Les modules et la bibliothèque ALGB contiennent des programmes:

• de simplification d’expressions beaucoup plus efficaces que COLCT et EXPAN. On peut par exemple développer '(1+X)^12-(1-X)^12' en 4 secondes en tapant EXPA alors que par extrapolation, il faudrait une dizaine de jours en utilisant uniquement les instructions de la ROM (avec de plus l’obligation d’écrire le petit programme EXCO décrit pages 31-22 et 31-23 du manuel de la 48S). Cette version est également capable de simplifier des expressions à plusieurs variables en un temps raisonnable. Par exemple

\frac{1 − \frac{1− \frac{y}{x+y}}{1− \frac{x}{x+y}}}{y^{2} − \frac{x}{1+ \frac{x}{y−x}} . (\frac{xy}{y−x} − x)} → EXPA → \frac{1}{y^{2} + xy + x^{2}}

en un peu moins de 16s sur une 48S(X) ou un peu plus de 10s sur une GX. On peut également factoriser certaines expressions en utilisant COLC, par exemple 'X^2+X+2*X*Y+Y+Y^2' COLC donne

     '(X+Y)*(X+Y+1)' en 7 secondes.

• d’arithmétique sur les entiers, les polynômes à coefficient réels ou complexes (PGCD, PPMC, factorisation), les fractions rationnelles, les irrationnels quadratiques (c’est-à-dire les nombres de la forme a + b\sqrt{c}), les matrices numériques ou symboliques, incluant bien sûr les opérations +, −, ∗, / mais également les puissances entières.

• de calcul symbolique d’intégrales de fractions rationnelles (en x, ou en sin x / cos x, ou en sinh x / cosh x), de logarithmes et exponentielles, de calcul de transformée de Laplace inverse de fractions rationnelles réelles,

• de diagonalisation de matrices (avec éventuellement recherche des vecteurs caractéristiques et mise sous forme normale de Jordan)

• de réduction de matrices (par la méthode du pivot partiel) avec la possibilité de suivre l’algorithme de Gauß pas à pas, en particulier calcul de déterminant, d’inverse, de factorisation LU par cette méthode et résolution des systèmes linéaires sous ou sur-déterminés,

• d’orthogonalisation de formes quadratiques (décomposition en somme de carrés),

• de calcul de développements limités analogues à la commande TAYLR, mais plus rapides et capables de traiter des expressions plus complexes ainsi que dans une certaine mesure des expressions indéterminées en un point.

L’originalité des programmes présentés ici tient au fait que:

• ils acceptent des paramètres (d’où l’utilisation des délimiteurs { } au lieu de [ et ] pour les tableaux),

• ils effectuent des calculs sur les racines carrées sans les évaluer,

• ils essaient dans la mesure du possible de s’adapter à des données de type variable (par exemple le programme GCD de calcul de plus grand commun démoninateur accepte des entiers, des polynômes-listes ou des polynômes symboliques).

• les principaux programmes essaient d’utiliser les mêmes représentations d’objets que la calculatrice, par exemple, on peut rentrer une fraction à décomposer en élements simples à l’aide d’EquationWriter et visualiser les résultats de la même façon. D’un autre côté, les programmeurs peuvent utiliser des représentations moins intuitives mais plus faciles à manipuler.

• les fractions sont représentées par des objets symboliques, comme '1/2', et pas par des complexes ou autres, ce qui permet justement d’utiliser les complexes (y compris d’ailleurs dans des fractions)

• les points d’entrées en ROM utilisés sont uniquement ceux garantis par HP (ceux du fichier ENTRIES.A), ce qui devrait garantir la portabilité sur les 48 S, SX, G, GX mais j’espère aussi sur les modèles futurs (moyennant recompilation). À propos des successeurs de la HP48, signalons que la HP38G est certes postérieure à la 48G mais n’est pas un successeur de la 48G. Il nous faudra patienter (au moins un an à mon avis).

Cette philosophie pénalise un peu les temps de calcul mais l’usage est plus confortable.

L’ensemble d’ALGB a été développé sur un PC Pentium 90Mhz, sous Linux version 2.0, avec le

système X-Windows XFree86, l’éditeur GNU emacs, l’émulateur x48 avec JAZZ, les gtools (compilateur GNU pour HP48) et kermit. Sans le projet GNU et la Free Software Foundation, ALGB n’en serait pas là.

3.2 Présentation de la documentation.

Voici le plan de ce mode d’emploi:

• La section 4 explique comment sont représentées les objets sur la pile (représentation utilisateur et interne des polynômes, des matrices, etc. ), indique les principaux utilitaires de la bibliothèque à connaître et montre comment y accéder efficacement par l’interface de redéfinition des touches (mode

USER).

• La section 5 décrit comment utiliser les programmes du module d’intégration (intégration de fractions rationnelles, en sin, cos, ou en sinh, cosh, décomposition en éléments simples, transformée de Laplace inverse).

• la section 6 décrit les utilitaires du module de calcul matriciel (méthode du pivot et diagonalisation), • la section 7 explique comment utiliser le programme 'TAYLR' (qui se substitue à l’instruction intégrée

de la HP et accepte la même syntaxe).

• la section 8 décrit les utilitaires arithmétiques (Bezout, décomposition en éléments simples par l’algorithme de Bezout, reconstruction d’un irrationnel quadratique, ...)

• la section 9 décrit les programmes de réduction des formes quadratiques,

• La section 10 décrit l’ensemble des utilitaires de la bibliothèque.

• En appendice, on trouvera la liste des flags utilisateurs qui permettent de paramétrer les programmes, la liste alphabétique de toutes les fonctions (avec une brève explication de l’utilité, de la liste des arguments à mettre sur la pile avant l’appel et de la liste des arguments renvoyés) et la liste des redéfinitions de touches.

Cette documentation s’applique à la version 2.28 de ALGB (pour déterminer la version de ALGB,

vous pouvez utiliser l’instruction VER qui affiche en clair le numéro de version et renvoie sur le niveau 1 de la pile le numéro de version).

Remarque 1 Attention, vous devez utiliser les même versions de ALGB pour les modules et pour la bibliothèque. Si vous changez de version pour la biblithèque vous devez penser à mettre à jour les répertoires. Sinon, vous risquez de perdre toutes vos données. Pour être sur que la version des répertoires est compatible avec la bibliothèque, lancez le programme INIT du répertoire ALGB.

3.3 Autres programmes et calculateurs.

Parmi les autres programmes mathématiques pour HP48 disponibles sur le réseau, je vous conseille

aussi de tester ALG48 ([5] le successeur de [7]). Il propose des fonctions arithmétiques bien plus évoluées qu’ALGB et les simplification d’expressions y sont de 1 à 5 fois plus rapides. Malheureusement ALG48 ne simplifie pas les irrationnels quadratiques, à commencer par les complexes, et il n’y a pas à l’heure actuelle d’équivalent des répertoires MATR, INTG, ... utilisant ALG48 (certaines opérations comme la diagonalisation ou l’intégration symbolique ne peuvent d’ailleurs pas utiliser une librairie n’acceptant pas les complexes car elles nécessitent de factoriser des polynômes).

En sus de la HP48, seule la TI92 mérite le nom de calculateur symbolique. La TI92 est à un prix

équivalent à celui d’une HP48GX, avec une mémoire comparable à celle d’une GX où on aurait installé par exemple JAVA et ALGB ou ALG48. Les atouts actuels de la TI92 sont: sa vitesse et la puissance de certaines instructions symboliques (par exemple l’intégration, encore que j’espère bientôt avoir une implémentation complète de l’algorithme de Risch (cf. [3]) sur la HP). Les faiblesses de la TI92 sont: la taille (vous aurez du mal à la mettre dans une poche de veste!), la lenteur en calcul matriciel, le faible nombre d’instructions numériques et d’algèbre linéaire, la faiblesse en arithmétique (par exemple la TI92 est incapable de factoriser des nombres dont les facteurs premiers sont supérieurs à 65536!). Plus généralement, je considère que la TI92 a peu d’utilité en-dehors du lycée et de la première année à l’Université. De plus les possibilités de programmation de la TI92 ne se comparent pas à celle de la HP48. Enfin, la syntaxe polonaise inversée est à mon avis la seule façon naturelle de faire du calcul formel, son absence est un des points faibles des systèmes comme Derive, Maple ou Mathématica.

4 Interface utilisateur.

4.1 Représentation interne des données.

La librairie et les modules manipulent:

1. des entiers,

2. des réels et complexes,

3. des noms de variables (ou noms globaux).

4. des listes,

5. des polynômes,

6. des expressions symboliques,

7. des matrices,

Ces données sont représentées de deux façons différentes: la représentation utilisateur, qui est

la plus intuitive et la représentation interne moins intuitive mais plus rapide et qui occupe moins de place mémoire. Le passage explicite de l’une à l’autre se fait par l’instruction L2S qui sera expliquée un peu plus loin. (Le calculateur détermine le type de représentation utilisée en fonction de l’état du flag 17). Passons maintenant en revue l’ensemble des types:

1. les entiers: dans les deux modes, ce sont des real (user-type 0), par exemple l’entier 5 est représenté par 5,^{1}

2. les réel et complexes: dans les deux modes, ce sont des real ou cmp (user-type 0 et 1), par exemple le réel numérique \sqrt{2} est représenté par 1,414235...,

3. les fractions: dans les deux modes, il s’agit d’une expression symbolique (user-type 9), par exemple

'3/4'.

4. les irrationnels quadratiques (irrquad): il s’agit de nombres de la forme a + b\sqrt{c}. En mode utilisateur, on les représente par une expression symbolique, par exemple '1+2*√ 5'. En mode interne, j’utilise le type user des programmes, l’exemple ci-dessus sera alors: « 1 2 5 ». Les trois composantes a, b et c de l’irrquad peuvent être des scalaires quelconques (i.e. des réels, complexes, entiers, fractions, polynômes ou des irrquads).

5. polynôme: en mode utilisateur, il s’agit d’une expression algébrique (user-type 6,7 ou 9) polynomiale par rapport à une ou plusieurs variables, en mode interne, il s’agit d’une liste des coefficients par ordre de degré décroissant (user-type 5). Pour les polynômes à plusieurs variables, on obtient des listes de listes.

Par exemple, le polynôme x^{5} − 3x^{2} + ax − b + 7 est représenté par l’algébrique 'X^5-3*X^2+A*X-B+7' ou, par rapport à la liste de variables { X B A }, par la liste de listes:

{ 1 0 0 -3 { { 1 0 } } { -1 7 } }

6. les vecteurs et matrices: ce sont des tableaux (vecteurs et matrices numériques) ou des list (user-type 5) (vecteurs et matrices symboliques) en mode interne et en utilisateur. Les coefficients d’un vecteur ou d’une matrice numérique sont des réels ou des complexes, ceux d’un vecteur ou d’une matrice symbolique sont des scalaires (réels, complexe, entiers, irrationnels quadratiques, polynômes, fractions rationnelles, irrquads).

   array           list
[[ 1  0 3 ]      { { 1  0 3 }
 [ 2 -1 4 ]        { 2 -1 4 }
 [ 5  1 0 ]]       { 5  1 0 } }

Remarquez que les calculs sur les tableaux sont plus rapides (surtout les multiplications), mais ils n’acceptent pas de paramètres.

Remarque 2 • Certaines expressions symboliques calculées en mode interne par ALGB peuvent contenir des listes, ce qui n’est jamais le cas lorsqu’on utilise les instructions intégrées de la HP. Par exemple, si vous tapez {1 2} {3 4} NDXF. Le compilateur/décompilateur de la HP ne reconnait pas ce type de fractions et affiche 'UNKNOWN/UNKNOWN'. Pour faire face à ce problème, il y a deux solutions: soit utiliser FXND pour voir apparaître les listes en clair, soit utiliser une autre pile interactive, par exemple EQSTK ([8]) de Mika Heiskanen ou JAVA ([12]) de Richard Steventon et Andre Schoorl.

1Vous pouvez aussi utiliser des entiers “binaires” (par exemple #5h) sauf dans des expressions symboliques. Le compilateur de la HP48 est responsable de cet état de fait. Espérons que le prochain modèle de HP autorisera les entiers dans des expressions symboliques. J’espère dans un avenir proche pouvoir utiliser d’autres bibliothèques pour représenter les entiers en interne par des entiers binaires de longueur non limitée.

• Ne modifiez pas manuellement la position du flag 17 tant que vous ne maitrisez pas ALGB. Notez qu’en tapant VER, vous restaurez les flags 12 à 17 à leur valeur par défaut.

• Lorsque le flag 13 est désarmé, toute expression symbolique est considérée comme réelle au cours des simplifications. Ceci est important lorsqu’on prend la partie réelle, imaginaire ou le conjugué d’une expression. Pour un nom global devant représenter un complexe, il faut utiliser deux variables (remplacer Z par 'X+iY'). Dans les autres cas, la seule solution est d’armer le flag 13. Attention, même si tous vos noms globaux remplacent des réels, rien ne dit qu’une expression contenant ces noms globaux est réelle, par exemple les fonctions réciproques font facilement passer dans le domaine complexe (c’est le cas pour ln(−1), \sqrt{−1}, arcsin(2), ...)

4.2 Le menu CST.

Il est accesible depuis le répertoire ALGB et ses sous-répertoires, il contient les menus suivants:

• ARIT fonctions arithmetiques,

• MATR opérations sur les matrices,

• FACT utilitaires de factorisation,

• CONV routines de conversion de type,

• MISC autres utilitaires,

• JAZZ quelques fonctions de l’assembleur JAZZ

Le texte source du menu CST se trouve dans le répertoire ALGB dans la variable 'SCST'. Pour

l’adapter à vos besoins, suivez la procédure suivante:

• 1) éditez 'SCST',

• 2)

tapez INIT ou

tapez STR→ puis 'CST' STO.

4.3 Les touches en mode USER.

Le texte source des touches réassignées est contenu dans la variable 'UKEYS'. Pour l’adapter à

vos besoins, utilisez la même procédure que pour modifier le menu CST.

Rappelons qu’on entre en mode USER en tapant le premier shift suivi de USR (touche α) une ou 2

fois (selon que l’on voit USER ou 1USR à l’affichage) et qu’on en sort de la même manière.

Dans tous les exemples, on suppose que l’on est en mode symbolique (flags 12, 14 et 15 armés).

Ce mode peut être activé soit en tapant ->q, soit en utilisant EXPA sur une expression quelconque.

Hormis trois exceptions, les seules touches redéfinies sont les touches en mode α shiftée avec le

shift droit (le bleu sur la 48S/SX). Les deux premières exceptions sont les touches →Q (pour la 48S(X)) ou α-shift droit-Q (pour la 48G(X)) et →NUM du clavier dont l’action est identique à celle de la calculatrice mais étendue aux listes et tableaux. La troisième exception est la touche EVAL qui est redéfinie en mode α-shift gauche pour passer de la représentation interne à la représentation utilisateur et inversement, voir la section 4.5.

Les touches α-shiftée redéfinies sont:

• SPC, fonction rref Appelle l’algorithme de réduction de matrices, renvoie la liste des pivots utilisés au niveau 2 et la matrice réduite au niveau 1. Si le flag 1 est activé, les étapes intermédiaires de la réduction sont affichées.

• 1 , Exécute 13 CF pour passer en mode réel.

• 2 , Exécute 13 SF pour passer en mode complexe

• 3 (CMD), fonction AXL: Conversion du format liste au format symbolique et réciproquement d’un vecteur ou d’une matrice. Dans le sens symbolique vers numérique, le programme essaie de convertir les expressions algébriques en nombres. En cas d’impossibilité, on obtient une erreur avec sur la pile les arguments de l’instruction

->ARRY.
[ 1 2 3 ] AXL { 1 2 3 }
{ { '1/2' 1 } { -1 '3/4' } } AXL [[ .5 1 ] [ -1 .75 ]]

• 4 (TIME), fonction tEVAL: calcule le temps nécessaire à l’évaluation de l’objet situé au niveau 1 de la pile, par exemple si le niveau 1 contient le nom d’un programme, il calcule le temps de déroulement de ce programme,

'X+2' '2*X+3' « add » tEVAL -> '3*X+5' :s: 0.6575 Il faut donc un peu plus d’une demi-seconde

pour additionner ces deux polynôme.

• 5 , fonction EXEC Selon le niveau 1:

– Substitution (si le niveau 1 est une équation): { 1 'M+2' 'M-3' }, 'M=4' -> { 1 6 1 }

– Exécution d’un programme sur une liste, si le niveau 1 est un programme Exemple: { 1 2 3 } « NEG » EXEC équivaut à: { 1 2 3 } CHS

– Plusieurs substitutions, si les niveaux 2 et 1 sont des listes. Exemple:

    'COS(X)+i*SIN(X)'
    { SIN COS }
    { « i * EXP DUP INV - i 2 * / »
      « i * EXP DUP INV + 2 / »
    }
    EXEC EXPA -> 'EXP(i*X)'

• 6 , fonction COLC:

Tente de factoriser une expression symbolique.

'X^2-4' COLC '(X-2)*(X+2)'
'SIN(X)^2-X^2' COLC '(X-SIN(X))*(X+SIN(X))'

La factorisation est effectuée par rapport à la variable contenue dans VX si l’expression en dépend, sinon par rapport à la première variable renvoyée par LVAR. L’algorithme recherche des facteurs du premier degré (dits facteurs évidents), et effectue ensuite une factorisation sans facteurs carrés (square free factorization). Il peut être nécessaire de taper une deuxième fois COLC pour obtenir une factorisation plus poussée (mais pas forcément plus simple) si des facteurs de degré deux apparaissent. Attention, cet algorithme (de même que FROOT et FACTO) peut être très long, en particulier avec des expressions à plusieurs variables.

• 7 (SOLVE), fonction FROOTS:

factorise un polynôme, le résultat au niveau 1 est une liste de racines. Exemple:

'X^2+X+1' FROOTS donne

\{−\frac{1}{2} − \frac{1}{2}i\sqrt{3}1 − \frac{1}{2} + \frac{1}{2}i\sqrt{3}1\}

i.e. j^{2} et j les deux racines complexes de multiplicté 1 de x^{2} + x + 1 = 0. Vous pouvez oublier les niveaux 2 et 3 de la pile dans le cas de polynôme-listes. Ces niveaux 2 et 3 ont une importance dans le cas de recherche de racines d’expressions symboliques: il s’agit du polynôme développé et de la liste des variables. Par exemple:

'X^2-4' FROOTS -> { X }, 'X^2-4', { 2 1 -2 1 }
'X^2+2*X*Y+Y^2' FROOT
-> { X Y }, 'X^2+2*X*Y+Y^2', { '-Y' 1 '-Y' 1 }

le niveau 3 contient la liste des variables (avec le contenu de VX en première position si l’expression symbolique dépend de VX), le niveau 2 contient le polynôme développé. Attention, la liste de racines peut dépendre indirectement de la variable par rapport à laquelle on factorise, par exemple dans

l’expression 'SIN(X)^2-X^2'.

Notez que les racines carrées d’expressions sont considérées comme des variables. De ce fait, les racines d’une expression contenant des racines doivent parfois etre simplifiees a leur tour. Par exemple, si on factorise x^{2} − (2\sqrt{2} + 1)x + \sqrt{2} + 2, il faut exécuter EXPA après FROOTS pour obtenir les racines \sqrt{2} et 1 + \sqrt{2}.

• 8 :

Exécute TSIMP si celui-ci est accessible depuis le chemin courant. Cette fonction est utilisée pour simplifier des fonctions non rationnelles et pour préparer l’intégration par l’algorithme de Risch.

• 9 (ALGEBRA ou SYMBOLIC), fonction EXPA:

Simplifie l’objet situé au niveau 1 de la pile.

• EVAL , fonction L2S:

Conversion liste vers symbolique.

{ { 1 2 } { 3 4 } }, { X Y } -> '(Y+2)*X+(3*Y+4)'
{ 1 2 3 } A -> 'A^2+2*A+3'

• SIN (∂), fonction FDER:

dérive un polynôme-liste, une fraction-liste, ou une expression algébrique par rapport à la variable contenue dans VX:

{ 2 3 4 } FDER -> { 4 3 }
'X/(X+1)' FDER -> '1/((X+1)*(X+1))'

• COS (∫), fonction FINTG:

calcule la primitive s’annulant en 0 d’un polynôme-liste, ou la primitive s’annulant en α d’une expression algébrique par rapport à la variable contenue dans VX (en appelant la fonction d’intégration de la ROM de la HP après décomposition en éléments simples)

{ 2 3 4 } FINTG -> { '2/3' '3/2' 4 0 }
'1/X' FINTG EVAL -> 'LN(X)-LN(alpha)'
• + , - , * , / , fonctions add, SUBT, MULT, DIV1:

Additionne, soustrait, multiplie, divise 2 quantités. Pour la multiplication, priorité est donné à la multiplication de matrices lorsqu’il y a ambiguité entre matrice symbolique et polynôme-liste à plusieurs variables.

'1+X' 'X+2' add -> '2*X+3'
{ { 1 A } { A 1 } } { 1 'sqrt[2]' } MULT -> { '1+A*sqrt[2]' 'A+sqrt[2]' }

• √ , fonction SQRT:

Calcule la racine carrée d’un réel, d’un complexe, d’un polynôme liste ou d’un objet symbolique. Par exemple:

'1+2*A+A^2' SQRT donne 'A+1',

50 SQRT donne 5\sqrt{2}

(0 1) SQRT donne '(1,1)/2*\sqrt{2}'.

• 1/x , fonction MAD:

Calcule le polynôme caractéristique, le polynôme matriciel adjoint, l’inverse et le déterminant d’un objet. Pour un objet qui n’est pas une matrice le polynôme caractéritique et le polynôme matriciel adjoint sont des listes vides et le déterminant est l’objet lui-même.

[[ 1 2 ] [ 3 4 ]] MAD
-> 4: -2
   3: { { -2 1 } { '3/2' '-1/2' } }
   2: { [[ 1 0 ] [ 0 1 ]] [[ -4 2 ] [ 3 -1 ]] }
   1: { 1 -5 -2 }
5 MAD -> 5, '1/5', {}, {}

En fait, le niveau 4 de la pile est égal au déterminant pour une matrice d’ordre pair et à son opposé pour une matrice d’ordre impair. La dernière matrice du polynôme matriciel adjoint est l’opposé de la comatrice de la matrice de départ (si l’ordre est pair) ou la comatrice (si l’ordre est impair).

• y^{x} , fonction POWER Calcule la puissance entière d’un objet situé au niveau 1. La puissance peut être négative pour un objet inversible (par exemple une matrice carrée ou un polynôme).

'3/7' -5 POWER -> '16807/243'
{ { 1 -1 } { 2 4 } } -5 POWER
-> { { '227/3888' '211/7776' } { '-211/3888' '-179/7776' } }
'1+X' 4 POWER -> 'X^4+4*X^3+6*X^2+4*X+1'
#11h 9 POWER -> # 1B9C636491h

Si la puissance n’est pas entière, POWER appelle la fonction intégrée y^{x}.

• ± , fonction CHS Change le signe d’un objet

5 CHS -> -5
{ 1 2 } CHS -> { -1 -2 }

4.4 Drapeaux.

Pour contrôler le comportement des programmes, vous disposez:

• de l’indicateur système -27 qui contrôle si les complexes sont renvoyés sous forme symbolique ('1+2*i') ou complexe ('(1,2)').

• des indicateurs utilisateurs 1, 12, 13, 15, 17 et 21 (cf. la section A de l’appendice).

Brièvement, l’indicateur 1 est une bascule autorisant ou interdisant l’affichage de messages durant l’exécution des programmes, l’indicateur 12 indique qu’il faut ou non simplifier des fractions par division par leur PGCD commun, l’indicateur 13 doit être armé si vous manipulez des données complexes et désarmé si vous ne manipulez que des réels, l’indicateur 15 autorise la création de fractions d’entiers, l’indicateur 17 est désarmé en mode de représentation des données utilisateur et armé en mode interne et l’indicateur 21 indique si les simplifications doivent être effectuées de manière récursive.

Pour un usage pédagogique d’ALGB, je vous conseille de garder les flags 12, 14 et 15 armés, si vous faites par contre des calculs numériques désarmez les flags 12, 14 et 15. La position du flag 13 est surtout importante lorsqu’on factorise des polynômes d’une variable ou lorsqu’on intègre des fractions rationnelles.

• de la variable ε (EPS du répertoire HOME ou d’un descendant). Quand ils recherchent des erreurs d’arrondi, les programmes considèrent tout nombre inférieur à ε comme nul.

• de la variable 'VX' qui contient un nom d’inconnue. A chaque arrêt système 'VX' est fixé à 'X'.

A chaque arrêt système (provoqué par exemple par ON -C), ε est fixé à 10^{−10}, 'VX' à 'X', les flags 12 à 15 sont activés et les flags 16 à 21 désactivés.

4.5 Passage de la représentation interne à la représentation utilisateur.

Ceci s’adresse plutôt aux personnes qui désirent programmer en utilisant les routines de ALGB (en

RPL utilisateur, pour le RPL système, je n’ai pas écrit de documentation autre que celle du code source de ALGB). Lorsqu’on écrit des programmes, on s’aperçoit rapidement qu’on perd beaucoup de temps si à chaque instruction il est nécessaire de convertir du mode utilisateur au mode interne et réciproquement. Par exemple, si on additionne ’X+1’ et ’X+1’, l’addition en interne prend 0.2s environ, alors que les conversions durent 0.4s. L’instruction SXL a pour but de convertir une fois en début de programme l’ensemble des entrées utilisateur en entrée interne et la même instruction convertit à nouveau les données internes au format utilisateur. Le flag 17 indique aux instructions intermédiaires qu’il n’est pas utile de convertir les données.

Le schéma de pile est le suivant pour convertir en interne:

stk n+1: obj_n    ->  stk n+1: liste des variables
 ...              ->  stk   n: obj_n
stk   2: obj_1    ->    ....
stk   1: #n       ->  stk   1: obj_1

Réciproquement, il faut mettre sur la pile la liste des profondeurs des objets symboliques, c’est-à-dire #2h pour une matrice, #1h pour un vecteur et #0h sinon:

stk n+2: liste de variables   ->
stk n+1: obj_n                ->
 ...                          -> stk   n: obj_n
stk   2: obj_1                ->      ....
stk   1: { #pn ... #p1 }      -> stk   1: obj_1

Exemple:

Le crochet de Poisson de 2 matrices est défini par:

{A, B} = A ∗ B − B ∗ A

(en mécanique quantique, c’est le symbole principal du commutateur de deux observables à h̄ près) On pourrait écrire le programme suivant:

« @ A, B -> A*B-B*A
   DUP2 0 MMULT 3 ROLLD SWAP 0 MMULT SUBT
   »

et le sauvegarder dans la variable POISSON. Si on essaie ce programme sur les deux matrices:

  A = { { X 'X+1' }     B = { { 'X-1' '3*X' }
        { 'X+2' 2 } }         { 'X^2+4'  7  } }

on obtient la réponse:

  { { 'X^3-2*X^2-2*X+4'   '2*X^2+X+8'        }
    { '-X^3+3*X^2-10*X-8' '-X^3+2*X^2+2*X-4' } }

après 9.2s. Si on modifie le programme en:

« #2 SXL
   DUP2 0 MMULT 3 ROLLD SWAP 0 MMULT SUBT
   { #2 } SXL
   »

on obtient la même réponse après 3.8s. Notez que l’argument #2 avant le premier appel à SXL signifie que le programme agit sur 2 arguments, alors que la liste { #2 } avant SXL signifie que la réponse est une matrice (profondeur 2) et non un polynôme ou un vecteur.

Notez que l’instruction MMULT permet d’effectuer des produits de différents types, selon l’argument

situé au niveau 1 de la pile, les arguments aux niveaux 2 et 3 sont:

• 0: matrice, matrice

• 1: matrice, vecteur colonne

• 2: matrice, scalaire,

• 3: vecteur, scalaire

• 6: scalaire, matrice

• 7: scalaire, vecteur

5 Intégration, transformée de Laplace inverse.

Les programmes risch, INT et LIN devraient vous permettre d’intégrer un assez grand nombre de

fonctions. Le programme INT permet également de calculer les transformées de Laplace inverse de fractions rationnelles propres. Enfin, le programme LDEC permet de résoudre des systèmes d’équations différentielles linéaires à coefficients constants.

5.1 Le programme risch

Le programme risch implémente une version partielle de l’agorithme de Risch pour intégrer des

fonctions en extension transcendente pure les unes par rapport aux autres. Pour l’instant les extensions multiples de type exponentiel ne doivent pas avoir de partie polynomiale. Exemples:

ln ln(x), \frac{1}{e^{ln(x)^{2}+1} − 1}, x^{3}e^{(^{\frac{x+1}{x+2}})}

Par contre, les fonctions suivantes:

\sqrt{x^{2} − 1}, e^{ln(x)^{2}+1}

ne peuvent être intégrées par risch car la première est une extension algébrique et la deuxième est une extension exponentielle sur un logarithme avec partie polynomiale. Notez que la primitive de \sqrt{x^{2} − 1} est calculable par INT.

Avant d’appeler risch, il peut être nécessaire d’utiliser TSIMP en mode complexe (flag 13 actif)

pour transformer les fonctions trigonométriques et trigonométriques inverses usuelles en exponentielles et en logarithmes indépendants. Après calcul de la primitive par risch, il est souvent nécessaire de refaire la conversion inverse à nouveau à l’aide de TSIMP en mode réel (flag 13 désactivé). Exemple:

\frac{sin(x)}{x^{2}} − \frac{cos(x)}{x}, arctan(x)

Dans le cas de fractions rationnelles en sin cos, utilisez plutôt INT, et pour des polynômes trigonométriques

LIN.

5.2 Utilisation normale de INT.

Placez vous dans le répertoire {HOME ALGB INTG}. Entrez, par exemple à l’aide d’EquationWriter,

une fraction rationnelle comme:

\frac{1}{x^{2} − 4},

sur le niveau 1 de la pile ('1/(X^2-4)'), puis choisissez le programme INT dans le menu. Choisissez ensuite ∫. Au bout de quelques secondes, la primitive apparaît sous la forme:

\frac{1}{4} ln(x − 2) + \frac{−1}{4} ln(x + 2),

au niveau 1 de la pile. Le résultat peut-être visualisé à l’aide d’EquationWriter, il suffit de taper sur ↓ . Si vous aviez choisi PF (pour partial fraction decomposition et non pour primitive formelle!) au lieu de ∫, le résultat aurait été:

\frac{1}{4} \frac{1}{x − 2} − \frac{1}{4} \frac{1}{x + 2}

la décomposition en éléments simples de la fraction.

La dernière primitive calculée est conservée dans la variable PRIMIT. Pour l’évaluer entre deux

bornes, rappelez si nécessaire la primitive sur la pile, puis tapez la borne inférieure et la borne supérieure et appelez enfin le programme PEVAL.

Vous pouvez également évaluer des intégrales au format habituel HP. Par exemple, tapez:

∫_{3}^{15} \frac{1}{X^{2} − 1} dX,

puis lancez INT. Le résultat formel exact apparait en 20 secondes environ (alors que →NUM effectue le calcul en 42s). Remarquez que la primitive formelle est toujours stockée dans la variable PRIMIT.

Normalement (!) ce programme intègre toutes les fractions rationnelles à coefficients réels ou

complexes, mais en cas de factorisation numérique, les erreurs de calcul s’additionnant, les résultats pourraient être mauvais. De plus en intégration formelle, les calculs peuvent s’allonger. Enfin, en calcul avec paramètres, il n’est pas sûr que la calculatrice arrive à factoriser le polynôme. Vous pouvez entrer par exemple:

\frac{1}{X^{2} − A^{2}} ou \frac{1}{X^{3} − A^{3}} (ce sera long)

mais pas:

\frac{1}{X^{4} + A^{4}}

En général la factorisation du dénominateur n’est pas assurée au-delà du degré 2 (le programme de factorisation détectera néanmoins les racines évidentes). Pour ce genre de polynôme, il est souvent intéressant de laisser le dénominateur sous forme la plus factorisée connue et d’armer l’indicateur 14. Par exemple pour x^{4} − a^{4}, le programme s’exécutera plus rapidement si vous entrez au dénominateur (X^2-A^2)(X^2+A^2) au

lieu de X^4-A^4.

Enfin, il est bien sûr impossible de prendre un degré qui ne soit pas de type entier (inutile d’essayer

\frac{1}{x^{2n}+1}, n ∈ IN).

Remarque 3 • Le rôle de l’indicateur utilisateur 13 est ici primordial. Si vous intégrez une fraction à coefficients réels et que vous désirez obtenir un résultat formel ne faisant pas intervenir les nombres complexes, désarmez le flag 13. Par exemple '1/(X^2+1)' INT donne avec le flag 13 armé:

     '(0,-1)/2*LN(X-(0,1))+(0,1)/2*LN(X-(0,-1))'

et avec le flag 13 désarmé 'ATAN(X)'.

• Attention, le contenu de la variable {ALGB INTG VX} est automatiquement modifié par le programme d’intégration (si vous intégrez systématiquement par rapport à x vous n’aurez jamais de problèmes).

5.3 Fractions trigonométriques.

Le programme d’intégration INT permet également d’intégrer des fractions rationnelles contenant

soit des sin x et cos x, soit des sinh x et cosh x. Attention, ils ne reconnaissent pas tan x, ni tanh x, ni d’ailleurs sin 2x ou autres...

La méthode d’intégration est le changement de variables y = tan \frac{x}{2} ou y = e^{x} selon le cas et

le résultat que vous obtiendrez sera une fraction rationnelle de y. Pour revenir à des sinus et cosinus (hyperboliques), les formules sont les suivantes:

tan \frac{x}{2} = \frac{1 − cos x}{sin x}, e^{x} = cosh x + sinh x

Par exemple, pour trouver la primitive de la cosécante ∫ \frac{1}{sin x} dx, on tape '1/SIN(X)' puis INT

et on obtient en 10 secondes: 'LN(TAN(X/2))'.

Remarque 4 Pourquoi y a-t-il des termes en FLOOR dans les primitives de fractions en sin x ou cos x? Dans l’intégration de fractions rationnelles en sin x, cos x, le changement de variables effectué n’est pas bijectif. La primitive obtenue n’est donc valable que localement. Pour la recoller sur IR tout entier, il faut recoller les arctangentes (lorsque cela est possible) en x = (2k + 1)π (k entier). Par exemple:

• pour \frac{1}{sin x}, c’est impossible (car l’intégrale diverge en x = kπ),

• pour \frac{1}{sin x+2}, on trouve comme primitive (flag 13 désarmé):

\frac{2}{3}\sqrt{3} arctan (\frac{tan \frac{x}{2} + \frac{1}{2}}{\frac{\sqrt{3}}{2}} ) ,

pour x = (2k +1)π, la tangente n’est pas définie, alors que la primitive l’est. Plaçons-nous par exemple en x = π^{−}. Notre résultat tend vers \frac{2}{3} \sqrt{3}\frac{π}{2} . Alors qu’en x = π^{+}, il tend vers −\frac{2}{3} \sqrt{3}\frac{π}{2} . Il faut donc rajouter 2 ∗ \frac{2}{3} \sqrt{3}\frac{π}{2} à notre résultat sur l’intervalle ]π, 3π[. Le même raisonnement en (2k + 1)π pour k entier conduit à la primitive sur IR tout entier:

∫ \frac{dx}{sin x + 2} = \frac{2}{3}\sqrt{3} arctan (\frac{tan \frac{x}{2} + \frac{1}{2}}{\frac{\sqrt{3}}{2}} ) + \frac{2\sqrt{3}}{3}πE(\frac{x − π}{2π}) + C.

Notez que le recollement des arctangeantes peut provoquer des erreurs d’évaluation par la HP, la moindre erreur d’arrondi pour x voisin de (2k + 1)π est fatale!

Exemples:

13 CF '1/((X^2+1)*(X^2+2))' INT -> 'ATAN(X)+-1/2*\v/2*ATAN(X/2*\v/2)'
13 SF '1/((X^2+1)*(X^2+2))' INT
     -> '(0,-1)/2*LN(X-(0,1))+(0,1)/2*LN(X-(0,-1))
        +(0,1)/4*\v/2*LN(X-(0,1)*\v/2)+(0,-1)/4*\v/2*LN(X-(0,-1)*\v/2)'
13 CF '\int(A,B,'1/SIN(X)',X)' INT -> 'LN(TAN(B/2))-LN(TAN(A/2))'
      (\int signifie int\'egrale, utilisez EquationWriter pour taper cet exemple)
      '1/(COSH(X)+1)' INT -> '-2/(e^X+1)'
      '1/(X^2+A^2)' INT -> '1/A*ATAN(X/A)'

5.4 Racines de trinômes du second degré.

Le programme INT peut intégrer des fractions rationnelles en deux variables: x et un trinôme du

second degré en x. Actuellement, seuls les trinômes hyperboliques et paraboliques sont traités dans le réel, les trinômes elliptiques sont traités dans le complexe (d’où des résultats peu exploitables). Par exemple,

'X/sqrt(X^2+X-2)' INT

renvoie:

\frac{1}{2}\sqrt{x^{2} + x − 2} + \frac{1}{2} ln(\sqrt{x^{2} + x − 2} − \frac{1}{2}) − \frac{9}{8} \frac{1}{\sqrt{x^{2} + x − 2} − \frac{1}{2}}

qu’on simplifie par EXPA en:

\frac{2 ln(\sqrt{x^{2} + x − 2} − \frac{1}{2}) + 1}{4} + \sqrt{x^{2} + x − 2}

5.5 Transformée de Laplace inverse.

L’option ILAP de INT calcule la transformée de Laplace inverse d’une fraction rationnelle réelle

propre (sans partie entière). Par exemple:

\frac{1}{x^{2} + a^{2}} → \frac{−1}{a} sin(−ax)

On peut en forçant le flag 16 obliger INT à effectuer une transformée inverse. L’appel de cette fonction désactive automatiquement le flag 13 (passage en mode réel).

Exemple d’application: Résolution d’une équation différentielle linéaire du second ordre à coeffi-

cients constants: Soit à résoudre:

y′′ + 5y′ + 6y = sin(2x), y(0) = −1, y′(0) = −2

On prend la transformée de Laplace des 2 membres:

p^{2}Y − py(0^{+}) − y′(0^{+}) + 5(pY − y(0^{+})) + 6Y = \frac{2}{p^{2} + 4}

D’où l’équation en Y:

(p^{2} + 5p + 6)Y = \frac{2}{p^{2} + 4} − p − 7

On en déduit Y puis par transformée inverse:

y(x) = \frac{−5}{52} cos(−2x) + \frac{−1}{52} sin(−2x) + \frac{−19}{4} exp(−2x) + \frac{50}{13} exp(−3 ∗ x)

5.6 Systèmes d’équations différentielles linéaires à coeffcients constants

Exemple: supposons qu’on souhaite résoudre le système:

\{ \begin{matrix}y′_{1}(x) & = & y_{1}(x) & − & y_{2}(x) & + & 1 \\ y′_{2}(x) & = & 2y_{1}(x) & + & 4y_{2}(x) & + & e^{x} \end{matrix}

avec conditions initiales y1(0) = y2(0) = 0.

Pour un équation différentielle linéaire à coefficients constants, la méthode classique utilise la

transformation de Laplace, par exemple pour résoudre:

ay′′ + by′ + cy = f(x)

on effectue la transformation de Laplace ce qui donne:

(ap^{2} + bp + c)L(y) = L(f)(p) + a(pf(0) + f′(0)) + bf(0)

où f(0) et f′(0) sont les conditions initiales. Si L(f) est une fraction rationnelle, INT ILAP permet de retrouver y par transforamtion inverse de:

(L(f)(p) + a(pf(0) + f′(0)) + bf(0)/(ap^{2} + bp + c)

Cette méthode fonctionne également pour des systèmes. Soit y = (y_{1}, ..., y_{n}) un vecteur de

fonctions de x et supposons qu’on souhaite résoudre:

y′ = Ay + b

où A est une matrice constante n × n et b un vecteur de n fonctions de x. Soit L(b) le vecteur des n transformées de Laplace des n fonctions de b et y(0) le vecteur de données initiales en x = 0. Alors, on a:

(pId − A)L(y) = L(b) + y(0)

d’où:

L(y) = (pId − A)^{−1}(L(b) + y(0))

Le programme LDEC effectue le calcul suivant:

(pId − A)^{−1}(L(b) + y(0))

la pile doit contenir A et L(b) + y(0).

stk2: A,

stk1: L(b) + y(0) LDEC -> (pId − A)^{−}1(L(b) + y(0))

Dans l’exemple ci-dessus, A est la matrice [ [ 1 -1 ] [ 2 4 ] ] et comme les transformées de

Laplace respectives de 1 et e^{x} sont 1/p et 1/(p − 1), on place L(b) + y(0) sur la pile: { '1/X' '1/(X-1)' } (on admet ici que VX a la valeur habituelle de 'X') On appelle LDEC, ce qui donne:

{ '(X^2-6*X+4)/(X^2-X)/((X-3)*(X-2))' '(X+2)/X/((X-3)*(X-2))' } which is the { Laplace(y_{1} ) Laplace(y_{2})

}. Pour en déduire y_{1} et y_{2}, on tape maintenat EVAL puis INT ILAP pour chaque coordonnée. On obtient ainsi:

\{ \begin{matrix}y_{1} & = & −1/2 ∗ e^{x} − 2/3 + 2 ∗ e^{2x} − 5/6 ∗ e^{3x} \\ y_{2} & = & 1/3 − 2 ∗ e^{2x} + 5/3 ∗ e^{3x} \end{matrix}

Si les données initiales sont y_{1}(0) = 1, y_{2}(0) = 2 on reprend la même procédure en remplaçant { '1/X' '1/(X-1)' }

par { '1/X+1' '1/(X-1)+2' }..

5.7 Linéarisations.

Le programme LIN permet de linéariser des polynômes en sin x, cos x ou en sinh x, cosh x. On peut

placer sur la pile soit un complexe, soit une expression algébrique en c, s, soit une liste de listes (par rapport à la liste de variables { s c }), on obtient un résultat algébrique en clair. Le complexe (r, i) représente cos^{r} x sin^{i} x ou cosh^{r} x sinh^{i} x, pour s’en souvenir on pourra se rappeler que e^{iα} = cos α + i sin α ce qui justifie le choix de l’exposant de cos x en partie réelle.

L’entrée d’une liste de listes ou d’un complexe est plus rapide que celle d’un polynôme en c et s.

Exemples:

(1,1) LIN COS -> '1/2*SIN(2*X)'
(2,0) LIN COSH -> '1/2+1/2*COSH(2*X)'
'c*s+c^2*s^2' LIN COS -> '1/2*SIN(2*X)+1/8-1/8*COS(4*X)'
{ { 2 1 } { 3 4 1 } 2 } equivaut a '(2*c+1)*s^2+(3*c^2+4*c+1)*s+2'

Il ne reste alors qu’à taper PINTG (touche α-∫ en mode USER) pour en déduire la primitive.

5.8 Changement de variables.

Il faut pour l’instant exprimer la variable d’intégration par une expression ne faisant intervenir

qu’une seule fois la nouvelle variable, par exemple 'X=SIN(Y)+1' mais pas 'X=(Y-1)/(Y-3)' (ici, il faudrait utiliser 'X=1-2/(Y-3)'). On utilise alors l’instruction EXEC comme pour une substitution ordinaire.

Notez aussi que la présence de paramètres peut fausser l’interprétation de la nouvelle variable (il

s’agit d’une fonctionnalité qui n’est pas encore au point).

5.9 Entrée pour programmeurs.

Il est possible d’utiliser INT en mode liste pour intégrer ou décomposer des fractions rationnelles.

Armez le flag 17 si ce n’est pas fait. Entrez alors le numérateur sous forme de polynôme-liste et les racines du dénominateur sous forme de liste puis le dénominateur-liste (pour le dénominateur vous avez le choix entre entrer la liste des racines, dupliquer et taper pcoef ou entrer le dénominateur liste, taper FROOTS et supprimez le niveaux 3). Ensuite armez ou désarmez l’indicateur 19 (19 SF ou 19 CF) selon que vous désirez la primitive ou la décomposition en éléments simples de la fraction rationnelle. Vérifiez que l’indicateur 13 est dans la position souhaitée (armé: mode complexe, désarmé: mode réel). Enfin tapez INT. Le résultat apparaît aux niveaux 2 (liste alternant les pôles et les coefficients de la décomposition) et 1 (partie entière), le temps de calcul est très variable.

Exemples: Soit à décomposer en éléments simples: •

\frac{X + 2}{(X − 1)(X + 1)^{2}} = \frac{3}{4} \frac{1}{X − 1} − \frac{1}{2}.\frac{1}{(X + 1)^{2}} − \frac{3}{4}.\frac{1}{X + 1}.

On entre {1 2} puis {1 -1 -1} puis ENTER puis pcoef, ensuite on tape 19 CF puis INT. La décomposition apparaît alors:

     2: {1 '3/4' -1 '-1/2' -1 '-3/4'}, 1: { 0 }.

•

\frac{X}{X^{2} − 2} = \frac{1}{2}.\frac{1}{X − \sqrt{2}} + \frac{1}{2}.\frac{1}{X + \sqrt{2}}

On entre {1 0} puis le dénominateur-liste {1 0 -2}, puis α-shift droit- SOLVE (en mode user, sinon il faut taper FROOT), on supprime le niveau 3 (en tapant ROT DROP) et enfin INT et on obtient:

     2: { '-V2' '1/2' 'V2' '1/2'}, 1: { 0 }

6 Réduction et diagonalisation des matrices.

Ces programmes se trouvent dans le répertoire {ALGB MATR}. Remarques préliminaires:

• la dernière matrice entrée au clavier est enregistrée par DIAG et par RED (si elle contient un paramètre au moins pour RED) dans la variable MATRIX. Pour la rappeller sur la pile, tapez simplement MATRIX, pour un système tapez ensuite EVAL

• Vous pouvez supprimer certains des programmes de ce répertoire, notez toutefois que:

– PCAR utilise DET (ce dernier n’a besoin que de la bibliothèque) (DET+PCAR=300 octets)

– DIAG utilise REDLIB (DIAG=1000 octets)

– RED utilise REDLIB (RED=800 octets)

• REDLIB n’est pas prévu pour être appelé par un programme écrit en RPL usuel, cet objet contient les routines de réduction sous forme échelonnée et peut être appelé par des programmes écrits en RPL système (voyez le fichier source matr.s).

6.1 Réduction des matrices par l’algorithme du pivot partiel.

Pour réduire une matrice, entrez la matrice sur le niveau 1 de la pile (si la matrice ne contient

pas de paramètres, vous pouvez utiliser MatrixWriter, sinon il faut rentrer une liste de listes, en d’autres termes remplacer les crochets [ ] par des accolades {}) puis lancez le programme RED.

Vous avez alors le choix entre RED qui crée des 0 de part et d’autre de la diagonale ou RANG qui

crée des 0 sous la diagonale. Attention: le programme considère que la dernière colonne est une colonne de constantes (2ème membre d’un système par exemple), et ne crée pas de 0 dans cette colonne. Si nécessaire, ajoutez une colonne de zéros!

Si le flag 1 est armé, les étapes intermédiaires de la réduction sont affichées, l’utilisateur doit

appuyer sur CONT (la touche-menu en haut à droite) à chaque étape. Il peut également interrompre la réduction en tapant HALT par exemple pour visualiser complètement une grande matrice. La reprise du programme s’effectue alors par CONT (la touche en bas du clavier).

Le pivot choisi est l’élément du reste de la colonne dont le module est maximal. Par convention:

• un scalaire nul a comme module -8,

• un scalaire non nul a comme module sa valeur absolue lorsque le flag 15 est désarmé ou 1 pour un complexe et 2 pour un réel lorsque le flag 15 est armé,

• un identificateur global a pour module \frac{−1}{180},

• un algébrique ou une liste −\frac{l}{180}, où l est le nombre d’éléments de l’algébrique.

En mode symbolique (flag 15 armé), on limite ainsi les cas particuliers et on facilite leur résolution, alors qu’en mode numérique on minimise les erreurs d’arrondi (meilleure stabilité).

A la fin de la réduction, vous voyez au niveau 2 la liste des pivots. Chaque fois qu’un pivot

de type symbolique s’annule, il faut reprendre la réduction dans ce cas particulier. Si vous savez résoudre l’équation pivot=0 , rappelez la matrice originale sur la pile (tapez MATRIX) puis tapez une équation du type '<parametre>=valeur' puis L2S (ou α-shift droit- EVAL en mode User) et enfin à nouveau RED.

Par exemple, supposons que l’on résolve le système:

\{ \begin{matrix}mx & + & y & = & −2 \\ mx & + & (m − 1)y & = & 2 \end{matrix}

Pour m ≠ 2 et m ≠ 0, il y a une solution unique obtenue en tapant

{ {M 1 -2} { M 'M-1' 2 } }

puis RED RED qui donne au niveau 1:

{ { '-M^2+2*M' 0 '2*M' } { 0 '2-M' -4 } }.

C’est-à-dire que:

x = \frac{2m}{2m − m^{2}} = \frac{−2}{m − 2}, y = \frac{4}{m − 2}.

Au niveau 2 de la pile se trouvent la liste des pivots. Le pivot 'M^2+-2*M' s’annule lorsque m = 2 et m = 0 et on s’aperçoit qu’il n’y a pas d’autres cas particuliers. Pour réduire le système lorsque m = 0 par exemple, rappelez la matrice au niveau 1 (en tapant MATRIX), puis tapez 'M=0' suivi de L2S (ou α-shift-EVAL en mode user) puis relancez RED RED (on obtient ainsi x quelconque et y = −2). Pour le cas m = 2, recommencez la même opération.

A noter que les sous-programmes SYST et SOLGEN sont prévus spécialement pour résoudre les

systèmes linéaires. Au niveau 1 de la pile vous rajoutez la liste des variables et le coefficient multiplicateur de la colonne des coefficients constants (-1 si les coefficients constants sont à droite du signe “=", 1 sinon). Vous obtenez alors les inconnues principales en fonction des inconnues auxiliaires et les équations de compatibilité sur les paramètres (attention, les inconnues auxiliaires peuvent ne pas apparaître dans l’expression des inconnues principales, mais la liste des inconnues au niveau 3 est ordonnée de la façon suivante: inconnues principales, inconnues auxiliaires, la coupure est faite par le terme 1 ou -1 s’il y a des termes constant sinon il faut comparer avec la liste originale). Par exemple, pour le système ci-dessus, le niveau 1 doit contenir {X Y -1} et le niveau 2 la matrice

{ {M 1 -2} {M 'M-1' 2} }

On obtient alors la solution unique du cas général:

{ :'X': '2/(-M+2)' :'Y': '4/(M+-2)' }

Ici, il n’y a pas d’inconnues auxiliaires (le niveau 2 contient { X Y -1} identique au niveau 3). Les cas particuliers sont au niveau 2. Pour m = 0, on reprend la liste de variables et la matrice de départ (tapez MATRIX puis EVAL (non-shifté car il s’agit de décomposer la liste du niveau 1 en 2 listes) puis → (pour SWAP) puis 'M=0' L2S et encore → ), ce qui donne:

2: { { 0 1 -2} { 0 -1 2 } }
1: { X Y Z -1}

on tape enfin RED puis SYST et on obtient la solution générale:

{ :'Y': -2  }

donc les deux équations sont compatibles et y = −2. De plus au niveau 2, la liste des variables est {Y -1 X} donc x est une inconnue auxiliaire (en d’autres termes x est quelconque). En général les inconnues auxiliaires apparaissent dans l’expression des inconnues principales (ce n’est pas le cas ici). Pour m = 2, on obtient:

{ :'X': '-1-1/2*Y' :-1: 0 }

donc les équations sont incompatibles car −1 ≠ 0.

Vous pouvez aussi obtenir une représentation paramétrique de l’espace des solutions d’un sys-

tème en tapant SOLGEN au lieu de SYST. Le niveau 1 contient alors la solution générale et les équations de compatibilité. Sur l’exemple précédent (m = 0), on obtient ainsi au niveau 1:

If { }, { X Y }=: { X -2 }

L’option INVL de RED permet d’inverser une matrice carrée placée au niveau 1 de la pile. Son

intérêt est d’inverser des matrices avec paramètres, fractions et racines carrées (à condition qu’il n’y ait pas trop de paramètres, sinon les calculs seront pénibles et longs),

Enfin, l’option DET de RED calcule le déterminant d’une matrice carrée par réduction. Ce qui

permet parfois d’obtenir le déterminant sous forme factorisée, contrairement au programme DET qui renvoie toujours un résultat non factorisé. Vous pouvez naturellement poursuivre la factorisation en tapant COLC. Notez que le résutat peut avoir un dénominateur, dans ce cas utilisez EXPA pour le supprimer (parfois on peut aussi utiliser COLC suivi de COLCT).

Schémas de pile des programmes appelés par RED

Programme Option  Entrée  Sortie
RED  RANG  1: matrice  2: pivots, 1: matrice réduite
RED  RED  1: matrice  2: pivots, 1: matrice réduite
RED  DET  1: matrice  3: pivots, 2: matrice réduite, 1:déterminant
RED  INVL  1: matrice  2: pivots, 1: inverse
RED  SYST  2: matrice, 1: liste var 4: liste de variables,

3: liste de variables principales et auxiliaires 2: liste des pivots 1: liste d’algébriques taggués

RED  SOLGEN 2: matrice, 1: liste var 5: pivots, 4: liste de variables,

3: liste de variables principales et auxiliaires 2: liste d’algébriques taggués, 1: résultat

Quelques exemples d’utilisation:

• Réduire un système:

Exemple:

\{ \begin{matrix}x + ay + z & = & 1 \\ 2x + 2ay + az & = & 2 + b \\ x + y − z & = & 1 + b \end{matrix} .

Vous entrez sur la pile:

{ {1 A 1 1} {2 '2*A' A '2+B'} {1 1 -1  '1+B'} }

puis vous tapez RED RED . Vous obtenez sur la pile:

– au niveau 2, la liste des pivots,

    { 1 1 -1 'A-1' '-A+2' '-A+2' }

ici le sytème est singulier si a = 1 ou si a = 2: il y a deux cas particuliers à étudier.

– au niveau 1, la matrice réduite:

    { { '-A^2+3*A+2' 0 0 '(-A^2+A-1)*B+(-A^2+3*A-2)' }
      { 0 'A^2+-3*A+2' 0 '-A*B' }
      { 0 0 'A+-2' B } }

donc le système admet une solution unique (si a ≠ 1 et a ≠ 2):

x = b\frac{−a^{2} + a + 1}{−a^{2} + 3a + 2} + 1, y = \frac{ab}{2 − a^{2} + 3a}, z = −\frac{b}{2a}.

Vous pouviez aussi taper { X Y Z -1} après la matrice de coefficients puis RED et enfin SYST ou

 SOLGEN .

• Pour déterminer le rang d’une matrice, par exemple:

( \begin{matrix}1 & 2 & 4 & 6 \\ −1 & 3 & 5 & 7 \\ 2 & 1 & 0 & 1 \\ 2 & 6 & 9 & 14 \end{matrix} ) ,

vous entrez les coefficients (par exemple avec MatrixWriter) puis vous tapez RED et RANG , le rang est le nombre de coefficients diagonaux non nuls (ici 3).

• Même question mais avec un paramètre:

{ { 1 1 M } { 1 M 1 } { M 1 1 } } RED RANG

La matrice réduite est:

{ { 1 1 M } { 0 '-1+M' '1-M' } { 0 0 '2-M-M^2' } }

Au niveau 2, on voit un cas particulier m = 1. Pour l’étudier, tapez simplement MATRIX puis 'M=1' puis L2S (ou α-shift- EVAL en mode USER) et relancez RED RANG . Essayez à nouveau cet exemple mais après avoir éteint l’indicateur 1 (1 CF) et comparez la vitesse d’exécution.

• Recherche de relations entre vecteurs.

Supposons que l’on cherche à la fois le rang d’une famille {v_{1}, v_{2}, v_{3}} et les relations linéaires entre les vecteurs v_{1}, v_{2} et v_{3}. On rentre les coordonnées de v_{1} en ligne suivie de V1, puis celles de v_{2} suivies de V2 et enfin celles de v_{3} suivies de V3 puis on tape RED RANG . Si une ligne de coordonnées nulle apparaît, on a alors une relation linéaire entre les trois vecteurs (et le rang est le nombre de lignes non nulles). Par exemple si v_{1}(1, 2, 0), v_{2}(−2, −1, 1), v_{3}(0, 3, 1), on entre:

{ { 1 2 0 V1 }
  { -2 -1 1 V2 }
  { 0 3 1 V3 } }

puis RED, RANG et on obtient:

{ { 1 2 0 V1 }
  { 0 3 1 '2*V1+V2' }
  { 0 0 0 '-(2*V1)-V2+V3' } }

donc la famille est de rang 2 et on a −2v_{1} − v_{2} + v_{3} = 0.

• Calcul d’inverse par la méthode du pivot de Gauß .

Exemple:

{ { '1/2' -1 }
  { 1    '2/3' } }
RED INVL
-> { { '1/2' '3/4'  }
     { '-3/4' '3/8' } }

• calcul d’un déterminant par réduction:

{ { 1 T T T }
  { 1 K T T }
  { 1 T K T }
  { 1 T T K } }
RED DET -> '(-T+K)*(-T+K)*(-T+K)'

Sur cet exemple particulièrement bien adapté, le déterminant est factorisé.

Remarque 5 • Armer le flag 1 permet d’afficher les étapes intermédiaires de la réduction. Cela diminue évidemment la vitesse de la réduction, puisque l’utilisateur doit taper sur CONT à chaque étape.

• Sur les modèles G/GX, on peut aussi utiliser les instructions RREF et LU qui sont plus rapides dans le cas des matrices numériques. Mais, contrairement à RED, ces routines n’indiquent pas les étapes intermédiaires et ne traitent pas les matrices symboliques.

• Dans les exemples pédagogiques, la réduction de Gauß devrait amener à des simplifications!

6.2 Diagonalisation (algorithme de Laguerre-Souriau-Faddeev).

Le programme DIAG permet de diagonaliser (ou de mettre sous forme de Jordan) une matrice.

Vérifiez que l’indicateur 13 est armé.

Vous fournissez au niveau 1 de la pile la matrice et le programme renvoie aux niveaux:

• 1: liste des racines du polynôme caractéristique (répétées si elles sont multiples), • 2: liste de vecteurs propres taggués par la valeur propre correspondante. Si la valeur propre est

multiple, elle est suivie d’une liste de vecteurs caractéristiques ordonnées en cycles de Jordan, chaque cycle se termine par un vecteur propre taggué par le mot "Eigen" (les vecteurs caractéristiques sont taggués par "Char").

• 3: polynôme minimal (sous forme liste),

• 4: polynôme caractéristique (sous forme liste), c’est un multiple du polynôme minimal,

• 5: polynôme-matrice adjoint “réduit". Ce polynôme-liste à coefficients matriciels est le polynôme P défini par (cf. [6, chapitre 5]):

M(A) − M(λ).I_{n} = M(λ).I_{n} = (A − λ)P (λ).

où M désigne le polynôme minimal de la matrice A. La dernière matrice de ce polynôme-liste est la comatrice de A au signe près si l’ordre est pair.

• 6: l’inverse de A

• 7: le déterminant de A si A est d’ordre pair ou son opposé si l’ordre est impair,

Exemples:

1.

A = ( \begin{matrix}1 & −1 & 0 \\ 0 & 1 & −1 \\ −1 & 0 & 1 \end{matrix} )

le programme renvoie après environ 40 secondes (en mode symbolique):

7: 0
6: { { '1/0' '1/0' '1/0' }
     { '1/0' '1/0' '1/0' }
     { '1/0' '1/0' '1/0' } }
5: { {{1 0 0}  {{-2 -1 0}  {{1 1 1}
      {0 1 0}   {0 -2 -1}   {1 1 1}
      {0 0 1}}  {-1 0 -2}}  {1 1 1}} }
4: {1 -3 3 0}
3: {1 -3 3 0}
2: { :0: {1 1 1}
     :«(3,0)/2 (0,1)/2 3»: {1 '(-1,0)/2+(0,-1)/2*V3' '(-1,0)/2+(0,1)/2*V3'}
     :« (3,0)/2 (0,-1)/2 3»: {1 '(-1,0)/2+(0,1)/2*V3' '(-1,0)/2+(0,-1)/2*V3'}
1: {0 '(3,0)/2+(0,1)/2*V3' '(3,0)/2+(0,1)/2*V3' }

Donc A possède 3 valeurs propres \frac{3±\sqrt{3}i}{2}, et une base de vecteurs propres est donnée par:

\{(1, 1, 1), (1, \frac{−1 ∓ i\sqrt{3}}{2}, \frac{−1 ± i\sqrt{3}}{2})\}

correspondants à 0, (3+\sqrt{3}i)/2, (3−\sqrt{3}i)/2. Le polynôme minimal et le polynôme caractéristique sont ici identiques (c’est le cas générique) et valent X^{3} − 3X^{2} + 3X. La matrice n’est pas inversible (les coefficients de l’inverse sont invalides), son déterminant au niveau 7 est nul.

2. Pour la matrice identité I_{2}, on obtient en 10 secondes:

7: 1
6: { { 1 0 } { 0 1 } }
5: { [[1 0]

      [0 1]] }
4: {1 -2 1}
3: {1 -1}
1: { :1, Eigen: { 0 1 } :1, Eigen: { 1 0 } }
2: {1 1}

ici le polynôme minimal est X −1, il est différent du polynôme caractéristique (X −1)^{2} = X^{2} −2X +1. Les deux vecteurs propres calculés sont { 1 0 } et { 0 1 } (Eigen est là pour Eigenvector c’est-à-dire vecteur propre, ce qui diffère de Char pour vecteur caractéristique cf. infra l’exemple de bloc de Jordan).

3.

( \begin{matrix}1 & 2 & 1 \\ 2 & 0 & 0 \\ 1 & 0 & 3 \end{matrix} )

en un peu moins d’une minute, on obtient les 3 valeurs propres 1±\sqrt{7} et 2 de vecteurs propres associés (1 ± \sqrt{7}, 2, 3 ± \sqrt{7}) et (1, 1, −1).

4. Un exemple avec paramètres qui est traité automatiquement en 12 secondes:

{ { 1 A }
  { A 1 } }

5. Pour les matrices à paramètres de dimension supérieure ou égale à 3, il peut être nécessaire d’appeler MAD, et de factoriser séparément le polynôme caractéristique (par exemple avec l’instruction FCTR de ALG48), avant d’appeler DIAG. On peut ainsi diagonaliser

{ { 1 1 A }
  { 1 A 1 }
  { A 1 1 } }

directement en tapant DIAG (1 minute environ) ou en suivant la procédure par étapes décrite ci-dessous: On appelle MAD qui renvoie en le polynôme caractéristique:

'X^3+(-A-2)*X^2+(-A^2+2*A-1)*X+A^3-3*A+2'}

On factorise avec COLC ou FCTR, et on appelle enfin DIAG pour terminer la diagonalisation:

λ = a + 2 : (1, 1, 1), λ = a − 1 : (1, −2, 1), λ = 1 − a : (1, 0, −1)

(les vecteurs propres ne dépendent pas de a).

6. Un exemple de bloc de Jordan:

A = ( \begin{matrix}3 & −1 & 1 \\ 2 & 0 & 1 \\ 1 & −1 & 2 \end{matrix} ) ,

donne:

7: -4
6: : { { '1/4' '1/4' '-1/4' }
       { '-3/4' '5/4' '-1/4' }
       { '-1/2' '1/2' '1/2'  } }
5: { [[ 1 0 0]  [[ -2 -1  1]  [[ 1 1 -1]
      [ 0 1 0]   [  2 -5  1]   [-3 5 -1]
      [ 0 0 1]]  [  1 -1 -3]]  [-2 2  2]] }
4: {1 -5 8 -4}
3: {1 -5 8 -4}
2: { :2, Char: { 2 2 1 }  :2, Eigen:{ 1 1 0 }  :1: { 0 1 1 } }
1: { 2 2 1}

ce qui signifie que 1 est valeur propre simple et 2 valeur propre double mais l’espace propre associé est de dimension 1 (engendré par (1, 1, 0)). Le vecteur (2, 2, 1) est caractéristique, son image par A − 2I est le vecteur suivant de la chaîne(i.e. (1, 1, 0)). Les chaînes de Jordan commencent par un vecteur caractéristique (Char) et se terminent par un vecteur propre (Eigen).

Remarque 6 Sur les modèles G/GX, on pourrait se demander s’il est utile de conserver cet algorithme de diagonalisation. En fait, pour de petites matrices numériques (probablement jusqu’à la taille 5), la diagonalisation par DIAG est presque 2 fois plus rapide que par l’instruction intégrée EGVL. De plus, l’instruction intégrée étant numérique, elle ne peut pas rechercher de cycles de Jordan, ni bien sûr traiter de petites matrices à paramètres.

En général les matrices à paramètres ne sont pas diagonalisable formellement, sauf si le polynôme

caractéristique admet des racines évidentes.

6.3 Déterminant.

Entrez simplement la matrice puis tapez DET. Par exemple:

{ { 1 1 A }
  { 1 A 1 }
  { A 1 1 } }
DET -> '2-3*A-A^3'

Vous pouvez également obtenir le polynôme caractéristique d’une matrice en tapant PCAR.

6.4 Produit vectoriel.

Le programme cross effectue le produit vectoriel de deux vecteurs symboliques ou numériques

de I C^{3},

7 Fonctions

7.1 Développements limités.

Le programme 'TAYLR' du répertoire 'ALGB FUNC' effectue l’équivalent de l’instruction intégrée

de même nom mais avec deux extensions: la possibilité de faire un développement en un autre point que x = 0 et de faire dans une mesure très limitée des développements asymptotiques.

Rappelons la syntaxe de la commande TAYLR: au niveau 1 on entre une expression algébrique (la

fonction), au niveau 2 un nom global (la variable) et au niveau 1 un entier positif (l’ordre souhaité). Le programme accepte également au niveau 2 une expression du type 'nom global=valeur pour effectuer un développement limité ailleurs qu’en 0. Il renvoie le développement limité sous forme algébrique au niveau 1, et sous forme liste, valuation aux niveaux 2 et 3.

Exemples:

• Déterminer le développement limité de sin(x) en x = 0 à l’ordre 3:

     'SIN(X)' 'X' 3 TAYLR ->
     3: 0
     2: { 0 1 0 '-1/6' }
     1: 'X+-1/6*X^3'

• Déterminer le développement limité de e^{x} en x = 1 à l’ordre 4:

     'EXP(X)' 'X=1' 4 TAYLR ->
     3: 0
     2: { 'e' 'e' 'e/2' 'e/6' 'e/24' }
     1: 'e+e*(X-1)+e/2*(X-1)^2+e/6*(X-1)^3+e/24*(X-1)^4'

Remarque 7 Résolution des formes indéterminées et développement asymptotiques: Dans sa version actuelle, TAYLR résoud les formes indéterminées suivantes:

• division de deux monômes, le numérateur s’annulant à un ordre supérieur à l’ordre d’annulation du dénominateur au point considéré, par exemple 'X/(X+X^2)' X 3 TAYLR renvoie '1-X+X^2' (notez que l’on a perdu un ordre au passage)

• division de deux monômes, le numérateur s’annulant à un ordre inférieur à l’ordre d’annulation du dénominateur au point considéré. Le résultat renvoyé est un développement asymptotique, par exemple '1/(X+X^2)' X 3 TAYLR renvoie '(1-X+X^2)/X' (notez que l’on a aussi perdu un ordre au passage)

7.2 Transformation de cos nx et sin nx en polynômes de cos x et sin x.

Le programme COSN effectue l’inverse d’une linéarisation (LIN du répertoire INTG): il permet de

transformer cos(nx) et sin(nx) en polynômes de c = cos x et s = sin x. On entre l’entier n au niveau 1, le programme revoie cos(nx) au niveau 1 et sin(nx) au niveau 2. Par exemple:

2 COSN -> 2: '2*s*c', 1:'2c^2-1'.

Ce qui signifie que sin 2x = 2 sin x cos x et cos 2x = 2 cos^{2} x − 1 mais ces 2 égalités sont également vraies si vous remplacez toute les lignes trigonométriques par leurs équivalents hyperboliques (attention, ce dernier fait n’est pas exact pour n’importe quel polynôme trigonométrique!).

Remarque 8 Il est également possible de placer sur la pile un entier négatif, dans ce cas COSN renvoie deux listes de listes, ce qui est moins lisible mais plus facile à manipuler par un programme.

7.3 Dérivée et gradient.

Le programme DER calcule la dérivée d’une (liste de) fonction(s) par rapport à 1 variable ou le

gradient d’une (liste de) fonction(s) par rapport à une liste de variables. Exemple:

2: { 'X^2+LN(X)' 'X*Y' }
1: X
-> { '2*X+INV(X)' 'Y' }
2: 'X^2+2*X*LN(Y)-1/Y'
1:{ X Y }
->  { '2*X+2*LN(Y)' '2*X*(1/Y)+1/Y^2' }

Il est presque identique au programme intégré, la différence principale est que les expressions comme \sqrt{2} ou \frac{1}{3} ne sont pas évaluées. Une autre différence apparaît lorsqu’on dérive des fonctions utilisateurs. La notation de la HP 'derZ(X,1)' ne me paraît pas naturelle pour la dérivée de la fonction 'Z(X)', elle le devient encore moins pour des fonctions à plusieurs variables. J’ai décidé d’introduire les notations usuelles dans le domaine des équations aux dérivées partielles: ∂_{k}f désigne la dérivée partielle de f par rapport à la kième variable. Donc 'Z(X)' X DER renvoie ∂_{1}z(x). Remarquez que pour rentrer la définition d’une fonction dérivée utilisateur, il faut la créer sur la pile à l’aide de dérivation(s), puis entrer la formule définissant ∂_{1}z, et enfin taper = DEFINE. L’avantage est qu’on a ainsi un résultat plus habituel pour par exemple

'Z(X,X^2)' X DER.

8 Arithmétique.

Dans le répertoire ARIT sont regroupés quelques utilitaires d’arithmétique entière et polynômiale.

Les autres utilitaires d’arithmétique sont dans la bibliothèque (cf. section 10.6).

• EULER retourne l’indicatrice d’Euler d’un entier (i.e. le nombre d’entiers naturels p ∈ [1, n] premiers avec n), par exemple l’indicatrice d’Euler de 12 est 4 car seuls 1,5,7,11 sont inférieurs à 12 et premiers avec 12.

• Le programme CAB permet de résoudre une équation de type Bezout pour des polynômes:

ax + by = c

où a, b et c sont trois polynômes (tels que le PGCD de a et b divise c sinon il n’y a pas de solutions). Vous entrez dans l’ordre c, a, b sur la pile et le programme renvoie x et y aux niveaux 3 et 2 et 1 au niveau 1 s’il y a une solution, ou 0 au niveau 1 s’il n’y a pas de solutions.

Exemples:

* 1 'X^2+2*X+1' 'X^2+2*X+3' -> -1 1 1
* 1 'X^2+2*X+1' 'X^2+2*X+3' -> 0

Dans le premier cas, on a:

(X + 1) = −(X^{2} + 2X + 1) ∗ (−1) + (X^{2} + 3X + 2) ∗ 1

alors que dans le second cas il n’y a pas de solution, car le PGCD de x^{2} + 1 ∗ x + 1 et x^{2} + 3 ∗ x + 2 ne divise pas 1.

• FCLI: transforme un réel positif en une liste qui est le début de son développement en fraction continuée ou en une fraction. Par exemple, 1.75 FCLI donne '7/4', alors que π →NUM FCLI renvoie { 3 7 15 1} qui correspond à:

3 + \frac{1}{7 + \frac{1}{15+ \frac{1}{1}}} = \frac{355}{113}.

La longueur du développement dépend de la valeur de ε (on suppose que le réel au niveau 1 est connu à ε près).

• LIFC: transforme une liste en numérateur et dénominateur, par exemple {3 7 15 1} LIFC donne 355 au niveau 2 et 113 au niveau 1.

• XFRC: transforme un objet algébrique, réel ou complexe ou une liste contenant des objets de ce type à la manière de l’instruction intégrée →Q mais en détectant les nombres quadratiques. Par exemple: 1.20710678118 devient '1/2+1/2*\v/2' et 1.5 '3/2'.

• ORND (object round) permet d’éliminer des erreurs d’arrondis. Cette fonction sert à remplacer des expressions du type 0.4999999999 par 0.5 ce qui est surtout utile dans les expressions algébriques . Il faut connaître le dénominateur supposé commun à toute l’expression algébrique (2 dans l’exemple). On met au niveau 2 l’expression algébrique (ou un objet plus simple) et au niveau 1 le dénominateur, la fonction renvoie l’expression algébrique nettoyée. L’intérêt de cette fonction par rapport à →Q est que le résultat est plus rapide à évaluer par →NUM. Supposons par exemple que sur le niveau 1 de la pile se trouve l’expression:

'1.33333333341*LN(X-1.49999999997)'

On voit facilement que le facteur du ln est '4/3' et que l’autre réel est '3/2'. Pour remplacer l’expression ci-dessus par:

'4/3*LN(X-3/2)'

(sans l’éditer) il suffit de taper →Q. Pour la remplacer par:

'1.33333333333*LN(X-1.5)'

il faut taper 6 ORND. (Ici, on a pris ε = 10^{−10}),

9 Forme quadratiques.

Ces programmes se trouvent dans le répertoire {ALGB QUAD}. Pour effectuer des calculs plus

rapidement, on peut désarmer le flag 15.

L’utilitaire principal est GAUSS qui réduit une forme quadratique q en somme et différence de carrés

de formes linéaires indépendantes. Au niveau 1 de la pile, on place la matrice A de la forme quadratique q, le programme renvoie au niveau 2 la diagonale de la matrice D de la forme quadratique réduite et au niveau 1 la matrice P des formes linéaires (écrite en ligne). On a l’égalité:

A = ^{t}P DP

de sorte que

q(X) = ^{t}XAX = ^{t}(P X)DP X

est somme des carrés des formes linéaires ayant pour coordonnées celles de P X affectées des coefficients correspondants de D. Pour trouver une base orthogonale de q, il suffit d’inverser la matrice P, les colonnes de P^{−1} sont alors les coordonnées d’une base orthogonale. Si l’on s’intéresse plutôt à l’aspect décomposition en sommes de carrés, on donne l’expression symbolique comme argument de GAUSS qui renvoie alors D, P, A, la liste des variables, et un symbolique (cf. les exemples plus bas)

Exemple|

Considérons q(x, y) = 4x^{2} + 2xy − 3y^{2}, la matrice de q est:

A = ( \begin{matrix}4 & 1 \\ 1 & −3 \end{matrix} ) ,

(pour trouver la matrice de q à partir de l’expression algébrique '4*X^2+2*X*Y-3*Y^2' entrez encore la liste des variables { X Y} puis tapez SYMXA). On appelle GAUSS qui renvoie:

2: { '1/4' '-13/4' }
1: { { 4 1 } { 0 1 } }

ce qui signifie que:

A = ( \begin{matrix}4 & 0 \\ 1 & 1 \end{matrix} ) ( \begin{matrix}′1/4′ & 0 \\ 0 & ′ − 13/4′ \end{matrix} ) ( \begin{matrix}4 & 1 \\ 0 & 1 \end{matrix} ) .

Au niveau des formes quadratiques, on a:

q(x, y) = 4x^{2} + 2xy − 3y^{2} = \frac{1}{4}(4x + y)^{2} − \frac{13}{4}y^{2}.

égalité que l’on peut obtenir directement en appelant GAUSS avec comme argument la forme algébrique de q au lieu de sa représentation matricielle.

Pour obtenir une base orthogonale de q, on inverse P, ce qui donne (en tapant L→A puis 1/x)

P^{−1} = ( \begin{matrix}′1/4′ & ′ − 1/4′ \\ 0 & 1 \end{matrix} ) ,

donc les vecteurs u⃗(\frac{1}{4}, 0) et v⃗(−\frac{1}{4}, 1) forment une base orthogonale pour q (on a bien q(u⃗) = \frac{1}{4} q(v⃗) = −\frac{13}{4} et ϕ(u, v) = 0, on retrouve les coefficients diagonaux de D).

Exemples

'X^2+4*X*Y-2*X*Z+4*Y^2+6*Y*Z+7*Z^2' GAUSS
5: { 1 '-25/6' '1/6' }
4: { { 1 2 -1 } { 0 1 0 } { 0 5 6 } }
3: { { 1 2 -1 } { 2 4 3 } { -1 3 7 } }
2: { X Y Z }
1: '1/6*(6*Z+5*Y)^2+ -25/6*Y^2+(-Z+2*Y+X)^2'
Le meme exemple avec les variables dans un ordre specifie:

'X^2+4*X*Y-2*X*Z+4*Y^2+6*Y*Z+7*Z^2' { Z Y X } GAUSS
5: { '1/7' '7/19' '-25/19' }
4: { { 7 3 -1 } { 0 '19/7' '17/7' } { 0 0 1 } }
3: { { 7 3 -1 } { 3 4 2 } { -1 2 1 } }
2: { Z Y X }
1: '-25/19*X^2+7/19*(17/7*X+19/7*Y)^2+1/7*(-X+3*Y+7*Z)^2
orthogonalisation avec parametres:
'X^2+2*A*X*Y' { Y X } GAUSS
5: { '-A^2' 1 }
4: { { 1 0 } { A 1 } }
3: { { 0 A } { A 1 } }
2: { Y X }
1: '(X+A*Y)^2-A^2*Y^2'

Ce répertoire contient aussi 2 utilitaires de conversion: AXQ et QXA qui effectuent la conversion de

la représentation matricielle à la représentation algébrique d’une forme quadratique q (array ↔ symbolic).

Remarque 9 Contrairement aux valeurs propres, les coefficients diagonaux de D ne caractérisent pas la forme quadratique. Par contre, le nombre de coefficients positifs et négatifs (la signature) sont intrinsèques (théorème de Sylvester). Notons encore qu’il est possible de trouver des bases orthogonales à la fois pour le produit scalaire euclidien et la forme quadratique q en diagonalisant la matrice A. Mais alors que la diagonalisation nécessite une factorisation, le programme GAUSS permet de traiter toutes les formes quadratiques (en particulier avec paramètres).

10 Les utilitaires de la bibliothèque.

10.1 Transformations de types et simplifications.

Il s’agit de:

• EXPA qui simplifie une fractions d’entiers relatifs ou de polynômes algébriques.

Exemple:

'1/3+1/6'    -> '1/2'
'X+2*X'      ->'3*X'
'\v/2/(1-\v/2)' -> '-2-\v/2'
'(1+2*X+X^2)/(2+3*X+X^2)' -> '(1+X)/(2+X)'

• SIMP2: analogue à EXPA mais agit sur deux niveaux, le niveau 2 est le numérateur et le niveau 1 le dénominateur. Exemple

15 5 SIMP2 3 1
'1+X' 'X^2+2*X+1' SIMP2 1 'X+1'

Ceci suppose que le flag 12 est armé

• AXL permet de passer de la représentation array à la représentation list (ou inversement si tous les coefficients sont numériques) d’une matrice, Exemple:

[ [ 1 2 ]
  [ 3 4 ] ]    <->  { { 1 2 } { 3 4 } }

• SXL qui transforme de la représentation interne en utilisateur et réciproquement (cf. la section 4.5) Remarquez que si l’argument situé au niveau 1 n’est pas une liste ni un entier binaire (hexstring), la transfomation de symbolique en liste est faite par rapport à la variable contenu de 'VX'. Si la liste au niveau 1 n’est pas une liste d’entiers binaires, la conversion inverse est opérée.

• EPSX0: élimine les 0 en tête de polynôme-listes, remplace les objets inférieurs à EPS par 0.

• FXND: transforme une fraction algébrique en son numérateur et son dénominateur (algébriques),

• NDXF: inverse de FXND.

• XI: transforme tous les complexes de la forme numérique (a, b) en algébrique 'a+ib'. Utilisez →NUM pour transformer un algébrique de type a + ib en complexe numérique.

• CALC: transformation d’un algébrique en une seule fraction.

10.2 Factorisation.

La commande FACTO renvoie au niveau 3 la liste des variables, 2 le polynôme-liste {a_{n}...a_{0}}, au

niveau 1 la liste des facteurs et des multiplicités {a_{n}, m_{a_{n}}, x−x_{1}, m_{x_{1}}..., x−x_{n}, m_{x_{n}}} (sous forme symbolique), de sorte que

P (x) = a_{n} ∏_{k=1}^{n}(x − x_{k}) = ∑_{k=0}^{n} a_{k}x^{k},

Notez que a_{n} peut être factorisé également. Exemple:

'(X-1)^2*(X^2+2*X+1)'
-> 3: { X }
2: { 1 0 -2 0 1 },
1: { 'X-1 2 'X+1' 2 }

Le second utilitaire de factorisation est FROOTS déjà décrit. Ce dernier peut également déterminer

numériquement les racines d’un polynôme à coefficients réels ou complexes. Il regroupe ensuite par paires les racines numériques pour déterminer s’il s’agit de racines d’une équation de degré 2 à coefficients entiers. La méthode utilisée est celle de Bairstow dans le premier cas et celle de Laguerre dans le second cas. Le contrôle des itérations s’effectue par ε: le programme effectue un test par rapport à ε et effectue encore 2 itérations lorsque ce test a joué. Lorsque ce programme s’exécute (et que l’indicateur 1 est armé), l’écran affiche les dernières racines trouvées, et la valeur actuelle du test. Vous pouvez ainsi détecter les cas où l’algorithme ne converge pas. Les touches de menus vous permettent alors d’agir. Les touches E*10 et E/10 permettent de modifier d’un facteur 10 la valeur de ε. Par exemple, pour un polynôme ayant des racines multiples, le test se stabilise à des valeurs de l’ordre de 10^{−8} ou de 10^{−6} pour des racines doubles ou triples. Il vous suffit alors d’augmenter ε (en tapant plusieurs fois sur E*10).

Si l’algorithme de Bairstow tourne en rond, vous pouvez taper sur RAND qui redémarre l’algorithme

avec des valeurs prises au hasard, vous avez alors des chances de sortir l’algorithme de ce cercle vicieux. En dernier ressort, vous pouvez rentrez dans le polynôme un coefficient complexe de partie imaginaire nulle afin d’obliger le programme à utiliser l’algorithme de Laguerre. Exemple:

{1 -21 183 -847 2196 -3024 1728 }
.0001
3
FROOTS -> environ { 3 3 3 4 4 4 }

Ici le polynôme admet 2 racine triples, donc les résultats sont très approximatifs, d’où l’intérêt de l’algorithme de recherche de racines évidentes:

10.3 Opérations.

Ce sont:

• add, SUBT: addition et soustraction

• CHS, re, im, conj: opposé, partie réelle, partie imaginaire, conjugué d’un objet,

• POWER qui calcule la puissance n-ième d’un objet, pour n un entier.

10.4 Objets symboliques.

• MULT, DIV1 et DIV2: multiplication et division de polynômes, d’entiers ou de symboliques. Pour DIV2, il s’agit d’une division euclidienne qui renvoie le reste au niveau 1 et le quotient au niveau 2,

• PDER, PINTG: dérivation et intégration d’un polynôme.

• DEGRE: degré d’un polynôme liste.

Exemple:

     { 0 (0,0) -1 2 } -> 1

• FCOEF: renvoie le polynôme ayant cette liste de { racines multiplictés } (inverse de FROOTS). Exemple:

     { 3 3 4 3 } FCOEF 'X^6-21*X^5+183*X^4-847*X^3+2196*X^2-3024*X+1728'

• HORN: Schéma de Horner

     'X^2+2*X+3' 5 HORN -> 'X+7', 5, 38   (mode utilisateur)
     { 1 2 3 }, 5 HORN -> { 1 7 }, 5, 38  (mode interne)

Ce qui signifie que 'X^2+2*X+3' divisé par '(X-5)' vaut 'X+7', reste 38.

• L2S: prend en argument un polynôme-liste (d’une ou plusieurs variables) et la valeur d’un argument ou la liste des valeurs des arguments et renvoie le résultat de l’évaluation. Par exemple

{ { 1 2 3 } { 4 5 6 } }
{ X Y } L2S
renvoie '(Y^2+2*Y+3)*X+4*Y^2+5*Y+6'.

• S2L: transforme un polynôme algébrique en une variable en polynôme liste par rapport à cette variable. Renvoie la liste de variables au niveau 2. Exemple:

{ '1+A*X' 'A^2' }
'A' S2L -> { { X 1 } { 1 0 0 } }
{ '1+A*X' 'A^2' }
{ A } S2L -> { A }, { { X 1 } { 1 0 0 } }

• PTAYL: effectue un changement d’origine (en calculant le développement de Taylor au point considéré). Par exemple 'X^3+2*X' 2 PTAYL donne 'X^3+6*X^2+14*X+12 car 1.(x + 2)^{3} + 2(x + 2) = x^{3} + 6x^{2} + 14x + 12.

10.5 Programmation.

Les utilitaires pouvant servir à programmer sont:

• EXEC permet d’étendre un objet-programme dont le schéma fonctionnel est stk1 -> stk1 (où stk1 désigne le niveau 1 de la pile) prévu pour des objets de type réel, complexe, algébrique, ou noms globaux (user-type 0,1,6,9) à n’importe quel objet composé de ces objets (par exemple les listes ou tableaux). Attention, utilisez cette instruction avec prudence, car une faute de pile du programme situé au niveau 1 de la pile peut entraîner des conséquences imprévisibles.

Exemples:

{ 1 { 2 3 } 4 } « 5 + » DOALL -> { 6 { 7 8 } 9 }
{ 1 (0,3) } « IM » DOALL  -> { 0 3 }

car la partie imaginaire de 1 [resp 3i] est 0 [3]. Bien sûr, on peut utiliser im directement!

• LVAR: renvoie la liste des variables d’une expression algébrique, Exemple:

'X+2*SIN(A)' -> { 'SIN(A)' X }

Les variables sont ordonnées par ordre de complexité décroissante puis par ordre alphabétique inverse.

• DIVIS: renverse l’ordre dans une liste.

10.6 Arithmétique.

Les arguments sont des nombres entiers (éventuellement fractions de nombres entiers) ou des

polynômes (éventuellement fractions de polynômes). Les programmes les plus utilisés sont accessibles par le menu CST ou les touches redéfinies en mode USER:

• Calcul sur les fractions:

EXPA (menu CST) met sous forme d’1 seule fraction une expression contenant des sommes, produits, différence, quotient, puissances entières de fractions puis simplifie la fraction obtenue. Dans le cas de fractions de polynômes, pour obtenir une simplification efficace, utilisez d’abord DVLP puis SIMPF.

• Factorisation:

FACTO (USER touche SOLVE) permet de connaître les facteurs premiers d’un nombre entier ou les racines d’un polynôme (polynôme-liste ou algébrique de la variable contenue dans 'VX', i.e. 'X' en général). Renvoie une liste contenant ces facteurs suivis de leurs multiplicités respectives. Exemple:

100 -> { 2 2 5 2 }

• Extraction de racine carrée:

le programme SQRT (touche USER √ α-shiftée) permet de calculer la racine carrée symbolique d’un entier ou d’un polynôme. Pour un polynôme liste le résultat peut donner un affichage bizarre sur la pile (√ UNKNOWN).

• Division euclidienne:

Si vous placez le numérateur au niveau 2 et le dénominateur au niveau 1, le programme DIV2 (touche USER) place le quotient au niveau 2 et le reste au niveau 1. Les arguments doivent être des entiers ou des polynôme-listes.

• DIVIS: renvoie la liste des diviseurs d’un objet. Si l’objet est un polynôme, utilisez de préférence FACTO qui renvoie la liste des facteurs. Exemple:

100 DIVIS -> { 1 5 25 2 10 50 4 20 100 }

• PGCD (Plus Grand Diviseur Commun), PPMC:

Le programme GCD1 recherche le PGCD de deux éléments: deux entiers, deux polynômes-listes ou deux algébriques (de n’importe quelle variable, pas forcément de celle contenue dans 'VX'). Le programme LGCD renvoie le PGCD d’une liste d’éléments. Le programme LCM calcule le PPMC des deux arguments. Exemple:

25 35 GCD1 -> 5
'1+2*X+X^2' '1+3*X+2*X^2' GCD1 -> '1+X'
{ 1 2 1 } { 2 3 1 } GCD1 -> { 1 1 }
{ 25 35 45 } LGCD -> 5

10.7 Matrices et vecteurs.

Ce sont:

• add [resp. SUBT] permet d’additionner [resp. soustraire] 2 matrices de même type (formelles ou numériques),

• MMULT multiplie 2 matrices formelles ou numériques

• VMULT multiplie une matrice formelle par un vecteur formel,

• CHS renvoie l’opposé d’une matrice,

• XY qui effectue le produit scalaire de deux vecteurs formels,

• TR qui calcule la trace d’une matrice (array ou liste), c’est-à-dire la somme des éléments diagonaux de la matrice Exemple:

{ { '1+A' 2 }
  { -1 '3-A' } }
TR -> 4

• TRAN qui calcule la transposée d’une matrice (array ou liste), c’est-à-dire effectue une symétrie par rapport à la première diagonale. Attention pour les matrices à coefficients complexes, il s’agit bien de la transposée et pas de la matrice adjointe (il n’y a pas conjugaison des coefficients comme c’est le cas lorsqu’on utilise l’instruction intégrée TRN),

• MAD qui calcule l’inverse (niveau 3), le polynôme-matrice adjoint (non réduit) au niveau 2 et le polynôme caractéristique au niveau 1 de la matrice donnée au départ. Les résultats aux niveaux 1 et 2 sont des polynôme-liste. Pour avoir les valeurs propres, il suffit de taper ENTER pour dupliquer le polynôme caractéristique puis FROOTS, (ce qui ne fonctionnera pas toujours avec des paramètres).

• rref qui généralise l’instruction RREF aux matrices symboliques

• LU2 qui généralise LU aux matrices symboliques, mais contrairement à LU, LU2 renvoie L^{−1} et U tels que A = LU (pour mémoire, LU renvoie P, L et U tels que P A = LU).

10.8 VER.

Affiche à l’écran le numéro de version, mon nom et mes coordonnées (adresse électronique), renvoie

le numéro de version sous forme d’un réel sur la pile.

Remerciements.

Je remercie:

• Gilles Virone de m’avoir montré ce qu’était capable de faire une HP28/48 et de m’avoir prêté son Pentium durant l’été 1995,

• HP Corvallis et W. Wickes pour TOOLS.EXE, D. Müller et R. Hellstern pour RPL48v20.ZIP, M.Heiskanen pour JAZZ, P. Courbis et S. Lalande pour [2],

• les administrateurs des sites ftp anonymes, en particulier ceux de ftp.funet.fi, ftp.cis.com,

  hplyot.obspm.fr, hpcvbbs.cv.hp.com et wuarchive.wustl.edu,

• J.M. Ferrard pour la source d’inspiration qu’a été son livre [4],

• mes (ex-)étudiants de l’Université de Grenoble, plus particulièrement Christophe Burdin, Jérôme Coss, Ludovic Dumaine, Frédéric Hermann, Stéphane Monboisset, Lionel Pilot, Éric Saya, Quan Tong Duc, Samy Venin...

• les utilisateurs d’ALGB sur le réseau (en particulier Craig Clifford, David Czinczenheim, ...)

Appendices.

A Les indicateurs utilisateurs.

A tout instant, l’état de l’indicateur système 1 est affiché (si l’indicateur 1 est armé, vous voyez

un 1 au-dessus de la date). La signification des indicateurs utilisateur est la suivante:

• indicateur 1 armé: affichage actif, désarmé: pas d’affichage.

• indicateur 10 (usage interne) armé: arithmétique entière, désarmé: arithmétique polynomiale (affecte le comportement de DIV2)

• indicateur 11 (usage interne): désarmé par S2L lorsqu’il rencontre une fonction inconnue (i.e. non rationnelle par rapport à la liste des variables)

• indicateur 12 armé: Autorise la recherche des PGCD, désarmé: renvoie systématiquement 1 ou { 1 } comme PGCD. La recherche de PGCD permet de simplifier des expressions et de trouver des racines multiples de polynômes. Pour la diagonalisation des matrices ou les calculs de primitives, il est fortement conseillé d’armer l’indicateur 12. Par contre, si vous travaillez avec plus d’un paramètre, désarmez l’indicateur 12.

• indicateur 13 armé: mode imaginaire, désarmé: mode réel.

• indicateur 14 armé: calcul formel, désarmé: calcul numérique uniquement. Il est conseillé d’armer cet indicateur si on travaille avec des entiers, des racines carrées ou des paramètres, les résultats sont alors plus précis bien que les temps de calculs soient allongés.

• indicateur 15 armé: calcul avec des entiers (autorise la suppression d’erreurs d’arrondi), désarmé: calcul numérique. Si cet indicateur est désarmé, les divisions euclidiennes s’exécuteront nettement plus vite. Mais la recherche de racines évidentes sera désactivée.

• indicateur 16 armé: usage interne dans les versions précédentes Devait être désarmé en usage normal. Indiquait qu’un calcul est en cours avec remplacement d’expressions symboliques par des listes

• indicateur 17 armé: usage interne Doit être désarmé en usage normal. Interdit la conversion de symboles en listes pour les calculs intermédiaires

• indicateur 18 armé/désarmé: usage interne (recherche en cours d’une primitive d’une fraction rationnelle en sin, cos).

• indicateur 19 armé/désarmé: recherche de primitives ou simple décomposition en éléments simples (à armer éventuellement avant appel du programme INTG).

• indicateur 20 armé: usage interne. Doit être désarmé en usage normal. Donne la priorité absolue à la multiplication matrice × polynôme liste lorsqu’il y a ambiguïté.

• indicateur 21 armé: simplification récursive lros de l’exécution de EXPA et de TSIMP.

Rappelons que pour armer un indicateur système, il suffit de taper son numéro suivi de SF (par

exemple 1 SF arme l’indicateur 1 et 1 CF le désarme). Le mieux en général est de garder les indicateurs 1,12,14 et 15 armés et d’armer ou de désarmer l’indicateur 13 selon que l’on travaille ou non en arithmétique complexe.

B Liste des fonctions par ordre alphabétique.

Les symboles suivants seront utilisés:

• %: un réel

• C%: un complexe

• n: un entier (représenté par un réel sans partie fractionnaire)

• [ ]: une matrice numérique

• { l }: une liste

• { m }: une matrice symbolique

• p: un polynôme ({ p } un polynôme-liste),

• { v }: une liste de variables

• s: un objet symbolique (de type 9)

• v: une variable (de type 6 ou 9)

• f: une fraction,

• N, D: le numérateur et le dénominateur d’une fraction,

• o: un objet de type donnée quelconque (réel, complexe, matrice, liste, ...)

Fonction  Explication  Argument(s)  Sortie

{ALGB}  ({VAR})

ARIT  Répertoire  rien  rien
CST  Menu CST  rien  { l }
FUNC  Répertoire  rien  rien
GETALL  Télécharge tous les modules  rien  rien
INIT  initialisation  rien  rien
INTG  Répertoire  rien  rien
MATR  Répertoire  rien  rien
PURG  Purge ALGB  rien  rien
QUAD  Répertoire  rien  rien
SCST  Source du menu CST  rien  chaîne
SENDIR  Envoie la librairie  rien  rien
SETFR  Mettre les flags français  rien  rien
UKEYS  Source des touches User  rien  chaîne
risch  Intégration  s  s
TSIMP  Simplification  s  s

{ALGB ARIT}  ({VAR})

CAB  Bezout ax + by = c  3,2,1: c, a, b  1:1 [3,2: x, y] ou 1: 0
EULER  Indicatrice d’Euler  n  n
FCLI  → Fraction continuée  %  f ou % ou { l }
LIFC  Fraction continuée →  { l }  2: N, 1: D
ORND  Arrondir un objet  2: o, 1: D  o
XFRC  Quadratique irrationnel  o  o

{ALGB FUNC}  ({VAR})

COSN  cos, sin(nx) → P (cos x, sin x)  n > 0  2: s, 1: s
n < 0  2: { p }, 1: { p }
DER  dérivée  2: s, 1: v  1: s′
TAYLR  Taylor  3: s, 2: v, 1: n  3: n, 2: { p }, 1: s

{ALGB INTG}  ({VAR})

INTG  Intégration symbolique  s  s
LIN  Linéarisation  C%, s ou { p }  s
PEVAL  Évaluation  3: primitive, 2,1:bornes  s
PRIMIT  Dernière primitive  Rien  s
VX  Variable d’intégration  Rien  v

{ALGB MATR}  ({VAR})

cross  Produit vectoriel  2: x, 1: y  x ∧ y
DET  Déterminant formel  endomorphisme  déterminant
DIAG  Diagonalisation (Faddeev)  endomorphisme  7 à 1: cf. section 6
MATRIX  Dernière matrice  rien  matrice
PCAR  Polynôme caractéritique  endomorphisme  s
RED  Pivot de Gauß  matrice ou système  cf. section 6
REDLIB  Routines de RED  entier système  3 ou 6 programmes
STUDMULT  × de matrices étudiants  M, M′  “MṀ′ ”

{ALGB QUAD}  ({VAR})

AXQ  Transtypage de forme quadr.  { m }  s
2: { m }, 1: { v }  s
GAUSS réduction d’une forme 1: A 2: D, 1: P
s  5: D, 4: P, 3: A, 2: { v },1: s
2: s, 1: { v }  5: D, 4: P, 3: A, 2: { v },1: s
QXA Transtypage de forme quadr. 2: s, 1: { v } { m }
s  { m }

Fonction  Explication  Argument(s)  Sortie

{ALGB.LIB}  (0:788)

AXL  transtypage  [ ] ou { m }  { m } ou [ ]
add  Addition  2: o_{2}, 1: o_{1}  o_{2} + o_{1}
CHS  Changer le signe  o  −o
COLC  Factorisation  s  s
conj  Conjugué  o  \overline{o}
DEGRE  Degré  { p }  n
DIV1  Division  2: o_{2}, 1: o_{1}  o_{2}/o_{1}
DIV2  Division euclidienne  2: o_{2}, 1: o_{1}  2: o_{2} div o_{1}, 1: o_{2} mod o_{1}
DIVIS  Diviseurs  o  { l }
EPSX0  “Strip”  o  o
EXEC  Substitution ou doall  2: { l }, 1: programme  1: { l }
2: s, 1: o_{1} = o_{2}  s
3: s, 2: { l1 } 1: { l2 }  s
EXPA  Simplification  o  o′
FACTO  Factorisation  o  3: { v } 2: p , 1: { f_{1}n_{1}f_{2}n_{2} ... }
FCOEF  racines/pôles → Fraction  { r_{1}n_{1}r_{2}n_{2} ... }  { f }
FDER  Dérivation  p  p
FINTG  Intégration  p ou s  p ou s
FROOTS  Factorisation  o  3: { v } 2: p , 1: { r_{1}n_{1}r_{2}n_{2} ... }
FXND  Décomposer une fraction  f = N/D  2: N, 1: D
GCD1  PGCD  2: o_{2}, 1: o_{1}  PGCD(o_{2},o_{1})
GCD3  GCD (solves au + bv = d)  2,1: a , b  GCD(a, b) = d, u, v
HORN  Schéma de Horner  2:p , 1: r  3: p/(X − r) , 2: r, 1: P (r)
idn  identity  real integer or matrix  identity matrix
im  Partie imaginaire  o  ℑ(o)
L2S  Évaluation  2: { p }, 1:v  p(v)
2: { p },1: { v }  p(v)
LCM  PPMC  2: o_{2}, 1: o_{1}  PPMC(o_{2},o_{1})
LGCD  PGCD de liste  { l }  o=PGCD
LU2  LU décomposition  M  L^{−}1, U
LVAR  liste de variables  o  { v }
MAD  inverse, polynôme carac., etc.  o  4: det, 3: 1/o, 2: { p }, 1: { p }
MMULT  produit spécial  3: o_{2}, o_{1}, n  “o_{2} × o_{1}”
MULT  produit  2: o_{2}, o_{1}  o_{2} × o_{1}
NDXF  créer une fraction  2: N, 1: D  f = N/D
PF  Partial fraction  f  ∑_{i} f_{i}
POWER  puissance entière  2: o, 1: n  o^{n}
PTAYL  Déplace origine  2: P (X), 1: o  P (X − o)
re  Partie réelle  o  ℜ(o)
rref  Réduction de Gauß  M  { s }, matrice réduite
S2L  Symbolique vers liste  2: o, 1: { v }  2: { v }, 1:{ p }
2: o, 1: v  { p }
SIMP2  Simplification  2: o_{2}, 1: o_{1}  2: o′_{2}, 1: o′_{1}
SQRT  Racine carrée  n ou C% ou s  n ou C% ou s
SUBT  Soustraction  2: o_{2}, 1: o_{1}  o_{2} − o_{1}
SXL  Conversion  Interne [utilisateur]  Utilisateur [interne]
tEVAL  Temps d’exécution  ..., 1: o  EVAL(o), 1: temps
TR  trace  [ ] ou { m }= (a_{ij})_{1≤i,j≤n}  ∑_{i=1}^{n} a_{ii}
TRAN  transposée  [ ] ou { m }  [ ] ou { m }
VER  Version  rien  % 2.28
XY  produit scalaire de 2 vecteurs  2: x 1: y  x.y
XNUM  → Numérique  o  o
XQ  → Rationnel  o  o

Références

[1] H. P. Corvallis. TOOLS.EXE. hpcvbbs.cv.hp.com ftp.funet.fi wuarchive.wustl.edu, 1991.

[2] P. Courbis and S. Lalande. Voyage au centre de la HP 48 S/SX. Angkor, 1993.

[3] Davenport, Siret, and Tournier. Calcul formel: Systèmes et algorithmes de manipulations algébriques. Masson, 1989.

[4] J. Ferrard. “Mathez” la HP 48 G/GX. D31 Diffusion, 1993.

[5] C. N. Fiechter and M. Heiskanen. ALG48V30.ZIP. http://www.hut.fi/ mheiskan, 1996.

[6] F. Gantmacher. Théorie des matrices, volume 1. Dunod, 1966.

[7] M. Heiskanen. POLYLIB.ZIP. http://www.hut.fi/ mheiskan, 1992,1995.
[8] M. Heiskanen. EQSTK60.ZIP. http://www.hut.fi/ mhesikan, 1996.
[9] M. Heiskanen. JAZZV6x.ZIP. http://www.hut.fi/ mheiskan, 1996.
[10] M. Mikocevic. GNUTOOLS. ftp://srcm1.zems.fer.hr:/pub/hp48/tools2.0.4.zip, 1995.
[11] D. Müeller and R. Hellstern. RPL48V20.ZIP. ftp.funet.fi cbs.cis.com hplyot.obspm.fr, 1993.
[12] R. Steventon and A. Schoorl. JAVA28.ZIP. //ftp:ftp.cis.com/pub/hp48g/uploads/java28.zip,

1996.