math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,232 @@
+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 { probaLawFlip } from "../../../utils/alea/probaLawFlip.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, indexAsked } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    const nameVertexAsked = graph.vertexNames[indexAsked];
+    const arrNameVertexAdjacent = graph.getArrVertexNameAdjacent(nameVertexAsked);
+    return {
+        graph,
+        nameVertexAsked,
+        arrNameVertexAdjacent,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nameVertexAsked } = getHydrated(identifiers);
+    return `Un graphe est représenté ci-dessous.
+Quel est le degré du sommet $${nameVertexAsked}$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { arrNameVertexAdjacent } = getHydrated(identifiers);
+    return arrNameVertexAdjacent.length.toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Le degré d'un sommet est le nombre d'arêtes incidentes à ce sommet, sans tenir compte de leur sens de parcours.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameVertexAsked, arrNameVertexAdjacent } = getHydrated(identifiers);
+    const nbAdjacent = arrNameVertexAdjacent.length;
+    return `Le sommet $${nameVertexAsked}$ a pour ${nbAdjacent === 1 ? "sommet adjacent" : "sommets adjacents"} ${joinanded(arrNameVertexAdjacent.map((nameVertex) => `$${nameVertex}$`), ", ", " et ")}.
+  
+Le degré de $${nameVertexAsked}$ est donc $${nbAdjacent.frenchify()}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { graphNodes, graphEdges } = identifiers;
+    const { graph, nameVertexAsked } = 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: point.name === nameVertexAsked ? greenMain : "#000000",
+    }));
+    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})`,
+            ...(e.from === nameVertexAsked || e.to === nameVertexAsked
+                ? [`SetColor(edge${i + 1}, "${greenMain}")`]
+                : []),
+        ];
+    });
+    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 { graph, nameVertexAsked } = getHydrated(identifiers);
+    //student: d -> d+ or d -> d-
+    if (graph.isDirected) {
+        const [_, dMinus, dPlus] = graph.getArrDegreeOfVertex(nameVertexAsked);
+        const [isAddWrongPropDMinus, isAddWrongPropDPlus] = probaLawFlip([
+            [[true, false], 0.4],
+            [[false, true], 0.4],
+            [[true, true], 0.2],
+        ]);
+        if (isAddWrongPropDMinus) {
+            tryToAddWrongProp(propositions, dMinus.frenchify());
+        }
+        if (isAddWrongPropDPlus) {
+            tryToAddWrongProp(propositions, dPlus.frenchify());
+        }
+    }
+    //student: degree of other vertex
+    {
+        [...Array(graph.vertexNames.length).keys()].forEach((index) => {
+            const identifiersWrong = {
+                ...identifiers,
+                indexAsked: index,
+            };
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        const dWrong = randint(1, 10);
+        tryToAddWrongProp(propositions, dWrong.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 indexAsked = randint(0, nbVertices);
+    const { nodes: graphNodes, edges: graphEdges } = GraphRenderer.renderToNodesAndEdges(graph);
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        indexAsked,
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsDegreeOfVertexQuestion = (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 graphsDegreeOfVertex = {
+    id: "graphsDegreeOfVertex",
+    label: "Déterminer le degré du sommet d'un graphe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsDegreeOfVertexQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { GraphIdentifiers } from "../../../math/graphs/graph.js";
+import { GraphEdge, GraphNode } from "../../../math/utils/graphs/graphRenderer.js";
+type Identifiers = {
+    graphIds: GraphIdentifiers;
+    graphNodes: GraphNode[];
+    graphEdges: GraphEdge[];
+};
+type Options = {
+    graphType: string;
+};
+export declare const graphsOrderOfGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=graphsOrderOfGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsOrderOfGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsOrderOfGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAAoB,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EACL,SAAS,EACT,SAAS,EAEV,MAAM,0CAA0C,CAAC;AAUlD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAG3B,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AAoPF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsBF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}

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