Fonctions Mathématiques dans SQLite

SQLite propose un ensemble de fonctions mathématiques qui permettent d’effectuer des calculs scientifiques et techniques directement dans vos requêtes SQL. Ces fonctions sont particulièrement utiles pour les applications nécessitant des calculs précis sans avoir à extraire les données et les traiter dans un langage de programmation externe.

NOTE

Les fonctions mathématiques avancées ne sont pas disponibles par défaut dans toutes les versions de SQLite. Selon votre installation, certaines fonctions peuvent nécessiter l’activation des extensions mathématiques.

Dans ce tutoriel, nous allons explorer les différentes fonctions mathématiques disponibles dans SQLite et montrer comment les utiliser efficacement dans vos requêtes.

Fonctions mathématiques de base

Commençons par les fonctions mathématiques fondamentales :

-- Création d'une table d'exemple
CREATE TABLE mesures (
  id INTEGER PRIMARY KEY,
  valeur REAL,
  angle_degres REAL
);

-- Insertion de quelques données
INSERT INTO mesures (valeur, angle_degres) VALUES
  (5.7, 30),
  (10.3, 45),
  (15.8, 60),
  (20.2, 90),
  (25.5, 120),
  (30.1, 180),
  (35.9, 270),
  (40.4, 360);

-- Fonctions mathématiques de base
SELECT
  valeur,
  ABS(-valeur) AS valeur_absolue,
  ROUND(valeur) AS valeur_arrondie,
  ROUND(valeur, 1) AS valeur_arrondie_1_decimale,
  CEILING(valeur) AS plafond,
  FLOOR(valeur) AS plancher,
  TRUNC(valeur) AS troncature,
  SIGN(valeur) AS signe
FROM mesures;

Dans cet exemple :

• ABS(X) retourne la valeur absolue de X
• ROUND(X, Y) arrondit X à Y décimales (Y est optionnel, 0 par défaut)
• CEILING(X) ou CEIL(X) arrondit vers le haut à l’entier supérieur
• FLOOR(X) arrondit vers le bas à l’entier inférieur
• TRUNC(X) tronque la partie décimale (arrondit vers zéro)
• SIGN(X) retourne le signe de X (-1, 0, ou 1)

Fonctions trigonométriques

SQLite propose des fonctions trigonométriques qui opèrent en radians :

-- Conversion degrés en radians
SELECT
  angle_degres,
  angle_degres * PI() / 180 AS angle_radians
FROM mesures;

-- Fonctions trigonométriques
SELECT
  angle_degres,
  angle_degres * PI() / 180 AS angle_radians,
  SIN(angle_degres * PI() / 180) AS sinus,
  COS(angle_degres * PI() / 180) AS cosinus,
  TAN(angle_degres * PI() / 180) AS tangente
FROM mesures;

-- Fonctions trigonométriques inverses
SELECT
  0.5 AS valeur,
  ASIN(0.5) AS arc_sinus_radians,
  ASIN(0.5) * 180 / PI() AS arc_sinus_degres,
  ACOS(0.5) AS arc_cosinus_radians,
  ACOS(0.5) * 180 / PI() AS arc_cosinus_degres,
  ATAN(0.5) AS arc_tangente_radians,
  ATAN(0.5) * 180 / PI() AS arc_tangente_degres
FROM mesures LIMIT 1;

-- Fonction ATAN2
SELECT
  ATAN2(1, 1) AS arc_tangente_radians,
  ATAN2(1, 1) * 180 / PI() AS arc_tangente_degres
FROM mesures LIMIT 1;

Dans ces exemples :

• PI() retourne la valeur de π (3.141592653589793)
• SIN(X), COS(X), TAN(X) calculent respectivement le sinus, cosinus et tangente de X en radians
• ASIN(X), ACOS(X), ATAN(X) calculent les fonctions trigonométriques inverses (résultat en radians)
• ATAN2(Y, X) calcule l’arctangente de Y/X, en tenant compte du quadrant (résultat en radians)

NOTE

Pour convertir des degrés en radians : radians = degrés * π / 180
Pour convertir des radians en degrés : degrés = radians * 180 / π

Fonctions exponentielles et logarithmiques

-- Fonctions exponentielles et logarithmiques
SELECT
  valeur,
  EXP(valeur) AS exponentielle,
  LOG(valeur) AS logarithme_naturel,
  LOG10(valeur) AS logarithme_base_10,
  LOG(2, valeur) AS logarithme_base_2,
  POWER(valeur, 2) AS valeur_au_carre,
  POWER(valeur, 0.5) AS racine_carree,
  SQRT(valeur) AS racine_carree_bis
FROM mesures;

Dans cet exemple :

• EXP(X) calcule e^X (e élevé à la puissance X)
• LOG(X) calcule le logarithme naturel (base e) de X
• LOG10(X) calcule le logarithme en base 10 de X
• LOG(B, X) calcule le logarithme en base B de X
• POWER(X, Y) ou POW(X, Y) calcule X élevé à la puissance Y
• SQRT(X) calcule la racine carrée de X (équivalent à POWER(X, 0.5))

Fonctions hyperboliques

SQLite supporte également les fonctions hyperboliques :

-- Fonctions hyperboliques
SELECT
  valeur,
  SINH(valeur) AS sinus_hyperbolique,
  COSH(valeur) AS cosinus_hyperbolique,
  TANH(valeur) AS tangente_hyperbolique
FROM mesures
WHERE valeur < 10;  -- Limitons aux petites valeurs pour éviter les débordements

Ces fonctions sont utiles dans certains calculs scientifiques et en ingénierie.

Applications pratiques

Calculs géométriques

-- Créons une table pour stocker des coordonnées
CREATE TABLE points (
  id INTEGER PRIMARY KEY,
  nom TEXT,
  x REAL,
  y REAL
);

INSERT INTO points (nom, x, y) VALUES
  ('Point A', 0, 0),
  ('Point B', 3, 0),
  ('Point C', 3, 4),
  ('Point D', 0, 4),
  ('Point E', 5, 5),
  ('Point F', 10, 8);

-- Calcul de la distance entre deux points
SELECT
  a.nom AS point_1,
  b.nom AS point_2,
  SQRT(POWER(b.x - a.x, 2) + POWER(b.y - a.y, 2)) AS distance
FROM points a, points b
WHERE a.id < b.id  -- Pour éviter les doublons et la distance d'un point à lui-même
ORDER BY distance;

-- Calcul de l'angle entre trois points (avec B comme sommet)
SELECT
  a.nom AS point_1,
  b.nom AS point_sommet,
  c.nom AS point_2,
  -- Calcul des vecteurs
  (a.x - b.x) AS vect1_x,
  (a.y - b.y) AS vect1_y,
  (c.x - b.x) AS vect2_x,
  (c.y - b.y) AS vect2_y,
  -- Calcul du produit scalaire
  ((a.x - b.x) * (c.x - b.x) + (a.y - b.y) * (c.y - b.y)) AS prod_scalaire,
  -- Calcul des normes
  SQRT(POWER(a.x - b.x, 2) + POWER(a.y - b.y, 2)) AS norme1,
  SQRT(POWER(c.x - b.x, 2) + POWER(c.y - b.y, 2)) AS norme2,
  -- Calcul de l'angle en radians puis conversion en degrés
  ACOS(
    ((a.x - b.x) * (c.x - b.x) + (a.y - b.y) * (c.y - b.y)) /
    (SQRT(POWER(a.x - b.x, 2) + POWER(a.y - b.y, 2)) * SQRT(POWER(c.x - b.x, 2) + POWER(c.y - b.y, 2)))
  ) * 180 / PI() AS angle_degres
FROM points a, points b, points c
WHERE a.id < b.id AND b.id < c.id  -- Pour éviter les combinaisons redondantes
ORDER BY angle_degres;

Cet exemple montre comment calculer la distance entre deux points et l’angle formé par trois points en utilisant des formules géométriques.

Calculs financiers

-- Créons une table pour des calculs financiers
CREATE TABLE investissements (
  id INTEGER PRIMARY KEY,
  montant_initial REAL,
  taux_interet_annuel REAL,
  duree_annees INTEGER
);

INSERT INTO investissements (montant_initial, taux_interet_annuel, duree_annees) VALUES
  (1000, 0.03, 5),   -- 1000€ à 3% sur 5 ans
  (5000, 0.045, 10), -- 5000€ à 4.5% sur 10 ans
  (10000, 0.05, 20), -- 10000€ à 5% sur 20 ans
  (25000, 0.04, 15); -- 25000€ à 4% sur 15 ans

-- Calcul de l'intérêt composé
SELECT
  montant_initial,
  taux_interet_annuel,
  duree_annees,
  montant_initial * POWER(1 + taux_interet_annuel, duree_annees) AS montant_final,
  montant_initial * POWER(1 + taux_interet_annuel, duree_annees) - montant_initial AS interet_gagne
FROM investissements;

Cet exemple illustre le calcul de l’intérêt composé pour différents investissements.

Probabilités et statistiques

-- Créons une table pour des données statistiques
CREATE TABLE notes_etudiants (
  id INTEGER PRIMARY KEY,
  etudiant TEXT,
  note REAL
);

INSERT INTO notes_etudiants (etudiant, note) VALUES
  ('Alice', 15.5),
  ('Bob', 12.0),
  ('Charlie', 18.5),
  ('David', 9.5),
  ('Eva', 14.0),
  ('Frank', 16.5),
  ('Grace', 13.0),
  ('Henry', 11.0),
  ('Isabella', 17.0),
  ('Jack', 10.5);

-- Calculs statistiques
SELECT
  COUNT(*) AS nombre_etudiants,
  AVG(note) AS moyenne,
  MIN(note) AS note_min,
  MAX(note) AS note_max,
  MAX(note) - MIN(note) AS amplitude,
  -- Écart-type (calcul simplifié)
  SQRT(AVG(POWER(note - (SELECT AVG(note) FROM notes_etudiants), 2))) AS ecart_type
FROM notes_etudiants;

-- Calculons la distribution normale pour chaque note
SELECT
  etudiant,
  note,
  -- Calculons la position par rapport à la moyenne (Z-score)
  (note - (SELECT AVG(note) FROM notes_etudiants)) /
  (SELECT SQRT(AVG(POWER(note - (SELECT AVG(note) FROM notes_etudiants), 2))) FROM notes_etudiants) AS z_score,
  -- Calculons la probabilité associée à cette note dans une distribution normale
  -- (approximation simplifiée)
  0.5 * (1 + SIGN(note - (SELECT AVG(note) FROM notes_etudiants)) *
        (1 - EXP(-0.7 * POWER(ABS(note - (SELECT AVG(note) FROM notes_etudiants)) /
        (SELECT SQRT(AVG(POWER(note - (SELECT AVG(note) FROM notes_etudiants), 2))) FROM notes_etudiants), 2))))
        AS probabilite_approx
FROM notes_etudiants
ORDER BY note;

Cet exemple montre comment calculer des statistiques de base et des approximations de probabilités basées sur la distribution normale.

Utilisation avancée avec des fonctions personnalisées

Dans certains cas, vous pourriez avoir besoin de fonctions mathématiques qui ne sont pas incluses dans SQLite. Vous pouvez alors créer vos propres fonctions en utilisant l’API C/C++ de SQLite, ou en utilisant des extensions comme SQLite-Math.

Par exemple, si vous avez accès à cette extension, vous pourriez utiliser des fonctions comme :

-- Exemples de fonctions mathématiques avancées (nécessite l'extension appropriée)
SELECT
  -- Fonction gamma
  GAMMA(5) AS gamma_5, -- Devrait retourner 24 (4!)

  -- Fonction bêta
  BETA(2, 3) AS beta_2_3,

  -- Fonction de Bessel
  BESSELJ(1, 2) AS bessel_j_1_2

Résumé des fonctions mathématiques dans SQLite

Catégorie	Fonction	Description	Exemple d’utilisation
Basiques	ABS(X)	Valeur absolue de X	ABS(-10) = 10
	ROUND(X, Y)	Arrondit X à Y décimales	ROUND(3.14159, 2) = 3.14
	CEILING(X) / CEIL(X)	Arrondit vers le haut	CEILING(3.14) = 4
	FLOOR(X)	Arrondit vers le bas	FLOOR(3.14) = 3
	TRUNC(X)	Tronque la partie décimale	TRUNC(3.14) = 3
	SIGN(X)	Signe de X (-1, 0, 1)	SIGN(-10) = -1
Exponentielle	EXP(X)	e élevé à la puissance X	EXP(1) = 2.718…
	LOG(X)	Logarithme naturel de X	LOG(2.718) ≈ 1
	LOG10(X)	Logarithme base 10 de X	LOG10(100) = 2
	LOG(B, X)	Logarithme base B de X	LOG(2, 8) = 3
	POWER(X, Y) / POW(X, Y)	X élevé à la puissance Y	POWER(2, 3) = 8
	SQRT(X)	Racine carrée de X	SQRT(16) = 4
Trigonométrie	PI()	Constante π	PI() = 3.14159…
	SIN(X)	Sinus de X (radians)	SIN(PI()/2) = 1
	COS(X)	Cosinus de X (radians)	COS(PI()) = -1
	TAN(X)	Tangente de X (radians)	TAN(PI()/4) = 1
	ASIN(X)	Arc sinus de X (radians)	ASIN(1) = 1.57…
	ACOS(X)	Arc cosinus de X (radians)	ACOS(0) = 1.57…
	ATAN(X)	Arc tangente de X (radians)	ATAN(1) = 0.78…
	ATAN2(Y, X)	Arc tangente de Y/X (radians)	ATAN2(1, 1) = 0.78…
Hyperboliques	SINH(X)	Sinus hyperbolique de X	SINH(1) = 1.175…
	COSH(X)	Cosinus hyperbolique de X	COSH(1) = 1.543…
	TANH(X)	Tangente hyperbolique de X	TANH(1) = 0.762…

Conclusion

Les fonctions mathématiques de SQLite offrent un large éventail de possibilités pour effectuer des calculs directement dans vos requêtes SQL. Ces fonctions sont particulièrement utiles pour :

• Réaliser des calculs scientifiques et d’ingénierie sur vos données
• Effectuer des transformations géométriques et des calculs spatiaux
• Analyser des données statistiques et financières
• Créer des rapports incluant des calculs avancés

En utilisant ces fonctions directement dans vos requêtes SQL, vous pouvez souvent éviter d’extraire les données pour les traiter dans un langage de programmation externe, ce qui peut améliorer significativement les performances de vos applications.

N’oubliez pas que selon votre installation de SQLite, certaines fonctions mathématiques avancées peuvent nécessiter l’activation d’extensions spécifiques. Consultez la documentation officielle pour savoir comment activer ces extensions si nécessaire.