math-exercises 2.0.0 → 2.0.2

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIjE;;;;;;;EAOE;AAEF,QAAA,MAAM,gBAAgB,0BAAiB,CAAC;AAExC,QAAA,MAAM,4BAA4B;aACT,WAAW;UAAQ,YAAY,EAAE;GAkBzD,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,4BAA4B,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/index.js

@@ -1,33 +1,61 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllMathExercisesBySection = exports.allMathExercises = void 0;
-const exercises_1 = require("./exercises/exercises");
+exports.mathExercises = void 0;
 /**
  * TODO
  * Décimal : permettre facilement -0.xxx
  * Tree shaking export
  *
+ * VEA:
+ *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+ *      ->> faire le meme delire que pour les power mais pour les opposite ?
+ *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+ *  -> faire des nodes pour les Ensembles de nombre
+ *
+ * !-> choses pour lesquelles la v1 ne marchera pas :
+ *  !-- fractions non réduites
+ *  !-- nbs décimaux avec des 0
+ *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+ * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+ *
+ * Passer les sqrtNode en tree-iable
  *
+ *
+ *
+ * !!!à fix :
+ * ! fraction réductible
+ * ! 0,20 au lieu de 0,2
+ * ! moins partout dans fraction
+ * !puissances négatives vers inverse fraction
+ * ! simplification du ln
+ * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+ *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+ * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
 
 */
-const allMathExercises = [...exercises_1.exercises];
-exports.allMathExercises = allMathExercises;
-const getAllMathExercisesBySection = () => {
-    const data = [];
-    allMathExercises.forEach((exo) => {
-        const sectionsData = data.filter((el) => exo.sections.includes(el.section));
-        if (!sectionsData.length) {
-            exo.sections.forEach((section) => data.push({
-                section,
-                exos: [exo],
-            }));
-        }
-        else {
-            sectionsData.forEach((sectionData) => {
-                data.find((d) => d.section === sectionData.section)?.exos.push(exo);
-            });
-        }
-    });
-    return data;
-};
-exports.getAllMathExercisesBySection = getAllMathExercisesBySection;
+const Exercises = __importStar(require("./exercises"));
+const mathExercises = Object.values(Exercises);
+exports.mathExercises = mathExercises;

package/lib/math/complex/complex.d.ts

@@ -1,5 +1,7 @@
-import { ComplexNode } from '../../tree/nodes/complex/complexNode';
-import { AddNode } from '../../tree/nodes/operators/addNode';
+import { ComplexNode } from "../../tree/nodes/complex/complexNode";
+import { OppositeNode } from "../../tree/nodes/functions/oppositeNode";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { FractionNode } from "../../tree/nodes/operators/fractionNode";
 export declare abstract class ComplexConstructor {
     static random(): Complex;
     static randomNotReal(): Complex;
@@ -9,11 +11,15 @@ export declare class Complex {
     im: number;
     constructor(re: number, im: number);
     moduleSquared(): number;
-    inverseNode(): AddNode;
-    divideNode(z: Complex): import("../../tree/nodes/node").Node;
+    inverseNode(): ComplexNode;
+    add(z: Complex): Complex;
+    divideNode(z: Complex): ComplexNode;
     multiply(z: Complex): Complex;
+    times(n: number): Complex;
     opposite(): Complex;
     conjugate(): Complex;
+    toArgumentTree(): NumberNode | FractionNode | OppositeNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | undefined;
+    toModuleTree(): import("../../tree/nodes/node").Node;
     toTree(): ComplexNode;
 }
 //# sourceMappingURL=complex.d.ts.map

package/lib/math/complex/complex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../../src/math/complex/complex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAO7D,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAQb,MAAM,CAAC,aAAa;CAQrB;AACD,qBAAa,OAAO;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;gBACC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIlC,aAAa;IAIb,WAAW;IAQX,UAAU,CAAC,CAAC,EAAE,OAAO;IAYrB,QAAQ,CAAC,CAAC,EAAE,OAAO;IAGnB,QAAQ;IAGR,SAAS;IAGT,MAAM;CAGP"}
+{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../../src/math/complex/complex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAKvE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAQb,MAAM,CAAC,aAAa;CAQrB;AACD,qBAAa,OAAO;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;gBACC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIlC,aAAa;IAIb,WAAW;IAQX,GAAG,CAAC,CAAC,EAAE,OAAO;IAGd,UAAU,CAAC,CAAC,EAAE,OAAO;IAWrB,QAAQ,CAAC,CAAC,EAAE,OAAO;IAMnB,KAAK,CAAC,CAAC,EAAE,MAAM;IAGf,QAAQ;IAGR,SAAS;IAGT,cAAc;IAqBd,YAAY;IAGZ,MAAM;CAGP"}

package/lib/math/complex/complex.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Complex = exports.ComplexConstructor = void 0;
 const complexNode_1 = require("../../tree/nodes/complex/complexNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const piNode_1 = require("../../tree/nodes/numbers/piNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const rational_1 = require("../numbers/rationals/rational");
+const real_1 = require("../numbers/reals/real");
 const randint_1 = require("../utils/random/randint");
 class ComplexConstructor {
     static random() {
@@ -39,34 +41,64 @@ class Complex {
         const conj = this.conjugate();
         const invRe = new rational_1.Rational(conj.re, moduleSq).simplify().toTree();
         const invIm = new rational_1.Rational(conj.im, moduleSq).simplify().toTree();
-        return new addNode_1.AddNode(invRe, new multiplyNode_1.MultiplyNode(invIm, new variableNode_1.VariableNode('i')));
+        return new complexNode_1.ComplexNode(invRe, invIm);
+    }
+    add(z) {
+        return new Complex(this.re + z.re, this.im + z.im);
     }
     divideNode(z) {
         const moduleSq = z.moduleSquared();
-        const newRe = new rational_1.Rational(this.re * z.re + this.im * z.im, moduleSq).simplify().toTree();
-        const newIm = new rational_1.Rational(this.im * z.re - z.im * this.re, moduleSq).simplify().toTree();
-        let imNode;
-        if (newIm.toTex() === '0')
-            return newRe;
-        if (newIm.toTex() === '1')
-            imNode = new variableNode_1.VariableNode('i');
-        else
-            imNode = new multiplyNode_1.MultiplyNode(newIm, new variableNode_1.VariableNode('i'));
-        if (newRe.toTex() === '0')
-            return imNode;
-        return new addNode_1.AddNode(newRe, new multiplyNode_1.MultiplyNode(newIm, new variableNode_1.VariableNode('i')));
+        const newRe = new rational_1.Rational(this.re * z.re + this.im * z.im, moduleSq)
+            .simplify()
+            .toTree();
+        const newIm = new rational_1.Rational(this.im * z.re - z.im * this.re, moduleSq)
+            .simplify()
+            .toTree();
+        return new complexNode_1.ComplexNode(newRe, newIm);
     }
     multiply(z) {
         return new Complex(this.re * z.re - this.im * z.im, this.re * z.im + this.im * z.re);
     }
+    times(n) {
+        return new Complex(this.re * n, this.im * n);
+    }
     opposite() {
         return new Complex(-this.re, -this.im);
     }
     conjugate() {
         return new Complex(this.re, -this.im);
     }
+    toArgumentTree() {
+        if (this.re === 0 && this.im === 0)
+            throw Error("0 n'a pas d'argument");
+        if (this.re === 0) {
+            const piOver2 = new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(2));
+            if (this.im > 0)
+                return piOver2;
+            else
+                return new oppositeNode_1.OppositeNode(piOver2);
+        }
+        if (this.im === 0) {
+            if (this.re > 0)
+                return new numberNode_1.NumberNode(0);
+            else
+                return piNode_1.PiNode;
+        }
+        if (this.re > 0) {
+            //arctan(b/a)
+        }
+        if (this.im > 0) {
+            //arctan(b/a)+pi
+        }
+        if (this.im < 0) {
+            //arctan(b/a)-pi
+        }
+    }
+    toModuleTree() {
+        return new real_1.SquareRoot(this.re ** 2 + this.im ** 2).simplify().toTree();
+    }
     toTree() {
-        return new complexNode_1.ComplexNode(this.re, this.im);
+        return new complexNode_1.ComplexNode(new numberNode_1.NumberNode(this.re), new numberNode_1.NumberNode(this.im));
     }
 }
 exports.Complex = Complex;

package/lib/math/geometry/point.d.ts

@@ -1,5 +1,5 @@
-import { Node } from '../../tree/nodes/node';
-import { MathSet } from '../sets/mathSet';
+import { Node } from "../../tree/nodes/node";
+import { MathSet } from "../sets/mathSet";
 export declare abstract class PointConstructor {
     static random(domainX?: MathSet, domainY?: MathSet): Point;
 }
@@ -10,12 +10,11 @@ export declare class Point {
     constructor(name: string, x: Node, y: Node);
     toTex(): string;
     toTexWithCoords(): string;
+    toCoords(): string;
     getXnumber(): number;
     getYnumber(): number;
     midpoint(B: Point, name?: string): Point;
     distanceTo(B: Point): number;
-    distanceToNode(B: Point): Node;
-    equalTo(B: Point): boolean;
 }
 /**
  * Droite{

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG1C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,OAAO,GAAE,OAAqC,EAAE,OAAO,GAAE,OAAqC,GAAG,KAAK;CAOrH;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAM1C,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAIzB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI;IAO9B,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;CAG3B;AAED;;;;;;;;;;;;GAYG"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI1C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CACX,OAAO,GAAE,OAAqC,EAC9C,OAAO,GAAE,OAAqC,GAC7C,KAAK;CAOT;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAM1C,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;CAK7B;AAED;;;;;;;;;;;;GAYG"}

package/lib/math/geometry/point.js

@@ -1,22 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Point = exports.PointConstructor = void 0;
-const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+const node_1 = require("../../tree/nodes/node");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
-const powerNode_1 = require("../../tree/nodes/operators/powerNode");
-const substractNode_1 = require("../../tree/nodes/operators/substractNode");
-const simplify_1 = require("../../tree/parsers/simplify");
-const mathjs_1 = require("mathjs");
 const intervals_1 = require("../sets/intervals/intervals");
+const rational_1 = require("../numbers/rationals/rational");
 class PointConstructor {
-    static random(domainX = new intervals_1.Interval('[[-10; 10]]'), domainY = new intervals_1.Interval('[[-10; 10]]')) {
+    static random(domainX = new intervals_1.Interval("[[-10; 10]]"), domainY = new intervals_1.Interval("[[-10; 10]]")) {
         const x = domainX.getRandomElement();
         const y = domainY.getRandomElement();
         if (x === null || y === null)
             throw Error("can't build point with thoses sets");
-        return new Point('A', new numberNode_1.NumberNode(x.value), new numberNode_1.NumberNode(y.value));
+        return new Point("A", new numberNode_1.NumberNode(x.value), new numberNode_1.NumberNode(y.value));
     }
 }
 exports.PointConstructor = PointConstructor;
@@ -32,29 +27,35 @@ class Point {
     toTexWithCoords() {
         return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
     }
+    toCoords() {
+        return `\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
+    }
     getXnumber() {
-        return (0, mathjs_1.evaluate)(this.x.toMathString());
+        if (this.x.type !== node_1.NodeType.number)
+            throw Error("general point not implemented yet");
+        return this.x.value;
     }
     getYnumber() {
-        return (0, mathjs_1.evaluate)(this.y.toMathString());
+        if (this.y.type !== node_1.NodeType.number)
+            throw Error("general point not implemented yet");
+        return this.y.value;
     }
-    midpoint(B, name = 'I') {
-        return new Point(name, (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new addNode_1.AddNode(this.x, B.x), new numberNode_1.NumberNode(2))), (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new addNode_1.AddNode(this.y, B.y), new numberNode_1.NumberNode(2))));
+    midpoint(B, name = "I") {
+        const types = [this.x.type, this.y.type, B.x.type, B.y.type];
+        if (types.some((type) => type !== node_1.NodeType.number)) {
+            throw Error("general midpoint not implemented yet");
+        }
+        return new Point(name, new rational_1.Rational(this.x.value + B.x.value, 2)
+            .simplify()
+            .toTree(), new rational_1.Rational(this.y.value + B.y.value, 2)
+            .simplify()
+            .toTree());
     }
     distanceTo(B) {
         const dx = this.getXnumber() - B.getXnumber();
         const dy = this.getYnumber() - B.getYnumber();
         return Math.sqrt(dx ** 2 + dy ** 2);
     }
-    distanceToNode(B) {
-        const dx = new substractNode_1.SubstractNode(this.x, B.x);
-        const dy = new substractNode_1.SubstractNode(this.y, B.y);
-        const sum = new addNode_1.AddNode(new powerNode_1.PowerNode(dx, new numberNode_1.NumberNode(2)), new powerNode_1.PowerNode(dy, new numberNode_1.NumberNode(2)));
-        return new sqrtNode_1.SqrtNode((0, simplify_1.simplifyNode)(sum));
-    }
-    equalTo(B) {
-        return this.getXnumber() === B.getXnumber() && this.getYnumber() === B.getYnumber();
-    }
 }
 exports.Point = Point;
 /**

package/lib/math/geometry/vector.d.ts

@@ -1,5 +1,5 @@
-import { Node } from '../../tree/nodes/node';
-import { Point } from './point';
+import { Node } from "../../tree/nodes/node";
+import { Point } from "./point";
 export declare abstract class VectorConstructor {
     static fromPoints(origin: Point, end: Point): Vector;
     static random(name: string): Vector;

package/lib/math/geometry/vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAO7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAGpC;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAO1C,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAIzB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAG5B,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;CAG/B"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAIvD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAOpC;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAO1C,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAa5B,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;CAa/B"}

package/lib/math/geometry/vector.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector = exports.VectorConstructor = void 0;
+const node_1 = require("../../tree/nodes/node");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
-const simplify_1 = require("../../tree/parsers/simplify");
 const randint_1 = require("../utils/random/randint");
 class VectorConstructor {
     static fromPoints(origin, end) {
@@ -30,10 +28,22 @@ class Vector {
         return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\end{pmatrix}`;
     }
     determinant(v) {
-        return (0, simplify_1.simplifyNode)(new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(this.x, v.y), new multiplyNode_1.MultiplyNode(this.y, v.x)));
+        if ([this.x.type, this.y.type, v.x.type, v.y.type].some((el) => el !== node_1.NodeType.number))
+            throw Error("general determinant not implemented");
+        const xValue = this.x.value;
+        const yValue = this.y.value;
+        const vxValue = v.x.value;
+        const vyValue = v.y.value;
+        return new numberNode_1.NumberNode(xValue * vyValue - yValue * vxValue);
     }
     scalarProduct(v) {
-        return (0, simplify_1.simplifyNode)(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.x, v.x), new multiplyNode_1.MultiplyNode(this.y, v.y)));
+        if ([this.x.type, this.y.type, v.x.type, v.y.type].some((el) => el !== node_1.NodeType.number))
+            throw Error("general determinant not implemented");
+        const xValue = this.x.value;
+        const yValue = this.y.value;
+        const vxValue = v.x.value;
+        const vyValue = v.y.value;
+        return new numberNode_1.NumberNode(xValue * vxValue + yValue * vyValue);
     }
 }
 exports.Vector = Vector;

package/lib/math/numbers/decimals/decimal.d.ts

@@ -1,5 +1,5 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
+import { Node } from "../../../tree/nodes/node";
+import { Nombre, NumberType } from "../nombre";
 export declare abstract class DecimalConstructor {
     static randomFracPart(precision: number, leadingZeros?: number): string;
     static random(min: number, max: number, precision?: number): Decimal;

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAK7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAU1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAI/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAoEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAsBlC,gBAAgB,IAAI,IAAI;IAUxB,oBAAoB,IAAI,IAAI;IAgB5B,MAAM,IAAI,IAAI;CAGf"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAK7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAI/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA2BlC,gBAAgB,IAAI,IAAI;IAgBxB,oBAAoB,IAAI,IAAI;IAmB5B,MAAM,IAAI,IAAI;CAGf"}

package/lib/math/numbers/decimals/decimal.js

@@ -9,10 +9,10 @@ const integer_1 = require("../integer/integer");
 const nombre_1 = require("../nombre");
 class DecimalConstructor {
     static randomFracPart(precision, leadingZeros = 0) {
-        let decimals = '';
+        let decimals = "";
         for (let i = 0; i < precision; i++) {
             if (i < leadingZeros)
-                decimals += '0';
+                decimals += "0";
             if (i === precision - 1 || (i === 0 && !leadingZeros))
                 decimals += (0, randint_1.randint)(1, 10);
             else
@@ -22,17 +22,17 @@ class DecimalConstructor {
     }
     static random(min, max, precision) {
         let prec = precision ?? (0, randint_1.randint)(1, 4);
-        const int = (0, randint_1.randint)(min, max) + '';
+        const int = (0, randint_1.randint)(min, max) + "";
         const decimals = DecimalConstructor.randomFracPart(prec);
         return DecimalConstructor.fromParts(int, decimals);
     }
     static fromParts(intPart, decimalPart) {
-        return new Decimal(Number('' + intPart + '.' + decimalPart));
+        return new Decimal(Number("" + intPart + "." + decimalPart));
     }
     //returns X.YYYY where X € [0, 9] and first Y is not zero if X is zero
     static randomScientific(precision) {
         let prec = precision ?? (0, randint_1.randint)(1, 4);
-        const int = (0, randint_1.randint)(0, 10) + '';
+        const int = (0, randint_1.randint)(0, 10) + "";
         const decimals = DecimalConstructor.randomFracPart(prec, 0);
         return DecimalConstructor.fromParts(int, decimals);
     }
@@ -42,10 +42,10 @@ class Decimal {
     constructor(value) {
         this.type = nombre_1.NumberType.Decimal;
         this.value = value;
-        this.tex = value + '';
-        let [intPartString, decimalPartString] = (value + '').split('.');
+        this.tex = value + "";
+        let [intPartString, decimalPartString] = (value + "").split(".");
         this.intPart = Number(intPartString);
-        this.decimalPart = decimalPartString || '';
+        this.decimalPart = decimalPartString || "";
         this.precision = this.decimalPart.length;
     }
     /**
@@ -54,7 +54,7 @@ class Decimal {
      * @returns
      */
     round(precision) {
-        const intPartString = this.intPart + '';
+        const intPartString = this.intPart + "";
         if (precision < 0) {
             if (precision < -intPartString.length)
                 throw Error("can't round to higher precision");
@@ -64,7 +64,7 @@ class Decimal {
             throw Error("can't round to higher precision");
         if (precision === this.precision)
             return this;
-        let newFracPart = '', newIntPart = '';
+        let newFracPart = "", newIntPart = "";
         const shouldRoundUp = Number(this.decimalPart[precision]) > 4;
         if (shouldRoundUp) {
             let retenue = true;
@@ -87,7 +87,7 @@ class Decimal {
                 }
                 else {
                     const nb = (Number(intPartString[i + intPartString.length]) + 1) % 10;
-                    newIntPart = nb + '' + newIntPart;
+                    newIntPart = nb + "" + newIntPart;
                     if (nb !== 0) {
                         retenue = false;
                         for (let j = i + intPartString.length - 1; j > -1; j--) {
@@ -127,22 +127,23 @@ class Decimal {
         return DecimalConstructor.fromParts(newIntPart, newFracPart);
     }
     multiplyByPowerOfTen(power) {
-        let newIntPart = '', newFracPart = '';
+        let newIntPart = "", newFracPart = "";
         if (power > -1) {
-            newIntPart = this.intPart + '';
+            newIntPart = this.intPart + "";
             for (let i = 0; i < power; i++) {
-                newIntPart += i > this.decimalPart.length - 1 ? '0' : this.decimalPart[i];
+                newIntPart +=
+                    i > this.decimalPart.length - 1 ? "0" : this.decimalPart[i];
             }
             newFracPart = this.decimalPart.slice(power);
         }
         else {
-            const intPartString = this.intPart + '';
+            const intPartString = this.intPart + "";
             newFracPart = this.decimalPart;
             for (let i = intPartString.length - 1; i > intPartString.length - 1 + power; i--) {
-                newFracPart = (i < 0 ? '0' : intPartString[i]) + newFracPart;
+                newFracPart = (i < 0 ? "0" : intPartString[i]) + newFracPart;
             }
             if (power + intPartString.length < 1)
-                newIntPart = '0';
+                newIntPart = "0";
             else
                 newIntPart = intPartString.slice(0, power + intPartString.length);
         }
@@ -154,10 +155,12 @@ class Decimal {
         if (intSize === 0 && this.intPart !== 0)
             return this.toTree();
         if (this.intPart === 0) {
-            const firstNonZeroIndex = this.decimalPart.split('').findIndex((el) => Number(el) !== 0);
-            return new numberNode_1.NumberNode(Number('0.' + this.decimalPart.slice(firstNonZeroIndex)));
+            const firstNonZeroIndex = this.decimalPart
+                .split("")
+                .findIndex((el) => Number(el) !== 0);
+            return new numberNode_1.NumberNode(Number("0." + this.decimalPart.slice(firstNonZeroIndex)));
         }
-        return new numberNode_1.NumberNode(Number(intString[0] + '.' + intString.slice(1) + this.decimalPart));
+        return new numberNode_1.NumberNode(Number(intString[0] + "." + intString.slice(1) + this.decimalPart));
     }
     toScientificNotation() {
         const intString = this.intPart.toString();
@@ -166,7 +169,7 @@ class Decimal {
             return this.toTree();
         const decNode = this.toScientificPart();
         let leadingZeros = 0;
-        const nbs = this.decimalPart.split('').map(Number);
+        const nbs = this.decimalPart.split("").map(Number);
         for (let i = 0; i < nbs.length; i++) {
             if (nbs[i] !== 0)
                 break;

package/lib/math/numbers/integer/integer.d.ts

@@ -1,5 +1,6 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
+import { Node } from "../../../tree/nodes/node";
+import { Nombre, NumberType } from "../nombre";
+import { Rational } from "../rationals/rational";
 export declare abstract class IntegerConstructor {
     static random(nbOfDigits: number, excludes?: number[]): number;
     static randomPrime(max?: number): number;
@@ -13,5 +14,8 @@ export declare class Integer implements Nombre {
     toTree(): Node;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;
+    multiply(nb: Nombre): Rational | Integer;
+    opposite(): Integer;
+    add(nb: Nombre): Nombre;
 }
 //# sourceMappingURL=integer.d.ts.map

package/lib/math/numbers/integer/integer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAG7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAI/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;CAWlF;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,IAAI,IAAI;IAId,KAAK,CAAC,SAAS,EAAE,MAAM;IAiCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;CAW3B"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAG7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,IAAI,IAAI;IAId,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}

package/lib/math/numbers/integer/integer.js

@@ -30,27 +30,27 @@ exports.IntegerConstructor = IntegerConstructor;
 class Integer {
     constructor(value, tex) {
         this.value = value;
-        this.tex = tex || value + '';
+        this.tex = tex || value + "";
         this.type = nombre_1.NumberType.Integer;
     }
     toTree() {
         return new numberNode_1.NumberNode(this.value, this.tex);
     }
     round(precision) {
-        const intString = this.value + '';
+        const intString = this.value + "";
         if (precision >= intString.length || precision < 1)
             throw Error("can't round to higher precision");
-        let newInt = '';
+        let newInt = "";
         const shouldRoundUp = Number(intString[intString.length - precision]) > 4;
         if (shouldRoundUp) {
             for (let i = 0; i < precision; i++) {
-                newInt += '0';
+                newInt += "0";
             }
             let retenue = true;
             let i = intString.length - precision - 1;
             while (retenue) {
                 const nb = (Number(intString[i]) + 1) % 10;
-                newInt = '' + nb + newInt;
+                newInt = "" + nb + newInt;
                 if (nb === 0) {
                     i--;
                 }
@@ -64,7 +64,7 @@ class Integer {
         }
         else {
             for (let i = 0; i < intString.length; i++) {
-                newInt += i < intString.length - precision ? intString[i] : '0';
+                newInt += i < intString.length - precision ? intString[i] : "0";
             }
         }
         return new Integer(Number(newInt));
@@ -77,7 +77,34 @@ class Integer {
                 const rational = nb;
                 return new rational_1.Rational(this.value * rational.denum, rational.num).simplify();
             default:
-                throw Error('not implemented');
+                throw Error("not implemented");
+        }
+    }
+    multiply(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer:
+                const int = nb;
+                return new Integer(this.value * int.value);
+            case nombre_1.NumberType.Rational:
+                const rational = nb;
+                return rational.multiply(this);
+            default:
+                throw Error("not implemented");
+        }
+    }
+    opposite() {
+        return new Integer(-this.value);
+    }
+    add(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer:
+                const int = nb;
+                return new Integer(this.value + int.value);
+            case nombre_1.NumberType.Rational:
+                const rational = nb;
+                return rational.add(this);
+            default:
+                throw Error("general integer add not implemented");
         }
     }
 }

package/lib/math/numbers/integer/power.d.ts

@@ -1,5 +1,5 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
+import { Node } from "../../../tree/nodes/node";
+import { Nombre, NumberType } from "../nombre";
 export declare class Power implements Nombre {
     value: number;
     tex: string;