| | --- |
| | license: mit |
| | --- |
| | |
| | **Nekomaths** |
| |
|
| |  |
| |
|
| |
|
| | 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 |
| |
|
| | **Pour télécharger la dernière version complète** : https://www.npmjs.com/package/nekomaths?activeTab=readme |
