math-exercises 2.0.3 → 2.0.4

package/lib/exercises/functions/basics/inverseImageFunctionGeogebra.d.ts

@@ -2,8 +2,8 @@ import { MathExercise } from "../../../exercises/exercise";
 type Identifiers = {
     xValue: number;
     yValue: number;
-    affineCoeffs: number[];
-    trinomCoeffs: number[];
+    affineCoeffs?: number[];
+    trinomCoeffs?: number[];
     isAffine: boolean;
 };
 export declare const inverseImageFunctionGeogebra: MathExercise<Identifiers>;

package/lib/exercises/functions/basics/inverseImageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA8LF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAalE,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgLF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/functions/basics/inverseImageFunctionGeogebra.js

@@ -11,56 +11,30 @@ const shuffle_1 = require("../../../utils/shuffle");
 const getInverseImageFunctionGeogebra = () => {
     const isAffine = (0, coinFlip_1.coinFlip)();
     const xValue = (0, randint_1.randint)(-5, 6);
-    const yValue = (0, randint_1.randint)(-5, 6);
+    // const yValue = randint(-5, 6);
+    let yValue;
     let affine;
-    do {
-        affine = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
-    } while (affine.calculate(xValue) > 10 || affine.calculate(xValue) < -10);
-    let trinom = new polynomial_1.Polynomial([
-        (0, randint_1.randint)(-9, 10) - yValue,
-        (0, randint_1.randint)(-9, 10),
-        (0, randint_1.randint)(-4, 5, [0]),
-    ]);
-    let roots = trinom.getRoots();
-    if (roots.length === 2)
-        while (roots[0] > 10 || roots[0] < -10 || roots[1] > 10 || roots[1] < -10) {
-            trinom = new polynomial_1.Polynomial([
-                (0, randint_1.randint)(-9, 10) - yValue,
-                (0, randint_1.randint)(-9, 10),
-                (0, randint_1.randint)(-4, 5, [0]),
-            ]);
-            roots = trinom.getRoots();
-        }
-    else if (roots.length === 1)
-        while (roots[0] < -10 || roots[0] > 10) {
-            trinom = new polynomial_1.Polynomial([
-                (0, randint_1.randint)(-9, 10) - yValue,
-                (0, randint_1.randint)(-9, 10),
-                (0, randint_1.randint)(-4, 5, [0]),
-            ]);
-            roots = trinom.getRoots();
-        }
-    const statement = isAffine
-        ? `Déterminer le ou les antécédents de $${affine.calculate(xValue)}$ par la fonction $f$ représentée ci dessous.`
-        : `Déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
-    let answer = isAffine
-        ? xValue
-        : roots.length === 2
-            ? `${(0, round_1.round)(roots[0], 1).toString().replace(".", ",")}\\text{ et }${(0, round_1.round)(roots[1], 1)
-                .toString()
-                .replace(".", ",")}`
-            : roots.length === 1
-                ? roots[0].toString().replace(".", ",")
-                : `\\text{Aucun}`;
-    const optimum = trinom.derivate().getRoots()[0];
-    let xmin = 0, xmax = 0, ymin = 0, ymax = 0;
+    let trinom;
+    let statement = "";
+    let answer = "";
+    let xmin = -1;
+    let xmax = 1;
+    let ymin = -1;
+    let ymax = 1;
+    let commands;
     if (isAffine) {
-        if (affine.calculate(xValue) > 0) {
-            ymax = affine.calculate(xValue) + 1;
+        do {
+            affine = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+            yValue = affine.calculate(xValue);
+        } while (Math.abs(yValue) > 10);
+        statement = `Déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
+        answer = xValue.toString().replace(".", ",");
+        if (yValue > 0) {
+            ymax = yValue + 1;
             ymin = -1;
         }
         else {
-            ymin = affine.calculate(xValue) - 1;
+            ymin = yValue - 1;
             ymax = 1;
         }
         if (xValue > 0) {
@@ -71,16 +45,35 @@ const getInverseImageFunctionGeogebra = () => {
             xmin = xValue - 1;
             xmax = 1;
         }
+        commands = [affine.toString()];
     }
     else {
+        let roots;
+        yValue = (0, randint_1.randint)(-5, 6);
+        do {
+            trinom = new polynomial_1.Polynomial([
+                (0, randint_1.randint)(-9, 10) - yValue,
+                (0, randint_1.randint)(-9, 10),
+                (0, randint_1.randint)(-4, 5, [0]),
+            ]);
+            roots = trinom.getRoots();
+        } while (roots.some((root) => Math.abs(root) > 10));
+        statement = `Déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
+        answer = !roots.length
+            ? "\\text{Aucun}"
+            : roots
+                .map((r) => (0, round_1.round)(r, 1).toString().replace(".", ","))
+                .join("\\text{ et }");
+        const alpha = trinom.derivate().getRoots()[0];
+        const beta = trinom.calculate(alpha);
         if (roots.length === 2) {
-            if (yValue > trinom.calculate(optimum) + yValue) {
+            if (yValue > beta + yValue) {
                 ymax = yValue + 2;
-                ymin = trinom.calculate(optimum) + yValue - 2;
+                ymin = beta + yValue - 2;
             }
             else {
                 ymin = yValue - 2;
-                ymax = trinom.calculate(optimum) + yValue + 2;
+                ymax = beta + yValue + 2;
             }
             xmax = Math.max(roots[0], roots[1]) + 1;
             xmin = Math.min(roots[0], roots[1]) - 1;
@@ -94,30 +87,27 @@ const getInverseImageFunctionGeogebra = () => {
                 ymin = yValue - 5;
                 ymax = yValue + 1;
             }
-            xmax = optimum + 5;
-            xmin = optimum - 5;
+            xmax = alpha + 5;
+            xmin = alpha - 5;
         }
         if (roots.length === 0) {
-            if (yValue > trinom.calculate(optimum) + yValue) {
+            if (yValue > beta + yValue) {
                 ymax = yValue + 1;
-                ymin = trinom.calculate(optimum) + yValue - 3;
+                ymin = beta + yValue - 3;
             }
             else {
                 ymin = yValue - 1;
-                ymax = trinom.calculate(optimum) + yValue + 3;
+                ymax = beta + yValue + 3;
             }
-            xmax = optimum + 5;
-            xmin = optimum - 5;
+            xmax = alpha + 5;
+            xmin = alpha - 5;
         }
-    }
-    const commands = [
-        isAffine
-            ? affine.toString()
-            : yValue !== 0
+        commands = [
+            yValue !== 0
                 ? trinom.add(new polynomial_1.Polynomial([yValue])).toString()
                 : trinom.toString(),
-    ];
-    answer = (answer + "").replaceAll(".", ",");
+        ];
+    }
     const question = {
         instruction: statement,
         answer,
@@ -127,8 +117,8 @@ const getInverseImageFunctionGeogebra = () => {
         answerFormat: "tex",
         identifiers: {
             xValue,
-            affineCoeffs: affine.coefficients,
-            trinomCoeffs: trinom.coefficients,
+            affineCoeffs: isAffine ? affine.coefficients : undefined,
+            trinomCoeffs: isAffine ? undefined : trinom.coefficients,
             yValue,
             isAffine,
         },
@@ -138,17 +128,20 @@ const getInverseImageFunctionGeogebra = () => {
 const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const polynome1 = new polynomial_1.Polynomial(affineCoeffs);
-    const roots = new polynomial_1.Polynomial(trinomCoeffs).getRoots();
+    (0, exercise_1.tryToAddWrongProp)(propositions, "\\text{Aucun}");
+    if (isAffine) {
+        const affine = new polynomial_1.Polynomial(affineCoeffs);
+        (0, exercise_1.tryToAddWrongProp)(propositions, affine.calculate(yValue).toString().replace(".", ","));
+    }
+    else {
+        const trinom = new polynomial_1.Polynomial(trinomCoeffs);
+        (0, exercise_1.tryToAddWrongProp)(propositions, trinom.calculate(yValue).toString().replace(".", ","));
+    }
     while (propositions.length < n) {
-        const wrongAnswer = isAffine
-            ? (0, randint_1.randint)(-9, 10, [polynome1.calculate(xValue)])
-            : roots.length === 2
-                ? `${(0, randint_1.randint)(-9, 10)}\\text{ et }${(0, randint_1.randint)(-9, 10)}`.replaceAll(".", ",")
-                : roots.length === 1
-                    ? (0, randint_1.randint)(-9, 10, [roots[0]]).toString().replace(".", ",")
-                    : `\\text{Aucun}`;
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer + "");
+        const wrongAnswer = (0, coinFlip_1.coinFlip)()
+            ? `${(0, randint_1.randint)(-9, 10)}`
+            : `${(0, randint_1.randint)(-9, 10)}\\text{ et }${(0, randint_1.randint)(-9, 10)}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);
 };

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

@@ -4,5 +4,6 @@ export { exponentialPrimitive } from "./exponentialPrimitive";
 export { logarithmePrimitive } from "./logarithmePrimitive";
 export { polynomialPrimitive } from "./polynomialPrimitive";
 export { sinCosPrimitive } from "./sinCosPrimitive";
+export { sinUCosUPrimitive } from "./sinUCosUPrimitive";
 export * from "./usualPrimitives";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,cAAc,mBAAmB,CAAC"}

package/lib/exercises/primitive/index.js

@@ -14,7 +14,7 @@ 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 });
-exports.sinCosPrimitive = exports.polynomialPrimitive = exports.logarithmePrimitive = exports.exponentialPrimitive = exports.expUPrimitive = exports.constantPrimitive = void 0;
+exports.sinUCosUPrimitive = exports.sinCosPrimitive = exports.polynomialPrimitive = exports.logarithmePrimitive = exports.exponentialPrimitive = exports.expUPrimitive = exports.constantPrimitive = void 0;
 var constantPrimitive_1 = require("./constantPrimitive");
 Object.defineProperty(exports, "constantPrimitive", { enumerable: true, get: function () { return constantPrimitive_1.constantPrimitive; } });
 var expUPrimitive_1 = require("./expUPrimitive");
@@ -27,5 +27,6 @@ var polynomialPrimitive_1 = require("./polynomialPrimitive");
 Object.defineProperty(exports, "polynomialPrimitive", { enumerable: true, get: function () { return polynomialPrimitive_1.polynomialPrimitive; } });
 var sinCosPrimitive_1 = require("./sinCosPrimitive");
 Object.defineProperty(exports, "sinCosPrimitive", { enumerable: true, get: function () { return sinCosPrimitive_1.sinCosPrimitive; } });
-// export { sinUCosUPrimitive } from "./sinUCosUPrimitive";
+var sinUCosUPrimitive_1 = require("./sinUCosUPrimitive");
+Object.defineProperty(exports, "sinUCosUPrimitive", { enumerable: true, get: function () { return sinUCosUPrimitive_1.sinUCosUPrimitive; } });
 __exportStar(require("./usualPrimitives"), exports);

package/lib/index.d.ts

@@ -352,8 +352,8 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     xValue: number;
     yValue: number;
-    affineCoeffs: number[];
-    trinomCoeffs: number[];
+    affineCoeffs?: number[] | undefined;
+    trinomCoeffs?: number[] | undefined;
     isAffine: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     k: number;
@@ -546,6 +546,9 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     isCos: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    coeffs: number[];
+    isCos: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     type: number;
     a?: number | undefined;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/math/polynomials/polynomial.js

@@ -233,23 +233,25 @@ class Polynomial {
     // }
     integrateToNode(opts) {
         let integralPolynomial = new variableNode_1.VariableNode("C");
+        const varNode = new variableNode_1.VariableNode(this.variable);
         for (let i = 0; i < this.degree + 1; i++) {
             const coeff = this.coefficients[i];
             if (coeff === 0)
                 continue;
             const nodeCoeff = new rational_1.Rational(coeff, i + 1).simplify().toTree();
             const powerNode = i + 1 === 1
-                ? new variableNode_1.VariableNode("x")
-                : new powerNode_1.PowerNode(new variableNode_1.VariableNode("x"), new numberNode_1.NumberNode(i + 1), opts);
+                ? varNode
+                : new powerNode_1.PowerNode(varNode, new numberNode_1.NumberNode(i + 1), opts);
             let terme;
-            if (nodeCoeff.toTex() === "1")
+            const coeffTex = nodeCoeff.toTex();
+            if (coeffTex === "1")
                 terme = powerNode;
-            else if (nodeCoeff.toTex() === "-1")
+            else if (coeffTex === "-1")
                 terme = new oppositeNode_1.OppositeNode(powerNode, opts);
             else {
                 terme = new multiplyNode_1.MultiplyNode(nodeCoeff, i + 1 === 1
-                    ? new variableNode_1.VariableNode("x")
-                    : new powerNode_1.PowerNode(new variableNode_1.VariableNode("x"), new numberNode_1.NumberNode(i + 1), opts), opts);
+                    ? varNode
+                    : new powerNode_1.PowerNode(varNode, new numberNode_1.NumberNode(i + 1), opts), opts);
             }
             integralPolynomial = new addNode_1.AddNode(terme, integralPolynomial, opts);
         }

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

@@ -1 +1 @@
-{"version":3,"file":"rationalFrac.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/rationalFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAGrD,qBAAa,YAAY;IACvB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;gBACN,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAI9C,MAAM;IAGN,QAAQ;CAwCT"}
+{"version":3,"file":"rationalFrac.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/rationalFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAGrD,qBAAa,YAAY;IACvB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;gBACN,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAI9C,MAAM;IAGN,QAAQ;CAuCT"}

package/lib/math/polynomials/rationalFrac.js

@@ -18,9 +18,9 @@ class RationalFrac {
         if (this.num.coefficients.length === 1 && this.num.coefficients[0] === 0)
             return new integer_1.Integer(0);
         const numCoeffs = this.num.coefficients.filter((c) => c !== 0);
-        const numPGCD = numCoeffs.length > 1 ? (0, gcd_1.multigcd)(...numCoeffs) : numCoeffs[0];
+        const numPGCD = numCoeffs.length > 1 ? (0, gcd_1.gcd)(...numCoeffs) : numCoeffs[0];
         const denumCoeffs = this.denum.coefficients.filter((c) => c !== 0);
-        const denumPGCD = denumCoeffs.length > 1 ? (0, gcd_1.multigcd)(...denumCoeffs) : denumCoeffs[0];
+        const denumPGCD = denumCoeffs.length > 1 ? (0, gcd_1.gcd)(...denumCoeffs) : denumCoeffs[0];
         const rational = new rational_1.Rational(numPGCD, denumPGCD);
         if (rational.isIrreductible()) {
             return this;

package/lib/math/polynomials/trinom.js

@@ -92,7 +92,7 @@ class Trinom extends polynomial_1.Polynomial {
         let [sqrtA, sqrtB] = new real_1.SquareRoot(delta).getSimplifiedCoeffs();
         let denum = 2 * this.a;
         let trueB = this.b;
-        const pgcd = (0, gcd_1.multigcd)(sqrtA, trueB, denum);
+        const pgcd = (0, gcd_1.gcd)(sqrtA, trueB, denum);
         [sqrtA, trueB, denum] = [sqrtA, trueB, denum].map((n) => n / pgcd);
         const sqrtNode = sqrtA === 1
             ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(sqrtB))

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

@@ -1,3 +1,2 @@
-export declare function gcd(a: number, b: number): number;
-export declare function multigcd(...args: number[]): number;
+export declare function gcd(...args: number[]): number;
 //# sourceMappingURL=gcd.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gcd.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/gcd.ts"],"names":[],"mappings":"AAAA,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAGlD"}
+{"version":3,"file":"gcd.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/gcd.ts"],"names":[],"mappings":"AAIA,wBAAgB,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAG7C"}

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

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.multigcd = exports.gcd = void 0;
-function gcd(a, b) {
+exports.gcd = void 0;
+function pgcd(a, b) {
     return b ? gcd(b, a % b) : a;
 }
-exports.gcd = gcd;
-function multigcd(...args) {
+function gcd(...args) {
     if (args.length === 2)
-        return gcd(args[0], args[1]);
+        return pgcd(args[0], args[1]);
     else
-        return gcd(args[0], multigcd(...args.slice(1)));
+        return gcd(args[0], gcd(...args.slice(1)));
 }
-exports.multigcd = multigcd;
+exports.gcd = gcd;

package/lib/server.js

@@ -35,22 +35,12 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
-const rational_1 = require("./math/numbers/rationals/rational");
-const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
-const numberNode_1 = require("./tree/nodes/numbers/numberNode");
-const oppositeNode_1 = require("./tree/nodes/functions/oppositeNode");
-const gcd_1 = require("./math/utils/arithmetic/gcd");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
-    console.log((0, gcd_1.multigcd)(5, 11, 15, 25, 55));
-    const frac = new rational_1.Rational(-2, 3).simplify().toTree();
-    console.log(frac.toAllValidTexs());
-    const prod = new oppositeNode_1.OppositeNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new numberNode_1.NumberNode(3)));
-    console.log(prod.toAllValidTexs());
     console.log(exercises.length);
     app.get("/", (req, res) => {
         res.json(allExercises);

package/lib/tree/nodes/functions/oppositeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpD,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAqCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;CAQ7C"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpD,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;CAQ7C"}

package/lib/tree/nodes/functions/oppositeNode.js

@@ -6,6 +6,7 @@ const node_1 = require("../node");
 const operatorNode_1 = require("../operators/operatorNode");
 const functionNode_1 = require("./functionNode");
 const numberNode_1 = require("../numbers/numberNode");
+const fractionNode_1 = require("../operators/fractionNode");
 function isOppositeNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.opposite;
 }
@@ -40,31 +41,14 @@ class OppositeNode {
         const externalNodes = [];
         //! est ce qu'il faut faire ici des simplifications du type -ln(2) => 1/ln(2)
         //! ou meme -(a+b) => -a - b
-        // if (isMultiplyNode(this.child))
-        //   res.push(
-        //     ...new MultiplyNode(
-        //       new OppositeNode(this.child.leftChild),
-        //       this.child.rightChild,
-        //     ).toEquivalentNodes(options),
-        //   );
-        // else if (isDivideNode(this.child))
-        //   res.push(
-        //     ...new DivideNode(
-        //       new OppositeNode(this.child.leftChild),
-        //       this.child.rightChild,
-        //     ).toEquivalentNodes(options),
-        //   );
-        // else if (isFractionNode(this.child))
-        //   res.push(
-        //     ...new FractionNode(
-        //       new OppositeNode(this.child.leftChild),
-        //       this.child.rightChild,
-        //     ).toEquivalentNodes(options),
-        //   );
-        // else {
+        //!version simplifiée pour juste gérer les fractions
+        //!la bonne solution serait de parse l'arbre et déplacer l'opposite sur chaque child d'un sous arbre multiplicatif
         const childNodes = this.child.toEquivalentNodes(options);
         childNodes.forEach((childNode) => {
             res.push(new OppositeNode(childNode));
+            if ((0, fractionNode_1.isFractionNode)(childNode)) {
+                res.push(new fractionNode_1.FractionNode(new OppositeNode(childNode.leftChild), childNode.rightChild, { allowMinusAnywhereInFraction: true }), new fractionNode_1.FractionNode(childNode.leftChild, new OppositeNode(childNode.rightChild), { allowMinusAnywhereInFraction: true }));
+            }
         });
         // }
         return res;

package/lib/tree/nodes/operators/multiplyNode.js

@@ -44,9 +44,9 @@ class MultiplyNode {
         let leftTex = this.leftChild.toTex();
         let rightTex = this.rightChild.toTex();
         if (leftTex === "1") {
-            if ((0, numberNode_1.isNumberNode)(this.rightChild)) {
-                return rightTex;
-            }
+            // if (isNumberNode(this.rightChild) || isVariableNode(this.rightChild)) {
+            return rightTex;
+            // }
         }
         if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
             if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))

package/package.json

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