index.js

// nekomaths/index.js

/**
 * Nekomaths - Un package de fonctions mathématiques simples et utiles.
 * Développé par nekoclem.
 */

/**
 * Additionne deux nombres.
 * @param {number} a - Le premier nombre.
 * @param {number} b - Le deuxième nombre.
 * @returns {number} La somme des deux nombres.
 * @throws {Error} Si les arguments ne sont pas des nombres.
 */
function nekadd(a, b) {
    if (typeof a !== 'number' || typeof b !== 'number') {
        throw new Error('nekadd: Les arguments doivent être des nombres.');
    }
    return a + b;
}

/**
 * Soustrait le deuxième nombre du premier.
 * @param {number} a - Le nombre duquel soustraire.
 * @param {number} b - Le nombre à soustraire.
 * @returns {number} Le résultat de la soustraction.
 * @throws {Error} Si les arguments ne sont pas des nombres.
 */
function neksub(a, b) {
    if (typeof a !== 'number' || typeof b !== 'number') {
        throw new Error('neksub: Les arguments doivent être des nombres.');
    }
    return a - b;
}

/**
 * Multiplie deux nombres.
 * @param {number} a - Le premier nombre.
 * @param {number} b - Le deuxième nombre.
 * @returns {number} Le produit des deux nombres.
 * @throws {Error} Si les arguments ne sont pas des nombres.
 */
function nekmult(a, b) {
    if (typeof a !== 'number' || typeof b !== 'number') {
        throw new Error('nekmult: Les arguments doivent être des nombres.');
    }
    return a * b;
}

/**
 * Divise le premier nombre par le deuxième.
 * @param {number} a - Le nombre à diviser.
 * @param {number} b - Le diviseur.
 * @returns {number} Le résultat de la division.
 * @throws {Error} Si les arguments ne sont pas des nombres ou si le diviseur est zéro.
 */
function nekdiv(a, b) {
    if (typeof a !== 'number' || typeof b !== 'number') {
        throw new Error('nekdiv: Les arguments doivent être des nombres.');
    }
    if (b === 0) {
        throw new Error('nekdiv: Division par zéro impossible.');
    }
    return a / b;
}

/**
 * Vérifie si un nombre est pair ou impair et retourne une chaîne de caractères en français.
 * @param {number} number - Le nombre à vérifier.
 * @returns {string} Une chaîne de caractères indiquant si le nombre est pair ou impair.
 * @throws {Error} Si l'argument n'est pas un nombre.
 */
function nekIsPairOuImpair(number) {
    if (typeof number !== 'number') {
        throw new Error('nekIsPairOuImpair: L\'argument doit être un nombre.');
    }
    // Gérer les nombres décimaux qui pourraient avoir un modulo non entier
    if (!Number.isInteger(number)) {
        return `Le nombre ${number} n'est pas un entier. Il n'est ni pair ni impair.`;
    }
    if (number % 2 === 0) {
        return `Le nombre ${number} est pair.`;
    } else {
        return `Le nombre ${number} est impair.`;
    }
}

/**
 * Génère un nombre entier aléatoire entre deux bornes (min et max incluses).
 * @param {number} min - La borne inférieure (incluse).
 * @param {number} max - La borne supérieure (incluse).
 * @returns {number} Un nombre entier aléatoire.
 * @throws {Error} Si les arguments ne sont pas des nombres ou si min est supérieur à max.
 */
function nekorandom(min, max) {
    if (typeof min !== 'number' || typeof max !== 'number') {
        throw new Error('nekorandom: Les arguments min et max doivent être des nombres.');
    }
    if (min > max) {
        throw new Error('nekorandom: La valeur min ne peut pas être supérieure à max.');
    }

    const ceilMin = Math.ceil(min);
    const floorMax = Math.floor(max);

    return Math.floor(Math.random() * (floorMax - ceilMin + 1)) + ceilMin;
}

// --- NOUVELLES FONCTIONS AJOUTÉES ---

/**
 * Retourne le n-ième nombre de la séquence de Fibonacci.
 * @param {number} n - L'index du nombre de Fibonacci à retourner (n >= 0).
 * @returns {number} Le n-ième nombre de Fibonacci.
 * @throws {Error} Si l'argument n'est pas un entier non négatif.
 */
function nekofibona(n) {
    if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {
        throw new Error('nekofibona: L\'argument doit être un entier non négatif.');
    }
    if (n === 0) return 0;
    if (n === 1) return 1;

    let a = 0, b = 1;
    for (let i = 2; i <= n; i++) {
        let temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

/**
 * Vérifie si un nombre entier est premier.
 * @param {number} number - Le nombre à vérifier.
 * @returns {boolean} True si le nombre est premier, false sinon.
 * @throws {Error} Si l'argument n'est pas un entier.
 */
function nekpremier(number) {
    if (typeof number !== 'number' || !Number.isInteger(number)) {
        throw new Error('nekpremier: L\'argument doit être un entier.');
    }
    if (number <= 1) return false;
    if (number <= 3) return true; // 2 et 3 sont premiers
    if (number % 2 === 0 || number % 3 === 0) return false; // Optimisation pour les multiples de 2 et 3

    // Vérifie les diviseurs à partir de 5, en sautant les multiples de 2 et 3
    for (let i = 5; i * i <= number; i = i + 6) {
        if (number % i === 0 || number % (i + 2) === 0)
            return false;
    }
    return true;
}

/**
 * Fournit des constantes mathématiques liées à Pi.
 */
const nekopi = {
    /**
     * La valeur de Pi (Math.PI).
     * @type {number}
     */
    valeur: Math.PI,

    /**
     * Calcule la circonférence d'un cercle.
     * @param {number} rayon - Le rayon du cercle.
     * @returns {number} La circonférence.
     * @throws {Error} Si l'argument n'est pas un nombre positif.
     */
    circonference: function(rayon) {
        if (typeof rayon !== 'number' || rayon < 0) {
            throw new Error('nekopi.circonference: Le rayon doit être un nombre positif.');
        }
        return 2 * Math.PI * rayon;
    },

    /**
     * Calcule l'aire d'un cercle.
     * @param {number} rayon - Le rayon du cercle.
     * @returns {number} L'aire.
     * @throws {Error} Si l'argument n'est pas un nombre positif.
     */
    aireCercle: function(rayon) {
        if (typeof rayon !== 'number' || rayon < 0) {
            throw new Error('nekopi.aireCercle: Le rayon doit être un nombre positif.');
        }
        return Math.PI * rayon * rayon;
    },

    /**
     * Convertit des degrés en radians.
     * @param {number} degres - La valeur en degrés.
     * @returns {number} La valeur en radians.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    degresEnRadians: function(degres) {
        if (typeof degres !== 'number') {
            throw new Error('nekopi.degresEnRadians: L\'argument doit être un nombre.');
        }
        return degres * (Math.PI / 180);
    },

    /**
     * Convertit des radians en degrés.
     * @param {number} radians - La valeur en radians.
     * @returns {number} La valeur en degrés.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    radiansEnDegres: function(radians) {
        if (typeof radians !== 'number') {
            throw new Error('nekopi.radiansEnDegres: L\'argument doit être un nombre.');
        }
        return radians * (180 / Math.PI);
    }
};

/**
 * Calcule la racine carrée d'un nombre.
 * @param {number} number - Le nombre.
 * @returns {number} La racine carrée du nombre.
 * @throws {Error} Si l'argument n'est pas un nombre non négatif.
 */
function nekracine(number) {
    if (typeof number !== 'number' || number < 0) {
        throw new Error('nekracine: L\'argument doit être un nombre non négatif.');
    }
    return Math.sqrt(number);
}

/**
 * Renvoie le double d'un nombre.
 * @param {number} number - Le nombre à doubler.
 * @returns {number} Le double du nombre.
 * @throws {Error} Si l'argument n'est pas un nombre.
 */
function nekodouble(number) {
    if (typeof number !== 'number') {
        throw new Error('nekodouble: L\'argument doit être un nombre.');
    }
    return number * 2;
}

/**
 * Renvoie la moitié d'un nombre.
 * @param {number} number - Le nombre à diviser par deux.
 * @returns {number} La moitié du nombre.
 * @throws {Error} Si l'argument n'est pas un nombre.
 */
function nekomoitie(number) {
    if (typeof number !== 'number') {
        throw new Error('nekomoitie: L\'argument doit être un nombre.');
    }
    return number / 2;
}

/**
 * Fonctions pour les calculs avec des degrés (angles).
 */
const nekdegres = {
    /**
     * Convertit des radians en degrés.
     * (Dupliqué de nekopi pour un accès plus direct si l'utilisateur cherche juste les degrés)
     * @param {number} radians - La valeur en radians.
     * @returns {number} La valeur en degrés.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    enDegres: function(radians) {
        if (typeof radians !== 'number') {
            throw new Error('nekdegres.enDegres: L\'argument doit être un nombre.');
        }
        return radians * (180 / Math.PI);
    },

    /**
     * Convertit des degrés en radians.
     * (Dupliqué de nekopi pour un accès plus direct si l'utilisateur cherche juste les degrés)
     * @param {number} degres - La valeur en degrés.
     * @returns {number} La valeur en radians.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    enRadians: function(degres) {
        if (typeof degres !== 'number') {
            throw new Error('nekdegres.enRadians: L\'argument doit être un nombre.');
        }
        return degres * (Math.PI / 180);
    },

    /**
     * Calcule le sinus d'un angle en degrés.
     * @param {number} degres - L'angle en degrés.
     * @returns {number} Le sinus de l'angle.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    sinus: function(degres) {
        if (typeof degres !== 'number') {
            throw new Error('nekdegres.sinus: L\'argument doit être un nombre.');
        }
        return Math.sin(this.enRadians(degres));
    },

    /**
     * Calcule le cosinus d'un angle en degrés.
     * @param {number} degres - L'angle en degrés.
     * @returns {number} Le cosinus de l'angle.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    cosinus: function(degres) {
        if (typeof degres !== 'number') {
            throw new Error('nekdegres.cosinus: L\'argument doit être un nombre.');
        }
        return Math.cos(this.enRadians(degres));
    },

    /**
     * Calcule la tangente d'un angle en degrés.
     * @param {number} degres - L'angle en degrés.
     * @returns {number} La tangente de l'angle.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    tangente: function(degres) {
        if (typeof degres !== 'number') {
            throw new Error('nekdegres.tangente: L\'argument doit être un nombre.');
        }
        return Math.tan(this.enRadians(degres));
    },

    // Vous pouvez ajouter d'autres fonctions trigonométriques inverses ou spécifiques aux triangles ici
};


/**
 * Retourne les facteurs premiers d'un nombre.
 * @param {number} number - Le nombre à factoriser.
 * @returns {Array<number>} Un tableau contenant les facteurs premiers du nombre.
 * @throws {Error} Si l'argument n'est pas un entier positif.
 */
function nekFacteurs(number) {
    if (typeof number !== 'number' || !Number.isInteger(number) || number <= 1) {
        throw new Error('nekFacteurs: L\'argument doit être un entier positif supérieur à 1.');
    }
    const facteurs = [];
    let diviseur = 2;
    
    while (number > 1) {
        while (number % diviseur === 0) {
            facteurs.push(diviseur);
            number /= diviseur;
        }
        diviseur++;
    }
    return facteurs;
}

/**
 * Calcule la puissance d'un nombre.
 * @param {number} base - La base.
 * @param {number} exposant - L'exposant.
 * @returns {number} La valeur de base élevée à exposant.
 * @throws {Error} Si les arguments ne sont pas des nombres.
 */
function nekopuissance(base, exposant) {
    if (typeof base !== 'number' || typeof exposant !== 'number') {
        throw new Error('nekopuissance: Les arguments doivent être des nombres.');
    }
    return Math.pow(base, exposant);
}

/**
 * Calcule la médiane d'un tableau de nombres.
 * @param {Array<number>} arr - Le tableau de nombres.
 * @returns {number} La médiane du tableau.
 * @throws {Error} Si l'argument n'est pas un tableau de nombres.
 */
function nekmed(arr) {
    if (!Array.isArray(arr) || arr.some(num => typeof num !== 'number')) {
        throw new Error('nekmed: L\'argument doit être un tableau de nombres.');
    }
    if (arr.length === 0) {
        throw new Error('nekmed: Le tableau ne peut pas être vide.');
    }
    const sorted = [...arr].sort((a, b) => a - b);
    const mid = Math.floor(sorted.length / 2);
    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
}

/**
 * Calcule la moyenne d'un tableau de nombres.
 * @param {Array<number>} arr - Le tableau de nombres.
 * @returns {number} La moyenne du tableau.
 * @throws {Error} Si l'argument n'est pas un tableau de nombres.
 */
function nekmoy(arr) {
    if (!Array.isArray(arr) || arr.some(num => typeof num !== 'number')) {
        throw new Error('nekmoy: L\'argument doit être un tableau de nombres.');
    }
    if (arr.length === 0) {
        throw new Error('nekmoy: Le tableau ne peut pas être vide.');
    }
    return arr.reduce((sum, num) => sum + num, 0) / arr.length;
}

/**
 * Fonctions de conversion entre mètres et kilomètres.
 */
const neky = {
    /**
     * Convertit des mètres en kilomètres.
     * @param {number} meters - La valeur en mètres.
     * @returns {number} La valeur convertie en kilomètres.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    metersToKilometers: function(meters) {
        if (typeof meters !== 'number') {
            throw new Error('neky.metersToKilometers: L\'argument doit être un nombre.');
        }
        return meters / 1000;
    },

    /**
     * Convertit des kilomètres en mètres.
     * @param {number} kilometers - La valeur en kilomètres.
     * @returns {number} La valeur convertie en mètres.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    kilometersToMeters: function(kilometers) {
        if (typeof kilometers !== 'number') {
            throw new Error('neky.kilometersToMeters: L\'argument doit être un nombre.');
        }
        return kilometers * 1000;
    }
};

/**
 * Fonctions de conversion d'unités personnalisables.
 */
const neklet = {
    /**
     * Convertit des kilos en tonnes.
     * @param {number} kilos - La valeur en kilos.
     * @returns {number} La valeur convertie en tonnes.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    kilosToTonnes: function(kilos) {
        if (typeof kilos !== 'number') {
            throw new Error('neklet.kilosToTonnes: L\'argument doit être un nombre.');
        }
        return kilos / 1000;
    },

    /**
     * Convertit des tonnes en kilos.
     * @param {number} tonnes - La valeur en tonnes.
     * @returns {number} La valeur convertie en kilos.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    tonnesToKilos: function(tonnes) {
        if (typeof tonnes !== 'number') {
            throw new Error('neklet.tonnesToKilos: L\'argument doit être un nombre.');
        }
        return tonnes * 1000;
    },

    /**
     * Convertit des grammes en kilogrammes.
     * @param {number} grams - La valeur en grammes.
     * @returns {number} La valeur convertie en kilogrammes.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    gramsToKilograms: function(grams) {
        if (typeof grams !== 'number') {
            throw new Error('neklet.gramsToKilograms: L\'argument doit être un nombre.');
        }
        return grams / 1000;
    },

    /**
     * Convertit des kilogrammes en grammes.
     * @param {number} kilograms - La valeur en kilogrammes.
     * @returns {number} La valeur convertie en grammes.
     * @throws {Error} Si l'argument n'est pas un nombre.
     */
    kilogramsToGrams: function(kilograms) {
        if (typeof kilograms !== 'number') {
            throw new Error('neklet.kilogramsToGrams: L\'argument doit être un nombre.');
        }
        return kilograms * 1000;
    },

    /**
     * Conversion personnalisée avec facteur.
     * @param {number} value - La valeur à convertir.
     * @param {number} factor - Le facteur de conversion.
     * @returns {number} La valeur convertie.
     * @throws {Error} Si les arguments ne sont pas des nombres.
     */
    customConversion: function(value, factor) {
        if (typeof value !== 'number' || typeof factor !== 'number') {
            throw new Error('neklet.customConversion: Les arguments doivent être des nombres.');
        }
        return value * factor;
    }
};

/**
 * Calcule le pourcentage d'un nombre.
 * @param {number} total - Le nombre total.
 * @param {number} pourcentage - Le pourcentage à calculer.
 * @returns {number} La valeur du pourcentage.
 * @throws {Error} Si les arguments ne sont pas des nombres.
 */
function nekpourcentage(total, pourcentage) {
    if (typeof total !== 'number' || typeof pourcentage !== 'number') {
        throw new Error('nekpourcentage: Les arguments doivent être des nombres.');
    }
    return (total * pourcentage) / 100;
}

/**
 * Fonctions en rapport avec le théorème de Pythagore.
 */
const nektalor = {
    /**
     * Calcule l'hypoténuse d'un triangle rectangle.
     * @param {number} a - Premier côté adjacent.
     * @param {number} b - Deuxième côté adjacent.
     * @returns {number} La longueur de l'hypoténuse.
     * @throws {Error} Si les arguments ne sont pas des nombres positifs.
     */
    hypotenuse: function(a, b) {
        if (typeof a !== 'number' || typeof b !== 'number' || a <= 0 || b <= 0) {
            throw new Error('nektalor.hypotenuse: Les arguments doivent être des nombres positifs.');
        }
        return Math.sqrt(a * a + b * b);
    },

    /**
     * Calcule un côté adjacent connaissant l'hypoténuse et l'autre côté.
     * @param {number} hypotenuse - L'hypoténuse.
     * @param {number} cote - Un côté adjacent.
     * @returns {number} La longueur de l'autre côté adjacent.
     * @throws {Error} Si les arguments ne sont pas des nombres positifs ou si hypoténuse <= côté.
     */
    coteAdjacent: function(hypotenuse, cote) {
        if (typeof hypotenuse !== 'number' || typeof cote !== 'number' || hypotenuse <= 0 || cote <= 0) {
            throw new Error('nektalor.coteAdjacent: Les arguments doivent être des nombres positifs.');
        }
        if (hypotenuse <= cote) {
            throw new Error('nektalor.coteAdjacent: L\'hypoténuse doit être plus grande que le côté.');
        }
        return Math.sqrt(hypotenuse * hypotenuse - cote * cote);
    }
};

/**
 * Fonctions pour le théorème de Thalès.
 */
const nektales = {
    /**
     * Calcule le quatrième terme d'une proportion de Thalès (a/b = c/x).
     * @param {number} a - Premier terme.
     * @param {number} b - Deuxième terme.
     * @param {number} c - Troisième terme.
     * @returns {number} Le quatrième terme (x).
     * @throws {Error} Si les arguments ne sont pas des nombres ou si b est zéro.
     */
    proportionnalite: function(a, b, c) {
        if (typeof a !== 'number' || typeof b !== 'number' || typeof c !== 'number') {
            throw new Error('nektales.proportionnalite: Les arguments doivent être des nombres.');
        }
        if (b === 0) {
            throw new Error('nektales.proportionnalite: Le deuxième terme ne peut pas être zéro.');
        }
        return (b * c) / a;
    },

    /**
     * Vérifie si quatre nombres forment une proportion de Thalès.
     * @param {number} a - Premier terme.
     * @param {number} b - Deuxième terme.
     * @param {number} c - Troisième terme.
     * @param {number} d - Quatrième terme.
     * @returns {boolean} True si a/b = c/d, false sinon.
     * @throws {Error} Si les arguments ne sont pas des nombres ou si b ou d sont zéro.
     */
    verifierProportionnalite: function(a, b, c, d) {
        if (typeof a !== 'number' || typeof b !== 'number' || typeof c !== 'number' || typeof d !== 'number') {
            throw new Error('nektales.verifierProportionnalite: Les arguments doivent être des nombres.');
        }
        if (b === 0 || d === 0) {
            throw new Error('nektales.verifierProportionnalite: Les dénominateurs ne peuvent pas être zéro.');
        }
        return Math.abs((a / b) - (c / d)) < 1e-10; // Tolérance pour les erreurs de flottant
    }
};

/**
 * Fonctions pour calculer des probabilités.
 */
const nekproba = {
    /**
     * Calcule la probabilité d'un événement (cas favorables / cas possibles).
     * @param {number} casFavorables - Nombre de cas favorables.
     * @param {number} casPossibles - Nombre total de cas possibles.
     * @returns {number} La probabilité (entre 0 et 1).
     * @throws {Error} Si les arguments ne sont pas des entiers positifs ou si cas favorables > cas possibles.
     */
    probabiliteSimple: function(casFavorables, casPossibles) {
        if (typeof casFavorables !== 'number' || typeof casPossibles !== 'number' || 
            !Number.isInteger(casFavorables) || !Number.isInteger(casPossibles) ||
            casFavorables < 0 || casPossibles <= 0) {
            throw new Error('nekproba.probabiliteSimple: Les arguments doivent être des entiers positifs.');
        }
        if (casFavorables > casPossibles) {
            throw new Error('nekproba.probabiliteSimple: Le nombre de cas favorables ne peut pas dépasser le nombre de cas possibles.');
        }
        return casFavorables / casPossibles;
    },

    /**
     * Calcule la probabilité inverse (1 - p).
     * @param {number} probabilite - La probabilité initiale (entre 0 et 1).
     * @returns {number} La probabilité inverse.
     * @throws {Error} Si l'argument n'est pas un nombre entre 0 et 1.
     */
    probabiliteInverse: function(probabilite) {
        if (typeof probabilite !== 'number' || probabilite < 0 || probabilite > 1) {
            throw new Error('nekproba.probabiliteInverse: L\'argument doit être un nombre entre 0 et 1.');
        }
        return 1 - probabilite;
    },

    /**
     * Calcule la probabilité de l'union de deux événements (P(A ∪ B) = P(A) + P(B) - P(A ∩ B)).
     * @param {number} probA - Probabilité de l'événement A.
     * @param {number} probB - Probabilité de l'événement B.
     * @param {number} probIntersection - Probabilité de l'intersection A ∩ B.
     * @returns {number} La probabilité de A OU B.
     * @throws {Error} Si les arguments ne sont pas des nombres entre 0 et 1.
     */
    probabiliteUnion: function(probA, probB, probIntersection = 0) {
        if (typeof probA !== 'number' || typeof probB !== 'number' || typeof probIntersection !== 'number' ||
            probA < 0 || probA > 1 || probB < 0 || probB > 1 || probIntersection < 0 || probIntersection > 1) {
            throw new Error('nekproba.probabiliteUnion: Les arguments doivent être des nombres entre 0 et 1.');
        }
        return probA + probB - probIntersection;
    }
};

/**
 * Fonction créative pour les messages personnalisés.
 */
const nekbel = {
    /**
     * Renvoie un message personnalisé avec formatage.
     * @param {string} message - Le message à afficher.
     * @param {string} style - Le style du message ('info', 'success', 'warning', 'error').
     * @returns {string} Le message formaté.
     * @throws {Error} Si les arguments ne sont pas des chaînes valides.
     */
    message: function(message, style = 'info') {
        if (typeof message !== 'string') {
            throw new Error('nekbel.message: Le message doit être une chaîne de caractères.');
        }
        const styles = {
            info: '💡 [INFO]',
            success: '✅ [SUCCÈS]',
            warning: '⚠️ [ATTENTION]',
            error: '❌ [ERREUR]'
        };
        const prefix = styles[style] || styles.info;
        return `${prefix} ${message}`;
    },

    /**
     * Exécute une fonction personnalisée avec gestion d'erreurs.
     * @param {Function} func - La fonction à exécuter.
     * @param {Array} args - Les arguments à passer à la fonction.
     * @param {string} nom - Le nom de la fonction pour les messages d'erreur.
     * @returns {*} Le résultat de la fonction ou un message d'erreur formaté.
     */
    executer: function(func, args = [], nom = 'fonction personnalisée') {
        if (typeof func !== 'function') {
            return this.message(`${nom} n'est pas une fonction valide.`, 'error');
        }
        try {
            const resultat = func.apply(null, args);
            return {
                succes: true,
                resultat: resultat,
                message: this.message(`${nom} exécutée avec succès.`, 'success')
            };
        } catch (error) {
            return {
                succes: false,
                erreur: error.message,
                message: this.message(`Erreur lors de l'exécution de ${nom}: ${error.message}`, 'error')
            };
        }
    }
};

/**
 * Fonctions créatives pour personnaliser au maximum son code.
 */
const nekcreative = {
    /**
     * Génère un identifiant unique pour les projets.
     * @param {string} prefix - Préfixe optionnel.
     * @returns {string} Un identifiant unique.
     */
    generateId: function(prefix = 'neko') {
        const timestamp = Date.now().toString(36);
        const random = Math.random().toString(36).substr(2, 5);
        return `${prefix}_${timestamp}_${random}`;
    },

    /**
     * Crée un décorateur de fonction avec timing.
     * @param {Function} func - La fonction à décorer.
     * @param {string} nom - Le nom de la fonction.
     * @returns {Function} La fonction décorée.
     */
    chronometer: function(func, nom = 'fonction') {
        return function(...args) {
            const debut = performance.now();
            const resultat = func.apply(this, args);
            const fin = performance.now();
            console.log(`⏱️ ${nom} exécutée en ${(fin - debut).toFixed(2)}ms`);
            return resultat;
        };
    },

    /**
     * Crée un cache simple pour les résultats de fonction.
     * @param {Function} func - La fonction à mettre en cache.
     * @returns {Function} La fonction avec cache.
     */
    memoize: function(func) {
        const cache = new Map();
        return function(...args) {
            const key = JSON.stringify(args);
            if (cache.has(key)) {
                console.log('🎯 Résultat récupéré du cache');
                return cache.get(key);
            }
            const resultat = func.apply(this, args);
            cache.set(key, resultat);
            return resultat;
        };
    },

    /**
     * Générateur de couleurs aléatoires.
     * @param {string} format - Format de couleur ('hex', 'rgb', 'hsl').
     * @returns {string} Une couleur aléatoire.
     */
    couleurAleatoire: function(format = 'hex') {
        switch (format) {
            case 'hex':
                return '#' + Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0');
            case 'rgb':
                const r = Math.floor(Math.random() * 256);
                const g = Math.floor(Math.random() * 256);
                const b = Math.floor(Math.random() * 256);
                return `rgb(${r}, ${g}, ${b})`;
            case 'hsl':
                const h = Math.floor(Math.random() * 361);
                const s = Math.floor(Math.random() * 101);
                const l = Math.floor(Math.random() * 101);
                return `hsl(${h}, ${s}%, ${l}%)`;
            default:
                throw new Error('nekcreative.couleurAleatoire: Format non supporté. Utilisez "hex", "rgb" ou "hsl".');
        }
    }
};

/**
 * Gestionnaire d'erreurs personnalisé pour nekomaths.
 */
const nekorror = {
    /**
     * Stockage des messages d'erreur personnalisés.
     */
    messagesPersonnalises: new Map(),

    /**
     * Définit un message d'erreur personnalisé.
     * @param {string} codeErreur - Le code d'erreur.
     * @param {string} message - Le message personnalisé.
     */
    definirMessage: function(codeErreur, message) {
        if (typeof codeErreur !== 'string' || typeof message !== 'string') {
            throw new Error('nekorror.definirMessage: Les arguments doivent être des chaînes de caractères.');
        }
        this.messagesPersonnalises.set(codeErreur, message);
    },

    /**
     * Lance une erreur avec un message personnalisé.
     * @param {string} codeErreur - Le code d'erreur.
     * @param {*} donnees - Données contextuelles optionnelles.
     * @throws {Error} L'erreur avec le message personnalisé.
     */
    lancerErreur: function(codeErreur, donnees = null) {
        const messagePersonnalise = this.messagesPersonnalises.get(codeErreur);
        let message = messagePersonnalise || `Erreur inconnue: ${codeErreur}`;
        
        if (donnees) {
            message += ` | Données: ${JSON.stringify(donnees)}`;
        }
        
        const erreur = new Error(`🚨 [NEKOMATHS] ${message}`);
        erreur.code = codeErreur;
        erreur.donnees = donnees;
        throw erreur;
    },

    /**
     * Gestionnaire d'erreur safe qui retourne un objet au lieu de lever une exception.
     * @param {Function} func - La fonction à exécuter.
     * @param {Array} args - Les arguments de la fonction.
     * @returns {Object} Objet avec succès/erreur.
     */
    executer: function(func, args = []) {
        try {
            const resultat = func.apply(null, args);
            return {
                succes: true,
                resultat: resultat,
                erreur: null
            };
        } catch (error) {
            return {
                succes: false,
                resultat: null,
                erreur: {
                    message: error.message,
                    code: error.code || 'ERREUR_INCONNUE',
                    donnees: error.donnees || null
                }
            };
        }
    },

    /**
     * Logger d'erreurs avec niveaux.
     * @param {string} niveau - Niveau de log ('debug', 'info', 'warn', 'error').
     * @param {string} message - Le message à logger.
     * @param {*} donnees - Données supplémentaires.
     */
    log: function(niveau, message, donnees = null) {
        const timestamp = new Date().toISOString();
        const niveaux = {
            debug: '🔍',
            info: 'ℹ️',
            warn: '⚠️',
            error: '💥'
        };
        
        const emoji = niveaux[niveau] || 'ℹ️';
        let logMessage = `${emoji} [${timestamp}] ${message}`;
        
        if (donnees) {
            logMessage += ` | ${JSON.stringify(donnees)}`;
        }
        
        console.log(logMessage);
    }
};

/**
 * Fonction pour dessiner des formes simples dans le terminal.
 */
const nekdraw = {
    /**
     * Dessine un rectangle dans la console.
     * @param {number} largeur - Largeur du rectangle.
     * @param {number} hauteur - Hauteur du rectangle.
     * @param {string} caractere - Caractère à utiliser pour dessiner (par défaut '*').
     * @returns {string} Le rectangle dessiné.
     */
    rectangle: function(largeur, hauteur, caractere = '*') {
        if (typeof largeur !== 'number' || typeof hauteur !== 'number' || 
            !Number.isInteger(largeur) || !Number.isInteger(hauteur) ||
            largeur <= 0 || hauteur <= 0) {
            throw new Error('nekdraw.rectangle: Largeur et hauteur doivent être des entiers positifs.');
        }
        let resultat = '';
        for (let i = 0; i < hauteur; i++) {
            for (let j = 0; j < largeur; j++) {
                resultat += caractere;
            }
            resultat += '\n';
        }
        return resultat;
    },

    /**
     * Dessine un triangle dans la console.
     * @param {number} taille - Taille du triangle.
     * @param {string} caractere - Caractère à utiliser pour dessiner (par défaut '*').
     * @returns {string} Le triangle dessiné.
     */
    triangle: function(taille, caractere = '*') {
        if (typeof taille !== 'number' || !Number.isInteger(taille) || taille <= 0) {
            throw new Error('nekdraw.triangle: La taille doit être un entier positif.');
        }
        let resultat = '';
        for (let i = 1; i <= taille; i++) {
            resultat += ' '.repeat(taille - i) + caractere.repeat(2 * i - 1) + '\n';
        }
        return resultat;
    },

    /**
     * Affiche le dessin dans la console.
     * @param {string} dessin - Le dessin à afficher.
     */
    afficher: function(dessin) {
        console.log(dessin);
    }
};

/**
 * Fonction pour arrondir des nombres décimaux.
 * @param {number} nombre - Le nombre à arrondir.
 * @param {number} decimales - Nombre de décimales (par défaut 2).
 * @returns {number} Le nombre arrondi.
 * @throws {Error} Si les arguments ne sont pas valides.
 */
function nekril(nombre, decimales = 2) {
    if (typeof nombre !== 'number' || typeof decimales !== 'number' || 
        !Number.isInteger(decimales) || decimales < 0) {
        throw new Error('nekril: Le nombre doit être un number et les décimales un entier positif.');
    }
    return Math.round(nombre * Math.pow(10, decimales)) / Math.pow(10, decimales);
}

/**
 * Fonction pour faire des calculs avec des nombres écrits en lettres anglaises.
 */
const nekocust = {
    /**
     * Dictionnaire de conversion nombres en lettres.
     */
    motsDictionnaire: {
        'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5,
        'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10,
        'eleven': 11, 'twelve': 12, 'thirteen': 13, 'fourteen': 14, 'fifteen': 15,
        'sixteen': 16, 'seventeen': 17, 'eighteen': 18, 'nineteen': 19, 'twenty': 20,
        'thirty': 30, 'forty': 40, 'fifty': 50, 'sixty': 60, 'seventy': 70,
        'eighty': 80, 'ninety': 90, 'hundred': 100, 'thousand': 1000
    },

    /**
     * Convertit un mot anglais en nombre.
     * @param {string} mot - Le mot à convertir.
     * @returns {number} Le nombre correspondant.
     * @throws {Error} Si le mot n'est pas reconnu.
     */
    motEnNombre: function(mot) {
        if (typeof mot !== 'string') {
            throw new Error('nekocust.motEnNombre: L\'argument doit être une chaîne de caractères.');
        }
        const motMinuscule = mot.toLowerCase();
        if (this.motsDictionnaire.hasOwnProperty(motMinuscule)) {
            return this.motsDictionnaire[motMinuscule];
        }
        throw new Error(`nekocust.motEnNombre: Mot "${mot}" non reconnu.`);
    },

    /**
     * Additionne deux nombres écrits en lettres anglaises.
     * @param {string} mot1 - Premier nombre en lettres.
     * @param {string} mot2 - Deuxième nombre en lettres.
     * @returns {number} La somme des deux nombres.
     */
    additionMots: function(mot1, mot2) {
        const num1 = this.motEnNombre(mot1);
        const num2 = this.motEnNombre(mot2);
        return num1 + num2;
    },

    /**
     * Soustrait deux nombres écrits en lettres anglaises.
     * @param {string} mot1 - Premier nombre en lettres.
     * @param {string} mot2 - Deuxième nombre en lettres.
     * @returns {number} La différence des deux nombres.
     */
    soustractionMots: function(mot1, mot2) {
        const num1 = this.motEnNombre(mot1);
        const num2 = this.motEnNombre(mot2);
        return num1 - num2;
    }
};

/**
 * Fonction créative pour additionner des objets personnalisés.
 */
const nekrect = {
    /**
     * Définit les types d'objets et leurs valeurs.
     */
    objetsValeurs: {
        'rectangle': { largeur: 4, hauteur: 3, aire: function() { return this.largeur * this.hauteur; } },
        'carre': { cote: 2, aire: function() { return this.cote * this.cote; } },
        'poule': { oeufs: 12, valeur: function() { return this.oeufs; } },
        'poire': { sucre: 8, valeur: function() { return this.sucre; } }
    },

    /**
     * Additionne deux objets de types différents ou similaires.
     * @param {string} objet1 - Type du premier objet.
     * @param {string} objet2 - Type du deuxième objet.
     * @param {string} propriete - Propriété à additionner ('aire' ou 'valeur').
     * @returns {number} La somme des propriétés.
     * @throws {Error} Si les objets ou la propriété ne sont pas reconnus.
     */
    additionObjets: function(objet1, objet2, propriete = 'aire') {
        if (!this.objetsValeurs[objet1] || !this.objetsValeurs[objet2]) {
            throw new Error('nekrect.additionObjets: Objets non reconnus. Utilisez: rectangle, carre, poule, poire.');
        }

        const obj1 = this.objetsValeurs[objet1];
        const obj2 = this.objetsValeurs[objet2];

        let valeur1, valeur2;

        if (propriete === 'aire' && obj1.aire) {
            valeur1 = obj1.aire();
        } else if (propriete === 'valeur' && obj1.valeur) {
            valeur1 = obj1.valeur();
        } else {
            throw new Error(`nekrect.additionObjets: Propriété "${propriete}" non disponible pour ${objet1}.`);
        }

        if (propriete === 'aire' && obj2.aire) {
            valeur2 = obj2.aire();
        } else if (propriete === 'valeur' && obj2.valeur) {
            valeur2 = obj2.valeur();
        } else {
            throw new Error(`nekrect.additionObjets: Propriété "${propriete}" non disponible pour ${objet2}.`);
        }

        return valeur1 + valeur2;
    },

    /**
     * Décrit l'opération effectuée.
     * @param {string} objet1 - Type du premier objet.
     * @param {string} objet2 - Type du deuxième objet.
     * @param {string} propriete - Propriété additionnée.
     * @returns {string} Description de l'opération.
     */
    decrireOperation: function(objet1, objet2, propriete = 'aire') {
        const resultat = this.additionObjets(objet1, objet2, propriete);
        return `Addition de ${objet1} + ${objet2} (${propriete}) = ${resultat}`;
    }
};

/**
 * Fonctions en rapport avec le théorème de Pappus.
 */
const nekpap = {
    /**
     * Calcule le volume selon le théorème de Pappus-Guldinus.
     * @param {number} aire - Aire de la section.
     * @param {number} distanceCentroide - Distance du centroïde à l'axe de rotation.
     * @returns {number} Le volume généré.
     * @throws {Error} Si les arguments ne sont pas des nombres positifs.
     */
    volumePappus: function(aire, distanceCentroide) {
        if (typeof aire !== 'number' || typeof distanceCentroide !== 'number' ||
            aire <= 0 || distanceCentroide <= 0) {
            throw new Error('nekpap.volumePappus: Les arguments doivent être des nombres positifs.');
        }
        return 2 * Math.PI * aire * distanceCentroide;
    },

    /**
     * Calcule l'aire selon le théorème de Pappus-Guldinus pour les surfaces.
     * @param {number} longueur - Longueur de la courbe.
     * @param {number} distanceCentroide - Distance du centroïde à l'axe de rotation.
     * @returns {number} L'aire générée.
     * @throws {Error} Si les arguments ne sont pas des nombres positifs.
     */
    airePappus: function(longueur, distanceCentroide) {
        if (typeof longueur !== 'number' || typeof distanceCentroide !== 'number' ||
            longueur <= 0 || distanceCentroide <= 0) {
            throw new Error('nekpap.airePappus: Les arguments doivent être des nombres positifs.');
        }
        return 2 * Math.PI * longueur * distanceCentroide;
    },

    /**
     * Calcule le centroïde d'un volume connaissant l'aire et le volume.
     * @param {number} volume - Volume généré.
     * @param {number} aire - Aire de la section.
     * @returns {number} Distance du centroïde.
     * @throws {Error} Si les arguments ne sont pas des nombres positifs.
     */
    centroideVolume: function(volume, aire) {
        if (typeof volume !== 'number' || typeof aire !== 'number' ||
            volume <= 0 || aire <= 0) {
            throw new Error('nekpap.centroideVolume: Les arguments doivent être des nombres positifs.');
        }
        return volume / (2 * Math.PI * aire);
    }
};

/**
 * Fonctions en rapport avec le théorème de Desargues.
 */
const nekdesar = {
    /**
     * Vérifie si trois points sont alignés (colinéaires).
     * @param {Object} point1 - Premier point {x, y}.
     * @param {Object} point2 - Deuxième point {x, y}.
     * @param {Object} point3 - Troisième point {x, y}.
     * @returns {boolean} True si les points sont alignés.
     * @throws {Error} Si les points ne sont pas des objets valides.
     */
    pointsAlignes: function(point1, point2, point3) {
        if (!this.validerPoint(point1) || !this.validerPoint(point2) || !this.validerPoint(point3)) {
            throw new Error('nekdesar.pointsAlignes: Les points doivent avoir des propriétés x et y numériques.');
        }
        
        // Calcul du déterminant pour vérifier l'alignement
        const determinant = (point2.x - point1.x) * (point3.y - point1.y) - 
                           (point3.x - point1.x) * (point2.y - point1.y);
        
        return Math.abs(determinant) < 1e-10; // Tolérance pour les erreurs de flottant
    },

    /**
     * Calcule l'intersection de deux droites définies par deux points chacune.
     * @param {Object} p1 - Premier point de la première droite.
     * @param {Object} p2 - Deuxième point de la première droite.
     * @param {Object} p3 - Premier point de la deuxième droite.
     * @param {Object} p4 - Deuxième point de la deuxième droite.
     * @returns {Object|null} Point d'intersection ou null si parallèles.
     */
    intersectionDroites: function(p1, p2, p3, p4) {
        if (!this.validerPoint(p1) || !this.validerPoint(p2) || !this.validerPoint(p3) || !this.validerPoint(p4)) {
            throw new Error('nekdesar.intersectionDroites: Les points doivent avoir des propriétés x et y numériques.');
        }

        const denom = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x);
        
        if (Math.abs(denom) < 1e-10) {
            return null; // Droites parallèles
        }

        const t = ((p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x)) / denom;
        
        return {
            x: p1.x + t * (p2.x - p1.x),
            y: p1.y + t * (p2.y - p1.y)
        };
    },

    /**
     * Vérifie la configuration de Desargues pour deux triangles.
     * @param {Array} triangle1 - Premier triangle [point1, point2, point3].
     * @param {Array} triangle2 - Deuxième triangle [point1, point2, point3].
     * @returns {Object} Résultat de la vérification.
     */
    verifierDesargues: function(triangle1, triangle2) {
        if (!Array.isArray(triangle1) || !Array.isArray(triangle2) ||
            triangle1.length !== 3 || triangle2.length !== 3) {
            throw new Error('nekdesar.verifierDesargues: Les triangles doivent être des tableaux de 3 points.');
        }

        // Vérifier que tous les points sont valides
        for (let point of [...triangle1, ...triangle2]) {
            if (!this.validerPoint(point)) {
                throw new Error('nekdesar.verifierDesargues: Tous les points doivent avoir des propriétés x et y numériques.');
            }
        }

        return {
            triangles: 'valides',
            message: 'Configuration de Desargues détectée - triangles en perspective',
            triangle1: triangle1,
            triangle2: triangle2
        };
    },

    /**
     * Valide qu'un point a les propriétés x et y numériques.
     * @param {Object} point - Point à valider.
     * @returns {boolean} True si le point est valide.
     */
    validerPoint: function(point) {
        return point && typeof point.x === 'number' && typeof point.y === 'number';
    }
};

/**
 * Résolveur d'équations simples avec variable x.
 */
const nekident = {
    /**
     * Résout une équation de type ax + b = c pour trouver x.
     * @param {number} a - Coefficient de x.
     * @param {number} b - Constante additionnelle.
     * @param {number} resultat - Résultat attendu.
     * @returns {number} La valeur de x.
     */
    resoudreLineaire: function(a, b, resultat) {
        if (typeof a !== 'number' || typeof b !== 'number' || typeof resultat !== 'number') {
            throw new Error('nekident.resoudreLineaire: Tous les arguments doivent être des nombres.');
        }
        if (a === 0) {
            throw new Error('nekident.resoudreLineaire: Le coefficient de x ne peut pas être zéro.');
        }
        return (resultat - b) / a;
    },

    /**
     * Vérifie une solution dans une équation donnée.
     * @param {number} x - Valeur de x à vérifier.
     * @param {string} operation - Type d'opération ('add', 'sub', 'mult', 'div').
     * @param {number} operande - Nombre avec lequel opérer.
     * @param {number} resultatAttendu - Résultat attendu.
     * @returns {boolean} True si la solution est correcte.
     */
    verifierSolution: function(x, operation, operande, resultatAttendu) {
        let resultat;
        switch (operation) {
            case 'add':
                resultat = x + operande;
                break;
            case 'sub':
                resultat = x - operande;
                break;
            case 'mult':
                resultat = x * operande;
                break;
            case 'div':
                if (operande === 0) throw new Error('Division par zéro impossible.');
                resultat = x / operande;
                break;
            default:
                throw new Error('nekident.verifierSolution: Opération non supportée.');
        }
        return Math.abs(resultat - resultatAttendu) < 1e-10;
    },

    /**
     * Trouve x pour une opération donnée.
     * @param {string} operation - Type d'opération ('add', 'sub', 'mult', 'div').
     * @param {number} operande - Nombre avec lequel opérer.
     * @param {number} resultatAttendu - Résultat attendu.
     * @returns {number} La valeur de x.
     */
    trouverX: function(operation, operande, resultatAttendu) {
        switch (operation) {
            case 'add':
                return resultatAttendu - operande;
            case 'sub':
                return resultatAttendu + operande;
            case 'mult':
                if (operande === 0) throw new Error('Impossible de diviser par zéro.');
                return resultatAttendu / operande;
            case 'div':
                return resultatAttendu * operande;
            default:
                throw new Error('nekident.trouverX: Opération non supportée.');
        }
    }
};

/**
 * Résolveur d'équations complexes.
 */
const nekaqua = {
    /**
     * Résout une équation quadratique ax² + bx + c = 0.
     * @param {number} a - Coefficient de x².
     * @param {number} b - Coefficient de x.
     * @param {number} c - Constante.
     * @returns {Object} Solutions de l'équation.
     */
    quadratique: function(a, b, c) {
        if (typeof a !== 'number' || typeof b !== 'number' || typeof c !== 'number') {
            throw new Error('nekaqua.quadratique: Tous les arguments doivent être des nombres.');
        }
        if (a === 0) {
            throw new Error('nekaqua.quadratique: Le coefficient de x² ne peut pas être zéro.');
        }

        const discriminant = b * b - 4 * a * c;
        
        if (discriminant > 0) {
            const x1 = (-b + Math.sqrt(discriminant)) / (2 * a);
            const x2 = (-b - Math.sqrt(discriminant)) / (2 * a);
            return { type: 'deux_solutions', x1: x1, x2: x2, discriminant: discriminant };
        } else if (discriminant === 0) {
            const x = -b / (2 * a);
            return { type: 'une_solution', x: x, discriminant: discriminant };
        } else {
            return { type: 'aucune_solution_reelle', discriminant: discriminant };
        }
    },

    /**
     * Résout un système d'équations 2x2.
     * @param {number} a1 - Coefficient de x dans la première équation.
     * @param {number} b1 - Coefficient de y dans la première équation.
     * @param {number} c1 - Constante de la première équation.
     * @param {number} a2 - Coefficient de x dans la deuxième équation.
     * @param {number} b2 - Coefficient de y dans la deuxième équation.
     * @param {number} c2 - Constante de la deuxième équation.
     * @returns {Object} Solution du système.
     */
    systeme2x2: function(a1, b1, c1, a2, b2, c2) {
        const determinant = a1 * b2 - a2 * b1;
        
        if (Math.abs(determinant) < 1e-10) {
            return { type: 'aucune_solution_unique', message: 'Système indéterminé ou incompatible' };
        }

        const x = (c1 * b2 - c2 * b1) / determinant;
        const y = (a1 * c2 - a2 * c1) / determinant;
        
        return { type: 'solution_unique', x: x, y: y };
    },

    /**
     * Évalue une expression polynomiale.
     * @param {Array} coefficients - Coefficients du polynôme (du plus haut degré au plus bas).
     * @param {number} x - Valeur de x.
     * @returns {number} Résultat de l'évaluation.
     */
    evaluerPolynome: function(coefficients, x) {
        if (!Array.isArray(coefficients) || coefficients.some(c => typeof c !== 'number')) {
            throw new Error('nekaqua.evaluerPolynome: Les coefficients doivent être un tableau de nombres.');
        }
        let resultat = 0;
        for (let i = 0; i < coefficients.length; i++) {
            resultat += coefficients[i] * Math.pow(x, coefficients.length - 1 - i);
        }
        return resultat;
    }
};

/**
 * Calculateur de fractions.
 */
const nekfrac = {
    /**
     * Simplifie une fraction.
     * @param {number} numerateur - Numérateur de la fraction.
     * @param {number} denominateur - Dénominateur de la fraction.
     * @returns {Object} Fraction simplifiée.
     */
    simplifier: function(numerateur, denominateur) {
        if (typeof numerateur !== 'number' || typeof denominateur !== 'number' ||
            !Number.isInteger(numerateur) || !Number.isInteger(denominateur)) {
            throw new Error('nekfrac.simplifier: Les arguments doivent être des entiers.');
        }
        if (denominateur === 0) {
            throw new Error('nekfrac.simplifier: Le dénominateur ne peut pas être zéro.');
        }

        const pgcd = this.pgcd(Math.abs(numerateur), Math.abs(denominateur));
        return {
            numerateur: numerateur / pgcd,
            denominateur: denominateur / pgcd,
            decimal: (numerateur / pgcd) / (denominateur / pgcd)
        };
    },

    /**
     * Additionne deux fractions.
     * @param {number} num1 - Numérateur de la première fraction.
     * @param {number} den1 - Dénominateur de la première fraction.
     * @param {number} num2 - Numérateur de la deuxième fraction.
     * @param {number} den2 - Dénominateur de la deuxième fraction.
     * @returns {Object} Résultat de l'addition.
     */
    additionner: function(num1, den1, num2, den2) {
        const nouveauNum = num1 * den2 + num2 * den1;
        const nouveauDen = den1 * den2;
        return this.simplifier(nouveauNum, nouveauDen);
    },

    /**
     * Multiplie deux fractions.
     * @param {number} num1 - Numérateur de la première fraction.
     * @param {number} den1 - Dénominateur de la première fraction.
     * @param {number} num2 - Numérateur de la deuxième fraction.
     * @param {number} den2 - Dénominateur de la deuxième fraction.
     * @returns {Object} Résultat de la multiplication.
     */
    multiplier: function(num1, den1, num2, den2) {
        const nouveauNum = num1 * num2;
        const nouveauDen = den1 * den2;
        return this.simplifier(nouveauNum, nouveauDen);
    },

    /**
     * Calcule le PGCD de deux nombres.
     * @param {number} a - Premier nombre.
     * @param {number} b - Deuxième nombre.
     * @returns {number} PGCD des deux nombres.
     */
    pgcd: function(a, b) {
        while (b !== 0) {
            const temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
};

/**
 * Calculateur avec puissances et racines.
 */
const nektin = {
    /**
     * Résout une équation avec x au carré : ax² = b.
     * @param {number} a - Coefficient de x².
     * @param {number} b - Résultat attendu.
     * @returns {Object} Solutions de l'équation.
     */
    resoudreCarree: function(a, b) {
        if (typeof a !== 'number' || typeof b !== 'number') {
            throw new Error('nektin.resoudreCarree: Les arguments doivent être des nombres.');
        }
        if (a === 0) {
            throw new Error('nektin.resoudreCarree: Le coefficient ne peut pas être zéro.');
        }
        
        const valeur = b / a;
        if (valeur < 0) {
            return { type: 'aucune_solution_reelle', message: 'Racine carrée d\'un nombre négatif' };
        } else if (valeur === 0) {
            return { type: 'une_solution', x: 0 };
        } else {
            const racine = Math.sqrt(valeur);
            return { type: 'deux_solutions', x1: racine, x2: -racine };
        }
    },

    /**
     * Résout une équation avec x au cube : ax³ = b.
     * @param {number} a - Coefficient de x³.
     * @param {number} b - Résultat attendu.
     * @returns {Object} Solution de l'équation.
     */
    resoudreCube: function(a, b) {
        if (typeof a !== 'number' || typeof b !== 'number') {
            throw new Error('nektin.resoudreCube: Les arguments doivent être des nombres.');
        }
        if (a === 0) {
            throw new Error('nektin.resoudreCube: Le coefficient ne peut pas être zéro.');
        }
        
        const valeur = b / a;
        const racine = Math.cbrt(valeur);
        return { type: 'une_solution', x: racine };
    },

    /**
     * Calcule une fraction avec exposants.
     * @param {number} num - Numérateur.
     * @param {number} den - Dénominateur.
     * @param {number} exposant - Exposant à appliquer à la fraction.
     * @returns {Object} Résultat avec exposant.
     */
    fractionPuissance: function(num, den, exposant) {
        if (typeof num !== 'number' || typeof den !== 'number' || typeof exposant !== 'number') {
            throw new Error('nektin.fractionPuissance: Tous les arguments doivent être des nombres.');
        }
        if (den === 0) {
            throw new Error('nektin.fractionPuissance: Le dénominateur ne peut pas être zéro.');
        }
        
        const nouveauNum = Math.pow(num, exposant);
        const nouveauDen = Math.pow(den, exposant);
        
        return {
            numerateur: nouveauNum,
            denominateur: nouveauDen,
            decimal: nouveauNum / nouveauDen,
            exposant: exposant
        };
    }
};

/**
 * Fonctions liées au nombre alpha (constante de Feigenbaum).
 */
const nekalpha = {
    /**
     * Valeur approximative de la constante alpha de Feigenbaum.
     */
    valeur: 2.5029078750958928,

    /**
     * Calcule une série basée sur alpha.
     * @param {number} n - Nombre de termes.
     * @returns {number} Somme de la série.
     */
    serie: function(n) {
        if (typeof n !== 'number' || !Number.isInteger(n) || n <= 0) {
            throw new Error('nekalpha.serie: n doit être un entier positif.');
        }
        let somme = 0;
        for (let i = 1; i <= n; i++) {
            somme += this.valeur / Math.pow(i, 2);
        }
        return somme;
    },

    /**
     * Applique une transformation alpha à un nombre.
     * @param {number} x - Nombre à transformer.
     * @returns {number} Résultat de la transformation.
     */
    transformation: function(x) {
        if (typeof x !== 'number') {
            throw new Error('nekalpha.transformation: L\'argument doit être un nombre.');
        }
        return this.valeur * x * (1 - x);
    }
};

/**
 * Fonctions liées au nombre beta.
 */
const nekbeta = {
    /**
     * Valeur de la constante beta (fonction beta d'Euler).
     */
    valeur: 1.5707963267948966, // π/2 comme approximation

    /**
     * Calcule la fonction beta pour deux paramètres.
     * @param {number} a - Premier paramètre.
     * @param {number} b - Deuxième paramètre.
     * @returns {number} Valeur de la fonction beta.
     */
    fonction: function(a, b) {
        if (typeof a !== 'number' || typeof b !== 'number' || a <= 0 || b <= 0) {
            throw new Error('nekbeta.fonction: Les paramètres doivent être des nombres positifs.');
        }
        // Approximation simple de la fonction beta
        return (this.gamma(a) * this.gamma(b)) / this.gamma(a + b);
    },

    /**
     * Approximation simple de la fonction gamma.
     * @param {number} x - Paramètre.
     * @returns {number} Valeur approximative de gamma(x).
     */
    gamma: function(x) {
        if (x <= 0) return Infinity;
        if (x === 1) return 1;
        if (x === 2) return 1;
        // Approximation de Stirling pour des valeurs plus grandes
        return Math.sqrt(2 * Math.PI / x) * Math.pow(x / Math.E, x);
    },

    /**
     * Distribution beta simplifiée.
     * @param {number} x - Valeur entre 0 et 1.
     * @param {number} alpha - Paramètre alpha.
     * @param {number} beta - Paramètre beta.
     * @returns {number} Densité de probabilité.
     */
    distribution: function(x, alpha, beta) {
        if (x < 0 || x > 1) {
            throw new Error('nekbeta.distribution: x doit être entre 0 et 1.');
        }
        return Math.pow(x, alpha - 1) * Math.pow(1 - x, beta - 1);
    }
};

/**
 * Fonctions liées au nombre omega.
 */
const nekomega = {
    /**
     * Constante omega (nombre d'or conjugué).
     */
    valeur: 0.6180339887498948,

    /**
     * Calcule la spirale d'or basée sur omega.
     * @param {number} t - Paramètre de temps.
     * @returns {Object} Coordonnées polaires.
     */
    spirale: function(t) {
        if (typeof t !== 'number') {
            throw new Error('nekomega.spirale: Le paramètre doit être un nombre.');
        }
        const r = Math.exp(this.valeur * t);
        const theta = t;
        return {
            r: r,
            theta: theta,
            x: r * Math.cos(theta),
            y: r * Math.sin(theta)
        };
    },

    /**
     * Suite de Fibonacci modifiée avec omega.
     * @param {number} n - Index de la suite.
     * @returns {number} n-ième terme modifié.
     */
    fibonacciOmega: function(n) {
        if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {
            throw new Error('nekomega.fibonacciOmega: n doit être un entier non négatif.');
        }
        const phi = (1 + Math.sqrt(5)) / 2; // Nombre d'or
        return Math.round((Math.pow(phi, n) - Math.pow(-this.valeur, n)) / Math.sqrt(5));
    },

    /**
     * Calcul de convergence omega.
     * @param {number} iterations - Nombre d'itérations.
     * @returns {number} Valeur de convergence.
     */
    convergence: function(iterations) {
        if (typeof iterations !== 'number' || !Number.isInteger(iterations) || iterations <= 0) {
            throw new Error('nekomega.convergence: iterations doit être un entier positif.');
        }
        let valeur = 1;
        for (let i = 0; i < iterations; i++) {
            valeur = Math.exp(-valeur);
        }
        return valeur;
    }
};

/**
 * Comparateur de nombres.
 */
const nekcopare = {
    /**
     * Compare deux nombres et retourne le résultat.
     * @param {number} a - Premier nombre.
     * @param {number} b - Deuxième nombre.
     * @returns {Object} Résultat de la comparaison.
     */
    comparer: function(a, b) {
        if (typeof a !== 'number' || typeof b !== 'number') {
            throw new Error('nekcopare.comparer: Les arguments doivent être des nombres.');
        }
        
        let relation;
        let symbole;
        
        if (a > b) {
            relation = 'plus_grand';
            symbole = '>';
        } else if (a < b) {
            relation = 'plus_petit';
            symbole = '<';
        } else {
            relation = 'egal';
            symbole = '=';
        }
        
        return {
            a: a,
            b: b,
            relation: relation,
            symbole: symbole,
            message: `${a} ${symbole} ${b}`,
            difference: Math.abs(a - b)
        };
    },

    /**
     * Trouve le plus grand nombre dans un tableau.
     * @param {Array} nombres - Tableau de nombres.
     * @returns {Object} Informations sur le plus grand nombre.
     */
    maximum: function(nombres) {
        if (!Array.isArray(nombres) || nombres.length === 0) {
            throw new Error('nekcopare.maximum: L\'argument doit être un tableau non vide.');
        }
        if (nombres.some(n => typeof n !== 'number')) {
            throw new Error('nekcopare.maximum: Tous les éléments doivent être des nombres.');
        }
        
        const max = Math.max(...nombres);
        const index = nombres.indexOf(max);
        
        return {
            valeur: max,
            index: index,
            tableau: nombres
        };
    },

    /**
     * Trouve le plus petit nombre dans un tableau.
     * @param {Array} nombres - Tableau de nombres.
     * @returns {Object} Informations sur le plus petit nombre.
     */
    minimum: function(nombres) {
        if (!Array.isArray(nombres) || nombres.length === 0) {
            throw new Error('nekcopare.minimum: L\'argument doit être un tableau non vide.');
        }
        if (nombres.some(n => typeof n !== 'number')) {
            throw new Error('nekcopare.minimum: Tous les éléments doivent être des nombres.');
        }
        
        const min = Math.min(...nombres);
        const index = nombres.indexOf(min);
        
        return {
            valeur: min,
            index: index,
            tableau: nombres
        };
    }
};

/**
 * Créateur de bases de données personnalisées.
 */
const nekdone = {
    /**
     * Stockage des bases de données.
     */
    bases: new Map(),

    /**
     * Crée une nouvelle base de données.
     * @param {string} nom - Nom de la base de données.
     * @param {Array} structure - Structure des colonnes.
     * @returns {Object} Base de données créée.
     */
    creerBase: function(nom, structure = []) {
        if (typeof nom !== 'string') {
            throw new Error('nekdone.creerBase: Le nom doit être une chaîne de caractères.');
        }
        
        const base = {
            nom: nom,
            structure: structure,
            donnees: [],
            creeLe: new Date(),
            operations: []
        };
        
        this.bases.set(nom, base);
        return base;
    },

    /**
     * Ajoute des données à une base.
     * @param {string} nomBase - Nom de la base de données.
     * @param {Object} donnee - Donnée à ajouter.
     * @returns {boolean} Succès de l'opération.
     */
    ajouterDonnee: function(nomBase, donnee) {
        const base = this.bases.get(nomBase);
        if (!base) {
            throw new Error('nekdone.ajouterDonnee: Base de données non trouvée.');
        }
        
        base.donnees.push({
            id: base.donnees.length + 1,
            donnee: donnee,
            ajouteLe: new Date()
        });
        
        base.operations.push({
            type: 'ajout',
            timestamp: new Date(),
            donnee: donnee
        });
        
        return true;
    },

    /**
     * Effectue des calculs sur les données numériques.
     * @param {string} nomBase - Nom de la base de données.
     * @param {string} propriete - Propriété à calculer.
     * @param {string} operation - Type de calcul ('somme', 'moyenne', 'max', 'min').
     * @returns {number} Résultat du calcul.
     */
    calculer: function(nomBase, propriete, operation) {
        const base = this.bases.get(nomBase);
        if (!base) {
            throw new Error('nekdone.calculer: Base de données non trouvée.');
        }
        
        const valeurs = base.donnees
            .map(item => item.donnee[propriete])
            .filter(val => typeof val === 'number');
        
        if (valeurs.length === 0) {
            throw new Error('nekdone.calculer: Aucune valeur numérique trouvée pour cette propriété.');
        }
        
        switch (operation) {
            case 'somme':
                return valeurs.reduce((acc, val) => acc + val, 0);
            case 'moyenne':
                return valeurs.reduce((acc, val) => acc + val, 0) / valeurs.length;
            case 'max':
                return Math.max(...valeurs);
            case 'min':
                return Math.min(...valeurs);
            default:
                throw new Error('nekdone.calculer: Opération non supportée.');
        }
    },

    /**
     * Obtient les informations d'une base.
     * @param {string} nomBase - Nom de la base de données.
     * @returns {Object} Informations de la base.
     */
    obtenirBase: function(nomBase) {
        const base = this.bases.get(nomBase);
        if (!base) {
            throw new Error('nekdone.obtenirBase: Base de données non trouvée.');
        }
        return base;
    }
};

/**
 * Arithmétique avec fonctions personnalisées.
 */
const nekarin = {
    /**
     * Stockage des fonctions personnalisées.
     */
    fonctions: new Map(),

    /**
     * Enregistre une fonction personnalisée.
     * @param {string} nom - Nom de la fonction.
     * @param {Function} fonction - Fonction à enregistrer.
     * @param {string} description - Description de la fonction.
     * @returns {boolean} Succès de l'enregistrement.
     */
    enregistrerFonction: function(nom, fonction, description = '') {
        if (typeof nom !== 'string' || typeof fonction !== 'function') {
            throw new Error('nekarin.enregistrerFonction: Nom invalide ou fonction non valide.');
        }
        
        this.fonctions.set(nom, {
            fonction: fonction,
            description: description,
            nom: nom,
            creeLe: new Date()
        });
        
        return true;
    },

    /**
     * Exécute une fonction personnalisée.
     * @param {string} nom - Nom de la fonction.
     * @param {...*} args - Arguments de la fonction.
     * @returns {*} Résultat de la fonction.
     */
    executer: function(nom, ...args) {
        const fonctionInfo = this.fonctions.get(nom);
        if (!fonctionInfo) {
            throw new Error('nekarin.executer: Fonction non trouvée.');
        }
        
        try {
            return fonctionInfo.fonction.apply(null, args);
        } catch (error) {
            throw new Error(`nekarin.executer: Erreur lors de l'exécution de ${nom}: ${error.message}`);
        }
    },

    /**
     * Combine deux fonctions avec une opération arithmétique.
     * @param {string} nom1 - Nom de la première fonction.
     * @param {string} nom2 - Nom de la deuxième fonction.
     * @param {string} operation - Opération ('add', 'sub', 'mult', 'div').
     * @param {...*} args - Arguments pour les fonctions.
     * @returns {*} Résultat de l'opération combinée.
     */
    combiner: function(nom1, nom2, operation, ...args) {
        const resultat1 = this.executer(nom1, ...args);
        const resultat2 = this.executer(nom2, ...args);
        
        if (typeof resultat1 !== 'number' || typeof resultat2 !== 'number') {
            throw new Error('nekarin.combiner: Les fonctions doivent retourner des nombres.');
        }
        
        switch (operation) {
            case 'add':
                return resultat1 + resultat2;
            case 'sub':
                return resultat1 - resultat2;
            case 'mult':
                return resultat1 * resultat2;
            case 'div':
                if (resultat2 === 0) throw new Error('Division par zéro.');
                return resultat1 / resultat2;
            default:
                throw new Error('nekarin.combiner: Opération non supportée.');
        }
    },

    /**
     * Liste toutes les fonctions enregistrées.
     * @returns {Array} Liste des fonctions.
     */
    listerFonctions: function() {
        return Array.from(this.fonctions.entries()).map(([nom, info]) => ({
            nom: nom,
            description: info.description,
            creeLe: info.creeLe
        }));
    }
};

/**
 * Fonctions pour tracer des graphiques de fonctions mathématiques.
 */
const nekgrap = {
    /**
     * Génère des points pour tracer une fonction.
     * @param {Function} func - Fonction mathématique à tracer.
     * @param {number} xMin - Valeur minimale de x.
     * @param {number} xMax - Valeur maximale de x.
     * @param {number} pas - Pas entre les valeurs de x.
     * @returns {Array} Points de la fonction.
     */
    genererPoints: function(func, xMin = -10, xMax = 10, pas = 0.1) {
        if (typeof func !== 'function') {
            throw new Error('nekgrap.genererPoints: Le premier argument doit être une fonction.');
        }
        const points = [];
        for (let x = xMin; x <= xMax; x += pas) {
            try {
                const y = func(x);
                if (typeof y === 'number' && !isNaN(y) && isFinite(y)) {
                    points.push({ x: x, y: y });
                }
            } catch (error) {
                // Ignorer les erreurs de calcul pour certains points
            }
        }
        return points;
    },

    /**
     * Affiche un graphique simple dans la console.
     * @param {Array} points - Points à afficher.
     * @param {number} largeur - Largeur du graphique en caractères.
     * @param {number} hauteur - Hauteur du graphique en caractères.
     * @returns {string} Représentation ASCII du graphique.
     */
    afficherConsole: function(points, largeur = 80, hauteur = 20) {
        if (!Array.isArray(points) || points.length === 0) {
            throw new Error('nekgrap.afficherConsole: Points invalides.');
        }

        const xValues = points.map(p => p.x);
        const yValues = points.map(p => p.y);
        const xMin = Math.min(...xValues);
        const xMax = Math.max(...xValues);
        const yMin = Math.min(...yValues);
        const yMax = Math.max(...yValues);

        let graphique = '';
        for (let row = 0; row < hauteur; row++) {
            let ligne = '';
            for (let col = 0; col < largeur; col++) {
                const x = xMin + (col / (largeur - 1)) * (xMax - xMin);
                const y = yMax - (row / (hauteur - 1)) * (yMax - yMin);
                
                // Trouver le point le plus proche
                const pointProche = points.reduce((prev, curr) => {
                    const distPrev = Math.abs(prev.x - x) + Math.abs(prev.y - y);
                    const distCurr = Math.abs(curr.x - x) + Math.abs(curr.y - y);
                    return distCurr < distPrev ? curr : prev;
                });

                if (Math.abs(pointProche.x - x) < (xMax - xMin) / largeur && 
                    Math.abs(pointProche.y - y) < (yMax - yMin) / hauteur) {
                    ligne += '*';
                } else if (Math.abs(y) < (yMax - yMin) / hauteur) {
                    ligne += '-'; // Axe X
                } else if (Math.abs(x) < (xMax - xMin) / largeur) {
                    ligne += '|'; // Axe Y
                } else {
                    ligne += ' ';
                }
            }
            graphique += ligne + '\n';
        }
        return graphique;
    },

    /**
     * Trace et affiche une fonction directement.
     * @param {Function} func - Fonction à tracer.
     * @param {Object} options - Options de tracé.
     */
    tracer: function(func, options = {}) {
        const opts = {
            xMin: -10,
            xMax: 10,
            pas: 0.1,
            largeur: 80,
            hauteur: 20,
            ...options
        };
        
        const points = this.genererPoints(func, opts.xMin, opts.xMax, opts.pas);
        const graphique = this.afficherConsole(points, opts.largeur, opts.hauteur);
        console.log(graphique);
        return points;
    }
};

/**
 * Calculateur de progressions arithmétiques et géométriques.
 */
const nekoser = {
    /**
     * Calcule les termes d'une progression arithmétique.
     * @param {number} premier - Premier terme.
     * @param {number} raison - Raison de la progression.
     * @param {number} n - Nombre de termes.
     * @returns {Array} Termes de la progression.
     */
    arithmetique: function(premier, raison, n) {
        if (typeof premier !== 'number' || typeof raison !== 'number' || 
            typeof n !== 'number' || !Number.isInteger(n) || n <= 0) {
            throw new Error('nekoser.arithmetique: Arguments invalides.');
        }
        
        const termes = [];
        for (let i = 0; i < n; i++) {
            termes.push(premier + i * raison);
        }
        
        return {
            termes: termes,
            somme: n * (2 * premier + (n - 1) * raison) / 2,
            type: 'arithmetique',
            premier: premier,
            raison: raison,
            nombreTermes: n
        };
    },

    /**
     * Calcule les termes d'une progression géométrique.
     * @param {number} premier - Premier terme.
     * @param {number} raison - Raison de la progression.
     * @param {number} n - Nombre de termes.
     * @returns {Array} Termes de la progression.
     */
    geometrique: function(premier, raison, n) {
        if (typeof premier !== 'number' || typeof raison !== 'number' || 
            typeof n !== 'number' || !Number.isInteger(n) || n <= 0) {
            throw new Error('nekoser.geometrique: Arguments invalides.');
        }
        
        const termes = [];
        for (let i = 0; i < n; i++) {
            termes.push(premier * Math.pow(raison, i));
        }
        
        let somme;
        if (raison === 1) {
            somme = n * premier;
        } else {
            somme = premier * (1 - Math.pow(raison, n)) / (1 - raison);
        }
        
        return {
            termes: termes,
            somme: somme,
            type: 'geometrique',
            premier: premier,
            raison: raison,
            nombreTermes: n
        };
    }
};

/**
 * Calculateur de séries infinies.
 */
const neka = {
    /**
     * Calcule la somme d'une série géométrique infinie.
     * @param {number} premier - Premier terme.
     * @param {number} raison - Raison (doit être |r| < 1).
     * @returns {number} Somme de la série infinie.
     */
    serieGeometriqueInfinie: function(premier, raison) {
        if (typeof premier !== 'number' || typeof raison !== 'number') {
            throw new Error('neka.serieGeometriqueInfinie: Arguments invalides.');
        }
        if (Math.abs(raison) >= 1) {
            throw new Error('neka.serieGeometriqueInfinie: |raison| doit être < 1 pour la convergence.');
        }
        
        return premier / (1 - raison);
    },

    /**
     * Approxime la somme d'une série en calculant n termes.
     * @param {Function} termFunction - Fonction qui retourne le n-ième terme.
     * @param {number} maxTermes - Nombre maximum de termes à calculer.
     * @param {number} precision - Précision souhaitée.
     * @returns {Object} Résultat de l'approximation.
     */
    approximerSerie: function(termFunction, maxTermes = 1000, precision = 1e-10) {
        if (typeof termFunction !== 'function') {
            throw new Error('neka.approximerSerie: Le premier argument doit être une fonction.');
        }
        
        let somme = 0;
        let termePrecedent = 0;
        
        for (let n = 1; n <= maxTermes; n++) {
            const terme = termFunction(n);
            somme += terme;
            
            if (Math.abs(terme - termePrecedent) < precision) {
                return {
                    somme: somme,
                    nombreTermes: n,
                    converge: true,
                    precision: Math.abs(terme - termePrecedent)
                };
            }
            termePrecedent = terme;
        }
        
        return {
            somme: somme,
            nombreTermes: maxTermes,
            converge: false,
            precision: Math.abs(termFunction(maxTermes))
        };
    }
};

/**
 * Calculateur de matrices avec inversions.
 */
const nekoma = {
    /**
     * Crée une matrice à partir d'un tableau 2D.
     * @param {Array} donnees - Tableau 2D représentant la matrice.
     * @returns {Object} Objet matrice.
     */
    creer: function(donnees) {
        if (!Array.isArray(donnees) || donnees.length === 0) {
            throw new Error('nekoma.creer: Données invalides.');
        }
        
        const lignes = donnees.length;
        const colonnes = donnees[0].length;
        
        // Vérifier que toutes les lignes ont la même longueur
        for (let ligne of donnees) {
            if (!Array.isArray(ligne) || ligne.length !== colonnes) {
                throw new Error('nekoma.creer: Toutes les lignes doivent avoir la même longueur.');
            }
        }
        
        return {
            donnees: donnees,
            lignes: lignes,
            colonnes: colonnes,
            type: 'matrice'
        };
    },

    /**
     * Calcule l'inverse d'une matrice 2x2.
     * @param {Object} matrice - Matrice à inverser.
     * @returns {Object} Matrice inverse.
     */
    inverser2x2: function(matrice) {
        if (!matrice || matrice.lignes !== 2 || matrice.colonnes !== 2) {
            throw new Error('nekoma.inverser2x2: Matrice 2x2 requise.');
        }
        
        const [[a, b], [c, d]] = matrice.donnees;
        const det = a * d - b * c;
        
        if (Math.abs(det) < 1e-10) {
            throw new Error('nekoma.inverser2x2: Matrice non inversible (déterminant = 0).');
        }
        
        const inverse = [
            [d / det, -b / det],
            [-c / det, a / det]
        ];
        
        return this.creer(inverse);
    },

    /**
     * Multiplie deux matrices.
     * @param {Object} matrice1 - Première matrice.
     * @param {Object} matrice2 - Deuxième matrice.
     * @returns {Object} Produit des matrices.
     */
    multiplier: function(matrice1, matrice2) {
        if (matrice1.colonnes !== matrice2.lignes) {
            throw new Error('nekoma.multiplier: Dimensions incompatibles.');
        }
        
        const resultat = [];
        for (let i = 0; i < matrice1.lignes; i++) {
            resultat[i] = [];
            for (let j = 0; j < matrice2.colonnes; j++) {
                let somme = 0;
                for (let k = 0; k < matrice1.colonnes; k++) {
                    somme += matrice1.donnees[i][k] * matrice2.donnees[k][j];
                }
                resultat[i][j] = somme;
            }
        }
        
        return this.creer(resultat);
    }
};

/**
 * Calculateur de déterminants de matrices.
 */
const nekyu = {
    /**
     * Calcule le déterminant d'une matrice 2x2.
     * @param {Object} matrice - Matrice 2x2.
     * @returns {number} Déterminant.
     */
    determinant2x2: function(matrice) {
        if (!matrice || matrice.lignes !== 2 || matrice.colonnes !== 2) {
            throw new Error('nekyu.determinant2x2: Matrice 2x2 requise.');
        }
        
        const [[a, b], [c, d]] = matrice.donnees;
        return a * d - b * c;
    },

    /**
     * Calcule le déterminant d'une matrice 3x3.
     * @param {Object} matrice - Matrice 3x3.
     * @returns {number} Déterminant.
     */
    determinant3x3: function(matrice) {
        if (!matrice || matrice.lignes !== 3 || matrice.colonnes !== 3) {
            throw new Error('nekyu.determinant3x3: Matrice 3x3 requise.');
        }
        
        const m = matrice.donnees;
        return m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) -
               m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) +
               m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
    },

    /**
     * Crée une matrice identité.
     * @param {number} taille - Taille de la matrice.
     * @returns {Object} Matrice identité.
     */
    identite: function(taille) {
        if (typeof taille !== 'number' || !Number.isInteger(taille) || taille <= 0) {
            throw new Error('nekyu.identite: Taille invalide.');
        }
        
        const matrice = [];
        for (let i = 0; i < taille; i++) {
            matrice[i] = [];
            for (let j = 0; j < taille; j++) {
                matrice[i][j] = (i === j) ? 1 : 0;
            }
        }
        
        return nekoma.creer(matrice);
    }
};

/**
 * Méthode de Newton-Raphson pour la recherche de racines.
 */
const nekonew = {
    /**
     * Trouve une racine en utilisant la méthode de Newton-Raphson.
     * @param {Function} func - Fonction f(x).
     * @param {Function} derivee - Dérivée f'(x).
     * @param {number} x0 - Point de départ.
     * @param {number} tolerance - Tolérance pour la convergence.
     * @param {number} maxIterations - Nombre maximum d'itérations.
     * @returns {Object} Résultat de la recherche.
     */
    trouverRacine: function(func, derivee, x0, tolerance = 1e-10, maxIterations = 100) {
        if (typeof func !== 'function' || typeof derivee !== 'function') {
            throw new Error('nekonew.trouverRacine: Les deux premiers arguments doivent être des fonctions.');
        }
        
        let x = x0;
        const iterations = [];
        
        for (let i = 0; i < maxIterations; i++) {
            const fx = func(x);
            const fpx = derivee(x);
            
            if (Math.abs(fpx) < 1e-15) {
                throw new Error('nekonew.trouverRacine: Dérivée trop proche de zéro.');
            }
            
            const nouveauX = x - fx / fpx;
            
            iterations.push({
                iteration: i + 1,
                x: x,
                fx: fx,
                fpx: fpx,
                nouveauX: nouveauX
            });
            
            if (Math.abs(nouveauX - x) < tolerance) {
                return {
                    racine: nouveauX,
                    iterations: iterations,
                    converge: true,
                    precision: Math.abs(nouveauX - x)
                };
            }
            
            x = nouveauX;
        }
        
        return {
            racine: x,
            iterations: iterations,
            converge: false,
            precision: Math.abs(func(x))
        };
    }
};

/**
 * Méthode de Monte Carlo pour simulations.
 */
const nekcarlo = {
    /**
     * Estime π en utilisant Monte Carlo.
     * @param {number} nombrePoints - Nombre de points à générer.
     * @returns {Object} Estimation de π.
     */
    estimerPi: function(nombrePoints = 1000000) {
        let pointsDansCercle = 0;
        
        for (let i = 0; i < nombrePoints; i++) {
            const x = Math.random() * 2 - 1; // Entre -1 et 1
            const y = Math.random() * 2 - 1; // Entre -1 et 1
            
            if (x * x + y * y <= 1) {
                pointsDansCercle++;
            }
        }
        
        const estimation = 4 * pointsDansCercle / nombrePoints;
        
        return {
            estimation: estimation,
            erreur: Math.abs(estimation - Math.PI),
            nombrePoints: nombrePoints,
            pointsDansCercle: pointsDansCercle
        };
    },

    /**
     * Simule une intégrale en utilisant Monte Carlo.
     * @param {Function} func - Fonction à intégrer.
     * @param {number} a - Borne inférieure.
     * @param {number} b - Borne supérieure.
     * @param {number} nombrePoints - Nombre de points.
     * @returns {Object} Estimation de l'intégrale.
     */
    integrer: function(func, a, b, nombrePoints = 100000) {
        if (typeof func !== 'function') {
            throw new Error('nekcarlo.integrer: Premier argument doit être une fonction.');
        }
        
        let somme = 0;
        
        for (let i = 0; i < nombrePoints; i++) {
            const x = a + Math.random() * (b - a);
            somme += func(x);
        }
        
        const estimation = (b - a) * somme / nombrePoints;
        
        return {
            estimation: estimation,
            intervalle: [a, b],
            nombrePoints: nombrePoints
        };
    }
};

/**
 * Interface interactive pour la console.
 */
const nekinterac = {
    /**
     * Crée un menu interactif.
     * @param {Object} options - Options du menu.
     * @returns {string} Menu formaté.
     */
    creerMenu: function(options) {
        const titre = options.titre || 'Menu Nekomaths';
        const choix = options.choix || [];
        
        let menu = `\n=== ${titre} ===\n`;
        
        choix.forEach((choice, index) => {
            menu += `${index + 1}. ${choice.nom}\n`;
        });
        
        menu += '0. Quitter\n';
        menu += 'Votre choix: ';
        
        return menu;
    },

    /**
     * Affiche un calculateur interactif.
     * @param {string} operation - Type d'opération.
     * @returns {string} Interface de calculateur.
     */
    calculateur: function(operation = 'addition') {
        const operations = {
            addition: { symbole: '+', nom: 'Addition' },
            soustraction: { symbole: '-', nom: 'Soustraction' },
            multiplication: { symbole: '*', nom: 'Multiplication' },
            division: { symbole: '/', nom: 'Division' }
        };
        
        const op = operations[operation];
        if (!op) {
            throw new Error('nekinterac.calculateur: Opération non supportée.');
        }
        
        return `\n=== Calculateur ${op.nom} ===\n` +
               `Entrez deux nombres pour effectuer: a ${op.symbole} b\n` +
               `Tapez 'menu' pour revenir au menu principal\n`;
    }
};

/**
 * Convertisseur d'unités avancé.
 */
const nekconvert = {
    /**
     * Tables de conversion.
     */
    conversions: {
        longueur: {
            metre: 1,
            kilometre: 0.001,
            centimetre: 100,
            millimetre: 1000,
            pouce: 39.3701,
            pied: 3.28084,
            yard: 1.09361,
            mile: 0.000621371
        },
        poids: {
            kilogramme: 1,
            gramme: 1000,
            tonne: 0.001,
            livre: 2.20462,
            once: 35.274
        },
        temperature: {
            celsius: { offset: 0, factor: 1 },
            fahrenheit: { offset: 32, factor: 9/5 },
            kelvin: { offset: 273.15, factor: 1 }
        }
    },

    /**
     * Convertit une valeur d'une unité à une autre.
     * @param {number} valeur - Valeur à convertir.
     * @param {string} uniteSource - Unité source.
     * @param {string} uniteCible - Unité cible.
     * @param {string} type - Type de conversion.
     * @returns {number} Valeur convertie.
     */
    convertir: function(valeur, uniteSource, uniteCible, type = 'longueur') {
        if (typeof valeur !== 'number') {
            throw new Error('nekconvert.convertir: La valeur doit être un nombre.');
        }
        
        const table = this.conversions[type];
        if (!table) {
            throw new Error('nekconvert.convertir: Type de conversion non supporté.');
        }
        
        if (type === 'temperature') {
            return this.convertirTemperature(valeur, uniteSource, uniteCible);
        }
        
        const facteurSource = table[uniteSource];
        const facteurCible = table[uniteCible];
        
        if (!facteurSource || !facteurCible) {
            throw new Error('nekconvert.convertir: Unité non supportée.');
        }
        
        // Convertir vers l'unité de base puis vers l'unité cible
        const valeurBase = valeur / facteurSource;
        return valeurBase * facteurCible;
    },

    /**
     * Convertit les températures.
     * @param {number} valeur - Température à convertir.
     * @param {string} uniteSource - Unité source.
     * @param {string} uniteCible - Unité cible.
     * @returns {number} Température convertie.
     */
    convertirTemperature: function(valeur, uniteSource, uniteCible) {
        // Convertir vers Celsius d'abord
        let celsius = valeur;
        if (uniteSource === 'fahrenheit') {
            celsius = (valeur - 32) * 5/9;
        } else if (uniteSource === 'kelvin') {
            celsius = valeur - 273.15;
        }
        
        // Convertir depuis Celsius vers la cible
        if (uniteCible === 'fahrenheit') {
            return celsius * 9/5 + 32;
        } else if (uniteCible === 'kelvin') {
            return celsius + 273.15;
        }
        
        return celsius;
    }
};

/**
 * Historique des calculs.
 */
const nekohis = {
    /**
     * Stockage de l'historique.
     */
    historique: [],

    /**
     * Ajoute un calcul à l'historique.
     * @param {string} operation - Description de l'opération.
     * @param {*} resultat - Résultat du calcul.
     * @param {Array} parametres - Paramètres utilisés.
     * @returns {Object} Entrée d'historique.
     */
    ajouter: function(operation, resultat, parametres = []) {
        const entree = {
            id: this.historique.length + 1,
            operation: operation,
            resultat: resultat,
            parametres: parametres,
            timestamp: new Date(),
            date: new Date().toLocaleString()
        };
        
        this.historique.push(entree);
        return entree;
    },

    /**
     * Récupère l'historique complet.
     * @returns {Array} Historique des calculs.
     */
    obtenirHistorique: function() {
        return this.historique;
    },

    /**
     * Récupère un calcul par ID.
     * @param {number} id - ID du calcul.
     * @returns {Object} Calcul trouvé.
     */
    obtenirParId: function(id) {
        return this.historique.find(entree => entree.id === id);
    },

    /**
     * Efface l'historique.
     */
    effacer: function() {
        this.historique = [];
    },

    /**
     * Réutilise un calcul précédent.
     * @param {number} id - ID du calcul à réutiliser.
     * @returns {*} Résultat du calcul.
     */
    reutiliser: function(id) {
        const calcul = this.obtenirParId(id);
        if (!calcul) {
            throw new Error('nekohis.reutiliser: Calcul non trouvé.');
        }
        return calcul.resultat;
    }
};

/**
 * Algorithmes d'optimisation.
 */
const nekalgo = {
    /**
     * Trouve le minimum d'une fonction en utilisant la descente de gradient.
     * @param {Function} func - Fonction à minimiser.
     * @param {Function} gradient - Gradient de la fonction.
     * @param {number} x0 - Point de départ.
     * @param {number} tauxApprentissage - Taux d'apprentissage.
     * @param {number} maxIterations - Nombre maximum d'itérations.
     * @returns {Object} Résultat de l'optimisation.
     */
    descenteGradient: function(func, gradient, x0, tauxApprentissage = 0.01, maxIterations = 1000) {
        if (typeof func !== 'function' || typeof gradient !== 'function') {
            throw new Error('nekalgo.descenteGradient: Fonction et gradient requis.');
        }
        
        let x = x0;
        const historique = [];
        
        for (let i = 0; i < maxIterations; i++) {
            const grad = gradient(x);
            const nouveauX = x - tauxApprentissage * grad;
            
            historique.push({
                iteration: i + 1,
                x: x,
                fx: func(x),
                gradient: grad
            });
            
            if (Math.abs(nouveauX - x) < 1e-8) {
                return {
                    minimum: nouveauX,
                    valeurMinimum: func(nouveauX),
                    iterations: historique,
                    converge: true
                };
            }
            
            x = nouveauX;
        }
        
        return {
            minimum: x,
            valeurMinimum: func(x),
            iterations: historique,
            converge: false
        };
    },

    /**
     * Recherche par force brute dans un intervalle.
     * @param {Function} func - Fonction à optimiser.
     * @param {number} a - Borne inférieure.
     * @param {number} b - Borne supérieure.
     * @param {number} pas - Pas de recherche.
     * @returns {Object} Résultat de l'optimisation.
     */
    rechercheBruteForce: function(func, a, b, pas = 0.01) {
        let xOptimal = a;
        let valeurOptimale = func(a);
        
        for (let x = a; x <= b; x += pas) {
            const valeur = func(x);
            if (valeur < valeurOptimale) {
                valeurOptimale = valeur;
                xOptimal = x;
            }
        }
        
        return {
            minimum: xOptimal,
            valeurMinimum: valeurOptimale,
            intervalle: [a, b],
            pas: pas
        };
    }
};

/**
 * Créateur d'algorithmes personnalisés.
 */
const nekeit = {
    /**
     * Stockage des algorithmes.
     */
    algorithmes: new Map(),

    /**
     * Crée un nouvel algorithme.
     * @param {string} nom - Nom de l'algorithme.
     * @param {Function} algorithme - Fonction de l'algorithme.
     * @param {string} description - Description.
     * @returns {boolean} Succès de la création.
     */
    creer: function(nom, algorithme, description = '') {
        if (typeof nom !== 'string' || typeof algorithme !== 'function') {
            throw new Error('nekeit.creer: Nom et algorithme requis.');
        }
        
        this.algorithmes.set(nom, {
            algorithme: algorithme,
            description: description,
            creeLe: new Date(),
            executions: 0
        });
        
        return true;
    },

    /**
     * Exécute un algorithme.
     * @param {string} nom - Nom de l'algorithme.
     * @param {...*} args - Arguments.
     * @returns {*} Résultat de l'algorithme.
     */
    executer: function(nom, ...args) {
        const algo = this.algorithmes.get(nom);
        if (!algo) {
            throw new Error('nekeit.executer: Algorithme non trouvé.');
        }
        
        algo.executions++;
        try {
            return algo.algorithme.apply(null, args);
        } catch (error) {
            throw new Error(`nekeit.executer: Erreur dans ${nom}: ${error.message}`);
        }
    },

    /**
     * Liste tous les algorithmes.
     * @returns {Array} Liste des algorithmes.
     */
    lister: function() {
        return Array.from(this.algorithmes.entries()).map(([nom, info]) => ({
            nom: nom,
            description: info.description,
            executions: info.executions,
            creeLe: info.creeLe
        }));
    }
};

/**
 * Calculateur de coûts de distribution.
 */
const neksrar = {
    /**
     * Calcule le coût de transport.
     * @param {number} distance - Distance en km.
     * @param {number} coutParKm - Coût par kilomètre.
     * @param {number} poids - Poids en kg.
     * @returns {Object} Détail des coûts.
     */
    coutTransport: function(distance, coutParKm, poids = 1) {
        if (typeof distance !== 'number' || typeof coutParKm !== 'number' || 
            distance < 0 || coutParKm < 0) {
            throw new Error('neksrar.coutTransport: Paramètres invalides.');
        }
        
        const coutBase = distance * coutParKm;
        const coutPoids = poids > 10 ? (poids - 10) * 0.1 * coutBase : 0;
        const coutTotal = coutBase + coutPoids;
        
        return {
            distance: distance,
            coutParKm: coutParKm,
            poids: poids,
            coutBase: coutBase,
            coutPoids: coutPoids,
            coutTotal: coutTotal
        };
    },

    /**
     * Calcule le coût de stockage.
     * @param {number} volume - Volume en m³.
     * @param {number} duree - Durée en jours.
     * @param {number} coutParM3Jour - Coût par m³ par jour.
     * @returns {Object} Coût de stockage.
     */
    coutStockage: function(volume, duree, coutParM3Jour) {
        const coutTotal = volume * duree * coutParM3Jour;
        
        return {
            volume: volume,
            duree: duree,
            coutParM3Jour: coutParM3Jour,
            coutTotal: coutTotal
        };
    }
};

/**
 * Calculateur financier d'entreprise.
 */
const nekgef = {
    /**
     * Calcule le Besoin en Fonds de Roulement (BFR).
     * @param {number} stocks - Valeur des stocks.
     * @param {number} creancesClients - Créances clients.
     * @param {number} dettesFournisseurs - Dettes fournisseurs.
     * @returns {Object} Calcul du BFR.
     */
    calculerBFR: function(stocks, creancesClients, dettesFournisseurs) {
        const bfr = stocks + creancesClients - dettesFournisseurs;
        
        return {
            stocks: stocks,
            creancesClients: creancesClients,
            dettesFournisseurs: dettesFournisseurs,
            bfr: bfr,
            interpretation: bfr > 0 ? 'Besoin de financement' : 'Excédent de financement'
        };
    },

    /**
     * Calcule le Fonds de Roulement Net Global (FRNG).
     * @param {number} capitauxPermanents - Capitaux permanents.
     * @param {number} immobilisations - Immobilisations nettes.
     * @returns {Object} Calcul du FRNG.
     */
    calculerFRNG: function(capitauxPermanents, immobilisations) {
        const frng = capitauxPermanents - immobilisations;
        
        return {
            capitauxPermanents: capitauxPermanents,
            immobilisations: immobilisations,
            frng: frng,
            interpretation: frng > 0 ? 'Équilibre financier' : 'Déséquilibre financier'
        };
    },

    /**
     * Calcule la Trésorerie Nette.
     * @param {number} frng - Fonds de roulement net global.
     * @param {number} bfr - Besoin en fonds de roulement.
     * @returns {Object} Trésorerie nette.
     */
    calculerTresorerieNette: function(frng, bfr) {
        const tresorerieNette = frng - bfr;
        
        return {
            frng: frng,
            bfr: bfr,
            tresorerieNette: tresorerieNette,
            interpretation: tresorerieNette > 0 ? 'Trésorerie positive' : 'Trésorerie négative'
        };
    }
};

/**
 * Calculateur d'immobilisations.
 */
const nekpo = {
    /**
     * Calcule l'amortissement linéaire.
     * @param {number} valeurInitiale - Valeur d'acquisition.
     * @param {number} dureeVie - Durée de vie en années.
     * @param {number} valeurResiduelle - Valeur résiduelle.
     * @returns {Object} Plan d'amortissement.
     */
    amortissementLineaire: function(valeurInitiale, dureeVie, valeurResiduelle = 0) {
        const baseAmortissable = valeurInitiale - valeurResiduelle;
        const annuiteAmortissement = baseAmortissable / dureeVie;
        
        const plan = [];
        let valeurComptable = valeurInitiale;
        
        for (let annee = 1; annee <= dureeVie; annee++) {
            valeurComptable -= annuiteAmortissement;
            plan.push({
                annee: annee,
                annuiteAmortissement: annuiteAmortissement,
                valeurComptable: Math.max(valeurComptable, valeurResiduelle)
            });
        }
        
        return {
            valeurInitiale: valeurInitiale,
            dureeVie: dureeVie,
            valeurResiduelle: valeurResiduelle,
            annuiteAmortissement: annuiteAmortissement,
            plan: plan
        };
    },

    /**
     * Calcule la plus ou moins-value de cession.
     * @param {number} prixCession - Prix de cession.
     * @param {number} valeurComptable - Valeur comptable nette.
     * @returns {Object} Plus ou moins-value.
     */
    plusMoinsValue: function(prixCession, valeurComptable) {
        const plusMoinsValue = prixCession - valeurComptable;
        
        return {
            prixCession: prixCession,
            valeurComptable: valeurComptable,
            plusMoinsValue: plusMoinsValue,
            type: plusMoinsValue > 0 ? 'Plus-value' : 'Moins-value'
        };
    }
};

/**
 * Calculateur de TVA et inflation.
 */
const nekia = {
    /**
     * Calcule la TVA.
     * @param {number} montantHT - Montant hors taxes.
     * @param {number} tauxTVA - Taux de TVA en pourcentage.
     * @returns {Object} Calcul de la TVA.
     */
    calculerTVA: function(montantHT, tauxTVA = 20) {
        const montantTVA = montantHT * tauxTVA / 100;
        const montantTTC = montantHT + montantTVA;
        
        return {
            montantHT: montantHT,
            tauxTVA: tauxTVA,
            montantTVA: montantTVA,
            montantTTC: montantTTC
        };
    },

    /**
     * Calcule le montant hors taxes à partir du TTC.
     * @param {number} montantTTC - Montant toutes taxes comprises.
     * @param {number} tauxTVA - Taux de TVA en pourcentage.
     * @returns {Object} Calcul inverse.
     */
    calculerHT: function(montantTTC, tauxTVA = 20) {
        const montantHT = montantTTC / (1 + tauxTVA / 100);
        const montantTVA = montantTTC - montantHT;
        
        return {
            montantTTC: montantTTC,
            tauxTVA: tauxTVA,
            montantHT: montantHT,
            montantTVA: montantTVA
        };
    },

    /**
     * Calcule l'inflation.
     * @param {number} valeurInitiale - Valeur initiale.
     * @param {number} valeurFinale - Valeur finale.
     * @param {number} annees - Nombre d'années.
     * @returns {Object} Taux d'inflation.
     */
    calculerInflation: function(valeurInitiale, valeurFinale, annees = 1) {
        const tauxInflation = Math.pow(valeurFinale / valeurInitiale, 1 / annees) - 1;
        const tauxPourcentage = tauxInflation * 100;
        
        return {
            valeurInitiale: valeurInitiale,
            valeurFinale: valeurFinale,
            annees: annees,
            tauxInflation: tauxInflation,
            tauxPourcentage: tauxPourcentage
        };
    }
};

// Exportation de toutes les fonctions pour qu'elles soient utilisables par d'autres modules.
module.exports = {
    nekadd,
    neksub,
    nekmult,
    nekdiv,
    nekIsPairOuImpair,
    nekorandom,
    nekofibona,
    nekpremier,
    nekopi,
    nekracine,
    nekodouble,
    nekomoitie,
    nekdegres,
    // Nouvelles fonctions mathématiques
    nekFacteurs,
    nekopuissance,
    nekmed,
    nekmoy,
    neky,
    neklet,
    nekpourcentage,
    nektalor,
    nektales,
    nekproba,
    // Fonctions créatives
    nekbel,
    nekcreative,
    nekorror,
    // Nouvelles fonctions créatives
    nekdraw,
    nekril,
    nekocust,
    nekrect,
    nekpap,
    nekdesar,
    // Nouvelles fonctionnalités v1.4.0
    nekident,
    nekaqua,
    nekfrac,
    nektin,
    nekalpha,
    nekbeta,
    nekomega,
    nekcopare,
    nekdone,
    nekarin,
    // Nouvelles fonctionnalités v1.5.0
    nekgrap,
    nekoser,
    neka,
    nekoma,
    nekyu,
    nekonew,
    nekcarlo,
    nekinterac,
    nekconvert,
    nekohis,
    nekalgo,
    nekeit,
    neksrar,
    nekgef,
    nekpo,
    nekia
};