|
|
--- |
|
|
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 |
