> <\body> <\expand|make-title> <\address> <\with|paragraph mode|center> email : michel.gosse@ac-poitiers.fr\ > Cet article est la traduction en français du document d'introduction sur Maxima, écrit par Richard Hand, de l'Université de Cornell. Ce document a été produit par le logiciel (voir ), qui s'interface avec Maxima et permet une présentation en notation mathématique standard des résultats produits par ce logiciel de calcul formel. <\expand|table-of-contents|toc> |Table des matières> |1Introduction> |2Les touches et les symboles spéciaux> |3Arithmétique> |4Algèbre> |5Calcul différentiel> |6Calcul matriciel> |7Programmer avec Maxima> |8Une liste partielle des fonctions Maxima> Pour lancer Maxima sous Windows, double-cliquer sur le fichier xmaxima, qui est situé dans le sous-répertoire d'installation du logiciel. Sous Linux, on peut taper dans une console soit maxima, ce qui lance le logiciel en mode texte, soit xmaxima, qui le lancera en mode graphique. Dans tous les cas, on obtient un message ressemblant à : <\session|maxima|default> <\output> GCL (GNU Common Lisp) \ Version(2.4.0) Wed May \ 9 12:02:00 CDT 2001 Licensed under GNU Library General Public License Contains Enhancements by W. Schelter Maxima 5.6 Wed May 9 12:01:49 CDT 2001 (with enhancements by W. Schelter). Licensed under the GNU Public License (see file COPYING) \; <\input|<\with|color|red> (C1) > \; (C1) est une étiquette. Chaque entrée ou sortie est numérotée et on peut s'y référer par son étiquette durant toute une session maxima. Le C indique une entrée ( Command ), et le D une sortie ( Display ). Il ne faudra donc jamais employer de variables telles que C1 ou D5, car cela prêtera à confusion. Maxima ne distingue pas les caractères en majuscule et en minuscule; Si vous entrez sin(x) ou SIN(x), cela désignera la fonction sinus pour le logiciel. Par contre, pour les réponses qu'il renvoie, le logiciel emploiera systématiquement une notation en majuscule. Cette règle ne s'applique pas aux variables définies par l'utilisateur; par exemple, les variables x et X sont distinctes pour Maxima. Testez-le ... <\expand|enumerate-numeric> <\with|line stretch|0.3cm> <\with|line stretch|0cm> Pour arrêter une session maxima, taper . Si vous tapez CTRL C, alors voici ce que Maxima va afficher :\ <\code> Correctable error : Console interrupt Signalled by Macysgma-top-level If continued : Type :r to resume execution, or :q to quit to top level Broken at SYSTEM:TERMINAL-INTERRUPT Type :H for Help Maxima\ \:q <\with|paragraph mode|left> <\with|paragraph mode|left> A l'invite de Maxima, il faut donc taper :q ( ou :t ) pour arrêter le calcul en cours et retourner au prompt de Maxima. Si on entre :r, le calcul continuera. L'appui sur les touches CRTL Y n'aura aucun effet à part celui d'être indiqué à l'écran. Enfin, CRTL Z aura le même effet que la commande quit(); On note CTRL C l'appui simultané sur les touches CONTROLE et C du clavier. Pour arrêter un calcul sans quitter Maxima, tapez CTRL C. Il est important de connaître ce que l'on doit faire dans ce cas, qui peut se produire si vous lancez un calcul qui dure trop longtemps. Rappelez-vous de taper :q à l'invite MAXIMA\\ qui apparaîtra, afin de revenir à l'écran de saisie des commandes de Maxima.\ Afin de signaler à Maxima la fin d'une entrée de commande, il faut mettre à la fin de la saisie un point-virgule, puis appuyer sur la touche ENTREE. Remarquez que le seul appui sur la touche ENTREE n'est pas suffisant pour faire exécuter une commande par Maxima. Une autre façon de signaler la fin d'une commande est d'utiliser le symbole dollar, qui supprimera l'affichage du résultat du calcul. Ceci est utile si vous évaluez un résultat intermédiaire très long, et que vous ne voulez pas perdre de temps à afficher ce résultat à l'écran. Si vous voulez répéter une commande antérieure, par exemple celle désignée par l'invite (C5), vous pouvez le faire sans retaper la commande en faisant précéder l'étiquette par deux simples quottes ( '' ), ce qui donnera ''C5. Notez que si vous évaluez juste C5, cela ne correspondra pas à l'action recherchée. Si vous voulez vous référez au résultat du calcul précédent fait par Maxima, vous pouvez soit utiliser son étiquette D, soit utiliser le symbole pourcentage ( % ). Les constantes ( exponentielle de 1 ), ( le nombre complexe tel que =-1> ) et > sont désignées par respectivement %E ( ou %e ), %I ( ou %i ) et %PI ( ou %pi ). Remarquez que le % employé ici n'a aucun rapport avec le % désignant le résultat précédemment calculé par Maxima. Afin d'affecter une valeur à une variable, Maxima utilise le signe deux-points ( : ), et non pas le signe égal. Le signe égal sert à écrire une équation. \ Les opérations fondamentales sont : <\expand|itemize-dot> l'addition notée + la soustraction notée - la multiplication des réels notée * la division notée / l'élévation à la puissance notée ^ ou ** la multiplication matricielle notée . la fonction racine carrée notée sqrt Les sorties de Maxima se font en valeur exacte. Par exemple : <\session|maxima|default> <\input|maxima] > 1/100+1/101; <\output> <\with|mode|math> >> \; Si on emploie des nombres irrationnels, alors ceux-ci sont conservés sous forme symbolique : <\session|maxima|default> <\input|maxima] > (1+sqrt(2))^5; <\output> <\with|mode|math> >+1> \; <\input|<\with|color|red> (C4) > expand(%); <\output> <\with|mode|math> >29*+41> \; Toutefois, il est souvent utile d'obtenir une valeur approchée d'un résultat. Cette opération s'effectue en faisant suivre l'expression demandée de la commande , : <\session|maxima|default> <\input|maxima] > %,numer; <\output> <\with|mode|math> >82.01219330881976> \; Notez que le % se réfère ici au résultat du calcul précédent. Par défaut, la commande donne 16 chiffres significatifs, le dernier pouvant être erroné. Toutefois, Maxima peut calculer avec une précision arbitraire aussi importante que l'on veut grâce à la fonction : <\session|maxima|default> <\input|maxima] > bfloat(D3); <\output> 8.201219330881976B1 \; Le nombre de décimales est contrôlé par la variable Maxima , qui a par défaut la valeur 16 : <\session|maxima|default> <\input|maxima] > fpprec; <\output> <\with|mode|math> >16> \; Assignons à cette variable la valeur 100 : <\session|maxima|default> <\input|maxima] > fpprec:100; <\output> <\with|mode|math> >100> \; <\input|<\with|color|red> (C9) > bfloat(D3); <\output> 8.2012193308819756415248973002081244278520484385931494122123712401731 \ 2418754011041266612384955016056B1 \; Maxima peut calculer les valeurs exactes de très grand nombres : <\session|maxima|default> <\input|maxima] > 100!; <\output> <\with|mode|math> >93326215443944152681699\ 238856266700490715968264381621468592963895217599993229915608941463976\ 156518286253697920827223758251185210916864000000000000000000000000> \; L'importance de Maxima comme logiciel de calcul formel appairait clairement quand nous voyons avec quelle facilité le logiciel va effectuer des calculs algébriques. Voici un exemple de développement d'un polynôme : <\session|maxima|default> <\output> \; <\input|<\with|color|red> (C1) > (x+3*y+x^2*y)^3; <\output> <\with|mode|math> >x*y+3*y+\ x> \; <\input|<\with|color|red> (C2) > expand(%); <\output> <\with|mode|math> >x*y+9*x<\ rsup|4>*y+27*x*y+27*y+3*x*y+18*x*y+27*x*y+3*x*y+9*x*y+x> \; \; Supposons maintenant que nous voulons remplacer par la valeur > dans l'expression précédente : <\session|maxima|default> <\input|maxima] > d2,x=5/z; <\output> <\with|mode|math> >|z>+<\ frac|675*y|z>+>+|z>+>+|z>+\ >+|z>+|z>+27*y> \; La fonction RATSIMP de Maxima réduit l'expression au même dénominateur : <\session|maxima|default> <\input|maxima] > ratsimp(%); <\output> <\with|mode|math> >*z+135*y*z+675*y+225*y*z+2250*y+125*z+5625*y+1875*y*z+9375*y*z+15625*y|z>> \; Les expressions peuvent être factorisées : <\session|maxima|default> <\input|maxima] > factor(%); <\output> <\with|mode|math> >3*y*z+5*z+25*y|z>> \; Maxima peut trouver les valeurs exactes des solutions de systèmes d'équations algébriques, même dans des cas non linéaires. Dans l'exemple suivant, on résout trois équations dont les inconnues sont , et : <\session|maxima|default> <\input|maxima] > a+b*c=1; <\output> <\with|mode|math> >b*c+a=1> \; <\input|<\with|color|red> (C8) > b-a*c=0; <\output> <\with|mode|math> >b-a*c=0> \; <\input|<\with|color|red> (C9) > a+b=5; <\output> <\with|mode|math> >b+a=5> \; <\input|<\with|color|red> (C10) > solve([d7,d8,d9],[a,b,c]); <\output> <\with|mode|math> >a=*i+25|6**i-34>,b=*i+5|*i+11>,c=*i+1|10>,a=*i-25|6**i+34>,b=*i-5|*i-11>,c=-\ *i-1|10>> \; Remarquez que la sortie consiste en une " liste ", c'est à dire en une expression comprise entre deux crochets [ ... ], qui contient elle-même deux listes. Chacune de ces dernières contient une solution au système d'équations. Les formules trigonométriques se manipulent aisément avec Maxima. La fonction TRIGEXPAND utilise la formule de la somme afin de simplifier au maximum l'argument de chacune des fonctions trigonométriques utilisées : <\session|maxima|default> \; <\input|<\with|color|red> (C1) > sin(u+v)*cos(u)^3; <\output> <\with|mode|math> >cos u*sin v+u> \; <\input|<\with|color|red> (C2) > trigexpand(%); <\output> <\with|mode|math> >cos u*cos u*sin v+sin u*cos v> \; Inversement, la fonction TRIGREDUCE transforme une expression trigonométrique en une somme de termes dont chacun ne comporte qu'une seule fois la fonction sinus ou la fonction cosinus : <\session|maxima|default> <\input|maxima] > trigreduce(d1); <\output> <\with|mode|math> >v+4*u+sin v-2*u|8>+v+2*u+3*sin v|8>> \; Les fonctions REALPART et IMAGPART renvoient respectivement la partie réelle et la partie imaginaire d'un nombre complexe : <\session|maxima|default> <\input|maxima] > w:3+k*%i; <\output> <\with|mode|math> >i*k+3> \; <\input|<\with|color|red> (C5) > w^2*%e^w; <\output> <\with|mode|math> >i*k+3*e> \; <\input|<\with|color|red> (C6) > realpart(%); <\output> <\with|mode|math> >e*9-k*cos k-6*e*k*sin k> \; <\input|<\with|color|red> (C7) > imagpart(D5); <\output> <\with|mode|math> >e*9-k*sin k+6*e*k*cos k> Maxima calcule dérivées et intégrales, effectue des développements en série de Taylor, trouve les limites, et sait résoudre en valeur exacte les équations différentielles ordinaires. Nous commençons par définir la fonction de la variable numérique par : <\session|maxima|default> <\input|maxima] > f:x^3*%e^(k*x)*sin(a*x); <\output> <\with|mode|math> >x*e*si\ n a*x> \; On calcule l'expression de la dérivée de par rapport à : <\session|maxima|default> <\input|maxima] > diff(f,x); <\output> <\with|mode|math> >k*x*e\ *sin a*x+3*x*e*sin a*x+a*x*e*cos a*x> \; Maintenant, on calcule une primitive de par rapport à : <\session|maxima|default> <\input|maxima] > integrate(f,x); <\output> <\with|mode|math> >k\ +3*a*k+3*a*k+a*k*x+-3*k-3*a*k+3*a\ *k+3*a*x+6*k-12*a*k-18*a*k*x-6*k+36*a*k<\ rsup|2>-6*a*e*sin a*x+-a*k-3*a*k-3*a*k-a*x+6*a*k+12*a*k+6*a*k*x+-18*a*k-12*a*k+6*a*x+24*a*\ k-24*a*k*e*cos a*x|k+4*a*k+6*a*k+4*a*k+a>>> \; Un léger changement de syntaxe fournit l'intégrale définie : <\session|maxima|default> <\input|maxima] > integrate(1/x^2,x,1,inf); <\output> <\with|mode|math> >1> \; <\input|<\with|color|red> (C13) > integrate(1/x,x,0,inf); <\output> Integral is divergent \ -- an error. \ Quitting. \ To debug this try DEBUGMODE(TRUE);) \; Ensuite, nous définissons la fonction à l'aide de la fonction et du sinus hyperbolique, puis nous trouvons le développement en série de Taylor de à l'ordre 3 au voisinage de . <\session|maxima|default> <\input|maxima] > g:f/sinh(k*x)^4; <\output> <\with|mode|math> >*e*sin a*x|sinh k*x>> \; <\input|<\with|color|red> (C15) > taylor(g,x,0,3); <\output> <\with|mode|math> >>+>-a*k+a*x|6*k>-3*a*k+a*x|6*k>+\> \; La limite de quand tend vers se calcule par l'instruction suivante : <\session|maxima|default> <\input|maxima] > limit(g,x,0); <\output> <\with|mode|math> >>> \; Maxima peut aussi représenter des dérivées sous une forme non évaluée. On remarquera le signe quotte (') devant l'expression : <\session|maxima|default> <\input|maxima] > 'diff(y,x); <\output> <\with|mode|math> >*y> \; L'opérateur quotte (') dans l'expression précédente signifie " ne pas évaluer ". Sans ce symbole, Maxima aurait retourné 0 : <\session|maxima|default> <\input|maxima] > diff(y,x); <\output> <\with|mode|math> >0> \; En utilisant ce symbole quotte ('), on peut écrire des équations différentielles : <\session|maxima|default> <\input|maxima] > 'diff(y,x,2)+'diff(y,x)+y; <\output> <\with|mode|math> >|d*x>*y+*y+y> \; La fonction ODE2 de Maxima peut résoudre des équations différentielles du premier et second ordre : <\session|maxima|default> <\input|maxima] > ode2(D19,y,x); <\output> <\with|mode|math> >y=e>*<\ left|(>*sin *x|2>+*cos *x|2>> \; %K1 et %K2 désignent des constantes réelles. Maxima peut calculer le déterminant, l'inverse, les valeurs propres et les vecteurs propres d'une matrice qui comporte des éléments symboliques ( c'est à dire des expressions avec des variables algébriques ). On commence par entrer une matrice élément par élément : <\session|maxima|default> <\input|maxima] > m:entermatrix(3,3); <\output> Is the matrix \ 1. Diagonal \ 2. Symmetric \ 3. Antisymmetric \ 4. General \; <\input|<\with|color|red> Answer 1, 2, 3 or 4 : > 4; <\input|<\with|color|red> Row 1 Column 1: > 0; <\input|<\with|color|red> Row 1 Column 2: > 1; <\input|<\with|color|red> Row 1 Column 3: > a; <\input|<\with|color|red> Row 2 Column 1: > 1; <\input|<\with|color|red> Row 2 Column 2: > 0; <\input|<\with|color|red> Row 2 Column 3: > 1; <\input|<\with|color|red> Row 3 Column 1: > 1; <\input|<\with|color|red> Row 3 Column 2: > 1; <\input|<\with|color|red> Row 3 Column 3: > 0; <\output> Matrix entered. <\with|mode|math> >||>|||>|||>>>>> \; On calcule ensuite sa transposée, son déterminant et son inverse : <\session|maxima|default> <\input|maxima] > transpose(m); <\output> <\with|mode|math> >||>|||>|||>>>>> \; <\input|<\with|color|red> (C23) > determinant(m); <\output> <\with|mode|math> >a+1> \; <\input|<\with|color|red> (C24) > invert(m),detout; <\output> <\with|mode|math> >||>|||>|||>>>>|\ a+1>> \; Dans l'entrée C24, l'option detout impose la factorisation par le déterminant, ce dernier restant à l'extérieur de la matrice. Comme vérification, on peut multiplier par son inverse ( remarquer l'usage du point (.) pour désigner le produit matriciel ) : <\session|maxima|default> <\input|maxima] > m.d24; <\output> <\with|mode|math> >||>|||>|||>>>>\||\ >|||>|||>>>>|a+1>> \; <\input|<\with|color|red> (C26) > expand(%); <\output> <\with|mode|math> >+>||>||+>|>|||+>>>>>> \; <\input|<\with|color|red> (C27) > factor(%); <\output> <\with|mode|math> >||>|||>|||>>>>> \; Pour trouver valeurs et vecteurs propres, on utilise la commande EIGENVECTORS : <\session|maxima|default> <\input|maxima] > eigenvectors(m); <\output> Warning - you are redefining the MACSYMA function EIGENVALUES Warning - you are redefining the MACSYMA function EIGENVECTORS <\with|mode|math> >--1|2>,+1|2>,-1,1,1,1,1,--1|2*a+2>,--1|2*a+2>,1,+1|2*a+2\ >,+1|2*a+2>,1,-1,0> \; Dans l'expression D28, le premier crochet à l'intérieur du triple crochet donne les trois valeurs propres, le suivant leur ordre de multiplicité respectifs, et les crochets suivants fournissent les coordonnées des vecteurs propres associés aux valeurs propres. Afin d'extraire un vecteur propre de l'expression précédente, on utilise la commande PART : <\session|maxima|default> <\input|maxima] > part(D28,2); <\output> <\with|mode|math> >1,--1|2*a+2>,--1|2*a+2>> Jusqu'à présent, nous avons utilisé Maxima en mode interactif, comme une super calculatrice. Toutefois, pour des calculs qui nécessitent une séquence de commandes répétitive, il est préférable d'exécuter un programme. Nous présentons maintenant un exemple de court programme \ permettant le calcul des points critiques d'une fonction de deux variables et . Le programme demande à l'utilisateur d'entrer une fonction , puis il calcule les dérivées partielles f|\x> et >f|\y>>, et enfin il fait appel à la commande SOLVE de Maxima pour obtenir les solutions du système d'équations : <\expand|equation*> f|\x>=0 \ \ \ \ et \ \ \ >f|\y>=0>> Le programme est écrit avec un éditeur de textes quelconque, puis est chargé dans Maxima avec la commande BATCH. Voici le listing du programme : <\code> /*-----------------------------------------------------------------------\ --- Ceci est le programme critpts.max comme vous le voyez, les commentaires avec Maxima sont analogues à ceux en langage C Auteur : Nelson Luis Dias Créé le 07/07/2000 -------------------------------------------------------------------------\ --* critpts():=( print("Programme pour déterminer les points critiques "), /* ----------------------------------------------------------------------\ --- On entre une fonction -------------------------------------------------------------------------\ --* f:read("Entrez f(x,y)"), /*-----------------------------------------------------------------------\ --- On renvoie la réponse pour vérification -------------------------------------------------------------------------\ --* print("f = ",f), /*-----------------------------------------------------------------------\ --- On construit une liste avec les dérivées partielles : -------------------------------------------------------------------------\ --* eqs:[diff(f,x),diff(f,y)], /*-----------------------------------------------------------------------\ --- On construit la liste des inconnues -------------------------------------------------------------------------\ --* unk:[x,y], /*-----------------------------------------------------------------------\ --- On résout le système\ -------------------------------------------------------------------------\ --* solve(eqs,unk) ) $ Le programme ( qui est en l'état actuel une fonction sans argument ) s'appelle critpts. Chaque ligne est une commande ( qui doit être valide ) Maxima qui pourrait être exécutée en mode interactif, et qui est séparée de la commande suivante par une virgule. Les dérivées partielles sont stockées dans une liste qui s'appelle eqs, et les inconnues dans une liste qui s'appelle unk. Voici un exemple d'exécution du programme : <\session|maxima|default> \; <\input|<\with|color|red> (C1) > batch("/home/michel/temp/critpts.max"); batching #p/home/michel/temp/critpts.max\ (C2) critpts() := (PRINT("Programme recherchant les points critiques "), f : READ("Entrez f(x,y)"), PRINT(" f = ", f), eqs : [DIFF(f, x), DIFF(f, y)], unk : [x, y], SOLVE(eqs, unk)) (C3) critpts(); Programme recherchant les points critiques\ Entrez f(x,y)\ %E^(x^3+y^2)*(x+y);\ +x>> (D3) [[x = 0.4588955685487 %I + 0.35897908710869, y = 0.49420173682751 %I - 0.12257873677837], [x = 0.35897908710869 - 0.4588955685487 %I, y = - 0.49420173682751 %I - 0.12257873677837], [x = 0.41875423272348 %I - 0.69231242044203, y = 0.86972626928141 %I + 0.4559120701117]] y = 0.4559120701117 - 0.86972626928141 %I], [x = - 0.41875423272348 %I - 0.69231242044203, y = 0.86972626928141 %I + 0.4559120701117]] Vous pouvez consulter le manuel Maxima dans le sous-répertoire maxima-/info au format texinfo ou html. A l'intérieur de Maxima, vous pouvez utiliser la commande DESCRIBE(nom de la fonction ). <\expand|itemize-dot> ALLROOTS(A)\ Trouve toutes les solutions en valeur approchée ( avec 16 chiffres significatifs par défaut ), éventuellement dans le corps des nombres complexes, d'une équation polynomiale A, et en donne une liste. APPEND(A,B) Réunit la liste A et la liste B, et donc renvoie une liste unique. BATCH(A) Charge et lance un programme BATCH du nom de A COEFF(A,B,C) Renvoie le coefficient de B puissance C dans l'expression A CONCAT(A,B) Crée le symbole AB CONS(A,B) Ajoute A à la liste B en première position DEMOIVRE(A) Transforme toutes les exponentielles complexes sous forme trigonométrique DENOM(A) Renvoie le dénominateur de A DEPENDS(A,B) Cette commande indique que A est une fonction de B. Cette dernière est utile pour écrire des dérivées de manière générale, comme par exemple dans les équations différentielles. DESOLVE(A,B) Essaie de résoudre un système linéaire A d'équations différentielles d'inconnues B en utilisant la transformée de Laplace DETERMINANT(A) Renvoie le déterminant de la matrice carrée A DIFF(A,B1,C1,B2,C2,...,Bn,Cn) Renvoie les dérivées partielles de A par rapport aux variables B1 à la puissance C1, B2 à la puissance C2, etc..; Un raccourci pour DIFF(A,B,1) est DIFF(A,B). 'DIFF(A,B) représente la dérivée sous forme non évaluée, ce qui est utile pour les équations différentielles. EIGENVALUES(A) Renvoie deux listes, la première étant les valeurs propres d'une matrice carrée A, et la seconde leur ordre respectif de multiplicité. EIGENVECTORS(A) Fait la même chose que la commande précédente, mais rajoute la liste des vecteurs propres associés ENTERMATRIX(A,B) Demande à l'utilisateur d'entrer une matrice n sur m, élément par élément EV(A,B1,B2,...,Bn) Évalue A en tenant compte des conditions B1, B2, ... Bn. En particulier, les Bi peuvent être des équations, des listes d'équations ( comme ce que retourne la commande SOLVE ), ou bien des assignations, c'est à dire que dans ce cas la commande EV remplace les Bi par leurs valeurs dans A. Les Bi peuvent être des mots comme NUMER ( ce qui dans ce cas renvoie une valeur numérique pour A ), DETOUT ( ce qui dans ce cas entraîne que tout calcul de matrice inverse se fera en gardant le déterminant en facteur, c'est à dire à l'extérieur de la matrice ), ou DIFF ( et dans ce cas tous les calculs de dérivation sont effectués, c'est à dire que 'DIFF est remplacé par DIFF). Pour abréger une commande interactive, c'est à dire qui n'est pas incluse dans la définition d'une fonction, la commande EV peut être omise, ce qui raccourcit la commande sous la forme : A,B1,B2,...,Bn EXPAND(A) Effectue le développement de A. En particulier, les multiplications sont distribuées par rapport aux additions. EXPONENTIALIZE(A) Transforme toutes les fonctions trigonométriques contenues dans A en exponentielles complexes. FACTOR(A) Factorise l'expression A FREEOF(A,B) Renvoie TRUE si l'expression B ne comporte pas la variable A GRIND(A) Ecrit une variable ou une fonction A sous une forme compacte. Si cette commande est utilisée avec WRITEFILE et un éditeur de textes, cela permet de produire des fichiers BATCH incluant des expressions générées par Maxima. IDENT(A) Renvoie la matrice identité d'ordre A IMAGPART(A) Renvoie la partie imaginaire de A INTEGRATE(A,B) Essaie de déterminer une primitive de A par rapport à B INTEGRATE(A,B,C,D) Essaie de calculer l'intégrale de A par rapport à B entre les bornes C et D. Les bornes de l'intégrale peuvent être INF ( plus l'infini ) ou MINF ( moins l'infini ). INVERT(A) Calcule la matrice inverse de la matrice carrée A KILL(A) Élimine la variable A de toutes les définitions et propriétés de l'environnement actuel de Maxima LIMIT(A,B,C) Donne la limite de l'expression A quand B tend vers C. Cette dernière variable peut prendre comme valeur INF ( plus l'infini ) ou MINF (moins l'infini ), comme pour l'intégrale définie. LHS(A) Donne le membre de gauche d'une équation A LOADFILE(A) Charge un fichier du nom de A situé dans le répertoire courant. Le fichier doit être dans un format adapté, c'est à dire avoir été auparavant créé par la commande SAVE MAKELIST(A,B,C,D) Crée une liste d'éléments A ( chacun d'eux dépendant probablement de B ) pour B variant de C à D MAP(A,B) Applique la fonction A à la sous-expression B MATRIX(A1,A2,...An) Crée la matrice dont les lignes sont les Ai, chacun des Ai étant une liste de m éléments [B1,B2,...Bm] NUM(A) Renvoie le numérateur de A ODE2(A,B,C) Essaie de résoudre l'équation différentielle du premier ou du second ordre A d'inconnue la fonction B dont la variable est C PART(A,B1,B2,...Bn) Prend la B1 ième partie de A, puis la B2 ième partie de A, et ainsi de suite PLAYBACK(A) Affiche les dernières A ( entiers ) sorties produites par Maxima. Si A n'est pas fourni, alors toutes les lignes depuis le début de la session sont affichées\ RATSIMP(A) Simplifie A et renvoie le quotient de deux polynômes REALPART(A) Renvoie la partie réelle de A RHS(A) Donne le membre de droite d'une équation A SAVE(A,B1,B2,...Bn) Crée un fichier dont le nom est A dans le sous-répertoire par défaut, contenant les variables, les fonctions ou les tableaux Bi. Le format de ce fichier permet son chargement ultérieur dans Maxima en utilisant la commande LOADFILE. Toute la session, incluant les étiquettes, peut être sauvegardée en choisissant B1 égal à ALL.\ SOLVE(A,B) Essaie de résoudre l'équation algébrique A d'inconnue B. Une liste des solutions est renvoyée. Par simplification, si A est une équation de la forme C=0, alors il est possible de n'écrire que C seulement. STRING(A) Convertit A en notation linéaire Maxima, analogue à celle utilisée en Fortran, comme si l'expression avait été entrée directement, et mets A dans un buffer pour une édition possible. L'expression ainsi obtenue ne doit pas être employée pour des calculs ultérieurs. STRINGOUT(A,B1,B2,..,Bn) Crée un fichier dont le nom est A dans le sous-répertoire courant, contenant les variables B1, B2,..Bn. Ce fichier est au format texte et on ne peut pas l'ouvrir avec Maxima. Cependant, les expressions sauvegardées ainsi peuvent être réutilisées dans un programme en Fortran, en Basic ou en C avec quelques modifications. SUBST(A,B,C) Remplace la valeur A par B dans C TAYLOR(A,B,C,D) Développe A en série de Taylor par rapport à la variable B au voisinage de C, jusqu'à l'ordre D, en incluant le terme (B-C)>. Maxima peut aussi effectuer des développements en série de Taylor avec plus d'une variable indépendante. Consulter le manuel Maxima. TRANSPOSE(A) Renvoie la transposée de la matrice A TRIGEXPAND(A) Est une fonction de simplication trigonométrique qui utilise la formule de la somme des angles pour simplifier les arguments des fonctions SIN et COS rencontrées. Par exemple, TRIGEXPAND(SIN(x+y)) donne COS(x)SIN(y)+SIN(x)COS(y). TRIGREDUCE(A) Est une fonction de simplication trigonométrique qui utilise des égalités trigonométriques pour convertir des produits et des puissances de SIN et COS en une somme de termes, chacun d'eux ne contenant qu'une seule fois la fonction SIN ou COS. Par exemple, TRIGREDUCE(SIN(x)^2) donne (1-COS(2x))/2. TRIGSIMP(A) Est une fonction de simplification trigonométrique qui remplace TAN, SEC, etc, par leurs équivalents en SIN et COS. L'égalité SIN()+COS(x)=1> est aussi utilisée.\ \; <\initial> <\collection> <\references> <\collection> > > > > > > > > > <\auxiliary> <\collection> <\associate|toc> |math font series||1Introduction> |math font series||2Les touches et les symboles spéciaux> |math font series||3Arithmétique> |math font series||4Algèbre> |math font series||5Calcul différentiel> |math font series||6Calcul matriciel> |math font series||7Programmer avec Maxima> |math font series||8Une liste partielle des fonctions Maxima>