math-exercises 3.0.83 → 3.0.85

package/lib/exercises/math/calcul/arithmetics/decimalBoundingOnLine.d.ts

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

package/lib/exercises/math/calcul/arithmetics/decimalBoundingOnLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimalBoundingOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/decimalBoundingOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAUtC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAkMF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAmBvD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/decimalBoundingOnLine.js

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getPropositions = (n, context) => {
+    const { answer, point, bounding } = context;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const x = round(pointObj.x.evaluate(), 2);
+    const vNode = new VariableNode(pointObj.name.toLocaleLowerCase());
+    const correctLower = round(Math.floor(x / bounding) * bounding, 2);
+    const correctUpper = round(correctLower + bounding, 2);
+    while (propositions.length < n) {
+        let wrongLower = round(correctLower + randfloat(-2, 2, 1), 1);
+        let wrongUpper = round(correctUpper + randfloat(-2, 2, 1), 1);
+        const node = new InequationNode([wrongLower.toTree(), vNode, wrongUpper.toTree()], ["<", "<"]);
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ point, bounding }) => {
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const x = round(pointObj.x.evaluate(), 2);
+    const lowerBound = round(Math.floor(x / bounding) * bounding, 2);
+    const upperBound = round(lowerBound + bounding, 2);
+    const vNode = new VariableNode(pointObj.name.toLocaleLowerCase());
+    const inequation = new InequationNode([lowerBound.toTree(), vNode, upperBound.toTree()], ["<", "<"]);
+    return `${inequation.toTex()}`;
+};
+const getInstruction = ({ point, bounding }) => {
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    return `Déterminer un encadrement décimal d'amplitude $${bounding.frenchify()}$ du nombre réel $${pointObj.name.toLocaleLowerCase()}$.
+  
+Donner une réponse sous la forme : $x < a < y$.`;
+};
+const getHint = ({ point }) => {
+    return `Pour encadrer le nombre, repère les deux nombres décimaux consécutifs de part et d'autre du nombre $${point.name.toLocaleLowerCase()}$. Cela donne un encadrement sous la forme $x<a<y$.
+  
+Par exemple, un encadrement à $10^{-1}$ de $14,25$ est : 
+
+$$
+14,2 < 14,25 < 14,3
+$$`;
+};
+const getCorrection = ({ point, bounding }) => {
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const x = round(pointObj.x.evaluate(), 2);
+    const firstDiv = round(x / bounding, 2);
+    const quotient = Math.floor(x / bounding);
+    const lowerBound = round(quotient * bounding, 2);
+    const upperBound = round(lowerBound + bounding, 2);
+    const inequation = getAnswer({ point, bounding });
+    const name = pointObj.name.toLocaleLowerCase();
+    return `On lit sur la droite que $${name} > ${lowerBound.frenchify()}$ et $${name} < ${upperBound.frenchify()}$. 
+  
+Ainsi, un encadrement à $${bounding.frenchify()}$ de $${name}$ est : 
+
+$$
+${inequation}
+$$`;
+};
+const getGGBOptions = ({ point, bounding }) => {
+    const A = PointConstructor.fromIdentifiers(point);
+    const commands = [
+        ...A.toGGBCommand({
+            style: 3,
+            size: 4,
+            label: "a",
+        }),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: true,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 0.1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: [A.x.evaluate() - 2.2, A.x.evaluate() + 2.2, -0.2, 0.2],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["inf", "a"];
+};
+function parseInequationFromUser(input) {
+    const clean = input.replace(/\\text\{([A-Za-z])\}/g, "$1").replace(/\s/g, "");
+    const match = clean.match(/^([-\d,]+)(<|\\leq)([A-Za-z])(<|\\leq)([-\d,]+)$/);
+    if (!match)
+        return null;
+    const [, lowerStr, sym1, variableRaw, sym2, upperStr] = match;
+    const symbolMap = {
+        "<": "<",
+        "\\le": "\\le",
+    };
+    const variable = variableRaw.toUpperCase();
+    return {
+        lower: lowerStr.unfrenchify(),
+        upper: upperStr.unfrenchify(),
+        variable,
+        symbols: [symbolMap[sym1], symbolMap[sym2]],
+    };
+}
+function constructInequationNodeFromParsed(parsed) {
+    const lowerNode = parsed.lower.toTree();
+    const upperNode = parsed.upper.toTree();
+    const variableNode = new VariableNode(parsed.variable);
+    return new InequationNode([lowerNode, variableNode, upperNode], parsed.symbols);
+}
+const isAnswerValid = (ans, { point, bounding, answer }) => {
+    // const parsed = parseInequationFromUser(ans);
+    // if (!parsed) return false;
+    // const userNode = constructInequationNodeFromParsed(parsed);
+    // return userNode.toTex() === answer;
+    return ans === answer;
+};
+const getDecimalBoundingOnLineQuestion = () => {
+    const x = doWhile(() => randfloat(-5, 5, 7), (a) => Math.abs(round(a, 1) - a) < 0.025);
+    const point = new Point("A", x, 0);
+    // const bounding = randfloat(0.1, 0.4, 1);
+    const bounding = 0.1;
+    const pointIdentifier = point.toIdentifiers();
+    const identifiers = {
+        point: pointIdentifier,
+        bounding,
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const decimalBoundingOnLine = {
+    id: "decimalBoundingOnLine",
+    label: "Donner un encadrement d’un nombre placé sur une droite graduée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getDecimalBoundingOnLineQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/arithmetics/evalFractionExpression.d.ts

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

package/lib/exercises/math/calcul/arithmetics/evalFractionExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evalFractionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/evalFractionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/evalFractionExpression.js

@@ -0,0 +1,112 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.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 newFrac = RationalConstructor.randomIrreductible().toTree().toTex();
+        const a = randint(-10, 11).frenchify();
+        const newValue = coinFlip() ? newFrac : a;
+        tryToAddWrongProp(propositions, newValue);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { expr, x } = identifiers;
+    const exprNode = reifyAlgebraic(expr);
+    const fractionTex = exprNode
+        .toDetailedEvaluation({ x: x.toTree() })
+        .simplify()
+        .toTex();
+    return fractionTex;
+};
+const getInstruction = (identifiers) => {
+    const { expr, x } = identifiers;
+    const exprTex = reifyAlgebraic(expr).toTex();
+    return `On note : 
+  
+$$
+A = ${exprTex}
+$$ 
+
+Calculer, si possible, la valeur de $A$ pour $x = ${x}$.`;
+};
+const getHint = (identifiers) => {
+    return `Remplace $x$ par $${identifiers.x}$ dans l'expression, puis simplifie.`;
+};
+const getCorrection = ({ expr, x }) => {
+    const exprNode = reifyAlgebraic(expr);
+    const replaced = exprNode.toDetailedEvaluation({ x: x.toTree() });
+    const simplified = replaced.simplify();
+    const exprTex = exprNode.toTex();
+    const replacedTex = replaced.toTex();
+    const simplifiedTex = simplified.toTex();
+    return `On peut bien calculer la valeur de $A$ pour $x = ${x}$, car le dénominateur ne s'annule pas en remplaçant $x$ par $${x}$. 
+  
+On remplace donc $x$ par $${x}$ dans l'expression :
+
+${alignTex([
+        [exprTex, "=", replacedTex],
+        ["", "=", simplifiedTex],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getEvalFractionExpressionQuestion = (ops) => {
+    const nominator = AffineConstructor.random().toTree();
+    const denominator = AffineConstructor.random().toTree();
+    const expr = frac(nominator, denominator);
+    const x = doWhile(() => randint(-10, 11), (a) => denominator.evaluate({ x: a }) === 0);
+    const identifiers = { expr: expr.toIdentifiers(), x };
+    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 evalFractionExpression = {
+    id: "evalFractionExpression",
+    label: "Calculer une expression fractionnaire pour une valeur de x donnée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEvalFractionExpressionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/arithmetics/index.d.ts

@@ -25,4 +25,7 @@ export * from "./calculateWithAbsoluteValue.js";
 export * from "./sqrtInequality.js";
 export * from "./calculateDistanceWithAbsoluteValue.js";
 export * from "./isNumberInInterval.js";
+export * from "./evalFractionExpression.js";
+export * from "./simplifyToFraction.js";
+export * from "./decimalBoundingOnLine.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/arithmetics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,yCAAyC,CAAC;AACxD,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,yCAAyC,CAAC;AACxD,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC"}

package/lib/exercises/math/calcul/arithmetics/index.js

@@ -25,3 +25,6 @@ export * from "./calculateWithAbsoluteValue.js";
 export * from "./sqrtInequality.js";
 export * from "./calculateDistanceWithAbsoluteValue.js";
 export * from "./isNumberInInterval.js";
+export * from "./evalFractionExpression.js";
+export * from "./simplifyToFraction.js";
+export * from "./decimalBoundingOnLine.js";

package/lib/exercises/math/calcul/arithmetics/simplifyToFraction.d.ts

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

package/lib/exercises/math/calcul/arithmetics/simplifyToFraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplifyToFraction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/simplifyToFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAoB7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAqKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/simplifyToFraction.js

@@ -0,0 +1,168 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.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 a = randint(-10, 11, [0]);
+        const b = randint(-10, 11, [0]);
+        const powerExpr = power("x", randint(2, 5));
+        const expressions = [
+            add(a, frac(b, "x")),
+            multiply(frac(a, powerExpr), frac(b, powerExpr)),
+            multiply(frac(powerExpr, a), frac(powerExpr, b)),
+        ];
+        const chosenExpr = random(expressions).simplify({
+            calculatePowers: true,
+            keepPowers: true,
+        });
+        tryToAddWrongProp(propositions, chosenExpr.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { expr } = identifiers;
+    const exprNode = reifyAlgebraic(expr);
+    const simplified = exprNode.simplify({ forbidFactorize: true });
+    return `${simplified.toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const { expr } = identifiers;
+    const exprNode = reifyAlgebraic(expr);
+    return `Écrire l'expression suivante sous forme d'une fraction :
+  
+$$
+${exprNode.toTex()}
+$$`;
+};
+const getHint = ({ expr }) => {
+    const exprNode = reifyAlgebraic(expr);
+    if (isAddNode(exprNode)) {
+        return `Écris le nombre entier sous la forme d'un fraction, en le mettant au même dénominateur que la fraction. Puis, additionne les deux fractions obtenues.`;
+    }
+    return `Multiplie les deux fractions entre elles (en multipliant les numérateurs entre eux et les dénominateurs entre eux). Puis, simplifie la fraction obtenue.`;
+};
+const getCorrection = ({ expr }) => {
+    const exprNode = reifyAlgebraic(expr);
+    const simplified = exprNode.simplify({ forbidFactorize: true });
+    let explanation = ``;
+    if (isAddNode(exprNode)) {
+        const entier = exprNode.leftChild;
+        const fraction = exprNode.rightChild;
+        explanation += `On met les deux termes au même dénominateur pour les additionner :
+
+${alignTex([
+            [
+                exprNode.toTex(),
+                "=",
+                add(frac(multiply(entier, fraction.rightChild), fraction.rightChild), fraction).toTex(),
+            ],
+            ["", "=", simplified.toTex()],
+        ])}`;
+    }
+    else if (isMultiplyNode(exprNode)) {
+        const frac1 = exprNode.leftChild;
+        const frac2 = exprNode.rightChild;
+        explanation += `
+On multiplie les fractions, puis on simplifie :
+
+${alignTex([
+            [
+                exprNode.toTex(),
+                "=",
+                frac(multiply(frac1.leftChild, frac2.leftChild), multiply(frac1.rightChild, frac2.rightChild)).toTex(),
+            ],
+            ["", "=", simplified.toTex()],
+        ])}`;
+    }
+    else {
+        const num = exprNode.leftChild;
+        const denum = exprNode.rightChild;
+        explanation += `Diviser par une fraction revient à multiplier par son inverse. On a donc : 
+
+${alignTex([
+            [exprNode.toTex(), "=", multiply(num, denum.toInversed()).toTex()],
+            ["", "=", simplified.toTex()],
+        ])}`;
+    }
+    return explanation;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        return ansNode.simplify({ forbidFactorize: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSimplifyToFractionQuestion = (ops) => {
+    const type = randint(1, 4);
+    const a = randint(-10, 11, [-1, 0, 1]);
+    const b = randint(-10, 11, [-1, 0, 1]);
+    const powerA = randint(1, 5);
+    const powerB = randint(1, 5, type === 3 ? [powerA] : []);
+    const powerANode = powerA === 1 ? new VariableNode("x") : power("x", powerA);
+    const powerBNode = powerB === 1 ? new VariableNode("x") : power("x", powerB);
+    let expr;
+    let order = [];
+    switch (type) {
+        case 1:
+            expr = add(a, frac(b, "x")).toIdentifiers();
+            break;
+        case 2:
+            order = shuffle([a.toTree(), b.toTree(), powerANode, powerBNode]);
+            expr = multiply(frac(order[0], order[1]), frac(order[2], order[3])).toIdentifiers();
+            break;
+        case 3:
+        default:
+            order = shuffle([a.toTree(), powerANode, powerBNode]);
+            expr = frac(order[0], frac(order[1], order[2])).toIdentifiers();
+            break;
+    }
+    const identifiers = { type, expr };
+    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 simplifyToFraction = {
+    id: "simplifyToFraction",
+    label: "Écrire sous la forme d'une expression fractionnaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSimplifyToFractionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/fractions/fractionForbiddenValue.d.ts

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

package/lib/exercises/math/calcul/fractions/fractionForbiddenValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fractionForbiddenValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionForbiddenValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionForbiddenValue.js

@@ -0,0 +1,100 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equationResolutionTex } from "../../../../tree/nodes/equations/equalNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const affine1 = new Affine(a, b);
+    const affine2 = new Affine(c, d);
+    const fct = new FractionNode(affine1.toTree(), affine2.toTree());
+    const fctTex = fct.toTex();
+    return `On note : 
+  
+$$
+A = ${fctTex}
+$$ 
+  
+Pour quelle valeur de $x$ ne peut-on pas calculer $A$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const answerTree = new Rational(-d, c).simplify().toTree();
+    const answer = answerTree.toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Il est interdit de diviser par $0$. Cherche donc la valeur de $x$ pour laquelle le dénominateur de $A$ vaut $0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const equa = equationResolutionTex(c.toTree(), d.toTree(), (0).toTree(), (0).toTree());
+    return `On cherche la valeur de $x$ qui rend le dénominateur de $A$ nul. 
+  
+On résout donc l'équation : 
+
+$$
+${equa}
+$$
+
+On ne peut donc pas calculer $A$ pour $x = ${getAnswer(identifiers)}$.
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getRationalFractionForbiddenValueQuestion = () => {
+    const a = randint(-10, 11, [0]);
+    const b = randint(-10, 11);
+    //pour éviter affine2 = k*affine1
+    let c, d;
+    do {
+        c = randint(-10, 11, [0]);
+        d = randint(-10, 11);
+    } while (a * d - b * c === 0);
+    const identifiers = { a, b, c, d };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, a, b, c, d }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new Rational(-b, a).simplify().toTree().toTex());
+    tryToAddWrongProp(propositions, d + "");
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-10, 11) + "");
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { c, d }) => {
+    const answerTree = new Rational(-d, c)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const fractionForbiddenValue = {
+    id: "fractionForbiddenValue",
+    connector: "=",
+    label: "Déterminer la valeur interdite d'une fraction",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRationalFractionForbiddenValueQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/fractions/index.d.ts

@@ -15,4 +15,5 @@ export * from "./fractionsOperations.js";
 export * from "./fractionSquare.js";
 export * from "./fractionsSubstraction.js";
 export * from "./powerNotation.js";
+export * from "./fractionForbiddenValue.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/fractions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/calcul/fractions/index.js

@@ -15,3 +15,4 @@ export * from "./fractionsOperations.js";
 export * from "./fractionSquare.js";
 export * from "./fractionsSubstraction.js";
 export * from "./powerNotation.js";
+export * from "./fractionForbiddenValue.js";

package/lib/exercises/math/calcul/ordering/framing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"framing.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/framing.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,GAAG,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA2KF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}
+{"version":3,"file":"framing.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/framing.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,GAAG,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA+NF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAczC,CAAC"}