Upload 4 files

README-6.md

@@ -0,0 +1,925 @@
+
+**Nekomaths**
+
+![🍭💖nekomaths💖🍭](http://www.image-heberg.fr/files/17506757603536301054.webp)
+
+
+Un package Node.js simple et convivial, développé par nekoclem, offrant des fonctions mathématiques de base, des utilitaires pratiques et des outils plus spécifiques pour vos projets.
+
+**Installation**
+
+Pour installer nekomaths dans votre projet, utilisez npm :
+
+```
+npm install nekomaths
+```
+
+**Utilisation**
+
+Importez les fonctions de nekomaths dans votre fichier JavaScript. Vous pouvez importer l'objet complet ou déstructurer pour n'importer que les fonctions spécifiques dont vous avez besoin.
+
+```
+const nekomaths = require('nekomaths');
+// Ou en ES Modules (si votre projet supporte) :
+// import nekomaths from 'nekomaths';
+
+// Exemple de déstructuration pour n'importer que certaines fonctions :
+// const { nekadd, nekpremier } = require('nekomaths');
+```
+
+**Fonctionnalités**
+
+nekomaths offre les fonctions et modules suivants :
+
+## 1. Calculs Arithmétiques Simples
+Ces fonctions effectuent les opérations mathématiques de base et retournent le résultat.
+ * `nekadd(a, b)` : Additionne deux nombres.
+ * `neksub(a, b)` : Soustrait le deuxième nombre du premier.
+ * `nekmult(a, b)` : Multiplie deux nombres.
+ * `nekdiv(a, b)` : Divise le premier nombre par le deuxième. (Gère la division par zéro).
+ * `nekodouble(number)` : Renvoie le double d'un nombre.
+ * `nekomoitie(number)` : Renvoie la moitié d'un nombre.
+ * `nekracine(number)` : Calcule la racine carrée d'un nombre.
+ * `nekopuissance(base, exposant)` : Calcule la puissance d'un nombre.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Addition
+console.log("4 + 5 =", nekomaths.nekadd(4, 5)); // Renvoie 9
+
+// Soustraction
+console.log("10 - 3 =", nekomaths.neksub(10, 3)); // Renvoie 7
+
+// Multiplication
+console.log("6 * 7 =", nekomaths.nekmult(6, 7)); // Renvoie 42
+
+// Division
+console.log("20 / 4 =", nekomaths.nekdiv(20, 4)); // Renvoie 5
+
+// Gestion de la division par zéro
+try {
+    nekomaths.nekdiv(10, 0);
+} catch (error) {
+    console.error(error.message); // Affiche : nekdiv: Division par zéro impossible.
+}
+
+// Doubler un nombre
+console.log("Le double de 7 est :", nekomaths.nekodouble(7)); // Renvoie 14
+
+// Moitié d'un nombre
+console.log("La moitié de 15 est :", nekomaths.nekomoitie(15)); // Renvoie 7.5
+
+// Racine carrée
+console.log("La racine carrée de 25 est :", nekomaths.nekracine(25)); // Renvoie 5
+
+// Puissance
+console.log("2 à la puissance 3 :", nekomaths.nekopuissance(2, 3)); // Renvoie 8
+```
+
+## 2. Fonctions de Vérification et Séquences
+ * `nekIsPairOuImpair(number)` : Vérifie si un nombre est pair ou impair et retourne une phrase explicative en français.
+ * `nekofibona(n)` : Retourne le n-ième nombre de la séquence de Fibonacci.
+ * `nekpremier(number)` : Vérifie si un nombre entier est premier. Retourne true si le nombre est premier, false sinon.
+ * `nekFacteurs(number)` : Retourne un tableau des facteurs premiers d'un nombre.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Détection de Nombre Pair ou Impair
+console.log(nekomaths.nekIsPairOuImpair(7)); // Renvoie "Le nombre 7 est impair."
+console.log(nekomaths.nekIsPairOuImpair(12)); // Renvoie "Le nombre 12 est pair."
+
+// Calcul du nombre de Fibonacci
+console.log("Le 10ème nombre de Fibonacci est :", nekomaths.nekofibona(10)); // Renvoie 55
+
+// Vérification de Nombre Premier
+console.log("17 est premier ?", nekomaths.nekpremier(17)); // Renvoie true
+console.log("18 est premier ?", nekomaths.nekpremier(18)); // Renvoie false
+
+// Facteurs premiers
+console.log("Facteurs premiers de 12 :", nekomaths.nekFacteurs(12)); // Renvoie [2, 2, 3]
+```
+
+## 3. Statistiques et Calculs sur Tableaux
+ * `nekmed(arr)` : Calcule la médiane d'un tableau de nombres.
+ * `nekmoy(arr)` : Calcule la moyenne d'un tableau de nombres.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+const nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+// Médiane
+console.log("Médiane :", nekomaths.nekmed(nombres)); // Renvoie 5.5
+
+// Moyenne
+console.log("Moyenne :", nekomaths.nekmoy(nombres)); // Renvoie 5.5
+```
+
+## 4. Génération de Nombre Aléatoire
+ * `nekorandom(min, max)` : Génère un nombre entier aléatoire entre min et max (inclus).
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Générer un nombre aléatoire entre 5 et 10 (inclus)
+const randomNumber = nekomaths.nekorandom(5, 10);
+console.log(`Un nombre aléatoire entre 5 et 10 : ${randomNumber}`);
+```
+
+## 5. Calculs avec Pi (nekopi)
+L'objet nekopi fournit la valeur de Pi et des fonctions pour les calculs géométriques courants.
+ * `nekopi.valeur` : La valeur de Pi (Math.PI).
+ * `nekopi.circonference(rayon)` : Calcule la circonférence d'un cercle.
+ * `nekopi.aireCercle(rayon)` : Calcule l'aire d'un cercle.
+ * `nekopi.degresEnRadians(degres)` : Convertit des degrés en radians.
+ * `nekopi.radiansEnDegres(radians)` : Convertit des radians en degrés.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("La valeur de Pi est :", nekomaths.nekopi.valeur); // Affiche Math.PI
+
+// Calculs de cercle
+console.log("Circonférence d'un cercle de rayon 5 :", nekomaths.nekopi.circonference(5));
+console.log("Aire d'un cercle de rayon 5 :", nekomaths.nekopi.aireCercle(5));
+
+// Conversions d'angles
+console.log("90 degrés en radians :", nekomaths.nekopi.degresEnRadians(90)); // Renvoie 1.57... (Pi/2)
+console.log("1.5708 radians en degrés :", nekomaths.nekopi.radiansEnDegres(1.5708)); // Renvoie ~90
+```
+
+## 6. Calculs Trigonométriques et Angles (nekdegres)
+L'objet nekdegres fournit des fonctions pour manipuler et calculer des angles en degrés.
+ * `nekdegres.enDegres(radians)` : Convertit des radians en degrés.
+ * `nekdegres.enRadians(degres)` : Convertit des degrés en radians.
+ * `nekdegres.sinus(degres)` : Calcule le sinus d'un angle en degrés.
+ * `nekdegres.cosinus(degres)` : Calcule le cosinus d'un angle en degrés.
+ * `nekdegres.tangente(degres)` : Calcule la tangente d'un angle en degrés.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Conversions
+console.log("Pi/2 radians en degrés :", nekomaths.nekdegres.enDegres(Math.PI / 2)); // Renvoie 90
+console.log("45 degrés en radians :", nekomaths.nekdegres.enRadians(45)); // Renvoie 0.785... (Pi/4)
+
+// Fonctions trigonométriques
+console.log("Sinus de 90 degrés :", nekomaths.nekdegres.sinus(90)); // Renvoie 1
+console.log("Cosinus de 0 degré :", nekomaths.nekdegres.cosinus(0)); // Renvoie 1
+console.log("Tangente de 45 degrés :", nekomaths.nekdegres.tangente(45)); // Renvoie 1
+```
+
+## 7. Conversions d'Unités
+
+### 7.1 Conversions Métriques (neky)
+ * `neky.metersToKilometers(meters)` : Convertit des mètres en kilomètres.
+ * `neky.kilometersToMeters(kilometers)` : Convertit des kilomètres en mètres.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("1000 mètres =", nekomaths.neky.metersToKilometers(1000), "kilomètres"); // Renvoie 1
+console.log("2.5 kilomètres =", nekomaths.neky.kilometersToMeters(2.5), "mètres"); // Renvoie 2500
+```
+
+### 7.2 Conversions de Poids (neklet)
+ * `neklet.kilosToTonnes(kilos)` : Convertit des kilos en tonnes.
+ * `neklet.tonnesToKilos(tonnes)` : Convertit des tonnes en kilos.
+ * `neklet.gramsToKilograms(grams)` : Convertit des grammes en kilogrammes.
+ * `neklet.kilogramsToGrams(kilograms)` : Convertit des kilogrammes en grammes.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("1500 kilos =", nekomaths.neklet.kilosToTonnes(1500), "tonnes"); // Renvoie 1.5
+console.log("2.5 tonnes =", nekomaths.neklet.tonnesToKilos(2.5), "kilos"); // Renvoie 2500
+console.log("1500 grammes =", nekomaths.neklet.gramsToKilograms(1500), "kg"); // Renvoie 1.5
+```
+
+## 8. Calculs de Pourcentage
+ * `nekpourcentage(total, pourcentage)` : Calcule le pourcentage d'un nombre.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("20% de 150 =", nekomaths.nekpourcentage(150, 20)); // Renvoie 30
+```
+
+## 9. Théorèmes Géométriques
+
+### 9.1 Théorème de Pythagore (nektalor)
+ * `nektalor.hypotenuse(a, b)` : Calcule l'hypoténuse d'un triangle rectangle.
+ * `nektalor.coteAdjacent(hypotenuse, cote)` : Calcule un côté adjacent.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Hypoténuse d'un triangle 3-4 :", nekomaths.nektalor.hypotenuse(3, 4)); // Renvoie 5
+console.log("Côté adjacent (hyp=5, côté=3) :", nekomaths.nektalor.coteAdjacent(5, 3)); // Renvoie 4
+```
+
+### 9.2 Théorème de Thalès (nektales)
+ * `nektales.proportionnalite(a, b, c)` : Calcule la quatrième proportionnelle selon Thalès.
+ * `nektales.verifierProportionnalite(a, b, c, d)` : Vérifie si quatre segments sont proportionnels.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Quatrième proportionnelle (2,3,4) :", nekomaths.nektales.proportionnalite(2, 3, 4)); // Renvoie 6
+console.log("Proportionnalité (2,3,4,6) :", nekomaths.nektales.verifierProportionnalite(2, 3, 4, 6)); // Renvoie true
+```
+
+## 10. Calculs de Probabilité (nekproba)
+ * `nekproba.probabiliteSimple(evenementsFavorables, evenementsPossibles)` : Calcule une probabilité simple.
+ * `nekproba.probabiliteInverse(probabilite)` : Calcule la probabilité inverse.
+ * `nekproba.probabiliteUnion(probA, probB, probIntersection)` : Calcule P(A ∪ B).
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Probabilité (2 sur 6) :", nekomaths.nekproba.probabiliteSimple(2, 6)); // Renvoie 0.333...
+console.log("Probabilité inverse (0.25) :", nekomaths.nekproba.probabiliteInverse(0.25)); // Renvoie 0.75
+console.log("Probabilité union :", nekomaths.nekproba.probabiliteUnion(0.3, 0.4, 0.1)); // Renvoie 0.6
+```
+
+## 11. Fonctionnalités Créatives et Personnalisation
+
+### 11.1 Messages Personnalisés (nekbel)
+ * `nekbel.message(contenu, type, options)` : Affiche des messages personnalisés.
+ * `nekbel.executer(nom, fonction, ...args)` : Exécute des fonctions avec gestion d'erreurs.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Message personnalisé
+nekomaths.nekbel.message("Calcul terminé avec succès!", "success", {prefix: "🎉"});
+
+// Exécution sécurisée
+const resultat = nekomaths.nekbel.executer("addition", nekomaths.nekadd, 5, 3);
+console.log(resultat);
+```
+
+### 11.2 Outils Créatifs (nekcreative)
+ * `nekcreative.generateId(prefix)` : Génère des identifiants uniques.
+ * `nekcreative.chronometer(func, nom)` : Mesure le temps d'exécution des fonctions.
+ * `nekcreative.memoize(func)` : Met en cache les résultats des fonctions.
+ * `nekcreative.couleurAleatoire(format)` : Génère des couleurs aléatoires.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Génération d'ID
+console.log(nekomaths.nekcreative.generateId("projet")); // "projet_abc123_xyz789"
+
+// Couleur aléatoire
+console.log(nekomaths.nekcreative.couleurAleatoire("hex")); // "#a1b2c3"
+console.log(nekomaths.nekcreative.couleurAleatoire("rgb")); // "rgb(123, 45, 67)"
+```
+
+### 11.3 Gestion d'Erreurs Personnalisée (nekorror)
+ * `nekorror.definirMessage(codeErreur, message)` : Définit des messages d'erreur personnalisés.
+ * `nekorror.lancerErreur(codeErreur, donnees)` : Lance des erreurs avec messages personnalisés.
+ * `nekorror.executer(fonction, gestionErreur)` : Exécute des fonctions avec gestion d'erreurs.
+ * `nekorror.log(niveau, message, donnees)` : Logger avec différents niveaux.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Définir un message d'erreur personnalisé
+nekomaths.nekorror.definirMessage("DIVISION_ZERO", "Impossible de diviser par zéro !");
+
+// Logger des informations
+nekomaths.nekorror.log("info", "Calcul en cours...");
+nekomaths.nekorror.log("error", "Une erreur est survenue", {valeur: 42});
+```
+
+## 12. Nouvelles Fonctionnalités Créatives
+
+### 12.1 Dessin ASCII (nekdraw)
+ * `nekdraw.rectangle(largeur, hauteur, caractere)` : Dessine un rectangle dans la console.
+ * `nekdraw.triangle(taille, caractere)` : Dessine un triangle dans la console.
+ * `nekdraw.afficher(dessin)` : Affiche le dessin dans la console.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Dessiner un rectangle
+const rect = nekomaths.nekdraw.rectangle(5, 3, '#');
+nekomaths.nekdraw.afficher(rect);
+// Affiche:
+// #####
+// #####
+// #####
+
+// Dessiner un triangle
+const triangle = nekomaths.nekdraw.triangle(4, '*');
+nekomaths.nekdraw.afficher(triangle);
+// Affiche:
+//    *
+//   ***
+//  *****
+// *******
+```
+
+### 12.2 Arrondi Personnalisé (nekril)
+ * `nekril(nombre, decimales)` : Arrondit un nombre décimal au nombre de décimales spécifié.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log(nekomaths.nekril(3.14159, 2)); // Renvoie 3.14
+console.log(nekomaths.nekril(2.7777777, 4)); // Renvoie 2.7778
+console.log(nekomaths.nekril(10.555, 1)); // Renvoie 10.6
+```
+
+### 12.3 Calculs avec Mots Anglais (nekocust)
+ * `nekocust.motEnNombre(mot)` : Convertit un mot anglais en nombre.
+ * `nekocust.additionMots(mot1, mot2)` : Additionne deux nombres écrits en lettres.
+ * `nekocust.soustractionMots(mot1, mot2)` : Soustrait deux nombres écrits en lettres.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log(nekomaths.nekocust.motEnNombre("four")); // Renvoie 4
+console.log(nekomaths.nekocust.additionMots("three", "seven")); // Renvoie 10
+console.log(nekomaths.nekocust.soustractionMots("ten", "four")); // Renvoie 6
+```
+
+### 12.4 Addition d'Objets Créatifs (nekrect)
+ * `nekrect.additionObjets(objet1, objet2, propriete)` : Additionne deux objets selon une propriété.
+ * `nekrect.decrireOperation(objet1, objet2, propriete)` : Décrit l'opération effectuée.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Addition d'aires
+console.log(nekomaths.nekrect.additionObjets("rectangle", "carre", "aire")); // Renvoie 16
+console.log(nekomaths.nekrect.additionObjets("poule", "poire", "valeur")); // Renvoie 20
+
+// Description de l'opération
+console.log(nekomaths.nekrect.decrireOperation("rectangle", "carre", "aire"));
+// Renvoie: "Addition de rectangle + carre (aire) = 16"
+```
+
+## 13. Théorèmes Géométriques Avancés
+
+### 13.1 Théorème de Pappus (nekpap)
+ * `nekpap.volumePappus(aire, distanceCentroide)` : Calcule le volume selon Pappus-Guldinus.
+ * `nekpap.airePappus(longueur, distanceCentroide)` : Calcule l'aire selon Pappus-Guldinus.
+ * `nekpap.centroideVolume(volume, aire)` : Calcule la distance du centroïde.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Volume Pappus :", nekomaths.nekpap.volumePappus(10, 5)); // Volume généré
+console.log("Aire Pappus :", nekomaths.nekpap.airePappus(8, 3)); // Aire générée
+console.log("Centroïde :", nekomaths.nekpap.centroideVolume(100, 4)); // Distance centroïde
+```
+
+### 13.2 Théorème de Desargues (nekdesar)
+ * `nekdesar.pointsAlignes(point1, point2, point3)` : Vérifie si trois points sont alignés.
+ * `nekdesar.intersectionDroites(p1, p2, p3, p4)` : Calcule l'intersection de deux droites.
+ * `nekdesar.verifierDesargues(triangle1, triangle2)` : Vérifie la configuration de Desargues.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Vérifier l'alignement
+const p1 = {x: 0, y: 0};
+const p2 = {x: 1, y: 1};
+const p3 = {x: 2, y: 2};
+console.log(nekomaths.nekdesar.pointsAlignes(p1, p2, p3)); // Renvoie true
+
+// Intersection de droites
+const intersection = nekomaths.nekdesar.intersectionDroites(
+    {x: 0, y: 0}, {x: 2, y: 2},
+    {x: 0, y: 2}, {x: 2, y: 0}
+);
+console.log(intersection); // {x: 1, y: 1}
+
+// Configuration de Desargues
+const triangle1 = [{x: 0, y: 0}, {x: 2, y: 0}, {x: 1, y: 2}];
+const triangle2 = [{x: 1, y: 1}, {x: 3, y: 1}, {x: 2, y: 3}];
+console.log(nekomaths.nekdesar.verifierDesargues(triangle1, triangle2));
+```
+
+## 14. Nouvelles Fonctionnalités v1.4.0
+
+### 14.1 Résolution d'Équations avec Variable (nekident)
+ * `nekident.resoudreLineaire(a, b, resultat)` : Résout ax + b = resultat pour trouver x.
+ * `nekident.verifierSolution(x, operation, operande, resultatAttendu)` : Vérifie une solution.
+ * `nekident.trouverX(operation, operande, resultatAttendu)` : Trouve x pour une opération donnée.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Résoudre 2x + 5 = 15 (x = 5)
+console.log("Solution de 2x + 5 = 15 :", nekomaths.nekident.resoudreLineaire(2, 5, 15)); // Renvoie 5
+
+// Vérifier si x = 4 est solution de x + 3 = 7
+console.log("Vérification :", nekomaths.nekident.verifierSolution(4, 'add', 3, 7)); // Renvoie true
+
+// Trouver x pour x * 3 = 12
+console.log("x pour x * 3 = 12 :", nekomaths.nekident.trouverX('mult', 3, 12)); // Renvoie 4
+```
+
+### 14.2 Équations Complexes (nekaqua)
+ * `nekaqua.quadratique(a, b, c)` : Résout ax² + bx + c = 0.
+ * `nekaqua.systeme2x2(a1, b1, c1, a2, b2, c2)` : Résout un système 2x2.
+ * `nekaqua.evaluerPolynome(coefficients, x)` : Évalue un polynôme.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Résoudre x² - 5x + 6 = 0
+const equation = nekomaths.nekaqua.quadratique(1, -5, 6);
+console.log("Solutions quadratique :", equation); // x1 = 3, x2 = 2
+
+// Système d'équations 2x + 3y = 7, x - y = 1
+const systeme = nekomaths.nekaqua.systeme2x2(2, 3, 7, 1, -1, 1);
+console.log("Solution système :", systeme); // x = 2, y = 1
+
+// Évaluer P(x) = 2x² + 3x + 1 pour x = 2
+console.log("P(2) =", nekomaths.nekaqua.evaluerPolynome([2, 3, 1], 2)); // Renvoie 15
+```
+
+### 14.3 Calculs de Fractions (nekfrac)
+ * `nekfrac.simplifier(numerateur, denominateur)` : Simplifie une fraction.
+ * `nekfrac.additionner(num1, den1, num2, den2)` : Additionne deux fractions.
+ * `nekfrac.multiplier(num1, den1, num2, den2)` : Multiplie deux fractions.
+ * `nekfrac.pgcd(a, b)` : Calcule le PGCD.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Simplifier 12/18
+console.log("12/18 simplifié :", nekomaths.nekfrac.simplifier(12, 18)); // 2/3
+
+// Additionner 1/3 + 1/4
+const addition = nekomaths.nekfrac.additionner(1, 3, 1, 4);
+console.log("1/3 + 1/4 =", addition); // 7/12
+
+// Multiplier 2/3 * 3/4
+const multiplication = nekomaths.nekfrac.multiplier(2, 3, 3, 4);
+console.log("2/3 * 3/4 =", multiplication); // 1/2
+```
+
+### 14.4 Calculs avec Puissances (nektin)
+ * `nektin.resoudreCarree(a, b)` : Résout ax² = b.
+ * `nektin.resoudreCube(a, b)` : Résout ax³ = b.
+ * `nektin.fractionPuissance(num, den, exposant)` : Calcule (num/den)^exposant.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Résoudre 2x² = 8 (x = ±2)
+console.log("Solutions de 2x² = 8 :", nekomaths.nektin.resoudreCarree(2, 8));
+
+// Résoudre x³ = 27 (x = 3)
+console.log("Solution de x³ = 27 :", nekomaths.nektin.resoudreCube(1, 27));
+
+// Calculer (3/4)²
+console.log("(3/4)² =", nekomaths.nektin.fractionPuissance(3, 4, 2));
+```
+
+### 14.5 Nombre Alpha (nekalpha)
+ * `nekalpha.valeur` : Constante alpha de Feigenbaum.
+ * `nekalpha.serie(n)` : Calcule une série basée sur alpha.
+ * `nekalpha.transformation(x)` : Transformation alpha.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Constante alpha :", nekomaths.nekalpha.valeur);
+console.log("Série alpha (10 termes) :", nekomaths.nekalpha.serie(10));
+console.log("Transformation alpha(0.5) :", nekomaths.nekalpha.transformation(0.5));
+```
+
+### 14.6 Nombre Beta (nekbeta)
+ * `nekbeta.fonction(a, b)` : Fonction beta d'Euler.
+ * `nekbeta.gamma(x)` : Approximation de la fonction gamma.
+ * `nekbeta.distribution(x, alpha, beta)` : Distribution beta.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Beta(2, 3) :", nekomaths.nekbeta.fonction(2, 3));
+console.log("Gamma(4) :", nekomaths.nekbeta.gamma(4));
+console.log("Distribution beta :", nekomaths.nekbeta.distribution(0.5, 2, 3));
+```
+
+### 14.7 Nombre Omega (nekomega)
+ * `nekomega.spirale(t)` : Calcule la spirale d'or.
+ * `nekomega.fibonacciOmega(n)` : Fibonacci modifié avec omega.
+ * `nekomega.convergence(iterations)` : Calcul de convergence.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+console.log("Spirale omega :", nekomaths.nekomega.spirale(1));
+console.log("Fibonacci omega(10) :", nekomaths.nekomega.fibonacciOmega(10));
+console.log("Convergence omega :", nekomega.convergence(5));
+```
+
+### 14.8 Comparaison de Nombres (nekcopare)
+ * `nekcopare.comparer(a, b)` : Compare deux nombres.
+ * `nekcopare.maximum(nombres)` : Trouve le maximum dans un tableau.
+ * `nekcopare.minimum(nombres)` : Trouve le minimum dans un tableau.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Comparer 5 et 8
+const comparaison = nekomaths.nekcopare.comparer(5, 8);
+console.log("Comparaison :", comparaison); // 5 < 8
+
+// Trouver le maximum
+const nombres = [3, 7, 2, 9, 1];
+console.log("Maximum :", nekomaths.nekcopare.maximum(nombres)); // 9
+
+// Trouver le minimum
+console.log("Minimum :", nekomaths.nekcopare.minimum(nombres)); // 1
+```
+
+### 14.9 Base de Données Personnalisée (nekdone)
+ * `nekdone.creerBase(nom, structure)` : Crée une base de données.
+ * `nekdone.ajouterDonnee(nomBase, donnee)` : Ajoute des données.
+ * `nekdone.calculer(nomBase, propriete, operation)` : Effectue des calculs.
+ * `nekdone.obtenirBase(nomBase)` : Obtient les informations d'une base.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Créer une base de données
+nekomaths.nekdone.creerBase("ventes", ["produit", "prix", "quantite"]);
+
+// Ajouter des données
+nekomaths.nekdone.ajouterDonnee("ventes", {produit: "ordinateur", prix: 800, quantite: 2});
+nekomaths.nekdone.ajouterDonnee("ventes", {produit: "souris", prix: 25, quantite: 5});
+
+// Calculer la somme des prix
+const sommePrix = nekomaths.nekdone.calculer("ventes", "prix", "somme");
+console.log("Somme des prix :", sommePrix);
+
+// Obtenir toute la base
+const base = nekomaths.nekdone.obtenirBase("ventes");
+console.log("Base de données :", base);
+```
+
+### 14.10 Arithmétique Personnalisée (nekarin)
+ * `nekarin.enregistrerFonction(nom, fonction, description)` : Enregistre une fonction.
+ * `nekarin.executer(nom, ...args)` : Exécute une fonction personnalisée.
+ * `nekarin.combiner(nom1, nom2, operation, ...args)` : Combine deux fonctions.
+ * `nekarin.listerFonctions()` : Liste toutes les fonctions enregistrées.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Enregistrer une fonction personnalisée
+nekomaths.nekarin.enregistrerFonction("double", (x) => x * 2, "Multiplie par 2");
+nekomaths.nekarin.enregistrerFonction("carre", (x) => x * x, "Met au carré");
+
+// Exécuter les fonctions
+console.log("Double de 5 :", nekomaths.nekarin.executer("double", 5)); // 10
+console.log("Carré de 4 :", nekomaths.nekarin.executer("carre", 4)); // 16
+
+// Combiner les fonctions (double + carré pour x=3)
+const resultat = nekomaths.nekarin.combiner("double", "carre", "add", 3);
+console.log("Double(3) + Carré(3) =", resultat); // 6 + 9 = 15
+
+// Lister toutes les fonctions
+console.log("Fonctions enregistrées :", nekomaths.nekarin.listerFonctions());
+```
+
+## 15. Nouvelles Fonctionnalités v1.5.0
+
+### 15.1 Tracé de Graphiques (nekgrap)
+ * `nekgrap.genererPoints(func, xMin, xMax, pas)` : Génère des points pour tracer une fonction.
+ * `nekgrap.afficherConsole(points, largeur, hauteur)` : Affiche un graphique ASCII dans la console.
+ * `nekgrap.tracer(func, options)` : Trace et affiche une fonction directement.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Tracer une fonction quadratique
+const points = nekomaths.nekgrap.tracer(x => x * x, {
+    xMin: -5,
+    xMax: 5,
+    pas: 0.1,
+    largeur: 60,
+    hauteur: 15
+});
+
+// Tracer une fonction sinus
+nekomaths.nekgrap.tracer(Math.sin, { xMin: -Math.PI, xMax: Math.PI });
+```
+
+### 15.2 Progressions et Séries (nekoser)
+ * `nekoser.arithmetique(premier, raison, n)` : Calcule une progression arithmétique.
+ * `nekoser.geometrique(premier, raison, n)` : Calcule une progression géométrique.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Progression arithmétique : 2, 5, 8, 11, 14
+const arith = nekomaths.nekoser.arithmetique(2, 3, 5);
+console.log("Termes :", arith.termes); // [2, 5, 8, 11, 14]
+console.log("Somme :", arith.somme); // 40
+
+// Progression géométrique : 1, 2, 4, 8, 16
+const geom = nekomaths.nekoser.geometrique(1, 2, 5);
+console.log("Termes :", geom.termes); // [1, 2, 4, 8, 16]
+console.log("Somme :", geom.somme); // 31
+```
+
+### 15.3 Séries Infinies (neka)
+ * `neka.serieGeometriqueInfinie(premier, raison)` : Calcule la somme d'une série géométrique infinie.
+ * `neka.approximerSerie(termFunction, maxTermes, precision)` : Approxime une série par calcul de termes.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Série géométrique infinie 1 + 1/2 + 1/4 + 1/8 + ... = 2
+const sommeInfinie = nekomaths.neka.serieGeometriqueInfinie(1, 0.5);
+console.log("Somme infinie :", sommeInfinie); // 2
+
+// Approximer la série harmonique
+const harmonique = nekomaths.neka.approximerSerie(n => 1/n, 1000);
+console.log("Approximation :", harmonique);
+```
+
+### 15.4 Matrices et Inversions (nekoma)
+ * `nekoma.creer(donnees)` : Crée une matrice à partir d'un tableau 2D.
+ * `nekoma.inverser2x2(matrice)` : Calcule l'inverse d'une matrice 2x2.
+ * `nekoma.multiplier(matrice1, matrice2)` : Multiplie deux matrices.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Créer et inverser une matrice 2x2
+const matrice = nekomaths.nekoma.creer([[2, 1], [1, 1]]);
+const inverse = nekomaths.nekoma.inverser2x2(matrice);
+console.log("Matrice inverse :", inverse.donnees);
+
+// Multiplication de matrices
+const produit = nekomaths.nekoma.multiplier(matrice, inverse);
+console.log("Produit (devrait être identité) :", produit.donnees);
+```
+
+### 15.5 Déterminants (nekyu)
+ * `nekyu.determinant2x2(matrice)` : Calcule le déterminant d'une matrice 2x2.
+ * `nekyu.determinant3x3(matrice)` : Calcule le déterminant d'une matrice 3x3.
+ * `nekyu.identite(taille)` : Crée une matrice identité.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Déterminant 2x2
+const matrice2x2 = nekomaths.nekoma.creer([[3, 2], [1, 4]]);
+const det2x2 = nekomaths.nekyu.determinant2x2(matrice2x2);
+console.log("Déterminant 2x2 :", det2x2); // 10
+
+// Créer une matrice identité 3x3
+const identite = nekomaths.nekyu.identite(3);
+console.log("Matrice identité :", identite.donnees);
+```
+
+### 15.6 Méthode de Newton-Raphson (nekonew)
+ * `nekonew.trouverRacine(func, derivee, x0, tolerance, maxIterations)` : Trouve une racine par Newton-Raphson.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Trouver la racine de x² - 2 = 0 (√2)
+const func = x => x * x - 2;
+const derivee = x => 2 * x;
+const resultat = nekomaths.nekonew.trouverRacine(func, derivee, 1);
+console.log("Racine trouvée :", resultat.racine); // ≈ 1.414
+console.log("Convergé :", resultat.converge);
+```
+
+### 15.7 Méthode de Monte Carlo (nekcarlo)
+ * `nekcarlo.estimerPi(nombrePoints)` : Estime π par simulation Monte Carlo.
+ * `nekcarlo.integrer(func, a, b, nombrePoints)` : Calcule une intégrale par Monte Carlo.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Estimer π
+const estimationPi = nekomaths.nekcarlo.estimerPi(1000000);
+console.log("Estimation de π :", estimationPi.estimation);
+console.log("Erreur :", estimationPi.erreur);
+
+// Intégrer x² de 0 à 1
+const integrale = nekomaths.nekcarlo.integrer(x => x * x, 0, 1, 100000);
+console.log("Intégrale de x² :", integrale.estimation); // ≈ 0.333
+```
+
+### 15.8 Interface Interactive (nekinterac)
+ * `nekinterac.creerMenu(options)` : Crée un menu interactif.
+ * `nekinterac.calculateur(operation)` : Affiche un calculateur interactif.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Créer un menu
+const menu = nekomaths.nekinterac.creerMenu({
+    titre: "Calculatrice",
+    choix: [
+        { nom: "Addition" },
+        { nom: "Multiplication" },
+        { nom: "Graphiques" }
+    ]
+});
+console.log(menu);
+
+// Interface de calculateur
+const calc = nekomaths.nekinterac.calculateur('addition');
+console.log(calc);
+```
+
+### 15.9 Conversions Avancées (nekconvert)
+ * `nekconvert.convertir(valeur, uniteSource, uniteCible, type)` : Convertit entre différentes unités.
+ * `nekconvert.convertirTemperature(valeur, uniteSource, uniteCible)` : Conversions de température.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Conversion de longueur
+const metres = nekomaths.nekconvert.convertir(100, 'metre', 'pied', 'longueur');
+console.log("100 mètres =", metres, "pieds");
+
+// Conversion de température
+const fahrenheit = nekomaths.nekconvert.convertirTemperature(0, 'celsius', 'fahrenheit');
+console.log("0°C =", fahrenheit, "°F"); // 32°F
+
+// Conversion de poids
+const livres = nekomaths.nekconvert.convertir(10, 'kilogramme', 'livre', 'poids');
+console.log("10 kg =", livres, "livres");
+```
+
+### 15.10 Historique des Calculs (nekohis)
+ * `nekohis.ajouter(operation, resultat, parametres)` : Ajoute un calcul à l'historique.
+ * `nekohis.obtenirHistorique()` : Récupère l'historique complet.
+ * `nekohis.reutiliser(id)` : Réutilise un calcul précédent.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Ajouter des calculs à l'historique
+nekomaths.nekohis.ajouter("Addition", 15, [10, 5]);
+nekomaths.nekohis.ajouter("Multiplication", 50, [10, 5]);
+
+// Voir l'historique
+const historique = nekomaths.nekohis.obtenirHistorique();
+console.log("Historique :", historique);
+
+// Réutiliser un résultat
+const ancienResultat = nekomaths.nekohis.reutiliser(1);
+console.log("Ancien résultat :", ancienResultat);
+```
+
+### 15.11 Algorithmes d'Optimisation (nekalgo)
+ * `nekalgo.descenteGradient(func, gradient, x0, tauxApprentissage, maxIterations)` : Optimisation par descente de gradient.
+ * `nekalgo.rechercheBruteForce(func, a, b, pas)` : Recherche par force brute.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Minimiser f(x) = x² - 4x + 3
+const func = x => x * x - 4 * x + 3;
+const gradient = x => 2 * x - 4;
+const resultat = nekomaths.nekalgo.descenteGradient(func, gradient, 0, 0.1);
+console.log("Minimum trouvé en x =", resultat.minimum); // ≈ 2
+console.log("Valeur minimum =", resultat.valeurMinimum); // ≈ -1
+
+// Recherche par force brute
+const brutForce = nekomaths.nekalgo.rechercheBruteForce(func, 0, 5, 0.01);
+console.log("Minimum par force brute :", brutForce);
+```
+
+### 15.12 Algorithmes Personnalisés (nekeit)
+ * `nekeit.creer(nom, algorithme, description)` : Crée un algorithme personnalisé.
+ * `nekeit.executer(nom, ...args)` : Exécute un algorithme.
+ * `nekeit.lister()` : Liste tous les algorithmes.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Créer un algorithme personnalisé
+nekomaths.nekeit.creer("fibonacci", function(n) {
+    if (n <= 1) return n;
+    return this.executer("fibonacci", n-1) + this.executer("fibonacci", n-2);
+}, "Calcule le n-ième nombre de Fibonacci");
+
+// Créer un algorithme de tri
+nekomaths.nekeit.creer("triRapide", function(arr) {
+    if (arr.length <= 1) return arr;
+    const pivot = arr[Math.floor(arr.length / 2)];
+    const left = arr.filter(x => x < pivot);
+    const middle = arr.filter(x => x === pivot);
+    const right = arr.filter(x => x > pivot);
+    return [...this.executer("triRapide", left), ...middle, ...this.executer("triRapide", right)];
+}, "Tri rapide (quicksort)");
+
+// Exécuter les algorithmes
+console.log("Fibonacci(10) :", nekomaths.nekeit.executer("fibonacci", 10));
+console.log("Tri [3,1,4,1,5] :", nekomaths.nekeit.executer("triRapide", [3,1,4,1,5]));
+
+// Lister les algorithmes
+console.log("Algorithmes :", nekomaths.nekeit.lister());
+```
+
+### 15.13 Coûts de Distribution (neksrar)
+ * `neksrar.coutTransport(distance, coutParKm, poids)` : Calcule le coût de transport.
+ * `neksrar.coutStockage(volume, duree, coutParM3Jour)` : Calcule le coût de stockage.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Coût de transport
+const transport = nekomaths.neksrar.coutTransport(150, 1.2, 25);
+console.log("Coût de transport :", transport);
+// { distance: 150, coutParKm: 1.2, poids: 25, coutTotal: 198 }
+
+// Coût de stockage
+const stockage = nekomaths.neksrar.coutStockage(10, 30, 2.5);
+console.log("Coût de stockage :", stockage);
+// { volume: 10, duree: 30, coutTotal: 750 }
+```
+
+### 15.14 Gestion Financière d'Entreprise (nekgef)
+ * `nekgef.calculerBFR(stocks, creancesClients, dettesFournisseurs)` : Calcule le BFR.
+ * `nekgef.calculerFRNG(capitauxPermanents, immobilisations)` : Calcule le FRNG.
+ * `nekgef.calculerTresorerieNette(frng, bfr)` : Calcule la trésorerie nette.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Calcul du BFR
+const bfr = nekomaths.nekgef.calculerBFR(50000, 30000, 20000);
+console.log("BFR :", bfr);
+// { bfr: 60000, interpretation: "Besoin de financement" }
+
+// Calcul du FRNG
+const frng = nekomaths.nekgef.calculerFRNG(200000, 150000);
+console.log("FRNG :", frng);
+// { frng: 50000, interpretation: "Équilibre financier" }
+
+// Trésorerie nette
+const tresorerie = nekomaths.nekgef.calculerTresorerieNette(50000, 60000);
+console.log("Trésorerie :", tresorerie);
+// { tresorerieNette: -10000, interpretation: "Trésorerie négative" }
+```
+
+### 15.15 Calculs d'Immobilisations (nekpo)
+ * `nekpo.amortissementLineaire(valeurInitiale, dureeVie, valeurResiduelle)` : Calcule l'amortissement linéaire.
+ * `nekpo.plusMoinsValue(prixCession, valeurComptable)` : Calcule la plus ou moins-value de cession.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Amortissement linéaire d'un équipement
+const amortissement = nekomaths.nekpo.amortissementLineaire(100000, 5, 10000);
+console.log("Plan d'amortissement :", amortissement);
+// Annuité : 18000 par an pendant 5 ans
+
+// Plus ou moins-value de cession
+const cession = nekomaths.nekpo.plusMoinsValue(45000, 40000);
+console.log("Plus-value :", cession);
+// { plusMoinsValue: 5000, type: "Plus-value" }
+```
+
+### 15.16 TVA et Inflation (nekia)
+ * `nekia.calculerTVA(montantHT, tauxTVA)` : Calcule la TVA.
+ * `nekia.calculerHT(montantTTC, tauxTVA)` : Calcule le montant HT à partir du TTC.
+ * `nekia.calculerInflation(valeurInitiale, valeurFinale, annees)` : Calcule le taux d'inflation.
+
+```javascript
+const nekomaths = require('nekomaths');
+
+// Calcul de TVA
+const tva = nekomaths.nekia.calculerTVA(1000, 20);
+console.log("Calcul TVA :", tva);
+// { montantHT: 1000, montantTVA: 200, montantTTC: 1200 }
+
+// Calcul HT à partir du TTC
+const ht = nekomaths.nekia.calculerHT(1200, 20);
+console.log("Calcul HT :", ht);
+// { montantTTC: 1200, montantHT: 1000, montantTVA: 200 }
+
+// Calcul d'inflation
+const inflation = nekomaths.nekia.calculerInflation(100, 105, 1);
+console.log("Inflation :", inflation);
+// { tauxPourcentage: 5, interpretation: "5% d'inflation par an" }
+```
+
+**Contribution**
+
+Les contributions sont les bienvenues ! Si vous avez des idées de nouvelles fonctions, des améliorations ou des corrections de bugs, n'hésitez pas à ouvrir une issue ou à soumettre une pull request sur le dépôt GitHub.
+
+**Lien de notre documentation officielle**
+
+https://nekocute-math-tools.lovable.app

package-2.json

@@ -0,0 +1,27 @@
+{
+  "name": "nekomaths",
+  "version": "1.5.0",
+  "description": "Un package utilitaire mathématique simple et convivial par Nekoclem",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "math",
+    "calculations",
+    "numbers",
+    "utility",
+    "nekomaths",
+    "nekoclem"
+  ],
+  "author": "nekoclem <ton-email@exemple.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clem27game/NEKOMATHS.git"
+  },
+  "bugs": {
+    "url": "https://github.com/clem27game/NEKOMATHS/issues"
+  },
+  "homepage": "https://github.com/nekoclem/nekomaths#readme"
+}

package-lock-2.json

@@ -0,0 +1,13 @@
+{
+  "name": "nekomaths",
+  "version": "1.5.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "nekomaths",
+      "version": "1.5.0",
+      "license": "MIT"
+    }
+  }
+}