math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,155 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../utils/alea/random.js";
+import { zip } from "../../../utils/arrays/arrayZip.js";
+const _isMatrixSymH = (mat) => {
+    return zip(mat.elements, mat.elements.toReversed()).every(([row1, row2]) => zip(row1, row2).every(([node1, node2]) => NodeComparator.isEqualViaSub(node1, node2)));
+};
+const _isMatrixSymV = (mat) => {
+    return _isMatrixSymV(mat.transposed());
+};
+const isMatrixSymMat = (mat) => {
+    return mat.equals(mat.transposed());
+};
+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()}
+$$
+
+La matrice $A$ est-elle symétrique ?`;
+};
+const getAnswer = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return isMatrixSymMat(matA) ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `Une matrice est symétrique si elle est égale à sa transposée.
+Les symétries axiales n'ont rien à voir avec cette qualification.`;
+};
+const getCorrection = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return `On a :
+  
+$$
+{}^{t}A = ${matA.transposed().toTex()}
+$$
+
+${(() => {
+        if (isMatrixSymMat(matA)) {
+            return `On a $A = {}^{t}A$. La matrice est donc symétrique.`;
+        }
+        else {
+            return `On a $A \\neq {}^{t}A$. La matrice n'est donc pas symétrique.`;
+        }
+    })()}
+
+`;
+};
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = () => {
+    const createMatWithSymH = (nbRows, nbCols) => {
+        const nbRowsTop = Math.floor(nbRows / 2);
+        const nbRowsCenter = nbRows - 2 * nbRowsTop;
+        const elementsTop = MatrixConstructor.random(nbRowsTop, nbCols).elements;
+        const elementsCenter = nbRowsCenter > 0
+            ? MatrixConstructor.random(nbRowsCenter, nbCols).elements
+            : [];
+        const elements = [
+            ...elementsTop,
+            ...elementsCenter,
+            ...elementsTop.toReversed(),
+        ];
+        const mat = new Matrix(elements);
+        return mat;
+    };
+    const matA = (() => {
+        const typeSym = random([
+            "symH",
+            "symV",
+            "symMat",
+            "square",
+        ]);
+        switch (typeSym) {
+            case "symH": {
+                const nbRows = randint(3, 6);
+                const nbCols = randint(3, 6);
+                return createMatWithSymH(nbRows, nbCols);
+            }
+            case "symV": {
+                const nbRows = randint(3, 6);
+                const nbCols = randint(3, 6);
+                return createMatWithSymH(nbRows, nbCols).transposed();
+            }
+            case "symMat": {
+                const dim = randint(3, 6);
+                const matRandom = MatrixConstructor.random(dim, dim);
+                return matRandom
+                    .add(matRandom.transposed())
+                    .simplify({ towardsDistribute: true });
+            }
+            case "square": {
+                const dim = randint(3, 6);
+                const matRandom = MatrixConstructor.random(dim, dim);
+                return matRandom.simplify({ towardsDistribute: true });
+            }
+        }
+    })();
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixCheckIsSymmetricalQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, optsIn) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: optsIn,
+    };
+    return question;
+};
+export const matrixCheckIsSymmetrical = {
+    id: "matrixCheckIsSymmetrical",
+    connector: "=",
+    label: "Déterminer si une matrice est symétrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixCheckIsSymmetricalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/matrices/matrixComputeDetOfMat2.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 matrixComputeDetOfMat2: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=matrixComputeDetOfMat2.d.ts.map

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

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

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