math-exercises 3.0.78 → 3.0.80

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

@@ -97,7 +97,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const getParityBetweenTwoNumbers = {
     id: "getParityBetweenTwoNumbers",
-    label: "Le nombre de valeurs paires/impaires entre a et b",
+    label: "Déterminer le nombre de valeurs paires/impaires entre $a$ et $b$",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getGetParityBetweenTwoNumbersQuestion(opts), nb),
     qcmTimer: 60,

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

@@ -9,6 +9,7 @@ export * from "./ppcmCalcul.js";
 export * from "./getParityBetweenTwoNumbers.js";
 export * from "./primeNumberIdentification.js";
 export * from "./imageOfSquareFunction.js";
+export * from "./isNumberDecimal.js";
 export * from "./isInequalityTrue.js";
 export * from "./minNumberInequality.js";
 export * from "./squareRootCalculation.js";
@@ -23,4 +24,5 @@ export * from "./compareSquaredValues.js";
 export * from "./calculateWithAbsoluteValue.js";
 export * from "./sqrtInequality.js";
 export * from "./calculateDistanceWithAbsoluteValue.js";
+export * from "./isNumberInInterval.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,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"}
+{"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"}

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

@@ -9,6 +9,7 @@ export * from "./ppcmCalcul.js";
 export * from "./getParityBetweenTwoNumbers.js";
 export * from "./primeNumberIdentification.js";
 export * from "./imageOfSquareFunction.js";
+export * from "./isNumberDecimal.js";
 export * from "./isInequalityTrue.js";
 export * from "./minNumberInequality.js";
 export * from "./squareRootCalculation.js";
@@ -23,3 +24,4 @@ export * from "./compareSquaredValues.js";
 export * from "./calculateWithAbsoluteValue.js";
 export * from "./sqrtInequality.js";
 export * from "./calculateDistanceWithAbsoluteValue.js";
+export * from "./isNumberInInterval.js";

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    options: {
+        a: NodeIdentifiers;
+        isDecimal: boolean;
+    }[];
+};
+export declare const isNumberdecimal: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isNumberDecimal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNumberDecimal.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/isNumberDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QACP,CAAC,EAAE,eAAe,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,EAAE,CAAC;CACL,CAAC;AA8HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}

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

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.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 { isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.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, options }) => {
+    const propositions = [];
+    for (const { a, isDecimal } of options) {
+        const prop = reifyAlgebraic(a).toTex();
+        if (isDecimal) {
+            addValidProp(propositions, prop);
+        }
+        else {
+            tryToAddWrongProp(propositions, prop);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return "";
+};
+const getInstruction = (identifiers) => {
+    return "Parmi ces nombres, lesquels sont décimaux ?";
+};
+const getHint = (identifiers) => {
+    return "Un nombre est décimal s'il a un nombre fini de chiffres après la virgule.";
+};
+const getCorrection = (identifiers) => {
+    const { options } = identifiers;
+    let correction = "";
+    for (const { a, isDecimal } of options) {
+        const node = reifyAlgebraic(a);
+        const tex = node.toTex();
+        if (isFractionNode(node)) {
+            const denom = node.rightChild.toTex();
+            if (isDecimal) {
+                correction += `- $${tex} = ${node
+                    .evaluate()
+                    .frenchify()}$ est un nombre décimal car il s'écrit avec un nombre fini de chiffres après la virgule.\n\n`;
+            }
+            else {
+                correction += `- $${tex} \\approx ${node
+                    .evaluate()
+                    .frenchify()
+                    .slice(0, 8)}\\ldots$ n'est pas un nombre décimal, car il s'écrit avec un nombre infini de chiffres après la virgule.\n\n`;
+            }
+        }
+        else {
+            if (isDecimal) {
+                correction += `- $${tex}$ est un nombre décimal car il a un nombre fini de chiffres après sa virgule.\n\n`;
+            }
+            else {
+                correction += `- $${tex}$ est un nombre décimal car c'est un nombre entier. En effet, on peut écrire $${tex} = ${tex},0$.\n\n`;
+            }
+        }
+    }
+    return correction;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const generateNonDecimalNumber = () => {
+    const nonDecimals = [];
+    nonDecimals.push(randint(0, 100).toTree().toIdentifiers());
+    nonDecimals.push(RationalConstructor.randomPureRational().toTree().toIdentifiers());
+    return random(nonDecimals);
+};
+const generateDecimalNumber = () => {
+    const decimals = [];
+    decimals.push(randfloat(0, 100, 2).toTree().toIdentifiers());
+    decimals.push(new NumberNode(randfloat(0, 100, 2)).toFrac(true).toIdentifiers());
+    return random(decimals);
+};
+const getIsNumberdecimalQuestion = (ops) => {
+    let choices = [];
+    const decimal = generateDecimalNumber();
+    const nonDecimal = generateNonDecimalNumber();
+    choices.push({ a: decimal, isDecimal: true });
+    choices.push({ a: nonDecimal, isDecimal: false });
+    for (let i = 0; i < 2; i++) {
+        const isDecimal = coinFlip();
+        const randomNumber = isDecimal
+            ? generateDecimalNumber()
+            : generateNonDecimalNumber();
+        choices.push({ a: randomNumber, isDecimal });
+    }
+    const identifiers = { options: choices };
+    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 isNumberdecimal = {
+    id: "isNumberDecimal",
+    label: "Dire si un nombre est décimal",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsNumberdecimalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNumberInInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/isNumberInInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAsLF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

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

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.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, "tex");
+    if (answer === "\\in") {
+        tryToAddWrongProp(propositions, "\\notin", "tex");
+    }
+    else {
+        tryToAddWrongProp(propositions, "\\in", "tex");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    if (intervalNode instanceof IntervalNode) {
+        const aValue = aNode.evaluate();
+        const aMin = intervalNode.a.evaluate();
+        const aMax = intervalNode.b.evaluate();
+        const leftClosed = intervalNode.isLeftClosed();
+        const rightClosed = intervalNode.isRightClosed();
+        if ((aValue > aMin || (leftClosed && aValue === aMin)) &&
+            (aValue < aMax || (rightClosed && aValue === aMax))) {
+            return "\\in";
+        }
+    }
+    return "\\notin";
+};
+const getInstruction = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    return `Compléter par le bon symbole : 
+  
+  
+$$
+${aNode.toTex()} \\ \\ldots \\ ${intervalNode.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    return `Pour déterminer si $${aNode.toTex()}$ appartient à l'intervalle $${intervalNode.toTex()}$, il faut vérifier si cette valeur est comprise entre les bornes de l'intervalle.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    const aValue = aNode.evaluate();
+    const aMin = intervalNode.a.evaluate();
+    const aMax = intervalNode.b.evaluate();
+    const leftClosed = intervalNode.isLeftClosed();
+    const rightClosed = intervalNode.isRightClosed();
+    let minCondition, maxCondition;
+    if (leftClosed) {
+        minCondition = aValue >= aMin ? "vérifiée" : "non vérifiée";
+    }
+    else {
+        minCondition = aValue > aMin ? "vérifiée" : "non vérifiée";
+    }
+    if (rightClosed) {
+        maxCondition = aValue <= aMax ? "vérifiée" : "non vérifiée";
+    }
+    else {
+        maxCondition = aValue < aMax ? "vérifiée" : "non vérifiée";
+    }
+    const result = (aValue > aMin || (leftClosed && aValue === aMin)) &&
+        (aValue < aMax || (rightClosed && aValue === aMax));
+    return `Pour que le nombre $${aNode.toTex()}$ appartienne à l'intervalle $${intervalNode.toTex()}$, il faut qu'il soit ${leftClosed ? "supérieur ou égal" : "strictement supérieur"} à $${intervalNode.a.toTex()}$ et ${rightClosed ? "inférieur ou égal" : "strictement inférieur"} à $${intervalNode.b.toTex()}$.
+
+Vérifions ces conditions :
+- $${aNode.toTex()}$ ${leftClosed ? "$\\ge$" : "$>$"} $${intervalNode.a.toTex()}$ : condition ${minCondition}
+- $${aNode.toTex()}$ ${rightClosed ? "$\\le$" : "$<$"} $${intervalNode.b.toTex()}$ : condition ${maxCondition}
+
+${result
+        ? `Les deux conditions sont vérifiées, donc $${aNode.toTex()} \\in ${intervalNode.toTex()}$.`
+        : `Au moins une condition n'est pas vérifiée, donc $${aNode.toTex()} \\notin ${intervalNode.toTex()}$.`}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIsNumberInIntervalQuestion = (ops) => {
+    const lowerBound = coinFlip()
+        ? randint(-10, 10)
+        : round(randfloat(-10, 10, 2), 2);
+    const width = randint(1, 20);
+    const upperBound = round(lowerBound + width, 2);
+    const closures = [
+        ClosureType.FF,
+        ClosureType.FO,
+        ClosureType.OF,
+        ClosureType.OO,
+    ];
+    const closure = random(closures);
+    const isInside = coinFlip();
+    let a;
+    if (isInside) {
+        a = coinFlip()
+            ? randint(Math.ceil(lowerBound), Math.floor(upperBound) - 1)
+            : randfloat(lowerBound, upperBound, 2);
+    }
+    else {
+        if (coinFlip()) {
+            const outisde = [];
+            a = coinFlip()
+                ? randint(-20, Math.floor(lowerBound) - 1)
+                : randfloat(-20, lowerBound - 0.01, 2);
+            outisde.push(a);
+            a = coinFlip()
+                ? randint(Math.ceil(upperBound) + 1, 20)
+                : randfloat(upperBound + 0.01, 20, 2);
+            outisde.push(a);
+            a = random(outisde);
+        }
+        else {
+            a = coinFlip() ? lowerBound : upperBound;
+        }
+    }
+    const interval = new IntervalNode(lowerBound.toTree(), upperBound.toTree(), closure);
+    const identifiers = {
+        a: a.toTree().toIdentifiers(),
+        interval: interval.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 isNumberInInterval = {
+    id: "isNumberInInterval",
+    label: "Appartenance d'un nombre à un intervalle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsNumberInIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -6,6 +6,7 @@ export * from "./fractionsDivision.js";
 export * from "./fractionsProduct.js";
 export * from "./fractionsSum.js";
 export * from "./simplifyFraction.js";
+export * from "./simplifyFractionWithPrimeFactorization.js";
 export * from "./periodicWritingToFraction.js";
 export * from "./fractionsSumsSameDenominators.js";
 export * from "./fractionsSumsMultiplesDenominators.js";

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,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"}

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

@@ -6,6 +6,7 @@ export * from "./fractionsDivision.js";
 export * from "./fractionsProduct.js";
 export * from "./fractionsSum.js";
 export * from "./simplifyFraction.js";
+export * from "./simplifyFractionWithPrimeFactorization.js";
 export * from "./periodicWritingToFraction.js";
 export * from "./fractionsSumsSameDenominators.js";
 export * from "./fractionsSumsMultiplesDenominators.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"simplifyFractionWithPrimeFactorization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/simplifyFractionWithPrimeFactorization.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2GF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAqBxE,CAAC"}

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

@@ -0,0 +1,104 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { num, denum } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { num, denum } = identifiers;
+    return frac(num, denum).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { num, denum } = identifiers;
+    return `On donne la décomposition en produit de facteurs premiers des nombres suivants:
+  
+- $${num} = ${new NumberNode(num).toPrimeDecomposition().toTex()}$
+- $${denum} = ${new NumberNode(denum).toPrimeDecomposition().toTex()}$
+
+Simplifiez la fraction $${frac(num, denum).toTex()}$.
+`;
+};
+const getHint = (identifiers) => {
+    return `Utilise la propriété : 
+  
+$$
+\\frac{k\\times a}{k\\times b} = \\frac{a}{b}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { num, denum } = identifiers;
+    const simpNum = round(num / gcd(num, denum), 3);
+    const simpDenum = round(denum / gcd(num, denum), 3);
+    return `On a : 
+    
+$$
+${frac(num, denum).toTex()} = ${frac(new NumberNode(num).toPrimeDecomposition(), new NumberNode(denum).toPrimeDecomposition()).toTex()}
+$$
+
+On simplifie alors par les facteurs apparaissant à la fois au numérateur et au dénominateur : 
+
+${alignTex([
+        [
+            frac(num, denum).toTex(),
+            "=",
+            frac(new NumberNode(simpNum).toPrimeDecomposition(), new NumberNode(simpDenum).toPrimeDecomposition()).toTex(),
+        ],
+        ["", "=", frac(num, denum).simplify().toTex()],
+    ])}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getSimplifyFractionWithPrimeFactorizationQuestion = (ops) => {
+    let num = 0;
+    let denum = 0;
+    do {
+        num = randint(2, 100);
+        denum = randint(2, 100);
+    } while (isPrime(num) ||
+        isPrime(denum) ||
+        [1, denum].includes(gcd(num, denum)));
+    const identifiers = { num, denum };
+    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 simplifyFractionWithPrimeFactorization = {
+    id: "simplifyFractionWithPrimeFactorization",
+    label: "Simplifier une fraction en utilisant la décomposition en nombres premiers",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSimplifyFractionWithPrimeFactorizationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -12,5 +12,6 @@ export * from "./digitRankNumber.js";
 export * from "./digitDecimalRankNumber.js";
 export * from "./ordering/index.js";
 export * from "./decimals/index.js";
+export * from "./rationals/index.js";
 export * from "./sign/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC"}

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

@@ -13,4 +13,5 @@ export * from "./digitDecimalRankNumber.js";
 export * from "./ordering/index.js";
 export * from "./decimals/index.js";
 // export * from "./writing";
+export * from "./rationals/index.js";
 export * from "./sign/index.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rationals/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./rationalNumbers.js";

package/lib/exercises/math/calcul/rationals/rationalNumbers.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    choices: {
+        node: NodeIdentifiers;
+        irrationalUsed: NodeIdentifiers | null;
+    }[];
+};
+export declare const rationalNumbers: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=rationalNumbers.d.ts.map

package/lib/exercises/math/calcul/rationals/rationalNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rationalNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rationals/rationalNumbers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QACP,IAAI,EAAE,eAAe,CAAC;QAEtB,cAAc,EAAE,eAAe,GAAG,IAAI,CAAC;KACxC,EAAE,CAAC;CACL,CAAC;AA+LF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}