math-exercises 3.0.215 → 3.0.216

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

@@ -0,0 +1,142 @@
+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 { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA } = identifiers;
+    const [matA] = [matIdsA].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    return {
+        matA,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return `Soit :
+
+$$
+A = ${matA.toTex()}
+$$
+
+Calculer le déterminant de $A$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return matA.determinant();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = () => {
+    const matA = 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()}
+$$
+
+$$
+\\text{det}(A) = \\begin{vmatrix} a & b \\\\ c & d \\end{vmatrix} = ${matA
+        .determinant()
+        .toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return `${alignTex([
+        ["\\text{det}(A)", "=", matA.toTex().replaceAll("pmatrix", "vmatrix")],
+        [
+            "",
+            "=",
+            matA
+                .determinant()
+                .toTex({ forceNoSimplification: true, forceTimesSign: true }),
+        ],
+        ["", "=", matA.determinant().simplify({ towardsDistribute: true }).toTex()],
+    ])}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { matA } = getHydrated(identifiers);
+    //student ad-cb -> ad+cb
+    {
+        const [[a, b], [c, d]] = matA.elements;
+        const detWrong = add(multiply(a, d), multiply(b, c)).simplify({
+            towardsDistribute: true,
+        });
+        tryToAddWrongProp(propositions, detWrong.toTex());
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers();
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const matA = MatrixConstructor.random(2, 2);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixComputeDetOfMat2Question = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+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;
+};
+export const matrixComputeDetOfMat2 = {
+    id: "matrixComputeDetOfMat2",
+    connector: "=",
+    label: "Calculer le déterminant d'une matrice carrée d'ordre $2$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixComputeDetOfMat2Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

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

@@ -0,0 +1,237 @@
+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 { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA } = identifiers;
+    const [matA] = [matIdsA].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    return {
+        matA,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return `Soit :
+
+$$
+A = ${matA.toTex()}
+$$
+
+Déterminer l'inverse de $A$.`;
+};
+const getAnswer = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    const matInverse = matA.inverse();
+    return matInverse
+        ? matInverse.simplify({ towardsDistribute: true }).toTex()
+        : "A\\text{ n'est pas inversible}";
+};
+const getHint = () => {
+    const matA = 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()}
+$$
+
+$$
+\\text{det}(A) = \\begin{vmatrix} a & b \\\\ c & d \\end{vmatrix} = ${matA
+        .determinant()
+        .toTex()}
+$$
+
+Si $\\text{det}(A) \\neq 0$ alors $A$ est inversible et 
+
+$$
+A^{-1} = \\frac{1}{\\text{det}(A)} \\begin{pmatrix} d & -b \\\\ -c & a \\end{pmatrix}
+$$
+
+Sinon, $A$ n'a pas d'inverse.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    const [[a, b], [c, d]] = matA.elements;
+    const nodeDet = matA.determinant();
+    const matAForFormula = new Matrix([
+        ["a".toTree(), "b".toTree()],
+        ["c".toTree(), "d".toTree()],
+    ]);
+    return `On commence par calculer le déterminant de $A$ :
+  
+${alignTex([
+        ["\\text{det}(A)", "=", matA.toTex().replaceAll("pmatrix", "vmatrix")],
+        [
+            "",
+            "=",
+            nodeDet.toTex({ forceNoSimplification: true, forceTimesSign: true }),
+        ],
+        ["", "=", nodeDet.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+${(() => {
+        if (NodeComparator.isEqualViaSub(nodeDet, (0).toTree())) {
+            return `Le déterminant vaut $0$ : La matrice $A$ n'est donc pas inversible.`;
+        }
+        else {
+            return `Le déterminant n'est pas nul : La matrice $A$ est donc inversible.
+
+Pour une matrice carrée d'ordre $2$, il existe une formule pour calculer l'inverse.
+
+En posant: 
+
+$$
+A = ${matAForFormula.toTex()}
+$$
+    
+${alignTex([
+                [
+                    "A^{-1}",
+                    "=",
+                    "\\frac{1}{\\text{det}(A)} \\begin{pmatrix} d & -b \\\\ -c & a \\end{pmatrix}",
+                ],
+            ])}
+
+Ici, on a donc :
+
+${alignTex([
+                [
+                    "A^{-1}",
+                    "=",
+                    `\\frac{1}{${nodeDet
+                        .simplify({
+                        towardsDistribute: true,
+                    })
+                        .toTex()}} \\begin{pmatrix} ${d.toTex()} & ${opposite(b)
+                        .simplify()
+                        .toTex()} \\\\ ${opposite(c)
+                        .simplify()
+                        .toTex()} & ${a.toTex()} \\end{pmatrix}`,
+                ],
+                ["", "=", matA.inverse().simplify({ towardsDistribute: true }).toTex()],
+            ])}
+
+`;
+        }
+    })()}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //impossible
+    {
+        const texImpossible = "A\\text{ n'est pas inversible}";
+        tryToAddWrongProp(propositions, texImpossible);
+    }
+    const { matA } = getHydrated(identifiers);
+    //student A^{-1} -> tA
+    {
+        const matWrong = matA.transposed();
+        tryToAddWrongProp(propositions, matWrong.toTex());
+    }
+    //student ad-cb -> ad+cb
+    {
+        const [[a, b], [c, d]] = matA.elements;
+        const detWrong = add(multiply(a, d), multiply(b, c)).simplify({
+            towardsDistribute: true,
+        });
+        if (NodeComparator.isEqualViaSub(detWrong, (0).toTree())) {
+            //ignore
+        }
+        else {
+            const matWrong = new Matrix([
+                [d, opposite(b)],
+                [opposite(c), a],
+            ]).times(frac(1, detWrong));
+            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 [
+        {
+            id: "custom",
+            label: "A\\text{ n'est pas inversible}",
+            labelType: "tex",
+            mathfieldInstructions: {
+                content: "A\\text{ n'est pas inversible}",
+                method: "write",
+            },
+        },
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    if (answer === "A\\text{ n'est pas inversible}") {
+        return ans === answer;
+    }
+    else {
+        try {
+            const matAns = parseMatrix(ans);
+            const matAnswer = parseMatrix(answer);
+            return matAns.equals(matAnswer);
+        }
+        catch (e) {
+            handleVEAError(e);
+            return false;
+        }
+    }
+};
+const createRandomIdentifiers = () => {
+    const matA = MatrixConstructor.random(2, 2);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixComputeInverseOfMat2Question = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+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;
+};
+export const matrixComputeInverseOfMat2 = {
+    id: "matrixComputeInverseOfMat2",
+    connector: "=",
+    label: "Calculer l'inverse d'une matrice carrée d'ordre $2$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixComputeInverseOfMat2Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { MatrixIdentifiers } from "../../../math/matrices/matrix.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    matIdsA: MatrixIdentifiers;
+    matIdsB: MatrixIdentifiers;
+    nodeIdsKA: NodeIdentifiers;
+    nodeIdsKB: NodeIdentifiers;
+};
+type Options = {
+    typeLinComb: string;
+};
+export declare const matrixComputeLinearCombination: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=matrixComputeLinearCombination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matrixComputeLinearCombination.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/matrixComputeLinearCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;CAC5B,CAAC;AA8PF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAgBF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzE,CAAC"}

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