Gemini 4 Neon : tarifs API, niveaux de réflexion, Cursor et Copilot
Configurez Gemini 4 Neon dans Gemini API, Cursor ou GitHub Copilot. Comparez les tarifs officiels par jeton, les coûts des entrées en cache, les niveaux de réflexion et les résultats de CursorBench 4.1. Découvrez les changements nécessaires pour migrer depuis Hydrogen, Carbon, Gemini 3.1 Pro Preview et Gemini 3.8 Flash.
Sommaire

Pour utiliser Gemini 4 Neon en programmation, commencez par l’identifiant de modèle gemini-4-neon. Google l’a lancé le 18 novembre 2026 et l’a rendu généralement disponible pour les projets Gemini API payants. Vous pouvez également le sélectionner dans Cursor et GitHub Copilot, mais ces outils appliquent leurs propres conditions d’accès et de facturation.
Le tarif Standard de l’API est de $3 par million de jetons en entrée et de $15 par million de jetons en sortie. Les entrées en cache coûtent $0.15 par million de jetons. Neon utilise high comme niveau de réflexion par défaut, contrairement à Carbon, qui utilise medium.
Ce guide explique comment connecter Neon, choisir un niveau de réflexion, estimer les coûts et migrer une intégration Gemini existante.
1. Où pouvez-vous utiliser Gemini 4 Neon ?
L’identifiant officiel du modèle est gemini-4-neon. Google a annoncé sa disponibilité générale le 18 novembre 2026.
Neon se positionne entre Gemini 4 Hydrogen et Gemini 4 Carbon. Il cible l’ingénierie logicielle complexe, le débogage de plusieurs fichiers, la refactorisation de dépôts, les tâches de connaissance et le raisonnement scientifique.
Sa disponibilité dépend du produit et de l’abonnement.
| Produit | Disponibilité | Conditions d’accès |
|---|---|---|
| Gemini API | Disponibilité générale | Offre API payante |
| Google AI Studio | Disponible | Accès API payant ; les abonnés Google AI Pro et Ultra peuvent également essayer Neon |
| Android Studio | Disponible via Gemini API | Offre API payante |
| Google Antigravity | Déploiement progressif | Abonnement Google AI Pro ou Ultra |
| Application Gemini | Déploiement progressif | Abonnement Google AI Pro ou Ultra |
| Gemini for business | Disponible via l’API et le sélecteur de modèles | Accès professionnel éligible |
| GitHub Copilot | Disponibilité générale, déploiement progressif | Pro+, Max, Business, Enterprise |
| Cursor | Disponible | Offre éligible et facturation des modèles tiers |
Google a également annoncé que les membres éligibles du Fairwind Program commenceraient à recevoir l’accès dans les jours suivant l’annonce. Il s’agit d’un accès distinct, réservé aux participants répondant aux critères du programme de cybersécurité.
Distinguez Gemini API de Gemini Enterprise Agent Platform de Google Cloud. La documentation de cette dernière plateforme réserve l’accès aux entreprises vérifiées dans certaines régions. Cette restriction ne constitue pas une limitation géographique générale de l’API publique Gemini Developer.
Consultez l’annonce de lancement de Google et les notes de version de Gemini API.
Accès via GitHub Copilot
GitHub a annoncé la disponibilité de Neon le 18 novembre.
Vous pouvez le sélectionner dans le menu des modèles de :
- Visual Studio Code et Visual Studio
- Copilot CLI
- GitHub Copilot coding agent
- L’application GitHub Copilot et github.com
- GitHub Mobile
- Les IDE JetBrains
- Xcode et Eclipse
Les offres éligibles sont Copilot Pro+, Max, Business et Enterprise.
La facturation dépend de l’utilisation et suit le tarif public du fournisseur du modèle. Ne supposez pas que la sélection de Neon consomme uniquement le quota habituellement inclus dans votre abonnement.
Les administrateurs Business et Enterprise peuvent contrôler l’accès depuis la politique des modèles dans les paramètres Copilot. Si Neon n’apparaît pas, vérifiez le déploiement progressif et la politique de votre organisation avant de changer de compte.
Consultez l’annonce officielle de GitHub Copilot.
Sélection et facturation dans Cursor
Cursor répertorie l’identifiant exact gemini-4-neon.
Ouvrez le sélecteur de modèles dans votre chat ou votre panneau Agent, puis choisissez Gemini 4 Neon. Vous pouvez aussi appuyer sur Cmd Ctrl + / pour parcourir les modèles disponibles. Votre sélection reste active d’une conversation à l’autre jusqu’à ce que vous la changiez.
La documentation actuelle de Cursor indique que les modèles tiers sont accessibles avec les offres Premium et supérieures, Teams, Enterprise, ainsi que les anciennes offres Pro, Pro+ et Ultra. Les offres Free et Plus comprennent uniquement les modèles propres à Cursor.
Après avoir sélectionné Neon, vérifiez le sélecteur situé en haut du panneau de chat. Il affiche le modèle actif. Si vous choisissez Auto, le routeur peut sélectionner un autre modèle pour certaines requêtes.
Neon est un modèle tiers. Son utilisation ne fait pas partie du quota inclus dans les offres Cursor.
Cursor documente deux modes de facturation :
- The X Subscription : l’utilisation de Neon est déduite du crédit prépayé.
- Anciennes offres Cursor : l’utilisation est déduite du pool Other Models.
Les tarifs publiés par million de jetons sont les suivants :
| Type de jeton | Prix |
|---|---|
| Entrée | $3.00 |
| Écriture dans le cache | Non indiqué |
| Lecture du cache | $0.15 |
| Sortie | $15.00 |
Vérifiez votre offre Cursor actuelle avant d’utiliser Neon. L’accès aux modèles tiers et le quota inclus dans l’abonnement sont deux droits distincts.
Cursor indique également une fenêtre de contexte de 200K et un contexte maximal de 1M pour Neon. Ce sont les limites documentées par Cursor. Ne les confondez pas avec la fenêtre de contexte unifiée de 1,048,576 jetons de l’API Google.
Consultez la documentation Cursor sur Gemini 4 Neon et les instructions de sélection des modèles.
2. Combien coûte Gemini 4 Neon ?
Au 19 novembre 2026, les tarifs Standard de Gemini API publiés par Google sont les suivants :
| Élément facturé | Prix par 1M jetons |
|---|---|
| Entrée | $3.00 |
| Sortie, y compris les jetons de réflexion | $15.00 |
| Entrée mise en cache implicitement | $0.15 |
| Mise en cache explicite du contexte | Non prise en charge |
Neon ne dispose pas d’offre Free.
Google facture chaque jeton traité par le modèle. Cela inclut les jetons de réflexion. Avec le grounding, les instructions système internes des outils et les déclarations de fonctions sont également facturées.
Le tarif de $0.15 pour les entrées en cache représente une réduction de 95% par rapport au tarif d’entrée standard. Cette réduction s’applique aux accès réussis au cache implicite répondant aux conditions requises, notamment aux préfixes de prompt partagés d’au moins 4,096 jetons. Elle ne concerne pas les caches explicites créés manuellement.
Comparaison de Neon avec Carbon et Hydrogen
Les trois modèles répondent à des besoins différents.
| Modèle | Entrée / 1M | Sortie / 1M | Niveau de réflexion par défaut |
|---|---|---|---|
| Gemini 4 Hydrogen | $1.50 | $7.50 | high |
| Gemini 4 Neon | $3.00 | $15.00 | high |
| Gemini 4 Carbon | $2.00 jusqu’au 30 novembre ; $4.00 à partir du 1er décembre | $10.00 jusqu’au 30 novembre ; $20.00 à partir du 1er décembre | medium |
Tous ces tarifs correspondent à l’offre payante Standard.
Le tarif de lancement de Carbon prend fin le 30 novembre 2026. Son tarif normal entre en vigueur le 1er décembre. Neon ne bénéficie d’aucun tarif de lancement.
Hydrogen reste le choix le moins cher pour la programmation courante. Neon coûte davantage, mais offre un raisonnement plus approfondi pour les tâches d’ingénierie complexes et répétées. Carbon reste adapté aux problèmes les plus difficiles d’architecture, de science, de débogage et de sécurité.
Pour une analyse détaillée des coûts, consultez les tarifs de l’API Gemini 4 Carbon et son guide de migration.
Exemple : estimer le coût d’une requête de programmation
Supposons qu’une requête consomme :
- 100,000 jetons d’entrée sans cache
- 20,000 jetons de sortie, réflexion comprise
- Aucun coût supplémentaire de grounding
Le calcul au tarif Standard est le suivant :
| Élément | Calcul | Coût |
|---|---|---|
| Entrée | 0.1 × $3 | $0.30 |
| Sortie | 0.02 × $15 | $0.30 |
| Total | $0.30 + $0.30 | $0.60 |
Si 80,000 jetons d’entrée sont déjà présents dans le cache et que l’accès au cache remplit les conditions du tarif réduit, le calcul devient :
- 20,000 jetons sans cache : $0.06
- 80,000 jetons en cache : $0.012
- Sortie : $0.30
Le total estimé passe à $0.372.
Il s’agit d’estimations illustratives, et non de tarifs fixes par requête. La consommation réelle dépend de la longueur du prompt, de la profondeur du raisonnement, des appels aux outils, des accès au cache et du contenu généré.
Neon prend également en charge Batch API et Flex inference. Leurs conditions d’exécution diffèrent de celles des requêtes synchrones Standard. Avant de choisir l’un de ces modes, consultez la page actuelle des prix de Gemini API pour vérifier les tarifs applicables.
Quel modèle choisir ?
Utilisez Hydrogen pour la programmation courante, les applications interactives et l’exécution d’agents sensibles aux coûts.
Choisissez Neon lorsque Hydrogen rencontre des difficultés avec les modifications de plusieurs fichiers ou le raisonnement complexe. Son niveau par défaut high constitue un bon point de départ.
Choisissez Carbon lorsqu’une tâche difficile nécessite des vérifications supplémentaires, notamment en architecture, en sécurité ou en recherche scientifique.
Jusqu’au 30 novembre, le tarif de lancement de Carbon est inférieur à celui de Neon. Refaites la comparaison à partir du 1er décembre, lorsque les tarifs normaux de Carbon entreront en vigueur.
3. Quel niveau de réflexion utiliser ?
Neon accepte quatre valeurs :
lowmediumhighxhigh
La valeur par défaut est high.
Le niveau de réflexion contrôle la profondeur du raisonnement, la latence et la consommation de jetons. Il ne s’agit ni d’un niveau d’abonnement ni d’un identifiant de modèle distinct.
| Niveau | Utilisation habituelle | Compromis |
|---|---|---|
low | Traitement à haut débit et chat rapide | Consommation de jetons et latence minimales |
medium | Programmation interactive, prototypage d’interfaces, appels d’outils réactifs | Réponses plus rapides et consommation réduite |
high | Programmation complexe, agents, appels d’outils, analyse multimodale | Valeur par défaut recommandée |
xhigh | Ingénierie complexe en plusieurs étapes, analyses mathématiques et scientifiques | Raisonnement plus approfondi, latence et consommation supérieures |
Commencez par high pour les tâches de programmation complexes.
Utilisez medium lorsqu’un agent interactif doit répondre plus rapidement. Essayez low pour les tâches répétitives sensibles aux coûts.
Passez à xhigh lorsque high ne suffit pas pour une tâche difficile. Ce niveau peut être utile pour les changements d’architecture impliquant plusieurs fichiers, le débogage complexe et le raisonnement scientifique.
N’utilisez pas xhigh pour chaque requête. Les jetons de réflexion supplémentaires augmentent la facture et peuvent allonger le temps de réponse.
Pourquoi Neon diffère-t-il de Carbon ?
Carbon utilise medium par défaut et accepte low, medium et high.
Neon utilise high par défaut et ajoute xhigh.
Cette différence compte lorsque vous remplacez l’identifiant de Carbon sans modifier le reste de votre application. La même requête peut consommer davantage de jetons de réflexion après la migration, car Neon commence à un niveau supérieur.
Si votre intégration Carbon utilisait explicitement medium, définissez également medium dans Neon pour conserver le même choix. Mesurez séparément la latence et la consommation réelles de Neon.
Google recommande d’évaluer les différents niveaux avec vos propres tâches et de choisir le niveau le plus bas qui répond à vos exigences de qualité.
Consultez la documentation de Google sur les niveaux de réflexion.
4. Connecter Gemini 4 Neon via l’API
Vous pouvez envoyer votre première requête avec le SDK officiel Google Gen AI et l’Interactions API.
Vous avez besoin de :
- Un compte Google ayant accès à Google AI Studio.
- Une clé Gemini API.
- Un projet disposant d’un accès payant à Gemini API.
- Le SDK Google Gen AI pour Python.
Créez une clé dans Google AI Studio. Activez la facturation payante du projet, car Neon n’est pas disponible dans l’offre Free.
Dans Bash, saisissez votre clé sans l’afficher à l’écran :
read -rs GEMINI_API_KEY && export GEMINI_API_KEY
Installez le SDK Python :
pip install --upgrade google-genai
Exécutez cette requête minimale :
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-neon",
input="Build an interactive single-file HTML token bucket rate-limiter simulator with live sliders for burst size and request traffic."
)
print(interaction.output_text)
Le SDK lit la clé API dans l’environnement. La requête spécifie gemini-4-neon et récupère le texte généré avec interaction.output_text.
Une réponse réussie confirme que la clé, le projet, le point de terminaison et l’identifiant du modèle fonctionnent ensemble.
Pour une tâche d’ingénierie plus exigeante, définissez explicitement le niveau de réflexion :
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-neon",
input="Audit this payment retry queue for race conditions and rewrite the lock acquisition logic.",
generation_config={
"thinking_level": "xhigh"
}
)
print(interaction.output_text)
La première requête vérifie la connexion. La seconde montre comment augmenter la profondeur du raisonnement.
Que faire si la réponse est tronquée ?
La fenêtre de contexte unifiée de Neon contient 1,048,576 jetons. Les jetons d’entrée, de réflexion et de sortie partagent ce budget.
La limite de sortie synchrone par défaut est de 65,536 jetons. Ce plafond s’applique à la sortie synchrone au sein de la fenêtre de contexte partagée de 1,048,576 jetons.
Le champ max_output_tokens limite le total des jetons de réflexion et de sortie générée. Si votre application existante définit une limite basse, vérifiez-la avant la migration.
Pour les tâches courantes, conservez la valeur par défaut ou omettez ce champ. Si votre application utilisait auparavant une limite de 8,192 jetons, Google recommande de supprimer cette limite codée en dur ou de la relever à 65,536.
Pour produire plus de 65,536 jetons, Google recommande l’exécution en arrière-plan avec background=True et une valeur supérieure de max_output_tokens. Le maximum est de 1,048,576 moins le nombre de jetons d’entrée.
La documentation de Google sur la génération longue recommande les versions les plus récentes du SDK Google GenAI pour poursuivre la génération côté client. Le guide Neon ne précise aucune version minimale du SDK. Consultez la documentation actuelle plutôt que de supposer une version.
Les exemples REST de l’Interactions API utilisent v1beta. Conservez cette version lorsque vous suivez les exemples REST documentés.
Consultez les instructions de Google sur la génération longue.
5. Que montrent les résultats de CursorBench 4.1 pour Neon ?
Les résultats de CursorBench 4.1 du 18 novembre 2026 placent Neon parmi les modèles les mieux classés de cette évaluation.
| Modèle et niveau d’effort | Score | Coût moyen par tâche |
|---|---|---|
| Neon Extra High | 65.4% | $10.67 |
| Neon High | 63.7% | $6.54 |
| Carbon High | 61.5% | $8.52 |
| Hydrogen Extra High | 61.4% | $8.09 |
| Fable 5.2 Max | 61.3% | $48.11 |
| Carbon Medium | 60.4% | $7.22 |
| Neon Medium | 57.7% | $3.07 |
| Hydrogen High | 57.3% | $4.57 |
Ces chiffres décrivent l’évaluation des agents de Cursor, et non un benchmark du modèle isolé.
CursorBench évalue les agents sur des tâches ambiguës impliquant plusieurs fichiers, issues de véritables sessions Cursor. Le score mesure la réussite des tâches. Le coût par tâche applique les tarifs publiés aux jetons consommés.
Cursor a mis à jour le benchmark le 18 novembre. L’entreprise a modifié les problèmes servant à évaluer le suivi des instructions et augmenté la limite de temps des agents.
Tenez compte de ces changements lorsque vous comparez les résultats avec les anciennes versions de CursorBench.
Comment interpréter les scores ?
Neon High obtient 63.7%, contre 57.3% pour Hydrogen High.
L’écart atteint 6.4 points de pourcentage dans ce benchmark.
Neon Extra High atteint 65.4%, mais son coût moyen par tâche est de $10.67. Neon High obtient 63.7% pour $6.54 par tâche.
Le raisonnement supplémentaire améliore donc le score du benchmark, mais augmente également le coût mesuré par tâche.
Dans cette évaluation précise, Neon High dépasse aussi Carbon High tout en coûtant moins cher par tâche. Cela ne prouve pas que Neon surpassera Carbon sur tous les dépôts ou toutes les tâches d’architecture.
Cursor précise que les résultats varient et que les petits écarts de score ne sont pas nécessairement statistiquement significatifs.
Utilisez ces résultats pour choisir une configuration initiale, puis testez Neon sur vos propres dépôts. Évaluez la qualité de ses tâches terminées, les modifications inutiles, les résultats des tests, la latence et la consommation réelle de jetons.
Pour une comparaison plus large des évaluations d’agents de programmation et des niveaux de réflexion, consultez Coding Agent Index v2.1 : les niveaux d’effort de Fable 5.2 et Opus 5.5.
Consultez le classement CursorBench 4.1.
6. Migrer depuis Hydrogen, Carbon ou Gemini 3
Google documente une migration relativement simple entre les modèles Gemini 4. Le principal changement concerne l’identifiant du modèle.
En revanche, une migration depuis Gemini 3 nécessite également de nettoyer les paramètres des requêtes.
Depuis Gemini 4 Hydrogen ou Carbon
Si votre application utilise déjà un modèle Gemini 4, commencez par ce changement :
model="gemini-4-neon"
Une migration de base entre modèles Gemini 4 ne nécessite aucune modification du schéma de requête.
Vérifiez votre configuration de réflexion :
- Hydrogen utilise
highpar défaut. - Carbon utilise
mediumpar défaut. - Neon utilise
highpar défaut.
Si votre application Carbon dépendait de sa valeur par défaut, définissez explicitement medium lors du premier test de migration.
Comparez ensuite les résultats avec high.
Ne supposez pas que des prompts identiques produisent la même consommation ou la même latence.
Pour une comparaison plus détaillée des coûts et du comportement de migration de Hydrogen, consultez les tarifs de l’API Gemini 4 Hydrogen et le guide de migration.
Depuis Gemini 3.1 Pro Preview ou Gemini 3.8 Flash
Google recommande gemini-4-neon comme modèle de remplacement pour gemini-3.1-pro-preview. Utilisez Carbon pour les problèmes les plus difficiles.
Lors d’une migration depuis gemini-3.8-flash ou un modèle Gemini 3 antérieur, vérifiez les changements suivants.
1. Remplacez l’identifiant du modèle.
model="gemini-4-neon"
2. Remplacez l’ancienne configuration de réflexion.
Neon accepte les valeurs suivantes :
thinking_level="low"
thinking_level="medium"
thinking_level="high"
thinking_level="xhigh"
La valeur par défaut devient high.
L’ancienne valeur minimal est rejetée. Supprimez thinking_budget et utilisez thinking_level à la place.
3. Vérifiez les limites de contexte et de sortie.
Gemini 3.8 Flash sépare son budget de 1M jetons en entrée et de 64K jetons en sortie. Neon partage une seule fenêtre de 1,048,576 jetons entre l’entrée, la réflexion et la sortie.
Neon conserve une limite de sortie de 65,536 jetons par requête. Vérifiez les limites max_output_tokens codées en dur et ajustez-les à la limite documentée si nécessaire.
4. Supprimez le cache explicite du contexte.
Neon ne prend pas en charge le cache explicite du contexte via cachedContents ou caches.create.
Supprimez les champs cached_content de vos requêtes.
Utilisez plutôt le cache implicite. Google l’applique automatiquement aux préfixes de prompt partagés d’au moins 4,096 jetons. Seuls les accès réussis à ce cache, lorsque les conditions sont remplies, bénéficient de la réduction de 95% sur les jetons d’entrée.
Placez les instructions statiques, le contexte du dépôt et la documentation réutilisable au début du prompt. Les requêtes répétées ont ainsi davantage de chances de partager un préfixe pouvant être mis en cache.
5. Supprimez les paramètres d’échantillonnage.
Supprimez les paramètres suivants :
temperature
top_p
top_k
Neon ignore les valeurs personnalisées comprises dans les plages autorisées. Les valeurs hors plage renvoient une erreur de validation 400.
Ne conservez pas ces paramètres uniquement parce que votre ancienne intégration Gemini 3 les utilisait.
6. Préservez l’état de la conversation et les signatures des outils.
Pour les sessions comportant plusieurs tours de conversation et utilisant l’Interactions API, utilisez previous_interaction_id afin de préserver l’état de la conversation.
Si votre application gère elle-même l’historique de generateContent, renvoyez à l’API les tours précédents complets du modèle et leurs thought signatures sans les modifier à chaque nouveau tour. Ne copiez pas une thought signature d’une partie functionCall parallèle vers une autre.
Dans les applications qui appellent des outils, déclarez-les avec le mécanisme natif de function calling. Ne demandez pas au modèle de produire des appels d’outils JSON personnalisés en texte brut sans avoir déclaré les outils. Le guide de migration de Google indique que cette situation peut provoquer MALFORMED_FUNCTION_CALL.
Vérifiez ces changements avant de déployer un agent existant.
Les instructions complètes figurent dans la liste de migration officielle de Google pour Gemini 4 Neon.
7. Quelle méthode d’accès choisir ?
Votre choix dépend de votre besoin : l’API native de Google, un outil de programmation existant ou un mode de facturation distinct.
| Méthode | Prérequis | À choisir lorsque |
|---|---|---|
| Google Gemini API | Compte Google, clé API et projet payant | Vous contrôlez l’application et souhaitez un accès direct à l’API |
| Google AI Studio | Accès Google AI Pro ou Ultra éligible pour essayer Neon | Vous souhaitez comparer les prompts avant l’intégration |
| Cursor | Offre éligible aux modèles tiers et crédit prépayé ou pool d’utilisation applicable | Vous travaillez déjà dans Cursor |
| GitHub Copilot | Pro+, Max, Business ou Enterprise | Votre environnement de programmation utilise déjà Copilot |
| Autres passerelles API à l’usage | Identifiant du modèle dans le catalogue et compatibilité documentée du point de terminaison | Vous souhaitez accéder aux modèles par un canal indépendant et payer selon votre consommation |
Une passerelle comme BetterToken est une plateforme multi-modèles et une couche d’accès API destinée aux particuliers, aux développeurs et aux équipes. Elle propose un accès aux modèles avec facturation à l’usage. Vérifiez l’identifiant exact du modèle et sa compatibilité avec votre outil avant de changer de point de terminaison. Ne supposez pas que Neon figure dans son catalogue.
Si vous avez besoin précisément de Neon et souhaitez contrôler le niveau de réflexion, le cache et la configuration des requêtes API, l’API Gemini payante de Google est la solution la plus directe.
Si vous préférez ne pas gérer vous-même les requêtes API, commencez par Cursor ou Copilot. Vérifiez ensuite leurs conditions distinctes de facturation des modèles tiers.
Liste de vérification finale
Avant d’utiliser Neon dans un agent de programmation en production, vérifiez les points suivants :
- L’identifiant du modèle est
gemini-4-neon. - Votre projet Gemini API utilise l’offre payante.
- Votre application peut accéder à la clé API.
- Le niveau de réflexion initial est
highou une autre valeur sélectionnée explicitement. - Votre budget tient compte des jetons de réflexion facturés au tarif de sortie.
- Votre application ne dépend plus du cache explicite du contexte.
- Vous avez supprimé les paramètres de génération non pris en charge ou ignorés.
- Votre limite de sortie synchrone tient compte des jetons de réflexion.
- Vos appels d’outils à plusieurs tours préservent l’état de conversation et les signatures nécessaires.
- Vous avez testé Neon avec vos propres tâches et vérifié que la qualité des résultats et la consommation réelle de jetons respectent vos exigences de mise en production.
Neon constitue un bon point de départ lorsque Hydrogen ne suffit pas pour les tâches de programmation complexes et que le raisonnement supplémentaire de Carbon n’est pas nécessaire. Commencez avec high, évaluez Neon sur vos propres tâches et réservez xhigh aux situations où le raisonnement supplémentaire améliore le résultat.