Calculs numériques et symboliques (octave, scilab, numpy, pandas, scipy, sympy, matplotlib, seaborn)

Alternatives à Matlab (Octave, scilab, SageMath)

Plusieurs logiciels libres existent en alternatives à Matlab. Quelques-uns sont listés ci-dessous :

• GNU Octave, projet GNU
• scilab, porté par Dassault Systèmes
• SageMath

Octave utilise le même langage que Matlab de telle manière qu'un programme écrit en Matlab devrait être exécutable avec Octave. Il est extensible avec des packages.

Scilab est un outil de calcul porté par Dassault Systèmes. Il peut également être étendu avec des boîtes à outils installables avec atoms, par exemple pour la mécanisque spatiale par le CNES.

SageMath est un outil pour les mathématiques, pour le calcul numérique, le calcul symbolique, le tracé, etc... On trouvera plus d'informations dans le livre en Français Calcul mathématique avec Sage.

Outils python du calcul scientifique

Dans l'écosystème python, plusieurs librairies pour le calcul scientifique sont incontournables :

• numpy : calcul numérique en général
• scipy : traitement du signal
• sympy : calcul symbolique
• matplotlib : tracé
• seaborn : tracé.

Calcul numérique (numpy, scipy)

La librairie numpy est un incontournable pour le calcul numérique en python. Avec un coeur écrit en C++ et un wrapper python, elle est à la foi efficace et confortable d'utilisation. Vous trouverez des guides sur la page https://numpy.org/learn/ pour prendre en main numpy. Il existe également des livres en accès libre comme From python to numpy.

Pour l'utiliser :

$ python3 -m pip install numpy

Traitement des images (scikit-image, opencv)

Pour le traitement des images, des librairies standards comme OpenCV ou scikit-image vous offrent un certain nombre d'algorithmes :

• scikit-image
• opencv

La librairie OpenCV en particulier est en partculier très développée avec des algorithmes de calibration de caméra, détection de ligne (transformée de Hough, opérateurs morphologiques, ...) . Pour l'utiliser en python, vous pouvez l'installer avec pip :

$ python3 -m pip install opencv-python-headless

Calcul symbolique (sympy)

sympy est une librairie python qui va vous permettre de manipuler symboliquement des expressions mathématiques. Pour l'installer :

$ python3 -m pip install sympy

Par exemple, considérons deux référentiels A et B, l'orientation du référentiel B dans le référentiel A étant donnée par le quaternion (\(q_x, q_y, q_z, q_w)\). On peut calculer symboliquement les coordonnées, dans le référentiel A, du vecteur \((1, 0, 0)\) dans le référentiel B, projeté sur le plan x-y du référentiel A à l'aide de sympy :

import sympy
from sympy.algebras.quaternion import Quaternion
from sympy import symbols
from sympy import conjugate

qx = symbols('qx')
qy = symbols('qy')
qz = symbols('qz')
qw = symbols('qw')

q1 = Quaternion(qw, qx, qy, qz, real_field=True)

# Vecteur x dans le référentiel B
v = Quaternion(0, 1, 0, 0)

res = q1 * v * conjugate(q1)
print(f"Après rotation : {res}"))

horizontal_res = Quaternion(res.a, res.b, res.c, 0.0).normalize().simplify()
print(f"Vecteur projeté normalisé : {horizontal_res}")

Tracé (matplotlib, seaborn)

Pour tracé des données avec un programme python, vous pouvez utiliser les librairies matplotlib et seaborn.

Pour apprendre à prendre en main ces libraiires, il existe des tutoriels pour matplotlib et des tutoriels pour seaborn.

Machine learning (scikit-learn, pandas, pytorch, tensorflow)

Les librairies pour l'apprentissage automatique sont nombreuses. On atteint probablement les limites de l'objectif de ce site web en ne pouvant pas lister toutes les librairies pertinentes pour ce sujet. Mais disons qu'on peut donner quelques pointeurs :

• scikit-learn : proposent des implémentations de beaucoup d'algorithmes d'apprentissage automatique (arbres, svm, réseaux de neurones, k-means, ...), de datasets, etc..
• pandas : librairie particulièrement efficace pour traiter de grandes masses de données (en "local", vs hadoop/spark pour des traitements distribués)
• pytorch et tensorflow : pour le deep learning
• jax qui est apparu dans le sillage des librairies de deeplearning, que l'on pourrait définir comme un numpy qui peut exécuter ses calculs sur CPU/GPU/TPU, et avec la différentiabilité des opérations