Domaine de définition: la fonction singular permet de déterminer les singularités de certaines fonctions:

> restart;
    singular(tan(x));

Continuité: la fonction iscont permet de déterminer la continuité de certaines fonctions.

closed signifie que l'intervalle est fermé.MAPLE travaille par défaut sur des intervalles ouverts.

> iscont(tan(x),x=-Pi/2..Pi/2,closed);

> iscont(tan(x),x=-Pi/2..Pi/2);

Image d'une réunion d'intervalles fermés , avec la fonction evalr :

> evalr((x->x^2)(INTERVAL(-1..-0.5)));

Extrema d'une fonction , avec les fonctions minimize et maximize :

> minimize(x^2+x-3),maximize(-x^4+x^2+1);

Fonctions définies par intervalles:
piecewise permet de définir une fonction à partir de conditions sur différents
intervalles: piecewise (cond1,f1, cond2,f2, ..., condN,fN, f_autrement)

> f:=piecewise(x<0,exp(x),x<=4,x/4+1,2);

> plot(f(x),x=-4..8);

Limites: avec la fonction limit(expr, x=a , option) option = left , right .

> limit(sin(x)/x,x=0);

> limit(1/x^3,x=0);

Utilisation de la forme inerte Limit :

> Limit(1/x^3,x=0,right) = limit(1/x^3,x=0,right);

Etude locale: avec taylor(expr , x=a , n) pour les développements limités ou de Taylor,

series(expr , x=a , n) ou asympt(expr , x , n) pour des développements asymptotiques plus

généraux. L'ordre n est facultatif et vaut 6 par défaut .

> taylor(sin(x),x); # a=0 par défaut

> taylor(x^2/(x^2+1),x=infinity,10);

> series(exp(x)/x,x,9); # a=0 par défaut

> asympt(ln(x+1/x),x,7); # toujours en plus l'infini

> asympt(Sum(1/k,k=1..n)-ln(n),n,10); # la constante d'Euler gamma

> evalf(gamma);

leadterm donne le terme principal d'une série:

> series(leadterm(sin(x^3)/(2*x)),x=0);

Conversion en polynôme de Taylor:

> P:=convert(taylor(exp(x),x=0,5),polynom);

Dérivation:

Pour dériver une fonction , utiliser diff(expr,v1,v2,...,vn) qui calcule la dérivée partielle de expr

par rapport aux variables v1,v2,...,vn .

> Diff(x/(x^2+y^2),x,y)=diff(x/(x^2+y^2),x,y); # équivaut à Diff(x/(x^2+y^2),x,y): % = value(%);

Noter l'absence de parenthèses dans l'écriture du premier membre .

On peut utiliser l'opérateur $ pour éviter de répéter plusieurs fois une variable :

> Diff(x/(x^2+y^2),x$2,y) : % = value(%);

Opérateur différentiel D: D( f ) retourne la fonction dérivée première de f
Fonctions dérivées première et seconde:

> D(sin),(D@@2)(sin);

> D(x->x*sin(x)-x);

> f:=(x,y,z)->x^2-3*x*y*z+z^4;

fonction dérivée par rapport à x,y , et z respectivement :

> D[1](f);D[2](f);D[3](f);

D[i,j](f) équivaut à D[i](D[j](f)) :

> D[1,2](f);

Suites définies par des sommes ou des produits:

> Sum(k^2,k=1..n) : % = factor(value(%));

> Product(k/(k+1),k=1..n) : % = simplify(value(%));

Développement asymptotique de la somme partielle d'une série:

> series(sum(1/k^2,k=1..n),n=infinity);

Suites récurrentes:  

Type :

Exemple: , calcul de , pour ,..,15.

> f:=x->cos(x):n:=15:u[0]:=-1:
    for k to n do u[k]:=evalf(f(u[k-1])) end do:

On peut représenter graphiquement la convergence de la suite en construisant une liste T formée

des points (u(0),0) , (u(0),u(1)) , (u(1),u(1)) , (u(1),u(2)) , etc...

> T:=array(1..4*n,[u[0],0,u[0],f(u[0])]):
    for k from 2 to 2*n-1 do
        T[2*k+1]:=T[2*k]:
        if is(k,odd) then T[2*(k+1)]:=evalf(f(T[2*k+1])) else
            T[2*(k+1)]:=evalf(T[2*k+1])
        end if
    end do:
    T:=convert(T,list):U:=NULL:
    for k to nops(T)-1 by 2 do
        U:=U,[T[k],T[k+1]]
    end do:     U:=plot([U],color=blue):G:=plot({f(x),x},x=-1.3..1.3,scaling=constrained):plots[display]({G,U},title="point fixe du cosinus",view=[-1.3..1.3,-1.3..1.3]);

Type :

Exemple: .

> u[0]:=1:v[0]:=4:n:=15:
    for k to n do
        u[k]:=evalf(sqrt(u[k-1]*v[k-1])):v[k]:=(u[k-1]+v[k-1])/2
    end do:

Type :

Exemple: .

> u[0]:=0:u[1]:=4:n:=15:
    for k from 2 to n do u[k]:=evalf(sqrt(u[k-1]+u[k-2])) end do:

Résolution de récurrences , avec la fonction rsolve .

Une suite arithmétique de raison -3:

> restart:rsolve(w(n+1) = w(n)-3,w);

Une suite géométrique avec condition initiale:

> rsolve({w(n+1)=w(n)/3,w(0)=-7},w);

La suite de Fibonacci:

> rsolve({fib(n+2)=fib(n+1)+fib(n),fib(0)=0,fib(1)=1},fib);

Somme d'une série de Riemann convergente:

> sum(1/k^2,k=1..infinity);

La série harmonique est divergente:

> sum(1/k,k=1..infinity);

Calcul de la somme d'une série de fonctions

> Sum(sin(x)^k,k=1..infinity)=sum(sin(x)^k,k=1..infinity);

Le package powseries contient des fonctions mettant en jeu les séries entières:

Consulter les pages d'aide de powseries pour plus de précision.

> with(powseries);

> sh := evalpow( sinh(x) ): tpsform(sh, x, 9);

Le calcul des primitives et des intégrales se fait avec la fonction int .

Syntaxes: int(expr , x) et int(expr, x=a..b) .

> Int(x/(x^4+1),x)=int(x/(x^4+1),x);
    # équivaut à Int(x/(x^4+1),x) : % = value(%);

> Int(x/(x^4+1),x=0..1) : % = value(%);

Intégrale généralisée convergente:

> Int(x/(x^4+1),x=0..infinity) : % = value(%);

Intégrale généralisée divergente:

> Int(exp(x)/x,x=1..infinity) : % = value(%);

Le package inttrans contient quelques outils pour la transformation d'intégrales.

Consulter les pages d'aide de inttrans pour plus de précision.

> with(inttrans);

La transformée de Laplace de f est définie par = .

> laplace(sin(omega*t), t, s);

Quelques outils du package student :

> with(student);

Changement de variables dans les intégrales:  changevar(eq , intégrale , u)

eq est l'équation du changement de variable de la forme f(x)=g(u) , intégrale est l'intégrale

et u la nouvelle variable d'intégration :

> J:=Int(t/((t^2+1)*sqrt(1-t^4)),t=0..1);

> changevar(t^2=u,J,u):% = value(%);

Intégration par parties , avec la fonction intparts(intégrale,u) , u est le facteur à dériver.

> J:=Int(x^2*arccos(x),x):intparts(J,arccos(x));

> J:=value(%);

METHODE DES RECTANGLES: On découpe [a,b] en n intervalles de même longueur

extrémité gauche :

représentation avec leftbox(expr,x=a..b,n) , calcul avec leftsum(expr,x=a..b,n)

extrémité droite :

représentation avec rightbox(expr,x=a..b,n) , calcul avec rightsum(expr,x=a..b,n)

point médian :

représentation avec middlebox(expr,x=a..b,n) , calcul avec middlesum(expr,x=a..b,n)

METHODE DES TRAPEZES: calcul avec trapezoid(expr,x=a..b,n)

METHODE DE SIMPSON: calcul avec simpson(expr,x=a..b,n) , avec n pair.

Exemple: avec f:

> middlebox(exp(-x^2),x=-1..1,20);middlesum(exp(-x^2),x=-1..1,20);evalf(%);

> evalf(trapezoid(exp(-x^2),x=-1..1,20));

> evalf(simpson(exp(-x^2),x=-1..1,20));

Calcul d'intégrales doubles ou triples:

> Doubleint(x^3*y-x^2-y*x,x=-a..a,y=-b..b):%=value(%);

> Tripleint(x*y*z*sin(x+y+z),x=0..Pi,y=-Pi..Pi,z=0..Pi):%=value(%);

Equations du premier ordre: MAPLE sait résoudre directement les équations de type classique

- linéaire - avec facteur intégrant - séparable - homogène - résolue en x - de Bernoulli - de Clairaut

- de Riccati .

Équation y ' + 3 y =

> restart:eq:=diff(y(x),x)+3*y(x)=exp(-x):dsolve(eq,y(x));

_C1 désigne une constante réelle arbitraire.

La même avec la condition initiale

> dsolve({eq,y(0)=1.5},y(x));

Les solutions y(x) ne sont pas directement utilisables : en assignant la solution à y(x) on peut utiliser le résultat , par exemple pour représenter les courbes intégrales :

> assign(dsolve(eq,y(x))):y:=unapply(y(x),_C1,x);

> plot({seq(y(_C1,x),_C1=-3..3)},x=-5..5,y=-20..20);

On peut préciser des options de résolution : explicit (pour tenter d'exprimer la solution comme

fonction explicite de la variable) , series (chercher les solutions sous forme de séries)

> eq:={diff(z(x),x)+z(x)*cos(x)=1,z(0)=1}:
    dsolve(eq,z(x));dsolve(eq,z(x),series);

La fonction odeplot du package plots permet de représenter les solutions d'une équation différentielle:

> with(plots,odeplot):
    p:= dsolve({D(z)(x) = z(x),z(0)=1}, z(x),type=numeric): odeplot(p,[x,z(x)],-2..2,title="Fonction exponentielle");

Equations du second ordre: MAPLE sait résoudre directement les équations de type classique

- linéaire - d'Euler - de Bessel .

Équation y " + y ' + y = t

> restart:eq2:=diff(y(t),t$2)+diff(y(t),t)+y(t)=t;

> dsolve(eq2,y(t));

La même avec conditions initiales:

> dsolve({eq2,y(0)=0,D(y)(0)=-1},y(t));

Les options de résolution sont les mêmes qu'à l'ordre 1.

Systèmes différentiels:

Exemple: résoudre x ' =x- 2 y , y ' = 2 x+ 3 y . Représenter la solution vérifiant x (0) = 0 et y( 0) = 1 .

> restart:sys:=diff(x(t),t)=x(t)-2*y(t),diff(y(t),t)=2*x(t)+3*y(t):
    dsolve({sys},{x(t),y(t)});

> p:=dsolve({sys,x(0)=0,y(0)=1},{x(t),y(t)},numeric):
    with(plots):odeplot(p,[[t,x(t)],[t,y(t)]],-1..2);

Résolution d'équations aux dérivées partielles:

> edp:=y*diff(U(x,y),x)+x*diff(U(x,y),y)=0;

> pdsolve(edp,U(x,y) );

Soit f la fonction définie pour tout réel x >0 par .

1° Etablir les singularités de la fonction f et vérifier sa continuité.

2° Etudier les limites de f aux bornes des intervalles composant Df.

Quelle est l'asymptote de la courbe Cf de f ?

3° Calculer f '( x ) et étudier son signe ( on aura recours à une fonction auxiliaire g ).

4° Représenter la courbe Cf.