math-exercises 2.2.61 → 2.2.62

package/lib/exercises/math/functions/basics/graphicInequationAffine.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { InegalitySymbols } from "../../../../math/inequations/inequation";
+type Identifiers = {
+    yValue: number;
+    xValue: number;
+    inegalitySymbol: InegalitySymbols;
+    a: number;
+    b: number;
+};
+export declare const graphicInequationAffine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=graphicInequationAffine.d.ts.map

package/lib/exercises/math/functions/basics/graphicInequationAffine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphicInequationAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicInequationAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAa3C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,gBAAgB,CAAC;IAClC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}

package/lib/exercises/math/functions/basics/graphicInequationAffine.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphicInequationAffine = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const inequation_1 = require("../../../../math/inequations/inequation");
+const affine_1 = require("../../../../math/polynomials/affine");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+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/alea/coinFlip");
+const random_1 = require("../../../../utils/alea/random");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const isTowardsLeft = (0, coinFlip_1.coinFlip)();
+        const k = (0, randint_1.randint)(-10, 10).toTree();
+        const bounds = isTowardsLeft
+            ? [infiniteNode_1.MinusInfinityNode, k]
+            : [k, infiniteNode_1.PlusInfinityNode];
+        const closure = closure_1.Closure.fromBrackets(isTowardsLeft ? "]" : "[", (0, random_1.random)(["]", "["]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(bounds[0], bounds[1], closure).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    //ax+b ! y
+    const { a, inegalitySymbol, xValue } = identifiers;
+    const inequation = new inequation_1.InequationSymbol(inegalitySymbol);
+    const isStrict = inequation.isStrict;
+    const isAskingSup = inequation.isSup;
+    const isCroissante = a > 0;
+    const inter = new intervalNode_1.IntervalNode(isCroissante === isAskingSup ? xValue.toTree() : infiniteNode_1.MinusInfinityNode, isCroissante === isAskingSup ? infiniteNode_1.PlusInfinityNode : xValue.toTree(), isStrict
+        ? closure_1.ClosureType.OO
+        : isCroissante === isAskingSup
+            ? closure_1.ClosureType.FO
+            : closure_1.ClosureType.OF);
+    return inter.toTex();
+};
+const getInstruction = (identifiers) => {
+    const { yValue, inegalitySymbol, a, b } = identifiers;
+    const inequation = new inequation_1.InequationSymbol(inegalitySymbol);
+    const isStrict = inequation.isStrict;
+    const isAskingSup = inequation.isSup;
+    return `Ci-dessous est tracé la courbe représentative d'une fonction $f$. Déterminer graphiquement les solutions de l'inéquation $f(x)${isAskingSup ? (isStrict ? ">" : "\\geq") : isStrict ? "<" : "\\leq"}${yValue}$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new affine_1.Affine(a, b);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands: affine.toGGBCommands(),
+    });
+    return ggb.getOptions({
+        coords: [-10, 10, -10, 10],
+    });
+};
+const getKeys = (identifiers) => {
+    return [
+        "S",
+        "equal",
+        "lbracket",
+        "semicolon",
+        "rbracket",
+        "infty",
+        "cup",
+        "lbrace",
+        "rbrace",
+        "varnothing",
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const inter = answer;
+    return ans === inter || ans === "S=" + inter;
+    throw Error("VEA not implemented");
+};
+const getGraphicInequationAffineQuestion = (opts) => {
+    const yValue = (0, randint_1.randint)(-5, 6);
+    const xValue = (0, randint_1.randint)(-5, 6);
+    const a = (0, randfloat_1.randfloat)(-3, 4, 1, [0]);
+    const b = yValue - a * xValue;
+    const inegalitySymbol = inequation_1.InequationSymbolConstructor.randomSymbol();
+    const identifiers = {
+        a,
+        b,
+        xValue,
+        yValue,
+        inegalitySymbol,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+exports.graphicInequationAffine = {
+    id: "graphicInequationAffine",
+    connector: "=",
+    label: "Résoudre graphiquement une inéquation (fonctions affines)",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getGraphicInequationAffineQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+};

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

@@ -8,4 +8,5 @@ export * from "./twoFunctionsEquation";
 export * from "./twoFunctionsInequation";
 export * from "./inverseImageFunctionTable";
 export * from "./imageAntecedentFromSentence";
+export * from "./graphicInequationAffine";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC"}

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

@@ -24,3 +24,4 @@ __exportStar(require("./twoFunctionsEquation"), exports);
 __exportStar(require("./twoFunctionsInequation"), exports);
 __exportStar(require("./inverseImageFunctionTable"), exports);
 __exportStar(require("./imageAntecedentFromSentence"), exports);
+__exportStar(require("./graphicInequationAffine"), exports);

package/lib/exercises/math/functions/trinoms/findSecondRoot.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralTrinomIdentifiers } from "../../../../math/polynomials/generalTrinom";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor";
+type Identifiers = {
+    trinomIdentifiers: GeneralTrinomIdentifiers;
+    firstRootIdentifiers: NodeIdentifiers;
+};
+export declare const findSecondRoot: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findSecondRoot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findSecondRoot.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/findSecondRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAGL,wBAAwB,EACzB,MAAM,sCAAsC,CAAC;AAI9C,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,wBAAwB,CAAC;IAC5C,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AAiHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAiBhD,CAAC"}

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSecondRoot = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const generalTrinom_1 = require("../../../../math/polynomials/generalTrinom");
+const randint_1 = require("../../../../math/utils/random/randint");
+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 getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { trinomIdentifiers, firstRootIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const firstRoot = nodeConstructor_1.NodeConstructor.fromIdentifiers(firstRootIdentifiers);
+    const firstRootTex = firstRoot.toTex();
+    const roots = trinom.getRoots().map((e) => e.toTex());
+    return roots.find((r) => r !== firstRootTex);
+};
+const getInstruction = (identifiers) => {
+    const { trinomIdentifiers, firstRootIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const firstRoot = nodeConstructor_1.NodeConstructor.fromIdentifiers(firstRootIdentifiers);
+    const firstRootTex = firstRoot.toTex();
+    return `Soit $f$ la fonction polynôme du second degré définie sur $\\mathbb{R}$ par :
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+  
+On admet que $f$ admet deux racines, dont une vaut $${firstRootTex}$. 
+  
+Sans calculer $\\Delta$, déterminer la deuxième racine de $f$.`;
+};
+const getHint = (identifiers) => {
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines $x_1$ et $x_2$, alors leur produit vaut : 
+    
+$$
+x_1\\times x_2 = \\frac{c}{a}
+$$
+
+En remplaçant les valeurs par celles données dans l'énoncé, on peut déterminer la deuxième racine de $f$. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { trinomIdentifiers, firstRootIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const firstRoot = nodeConstructor_1.NodeConstructor.fromIdentifiers(firstRootIdentifiers);
+    const cOverA = (0, fractionNode_1.frac)(trinom.c, trinom.a).simplify();
+    return `On sait que le produit des racines $x_1$ et $x_2$ de $f$ vaut :
+  
+$$
+x_1\\times x_2 = \\frac{c}{a} = ${cOverA.toTex()}
+$$
+
+Or on sait que $x_1 = ${firstRoot.toTex()}$. On a donc : 
+
+$$
+x_2 = ${(0, fractionNode_1.frac)(cOverA, firstRoot).toSimplificationString()}
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getFindSecondRootQuestion = (ops) => {
+    // const firstRoot = coinFlip()
+    //   ? randint(-10, 10).toTree()
+    //   : RationalConstructor.randomIrreductibleWithSign(5).toTree();
+    const firstRoot = (0, randint_1.randint)(-10, 10);
+    // const secondRoot = doWhile(
+    //   () =>
+    //     coinFlip()
+    //       ? randint(-10, 10).toTree()
+    //       : RationalConstructor.randomIrreductibleWithSign(5).toTree(),
+    //   (x) => x.equals(firstRoot),
+    // );
+    const secondRoot = (0, randint_1.randint)(-10, 10, [firstRoot]);
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const b = (0, oppositeNode_1.opposite)((0, multiplyNode_1.multiply)(a, (0, addNode_1.add)(firstRoot, secondRoot))).simplify();
+    const c = (0, multiplyNode_1.multiply)(a, (0, multiplyNode_1.multiply)(firstRoot, secondRoot)).simplify();
+    //first*second = c/a
+    const identifiers = {
+        firstRootIdentifiers: firstRoot.toTree().toIdentifiers(),
+        trinomIdentifiers: new generalTrinom_1.GeneralTrinom(a, b, c).toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.findSecondRoot = {
+    id: "findSecondRoot",
+    connector: "=",
+    label: "Déterminer la deuxième racine d'un trinôme sans utiliser $\\Delta$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getFindSecondRootQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -19,4 +19,7 @@ export * from "./solveSecondDegreeEquationByFactorisation";
 export * from "./solveSecondDegreeEquationFromCano";
 export * from "./trinomSignFromRoots";
 export * from "./coefficientsIdentification";
+export * from "./rootsSum";
+export * from "./rootsProduct";
+export * from "./findSecondRoot";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

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

@@ -35,3 +35,6 @@ __exportStar(require("./solveSecondDegreeEquationByFactorisation"), exports);
 __exportStar(require("./solveSecondDegreeEquationFromCano"), exports);
 __exportStar(require("./trinomSignFromRoots"), exports);
 __exportStar(require("./coefficientsIdentification"), exports);
+__exportStar(require("./rootsSum"), exports);
+__exportStar(require("./rootsProduct"), exports);
+__exportStar(require("./findSecondRoot"), exports);

package/lib/exercises/math/functions/trinoms/rootsProduct.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralTrinomIdentifiers } from "../../../../math/polynomials/generalTrinom";
+type Identifiers = {
+    trinomIdentifiers: GeneralTrinomIdentifiers;
+};
+export declare const rootsProduct: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=rootsProduct.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rootsProduct.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/rootsProduct.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;AA0GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootsProduct = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const generalTrinom_1 = require("../../../../math/polynomials/generalTrinom");
+const randint_1 = require("../../../../math/utils/random/randint");
+const oppositeNode_1 = require("../../../../tree/nodes/functions/oppositeNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const getPropositions = (n, { answer, trinomIdentifiers }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(trinom.b), trinom.a).simplify().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(trinom.c), trinom.a).simplify().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(trinom.b), (0, multiplyNode_1.multiply)(2, trinom.a)).simplify().toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const ans = (0, fractionNode_1.frac)(trinom.c, trinom.a).simplify().toTex();
+    return ans;
+};
+const getInstruction = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par :
+    
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+  
+On admet que $f$ possède deux racines. 
+
+Que vaut le produit des racines de $f$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur produit $P$ vaut : 
+    
+$$
+P = \\frac{c}{a}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const aTex = trinom.a.toTex();
+    const cTex = trinom.c.toTex();
+    const ans = (0, fractionNode_1.frac)(trinom.c, trinom.a);
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur produit $P$ vaut : 
+    
+$$
+P = \\frac{c}{a}
+$$
+  
+Ici, on a $a = ${aTex}$ et $c = ${cTex}$, donc :
+
+$$
+P = ${ans.toSimplificationString()}
+$$
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getRootsProductQuestion = (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 trinom = new generalTrinom_1.GeneralTrinom(a, b, c);
+    const identifiers = {
+        trinomIdentifiers: trinom.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.rootsProduct = {
+    id: "rootsProduct",
+    connector: "=",
+    label: "Produit des racines d'un trinôme",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getRootsProductQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { GeneralTrinomIdentifiers } from "../../../../math/polynomials/generalTrinom";
+type Identifiers = {
+    trinomIdentifiers: GeneralTrinomIdentifiers;
+};
+export declare const rootsSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=rootsSum.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootsSum = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const generalTrinom_1 = require("../../../../math/polynomials/generalTrinom");
+const randint_1 = require("../../../../math/utils/random/randint");
+const oppositeNode_1 = require("../../../../tree/nodes/functions/oppositeNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const getPropositions = (n, { answer, trinomIdentifiers }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)(trinom.b, trinom.a).simplify().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)(trinom.c, trinom.a).simplify().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(trinom.b), (0, multiplyNode_1.multiply)(2, trinom.a)).simplify().toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const ans = (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(trinom.b), trinom.a).simplify().toTex();
+    return ans;
+};
+const getInstruction = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par :
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+
+On admet que $f$ possède deux racines. 
+  
+Que vaut la somme des racines de $f$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur produit vaut : 
+  
+$$
+S = -\\frac{b}{a}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = generalTrinom_1.GeneralTrinomConstructor.fromIdentifiers(trinomIdentifiers);
+    const aTex = trinom.a.toTex();
+    const bTex = trinom.b.toTex();
+    const ans = (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(trinom.b), trinom.a);
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur smomme $S$ vaut : 
+  
+$$
+S = \\frac{c}{a}
+$$
+
+Ici, on a $a = ${aTex}$ et $b = ${bTex}$, donc :
+
+$$
+S = ${ans.toSimplificationString()}
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+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 trinom = GeneralTrinomConstructor.randomNiceRoots(2);
+    const trinom = new generalTrinom_1.GeneralTrinom(a, b, c);
+    const identifiers = {
+        trinomIdentifiers: trinom.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.rootsSum = {
+    id: "rootsSum",
+    connector: "=",
+    label: "Somme des racines d'un trinôme",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getRootsSumQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -5,6 +5,9 @@ type Identifiers = {
     startPoint: string;
     translationPoints: string[];
 };
-export declare const pointImageFromTranslation: Exercise<Identifiers>;
+type Options = {
+    useVector: boolean;
+};
+export declare const pointImageFromTranslation: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=pointImageFromTranslation.d.ts.map

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,EAST,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;AAgHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,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;AAiIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAepE,CAAC"}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pointImageFromTranslation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
 const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
@@ -10,8 +11,10 @@ const point_1 = require("../../../../math/geometry/point");
 const vector_1 = require("../../../../math/geometry/vector");
 const random_1 = require("../../../../utils/alea/random");
 const doWhile_1 = require("../../../../utils/doWhile");
-const getInstruction = (identifiers) => {
-    return `Placer l'image du point $${identifiers.startPoint}$ par la translation qui transforme $${identifiers.translationPoints[0]}$ en $${identifiers.translationPoints[1]}$.`;
+const getInstruction = (identifiers, opts) => {
+    return `Placer l'image du point $${identifiers.startPoint}$ par la translation ${opts?.useVector
+        ? `de vecteur $\\overrightarrow{${identifiers.translationPoints[0]}${identifiers.translationPoints[1]}}$.`
+        : `qui transforme $${identifiers.translationPoints[0]}$ en $${identifiers.translationPoints[1]}$.`}`;
 };
 const getEndPoint = (identifiers) => {
     const translationPoints = [
@@ -59,7 +62,7 @@ const isGGBAnswerValid = (ans, { ggbAnswer }) => {
     return ((0, approxEqual_1.approxEqual)(coords.x, coordsAns.x, 0.2) &&
         (0, approxEqual_1.approxEqual)(coords.y, coordsAns.y, 0.2));
 };
-const getPointImageFromTranslationQuestion = () => {
+const getPointImageFromTranslationQuestion = (opts) => {
     const points = [];
     for (let i = 0; i < 4; i++) {
         const name = String.fromCharCode(65 + i);
@@ -78,7 +81,7 @@ const getPointImageFromTranslationQuestion = () => {
     };
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        instruction: getInstruction(identifiers, opts),
         studentGgbOptions: getStudentGGBOptions(identifiers),
         identifiers,
         // hint: getHint(identifiers),
@@ -86,11 +89,19 @@ const getPointImageFromTranslationQuestion = () => {
     };
     return question;
 };
+const options = [
+    {
+        id: "useVector",
+        label: 'Utiliser le terme "translation de vecteur"',
+        type: exercise_1.GeneratorOptionType.checkbox,
+        target: exercise_1.GeneratorOptionTarget.instruction,
+    },
+];
 exports.pointImageFromTranslation = {
     id: "pointImageFromTranslation",
     label: "Placer l'image d'un point par une translation",
     isSingleStep: true,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPointImageFromTranslationQuestion, nb),
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPointImageFromTranslationQuestion(opts), nb),
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
@@ -99,4 +110,5 @@ exports.pointImageFromTranslation = {
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",
+    options,
 };

package/lib/exercises/math/powers/powersProduct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAaT,MAAM,gBAAgB,CAAC;AAMxB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAoIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CA8BpD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBxD,CAAC"}
+{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAaT,MAAM,gBAAgB,CAAC;AAMxB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AA2HF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CA8BpD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBxD,CAAC"}

package/lib/exercises/math/powers/powersProduct.js

@@ -95,23 +95,15 @@ const getPropositions = (n, { answer, a, b, c }) => {
 };
 const isAnswerValid = (ans, { a, b, c }) => {
     const powerNode = (0, powerNode_1.power)(a, b + c);
-    //version frac ou number
-    //version power absolute
-    //version 1/power
     const answerTree = powerNode.simplify();
     const ev = answerTree.evaluate();
     const parsed = (0, rationalParser_1.rationalParser)(ans);
-    console.log(parsed, ev);
     if (parsed && Math.abs(parsed.evaluate() - ev) < 0.000001)
         return true;
     const powerParsed = (0, powerParser_1.powerParser)(ans);
     if (powerParsed && Math.abs(powerParsed.evaluate() - ev) < 0.000001)
         return true;
     return false;
-    // const texs = answerTree.toAllValidTexs();
-    // const rawTex = powerNode.toTex();
-    // if (!texs.includes(rawTex)) texs.push(rawTex);
-    // return texs.includes(ans);
 };
 exports.powersOfTenProduct = {
     id: "powersOfTenProduct",

package/lib/exercises/vea/rationalVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const rationalVEA: (studentAns: string, answer: string) => boolean;
+//# sourceMappingURL=rationalVEA.d.ts.map

package/lib/exercises/vea/rationalVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,eAAgB,MAAM,UAAU,MAAM,YAK7D,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rationalVEA = void 0;
+const latexParser_1 = require("../../tree/parsers/latexParser");
+const rationalParser_1 = require("../../tree/parsers/rationalParser");
+//return true if studentAns is a number or rational, and if it evaluates to answer
+const rationalVEA = (studentAns, answer) => {
+    const parsed = (0, rationalParser_1.rationalParser)(studentAns);
+    if (!parsed)
+        return false;
+    const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
+    return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+};
+exports.rationalVEA = rationalVEA;

package/lib/index.d.ts

@@ -691,6 +691,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     isImage: boolean;
     x: number;
     y: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    yValue: number;
+    xValue: number;
+    inegalitySymbol: import("./math/inequations/inequation").InegalitySymbols;
+    a: number;
+    b: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     k: number;
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -780,6 +786,13 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     bIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
     cIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
     isAsking: string;
+}, {}> | import("./exercises/exercise").Exercise<{
+    trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
+}, {}> | import("./exercises/exercise").Exercise<{
+    trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
+}, {}> | import("./exercises/exercise").Exercise<{
+    trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
+    firstRootIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
 }, {}> | import("./exercises/exercise").Exercise<{
     a: number;
     k: number;
@@ -1121,7 +1134,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     points: import("./math/geometry/point").PointIdentifiers[];
     startPoint: string;
     translationPoints: string[];
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    useVector: boolean;
+}> | import("./exercises/exercise").Exercise<{
     type: number;
     commands: string[];
 }, {}> | import("./exercises/exercise").Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -1,6 +1,7 @@
 export type InegalitySymbols = "<" | ">" | "\\le" | "\\ge";
 export declare abstract class InequationSymbolConstructor {
     static random(): InequationSymbol;
+    static randomSymbol(): InegalitySymbols;
 }
 export declare class InequationSymbol {
     isStrict: boolean;

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

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

package/lib/math/inequations/inequation.js

@@ -6,6 +6,9 @@ class InequationSymbolConstructor {
     static random() {
         return new InequationSymbol((0, random_1.random)(["<", ">", "\\le", "\\ge"]));
     }
+    static randomSymbol() {
+        return (0, random_1.random)(["<", ">", "\\le", "\\ge"]);
+    }
 }
 exports.InequationSymbolConstructor = InequationSymbolConstructor;
 class InequationSymbol {

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

@@ -32,5 +32,6 @@ export declare class Affine extends Polynomial {
     times(n: number): Affine;
     toString(): string;
     toReducedEquation(): string;
+    toGGBCommands(): string[];
 }
 //# sourceMappingURL=affine.d.ts.map

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":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,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,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,QAAQ,IAAI,MAAM;IAIlB,iBAAiB,IAAI,MAAM;CAG5B"}
+{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,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,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,QAAQ,IAAI,MAAM;IAIlB,iBAAiB,IAAI,MAAM;IAI3B,aAAa;CAGd"}

package/lib/math/polynomials/affine.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Affine = exports.AffineConstructor = void 0;
+const colors_1 = require("../../geogebra/colors");
 const rational_1 = require("../numbers/rationals/rational");
 const randint_1 = require("../utils/random/randint");
 const polynomial_1 = require("./polynomial");
@@ -51,5 +52,8 @@ class Affine extends polynomial_1.Polynomial {
     toReducedEquation() {
         return `y=${this.toTex()}`;
     }
+    toGGBCommands() {
+        return [`f(x) = ${this.toString()}`, `SetColor(f, "${(0, colors_1.randomColor)()}")`];
+    }
 }
 exports.Affine = Affine;

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

@@ -1,6 +1,6 @@
-import { AddNode } from "../../tree/nodes/operators/addNode";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 import { NodeType } from "../../tree/nodes/node";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
 export declare abstract class GeneralTrinomConstructor {
     static random(aOpts?: {
         min?: number;
@@ -31,7 +31,14 @@ export declare abstract class GeneralTrinomConstructor {
     }): GeneralTrinom;
     static randomNiceRoots(nbOfRoots?: number): GeneralTrinom;
     static fromCoeffs(coeffs: number[]): GeneralTrinom;
+    static fromIdentifiers(identifiers: GeneralTrinomIdentifiers): GeneralTrinom;
 }
+export type GeneralTrinomIdentifiers = {
+    a: number | NodeIdentifiers;
+    b: number | NodeIdentifiers;
+    c: number | NodeIdentifiers;
+    opts?: GeneralTrinomOptions;
+};
 type GeneralTrinomOptions = {
     variable: string;
 };
@@ -44,9 +51,10 @@ export declare class GeneralTrinom {
     constructor(a: AlgebraicNode | number, b: AlgebraicNode | number, c: AlgebraicNode | number, opts?: GeneralTrinomOptions);
     getDelta(): AlgebraicNode;
     getRoots(): AlgebraicNode[];
-    toTree(): AddNode;
+    toTree(): import("../../tree/nodes/operators/multiplyNode").MultiplyNode | import("../../tree/nodes/operators/addNode").AddNode;
     toTex(): string;
     getCoeffs(): number[];
+    toIdentifiers(): GeneralTrinomIdentifiers;
 }
 export {};
 //# sourceMappingURL=generalTrinom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generalTrinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalTrinom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AA0BlE,OAAO,EAAE,aAAa,EAAmB,MAAM,gCAAgC,CAAC;AAIhF,OAAO,EAGL,QAAQ,EAET,MAAM,uBAAuB,CAAC;AAG/B,8BAAsB,wBAAwB;IAC5C,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,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,aAAa;IAmBhB,MAAM,CAAC,eAAe,CACpB,KAAK,CAAC,EAAE;QACN,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,EACD,SAAS,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC/D,QAAQ,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC7D,aAAa;IAmBhB,MAAM,CAAC,eAAe,CAAC,SAAS,GAAE,MAAU;IAqB5C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE;CAGnC;AAED,KAAK,oBAAoB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AACjD,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAmB;gBAG/B,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,IAAI,CAAC,EAAE,oBAAoB;IAS7B,QAAQ;IAiBR,QAAQ,IAAI,aAAa,EAAE;IAgB3B,MAAM;IAON,KAAK;IAGL,SAAS;CAGV"}
+{"version":3,"file":"generalTrinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalTrinom.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAE1C,8BAAsB,wBAAwB;IAC5C,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,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,aAAa;IAmBhB,MAAM,CAAC,eAAe,CACpB,KAAK,CAAC,EAAE;QACN,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,EACD,SAAS,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC/D,QAAQ,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC7D,aAAa;IAmBhB,MAAM,CAAC,eAAe,CAAC,SAAS,GAAE,MAAU;IAqB5C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE;IAIlC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAc7D;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;IAC5B,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;IAC5B,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AACjD,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAmB;gBAG/B,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,IAAI,CAAC,EAAE,oBAAoB;IAS7B,QAAQ;IAiBR,QAAQ,IAAI,aAAa,EAAE;IAgB3B,MAAM;IAYN,KAAK;IAGL,SAAS;IAIT,aAAa,IAAI,wBAAwB;CAQ1C"}

package/lib/math/polynomials/generalTrinom.js

@@ -11,6 +11,7 @@ const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const randint_1 = require("../utils/random/randint");
 const random_1 = require("../../utils/alea/random");
 const node_1 = require("../../tree/nodes/node");
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
 class GeneralTrinomConstructor {
     static random(aOpts, bOpts, cOpts) {
         const a = (0, randint_1.randint)(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
@@ -53,6 +54,15 @@ class GeneralTrinomConstructor {
     static fromCoeffs(coeffs) {
         return new GeneralTrinom(coeffs[2], coeffs[1], coeffs[0]);
     }
+    static fromIdentifiers(identifiers) {
+        return new GeneralTrinom(typeof identifiers.a === "number"
+            ? identifiers.a
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.a), typeof identifiers.b === "number"
+            ? identifiers.b
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.b), typeof identifiers.c === "number"
+            ? identifiers.c
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.c), identifiers.opts);
+    }
 }
 exports.GeneralTrinomConstructor = GeneralTrinomConstructor;
 class GeneralTrinom {
@@ -90,7 +100,17 @@ class GeneralTrinom {
         ].sort((a, b) => a.evaluate() - b.evaluate());
     }
     toTree() {
-        return (0, addNode_1.add)((0, multiplyNode_1.multiply)(this.a, (0, powerNode_1.square)(this.variable)), (0, addNode_1.add)((0, multiplyNode_1.multiply)(this.b, this.variable), this.c));
+        const bEv = this.b.evaluate();
+        const cEv = this.c.evaluate();
+        const highMonom = (0, multiplyNode_1.multiply)(this.a, (0, powerNode_1.square)(this.variable));
+        const middleMonom = (0, multiplyNode_1.multiply)(this.b, this.variable);
+        if (!bEv && !cEv)
+            return highMonom;
+        if (!cEv)
+            return (0, addNode_1.add)(highMonom, middleMonom);
+        if (!bEv)
+            return (0, addNode_1.add)(highMonom, this.c);
+        return (0, addNode_1.add)(highMonom, (0, addNode_1.add)(middleMonom, this.c));
     }
     toTex() {
         return this.toTree().toTex();
@@ -98,5 +118,13 @@ class GeneralTrinom {
     getCoeffs() {
         return [this.c.evaluate(), this.b.evaluate(), this.a.evaluate()];
     }
+    toIdentifiers() {
+        return {
+            a: this.a.toIdentifiers(),
+            b: this.b.toIdentifiers(),
+            c: this.c.toIdentifiers(),
+            opts: { variable: this.variable },
+        };
+    }
 }
 exports.GeneralTrinom = GeneralTrinom;

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

@@ -33,5 +33,6 @@ export declare class FractionNode implements OperatorNode {
     simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): FractionNode;
+    toSimplificationString(): string;
 }
 //# sourceMappingURL=fractionNode.d.ts.map

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,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,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;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,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;CAMzD"}
+{"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,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,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;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,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;CAQvB"}

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

@@ -236,5 +236,15 @@ class FractionNode {
     toDetailedEvaluation(vars) {
         return new FractionNode(this.leftChild.toDetailedEvaluation(vars), this.rightChild.toDetailedEvaluation(vars));
     }
+    toSimplificationString() {
+        const simplified = this.simplify();
+        const thisTex = this.toTex();
+        const simpTex = simplified.toTex();
+        const isSimplified = thisTex === simpTex;
+        if (isSimplified)
+            return thisTex;
+        else
+            return `${thisTex} = ${simpTex}`;
+    }
 }
 exports.FractionNode = FractionNode;

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,+IA2BzC,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,+IAwBzC,CAAC"}

package/lib/tree/parsers/rationalParser.js

@@ -32,8 +32,5 @@ const rationalParser = (ans) => {
         const nodeFracs = fracs.map((e) => e.unfrenchify().toTree());
         return (0, oppositeNode_1.opposite)((0, fractionNode_1.frac)(nodeFracs[0], nodeFracs[1]));
     }
-    // const nb = ans.unfrenchify();
-    // if (isNaN(nb)) return false;
-    // return nb.frenchify();
 };
 exports.rationalParser = rationalParser;

package/package.json

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