math-exercises 2.0.1 → 2.0.3

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";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllMathExercisesBySection = exports.allMathExercises = void 0;
-const exercises_1 = require("./exercises/exercises");
-/**
- * TODO
- * Décimal : permettre facilement -0.xxx
- * Tree shaking export
- *
- *
-
-*/
-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;
+"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.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 Exercises = __importStar(require("./exercises"));
+const mathExercises = Object.values(Exercises);
+exports.mathExercises = mathExercises;

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

@@ -1,24 +1,25 @@
-import { ComplexNode } from "../../tree/nodes/complex/complexNode";
-import { OppositeNode } from "../../tree/nodes/functions/oppositeNode";
-import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-import { AddNode } from "../../tree/nodes/operators/addNode";
-import { FractionNode } from "../../tree/nodes/operators/fractionNode";
-export declare abstract class ComplexConstructor {
-    static random(): Complex;
-    static randomNotReal(): Complex;
-}
-export declare class Complex {
-    re: number;
-    im: number;
-    constructor(re: number, im: number);
-    moduleSquared(): number;
-    inverseNode(): AddNode;
-    divideNode(z: Complex): import("../../tree/nodes/node").Node;
-    multiply(z: Complex): Complex;
-    opposite(): Complex;
-    conjugate(): Complex;
-    toArgumentTree(): NumberNode | FractionNode | OppositeNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | undefined;
-    toModuleTree(): import("../../tree/nodes/node").Node;
-    toTree(): ComplexNode;
-}
+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;
+}
+export declare class Complex {
+    re: number;
+    im: number;
+    constructor(re: number, im: number);
+    moduleSquared(): number;
+    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,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAQvE,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,cAAc;IAsBd,YAAY;IAGZ,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

@@ -1,106 +1,104 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Complex = exports.ComplexConstructor = void 0;
-const complexNode_1 = require("../../tree/nodes/complex/complexNode");
-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 addNode_1 = require("../../tree/nodes/operators/addNode");
-const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const variableNode_1 = require("../../tree/nodes/variables/variableNode");
-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() {
-        const re = (0, randint_1.randint)(-10, 11);
-        let im = 0;
-        do {
-            im = (0, randint_1.randint)(-10, 11);
-        } while (re === 0 && im === 0);
-        return new Complex(re, im);
-    }
-    static randomNotReal() {
-        const re = (0, randint_1.randint)(-10, 11);
-        let im = 0;
-        do {
-            im = (0, randint_1.randint)(-10, 11, [0]);
-        } while (re === 0 && im === 0);
-        return new Complex(re, im);
-    }
-}
-exports.ComplexConstructor = ComplexConstructor;
-class Complex {
-    constructor(re, im) {
-        this.re = re;
-        this.im = im;
-    }
-    moduleSquared() {
-        return this.re ** 2 + this.im ** 2;
-    }
-    inverseNode() {
-        const moduleSq = this.moduleSquared();
-        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")));
-    }
-    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")));
-    }
-    multiply(z) {
-        return new Complex(this.re * z.re - this.im * z.im, this.re * z.im + this.im * z.re);
-    }
-    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);
-    }
-}
-exports.Complex = Complex;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Complex = exports.ComplexConstructor = void 0;
+const complexNode_1 = require("../../tree/nodes/complex/complexNode");
+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() {
+        const re = (0, randint_1.randint)(-10, 11);
+        let im = 0;
+        do {
+            im = (0, randint_1.randint)(-10, 11);
+        } while (re === 0 && im === 0);
+        return new Complex(re, im);
+    }
+    static randomNotReal() {
+        const re = (0, randint_1.randint)(-10, 11);
+        let im = 0;
+        do {
+            im = (0, randint_1.randint)(-10, 11, [0]);
+        } while (re === 0 && im === 0);
+        return new Complex(re, im);
+    }
+}
+exports.ComplexConstructor = ComplexConstructor;
+class Complex {
+    constructor(re, im) {
+        this.re = re;
+        this.im = im;
+    }
+    moduleSquared() {
+        return this.re ** 2 + this.im ** 2;
+    }
+    inverseNode() {
+        const moduleSq = this.moduleSquared();
+        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 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();
+        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(new numberNode_1.NumberNode(this.re), new numberNode_1.NumberNode(this.im));
+    }
+}
+exports.Complex = Complex;

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

@@ -1,33 +1,32 @@
-import { Node } from '../../tree/nodes/node';
-import { MathSet } from '../sets/mathSet';
-export declare abstract class PointConstructor {
-    static random(domainX?: MathSet, domainY?: MathSet): Point;
-}
-export declare class Point {
-    name: string;
-    x: Node;
-    y: Node;
-    constructor(name: string, x: Node, y: Node);
-    toTex(): string;
-    toTexWithCoords(): string;
-    getXnumber(): number;
-    getYnumber(): number;
-    midpoint(B: Point, name?: string): Point;
-    distanceTo(B: Point): number;
-    distanceToNode(B: Point): Node;
-    equalTo(B: Point): boolean;
-}
-/**
- * Droite{
- * constructor :
- *  depuis 2 points : A,B --> Droite
- *  depuis 1 point + coeff dir --> Droite
- *  avec une équation de droite --> Droite
- *
- * méthodes :
- *    toEquation() --> y = 3x+2
- *    toCoeffDIr --> a
-
- * }
- */
+import { Node } from "../../tree/nodes/node";
+import { MathSet } from "../sets/mathSet";
+export declare abstract class PointConstructor {
+    static random(domainX?: MathSet, domainY?: MathSet): Point;
+}
+export declare class Point {
+    name: string;
+    x: Node;
+    y: Node;
+    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;
+}
+/**
+ * Droite{
+ * constructor :
+ *  depuis 2 points : A,B --> Droite
+ *  depuis 1 point + coeff dir --> Droite
+ *  avec une équation de droite --> Droite
+ *
+ * méthodes :
+ *    toEquation() --> y = 3x+2
+ *    toCoeffDIr --> a
+
+ * }
+ */
 //# sourceMappingURL=point.d.ts.map

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,72 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Point = exports.PointConstructor = void 0;
-const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
-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");
-class PointConstructor {
-    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));
-    }
-}
-exports.PointConstructor = PointConstructor;
-class Point {
-    constructor(name, x, y) {
-        this.name = name;
-        this.x = x;
-        this.y = y;
-    }
-    toTex() {
-        return `${this.name}`;
-    }
-    toTexWithCoords() {
-        return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
-    }
-    getXnumber() {
-        return (0, mathjs_1.evaluate)(this.x.toMathString());
-    }
-    getYnumber() {
-        return (0, mathjs_1.evaluate)(this.y.toMathString());
-    }
-    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))));
-    }
-    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;
-/**
- * Droite{
- * constructor :
- *  depuis 2 points : A,B --> Droite
- *  depuis 1 point + coeff dir --> Droite
- *  avec une équation de droite --> Droite
- *
- * méthodes :
- *    toEquation() --> y = 3x+2
- *    toCoeffDIr --> a
-
- * }
- */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point = exports.PointConstructor = void 0;
+const node_1 = require("../../tree/nodes/node");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+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]]")) {
+        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));
+    }
+}
+exports.PointConstructor = PointConstructor;
+class Point {
+    constructor(name, x, y) {
+        this.name = name;
+        this.x = x;
+        this.y = y;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toTexWithCoords() {
+        return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
+    }
+    toCoords() {
+        return `\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
+    }
+    getXnumber() {
+        if (this.x.type !== node_1.NodeType.number)
+            throw Error("general point not implemented yet");
+        return this.x.value;
+    }
+    getYnumber() {
+        if (this.y.type !== node_1.NodeType.number)
+            throw Error("general point not implemented yet");
+        return this.y.value;
+    }
+    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);
+    }
+}
+exports.Point = Point;
+/**
+ * Droite{
+ * constructor :
+ *  depuis 2 points : A,B --> Droite
+ *  depuis 1 point + coeff dir --> Droite
+ *  avec une équation de droite --> Droite
+ *
+ * méthodes :
+ *    toEquation() --> y = 3x+2
+ *    toCoeffDIr --> a
+
+ * }
+ */