math-exercises 3.0.216 → 3.0.217

package/lib/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expOfFEqualsExpOfGEquation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4DrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyaF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBrE,CAAC"}
+{"version":3,"file":"expOfFEqualsExpOfGEquation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4DrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA2ZF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBrE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.js

@@ -268,6 +268,8 @@ const getKeys = (_, optsIn) => {
     ];
 };
 const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    console.log("ans", ans);
+    console.log("answer", answer);
     const opts = optsIn ?? optsDefault;
     const answerInputTypes = getAnswerInputTypes(opts);
     const answerNode = getAnswerNode(identifiers);
@@ -276,27 +278,23 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
             .elements;
         function getParsedNodesForAnswerInputType(ans, answerInputType) {
             switch (answerInputType) {
-                case "x=... ou x=...":
-                    {
-                        const formated = ans
-                            .replaceAll("text{ ou }", ";")
-                            .replaceAll("x", "")
-                            .replaceAll("=", "");
-                        const elements = formated.split(";").map((e) => parseAlgebraic(e));
-                        return elements;
+                case "x=... ou x=...": {
+                    const formated = ans
+                        .replaceAll("text{ ou }", ";")
+                        .replaceAll("x", "")
+                        .replaceAll("=", "");
+                    const elements = formated.split(";").map((e) => parseAlgebraic(e));
+                    return elements;
+                }
+                case "S={...;...}": {
+                    const discreteSetNodeCandidate = discreteSetParser(ans);
+                    if (discreteSetNodeCandidate) {
+                        return discreteSetNodeCandidate.elements;
                     }
-                    break;
-                case "S={...;...}":
-                    {
-                        const discreteSetNodeCandidate = discreteSetParser(ans);
-                        if (discreteSetNodeCandidate) {
-                            return discreteSetNodeCandidate.elements;
-                        }
-                        else {
-                            return [];
-                        }
+                    else {
+                        return [];
                     }
-                    break;
+                }
                 default:
                     throw new Error("Unsupported answerInputType: " + answerInputType);
             }
@@ -325,19 +323,8 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
     }
     else {
-        const inequationSolutionNode = answerNode;
-        const texInterval = inequationSolutionNode.intervalSolution.toTex();
-        function isAnswerValidForAnswerInputType(answerInputType) {
-            switch (answerInputType) {
-                case "x=... ou x=...":
-                    return `x\\in${texInterval}`;
-                case "S={...;...}":
-                    return `S=${texInterval}`;
-                default:
-                    throw new Error("Unsupported answerInputType: " + answerInputType);
-            }
-        }
-        return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+        //answer is mathbbR
+        return ans === answer;
     }
 };
 const getExpOfFEqualsExpOfGEquationQuestion = (optsIn) => {

package/lib/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.js

@@ -388,10 +388,10 @@ const getPropositions = (n, { answer: _answer, ...identifiers }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
+const isAnswerValid = (ans, { answer }) => {
     try {
         const nodeAns = parseAlgebraic(ans);
-        const nodeAnswer = getAnswerNode(identifiers);
+        const nodeAnswer = parseAlgebraic(answer);
         return NodeComparator.isEqualViaRandomSubstitutions(nodeAns, nodeAnswer, 3);
     }
     catch (e) {

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

@@ -0,0 +1,11 @@
+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[];
+};
+export declare const graphsCheckIsConnectedGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=graphsCheckIsConnectedGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsCheckIsConnectedGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsCheckIsConnectedGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,SAAS,EACT,SAAS,EAEV,MAAM,0CAA0C,CAAC;AASlD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAG3B,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AA2OF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAiB7D,CAAC"}

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

@@ -0,0 +1,178 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.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 { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { splitIntoRandomChunks } from "../../../utils/arrays/arrayChunks.js";
+import { joinanded } from "../../../utils/strings/joinanded.js";
+import * as Flatten from "@flatten-js/core";
+const getHydrated = (identifiers) => {
+    const { graphIds } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    return {
+        graph,
+    };
+};
+const getInstruction = () => {
+    return `Un graphe non orienté est représenté ci-dessous.
+Le graphe est-il connexe ?
+*On peut déplacer les points sur la figure.*`;
+};
+const getAnswer = (identifiers) => {
+    const { graph } = getHydrated(identifiers);
+    return graph.isWeaklyConnected() ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `Un graphe non orienté est connexe si et seulement si chaque couple de ses sommets peut être relié par une chaîne.`;
+};
+const getCorrection = (identifiers) => {
+    const { graph } = getHydrated(identifiers);
+    const arrWeaklyConnectedSubgraph = graph
+        .getWeaklyConnectedSubgraphCoveringChainsAsArrIndex()
+        .map((chain) => chain.map((index) => graph.vertexNames[index]));
+    if (graph.isWeaklyConnected()) {
+        const [chain0] = arrWeaklyConnectedSubgraph;
+        return `On peut former une chaîne qui relie tous les sommets : ${chain0
+            .map((str) => `$${str}$`)
+            .join("-")}.
+Le graphe est donc connexe.`;
+    }
+    else {
+        return `On ne peut pas former une chaîne qui relie tous les sommets.
+Le graphe contient des sous-graphes disjoints contenant les chaînes ${joinanded(arrWeaklyConnectedSubgraph.map((chain) => chain.map((str) => `$${str}$`).join("-")), ", ", " et ")}.
+Le graphe n'est donc pas connexe.`;
+    }
+};
+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 = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = () => {
+    const nbVertices = randint(7, 9);
+    const isSimple = true;
+    const minDensity = 0.4;
+    const isConnected = coinFlip();
+    const vertexNames = "ABCDEFGHIJKLM".split("").slice(0, nbVertices);
+    const { graph, graphNodes, graphEdges } = (() => {
+        let isFound = false;
+        let graph;
+        let graphNodes;
+        let arrGraphEdges;
+        while (!isFound) {
+            const graphForPoints = GraphConstructor.randomConnected(nbVertices, isSimple, false, minDensity, vertexNames);
+            const { nodes: graphNodes0, edges: graphEdges0 } = GraphRenderer.renderToNodesAndEdges(graphForPoints, "circo");
+            graphNodes = graphNodes0;
+            let arrGraphNodes; //to check overlapping
+            [graph, arrGraphEdges, arrGraphNodes] = (() => {
+                if (isConnected) {
+                    return [graphForPoints, [graphEdges0], [graphNodes0]];
+                }
+                else {
+                    const arrVertexNamesChunk = splitIntoRandomChunks(shuffle(vertexNames), 3);
+                    const arrSubGraph = arrVertexNamesChunk.map((vertexNamesChunk) => GraphConstructor.randomConnected(vertexNamesChunk.length, isSimple, false, minDensity, vertexNamesChunk));
+                    const graph = GraphConstructor.graphByMergingSimpleGraphs(arrSubGraph);
+                    const arrGraphEdges = arrSubGraph.map((graph) => graph.arrConnection().map(([from, to, _]) => {
+                        return { from, to };
+                    }));
+                    const dictGraphNodes = Object.fromEntries(graphNodes.map((graphNode) => [graphNode.label, graphNode]));
+                    const arrGraphNodes = arrSubGraph.map((graph) => graph.vertexNames.map((nameVertex) => dictGraphNodes[nameVertex]));
+                    return [graph, arrGraphEdges, arrGraphNodes];
+                }
+            })();
+            const arrGraphNodes1GraphNodes2 = [...Array(arrGraphNodes.length).keys()]
+                .flatMap((i) => [...Array(i + 1).keys()].map((j) => [i, j]))
+                .map(([i, j]) => [arrGraphNodes[i], arrGraphNodes[j]]);
+            try {
+                isFound = arrGraphNodes1GraphNodes2.every(([graphNodes1, graphNodes2]) => {
+                    const [polygon1, polygon2] = [graphNodes1, graphNodes2].map((graphNodes) => {
+                        const arrPoint = graphNodes.map(({ x, y }) => new Flatten.Point(x, y));
+                        const polygon = new Flatten.Polygon(arrPoint);
+                        return polygon;
+                    });
+                    return Flatten.Relations.intersect(polygon1, polygon2);
+                });
+            }
+            catch {
+                isFound = false;
+            }
+        }
+        const graphEdges = arrGraphEdges.reduce((acc, graphEdges) => {
+            acc = [...acc, ...graphEdges];
+            return acc;
+        }, []);
+        return { graph: graph, graphNodes: graphNodes, graphEdges };
+    })();
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsCheckIsConnectedGraphQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const graphsCheckIsConnectedGraph = {
+    id: "graphsCheckIsConnectedGraph",
+    label: "Déterminer si un graphe est connexe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsCheckIsConnectedGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

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

@@ -32,7 +32,7 @@ const getHint = () => {
 const getCorrection = (identifiers) => {
     const { graph } = getHydrated(identifiers);
     const arrWeaklyConnectedSubgraph = graph
-        .getWeaklyConnectedSubgraphChainsAsArrIndex()
+        .getWeaklyConnectedSubgraphCoveringChainsAsArrIndex()
         .map((chain) => chain.map((index) => graph.vertexNames[index]));
     if (graph.isWeaklyConnected()) {
         const [chain0] = arrWeaklyConnectedSubgraph;

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

@@ -2,7 +2,7 @@ export * from "./graphsOrderOfGraph.js";
 export * from "./graphsDegreeOfVertex.js";
 export * from "./graphsCheckIsVerticesAdjacent.js";
 export * from "./graphsCheckIsSameGraph.js";
-export * from "./graphsCheckIsConnectedUndirectedGraph.js";
+export * from "./graphsCheckIsConnectedGraph.js";
 export * from "./graphsChainOrPathOfLengthN.js";
 export * from "./edgesNumberFromSummitsDegrees.js";
 export * from "./adjacentMatrixPath.js";

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

@@ -1 +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"}
+{"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,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC"}

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

@@ -2,7 +2,7 @@ export * from "./graphsOrderOfGraph.js";
 export * from "./graphsDegreeOfVertex.js";
 export * from "./graphsCheckIsVerticesAdjacent.js";
 export * from "./graphsCheckIsSameGraph.js";
-export * from "./graphsCheckIsConnectedUndirectedGraph.js";
+export * from "./graphsCheckIsConnectedGraph.js";
 export * from "./graphsChainOrPathOfLengthN.js";
 export * from "./edgesNumberFromSummitsDegrees.js";
 export * from "./adjacentMatrixPath.js";

package/lib/exercises/math/integration/fromExpr/integralFromExpr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integralFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/integralFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAqWF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA2CF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC"}
+{"version":3,"file":"integralFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/integralFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAuWF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA2CF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC"}

package/lib/exercises/math/integration/fromExpr/integralFromExpr.js

@@ -252,7 +252,9 @@ const isIdentifiersQCPassed = (identifiers) => {
     const isExploding = (identifiers) => {
         let isExploding = false;
         try {
+            //anything that contain exploding simplify()
             getAnswer(identifiers);
+            getCorrection(identifiers);
         }
         catch (_) {
             isExploding = true;

package/lib/exercises/math/spaceGeometry/parametricLine/lineLineRelativePositionsFromParametricLines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineLineRelativePositionsFromParametricLines.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/parametricLine/lineLineRelativePositionsFromParametricLines.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAgH5C,KAAK,YAAY,GAAG;IAClB,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,sBAAsB,CAAC;CACxC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,qBAAqB,EAAE,CAAC;IACzC,YAAY,EAAE,YAAY,EAAE,CAAC;CAC9B,CAAC;AAyTF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAoB5E,CAAC"}
+{"version":3,"file":"lineLineRelativePositionsFromParametricLines.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/parametricLine/lineLineRelativePositionsFromParametricLines.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAgH5C,KAAK,YAAY,GAAG;IAClB,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,sBAAsB,CAAC;CACxC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,qBAAqB,EAAE,CAAC;IACzC,YAAY,EAAE,YAAY,EAAE,CAAC;CAC9B,CAAC;AA6XF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAoB5E,CAAC"}

package/lib/exercises/math/spaceGeometry/parametricLine/lineLineRelativePositionsFromParametricLines.js

@@ -1,8 +1,8 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { ParametricLine } from "../../../../math/geometry/parametricLine.js";
-import { SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
-import { SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector, SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
 import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
@@ -293,8 +293,61 @@ const createRandomIdentifiers = () => {
     };
     return identifiers;
 };
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            //ensure only one valid proposition
+            const n = 4;
+            const answer = getAnswer(identifiers);
+            const propositions = getPropositions(n, { answer, ...identifiers });
+            const nbRightAnswers = propositions.filter((proposition) => proposition.isRightAnswer).length;
+            if (nbRightAnswers !== 1) {
+                throw new Error("nbRightAnswers !== 1");
+            }
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = () => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const vec1 = new SpaceVector("v1", (1).toTree(), (0).toTree(), (0).toTree());
+        const vec2 = new SpaceVector("v2", (2).toTree(), (0).toTree(), (0).toTree());
+        const A = new SpacePoint("A", (0).toTree(), (1).toTree(), (0).toTree());
+        const B = new SpacePoint("B", (0).toTree(), (0).toTree(), (2).toTree());
+        const identifiersDefault = {
+            spacePointIdsAB: [A, B].map((spacePoint) => spacePoint.toIdentifiers()),
+            spaceLineIds: [
+                [A, vec1],
+                [B, vec2],
+            ].map(([spacePoint, spaceVector]) => {
+                return {
+                    spacePointIds: spacePoint.toIdentifiers(),
+                    spaceVectorIds: spaceVector.toIdentifiers(),
+                };
+            }),
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
 const getLineLineRelativePositionsFromParametricLinesQuestion = () => {
-    const identifiers = createRandomIdentifiers();
+    const identifiers = createQCPassedIdentifiers();
     return getQuestionFromIdentifiers(identifiers);
 };
 const getQuestionFromIdentifiers = (identifiers, _opts) => {

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findNormalVectorFromPlaneEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsF7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AA+QF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAmBnE,CAAC"}
+{"version":3,"file":"findNormalVectorFromPlaneEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsF7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AAuRF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAmBnE,CAAC"}

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.js

@@ -140,7 +140,9 @@ const getPropositions = (n, { answer, ...identifiers }) => {
             }
         }
     }
+    let counter = -1;
     propWhile(propositions, n, () => {
+        counter++;
         const nodeFactorW = randint(-4, 5, [0, 1]).toTree();
         const arr = [nodeA, nodeB, nodeC, nodeD].map((node) => multiply(nodeFactorW, node).simplify({ towardsDistribute: true }));
         {
@@ -160,6 +162,10 @@ const getPropositions = (n, { answer, ...identifiers }) => {
                 }
             }
         }
+        if (counter > 50) {
+            const identifiersWrong = createRandomIdentifiers();
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        }
     });
     return shuffleProps(propositions, n);
 };

package/lib/exercises/vea/treeTableVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAgB5B,CAAC"}
+{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAiB5B,CAAC"}

package/lib/exercises/vea/treeTableVEA.js

@@ -1,3 +1,4 @@
+import { percentVEA } from "./percentVEA.js";
 import { rationalVEA } from "./rationalVEA.js";
 // type Options = {
 // }
@@ -6,5 +7,6 @@ export const treeTableVEA = (ans, answerTable) => {
     //les branches peuvent commuter au sein d'un block
     //les blocks peuvent commuter au sein d'un step
     return ans.every((step, i) => step.every((block, j) => block.every((branch, k) => branch.every((value, l) => value === answerTable[i][j][k][l] ||
+        percentVEA(value, answerTable[i][j][k][l]) ||
         rationalVEA(value, answerTable[i][j][k][l])))));
 };

package/lib/math/graphs/graph.d.ts

@@ -26,7 +26,7 @@ export declare class Graph {
     densifyUpTo(minDensity: number): Graph;
     undirectedGraph(): Graph;
     isWeaklyConnected(): boolean;
-    getWeaklyConnectedSubgraphChainsAsArrIndex(): number[][];
+    getWeaklyConnectedSubgraphCoveringChainsAsArrIndex(): number[][];
     getSomePathsWithNbEdges(nbEdges: number, nbToFindIfPossible: number): number[][];
     /**
      *

package/lib/math/graphs/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/math/graphs/graph.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,MAAM,EAEN,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EAEzB,cAAc,GAAE,MAAM,EAA8B;IA6EtD,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EACzB,cAAc,GAAE,MAAM,EAA8B,EACpD,WAAW,GAAE,OAAc;IAkC7B,MAAM,CAAC,WAAW,CAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EAAE,YAA4B,EACpD,UAAU,EAAE,OAAO;IAuErB,MAAM,CAAC,0BAA0B,CAAC,QAAQ,EAAE,KAAK,EAAE;IAgCnD,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IA0BnD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAKrD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,qBAAa,KAAK;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;gBACR,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO;IAMpE,aAAa;IASb,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAmB1D,aAAa,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAc5C,OAAO,IAAI,MAAM;IAIjB,WAAW,CAAC,UAAU,EAAE,MAAM;IAc9B,eAAe,IAAI,KAAK;IASxB,iBAAiB,IAAI,OAAO;IAoC5B,0CAA0C,IAAI,MAAM,EAAE,EAAE;IA8CxD,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,EAAE;IAmCb;;;;OAIG;IACH,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE;IAqBxD,wBAAwB,CAAC,gBAAgB,EAAE,MAAM;IAUjD,+BAA+B,CAC7B,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,EAAE,OAAO;IAmB7B,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ7C,eAAe;IAWf,MAAM,CAAC,MAAM,EAAE,KAAK;CAQrB"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/math/graphs/graph.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,MAAM,EAEN,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EAEzB,cAAc,GAAE,MAAM,EAA8B;IA6EtD,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EACzB,cAAc,GAAE,MAAM,EAA8B,EACpD,WAAW,GAAE,OAAc;IAkC7B,MAAM,CAAC,WAAW,CAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EAAE,YAA4B,EACpD,UAAU,EAAE,OAAO;IAuErB,MAAM,CAAC,0BAA0B,CAAC,QAAQ,EAAE,KAAK,EAAE;IAgCnD,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IA0BnD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAKrD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,qBAAa,KAAK;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;gBACR,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO;IAMpE,aAAa;IASb,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAmB1D,aAAa,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAc5C,OAAO,IAAI,MAAM;IAIjB,WAAW,CAAC,UAAU,EAAE,MAAM;IAc9B,eAAe,IAAI,KAAK;IASxB,iBAAiB,IAAI,OAAO;IAoC5B,kDAAkD,IAAI,MAAM,EAAE,EAAE;IAuGhE,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,EAAE;IAmCb;;;;OAIG;IACH,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE;IAqBxD,wBAAwB,CAAC,gBAAgB,EAAE,MAAM;IAUjD,+BAA+B,CAC7B,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,EAAE,OAAO;IAmB7B,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ7C,eAAe;IAWf,MAAM,CAAC,MAAM,EAAE,KAAK;CAQrB"}

package/lib/math/graphs/graph.js

@@ -265,44 +265,100 @@ export class Graph {
         return visited.every((v) => v);
         //AI CODE (Edge) }
     }
-    getWeaklyConnectedSubgraphChainsAsArrIndex() {
+    getWeaklyConnectedSubgraphCoveringChainsAsArrIndex() {
         const adjMatrix = (this.isDirected ? this.undirectedGraph() : this)
             .adjacencyMatrix()
             .elements.map((row) => row.map((elt) => elt.evaluate()));
-        //AI CODE (Edge) {
-        // Validate input
-        if (!Array.isArray(adjMatrix) || adjMatrix.length === 0) {
-            throw new Error("Adjacency matrix must be a non-empty 2D array.");
-        }
         const n = adjMatrix.length;
-        if (!adjMatrix.every((row) => Array.isArray(row) && row.length === n)) {
-            throw new Error("Adjacency matrix must be square.");
-        }
-        const visited = new Array(n).fill(false);
-        const subgraphs = [];
-        // DFS to collect connected nodes
-        function dfs(node, component) {
-            visited[node] = true;
-            component.push(node);
-            for (let neighbor = 0; neighbor < n; neighbor++) {
-                if (adjMatrix[node][neighbor] !== 0 && !visited[neighbor]) {
-                    dfs(neighbor, component);
+        const linked = (i, j) => i !== j &&
+            ((adjMatrix[i]?.[j] ?? 0) !== 0 || (adjMatrix[j]?.[i] ?? 0) !== 0);
+        // Voisinage non orienté
+        const neighbors = Array.from({ length: n }, (_, i) => {
+            const list = [];
+            for (let j = 0; j < n; j++)
+                if (linked(i, j))
+                    list.push(j);
+            return list;
+        });
+        // 1. Composantes connexes
+        const seen = new Array(n).fill(false);
+        const components = [];
+        for (let start = 0; start < n; start++) {
+            if (seen[start])
+                continue;
+            const component = [];
+            const stack = [start];
+            seen[start] = true;
+            while (stack.length > 0) {
+                const node = stack.pop();
+                component.push(node);
+                for (const nb of neighbors[node]) {
+                    if (!seen[nb]) {
+                        seen[nb] = true;
+                        stack.push(nb);
+                    }
                 }
             }
+            components.push(component.sort((a, b) => a - b));
         }
-        // Find connected components
-        for (let i = 0; i < n; i++) {
-            if (!visited[i]) {
-                const component = [];
-                dfs(i, component);
-                if (component.length > 1) {
-                    // Only keep subgraphs with ≥ 2 nodes
-                    subgraphs.push(component);
+        // 2. Chaîne couvrant une composante
+        const coveringChain = (component) => {
+            if (component.length === 1)
+                return [...component];
+            // Arbre couvrant en profondeur (donne des branches longues)
+            const tree = new Map(component.map((v) => [v, []]));
+            const inTree = new Set([component[0]]);
+            const grow = (u) => {
+                for (const v of neighbors[u]) {
+                    if (!inTree.has(v)) {
+                        inTree.add(v);
+                        tree.get(u).push(v);
+                        tree.get(v).push(u);
+                        grow(v);
+                    }
                 }
-            }
-        }
-        return subgraphs;
-        //AI CODE (Edge) }
+            };
+            grow(component[0]);
+            // Sommet le plus éloigné (BFS dans l'arbre) + parents pour remonter la branche
+            const farthest = (src) => {
+                const parent = new Map([[src, -1]]);
+                const queue = [src];
+                for (let i = 0; i < queue.length; i++) {
+                    for (const v of tree.get(queue[i])) {
+                        if (!parent.has(v)) {
+                            parent.set(v, queue[i]);
+                            queue.push(v);
+                        }
+                    }
+                }
+                return { last: queue[queue.length - 1], parent };
+            };
+            // Diamètre de l'arbre : de a à b
+            const a = farthest(component[0]).last;
+            const { last: b, parent } = farthest(a);
+            const onDiameter = new Set();
+            for (let v = b; v !== -1; v = parent.get(v))
+                onDiameter.add(v);
+            // Parcours depuis a : les sous-arbres annexes d'abord (avec retour),
+            // la branche du diamètre en dernier (sans retour)
+            const chain = [];
+            const visit = (u, from) => {
+                chain.push(u);
+                const children = tree
+                    .get(u)
+                    .filter((v) => v !== from)
+                    .sort((x, y) => Number(onDiameter.has(x)) - Number(onDiameter.has(y)));
+                for (const child of children) {
+                    visit(child, u);
+                    if (!onDiameter.has(child))
+                        chain.push(u); // retour arrière
+                }
+            };
+            visit(a, -1);
+            // Normalisation : commencer par la plus petite extrémité
+            return chain[0] > chain[chain.length - 1] ? chain.reverse() : chain;
+        };
+        return components.map(coveringChain);
     }
     getSomePathsWithNbEdges(nbEdges, nbToFindIfPossible) {
         const n = nbEdges;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.216",
+  "version": "3.0.217",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [