math-exercises 3.0.215 → 3.0.216

package/lib/exercises/math/graphs/graphsOrderOfGraph.js

@@ -0,0 +1,222 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../exercises/utils/options/arrayedOptions.js";
+import { greenMain } from "../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../math/geometry/point.js";
+import { GraphConstructor } from "../../../math/graphs/graph.js";
+import { GraphRenderer, } from "../../../math/utils/graphs/graphRenderer.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../utils/alea/probaFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { joinanded } from "../../../utils/strings/joinanded.js";
+const getHydrated = (identifiers) => {
+    const { graphIds } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    return {
+        graph,
+    };
+};
+const getInstruction = () => {
+    return `Un graphe est représenté ci-dessous.
+Quel est son ordre ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { graph } = getHydrated(identifiers);
+    return graph.vertexNames.length.toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `L'ordre d'un graphe est le nombre de sommets dont il est composé.`;
+};
+const getCorrection = (identifiers) => {
+    const { graph } = getHydrated(identifiers);
+    return `Le graphe a pour sommets ${joinanded(graph.vertexNames.map((nameVertex) => `$${nameVertex}$`), ", ", " et ")}.
+  
+L'ordre du graphe est donc $${graph.vertexNames.length.frenchify()}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { graphNodes, graphEdges } = identifiers;
+    const { graph } = getHydrated(identifiers);
+    const arrPoint = graphNodes.map(({ label, x, y }) => new Point(label, x, y));
+    const pointCommands = arrPoint.flatMap((point) => point.toGGBCommand({
+        isFixed: false,
+        isSelectionnable: true,
+        showLabel: true,
+        style: 0,
+        size: 8,
+        color: greenMain,
+    }));
+    const edgeCommands = graphEdges.flatMap((e, i) => {
+        return [
+            graph.isDirected
+                ? `edge${i + 1} = Vector(${e.from}, ${e.to})`
+                : `edge${i + 1} = Segment(${e.from}, ${e.to})`,
+        ];
+    });
+    const ggb = new GeogebraConstructor({
+        commands: [...pointCommands, ...edgeCommands],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPoint),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { graphNodes, graphEdges } = identifiers;
+    const { graph } = getHydrated(identifiers);
+    const arrPoint = graphNodes.map(({ label, x, y }) => new Point(label, x, y));
+    const pointCommands = arrPoint.flatMap((point) => point.toGGBCommand({
+        isFixed: false,
+        isSelectionnable: true,
+        showLabel: true,
+        style: 0,
+        size: 8,
+    }));
+    const edgeCommands = graphEdges.map((e, i) => graph.isDirected
+        ? `v${i + 1} = Vector(${e.from}, ${e.to})`
+        : `s${i + 1} = Segment(${e.from}, ${e.to})`);
+    const arrGGBCommandForGraph = [...pointCommands, ...edgeCommands];
+    const ggb = new GeogebraConstructor({
+        commands: [...arrGGBCommandForGraph],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPoint),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { graphEdges } = identifiers;
+    const { graph } = getHydrated(identifiers);
+    const isTerror = probaFlip(0.4);
+    //student: number of edges
+    {
+        const nbWrong = graphEdges.length;
+        tryToAddWrongProp(propositions, nbWrong.frenchify());
+        if (isTerror) {
+            if (coinFlip()) {
+                tryToAddWrongProp(propositions, (nbWrong - 1).frenchify());
+            }
+            if (coinFlip()) {
+                tryToAddWrongProp(propositions, (nbWrong + 1).frenchify());
+            }
+        }
+    }
+    //student: counting mistake (offset)
+    if (!isTerror) {
+        const nbAnswer = graph.vertexNames.length;
+        if (coinFlip()) {
+            tryToAddWrongProp(propositions, (nbAnswer - 1).frenchify());
+        }
+        if (coinFlip()) {
+            tryToAddWrongProp(propositions, (nbAnswer + 1).frenchify());
+        }
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        const nbWrong = randint(5, 15);
+        tryToAddWrongProp(propositions, nbWrong.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (isDirected) => {
+    const nbVertices = randint(5, 10);
+    const isSimple = true;
+    const minDensity = (() => {
+        switch (nbVertices) {
+            case 5:
+                return isDirected ? 0.4 : 0.62;
+            case 6:
+                return isDirected ? 0.35 : 0.57;
+            case 7:
+                return isDirected ? 0.3 : 0.52;
+            case 8:
+                return isDirected ? 0.27 : 0.37;
+            case 9:
+                return isDirected ? 0.24 : 0.32;
+        }
+    })();
+    const graph = GraphConstructor.random(nbVertices, isSimple, isDirected, minDensity, "ABCDEFGHIJKLM".split(""), true);
+    const { nodes: graphNodes, edges: graphEdges } = GraphRenderer.renderToNodesAndEdges(graph);
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsOrderOfGraphQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        graphType: random(arrayedOpts.graphType),
+    };
+    const isDirected = opts.graphType === "orienté";
+    const identifiers = createRandomIdentifiers(isDirected);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    graphType: ["non orienté"],
+};
+const options = [
+    {
+        id: "graphType",
+        label: "Types de graphes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["non orienté", "orienté"],
+        defaultValue: arrayedOptsDefault.graphType,
+    },
+];
+export const graphsOrderOfGraph = {
+    id: "graphsOrderOfGraph",
+    label: "Déterminer l'ordre d'un graphe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsOrderOfGraphQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,10 @@
+export * from "./graphsOrderOfGraph.js";
+export * from "./graphsDegreeOfVertex.js";
+export * from "./graphsCheckIsVerticesAdjacent.js";
+export * from "./graphsCheckIsSameGraph.js";
+export * from "./graphsCheckIsConnectedUndirectedGraph.js";
+export * from "./graphsChainOrPathOfLengthN.js";
+export * from "./edgesNumberFromSummitsDegrees.js";
+export * from "./adjacentMatrixPath.js";
+export * from "./eulerianChainFromAdjacentMatrix.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oCAAoC,CAAC;AACnD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC"}

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

@@ -0,0 +1,9 @@
+export * from "./graphsOrderOfGraph.js";
+export * from "./graphsDegreeOfVertex.js";
+export * from "./graphsCheckIsVerticesAdjacent.js";
+export * from "./graphsCheckIsSameGraph.js";
+export * from "./graphsCheckIsConnectedUndirectedGraph.js";
+export * from "./graphsChainOrPathOfLengthN.js";
+export * from "./edgesNumberFromSummitsDegrees.js";
+export * from "./adjacentMatrixPath.js";
+export * from "./eulerianChainFromAdjacentMatrix.js";

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

@@ -26,5 +26,6 @@ export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
 export * from "./integration/index.js";
+export * from "./graphs/index.js";
 export * from "./arithmetic/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAElC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/index.js

@@ -26,5 +26,6 @@ export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
 export * from "./integration/index.js";
+export * from "./graphs/index.js";
 // export * from "./_debug/index.js";
 export * from "./arithmetic/index.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"areMatricesInverse.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/areMatricesInverse.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAKvC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAmGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAmBpD,CAAC"}

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

@@ -0,0 +1,106 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.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 { aIds, bIds } = identifiers;
+    const a = MatrixConstructor.fromIdentifiers(aIds);
+    const b = MatrixConstructor.fromIdentifiers(bIds);
+    const inv = a.toInversed();
+    return inv.simplify().toTex() === b.simplify().toTex() ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = MatrixConstructor.fromIdentifiers(aIds);
+    const b = MatrixConstructor.fromIdentifiers(bIds);
+    return `On considère les matrices :
+
+$$
+A = ${a.toTex()}
+$$
+
+$$
+B = ${b.toTex()}
+$$
+
+$B$ est-elle la matrice inverse de $A$ ?`;
+};
+const getHint = () => {
+    return `$B$ est la matrice inverse de $A$ si et seulement si $AB = I$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = MatrixConstructor.fromIdentifiers(aIds);
+    const b = MatrixConstructor.fromIdentifiers(bIds);
+    const ab = a.matrixProduct(b);
+    const absimp = ab.simplify();
+    const isInv = absimp.isIdentity();
+    return `$B$ est la matrice inverse de $A$ si et seulement si $AB = I$.
+  
+On calcule donc le produit $AB$ :
+
+$$
+A\\times B = ${ab.toTex()}
+$$
+
+$$
+A\\times B = ${absimp.toTex()}
+$$
+
+${isInv
+        ? `On a donc $AB = I$ et donc $B$ est la matrice inverse de $A$.`
+        : `On a donc $AB \\neq I$ et donc $B$ n'est pas la matrice inverse de $A$.`}`;
+};
+const getAreMatricesInverseQuestion = () => {
+    const isInv = coinFlip();
+    const a = MatrixConstructor.randomInversible(2, 2, {
+        allowIdentity: false,
+        elementsOpts: [-5, 6],
+    });
+    const b = a.toInversed().simplify();
+    if (!isInv) {
+        b.elements[randint(0, 2)][randint(0, 2)] = add(b.elements[randint(0, 2)][randint(0, 2)], randint(-2, 2, [0])).simplify();
+    }
+    const identifiers = {
+        aIds: a.toIdentifiers(),
+        bIds: b.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const areMatricesInverse = {
+    id: "areMatricesInverse",
+    label: "Vérifier si $B$ est la matrice inverse de $A$ (matrices $2 \\times 2$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAreMatricesInverseQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"computeFixedMatrixInRecurrenceSequence.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/computeFixedMatrixInRecurrenceSequence.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAUvC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAqIF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAqBxE,CAAC"}

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