math-exercises 2.2.80 → 2.2.82

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

@@ -3,17 +3,74 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intervalsIntersection = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
 const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
 const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const discreteSetParser_1 = require("../../../../tree/parsers/discreteSetParser");
+const intervalParser_1 = require("../../../../tree/parsers/intervalParser");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const rebuildIdentifiers = (oldIds) => {
+    const a1 = oldIds.int1Min === "-infty" ? infiniteNode_1.MinusInfinityNode : oldIds.int1Min.toTree();
+    const b1 = oldIds.int1Max === "infty" ? infiniteNode_1.PlusInfinityNode : oldIds.int1Max.toTree();
+    const closure1 = oldIds.int1Closure;
+    const interval1 = new intervalNode_1.IntervalNode(a1, b1, closure1);
+    const a2 = oldIds.int2Min === "-infty" ? infiniteNode_1.MinusInfinityNode : oldIds.int2Min.toTree();
+    const b2 = oldIds.int2Max === "infty" ? infiniteNode_1.PlusInfinityNode : oldIds.int2Max.toTree();
+    const closure2 = oldIds.int2Closure;
+    const interval2 = new intervalNode_1.IntervalNode(a2, b2, closure2);
+    return {
+        int1Identifiers: interval1.toIdentifiers(),
+        int2Identifiers: interval2.toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    return `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. 
+ 
+Déterminer $I\\cap J$.`;
+};
+const getAnswer = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    const inter = int1.intersection(int2);
+    return inter.toTex();
+};
+const getCorrection = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    const inter = int1.intersection(int2);
+    const answer = inter.toTex();
+    return `$I$ contient les nombres ${int1.toText(true, false)}. 
+    
+$J$ contient les nombres ${int2.toText(false, false)}.
+    
+${(0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 0
+        ? `Il n'y a donc aucun nombre commun aux intervalles $I$ et $J$.`
+        : (0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 1
+            ? `Il n'y a donc qu'un nombre commun aux intervalles $I$ et $J$ : $${inter.elements[0].toTex()}$.`
+            : (0, intervalNode_1.isIntervalNode)(inter) &&
+                `Les nombres communs à $I$ et $J$ sont donc les nombres ${inter.toText(true, false)}.`}
+    
+Ainsi, $I\\cap J = ${answer}$`;
+};
 const getIntervalsIntersectionQuestion = () => {
-    const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
+    const [int1, int2] = intervalNode_1.IntervalNodeConstructor.differentRandoms(2);
     const inter = int1.intersection(int2);
     const answer = inter.toTex();
+    const identifiers = {
+        int1Identifiers: int1.toIdentifiers(),
+        int2Identifiers: int2.toIdentifiers(),
+    };
     const question = {
-        answer,
-        instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [
             "infty",
             "varnothing",
@@ -26,44 +83,46 @@ const getIntervalsIntersectionQuestion = () => {
             "rbrace",
         ],
         answerFormat: "tex",
-        identifiers: {
-            int1Closure: int1.closure,
-            int1Max: int1.max,
-            int1Min: int1.min,
-            int2Closure: int2.closure,
-            int2Max: int2.max,
-            int2Min: int2.min,
-        },
+        identifiers,
         hint: `Détermine l'ensemble des nombres qui appartiennent à la fois à $I$ et à $J$.`,
-        correction: `$I$ contient les nombres ${int1.toTree().toText(true, false)}. 
-    
-$J$ contient les nombres ${int2.toTree().toText(false, false)}.
-    
-${(0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 0
-            ? `Il n'y a donc aucun nombre commun aux intervalles $I$ et $J$.`
-            : (0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 1
-                ? `Il n'y a donc qu'un nombre commun aux intervalles $I$ et $J$ : $${inter.elements[0].toTex()}$.`
-                : (0, intervalNode_1.isIntervalNode)(inter) &&
-                    `Les nombres communs à $I$ et $J$ sont donc les nombres ${inter.toText(true, false)}.`}
-    
-Ainsi, $I\\cap J = ${answer}$`,
+        correction: getCorrection(identifiers),
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
+const getPropositions = (n, { answer, int1Identifiers, int2Identifiers }) => {
     const propositions = [];
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int2Identifiers),
+    ];
     (0, exercise_1.addValidProp)(propositions, answer);
-    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);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int1.union(int2).toTex());
     while (propositions.length < n) {
-        const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
+        const wrongAnswer = intervalNode_1.IntervalNodeConstructor.random().toTex();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, int1Identifiers, int2Identifiers }) => {
+    try {
+        if (answer === "\\varnothing")
+            return ans === answer;
+        if (answer.includes("\\{")) {
+            const setParsed = (0, discreteSetParser_1.discreteSetParser)(ans);
+            if (!setParsed)
+                return false;
+            return setParsed.simplify().toTex() === answer;
+        }
+        else {
+            const parsed = (0, intervalParser_1.intervalParser)(ans);
+            if (!parsed)
+                return false;
+            return parsed.simplify().toTex() === answer;
+        }
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.intervalsIntersection = {
     id: "intervalsIntersection",
@@ -79,4 +138,5 @@ exports.intervalsIntersection = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    rebuildIdentifiers,
 };

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

@@ -1,12 +1,8 @@
 import { Exercise } from "../../../../exercises/exercise";
-import { ClosureType } from "../../../../tree/nodes/sets/closure";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Min: number;
-    int1Max: number;
-    int1Closure: ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: ClosureType;
+    int1Identifiers: IntervalNodeIdentifiers;
+    int2Identifiers: IntervalNodeIdentifiers;
 };
 export declare const intervalsUnion: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,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,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAI5C,KAAK,WAAW,GAAG;IAOjB,eAAe,EAAE,uBAAuB,CAAC;IACzC,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAyFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

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

@@ -3,42 +3,80 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intervalsUnion = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const unionIntervalParser_1 = require("../../../../tree/parsers/unionIntervalParser");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
-const getIntervalsUnionQuestion = () => {
-    const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
+const rebuildIdentifiers = (oldIds) => {
+    const a1 = oldIds.int1Min === "-infty" ? infiniteNode_1.MinusInfinityNode : oldIds.int1Min.toTree();
+    const b1 = oldIds.int1Max === "infty" ? infiniteNode_1.PlusInfinityNode : oldIds.int1Max.toTree();
+    const closure1 = oldIds.int1Closure;
+    const interval1 = new intervalNode_1.IntervalNode(a1, b1, closure1);
+    const a2 = oldIds.int2Min === "-infty" ? infiniteNode_1.MinusInfinityNode : oldIds.int2Min.toTree();
+    const b2 = oldIds.int2Max === "infty" ? infiniteNode_1.PlusInfinityNode : oldIds.int2Max.toTree();
+    const closure2 = oldIds.int2Closure;
+    const interval2 = new intervalNode_1.IntervalNode(a2, b2, closure2);
+    return {
+        int1Identifiers: interval1.toIdentifiers(),
+        int2Identifiers: interval2.toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    return `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$.
+  
+Déterminer $I\\cup J$.`;
+};
+const getAnswer = (identifiers) => {
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
     const set = int1.union(int2);
-    const answer = set.tex;
+    return set.toTex();
+};
+const getIntervalsUnionQuestion = () => {
+    const [int1, int2] = intervalNode_1.IntervalNodeConstructor.differentRandoms(2);
+    const identifiers = {
+        int1Identifiers: int1.toIdentifiers(),
+        int2Identifiers: int2.toIdentifiers(),
+    };
     const question = {
-        answer,
-        instruction: `Soit $I = ${int1.tex}$ et $J = ${int2.tex}$. Déterminer $I\\cup J$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["infty", "lbracket", "rbracket", "semicolon", "cup", "cap"],
         answerFormat: "tex",
-        identifiers: {
-            int1Closure: int1.closure,
-            int1Max: int1.max,
-            int1Min: int1.min,
-            int2Closure: int2.closure,
-            int2Max: int2.max,
-            int2Min: int2.min,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
+const getPropositions = (n, { answer, int1Identifiers, int2Identifiers }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
-    const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
+    const [int1, int2] = [
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int1Identifiers),
+        intervalNode_1.IntervalNodeConstructor.fromIdentifiers(int2Identifiers),
+    ];
     (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).toTex());
     while (propositions.length < n) {
-        const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
+        const wrongAnswer = intervalNode_1.IntervalNodeConstructor.random().toTex();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    try {
+        const parsed = (0, unionIntervalParser_1.unionIntervalParser)(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.intervalsUnion = {
     id: "intervalsUnion",
@@ -53,4 +91,5 @@ exports.intervalsUnion = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    rebuildIdentifiers,
 };

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

@@ -47,6 +47,8 @@ export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos";
 export * from "../math/geometry/vectors/coordinatesReading";
 export * from "../math/functions/affines/affineExpressionReading";
+export * from "../math/geometry/thales/thales";
+export * from "../math/geometry/thales/thalesCalcul";
 export * from "../math/equaDiff/equaDiffCheckSolutionFirstOrder";
 export * from "../math/equaDiff/equaDiffGeneralForme";
 export * from "../math/equaDiff/equaDiffGeneralFormeWithIC";
@@ -55,4 +57,6 @@ export * from "../math/derivation/derivative/usualderivative";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/thirdDegreeDerivative";
 export { firstDegreeDerivative } from "../math/derivation/derivative/firstDegreeDerivative";
 export { secondDegreeDerivative } from "../math/derivation/derivative/secondDegreeDerivative";
+export * from "../math/trigonometry/trigonometrySideCalcul";
+export * from "../math/trigonometry/trigonometryAngleCalcul";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AAExB,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAIlE,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AAExB,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC9F,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC"}

package/lib/exercises/pc/index.js

@@ -68,9 +68,8 @@ __exportStar(require("../math/geometry/vectors/scalarProduct/scalarProductViaCoo
 __exportStar(require("../math/geometry/vectors/scalarProduct/scalarProductViaCos"), exports);
 __exportStar(require("../math/geometry/vectors/coordinatesReading"), exports);
 __exportStar(require("../math/functions/affines/affineExpressionReading"), exports);
-//!FIX TRIANGLE
-// export * from "../math/geometry/thales/thales";
-// export * from "../math/geometry/thales/thalesCalcul";
+__exportStar(require("../math/geometry/thales/thales"), exports);
+__exportStar(require("../math/geometry/thales/thalesCalcul"), exports);
 __exportStar(require("../math/equaDiff/equaDiffCheckSolutionFirstOrder"), exports);
 __exportStar(require("../math/equaDiff/equaDiffGeneralForme"), exports);
 __exportStar(require("../math/equaDiff/equaDiffGeneralFormeWithIC"), exports);
@@ -82,6 +81,5 @@ var firstDegreeDerivative_1 = require("../math/derivation/derivative/firstDegree
 Object.defineProperty(exports, "firstDegreeDerivative", { enumerable: true, get: function () { return firstDegreeDerivative_1.firstDegreeDerivative; } });
 var secondDegreeDerivative_1 = require("../math/derivation/derivative/secondDegreeDerivative");
 Object.defineProperty(exports, "secondDegreeDerivative", { enumerable: true, get: function () { return secondDegreeDerivative_1.secondDegreeDerivative; } });
-// export * from "../math/trigonometry/trigonometrySideCalcul";
-// export * from "../math/trigonometry/trigonometryAngleCalcul";
-//!FIX TRIANGLE
+__exportStar(require("../math/trigonometry/trigonometrySideCalcul"), exports);
+__exportStar(require("../math/trigonometry/trigonometryAngleCalcul"), exports);

package/lib/exercises/vea/equationVEA.js

@@ -12,9 +12,9 @@ const equationVEA = (ans, solutionTex) => {
         }
         else {
             const setParsed = (0, discreteSetParser_1.discreteSetParser)(ans);
-            if (!setParsed || setParsed.length !== 1)
+            if (!setParsed || setParsed.elements.length !== 1)
                 return false;
-            return (0, rationalVEA_1.rationalVEA)(setParsed[0].toTex(), solutionTex);
+            return (0, rationalVEA_1.rationalVEA)(setParsed.elements[0].toTex(), solutionTex);
         }
     }
     catch (err) {

package/lib/geogebra/lagrange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAelE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAelE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/geogebra/spline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE,8BAAsB,iBAAiB;IACrC,MAAM;CAQP;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE,8BAAsB,iBAAiB;IACrC,MAAM;CAQP;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/index.d.ts

@@ -354,14 +354,18 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
+}, {
+    inequationSolutionFormat: string;
+}> | Exercise<{
     coeff: number;
     ineqType: import("./math/inequations/inequation").InegalitySymbols;
     a: number;
     b: number;
     c: number;
     d: number;
-}, {}> | Exercise<{
+}, {
+    inequationSolutionFormat: string;
+}> | Exercise<{
     k: number;
     inequationSymbol: import("./math/inequations/inequation").InegalitySymbols;
 }, {}> | Exercise<{
@@ -850,12 +854,16 @@ declare const mathExercises: (Exercise<{
     c: number;
     k: number;
     isLog10: boolean;
-}, {}> | Exercise<{
+}, {
+    isLog10: boolean;
+}> | Exercise<{
     nb: number;
     powers: number[];
     signs: number[];
     isLog10: boolean;
-}, {}> | Exercise<{
+}, {
+    isLog10: boolean;
+}> | Exercise<{
     type: string;
     fctTex: string;
 }, {}> | Exercise<{
@@ -1631,27 +1639,15 @@ declare const mathExercises: (Exercise<{
     points: number[][];
     isArithmetic: boolean;
 }, {}> | Exercise<{
-    intervalMin: string | number;
-    intervalMax: string | number;
-    intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
+    intervalIdentifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
-    int1Min: number;
-    int1Max: number;
-    int1Closure: import("./tree/nodes/sets/closure").ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: import("./tree/nodes/sets/closure").ClosureType;
+    int1Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
+    int2Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
-    int1Min: number;
-    int1Max: number;
-    int1Closure: import("./tree/nodes/sets/closure").ClosureType;
-    int2Min: number;
-    int2Max: number;
-    int2Closure: import("./tree/nodes/sets/closure").ClosureType;
+    int1Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
+    int2Identifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
-    intervalMin: string | number;
-    intervalMax: string | number;
-    intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
+    intervalIdentifiers: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
     type: number;
     nb: string;
@@ -1873,12 +1869,33 @@ declare const pcExercises: (Exercise<{
     c: number;
     k: number;
     isLog10: boolean;
-}, {}> | Exercise<{
+}, {
+    isLog10: boolean;
+}> | Exercise<{
     nb: number;
     powers: number[];
     signs: number[];
     isLog10: boolean;
+}, {
+    isLog10: boolean;
+}> | Exercise<{
+    vertices: string[];
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+    xC: number;
+    yC: number;
+    factor: number;
 }, {}> | Exercise<{
+    ratio: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+    insidePointsNames: string[];
+    segmentAskedName: string;
+    isPapillon: boolean;
+}, {
+    configurationType: string;
+}> | Exercise<{
     xA: number;
     xB: number;
     yA: number;
@@ -1899,6 +1916,15 @@ declare const pcExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, {}> | Exercise<{
+    randAngle: number;
+    hiddenSide: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+}, {}> | Exercise<{
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
     reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
 }, {}> | Exercise<{

package/lib/index.d.ts.map

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

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":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}

package/lib/math/inequations/inequation.d.ts

@@ -11,6 +11,6 @@ export declare class InequationSymbol {
     reversed: () => InegalitySymbols;
     toReversed: () => InequationSymbol;
     toStrictnessToggled: () => InequationSymbol;
-    strictnessToggled: () => "<" | ">" | "\\le" | "\\ge";
+    strictnessToggled: () => InegalitySymbols;
 }
 //# sourceMappingURL=inequation.d.ts.map

package/lib/math/inequations/inequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequation.d.ts","sourceRoot":"","sources":["../../../src/math/inequations/inequation.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,gBAAgB,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,8BAAsB,2BAA2B;IAC/C,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,YAAY;CAGpB;AACD,qBAAa,gBAAgB;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;gBACb,MAAM,EAAE,gBAAgB;IAKpC,QAAQ,QAAO,gBAAgB,CAW7B;IACF,UAAU,yBAER;IACF,mBAAmB,yBAEjB;IACF,iBAAiB,oCAWf;CACH"}
+{"version":3,"file":"inequation.d.ts","sourceRoot":"","sources":["../../../src/math/inequations/inequation.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,gBAAgB,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,8BAAsB,2BAA2B;IAC/C,MAAM,CAAC,MAAM;IAGb,MAAM,CAAC,YAAY;CAGpB;AACD,qBAAa,gBAAgB;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;gBACb,MAAM,EAAE,gBAAgB;IAKpC,QAAQ,QAAO,gBAAgB,CAW7B;IACF,UAAU,yBAER;IACF,mBAAmB,yBAEjB;IACF,iBAAiB,QAAO,gBAAgB,CAWtC;CACH"}

package/lib/math/numbers/integer/integer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAIN,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMxB,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,UAAU;IAIpB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMxB,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}

package/lib/math/numbers/rationals/rational.d.ts

@@ -1,6 +1,5 @@
-import { OppositeNode } from "../../../tree/nodes/functions/oppositeNode";
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
 import { NodeOptions } from "../../../tree/nodes/node";
-import { FractionNode } from "../../../tree/nodes/operators/fractionNode";
 import { Integer } from "../integer/integer";
 import { Nombre, NumberType } from "../nombre";
 export declare abstract class RationalConstructor {
@@ -30,7 +29,7 @@ export declare class Rational implements Nombre {
     reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): FractionNode | OppositeNode<FractionNode>;
+    toTree(opts?: NodeOptions): AlgebraicNode;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

package/lib/math/numbers/rationals/rational.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAMvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAgBzB,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa;IAgBzC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}

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

@@ -1,10 +1,8 @@
 import { NumberNode } from "../../tree/nodes/numbers/numberNode";
 import { AddNode } from "../../tree/nodes/operators/addNode";
-import { FractionNode } from "../../tree/nodes/operators/fractionNode";
 import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
 import { Point } from "../geometry/point";
 import { Polynomial } from "./polynomial";
-import { OppositeNode } from "../../tree/nodes/functions/oppositeNode";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class TrinomConstructor {
     static random(aOpts?: {
@@ -65,9 +63,9 @@ export declare class Trinom extends Polynomial {
     getRootsNode(): AlgebraicNode[];
     getRootsEquationSolutionTex(): string;
     getAlpha(): number;
-    getAlphaNode(): NumberNode | FractionNode | OppositeNode<FractionNode>;
+    getAlphaNode(): AlgebraicNode | NumberNode;
     getBeta(): number;
-    getBetaNode(): NumberNode | FractionNode | OppositeNode<FractionNode>;
+    getBetaNode(): AlgebraicNode | NumberNode;
     getFactorizedForm(): AlgebraicNode | MultiplyNode;
     getCanonicalForm(): AddNode | MultiplyNode;
     getSommet(): Point;

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/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAKtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAsDA,eAAO,MAAM,UAAU,YAGtB,CAAC"}

package/lib/playground.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
+const sqrtNode_1 = require("./tree/nodes/functions/sqrtNode");
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
+const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
 const playground = () => {
-    // const a = multiply(-3, power("x", 2));
-    // console.log(isMonom(a));
-    // const a = "-3x^2";
-    // console.log(isMonom(parsed));
+    const a = (0, multiplyNode_1.multiply)(3, (0, sqrtNode_1.sqrt)(2));
+    console.log(a.simplify().toTex());
 };
 exports.playground = playground;
 const logIdentifiers = () => {

package/lib/tree/nodes/equations/equationSolutionNode.d.ts

@@ -23,7 +23,6 @@ export declare class EquationSolutionNode implements Node {
     toAllTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): EquationSolutionNode[];
     toMathString(): string;
-    toMathjs(): string;
     toTex(): string;
     simplify(): this;
 }