math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/matrices/matrixComputeLinearCombination.js

@@ -0,0 +1,232 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { probaLawFlip } from "../../../utils/alea/probaLawFlip.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { zip } from "../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA, matIdsB, nodeIdsKA, nodeIdsKB } = identifiers;
+    const [matA, matB] = [matIdsA, matIdsB].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    const [nodeKA, nodeKB] = [nodeIdsKA, nodeIdsKB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeExprInstruction = add(multiply(nodeKA, "A".toTree()), multiply(nodeKB, "B".toTree()));
+    return {
+        matA,
+        matB,
+        nodeKA,
+        nodeKB,
+        nodeExprInstruction,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA, matB, nodeExprInstruction } = getHydrated(identifiers);
+    return `Soient :
+
+$$
+A = ${matA.toTex()}
+$$
+
+$$
+B = ${matB.toTex()}
+$$
+
+Calculer $${nodeExprInstruction.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { matA, matB, nodeKA, nodeKB } = getHydrated(identifiers);
+    const matLinComb = matA.times(nodeKA).add(matB.times(nodeKB));
+    const matLinCombSimplified = matLinComb.simplify({ towardsDistribute: true });
+    return matLinCombSimplified.toTex();
+};
+const getHint = (_identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return `Soient $A$ et $B$ deux matrices à $2$ lignes et $2$ colonnes. Soit $k$ un nombre réel.
+  
+$$
+A = \\begin{pmatrix} a & b \\\\ c & d \\end{pmatrix}
+$$
+
+$$
+B = \\begin{pmatrix} r & s \\\\ t & u \\end{pmatrix}
+$$
+
+alors :
+
+$$
+A + B = \\begin{pmatrix} a+r & b+s \\\\ c+t & d+u \\end{pmatrix}
+$$
+
+${(() => {
+        switch (opts.typeLinComb) {
+            case "Combinaison linéaire":
+                return `
+    
+$$
+kA = \\begin{pmatrix} ka & kb \\\\ kc & kd \\end{pmatrix}
+$$
+
+`;
+            default:
+                return "";
+        }
+    })()}`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { matA, matB, nodeExprInstruction, nodeKA, nodeKB } = getHydrated(identifiers);
+    const matKAA = matA.times(nodeKA);
+    const matKBB = matB.times(nodeKB);
+    const matLinComb = matKAA.add(matKBB);
+    const [texKA, texKB] = [nodeKA, nodeKB]
+        .map((node) => node.toTex())
+        .map((str) => (str === "1" ? "" : str.startsWith("-") ? `(${str})` : str));
+    switch (opts.typeLinComb) {
+        case "Combinaison linéaire":
+            return `${alignTex([
+                ["", nodeExprInstruction.toTex()],
+                ["=", `${texKA} ${matA.toTex()} + ${texKB} ${matB.toTex()}`],
+                ["=", `${matKAA.toTex()} + ${matKBB.toTex()}`],
+                ["=", matLinComb.toTex()],
+                ["=", matLinComb.simplify({ towardsDistribute: true }).toTex()],
+            ])}`;
+        case "Somme simple":
+            return `${alignTex([
+                ["", nodeExprInstruction.toTex()],
+                ["=", `${matKAA.toTex()} + ${matKBB.toTex()}`],
+                ["=", matLinComb.toTex()],
+                ["=", matLinComb.simplify({ towardsDistribute: true }).toTex()],
+            ])}`;
+        default:
+            throw new Error("Unsupported opts.typeLinComb: " + opts.typeLinComb);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { matA, matB, nodeKA, nodeKB } = getHydrated(identifiers);
+    const matKAA = matA.times(nodeKA);
+    const matKBB = matB.times(nodeKB);
+    //student: (kA A) * (kB B)
+    {
+        const matWrong = matKAA.matrixProduct(matKBB);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: strange addition which resembles product
+    {
+        function matrixSumWrong(mat1, mat2) {
+            const mat2Transposed = mat2.transposed();
+            const arrElementSumWrong = mat1.elements.map((row) => mat2Transposed.elements.map((column) => zip(row, column).reduce((acc, [nodeAik, nodeBkj], i) => {
+                const nodeAikBkj = add(nodeAik, nodeBkj);
+                if (i === 0) {
+                    return nodeAikBkj;
+                }
+                else {
+                    return add(acc, nodeAikBkj);
+                }
+            }, (0).toTree())));
+            return new Matrix(arrElementSumWrong);
+        }
+        const matWrong = matrixSumWrong(matKAA, matKBB);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const [nodeKA, nodeKB] = (() => {
+        switch (opts.typeLinComb) {
+            case "Somme simple":
+                return [(1).toTree(), (1).toTree()];
+            case "Combinaison linéaire":
+                return shuffle(probaLawFlip([
+                    [[(1).toTree(), (2).toTree()], 0.35],
+                    [[(1).toTree(), (3).toTree()], 0.25],
+                    [[(1).toTree(), (-2).toTree()], 0.15],
+                    [[(1).toTree(), (-1).toTree()], 0.15],
+                ]));
+            default:
+                throw new Error("Unsupported opts.typeLinComb: " + opts.typeLinComb);
+        }
+    })();
+    const matA = MatrixConstructor.random(2, 2);
+    const matB = MatrixConstructor.random(2, 2);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+        matIdsB: matB.toIdentifiers(),
+        nodeIdsKA: nodeKA.toIdentifiers(),
+        nodeIdsKB: nodeKB.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixComputeLinearCombinationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, optsIn) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, optsIn),
+        correction: getCorrection(identifiers, optsIn),
+        options: optsIn,
+    };
+    return question;
+};
+const optsDefault = {
+    typeLinComb: "Combinaison linéaire",
+};
+const options = [
+    {
+        id: "typeLinComb",
+        label: "Type de combinaison linéaire",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Somme simple", "Combinaison linéaire"],
+        defaultValue: optsDefault.typeLinComb,
+    },
+];
+export const matrixComputeLinearCombination = {
+    id: "matrixComputeLinearCombination",
+    connector: "=",
+    label: "Calculer une combinaison linéaire de deux matrices",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixComputeLinearCombinationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/matrices/matrixComputePower.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { MatrixIdentifiers } from "../../../math/matrices/matrix.js";
+type Identifiers = {
+    matIdsA: MatrixIdentifiers;
+    exponent: number;
+};
+type Options = {
+    exponent: string;
+};
+export declare const matrixComputePower: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=matrixComputePower.d.ts.map

package/lib/exercises/math/matrices/matrixComputePower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixComputePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/matrixComputePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAQvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA4PF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgBF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}

package/lib/exercises/math/matrices/matrixComputePower.js

@@ -0,0 +1,230 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA, exponent } = identifiers;
+    const [matA] = [matIdsA].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    const nodeExprInstruction = power("A".toTree(), exponent);
+    return {
+        matA,
+        nodeExprInstruction,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA, nodeExprInstruction } = getHydrated(identifiers);
+    return `Soit :
+
+$$
+A = ${matA.toTex()}
+$$
+
+Calculer $${nodeExprInstruction.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { exponent } = identifiers;
+    const { matA } = getHydrated(identifiers);
+    const matProduct = matA.power(exponent);
+    const matProductSimplified = matProduct.simplify({ towardsDistribute: true });
+    return matProductSimplified.toTex();
+};
+const getHint = () => {
+    const matA = new Matrix([
+        ["a".toTree(), "b".toTree()],
+        ["c".toTree(), "d".toTree()],
+    ]);
+    const matASpaced = new Matrix([
+        ["\\ \\ \\ a".toTree(), "\\ \\ \\ \\ \\ b \\ \\ \\ ".toTree()],
+        ["\\ \\ \\ c".toTree(), "\\ \\ \\ \\ \\ d \\ \\ \\ ".toTree()],
+    ]);
+    return `Soient $A$ une matrice à $2$ lignes et $2$ colonnes à coefficients réels.
+  
+$$
+A = ${matA.toTex()}
+$$
+
+Pour calculer $A^2=AA$,
+tu peux disposer les matrices de cette façon pour ne pas te tromper :
+
+$$
+\\begin{matrix} {\\begin{matrix} \\  & \\  \\\\ \\  & \\  \\end{matrix}} & {${matASpaced.toTex()}} \\\\ {${matA.toTex()}} & {\\begin{pmatrix} {...} & {ab+bd}  \\\\ {...}  & {...}  \\end{pmatrix}} \\end{matrix}
+$$
+
+Ce qui donne :
+
+$$
+A^2 = AA = ${matA.matrixProduct(matA).toTex()}
+$$
+
+Continue ainsi pour les autres puissances de $A$ :
+
+$$
+A^3 = AAA = A^2 A
+$$
+
+etc.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { exponent } = identifiers;
+    const { matA } = getHydrated(identifiers);
+    const matA2 = matA.matrixProduct(matA);
+    const matA2Simplified = matA2.simplify({ towardsDistribute: true });
+    const matA3 = matA2Simplified.matrixProduct(matA);
+    const matA3Simplified = matA3.simplify({ towardsDistribute: true });
+    switch (exponent) {
+        case 2:
+            return `${alignTex([
+                ["", "A^2"],
+                ["=", `${matA.toTex()} ${matA.toTex()}`],
+                ["=", matA2.toTex()],
+                ["=", matA2Simplified.toTex()],
+            ])}`;
+        case 3:
+            return `
+      
+${alignTex([
+                ["", "A^2"],
+                ["=", `${matA.toTex()} ${matA.toTex()}`],
+                ["=", matA2.toTex()],
+                ["=", matA2Simplified.toTex()],
+            ])}
+      
+${alignTex([
+                ["", "A^3"],
+                ["=", "A^2 A"],
+                ["=", `${matA2Simplified.toTex()} ${matA.toTex()}`],
+                ["=", matA3.toTex()],
+                ["=", matA3Simplified.toTex()],
+            ])}
+      
+`;
+        default:
+            throw new Error("Unsupported exponent: " + exponent);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { exponent } = identifiers;
+    const { matA } = getHydrated(identifiers);
+    function createPowerFuncWrong(funcAB) {
+        const func = (matA, exponent) => [...Array(exponent).keys()].reduce((acc, i) => {
+            if (i === 0) {
+                return matA;
+            }
+            else {
+                return funcAB(acc, matA);
+            }
+        }, matA);
+        return func;
+    }
+    //student: AB = A+B
+    {
+        const powerFuncWrong = createPowerFuncWrong((matA, matB) => matA.add(matB));
+        const matWrong = powerFuncWrong(matA, exponent);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (a_{ij}b_{ij})
+    {
+        function matrixProductWrong(mat1, mat2) {
+            const arrElementSumWrong = mat1.elements.map((row, i) => row.map((elt1, j) => {
+                const elt2 = mat2.elements[i][j];
+                return multiply(elt1, elt2);
+            }));
+            return new Matrix(arrElementSumWrong);
+        }
+        const powerFuncWrong = createPowerFuncWrong(matrixProductWrong);
+        const matWrong = powerFuncWrong(matA, exponent);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (sum(a_{ik}b_{jk}))
+    {
+        const powerFuncWrong = createPowerFuncWrong((matA, matB) => matA.matrixProduct(matB.transposed()));
+        const matWrong = powerFuncWrong(matA, exponent);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const matA = MatrixConstructor.random(2, 2);
+    const exponent = parseInt(opts.exponent);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+        exponent,
+    };
+    return identifiers;
+};
+const getMatrixComputePowerQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, optsIn) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: optsIn,
+    };
+    return question;
+};
+const optsDefault = {
+    exponent: "2",
+};
+const options = [
+    {
+        id: "exponent",
+        label: "Valeur de l'exposant",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["2", "3"],
+        defaultValue: optsDefault.exponent,
+    },
+];
+export const matrixComputePower = {
+    id: "matrixComputePower",
+    connector: "=",
+    label: "Calculer une puissance d'une matrice",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixComputePowerQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/matrices/matrixComputeProduct.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { MatrixIdentifiers } from "../../../math/matrices/matrix.js";
+type Identifiers = {
+    matIdsA: MatrixIdentifiers;
+    matIdsB: MatrixIdentifiers;
+};
+export declare const matrixComputeProduct: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=matrixComputeProduct.d.ts.map

package/lib/exercises/math/matrices/matrixComputeProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixComputeProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/matrixComputeProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAOvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AA0MF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/matrices/matrixComputeProduct.js

@@ -0,0 +1,178 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA, matIdsB } = identifiers;
+    const [matA, matB] = [matIdsA, matIdsB].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    const nodeExprInstruction = multiply("A".toTree(), "B".toTree()).simplify();
+    return {
+        matA,
+        matB,
+        nodeExprInstruction,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA, matB, nodeExprInstruction } = getHydrated(identifiers);
+    return `Soient :
+
+$$
+A = ${matA.toTex()}
+$$
+
+$$
+B = ${matB.toTex()}
+$$
+
+Calculer $${nodeExprInstruction.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { matA, matB } = getHydrated(identifiers);
+    const matProduct = matA.matrixProduct(matB);
+    const matProductSimplified = matProduct.simplify({ towardsDistribute: true });
+    return matProductSimplified.toTex();
+};
+const getHint = () => {
+    const matA = new Matrix([
+        ["a".toTree(), "b".toTree()],
+        ["c".toTree(), "d".toTree()],
+    ]);
+    const matB = new Matrix([
+        ["r".toTree(), "s".toTree()],
+        ["t".toTree(), "u".toTree()],
+    ]);
+    const matBSpaced = new Matrix([
+        ["\\ \\ \\ r".toTree(), "\\ \\ \\ \\ \\ s \\ \\ \\ ".toTree()],
+        ["\\ \\ \\ t".toTree(), "\\ \\ \\ \\ \\ u \\ \\ \\ ".toTree()],
+    ]);
+    return `Soient $A$ et $B$ deux matrices à $2$ lignes et $2$ colonnes à coefficients réels.
+  
+$$
+A = ${matA.toTex()}
+$$
+
+$$
+B = ${matB.toTex()}
+$$
+
+Pour calculer le produit matriciel $AB$,
+tu peux disposer les matrices $A$ et $B$ de cette façon pour ne pas te tromper :
+
+$$
+\\begin{matrix} {\\begin{matrix} \\  & \\  \\\\ \\  & \\  \\end{matrix}} & {${matBSpaced.toTex()}} \\\\ {${matA.toTex()}} & {\\begin{pmatrix} {...} & {as+bu}  \\\\ {...}  & {...}  \\end{pmatrix}} \\end{matrix}
+$$
+
+Ce qui donne :
+
+$$
+AB = ${matA.matrixProduct(matB).toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { matA, matB, nodeExprInstruction } = getHydrated(identifiers);
+    const matProduct = matA.matrixProduct(matB);
+    const matProductSimplified = matProduct.simplify({ towardsDistribute: true });
+    return `${alignTex([
+        ["", nodeExprInstruction.toTex()],
+        ["=", `${matA.toTex()} ${matB.toTex()}`],
+        ["=", matProduct.toTex()],
+        ["=", matProductSimplified.toTex()],
+    ])}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { matA, matB } = getHydrated(identifiers);
+    //student: AB = A+B
+    {
+        const matWrong = matA.add(matB);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (a_{ij}b_{ij})
+    {
+        function matrixProductWrong(mat1, mat2) {
+            const arrElementSumWrong = mat1.elements.map((row, i) => row.map((elt1, j) => {
+                const elt2 = mat2.elements[i][j];
+                return multiply(elt1, elt2);
+            }));
+            return new Matrix(arrElementSumWrong);
+        }
+        const matWrong = matrixProductWrong(matA, matB);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (sum(a_{ik}b_{jk}))
+    {
+        const matWrong = matA.matrixProduct(matB.transposed());
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers();
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const nodeKA = (1).toTree();
+    const nodeKB = (2).toTree();
+    const matA = MatrixConstructor.random(2, 2);
+    const matB = MatrixConstructor.random(2, 2);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+        matIdsB: matB.toIdentifiers(),
+        nodeIdsKA: nodeKA.toIdentifiers(),
+        nodeIdsKB: nodeKB.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixComputeProductQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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 matrixComputeProduct = {
+    id: "matrixComputeProduct",
+    connector: "=",
+    label: "Calculer le produit de deux matrices",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMatrixComputeProductQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/matrices/writeMatrixAssociatedToSystem.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { GeneralSystemIdentifiers } from "../../../math/systems/generalSystem.js";
+type Identifiers = {
+    systemIds: GeneralSystemIdentifiers;
+};
+export declare const writeMatrixAssociatedToSystem: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=writeMatrixAssociatedToSystem.d.ts.map

package/lib/exercises/math/matrices/writeMatrixAssociatedToSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeMatrixAssociatedToSystem.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/writeMatrixAssociatedToSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAG7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,wBAAwB,CAAC;CACrC,CAAC;AA6FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}