Aller au contenu
Criée

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

  • quantite est un entier strictement positif ;
  • limite vaut null ou un entier strictement positif (et, plus tard, un multiple du pas) ;
  • id est unique dans la séance ;
  • rang croî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.

Envoyez un ordre au moteurcarnet : vente 10 × 10 000, achat 10 × 9 900

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.

La naissance d’un ordre1/5

saisie brute

{
sens: 'achat'
quantite: '2,5'
limite: '10 100'
}

formulaire envoyé

Des chaînes, pas encore un ordre

Un formulaire envoie du texte. Tant qu’il n’est pas lu et validé, ce n’est pas un objet du domaine.

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 :

  1. 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.
  2. lireOrdre({ id: 'o2', sens: 'achat', quantite: '25', limite: '10 100' }) renvoie un ordre limité à 10100.
  3. 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

Comment stocker un prix d'obligation coté 99,50 % ?

1Comment stocker un prix d'obligation coté 99,50 % ?

Dans le type Ordre du moteur, limite vaut null pour...

2Dans le type Ordre du moteur, limite vaut null pour...

Quelle règle le moteur pédagogique vérifie-t-il lui-même ?

3Quelle règle le moteur pédagogique vérifie-t-il lui-même ?

Le pas de cotation actuel de la BVMAC est...

4Le pas de cotation actuel de la BVMAC est...

Que renvoie lireOrdre pour une quantité « 2,5 » et une limite « 10 100,5 » ?

5Que renvoie lireOrdre pour une quantité « 2,5 » et une limite « 10 100,5 » ?

Pourquoi écrire const jamais: never = o dans le default ?

6Pourquoi écrire const jamais: never = o dans le default ?

À 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.

Partager :WhatsAppLinkedIn

Pour aller plus loin