Vision tridimensionelle

TOUR : Introduction à Mathematica

Ce notebook Mathematica a été crée pour introduire les concepts importants de Mathematica.
De plus, on y présente des exercices reliés aux modèles de caméra et à la géométrie projective.

Operations simples

(Utiliser shift-return pour faire evaluer une cellule)

3 + 5

2^8

3 + 1/2

On peut mettre plusieurs expressions dans une même cellule, en les mettant sur des lignes différentes.

3 + 5
2^8
3 + 1/2

Les nombres exacts deviennent flottant avec N[]

Pi

N[Pi]

N[5]

Pour avoir de l'aide, utiliser le Help ou faire "?" devant la commande

?Prime

Prime[100000]

?N

Symboles et accents

Vous pouvez utiliser des symboles et des accents dans les expressions. Ceux-ci sont crées par une séquence
Esc <code du symbole>  Esc
Tous les détails sont dans la section 3.10 du Mathematica Book (dans le Help Browser)

En principe, vous pouvez le tapper directement des caractères avec des accents. Si ça ne fonctionne pas, par exemple, pour un é, faire  Esce ' Esc.

Pour un symbole α, faire Escalpha Esc

Variables

Les variables sont définies en utilisant le =
Les noms doivent commencer par une lettre.

a = 123

a*2

bonjour = 1/2

bonjour ^ 2

Important:Si vous définissez une variable,elle sera définie pour toujours.Si vous revenez en arrière dans le notebook,elle est encore définie! Cela cause beaucoup d'erreurs...

Pour éliminer une variable (ou une fonction), utilisez Remove.

a

Remove[a]

a

Si vous utilisé cette variable, elle le sera de façon symbolique

(a^2)

Vecteurs

Pour ne pas imprimer un résultat, utiliser toujours un ";" à la fin d'une expression

u = {1, 2, 3};

u = {1, 2, 3}

Suggestion:Utilisez TOUJOURS un ";" sauf si vous voulez vraiment voir le contenu d'une variable.L' idéal est de définir la variable,puis d'afficher son contenu.

Pour afficher un vecteur ou matrice

u // MatrixForm

MatrixForm[u]

v = {4, 5, 6}; v // MatrixForm

Sous vecteur

u[[1]]
u[[{1, 3}]]
u[[-1]]

u + v

Produit scalaire

u . v

En forme symbolique

{x1, x2, x3} . {y1, y2, y3}

Produit vectoriel Esc cross  Esc

u\[Cross]v
Cross[u, v]

En forme symbolique

{x1, x2, x3}\[Cross]{y1, y2, y3}

Matrices

m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; m // MatrixForm

ou aller dans: Input, Create Table/Matrix/Palette

m= (({{1, 2, 3}, {4, 5, 6}, {7, 8, 10}}));m // MatrixForm

n = {{a11, 1}, {2, a22}}; n // MatrixForm

Sous-Matrice

m[[1]]
Transpose[m][[1]]
m[[All, 1]]
m[[1, All]]
m[[{1, 2}, All]]

Fonctions numériques ou symboliques

Inverse[m]
Inverse[N[m]]

Inverse[n]

Det[n]

Multiplication

(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})).(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}))

Fonctions

f[x_] := 2/x;

?f

Les cas spéciaux passe avant les cas généraux

f[0] := e;

?f

f[6] + f[a + b] + f[0]

Efface le symbole f

Remove[f];

Fonction factorielle

f[i_] := i*f[i - 1];

f[4]

f[0] := 1;

?f

f[4]

Les paramètres des fonctions sont des "patterns"

Remove[g];

g[x_] := 2 x;

g[{x_, y_}] := x + y;

g[5]

g[{1, 2}]

Calculs symboliques

f[x_] := Sqrt[x] Sqrt[1 + x];

f[y]

f[1]

N[f[1]]

Intégration symbolique

Integrate[f[x], x]

g[x_] := x^2 + x;

Solution d'équation quadratique

s = Solve[g[x] == a, x]; s

x /. s

(x /. s) /. {a -> 5.0}

Coefficient d'un système d'équations

Remove[a, b, c, d]
eq  = a + 2  b + 3  c + 4  d;
var  =  Variables[eq];
coeff = Coefficient[eq,  var]
var . coeff
% - eq

Pour en savoir plus sur les règles de remplacement (->),voir la section 1.4.2 du Mathematica Book.

Calculs numériques

NSolve[x^5 - 6  x^3 + 8  x + 1 == 0, x]

FindRoot[Cos[x] == x + Log[x], {x, 1}]

Graphiques

Fonction à une dimension

Plot[Cos[x] - (x + Log[x]), {x, 0.1, 2}];

f[x_] := Sin[x] + Sin[1.6  x];

Plot[f[x], {x, 0, 40}];

Fonction à deux dimensions

Plot3D[Sin[x y], {x, 0, 4}, {y, 0, 4}];

DensityPlot[Sin[x y], {x, 0, 4}, {y, 0, 4}];

ContourPlot[Sin[x y], {x, 0, 4}, {y, 0, 4}];

<< Graphics`ImplicitPlot`

ImplicitPlot[{x, y, 1} . {1, (1/2), 0} == 0,  {x, -10, 
        10}, {y, -10, 10}]

Pour connaitre les options possibles d' une commande graphique, utiliser ??

?? ContourPlot

ContourPlot[Sin[x y], {x, 0, 4}, {y, 0, 4}, 
        Contours -> 5];

Tables

Table[i, {i, 1, 10}]

u = Table[Random[], {i, 1, 20}]

Length[u]

On peut afficher une graphiquement des listes à une ou plusieurs dimensions

ListPlot[u, PlotJoined -> True, PlotRange -> {0, 1}];

Dans cette table à deux dimensions, i est la rangée, j la colonne

m = Table[(i)*Random[], {i, 1, 8}, {j, 1, 8}]; 
    m // MatrixForm

ListPlot3D[m, PlotRange -> All];

ListDensityPlot[m, PlotRange -> All];

ListContourPlot[m]

Première rangée d'un tableau

m[[1]]

Élément de la rangé 1 et colonne 5

m[[1, 5]]

Operations sur les tables

u = {a, b, c, d, e}

Delete[u, 3]

Append[u, 999]

Take[u, 3]

Take[u, -3]

Partition[{1, 2, 3, 4, 5, 6, 7, 8}, 2] // MatrixForm

Partition[{1, 2, 3, 4, 5, 6, 7, 8}, 4] // MatrixForm

Applique la fonction toto[] à chaque élement de u (voir aussi Map)

toto  /@  u

?Map

Applique la fonction toto à l'ensemble du vecteur u (voir aussi Apply)

toto  @@  u

?Apply

Exemples pour les matrices

m = {{a, b, c}, {d, e, f}, {g, h, i}}; m // MatrixForm

toto  /@  m  // MatrixForm

Applique toto à la deuxième dimension seulement...

Map[toto, m, {2}] // MatrixForm

Applique une fonction à deux (ou plusieurs) tableaux à la fois

MapThread[toto, {{a1, b1, c1}, {a2, b2, c2}}]

MapThread[toto, {{a1, b1, c1}, {a2, b2, c2}, {a3, b3, c3}}]

un équivalent... moins élégant...

toto  /@  Transpose[{{a1, b1, c1}, {a2, b2, c2}}]

Souscript Ctrl-_

m  = Table[(Subscript[a, i]), {i, 1, 4}]

Mais attention, il faut que la variable soit Symbolique

m
a = 1
m
Clear[a]
m

Variables locales dans les fonctions

Voici une fonction qui mélange un tableau.
Notez que le résultat de la dernière commande d'un "block" est retournée par la fonction.

permute[{}] := {};

Les variables pos,t1,t2 sont locales à la fonction.
La fonction retourne le résultat de t2

\(\(permute[t_] := 
        Module[{pos, t1, 
            t2}, \((
			pos = 
              Random[Integer, {1, Length[t]}]; 
			t1 = 
              permute[Delete[t, pos]]; 
			t2 = 
              Append[t1, t[\([pos]\)]]; 
			t2
			)\)];\)\)

permute[{1, 2, 3, 4, 5}]

Cette fonction inverse une table (récursivement)

invtable[{}] := {};

invtable[t_] := 
        Append[invtable[Delete[t, 1]], t[[1]]];

invtable[{1, 2, 3, 4, 5, 6}]

Comment définir une fonction pure

u = {1, 2, 3, 4};

toto  /@  u

Les symboles représente un paramètre de la fonction, le & est l'opérateur qui construit la fonction

(# + 1) &  /@  u

Un peu d'Orienté-Objet (!)

Comment peut-on représenter un "objet" et definir des "méthodes"?
On utilise un nom de fonction...

Constructeurs...

Point2d[] := Point2d[0, 0];

Affiche[p_Point2d] := "(" <> ToString[p[[1]]] <> "," <> 
          ToString[p[[2]]] <> ")";

Ajoute[Point2d[x1_, y1_], Point2d[x2_, y2_]] := 
        Point2d[x1 + x2, y1 + y2];

a = Point2d[1, 2];
b = Point2d[3, 4];

Affiche[a]

Affiche[a + b]

c = Ajoute[a, b];

Affiche[c]

L'ennemi : le FOR

Ne jamais utiliser le FOR pour une boucle. Utiliser Map (/@), Apply (@@) ou MapThread à la place.

t = Table[Random[], {i, 1, 20000}];

r1=Timing[For[somme = 0; i = 1, i <= Length[t], i++, somme += t[[i]]];somme]

Nettement plus efficace...

r2 = Timing[Plus  @@  t]

ratio = r1[[1, 1]]/r2[[1, 1]];
Print["Le FOR est ", 
        ratio, " fois plus lent que le Apply"];

Graphisme 3D de base

Création de 40 points aléatoires 3D

p = Partition[Table[Random[], {i, 1, 40*3}], 3];

Afficher les 10 premiers points

Take[p, 10] // MatrixForm

s1 = Point  /@  p;

Ceci est équivalent à la formulation:

s1 = Table[Point[p[[i]]], {i, 1, Length[p]}];

Show[Graphics3D[s1]];

s2 = Line[p];

Show[Graphics3D[{RGBColor[1, 0, 0], s2}]];

Partitione la liste de point en groupes de 3 points

poly = Partition[p, 3];

s3 = Polygon  /@  poly;

Show[Graphics3D[s3]];

?Text

s4 = Table[Text[i, p[[i]]], {i, 1, Length[p]}];

Show[Graphics3D[s4]];

Show[Graphics3D[{s2, RGBColor[0, 1, 0], s4}]];

I/O de base

Sauvegarder et lire des tables

t  = Table[{i, 2  i, 3  i}, {i, 1, 10}];

Export["t.dat", t, "Table"]

t2 = Import["t.dat", "Table"]

Clear[a]
t  = Table[{func[a], 2  i, 3  i}, {i, 1, 10}];

On peut aussi le faire en symbolique

Export["t.dat", t]

t2 = Import["t.dat"]

Mais attention t2 n'est qu'une suite de string, et il faut le transformer en expression avec ToExpression si on veut que ça soit du "code"

a = 1
func[x_] := x;
t2
t2 // ToExpression