a:=10!:
b:=8!;
b/a;
MuPad - Astuces et exemples
Dans les explications qui suivent, <xyz> désigne une touche nommée xyz
Terminer une commande, mise en forme des commandes
avec <:> pour l'exécuter sans affichier le résultat,
<;> pour exéctuer et afficher le résultat
Retour à la ligne
La touche <Retour> exécute les commandes entre crochet
<Maj-Retour> permet d'entrer des lignes supplmentaires dans un paragraphe de programmation
sans exécuter tout le paragraphe
Les commandes peuvent s'étendre sur plusieurs lignes
Tabulations : <Ctrl-Tab> permet de mettre en retrait pour la lisibilité
Le double caractère %? permet de créer des cases à remplir
qu'on atteint successivement avec la toucht <Tab>
(C'est ce qui se passe quand crée des commandes à partir de la barre d'outils,
mais cela marche aussi en fabriquant des modèles de commandes soi-même)
Commentaires
// introduit un commentaire en fin de ligne
/* ......... */ entoure plusieurs lignes de commentaires
a:=10!:
b:=8!;
b/a;
Le symbole de boucle le plus simple : $
Ce symbole permet de créer facilement des séquences ou des listes d'objets à traiter
ou de créer une boucle procédurale sans utiliser for ... end_for
Voir plus bas l'explication sur les listes
print(x*(x-1) $ x=5..10):
_plus(x*(x-1) $ x=5..10); // total des nombres listés ci-dessus
_mult(x*(x-1) $ x=5..10); // total des nombres listés ci-dessus
print(x, x*(x-1)/2) $ x=5..10: // affiche 6 fois 2 nombres
20, 30, 42, 56, 72, 90
5, 10
6, 15
7, 21
8, 28
9, 36
10, 45
Définir une fonction simple
avec la syntaxe
f:=x->expression:
f:=(x,y,z)->expression:
f:=()->expression pour une procédure sans arguments
f:=()->expression faisant intervenir args() pour une procédure avec un nombre indéterminé d'arguments
Note : le signe := peut être collé ou non
f := x->x^2-1:
g := (x,y)->2/(1/x+1/y): // moyenne harmonique de deux nombres
h := print(Unquoted, "----------------"): // affiche des traits de séparation
S := ()->_plus(x^2 $ x in args()): // somme des carrés d'une série de nombres
f(3);
g(4,5);
h();
S(3,4,5,6);
----------------
Définir une fonction plus complexe avec une procédure
Utiliser la syntaxe
f:=proc(x,y)
local = r, s ;
begin
lignes de procédure
avec les variable x, y
utilisant les varialbes locales r, s
end_proc
Veiller à déclrarer locales les variables internes
sinon on risque des surprises par collusion avec des variables
utilisées en dehors de la procédure
Exemple : procédure affichant les nombres premiers entre deux nombres
en revenant à la ligne tous les 10 nombres affichés et
affichant finalement le nombre de nombres premiers trouvés
listepremiers:=proc(n1,n2) // affiche les nombres premiers entre n1 et n2
local compte;
begin
compte:=0:
(if isprime(i) then
compte:=compte+1: print(NoNL, i, " "):
if (compte mod 10) = 0 then
print(Unquoted, "\n"):
end_if:
end_if) $ i=n1..n2:
print(
Unquoted,
"`\nConclusion : ".int2text(compte)." nombres premiers de ".int2text(n1)." à ".int2text(n2)." !!"
)
end_proc:
listepremiers(300,400);
307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, `
Conclusion : 16 nombres premiers de 300 à 400 !!
Astuces utilisées ci-dessus
Print(Unquoted, ...) permet d'imprimer du texte sans les guillemets (il y a aussi d'autres fonctions pour cela)
Le point permet de concaténer des chaînes de texte
int2text convertit un entier en texte (il y a une fonction plus générale pour cela, expr2text(expression)
"\n" permet d'inclure un code de retour à la ligne dans du texte imprimé avec l'option Unquoted
L'opérateur $ pour créer la séquence (voir paragraphe suivant)
La fonction isprime teste si un nombre est premier
Listes, séquences, ensembles, intervalles
Les simples séquences sont affichées par une suite d'expressions séparées par des virgules
Les listes sont affichées entre crochets
Les ensembles sont affichés entre accolades
On accède à un élément d'une liste (en lecture et écriture) avec la syntaxe liste[indice] - les indices commençant à 1
On peut extraire une sous-liste avec un intervalle comme paramètre
On peut créer des listes et des séquences avec l'opérateur $
Cet opérateur utilise aussi un objet de type intervalle, noté a..b (avec ou sans espaces entre les valeur et le double point)
Cet objet de type intervalle peut être créé indépendamment et utilisé au moyen d'une variable
La variable indiquée parcourt l'intervalle de 1 en 1 sauf spécification avec l'opérateur step
Les séquences sont pratiques pour les opérateurs utilisant un nombre indéterminés d'arguments
exemple : somme (opérateur _plus), moyenne, plot (affiche autant d'objets graphiques qu'on veut), etc.
x:=[i^2+1 $ i = 3..7]; // affiche la liste des nombres de la forme i^2+1 pour i allant de 3 à 7
// dans ce cas i ne correspond pas au numéro d'ordre dans la liste !
y:=10..15:
print(t, t!) $ t = y; // affiche les factorielles des nombres dans l'intervalle y défini précédemment
print(Unquoted, "----------------"):
print(t, t!) $ t = y step 2;
delete x, y:
10, 3628800
11, 39916800
12, 479001600
13, 6227020800
14, 87178291200
15, 1307674368000
----------------
10, 3628800
12, 479001600
14, 87178291200
Accès aux éléments d'une séquence, d'une liste, etc.
L'opérateur nops() indique le nombre d'éléments d'une liste (à partir du numéro 1, le numéro 0 n'est pas compté)
ou le nombre de composantes d'un objet composé
op(objet) fournit la séquence des composantes de objet
op(objet, n) fournit l'objet numéro n de l'objet complexe en argument
ce peut être le n-ième élément d'une liste, d'une séquence, d'un ensemble
(mais dans ce cas, la numérotation ne correspond pas forcément à l'ordre d'affichage de l'ensemble)
ou d'une expression (n-ième terme d'une somme, d'un polynôme, etc,)
il permet par exemple d'extraire un membre d'une équation
une solution d'un ensemble de solutions (mais il est difficile de prévoir laquelle!)
pour une expression, op(objet,0) fournit l'opérateur utilisé
op(objet, intervalle) extrait une partie d'une séquence
Pour une liste X, la syntaxe X[i] accède à l'élément numéro i et permet de le modifier, X[intervalle] fournit une sous-suite
z:liste:=[i*(i-1)/2 $ i=1..10];
liste[3];
liste[3..5];
op(liste);
P:=X^3+3*X^2-X+7;
op(P,0);
nops(P);
op(P,i) $ i=1..nops(P);
op(hold(2+3+4));
Un exemple pour les polynômes
Pour travailler avec des polynômes en une variable, on peut très bien se définir une fonction
qui permet de travailler avec la séquence des coefficients
On peut facilement modifier cette procédure pour les ordonner dans le sens usuel (terme constant à droite)
On pourrait aussi rajouter la variable à utiliser dans l'appel de procédure...
divide, appliqué à des expressions polynômiales, affiche le quotient et le reste
pol:=proc() // crée une expression polynômiale en x
// à partir d'une liste de coefficients
local coeff, degre;
begin
coeff := [args()]: // crée une liste avec les coefficients donnés
degre := nops(coeff)-1:
_plus(coeff[i+1]*x^i $ i=0..degre):
end_proc:
pol(1,2,3,4);
P1:=pol(-1,0,0,0,0,1);
P2:=pol(-1,1);
P3:=pol(1,1,1);
divide(P1,P2);
divide(P1,P3);
Graphiques
Il est en général utile de
a) créer d'abord les objets grapiques qu'on veut afficher avec objet: = plot::quelquechose
b) les afficher ensuite avec plot(objets)
Une fois les objets créés, on peut modifier au besoin leurs paramètres avec la syntaxe
objet::propriété := valeur
En 3d, dans les sufaces planes, seuls les triangles peuvent avoir une surface coloriée
figure1:=plot::Circle2d(sqrt(13), [3,3]
,LineColor = RGB::DarkGreen
,LineWidth = 1.2*unit::mm
,FillColor = RGB::GreenYellow.[0.6]
,Filled = TRUE
,FillPattern = Solid
):
figure2:=plot::Function2d(
x^3/15-2*x+1,
x = -2..8):
figure2::LineColor := RGB::Red:
figure2::LineWidth := 5*unit::point:
plot(figure1, figure2,
Scaling = Constrained,
ViewingBoxYRange = Automatic..8
);
Couleurs
Le jeu de couleurs le plus courant est trichrome, basé sur le système RGB
On y accède avec la syntaxe RGB::nomdecouleur
qui fournit une couleur sous forme de liste de 3 nombres réels entre 0 et 1
Pour les surfaces, on peut ajouter un quatrième nombre pour la transparence
On peut aussi indiquer les couleurs par leurs valeurs numériques
On peut afficher les noms des couleurs ou les couleurs elles-mêms avec les opérateurs ci-dessous
RGB::ColorNames(Blue); // liste les noms de couleurs contenant "Blue"
RGB::plotColorPalette(Green); // affiche la palette de ces mêmes couleurs
// ligne suivante désactivée car la palette complète est fort longue...
// RGB::plotColorPalette(); // affiche une palette de toutes les couleurs nommées
Sommes
La procédure avec _plus() est bien plus rapide que sum()
sum(x^3, x=5..10);
_plus(x^3 $ x=5..10);
COMBINATOIRE
Définitions des fonctions de base
comb:=(n,k)->combinat::chooseNK::count(n , k): // combinaisons sans répétitions
arrg:=(n,k)->combinat::permutationsNK::count(n , k): // arrangements sans répétitions
combR:=(n,k)->combinat::multisetsNK::count(n , k): // combinaisons avec répétitions
arrgR:=(n,k)->n^k: // arrangements avec répétition
permR:=()->_plus(args())!/_mult(x! $ x in args()): // permutations avec répétitions
// indiquer uniquement les multiplicités en arguments
Exemples (avec affiche d'égalités au moyen de output::mathText)
output::mathText("", hold(comb(8,3)), " = ", comb(8,3));
output::mathText("", hold(arrg(8,3)), " = ", arrg(8,3));
output::mathText("", hold(combR(8,3)), " = ", combR(8,3));
output::mathText("", hold(arrgR(8,3)), " = ", arrgR(8,3));
output::mathText("", hold(permR(3, 4, 5)), " = ", arrgR(8,3), " = nbre de groupements de",
3+4+5, " objets en groupes de 3, 4, 5");
Géométrie vectorielle 1ère année no 48
A := matrix([ // matrice des trois vecteurs donnés
[2, 1, 3],
[1, k, 2],
[2, 1, k]
]):
DD := linalg::det(A); // déterminant de la matrice
solve(DD=0, k); // condition de coplanarité
// ---------------------- résoucre X*V1 + Y*V2 + Z*V3 = 0
XYZ := matrix([[X],[Y],[Z]]);
AXYZ := A * XYZ;
solve([AXYZ[i]=0 $ i=1..3], [X,Y,Z]);
plot::Function2d(, %? = %?..%?)