math-exercises 3.0.136 → 3.0.138

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

@@ -1 +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"}
+{"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;AAgQF,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

@@ -102,7 +102,6 @@ Si on continue à décaler et diviser, on obtient d'autres fractions décimales
 `;
 };
 const getPropositions = (n, { answer, isFractionToDigital, nb }) => {
-    console.log("getPropositions", nb);
     const propositions = [];
     addValidProp(propositions, answer);
     const dec = new Decimal(nb);
@@ -110,7 +109,6 @@ const getPropositions = (n, { answer, isFractionToDigital, nb }) => {
     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,

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

@@ -1 +1 @@
-{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAatE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAsrBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAatE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAqqBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationFromProblem.js

@@ -267,20 +267,6 @@ Quel est le prix, noté a, d'un pot de sauce ?`, (_group, mysteryVar, groups, sh
         }, (_group, _mysteryVar, groups, shuffleFuncs) => {
             const { total, ...groupsWithoutTotal } = groups;
             const orderedNodes = shuffleFuncs[0](Object.values(groupsWithoutTotal)).map((group) => group.getNode());
-            // console.log(
-            //   "orderedNodes[0].leftChild",
-            //   (orderedNodes[0] as MultiplyNode).leftChild,
-            // );
-            // console.log(
-            //   "isAlgebraicNode((orderedNodes[0] as MultiplyNode).leftChild)",
-            //   isAlgebraicNode((orderedNodes[0] as MultiplyNode).leftChild),
-            // );
-            // console.log(
-            //   "orderedNodes[0].leftChild.evaluate",
-            //   (orderedNodes[0] as MultiplyNode).leftChild.evaluate,
-            // );
-            // console.log("orderedNodes[0].evaluate()", orderedNodes[0].evaluate());
-            // console.log("orderedNodes[1].evaluate()", orderedNodes[1].evaluate());
             return round(add(orderedNodes[0], orderedNodes[1]).evaluate(), 2).toTree();
         }, false, true),
     }, [["pizza", "sauce"]]),

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

@@ -15,4 +15,5 @@ export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
 export * from "./equationFromProblem.js";
+export * from "./isEqualityTrue.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
 export * from "./equationFromProblem.js";
+export * from "./isEqualityTrue.js";

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    evaluationDict: Record<string, NodeIdentifiers>;
+    equalNodeIds: NodeIdentifiers;
+    isEqual: boolean;
+};
+type Options = {
+    typeCoeff: "Entier" | "Fraction" | "Décimal";
+    typeTestValue: "Entier" | "Fraction" | "Décimal";
+};
+export declare const isEqualityTrue1: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=isEqualityTrue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isEqualityTrue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/isEqualityTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkB7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAChD,YAAY,EAAE,eAAe,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAkUF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,aAAa,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;CAClD,CAAC;AA6BF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB1D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/isEqualityTrue.js

@@ -0,0 +1,314 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const varNames = ["x", "y", "z", "t", "u", "v"];
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((strYN) => {
+        if (strYN === answer) {
+            addValidProp(propositions, strYN);
+        }
+        else {
+            tryToAddWrongProp(propositions, strYN);
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { isEqual } = identifiers;
+    return isEqual ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { evaluationDict, equalNodeIds } = identifiers;
+    const equalNode = NodeConstructor.fromIdentifiers(equalNodeIds);
+    const strEvaluation = `${joinanded(Object.entries(evaluationDict).map(([varName, nodeIds]) => {
+        const node = NodeConstructor.fromIdentifiers(nodeIds);
+        return `$${varName} = ${node.toTex()}$`;
+    }), ", ", " et ")}`;
+    return `En considérant l'équation ci-dessous, l'égalité est-elle vérifiée pour ${strEvaluation} ? 
+  
+$$
+${equalNode.toTex()}
+$$
+
+`;
+};
+const getHint = () => {
+    return `L'expression $3x$ vaut $3,3$ pour $x = 1,1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { evaluationDict, equalNodeIds, isEqual } = identifiers;
+    const evaluationEntries = Object.entries(evaluationDict).map(([varName, nodeIds]) => [
+        varName,
+        NodeConstructor.fromIdentifiers(nodeIds),
+    ]);
+    const equalNode = NodeConstructor.fromIdentifiers(equalNodeIds);
+    const [lhsNode, rhsNode] = [equalNode.leftChild, equalNode.rightChild];
+    const [evaluatedLhsNode, evaluatedRhsNode] = [lhsNode, rhsNode].map((nodeCarrier) => evaluationEntries.reduce((acc, [varName, nodeInjected]) => nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName)), nodeCarrier));
+    return `Pour tester si l'égalité est vérifiée, on évalue chaque membre de l'équation.
+  
+On évalue le membre de gauche : 
+
+${alignTex([
+        ["", lhsNode.toTex()],
+        ["=", evaluatedLhsNode.toTex()],
+        [
+            "=",
+            (() => {
+                const evLhsAsAddNode = evaluatedLhsNode;
+                return add(evLhsAsAddNode.leftChild.simplify(), evLhsAsAddNode.rightChild);
+            })().toTex(),
+        ],
+        ["=", evaluatedLhsNode.simplify().toTex()],
+    ])}
+
+On évalue le membre de droite : 
+
+${alignTex([
+        ["", rhsNode.toTex()],
+        ["=", evaluatedRhsNode.toTex()],
+        [
+            "=",
+            (() => {
+                const evRhsAsAddNode = evaluatedRhsNode;
+                return add(evRhsAsAddNode.leftChild.simplify(), evRhsAsAddNode.rightChild);
+            })().toTex(),
+        ],
+        ["=", evaluatedRhsNode.simplify().toTex()],
+    ])}
+
+${isEqual
+        ? `Les deux valeurs sont égales donc l'égalité est vérifiée.`
+        : `Les deux valeurs sont différentes. L'égalité n'est pas vérifiée.`}
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const getIsEqualityTrue1Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        typeCoeff: random(arrayedOptions.typeCoeff),
+        typeTestValue: random(arrayedOptions.typeTestValue),
+    };
+    const roundDecimalTo = 1;
+    const varName = random(varNames);
+    function getRandomIntNode(excludes = []) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const intExcludes = excludes
+                .filter((node) => isNumberNode(node))
+                .map((node) => node.evaluate())
+                .filter((value) => value % 1 === 0);
+            let n;
+            try {
+                n = randint(-9, 10, intExcludes);
+            }
+            catch (_) {
+                (() => { })();
+            }
+            if (n) {
+                outNode = n.toTree();
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomFractionNode(excludes = []) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const num = randint(-9, 10);
+            const den = randint(0, 10, [0, num]);
+            const fractionNode = frac(num, den);
+            const isExcluded = excludes.some((excludedNode) => substract(excludedNode, fractionNode).evaluate() === 0);
+            if (!isExcluded) {
+                outNode = fractionNode;
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomDecimalNode(excludes = [], roundTo) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const decimalNode = randfloat(-10, 10, roundTo).toTree();
+            const isExcluded = excludes.some((excludedNode) => substract(excludedNode, decimalNode).evaluate() === 0);
+            if (!isExcluded) {
+                outNode = decimalNode;
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomNode(typeCoeff, excludes = []) {
+        switch (typeCoeff) {
+            case "Fraction":
+                return getRandomFractionNode(excludes);
+            case "Décimal": {
+                return getRandomDecimalNode(excludes, roundDecimalTo);
+            }
+            case "Entier":
+            default:
+                return getRandomIntNode(excludes);
+        }
+    }
+    function createRandomIdentifiers() {
+        const [a, b] = [
+            getRandomNode(opts.typeCoeff),
+            getRandomNode(opts.typeCoeff),
+        ];
+        const [c, d] = [
+            getRandomNode(opts.typeCoeff, [a]),
+            getRandomNode(opts.typeCoeff),
+        ];
+        const lhsNode = add(multiply(a, varName.toTree()), b);
+        const rhsNode = add(multiply(c, varName.toTree()), d);
+        const equalNode = new EqualNode(lhsNode, rhsNode);
+        //ax+b=cx+d
+        //x=(d-b)/(a-c)
+        const solutionNode = frac(substract(d, b), substract(a, c)).simplify();
+        const isEqual = coinFlip();
+        const evaluationDict = {};
+        if (isEqual) {
+            let isSalvation = true;
+            switch (opts.typeTestValue) {
+                case "Entier":
+                    {
+                        const value = solutionNode.evaluate();
+                        const isInteger = value % 1 === 0;
+                        if (isInteger) {
+                            evaluationDict[varName] = value.toTree().toIdentifiers();
+                        }
+                        else {
+                            isSalvation = false;
+                        }
+                    }
+                    break;
+                case "Décimal":
+                    {
+                        const value = solutionNode.evaluate();
+                        const strValue = value.toString();
+                        const isDecimalWithNbDigits = strValue.split(".")?.[1]?.length === roundDecimalTo;
+                        if (isDecimalWithNbDigits) {
+                            evaluationDict[varName] = value.toTree().toIdentifiers();
+                        }
+                        else {
+                            isSalvation = false;
+                        }
+                    }
+                    break;
+                case "Fraction": {
+                    if (isFractionNode(solutionNode)) {
+                        evaluationDict[varName] = solutionNode.toIdentifiers();
+                    }
+                    else {
+                        isSalvation = false;
+                    }
+                }
+            }
+            if (!isSalvation) {
+                return null;
+            }
+        }
+        else {
+            const missNode = getRandomNode(opts.typeTestValue, [solutionNode]);
+            evaluationDict[varName] = missNode.toIdentifiers();
+        }
+        const identifiers = {
+            evaluationDict,
+            equalNodeIds: equalNode.toIdentifiers(),
+            isEqual,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    while (!identifiers && counter < 100) {
+        counter++;
+        identifiers = createRandomIdentifiers();
+    }
+    const defaultIdentifiers = {
+        evaluationDict: { x: (0).toTree().toIdentifiers() },
+        equalNodeIds: parseLatex("3x+4=-5x+4").toIdentifiers(),
+        isEqual: true,
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    typeCoeff: ["Entier"],
+    typeTestValue: ["Entier", "Fraction", "Décimal"],
+};
+const options = [
+    {
+        id: "typeCoeff",
+        label: "Type des coefficients",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Fraction", "Décimal"],
+        defaultValue: optsDefault.typeCoeff,
+    },
+    {
+        id: "typeTestValue",
+        label: "Type des valeurs de test",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Fraction", "Décimal"],
+        defaultValue: optsDefault.typeTestValue,
+    },
+];
+export const isEqualityTrue1 = {
+    id: "isEqualityTrue1",
+    label: "Tester une égalité pour une certaine valeur de la variable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsEqualityTrue1Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/calculLitteral/factorisation/factoType3.d.ts

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

package/lib/exercises/math/calculLitteral/factorisation/factoType3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factoType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,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,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAyJF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType3.js

@@ -0,0 +1,115 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, a, b, c, d, k, isSubstract }) => {
+    const propositions = [];
+    const affine1 = new Affine(a, b);
+    const affine2 = new Affine(c, d);
+    addValidProp(propositions, answer);
+    //erreur de signe
+    tryToAddWrongProp(propositions, getAnswer({ a, b, c, d, k, isSubstract: !isSubstract }));
+    //k(ax+b) -> kx(ax+b)
+    tryToAddWrongProp(propositions, new MultiplyNode(affine1.toTree(), add(affine2.toTree(), multiply(isSubstract ? -k : k, "x")).simplify({
+        towardsDistribute: true,
+    })).toTex());
+    //(ax+b)(cx+d)+-k(ax+b) -> (ax+b)(cx+d+-k(ax+b))
+    tryToAddWrongProp(propositions, new MultiplyNode(affine1.toTree(), add(affine2.toTree(), multiply(isSubstract ? -k : k, affine1.toTree())).simplify({ towardsDistribute: true })).toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, new MultiplyNode(affine1.toTree(), AffineConstructor.random().toTree()).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerTree = (identifiers) => {
+    const affine1 = new Affine(identifiers.a, identifiers.b);
+    const affine2 = new Affine(identifiers.c, identifiers.d);
+    return new MultiplyNode(affine1.toTree(), affine2
+        .add(identifiers.isSubstract ? -identifiers.k : identifiers.k)
+        .toTree());
+};
+const getAnswer = (identifiers) => {
+    return getAnswerTree(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const affine1 = new Affine(identifiers.a, identifiers.b);
+    const affine2 = new Affine(identifiers.c, identifiers.d);
+    const statement = new (identifiers.isSubstract ? SubstractNode : AddNode)(new MultiplyNode(affine1.toTree(), affine2.toTree()), multiply(identifiers.k, affine1.toTree()));
+    return `Factoriser et réduire : 
+  
+$$
+${statement.toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Repère d'abord le facteur commun dans cette expression. Puis multiplie ce facteur commun par les autres termes de l'expression.`;
+};
+const getCorrection = (identifiers) => {
+    const affine1 = new Affine(identifiers.a, identifiers.b);
+    const affine2 = new Affine(identifiers.c, identifiers.d);
+    const answer = getAnswer(identifiers);
+    const statement = new (identifiers.isSubstract ? SubstractNode : AddNode)(new MultiplyNode(affine1.toTree(), affine2.toTree()), multiply(identifiers.k, affine1.toTree()));
+    const corr = `
+${alignTex([
+        ["", statement.toTex()],
+        [
+            "=",
+            new AddNode(new MultiplyNode(affine1.toTree(), affine2.toTree()), multiply(affine1.toTree(), (identifiers.isSubstract ? -1 : 1) * identifiers.k)).toTex(),
+        ],
+        [
+            "=",
+            new MultiplyNode(affine1.toTree(), add(affine2.toTree(), (identifiers.isSubstract ? -1 : 1) * identifiers.k)).toTex(),
+        ],
+        ["=", answer],
+    ])}
+  `;
+    return corr;
+};
+const getKeys = () => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer, a, b, c, d, k, isSubstract }) => {
+    const tree = getAnswerTree({ a, b, c, d, k, isSubstract });
+    return ans === answer || tree.toAllValidTexs().includes(ans);
+};
+const getFactoType3Question = () => {
+    const b = randint(-10, 11);
+    const a = randint(-10, 11, [0, b, -b]);
+    const c = randint(-10, 11, [0]);
+    const d = randint(-10, 11, b === 0 ? [0, -1] : [0, c, -c]);
+    const k = randint(-10, 11, [0]);
+    const isSubstract = coinFlip();
+    const identifiers = { a, b, c, d, k, isSubstract };
+    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 factoType3 = {
+    id: "factoType3",
+    connector: "=",
+    label: "Factorisation du type $\\left(ax+b\\right)\\left(cx+d\\right)\\pm k \\left(ax+b\\right)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getFactoType3Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/factorisation/factoType4.d.ts

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

package/lib/exercises/math/calculLitteral/factorisation/factoType4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factoType4.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType4.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,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,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAoKF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType4.js

@@ -0,0 +1,112 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+const getPropositions = (n, { answer, a, b, c, d, k, isSubstract }) => {
+    const propositions = [];
+    const affine1 = new Affine(a, b);
+    const affine2 = new Affine(c, d);
+    addValidProp(propositions, answer);
+    //erreur de signe
+    tryToAddWrongProp(propositions, getAnswer({ a, b, c, d, k, isSubstract: !isSubstract }));
+    //k(ax+b)^2 -> k(ax+b)
+    tryToAddWrongProp(propositions, new MultiplyNode(affine1.toTree(), affine2.add(isSubstract ? -k : k).toTree()).toTex());
+    //(ax+b)(cx+d)+-k(ax+b)^2 -> (ax+b)(cx+d+-kx)
+    tryToAddWrongProp(propositions, new MultiplyNode(affine1.toTree(), add(affine2.toTree(), multiply(isSubstract ? -k : k, "x".toTree())).simplify({ towardsDistribute: true })).toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, new MultiplyNode(affine1.toTree(), AffineConstructor.random().toTree()).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerTree = (identifiers) => {
+    const affine1 = new Affine(identifiers.a, identifiers.b);
+    const affine2 = new Affine(identifiers.c, identifiers.d);
+    return new MultiplyNode(affine1.toTree(), add(affine2.toTree(), multiply(identifiers.isSubstract ? -identifiers.k : identifiers.k, affine1.toTree()).simplify({ towardsDistribute: true })).simplify({ towardsDistribute: true }));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerTree(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const affine1 = new Affine(identifiers.a, identifiers.b);
+    const affine2 = new Affine(identifiers.c, identifiers.d);
+    const statement = new (identifiers.isSubstract ? SubstractNode : AddNode)(new MultiplyNode(affine1.toTree(), affine2.toTree()), multiply(identifiers.k, power(affine1.toTree(), 2)));
+    return `Factoriser et réduire : 
+  
+$$
+${statement.toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Repère d'abord le facteur commun dans cette expression. Puis multiplie ce facteur commun par les autres termes de l'expression.`;
+};
+const getCorrection = (identifiers) => {
+    const affine1 = new Affine(identifiers.a, identifiers.b);
+    const affine2 = new Affine(identifiers.c, identifiers.d);
+    const answer = getAnswer(identifiers);
+    const statement = new (identifiers.isSubstract ? SubstractNode : AddNode)(new MultiplyNode(affine1.toTree(), affine2.toTree()), multiply(identifiers.k, power(affine1.toTree(), 2)));
+    const corr = `
+${alignTex([
+        ["", statement.toTex()],
+        [
+            "=",
+            new AddNode(new MultiplyNode(affine1.toTree(), affine2.toTree()), new MultiplyNode(affine1.toTree(), multiply((identifiers.isSubstract ? -1 : 1) * identifiers.k, affine1.toTree()))).toTex(),
+        ],
+        [
+            "=",
+            new MultiplyNode(affine1.toTree(), add(affine2.toTree(), multiply((identifiers.isSubstract ? -1 : 1) * identifiers.k, affine1.toTree()).simplify({ towardsDistribute: true }))).toTex(),
+        ],
+        ["=", answer],
+    ])}
+  `;
+    return corr;
+};
+const getKeys = () => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer, a, b, c, d, k, isSubstract }) => {
+    const tree = getAnswerTree({ a, b, c, d, k, isSubstract });
+    return ans === answer || tree.toAllValidTexs().includes(ans);
+};
+const getFactoType4Question = () => {
+    const b = randint(-10, 11);
+    const a = randint(-10, 11, [0, b, -b]);
+    const c = randint(-10, 11, [0]);
+    const d = randint(-10, 11, b === 0 ? [0, -1] : [0, c, -c]);
+    const k = randint(-10, 11, [0]);
+    const isSubstract = coinFlip();
+    const identifiers = { a, b, c, d, k, isSubstract };
+    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 factoType4 = {
+    id: "factoType4",
+    connector: "=",
+    label: "Factorisation du type $\\left(ax+b\\right)\\left(cx+d\\right)\\pm k {\\left(ax+b\\right)}^2$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getFactoType4Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};