Fonctions Mathématiques Essentielles

Les concepts mathématiques indispensables pour programmer : logarithmes, exponentielles, modulo.

algorithmique
 
Dans le monde du développement logiciel, les fonctions mathématiques forment la colonne vertébrale de nombreux algorithmes et solutions. Que vous construisiez des interfaces utilisateur réactives avec React ou que vous développiez des applications mobiles avec React Native, une compréhension solide des concepts mathématiques peut transformer votre code, le rendant plus élégant, plus performant et plus facile à entretenir.
Points essentiels à retenir:
  • Les fonctions en programmation et en mathématiques partagent les mêmes principes fondamentaux
  • Comprendre les différents types de fonctions mathématiques améliore votre capacité à résoudre des problèmes
  • TypeScript offre une excellente prise en charge des fonctions mathématiques avec typage statique
  • L'application pratique de ces concepts peut être maîtrisée en seulement quelques heures d'étude ciblée

1. Fondamentaux des fonctions en programmation

Dans sa forme la plus pure, une fonction est un mécanisme qui transforme des entrées en sorties selon une règle définie. Cette définition s'applique parfaitement aux mathématiques comme à la programmation.

Anatomie d'une fonction en TypeScript

Déclaration d'une fonction simple
// Fonction JavaScript traditionnelle
function double(x: number): number {
  return x * 2;
}

// Fonction fléchée (arrow function)
const triple = (x: number): number => x * 3;

// Fonction avec types génériques
function identite<T>(x: T): T {
  return x;
}
L'équivalent mathématique de ces fonctions serait :
  • f(x) = 2x pour la fonction double
  • g(x) = 3x pour la fonction triple
  • h(x) = x pour la fonction identite (fonction identité)

Composition de fonctions

Tout comme en mathématiques où l'on peut composer des fonctions (appliquer une fonction au résultat d'une autre), en programmation, nous pouvons enchaîner les appels de fonctions.
Composition en TypeScript
// Composition manuelle
const resultat = double(triple(5)); // Équivalent à f(g(5)) en maths

// Fonction de composition générique
function compose<T, U, V>(f: (y: U) => V, g: (x: T) => U) {
  return (x: T): V => f(g(x));
}

const sextuple = compose(double, triple);
console.log(sextuple(5)); // 30
1 2 3 4 5 6 7 5 10 15 20 f(x) = 2x g(x) = 3x h(x) = 6x Composition de fonctions linéaires

2. Fonctions linéaires et polynomiales

Les fonctions linéaires (f(x) = ax + b) et polynomiales sont parmi les plus utilisées en programmation. Elles servent à modéliser de nombreux phénomènes et comportements dans les applications.

Applications en React

Animation linéaire avec React
import React, { useState, useEffect } from 'react';

// Composant d'animation linéaire avec TypeScript
const LinearAnimation: React.FC = () => {
  const [position, setPosition] = useState(0);
  
  useEffect(() => {
    // Fonction linéaire: f(t) = 5t + 10
    const animate = (t: number) => 5 * t + 10;
    
    let startTime = 0;
    let animationId: number;
    
    const updateAnimation = (timestamp: number) => {
      if (!startTime) startTime = timestamp;
      const elapsed = (timestamp - startTime) / 1000; // en secondes
      
      if (elapsed < 3) { // Animation pendant 3 secondes setPosition(animate(elapsed)); animationId = requestAnimationFrame(updateAnimation); } }; animationId = requestAnimationFrame(updateAnimation); return () => cancelAnimationFrame(animationId);
  }, []);
  
  return (
    <div style={{ 
      transform: `translateX(${position}px)`,
      padding: '20px',
      background: '#EFB93D',
      display: 'inline-block'
    }}>
      Animation linéaire
    </div>
  );
};
Applications pratiques des fonctions linéaires :
  • Interpolation entre deux valeurs (mélanges de couleurs, transitions)
  • Calcul de proportions (mise à l'échelle responsive)
  • Prédictions simples (croissance linéaire)
  • Transformations géométriques en CSS ou SVG

Fonctions quadratiques et polynomiales

Les fonctions quadratiques (f(x) = ax² + bx + c) et d'autres polynômes de degré supérieur permettent de modéliser des comportements plus complexes comme des accélérations, des trajectoires ou des courbes d'animation avancées.
Animation avec easing quadratique
// Fonction d'easing quadratique
function easeInQuad(t: number): number {
  return t * t;
}

// Fonction d'easing cubique
function easeInOutCubic(t: number): number {
  return t < 0.5
    ? 4 * t * t * t
    : 1 - Math.pow(-2 * t + 2, 3) / 2;
}

// Utilisation dans un composant React
const QuadraticAnimation: React.FC = () => {
  // ... code similaire à l'exemple précédent
  const updateAnimation = (timestamp: number) => {
    // ...
    
    // Application de l'easing à une valeur linéaire
    const linearProgress = elapsed / duration; // 0 à 1
    const easedProgress = easeInOutCubic(linearProgress);
    
    // Calculer la position avec l'easing appliqué
    setPosition(startPosition + (endPosition - startPosition) * easedProgress);
    
    // ...
  };
  
  // ...
};

3. Fonctions trigonométriques

Les fonctions trigonométriques comme le sinus et le cosinus sont essentielles pour créer des mouvements circulaires, des oscillations et des ondes. En React et React Native, elles sont particulièrement utiles pour les animations et les visualisations.
π/2 π 3π/2 2π sin(x) cos(x) Fonctions trigonométriques

Application en animation

Animation d'oscillation avec sin()
import React, { useEffect, useState } from 'react';
import { View, Animated, StyleSheet } from 'react-native';

const OscillatingComponent: React.FC = () => {
  // Création d'une valeur animée
  const animatedValue = React.useRef(new Animated.Value(0)).current;
  
  useEffect(() => {
    // Animation en boucle infinie
    Animated.loop(
      Animated.timing(animatedValue, {
        toValue: 1,
        duration: 2000,
        useNativeDriver: true,
      })
    ).start();
  }, []);
  
  // Fonction de mappage pour transformer la valeur animée en sinus
  const translateX = animatedValue.interpolate({
    inputRange: [0, 0.25, 0.5, 0.75, 1],
    // Utilisation des valeurs clés du sinus pour l'interpolation
    outputRange: [0, 100, 0, -100, 0],
  });
  
  return (
    <View style={styles.container}>
      <Animated.View
        style={[
          styles.box,
          {
            transform: [{ translateX }],
          },
        ]}
      />
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  box: {
    width: 50,
    height: 50,
    backgroundColor: '#EFB93D',
    borderRadius: 5,
  },
});
Applications pratiques des fonctions trigonométriques :
  • Mouvements circulaires ou elliptiques
  • Animations de rebond naturelles
  • Visualisations de données cycliques
  • Calculs géométriques (distances, angles, rotations)
  • Création d'ondes sonores ou visuelles

4. Fonctions exponentielles et logarithmiques

Les fonctions exponentielles (f(x) = aˣ) et logarithmiques (f(x) = log_a(x)) sont essentielles pour modéliser la croissance ou décroissance rapide et pour créer des échelles non linéaires.

Applications en UX/UI

Fonction de zoom exponentiel
// Fonction de zoom exponentiel pour une carte
function calculateZoomLevel(pinchScale: number): number {
  // Base de l'exponentielle
  const base = 2;
  
  // Niveau de zoom actuel
  const currentZoom = 10;
  
  // Applique la transformation exponentielle
  return currentZoom * Math.pow(base, pinchScale - 1);
}

// Utilisation dans un gestionnaire d'événements de pincement
const handlePinch = (event: GestureResponderEvent) => {
  const { scale } = event.nativeEvent;
  const newZoom = calculateZoomLevel(scale);
  
  // Mettre à jour le niveau de zoom de la carte
  mapRef.current?.setZoom(newZoom);
};

Croissance logarithmique pour les performances

Les algorithmes et structures de données optimisées utilisent souvent des principes logarithmiques pour améliorer les performances. Par exemple, la recherche binaire opère en temps logarithmique O(log n).
Recherche binaire en TypeScript
// Implémentation de la recherche binaire
function binarySearch<T>(array: T[], target: T, compareFn: (a: T, b: T) => number): number {
  let left = 0;
  let right = array.length - 1;
  
  while (left <= right) {
    // Calcul du milieu (évite les dépassements d'entiers)
    const mid = left + Math.floor((right - left) / 2);
    
    const comparison = compareFn(array[mid], target);
    
    if (comparison === 0) {
      return mid; // Élément trouvé
    } else if (comparison < 0) { left = mid + 1; // Chercher dans la moitié droite } else { right = mid - 1; // Chercher dans la moitié gauche } } return -1; // Élément non trouvé } // Exemple d'utilisation const numbers = [1, 3, 5, 7, 9, 11, 13, 15]; const index = binarySearch(numbers, 7, (a, b) => a - b);
console.log(index); // 3

5. Fonctions d'arrondi et planchers

Les fonctions d'arrondi sont essentielles pour gérer les valeurs décimales, l'affichage et les calculs de précision. TypeScript et JavaScript offrent plusieurs méthodes d'arrondi dans l'objet Math.
Fonctions d'arrondi en TypeScript
// Arrondi au plus proche
Math.round(4.3); // 4
Math.round(4.5); // 5

// Arrondi vers le bas (floor)
Math.floor(4.9); // 4

// Arrondi vers le haut (ceiling)
Math.ceil(4.1); // 5

// Troncature (supprime la partie décimale)
Math.trunc(4.9); // 4
Math.trunc(-4.9); // -4

// Arrondir à une précision spécifique
function roundToDecimalPlaces(value: number, places: number): number {
  const factor = Math.pow(10, places);
  return Math.round(value * factor) / factor;
}

console.log(roundToDecimalPlaces(3.14159, 2)); // 3.14

Applications pratiques

Utilisations courantes des fonctions d'arrondi :
  • Gestion de la monnaie et des calculs financiers
  • Alignement d'éléments sur une grille en pixels entiers
  • Mise à l'échelle proportionnelle des images
  • Statistiques et traitement des données

6. Fonctions conditionnelles

Les fonctions conditionnelles mathématiques (comme la fonction de Heaviside ou la fonction valeur absolue) ont leurs équivalents directs en programmation avec les structures conditionnelles.
Implémentation de fonctions conditionnelles
// Fonction de Heaviside (fonction échelon unitaire)
function heaviside(x: number): number {
  return x >= 0 ? 1 : 0;
}

// Fonction valeur absolue
function absolute(x: number): number {
  return x >= 0 ? x : -x;
  // Équivalent à Math.abs(x)
}

// Fonction partie entière
function floor(x: number): number {
  return Math.floor(x);
}

// Fonction partie fractionnaire
function fractionalPart(x: number): number {
  return x - Math.floor(x);
}

// Fonction min et max
function clamp(value: number, min: number, max: number): number {
  return Math.min(Math.max(value, min), max);
}

À Retenir

  • Fonctions comme abstraction : Les fonctions en mathématiques et en programmation partagent le même concept fondamental de transformation d'entrées en sorties, ce qui facilite la résolution de problèmes complexes.
  • Types de fonctions : Comprendre les différentes familles de fonctions (linéaires, polynomiales, trigonométriques, exponentielles) permet d'implémenter des solutions élégantes et efficaces.
  • Composition : La capacité à composer des fonctions ensemble est une compétence puissante tant en mathématiques qu'en développement React/TypeScript.
  • Applications pratiques : Les animations, les calculs de layout, les algorithmes et les visualisations de données bénéficient tous d'une bonne maîtrise des concepts mathématiques.
  • Optimisation : La connaissance des propriétés mathématiques des fonctions permet d'optimiser les performances des applications.