math-exercises 2.1.8 → 2.1.10

package/lib/index.d.ts

@@ -167,6 +167,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
+    c: number;
+    d: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -175,9 +177,27 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
+    x: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    x: number;
+    b: number;
+    c: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    x: number;
+    b: number;
     c: number;
     d: number;
 }> | import("./exercises/exercise").Exercise<{
+    type: number;
+    vars: {
+        flip: boolean;
+        resultNb: number;
+        randAdd?: number | undefined;
+        op2?: string | undefined;
+    };
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -417,12 +437,37 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     affineA: number;
     affineB: number;
     power: number;
+}> | import("./exercises/exercise").Exercise<{
+    affinecoeffs: number[];
+}> | import("./exercises/exercise").Exercise<{
+    affinecoeffs: number[];
+}> | import("./exercises/exercise").Exercise<{
+    coeffs: number[];
+}> | import("./exercises/exercise").Exercise<{
+    askConvex: boolean;
+    quadcoeffs: number[];
+}> | import("./exercises/exercise").Exercise<{
+    quadcoeffs: number[];
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    c: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}> | import("./exercises/exercise").Exercise<{
+    coeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     x: number;
 }> | import("./exercises/exercise").Exercise<{
     A: number[];
     B: number[];
+}> | import("./exercises/exercise").Exercise<{
+    abscisse: number;
+    trinome: number[];
 }> | import("./exercises/exercise").Exercise<{
     a: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -436,6 +481,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -465,6 +513,26 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     b: number;
     secondPoint: number[];
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    isAskingA: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    G1x: number;
+    G2x: number;
+    G2y: number;
+    G1y: number;
+}> | import("./exercises/exercise").Exercise<{
+    rSquared: number;
+}> | import("./exercises/exercise").Exercise<{
+    G1x: number;
+    G2x: number;
+    G2y: number;
+    G1y: number;
+    rSquared: number;
 }> | import("./exercises/exercise").Exercise<{
     rand: boolean;
     poly1: number[];
@@ -641,6 +709,20 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     coordsA: number[];
     coordsB: number[];
+}> | import("./exercises/exercise").Exercise<{
+    aX: number;
+    aY: number;
+    bX: number;
+    bY: number;
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+}> | import("./exercises/exercise").Exercise<{
+    xValue: number;
+    yValue: number;
+}> | import("./exercises/exercise").Exercise<{
+    xValue: number;
+    yValue: number;
 }> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
@@ -730,6 +812,30 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     caracAsked: string;
     uPoints: number[][];
     vPoints: number[][];
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    u: {
+        x: number;
+        y: number;
+    };
+    v: {
+        x: number;
+        y: number;
+    };
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+}> | import("./exercises/exercise").Exercise<{
+    uX: number;
+    uY: number;
+    aX: number;
+    aY: number;
+}> | import("./exercises/exercise").Exercise<{
+    trinom: number[];
+}> | import("./exercises/exercise").Exercise<{
+    askConvex: boolean;
+    quadcoeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;
@@ -891,6 +997,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     xValues: number[];
     yValues: number[];
+}> | import("./exercises/exercise").Exercise<{
+    isJustified: boolean;
 }> | import("./exercises/exercise").Exercise<{
     pA: number;
     pB: number;
@@ -1099,6 +1207,50 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     randSideQuestion: number;
 }> | import("./exercises/exercise").Exercise<{
     angleValue: number;
+}> | import("./exercises/exercise").Exercise<{
+    exercise: {
+        a: number;
+        nbIteration: number;
+        op: string;
+        b?: number | undefined;
+    };
+}> | import("./exercises/exercise").Exercise<{
+    exercise: {
+        a: number;
+        b: number;
+        op: string;
+    };
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    id1: number;
+    id2: number;
+}> | import("./exercises/exercise").Exercise<{
+    initialValue: number;
+    step: number;
+    iterations: number;
+    opIndex: number;
+}> | import("./exercises/exercise").Exercise<{
+    initialValue: number;
+    step: number;
+    iterations: number;
+    opIndex: number;
+    a: number;
+    x: number;
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    trinom: number[];
+    image: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    opresult: number;
+}> | import("./exercises/exercise").Exercise<{
+    exercise: {
+        op: string;
+        n: number;
+        p: number;
+    };
 }>)[];
 declare const pcExercises: (import("./exercises/exercise").Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -0,0 +1,14 @@
+import { Point } from "./point";
+import { EqualNode } from "../../tree/nodes/equations/equalNode";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+export declare abstract class CloudPointsConstructor {
+    static random(nbPoints: number): CloudPoints;
+    static randomLinear(nbPoints: number): CloudPoints;
+}
+export declare class CloudPoints {
+    points: Point[];
+    constructor(points: Point[]);
+    getFineAdjustement(): EqualNode;
+    getCorrelationCoeff(): NumberNode;
+}
+//# sourceMappingURL=CloudPoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAgB,MAAM,qCAAqC,CAAC;AAM/E,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAQ9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}

package/lib/math/geometry/CloudPoints.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPoints = exports.CloudPointsConstructor = void 0;
+const point_1 = require("./point");
+const equalNode_1 = require("../../tree/nodes/equations/equalNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const randint_1 = require("../utils/random/randint");
+const covariance_1 = require("../utils/covariance");
+const variance_1 = require("../utils/variance");
+class CloudPointsConstructor {
+    static random(nbPoints) {
+        const names = [];
+        for (let i = 0; i < nbPoints; i++) {
+            names.push(`a${i}`);
+        }
+        return new CloudPoints(point_1.PointConstructor.randomDifferent(names));
+    }
+    static randomLinear(nbPoints) {
+        const points = [];
+        const deltaX = (0, randint_1.randint)(2, 6, [0]);
+        const deltaY = (0, randint_1.randint)(2, 6, [0]);
+        const a = (0, randint_1.randint)(-5, 6, [0]);
+        const b = (0, randint_1.randint)(-5, 6);
+        for (let i = -nbPoints * 2; i < nbPoints * 2; i += 4) {
+            points.push(new point_1.Point(`a${i + nbPoints * 2}`, new numberNode_1.NumberNode(i), new numberNode_1.NumberNode(a * i + b)));
+        }
+        points.forEach((point) => {
+            const x = point.getXnumber();
+            const y = point.getYnumber();
+            point.y = new numberNode_1.NumberNode(y + (0, randint_1.randint)(-deltaX, deltaX + 1));
+            point.x = new numberNode_1.NumberNode(x + (0, randint_1.randint)(-deltaY, deltaY + 1, [deltaX, -deltaX]));
+        });
+        return new CloudPoints(points);
+    }
+}
+exports.CloudPointsConstructor = CloudPointsConstructor;
+class CloudPoints {
+    constructor(points) {
+        this.points = points;
+    }
+    getFineAdjustement() {
+        const xValues = this.points.map((element) => {
+            return element.getXnumber();
+        });
+        const yValues = this.points.map((element) => {
+            return element.getYnumber();
+        });
+        const avgX = xValues.reduce((accumulator, nb) => {
+            return accumulator + nb;
+        }) / this.points.length;
+        const avgY = yValues.reduce((accumulator, nb) => {
+            return accumulator + nb;
+        }) / this.points.length;
+        const avgXsquare = xValues
+            .map((point) => {
+            return point * point;
+        })
+            .reduce((acc, nb) => {
+            return acc + nb;
+        }) / this.points.length;
+        const avgXY = xValues
+            .map((point, i) => {
+            return point * yValues[i];
+        })
+            .reduce((acc, nb) => {
+            return acc + nb;
+        }) / this.points.length;
+        const a = (avgXY - avgX * avgY) / (avgXsquare * Math.pow(avgX, avgX));
+        const b = avgY - a * avgX;
+        return new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(+a.toFixed(2)), new variableNode_1.VariableNode("x")).simplify(), new numberNode_1.NumberNode(+b.toFixed(2))));
+    }
+    getCorrelationCoeff() {
+        const xValues = this.points.map((point) => {
+            return point.getXnumber();
+        });
+        const yValues = this.points.map((point) => {
+            return point.getYnumber();
+        });
+        const avgX = xValues.reduce((accumulator, nb) => {
+            return accumulator + nb;
+        }) / this.points.length;
+        const avgY = yValues.reduce((accumulator, nb) => {
+            return accumulator + nb;
+        }) / this.points.length;
+        const covXY = (0, covariance_1.covarianceXY)(xValues, avgX, yValues, avgY);
+        const xVariance = (0, variance_1.variance)(xValues, avgX);
+        const yVariance = (0, variance_1.variance)(yValues, avgY);
+        return new numberNode_1.NumberNode(+(covXY / Math.sqrt(xVariance * yVariance)).toFixed(2));
+    }
+}
+exports.CloudPoints = CloudPoints;

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

@@ -1,5 +1,7 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { EqualNode } from "../../tree/nodes/equations/equalNode";
 import { Point } from "./point";
+import { Vector } from "./vector";
 export declare class Line {
     pointA: Point;
     pointB: Point;
@@ -10,5 +12,7 @@ export declare class Line {
     getParallele(point: Point): Line;
     includes(point: Point): boolean;
     getRandomPoint(name?: string): Point;
+    getEquation: (u: Vector, a: Point) => EqualNode;
+    getCartesianEquation(): EqualNode;
 }
 //# sourceMappingURL=line.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IAUzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;CAa7B"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IAUzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAc5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}

package/lib/math/geometry/line.js

@@ -1,15 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Line = void 0;
+const equalNode_1 = require("../../tree/nodes/equations/equalNode");
 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 multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
 const randint_1 = require("../utils/random/randint");
 const point_1 = require("./point");
+const vector_1 = require("./vector");
 class Line {
     constructor(pointA, pointB) {
+        this.getEquation = (u, a) => {
+            const x = new variableNode_1.VariableNode("x");
+            const y = new variableNode_1.VariableNode("y");
+            const uYDivuX = new fractionNode_1.FractionNode(u.y, u.x).simplify();
+            const natural = u.getYAsNumber() % u.getXAsNumber() === 0;
+            const aYuX = new multiplyNode_1.MultiplyNode(a.y, u.x).simplify();
+            const aXuY = new multiplyNode_1.MultiplyNode(a.x, u.y).simplify();
+            const rightSide = new addNode_1.AddNode(natural
+                ? new multiplyNode_1.MultiplyNode(uYDivuX, x).simplify()
+                : new multiplyNode_1.MultiplyNode(uYDivuX, x), new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(aYuX, aXuY).simplify(), u.x).simplify());
+            const equation = new equalNode_1.EqualNode(y, rightSide);
+            return equation;
+        };
         this.pointA = pointA;
         this.pointB = pointB;
         this.isVertical = pointA.x.equals(pointB.x);
@@ -48,5 +64,14 @@ class Line {
         console.log(y.toTex(), this.a.toTex(), x.toTex(), this.b?.toTex());
         return new point_1.Point(name ?? "A", x, y);
     }
+    getCartesianEquation() {
+        const u = new vector_1.Vector("u", new numberNode_1.NumberNode(this.pointB.getXnumber() - this.pointA.getXnumber()), new numberNode_1.NumberNode(this.pointB.getYnumber() - this.pointA.getYnumber()));
+        const b = -u.getXAsNumber();
+        const a = u.getYAsNumber();
+        const c = -a * this.pointA.getXnumber() - b * this.pointA.getYnumber();
+        const x = new variableNode_1.VariableNode("x");
+        const y = new variableNode_1.VariableNode("y");
+        return new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), x).simplify(), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(b), y).simplify()), new numberNode_1.NumberNode(c)).simplify({ forbidFactorize: true }), new numberNode_1.NumberNode(0));
+    }
 }
 exports.Line = Line;

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

@@ -13,11 +13,16 @@ export declare class Vector {
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
     toTex(): string;
     toTexWithCoords(): string;
+    toInlineCoordsTex(): string;
     isColinear(v: Vector): boolean;
     determinant(v: Vector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): Vector;
     scalarProduct(v: Vector): Node;
+    add(v: Vector): Vector;
+    getNorm(): AlgebraicNode;
     getEndPoint(startPoint: Point, name?: string): Point;
     equals(v: Vector): boolean;
+    getXAsNumber(): number;
+    getYAsNumber(): number;
 }
 //# sourceMappingURL=vector.d.ts.map

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,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAMvD,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,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAcrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9B,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;CAGjB"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAOvD,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,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAcrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAYtB,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;CAMb"}

package/lib/math/geometry/vector.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector = exports.VectorConstructor = 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 multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
 const randint_1 = require("../utils/random/randint");
 const point_1 = require("./point");
@@ -32,6 +34,11 @@ class Vector {
     toTexWithCoords() {
         return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\end{pmatrix}`;
     }
+    toInlineCoordsTex() {
+        return `\\left(${this.x.simplify().toTex()};${this.y
+            .simplify()
+            .toTex()}\\right)`;
+    }
     isColinear(v) {
         const det = this.determinant(v);
         return det.evaluate({}) === 0;
@@ -57,11 +64,35 @@ class Vector {
         const vyValue = v.y.value;
         return new numberNode_1.NumberNode(xValue * vxValue + yValue * vyValue);
     }
+    add(v) {
+        const x = v.x;
+        const y = v.y;
+        const resultX = new addNode_1.AddNode(this.x, x);
+        const resultY = new addNode_1.AddNode(this.y, y);
+        return new Vector(`${this.name}+${v.name}`, resultX.simplify(), resultY.simplify());
+    }
+    getNorm() {
+        const xValue = this.x.simplify().value;
+        const yValue = this.y.simplify().value;
+        return new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.SquareNode(new numberNode_1.NumberNode(xValue)), new powerNode_1.SquareNode(new numberNode_1.NumberNode(yValue))));
+    }
     getEndPoint(startPoint, name) {
         return new point_1.Point(name ?? "B", new addNode_1.AddNode(startPoint.x, this.x).simplify(), new addNode_1.AddNode(startPoint.y, this.y).simplify());
     }
     equals(v) {
         return this.x.equals(v.x) && this.y.equals(v.y);
     }
+    getXAsNumber() {
+        if (!(0, numberNode_1.isNumberNode)(this.x)) {
+            throw Error("not implemented for nodes other than NumberNode");
+        }
+        return this.x.value;
+    }
+    getYAsNumber() {
+        if (!(0, numberNode_1.isNumberNode)(this.y)) {
+            throw Error("not implemented for nodes other than NumberNode");
+        }
+        return this.y.value;
+    }
 }
 exports.Vector = Vector;

package/lib/math/polynomials/polynomial.d.ts

@@ -36,6 +36,7 @@ export declare class Polynomial {
     scalarDivide(n: number): Polynomial;
     opposite(): Polynomial;
     derivate(): Polynomial;
+    secondDerivate(): Polynomial;
     integrateToNode(opts?: NodeOptions): AlgebraicNode;
     calculate(x: number): number;
     getLimit(to: "+\\infty" | "-\\infty"): string;

package/lib/math/polynomials/polynomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAcjE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAY1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAmBtB,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IAyBf,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAcjE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAY1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IAyBf,QAAQ,IAAI,MAAM;CAGnB"}

package/lib/math/polynomials/polynomial.js

@@ -235,6 +235,14 @@ class Polynomial {
             res.push(i * this.coefficients[i]);
         return new Polynomial(res, this.variable);
     }
+    secondDerivate() {
+        if (this.coefficients.length <= 2)
+            return new Polynomial([0], this.variable);
+        const res = [];
+        for (let i = 2; i < this.coefficients.length; i++)
+            res.push(i * (i - 1) * this.coefficients[i]);
+        return new Polynomial(res, this.variable);
+    }
     // integrate(): Polynomial {
     //   const newCoefficients = this.coefficients.map(
     //     (coeff, exp) => coeff / (exp + 1),
@@ -321,11 +329,11 @@ class Polynomial {
     toTree(opts) {
         const recursive = (cursor) => {
             const coeff = this.coefficients[cursor];
-            if (coeff === 0)
-                return recursive(cursor - 1);
             if (cursor === 0) {
                 return new numberNode_1.NumberNode(coeff);
             }
+            if (coeff === 0)
+                return recursive(cursor - 1);
             const monome = cursor > 1
                 ? new powerNode_1.PowerNode(new variableNode_1.VariableNode(this.variable), new numberNode_1.NumberNode(cursor), opts)
                 : new variableNode_1.VariableNode(this.variable);

package/lib/math/polynomials/trinom.d.ts

@@ -68,5 +68,6 @@ export declare class Trinom extends Polynomial {
     getCanonicalForm(): MultiplyNode | AddNode;
     getSommet(): Point;
     getCoords(): number[];
+    toPython(): string;
 }
 //# sourceMappingURL=trinom.d.ts.map

package/lib/math/polynomials/trinom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}

package/lib/math/polynomials/trinom.js

@@ -199,5 +199,33 @@ class Trinom extends polynomial_1.Polynomial {
         const yMax = Math.max(1, this.a > 0 ? beta + 5 : beta + 2);
         return [xMin, xMax, yMin, yMax];
     }
+    toPython() {
+        const aString = this.a === 0
+            ? ""
+            : this.a === 1
+                ? "x**2"
+                : this.a === -1
+                    ? "-x**2"
+                    : `${this.a}*x**2`;
+        const bString = this.b === 0
+            ? ""
+            : this.b === 1
+                ? " + x"
+                : this.b === -1
+                    ? " - x"
+                    : this.b > 0
+                        ? ` + ${Math.abs(this.b)}*x`
+                        : ` - ${Math.abs(this.b)}*x`;
+        const cString = this.c === 0
+            ? ""
+            : this.c === 1
+                ? " + 1"
+                : this.c === -1
+                    ? " - 1"
+                    : this.c > 0
+                        ? ` + ${Math.abs(this.c)}`
+                        : ` - ${Math.abs(this.c)}`;
+        return `${aString}${bString}${cString}`;
+    }
 }
 exports.Trinom = Trinom;

package/lib/math/utils/arithmetic/factorial.d.ts

@@ -0,0 +1,2 @@
+export declare const factorial: (nb: number) => number;
+//# sourceMappingURL=factorial.d.ts.map

package/lib/math/utils/arithmetic/factorial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorial.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/factorial.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,OAAQ,MAAM,KAAG,MAItC,CAAC"}

package/lib/math/utils/arithmetic/factorial.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorial = void 0;
+const factorial = (nb) => {
+    let result = 1;
+    for (let i = 2; i <= nb; i++)
+        result = result * i;
+    return result;
+};
+exports.factorial = factorial;

package/lib/math/utils/covariance.d.ts

@@ -0,0 +1,4 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare function covXYAsNode(xValues: number[], avgX: AlgebraicNode, yValues: number[], avgY: AlgebraicNode): AlgebraicNode;
+export declare function covarianceXY(xValues: number[], avgX: number, yValues: number[], avgY: number): number;
+//# sourceMappingURL=covariance.d.ts.map

package/lib/math/utils/covariance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"covariance.d.ts","sourceRoot":"","sources":["../../../src/math/utils/covariance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,aAAa,GAClB,aAAa,CAef;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,CASR"}