Le Baranougat !

Bnmaster · » 21/09/06 - 19h26

Maple 9 est un logiciel qui permet de faire des calculs formels. Voici un guide d'utilisation succint permettant de se familiariser avec ce logiciel. La version utilisé ici sera la version 9. (vous pouvez retrouvé des explications et des exemples plus complets sur Maple, logiciel de calcul formel si vous souhaitez allez plus loin.)

Fonctionnement global :

Toutes les expressions commencent par [>
Finissent par ; (ça calcule alors le résultat)
Ou par : (ça calcule mais n’affiche pas)
Puis on tape enter pour calculer l'expression.
Ou on tape shift+enter. L'expression n'est pas calculée (ni affichée) mais la prochaine fois que l'on appuyera sur enter, cela calculera et affichera toutes les expressions.
% équivaut à « ans » (on peut monter jusqu’à 3 « ans » en mettant %%%)
Pour de l’aide, faire ?mot et ça affiche l’aide sur ce mot.
Commande « restart » réinitialise toutes les variables.
Error, `;` unexpected Il manque un ; ou une parenthèse avant.

Objets manipulés par Maple :

Nombres

Nombres entiers
- Factorielle !
- Puissance ^
- Puissance [indice]
- Coefficient binomial binomial(10,4)
- PGCD gcd(10,4) PPCM lcm(10,4)
- Nombre premier isprime(x); (réponse true si c'est un nombre premier ou false sinon)
- Factorisation en produit de facteur premier ifactor(123456789)
- Somme sum(f(k), k=1..10)
- Fait le produit (comme sum quoi) product(f(k), k=1..10)
Nombres rationnels
- Maple ne donne pas de valeur numérique (sauf si on demande) y met tout en fraction irréductible.
Nombres réles (ou flottant)
- evalf(1/2)=0.5 (avec un nombre quelconque de chiffre significatif. (10 par défaut) evalf[nb chiffre significatif](nombre) ou evalf(nombre, nb chiffre significatif)
- Digits :=50 (ça change la valeur du nb de chiffre significatif pour la suite des calculs. 10 par défaut)
- sqrt(x) racine carré
- Nombres complexes
- $e^{i\pi}$ est noté I
- Il fait les calculs dans C par defaut.
- Argument argument( (1+I)^2)
- Partie réelle Re(1+I)
- Partie imaginaire Im()
- Module abs()
- Pour dire ce qu’est un nombre assume(a, real) assume(b,real) ( ::integer pour imaginaire) Pour connaître le type whattype(a)

Variables

- Ne peut pas commencer par un chiffre, mais on tape les trucs et voilà. nom := expression ( := correspond <-- sur d’autres langages)
- Elle peut être affecté (avoir une valeur en gros) ou non
- Pour faire des calculs formels, les variables ne doivent pas être affectés. (car si les variables ont une valeur, rien ne va plus) Donc pour désaffecter une variable x := 'x'
- x :=y : y :=5 : y :=4 ; équivaut à x :=5 ; (ce qui permet de comprendre le fonctionnement de l’incrémentation des variables par ce logiciel.) - De même y:=4: x:=y: y:=5: alors x sera égale à 5.
- Une fonction eval(variable,niveau) va nous permettre d’avoir les valeurs de x à différentes niveaux. x :=y ; y :=y ; y :=5 ; alors eval(x,1) ; donnera y, eval(x,2) ; donnera z et eval(x,3) ; donnera 5.

Manipulation d’expressions

- Lorsqu’on entre une expression, Maple la simplifie au minimum . (mais sans plus vu qu’il ne sait pas ce que vous voulez faire. Il faut détailler pour cela, éh oui…)
- Développer (les polynômes, les fonctions trigonométries) expand((x+1)^10) ou expand(tan(3*x))
- Pour poser une expression (par exemple t=tan(x)) il faut faire subs(tan(x)=t, expression)
- Il factorise mais pas totalement. Par exemple : factor(x^2-1) est égale $(x-1)(x2+x+1)$ . Par défaut, Maple factorise dans le plus petit sous-corps de $\mathbb{R}$ contenant $\mathbb{Q}$ et les coefficients du polynômes. Mais on peut rajouter des coefficients à utiliser. Par exemple : factor(x^2+x+1, I) ou factor(x^2+x+1, {I, sqrt(3)})
- Pour résoudre les équations (en avoir les racines) il faut utiliser solve(équations)
- Le contraire de expand() est combine() (ça recombine, ça rassemble) Exemple : combine(sin(a)*cos(b))
- la commande simplify() permet de simplifier une expression. Exemple : simplify((cos(x))^2-(sin(x))^2*(cos(x))^2); donne $cos(x)^4$ . (mais ça ne fonctionne pas toujours. Il faut parfois dire qu'on travaille avec des réles : assume(x, real);) On peut aussi donner des règles de simplification au logiciel : exprimer $x^n + y^n$ en fonction de s=x+y et p=xy. Alors $x^2+y^2=(x+y)-2xy=s^2-2p$ de même avec $x^3+y^3$

Modules sympas

View/Palettes/ y a des tableaux d’affichage rapide de différents symboles et fonctions assez utiles.

Programmation

Structures de test

Les structures de tests seront de la forme :
Code :

if <test> then <suite d'instructions> end if

Ce qui signifie : si (if) le test est vérifiée. (on dit : si le test renvoie "true".) alors (then) on effectue la suite d'instructions. Sinon

Création de procédures (=fonction) > nomdelafonction := proc(a,b,c)
Un exemple ici de procédure permettant de trouver les solutions d'une équation du second degré. ( $a\times x^2+b\times x+c=0$ ) (on verra plus loin les procédures en détails)
Code :

resol2 := proc(a,b,c)
if a=0 then
  if b=0 then
    if c=0 then print(`tout x solution`)
           else print(`aucune solution`)
    end if
         else print(`solution unique`)
  end if
       else Delta:=b^2-4*a*c;    
         if Delta=0 then print(`Solution double`, -b/a)
                    else
                        if Delta>0 then print(`2 solutions réelles distinctes`, (-b-sqrt(Delta))/(2*a), (-b+sqrt(Delta))/(2*a))
                                   else print(`2 solutions complexes distinctes`, (-b-isqrt(Delta))/(2*a), (-b+isqrt(Delta))/(2*a))
                        end if
        end if
end if;
end proc;
Warning, `Delta` is implicitly declared local to procedure `resol2`
resol2(1,2,3);

Les boucles

Boucle for

Permet d’exécuter un certain nb de fois certaines instructions.
For <nom> from <instruction> by <expression> to <expression> while <cond> do <suite d’instructions> end for;
Signifie la suite dinstructions va être éxécutée par <nom> variant d’une <expression 1> jusqu’à expression 3, par pas de <expression 2> (s’il n’y en a pas, il est supposée égale à 1) et tant que <cond> est réalisé. (tout n’est pas obligatoire.
Conditions simplismes :
Calculer la somme (pour k variant de 1 à 1000 de 1/k)
Code :

 for n from 1 to 10000 by 50 do
 somme:=0.0:
 for i from 1 to n do
 somme:=somme+(1/i)
 end do:
 print(somme-evalf(ln(n)));
end do;

Boucles while

While <cond> do <instructions> endo ;
Signifie qu’on execute la suite d’insctructions <instructions> tant que la conditions <cond> est vérifiée.
Ex : On veut étudier la suite définie par

$\left\{\begin{array}{rcl} U_0&=&0\\ U_{n+1}&=&cos(U_n)\\ \end{array}\right.$

On veut en calculer la limite (on admet qu'elle converge) et s’arrêter au rang n tel que $|U_n-U_{n+1}|<10^-8$
On écrit alors :
Code :

u0:=0:u1:=evalf(cos(u0)):n:=0:
while abs(u1-u0)>10^(-8) do
  u0:=u1;
  u1:=cos(u1);
  n:=n+1;
end do: 
print(u1, `Obtenu en`,n,` étapes`);

On veut démontrer que la suite :
$\sum_{k=1}^n {1/k^2}$
converge.
Comparer sa limite à $\pi^2$ .
On écrit alors :
Code :

u1:=1:
u2:=1.25:
n:=3:
while (u2-u1)>10^(-5) do
  u1:=u2;
  u2:=u2+(1/(n^2));
  n:=n+1;
end do:
print(`Limite de la suite :`, evalf((Pi^2)/u2),`Nombre d'itérations`,n);

Procédures

Les procédures permettent de définir une nouvelle fonction en Maple. On choisit le nom de la fonction (certains noms sont prohibés. Comme par exemple cos, sin, etc...)
Voilà comment on construit une procédure :
Code :

nomdelafonction := proc(listes des paramètres formels qui seront par défaut locaux,a,b,c)
local liste de variables;
global liste des variables;
  corps de la procédure
 ---
 ---
 ---
 on fait tous les calculs
return(résultat désiré)
end proc;

Les variables dans la liste "local" sont considérés comme interne à la procédure, même si elles portent le même noms qu'une variable du programme. (expliquons : s'il existe déjà une variable "bonjour" dans la page Maple ouverte et qu'on en créé une du nom de "bonjour" dans la procédure; ces variables ne seront pas les mêmes, c'est comme si elles avaient 2 noms différents.)
Les variables dans la liste "global" sont donc des variables qui agissent sur tout le programme. (toute la page)

Pour savoir comment les fonctions de Maple sont codés il existe une fonction pour les afficher. (ça peut être assez amusant parfois^^)
Code :

interface(verboseproc=2);
print(nomdelafonction);

debug(nom_de_la_procédure) Affiche la liste de toutes les actions effectués (dans l'ordre) d'une procédure, permettant ainsi de trouver plus facilement l'erreur bn_wink

Un petit exemple pour mieux comprendre :
Code :

b:=0:
truc:=proc(a)
 local b;
 b:=a+1;
 return b;
end proc:
truc(1);
print(b);

Le résultat sera :
2 pour truc()
0 pour print()

Eh oui, la variable b est local. Si l'on veut qu'elle s'affiche sur toute la page, il suffit de modifier : local b; par global b; et on obtient alors :
2 pour print(b);

Voici un autre exemple avec la fonction factorielle :
Code :

fact:=proc(n)
 if n=0 then return(1)
 else return(n*fact(n-1))
 end if;
end proc;

Suite de Fibonnacci :

Soit $U(n) = U(n-1)+U(n-2)$ Avec $U(0) = 0$ et $U(1)=1$ .
On créé alors une procédure pour cette suite :
Code :

fibo:=proc(n)
 if n=0 then return (0) end if;
 if n=1 then return (1) end if;
 return fibo(n-1)+fibo1(n-2);
end proc:

Puis on va afficher toutes les valeurs de 0 à 500. (ne faites le test que si vous avez un bon ordinateur^^)
Code :

for i from 1 to 500 do
  print(i,fibo(i));
end do;

Ce qui auront essayé verront qu'au bout d'une vingtaine d'itérations, Maple commence à saturer^^ En effet, on a programmé une boucle récursive, ainsi, Maple recommence à compter à chaque fois à partir de Un ! (et au bout d'un certain moment, ça commence à faire mal.)
La parade consiste à demander à Maple de retenir les termes. Pour cela, on rajoute : option remember: après fibo:=proc(n). Ainsi, Maple retiendra les valeurs et affichera les 500 premiers termes de cette suites beaucoup plus rapidement !! Ce qui nous donne :
Code :

fibo:=proc(n) option remember;
 if n=0 then return (0) end if;
 if n=1 then return (1) end if;
 return fibo(n-1)+fibo1(n-2);
end proc;

for i from 1 to 500 do
  print(i,fibo(i));
end do;

Mais si on demande à Maple de retenir trop de chiffres, la mémoire de l'ordinateur risque de saturer au bout d'un certain point. Voilà pourquoi on utilise une autre méthode. regardez ce code :

Scoutone · » 09/11/06 - 17h18

Après une très longue recherche, voici un lien qui vous permet de télécharger Maple 10 gratuitement, sans limite de temps.
En fait, il y a un fichier licence dans le paquet, donc si vous avez déjà téléchargé Maple 10, soit vous jugez plus rapide de me demander le fichier (667Ko) par mail, soit vous télécharger tout.
taille : 120Mo

[edit BN : Téléchargement non légal]

Dernière modification par Scoutone (09/11/06 - 19h39)

Bnmaster · » 16/11/06 - 17h54

Yop !

Je préviens quand même... j'écris ce cours au fil de mes cours d'info, donc au niveau rédaction c'est pas top^^ (j'essais de m'appliquer, mais c'est pas facile de suivre en même temps bn_tongue

)
Quand on aura finit avec Maple, je reprendrai le tout pour faire un bon ensemble !

Cela dit, n'hésitez pas à y ajouter vos connaissances ! (critiques, erreurs, ajouts) Bref, lâchez-vous ^-^

DarKnight · » 16/11/06 - 18h46

Hum, le téléchargement que tu donnes Scout est-il légal?

Romain · » 17/11/06 - 15h54

DarKnight a écrit :

Hum, le téléchargement que tu donnes Scout est-il légal?

??

Scoutone · » 17/11/06 - 17h08

...je te laisse y réfléchir...

disons que si tu recois gratuitement le code pour faire marcher Maple 10 (que tu peux télécharger partout), tu te doute bien qu'il y a un soucis, a partir de là, c'est toi qui vois bn_big_smile

Bnmaster · » 30/11/06 - 17h04

Suite du cours^^ (la flemme de passer en bas à chaque fois bn_tongue

)

Code :

fibona:=proc(n)
 u0:=0: u1:=1:
 if n=0 then u2:=0
 else
  for i from 1 to n do
   u2:=u1+u0:
   u0:=u1:
   u1:=u2:
  end do;
 end if;
return(u2);
end proc;

Un petit exercice :

Ecrire une fonction f qui a tout entier n associe la somme du cube de ses chiffres en base 10 (utiliser convert())
Déterminer les entier $n \leq 100 000$ tel que $f(n)=n$

Correction :
Code :

f:=proc(n) 
 local liste,somme: 
 liste:=convert(n,base,10):  
 somme:=sum(liste[i]^3,i=1..nops(liste)); 
 return somme;
end proc:

Code :

for n from 1 to 100000 do
 if f(n)=n then printf("La somme des chiffres de n est : %g \n", f(n)) end if;
end do;

("La somme des chiffres de n est : %g", somme):

Pour $i \in \mathcal{N}$ On note t(i) le nombre de "1"
Dans une écrire en base 2 et $s(t)=(-1)^{t(i)}$
Calcule $\lim_{h \rightarrow + \infty} \prod_{i=0}^{n} (\frac{2 \times i + 1}{2 \times + 2})^{t(i)}$

la réponse vite fait :
t:=proc(n)
> local l;
> l:=convert(n,base,2);
> return(convert(l,`+`))
> end proc:s:=proc(n)
> if t(n) mod 2 = 0 then return(1)
> else return(O)
> end if:
> end proc:
>

Bnmaster · » 30/11/06 - 18h06

Mémo pour moi :
- faire un point sur convert()

Bnmaster · » 14/12/06 - 17h45

u:=proc(n)
> local u2,u0,u1:
> u0:=1:
> u1:=1:
> if n=0 or n=1 then u2:=1
> else
> if n mod 2 = 0 then u2:=u(n/2)^2+u(n/2-1)^2
> else u2:=2*u((n+1)/2)*u((n-1)/2)-u((n-1)/2)^2
> end if:
> end if:
> end proc:

DS :

> # Olivier MARIDAT - PCSI - Groupe 2

> #1 Fonction tricolore :
> tricolore:=proc(N)
> local n2,a,liste,n3,phrase:
> n2:=N^2:
> n3:=0:
> liste:=convert(n2,base,10):
> for a from 1 to nops(liste) do
> if (liste[a]=1 or liste[a]=4 or liste[a]=9) then n3:=n3+1 end if:
> end do:
> if n3=nops(liste) then return(1)
> else return(0)
> end if:
> end proc:
> #1 Fonction somme des tricolores :
> sum_tric:=proc(N)
> local a,b:
> b:=1:
> for a from 2 to N do
> if tricolore(a)=1 then b:=b,a end if:
> end do;
> return(b); return print(b): end proc:
>
>
> #1 Petit exemple :
> sum_tric(107);

1, 2, 3, 7, 12, 21, 38, 107

> #2 Fonction fibo :
> u:=proc(n)
> local u2,u0,u1:
> u0:=1:
> u1:=1:
> if n=0 or n=1 then u2:=1
> else
> if n mod 2 = 0 then u2:=u(n/2)^2+u(n/2-1)^2
> else u2:=2*u((n+1)/2)*u((n-1)/2)-u((n-1)/2)^2
> end if:
> end if:
> return(u2):
> end proc:
>
> #2 Petit exemple :
> u(20);

10946

>
>

> #3 Fonction :
> fonction:=proc(n,a,b)
> local u0,v0,v1,u1:
> u0:=a:
> v0:=b:
> while abs(u0-v0)>n do
> u1:=evalf(sqrt(u0*v0));
> v1:=((v0+u0)/2);
> u0:=u1;
> v1:=vo;
> end do;
> return((u0+v0)/2);
> end proc:
>
> #3 Petit exemple :
> fonction(90,14,20);

17

> #3 Les courbes :
> plot([sqrt(x),(x+1)/2,'fonction(0.1,1,x)'],x=0..10,color=[red,blue,green]);

>

ait drif · » 20/12/06 - 14h52

salut les gars
j'ai acheté un CD maple 10 mais je n'ai rien compris comment l'installer.
il demande une activation maplesoft...........qu'est ce que ça veut dire
qui a une bonne idée sur ce sujet m'aide
merci l'equipe

Bnmaster · » 20/12/06 - 15h12

activation maplesoft c'est la clé produit que tu as du (logiquement^^) recevoir avec le CD. (ou par e-mail, mais c'est moins probable) C'est donc une série de chiffres que tu dois trouver sur la boîte du CD et qu'il faut rentrer ! (c'est pour vérifier que tu es bien propriétaire du CD mini_bn

)

ait drif · » 23/12/06 - 15h05

salut
je souhaite que je regrette pas ma decision d'apprendre maple
chef.....le CD ne veut pas s'installer
est ce que m'il faut la connexion au bereau ou non pour l'installer
de plus si vous connaissez des adrresses ou je peux telecharger gratuitement d'autres version maple 9.5 ou 9 m'orienter svp
et merci (clin d'oeil)

Bnmaster · » 06/01/07 - 22h24

de plus si vous connaissez des adrresses ou je peux telecharger gratuitement d'autres version maple 9.5 ou 9 m'orienter svp

ça, ça doit pas exister^^ (pas légalement en tout cas bn_tongue

)

Si ton CD ne s'installe vraiment pas (il est possible qu'il te faille une connexion Internet, en effet. C'est le nouveau trip des programmeurs ça, de faire des CD d'installations inconstatables que si t'as le net...) éh bien, contacte le staff technique de Maple, ils pourront surement t'aider ou t'échanger le CD si ça ne va vraiment pas.

Au plaisir mini_bn

DarKnight · » 25/01/07 - 18h45

Cours sur Maple : Les listes, les sequences et les ensembles. (Cours bien fait, mais à intégrer à la fin ds le tuto BNbox bn_wink

).

(Avec exemples). D'ailleurs BN, une fois qu'on maîtrisera bien Maple, il faudra faire un vrai cours avec récapitulatif de toutes les commandes, etc...
Ca pourrait être bien funky comme dirait l'autre.

ETUDE DES TYPES SEQUENCES, LISTES, ENSEMBLES

1) Les séquences

- Une séquence est une collection ordonnée d'objets Maple, séparés par une virgule, un même objet pouvant apparaître plusieurs fois.

séquence:=expr1,expr2,...,exprn;

- Pour créer une séquence, on peut :

- écrire une collection d'objets séparés par une virgule :

restart;s:=a,1.1,sqrt(2),ln(2);

- utiliser l'opérateur seq de construction de séquences :

s1:=seq(i,i=0..10);

s2:=seq(1+i^2,i=1..5);

s3:=seq(i^2,i=s);

- L'instruction s:=NULL; définit la séquence vide .

- L'instruction s:=s1,s2 est la concaténation des séquences s1 et s2.

s4:=NULL;s5:=s1,s2,s4;

- On accède au ième terme de la séquence s par s[i] .

> s1[2];s3[2];

- Pour insérer un terme dans une séquence, on procède de la manière suivante : par exemple, pour insérer le terme 18 entre le troisième et le quatrième terme de la séquence s1

s1[1..3],18,s1[4..11];

Certaines fonctions MAPLE retournent les résultats sous forme de séquence.
Exemples :

P:=x^3-6*x^2+11*x-6;solve(P); # solve(P) retourne les solutions de l'équation P=0.

op(P);#retourne la séquence des termes de P

> op(2..3,P);# retourne la séquence du deuxieme au troisième terme de P.

Exercice : Objectif : Résoudre l'équation

(iz+1)^8/((iz-1)^8) = -1; .

1) Résoudre l'équation

Z^8 = -1 et ranger les solutions dans une séquence S. Quel est le nombre n de termes de S?

2) On appelle

S[k]; le k-ième terme de S. A l'aide de l'instruction seq, résoudre les équations

(iz+1)/(iz-1) = S[k]; , k variant entre 1 et n. Ranger les solutions dans une séquence R.

3) Mettre le deuxième terme de R sous sa forme algébrique à l'aide de evalc. En utilisant simplify, calculer un argument et le module de ce complexe puis

donner une valeur approchée du module que vous comparerez à

cotan(3*Pi/16) .

restart:

Remarques :

- Dans une séquence, Maple conserve l'ordre dans lequel on a entré les éléments.

- On ne peut pas changer un élément d'une séquence :

> s1[2]:=3; s1;

2) Les listes

- Une liste est une collection ordonnée d'objets Maple, séparés par une virgule, un même élément pouvant apparaître plusieurs fois, délimitée par des crochets.

ATTENTION : Une séquence est donc le contenu d'une liste mais certaines instructions valables pour les listes ne sont pas valables pour les séquences et réciproquement.

liste:=[expr1,expr2,...,exprn];

- Pour créer une liste, on écrit les termes de la liste entre [ et ] :

L1:=[a,1,sqrt(2)];L2:=[seq(i^2,i=1..5),9];

- La liste vide est définie par L:=[]; et on accède au ième terme de la liste par L[i];

- Comme pour les séquences, Maple conserve l'ordre dans lequel on a entré les éléments, et un même élément peut apparaître plusieurs fois.

DIFFERENCES avec les SEQUENCES :

- La fonction "op" donne le contenu de la liste, la fonction nops donne le nombre d' éléments de la liste. En fait, la fonction op transforme une liste en séquence.

> op(L1);nops(L1);op(L2);nops(L2);

>

- La concaténation de deux listes s'obtient de la manière suivante : [op(L1),op(L2)]

L3:=[op(L1),op(L2)];

L1,L2;# attention, ce n'est pas une liste, mais une séquence constituée de 2 listes

- Contrairement aux séquences, on peut changer un élément dans une liste :

L2[4];L2[4]:=0;L2;

- Pour insérer un terme dans une liste, on procède de la manière suivante : par exemple pour insérer le terme 18 entre le troisième et le quatrième terme de la liste L2

> L:=[op(L2[1..3]),18,op(L2[4..6])];

Pour utiliser la fonction subs (de substitution, il faut une liste (et pas une séquence) ; ex :

> restart: subs(x=1,y=2,3*x+2,5*y+4);

subs(x=1,[y=2,3*x+2,5*y+4]);

- La fonction map(f , liste ) renvoie une liste où toutes les opérandes de la liste sont remplacées par leur image par la fonction f .

Par exemple, reprenons l'exemple du paragraphe séquence :

restart:S:=solve(Z^8+1): R:=seq(solve((I*z-1)/(I*z+1)=S[k],z),k=1..8):
map(x->simplify(argument(evalc(x))),[R]);

Les solutions sont toutes réelles...

Pour tester si un objet X appartient ou non à une liste L, on utilise la fonction member.

Syntaxe : member(X,L) ou member(X,L,rg) . Lorsque l'on utilise le 3ième argument 'rg' si l'évaluation de la fonction member est true, la variable rg contient le rang de la première occurence de X dans L

> L:=[1,3,5,-1,5];member(5,L);member(5,L,'rg');rg;member(7,L);

Exercice : Dériver les fonctions d'expression sin(x), cos(x), tan(x). On pourra utiliser les fonctions maple diff (pour la dérivation) et map, on rangera la réponse dans une liste.

> restart;L:=[sin(x), cos(x), tan(x)]; map(diff,L,x);

3) Les ensembles

- Un ensemble est une collection non ordonnée d'objets distincts, séparés par une virgule et délimitée par des accolades. Maple se charge de supprimer les éventuelles répétitions et choisit lui même l'ordre dans lequel il affiche les expression (attention, cet ordre peut varier d'une session à l'autre!).

ensemble:={expr1,expr2,...,exprn};

{3,4,5};

{5,3,4};# Bien noter l'ordre

{a,d,b,d,f,e,c,c};

- Pour créer un ensemble, on écrit les termes de l'ensemble entre { et }.

- L'instruction E:={}; définit l'ensemble vide.

- Les fonctions op, nops, union, intersec, minus, map s'appliquent.

e1:={seq(i,i=1..5)}; e2:={seq(i^2,i=1..10)};

Quelques exemples :

> e1 union e2;e1 intersect e2; e1 minus e2;map(sin ,e1);

Dernière modification par DarKnight (25/01/07 - 18h46)

DarKnight · » 21/03/07 - 17h10

Cours sur Maple : Les fonctions.

Source d'inspiration pour le futur tuto Maple BNBOX bn_tongue

ETUDES DE FONCTIONS

1 - Définitions de fonctions
1) Fonctions prédéfinies

Les fonctions usuelles sont prédéfinies. Ainsi, on peut utiliser sin, exp, ln ...Il suffit aller dans l'aide.

2) Opérateur flèche

Pour définir une fonction, on utilise la syntaxe suivante :

fonction := var -> expression de la variable var ;

> restart;f :=x-> x^2+3*sin(x);

(la flèche est constituée des signes - et >)

On peut aussi définir des fonctions de plusieurs variables :

g :=(x,y,z)->x^2+2*y+sqrt(z);

3) Fonctions définies par morceaux

On peut également définir des fonctions par morceaux à l'aide de l'oprérateur-flèche et de l'instruction piecewise :

f:=x -> piecewise(cond1,expr1, cond2, expr2...exprn) ;

h :=x->piecewise(x<-1,-x-1,x<=1,x+1,-x+3);

plot(h);

Pour obtenir la valeur d'une fonction, on écrit simplement :

f(3);g(1,2,3);h(-2);h(0);h(4);

Exercice: Définir la fonction représentée par la droite d'équation y=-x si x appartient à [-2, 0] et par la demi-parabole d'équation

y = x^2; si x est positif.

Vérifier sur le graphe. Calculer les valeurs de k en -1, 0 et 5. Que répond Maple à k(-4)?

2. Fonctions et Expressions

1) ATTENTION !!!

Il ne faut pas confondre les fonctions et les expressions :

P:=x^2+4*sin(x);Q:=x^2+2*y+sqrt(z);

P et Q sont des expressions.

Pour obtenir la valeur d' une expression pour une valeur de x, on ne peut pas utiliser la même instruction qu'avec les fonctions :

> P(2);

La réponse faite n'a pas de sens. On utilise alors pour les expressions l'instruction suivante :

subs(x=2,P);P;x;

On a substitué 2 à x dans l'expression de P. P n'a pas été modifié et on n'a pas affecté la valeur à x : x reste une "variable".

Exercice : Calculer, simultanément, P et Q quand x=3.

ATTENTION : Pour écrire des expressions et pour utiliser l'instruction subs, les variables utilisées doivent être non affectées.

> x:=3;P;subs(x=2,P);# observez attentivement la réponse!

> x:='x';subs(x=2,P);x;

Dans le premier cas, étant donné que x vaut 3, il ne remplace par 2 uniquement que les "apparitions" du nombre 3 ( il ne reconnaît pas 3^2 dans 9)!

Ce n'est donc pas ce que l'on souhaite!

2) Pour transformer une fonction en une expression

P1:=f(t);Q1:=g(t,u,v);

ATTENTION! P1 et Q1 sont donc des expressions : les instructions suivantes n'ont pas de sens.

> P1(3); P1(t); Q1(1,2,3);

3) Pour transformer une expression en une fonction

On utilise l'instruction unapply :

f := unapply(expression, variable(s))

f1:=unapply(P,x);

ATTENTION : pour pouvoir utiliser la fonction "unapply", la variable x doit être désaffectée sinon apparaît un message d'erreur.

> x:=3;f1:=unapply(P,x);

x:='x';g1:=unapply(Q,x,y,z);

Il faudra bien faire la distinction entre fonctions et expressions car certaines commandes Maple demandent d'employer des fonctions, d'autres des expressions.

3. Outils d'analyse

1) Composition

On peut composer deux fonctions à l'aide de l'opérateur @. On peut composer n fois une même fonction en utilisant @@n.

> f:=x->x^3;g:=x->x^2;(f@g)(x);(f@@4)(x);

2) Limite

Maple calcule des limites d'expressions quand x tend vers a ou l'infini (infinity ou - infinity). On peut également obtenir des limites à droite ou à gauche.

> limit(1/(x+exp(x)),x=infinity);

> limit(tan(x), x=Pi/2,right);

Exercice : Déterminer la limite à gauche en

Pi/2; de la fonction tangente.

L'instruction Limit (avec un L majuscule) s'appelle forme inerte ; elle permet d'écrire le symbole mathématique :

Limit(1/x,x=0,left);

Cela permet d'écrire à l'écran des formules mathématiques : côté rédactionnel de la conclusion.

Limit(1/x,x=0,left)=limit(1/x,x=0,left);

Exercice : écrire à l'écran la formule donnant la limite en 0 de

proc (x) options operator, arrow; sin(x)/x end proc; .

Exercice: Interpréter le résultat suivant :

> f:=x->x^2;limit(f,x=0);limit(x^2,x=0);

3) Dérivées

* Pour dériver, on peut utiliser l'instruction diff qui s'applique à des expressions et renvoie des expressions,

ou bien l'opérateur D qui s'applique à des fonctions et renvoie des fonctions.

Exercice : Calculer, par les deux méthodes, la dérivée de la fonction

proc (x) options operator, arrow; xsin(x) end proc;

Attention : on ne peut pas utiliser f ' comme nom de variable car les quotes ont un rôle précis en Maple (pour la désaffectation par ex)

Exercice : Calculer à l'aide de diff la dérivée en 2 de la fonction

proc (x) options operator, arrow; cos(x)/x end proc;

Même chose en utilisant l'opérateur D. Commentaire.

Donner une valeur approchée de ce nombre dérivé, avec 15 chiffres après la virgule.

* Pour calculer des dérivées d'ordre supérieur, 3 par exemple, on utilise pour les expressions la syntaxe suivante:

> diff(x^4,x$3);

et pour les fonctions la syntaxe :

> (D@@3)(sin);h:=x->x*sin(x);(D@@3)(h);

* Pour dériver des fonctions de plusieurs variables, on utilise "D[i](f)" qui donne la dérivée partielle de f par rapport à sa ième variable ou bien "diff(f(x,y,z),y)" qui donne l'expression de la dérivée partielle de f par rapport à la variable y.

> f:=(x,y,z)->x^2+3*y^3+1/z;D[2](f);diff(f(x,y,z),y);

Pour les dérivées successives des dérivées partielles, consulter l'aide.

Exercice : Déterminer les intervalles où la fonction f

proc (x) options operator, arrow; (x+2)/sqrt(x^2+1) end proc; est croissante puis les intervalles où f ' est croissante.

4) Intégration

Maple calcule des primitives ou des intégrales. Pour cela, on utilise l'opérateur int qui s'applique à des expressions.

P := int(f(x),x); donne une expression d'une primitive de f.

integrale := int(f(x),x=a..b); donne l'intégrale de f entre a et b.

Exercice : Calculer une primitive de

proc (x) options operator, arrow; x^3 end proc; , de ln. On rappelle qu'en mathématiques, une primitive désigne une fonction ! Que remarquez-vous?

Calculer la primitive de

proc (x) options operator, arrow; x^3 end proc; qui s'annule en 1.

Calculer

int(sin(x), x = 0 .. Pi); ,

int(exp(-x), x = 2 .. infinity); .

Il existe aussi une forme inerte pour l'opérateur int qui s'écrit Int.

Exercice : Ecrire les formules donnant les deux résultats précédents.

5) Courbes représentatives

Pour faire la représentation graphique d'une fonction, on utilise l'instruction plot.

a) A partir d'une fonction :

plot(fonction, a..b, c..d, options);

Cette instruction va effectuer le tracé sur l'intervalle horizontal [a,b] et dans l'intervalle vertical [c,d].

Les trois derniers arguments sont optionnels. Par défaut, l'intervalle horizontal est [-10,10], tandis que l'intervalle vertical est calculé par Maple (selon les valeurs atteintes par la fonction).

plot(cos);plot(cos,-Pi..Pi); plot(cos,-Pi..Pi, 0..1);

b) A partir d'une expression

plot(expression_en_x, x=a..b,c..d,options);.

Remarquez bien les différences!!!

Même remarque sur les trois derniers arguments optionnels.

> plot(cos(x),x);

Exercice : Tracer les courbes représentatives des fonctions sin,

proc (x) options operator, arrow; x^2 end proc; entre -5 et 5,

proc (x) options operator, arrow; 1/x end proc; entre -1 et 1.

En cliquant sur le graphe, une barre d'outils apparaît : étudier l'utilité des différentes icônes.

Que remarquez-vous sur le dernier graphe tracé? Remédier à ce problème en utilisant l'option "discont" de plot...

Exercice : Tracer la courbe de tangente sans préciser la fenêtre. Améliorer le graphe.

c) Quelques options

* discont

* scaling = constrained (impose un repère orthonormé)

* color

* title

*numpoints

.........cf Help

d) Représentation simultanée de plusieurs graphes

Première méthode : à partir d'un ensemble ou d'une liste

plot({f1,f2,f3},x1..x2) ou plot([f1,f2,f3],x1..x2);

> plot({sin,cos,tan},0..10,-10..10,color=[red,blue,black]);

Deuxième méthode : à partir de l'instruction display

> ?display

Chaque graphique est rangé dans une variable (graphe_i)

display([graphe_1,graphe_2...graphe_n],options);

après avoir chargé le module "plots"

> restart;with(plots):

> g1:=plot(cos(x),x=-Pi..Pi,color=black):

> g2:=plot(sin(x),x=-Pi..Pi,color=red):

> g3:=plot(tan(x),x=-Pi..Pi,-3..3,color=blue,discont=true):

> display([g1,g2,g3],title="Fonctions trigonométriques");

Observez les différences entre les deux méthodes.

e) Tracés de lignes brisées

Pour tracer la ligne brisée A1, A2, ..., An on écrit plot ([[x1, y1], [x2, y2], ... , [xn, yn]]);

> plot([[1,1],[2,2],[3,1],[4,1.5]]);

Exercice : Tracer le polygone régulier formé par les racines sixièmes de l'unité, dans un repère orthonormé.

6) Courbes paramétrées

Maple sait représenter les courbes définies par un paramétrage cartésien ou une équation polaire :

plot([x(t),y(t),t = tmin..tmax],options);

plot([r(t),t,t = tmin..tmax],coords=polar,options);

Exemple1 :

> plot({[(t^2-2)/t,(t-1)/(t^2+t),t=-10..-1.01],[(t^2-2)/t,(t-1)/(t^2+t),t=-0.99..-0.01],[(t^2-2)/t,(t-1)/(t^2+t),t=0.01..10]},x=-10..10,y=-10..10,color=black);

Remarque : il faut découper l'ensemble de définition en intervalles.

Exemple 2 :

> plot([1+cos(t),t,t=0..2*Pi],coords=polar,scaling=constrained);

Bnmaster · » 25/03/07 - 15h52

Maintenant j'ai vu DarK bn_tongue

Va falloir que je mettes ça bien en page un de ces 4 bn_big_smile

Bnmaster · » 26/04/07 - 17h11

Dessiner plusieurs fonctions

Méthode 1 (avec `display()`)

La forme d'une fonction est :
Code :

f:=->x(1+x^2)/2;
courbe:= plot(f(x),x=0..3,color=red,linestyle=DASH,thickness=3);
courbe2:=plot(x,x=0..3,color=green);
with(plots): // On charge le plugin permettant d'afficher plusieurs courbes
display([courbe1,courbe2],title="Fonction et tangente");

Voici la liste de ce que l'on peut mettre après les attributs de plot(), c'est toujours utile^^
color=[red,green,blue,black,cyan,gold,gray,orange,yellow];
linestyle=[solid,dot,dash,dashdot,default]; (en majuscule bn_wink

)
title="Le titre des courbes";

Méthode 2 (avec `plot()` directement)

Code :

f:=x->g:
L:=[[0,1],[1,1],[1,2],[0,-5]]:
plot([f(x),x,L],x=0..2,color=[red,green,blue],linestyle=[SOLID,DASH,DOT]):

Bref, c'est la même chose mais en plus condensé. Ce n'est pas forcément plus rapide, par contre pour plusieurs fonctions compliqués, c'est pas top, il vaut mieux utiliser la première méthode mini_bn

Bon éh bien testons tout ça. Cette courbe est celle de la suite définie par récurrence : $U_{n-1} = \frac{1+(U_n)^2}{2}$ avec $U_0 = 0.5$ par exemple. Mais ça on vient de le faire c'est trop facile, donc on va en tracer l'escalier mini_bn

Code :

escalier:=proc(f,a,b,u,n)
local L,i,u0,u1:
    u0:=u:
    L:=[u0,0]:
    for i from 1 to n do
        u1:=f(u0):
        L:=L,[u0,u1],[u1,u1]:
        u0:=u1:
    end do:
    return(plot([f(x),x,[L]],x=a..b,color=[red,green,blue],linestyle=[SOLID,DASH,SOLID],title="Fonction,  tangente et escalier")):
end proc:

Bnmaster · » 14/06/07 - 16h32

Algèbre linéaire

(matrice, tableau tout ça)
Vecteur ligne : L:=array([1,2,3]);
Ecrivons-en un rapidement de la forme : $[1,x,..x^n]$
A:=array([[1,2,3],[1,2,2]]);

Vecteur colonne : C:=array([[1],[2],[2]]);
Ecrivons l'exemple précédent mais en colonne cette fois-ci mini_bn

L:=array([seq([y^k],k=0..5)]);

On créé alors une matrice en écrivant : M:=array([[1,2,3],[4,5,6],[7,8,9]]);
On va faire un grand mixe des 2 exemples précédents pour faire une matrice dit de VanDerMonde :
M:=array([seq([seq(x[l]^k,k=0..5)],l=1..5)]);

On peut afficher un tableau grâce à print() ou evalm().

Voici la liste des opérations "classiques" que l'on peut effectuer avec une matrice :
A+B, k*A, A&*B, A^(-1) (inverse), A^n, A+x (ajout de xIn)
La fonction map(); permet d'appliquer une fonction ou une applications à tous les éléments d'un tableau. Testez map(exp,M); et map(x->x^2,M); avec la matrice tout à l'heure bn_heureux

Pour la suite, nous allons télécharger le package LINALG : with(linalg);
On peut alors créer une matrice :
M:=matrix([[a,b],[c,d]]);Ou :
M:=matrix(2,3,(i,j)->i*j); C'est à dire une matrice de 2 lignes, 3 colonnes et en position (1,1), on a le coefficient 1, (1,2) on a 2, etc...

Un vecteur colonne d'une matrice (que Maple écrit en ligne bn_heureux

) utilise vector(); et de même :
vector([1,2,3,4,5]); ou vector(5,i->xî);

Résolution d'un système linéraire

- On peut écrire le système et le résoudre avec solve();
s:={x+3*z=3, 2*y+z=2, 2*x+3*y=1};
solve(s, {x,y,z});
- On peut écrire le système sous forme matriciel (AX=B) et le résoudre grâce à linsolve();
A:=matrix([[1,2,3],[a,2*a,a],[4,5,6]]);
B:=vector([a,1,1]);
linsolve(A,B);

Ces méthodes ne donnent aucun résultat s'il n' a pas de solution ou s'il y a des conditions de compatibilité à vérifier.
Exemple :
A:=matrix([[1,2,3,4],[4,5,6,10],[2,1,0,2]]);
B:=vector([a,b,c]);
linsolve(A,B);
Mais on peut résoudre ce systèmeà l'aide du pivot de Gauss mini_bn

A:=matrix([[1,2,3,4],[4,5,6,10],[2,1,0,2]]);
B:=vector([a,b,c]);
L:=augment(A,B);
L:=addrow(L,1,2,-4);
L:=addrow(L,1,3,-2);
L:=addrow(L,2,3,-1);
B2:=col(L,5);
A2:=submatrix(L,1..2,1..4);
B2:=submatrix(L,1..2,5..5);
linsolve(A2,B2);

DarKnight · » 14/06/07 - 19h01

J'avais oublié de mettre ça.
Ca peut toujours servir :

Procédure pour approcher une intégrale par des rectangles.

Code :

rectangle:=proc(f,a,b,n)
local x,pas,s;
s:=0;x:=a;
pas:=(b-a)/n;
while x<=b do
    s:=s+f(x);
    x:=x+pas;
end do;
s:=s*pas;
s;
end proc;

#Procédure pour approcher une intégrale avec des trapèzes

Code :

g:=x->x^2;
trapeze:=proc(f,a,b,n)
local x,pas,s,k;
s:=0;
pas:=(b-a)/n;
x:=a+pas;
for k from 1 to n-1 do
   s:=s+f(x);
   x:=x+pas;
end do;
s:=(s+((f(a)+f(b))/2))*pas;
end proc:

Bnmaster · » 04/10/07 - 14h44

Fonction `extrema()`

extrema(a*x^2+b*x+c, {}, {x,y}, s); veut dire : recherche des extrémas de $a*x^2+b*x+c$ , sans aucune condition, en les cherchant sur x et y et on met le résultat dans s.

Polynôme de Lagrange

Li les polynômes de Lagrange :
$Li(x_i) = 0 \,\,\, si \,\,\, i \neq j$
$Li(x_i) = 1$
Donc :
$Li = \prod_{j \neq i} \frac{X - x_j}{x_i - x_j}$

Le Baranougat !

Menu

Mon compte

Recherche

Annonce

#1 [Maple 9] Utilisation de Maple 9 » 21/09/06 - 19h26

Fonctionnement global :

Objets manipulés par Maple :

Nombres

Variables

Manipulation d’expressions

Modules sympas

Programmation

Structures de test

Les boucles

Boucle for

Boucles while

Procédures

Suite de Fibonnacci :

#2 » [Maple 9] Utilisation de Maple 9 » 09/11/06 - 17h18

#3 » [Maple 9] Utilisation de Maple 9 » 16/11/06 - 17h54

#4 » [Maple 9] Utilisation de Maple 9 » 16/11/06 - 18h46

#5 » [Maple 9] Utilisation de Maple 9 » 17/11/06 - 15h54

#6 » [Maple 9] Utilisation de Maple 9 » 17/11/06 - 17h08

#7 » [Maple 9] Utilisation de Maple 9 » 30/11/06 - 17h04

Un petit exercice :

#8 » [Maple 9] Utilisation de Maple 9 » 30/11/06 - 18h06

#9 » [Maple 9] Utilisation de Maple 9 » 14/12/06 - 17h45

#10 » [Maple 9] Utilisation de Maple 9 » 20/12/06 - 14h52

#11 » [Maple 9] Utilisation de Maple 9 » 20/12/06 - 15h12

#12 » [Maple 9] Utilisation de Maple 9 » 23/12/06 - 15h05

#13 » [Maple 9] Utilisation de Maple 9 » 06/01/07 - 22h24

#14 » [Maple 9] Utilisation de Maple 9 » 25/01/07 - 18h45

#15 » [Maple 9] Utilisation de Maple 9 » 21/03/07 - 17h10

#16 » [Maple 9] Utilisation de Maple 9 » 25/03/07 - 15h52

#17 » [Maple 9] Utilisation de Maple 9 » 26/04/07 - 17h11

Dessiner plusieurs fonctions

Méthode 1 (avec display())

Méthode 2 (avec plot() directement)

#18 » [Maple 9] Utilisation de Maple 9 » 14/06/07 - 16h32

Algèbre linéaire

Résolution d'un système linéraire

#19 » [Maple 9] Utilisation de Maple 9 » 14/06/07 - 19h01

#20 » [Maple 9] Utilisation de Maple 9 » 04/10/07 - 14h44

Fonction extrema()

Polynôme de Lagrange

Pied de page des forums

Mini-tchat

Publicité

Méthode 1 (avec `display()`)

Méthode 2 (avec `plot()` directement)

Fonction `extrema()`