math-exercises 3.0.108 → 3.0.109

package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.js

@@ -0,0 +1,348 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from '../../../../exercises/exercise.js';
+import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
+import { randint } from '../../../../math/utils/random/randint.js';
+import { opposite } from '../../../../tree/nodes/functions/oppositeNode.js';
+import { add } from '../../../../tree/nodes/operators/addNode.js';
+import { divide } from '../../../../tree/nodes/operators/divideNode.js';
+import { frac } from '../../../../tree/nodes/operators/fractionNode.js';
+import { multiply } from '../../../../tree/nodes/operators/multiplyNode.js';
+import { substract } from '../../../../tree/nodes/operators/substractNode.js';
+import { parseAlgebraic } from '../../../../tree/parsers/latexParser.js';
+import { coinFlip } from '../../../../utils/alea/coinFlip.js';
+import { random } from '../../../../utils/alea/random.js';
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const capitalize = (str) => {
+    if (!str)
+        return ''; // Handle empty strings
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+const arr_operator = [
+    { outputName: "Opposite", arity: 1 },
+    { outputName: "Inverse", arity: 1 },
+    { outputName: "Sum", arity: 2 },
+    { outputName: "Difference", arity: 2 },
+    { outputName: "Product", arity: 2 },
+    { outputName: "Quotient", arity: 2 },
+];
+const getNodeFromOperation = (operation) => {
+    let outNode;
+    if (!("b" in operation.operands)) {
+        const { a } = operation.operands;
+        switch (operation.operator.outputName) {
+            case "Opposite":
+                outNode = opposite(a);
+                break;
+            case "Inverse":
+                outNode = frac(1, a);
+                break;
+        }
+    }
+    else {
+        const { a, b } = operation.operands;
+        switch (operation.operator.outputName) {
+            case "Sum":
+                outNode = add(a, b);
+                break;
+            case "Difference":
+                outNode = substract(a, b);
+                break;
+            case "Product":
+                outNode = multiply(a, b);
+                break;
+            case "Quotient":
+                outNode = frac(a, b);
+                break;
+        }
+    }
+    return outNode;
+};
+const dict_texFactor_to_frenchFactor = {
+    [frac(1, 2).toTex()]: "la moitié",
+    [frac(1, 3).toTex()]: "le tiers",
+    [frac(1, 4).toTex()]: "le quart",
+    [frac(1, 5).toTex()]: "le cinquième",
+    [frac(1, 10).toTex()]: "le dixième",
+    [frac(1, 100).toTex()]: "le centième",
+    [frac(1, 1_000).toTex()]: "le millième",
+    [(2).frenchify()]: "le double",
+    [(3).frenchify()]: "le triple",
+    [(4).frenchify()]: "le quadruple",
+    [(5).frenchify()]: "le quintuple",
+};
+const buildFactorFrenchString = (tex__factor) => {
+    const str__french = dict_texFactor_to_frenchFactor[tex__factor];
+    return str__french;
+};
+const buildFrenchString = (identifiers) => {
+    const { operation, isUsingFrenchFactorNouns } = identifiers;
+    let str__french = "";
+    if (!("b" in operation.operands)) {
+        const { a } = operation.operands;
+        switch (operation.operator.outputName) {
+            case "Opposite":
+                str__french = `L'opposé de $ ${a} $`;
+                break;
+            case "Inverse":
+                str__french = `L'inverse de $ ${a} $`;
+                break;
+        }
+    }
+    else {
+        const { a, b } = operation.operands;
+        switch (operation.operator.outputName) {
+            case "Sum":
+                str__french = `La somme de $ ${a} $ et de $ ${b} $`;
+                break;
+            case "Difference":
+                str__french = `La différence entre $ ${a} $ et $ ${b} $`;
+                break;
+            case "Product":
+                {
+                    str__french = `Le produit de $ ${a} $ par $ ${b} $`;
+                    if (typeof b == 'string' && isUsingFrenchFactorNouns) {
+                        //"le double de x"
+                        const str__a__french = buildFactorFrenchString(a.frenchify());
+                        if (str__a__french) {
+                            str__french = `${str__a__french} de $ ${b} $`;
+                        }
+                    }
+                }
+                break;
+            case "Quotient":
+                {
+                    str__french = `Le quotient de $ ${a} $ par $ ${b} $`;
+                    if (typeof a == 'string' && isUsingFrenchFactorNouns) {
+                        //"le tiers de x"
+                        const oneOverB = frac(1, b);
+                        const str__oneOverB__french = buildFactorFrenchString(oneOverB.toTex());
+                        if (str__oneOverB__french) {
+                            str__french = `${str__oneOverB__french} de $ ${a} $`;
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    return str__french;
+};
+const getPropositions = (n, { answer, operation, isUsingFrenchFactorNouns }) => {
+    const propositions = [];
+    if (!("b" in operation.operands)) {
+        const { a } = operation.operands;
+        switch (operation.operator.outputName) {
+            case "Opposite":
+                addValidProp(propositions, answer);
+                tryToAddWrongProp(propositions, add(a, 1).toTex());
+                tryToAddWrongProp(propositions, frac(1, a).toTex());
+                tryToAddWrongProp(propositions, substract(1, a).toTex());
+                break;
+            case "Inverse":
+                if (coinFlip()) {
+                    addValidProp(propositions, answer);
+                }
+                else {
+                    addValidProp(propositions, divide(1, a).toTex());
+                }
+                tryToAddWrongProp(propositions, add(a, 1).toTex());
+                tryToAddWrongProp(propositions, opposite(a).toTex());
+                tryToAddWrongProp(propositions, frac(0, a).toTex());
+                break;
+        }
+    }
+    else {
+        const { a, b } = operation.operands;
+        switch (operation.operator.outputName) {
+            case "Sum":
+                if (coinFlip()) {
+                    addValidProp(propositions, answer);
+                }
+                else {
+                    addValidProp(propositions, add(b, a).toTex());
+                }
+                tryToAddWrongProp(propositions, multiply(a, b).toTex());
+                tryToAddWrongProp(propositions, substract(a, b).toTex());
+                tryToAddWrongProp(propositions, frac(a, b).toTex());
+                break;
+            case "Difference":
+                addValidProp(propositions, answer);
+                tryToAddWrongProp(propositions, substract(b, a).toTex());
+                tryToAddWrongProp(propositions, frac(a, b).toTex());
+                tryToAddWrongProp(propositions, frac(b, a).toTex());
+                break;
+            case "Product":
+                if (coinFlip()) {
+                    addValidProp(propositions, answer);
+                }
+                else {
+                    addValidProp(propositions, multiply(b, a).toTex());
+                }
+                tryToAddWrongProp(propositions, frac(a, b).toTex());
+                tryToAddWrongProp(propositions, substract(a, b).toTex());
+                tryToAddWrongProp(propositions, add(a, b).toTex());
+                break;
+            case "Quotient":
+                if (coinFlip()) {
+                    addValidProp(propositions, answer);
+                }
+                else {
+                    addValidProp(propositions, divide(a, b).toTex());
+                }
+                tryToAddWrongProp(propositions, frac(b, a).toTex());
+                tryToAddWrongProp(propositions, substract(a, b).toTex());
+                tryToAddWrongProp(propositions, multiply(a, b).toTex());
+                break;
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { operation, isUsingFrenchFactorNouns } = identifiers;
+    const node = getNodeFromOperation(operation).simplify();
+    return node.toTex();
+};
+const getInstruction = (identifiers) => {
+    const statementString = buildFrenchString(identifiers);
+    return `Écrire l'expression littérale pour : 
+
+${statementString}
+`;
+};
+const getHint = (identifiers) => {
+    const { operation } = identifiers;
+    switch (operation.operator.outputName) {
+        case "Opposite":
+            //return `L'opposé de $ ${"a".toTree().toTex()} $, c'est $ ${(0).frenchify()} $ moins $ ${"a".toTree().toTex()} $ (l'0pposé)`
+            return `L'opposé d'un nombre $x$ est $-x$.`;
+        case "Inverse":
+            //return `L'inverse de $ ${"a".toTree().toTex()} $, c'est $ ${(1).frenchify()} $ sur $ ${"a".toTree().toTex()} $ (l'1verse)`
+            return `L'inverse d'un nombre $x$ (différent de $0$) est $\\frac{1}{x}$.`;
+        case "Sum":
+            return `La somme est le résultat de l'addition de deux nombres ($ + $).`;
+        case "Difference":
+            return `La différence est le résultat de la soustraction d'un nombre à un autre ($ - $).`;
+        case "Product":
+            return `Le produit est le résultat de la multiplication de deux nombres ($ \\times $).`;
+        case "Quotient":
+            return `Le quotient est le résultat de la division d'un nombre par un autre ($ \\div $).`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const statementString = buildFrenchString(identifiers);
+    let outString = `${capitalize(statementString)} est $ ${getAnswer(identifiers)} $.`;
+    //explain rewriting if needed
+    const { operation, isUsingFrenchFactorNouns } = identifiers;
+    const node__raw = getNodeFromOperation(operation);
+    const node__refined = node__raw.simplify();
+    const tex__raw = node__raw.toTex({
+        allowDoubleMinus: true,
+        forceTimesSign: true,
+        forceParenthesis: true,
+        forceNoSimplification: true,
+        allowMinusAnywhereInFraction: true,
+    });
+    const tex__refined = node__refined.toTex();
+    if (tex__raw != tex__refined) {
+        outString += `
+
+En effet,
+$$
+${tex__raw}
+$$
+peut se réécrire :
+$$
+${tex__refined}
+$$
+    `;
+    }
+    return outString;
+};
+const getKeys = (identifiers) => {
+    const { operation } = identifiers;
+    const arr_operands = [operation.operands.a];
+    if ("b" in operation.operands) {
+        arr_operands.push(operation.operands.b);
+    }
+    return arr_operands.filter(elt => typeof elt === "string").map(elt => elt);
+};
+const isAnswerValid = (ans, { answer }) => {
+    //return LitExpVEA(ans, answer);
+    try {
+        const parsed = parseAlgebraic(ans);
+        return (parsed
+            .simplify()
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getWriteLitExprFromFrenchQuestion = (ops) => {
+    const operator = random(arr_operator);
+    const isUsingFrenchFactorNouns = coinFlip();
+    const str__var = random(["x", "y", "z", "t"]);
+    let a = "";
+    let b = undefined;
+    if (coinFlip()) {
+        a = str__var;
+        if (operator.outputName === "Quotient" && isUsingFrenchFactorNouns) {
+            const arr_fr = [2, 3, 4, 5, 10, 100, 1_000];
+            b = random([randint(-10, 21, [-1, 0, 1]), random(arr_fr)]);
+        }
+        else {
+            b = randint(-10, 11, [-1, 0, 1]);
+        }
+    }
+    else {
+        b = str__var;
+        if (operator.outputName === "Product" && isUsingFrenchFactorNouns) {
+            const arr_fr = [2, 3, 4, 5];
+            a = random([randint(-10, 21, [-1, 0, 1]), random(arr_fr)]);
+        }
+        else {
+            a = randint(-10, 11, [-1, 0, 1]);
+        }
+    }
+    let operands;
+    switch (operator.arity) {
+        case 1:
+            operands = { a };
+            break;
+        case 2:
+            operands = { a, b };
+            break;
+    }
+    const operation = {
+        operator: operator,
+        operands: operands,
+    };
+    const identifiers = { operation, isUsingFrenchFactorNouns };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: 'tex',
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers)
+    };
+};
+export const writeLitExprFromFrench = {
+    id: 'writeLitExprFromFrench',
+    label: "Ecrire une expression littérale à partir d'une expression en français",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getWriteLitExprFromFrenchQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true
+};

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}
+{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}

package/lib/exercises/math/dataRepresentations/pieChartReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pieChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/pieChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AA0BrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA+NF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}
+{"version":3,"file":"pieChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/pieChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AA0BrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA+NF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}

package/lib/exercises/math/derivation/tangent/derivativeTangentEquationReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeTangentEquationReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeTangentEquationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,GAAG,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAwQF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC;;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}
+{"version":3,"file":"derivativeTangentEquationReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeTangentEquationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,GAAG,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAwQF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC;;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}

package/lib/exercises/math/derivation/variations/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./thirdDegreeFunctionVariation.js";
+export * from "./thirdDegreeDerivativeVariation.js";
 export * from "./variationArrowAmount.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/variations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/derivation/variations/index.js

@@ -1,2 +1,3 @@
 export * from "./thirdDegreeFunctionVariation.js";
+export * from "./thirdDegreeDerivativeVariation.js";
 export * from "./variationArrowAmount.js";

package/lib/exercises/math/derivation/variations/thirdDegreeDerivativeVariation.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    coin: number;
+    r1: number;
+    r2: number;
+};
+export declare const thirdDegreeDerivativeVariation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=thirdDegreeDerivativeVariation.d.ts.map

package/lib/exercises/math/derivation/variations/thirdDegreeDerivativeVariation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thirdDegreeDerivativeVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/thirdDegreeDerivativeVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAmOF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAehE,CAAC"}

package/lib/exercises/math/derivation/variations/thirdDegreeDerivativeVariation.js

@@ -0,0 +1,201 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { coin } = identifiers;
+    return `Soit $f$ une fonction définie et dérivable sur $\\mathbb{R}$, dont la dérivée $f'$ est représentée ci-dessous. 
+    
+Sur quel(s) intervalle(s) la fonction $f$ est-elle ${coin < 0 ? "croissante" : "décroissante"} ?`;
+};
+const getHint = (identifiers) => {
+    return `Si la fonction dérivée $f'$ est positif sur un intervalle, alors la fonction $f$ est croissante sur cet intervalle.
+  
+À l'inverse, si la fonction dérivée $f'$ est négative sur un intervalle, alors la fonction $f$ est décroissante sur cet intervalle`;
+};
+const getCorrection = (identifiers) => {
+    const { coin } = identifiers;
+    const variation = coin < 0 ? "croissante" : "décroissante";
+    const sign = coin < 0 ? "positive" : "négative";
+    const intervals = getIntervalsSolution(identifiers);
+    return `Si la fonction dérivée $f'$ est ${sign} sur un intervalle, alors la fonction $f$ est ${variation} sur cet intervalle. 
+  
+Ici, on lit graphiquement que $f'$ est ${sign} sur $${intervals[0].toTex()}$${intervals[1] ? ` et sur $${intervals[1].toTex()}$` : ""}.
+
+On en déduit que $f$ est donc ${variation} sur : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getIntervalsSolution = (identifiers) => {
+    const { a, coin, r1, r2 } = identifiers;
+    const racine1Tree = new NumberNode(r1);
+    const racine2Tree = new NumberNode(r2);
+    const intervals = coin * a > 0
+        ? [new IntervalNode(racine1Tree, racine2Tree, ClosureType.FF)]
+        : [
+            new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF),
+            new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO),
+        ];
+    return intervals;
+};
+const getAnswer = (identifiers) => {
+    const intervals = getIntervalsSolution(identifiers);
+    if (intervals.length === 1)
+        return intervals[0].toTex();
+    else
+        return intervals.map((e) => e.toTex()).join("\\text{ et }\\ ");
+};
+const getGGBOptions = (identifiers) => {
+    const { a, r1, r2 } = identifiers;
+    // a/3 x^3 + (-a*(r1+r2))/2 x^2 + (a*r1*r2) * x + c
+    // La derive f' est
+    // ax^2 + -a(r1+r2)x + (a*r1*r2)
+    const polynomeDerivative = new Polynomial([a * r1 * r2, -a * (r1 + r2), a]);
+    const commands = [
+        `f'(x) = ${polynomeDerivative.toMathString()}`,
+        `SetColor(f', "${randomColor()}")`,
+    ];
+    // yMax dans un polynome racine 2 (ax^2 + -a(r1+r2)x + (a*r1*r2))
+    // => (2ax - a(r1+r2) = 0) => x = (r1+r2)/2x
+    const padding = 2;
+    const localMaxima = (r1 + r2) / 2;
+    const xMin = Math.min(r1, r2) - padding;
+    const xMax = Math.max(r1, r2) + padding;
+    const yMax = Math.abs(polynomeDerivative.calculate(localMaxima)) + padding;
+    const yMin = Math.min(-yMax, -2);
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+        // gridDistance: false,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getThirdDegreeDerivativeVariation = () => {
+    const a = randint(-3, 4, [0]);
+    let [r1, r2] = randTupleInt(2, {
+        from: -5,
+        to: 6,
+        allDifferent: true,
+    });
+    if (r2 < r1)
+        [r1, r2] = [r2, r1];
+    const coin = coinFlip() ? -1 : 1;
+    const identifiers = { coin, a, r1, r2 };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: "S",
+        answer: getAnswer(identifiers),
+        keys: ["lbracket", "rbracket", "semicolon", "infty", "et"],
+        answerFormat: "tex",
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, r1: racine1, r2: racine2, a, coin }) => {
+    const racine1Tree = new NumberNode(racine1);
+    const racine2Tree = new NumberNode(racine2);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const alpha = frac(add(racine1, racine2), 2).simplify();
+    //a>0 : parabole sourit
+    //coin1 = décroissant, coin -1 = croissant
+    //a>0 coin1 : -inf alpha
+    //a>0 coin -1 : alpha inf
+    //a<0 coin1 : alpha inf
+    //a<0 coin -1 : -inf alpha
+    if (a > 0 === coin > 0) {
+        tryToAddWrongProp(propositions, new IntervalNode(MinusInfinityNode, alpha, ClosureType.OF).toTex());
+    }
+    else {
+        tryToAddWrongProp(propositions, new IntervalNode(alpha, PlusInfinityNode, ClosureType.FF).toTex());
+    }
+    tryToAddWrongProp(propositions, new IntervalNode(racine1Tree, racine2Tree, coin > 0 ? ClosureType.FF : ClosureType.OF).toTex());
+    // tryToAddWrongProp(
+    //   propositions,
+    //   new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO).toTex(),
+    // );
+    // tryToAddWrongProp(
+    //   propositions,
+    //   new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF).toTex(),
+    // );
+    tryToAddWrongProp(propositions, [
+        new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF),
+        new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO),
+    ]
+        .map((e) => e.toTex())
+        .join("\\text{ et }\\ "));
+    while (propositions.length < n) {
+        const root1 = randint(-5, 4);
+        const root2 = randint(root1 + 1, 6);
+        const root1Tree = new NumberNode(root1);
+        const root2Tree = new NumberNode(root2);
+        const wrongAnswer = new IntervalNode(root1Tree, root2Tree, ClosureType.FF).toTex();
+        tryToAddWrongProp(propositions, wrongAnswer);
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, r1: racine1, r2: racine2, coin, a }) => {
+    try {
+        const intervals = ans
+            .split("\\text{ et }")
+            .map((s) => s.replaceAll("\\text{ }", "").replaceAll("\\ ", "").replaceAll(" ", ""));
+        const simped = intervals.map((e) => intervalParser(e, {
+            allowCommaInsteadOfSemicolon: true,
+            allowNoBrackets: true,
+        }));
+        if (simped.some((e) => e === false))
+            return false;
+        return (simped
+            .map((e) => e.simplify())
+            .sort((i1, i2) => i1.a.evaluate() - i2.a.evaluate())
+            .map((e, i) => e
+            .toClosure(simped.length === 2
+            ? i === 0
+                ? ClosureType.OF
+                : ClosureType.FO
+            : ClosureType.FF)
+            .toTex())
+            .join("\\text{ et }\\ ") === answer);
+        return false;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const thirdDegreeDerivativeVariation = {
+    id: "thirdDegreeDerivativeVariation",
+    connector: "=",
+    label: "Lecture des variations d'une fonction via le signe de sa dérivée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getThirdDegreeDerivativeVariation, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"graphicInequationAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicInequationAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAe9C,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;AAgKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"graphicInequationAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicInequationAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAe9C,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;AAgKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

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

@@ -3,4 +3,5 @@ export * from "./logSimplifiying.js";
 export * from "./log10PowerSimplifying.js";
 export * from "./logPowerEquation.js";
 export * from "./log10Simplifying.js";
+export * from "./powerEquation.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC"}

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

@@ -3,3 +3,4 @@ export * from "./logSimplifiying.js";
 export * from "./log10PowerSimplifying.js";
 export * from "./logPowerEquation.js";
 export * from "./log10Simplifying.js";
+export * from "./powerEquation.js";

package/lib/exercises/math/functions/logarithm/powerEquation.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+type Options = {
+    useLog10?: boolean;
+};
+export declare const powerEquation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=powerEquation.d.ts.map

package/lib/exercises/math/functions/logarithm/powerEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powerEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/powerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoJF,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAUF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBxD,CAAC"}