math-exercises 3.0.97 → 3.0.98

package/lib/exercises/math/functions/inverse/solveInverseEquation.js

@@ -0,0 +1,147 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, k }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const kNode = reifyAlgebraic(k);
+    tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([kNode])).toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([randint(-10, 10, [0]).toTree()])).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const kNode = reifyAlgebraic(identifiers.k);
+    const set = new EquationSolutionNode(new DiscreteSetNode([frac(1, kNode).simplify()]));
+    return set.toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre, pour $x\\neq 0$, l'équation suivante : 
+  
+$$
+\\frac{1}{x} = ${reifyAlgebraic(identifiers.k).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `La solution de l'équation $\\frac{1}{x} = k$ est : 
+  
+$$
+S=\\left\\lbrace \\frac{1}{k} \\right\\rbrace
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const kNode = reifyAlgebraic(identifiers.k);
+    const isSimp = frac(1, kNode).simplify().toTex() === frac(1, kNode).toTex();
+    return `La solution de l'équation $\\frac{1}{x} = k$ est : 
+  
+$$
+S=\\left\\lbrace \\frac{1}{k} \\right\\rbrace
+$$
+
+Ici, on a $k = ${kNode.toTex()}$, ${!isSimp
+        ? `et :
+
+$$
+\\frac{1}{${kNode.toTex()}}=${frac(1, kNode).simplify().toTex()}
+$$
+
+On a donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`
+        : `donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`}`;
+};
+const getKeys = (identifiers) => {
+    return ["S", "equal", "lbrace", "semicolon", "rbrace"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        return ("S=" +
+            parsed
+                .simplify({
+                decimalToFractions: true,
+            })
+                .toTex() ===
+            answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSolveInverseEquationQuestion = (ops) => {
+    const type = randint(0, 4);
+    let k;
+    switch (type) {
+        case 0:
+            k = (random([-1, 1]) * 2 ** randint(0, 3) * 5 ** randint(0, 3)).toTree();
+            break;
+        case 1:
+            let a;
+            do {
+                a = randint(-19, 20, [0]);
+            } while ((1 / a).toString().length > 5);
+            k = a.toTree();
+            break;
+        case 2:
+            const b = randint(-10, 10, [0, 1, -1]);
+            k = frac(1, b);
+            break;
+        case 3:
+        default:
+            let ratio;
+            do {
+                ratio = RationalConstructor.randomIrreductible();
+            } while (ratio.num === 1);
+            k = ratio.toTree();
+            break;
+    }
+    const identifiers = {
+        k: k.toIdentifiers(),
+    };
+    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 solveInverseEquation = {
+    id: "solveInverseEquation",
+    label: "Résoudre une équation du type $\\frac{1}{x}=k$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSolveInverseEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/sign/affineProductSignTable.js

@@ -65,7 +65,7 @@ $$`;
 const getHint = (identifiers) => {
     const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
     const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
-    return `Résout les inéquations $${affine1.toTree().toTex()}>0$ et $${affine2
+    return `Résous les inéquations $${affine1.toTree().toTex()}>0$ et $${affine2
         .toTree()
         .toTex()}>0$.
   

package/lib/exercises/math/functions/sign/affineProductSignTableThirdLine.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    affine1Coeffs: number[];
+    affine2Coeffs: number[];
+    initTable: string[][];
+};
+export declare const affineProductSignTableThirdLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=affineProductSignTableThirdLine.d.ts.map

package/lib/exercises/math/functions/sign/affineProductSignTableThirdLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineProductSignTableThirdLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/affineProductSignTableThirdLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AA8MF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAkBjE,CAAC"}

package/lib/exercises/math/functions/sign/affineProductSignTableThirdLine.js

@@ -0,0 +1,201 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    let root1 = affine1.getRoot().toTree();
+    let root2 = affine2.getRoot().toTree();
+    const isRoot1OfAffine1 = root1.evaluate() < root2.evaluate();
+    if (!isRoot1OfAffine1) {
+        [root1, root2] = [root2, root1];
+    }
+    const signs1 = affine1.a > 0 ? ["-", "+"] : ["+", "-"];
+    const signs2 = affine2.a > 0 ? ["-", "+"] : ["+", "-"];
+    const signs3 = affine1.a * affine2.a > 0 ? ["+", "-", "+"] : ["-", "+", "-"];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            root1.toTex(),
+            "\\ ",
+            root2.toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            `$${affine1.toTree().toTex()}$`,
+            "\\ ",
+            signs1[0],
+            isRoot1OfAffine1 ? "0" : signs1[0],
+            isRoot1OfAffine1 ? signs1[1] : signs1[0],
+            isRoot1OfAffine1 ? signs1[1] : "0",
+            signs1[1],
+            "\\ ",
+        ],
+        [
+            `$${affine2.toTree().toTex()}$`,
+            "\\ ",
+            signs2[0],
+            !isRoot1OfAffine1 ? "0" : signs2[0],
+            !isRoot1OfAffine1 ? signs2[1] : signs2[0],
+            !isRoot1OfAffine1 ? signs2[1] : "0",
+            signs2[1],
+            "\\ ",
+        ],
+        [`$f(x)$`, "\\ ", signs3[0], "0", signs3[1], "0", signs3[2], "\\ "],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    const product = multiply(affine1.toTree(), affine2.toTree());
+    return `Compléter le tableau de signes suivant afin de déterminer le signe de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${product.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    return `Utilise la règle des signes pour déterminer le signe de $f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const affine1 = AffineConstructor.fromCoeffs(identifiers.affine1Coeffs);
+    const affine2 = AffineConstructor.fromCoeffs(identifiers.affine2Coeffs);
+    let root1 = affine1.getRoot().toTree();
+    let root2 = affine2.getRoot().toTree();
+    const isRoot1OfAffine1 = root1.evaluate() < root2.evaluate();
+    if (!isRoot1OfAffine1) {
+        [root1, root2] = [root2, root1];
+    }
+    const signs3 = affine1.a * affine2.a > 0
+        ? ["positif", "négatif", "positif"]
+        : ["négatif", "positif", "négatif"];
+    return `En utilisant la règle des signes, on conclut que $f$ est ${signs3[0]} sur $]\\infty; ${root1.toTex()}]$, puis ${signs3[1]} sur $[${root1.toTex()}; ${root2.toTex()}[$, puis ${signs3[2]} sur $[${root2.toTex()}; +\\infty[$.
+`;
+};
+const getKeys = (identifiers) => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable, affine1Coeffs, affine2Coeffs }) => {
+    try {
+        const lastRowVEA = ans[3].every((cell, j) => cell === answerTable[3][j]);
+        if (!lastRowVEA)
+            return false;
+        return true;
+        return true;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const rowTableVEA = (row, answerRow, affineCoeffs) => {
+    const signs = affineCoeffs[1] > 0 ? ["-", "+"] : ["+", "-"];
+    const zero = row.indexOf("0");
+    if (!zero || answerRow[zero] !== "0")
+        return false;
+    const left = row.slice(1, zero);
+    const right = row.slice(zero + 1);
+    const leftGood = left.some((e) => e === signs[0]) &&
+        left.every((e) => e === signs[0] || e == "\\ " || e === "");
+    const rightGood = right.some((e) => e === signs[1]) &&
+        right.every((e) => e === signs[1] || e == "\\ " || e === "");
+    if (!leftGood || !rightGood)
+        return false;
+    return true;
+};
+const getTestSignTableQuestion = (ops) => {
+    let a = 0;
+    let b = 0;
+    let c = 0;
+    let d = 0;
+    do {
+        a = randint(-10, 10, [0]);
+        b = randint(-10, 10);
+        c = randint(-10, 10, [0]);
+        d = randint(-10, 10);
+    } while (c * b === a * d);
+    const affine1 = new Affine(a, b);
+    const affine2 = new Affine(c, d);
+    let root1 = affine1.getRoot().toTree();
+    let root2 = affine2.getRoot().toTree();
+    const isRoot1OfAffine1 = root1.evaluate() < root2.evaluate();
+    if (!isRoot1OfAffine1) {
+        [root1, root2] = [root2, root1];
+    }
+    const signs1 = affine1.a > 0 ? ["-", "+"] : ["+", "-"];
+    const signs2 = affine2.a > 0 ? ["-", "+"] : ["+", "-"];
+    const initTable = [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            root1.toTex(),
+            "\\ ",
+            root2.toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            `$${affine1.toTree().toTex()}$`,
+            "\\ ",
+            signs1[0],
+            isRoot1OfAffine1 ? "0" : signs1[0],
+            isRoot1OfAffine1 ? signs1[1] : signs1[0],
+            isRoot1OfAffine1 ? signs1[1] : "0",
+            signs1[1],
+            "\\ ",
+        ],
+        [
+            `$${affine2.toTree().toTex()}$`,
+            "\\ ",
+            signs2[0],
+            !isRoot1OfAffine1 ? "0" : signs2[0],
+            !isRoot1OfAffine1 ? signs2[1] : signs2[0],
+            !isRoot1OfAffine1 ? signs2[1] : "0",
+            signs2[1],
+            "\\ ",
+        ],
+        [`$f(x)$`, "\\ ", "", "", "", "", "", "\\ "],
+    ];
+    const identifiers = {
+        affine1Coeffs: [b, a],
+        affine2Coeffs: [d, c],
+        initTable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+    };
+};
+export const affineProductSignTableThirdLine = {
+    id: "affineProductSignTableThirdLine",
+    label: "Compléter la troisième ligne du tableau de signes d'un produit de fonctions affines",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+};

package/lib/exercises/math/functions/sign/affineSignTable.js

@@ -31,7 +31,7 @@ f(x) = ${affine.toTree().toTex()}
 $$`;
 };
 const getHint = (identifiers) => {
-    return `Résout l'inéquation $f(x)>0$.`;
+    return `Résous l'inéquation $f(x)>0$.`;
 };
 const getCorrection = (identifiers) => {
     const { affineCoeffs, initTable } = identifiers;

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

@@ -5,4 +5,5 @@ export * from "./readSignTable.js";
 export * from "./signTableFromGraph.js";
 export * from "./equationFromSignTable.js";
 export * from "./partialSignTableFromGraph.js";
+export * from "./affineProductSignTableThirdLine.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC"}

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

@@ -5,3 +5,4 @@ export * from "./readSignTable.js";
 export * from "./signTableFromGraph.js";
 export * from "./equationFromSignTable.js";
 export * from "./partialSignTableFromGraph.js";
+export * from "./affineProductSignTableThirdLine.js";

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

@@ -1,4 +1,6 @@
 export * from "./squareImageInterval.js";
 export * from "./imageOfSquareFunction.js";
 export * from "./compareSquaredValues.js";
+export * from "./squareImageIntervalWithGraph.js";
+export * from "./squareFunctionInequationWithGraph.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC"}

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

@@ -1,4 +1,5 @@
 export * from "./squareImageInterval.js";
 export * from "./imageOfSquareFunction.js";
 export * from "./compareSquaredValues.js";
-// export * from "./sqaureImageIntervalWithGraph.js";
+export * from "./squareImageIntervalWithGraph.js";
+export * from "./squareFunctionInequationWithGraph.js";

package/lib/exercises/math/functions/square/squareFunctionInequationWithGraph.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { InegalitySymbols } from "../../../../math/inequations/inequation.js";
+type Identifiers = {
+    k: number;
+    inequationSymbol: InegalitySymbols;
+};
+export declare const squareFunctionInequationWithGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=squareFunctionInequationWithGraph.d.ts.map

package/lib/exercises/math/functions/square/squareFunctionInequationWithGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareFunctionInequationWithGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/squareFunctionInequationWithGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAa9C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC;AAoKF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAenE,CAAC"}

package/lib/exercises/math/functions/square/squareFunctionInequationWithGraph.js

@@ -0,0 +1,151 @@
+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 { InequationSymbol, InequationSymbolConstructor, } from "../../../../math/inequations/inequation.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { OppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { InequationSolutionNode } from "../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getAnswer = (identifiers) => {
+    const { k, inequationSymbol } = identifiers;
+    const sqrtTree = sqrt(k).simplify();
+    const symbol = new InequationSymbol(inequationSymbol);
+    const isStrict = symbol.isStrict;
+    const insideInterval = new IntervalNode(new OppositeNode(sqrtTree), sqrtTree, isStrict ? ClosureType.OO : ClosureType.FF);
+    const set = symbol.isSup
+        ? insideInterval.toReversedClosure().toComplement()
+        : insideInterval;
+    const solution = new InequationSolutionNode(set);
+    return solution.toTex();
+};
+const getInstruction = (identifiers) => {
+    const { k, inequationSymbol } = identifiers;
+    return `On rappelle ci-dessous la courbe représentative de la fonction carré $f(x) = x^2$.
+
+À l'aide de la courbe, résoudre l'inéquation suivante :
+
+$$
+x^2 ${inequationSymbol} ${k}
+$$
+
+*On pourra zoomer et déplacer la courbe si besoin.*`;
+};
+const getHint = (identifiers) => {
+    const { k, inequationSymbol } = identifiers;
+    const word = inequationSymbol === "<"
+        ? "strictement inférieure"
+        : inequationSymbol === ">"
+            ? "strictement supérieure"
+            : inequationSymbol === "\\le"
+                ? "inférieure"
+                : "supérieure";
+    return `Lit graphiquement tous les points de la courbe dont l'ordonnée est ${word} à $${k.frenchify()}$. La solution de l'inéquation est alors l'ensemble des abscisses de ces points.`;
+};
+const getCorrection = (identifiers) => {
+    const { k, inequationSymbol } = identifiers;
+    const word = inequationSymbol === "<"
+        ? "strictement en-dessous"
+        : inequationSymbol === ">"
+            ? "strictement au-dessus"
+            : inequationSymbol === "\\ge"
+                ? "au-dessus"
+                : "en-dessous";
+    const sqrtIsSimp = sqrt(k).toTex() === sqrt(k).simplify().toTex();
+    return `On trace la droite d'équation $y = ${k.frenchify()}$, et on repère les points de la courbe qui sont ${word} de cette droite.
+  
+On repère deux points d'intersection de la droite et de la courbe : les points $\\left(-${sqrt(k).toTex()};${k.frenchify()}\\right)$ et $\\left(${sqrt(k).toTex()};${k.frenchify()}\\right)$.
+
+${sqrtIsSimp
+        ? `La solution de l'inéquation est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`
+        : `Puisque $${sqrt(k).toTex()} = ${sqrt(k)
+            .simplify()
+            .toTex()}$, on a donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`}`;
+};
+const getSquareFunctionInequationQuestion = () => {
+    const k = coinFlip() ? randint(1, 11) ** 2 : randint(1, 100);
+    const inequationSymbol = InequationSymbolConstructor.random();
+    const identifiers = { k, inequationSymbol: inequationSymbol.symbol };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: ["f(x) = x^2", `SetColor(f, "${randomColor()}")`],
+        lockedAxesRatio: false,
+    });
+    //   const { a, b } = identifiers;
+    return ggb.getOptions({
+        // coords: [
+        //   Math.min(a - 1, -1),
+        //   Math.max(b + 1, 1),
+        //   -1,
+        //   Math.max(a ** 2, b ** 2) + 1,
+        // ],
+        coords: [-11, 11, -5, 110],
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["S", "equal", "lbracket", "rbracket", "semicolon", "infty", "cup"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, k, inequationSymbol }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswer({ k: k ** 2, inequationSymbol }));
+    tryToAddWrongProp(propositions, getAnswer({
+        k,
+        inequationSymbol: new InequationSymbol(inequationSymbol).reversed(),
+    }));
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, getAnswer({ k: randint(1, 100), inequationSymbol }));
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, k, inequationSymbol }) => {
+    try {
+        const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return "S=\\ " + parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const squareFunctionInequationWithGraph = {
+    id: "squareFunctionInequationWithGraph",
+    label: "Résoudre une inéquation du type $x^2 < k$ (avec graphique)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSquareFunctionInequationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    pdfOptions: { shouldSpreadPropositions: true },
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/square/squareImageIntervalWithGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareImageIntervalWithGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/squareImageIntervalWithGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAW,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAMxE,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8LF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"squareImageIntervalWithGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/squareImageIntervalWithGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAW,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAMxE,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAoNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

package/lib/exercises/math/functions/square/squareImageIntervalWithGraph.js

@@ -67,7 +67,9 @@ $$
 
 On rappelle ci-dessous la courbe représentative de la fonction carré $f(x) = x^2$.
 
-À l'aide de la courbe, déterminer à quel intervalle appartient $x^2$.`;
+À l'aide de la courbe, déterminer à quel intervalle appartient $x^2$.
+
+*On pourra zoomer et déplacer la courbe si besoin.*`;
 };
 const getSquareImageIntervalQuestion = () => {
     let a;
@@ -97,12 +99,26 @@ const getSquareImageIntervalQuestion = () => {
     return getQuestionFromIdentifiers(identifiers);
 };
 const getHint = (identifiers) => {
-    return ``;
+    const { a, b, closure, type } = identifiers;
+    const interval = new IntervalNode(a.toTree(), b.toTree(), closure);
+    return `Repère sur la courbe les points dont l'abscisse est ${interval.toText(false, true)}. 
+  
+Lit alors la valeur minimale et la valeur maximale des ordonnées de ces points : cela te donnera l'intervalle auquel appartient $x^2$.`;
 };
 const getCorrection = (identifiers) => {
     const { a, b, closure, type } = identifiers;
     const interval = new IntervalNode(a.toTree(), b.toTree(), closure);
-    return ``;
+    const min = a * b < 0 ? 0 : Math.min(Math.abs(a), Math.abs(b)) ** 2;
+    const max = Math.max(Math.abs(a), Math.abs(b)) ** 2;
+    return `On lit sur la courbe l'ordonnée des points dont l'abscisse $x$ est ${interval.toText(false, true)}.
+  
+Au minimum, l'ordonnée peut valoir $${min}$, et au maximum, elle peut valoir $${max}$. 
+
+On en conclut que $x^2$ est compris dans l'intervalle : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
 };
 const getGGBOptions = (identifiers) => {
     const ggb = new GeogebraConstructor({

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

@@ -2,4 +2,8 @@ export * from "./varTableExtremaReading.js";
 export * from "./varTableFromGraph.js";
 export * from "./compareImagesInVarTable.js";
 export * from "./partialVarTableFromGraph.js";
+export * from "./varTableFromSentences.js";
+export * from "./readVarOnGraph.js";
+export * from "./readVarOnGraph2.js";
+export * from "./readExtremaOnGraph.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC"}

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

@@ -2,3 +2,7 @@ export * from "./varTableExtremaReading.js";
 export * from "./varTableFromGraph.js";
 export * from "./compareImagesInVarTable.js";
 export * from "./partialVarTableFromGraph.js";
+export * from "./varTableFromSentences.js";
+export * from "./readVarOnGraph.js";
+export * from "./readVarOnGraph2.js";
+export * from "./readExtremaOnGraph.js";