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
L'équivalent mathématique de ces fonctions serait :
// 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;
}
f(x) = 2xpour la fonctiondoubleg(x) = 3xpour la fonctiontripleh(x) = xpour la fonctionidentite(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.