math-exercises 2.0.11 → 2.0.13

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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,61 +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.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;
+"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,25 +1,25 @@
-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 | import("../../tree/nodes/numbers/constantNode").ConstantNode | FractionNode | OppositeNode | undefined;
-    toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
-    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 | import("../../tree/nodes/numbers/constantNode").ConstantNode | FractionNode | OppositeNode | undefined;
+    toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
+    toTree(): ComplexNode;
+}
 //# sourceMappingURL=complex.d.ts.map

package/lib/math/complex/complex.js

@@ -1,104 +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 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;
+"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/line.d.ts

@@ -0,0 +1,3 @@
+export declare class Line {
+}
+//# sourceMappingURL=line.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,qBAAa,IAAI;CAAG"}

package/lib/math/geometry/line.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Line = void 0;
+class Line {
+}
+exports.Line = Line;

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

@@ -1,32 +1,32 @@
-import { MathSet } from "../sets/mathSet";
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
-export declare abstract class PointConstructor {
-    static random(domainX?: MathSet, domainY?: MathSet): Point;
-}
-export declare class Point {
-    name: string;
-    x: AlgebraicNode;
-    y: AlgebraicNode;
-    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
-    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
-
- * }
- */
+import { MathSet } from "../sets/mathSet";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare abstract class PointConstructor {
+    static random(domainX?: MathSet, domainY?: MathSet): Point;
+}
+export declare class Point {
+    name: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
+    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.js

@@ -1,73 +1,73 @@
-"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
-
- * }
- */
+"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
+
+ * }
+ */