Modéliser un ordre
Un type, des entiers plutôt que des flottants, un rang plutôt qu’une heure, et les règles qui gardent un ordre valide.
Leçon 212 min
À la fin de cette leçon
- Modéliser un ordre avec des entiers pour les prix et les quantités
- Distinguer les règles que vérifie le moteur de celles laissées à votre code
- Utiliser une union discriminée et never pour faire signaler un cas oublié
Dans cette leçon4
Un ordre semble simple : acheter ou vendre, combien, à quel prix. Les bogues se cachent dans les détails du type : un prix en flottant, une quantité négative acceptée, deux ordres arrivés « en même temps ». Cette leçon fixe un modèle d'ordre et les règles qui le gardent valide.
Ce que dit la littérature
Dans la revue de référence sur les carnets d'ordres, un ordre est un triplet : un prix, une taille et une heure de soumission (Gould et al., 2013, section 2.1). Le règlement de la BVMAC admet deux types d'ordres vers le système de cotation : l'ordre à prix limité et l'ordre au marché, qui n'a pas de prix (RG BVMAC 2025, art. 157 à 160).
Voici le type du moteur pédagogique :
export type Sens = 'achat' | 'vente'
export interface Ordre {
id: string
sens: Sens
quantite: number
limite: number | null // null : ordre au marché
rang: number // rang d'arrivée, à la place d'une heure
auteur?: string // étiquette d'affichage
}
Ordre à cours limité
Ordre qui fixe un prix maximal à l'achat ou minimal à la vente ; sa partie non exécutée reste dans le carnet.
Trois choix de conception
Un null plutôt qu'un champ type. limite: number | null encode les deux types admis en un seul champ. L'alternative est une union discriminée, plus verbeuse mais plus explicite :
type OrdreModele =
| { type: 'limite'; sens: Sens; quantite: number; limite: number }
| { type: 'marche'; sens: Sens; quantite: number }
Elle a un avantage : le jour où un troisième type arrive, le compilateur signale chaque switch incomplet. Le règlement prévoit que la BVMAC « pourra autoriser d'autres types d'ordres » (même texte).
Un rang plutôt qu'une heure. Deux ordres peuvent porter la même heure à la milliseconde près. Un compteur strictement croissant ne produit jamais d'égalité, et la priorité de temps devient une simple comparaison d'entiers. Le projet de règles de marché de 2008 prévoyait déjà « un numéro d'ordre séquentiel par titre » (Instruction n°2, 2008) ; c'est un texte ancien, cité ici pour l'idée.
Des entiers plutôt que des flottants. C'est le choix qui évite le plus de bogues.
0.1 + 0.2 === 0.3 // false : 0.30000000000000004
10_050 + 50 === 10_100 // true, toujours
Le moteur exprime prix et quantités en entiers. Pour les actions, c'est naturel : les ordres sont exprimés en monnaie locale, par titre (RG BVMAC 2025, art. 156). Les obligations sont cotées en pourcentage du nominal avec deux décimales (art. 186) : stockez-les en centièmes de point, 99,50 % devient 9950. Un montant prix × quantite reste exact tant qu'il ne dépasse pas Number.MAX_SAFE_INTEGER, environ 9 × 10¹⁵ ; au-delà, passez à bigint.
Le pas de cotation (le plus petit écart de prix admis) est fixé par instruction de la BVMAC (RG BVMAC 2025, art. 133 et 166), mais sa valeur actuelle n'a pas été trouvée. Faites-en un paramètre par titre, jamais une constante.
Les règles qui gardent un ordre valide
quantiteest un entier strictement positif ;limitevautnullou un entier strictement positif (et, plus tard, un multiple du pas) ;idest unique dans la séance ;rangcroît strictement d'un ordre au suivant.
Le moteur en vérifie une seule : la première. Envoyez-lui des ordres et comparez son verdict avec vos règles. Essayez une quantité de 0, puis 2,5, puis une limite de -3 ou de 10000,5.
Essayez 0, 2,5, -3 ou une limite vide.
Quand le moteur accepte ce que vos règles refusent, vous ne tenez pas forcément un bogue : vous tenez une décision à prendre et un test à écrire.
Suivez maintenant une saisie de formulaire jusqu'à l'objet Ordre. Deux détails à guetter : le rang attribué à l'étape 4, qui ne vaut pas 1, et la limite décimale de l'étape 5, que le moteur laisse passer.
saisie brute
formulaire envoyé
Des chaînes, pas encore un ordre
De mémoire : pourquoi un rang entier plutôt qu'une heure pour la priorité de temps ?
Plus loin
Dans la leçon Le domaine en dix objets, l'ordre n'était qu'une case de la carte. Ici, il devient un type ; trois questions restent ouvertes en production.
Valider à la frontière, une seule fois. La scène le montre : entre le formulaire et le moteur, une étape de lecture transforme des chaînes en types. Faites-en une fonction qui renvoie soit un ordre valide, soit la liste de toutes les erreurs. Le reste du code ne manipule alors que des ordres déjà valides.
import type { Ordre, Sens } from '@criee/marche'
type Resultat =
| { ok: true; ordre: Omit<Ordre, 'rang'> }
| { ok: false; erreurs: string[] }
// lireNombre : '10 100' → 10100, '2,5' → 2.5, '' → null
function lireOrdre(s: { id: string; sens: string; quantite: string; limite: string }): Resultat {
const erreurs: string[] = []
const quantite = lireNombre(s.quantite) ?? NaN
const limite = lireNombre(s.limite) // null si le champ est vide : ordre au marché
if (s.sens !== 'achat' && s.sens !== 'vente') erreurs.push('sens inconnu')
if (!Number.isInteger(quantite) || quantite <= 0) erreurs.push('quantité non entière positive')
if (limite !== null && (!Number.isInteger(limite) || limite <= 0)) erreurs.push('limite non entière positive')
return erreurs.length
? { ok: false, erreurs }
: { ok: true, ordre: { id: s.id, sens: s.sens as Sens, quantite, limite } }
}
Pas à pas, sur trois saisies fictives :
lireOrdre({ id: 'o1', sens: 'achat', quantite: '2,5', limite: '10 100,5' })renvoie{ ok: false, erreurs: ['quantité non entière positive', 'limite non entière positive'] }: les deux erreurs d'un coup, pas seulement la première.lireOrdre({ id: 'o2', sens: 'achat', quantite: '25', limite: '10 100' })renvoie un ordre limité à10100.lireOrdre({ id: 'o3', sens: 'vente', quantite: '10', limite: '' })renvoie un ordre au marché,limite: null.
Les deux autres règles (identifiant unique, rang croissant) ne se vérifient pas sur un ordre isolé : elles demandent l'état de la séance, donc leur place est dans le moteur ou dans la passerelle qui l'alimente.
Le jour où prix × quantite déborde. Les montants ci-dessous sont fictifs et volontairement extrêmes :
Number.MAX_SAFE_INTEGER // 9007199254740991
const prix = 9_000_000, quantite = 2_000_000_000
Number.isSafeInteger(prix * quantite) // false
prix * quantite + 1 === prix * quantite // true : le +1 est perdu
BigInt(prix) * BigInt(quantite) + 1n // 18000000000000001n, exact
Au-delà de MAX_SAFE_INTEGER, deux entiers voisins ont la même représentation : l'erreur est silencieuse. Un test qui vérifie Number.isSafeInteger sur chaque montant coûte une ligne.
L'union discriminée et never. Avec OrdreModele, un switch peut exiger que chaque type d'ordre soit traité :
function decrire(o: OrdreModele): string {
switch (o.type) {
case 'limite': return `limité à ${o.limite}`
case 'marche': return 'au marché'
default: {
const jamais: never = o // ne compile plus si un type d'ordre est oublié
return jamais
}
}
}
Ajoutez une troisième variante à OrdreModele : la ligne const jamais: never = o cesse de compiler, et le compilateur vous mène à chaque switch à compléter.
De mémoire : dans la scène, pourquoi l'ordre o2 reçoit-il le rang 2 ? Et, d'après la leçon précédente, combien d'exécutions peut-il produire ?
À toi de jouer
À lire ensuite : Gould et al., « Limit order books », Quantitative Finance, 2013
Une question ? Posez-la à votre enseignant, ou à un assistant IA en lui donnant le titre de cette leçon.