math-exercises 3.0.72 → 3.0.73

package/lib/exercises/math/calculLitteral/inequations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AAEjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/index.js

@@ -3,3 +3,4 @@ export * from "./firstDegreeInequationsType1.js";
 export * from "./firstDegreeInequationsType2.js";
 export * from "./firstDegreeInequationsType3.js";
 export * from "./squareFunctionInequation.js";
+export * from "./inequationsSign.js";

package/lib/exercises/math/calculLitteral/inequations/inequationsSign.d.ts

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

package/lib/exercises/math/calculLitteral/inequations/inequationsSign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inequationsSign.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/inequationsSign.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IAEV,EAAE,EAAE,OAAO,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/inequationsSign.js

@@ -0,0 +1,75 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, ">");
+    tryToAddWrongProp(propositions, "<");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, lt, b } = identifiers;
+    return a < 0 === lt ? ">" : "<";
+};
+const getInstruction = (identifiers) => {
+    const { a, lt, b } = identifiers;
+    const simplifiedFrac = frac(b, a).simplify().toTex();
+    return `Complétez par le bon symbole:
+
+$$
+${a}x ${lt ? "<" : ">"} ${b} \\iff x \\, \\ldots ${simplifiedFrac}
+$$`;
+};
+const getHint = (identifiers) => {
+    const lt = identifiers.lt;
+    return `Si on multiplie (ou divise) les deux membres d'une inéquation par un nombre négatif, le sens de l'inéquation est inversé. Sinon, le sens de l'inéquation ne change pas.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, lt, b } = identifiers;
+    const simplifiedFrac = frac(b, a).simplify().toTex();
+    const invertSign = a < 0;
+    return `Puisque $${a} ${invertSign ? "<" : ">"} 0$, alors 
+  
+$$
+${a}x ${lt ? "<" : ">"} ${b} \\iff x ${invertSign ? (lt ? ">" : "<") : lt ? "<" : ">"} ${simplifiedFrac}
+$$`;
+};
+const getInequationsSignQuestion = (ops) => {
+    const irreductibleFrac = RationalConstructor.randomIrreductible();
+    const a = coinFlip() ? -irreductibleFrac.denum : irreductibleFrac.denum;
+    const b = coinFlip() ? -irreductibleFrac.num : irreductibleFrac.num;
+    const lt = coinFlip();
+    const identifiers = { a, lt, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const inequationsSign = {
+    id: "inequationsSign",
+    answerType: "QCU",
+    label: "Compléter une inégalité par le signe qui convient",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getInequationsSignQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/inequations/inverseInequality.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 inverseInequality: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=inverseInequality.d.ts.map

package/lib/exercises/math/calculLitteral/inequations/inverseInequality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inverseInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/inverseInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAiB9C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC;AAgJF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAcnD,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/inverseInequality.js

@@ -0,0 +1,120 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { InequationSymbol, InequationSymbolConstructor, } from "../../../../math/inequations/inequation.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { InequationSolutionNode } from "../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.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 { UnionIntervalNode } from "../../../../tree/nodes/sets/unionIntervalNode.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, k, inequationSymbol }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswer({ k: -k, inequationSymbol }));
+    tryToAddWrongProp(propositions, getAnswer({
+        k,
+        inequationSymbol: new InequationSymbol(inequationSymbol).reversed(),
+    }));
+    tryToAddWrongProp(propositions, getAnswer({
+        k,
+        inequationSymbol: new InequationSymbol(inequationSymbol).strictnessToggled(),
+    }));
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { k, inequationSymbol } = identifiers;
+    const symbol = new InequationSymbol(inequationSymbol);
+    const isStrict = symbol.isStrict;
+    if (k > 0) {
+        if (symbol.isSup) {
+            // Pour l'inegalite 1/x > k on a en solution [0, 1/k]
+            const interval = new IntervalNode(new NumberNode(0), frac(1, k).simplify(), 
+            // Toujours ferme sur 0
+            // Pour 1/k, ouvert si <, sinon ferme pour <=
+            isStrict ? ClosureType.FO : ClosureType.FF);
+            return new InequationSolutionNode(interval).toTex();
+        }
+        else {
+            // Pour l'inegalite 1/x < k on a en solution ]-inf, 0[ u [1/k, +inf]
+            const intervalNeg = new IntervalNode(MinusInfinityNode, new NumberNode(0), ClosureType.OO);
+            const intervalSup = new IntervalNode(frac(1, k).simplify(), PlusInfinityNode, 
+            // Pour 1/k, ouvert si <, sinon ferme pour <=
+            // Toujours ouvert sur +inf
+            isStrict ? ClosureType.OO : ClosureType.FO);
+            return new InequationSolutionNode(new UnionIntervalNode([intervalNeg, intervalSup])).toTex();
+        }
+    }
+    else {
+        if (symbol.isSup) {
+            // Pour 1/x > k on a en solution ]-inf, 1/k) u ]0, +inf[
+            const intervalNeg = new IntervalNode(MinusInfinityNode, 
+            // Pour 1/k, ouvert si <, sinon ferme pour <=
+            // Toujours ouvert sur +inf
+            frac(1, k).simplify(), isStrict ? ClosureType.OO : ClosureType.OF);
+            const intervalSup = new IntervalNode(new NumberNode(0), PlusInfinityNode, ClosureType.OO);
+            return new InequationSolutionNode(new UnionIntervalNode([intervalNeg, intervalSup])).toTex();
+        }
+        else {
+            // Pour 1/x < k on a en solution (1/k, 0[
+            const interval = new IntervalNode(frac(1, k).simplify(), new NumberNode(0), 
+            // Pour 1/k, ouvert si <, sinon ferme pour <=
+            // Toujours ouvert sur 0
+            isStrict ? ClosureType.OO : ClosureType.FO);
+            return new InequationSolutionNode(interval).toTex();
+        }
+    }
+};
+const getInstruction = (identifiers) => {
+    const { k, inequationSymbol } = identifiers;
+    return `Résoudre $${frac(1, "x").toTex()} ${inequationSymbol} ${k}$.`;
+};
+const getKeys = (identifiers) => {
+    return ["S", "equal", "lbracket", "rbracket", "semicolon", "infty", "cup"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return "S=\\ " + parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getInverseInequalityQuestion = (ops) => {
+    const k = randint(-40, 40, [0]);
+    const inequationSymbol = InequationSymbolConstructor.random();
+    const identifiers = {
+        k,
+        inequationSymbol: inequationSymbol.symbol,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+};
+export const inverseInequality = {
+    id: "inverseInequality",
+    label: "Résoudre $\\frac{1}{x} < k$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getInverseInequalityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/calculLitteral/simplifying/distributeAndSimplify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distributeAndSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/distributeAndSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"distributeAndSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/distributeAndSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/distributeAndSimplify.js

@@ -2,7 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { polynomialParser } from "../../../../tree/parsers/polynomialParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
@@ -16,6 +16,45 @@ const getStatementNode = (identifiers) => {
         : a.toTree(), new MultiplyNode(e.toTree(), new Affine(f, g).toTree()));
     return statement;
 };
+const getHint = (identifiers) => {
+    const { firstTermIsAffine } = identifiers;
+    return `Commence par développer  ${firstTermIsAffine ? "les produits" : "le produit"} en utilisant la distributivité. Puis, additionne les termes en $x$ entre eux, et les termes sans $x$ entre eux.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstTermIsAffine, a, b, c, d, e, f, g } = identifiers;
+    const first = firstTermIsAffine
+        ? new MultiplyNode(b.toTree(), new Affine(c, d).toTree())
+        : a.toTree();
+    const firstSimp = first.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const second = new MultiplyNode(e.toTree(), new Affine(f, g).toTree());
+    const secondSimp = second.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    return `On commence par développer ${firstTermIsAffine ? "les produits" : "le produit"} en utilisant la distributivité :
+
+${firstTermIsAffine
+        ? `
+$$
+${first.toTex()} = ${firstSimp.toTex()}
+$$
+`
+        : ""}
+$$
+${second.toTex()} = ${secondSimp.toTex()}
+$$
+
+On réduit ensuite l'expression : 
+
+$$
+${add(firstSimp, secondSimp).toTex()} = ${getAnswer(identifiers)}
+$$
+
+`;
+};
 const getInstruction = (identifiers) => {
     return `Développer et réduire : 
   
@@ -52,6 +91,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -88,4 +129,5 @@ export const distributeAndSimplify = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/curve/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./squareCurvePoint.js";
+export * from "./sqrtCurvePoint.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/curve/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/curve/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/curve/index.js

@@ -0,0 +1,2 @@
+export * from "./squareCurvePoint.js";
+export * from "./sqrtCurvePoint.js";

package/lib/exercises/math/curve/sqrtCurvePoint.d.ts

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

package/lib/exercises/math/curve/sqrtCurvePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtCurvePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/curve/sqrtCurvePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAatC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAuHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}

package/lib/exercises/math/curve/sqrtCurvePoint.js

@@ -0,0 +1,132 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../math/geometry/point.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { sqrt } from "../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const isPointOnCurve = (identifiers) => {
+    const { point } = identifiers;
+    const x = reifyAlgebraic(point.x);
+    const y = reifyAlgebraic(point.y);
+    // Point sur la courbe -> f(x) - y = 0
+    if (substract(sqrt(x), y).simplify().equals(new NumberNode(0))) {
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+const getAnswer = (identifiers) => {
+    if (isPointOnCurve(identifiers)) {
+        return "Oui";
+    }
+    else {
+        return "Non";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { point } = identifiers;
+    return `Le point $${PointConstructor.fromIdentifiers(point).toTexWithCoords()}$ appartient-il à la courbe de la fonction racine carré ?`;
+};
+const getHint = (identifiers) => {
+    return "Un point $A(x; y)$ appartient à la courbe de la fonction $f$ si et seulement si $f(x) = y$.";
+};
+const getCorrection = (identifiers) => {
+    const { point: pointId } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointId);
+    const x = point.x;
+    const y = point.y;
+    const isValidPoint = isPointOnCurve(identifiers);
+    const conclusion = isValidPoint
+        ? "Le point est donc sur la courbe."
+        : "Le point n'est donc pas sur la courbe.";
+    return `$${point.toTexWithCoords()}$ appartient à la courbe de la fonction racine carré si et seulement si :
+  
+${alignTex(sqrt(x).simplify().toTex() != sqrt(x).toTex()
+        ? [
+            ["", `f\\left(${x.toTex()}\\right)`, "=", `${y.toTex()}`],
+            ["\\iff", `${sqrt(x).toTex()}`, "=", `${y.toTex()}`],
+            ["\\iff", `${sqrt(x).simplify().toTex()}`, "=", `${y.toTex()}`],
+        ]
+        : [
+            ["", `f\\left(${x.toTex()}\\right)`, "=", `${y.toTex()}`],
+            ["\\iff", `${sqrt(x).toTex()}`, "=", `${y.toTex()}`],
+        ])}
+
+${conclusion}`;
+};
+const getSqrtCurvePointQuestion = (ops) => {
+    let x = null;
+    switch (randint(1, 3)) {
+        case 1:
+            x = new NumberNode(randint(1, 10));
+            break;
+        case 2:
+        default:
+            x = RationalConstructor.randomIrreductible(10).toTree();
+            break;
+    }
+    // 50% de chance que le point (x, y) soit sur la courbe
+    // Sinon il est proche de sqrt(x)
+    const bound = Math.floor(sqrt(x).evaluate());
+    let y = null;
+    if (coinFlip()) {
+        y = sqrt(x).simplify();
+    }
+    else {
+        switch (randint(1, 3)) {
+            case 1:
+                y = new NumberNode(randint(bound - 2, bound + 2));
+                break;
+            case 2:
+            default:
+                y = RationalConstructor.randomIrreductible(bound + 2).toTree();
+                break;
+        }
+    }
+    const point = new Point("A", x, y).toIdentifiers();
+    const identifiers = {
+        point,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const sqrtCurvePoint = {
+    id: "sqrtCurvePoint",
+    label: "Déterminer si un point appartient à la courbe de la fonction racine carré",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSqrtCurvePointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/curve/squareCurvePoint.d.ts

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

package/lib/exercises/math/curve/squareCurvePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareCurvePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/curve/squareCurvePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AActC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAyHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}

package/lib/exercises/math/curve/squareCurvePoint.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 { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { SquareRootConstructor } from "../../../math/numbers/reals/real.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
+import { square } from "../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const isPointOnCurve = (identifiers) => {
+    const { point } = identifiers;
+    const x = reifyAlgebraic(point.x);
+    const y = reifyAlgebraic(point.y);
+    // Point sur la courbe -> f(x) - y = 0
+    if (substract(square(x), y).simplify().equals(new NumberNode(0))) {
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+const getAnswer = (identifiers) => {
+    if (isPointOnCurve(identifiers)) {
+        return "Oui";
+    }
+    else {
+        return "Non";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { point } = identifiers;
+    return `Le point $${PointConstructor.fromIdentifiers(point).toTexWithCoords()}$ appartient-il à la courbe de la fonction carré ?`;
+};
+const getHint = (identifiers) => {
+    return "Un point $A(x; y)$ appartient à la courbe de la fonction $f$ si et seulement si $f(x) = y$.";
+};
+const getCorrection = (identifiers) => {
+    const { point: pointId } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointId);
+    const isValidPoint = isPointOnCurve(identifiers);
+    const conclusion = isValidPoint
+        ? "Le point est donc sur la courbe."
+        : "Le point n'est donc pas sur la courbe.";
+    return `$${point.toTexWithCoords()}$ appartient à la courbe de la fonction carré si et seulement si :
+  
+${alignTex([
+        ["", `f(${point.x.toTex()})`, "=", `${point.y.toTex()}`],
+        ["\\iff", `${square(point.x).toTex()}`, "=", `${point.y.toTex()}`],
+        ["\\iff", `${square(point.x).simplify().toTex()}`, "=", `${point.y.toTex()}`],
+    ])}
+
+${conclusion}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const getSquareCurvePointQuestion = (ops) => {
+    let x = null;
+    switch (randint(1, 4)) {
+        case 1:
+            x = new NumberNode(randint(-5, 5));
+            break;
+        case 2:
+            x = RationalConstructor.randomIrreductible().toTree();
+            break;
+        case 3:
+        default:
+            x = SquareRootConstructor.randomIrreductible(25).toTree();
+            break;
+    }
+    let y = null;
+    // 50% de chance que le point (x, y) soit sur la courbe
+    if (coinFlip()) {
+        y = square(x).simplify();
+    }
+    else {
+        switch (randint(1, 4)) {
+            case 1:
+                y = new NumberNode(randint(-5, 5));
+                break;
+            case 2:
+                y = RationalConstructor.randomIrreductible().toTree();
+                break;
+            case 3:
+            default:
+                y = SquareRootConstructor.randomIrreductible(25).toTree();
+                break;
+        }
+    }
+    const point = new Point("A", x, y).toIdentifiers();
+    const identifiers = {
+        point,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const squareCurvePoint = {
+    id: "squareCurvePoint",
+    label: "Déterminer si un point appartient à la courbe de la fonction carré",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSquareCurvePointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,4 +2,6 @@ export * from "./absoluteValueEquations.js";
 export * from "./absoluteValueInequations.js";
 export * from "./absolueValueAffineEquation.js";
 export * from "./absolueValueInequationsSup.js";
+export * from "./removeAbsNotation.js";
+export * from "./removeAbsNotationSign.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC"}

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

@@ -2,3 +2,5 @@ export * from "./absoluteValueEquations.js";
 export * from "./absoluteValueInequations.js";
 export * from "./absolueValueAffineEquation.js";
 export * from "./absolueValueInequationsSup.js";
+export * from "./removeAbsNotation.js";
+export * from "./removeAbsNotationSign.js";

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isSup: boolean;
+    n: number;
+};
+export declare const removeAbsNotation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=removeAbsNotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"removeAbsNotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/removeAbsNotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}