MISE À JOUR MAPLE V.4
Ce document reproduit l'addendum ajouté au livre Calcul formel : Mode d'emploi -- Exemples en Maple par Claude Gomez, Bruno Salvy et Paul Zimmermann, chez Masson, lors de la sortie de Maple V.4. Il suit la structure du livre, dont une table des matières se trouve ici (et ici en postscript).
Depuis la première parution de ce livre, une nouvelle version de Maple a vu le jour : la version V.4, sortie en janvier 1996 sur Windows. La plus grande partie de ce livre est indépendante du système utilisé et se concentre sur la description des fonctionnalités apportées par les et sur leur mise en oeuvre ; cette partie est bien sûr toujours valable. En revanche pour les exemples, qui utilisent la version V.3 de Maple, une mise à jour s'avère nécessaire.
Les différences entre Maple V.3 et Maple V.4 ne sont pas très importantes et la plupart des applications fonctionnent sans changement. Cependant quelques faiblesses de la version V.3 mises en évidence dans certains exemples ont été corrigées, quelques fonctionnalités supplémentaires sont apparues et, malheureusement, quelques fonctions ne doivent pas être utilisées de la même façon qu'auparavant.
Dans cette mise à jour, nous décrivons les différences les plus importantes entre les deux versions de Maple en reprenant la structure du livre chapitre par chapitre. Pour chaque chapitre, nous détaillons les principales évolutions du système, et nous signalons les modifications à apporter aux exemples lorsque l'ancienne syntaxe ne fournit plus le résultat souhaité.
L'accès le plus simple au détail des différences
entre les deux
versions de Maple est l'item Contents du menu
d'aide, sous la rubrique What's New. Sur certaines
versions (Windows 95 par exemple), un exécutable appelé
What's New fournit ces informations indépendamment de Maple.
On peut aussi exécuter ?updatesR4 directement sous Maple.
Un programme appelé updtsrc et fourni avec la version V.4 effectue la plus grande partie de la traduction d'un programme Maple V.3 en Maple V.4. Ce programme gère les changements syntaxiques entre les deux versions, comme les changements de noms de certaines variables ou fonctions (W est devenu LambertW, LegendreF est devenu EllipticK ou EllipticF, E est supprimé et remplacé par exp(1)). Il peut cependant s'avérer nécessaire d'effectuer d'autres modifications, liées à l'évolution des bibliothèques.
Les fichiers binaires .m créés par Maple V.3 ne peuvent pas être chargés dans Maple V.4. Il faut les recréer à partir de Maple V.4.
En dehors des nouvelles fonctionnalités et des anomalies corrigées, deux transformations du système ont des conséquences importantes sur la compatibilité avec la version antérieure.
Le système encourage donc plus qu'auparavant l'utilisation de la fonction assume pour préciser des hypothèses sur les paramètres. Parallèlement, les capacités de déduction du système à partir des informations données à assume se sont améliorées.
Cependant, spécifier de nombreuses hypothèses sur des paramètres se révèle souvent pénible. Plus fréquemment qu'en Maple V.3, on appellera donc la commande simplify avec l'option symbolic. Parfois cette option ne suffit pas, et l'on pourra alors avoir recours à l'option assume=positive qui exprime l'hypothèse que tous les paramètres sont des réels positifs.
La commande solve a été remaniée. Un plus grand nombre d'équations peuvent être résolues automatiquement. Au cours de ce remaniement, le traitement des équations comportant des RootOf a été altéré. Ainsi l'équation suivante, linéaire en x, a maintenant deux racines !
eq:=x-RootOf(_Z^2-4);
solve(eq,x);
Ce changement dans la sémantique de RootOf complique parfois l'utilisation de solve.
Nous passons maintenant en revue les nouveautés de la version V.4 en respectant la structure du livre.
Du fait de la pression de la concurrence entre les systèmes, les compagnies font porter un effort très important sur l'évolution des interfaces. En Maple V.4, ceci se traduit par des feuilles de travail ( worksheets) entièrement refondues, avec
Page 11. Après solve({eq1,eq2},{x,y}) on obtient des RootOf (cf. § 2.2.4) dans le résultat. La commande allvalues(") remplace les RootOf par les deux solutions.
Pages 13 et 15. Il faut remplacer
simplify(...,symbolic) parsimplify(...,assume=positive).
Il faut aussi utiliser le résultat de cette simplification lors du tracé de
la courbe. La commande de tracé devient donc :
plot("",K=0..2);
Page 23. E n'existe plus. Il est remplacé par exp(1).
Page 24. Après z:=a+I*b, Re(z),Im(z) n'effectuent plus les mêmes simplifications que dans la version V.3. La simplification présente dans Maple V.3 ne semble plus disponible.
Page 26, tab. I.5. L'option symbolic est plus souvent
nécessaire avec combine.
La simplification 
par
combine(...,exp) n'est plus activée que pour b entier ou a
et b de type numeric. On peut toujours obtenir cette
simplification par simplify(...,symbolic).
Page 29, ex. 15. La déduction du signe fonctionne maintenant :
assume(z<1,z>-1): signum(z^2-1);
Le langage de programmation a subi un bon nombre d'évolutions dans le sens d'une plus grande souplesse d'utilisation.
Deux nouvelles fonctions add et mul permettent de réaliser
des sommes et des produits d'expressions indexées. Ceci permet d'effectuer
la somme ou le produit des éléments d'une liste sans utiliser
la fonction convert. Par exemple, pour faire la somme des
éléments de la liste L, on pourra faire
add(i,i=L) plutôt que convert(L,`+`), et pour additionner les
occurrences d'une expression f pour i allant de a à
b, on pourra écrire simplement add(f,i=a..b) au lieu de
convert([seq(f,i=a..b)],`+`). Cette opération est
réalisée de manière efficace du point de vue de l'occupation mémoire.
Par exemple, la fonction u1 p. 188 s'écrit maintenant
u1:=proc(n::nonnegint) local i; if n=0 then 1 else u1(n-1)+add(u1(i)*u1(n-1-i),i=0..n-1) fi end:
Les opérateurs d'addition et de multiplication peuvent s'utiliser en forme
préfixe en V.4, par exemple `+`(10,20,30) ou
`*`(a,b). Ainsi, de plus en plus généralement, les objets
Maple vérifient l'identité
Il est dorénavant possible d'additionner des listes ou multiplier une liste par une constante de type numeric. Lorsque le type n'est pas numeric, l'opération n'a pas lieu. La règle appliquée est identique à celle qui préside au développement automatique de polynômes.
[1,2]+[20,30], 4*[a,2,c], a*[2,3,4];
Ces opérations s'étendent aux listes de listes, et permettent un peu de calcul matriciel.
A:=[[1,2],[3,4]]:B:=[[1,1],[2,3]]: A+2*B;
En conséquence, les fonctions qui manipulaient des listes comme structure de données (comme evalr) utilisent maintenant des fonctions ( INTERVAL dans le cas d'evalr).
L'indexation d'une sous-liste renvoie maintenant une liste au lieu d'une suite d'expressions : après L:=[10,20,30], L[1..2] renvoie la liste [10,20]. Il en est de même pour les ensembles. Il est également possible d'utiliser des indices négatifs pour accéder aux éléments d'une liste comptés en partant de la fin. Ainsi L[-1] renvoie le dernier élément de L, L[-2] renvoie l'avant-dernier, L[3..-2] renvoie la sous-liste comprenant les éléments du troisième à l'avant-dernier.
L'extraction d'une sous-matrice dans une matrice représentée par une liste de listes est ainsi facilitée:
A:=[seq([seq(x[i,j],j=1..5)],i=1..7)]: A[2..3,3..-2];
Une extension de la syntaxe de la fonction op permet d'imbriquer plusieurs appels à op plus facilement. Ainsi, l'appel op(3,op(2,(op(1,f)))) est maintenant remplacé par op([1,2,3],f).
L'opération est réalisée de manière plus efficace. La même extension a été effectuée sur la fonction subsop. Une nouvelle commande applyop permet d'effectuer en une étape l'opération fréquente
Exemple 1. Il est fréquent que dans une expression de taille importante on ne souhaite simplifier qu'une sous-expression. Voici un cas simple :
eq:=sin(x+y)=cos(2*x+3);
applyop(expand,1,eq);
Une nouvelle commande remove, complémentaire de select, est apparue.
Une nouvelle commande map2 permet d'effectuer l'équivalent de la commande map, mais sur le second argument de la fonction. Cette commande s'emploie fréquemment en conjonction avec la commande op :
map2(op,0,[sin(x),cos(2*u+4),tan(ln(2))]);
Dans les déclarations de procédures, :: remplace :. Cette ancienne syntaxe est cependant toujours acceptée, avec un message de mise en garde.
En outre, les déclarations de types dans les arguments des procédures sont plus riches. On peut utiliser le type evaln, qui évalue à un nom l'argument passé à la procédure (comme par la commande evaln), au lieu d'utiliser les règles d'évaluation normales de Maple. On peut utiliser également le type uneval, qui évite l'évaluation de l'argument lors de son passage à la procédure.
Exemple 2. Les deux procédures
test1:=proc(a,b,c) a+b+c end: test2:=proc(a,b::evaln,c::uneval) a+b+c end:permettent d'illustrer ce mécanisme. L'appel test1(u,evaln(v),'w'), où u, v et w sont des expressions quelconques, est strictement équivalent à l'appel test2(u,v,w).
Une nouvelle fonction, typematch permet simultanément de tester un type structuré et de récupérer les différents opérandes dans des variables. Ce mécanisme n'est malheureusement pas disponible au niveau du passage des arguments à une procédure.
typematch(sin(x)^2,a::anything^b::integer);
a,b;
Une nouvelle fonction maplemint prend en argument une procédure Maple et renvoie des commentaires similaires à ceux que produit le programme Mint.
Maple s'est enfin doté d'un debugger, avec une interface assez rustique. Il permet d'exécuter pas à pas une procédure, d'afficher la valeur des variables, et autre fonctions habituelles des debuggers. La documentation s'obtient par ?debugger.
Pour faciliter l'écriture de programmes écrivant ou lisant dans des fichiers, une nouvelle bibliothèque (I/O library) a été ajouté au système. La syntaxe de ses fonctions est inspirée du langage C (printf, scanf, etc.). L'accès à la documentation se fait par ?iolib.
La fonction profile, qui avait disparu de Maple dans la version V.3 a réapparu. Cette fonction permet d'analyser les consommations de temps de en mémoire dues aux différentes parties d'un programme, ce qui facilite l'optimisation de performances. Deux autres outils du même type ( exprofile et excallgraph) permettent d'obtenir des informations détaillées sur le déroulement d'un programme, mais ne fonctionnent pas sur toutes les architectures.
Les fichiers d'aide en ligne crées par `help/text/toto`:=TEXT(...) en V.3 ne fonctionnent plus en V.4 ; la commande makehelp permet dans une certaine mesure de récupérer les anciennes pages d'aide, mais sans le nouveau formattage des pages d'aide sous forme de worksheets structurés.
Dans le cadre des améliorations de l'interface, les graphiques ont beaucoup évolué. Le package plots contient de nouvelles fonctions. Par exemple, une fonction complexplot3d permet d'effectuer en une commande le tracé de la figure III.25 p. 92. Un package plottools vient compléter l'arsenal graphique en permettant de construire des objets graphiques à partir d'éléments prédéfinis.
Exemple 3. La figure 1 montre l'icosaèdre régulier dont les sommets sont aux centres des faces d'un dodécaèdre régulier. Cette figure est obtenue avec les commandes
with(plottools): f:=icosahedron([0,0,0],1,style=PATCH), dodecahedron([0,0,0],sqrt(2.),style=LINE): plots[display](f,scaling=CONSTRAINED);
Les changements à apporter aux exemples de ce chapitre sont mineurs.
Page 80, fig. III.1. L'aspect de la worksheet a légèrement changé.
Page 82, fig. III.5. Avec l'option style=point, on peut choisir en V.4 le symbole utilisé, qui est par défaut une croix. Pour obtenir exactement cette figure, il faut ajouter symbol=POINT.
Page 83, ex. 3. La syntaxe du tracé d'une liste de
points a changé. Il faut remplacer l[i]:=x,y par
l[i]:=[x,y] dans
l'exemple, ou mieux, utiliser la nouvelle fonction
plots[listplot], plus économe en mémoire :
plots[listplot]([seq([l[i]],i=1..10000)]);
Page 89.
La fonction traçant un ensemble de points en trois dimensions s'appelle
désormais pointplot3d au lieu de pointplot.
Page 91, fig. III.24. Il faut ajouter symbol=POINT
pour obtenir des
points et non des croix dans le tracé.
Le nouveau package combstruct fournit un langage de description des structures combinatoires décomposables dans l'esprit de la section combinatoire de ce chapitre. Le calcul de fonction génératrice n'y est pas encore disponible.
Pages 103 et 104.
Dans les exemples la forme des solutions retournées par isolve
est différente, mais les espaces engendrés sont bien les mêmes.
Pages 124 et 125, tableau V.3. La fonction add du package linalg a été renommée matadd, puisque add est maintenant une fonction du langage.
Page 130, ex. 15. eigenvects(A) donne maintenant directement toutes les valeurs et vecteurs propres et il n'y a plus de RootOf dans ce résultat. En conséquence, il est inutile d'utiliser eigenvects(A,radical) dans ce cas-ci.
Pages 130 et 131, ex. 17. Le calcul de la matrice de passage par jordan(A,'P') est maintenant possible.
Pages 131 à 133, ex. 19. La matrice de passage retournée par la
fonction jordan est l'inverse de celle donnée par la
version V.3. Il faut donc
intervertir P et 
en bas de la page 131 et en haut de la
page 132, et les deux calculs de F page 133 se font par :
F:=evalm(P &* B &* P^(-1)): print(F,map(expand,evalm(F^2)));(il faut appeler explicitement expand en V.4 pour obtenir la matrice de départ A).
Page 139. La matrice de passage P retournée étant l'inverse de celle donnée par la version V.3, cela implique une interversion des lignes et des colonnes dans le calcul. Au bas de la page 139, on calcule donc P de la façon suivante :
P:=augment(seq(map(simplify,normalize(i)),i=col(P,1..2)));et pour calculer le polynôme dans cette nouvelle base :
expand(evalm(subs(v=evalm(P &* vector([x,y])),Phi)));(ici aussi, il faut ajouter expand qui n'était pas nécessaire en V.3).
Certains calculs simples de géométrie euclidienne dans le plan peuvent maintenant être traités à l'aide d'un package geometry refait à neuf.
La commande coeff ne requiert plus que le polynôme soit développé par rapport à la variable correspondante. Dans le cas où l'on souhaite extraire plusieurs coefficients d'un polynôme, il reste recommandé d'effectuer collect au préalable, ce qui rend l'extraction de coefficients plus efficace.
Une nouvelle option fullparfrac de la commande convert
renvoie la
décomposition en éléments simples d'une fraction rationnelle
sur 
. Les calculs sont effectués de manière à renvoyer le
résultat sans effectuer de factorisation, il peut donc être
intéressant pour certaines applications de factoriser le
dénominateur au préalable.
Exemple 4. On considère la fraction rationnelle
f:=1/(x^3-2*x^2+2*x-4);
convert(f,parfrac,x);
convert(f,fullparfrac,x);
convert(factor(f),fullparfrac,x);
Les exemples de ce chapitre sont inchangés.
Le package LREtools contient un certain nombre d'outils pour la manipulation de récurrences linéaires, et en particulier les commandes polysols, ratpolysols et hypergeomsols qui trouvent les solutions polynomiales, rationnelles ou hypergéométriques de récurrences linéaires, et sont utilisées par rsolve pour résoudre plus de récurrences qu'auparavant. La robustesse de ces procédures laisse encore toutefois un peu à désirer.
Page 175. La récurrence rec peut maintenant être résolue par la routine polysols du package LREtools. Néanmoins, à la suite d'une anomalie dans cette procédure, il faut l'appeler avec l'une des options output=onesol ou output=basis pour obtenir le résultat.
Page 176. La récurrence rec devrait pouvoir être résolue par la procédure ratpolysols de LREtools. Là encore, il faut utiliser l'une des options ci-dessus. La commande rsolve, appliquée directement à rec renvoie maintenant un message d'erreur, à la suite d'une anomalie dans hypergeomsols.
Page 177. Là encore, les fonctionnalités de LREtools devraient permettre de venir à bout de cette récurrence, mais l'utilisation de ce package fait apparaître trop de difficultés.
Page 181, ex. 5. La fonction solve renvoie deux racines au lieu d'un RootOf, il faut donc changer le solve suivant en solve(x="[1],x),solve(x="[2],x);
Page 183. W est devenu LambertW.
Page 199. La fonction Psi s'est améliorée, on
obtient directement 
.
Page 200. W devient LambertW, et il faut ajouter l'option symbolic à simplify.
Page 215. Il faut augmenter l'ordre des développements pour obtenir le même résultat.
Page 220. Il faut ajouter eval à subs.
Page 220. readlib(laplace) devient with(inttrans,laplace).
Page 224. La fonction solve renvoie maintenant quatre
racines à l'équation de degré 2 comportant des RootOf. Il
n'est pas difficile de voir que la racine souhaitée
est 
, et le calcul se poursuit comme avant.
La fonction int parvient à calculer plus d'intégrales qu'en Maple V.3, et prête plus d'attention aux singularités et aux paramètres. Le nouveau package inttrans (pour integral transforms, c'est-à-dire transformations intégrales) regroupe les anciennes commandes fourier, invfourier, laplace, invlaplace, ztrans, invztrans et mellin, ainsi que de nouvelles transformations intégrales. Les tables ont été étendues et l'interface a été unifiée. En particulier, une nouvelle fonction addtable permet à l'utilisateur d'étendre les tables connues du système.
Page 234, ex. 10. L'intégrale du produit de fonctions de DIRAC est retournée sous une forme différente.
Page 236, ex. 13. Au bas de la page, le résultat de l'intégration est retourné sous une forme légèrement différente.
Page 238, ex. 14. Maple donne maintenant une réponse correcte, c'est-à-dire qu'il retourne l'intégrale non évaluée.
Page 238, ex. 17. Maple donne maintenant des réponses correctes pour toutes les intégrales : il retourne l'intégrale non évaluée pour
et fournit le bon résultat pour l'intégrale suivante :
f:=sqrt(1-cos(x)^2): F:=int(f,x);
int(f,x=0..Pi);
Page 239, ex. 18. Maple donne le résultat correct 0 pour le calcul de :
Page 241, ex. 19. Maple retourne le résultat sous une
forme différente en utilisant la fonction Bêta d'Euler
(l'appel à normal n'est plus nécessaire) :
int(x^(-1/3)*ln(x)*(1-x)^(1/2),x=0..1);
Page 242, ex. 21. Maple retourne le résultat sous une forme différente, car les intégrales elliptiques ont été renommées.
Page 242. Maple retourne ici encore le résultat de la
première intégration sous une forme différente en utilisant le
cosinus intégral 
:
assume(a>0):int(cos(x)/(x^2+a^2),x=0..infinity);
Im(");
Cette réponse est correcte car 
,
donc la partie réelle est nulle.
Signalons ici une erreur dans la dernière ligne de la page 242 : il ne faut pas
diviser l'intégrale par 2 car cela a déjà été fait dans l'expression de f.
Cette erreur ne porte pas à conséquence ici car l'intégrale est nulle.
Page 244, ex. 23. Le résultat renvoyé par solve est maintenant réduit au même dénominateur.
Page 245, ex. 24. Maple sait maintenant calculer l'intégrale et il est inutile de passer par la transformée de LAPLACE.
Page 246, ex. 25. La fonction fourier étant maintenant dans le package inttrans, il ne faut plus utiliser readlib(fourier). De plus le résultat n'est plus donné sous la même forme :
fourier(eq,t,s);
solve(",fourier(x(t),t,s));
Mais il faut alors aider Maple en lui indiquant comment transformer les fonctions fourier qui restent en fonctions de DIRAC :
addtable(fourier,exp(I*omega*t),2*Pi*Dirac(s-omega),t,s); ";
Ensuite, le calcul se poursuit normalement.
Page 251, ex. 30. Il est maintenant nécessaire de signaler à Maple que le paramètre t est positif, sinon une erreur est retournée par Maple dans le calcul de l'intégrale.
Page 252, ex. 32. L'utilisation de la fonction rsolve fonctionne toujours, mais le résultat n'est pas donné sous la même forme.
Le package DEtools a été sérieusement retravaillé. Les faiblesses de la fonction DEplot du package DEtools ont été résolues. La syntaxe des fonctions DEplot et phaseportrait a légèrement changé. De plus, par défaut des flèches indiquent la direction du champ de vecteurs lorsque l'on utilise les fonctions de tracé du package DEtools. Si l'on veut les supprimer il faut utiliser l'option arrows=NONE.
Une nouvelle fonction pdesolve résout certaines équations aux dérivées partielles, ce qui n'existait pas dans les versions précédentes.
Pages 257 et 258, ex. 1. La fonction dsolve donne le résultat sous une forme différente où intervient en particulier l'expression :
dont il faut se débarrasser afin de pouvoir terminer la résolution. Une solution est de remplacer cette expression par une de ses valeurs, après la commande "[1] :
subs(sqrt(1/(A*x*(y(x)^4-2*y(x)^2+1)))=
1/(sqrt(A)*sqrt(x)*(y(x)^2-1)),"):
puis de réaliser des simplifications (il faut ici signaler que A
est positif) :
assume(A>0):
collect(",indets(",ln(anything)),simplify);
Le calcul se poursuit alors normalement, la constante 
étant
maintenant égale à 0.
Page 258, ex. 2. La commande dsolve retourne la solution en fonction de :
qui correspond à la racine 
.
Pour obtenir le résultat désiré, on appelle ensuite la
fonction convert/radical :
convert([dsolve({deq,y(0)=1,D(y)(0)=1},y(x))],radical);
Page 261, ex. 7. La fonction DEplot a changé de syntaxe. La nouvelle syntaxe est :
DEtools[DEplot](deq,y(x),0..20,{[0,1]},
stepsize=0.2,arrows=NONE)
Page 262, ex. 7. On peut maintenant écrire directement, en tenant compte du changement de syntaxe :
DEtools[phaseportrait](
[D(x)(t)=y(t),D(y)(t)=-y(t)-3*sin(x(t))],
[x(t),y(t)],0..40,{[0,0,2]},stepsize=0.1,arrows=NONE);
Page 265, ex. 9. La commande pour le tracé de la géodésique :
plots[odeplot](res,subs(time_dep,pt),0..10);fonctionne maintenant correctement.
Page 274, ex. 7. Une nouvelle erreur est apparue dans la fonction limit :
limit((5/1296/2^s/(3^s)^2)^(-1/s),s=infinity);
Cette erreur est de plus non déterministe : la limite correcte 18 est
parfois renvoyée.
Lorsque le problème se produit, on peut le contourner en divisant au
préalable chaque
terme par son facteur rationnel, donné par icontent(t) :
f5bon:=select(t->test(
limit((t/icontent(t))^(-1/s),s=infinity)),f5):
Page 278. L'ordre 1 suffit pour avoir deux termes dans le premier
développement (en u). Dans le second développement, le terme d'erreur est
meilleur : 
au lieu de O(1).
Les fonctions C et fortran ne sont plus limitées à des expressions et parviennent maintenant à produire des fonctions C et Fortran à partir de certaines procédures Maple.
Page 293. Dans le calcul de la longueur L, il faut explicitement développer l'expression à intégrer afin de simplifier le travail pour Maple V.4. Cela était fait automatiquement dans la version V.3. Le calcul devient donc :
Lap:=l+(int(expand(dy[1]),x=0..c)+int(expand(dy[2]),x=c..l))/2:Le résultat obtenu n'a pas exactement la même forme. L'expression n'a donc pas le même nombre de termes :
length(Lap);
Certaines des commandes suivantes retournent donc les mêmes valeurs, mais sous une forme différente :
Lap:=limit(subs(c=l/2,l*p=ln(t),expand(convert(Lap,exp))),
t=infinity);
L = (24*T**2*l**2*p**3-12*F*M2*p**3*l-12*M1**2*p**3+3*F**2*p**3*l*
#*2+q**2*l**4*p**3+12*F*M1*p**3*l-12*M2**2*p**3-24*M1*M2*p**3+12*q*
#M1*l**2*p**3-24*q**2*l**2*p+60*q**2*l-12*q*M2*p**3*l**2+6*p**4*M1*
#*2*l-36*q*M1*p**2*l+36*q*M2*p**2*l+3*F*l**3*q*p**3-48*F*q*p*l-9*F*
#*2*p**2*l+6*p**4*M2**2*l)/T**2/l/p**3/24
Le package tensor donne des fonctions de manipulations de tenseurs.
Une nouvelle procédure piecewise permet de décrire des fonctions définies par morceaux. Certaines fonctions du système parviennent à s'en accommoder (par exemple, diff renvoie la dérivée par morceaux).
L'évaluation numérique des fonctions spéciales dans le plan complexe a fait l'objet d'un important effort. De nombreuses fonctions ont été ajoutées ; toutes peuvent maintenant être évaluées avec une précision arbitraire en tout point (non singulier) du plan complexe.