math-exercises 3.0.94 → 3.0.95

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

@@ -0,0 +1,213 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const oneSol = coinFlip();
+        const a = randint(-10, 10);
+        const b = randint(-10, 10, [a]);
+        const roots = oneSol
+            ? [a.toTree()]
+            : [a, b].sort((a, b) => a - b).map((e) => e.toTree());
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode(roots)).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getRoots = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    switch (identifiers.type) {
+        case 0:
+            return [frac(-b, a), frac(-d, c)].sort((r1, r2) => r1.evaluate() - r2.evaluate());
+        case 1:
+            return [frac(-b, a)];
+        case 2:
+        default:
+            return [opposite(sqrt(a)), sqrt(a)];
+    }
+};
+const getAnswer = (identifiers) => {
+    const roots = getRoots(identifiers).map((r) => r.simplify());
+    return new EquationSolutionNode(new DiscreteSetNode(roots)).toTex();
+};
+const buildFunc = (identifiers) => {
+    const { type, a, b, c, d } = identifiers;
+    switch (type) {
+        case 0: //product
+            return multiply(new Affine(a, b).toTree(), new Affine(c, d).toTree());
+            break;
+        case 1: //quotient
+            return frac(new Affine(a, b).toTree(), new Affine(c, d).toTree());
+            break;
+        case 2: //x^2 -k
+        default:
+            return substract(square("x"), a);
+            break;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { type, a, b, c, d } = identifiers;
+    const myFuncNode = buildFunc(identifiers);
+    return `Déterminer la ou les valeurs d'annulation de la fonction suivante : 
+  
+$$
+f(x)=${myFuncNode.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const type = identifiers.type;
+    if (type === 0) {
+        return `Un produit est nul si et seulement si au moins un des deux facteurs est nul. Cherche les valeurs de $x$ qui annulent chaque facteur.`;
+    }
+    if (type === 1) {
+        return `Un quotient est nul lorsque son numérateur est nul, et son dénominateur non nul. Cherche donc les valeurs de $x$ qui rendent le numérateur nul, mais pas le dénominateur.`;
+    }
+    return `Cherche les solutions de l'équation $x^2 = k$.`;
+};
+const getCorrection = (identifiers) => {
+    const myFunc = buildFunc(identifiers);
+    const tex = myFunc.toTex();
+    const answer = getAnswer(identifiers);
+    const { type, a, b, c, d } = identifiers;
+    if (type === 0) {
+        const polynome1 = new Polynomial([b, a]);
+        const polynome2 = new Polynomial([d, c]);
+        const sol1 = frac(-b, a).simplify();
+        const sol2 = frac(-d, c).simplify();
+        return `Un produit est nul si et seulement si un des deux facteurs est nul. On résout donc deux équations : 
+    
+${alignTex([
+            ["", buildFunc(identifiers).toTex() + "=0"],
+            [
+                "\\iff",
+                `${polynome1.toTree().toTex()} = 0 \\text{ ou } ${polynome2
+                    .toTree()
+                    .toTex()} = 0`,
+            ],
+            ["\\iff", `x=${sol1.toTex()} \\text{ ou } x=${sol2.toTex()}`],
+        ])}
+  
+  Ainsi, $${getAnswer(identifiers)}$`;
+    }
+    if (isFractionNode(myFunc)) {
+        const polynome1 = new Polynomial([b, a]);
+        const polynome2 = new Polynomial([d, c]);
+        const root1 = frac(-b, a).simplify().toTex();
+        const root2 = frac(-d, c).simplify().toTex();
+        const answer = getAnswer(identifiers);
+        return `Un quotient est nul si est seulement si le numérateur est nul et le dénominateur est non nul. Ainsi : 
+  
+${alignTex([
+            ["", buildFunc(identifiers).toTex() + "=0"],
+            ["\\iff", `${polynome1.toTex()}=0 \\text{ et } ${polynome2.toTex()}\\neq 0`],
+            ["\\iff", `x=${root1} \\text{ et } x\\neq ${root2}`],
+        ])}
+
+Il y a donc bien une solution pour cette équation : 
+    
+$$
+${answer}
+$$`;
+    }
+    return `On résout l'équation : 
+  
+${alignTex([
+        ["", buildFunc(identifiers).toTex() + "=0"],
+        ["\\iff", `x^2=${a}`],
+    ])}
+
+Il y a donc deux solutions à cette équaton : 
+
+$$
+${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().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindZeroesProductQuotientQuestion = () => {
+    const type = randint(0, 3);
+    let a = 0;
+    let b = undefined;
+    let c = undefined;
+    let d = undefined;
+    switch (type) {
+        case 0: //product
+            a = randint(-10, 10, [0]);
+            b = randint(-10, 10);
+            do {
+                c = randint(-10, 10, [0]);
+                d = randint(-10, 10, [0]);
+            } while (a / c === b / d);
+            break;
+        case 1: //quotient
+            a = randint(-10, 10, [0]);
+            b = randint(-10, 10);
+            do {
+                c = randint(-10, 10, [0]);
+                d = randint(-10, 10, [0]);
+            } while (a / c === b / d);
+            break;
+        case 2: //x^2 -k
+        default:
+            a = randint(1, 11) ** 2;
+            break;
+    }
+    const identifiers = { type, a, b, c, d };
+    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 findZeroesProductQuotient = {
+    id: "findZeroesProductQuotient",
+    label: "Déterminer la ou les valeur d'annulation d'une fonction par le calcul",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindZeroesProductQuotientQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -12,4 +12,7 @@ export * from "./graphicInequationAffine.js";
 export * from "./signOfFunction.js";
 export * from "./valueTableCompletion.js";
 export * from "./valueTableFromGraph.js";
+export * from "./isPointOnFunction.js";
+export * from "./countFunctionZeroes.js";
+export * from "./findZeroesProductQuotient.js";
 //# 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,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC"}

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

@@ -9,7 +9,9 @@ export * from "./twoFunctionsInequation.js";
 export * from "./inverseImageFunctionTable.js";
 export * from "./imageAntecedentFromSentence.js";
 export * from "./graphicInequationAffine.js";
-// export * from "./valueTableCompletion.js";
 export * from "./signOfFunction.js";
 export * from "./valueTableCompletion.js";
 export * from "./valueTableFromGraph.js";
+export * from "./isPointOnFunction.js";
+export * from "./countFunctionZeroes.js";
+export * from "./findZeroesProductQuotient.js";

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    point: PointIdentifiers;
+    func: NodeIdentifiers;
+};
+export declare const isPointOnFunction: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isPointOnFunction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/isPointOnFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA2HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

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

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { point, func } = identifiers;
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const funcNode = reifyAlgebraic(func);
+    const resolvedValue = funcNode
+        .toDetailedEvaluation({ x: pointObj.x })
+        .simplify();
+    const answer = resolvedValue.equals(pointObj.y) ? "Oui" : "Non";
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { point, func } = identifiers;
+    const pointTex = PointConstructor.fromIdentifiers(point).toTexWithCoords();
+    const funcTex = reifyAlgebraic(func).toTex();
+    return `On considère la fonction $f$ définie par : 
+  
+$$
+f(x) = ${funcTex}
+$$
+
+Le point $${pointTex}$ appartient-il à la courbe représentant la fonction $f$ ?`;
+};
+const getHint = (identifiers) => {
+    const { point, func } = identifiers;
+    const pointTex = PointConstructor.fromIdentifiers(point).toTexWithCoords();
+    const funcTex = reifyAlgebraic(func).toTex();
+    return `Pour vérifier si le point $${pointTex}$ appartient à la courbe de la fonction $f(x) = ${funcTex}$, remplace $x$ par l'abscisse du point dans l'expression de $f(x)$ et compare le résultat avec l'ordonnée du point.`;
+};
+const getCorrection = (identifiers) => {
+    const { point, func } = identifiers;
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const funcNode = reifyAlgebraic(func);
+    const detailedEval = funcNode.toDetailedEvaluation({ x: pointObj.x });
+    const simplifiedEval = detailedEval.simplify();
+    const pointTex = pointObj.toTexWithCoords();
+    const detailedTex = detailedEval.toTex();
+    const simplifiedTex = simplifiedEval.toTex();
+    const xTex = pointObj.x.toTex();
+    const yTex = pointObj.y.toTex();
+    if (getAnswer(identifiers) === "Oui") {
+        return `Pour vérifier si le point $${pointTex}$ appartient à la courbe de la fonction, on remplace $x$ par $${xTex}$ dans l'expression de $f(x)$ :
+
+$$
+${detailedTex} = ${simplifiedTex}
+$$
+
+On a donc bien $f(${xTex})=${yTex}$, donc le point appartient à la courbe.`;
+    }
+    return `Pour vérifier si le point $${pointTex}$ appartient à la courbe de la fonction, on remplace $x$ par $${xTex}$ dans l'expression de $f(x)$ :
+
+$$
+${detailedTex} = ${simplifiedTex}
+$$
+
+Comme $${simplifiedTex} \\neq ${yTex}$, le point n'appartient pas à la courbe.`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIsPointOnFunctionQuestion = (ops) => {
+    const useTrinom = coinFlip();
+    const func = useTrinom
+        ? TrinomConstructor.random()
+        : AffineConstructor.random();
+    const x = randint(1, 6);
+    const isSolution = coinFlip();
+    let y;
+    const correctY = func
+        .toTree()
+        .toDetailedEvaluation({ x: x.toTree() })
+        .evaluate();
+    const wrongY = correctY + randint(-5, 5, [0]);
+    isSolution ? (y = correctY) : (y = wrongY);
+    const point = new Point("A", x, y);
+    return getQuestionFromIdentifiers({
+        point: point.toIdentifiers(),
+        func: func.toTree().toIdentifiers(),
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isPointOnFunction = {
+    id: "isPointOnFunction",
+    label: "Déterminer si un point appartient à la courbe d’une fonction",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsPointOnFunctionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,4 +1,5 @@
 export * from "./cubicEquation.js";
 export * from "./imageOfCubeFunction.js";
 export * from "./compareCubeValues.js";
+export * from "./isPointOnCubicFunction.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC"}

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

@@ -1,3 +1,4 @@
 export * from "./cubicEquation.js";
 export * from "./imageOfCubeFunction.js";
 export * from "./compareCubeValues.js";
+export * from "./isPointOnCubicFunction.js";

package/lib/exercises/math/functions/cube/isPointOnCubicFunction.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    x: NodeIdentifiers;
+    y: NodeIdentifiers;
+};
+export declare const isPointOnCubicFunction: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isPointOnCubicFunction.d.ts.map

package/lib/exercises/math/functions/cube/isPointOnCubicFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnCubicFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/isPointOnCubicFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAiGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/functions/cube/isPointOnCubicFunction.js

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { x, y } = identifiers;
+    const cubicNode = power("x", 3);
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const cubicValue = cubicNode
+        .toDetailedEvaluation({ x: xNode })
+        .simplify({ calculatePowers: true, distributePowersOnFrac: true });
+    const answer = cubicValue.toTex() === yNode.toTex() ? "Oui" : "Non";
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { x, y } = identifiers;
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const point = new Point("A", xNode, yNode);
+    return `Le point $${point.toTexWithCoords()}$ appartient-il à la courbe de la fonction cube ?`;
+};
+const getHint = (identifiers) => {
+    return `Un point de coordonnées $(x;y)$ appartient à la courbe d'une fonction $f$ si et seulement $y = f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { x, y } = identifiers;
+    const cubicNode = power("x", 3);
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const cubicValue = cubicNode.toDetailedEvaluation({ x: xNode });
+    if (getAnswer(identifiers) == "Oui") {
+        return `On a bien $${cubicValue.toTex()} = ${yNode.toTex()}$, donc le point appartient à la courbe de la fonction cube.`;
+    }
+    else {
+        return `Le cube de $${xNode
+            .simplify()
+            .toTex()}$ est $${cubicValue.toTex()} = ${cubicValue
+            .simplify({ calculatePowers: true, distributePowersOnFrac: true })
+            .toTex()} \\neq ${yNode.toTex()}$. 
+      
+Le point n'appartient donc pas à la courbe de la fonction cube.`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans == answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIsPointOnCubicFunctionQuestion = (ops) => {
+    const xNumber = randint(0, 10);
+    const xFrac = RationalConstructor.randomIrreductible().toTree();
+    const xChoices = [xNumber.toTree(), xFrac];
+    const chosenX = random(xChoices);
+    const yNumber = coinFlip()
+        ? power(chosenX, 3)
+            .simplify({ calculatePowers: true, distributePowersOnFrac: true })
+            .toIdentifiers()
+        : randint(0, 10).toTree().toIdentifiers();
+    const identifiers = { x: chosenX.toIdentifiers(), y: yNumber };
+    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 isPointOnCubicFunction = {
+    id: "isPointOnCubicFunction",
+    label: "Déterminer si un point appartient à la courbe de la fonction cube",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsPointOnCubicFunctionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getPropositions,
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/inverse/compareInverseValues.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    isMinusInside: boolean;
+};
+export declare const compareInverseValues: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareInverseValues.d.ts.map

package/lib/exercises/math/functions/inverse/compareInverseValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareInverseValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/inverse/compareInverseValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAuIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}