math-exercises 3.0.134 → 3.0.136

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"coprime.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/coprime.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAWT,MAAM,sBAAsB,CAAC;AAQ9B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4GF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAezC,CAAC"}

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

@@ -0,0 +1,113 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { addValidProp, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
+import { primeDecomposition } from "../../../../math/utils/arithmetic/primeDecomposition.js";
+import { isCoprime } from "../../../../math/utils/arithmetic/isCoprime.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+import { primeDecompNode } from "../../../../math/utils/arithmetic/primeDecompNode.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Les nombres $${a}$ et $${b}$ sont-ils premiers entre eux ?`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    return ["Oui", "Non"][isCoprime(a, b) ? 0 : 1];
+};
+const getHint = () => {
+    return `On dit que deux nombres sont premiers entre eux lorsqu'ils n'ont qu'un seul diviseur commun (le nombre $1$).`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const [isPrimeA, isPrimeB] = [a, b].map((n) => isPrime(n));
+    if (isPrimeA && isPrimeB) {
+        return `$${a.frenchify()}$ est un nombre premier.
+$${b.frenchify()}$ est un nombre premier. 
+Les nombres $${a.frenchify()}$ et $${b.frenchify()}$ n'ont que $1$ comme diviseur commun.
+Autrement dit, ils sont premiers entre eux.`;
+    }
+    else {
+        const [dictDecompA, dictDecompB] = [a, b].map((n) => {
+            const arrDecomp = primeDecomposition(n);
+            const dictDecomp = Object.fromEntries(arrDecomp.map(({ value, power }) => [value, power]));
+            return dictDecomp;
+        });
+        const commonPrimeFactors = Object.keys(dictDecompA)
+            .filter((value) => dictDecompB[value] !== undefined)
+            .map((str) => +str);
+        return `
+Avant tout chose, on peut déjà dire que $${a.frenchify()}$ et $${b.frenchify()}$ ont $1$ comme un diviseur commun.
+
+Voici les décompositions en facteurs premiers de $${a.frenchify()}$ et $${b.frenchify()}$ :
+
+$$
+${a.frenchify()} = ${primeDecompNode(a).toTex()}
+$$
+
+$$
+${b.frenchify()} = ${primeDecompNode(b).toTex()}
+$$
+
+${(() => {
+            if (commonPrimeFactors.length === 0) {
+                return `
+Les nombres $${a.frenchify()}$ et $${b.frenchify()}$ n'admettent aucun facteur premier commun.
+Leur seul diviseur commun est $1$. 
+Ils sont premiers entre eux.`;
+            }
+            else {
+                return `
+Les nombres $${a.frenchify()}$ et $${b.frenchify()}$ admettent ${joinanded(commonPrimeFactors.map((v) => `$${v}$`), ", ", " et ")} comme ${commonPrimeFactors.length > 1
+                    ? "facteurs premiers communs"
+                    : "facteur premier commun"}. 
+Ils admettent donc au moins deux diviseurs communs : $1$ et $${commonPrimeFactors[0].frenchify()}$.
+Ils ne sont pas premiers entre eux.`;
+            }
+        })()}`;
+    }
+};
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const getCoprimeQuestion = () => {
+    const a = randint(2, 100);
+    const b = randint(2, 100, [a]);
+    const identifiers = { a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coprime = {
+    id: "coprime",
+    connector: "=",
+    label: "Déterminer si deux nombres sont premiers entre eux",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCoprimeQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -10,4 +10,5 @@ export * from "./getParityBetweenTwoNumbers.js";
 export * from "./primeNumberIdentification.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
+export * from "./coprime.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,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,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,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC"}

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

@@ -10,3 +10,4 @@ export * from "./getParityBetweenTwoNumbers.js";
 export * from "./primeNumberIdentification.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
+export * from "./coprime.js";

package/lib/exercises/math/calcul/decimals/decimalFractionToDecimal.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isFractionToDigital: boolean;
+    nb: number;
+};
+type Options = {
+    conversionType: string;
+};
+export declare const decimalFractionToDecimal: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=decimalFractionToDecimal.d.ts.map

package/lib/exercises/math/calcul/decimals/decimalFractionToDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimalFractionToDecimal.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/decimalFractionToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkQF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA4BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBnE,CAAC"}

package/lib/exercises/math/calcul/decimals/decimalFractionToDecimal.js

@@ -0,0 +1,243 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Decimal } from "../../../../math/numbers/decimals/decimal.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getAnswer = ({ nb, isFractionToDigital }) => {
+    const dec = new Decimal(nb);
+    const digitalTex = dec.toTree().toTex();
+    const fractionNode = dec.toRational(false).toTree();
+    return isFractionToDigital ? digitalTex : fractionNode.toTex();
+};
+const getInstruction = ({ isFractionToDigital, nb, }) => {
+    const dec = new Decimal(nb);
+    const digitalTex = dec.toTree().toTex();
+    const fractionTex = dec.toRational(false).toTree().toTex();
+    return `Écrire le nombre suivant ${isFractionToDigital
+        ? "sous forme de nombre à virgule"
+        : "sous forme de fraction décimale"} : 
+  
+$$
+${isFractionToDigital ? fractionTex : digitalTex}
+$$`;
+};
+const getHint = ({ isFractionToDigital }) => {
+    return `${isFractionToDigital
+        ? `Rappelle-toi que $\\frac{1}{100}$, c'est un centième, donc $0,01$.`
+        : `Rappelle-toi que $0,01$, c'est un centième, donc $1$ sur $100$, autrement dit $${new Decimal(0.01)
+            .toRational(false)
+            .toTree()
+            .toTex()}$.`}`;
+};
+const getCorrection = ({ isFractionToDigital, nb, }) => {
+    const dec = new Decimal(nb);
+    const digitalTex = dec.toTree().toTex();
+    const fractionNode = dec.toRational(false).toTree();
+    const numNodeSrc = fractionNode.leftChild;
+    const denNodeSrc = fractionNode.rightChild;
+    const log10OfDen = Math.log10(denNodeSrc.evaluate());
+    const arrFractionNodes = [...Array(log10OfDen).keys()].map((i) => {
+        const numNode = frac(numNodeSrc, power(10, i)).evaluate().toTree();
+        const denNode = operatorComposition(MultiplyNode, [...Array(log10OfDen - i).keys()].map(() => (10).toTree()));
+        return frac(numNode, denNode.evaluate());
+    });
+    const arrFractionNodesReversed = arrFractionNodes.toReversed();
+    return isFractionToDigital
+        ? `Quand on divise un nombre par $10$, cela revient à décaler tous les chiffres de son écriture décimale d'un rang vers la droite. 
+
+${(() => {
+            const fractionNodeExpanded = frac(numNodeSrc, operatorComposition(MultiplyNode, [...Array(log10OfDen).keys()].map(() => (10).toTree())));
+            const texFractionNode = fractionNode.toTex();
+            const texFractionNodeExpanded = fractionNodeExpanded.toTex();
+            if (texFractionNode !== texFractionNodeExpanded) {
+                return `Ici, on a :
+
+$$
+${texFractionNode} = ${texFractionNodeExpanded}
+$$`;
+            }
+            else {
+                return "";
+            }
+        })()}
+
+On divise ${log10OfDen > 1 ? "donc" : ""} $${log10OfDen}$ fois par $10$, donc on décale $${log10OfDen}$ fois les chiffres d'un rang vers la droite.
+
+$$
+${alignTex(arrFractionNodes.length > 1
+            ? [
+                [arrFractionNodes[0].toTex(), "=", arrFractionNodes[1].toTex()],
+                ...arrFractionNodes.slice(2).map((node) => ["", "=", node.toTex()]),
+                ["", "=", digitalTex],
+            ]
+            : [[arrFractionNodes[0].toTex(), "=", digitalTex]], true)}
+$$
+
+`
+        : `Pour écrire un nombre à virgule sous la forme d'une fraction décimale, 
+on a envie de décaler ses chiffres un certain nombre de fois vers la gauche, 
+ce qui revient à le multiplier par $10$ autant de fois que nécessaire jusqu'à ce que tous les chiffres soient à gauche de la virgule et qu'il n'y ait plus besoin de la faire figurer.
+Mais pour conserver l'égalité avec le nombre que l'on avait au départ, il ne faut pas oublier de diviser par $10$ autant de fois que l'on a décalé d'un rang vers la gauche.
+
+Ici on va faire $${log10OfDen}$ fois le décalage et la division.
+
+$$
+${alignTex([
+            [digitalTex, "=", arrFractionNodesReversed[0].toTex()],
+            ...arrFractionNodesReversed.slice(1).map((node) => ["", "=", node.toTex()]),
+        ], true)}
+$$
+
+Si on continue à décaler et diviser, on obtient d'autres fractions décimales égales à $${digitalTex}$.
+
+`;
+};
+const getPropositions = (n, { answer, isFractionToDigital, nb }) => {
+    console.log("getPropositions", nb);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const dec = new Decimal(nb);
+    const fractionNode = dec.toRational(false).toTree();
+    const denNodeSrc = fractionNode.rightChild;
+    const log10OfDen = Math.log10(denNodeSrc.evaluate());
+    const maxExponentExcluded = log10OfDen;
+    console.log("maxExponentExcluded", maxExponentExcluded);
+    const mandatoryExponents = [-1, ...(maxExponentExcluded > 1 ? [1] : [])];
+    const fillerExponents = [
+        -3,
+        -2,
+        ...(maxExponentExcluded > 2 ? [2] : []),
+        ...(maxExponentExcluded > 3 ? [3] : []),
+    ];
+    function tryToAddWrongPropWithExponent(exponent) {
+        const wrongNumber = dec.multiplyByPowerOfTen(exponent);
+        const node = isFractionToDigital
+            ? wrongNumber.toTree()
+            : wrongNumber.toRational(false).toTree();
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    mandatoryExponents.forEach((exponent) => {
+        tryToAddWrongPropWithExponent(exponent);
+    });
+    shuffle(fillerExponents).forEach((exponent) => {
+        if (propositions.length < n) {
+            tryToAddWrongPropWithExponent(exponent);
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, isFractionToDigital, nb }) => {
+    if (isFractionToDigital) {
+        const isValidDigital = /^\d+,\d+$/.test(ans);
+        if (!isValidDigital) {
+            return false;
+        }
+        const nodeAns = parseAlgebraic(answer);
+        return substract(nodeAns, nb).evaluate() === 0;
+    }
+    else {
+        const nodeAns = parseAlgebraic(ans);
+        if (isFractionNode(nodeAns)) {
+            const fractionNodeAns = nodeAns;
+            const denAns = fractionNodeAns.rightChild;
+            if (isNumberNode(denAns)) {
+                const log10Den = Math.log10(denAns.value);
+                const isDecAPowerOf10 = log10Den % 1 === 0;
+                if (isDecAPowerOf10) {
+                    return substract(nodeAns, nb).evaluate() === 0;
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+};
+const getDecimalFractionToDecimalQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        conversionType: random(arrayedOptions.conversionType),
+    };
+    const isFractionToDigital = opts.conversionType === "Fraction vers nombre à virgule";
+    const nb = (() => {
+        const createNum = (nbDigitsOfNum) => {
+            if (nbDigitsOfNum === 1) {
+                return randint(1, 10);
+            }
+            else {
+                return parseInt(`${randint(1, Math.pow(10, nbDigitsOfNum - 1))}${randint(1, 10)}`);
+            }
+        };
+        const nbDigitsOfNum = randint(1, 6);
+        const num = createNum(nbDigitsOfNum);
+        const den = Math.pow(10, randint(1, nbDigitsOfNum + 3));
+        return num / den;
+    })();
+    const identifiers = {
+        isFractionToDigital,
+        nb,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    conversionType: [
+        "Fraction vers nombre à virgule",
+        "Nombre à virgule vers fraction",
+    ],
+};
+const options = [
+    {
+        id: "conversionType",
+        label: "Type de conversion",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "Fraction vers nombre à virgule",
+            "Nombre à virgule vers fraction",
+        ],
+        defaultValue: optsDefault.conversionType,
+    },
+];
+export const decimalFractionToDecimal = {
+    id: "decimalFractionToDecimal",
+    connector: "=",
+    label: "Passer de la fraction décimale à l'écriture avec la virgule et vice-versa",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDecimalFractionToDecimalQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -1,4 +1,5 @@
 export * from "./multiplyDecimalByTens.js";
 export * from "./multiplyDecimalByNegativeTens.js";
 export * from "./decimalBoundingOnLine.js";
+export * from "./decimalFractionToDecimal.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC"}

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

@@ -1,3 +1,4 @@
 export * from "./multiplyDecimalByTens.js";
 export * from "./multiplyDecimalByNegativeTens.js";
 export * from "./decimalBoundingOnLine.js";
+export * from "./decimalFractionToDecimal.js";

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivityAdd.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { GeneralAffineIdentifiers } from "../../../../math/polynomials/generalAffine.js";
+type Identifiers = {
+    type: number;
+    affine1: GeneralAffineIdentifiers;
+    affine2: GeneralAffineIdentifiers;
+    affine3: GeneralAffineIdentifiers;
+    affine4?: GeneralAffineIdentifiers;
+};
+export declare const doubleDistributivityAdd: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=doubleDistributivityAdd.d.ts.map

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivityAdd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doubleDistributivityAdd.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistributivityAdd.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,wBAAwB,EACzB,MAAM,yCAAyC,CAAC;AASjD,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IAEb,OAAO,EAAE,wBAAwB,CAAC;IAClC,OAAO,EAAE,wBAAwB,CAAC;IAElC,OAAO,EAAE,wBAAwB,CAAC;IAElC,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACpC,CAAC;AAoLF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivityAdd.js

@@ -0,0 +1,173 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeneralAffine, GeneralAffineConstructor, } from "../../../../math/polynomials/generalAffine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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 { TrinomNodeConstructor } from "../../../../tree/nodes/polynomials/trinomNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+//(ax+b)(cx+d)+ex(gx+h)
+//(ax+b)(cx+d)+(ex+f)(gx+h)
+//(ax+b)(cx+d)+(ex+-f)^2
+const getPropositions = (n, { answer, affine1, affine2, affine3, type, affine4 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affs = [
+        GeneralAffineConstructor.fromIdentifiers(affine1),
+        GeneralAffineConstructor.fromIdentifiers(affine2),
+        GeneralAffineConstructor.fromIdentifiers(affine3),
+    ].map((e) => e.toTree());
+    if (affine4) {
+        affs.push(GeneralAffineConstructor.fromIdentifiers(affine4).toTree());
+    }
+    if (type === 3)
+        tryToAddWrongProp(propositions, substract(multiply(affs[0], affs[1]), square(affs[2]))
+            .simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        })
+            .toTex());
+    else
+        tryToAddWrongProp(propositions, substract(multiply(affs[0], affs[1]), multiply(affs[2], affs[3]))
+            .simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        })
+            .toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, TrinomNodeConstructor.random().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    return getStatementNode(identifiers).simplify({
+        forbidFactorize: true,
+        towardsDistribute: true,
+    });
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getStatementNode = (identifiers) => {
+    const affs = [
+        GeneralAffineConstructor.fromIdentifiers(identifiers.affine1),
+        GeneralAffineConstructor.fromIdentifiers(identifiers.affine2),
+        GeneralAffineConstructor.fromIdentifiers(identifiers.affine3),
+    ].map((e) => e.toTree());
+    if (identifiers.affine4) {
+        affs.push(GeneralAffineConstructor.fromIdentifiers(identifiers.affine4).toTree());
+    }
+    if (identifiers.affine4)
+        return add(multiply(affs[0], affs[1]), multiply(affs[2], affs[3]));
+    return add(multiply(affs[0], affs[1]), square(affs[2]));
+};
+const getInstruction = (identifiers) => {
+    return `Développer et réduire : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$
+`;
+};
+const getHint = () => {
+    return "Développe et réduit chacun des produits d'abord. Puis, additionne les deux résultats.";
+};
+const getCorrection = (identifiers) => {
+    const { affine1, affine2, affine3, type, affine4 } = identifiers;
+    const affs = [
+        GeneralAffineConstructor.fromIdentifiers(affine1),
+        GeneralAffineConstructor.fromIdentifiers(affine2),
+        GeneralAffineConstructor.fromIdentifiers(affine3),
+        affine4 ? GeneralAffineConstructor.fromIdentifiers(affine4) : 0,
+    ].map((e) => e.toTree());
+    const first = multiply(affs[0], affs[1]);
+    const second = type === 3 ? square(affs[2]) : multiply(affs[2], affs[3]);
+    const firstSimp = first.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const secondSimp = second.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    return `D'une part :
+  
+${alignTex([
+        ["", first.toTex()],
+        ["=", firstSimp.toTex()],
+    ])}
+
+D'autre part : 
+${alignTex([
+        ["", second.toTex()],
+        ["=", secondSimp.toTex()],
+    ])}
+
+On additionne les deux résultats : 
+
+${alignTex([
+        ["", add(first, second).toTex()],
+        ["=", add(firstSimp, secondSimp).toTex()],
+        [
+            "=",
+            add(first, second)
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}
+`;
+};
+const getKeys = () => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const texs = getAnswerNode(identifiers).toAllValidTexs({});
+    return texs.includes(ans);
+};
+const getDoubleDistributivityAddQuestion = () => {
+    const type = randint(1, 4);
+    const affine1 = GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const affine2 = GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const affine3 = type === 1
+        ? new GeneralAffine(randint(-10, 11, [0]), 0)
+        : GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const affine4 = type === 3
+        ? undefined
+        : GeneralAffineConstructor.randomInts({ allowBNull: false });
+    const identifiers = {
+        type,
+        affine1: affine1.toIdentifiers(),
+        affine2: affine2.toIdentifiers(),
+        affine3: affine3.toIdentifiers(),
+        affine4: affine4?.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const doubleDistributivityAdd = {
+    id: "doubleDistributivityAdd",
+    connector: "=",
+    label: "Double distributivité : addition de deux produits",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getDoubleDistributivityAddQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/distributivity/index.d.ts

@@ -10,4 +10,5 @@ export * from "./simpleDistriXCoeff.js";
 export * from "./doubleDistributivitySubstract.js";
 export * from "./identitiesWithNonIntegers.js";
 export * from "./simpleDistriMinus1.js";
+export * from "./doubleDistributivityAdd.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC"}

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

@@ -10,3 +10,4 @@ export * from "./simpleDistriXCoeff.js";
 export * from "./doubleDistributivitySubstract.js";
 export * from "./identitiesWithNonIntegers.js";
 export * from "./simpleDistriMinus1.js";
+export * from "./doubleDistributivityAdd.js";

package/lib/exercises/math/calculLitteral/equation/equationSecondDegreeWithNoB.d.ts

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

package/lib/exercises/math/calculLitteral/equation/equationSecondDegreeWithNoB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equationSecondDegreeWithNoB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationSecondDegreeWithNoB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAoKF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAa7D,CAAC"}