math-exercises 3.0.215 → 3.0.216

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

@@ -0,0 +1,148 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { MatrixConstructor } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { GeneralSystem, GeneralSystemConstructor, } from "../../../math/systems/generalSystem.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const matrix = MatrixConstructor.randomInversible(2, 2, {
+            niceInversible: true,
+            elementsOpts: [-10, 10, [0]],
+        });
+        const inv = matrix.toInversed().simplify();
+        tryToAddWrongProp(propositions, inv.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const matrix = system.getMatrix();
+    return matrix.toInversed().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const matrix = system.getMatrix();
+    return `On considère la matrice :
+  
+$$
+A = ${matrix.toTex()}
+$$
+
+et le système d'inconnues $x$ et $y$, où $a$ et $b$ sont des réels : 
+
+$$
+${system.toTex()}
+$$
+
+Résoudre le système, puis en déduire la matrice inverse de $A$.`;
+};
+const getHint = () => {
+    return `Commence par résoudre le système.
+  
+Puis, utilise le fait que si $A$ est inversible, alors $AX=B \\iff X = A^{-1}B$.`;
+};
+const getCorrection = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const { x, y } = system.solve();
+    const matrix = system.getMatrix();
+    return `On résout le système, on trouve : 
+  
+$$
+\\left\\{\\begin{matrix}
+x & = & ${x
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    })
+        .toTex()}\\\\
+y & = & ${y
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    })
+        .toTex()}
+\\end{matrix}\\right.
+$$
+
+Or, ce système est équivalent à $AX = B$ avec : 
+
+$$
+A=${matrix.toTex()}, X = \\begin{pmatrix}x\\\\ y\\end{pmatrix}, B =  \\begin{pmatrix}a\\\\ b\\end{pmatrix} 
+$$
+
+On a alors : 
+
+$$
+AX = B \\iff X = A^{-1} B
+$$
+
+donc 
+
+$$
+A^{-1} = ${matrix.toInversed().simplify().toTex()}
+$$`;
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindInversedMatrixFromSystemQuestion = () => {
+    const matrix = MatrixConstructor.randomInversible(2, 2, {
+        niceInversible: true,
+        elementsOpts: [-10, 10, [0]],
+    });
+    const sys = new GeneralSystem(matrix.elements.map((row, i) => [
+        ...row,
+        String.fromCharCode(97 + i).toTree(),
+    ]));
+    const identifiers = {
+        systemIds: sys.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findInversedMatrixFromSystem = {
+    id: "findInversedMatrixFromSystem",
+    connector: "=",
+    label: "Déterminer l'inverse d'une matrice en résolvant un système d'équations linéaires",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindInversedMatrixFromSystemQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,3 +1,15 @@
 export * from "./matrixInversibilityDomain.js";
 export * from "./productCell.js";
+export * from "./matrixComputeLinearCombination.js";
+export * from "./matrixComputeProduct.js";
+export * from "./matrixComputePower.js";
+export * from "./matrixBuildMatrixFromCoefficients.js";
+export * from "./matrixComputeDetOfMat2.js";
+export * from "./matrixComputeInverseOfMat2.js";
+export * from "./matrixCheckIsSymmetrical.js";
+export * from "./areMatricesInverse.js";
+export * from "./writeMatrixAssociatedToSystem.js";
+export * from "./findInversedMatrixFromSystem.js";
+export * from "./isMatrixTransitionMatrix.js";
+export * from "./computeFixedMatrixInRecurrenceSequence.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AAGjC,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wCAAwC,CAAC;AACvD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6CAA6C,CAAC"}

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

@@ -1,3 +1,15 @@
 export * from "./matrixInversibilityDomain.js";
 export * from "./productCell.js";
 // export * from "./matrixGeneralTerm.js";
+export * from "./matrixComputeLinearCombination.js";
+export * from "./matrixComputeProduct.js";
+export * from "./matrixComputePower.js";
+export * from "./matrixBuildMatrixFromCoefficients.js";
+export * from "./matrixComputeDetOfMat2.js";
+export * from "./matrixComputeInverseOfMat2.js";
+export * from "./matrixCheckIsSymmetrical.js";
+export * from "./areMatricesInverse.js";
+export * from "./writeMatrixAssociatedToSystem.js";
+export * from "./findInversedMatrixFromSystem.js";
+export * from "./isMatrixTransitionMatrix.js";
+export * from "./computeFixedMatrixInRecurrenceSequence.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"isMatrixTransitionMatrix.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/isMatrixTransitionMatrix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAUvC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AAgIF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}

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

@@ -0,0 +1,132 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { AddNode } from "../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../utils/doWhile.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { matrixIds } = identifiers;
+    const matrix = MatrixConstructor.fromIdentifiers(matrixIds);
+    return matrix.isTransition() ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { matrixIds } = identifiers;
+    const matrix = MatrixConstructor.fromIdentifiers(matrixIds);
+    return `On considère la matrice $P$ ci-dessous :
+  
+$$
+P = ${matrix.toTex()}
+$$
+
+$P$ est-elle une matrice de transition ?`;
+};
+const getHint = () => {
+    return `Une matrice de transition est une matrice associée à un graphe probabiliste, où le terme à la $i$-ème ligne et à la $j$-ème colonne est égale au poids de l'arête allant du sommet $i$ au sommet $j$ si elle existe, $0$ sinon.
+  
+Une matrice de transition est donc composée de probabilités, et la somme de chaque ligne doit valoir $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { matrixIds } = identifiers;
+    const matrix = MatrixConstructor.fromIdentifiers(matrixIds);
+    const nonProba = matrix.elements
+        .flat()
+        .find((x) => x.evaluate() < 0 || x.evaluate() > 1);
+    const lineNotOne = matrix.elements.find((line) => line.reduce((acc, el) => acc + el.evaluate(), 0) !== 1);
+    const hasNoProba = !!nonProba;
+    const hasLineNotOne = !!lineNotOne;
+    return `Une matrice est une matrice de transition si :
+  
+- elle est carrée ;
+- ses éléments sont des nombres compris entre $0$ et $1$ ;
+- la somme de chacune de ses lignes vaut $1$.
+
+La matrice proposée est bien carrée.
+
+${hasNoProba
+        ? `Cependant, au moins un de ses éléments n'est pas compris entre $0$ et $1$, puisque la matrice contient $${nonProba?.toTex()}$.
+    
+Ce n'est donc pas une matrice de transition.`
+        : `Ses éléments sont bien des nombres entre $0$ et $1$.`}
+
+${!hasNoProba &&
+        (hasLineNotOne
+            ? `Cependant, la somme d'au moins une de ses lignes de vaut pas $1$ :
+  
+$$
+${operatorComposition(AddNode, lineNotOne).toSimplificationTex()}
+$$
+
+Ce n'est donc pas une matrice de transition.
+`
+            : `La somme de chacune de ses lignes vaut bien $1$. 
+  
+C'est donc bien une matrice de transition.`)}
+`;
+};
+const getIsMatrixTransitionMatrixQuestion = () => {
+    let b;
+    let d;
+    const isTransition = coinFlip();
+    const isRational = coinFlip();
+    const getValue = () => isRational
+        ? RationalConstructor.randomIrreductibleProba().toTree()
+        : randfloat(0.01, 1, 2).toTree();
+    const a = getValue();
+    const c = getValue();
+    if (isTransition) {
+        b = substract(1, a).simplify();
+        d = substract(1, c).simplify();
+    }
+    else {
+        [b, d] = doWhile(() => [getValue(), getValue()], ([x, y]) => new Matrix([
+            [a, x],
+            [c, y],
+        ]).isTransition());
+    }
+    const identifiers = {
+        matrixIds: new Matrix([
+            [a, b],
+            [c, d],
+        ]).toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isMatrixTransitionMatrix = {
+    id: "isMatrixTransitionMatrix",
+    label: "Déterminer si une matrice est une matrice de transition",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsMatrixTransitionMatrixQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

@@ -0,0 +1,152 @@
+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 { arrayRotation } from "../../../utils/arrays/rotation.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA } = identifiers;
+    const [matA] = [matIdsA].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    const dictCoeffs = Object.fromEntries(matA.elements.flatMap((row, i) => row.map((elt, j) => [`a_{${i + 1},${j + 1}}`, elt])));
+    return {
+        matA,
+        dictCoeffs,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { dictCoeffs } = getHydrated(identifiers);
+    return `Soit :
+
+$$
+A = (a_{i,j})
+$$
+
+On donne : 
+
+${Object.entries(dictCoeffs)
+        .map(([tex, node]) => `
+  
+$$
+${tex} = ${node.toTex()}
+$$
+
+Écrire la matrice $A$.
+`)
+        .join("")}`;
+};
+const getAnswer = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return matA.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()}
+$$
+
+Dans l'expression des coefficients de $A$ (à savoir $A=(a_{ij})$), $i$ correspond à la ligne et $j$ correspond à la colonne.
+Ici, par exemple :
+
+$$
+a_{21} = c
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { matA } = getHydrated(identifiers);
+    return `Dans l'expression des coefficients de $A$ (à savoir $A=(a_{ij})$), $i$ correspond à la ligne et $j$ correspond à la colonne.
+
+$$
+A = ${matA.toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { matA } = getHydrated(identifiers);
+    //student a_{ij} -> a_{ji}
+    {
+        const matWrong = matA.transposed();
+        tryToAddWrongProp(propositions, matWrong.toTex());
+    }
+    //student: a_{12} -> a_{02}
+    {
+        const elementsShifted = arrayRotation(matA.elements, 1);
+        const matWrong = new Matrix(elementsShifted);
+        tryToAddWrongProp(propositions, matWrong.toTex());
+    }
+    //student: a_{ij} -> a_{ji} and a_{12} -> a_{02}
+    {
+        const elementsShifted = arrayRotation(matA.elements, 1);
+        const matWrong = new Matrix(elementsShifted).transposed();
+        tryToAddWrongProp(propositions, matWrong.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 matA = MatrixConstructor.random(2, 2);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixBuildMatrixFromCoefficientsQuestion = () => {
+    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 matrixBuildMatrixFromCoefficients = {
+    id: "matrixBuildMatrixFromCoefficients",
+    connector: "=",
+    label: "Écrire une matrice à partir de la donnée de ses coefficients $a_{ij}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixBuildMatrixFromCoefficientsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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