math-exercises 2.2.68 → 2.2.69

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralAffineIdentifiers } from "../../../../math/polynomials/generalAffine";
+type Identifiers = {
+    firstAffine: GeneralAffineIdentifiers;
+    secondAffine: GeneralAffineIdentifiers;
+};
+export declare const absolueValueAffineEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=absolueValueAffineEquation.d.ts.map

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"absolueValueAffineEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/absolueValueAffineEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAM9C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,wBAAwB,CAAC;IACtC,YAAY,EAAE,wBAAwB,CAAC;CACxC,CAAC;AA4KF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.absolueValueAffineEquation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const integer_1 = require("../../../../math/numbers/integer/integer");
+const nombre_1 = require("../../../../math/numbers/nombre");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const generalAffine_1 = require("../../../../math/polynomials/generalAffine");
+const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
+const absNode_1 = require("../../../../tree/nodes/functions/absNode");
+const rationalParser_1 = require("../../../../tree/parsers/rationalParser");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const fracs = [
+            rational_1.RationalConstructor.randomIrreductibleWithSign().toTree(),
+            rational_1.RationalConstructor.randomIrreductibleWithSign().toTree(),
+        ].sort((a, b) => a.evaluate() - b.evaluate());
+        (0, exercise_1.tryToAddWrongProp)(propositions, `x=${fracs[0].toTex()}\\text{ ou }${fracs[1].toTex()}`);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const affines = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.firstAffine),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.secondAffine),
+    ];
+    const firstIntersec = affines[0].xIntersect(affines[1]);
+    const oppositeAffine = affines[1].opposite();
+    const secondIntersec = oppositeAffine.xIntersect(affines[0]);
+    const res = [firstIntersec, secondIntersec]
+        .filter(Boolean)
+        .sort((a, b) => a.evaluate() - b.evaluate());
+    return res;
+};
+const getAnswer = (identifiers) => {
+    const nodes = getAnswerNode(identifiers);
+    if (nodes.length > 1)
+        return `x=${nodes[0].toTex()}\\text{ ou }x=${nodes[1].toTex()}`;
+    return `x=${nodes[0]?.toTex() || nodes[1]?.toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const affines = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.firstAffine),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.secondAffine),
+    ];
+    const node = (0, equalNode_1.equal)((0, absNode_1.abs)(affines[0].toTree()), (0, absNode_1.abs)(affines[1].toTree()));
+    return `Résoudre : 
+  
+$$
+${node.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `L'égalité $|a|=|b|$ est vraie si et seulement si $a = b$ ou $a = -b$.`;
+};
+const getCorrection = (identifiers) => {
+    const affines = [
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.firstAffine),
+        generalAffine_1.GeneralAffineConstructor.fromIdentifiers(identifiers.secondAffine),
+    ];
+    const firstIntersec = affines[0].xIntersect(affines[1]);
+    const oppositeAffine = affines[1].opposite();
+    const secondIntersec = oppositeAffine.xIntersect(affines[0]);
+    const res = [firstIntersec, secondIntersec]
+        .filter(Boolean)
+        .sort((a, b) => a.evaluate() - b.evaluate());
+    return `L'égalité $|a|=|b|$ est vraie si et seulement si $a = b$ ou $a=-b$.
+  
+On doit donc résoudre deux équations: d'une part,
+
+$$
+${affines[0].toTree().toTex()} = ${affines[1].toTree().toTex()}
+$$
+
+${firstIntersec
+        ? `ce qui donne : 
+  
+  $$
+  x=${firstIntersec?.toTex()}
+  $$`
+        : "qui n'a pas de solution, "}
+
+et d'autre part :
+
+$$
+${affines[0].toTree().toTex()} = ${oppositeAffine.toTree().toTex()}
+$$
+
+${secondIntersec
+        ? `ce qui donne : 
+  
+$$
+x=${secondIntersec?.toTex()}
+$$`
+        : "qui n'a pas de solution."}
+
+
+Ainsi, la solution de cette équation est :
+
+$$
+${res.length > 1
+        ? `x=${res[0].toTex()} \\text{ ou } x=${res[1].toTex()}`
+        : `x=${res[0]?.toTex() || res[1]?.toTex()}`}
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "equal", "ou"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const parsedOu = ans.split("\\text{ ou }");
+    console.log(parsedOu);
+    try {
+        const nodes = [];
+        parsedOu.forEach((item) => {
+            let formated = item
+                .replaceAll("\\text{", "")
+                .replaceAll("}", "")
+                .replaceAll(" ", "");
+            const equalForm = formated.split("=");
+            if (equalForm.length > 1 && equalForm[0] !== "x")
+                throw Error("wrong answer");
+            const nbStr = equalForm.length > 1 ? equalForm[1] : formated;
+            const node = (0, rationalParser_1.rationalParser)(nbStr);
+            if (!node)
+                throw Error("wrong answer");
+            nodes.push(node);
+        });
+        const answerNodes = getAnswerNode(identifiers);
+        return answerNodes.every((e) => nodes.some((n) => n.evaluate() === e.evaluate()));
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getAbsolueValueAffineEquationQuestion = (ops) => {
+    const types = [nombre_1.NumberType.Integer];
+    const [a, c] = nombre_1.NombreConstructor.manyRandom(4, {
+        types,
+        excludes: [new integer_1.Integer(0)],
+    }).map((e) => e.toTree());
+    const [b, d] = nombre_1.NombreConstructor.manyRandom(4, {
+        types,
+    }).map((e) => e.toTree());
+    const identifiers = {
+        firstAffine: new generalAffine_1.GeneralAffine(a, b).toIdentifiers(),
+        secondAffine: new generalAffine_1.GeneralAffine(c, d).toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.absolueValueAffineEquation = {
+    id: "absolueValueAffineEquation",
+    connector: "\\iff",
+    label: "Résoudre une équation avec valeur absolue du type $|ax+b|=|cx+d|$",
+    isSingleStep: false,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getAbsolueValueAffineEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/absolute/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./absoluteValueEquations";
 export * from "./absoluteValueInequations";
+export * from "./absolueValueAffineEquation";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/absolute/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/functions/absolute/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./absoluteValueEquations"), exports);
 __exportStar(require("./absoluteValueInequations"), exports);
+__exportStar(require("./absolueValueAffineEquation"), exports);

package/lib/exercises/math/functions/trinoms/rootsProduct.js

@@ -77,7 +77,7 @@ const getRootsProductQuestion = (ops) => {
     //ac <= 0
     const a = (0, randint_1.randint)(-10, 10, [0]);
     const b = (0, randint_1.randint)(-10, 10);
-    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 10, !b ? [0] : []);
+    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 0, !b ? [0] : []);
     const trinom = new generalTrinom_1.GeneralTrinom(a, b, c);
     const identifiers = {
         trinomIdentifiers: trinom.toIdentifiers(),

package/lib/exercises/math/functions/trinoms/rootsSum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/rootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAO9C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAqGF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAiB1C,CAAC"}
+{"version":3,"file":"rootsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/rootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAO9C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAoGF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAiB1C,CAAC"}

package/lib/exercises/math/functions/trinoms/rootsSum.js

@@ -56,7 +56,7 @@ const getCorrection = (identifiers) => {
     return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur somme $S$ vaut : 
   
 $$
-S = \\frac{c}{a}
+S = \\frac{-b}{a}
 $$
 
 Ici, on a $a = ${aTex}$ et $b = ${bTex}$, donc :
@@ -73,11 +73,10 @@ const isAnswerValid = (ans, { answer }) => {
     return (0, rationalVEA_1.rationalVEA)(ans, answer);
 };
 const getRootsSumQuestion = (ops) => {
-    //(b,c) != 0
     //ac <= 0
     const a = (0, randint_1.randint)(-10, 10, [0]);
     const b = (0, randint_1.randint)(-10, 10);
-    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 10, !b ? [0] : []);
+    const c = (a / Math.abs(a)) * (0, randint_1.randint)(-10, 0, !b ? [0] : []);
     // const trinom = GeneralTrinomConstructor.randomNiceRoots(2);
     const trinom = new generalTrinom_1.GeneralTrinom(a, b, c);
     const identifiers = {

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAiIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAepE,CAAC"}
+{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAepE,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -57,7 +57,10 @@ const isGGBAnswerValid = (ans, { ggbAnswer }) => {
     const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
     if (studentAns.length !== 1)
         return false;
-    const coords = (0, ggbPointToCoords_1.ggbPointToCoords)(studentAns[0].split("=")[1]);
+    const studentPoint = studentAns[0].split("=")[1];
+    if (studentPoint === undefined)
+        return false;
+    const coords = (0, ggbPointToCoords_1.ggbPointToCoords)(studentPoint);
     const coordsAns = (0, ggbPointToCoords_1.ggbPointToCoords)(ggbAnswer[0].split("=")[1]);
     return ((0, approxEqual_1.approxEqual)(coords.x, coordsAns.x, 0.2) &&
         (0, approxEqual_1.approxEqual)(coords.y, coordsAns.y, 0.2));

package/lib/index.d.ts

@@ -578,6 +578,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     isStrict: boolean;
+}, {}> | Exercise<{
+    firstAffine: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    secondAffine: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
 }, {}> | Exercise<{
     xA: number;
     yA: number;

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":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC"}

package/lib/math/numbers/nombre.d.ts

@@ -18,5 +18,10 @@ export declare abstract class NombreConstructor {
         types?: NumberType[];
         excludes?: Nombre[];
     }): Nombre;
+    static manyRandom(n: number, { types, excludes, allDifferent, }?: {
+        types?: NumberType[];
+        excludes?: Nombre[];
+        allDifferent?: boolean;
+    }): Nombre[];
 }
 //# sourceMappingURL=nombre.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;CAiCP"}
+{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQ1D,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;IAiCN,MAAM,CAAC,UAAU,CACf,CAAC,EAAE,MAAM,EACT,EACE,KAAK,EACL,QAAQ,EACR,YAAoB,GACrB,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,YAAY,CAAC,EAAE,OAAO,CAAC;KACnB;CAaT"}

package/lib/math/numbers/nombre.js

@@ -48,5 +48,17 @@ class NombreConstructor {
         }
         return res;
     }
+    static manyRandom(n, { types, excludes, allDifferent = false, } = {}) {
+        const res = [];
+        res.push(NombreConstructor.random({ types, excludes }));
+        for (let i = 0; i < n - 1; i++) {
+            let b;
+            do {
+                b = NombreConstructor.random({ types, excludes });
+            } while (allDifferent && res.some((el) => el.equals(b)));
+            res.push(b);
+        }
+        return res;
+    }
 }
 exports.NombreConstructor = NombreConstructor;

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

@@ -1,10 +1,23 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+export declare abstract class GeneralAffineConstructor {
+    static fromIdentifiers(identifiers: GeneralAffineIdentifiers): GeneralAffine;
+}
+export type GeneralAffineIdentifiers = {
+    id: "affine";
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    variable?: string;
+};
 export declare class GeneralAffine {
     a: AlgebraicNode;
     b: AlgebraicNode;
     variable: string;
     constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
+    toIdentifiers(): GeneralAffineIdentifiers;
     getRoot(): AlgebraicNode;
     toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
+    xIntersect(aff: GeneralAffine): AlgebraicNode | undefined;
+    opposite(): GeneralAffine;
 }
 //# sourceMappingURL=generalAffine.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAWxB,OAAO,IAAI,aAAa;IAIxB,MAAM;CAKP"}
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAQ1C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAM7D;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAIxB,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAGT"}

package/lib/math/polynomials/generalAffine.js

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeneralAffine = void 0;
+exports.GeneralAffine = exports.GeneralAffineConstructor = void 0;
 const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
 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");
+class GeneralAffineConstructor {
+    static fromIdentifiers(identifiers) {
+        return new GeneralAffine((0, nodeConstructor_1.reifyAlgebraic)(identifiers.a), (0, nodeConstructor_1.reifyAlgebraic)(identifiers.b));
+    }
+}
+exports.GeneralAffineConstructor = GeneralAffineConstructor;
 class GeneralAffine {
     constructor(a, b, variable = "x") {
         if (typeof a === "number")
@@ -19,6 +27,14 @@ class GeneralAffine {
             this.b = b;
         this.variable = variable;
     }
+    toIdentifiers() {
+        return {
+            id: "affine",
+            a: this.a.toIdentifiers(),
+            b: this.b.toIdentifiers(),
+            variable: this.variable !== "x" ? this.variable : undefined,
+        };
+    }
     getRoot() {
         return (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(this.b), this.a).simplify();
     }
@@ -28,5 +44,13 @@ class GeneralAffine {
             return monom;
         return (0, addNode_1.add)(monom, this.b);
     }
+    xIntersect(aff) {
+        if (aff.a.evaluate() === this.a.evaluate())
+            return undefined;
+        return (0, fractionNode_1.frac)((0, substractNode_1.substract)(aff.b, this.b), (0, substractNode_1.substract)(this.a, aff.a)).simplify();
+    }
+    opposite() {
+        return new GeneralAffine((0, oppositeNode_1.opposite)(this.a), (0, oppositeNode_1.opposite)(this.b));
+    }
 }
 exports.GeneralAffine = GeneralAffine;

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -2,7 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const playground = () => { };
+const fractionNode_1 = require("./tree/nodes/operators/fractionNode");
+const oppositeNode_1 = require("./tree/nodes/functions/oppositeNode");
+const playground = () => {
+    const fraction = (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(-6), (0, oppositeNode_1.opposite)(4)).toSimplificationString();
+    console.log(fraction);
+    console.log((0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(-6), 4).toTex());
+    console.log((0, oppositeNode_1.opposite)(-6).toTex());
+};
 exports.playground = playground;
 const logIdentifiers = () => {
     const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';

package/lib/tree/nodes/functions/absNode.d.ts

@@ -2,6 +2,7 @@ import { Node, NodeIds, NodeType } from "../node";
 import { FunctionNode, FunctionsIds } from "./functionNode";
 import { AlgebraicNode } from "../algebraicNode";
 export declare function isAbsNode(a: Node): a is AbsNode;
+export declare const abs: (a: AlgebraicNode | number | string) => AbsNode;
 export declare class AbsNode implements FunctionNode {
     id: FunctionsIds;
     child: AlgebraicNode;

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

@@ -1 +1 @@
-{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAOf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ;IAUR,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;CAIxC"}
+{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,eAAO,MAAM,GAAG,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,YAIrD,CAAC;AACF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAOf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ;IAUR,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;CAIxC"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbsNode = exports.isAbsNode = void 0;
+exports.AbsNode = exports.abs = exports.isAbsNode = void 0;
 // import { abs } from "mathjs";
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
@@ -12,6 +12,11 @@ function isAbsNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.abs;
 }
 exports.isAbsNode = isAbsNode;
+const abs = (a) => {
+    const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
+    return new AbsNode(nodeA);
+};
+exports.abs = abs;
 class AbsNode {
     constructor(child) {
         this.id = functionNode_1.FunctionsIds.abs;

package/lib/tree/nodes/nodeConstructor.d.ts

@@ -1,4 +1,7 @@
+import { AlgebraicNode } from "./algebraicNode";
 import { Node, NodeIds } from "./node";
+export declare const reifyAlgebraic: (identifiers: NodeIdentifiers) => AlgebraicNode;
+export declare const reifyNode: (identifiers: NodeIdentifiers) => Node;
 export type NodeIdentifiers = {
     id: NodeIds;
 } & Record<string, any>;

package/lib/tree/nodes/nodeConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAmBvC,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACpE,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;CAsR3D"}
+{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAwBhD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAmBvC,eAAO,MAAM,cAAc,gBAAiB,eAAe,kBACI,CAAC;AAChE,eAAO,MAAM,SAAS,gBAAiB,eAAe,SACR,CAAC;AAC/C,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACpE,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;CAsR3D"}

package/lib/tree/nodes/nodeConstructor.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeConstructor = void 0;
+exports.NodeConstructor = exports.reifyNode = exports.reifyAlgebraic = void 0;
 const point_1 = require("../../math/geometry/point");
 const complexNode_1 = require("./complex/complexNode");
 const equalNode_1 = require("./equations/equalNode");
@@ -42,6 +42,10 @@ const discreteSetNode_1 = require("./sets/discreteSetNode");
 const intervalNode_1 = require("./sets/intervalNode");
 const unionIntervalNode_1 = require("./sets/unionIntervalNode");
 const variableNode_1 = require("./variables/variableNode");
+const reifyAlgebraic = (identifiers) => NodeConstructor.fromIdentifiers(identifiers);
+exports.reifyAlgebraic = reifyAlgebraic;
+const reifyNode = (identifiers) => NodeConstructor.fromIdentifiers(identifiers);
+exports.reifyNode = reifyNode;
 class NodeConstructor {
     static fromIdentifiers(identifiers) {
         switch (identifiers.id) {

package/lib/tree/nodes/operators/fractionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAUT,KAAK,IAAI,MAAM;IAsBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;IAQtB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAUT,KAAK,IAAI,MAAM;IA2Bf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;IAQtB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

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

@@ -93,8 +93,13 @@ class FractionNode {
         return denum === 1;
     }
     toTex() {
+        //! this stinks
+        //! to tex shouldn't be doing all of this
+        //! we need a "canonicalToTex" or a "purifyTex" in order to print correct latex without simplifying mathematically
         if (!this.opts?.allowMinusAnywhereInFraction &&
-            ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||
+            (((0, oppositeNode_1.isOppositeNode)(this.leftChild) &&
+                (0, numberNode_1.isNumberNode)(this.leftChild.child) &&
+                this.leftChild.child.value > 0) ||
                 ((0, numberNode_1.isNumberNode)(this.leftChild) && this.leftChild.value < 0))) {
             return `-\\frac{${this.leftChild
                 .toTex()

package/lib/tree/parsers/rationalParser.d.ts

@@ -1,3 +1,3 @@
 import { FractionNode } from "../nodes/operators/fractionNode";
-export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/functions/oppositeNode").OppositeNode | FractionNode | undefined;
+export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/functions/oppositeNode").OppositeNode | FractionNode;
 //# sourceMappingURL=rationalParser.d.ts.map

package/lib/tree/parsers/rationalParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAQ,MAAM,iCAAiC,CAAC;AAGrE,eAAO,MAAM,cAAc,QAAS,MAAM,wMA0BzC,CAAC"}
+{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAQ,MAAM,iCAAiC,CAAC;AAGrE,eAAO,MAAM,cAAc,QAAS,MAAM,4LA2BzC,CAAC"}

package/lib/tree/parsers/rationalParser.js

@@ -36,5 +36,6 @@ const rationalParser = (ans) => {
             return false;
         return (0, oppositeNode_1.opposite)((0, fractionNode_1.frac)(nodeFracs[0], nodeFracs[1]));
     }
+    return false;
 };
 exports.rationalParser = rationalParser;

package/package.json

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