Marchés · Dérivés · Statistiques · Automatisation

Arrêtez de trader à l'aveugle.Structurez votre approche comme un professionnel.

Maîtrisez la microstructure des marchés, analysez l'exposition des market makers et automatisez vos stratégies pour obtenir un véritable avantage statistique.

Découvrir le programme Essayer les outils

01Mécanique des marchés
02Ingénierie des dérivés
03Avantage statistique
04Exécution algorithmique

Pré-lancement 2026

3 axes majeurs que nous développons chez Axiome

01 / 03 options et futures

La dynamique des dérivés

Ne tradez plus la surface du marché, comprenez sa mécanique interne. Décodez le positionnement institutionnel via les grecques — delta, gamma — sur les contrats d'options, et maîtrisez la microstructure des contrats futures pour anticiper l'action des prix avec la précision d'un professionnel.

Voir le programme

02 / 03 stratégies quantitatives

Arbitrage statistique et spread trading

Affranchissez-vous du hasard et des simples paris directionnels. Apprenez à exploiter mathématiquement les inefficiences du marché grâce à des stratégies quantitatives avancées : pairs trading, modèles statistiques et spread trading intraday.

Voir la méthode

03 / 03 du signal au code

L'exécution quantitative et algorithmique

Remplacez l'émotion et l'hésitation par l'ingénierie logicielle. Traduisez votre avantage statistique en code. Accédez aux scripts Python et gérez l'automatisation de vos alertes de marché via webhooks.

Voir l'automatisation

Quatre lectures du même marché

Prix et niveaux, profil de gain d'une position, écart normalisé d'une paire, sensibilité au sous-jacent. Quatre angles, un seul système de décision.

from math import log, sqrt, exp, erf, pi

def ncdf(x):
return 0.5 * (1.0 + erf(x / sqrt(2.0)))

def npdf(x):
return exp(-x * x / 2.0) / sqrt(2.0 * pi)

def greeks(kind, S, K, T, r, vol):
"""Black-Scholes europeen, sans dividende."""
if T <= 0 or vol <= 0:
raise ValueError("T et vol doivent etre > 0")
sq = vol * sqrt(T)
d1 = (log(S / K) + (r + vol * vol / 2) * T) / sq
d2 = d1 - sq
disc = exp(-r * T)
if kind == "C":
price = S * ncdf(d1) - K * disc * ncdf(d2)
delta = ncdf(d1)
theta = (-S * npdf(d1) * vol / (2 * sqrt(T))
- r * K * disc * ncdf(d2)) / 365
else:
price = K * disc * ncdf(-d2) - S * ncdf(-d1)
delta = ncdf(d1) - 1.0
theta = (-S * npdf(d1) * vol / (2 * sqrt(T))
+ r * K * disc * ncdf(-d2)) / 365
gamma = npdf(d1) / (S * sq)
vega = S * npdf(d1) * sqrt(T) / 100
return dict(price=price, delta=delta, gamma=gamma,
vega=vega, theta=theta)

def payoff(legs, S):
"""P&L a l'echeance, par unite de sous-jacent."""
total = 0.0
for leg in legs:
if leg.kind == "U":
intrinsic = S
elif leg.kind == "C":
intrinsic = max(S - leg.strike, 0.0)
else:
intrinsic = max(leg.strike - S, 0.0)
total += leg.qty * leg.way * (intrinsic - leg.premium)
return total

def metrics(legs, hi, n=1600):
"""Les extremes tombent sur un strike ou un bord."""
grid = [0.0, hi] + [l.strike for l in legs if l.kind != "U"]
values = [payoff(legs, s) for s in grid if 0 <= s <= hi]
step = hi / n
slope = payoff(legs, hi) - payoff(legs, hi - step)
return dict(gain_max=max(values),
perte_max=min(values),
gain_illimite=slope > 1e-9,
perte_illimitee=slope < -1e-9)

def breakevens(legs, lo, hi, n=2000):
out, prev = [], None
for i in range(n + 1):
S = lo + (hi - lo) * i / n
v = payoff(legs, S)
if prev and (prev[1] > 0) != (v > 0):
w = abs(prev[1]) / (abs(prev[1]) + abs(v))
out.append(prev[0] + (S - prev[0]) * w)
prev = (S, v)
return outfrom math import log, sqrt, exp, erf, pi

def ncdf(x):
return 0.5 * (1.0 + erf(x / sqrt(2.0)))

def npdf(x):
return exp(-x * x / 2.0) / sqrt(2.0 * pi)

def greeks(kind, S, K, T, r, vol):
"""Black-Scholes europeen, sans dividende."""
if T <= 0 or vol <= 0:
raise ValueError("T et vol doivent etre > 0")
sq = vol * sqrt(T)
d1 = (log(S / K) + (r + vol * vol / 2) * T) / sq
d2 = d1 - sq
disc = exp(-r * T)
if kind == "C":
price = S * ncdf(d1) - K * disc * ncdf(d2)
delta = ncdf(d1)
theta = (-S * npdf(d1) * vol / (2 * sqrt(T))
- r * K * disc * ncdf(d2)) / 365
else:
price = K * disc * ncdf(-d2) - S * ncdf(-d1)
delta = ncdf(d1) - 1.0
theta = (-S * npdf(d1) * vol / (2 * sqrt(T))
+ r * K * disc * ncdf(-d2)) / 365
gamma = npdf(d1) / (S * sq)
vega = S * npdf(d1) * sqrt(T) / 100
return dict(price=price, delta=delta, gamma=gamma,
vega=vega, theta=theta)

def payoff(legs, S):
"""P&L a l'echeance, par unite de sous-jacent."""
total = 0.0
for leg in legs:
if leg.kind == "U":
intrinsic = S
elif leg.kind == "C":
intrinsic = max(S - leg.strike, 0.0)
else:
intrinsic = max(leg.strike - S, 0.0)
total += leg.qty * leg.way * (intrinsic - leg.premium)
return total

def metrics(legs, hi, n=1600):
"""Les extremes tombent sur un strike ou un bord."""
grid = [0.0, hi] + [l.strike for l in legs if l.kind != "U"]
values = [payoff(legs, s) for s in grid if 0 <= s <= hi]
step = hi / n
slope = payoff(legs, hi) - payoff(legs, hi - step)
return dict(gain_max=max(values),
perte_max=min(values),
gain_illimite=slope > 1e-9,
perte_illimitee=slope < -1e-9)

def breakevens(legs, lo, hi, n=2000):
out, prev = [], None
for i in range(n + 1):
S = lo + (hi - lo) * i / n
v = payoff(legs, S)
if prev and (prev[1] > 0) != (v > 0):
w = abs(prev[1]) / (abs(prev[1]) + abs(v))
out.append(prev[0] + (S - prev[0]) * w)
prev = (S, v)
return out

import numpy as np
import statsmodels.api as sm
from statsmodels.tsa.stattools import adfuller

def hedge_ratio(a, b):
"""Beta par moindres carres : a = alpha + beta * b."""
X = sm.add_constant(b)
return sm.OLS(a, X).fit().params[1]

def spread(a, b):
beta = hedge_ratio(a, b)
return a - beta * b, beta

def is_cointegrated(a, b, seuil=0.05):
ecart, beta = spread(a, b)
stat, pvalue, *_ = adfuller(ecart, maxlag=1)
return pvalue < seuil, stat, pvalue, beta

def zscore(ecart, fenetre=60):
mu = ecart.rolling(fenetre).mean()
sigma = ecart.rolling(fenetre).std(ddof=1)
return (ecart - mu) / sigma

def demi_vie(ecart):
"""Vitesse de retour a la moyenne, AR(1)."""
lag = ecart.shift(1).dropna()
delta = ecart.diff().dropna()
phi = sm.OLS(delta, sm.add_constant(lag)).fit().params[1]
if phi >= 0:
return np.inf
return -np.log(2) / np.log(1 + phi)

def signaux(z, entree=2.0, sortie=0.0, stop=3.0):
position = 0
for t, valeur in z.items():
if position == 0 and abs(valeur) >= entree:
position = -1 if valeur > 0 else 1
yield t, "ENTREE", position
elif position and abs(valeur) >= stop:
position = 0
yield t, "STOP", 0
elif position and valeur * position >= sortie:
position = 0
yield t, "SORTIE", 0

def taille_position(capital, risque_pct, perte_max_unitaire):
"""La taille vient du stop, jamais de la prime."""
if perte_max_unitaire <= 0:
raise ValueError("perte maximale inconnue")
budget = capital * risque_pct / 100.0
return int(budget // perte_max_unitaire)

def envoyer_alerte(url, payload, timeout=5):
import requests
reponse = requests.post(url, json=payload, timeout=timeout)
reponse.raise_for_status()
journal.append(dict(horodatage=now(), **payload))
return reponse.status_codeimport numpy as np
import statsmodels.api as sm
from statsmodels.tsa.stattools import adfuller

def hedge_ratio(a, b):
"""Beta par moindres carres : a = alpha + beta * b."""
X = sm.add_constant(b)
return sm.OLS(a, X).fit().params[1]

def spread(a, b):
beta = hedge_ratio(a, b)
return a - beta * b, beta

def is_cointegrated(a, b, seuil=0.05):
ecart, beta = spread(a, b)
stat, pvalue, *_ = adfuller(ecart, maxlag=1)
return pvalue < seuil, stat, pvalue, beta

def zscore(ecart, fenetre=60):
mu = ecart.rolling(fenetre).mean()
sigma = ecart.rolling(fenetre).std(ddof=1)
return (ecart - mu) / sigma

def demi_vie(ecart):
"""Vitesse de retour a la moyenne, AR(1)."""
lag = ecart.shift(1).dropna()
delta = ecart.diff().dropna()
phi = sm.OLS(delta, sm.add_constant(lag)).fit().params[1]
if phi >= 0:
return np.inf
return -np.log(2) / np.log(1 + phi)

def signaux(z, entree=2.0, sortie=0.0, stop=3.0):
position = 0
for t, valeur in z.items():
if position == 0 and abs(valeur) >= entree:
position = -1 if valeur > 0 else 1
yield t, "ENTREE", position
elif position and abs(valeur) >= stop:
position = 0
yield t, "STOP", 0
elif position and valeur * position >= sortie:
position = 0
yield t, "SORTIE", 0

def taille_position(capital, risque_pct, perte_max_unitaire):
"""La taille vient du stop, jamais de la prime."""
if perte_max_unitaire <= 0:
raise ValueError("perte maximale inconnue")
budget = capital * risque_pct / 100.0
return int(budget // perte_max_unitaire)

def envoyer_alerte(url, payload, timeout=5):
import requests
reponse = requests.post(url, json=payload, timeout=timeout)
reponse.raise_for_status()
journal.append(dict(horodatage=now(), **payload))
return reponse.status_code

L'importance du flux d'options

Chaque jour, des milliers d'ordres passent sur le flux : il est donc nécessaire de savoir l'interpréter. Ces dernières années, le marché des options a fondamentalement changé.
Il est devenu le moteur principal de l'action des prix sur les marchés sous-jacents (actions, contrats à terme).

Flux d'options Calls / Puts — Haussier / Baissier — Prime min. 50 k€

Heure	Valeur	Titre	Spot	Strike	C/P	Échéance	Exéc.	Type	Prix	Taille	Conviction	Volume	Positions

Données simulées Aucune donnée de marché réelle. Ordres générés pour l'exercice, primes cotées par le modèle du site. Plus récent en haut

Ce que le flux dit, et ce qu'il ne dit pas

Ce qu'on peut lire

Le montant engagé, donc le sérieux de l'ordre. Le point mort, donc le mouvement nécessaire pour que l'acheteur gagne. Un sweep balaie plusieurs places d'un coup : quelqu'un accepte de payer plus cher pour être exécuté tout de suite. Un bloc est négocié de gré à gré, souvent par une institution.

Ce qu'on ne peut pas lire

Un gros achat de calls peut être une couverture sur une position vendeuse, le roulement d'une position existante, ou une jambe d'une structure à quatre pattes dont on ne voit qu'un morceau. Le flux ne dit jamais l'intention, et c'est la raison pour laquelle il ne constitue pas un signal.

Alternative sans code

La boîte à outils TradingView

Vous préférez rester sur des outils simples, directement intégrés à vos graphiques ? Accédez à nos indicateurs propriétaires en Pine Script™ pour visualiser la véritable dynamique du marché et lire les graphiques avec précision.

Voir les indicateurs

Pine Script™ est une marque de TradingView. Aucune affiliation.

Le mémo gratuit

« Options et futures : les 10 vérifications avant d'ouvrir une position » — un PDF de deux pages avec la checklist d'entrée, le tableau des grecques et les pièges classiques du débutant.

Laissez votre e-mail et recevez-le tout de suite. Pas de spam : quelques messages par mois, désinscription en un clic.

Prêt à structurer votre approche ?

Commencez par les fondations : comment se forment les prix, qui fournit la liquidité, et ce qu'est réellement un contrat. Les stratégies avancées viendront après, et elles tiendront.

Voir le programme complet Poser une question

Formation exclusivement pédagogique. Ni conseil en investissement, ni recommandation personnalisée, ni signal. Les produits dérivés comportent un risque de perte en capital pouvant dépasser le montant investi. Avertissement complet.