math-exercises 2.0.28 → 2.0.30

package/lib/exercises/functions/trinoms/canonicalFromDevForm.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.canonicalFromDevForm = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const integer_1 = require("../../../math/numbers/integer/integer");
 const trinom_1 = require("../../../math/polynomials/trinom");
-const discreteSet_1 = require("../../../math/sets/discreteSet");
 const shuffle_1 = require("../../../utils/shuffle");
 const getCanonicalFromDevFormQuestion = () => {
     const trinom = trinom_1.TrinomConstructor.randomCanonical();
@@ -25,7 +23,7 @@ const getPropositions = (n, { answer, a }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
     while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, trinom_1.TrinomConstructor.randomCanonical(new discreteSet_1.DiscreteSet([new integer_1.Integer(a), new integer_1.Integer(-a)]))
+        (0, exercise_1.tryToAddWrongProp)(propositions, trinom_1.TrinomConstructor.randomCanonical({ from: [a, -a] })
             .getCanonicalForm()
             .toTex());
     }

package/lib/exercises/functions/trinoms/secondDegreeInequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAa3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyHF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAa3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAuHF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/functions/trinoms/secondDegreeInequation.js

@@ -78,12 +78,9 @@ const getPropositions = (n, { answer, a, b, c, ineqType }) => {
 const isAnswerValid = (ans, { answer, a, b, c, ineqType }) => {
     const trinom = new trinom_1.Trinom(a, b, c);
     const roots = trinom.getRootsNode();
-    console.log("vea", roots.length);
     const ineq = new inequation_1.InequationSymbol(ineqType);
     const tree = getAnswer({ a, ineqType: ineq, roots });
     const texs = tree.toAllValidTexs();
-    console.log("2ndIneq VEA texs", texs);
-    console.log("2ndIneq VEA Answer", answer);
     return texs.includes(ans);
 };
 exports.secondDegreeInequation = {

package/lib/exercises/index.d.ts

@@ -8,6 +8,7 @@ export * from "./equaDiff";
 export * from "./functions";
 export * from "./geometry";
 export * from "./limits";
+export * from "./matrices";
 export * from "./percent";
 export * from "./powers";
 export * from "./primitive";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exercises/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exercises/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC"}

package/lib/exercises/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./equaDiff"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./geometry"), exports);
 __exportStar(require("./limits"), exports);
+__exportStar(require("./matrices"), exports);
 __exportStar(require("./percent"), exports);
 __exportStar(require("./powers"), exports);
 __exportStar(require("./primitive"), exports);

package/lib/exercises/limits/rationalFracForbiddenValueLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalFracForbiddenValueLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/rationalFracForbiddenValueLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AA+EF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,WAAW,CAarE,CAAC"}
+{"version":3,"file":"rationalFracForbiddenValueLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/rationalFracForbiddenValueLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAyEF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,WAAW,CAarE,CAAC"}

package/lib/exercises/limits/rationalFracForbiddenValueLimit.js

@@ -3,11 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rationalFracForbiddenValueLimit = void 0;
 const exercise_1 = require("../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
-const integer_1 = require("../../math/numbers/integer/integer");
 const affine_1 = require("../../math/polynomials/affine");
 const trinom_1 = require("../../math/polynomials/trinom");
-const discreteSet_1 = require("../../math/sets/discreteSet");
-const intervals_1 = require("../../math/sets/intervals/intervals");
 const randint_1 = require("../../math/utils/random/randint");
 const coinFlip_1 = require("../../utils/coinFlip");
 const getSign = (nb) => {
@@ -16,9 +13,7 @@ const getSign = (nb) => {
 const getSequenceRationalFracLimitQuestion = () => {
     const polyDenum = new affine_1.Affine(1, (0, randint_1.randint)(-9, 10, [0]));
     const forbiddenValue = -polyDenum.b;
-    const interval = new intervals_1.Interval("[[-10;10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(forbiddenValue)]));
-    const intervalStar = new intervals_1.Interval("[[-10;10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)]));
-    const polyNum = trinom_1.TrinomConstructor.randomFactorized(intervalStar, interval, interval);
+    const polyNum = trinom_1.TrinomConstructor.randomFactorized(undefined, { excludes: [forbiddenValue] }, { excludes: [forbiddenValue] });
     const numLimit = polyNum.calculate(-polyDenum.b);
     const isRight = (0, coinFlip_1.coinFlip)();
     const to = isRight ? `${forbiddenValue}` : `${forbiddenValue}`;

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

@@ -0,0 +1,2 @@
+export * from "./matrixInversibilityDomain";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/lib/exercises/matrices/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./matrixInversibilityDomain"), exports);

package/lib/exercises/matrices/matrixInversibilityDomain.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    a: string;
+    b: string;
+    c: string;
+    d: string;
+};
+export declare const matrixInversibilityDomain: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=matrixInversibilityDomain.d.ts.map

package/lib/exercises/matrices/matrixInversibilityDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixInversibilityDomain.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/matrixInversibilityDomain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAyBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0FF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAY/D,CAAC"}

package/lib/exercises/matrices/matrixInversibilityDomain.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matrixInversibilityDomain = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const matrix_1 = require("../../math/matrices/matrix");
+const integer_1 = require("../../math/numbers/integer/integer");
+const nombre_1 = require("../../math/numbers/nombre");
+const randint_1 = require("../../math/utils/random/randint");
+const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
+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 discreteSetNode_1 = require("../../tree/nodes/sets/discreteSetNode");
+const intervalNode_1 = require("../../tree/nodes/sets/intervalNode");
+const unionIntervalNode_1 = require("../../tree/nodes/sets/unionIntervalNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const latexParser_1 = require("../../tree/parsers/latexParser");
+const intervalKeys_1 = require("../utils/keys/intervalKeys");
+const getMatrixInversibilityDomainQuestion = () => {
+    const elements = [[], []];
+    for (let i = 0; i < 2; i++) {
+        for (let j = 0; j < 2; j++) {
+            elements[i][j] = nombre_1.NombreConstructor.random({
+                types: [nombre_1.NumberType.Integer, nombre_1.NumberType.Rational],
+                excludes: i === 0 && j === 0 ? [new integer_1.Integer(0)] : undefined,
+            }).toTree();
+        }
+    }
+    const matrix = new matrix_1.Matrix([
+        [new multiplyNode_1.MultiplyNode(elements[0][0], new variableNode_1.VariableNode("x")), elements[0][1]],
+        elements[1],
+    ]);
+    // si d=0 & (b|c)=0 alors det = 0 sur R donc non inversible sur R
+    // sinon si d=0, inversible sur R
+    // sinon x = bc /ad et inversible sur R\x
+    const isDZero = elements[1][1].evaluate({}) === 0;
+    const isBorCZero = elements[0][1].evaluate({}) === 0 || elements[1][0].evaluate({}) === 0;
+    const x = isDZero
+        ? undefined
+        : new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(elements[0][1], elements[1][0]), new multiplyNode_1.MultiplyNode(elements[0][0], elements[1][1])).simplify();
+    const answer = isDZero && isBorCZero
+        ? discreteSetNode_1.EmptySet.toTex()
+        : isDZero
+            ? "\\mathbb{R}"
+            : new unionIntervalNode_1.UnionIntervalNode([
+                new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, x, intervalNode_1.ClosureType.OO),
+                new intervalNode_1.IntervalNode(x, infiniteNode_1.PlusInfinityNode, intervalNode_1.ClosureType.OO),
+            ]).toTex();
+    const question = {
+        answer,
+        instruction: `Soit $M = ${matrix.toTex()}$, où $x\\in \\mathbb{R}$. Sur quel ensemble la matrice $M$ est-elle inversible ?
+    `,
+        keys: intervalKeys_1.intervalKeys,
+        answerFormat: "tex",
+        identifiers: {
+            a: elements[0][0].toTex(),
+            b: elements[0][1].toTex(),
+            c: elements[1][0].toTex(),
+            d: elements[1][1].toTex(),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c, d }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const aTree = (0, latexParser_1.parseLatex)(a);
+    const bTree = (0, latexParser_1.parseLatex)(b);
+    const cTree = (0, latexParser_1.parseLatex)(c);
+    const dTree = (0, latexParser_1.parseLatex)(d);
+    const det = new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(aTree, dTree), new multiplyNode_1.MultiplyNode(bTree, cTree)).simplify();
+    (0, exercise_1.tryToAddWrongProp)(propositions, unionIntervalNode_1.UnionIntervalNodeBuilder.realMinus(det).toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, unionIntervalNode_1.UnionIntervalNodeBuilder.realMinus((0, randint_1.randint)(-10, 10).toTree()).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.matrixInversibilityDomain = {
+    id: "matrixInversibilityDomain",
+    label: "Déterminer le domaine d'inversibilité d'une matrice",
+    levels: ["MathExp"],
+    isSingleStep: true,
+    sections: ["Matrices"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMatrixInversibilityDomainQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/sets/intervals/inequalityToInterval.d.ts

@@ -1,7 +1,10 @@
 import { MathExercise } from "../../../exercises/exercise";
+import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
     isIntervalToInequality: boolean;
-    intervalTex: string;
+    intervalMin: number;
+    intervalMax: number;
+    intervalClosure: ClosureType;
 };
 export declare const inequalityToInterval: MathExercise<Identifiers>;
 export {};

package/lib/exercises/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmKF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAKjE,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AA8KF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/sets/intervals/inequalityToInterval.js

@@ -38,12 +38,14 @@ const getInequalityToIntervalQuestion = () => {
         answerFormat: "tex",
         identifiers: {
             isIntervalToInequality: isIntervalToInequality,
-            intervalTex: interval.tex,
+            intervalMin: interval.min,
+            intervalMax: interval.max,
+            intervalClosure: interval.closure,
         },
     };
     return question;
 };
-const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) => {
+const getPropositions = (n, { answer, isIntervalToInequality, intervalClosure, intervalMax, intervalMin }) => {
     const reverseBracket = (bracket) => {
         return bracket === "[" ? "]" : "[";
     };
@@ -65,7 +67,7 @@ const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) =>
             return "<";
         return "\\le";
     };
-    const interval = new intervals_1.Interval(intervalTex);
+    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure);
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
     const xNode = new variableNode_1.VariableNode("x");
@@ -117,17 +119,18 @@ const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) =>
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { intervalTex, isIntervalToInequality }) => {
-    const interval = new intervals_1.Interval(intervalTex).toTree();
-    console.log(interval.toTex());
+const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin, isIntervalToInequality }) => {
+    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure).toTree();
+    console.log("int", interval.toTex());
     const inequality = interval.toInequality();
     const answer = isIntervalToInequality
         ? inequality
         : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
             allowRawRightChildAsSolution: true,
         });
+    console.log("ans", answer);
     const texs = answer.toAllValidTexs();
-    console.log(texs);
+    console.log("texs", texs);
     return texs.includes(ans);
 };
 exports.inequalityToInterval = {

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts

@@ -1,7 +1,12 @@
 import { MathExercise } from "../../../exercises/exercise";
+import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Tex: string;
-    int2Tex: string;
+    int1Min: number;
+    int1Max: number;
+    int1Closure: ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: ClosureType;
 };
 export declare const intervalsIntersection: MathExercise<Identifiers>;
 export {};

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAGjE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAwDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/sets/intervals/intervalsIntersection.js

@@ -22,15 +22,22 @@ const getIntervalsIntersectionQuestion = () => {
             "cap",
         ],
         answerFormat: "tex",
-        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
+        identifiers: {
+            int1Closure: int1.closure,
+            int1Max: int1.max,
+            int1Min: int1.min,
+            int2Closure: int2.closure,
+            int2Max: int2.max,
+            int2Min: int2.min,
+        },
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
+const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Tex);
-    const int2 = new intervals_1.Interval(int2Tex);
+    const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
+    const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
     (0, exercise_1.tryToAddWrongProp)(propositions, int1.union(int2).tex);
     while (propositions.length < n) {
         const wrongAnswer = intervals_1.IntervalConstructor.random().tex;

package/lib/exercises/sets/intervals/intervalsUnion.d.ts

@@ -1,7 +1,12 @@
 import { MathExercise } from "../../../exercises/exercise";
+import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Tex: string;
-    int2Tex: string;
+    int1Min: number;
+    int1Max: number;
+    int1Closure: ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: ClosureType;
 };
 export declare const intervalsUnion: MathExercise<Identifiers>;
 export {};

package/lib/exercises/sets/intervals/intervalsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsCF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAGjE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6CF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/sets/intervals/intervalsUnion.js

@@ -14,15 +14,22 @@ const getIntervalsUnionQuestion = () => {
         instruction: `Soit $I = ${int1.tex}$ et $J = ${int2.tex}$. Déterminer $I\\cup J$.`,
         keys: ["infty", "lbracket", "rbracket", "semicolon", "cup", "cap"],
         answerFormat: "tex",
-        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
+        identifiers: {
+            int1Closure: int1.closure,
+            int1Max: int1.max,
+            int1Min: int1.min,
+            int2Closure: int2.closure,
+            int2Max: int2.max,
+            int2Min: int2.min,
+        },
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
+const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Tex);
-    const int2 = new intervals_1.Interval(int2Tex);
+    const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
+    const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
     (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).tex);
     while (propositions.length < n) {
         const wrongAnswer = intervals_1.IntervalConstructor.random().tex;

package/lib/exercises/utils/keys/intervalKeys.d.ts

@@ -0,0 +1,3 @@
+import { KeyId } from "../../../types/keyIds";
+export declare const intervalKeys: KeyId[];
+//# sourceMappingURL=intervalKeys.d.ts.map

package/lib/exercises/utils/keys/intervalKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalKeys.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/keys/intervalKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,eAAO,MAAM,YAAY,EAAE,KAAK,EAM/B,CAAC"}

package/lib/exercises/utils/keys/intervalKeys.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalKeys = void 0;
+exports.intervalKeys = [
+    "lbracket",
+    "rbracket",
+    "semicolon",
+    "cup",
+    "infty",
+];

package/lib/index.d.ts

@@ -1,3 +1,9 @@
+declare global {
+    interface Number {
+        toTree: () => AlgebraicNode;
+    }
+}
+import { AlgebraicNode } from "./tree/nodes/algebraicNode";
 declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     chosenNumbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
@@ -32,6 +38,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     rationalNum: [number, number];
     rationalDenum: [number, number];
 }> | import("./exercises/exercise").MathExercise<{
+    /**
+     * 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!)
+    
+    */
     rational: [number, number];
     rational2: [number, number];
 }> | import("./exercises/exercise").MathExercise<{
@@ -453,6 +491,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     signs: number[];
     isLog10: boolean;
 }> | import("./exercises/exercise").MathExercise<{
+    /**
+     * 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!)
+    
+    */
     coin: boolean;
     radius: number;
     diametre: number;
@@ -588,6 +658,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     to: string;
     from: string | undefined;
     a: number | undefined;
+}> | import("./exercises/exercise").MathExercise<{
+    a: string;
+    b: string;
+    c: string;
+    d: string;
 }> | import("./exercises/exercise").MathExercise<{
     randNbr: number;
     randPercent: number;
@@ -596,7 +671,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     rate: number;
     nbMois: number;
 }> | import("./exercises/exercise").MathExercise<{
-    isFromEvolutionToCM: boolean;
+    isFromEvolutionToCM: boolean; /**
+     * 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!)
+    
+    */
     evolution: number;
 }> | import("./exercises/exercise").MathExercise<{
     evolutions: string[];
@@ -760,13 +866,23 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     coeffs: number[];
 }> | import("./exercises/exercise").MathExercise<{
     isIntervalToInequality: boolean;
-    intervalTex: string;
-}> | import("./exercises/exercise").MathExercise<{
-    int1Tex: string;
-    int2Tex: string;
-}> | import("./exercises/exercise").MathExercise<{
-    int1Tex: string;
-    int2Tex: string;
+    intervalMin: number;
+    intervalMax: number;
+    intervalClosure: import("./tree/nodes/sets/intervalNode").ClosureType;
+}> | import("./exercises/exercise").MathExercise<{
+    int1Min: number;
+    int1Max: number;
+    int1Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+}> | import("./exercises/exercise").MathExercise<{
+    int1Min: number;
+    int1Max: number;
+    int1Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
 }> | import("./exercises/exercise").MathExercise<{
     type: number;
     nb: string;

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":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/index.js

@@ -24,6 +24,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mathExercises = void 0;
+// import { exercises } from "./exercises/exercises";
+const numberNode_1 = require("./tree/nodes/numbers/numberNode");
+Number.prototype.toTree = function () {
+    const value = this.valueOf();
+    if (value === Infinity)
+        return infiniteNode_1.PlusInfinityNode;
+    if (value === -Infinity)
+        return infiniteNode_1.MinusInfinityNode;
+    return new numberNode_1.NumberNode(value);
+};
 /**
  * TODO
  * Décimal : permettre facilement -0.xxx
@@ -57,5 +67,6 @@ exports.mathExercises = void 0;
 
 */
 const Exercises = __importStar(require("./exercises"));
+const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const mathExercises = Object.values(Exercises);
 exports.mathExercises = mathExercises;

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":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,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"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,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/matrices/matrix.d.ts

@@ -0,0 +1,10 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare class Matrix {
+    elements: AlgebraicNode[][];
+    rows: number;
+    columns: number;
+    constructor(elements: AlgebraicNode[][]);
+    determinant(): AlgebraicNode;
+    toTex(): string;
+}
+//# sourceMappingURL=matrix.d.ts.map