math-exercises 2.0.20 → 2.0.21

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA2DF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA6DF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType0.js

@@ -21,7 +21,7 @@ const getFirstDegreeInequationsQuestion = () => {
     const answer = `x${ineqType.symbol}${result}`;
     const question = {
         answer: answer,
-        instruction: `Résoudre l'inéquation : $${affine.toTex()} ${ineqType} ${c}$ `,
+        instruction: `Résoudre l'inéquation : $${affine.toTex()} ${ineqType.symbol} ${c}$ `,
         keys: inequationKeys_1.inequationKeys,
         answerFormat: "tex",
         identifiers: { ineqType: ineqType.symbol, b: affine.b, c },

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType1.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAa3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAmEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAcjE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType1.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAS3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAqEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType1.js

@@ -22,7 +22,7 @@ const getFirstDegreeInequationsQuestion = () => {
     const answer = `x${affine.a > 0 ? ineqType.symbol : invIneqType}${result}`;
     const question = {
         answer: answer,
-        instruction: `Résoudre l'inéquation : $${affine.toTex()} ${ineqType} ${b}$ `,
+        instruction: `Résoudre l'inéquation : $${affine.toTex()} ${ineqType.symbol} ${b}$ `,
         keys: inequationKeys_1.inequationKeys,
         answerFormat: "tex",
         identifiers: { a: affine.a, b, ineqType: ineqType.symbol },

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType2.js

@@ -25,7 +25,7 @@ const getFirstDegreeInequationsQuestion = () => {
     const answer = `x${affine.a > 0 ? ineqType.symbol : invIneqType}${result}`;
     const question = {
         answer: answer,
-        instruction: `Résoudre l'inéquation : $${affine.toTex()} ${ineqType} ${c}$ `,
+        instruction: `Résoudre l'inéquation : $${affine.toTex()} ${ineqType.symbol} ${c}$ `,
         keys: inequationKeys_1.inequationKeys,
         answerFormat: "tex",
         identifiers: { a: affine.a, b: affine.b, c, ineqType: ineqType.symbol },

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkFF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoFF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType3.js

@@ -26,7 +26,7 @@ const getFirstDegreeInequationsQuestion = () => {
     const answer = `x${coeff > 0 ? ineqType.symbol : invIneqType}${result}`;
     const question = {
         answer: answer,
-        instruction: `Résoudre l'inéquation : $${affine1.toTex()} ${ineqType} ${affine2.toTex()}$ `,
+        instruction: `Résoudre l'inéquation : $${affine1.toTex()} ${ineqType.symbol} ${affine2.toTex()}$ `,
         keys: inequationKeys_1.inequationKeys,
         answerFormat: "tex",
         identifiers: {

package/lib/exercises/geometry/vectors/alignementViaColinearity.d.ts

@@ -0,0 +1,12 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    yA: number;
+    yB: number;
+    yC: number;
+};
+export declare const alignementViaColinearity: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=alignementViaColinearity.d.ts.map

package/lib/exercises/geometry/vectors/alignementViaColinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/geometry/vectors/alignementViaColinearity.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignementViaColinearity = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const line_1 = require("../../../math/geometry/line");
+const point_1 = require("../../../math/geometry/point");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getAlignementViaColinearityQuestion = () => {
+    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const line = new line_1.Line(points[0], points[1]);
+    let C;
+    const isAligned = (0, coinFlip_1.coinFlip)();
+    if (isAligned) {
+        do {
+            C = line.getRandomPoint("C");
+        } while (C.equals(points[0]) || C.equals(points[1]));
+    }
+    else {
+        do {
+            C = point_1.PointConstructor.random("C");
+        } while (C.equals(points[0]) || C.equals(points[1]) || line.includes(C));
+    }
+    const answer = isAligned ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soient trois points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$ et $${C.toTexWithCoords()}$. Les points $A$, $B$ et $C$ sont-ils alignés ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.alignementViaColinearity = {
+    id: "alignementViaColinearity",
+    label: "",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAlignementViaColinearityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/colinearity.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xu: number;
+    yu: number;
+    xv: number;
+    yv: number;
+};
+export declare const colinearity: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=colinearity.d.ts.map

package/lib/exercises/geometry/vectors/colinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/colinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyCF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAWjD,CAAC"}

package/lib/exercises/geometry/vectors/colinearity.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colinearity = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getColinearityQuestion = () => {
+    const u = vector_1.VectorConstructor.random("u", false);
+    const isColinear = (0, coinFlip_1.coinFlip)();
+    let v;
+    if (isColinear) {
+        const coeff = new numberNode_1.NumberNode((0, randint_1.randint)(-5, 5));
+        v = u.times(coeff, "v");
+    }
+    else {
+        do {
+            v = vector_1.VectorConstructor.random("v", false);
+        } while (u.isColinear(v));
+    }
+    // const isColinear = u.isColinear(v);
+    const answer = isColinear ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. $${u.toTex()}$ et $${v.toTex()}$ sont-ils colinéaires ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xu: u.x.evaluate({}),
+            xv: v.x.evaluate({}),
+            yu: u.y.evaluate({}),
+            yv: v.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.colinearity = {
+    id: "colinearity",
+    label: "Déterminer si deux vecteurs sont colinéaires",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getColinearityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/index.d.ts

@@ -4,4 +4,5 @@ export * from "./determinant";
 export * from "./scalarProductViaCoords";
 export * from "./vectorCoordinatesFromTwoPoints";
 export * from "./scalarProductViaCos";
+export * from "./colinearity";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/geometry/vectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}

package/lib/exercises/geometry/vectors/index.js

@@ -20,3 +20,5 @@ __exportStar(require("./determinant"), exports);
 __exportStar(require("./scalarProductViaCoords"), exports);
 __exportStar(require("./vectorCoordinatesFromTwoPoints"), exports);
 __exportStar(require("./scalarProductViaCos"), exports);
+__exportStar(require("./colinearity"), exports);
+// export * from "./alignementViaColinearity";

package/lib/exercises/probaStat/independancy.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    pA: number;
+    pB: number;
+    pUnion: number;
+};
+export declare const independancy: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=independancy.d.ts.map

package/lib/exercises/probaStat/independancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancy.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/independancy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiDF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAalD,CAAC"}

package/lib/exercises/probaStat/independancy.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.independancy = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../math/numbers/decimals/decimal");
+const frenchify_1 = require("../../math/utils/latex/frenchify");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const coinFlip_1 = require("../../utils/coinFlip");
+const shuffle_1 = require("../../utils/shuffle");
+const getIndependancyQuestion = () => {
+    const pA = decimal_1.DecimalConstructor.random(0, 1, (0, randint_1.randint)(1, 3));
+    const pATree = pA.toTree();
+    const pB = decimal_1.DecimalConstructor.random(0, 1, (0, randint_1.randint)(1, 3));
+    const pBTree = pB.toTree();
+    const areIndependants = (0, coinFlip_1.coinFlip)();
+    const answer = areIndependants ? "Oui" : "Non";
+    let pUnion;
+    const unionValueIfIndependants = (0, round_1.round)(pA.value + pB.value - pA.value * pB.value, 5);
+    if (areIndependants)
+        pUnion = unionValueIfIndependants;
+    else {
+        do {
+            pUnion = decimal_1.DecimalConstructor.random(0, 1, (0, randint_1.randint)(1, 3)).value;
+        } while ((pUnion < pA.value && pUnion < pB.value) ||
+            pUnion === unionValueIfIndependants ||
+            pUnion > pA.value + pB.value);
+    }
+    const question = {
+        answer,
+        instruction: `Soient deux événements $A$ et $B$ tels que $P(A) = ${(0, frenchify_1.frenchify)(pA.value)}$, $P(B) = ${(0, frenchify_1.frenchify)(pB.value)}$ et $P(A\\cup B) = ${(0, frenchify_1.frenchify)(pUnion)}$. Les événements $A$ et $B$ sont-ils indépendants ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { pA: pA.value, pB: pB.value, pUnion },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.independancy = {
+    id: "independancy",
+    connector: "=",
+    label: "Déterminer l'indépendance de deux événements via la formule de Poincaré",
+    levels: ["1reSpé", "TermTech"],
+    isSingleStep: true,
+    sections: ["Probabilités"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIndependancyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/probaStat/index.d.ts

@@ -5,4 +5,5 @@ export * from "./diceBasicProbas";
 export * from "./probabilityTree";
 export * from "./stats1var";
 export * from "./stats2var";
+export * from "./independancy";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/probaStat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/lib/exercises/probaStat/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./diceBasicProbas"), exports);
 __exportStar(require("./probabilityTree"), exports);
 __exportStar(require("./stats1var"), exports);
 __exportStar(require("./stats2var"), exports);
+__exportStar(require("./independancy"), exports);

package/lib/index.d.ts

@@ -510,6 +510,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+}> | import("./exercises/exercise").MathExercise<{
+    xu: number;
+    yu: number;
+    xv: number;
+    yv: number;
 }> | import("./exercises/exercise").MathExercise<{
     coeffs: number[];
     to: string;
@@ -652,6 +657,10 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     xValues: number[];
     yValues: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    pA: number;
+    pB: number;
+    pUnion: number;
 }> | import("./exercises/exercise").MathExercise<{
     firstValue: number;
     askedRank: number;

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/math/geometry/line.d.ts

@@ -1,3 +1,13 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { Point } from "./point";
 export declare class Line {
+    pointA: Point;
+    pointB: Point;
+    isVertical: boolean;
+    a: AlgebraicNode | undefined;
+    b: AlgebraicNode | undefined;
+    constructor(pointA: Point, pointB: Point);
+    includes(point: Point): boolean;
+    getRandomPoint(name?: string): Point;
 }
 //# 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,qBAAa,IAAI;CAAG"}
+{"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,QAAQ,CAAC,KAAK,EAAE,KAAK;IAWrB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;CAY7B"}

package/lib/math/geometry/line.js

@@ -1,6 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Line = void 0;
+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 randint_1 = require("../utils/random/randint");
+const point_1 = require("./point");
 class Line {
+    constructor(pointA, pointB) {
+        this.pointA = pointA;
+        this.pointB = pointB;
+        this.isVertical = pointA.x.equals(pointB.x);
+        if (this.isVertical) {
+            this.a = undefined;
+            this.b = undefined;
+        }
+        else {
+            this.a = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(this.pointB.y, this.pointA.y), new substractNode_1.SubstractNode(this.pointB.x, this.pointA.x)).simplify();
+            this.b = new substractNode_1.SubstractNode(this.pointA.y, new multiplyNode_1.MultiplyNode(this.a, this.pointA.x)).simplify();
+        }
+    }
+    includes(point) {
+        if (this.isVertical) {
+            return point.x.equals(this.pointA.x);
+        }
+        return (new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({}) === 0);
+    }
+    getRandomPoint(name) {
+        if (this.isVertical) {
+            return new point_1.Point(name ?? "A", this.pointA.x, new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10)));
+        }
+        const x = new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10));
+        const y = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, x), this.b).simplify();
+        return new point_1.Point(name ?? "A", x, y);
+    }
 }
 exports.Line = Line;

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

@@ -1,7 +1,7 @@
-import { MathSet } from "../sets/mathSet";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class PointConstructor {
-    static random(domainX?: MathSet, domainY?: MathSet): Point;
+    static random(name: string): Point;
+    static randomDifferent(names: string[]): Point[];
 }
 export declare class Point {
     name: string;
@@ -15,18 +15,7 @@ export declare class Point {
     getYnumber(): number;
     midpoint(B: Point, name?: string): Point;
     distanceTo(B: Point): number;
+    equals(B: Point): boolean;
+    isAligned(B: Point, C: 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
-
- * }
- */
 //# 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":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,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,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,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"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAKlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,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;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;CAK7B"}

package/lib/math/geometry/point.js

@@ -3,15 +3,28 @@ 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");
+const vector_1 = require("./vector");
+const randint_1 = require("../utils/random/randint");
 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));
+    static random(name) {
+        const x = (0, randint_1.randint)(-10, 11);
+        const y = (0, randint_1.randint)(-10, 11);
+        return new Point(name, new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y));
+    }
+    static randomDifferent(names) {
+        const res = [];
+        const points = [];
+        for (let i = 0; i < names.length; i++) {
+            let x;
+            let y;
+            do {
+                x = (0, randint_1.randint)(-10, 11);
+                y = (0, randint_1.randint)(-10, 11);
+            } while (points.some((point) => point[0] === x && point[1] === y));
+            res.push(new Point(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y)));
+        }
+        return res;
     }
 }
 exports.PointConstructor = PointConstructor;
@@ -56,18 +69,13 @@ class Point {
         const dy = this.getYnumber() - B.getYnumber();
         return Math.sqrt(dx ** 2 + dy ** 2);
     }
+    equals(B) {
+        return this.x.equals(B.x) && this.y.equals(B.y);
+    }
+    isAligned(B, C) {
+        const AB = vector_1.VectorConstructor.fromPoints(this, B);
+        const AC = vector_1.VectorConstructor.fromPoints(this, C);
+        return AB.isColinear(AC);
+    }
 }
 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
-
- * }
- */

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

@@ -1,18 +1,21 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 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;
+    static random(name: string, allowNull?: boolean): Vector;
 }
 export declare class Vector {
     name: string;
     tex: string;
-    x: Node;
-    y: Node;
-    constructor(name: string, x: Node, y: Node);
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
     toTex(): string;
     toTexWithCoords(): string;
-    determinant(v: Vector): Node;
+    isColinear(v: Vector): boolean;
+    determinant(v: Vector): AlgebraicNode;
+    times(k: AlgebraicNode, name?: string): Vector;
     scalarProduct(v: Vector): Node;
 }
 //# 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,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"}
+{"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;AAKvD,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;CAa/B"}

package/lib/math/geometry/vector.js

@@ -3,14 +3,17 @@ 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 multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
 const randint_1 = require("../utils/random/randint");
 class VectorConstructor {
     static fromPoints(origin, end) {
-        return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x), new substractNode_1.SubstractNode(end.y, origin.y));
+        return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x).simplify(), new substractNode_1.SubstractNode(end.y, origin.y).simplify());
     }
-    static random(name) {
-        return new Vector(name, new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
+    static random(name, allowNull = true) {
+        const x = new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11));
+        const y = new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11, !allowNull && x.value === 0 ? [0] : undefined));
+        return new Vector(name, x, y);
     }
 }
 exports.VectorConstructor = VectorConstructor;
@@ -27,6 +30,10 @@ class Vector {
     toTexWithCoords() {
         return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\end{pmatrix}`;
     }
+    isColinear(v) {
+        const det = this.determinant(v);
+        return det.evaluate({}) === 0;
+    }
     determinant(v) {
         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");
@@ -36,6 +43,9 @@ class Vector {
         const vyValue = v.y.value;
         return new numberNode_1.NumberNode(xValue * vyValue - yValue * vxValue);
     }
+    times(k, name) {
+        return new Vector(name ?? "v", new multiplyNode_1.MultiplyNode(this.x, k).simplify(), new multiplyNode_1.MultiplyNode(this.y, k).simplify());
+    }
     scalarProduct(v) {
         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");

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

@@ -1,6 +1,5 @@
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
-import { Integer } from "../integer/integer";
 import { Nombre, NumberType } from "../nombre";
 import { Rational } from "../rationals/rational";
 export declare abstract class DecimalConstructor {
@@ -26,7 +25,7 @@ export declare class Decimal implements Nombre {
     multiplyByPowerOfTen(power: number): Decimal;
     toScientificPart(): NumberNode;
     toScientificNotation(): NumberNode | MultiplyNode;
-    toRational(): Rational | Integer;
+    toRational(): Rational | import("../integer/integer").Integer;
     toTree(): NumberNode;
 }
 //# sourceMappingURL=decimal.d.ts.map

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":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,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;IAK/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;IA4BlC,gBAAgB;IAgBhB,oBAAoB;IAmBpB,UAAU;IAMV,MAAM;CAGP"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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;IAK/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;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA2BhB,oBAAoB;IAsBpB,UAAU;IAMV,MAAM;CAGP"}

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

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Decimal = exports.DecimalConstructor = void 0;
 const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
-const integer_1 = require("../integer/integer");
 const nombre_1 = require("../nombre");
 const rational_1 = require("../rationals/rational");
 class DecimalConstructor {
@@ -21,6 +21,7 @@ class DecimalConstructor {
         }
         return decimals;
     }
+    //! a refacto, pour inclure "-0" et des min/max décimaux
     static random(min, max, precision) {
         let prec = precision ?? (0, randint_1.randint)(1, 4);
         const int = (0, randint_1.randint)(min, max) + "";
@@ -57,84 +58,14 @@ class Decimal {
      * @returns
      */
     round(precision) {
-        const intPartString = this.intPart + "";
-        if (precision < 0) {
-            if (precision < -intPartString.length)
-                throw Error("can't round to higher precision");
-            return new integer_1.Integer(this.intPart).round(-precision);
-        }
-        if (precision > this.precision)
-            throw Error("can't round to higher precision");
-        if (precision === this.precision)
-            return this;
-        let newFracPart = "", newIntPart = "";
-        const shouldRoundUp = Number(this.decimalPart[precision]) > 4;
-        if (shouldRoundUp) {
-            let retenue = true;
-            let i = precision - 1;
-            while (retenue) {
-                if (i > -1) {
-                    const nb = (Number(this.decimalPart[i]) + 1) % 10;
-                    if (nb || newFracPart) {
-                        newFracPart = nb.toString() + newFracPart;
-                    }
-                    if (nb !== 0) {
-                        retenue = false;
-                        for (let j = i - 1; j > -1; j--) {
-                            newFracPart = this.decimalPart[j] + newFracPart;
-                        }
-                        newIntPart = intPartString;
-                    }
-                    else
-                        i--;
-                }
-                else {
-                    const nb = (Number(intPartString[i + intPartString.length]) + 1) % 10;
-                    newIntPart = nb + "" + newIntPart;
-                    if (nb !== 0) {
-                        retenue = false;
-                        for (let j = i + intPartString.length - 1; j > -1; j--) {
-                            newIntPart = intPartString[j] + newIntPart;
-                        }
-                    }
-                    else
-                        i--;
-                }
-            }
-        }
-        else {
-            let retenue = true;
-            let i = precision - 1;
-            while (retenue) {
-                if (i > -1) {
-                    const nb = Number(this.decimalPart[i]);
-                    if (nb || newFracPart) {
-                        newFracPart = nb.toString() + newFracPart;
-                    }
-                    if (nb !== 0) {
-                        retenue = false;
-                        for (let j = i - 1; j > -1; j--) {
-                            newFracPart = this.decimalPart[j] + newFracPart;
-                        }
-                        newIntPart = intPartString;
-                    }
-                    else
-                        i--;
-                }
-                else {
-                    newIntPart = intPartString;
-                    retenue = false;
-                }
-            }
-        }
-        return DecimalConstructor.fromParts(newIntPart, newFracPart);
+        return new Decimal((0, round_1.round)(this.value, precision));
     }
     multiplyByPowerOfTen(power) {
         if (power === 0)
             return this;
         let newIntPart = "", newFracPart = "";
-        if (power > -1) {
-            newIntPart = this.intPart + "";
+        if (power > 0) {
+            newIntPart = (this.value + "").split(".")[0];
             for (let i = 0; i < power; i++) {
                 newIntPart +=
                     i > this.decimalPart.length - 1 ? "0" : this.decimalPart[i];
@@ -142,35 +73,46 @@ class Decimal {
             newFracPart = this.decimalPart.slice(power);
         }
         else {
-            const intPartString = this.intPart + "";
+            const intPartString = this.intPart.toString().replace("-", "");
+            const isNegative = this.value < 0;
             newFracPart = this.decimalPart;
             for (let i = intPartString.length - 1; i > intPartString.length - 1 + power; i--) {
                 newFracPart = (i < 0 ? "0" : intPartString[i]) + newFracPart;
             }
             if (power + intPartString.length < 1)
-                newIntPart = "0";
+                newIntPart = isNegative ? "-0" : "0";
             else
-                newIntPart = intPartString.slice(0, power + intPartString.length);
+                newIntPart =
+                    (isNegative ? "-" : "") +
+                        intPartString.slice(0, power + intPartString.length);
         }
+        console.log("in", newIntPart, newFracPart);
         return DecimalConstructor.fromParts(newIntPart, newFracPart);
     }
     toScientificPart() {
-        const intString = this.intPart.toString();
-        const intSize = intString.length;
-        if (intSize === 0 && this.intPart !== 0)
-            return this.toTree();
+        if (!this.decimalPart.length)
+            return new numberNode_1.NumberNode(this.intPart);
+        // const intString = this.intPart.toString();
+        // const intSize = intString.length;
+        // if (intSize === 0 && this.intPart !== 0) return this.toTree();
         if (this.intPart === 0) {
+            //true for -0
             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((this.tex[0] === "-" ? "-0." : "0.") +
+                this.decimalPart.slice(firstNonZeroIndex)));
         }
-        return new numberNode_1.NumberNode(Number(intString[0] + "." + intString.slice(1) + this.decimalPart));
+        const intString = this.intPart + "";
+        return new numberNode_1.NumberNode(Number((this.tex[0] === "-" ? "-" + this.tex[1] : this.tex[0]) +
+            "." +
+            (this.tex[0] === "-" ? intString.slice(2) : intString.slice(1)) +
+            this.decimalPart));
     }
     toScientificNotation() {
-        const intString = this.intPart.toString();
-        const intSize = intString.length;
-        if (intSize === 0)
+        const intString = this.intPart + "";
+        // const intSize = intString.length + (this.value < 0 ? 1 : 0);
+        if (this.intPart > -10 && this.intPart < 10 && this.intPart !== 0)
             return this.toTree();
         const decNode = this.toScientificPart();
         let leadingZeros = 0;
@@ -180,7 +122,9 @@ class Decimal {
                 break;
             leadingZeros++;
         }
-        const power = this.intPart === 0 ? -leadingZeros : intSize - 1;
+        const power = this.intPart === 0 ? -leadingZeros : (this.intPart + "").length - 1;
+        if (power === 0)
+            return this.toTree();
         if (power === 1)
             return new multiplyNode_1.MultiplyNode(decNode, new numberNode_1.NumberNode(10));
         return new multiplyNode_1.MultiplyNode(decNode, new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(power)));

package/lib/server.js

@@ -35,6 +35,7 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
+const decimal_1 = require("./math/numbers/decimals/decimal");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 const runServer = () => {
@@ -51,6 +52,24 @@ const runServer = () => {
     // console.log(parsed?.evaluate({ x: 1 }));
     // console.log("time", Date.now() - before);
     // tokenize(string);
+    // const a = DecimalConstructor.random(-4, 8);
+    // const a = new Decimal(-0.0009343);
+    // console.log(a.value, a.multiplyByPowerOfTen(-2).toTree().toTex());
+    // const b = new Decimal(0.0009343);
+    // console.log(b.value, b.multiplyByPowerOfTen(-2).toTree().toTex());
+    // const c = new Decimal(-2.00009343);
+    // console.log(c.value, c.multiplyByPowerOfTen(-2).toTree().toTex());
+    // const d = new Decimal(2.009343);
+    // console.log(d.value, d.multiplyByPowerOfTen(-2).toTree().toTex());
+    const power = 1;
+    const a = new decimal_1.Decimal(-0.00400250009343);
+    console.log(a.value, a.multiplyByPowerOfTen(power).toTree().toTex());
+    const b = new decimal_1.Decimal(0.04010009343);
+    console.log(b.value, b.multiplyByPowerOfTen(power).toTree().toTex());
+    const c = new decimal_1.Decimal(-23.00009343);
+    console.log(c.value, c.multiplyByPowerOfTen(power).toTree().toTex());
+    const d = new decimal_1.Decimal(20.4009343);
+    console.log(d.value, d.multiplyByPowerOfTen(power).toTree().toTex());
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.0.20",
+  "version": "2.0.21",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [