math-exercises 2.0.41 → 2.0.43

package/lib/exercises/sequences/arithmetic/arithmeticReasonUsage.js

@@ -15,7 +15,7 @@ const getArithmeticReasonUsage = () => {
         instruction: `$(u_n)$ est une suite arithmétique de raison $r = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`,
         startStatement: `u_{${askedRank}}`,
         answer,
-        keys: ["r", "n", "u", "underscore"],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { reason, startRank, startValue },
     };
@@ -29,8 +29,12 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, startRank }) => {
+    return [
+        answer,
+        `u_${startRank + 1}=${answer}`,
+        `u_{${startRank + 1}}=${answer}`,
+    ].includes(ans);
 };
 exports.arithmeticReasonUsage = {
     id: "arithmeticReasonUsage",

package/lib/exercises/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAkCF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CAatE,CAAC"}
+{"version":3,"file":"arithmeticRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsCF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CAatE,CAAC"}

package/lib/exercises/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.js

@@ -15,7 +15,7 @@ const getArithmeticRecurrenceFormulaUsage = () => {
         instruction: `$(u_n)$ est une suite définie par $u_{n+1} = ${reason} + u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`,
         startStatement: `u_{${askedRank}}`,
         answer,
-        keys: ["r", "n", "u", "underscore"],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { firstRank, firstValue, reason },
     };
@@ -29,8 +29,12 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, firstRank }) => {
+    return [
+        answer,
+        `u_${firstRank + 1}=${answer}`,
+        `u_{${firstRank + 1}}=${answer}`,
+    ].includes(ans);
 };
 exports.arithmeticRecurrenceFormulaUsage = {
     id: "arithmeticRecurrenceFormulaUsage",

package/lib/exercises/sequences/explicitFormulaUsage.js

@@ -14,7 +14,7 @@ const getExplicitFormulaUsageQuestion = () => {
         instruction: `Soit $u$ la suite définie pour tout $n\\geq 0$ par $u_n = ${u
             .toTree()
             .toTex()}$. Calculer $u_${rank}$.`,
-        keys: [],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { rank, coeffs: u.coefficients },
     };
@@ -32,8 +32,8 @@ const getPropositions = (n, { answer, rank, coeffs }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, rank }) => {
+    return [answer, `u_{${rank}}=${answer}`, `u_${rank}=${answer}`].includes(ans);
 };
 exports.explicitFormulaUsage = {
     id: "explicitFormulaUsage",

package/lib/exercises/sequences/geometric/geometricExplicitFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4CF,eAAO,MAAM,6BAA6B,EAAE,YAAY,CAAC,WAAW,CAanE,CAAC"}
+{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgDF,eAAO,MAAM,6BAA6B,EAAE,YAAY,CAAC,WAAW,CAanE,CAAC"}

package/lib/exercises/sequences/geometric/geometricExplicitFormulaUsage.js

@@ -20,14 +20,18 @@ const getGeometricExplicitFormulaUsage = () => {
         instruction: `$(u_n)$ est une suite géométrique définie par $u_n = ${formulaTex}$. Calculer : $u_{${askedRank}}$`,
         startStatement: `u_{${askedRank}}`,
         answer,
-        keys: [],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { firstValue, reason, askedRank },
     };
     return question;
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, askedRank }) => {
+    return [
+        answer,
+        `u_{${askedRank}}=${answer}`,
+        `u_${askedRank}=${answer}`,
+    ].includes(ans);
 };
 const getPropositions = (n, { answer, firstValue, reason, askedRank }) => {
     const propositions = [];

package/lib/exercises/sequences/geometric/geometricReasonUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0CF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAY1D,CAAC"}
+{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8CF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAY1D,CAAC"}

package/lib/exercises/sequences/geometric/geometricReasonUsage.js

@@ -15,7 +15,7 @@ const getGeometricReasonUsage = () => {
         instruction: `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`,
         startStatement: `u_{${askedRank}}`,
         answer,
-        keys: ["q", "n", "u", "underscore"],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { startValue, reason, startRank },
     };
@@ -31,8 +31,12 @@ const getPropositions = (n, { answer, startValue, reason }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, startRank }) => {
+    return [
+        answer,
+        `u_{${startRank}}=${answer}`,
+        `u_${startRank}=${answer}`,
+    ].includes(ans);
 };
 exports.geometricReasonUsage = {
     id: "geometricReasonUsage",

package/lib/exercises/sequences/geometric/geometricRecurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA6CF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,WAAW,CAarE,CAAC"}
+{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkDF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,WAAW,CAarE,CAAC"}

package/lib/exercises/sequences/geometric/geometricRecurrenceFormulaUsage.js

@@ -15,7 +15,7 @@ const getGeometricRecurrenceFormulaUsage = () => {
         instruction: `$(u_n)$ est une suite définie par $u_{n+1} = ${reason}\\times u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`,
         startStatement: `u_{${askedRank}}`,
         answer,
-        keys: ["q", "n", "u", "underscore"],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { firstValue, reason, firstRank },
     };
@@ -31,7 +31,12 @@ const getPropositions = (n, { answer, firstValue, reason }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, firstRank }) => {
+    return [
+        answer,
+        `u_{${firstRank + 1}}=${answer}`,
+        `u_${firstRank + 1}=${answer}`,
+    ].includes(ans);
     return ans === answer;
 };
 exports.geometricRecurrenceFormulaUsage = {

package/lib/exercises/sequences/recurrenceFormulaUsage.js

@@ -20,7 +20,7 @@ const getRecurrenceFormulaUsageQuestion = () => {
         instruction: `Soit $u$ la suite définie par $u_0 = ${u0}$ et pour tout $n\\geq 1$, $u_{n+1} = ${u
             .toTree()
             .toTex()}$. Calculer $u_${rank}$.`,
-        keys: [],
+        keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { rank, u0, coeffs },
     };
@@ -37,8 +37,8 @@ const getPropositions = (n, { answer, rank, u0, coeffs }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+const isAnswerValid = (ans, { answer, rank }) => {
+    return [answer, `u_{${rank}}=${answer}`, `u_${rank}=${answer}`].includes(ans);
 };
 exports.recurrenceFormulaUsage = {
     id: "recurrenceFormulaUsage",

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

@@ -1,5 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
-import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
 type Identifiers = {
     isIntervalToInequality: boolean;
     intervalMin: number;

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;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"}
+{"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,+BAA+B,CAAC;AAK5D,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/intervalsIntersection.d.ts

@@ -1,5 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
-import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
 type Identifiers = {
     int1Min: number;
     int1Max: number;

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;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"}
+{"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,+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;AAwDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}

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

@@ -1,5 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
-import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
 type Identifiers = {
     int1Min: number;
     int1Max: number;

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;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"}
+{"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,+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,YAAY,CAAC,WAAW,CAapD,CAAC"}

package/lib/index.d.ts

@@ -18,6 +18,14 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     remainder: number;
 }> | import("./exercises/exercise").MathExercise<{
     type: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
 }> | import("./exercises/exercise").MathExercise<{
     integerFirst: boolean;
     integer: number;
@@ -200,6 +208,9 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: number;
     c: number;
     d: number;
+}> | import("./exercises/exercise").MathExercise<{
+    k: number;
+    inequationSymbol: import("./math/inequations/inequation").InegalitySymbols;
 }> | import("./exercises/exercise").MathExercise<{
     rand: boolean;
     poly1: number[];
@@ -218,6 +229,12 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     e: number;
     f: number;
     g: number;
+}> | import("./exercises/exercise").MathExercise<{
+    coeffs: number[][];
+    isXAsked: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    coeffs: number[][];
+    isXAsked: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     word: string;
 }> | import("./exercises/exercise").MathExercise<{
@@ -379,6 +396,19 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b?: number | undefined;
     coefficients?: number[] | undefined;
     tex?: string | undefined;
+}> | import("./exercises/exercise").MathExercise<{
+    affineA: number;
+    affineB: number;
+}> | import("./exercises/exercise").MathExercise<{
+    affineA: number;
+    affineB: number;
+}> | import("./exercises/exercise").MathExercise<{
+    affineA: number;
+    affineB: number;
+}> | import("./exercises/exercise").MathExercise<{
+    affineA: number;
+    affineB: number;
+    power: number;
 }> | import("./exercises/exercise").MathExercise<{
     coeffs: number[];
     x: number;
@@ -457,7 +487,21 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     intervals: {
         a: number;
         b: number;
-        closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+        closure: import("./tree/nodes/sets/closure").ClosureType;
+    }[];
+}> | import("./exercises/exercise").MathExercise<{
+    yValue: number;
+    fSplinePoints: number[][];
+    gSplinePoints: number[][];
+}> | import("./exercises/exercise").MathExercise<{
+    yValue: number;
+    fSplinePoints: number[][];
+    gSplinePoints: number[][];
+    ineqSymbol: import("./math/inequations/inequation").InegalitySymbols;
+    intervals: {
+        a: number;
+        b: number;
+        closure: import("./tree/nodes/sets/closure").ClosureType;
     }[];
 }> | import("./exercises/exercise").MathExercise<{
     k: number;
@@ -565,6 +609,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     type: string;
     fctCmd: string;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
+    closure: import("./tree/nodes/sets/closure").ClosureType;
+    type: number;
 }> | import("./exercises/exercise").MathExercise<{
     coin: boolean;
     radius: number;
@@ -962,21 +1011,21 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     isIntervalToInequality: boolean;
     intervalMin: number;
     intervalMax: number;
-    intervalClosure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
 }> | import("./exercises/exercise").MathExercise<{
     int1Min: number;
     int1Max: number;
-    int1Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int1Closure: import("./tree/nodes/sets/closure").ClosureType;
     int2Min: number;
     int2Max: number;
-    int2Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int2Closure: import("./tree/nodes/sets/closure").ClosureType;
 }> | import("./exercises/exercise").MathExercise<{
     int1Min: number;
     int1Max: number;
-    int1Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int1Closure: import("./tree/nodes/sets/closure").ClosureType;
     int2Min: number;
     int2Max: number;
-    int2Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int2Closure: import("./tree/nodes/sets/closure").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":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF;AAgDD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,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;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF;AAgDD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAM3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAWZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAWZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;CAGnB"}

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

@@ -1,6 +1,7 @@
 import { Nombre } from "../../../math/numbers/nombre";
 import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
-import { ClosureType, IntervalNode } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
+import { IntervalNode } from "../../../tree/nodes/sets/intervalNode";
 import { MathSet } from "../mathSet";
 import { MathSetInterface } from "../mathSetInterface";
 export declare abstract class IntervalConstructor {

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

@@ -1 +1 @@
-{"version":3,"file":"intervals.d.ts","sourceRoot":"","sources":["../../../../src/math/sets/intervals/intervals.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAc,MAAM,2BAA2B,CAAC;AAI/D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EACL,WAAW,EACX,YAAY,EAEb,MAAM,oCAAoC,CAAC;AAI5C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;CAWnC;AAED,qBAAa,QAAS,YAAW,gBAAgB;IAC/C,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;IACxB,oBAAoB,EAAE,MAAM,GAAG,GAAG,CAAC;IACnC,qBAAqB,EAAE,MAAM,GAAG,GAAG,CAAC;IACpC,GAAG,EAAE,MAAM,CAAC;gBACA,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW;IAiBxE,MAAM,CAAC,QAAQ,EAAE,QAAQ;IAOzB,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IA6ClC,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAyCzC,WAAW,IAAI,MAAM;IAGrB,KAAK,IAAI,MAAM;IAMf,YAAY,IAAI,MAAM;IAmBtB,gBAAgB,IAAI,MAAM;IAI1B,MAAM;CAGP"}
+{"version":3,"file":"intervals.d.ts","sourceRoot":"","sources":["../../../../src/math/sets/intervals/intervals.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAc,MAAM,2BAA2B,CAAC;AAI/D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAIlE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;CAWnC;AAED,qBAAa,QAAS,YAAW,gBAAgB;IAC/C,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;IACxB,oBAAoB,EAAE,MAAM,GAAG,GAAG,CAAC;IACnC,qBAAqB,EAAE,MAAM,GAAG,GAAG,CAAC;IACpC,GAAG,EAAE,MAAM,CAAC;gBACA,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW;IAiBxE,MAAM,CAAC,QAAQ,EAAE,QAAQ;IAOzB,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IA6ClC,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAyCzC,WAAW,IAAI,MAAM;IAGrB,KAAK,IAAI,MAAM;IAMf,YAAY,IAAI,MAAM;IAmBtB,gBAAgB,IAAI,MAAM;IAI1B,MAAM;CAGP"}

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Interval = exports.IntervalConstructor = void 0;
 const randint_1 = require("../../../math/utils/random/randint");
 const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
 const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const mathSet_1 = require("../mathSet");
@@ -15,37 +16,37 @@ class IntervalConstructor {
             case 0:
                 min = infiniteNode_1.MinusInfinityNode;
                 max = (0, randint_1.randint)(-10, 10).toTree();
-                closure = (0, coinFlip_1.coinFlip)() ? intervalNode_1.ClosureType.OF : intervalNode_1.ClosureType.OO;
+                closure = (0, coinFlip_1.coinFlip)() ? closure_1.ClosureType.OF : closure_1.ClosureType.OO;
                 break;
             case 1:
                 min = (0, randint_1.randint)(-10, 10).toTree();
                 max = infiniteNode_1.PlusInfinityNode;
-                closure = (0, coinFlip_1.coinFlip)() ? intervalNode_1.ClosureType.OO : intervalNode_1.ClosureType.FO;
+                closure = (0, coinFlip_1.coinFlip)() ? closure_1.ClosureType.OO : closure_1.ClosureType.FO;
                 break;
             case 2:
                 a = (0, randint_1.randint)(-10, 10);
                 min = a.toTree();
                 max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = intervalNode_1.ClosureType.FF;
+                closure = closure_1.ClosureType.FF;
                 break;
             case 3:
                 a = (0, randint_1.randint)(-10, 10);
                 min = a.toTree();
                 max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = intervalNode_1.ClosureType.OF;
+                closure = closure_1.ClosureType.OF;
                 break;
             case 4:
                 a = (0, randint_1.randint)(-10, 10);
                 min = a.toTree();
                 max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = intervalNode_1.ClosureType.FO;
+                closure = closure_1.ClosureType.FO;
                 break;
             case 5:
             default:
                 a = (0, randint_1.randint)(-10, 10);
                 min = a.toTree();
                 max = (0, randint_1.randint)(a + 1, a + 10).toTree();
-                closure = intervalNode_1.ClosureType.OO;
+                closure = closure_1.ClosureType.OO;
                 break;
         }
         return new Interval(min, max, closure);
@@ -73,9 +74,9 @@ class Interval {
         this.minTex = min.toTex();
         this.maxTex = max.toTex();
         this.leftBracket =
-            closure === intervalNode_1.ClosureType.FF || closure === intervalNode_1.ClosureType.FO ? "[" : "]";
+            closure === closure_1.ClosureType.FF || closure === closure_1.ClosureType.FO ? "[" : "]";
         this.rightBracket =
-            closure === intervalNode_1.ClosureType.FF || closure === intervalNode_1.ClosureType.OF ? "]" : "[";
+            closure === closure_1.ClosureType.FF || closure === closure_1.ClosureType.OF ? "]" : "[";
         this.leftInequalitySymbol = this.leftBracket === "[" ? "\\le" : "<";
         this.rightInequalitySymbol = this.rightBracket === "]" ? "\\le" : "<";
         this.tex = this.toTex();
@@ -117,7 +118,7 @@ class Interval {
                 : secondInterval.getRandomElement());
         }
         else {
-            const closure = (0, intervalNode_1.closureFromBrackets)(unionLeftBracket, unionRightBracket);
+            const closure = closure_1.Closure.fromBrackets(unionLeftBracket, unionRightBracket);
             return new Interval(min, max, closure);
         }
     }
@@ -149,7 +150,7 @@ class Interval {
             : b < d
                 ? this.rightBracket
                 : interval.rightBracket;
-        const closure = (0, intervalNode_1.closureFromBrackets)(leftBracket, rightBracket);
+        const closure = closure_1.Closure.fromBrackets(leftBracket, rightBracket);
         return new Interval(min, max, closure);
     }
     insideToTex() {
@@ -159,8 +160,8 @@ class Interval {
         return `${this.leftBracket}\\ ${this.insideToTex()}\\ ${this.rightBracket}\\ `;
     }
     toInequality() {
-        const isLeftClosed = this.closure === intervalNode_1.ClosureType.FO || this.closure === intervalNode_1.ClosureType.FF;
-        const isRightClosed = this.closure === intervalNode_1.ClosureType.FF || this.closure === intervalNode_1.ClosureType.OF;
+        const isLeftClosed = this.closure === closure_1.ClosureType.FO || this.closure === closure_1.ClosureType.FF;
+        const isRightClosed = this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.OF;
         if (this.max === Infinity) {
             if (isLeftClosed) {
                 return `x\\ge${this.minTex}`;
@@ -169,7 +170,7 @@ class Interval {
                 return `x>${this.minTex}`;
         }
         else if (this.min === -Infinity) {
-            if (this.closure === intervalNode_1.ClosureType.OF) {
+            if (this.closure === closure_1.ClosureType.OF) {
                 return `x\\le${this.maxTex}`;
             }
             else

package/lib/math/systems/system.d.ts

@@ -0,0 +1,14 @@
+export declare abstract class SystemConstructor {
+    static random(): System;
+    static niceValues(): System;
+}
+export declare class System {
+    coeffs: number[][];
+    constructor(coeffs: number[][]);
+    solve(): {
+        x: import("../../tree/nodes/algebraicNode").AlgebraicNode;
+        y: import("../../tree/nodes/algebraicNode").AlgebraicNode;
+    };
+    toTex(): string;
+}
+//# sourceMappingURL=system.d.ts.map

package/lib/math/systems/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/math/systems/system.ts"],"names":[],"mappings":"AASA,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;CAiBlB;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,MAAM,EAAE,MAAM,EAAE,EAAE;IAG9B,KAAK;;;;IAwCL,KAAK;CAcN"}

package/lib/math/systems/system.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.System = exports.SystemConstructor = void 0;
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const doWhile_1 = require("../../utils/doWhile");
+const randint_1 = require("../utils/random/randint");
+class SystemConstructor {
+    static random() {
+        const a1 = (0, randint_1.randint)(-10, 11, [0]);
+        const b1 = (0, randint_1.randint)(-10, 11, [0]);
+        const c1 = (0, randint_1.randint)(-10, 11);
+        const a2 = (0, randint_1.randint)(-10, 11, [0]);
+        const b2 = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(-10, 11, [0]), (x) => a1 / b1 === a2 / x);
+        const c2 = (0, randint_1.randint)(-10, 11);
+        return new System([
+            [a1, b1, c1],
+            [a2, b2, c2],
+        ]);
+    }
+    static niceValues() {
+        const a1 = (0, randint_1.randint)(-10, 11, [0]);
+        const b1 = (0, randint_1.randint)(-10, 11, [0]);
+        const a2 = (0, randint_1.randint)(-10, 11, [0]);
+        const b2 = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(-10, 11, [0]), (x) => a1 / b1 === a2 / x);
+        const x = (0, randint_1.randint)(-10, 11);
+        const y = (0, randint_1.randint)(-10, 11);
+        const c1 = a1 * x + b1 * y;
+        const c2 = a2 * x + b2 * y;
+        return new System([
+            [a1, b1, c1],
+            [a2, b2, c2],
+        ]);
+    }
+}
+exports.SystemConstructor = SystemConstructor;
+class System {
+    //coeffs[i][0]x+coeffs[i][1]y = coeffs[i][2]
+    constructor(coeffs) {
+        this.coeffs = coeffs;
+    }
+    solve() {
+        if (this.coeffs.length !== 2)
+            throw Error("General system resolution not implemented yet");
+        //x = (c'-b'c/b)/(a'-b'a/b)
+        if (!this.coeffs[0][1] ||
+            this.coeffs[1][0] ===
+                (this.coeffs[1][1] * this.coeffs[0][0]) / this.coeffs[0][1])
+            throw Error("No solution");
+        const x = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(this.coeffs[1][2].toTree(), new fractionNode_1.FractionNode((this.coeffs[1][1] * this.coeffs[0][2]).toTree(), this.coeffs[0][1].toTree())), new substractNode_1.SubstractNode(this.coeffs[1][0].toTree(), new fractionNode_1.FractionNode((this.coeffs[1][1] * this.coeffs[0][0]).toTree(), this.coeffs[0][1].toTree()))).simplify();
+        //y = c-ax/b
+        console.log("x", x.toTex());
+        const y = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(this.coeffs[0][2].toTree(), new multiplyNode_1.MultiplyNode(this.coeffs[0][0].toTree(), x)), this.coeffs[0][1].toTree()).simplify();
+        return {
+            x,
+            y,
+        };
+    }
+    toTex() {
+        const x = new variableNode_1.VariableNode("x");
+        const y = new variableNode_1.VariableNode("y");
+        return `\\left\\{\\begin{matrix}
+${new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.coeffs[0][0].toTree(), x), new multiplyNode_1.MultiplyNode(this.coeffs[0][1].toTree(), y)).toTex()}&=&${this.coeffs[0][2]} \\\\
+${new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.coeffs[1][0].toTree(), x), new multiplyNode_1.MultiplyNode(this.coeffs[1][1].toTree(), y)).toTex()}&=&${this.coeffs[1][2]}
+\\end{matrix}\\right.`;
+    }
+}
+exports.System = System;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPrime.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/isPrime.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,MAAO,MAAM,YAOhC,CAAC"}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrime = void 0;
+const isPrime = (n) => {
+    if (n === 0 || n === 1)
+        return false;
+    const sqrt = Math.floor(Math.sqrt(n));
+    for (let i = 2; i <= sqrt; i++) {
+        if (n % i === 0)
+            return false;
+    }
+    return true;
+};
+exports.isPrime = isPrime;

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC;AAarB,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAgB3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC;AAOrB,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAa3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;KACzB;CACF"}

package/lib/server.js

@@ -37,7 +37,6 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
 const numberNode_1 = require("./tree/nodes/numbers/numberNode");
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
-const round_1 = require("./math/utils/round");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 Number.prototype.toTree = function () {
@@ -56,7 +55,6 @@ const runServer = () => {
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
     console.log(exercises.length);
-    console.log((0, round_1.round)((35 * 10) / 6, 2) * 100);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/lib/tree/nodes/inequations/inequationNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAI3C,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,EAAe,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEjE,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAwBhD,UAAU;IA6CV,UAAU;IAQV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;CAGN"}
+{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAI3C,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAwBhD,UAAU;IA6CV,UAAU;IAQV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;CAGN"}