math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,144 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../exercises/vea/rationalVEA.js";
+import { Vector, VectorConstructor } from "../../../math/geometry/vector.js";
+import { MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { binom, isBinomialCoefficientNode, } from "../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, VectorConstructor.random("u").toBinomCoords().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    //u = (I-A)^(-1) * b
+    const { aIds, bIds } = identifiers;
+    const a = MatrixConstructor.fromIdentifiers(aIds);
+    const b = MatrixConstructor.fromIdentifiers(bIds);
+    const id = MatrixConstructor.identity(2);
+    const sub = id.substract(a).simplify();
+    const inv = sub.toInversed().simplify();
+    const u = inv.matrixProduct(b).simplify();
+    const vec = binom(u.elements[0][0], u.elements[1][0]);
+    return vec.toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = MatrixConstructor.fromIdentifiers(aIds);
+    const b = MatrixConstructor.fromIdentifiers(bIds);
+    return `Soient :
+
+$$
+A=${a.toTex()}, B=${b.toTex()} 
+$$
+
+Déterminer une matrice colonne $U$ tel que :
+
+$$
+U = AU+B
+$$
+`;
+};
+const getHint = () => {
+    return `Isole $U$ d'un côté de l'équation. Puis, utilise la calculatrice pour déterminer l'inverse d'une certaine matrice.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = MatrixConstructor.fromIdentifiers(aIds);
+    const b = MatrixConstructor.fromIdentifiers(bIds);
+    const id = MatrixConstructor.identity(2);
+    const iMinusA = id.substract(a);
+    const inv = iMinusA.toInversed().simplify();
+    return `On a : 
+  
+${alignTex([
+        ["U=AU+B", "\\iff", "U-AU=B"],
+        ["", "\\iff", "(I_2-A)U=B"],
+    ])}
+
+donc $U = (I_2-A)^{-1}B$.
+
+Or, 
+
+$$
+I_2-A = ${iMinusA.toTex()} = ${iMinusA.simplify().toTex()}
+$$
+
+Avec la calculatrice, ou en résolvant un système d'équations, on trouve : 
+
+$$
+(I_2-A)^{-1} = ${inv.toTex()}
+$$
+
+et donc 
+
+$$
+U = ${inv.toTex()}${b.toTex()} = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return ["binom"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const sol = parseAlgebraic(answer);
+        const solVector = new Vector("u", sol.leftChild, sol.rightChild);
+        const parsed = parseAlgebraic(ans);
+        if (!isBinomialCoefficientNode(parsed))
+            return false;
+        const vec = new Vector("u", parsed.leftChild, parsed.rightChild).simplify();
+        return (rationalVEA(solVector.x.toTex(), vec.x.toTex()) &&
+            rationalVEA(solVector.y.toTex(), vec.y.toTex()));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getComputeFixedMatrixInRecurrenceSequenceQuestion = () => {
+    const iMinusA = MatrixConstructor.randomInversible(2, 2, {
+        niceInversible: true,
+    });
+    const id = MatrixConstructor.identity(2);
+    const a = id.substract(iMinusA).simplify();
+    const b = MatrixConstructor.random(2, 1);
+    const identifiers = {
+        aIds: a.toIdentifiers(),
+        bIds: b.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 computeFixedMatrixInRecurrenceSequence = {
+    id: "computeFixedMatrixInRecurrenceSequence",
+    connector: "=",
+    label: "Déterminer une matrice $U$ tel que $U = AU+B$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComputeFixedMatrixInRecurrenceSequenceQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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