smart-thinking-mcp/build/utils/math-evaluator.d.ts

Un serveur MCP avancé pour le raisonnement multi-dimensionnel, adaptatif et collaboratif

/**
 * math-evaluator.ts
 *
 * Module optimisé pour la détection et l'évaluation performante d'expressions mathématiques dans un texte.
 * Utilise l'algorithme Shunting-Yard, une mise en cache des résultats, et des tables de lookup pour les opérateurs.
 */
import { CalculationVerificationResult } from '../types';
/**
 * Résultat détaillé de l'évaluation d'une expression mathématique
 */
export interface MathEvaluationResult {
    original: string;
    expressionText: string;
    result: number;
    isCorrect: boolean;
    claimedResult: number;
    confidence: number;
    context?: string;
}
/**
 * Classe utilitaire optimisée pour la détection et l'évaluation d'expressions mathématiques
 */
export declare class MathEvaluator {
    /**
     * Cache pour les expressions évaluées
     * @private
     */
    private static readonly expressionCache;
    /**
     * Types d'expressions mathématiques supportées (précompilées)
     * @private
     */
    private static readonly EXPRESSION_TYPES;
    /**
     * Expression régulière pour détecter les notations de fonctions (précompilée)
     * @private
     */
    private static readonly FUNCTION_NOTATION_REGEX;
    /**
     * Expression régulière pour extraire les revendications de résultat (précompilée)
     * @private
     */
    private static readonly CLAIMED_RESULT_REGEX;
    /**
     * Seuil de tolérance relatif pour comparer les nombres
     * @private
     */
    private static readonly RELATIVE_EPSILON;
    /**
     * Seuil de tolérance absolu minimal pour les petits nombres
     * @private
     */
    private static readonly ABSOLUTE_EPSILON;
    /**
     * Table de lookup pour la précédence des opérateurs dans l'algorithme Shunting-Yard
     * @private
     */
    private static readonly OPERATOR_PRECEDENCE;
    /**
     * Table de lookup pour l'associativité des opérateurs dans l'algorithme Shunting-Yard
     * @private
     */
    private static readonly OPERATOR_ASSOCIATIVITY;
    /**
     * Table de lookup pour les fonctions d'opération dans l'algorithme Shunting-Yard
     * @private
     */
    private static readonly OPERATOR_FUNCTIONS;
    /**
     * Détecte et évalue toutes les expressions mathématiques dans un texte
     *
     * @param text Texte à analyser
     * @returns Tableau des résultats d'évaluation pour chaque expression trouvée
     */
    static detectAndEvaluate(text: string): MathEvaluationResult[];
    /**
     * Détecte les notations de fonctions mathématiques
     * qui ne doivent pas être évaluées comme des calculs
     *
     * @param text Texte à analyser
     * @returns Tableau des notations de fonctions trouvées
     * @private
     */
    private static detectFunctionNotations;
    /**
     * Détecte et évalue les expressions séquentielles
     * (expressions avec plusieurs égalités en chaîne)
     *
     * @param text Texte à analyser
     * @param results Tableau des résultats à compléter
     * @private
     */
    private static detectSequentialExpressions;
    /**
     * Convertit une expression séquentielle en expression évaluable
     *
     * @param expr Expression à convertir
     * @returns Expression prête pour l'évaluation
     * @private
     */
    private static convertSequentialExpression;
    /**
     * Détecte et évalue les expressions d'un type spécifique dans un texte
     *
     * @param text Texte à analyser
     * @param type Type d'expression à rechercher
     * @param results Tableau des résultats à compléter
     * @private
     */
    private static detectExpressionsOfType;
    /**
     * Vérifie si une expression est une notation de fonction mathématique
     *
     * @param expr Expression à vérifier
     * @returns Vrai si c'est une notation de fonction
     * @private
     */
    private static isFunctionNotation;
    /**
     * Compare deux nombres en tenant compte des erreurs d'arrondi
     *
     * @param a Premier nombre
     * @param b Deuxième nombre
     * @returns Vrai si les nombres sont considérés égaux
     * @private
     */
    private static areNumbersEqual;
    /**
     * Convertit les résultats d'évaluation au format CalculationVerificationResult
     * utilisé par le système de vérification
     *
     * @param evaluationResults Résultats d'évaluation à convertir
     * @returns Liste des résultats de vérification de calculs
     */
    static convertToVerificationResults(evaluationResults: MathEvaluationResult[]): CalculationVerificationResult[];
    /**
     * Extrait l'expression standard à partir d'une expression complète
     *
     * @param expr Expression complète
     * @returns Expression standard
     * @private
     */
    private static extractStandardExpression;
    /**
     * Extrait l'expression avec parenthèses à partir d'une expression complète
     *
     * @param expr Expression complète
     * @returns Expression avec parenthèses
     * @private
     */
    private static extractParenthesesExpression;
    /**
     * Extrait l'expression de fonction à partir d'une expression complète
     *
     * @param expr Expression complète
     * @returns Expression de fonction
     * @private
     */
    private static extractFunctionExpression;
    /**
     * Nettoie une expression mathématique pour l'évaluation
     *
     * @param expr Expression à nettoyer
     * @returns Expression nettoyée
     * @private
     */
    private static sanitizeExpression;
    /**
     * Convertit une expression textuelle en expression mathématique
     *
     * @param textExpr Expression textuelle
     * @returns Expression mathématique
     * @private
     */
    private static convertTextToMathExpression;
    /**
     * Évalue une expression de manière sécurisée
     * Utilise la mise en cache et l'algorithme Shunting-Yard pour les expressions normales
     *
     * @param expr Expression à évaluer
     * @returns Résultat de l'évaluation
     * @private
     */
    private static safeEvaluate;
    /**
     * Évalue une expression Math.* de manière sécurisée
     *
     * @param expr Expression Math.* à évaluer
     * @returns Résultat de l'évaluation
     * @private
     */
    private static evaluateMathExpression;
    /**
     * Implémentation de l'algorithme Shunting-Yard pour l'évaluation d'expressions
     *
     * @param expr Expression à évaluer
     * @returns Résultat de l'évaluation
     * @private
     */
    private static evaluateWithShuntingYard;
}