Maxima est un système de calcul formel (CAS) complet et open-source, capable de manipuler des expressions symboliques et numériques. Pour débuter efficacement avec cet outil, il est essentiel de comprendre ses conventions de base et ses fonctions mathématiques principales.

Conventions et Syntaxe de Base

Avant de manipuler des focntions complexes, voici les règles syntaxiques fondamentales à retenir :

• Constantes mathématiques : Le nombre d'Euler est représenté par %e, la constante Pi par %pi, et l'unité imaginaire par %i.
• Commentaires : Comme en langage C, utilisez /* ... */ pour insérer des commentaires.
• Résultats de limites : Maxima peut retourner und (indéfini), ind (indéfini mais borné) ou infinity (divergence complexe).

Analyse : Calcul de Limites

L'instruction limit permet d'étudier le comportement d'une fonction en un point ou à l'infini.

/* Syntaxe générale */
limit(expression, variable, valeur);
limit(expression, variable, valeur, direction); /* plus pour la droite, minus pour la gauche */

Voici quelques exemples pratiques pour illustrer ces calculs :

/* Limite classique en 0 */
limit((exp(t) - 1) / t, t, 0);

/* Limite à l'infini */
limit(sqrt(x^2 + x) - x, x, inf);

/* Limites latérales */
limit(1/u, u, 0, plus);
limit(1/u, u, 0, minus);

/* Fonction trigonométrique */
limit(tan(z), z, %pi/2, minus);

Opérations de Sommation et de Produit

Pour les calculs itératifs sur des séries ou des suites, Maxima utilise les fonctions sum et product. L'option simpsum ou simpproduct permet de forcer la simplification du résultat.

/* Somme des carrés des entiers de 1 à n */
sum(k^2, k, 1, 10);

/* Somme symbolique avec simplification */
sum(1/2^n, n, 0, inf), simpsum;

/* Produit de termes successifs */
product(1 + 1/m, m, 1, 5);

/* Produit symbolique */
product(j, j, 1, n), simpproduct;

Développements en Série de Taylor

Maxima excelle dans l'approximation de fonctions via les séries de puissances. On distingue deux approches : le calcul de la série entière symbolique et le dévelloppement de Taylor à un ordre donné.

Pour obtenir une forme générale de série entière :

/* Série de puissances de 1/(1+x) au voisinage de 0 */
powerseries(1/(1+x), x, 0);

/* Utilisation de niceindices pour une notation plus propre */
niceindices(powerseries(exp(x), x, 0));

Pour un développement limité (Taylor) à un ordre spécifique :

/* Développement de cos(x) à l'ordre 6 en 0 */
taylor(cos(x), x, 0, 6);

/* Développement d'une fonction de deux variables */
taylor(log(1 + x + y), x, 0, 2, y, 0, 2);

Il est également possible de transformer un développement de Taylor en une fraction rationnelle grâce à l'approximation de Padé via la commande pade :

/* Approximation de Padé à partir d'un développement de Taylor */
ext_taylor : taylor(exp(x), x, 0, 6);
pade(ext_taylor, 3, 3);