Calcul formel |
Je remercie:
© 2002, 2006 Renée De Graeve, renee.degraeve@wanadoo.fr
La copie, la traduction et la redistribution de ce document sur support
électronique ou papier sont autorisés pour un usage non commercial
uniquement.
L’utilisation de ce document à des fins commerciales est interdite
sans l’accord écrit du détenteur du copyright.
Cette documentation est fournie en l’état, sans garantie d’aucune
sorte. En aucun cas le détenteur du copyright ne pourra être tenu
pour responsable de dommages résultant de l’utilisation de ce
document.
Ce document est disponible à l’adresse Internet suivante :
http://www-fourier.ujf-grenoble.fr/~parisse/cascmd_fr.pdf
Bernard Parisse
Maître de Conférences à l’Université de Grenoble I
Développeur du logiciel de calcul formel giac et de son interface
Xcas.
La version à jour se récupère sur ;
http://www-fourier.ujf-grenoble.fr/~parisse/giac.html
|
|
giac est la bibliothèque C++ de fonctions de calcul formel.
Pour connaitre le numéro de la version de giac que vous utilisez, on
tape :
On obtient par exemple :
Sous Unix, on peut utiliser cette bibliothèque de calcul formel avec plusieurs interfaces :
Cette interface va vous permettre d’ouvrir plusieurs sessions de
calculs : ces sessions ont plusieurs niveaux d’entrée, sont indépendantes
les unes des autres et peuvent être pliée ou dépliée.
Chaque session peut contenir des niveaux d’entrée numérotés qui
contiendront :
^10-1))^100-1))
Au sein d’une même session, les différents niveaux d’entrée ne sont pas
indépendants, par exemple, une variable définie dans une ligne de commandes
pourra être utilisée en géométrie ou dans le tableur.
L’ensemble de toutes ces sessions constitue votre espace de travail.
Le niveau actif est celui où se trouve le curseur et le niveau selectionné
est obtenu quand on clique sur son numéro, numéro qui sécrit alors sur
fond noir.
On peut déplacer un niveau ou un groupe de niveau
dans une session, ou le recopier dans une autre session.
Vous pouvez , à tout moment insérer un nouveau niveau ou encore changer
l’entrée d’un niveau : Enter valide le changement de ce niveau et
sélectionne l’entrée suivante, mais attention les niveaux suivants
ne seront pas recalculés. Il est toutefois possible après une modification
de réexécuter, soit tous les niveaux, soit les niveaux situés
après la modification (menu Edit puis Executer session ou
Executer en-dessous).
Il faut savoir qu’il suffit de faire :
Vous obtenez au démarrage l’ouverture d’une session avec de haut en bas :
\includegraphics[width=\textwidth]{session1}\usepackage{graphicx}Les différentes configurations se font :
On peut avoir de l’aide sur les différentes fonctions de calcul formel de plusieurs façons. On peut cocher la case Aide HTML automatique de la configuration générale pour avoir l’ouverture de l’aide detailléeà chaque appel d’une fonction se trouvant dans les menus ou ne pas cocher cette case pour avoir de l’aide seulement lorqu’on le désire, toutefois une aide succincte apparait dans la ligne des messages à chaque appel d’une fonction se trouvant dans les menus. On peut avoir accès à l’aide générale ou à l’aide par fonction tout le temps (voir ci-dessous).
Il est préférable de mettre les suffixe suivants :
.cxx (ou .map ou .mu ou .ti selon le mode) pour un
script et par exemple,
.xws pour la session de travail,
.cxx pour une fonction,
.tab pour le tableur,
.tex pour le graphique en latex,
.eps pour le graphique et pouvoir ensuite inclure le fichier dans un
texte en latex ou en postscipt,
.png pour le graphique et pouvoir ensuite inclure le fichier dans un
texte en html.
On peut à tout moment faire apparaitre une ligne pour écrire un commentaire
avec Alt+c.
Le commentaire s’écrit sans utiliser de guillemets et apparait en vert.
Le commentaire ne génère pas de réponse.
Le commentaire sert à commenter votre session.
Depuis un commentaire on peut ouvrir le navigateur à une adresse donnée
On tape dans une ligne de commentaire :
On obtient :
Dans une ligne de commentaire, on peut ouvrir le navigateur à une adresse donnée : On tape dans une ligne de commentaire :
On obtient :
Attention
Pour faire un commentaire dans un programme il faut utiliser la commande
comment qui a comme argument une chaîne de caractères ou bien
utiliser // qui doit etre suivi du commentaire et d’un retour à la
ligne. Quand il y a un commentaire dans un programme, tout se qui se trouve
entre // et le retour à la ligne n’est
pas pris en compte par le programme.
On tape :
On tape :
On obtient :
Dans l’éditeur d’expressions, l’affichage ne se fait pas linéairement mais
se fait en dimension 2d.
Quand on a mis une expression dans l’éditeur d’expressions, on peut facilement
sélectionner des sous-expressions et appeler les fonctions des menus sur
ces sous-expressions puis appuyer sur enter pour avoir la réponse en
dessous de l’éditeur d’expressions ou encore évaluer la sélection dans
l’éditeur d’expressions avec le bouton eval.
Dans l’éditeur d’expressions, on peut utiliser les raccourcis suivants sur la
sélection de sous-expressions :
Ctrl+s pour la commande simplify
Ctrl+r pour la commande integrate
Il faut tout d’abord ouvrir un tableur avec Alt+t.
À chaque tableur est attaché un écran de géométrie,
une barre de menu (Fich Edit Statistiques), des boutons
(reeval,val,Save), deux cases (l’une donne le nom du fichier
de sauvegarde et l’autre le nom de la cellule
sélectionnée) et deux lignes (l’une contient une case de sélection et
une ligne dite ligne de commandes qui sert soit à remplir la cellule
sélectionnée, soit à afficher ce que l’on a mis dans la cellule
sélectionnée, et l’autre est la ligne d’état qui rappelle la
configuration du tableur et sert de bouton pour ouvrir un écran de
configuration du tableur).
Si le graphe dépend d’une fonction utilisateur, il faut que la fonction soit définie lorsque le(s) paramètre(s) a (ont) une valeur formelle, ce qui peut se faire en testant le type du paramètre, comme dans l’exemple suivant : Je définis f avec le test du type du paramètre et g sans le test par :
f(x):= {
if (type(x)!=DOM_FLOAT) return 'f'(x);
while(x>0){ x--; }
return x;
}:;
g(x):= {
while(x>0){ x--; }
return x;
}:;
Si je tape :
F:=plotfunc(f(x)) ou G:=plotfunc(g(x)) j’obtiens le même graphe.
Le problème apparait lorsque x n’a pas de valeur et que l’on réutilise
G.
Mais si on fait :
G:=plotfunc(g(x)) puis symetrie(droite(y=x),G)
ou même simplement G on a l’erreur :
"Unable to eval test in loop : x>0.0 Error: Bad Argument Value"
parce que l’évaluation de g(x) ne peut pas se faire si x est formel.
Par contre, F:=plotfunc(f(x)) puis
symetrie(droite(y=x),F) renvoie bien le symétrique du graphe par
rapport à la première bissectrice grâce au test de la ligne :
if (type(x)!=DOM_FLOAT) return ’f’(x);. D’ou l’intérêt de rajouter
le test.
Par contre on peut taper directement sans provoquer d’erreurs :
symetrie(droite(y=x),plotfunc(g(x))).
Explications
Il faut savoir que dans les réponses de certaines commandes
(par exemple G:=plotfunc(g(x))) il va figurer l’expression
formelle de g(x) (par exemple G contient
expr("curve(group[pnt[x+(i)*g(x),x,x,-5.0,5.0125,0]...]))).
Lors de l’évaluation de G il y aura une erreur car x+(i)*g(x)
ne pourra pas être évalué puisque l’évaluation de g(x) provoque
l’évaluation du test x>0 qui ne peut pas être évalué car x
n’a pas de valeur ....d’où une erreur mais si dans
la fonction figure le test : if (type(x)!=DOM_FLOAT) return ’g’(x);
cela supprime l’évaluation de g(x) et donc l’erreur due au test
x>0.
En effet, F:=plotfunc(f(x)) puis
symetrie(droite(y=x),F) renvoie bien le symétrique du graphe par
rapport à la première bissectrice grâce au test de la ligne :
if (type(x)!=DOM_FLOAT) return ’f’(x);.
Par contre on peut taper directement sans provoquer d’erreurs :
symetrie(droite(y=x),plotfunc(g(x)))
Un écran graphique 2-d ou 3-d s’ouvre automatiquement en réponse d’une
commande graphique 2-d ou 3-d. À un écran graphique 2-d ou 3-d est attaché
des boutons situés en haut et à droite de cet écran.
Un écran de géométrie plane s’ouvre avec les touches Alt+g :
c’est un écran graphique 2-d interactif muni de lignes d’entrée, d’une barre
de menus contenant les menus Fich Edit et d’un bouton Save. Cet
écran graphique est interactif : on peut définir des points et des segments
en cliquant avec la souris.
Un écran de géométrie 3-d s’ouvre avec les touches Alt+h :
c’est un écran graphique 3-d muni de lignes d’entrée, d’une barre de
menus contenant les menus Fich Edit et d’un bouton Save.
Les boutons d’un écran graphique 2-d et 3-d sont les mêmes en apparence mais
leurs contenus sont quelquefois différents :
Avant de faire un tracé, il faut régler les différents paramètres de la
configuration de l’écran graphique :
le menu Cfg▸Configuration graphique (cf section 1.6.2) règle les
paramètres de tous les graphiques qui se feront lors de la session. On peut
changer ensuite ses paramètres au coup par coup avec le bouton cfg
attaché à chaque écran graphique (cf3.4).
Les commandes du cas qui ont comme réponses un graphique 2-d ou 3-d
seront tapées dans une ligne d’entrée. Toutefois les commandes du cas
qui ont comme réponses un graphique 2-d peuvent aussi être tapées soit
dans une ligne d’entrée d’un écran de géométrie.
Attention! Un écran de géométrie est un écran graphique
interactif.
Les commandes graphiques se trouvent dans le sous-menu Graphic du menu
Cmds.
Les commandes de géométrie se trouvent dans le menu Geo.
Le bouton cfg permet de régler la fenêtre graphique.
Voir aussi : 1.10.3 et 1.10.5
Il faut employer la commande graph2tex("nom.tex") (ou pour un graphique
3-d graph3d2tex("nom.tex")) pour transformer tous les
graphiques réalisés en le fichier Latex nom.tex.
Ce fichier pourra
être visualisé seul ou bien inséré dans un autre fichier Latex en otant
l’en tête \documentclass{article}...\begin{document}, et le
\end{document} de la fin et de rajouter \usepackage{pstricks}
dans l’en-tête du fichier dans lequel on l’insère.
Attention Dans ce fichier tous les graphiques seront superposés : pour
n’avoir qu’un seul graphique, il faut supprimer les niveaux contenant les
autres graphiques avant de faire graph2tex("nom.tex").
graphe_probabiliste a comme argument une matrice de transition
probabiliste A ayant au plus 7x7 entrées. On peut rajouter en option la
liste des positions des sommets du graph associé à la matrice A.
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
Si on ne met pas les "" autour d’un nom, si ce nom est le nom d’une variable
qui contient une valeur c’est cette valeur que sera affichée sinon les noms
s’afficheront sans "".
On peut aussi définir les points pour définir le graphe, par exemple,
on tape dans un nieau de géométrie 2d :
:
A:=point(0);
B:=point(1);
C:=point(i);
D:=point(2/2+2i/3);
graphe_probabiliste([[1/2,1/3,1/12,1/12],[1/3,1/2,1/6,0],
[0,0,1/2,1/2],[1/4,1/4,1/4,1/4]],[A,B,C,D])
On peut alors bouger les points A,B,C,D en mode pointeur.
On obtient après avoir bougé D :
plot(f(x),x) trace la représentation graphique de y=f(x).
On tape :
^2-2,x)On obtient :
^2-2On peut rajouter un paramètre pour indiquer le saut d’échantillonnage en x c’est à dire le pas en x que l’on veut utiliser pour faire le graphe. On tape :
^2-2,xstep=1)ou encore
^2-2,x,xstep=1)On obtient :
^2-2
On peut aussi spécifier le nombre de points d’échantillonage de la
fonction à représenter en utilisant nstep à la place
de xstep. Par exemple, on tape :
^2-2,x=-2..3,nstep=30)
plot3d a trois arguments une fonction de deux variables (ou une
expression de deux variables ou une liste de trois fonctions de deux variables
ou encore une liste de trois expressions de deux variables) et les noms de ces
deux variables.
plot3d trace la surface définie par le premier argument (soit z=f(x,y), soit x=f(u,v),y=g(u,v),z=h(u,v)).
On peut faire tourner ce graphique selon
l’axe des x, l’axe des y ou l’axe des z. Pour cela, il faut
cliquer avec la souris dans la fenêtre graphique en dehors du
parallélépipéde servant à la représentation, puis faire bouger la
souris (sans relacher son bouton) ou utiliser les touches x, X,
y, Y, z et Z.
On tape :
On obtient :
On tape :
On obtient :
Pour n’avoir qu’une portion de surface on peut indiquer l’intervalle de variation dans le deuxième et le troisème argument.
On tape :
On obtient :
plotinequation([f1(x,y)<a1,..,fk(x,y)<ak],[x=x1..x2,y=y1..y2]) trace la surface du plan définie par les inéquations à 2 variables :
| f1(x,y)<a1 |
| ... |
| fk(x,y)<ak |
| x1<x<x2 |
| y1<y<y2 |
On tape :
^2-y^2<3, [x=-2..2,y=-2..2],xstep=0.1,ystep=0.1)On obtient :
^2-y^2=3 est remplieOn tape :
^2<y], [x-2..2,y=-1..10],xstep=0.2,ystep=0.2)On obtient :
^2 est rempli
Attention
Si on ne met pas les bornes pour x et y ce sont les valeurs de
X-,X+,Y-,Y+ mises dans la configuration générale du graphique
(Cfg▸Configuration graphique) qui
seront prises en compte.
^2,x=0..1,5,trapeze)^2,x=0..1,5,trapeze); plot(x^2,x=0..1,affichage=rouge)^2,x=0..1,5,point_milieu)^2,x=0..1,5,point_milieu); plot(x^2,x=0..1,affichage=rouge)Remarque 1 On peut aussi taper, pour n’avoir que la valeur de l’aire :
^2,x=0..1,5,trapeze)[0,3];On obtient :
Remarque 2 Si on utilise plotarea avec le menu Graphic->Courbes->plotarea une boite de dialogue s’ouvre : vous entrez, l’expression de la fonction, le nom de la variable, les bornes de l’intervalle xmin,xmax, le pas xstep (on a alors n=(xmax-xmin)/xstep), la méthode d’intégration et aussi la couleur du dessin (on retrouve en effet le bouton Attribut en haut et à gauche de la boite de dialogue).
plotcontour(f(x,y),[x,y]) (ou DrwCtour(f(x,y),[x,y]) ou
encore contourplot(f(x,y),[x,y]))
trace les 11 lignes de niveaux z=−10, z=−8,.., z=0, z=2,.., z=10 de la
surface définie par z=f(x,y).
On tape :
^2+y^2,[x=-3..3,y=-3..3],[1,2,3], affichage=[vert,rouge,noir]+[rempli$3])On obtient :
^2+y^2=n pour n=1,2,3; les zones comprises entre ces cercles sont remplies avec la couleur verte,rouge ou noire On tape :
^2-y^2,[x,y])On obtient :
^2-y^2=n pour n=-10,-8,..10Pour visualiser la surface, on tape (plotfunc(f(x,y),[x,y]) trace la représentation graphique de z=f(x,y), voir 3.7.2):
^2-y^2,[x,y])On obtient :
^2+y^2On peut faire tourner ce graphique selon l’axe des x, l’axe des y ou l’axe des z. Pour cela, il faut cliquer avec la souris dans la fenêtre graphique en dehors du parallélépipéde servant à la représentation, puis faire bouger la souris (sans relacher son bouton) ou utiliser aux touches x, X, y, Y, z et Z.
plotdensity(f(x,y),[x,y]) ou
encore densityplot(f(x,y),[x,y])
trace le graphe de z=f(x,y) dans le plan en représentant
z par une des couleurs de l’arc en ciel.
On tape :
^2-y^2,[x=-2..2,y=-2..2],xstep=0.1,ystep=0.1)On obtient :
^2-y^2=z par une couleur de l’arc en cielOn remarquera que l’on a l’echelle des couleurs en dessous du graphe.
plotimplicit ou implicitplot permet de tracer des courbes ou des surfaces définies de façon implicite par une expression. Pour que Xcas ne cherche pas à factoriser l’expression, la commande plotimplicit ou implicitplot peut être utilisée avec l’option unfactored ou sans_factoriser mise comme dernier paramètre, :
Soient n+1 points Pj de contrôle (j=0..n) et L la séquence de ces
points.
La courbe de Bézier ayant les points de la séquence L comme points de
contrôle, a comme équation paramétrique :
∑j=0n comb(n,j)tj(1−t)n−j*L[j].
bezier(L,plot) renvoie le tracé de la courbe d’équation
paramétrique : ∑j=0n comb(n,j)tj(1−t)n−j*L[j].
parameq(bezier(L)) renvoie l’équation paramétrique de la courbe de
Bézier ayant comme points de contrôle les points de la séquence L.
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
plotpolar(f(t),t) trace la représentation polaire
de la courbe définie par : ρ=f(t).
On tape si dans la configuration du graphique t va de 0 à 10 :
On obtient :
On peut rajouter un paramètre (tstep=) pour indiquer le saut d’échantillonnage en t c’est à dire le pas en t que l’on veut utiliser pour faire le graphe. On tape si dans la configuration du graphique t va de 0 à 10 :
ou :
On obtient :
plotseq(f(x),a,n) ou plotseq(f(t),t=a,n) permet de
visualiser les n premiers termes d’une suite récurrente définie par :
u0=a, un=f(un−1)
On tape :
On obtient :
On peut tracer le champ des tangentes de léquation différentielle y′=f(t,y) ou du système déquations différentielles x′=u(x,y),y′=v(x,y) et on peut spécifier les plages de valeurs des paramètres.
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On peut tracer les solutions de léquation différentielle y′=f(t,y) ou du système déquations différentielles x′=u(t,x,y),y′=v(t,x,y) et on peut spécifier les plages de valeurs des paramètres.
On tape :
On obtient :
On tape :
On obtient le graphe dans l’espace de la solution de
| [h,p]′=[h−0.3 h p, 0.3 h p−p] [h,p](0)=[0.3,0.7] |
Pour avoir le graphe dans le plan, on ajoute l’option plan ou plane
Pour visualiser les valeurs de la solution, se reporter à la section 4.3.6 On tape :
On obtient :
Exemple
On trace 4 solutions du système d’équations différentielles dépendant de 2 paramètre a et b :
x′=−y+b
y′−1+(x−a)2+(y−b)2
Les conditions initiales sont :
pour t=0 x0=a+1,y0=b+0.5
pour t=0 x0=a+1,y0=b+0.1
pour t=0 x0=a+0.827,y0=b+0.827
pour t=0 x0=a−1.1,y0=b+
On tape :
avril(a,b):={
local L;
L:=NULL;
L:=L,affichage(plotode([-y+b,-1+(x-a)^2+(y-b)^2],[t=-3..3,x,y],[0,a+1,b+0.5],
plan),94+epaisseur_ligne_8);
L:=L,affichage(plotode([-y+b,-1+(x-a)^2+(y-b)^2], [t=-3..3,x,y],[0,a+1,b+0.1],
plan),4+epaisseur_ligne_8);
L:=L,affichage(plotode([-y+b,-1+(x-a)^2+(y-b)^2],[t=-6..3.65,x,y],
[0,a+0.827,b+0.827],plan),1+epaisseur_ligne_4);
L:=L,affichage(plotode([-y+b,-1+(x-a)^2+(y-b)^2], [t=-1.3..1.3,x,y],[0,a-1.1,b],
plan),1+epaisseur_ligne_4);
return L;
}:;
Puis on tape par exemple :
affichage(cercle(0,5,3*pi/4,4*pi/3),4+epaisseur_ligne_4); affichage(cercle(0,5,5*pi/3,2*pi+pi/4),4+epaisseur_ligne_4); affichage(segment(5*exp(-i*pi/3),5*exp(-2*i*pi/3)),4+epaisseur_ligne_4); avril(-1.4,-1);
interactive_plotode(f(t,y),[t,y]) trace le champ des tangentes
de l’équation différentielle y′=f(t,y) dans l’écran DispG et
interactive_plotode(f(t,y),[t=a...b,y]) trace le champ des tangentes
pour t allant de a à b de l’équation différentielle y′=f(t,y) dans l’écran DispG.
Lorsqu’on clique sur un point, on obtient le tracé de la solution de
y′=f(t,y) passant par ce point.
On peut faire autant de tracés que l’on veut (un tracé se fait chaque fois
que l’on clique sur un point avec la souris). On termine les tracés en
tapant sur la touche Esc ou Echap.
On peut aussi spécifier, comme dans plotfield, que le champ des
tangentes soit de norme 1 avec l’option normalize.
Attention
Si on ne veut pas de superposition avec les dessins faits auparavant, il ne
faut pas oublier de taper ClrGraph, avant d’utiliser
interactive_plotode, pour effacer l’écran DispG.
On tape :
On obtient :
IL se trouve que l’on sait résoudre cette équation : les solutions sont
y(x)=C*exp(-x)+x et on peut donc vérifier...
On tape :
On obtient :
On tape :
On obtient :
Dans un niveau de géométrie, le menu Graphe->Slopefield/Ode(2d) ouvre une boite de dialogues qui demande :
Lorsqu’on appuie sur OK, l’écran de géométrie est en mode plotode et si l’on a coché Field, le champ des tangentes apparait et la commande correspondante s’inscrit au niveau suivant de l’écran de géométrie, par exemple :
Si on a coché Field et ||=1, et que y′=sin(t*y).
Ensuite, il suffit de cliquer en différents points de lécran de
géométrie pour avoir les tracés des solutions passant par ces points et
les commandes correspondantes stockées dans une variable, par exemple :
Pour terminer, il suffit de changer de mode, par exemple passer en mode
Repere. Il faut noter que le mode plotode n’est pas accessible
directement : on doit réouvrir la boite de dialogue avec le menu
Graphe->Slopefield/Ode(2d).
Si on trouve que le champ des tangentes est génant, on peut le supprimer
facilement en supprimant le niveau correspondant à sa commande.
Xcas permet d’animer des graphes en 2-d, 3-d ou "4D" en calculant une fois pour toute une suite d’objets graphiques et en affichant chaque objet de la sequence en boucle.
Voici comment sont codées les nombres réels lorsque le nombre de chiffres
significatifs demandés est inférieur ou égal à 16 (par exemple
Digits:=15).
On écrit d, un nombre réel ou décimal, sous la forme :
d=2α(1+m) avec 0<m<1 et −210<α≥ 210.
On utilse 64 bits pour représenter ce nombre :
Codage de 2α :
α=0 est codé 011 1111 1111
α=1 est codé 100 0000 0000
α=4 est codé 100 0000 0011
α=5 est codé 100 0000 0100
α=−1 est codé 011 1111 1110
α=−4 est codé 011 1111 1011
α=−5 est codé 011 1111 1010
α=210 est codé 111 1111 1111
α=2−10−1 est codé 000 0000 0000.
Remarque
2−52=0.2220446049250313e−15
On peut évaluer une expression numérique grâce à la
commande evalf ou approx.
En mettant un deuxième argument n à evalf (ou approx), on
peut spécifier le nombre de chiffres significatifs de l’approximation.
Mettre ce deuxième argument a l’avantage de ne pas modifier la valeur de
Digits (i.e. la case Chiffres de la configuration du CAS).
Attention l’affichage tiendra compte de la valeur p de Digits
si p<15 et si le deuxième argument n de evalf est
supérieur à p mais les calculs seront faits avec n chiffres
significatifs.
Exemple 1
Avec Digits:=12.
On tape : a:=1234+1/7
On obtient : 8639/7
On tape : b:=evalf(a,9)
On obtient : 1234.14286 (9 chiffres significatifs avec un arrondi)
On tape : c:=evalf(a,16)
On obtient : 0.1234142857142857e4 (16 chiffres significatifs)
On tape : d:=evalf(a,21)
On obtient : 0.123414285714285714286e4 (21 chiffres significatifs)
On tape : 7*a,7*b,7*c,7*d
On obtient :
8639,8639.00002,0.8639000000000001e4,0.863900000000000000000e4
Mais avec Digits:=7.
On tape : a:=1234+1/7
On obtient : 8639/7
On tape : b:=evalf(a,9)
On obtient : 1234.143 (à l’affichage juste 7 chiffres significatifs)
On tape : b-1234
On obtient : 0.14286 (ce qui prouve que b vaut 1234.14286)
On tape : b-1234.14286
On obtient : 0.0 (ce qui prouve encore que b vaut 1234.14286)
On tape : c:=evalf(a,16)
On obtient : 0.1234142857142857e4
On tape : d:=evalf(a,21)
On obtient : 0.123414285714285714286e4
Exemple 2
Avec Digits:=7 ou si dans la configuration du cas (menu Cfg)
on a choisit Chiffres=7.
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
ce qui montre que evalf(sqrt(2),3) est le nombre 1.414
On tape :
On obtient :
On obtient toujours un affichage avec 7 chiffres significatifs si n est supérieur ou égal à 7 :
On tape :
On obtient toujours lorsque Digits:=7) :
ce qui montre que Xcas fait les calculs avec 14 chiffres significatifs.
Par contre, dés que le 2-ième argument n de evalf est
strictement supérieur à 14 l’affichage se fait avec n chiffres
significatifs.
On tape :
On obtient :
On tape :
On obtient :
et cela n’a pas modifié la configuration du CAS.
On peut changer le nombre de chiffres significatifs avec la variable
DIGITS ou Digits.
On tape :
Cela a pour effet de changer Configuration du CAS et de mettre 20 dans la case Chiffres.
On obtient 20 chiffres significatifs :
Notation : Le nombre réel 10−4 est un nombre exact alors que
1e−4 est un nombre approché.
On tape :
^-5)On obtient :
On tape :
^15)On obtient :
On tape :
^-5On obtient si Digits:=20:
Remarques On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
On tape :
On obtient :
Attention
Si vous définissez une fonction F(a) qui renvoie une séquence formée
par un nombre fractionnaire p/q et un entier n alors evalf(F(a))
renvéra une approximation de p/q avec n chiffres significatifs !
Il faut donc écrire evalf([F(a)]) pour avoir une liste constituée
d’une approximation de p/q et de n.
nSolve permet de résoudre numériquement des équations non
polynomiales : f(x)=0 pour x ∈ ]a,b[ (nSolve est une commande
compatible ti).
Les paramètres de nSsolve sont f(x)=0, x, ou x=x0
où x0 est un point de ]a,b[.
On tape :
On obtient soit :
soit une solution complexe :
En effet, si on ne précise pas la valeur qui démarre
l’itération, Xcas démarre l’itération avec une valeur aléatoire
réelle ou complexe.
On vérifie :
cos(-9.10998745394-2.95017086176*i)=-9.10998745394-2.95017086176*i
On tape :
On obtient :
On tape :
On obtient :
fsolve permet de résoudre numériquement des
équations non polynomiales : f(x)=0 pour x ∈ ]a,b[.
fsolve a comme arguments f(x)=0 et x=a..b ou f(x)=0, x et a..b.
fsolve donnera aussi les racines numériques complexes si dans la
configuration du CAS on a coché Complexe. Si Complexe est
décoché il faut utiliser cfsolve pour avoir les racines numériques
complexes.
On tape :
Ou on tape :
On obtient :
On peut rajouter en dernier argument la valeur de l’échantillonage en
spécifiant la valeur de xstep ou la valeur de nstep (nombre de
découpages de l’intervalle ]a,b[).
On tape :
On obtient :
On tape :
On obtient :
On peut utiliser différents algorithmes pour résoudre numériquement
f(x)=0 pour x ∈ ]a,b[.
Si on veut indiquer la mèthode, les paramètres de fsolve sont
f(x)=0, x, a..b ou
selon les méthodes un point x0 de ]a,b[ et le nom de la méthode
utilisée.
Les différentes méthodes sont détaillées ci dessous.
On propose six méthodes pour résoudre numériquement des systèmes
d’équations de la forme f(x)=0.
Remarque
fsolve donnera aussi les racines numériques complexes
si dans la
configuration du CAS on a coché Complexe. Si Complexe est
décoché il faut utiliser cfsolve pour avoir les racines numériques
complexes.
Trois méthodes utilisent la matrice jacobienne f′(x) et leurs noms se
terminent par j_solver.
Les trois autres méthodes utilisent des méthodes d’approximation de
f′(x) et utilisent uniquement f.
Les six méthodes utilisent une itération de type Newton :
xn+1=xn−f′(xn)−1*f(xn).
Les quatre méthodes hybrid*_solver utilisent aussi une méthode de
descente de gradient lorsque l’itération Newtonienne donne un pas trop
grand.
La longueur du pas est calculé sans facteur d’échelle pour hybrid_solver et hybridj_solver
ou avec facteur d’echelle (calculé à partir de f′(xn)) pour
hybrids_solver et hybridsj_solver
cfsolve effectue la résolution numérique sur ℂ d’une équation ou
d’un système, même si Complexe est décoché dans la
configuration du CAS.
fsolve donne aussi les racines numériques complexes d’une équation ou
d’un système si dans la configuration du CAS on a coché Complexe.
On tape :
On obtient :
On tape :
On obtient :
On tape :
^2+y+2,x+y^2+2],[x,y])On obtient :
proot a comme argument un polynôme ou le vecteur de
composantes les coefficients d’un polynôme (par ordre décroissant).
proot renvoie un vecteur dont les composantes sont les racines
numériques non multiples du polynôme.
On peut mettre en option un entier n pour préciser le nombre n de chiffres
significatifs de la réponse.
Pour chercher les racines numériques de P(x)=x3+1, on tape :
ou on tape :
^3+1) On obtient :
On tape pour avoir 20 chiffres significatifs :
ou on tape :
^3+1) On obtient :
On tape pour avoir les racines numériques de x2−3 :
ou :
^2-3)On obtient :
On tape pour avoir les racines numériques de P(x)=x2−3 avec 20 chiffres significatifs :
ou on tape :
^2-3,20) On obtient :
On tape pour avoir les racines numériques de P(x)=x10−15*x8+90*x6−270*x4+405*x2−243 :
ou on tape :
^10-15*x^8+90*x^6-270*x^4+405*x^2-243) On obtient :
Pour avoir les factorisations numériques de :
d’une matrice, on se reportera à la section 6.59.
Les constantes physiques (sous-menu Constante), les fonctions de conversion (sous-menu Unit_convert), les préfixes (sous-menu Unit_prefix) et les unités classées par thème, se trouvent dans le menu Phys.
e ou %e désigne le nombre exp(1);
pi ou %pi désigne le nombre π.
infinity désigne ∞.
+infinity ou inf désigne +∞.
-infinity ou -inf désigne −∞.
i ou %i désigne le nombre complexe i.
euler_gamma désigne la constante d’Euler γ.
On a :
euler_gamma est égal à limit(sum(1/k,k,1,n)-ln(n),n,+infinity).
On peut évaluer une expression booléenne grâce à la
commande evalb cette commande sert surtout pour la compatibilité Maple
car en Xcas, les booléens sont toujours évalués.
On tape :
Ou on tape :
On obtient :
On tape :
Ou on tape :
On obtient :
Dans tout ce paragraphe, on peut utiliser des entiers de Gauss (nombres complexes de la forme a+i*b avec a et b dans ℤ), à la place des entiers dans les différentes fonctions.
Une permutation p de longueur n est une bijection de [0..n−1] sur
[0..n−1] et est représentée par la liste :
[p(0),p(1),p(2)...p(n−1)].
Par exemple, la permutation p représentée par [1,3,2,0] est
l’application de [0,1,2,3] sur [0,1,2,3] définie par :
p(0)=1, p(1)=3, p(2)=2, p(3)=0.
Un cycle c d’ordre p est représenté par la liste
[(a0,...,ap−1)] (0≤ p≤ n−1) et c’est une permutation telle que :
c(ai)=ai+1 pour (i=0..p−2), c(ap−1)=a0 et
c(ai)=ai (i=p+1..n).
Un cycle c est représenté par la liste et une décomposition en
cycles par une liste de listes.
Par exemple, le cycle c représenté par la liste [3,2,1] est la
permutation c définie par c(3)=2, c(2)=1, c(1)=3, c(0)=0 (qui est
représenté en tant que permutation par la liste [0,3,1,2]).
Vous trouverez dans le menu Math (Cmplx) les fonctions
ayant comme paramètre une expression à valeur complexe.
Remarque
Les nombres complexes sont utilisés pour représenter un point sur l’écran graphique : par exemple, le graphe de y=f(x) est l’ensemble des points x+i*f(x) pour x
variant entre WX- et WX+ (WX- et WX+ sont initialisés
avec le menu Cfg▸Configuration graphique).
Un opérateur est une fonction infixée.
Les polynômes sont représentés par des expressions ou par la liste de leurs coefficients par ordre de puissances décroissantes. Dans le premier cas la variable utilisée par défaut est x. Pour les polynômes à coefficients dans ℤ/nℤ, appliquez % n à l’expression ou à chaque coefficient de la liste.
On peut faire des calculs modulo p c’est à dire dans ℤ/pℤ ou dans ℤ/pℤ[x] et la façon de s’y prendre dépends de la syntaxe choisie :
^2+3*x-1)%13 ou ^2+3%13*x-1%13.
Remarques
Voir aussi 6.51.5 and 8.
Fonctions utiles pour les statistiques dont les donn’ees sont des
listes :
^2=size(l)*stddev(l)^2/(size(l)-1).
Soit A la liste [0,1,2,3,4,5,6,7,8,9,10,11].
On tape :
A:=[0,1,2,3,4,5,6,7,8,9,10,11]
On obtient :
11/2 pour mean(A)
sqrt(143/12) pour stddev(A)
0 pour min(A)
[1.0] pour quantile(A,0.1)
[2.0] pour quantile(A,0.25)
[5.0] pour median(A) ou pour quantile(A,0.5)
[8.0] pour quantile(A,0.75)
[9.0] pour quantile(A,0.9)
11 pour max(A)
[[0.0],[2.0],[5.0],[8.0],[11.0]] pour quartiles(A)
Voir aussi ces fonctions pour les matrices à la section 6.51.5 et
pour les listes pondérées au chapitre 8.
Une table est une liste indicée par quelque chose de plus général que des
entiers.
Une table peut être utilisée, par exemple, pour stocker des numèros de
téléphone indicés par des noms.
Dans Xcas, les indices d’une table peuvent être n’importe quels objets
de Xcas.
L’accés se fait par un algorithme qui trie par type puis
utilise l’ordre de chaque type (par exemple < pour le type numérique,
l’ordre lexicographique pour les chaines etc...).
Par exemple pour définir une table représentant une matrice creuse, on
peut mettre des indices doubles entre des parenthèses. La commande
matrix permet de transformer une table ainsi définie en une matrice.
Inversement table permet de transformer une matrice en une table.
table a comme argument une liste ou une séquence d’égalité de la
forme :
"nom_index"=valeur_element.
table renvoie cette table.
On tape :
On tape :
On obtient :
On tape :
On obtient :
Pour définir une matrice creuse par une table, on tape par exemple :
Ou on tape de façon plus simple, on peut définir la variable B à l’aide d’une multi-affectation, à condition que la variable B soit purgée :
On tape :
On obtient :
Attention
B n’est pas une matrice mais une table ! On obtient facilement une
matrice à partir de B avec convert(B,array) ou matrix(B).
On tape :
On obtient :
On tape :
Ou on tape de façon plus simple :
On obtient :
Remarque
On peut faire toutes les opérations matricielles sur les tables par exemple :
B*B, B+B
Ne pas oublier de faire purge(B) avant de définir la variable
B à l’aide d’une multi-affectation.
Exemple
On veut coder les lettres "a","b",.."z" par 1,2,....26.
On tape :
alphab:="abcdefghijklmnopqrstuvwxyz";
puis :
code:=table(seq(alphab[j]=j+1,j=0..25));
On tape
code["c"]
On obtient 3
ou bien on écrit une fonction :
Code(a):={
local code,alphab,j;
alphab:="abcdefghijklmnopqrstuvwxyz";
code:=table(seq(alphab[j]=j+1,j=0..25));
return code(a);
};
On tape
Code("c")
On obtient 3
Remarque
Si on fait une affectation du type T[n]:= ... où T est le nom
d’une variable et n un entier
Une matrice est representée par une liste de listes de même longueur.
Dans les réponses de Xcas, les matrices sont parenthésées avec
[]. Par exemple, [1,2,3] désigne la matrice [[1,2,3]] qui a une seule ligne, alors que [1,2,3] désigne la liste [1,2,3].
Dans ce document, on utilise la notation habituelle ( [[1,2,3]]) pour les
matrices renvoyées comme réponses.
Voir aussi 6.43.1 pour les différentes norme d’un vecteur.
La factorisation des matrices renvoie en général des matrices numériques et quelquefois des matrices symboliques.
Dans tout ce paragraphe, on appelle "matrice augmentée" du système A*X=B la matrice formée par la matrice A bordée à droite par le vecteur colonne B ("matrice augmentée" du système A*X=B=border(A,tran(B))).
Pour le calcul numérique de solutions déquations différentielles on se reportera à odesolve et pour la représentation graphique de solutions déquations différentielles on se reportera à plotfield, plotode, interactive_plotode.
dayofweek(j,m,a renvoie 0 pour dimanche, 1 pour lundi ...6 pour samedi pour çindiquer le jour de la semaine qui correspond à la date donnée en argument date supérieure au 15 octobre 1582. On tape :
On obtient :
Donc le 15 octobre 1582 était un vendredi. En effet le calendrier grégorien
date du 15 octobre 1582 (le lendemain du jeudi 4 octobre 1582 fut le vendredi
15 octobre 1582 car avant les annèes bissextiles étaient tous les 4 ans ce
qui donne comme durée moyenne de l’annèe civile 365.25 jours alors que la
révolution de la terre autour du soleil est plus courte (365.242 jours)
d’où un décalage qui était de 10 jours en 1582.
Avec la nouvelle règle (la dernière année de chaque siécle est
bissextile si son millésime est divisble par 400) l’écart n’est plus
que de l’ordre de 1 jour tous les 3000 ans.
On tape :
On obtient :
Donc le 1ier octobre 2014 était un mercredi.
Soit une courbe Γ lieu des points M=M(t) de coordonnées
x(t),y(t),z(t) dans un repère orthonormé Oxyz.
Le vecteur directeur de la tangente à Γ est le premier vecteur
T= dpM/dtp qui ne soit pas nul.
À chaque tangente en M on associe :
une infinité de plans tangents qui sont les plans contenant T et
une infinité de normales qui sont toutes perpendiculaires en M à T et
qui forment le plan normal en M.
Comment se place la courbe par rapport à un certain plan Π tangent en M
à Γ ?
Soit N la normale qui est perpendiculaire à Π en M.
Soit M1 un point de Γ et m1 la projection de M1 sur T.
Mm1 a le sens de (t1−t)pdpM/dtp ( dpM/dtp étant le premier vecteur derivé de OM non nul.
M1 est dans la même région par rapport à Pi que le vecteur
(t1−t)qdqM/dtq où (t1−t)qdqM/dtq est la première des dérivées suivantes qui soit non nulles et non situés dans Pi
Soit une courbe Γ lieu des points M=M(t) de coordonnées
x(t),y(t),z(t) dans un repère orthonormé Oxyz.
On suppose que x(t),y(t),z(t) sonr continues , dérivables et à
dérivées continues.
On note dM/dt le vecteur de coordonnées
x′(t),y′(t),z′(t) qui est un vecteur tangent à Γ quelque soit t.
On introduit un nouveau paramétre s pour Γ pour que
dM/ds soit unitaire c’est à dire tel que :
ds2=dx2+dy2+dz2
Cette relation définie da dérivée de s par rapport à t au signe
près :
ds/dt=√x′(t)2+y′(t)2+z′(t)2 si on oriente
Γ selon les t croissants,
ds/dt=−√x′(t)2+y′(t)2+z′(t)2 si on oriente
Γ selon les t décroissants.
On appelle abscisse curviligne à partir de l’origine M0=M(t0), la
fonction s(t) ayant pour dérivée :
ds/dt=√x′(t)2+y′(t)2+z′(t)2 (ou ds/dt=−√x′(t)2+y′(t)2+z′(t)2 selon l’orientation choisie)
et telle que s(t0)=0.
La tangente orientée de Γ au point M est alors :
τ= dM/ds qui est le vecteur :
en coordonnées cartésiennes :
τ=(dx/ds,dy/ds,dz/ds).
en coordonnées semi-polaires
τ=(dρ/ds,ρ dθ/ds,dz/ds).
Soit une courbe Γ lieu des points M=M(t) de coordonnées
x(t),y(t),z(t) dans un repère orthonormé Oxyz.
Le vecteur directeur de la tangente à Γ est le premier vecteur
dpM/dtp qui ne soit pas nul.
Considérons le cas le plus courant où
dM/dt et d2M/dt2 sont non
nuls et non colinéaires.
Le plan osculateur est le plan des deux vecteurs
dM/dt et d2M/dt2 et plus
généralement le plan des deux premiers vecteurs :
dpM/dtp et dp+hM/dtp+h qui
ne sont ni nuls et ni colinéaires.
Remarque Le plan osculateur comme la tangente ne dépend pas du
paramètre utilisé.
Le vecteur d2M/ds2=dτ/ds est donc dans le
plan osculateur et il est orthogonal à τ.
On appelle normale principale l’intersection du plan normal (plan
perpendiculaire à la tangente τ) et du plan osculateur.
Soit n le vecteur unitaire de la normale principale orientée dans le sens
de la concavité i.e. selon dτ/ds
Lorsque Γ est une courbe du plan Oxy : son plan osculateur est le plan Oxy.
La torsion d’une courbe plane est nulle.
Soit α l’angle (Ox,τ. On a alors :
1/Rdα/ds et donc :
ds/dα=R
Soit ν tel que (τ ν)=π/2, on a ;
dτ =ν dα et si c est le centre de courbure en M on a :
MC= ds/dαν
On appelle développée d’une courbe plane Γ, le lieu des centres de
courbure de Γ : c’est aussi l’enveloppe de ses normales.
Exemple
Trouver la développée de la spirale logarithmique :
ρ=3eθ/2.
On tape :
developpee([3*exp(t/2)*cos(t),3*exp(t/2)*sin(t)],t,affichage=2))
On obtient :
Définition : Développante d’une courbe plane
On appelle développante d’une courbe plane Γ les courbes admettant
Γ comme développée.
On va décrire les différentes fonctions statistiques sur un exemple :
avec la liste A:=[0,1,2,3,4,5,6,7,8,9,10,11]
- en prenant comme série statistique d’effectif 1 la liste A, ou
- en prenant comme série statistique la liste A avec comme effectifs
encore la liste A.
On tape :
A:=[0,1,2,3,4,5,6,7,8,9,10,11]
On pourra se reporter aussi à 6.44 lorsque les arguments sont
des listes et à 6.51.5 lorsque les arguments sont des matrices.
On continue à utiliser la liste A dans les exemples.
On tape :
On peut exécuter une fonction pas à pas, en utilisant le debuggeur :
on se sert de l’instruction debug avec comme argument une fonction et ses
arguments et cela permet d’exécuter la fonction pas à pas. On a alors la
possibilité de voir l’évolution des variables de son choix (on se reportera
pour plus de détails à la section 9.7).
Un bloc d’instructions ou une séquence d’instructions doit être
parenthésé soit par {}, soit par begin et end.
Entre ces accolades (ou entre begin et end) on met les
instructions en les terminant par un point-virgule ;
Toutes les commandes graphiques faites dans une ligne d’entrée auront en
réponse l’ouverture d’un écran graphique.
Les dessins de la géométrie 2-d se font en général dans un écran de
géométrie 2-d qui est un écran graphique interactif muni d’un
éditeur de commandes et d’une barre de menus (on ouvre un écran de
géométrie 2-d avec Alt+g).
Les dessins faits dans un écran de géométrie 2-d sont interactifs :
on peut définir des points et des segments avec la souris et modifier une
figure en faisant bouger un de ses points avec la souris.
nodisp appliqué à une commande permet de ne pas afficher
la réponse, même quand il s’agit d’une commande graphique.
On peut aussi terminer la commande par :; pour ne pas générer de
réponse.
On tape :
On obtient :
On tape :
Ou on tape :
puis
On obtient :
nodisp permet de définir un objet géométrique sans le
tracer. On peut ensuite tracer l’objet en mettant comme commande son nom,
mais alors, son nom n’apparaitra pas sur la figure.
On peut aussi définir un objet géométrique et utiliser eval.
On tape :
Ou on tape :
puis on tape :
Ou on tape :
On obtient :
L’affectation d’un objet géométrique dans une variable permet de
définir cet objet géométrique et de le
tracer avec une légende ayant comme nom, le nom de la variable.
Si on veut donner à cet objet géométrique un nom différent de celui de
la variable, on peut définir l’objet géométrique avec une affectation qui
se termine par :; et utiliser legende. Voici des
exemples :
On tape :
Ou on tape :
Le point B est défini mais n’est pas tracé.
puis on tape :
Ou on tape :
On obtient :
Remarque
Si on veut définir l’objet géométrique sans le
tracer, puis le faire apparaitre avec son nom, on peut aussi utiliser
eval (voir la commande eval6.14.2).
On tape :
Ou on tape :
Le point B est défini mais n’est pas tracé.
puis on tape :
Ou on tape :
Ou on tape :
Ou on tape :
On obtient :
Si on tape :
On obtient :
Pour pouvoir faire une démonstration en géométrie, il suffit de demander au calcul formel de faire les calculs, en choisisant bien les paramètres du problème et ces paramètres doivent être formels....En géométrie les points peuvent avoir des coordonnèes exactes ou numériques ou formelles. Mais pour faire une figure, il faut affecter les paramètres formels. On peut le faire de différentes façons :
^2+1)
Pour les dessins dans l’espace voir la section 11.7
Voir aussi : 11.7.1 pour la géométrie 3-d.
Pour les dessins dans l’espace voir la section 11.8
Voir aussi : 11.9 pour la géométrie 3-d.
Les graphes ou les dessins de la géométrie 3-d se font dans un écran
graphique 3-d qui s’ouvre automatiquement en réponse d’une commande graphique
3-d.
Les dessins de la géométrie 3-d se font en général dans un écran de
géométrie 3-d qui est un écran graphique muni d’un éditeur
de commandes et d’une barre de menus at que l’on ouvre avec Alt+h.
Si on clique dans la fenêtre graphique avec la souris, en dehors du
parallélépipéde servant à la représentation,
on peut faire tourner les axes x, y ou z, soit avec les touches x,
X, y, Y, z, Z, soit en bougeant la souris
sans relacher son bouton. Cela modifie l’axe de vision (axe passant par
l’observateur et de vecteur directeur la direction de la visée de l’objet) et
le plan de vision (plan perpendiculaire à l’axe de vision dont l’équation
est inscrite en haut de l’écran). Le plan de vision est matérialisé par
son intersection avec le parallélépipéde servant à la représentation,
ces droites d’intersection sont dessinée en pointillé.
On peut aussi translater le plan de vision, le long de l’axe de vision grâce
à la molette de la souris : les plans successifs sont obtenus par une
translation de vecteur parallèle à l’axe de vision.
On peut se servir d’attributs pour faire une représentation
graphique 3-d comme la couleur, l’épaisseur, les lignes en pointillé pour
cela voir 10.3. Mais, les points ont toujours la forme d’un
carré et il faut mettre une epaisseur d’au moins 3 si on veut le voir
(point_width=3).
On peut faire des dessins en perspective ou en repère orthonormé (en
cochant Proj_ortho dans la configuration graphique (bouton cfg)),
les surfaces sont transparentes ou non et peuvent être éclairées par 8
spots que l’on peut placer en diffèrents endroits repérés par leur
coordonnées homogènes (on configure ses spots avec les boutons
l0,l1..l7 situés dans la configuration graphique).
Ces dessins sont interactifs :
on peut faire bouger, avec la souris, les points situés dans le plan de
vision, et aussi déplacer ces points, avec la molette de la souris, sur une
parallèle à l’axe de vision .
À noter que l’on peut aussi faire un zoom-in ou un zoom-out à l’aide des boutons in et out (voir 3.4).
Si dans la configuration du graphique,
on coche hidden3d, la surface sera tracée sans dessiner les lignes
qui sont cachées et si on veut voir les lignes cachées on décoche
hiden3d (voir aussi 1.6.2).
Pour la traduction Latex de l’écran 3-d on se reportera à la section
1.10.5.
Les angles d’Euler sont utilisés pour modifier le repère de visualisation.
Rappel
Soient deux repères : l’ancien (Oxyz) et le nouveau (OXYZ).
Soit Ou l’intersection du plan (OY,OZ) avec le plan (Ox,Oz) que l’on
oriente arbitrairement.
Soient :
On définit complètement la mise en place de (OXYZ) par rapport à
(Oxyz) en donnant les angles a,b,c de (OXYZ) par rapport
à (Oxyz) et en effectuant la composition de ces trois rotations :
Rc@Rb@Ra.
Les angles d’Euler sont :
a=(Oz,Ou),
b=(Ov,OX),
c=(Ou,OZ).
Les dessins de la géométrie 3-d se font en choissisant comme repère
Oxyz, Ox horizontal dirigé vers la droite, Oy vertical dirigé vers le
haut et l’axe des z qui pointe vers vous.
Les mesures en degré de a,b,c sont mises dans ry,rz,rx.
Selon l’orientation de Ou, les valeurs de a,b,c ne sont pas uniques :
a,b,c et a+180,180−b,c+180 mettent en place le même repère OXYZ,
Lorsque b est un angle droit, c’est à dire que l’axe OX et l’axe Oy
ont le même support on n’a pas non plus unicité:
a,90,c et a+c,90,0 mettent en place le même repère OXYZ et
a,−90,c et a−c,−90,0 mettent en place le même repère OXYZ.
On peut donc choisir, l’angle b dans ]−90,90[ et les angles a et c
dans ]−180,180] ou bien b dans −90,90 c=0 et a dans ]−180,180].
Le principe est de rajouter, si necessaire, un paramètre pour définir le plan du triangle et définir aussi l’orientation de ce plan. Pour la géométrie plane voir 10.10.
Voir aussi : 10.11 pour la géométrie plane.
Le principe est de rajouter si necessaire un paramètre pour définir le
plan du quadrilatère et définir aussi l’orientation de ce plan.
Voir aussi : 10.12 pour la géométrie plane.
Le principe est de rajouter si necessaire un paramètre pour définir le
plan du polygone et définir aussi l’orientation de ce plan.
Voir aussi : 10.13.1 pour la géométrie plane.
cercle, en géométrie 3-d, a comme argument :
À noter que dans les 2 cas, le premier et le troisième argument
peuvent être les coordonnées du point.
On tape :
Ou on tape :
Ou on tape :
On obtient :
On tape :
Ou on tape :
Ou on tape :
On obtient :
Pour les construire, on donne le centre, un sommet et un 3ème
point définissant un plan de symétrie.
Pour accélérer les calculs, il peut être utile faire seulement des
calculs approchés en utilisant evalf dans l’argument : on tapera,
par exemple :
cube_centre(evalf([0,0,0],[3,2,1],[1,1,0]))
Soit la variable a on peut donner sont type soit en la renommant soit en
mettant : puis son type :
a_i ou a:integer pour signifier que a est de type entier
a_d ou a:double ou a:real pour signifier que a est de type réel
a_c ou a:complex pour signifier que a est de type complexe
a_v ou a:vector pour signifier que a est de type vecteur
a_m ou a:matrix pour signifier que a est de type matrice
a_s ou a:string pour signifier que a est de type chaîne
de caractères
On peut utiliser giac à l’intérieur d’un programme C++ en
mettant au début du programme par exemple essai.cc :
#include<giac/giac.h>
puis en compilant le compilant avec :
c++ -g essai.cc -lgiac -lgmp
et en l’exécutant en mettant :
./a.out
Exemple
// -*- compile-command: "g++ -g pgcd.cc -lgiac -lgmp" -*-
#include <giac/giac.h>
using namespace std;
using namespace giac;
gen pgcd(gen a,gen b){
gen q,r;
for (;b!=0;){
r=irem(a,b,q);
a=b;
b=r;
}
return a;
}
int main(){
cout << "Entrer 2 entiers";
gen a,b;
cin >> a >> b;
cout << pgcd(a,b) << endl;
return 0;
}
On peut définir de nouvelles fonctions qui deviendront des fonctions de giac. Pour définir par exemple la fonction de nom pgcd ( et c’est l’instruction : const string _pgcd_s("pgcd"); qui définit le nom de la fonction), on tape :
// -*- mode:C++ ; compile-command: "g++ -I.. -fPIC -DPIC
-g -c pgcd.cpp -o pgcd.lo && ln -sf pgcd.lo pgcd.o && gcc
-shared pgcd.lo -lc -Wl,-soname -Wl,libpgcd.so.0 -o
libpgcd.so.0.0.0 && ln -sf libpgcd.so.0.0.0 libpgcd.so.0 &&
ln -sf libpgcd.so.0.0.0 libpgcd.so" -*-
using namespace std;
#include <stdexcept>
#include <cmath>
#include <cstdlib>
#include <giac/giac.h>
#include "pgcd.h"
#ifndef NO_NAMESPACE_GIAC
namespace giac {
#endif // ndef NO_NAMESPACE_GIAC
gen pgcd(gen a,gen b){
gen q,r;
for (;b!=0;){
r=irem(a,b,q);
a=b;
b=r;
}
return a;
}
gen _pgcd(const gen & args){
if ((args.type!=_VECT)||(args._VECTptr->size()!=2))
setsizeerr();
vecteur &v=*args._VECTptr;
return pgcd(v[0],v[1]);
}
const string _pgcd_s("pgcd");
unary_function_unary __pgcd(&_pgcd,_pgcd_s);
unary_function_ptr at_pgcd (&__pgcd,0,true);
#ifndef NO_NAMESPACE_GIAC
} // namespace giac
#endif // ndef NO_NAMESPACE_GIAC
On compile avec la commande située après compile-command de
l’en-tête du programme. Puis, pour l’insérer dans
une session Xcas, il faut taper la commande insmod
suivi du chemin absolu complet de la librairie, par exemple :
insmod("/home/user/giac-0.4.0/doc/en/libpgcd.so").
Cela suppose que le source de giac a été désarchivé dans le
répertoire /home/user).
Ce document a été traduit de LATEX par HEVEA