math-exercises 3.0.198 → 3.0.200

package/lib/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.js

@@ -0,0 +1,193 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { FunctionsIds, } from "../../../../tree/nodes/functions/functionNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+const rewriteFunctionNode = (nodeFunc) => {
+    const isChildMinusSigned = nodeFunc.child
+        .simplify({ towardsDistribute: true })
+        .toTex()
+        .startsWith("-");
+    if (isChildMinusSigned) {
+        switch (nodeFunc.id) {
+            case FunctionsIds.cos:
+                return cos(opposite(nodeFunc.child).simplify());
+            case FunctionsIds.sin:
+                return opposite(sin(opposite(nodeFunc.child).simplify()));
+            default:
+                return nodeFunc;
+        }
+    }
+    else {
+        return nodeFunc;
+    }
+};
+const rewriteNodeF = (nodeF) => {
+    return multiply(rewriteFunctionNode(nodeF.leftChild), rewriteFunctionNode(nodeF.rightChild));
+};
+const getParityType = (nodeF) => {
+    const [bit1, bit2] = [
+        nodeF.leftChild,
+        nodeF.rightChild,
+    ].map((node) => (node.id === FunctionsIds.sin ? 1 : 0));
+    if ((bit1 + bit2) % 2 === 0) {
+        return "even";
+    }
+    else {
+        return "uneven";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    return `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+La fonction $f$ est-elle paire, impaire, ou ni paire ni impaire ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const type = getParityType(nodeF);
+    switch (type) {
+        case "even":
+            return "Paire";
+        case "uneven":
+            return "Impaire";
+        default:
+            return "Ni paire, ni impaire";
+    }
+};
+const getHint = () => {
+    return `Une fonction $f$ est paire si pour tout $x$ de son ensemble de définition, on a : $f(-x) = f(x)$.
+  
+Une fonction $f$ est impaire si pour tout $x$ de son ensemble de définition, on a : $f(-x) = -f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const type = getParityType(nodeF);
+    const nodeFRewritten = rewriteNodeF(nodeF);
+    const isNodeFRewritable = nodeFRewritten.toTex() !== nodeF.toTex();
+    const nodeVarX = new VariableNode("x");
+    const nodeFOfMinusX = nodeBySubstitutingVar(nodeF, opposite(nodeVarX), nodeVarX);
+    const nodeFOfMinusXRewritten1 = multiply(nodeFOfMinusX.leftChild.simplify(), nodeFOfMinusX.rightChild.simplify());
+    const nodeFOfMinusXRewritten2 = rewriteNodeF(nodeFOfMinusXRewritten1);
+    return `${isNodeFRewritable
+        ? `On peut réécrire $f(x)$ : 
+    
+${alignTex([
+            ["f(x)", "=", nodeF.toTex()],
+            ["", "=", nodeFRewritten.toTex({ forceParenthesis: true })],
+            ...(() => {
+                const texNodeFRewrittenSimplified = nodeFRewritten.simplify().toTex();
+                if (texNodeFRewrittenSimplified !==
+                    nodeFRewritten.toTex({ forceParenthesis: true })) {
+                    return [["", "=", texNodeFRewrittenSimplified]];
+                }
+                else {
+                    return [];
+                }
+            })(),
+        ])}
+
+`
+        : ``}
+  
+On exprime $f(-x)$ : 
+
+${alignTex([
+        ["f(-x)", "=", nodeFOfMinusX.toTex()],
+        ["", "=", nodeFOfMinusXRewritten1.toTex()],
+        ...(() => {
+            const texNodeFOfMinusXRewritten2 = nodeFOfMinusXRewritten2.toTex({
+                forceParenthesis: true,
+            });
+            if (texNodeFOfMinusXRewritten2 !== nodeFOfMinusXRewritten1.toTex()) {
+                return [["", "=", texNodeFOfMinusXRewritten2]];
+            }
+            else {
+                return [];
+            }
+        })(),
+        ...(() => {
+            const texNodeFOfMinusXRewritten2Simplified = nodeFOfMinusXRewritten2
+                .simplify()
+                .toTex();
+            if (texNodeFOfMinusXRewritten2Simplified !==
+                nodeFOfMinusXRewritten2.toTex({ forceParenthesis: true })) {
+                return [["", "=", texNodeFOfMinusXRewritten2Simplified]];
+            }
+            else {
+                return [];
+            }
+        })(),
+    ])}
+
+${type === "even"
+        ? "Puisque $f(-x) = f(x)$, la fonction $f$ est paire."
+        : `Puisque $f(-x) = -f(x)$, la fonction $f$ est impaire.`}
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Paire", "raw");
+    tryToAddWrongProp(propositions, "Impaire", "raw");
+    tryToAddWrongProp(propositions, "Ni paire, ni impaire", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getParityOfCosAXTimesSinBXQuestion = () => {
+    const nodeVarX = new VariableNode("x");
+    const nodeFactor1 = ((coinFlip() ? +1 : -1) * randint(1, 10)).toTree();
+    const node1 = multiply(nodeFactor1, nodeVarX);
+    const nodeFactor2 = ((coinFlip() ? +1 : -1) * randint(1, 10)).toTree();
+    const node2 = multiply(nodeFactor2, nodeVarX);
+    const [func1, func2] = random([
+        [sin, sin],
+        [sin, cos],
+        [cos, sin],
+        [cos, cos],
+    ]);
+    const nodeF = multiply(func1(node1), func2(node2));
+    const identifiers = { nodeIdsF: nodeF.toIdentifiers() };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const parityOfCosAXTimesSinBX = {
+    id: "parityOfCosAXTimesSinBX",
+    label: "Déterminer si une fonction du type $\\cos(ax) \\sin(bx)$ est paire ou impaire",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getParityOfCosAXTimesSinBXQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/index.d.ts

@@ -3122,7 +3122,9 @@ declare const mathExercises: (Exercise<{
     kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    askParticularPrimitive?: boolean;
+}> | Exercise<{
     coeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
@@ -5034,6 +5036,18 @@ declare const mathExercises: (Exercise<{
     isGreaterCond: boolean;
     k?: number;
     randListAdd: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
 }, Record<string, string | boolean | string[]>>)[];
 declare const pcExercises: (Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/sets/setOperations.d.ts

@@ -0,0 +1,9 @@
+import { DiscreteSetNode } from "../../tree/nodes/sets/discreteSetNode.js";
+import { Tuple } from "./tuple.js";
+export declare const discreteSetCartesianProduct: (...arrDiscreteSet: DiscreteSetNode[]) => Tuple[];
+export declare const randomTupleInDiscreteSetPower: (nodeDiscreteSet: DiscreteSetNode, k: number, isWithoutDuplicate: boolean, isForceDuplicate?: boolean) => Tuple;
+export declare const randomManyTuplesInDiscreteSetPower: (nodeDiscreteSet: DiscreteSetNode, k: number, nbTuples: number, isWithoutDuplicate: boolean, isForceDuplicate?: boolean) => Tuple[];
+export declare const discreteSetSubstract: (discreteSetRecipient: DiscreteSetNode, ...arrDiscreteSet: DiscreteSetNode[]) => DiscreteSetNode;
+export declare const randomCombinationFromDiscreteSet: (nodeDiscreteSet: DiscreteSetNode, k: number) => DiscreteSetNode;
+export declare const randomManyCombinationsFromDiscreteSet: (nodeDiscreteSet: DiscreteSetNode, k: number, nbMany: number) => DiscreteSetNode[];
+//# sourceMappingURL=setOperations.d.ts.map

package/lib/math/sets/setOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setOperations.d.ts","sourceRoot":"","sources":["../../../src/math/sets/setOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAO3E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,eAAO,MAAM,2BAA2B,GACtC,GAAG,gBAAgB,eAAe,EAAE,YAOrC,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,iBAAiB,eAAe,EAChC,GAAG,MAAM,EACT,oBAAoB,OAAO,EAC3B,mBAAkB,OAAe,UA0BlC,CAAC;AAEF,eAAO,MAAM,kCAAkC,GAC7C,iBAAiB,eAAe,EAChC,GAAG,MAAM,EACT,UAAU,MAAM,EAChB,oBAAoB,OAAO,EAC3B,mBAAmB,OAAO,YAqB3B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,sBAAsB,eAAe,EACrC,GAAG,gBAAgB,eAAe,EAAE,oBAWrC,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAC3C,iBAAiB,eAAe,EAChC,GAAG,MAAM,oBAeV,CAAC;AAEF,eAAO,MAAM,qCAAqC,GAChD,iBAAiB,eAAe,EAChC,GAAG,MAAM,EACT,QAAQ,MAAM,sBAuBf,CAAC"}

package/lib/math/sets/setOperations.js

@@ -0,0 +1,84 @@
+import { DiscreteSetNode } from "../../tree/nodes/sets/discreteSetNode.js";
+import { isVariableNode } from "../../tree/nodes/variables/variableNode.js";
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { random } from "../../utils/alea/random.js";
+import { shuffle } from "../../utils/alea/shuffle.js";
+import { zip } from "../../utils/arrays/arrayZip.js";
+import { getFlatCartesianProducts } from "../../utils/arrays/cartesianProducts.js";
+import { Tuple } from "./tuple.js";
+export const discreteSetCartesianProduct = (...arrDiscreteSet) => {
+    return getFlatCartesianProducts(arrDiscreteSet.map((discreteSetNode) => discreteSetNode.elements))
+        .map((arrNode) => new Tuple(arrNode))
+        .toSorted((tuple1, tuple2) => tuple1.toTex().localeCompare(tuple2.toTex()));
+};
+export const randomTupleInDiscreteSetPower = (nodeDiscreteSet, k, isWithoutDuplicate, isForceDuplicate = false) => {
+    if (isWithoutDuplicate) {
+        if (k > nodeDiscreteSet.elements.length) {
+            throw new Error("k > nodeDiscreteSet.elements.length");
+        }
+        else {
+            return new Tuple(shuffle(shuffle(nodeDiscreteSet.elements).slice(0, k)));
+        }
+    }
+    else {
+        if (isForceDuplicate) {
+            const nodeDuplicated = random(nodeDiscreteSet.elements);
+            return new Tuple(shuffle([
+                nodeDuplicated,
+                nodeDuplicated,
+                ...[...Array(k - 2).keys()].map(() => random(nodeDiscreteSet.elements)),
+            ]));
+        }
+        else {
+            return new Tuple([...Array(k).keys()].map(() => random(nodeDiscreteSet.elements)));
+        }
+    }
+};
+export const randomManyTuplesInDiscreteSetPower = (nodeDiscreteSet, k, nbTuples, isWithoutDuplicate, isForceDuplicate) => {
+    const arrTuple = [];
+    let counter = -1;
+    while (arrTuple.length < nbTuples && counter < 1000) {
+        counter++;
+        const tupleCandidate = randomTupleInDiscreteSetPower(nodeDiscreteSet, k, isWithoutDuplicate, isForceDuplicate);
+        const isTupleAlreadyAdded = () => NodeComparator.isTupleInArrTuple(tupleCandidate, arrTuple);
+        if (!isTupleAlreadyAdded()) {
+            const tuple = tupleCandidate;
+            arrTuple.push(tuple);
+        }
+    }
+    return arrTuple;
+};
+export const discreteSetSubstract = (discreteSetRecipient, ...arrDiscreteSet) => {
+    const arrNode = discreteSetRecipient.elements.filter((nodeCandidate) => !arrDiscreteSet.some((discreteSetForbidden) => discreteSetForbidden.elements.some((nodeForbidden) => NodeComparator.isEqualViaSub(nodeCandidate, nodeForbidden))));
+    return new DiscreteSetNode(arrNode);
+};
+export const randomCombinationFromDiscreteSet = (nodeDiscreteSet, k) => {
+    if (k > nodeDiscreteSet.elements.length) {
+        throw new Error("k > nodeDiscreteSet.elements.length");
+    }
+    const arrElement = shuffle(nodeDiscreteSet.elements)
+        .slice(0, k)
+        .toSorted((node1, node2) => {
+        if (isVariableNode(node1) && isVariableNode(node2)) {
+            return node1.toTex().localeCompare(node2.toTex());
+        }
+        else {
+            return NodeComparator.compareViaSub(node1, node2);
+        }
+    });
+    return new DiscreteSetNode(arrElement);
+};
+export const randomManyCombinationsFromDiscreteSet = (nodeDiscreteSet, k, nbMany) => {
+    const arrCombination = [];
+    let counter = -1;
+    while (arrCombination.length < nbMany && counter < 1000) {
+        counter++;
+        const combinationCandidate = randomCombinationFromDiscreteSet(nodeDiscreteSet, k);
+        const isCombinationAlreadyAdded = () => arrCombination.some((combinationOfArr) => zip(combinationCandidate.elements, combinationOfArr.elements).every(([node1, node2]) => NodeComparator.isEqualViaSub(node1, node2)));
+        if (!isCombinationAlreadyAdded()) {
+            const combination = combinationCandidate;
+            arrCombination.push(combination);
+        }
+    }
+    return arrCombination;
+};

package/lib/math/sets/tuple.d.ts

@@ -0,0 +1,12 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+export type TupleIdentifiers = {
+    components: NodeIdentifiers[];
+};
+export declare class Tuple {
+    components: AlgebraicNode[];
+    constructor(components: AlgebraicNode[]);
+    toTex(): string;
+    toIdentifiers(): TupleIdentifiers;
+}
+//# sourceMappingURL=tuple.d.ts.map

package/lib/math/sets/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../src/math/sets/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAQtE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AAEF,qBAAa,KAAK;IACG,UAAU,EAAE,aAAa,EAAE;gBAA3B,UAAU,EAAE,aAAa,EAAE;IAE9C,KAAK,IAAI,MAAM;IAOf,aAAa,IAAI,gBAAgB;CAKlC"}

package/lib/math/sets/tuple.js

@@ -0,0 +1,17 @@
+export class Tuple {
+    components;
+    constructor(components) {
+        this.components = components;
+    }
+    toTex() {
+        const strSeparator = ";";
+        return `\\left(${this.components
+            .map((node) => node.toTex())
+            .join(strSeparator)}\\right)`;
+    }
+    toIdentifiers() {
+        return {
+            components: this.components.map((node) => node.toIdentifiers()),
+        };
+    }
+}

package/lib/server.js

@@ -27,8 +27,9 @@ const runServer = () => {
     dotenv.config();
     const app = express();
     app.use(cors());
-    console.log("math exos", mathExercises.length);
-    console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
+    console.log("math exos", mathExercises.filter((exo) => !exo.subject || exo.subject === "Mathématiques").length);
+    console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection &&
+        (!exo.subject || exo.subject === "Mathématiques")).length);
     console.log("pc exos", `${pcExercises.length}`);
     console.log("pc hints", pcExercises.filter((exo) => exo.hasHintAndCorrection).length);
     playground();
@@ -100,6 +101,31 @@ const runServer = () => {
         const props = exo.getPropositions(n, { answer, ...identifiers }, options);
         res.json(props);
     });
+    app.get("/getOrderedItems", (req, res) => {
+        const n = Number(req.query.n) || 4;
+        const exoId = req.query.exoId;
+        const options = req.query.options
+            ? JSON.parse(decodeURIComponent(req.query.options))
+            : undefined;
+        const identifiers = req.query.identifiers
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
+            : undefined;
+        const hasAnswer = !!req.query.answer && req.query.answer !== "undefined";
+        const answer = hasAnswer
+            ? JSON.parse(decodeURIComponent(req.query.answer))
+            : "";
+        const exo = allExercises.find((exo) => exo.id == exoId);
+        if (!exo) {
+            res.send("Exo not found");
+            return;
+        }
+        if (!exo?.getOrderedItems) {
+            res.send("no getOrderedItems");
+            return;
+        }
+        const props = exo.getOrderedItems(n, { answer, ...identifiers }, options);
+        res.json(props);
+    });
     app.get("/isAnswerTableValid", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options

package/lib/tests/pdfExo.test.js

@@ -1,8 +1,8 @@
 import { buildPdfForExercise } from "./pdfs/buildPDFForExercise.js";
 import "../prototypesEnhancement.js";
-import { equationFromSignTable } from "../exercises/math/index.js";
+import { independancyFromProbaTree, } from "../exercises/math/index.js";
 try {
-    buildPdfForExercise(equationFromSignTable);
+    buildPdfForExercise(independancyFromProbaTree);
 }
 catch (err) {
     console.log(err);

package/lib/tests/pdfs/buildPDFForExercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildPDFForExercise.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/buildPDFForExercise.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAe,MAAM,6BAA6B,CAAC;AAQpE,eAAO,MAAM,mBAAmB,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC,SA8LxD,CAAC"}
+{"version":3,"file":"buildPDFForExercise.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/buildPDFForExercise.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAe,MAAM,6BAA6B,CAAC;AASpE,eAAO,MAAM,mBAAmB,GAAI,KAAK,QAAQ,CAAC,MAAM,CAAC,SAwMxD,CAAC"}

package/lib/tests/pdfs/buildPDFForExercise.js

@@ -11,6 +11,7 @@ import { signTableToLatex } from "./signTableToLatex.js";
 import { varTableToLatex } from "./varTableToLatex.js";
 import { valueTableToLatex } from "./valueTableToLatex.js";
 import { signVarTableToLatex } from "./signVarTableToLatex.js";
+import { treeDiagramToLatex } from "./treeDiagramToLatex.js";
 export const buildPdfForExercise = (exo) => {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
@@ -45,6 +46,11 @@ export const buildPdfForExercise = (exo) => {
         for (const match of signVarTableMatches) {
             question.instruction = question.instruction.replace(match[0], signVarTableToLatex(JSON.parse(match[1])));
         }
+        const treeDiagramRegex = /<svg id=["']treeDiagram["']>([\s\S]*?)<\/svg>/g;
+        const treeDiagramMatches = question.instruction.matchAll(treeDiagramRegex);
+        for (const match of treeDiagramMatches) {
+            question.instruction = question.instruction.replace(match[0], treeDiagramToLatex(match[1]));
+        }
         const formatted = formatMarkdownToLatex(question.instruction);
         content += `
       ${formatted} \n

package/lib/tests/pdfs/quizPdfPreambule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quizPdfPreambule.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/quizPdfPreambule.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,cA6E5B,CAAC"}
+{"version":3,"file":"quizPdfPreambule.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/quizPdfPreambule.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,cA8E5B,CAAC"}

package/lib/tests/pdfs/quizPdfPreambule.js

@@ -2,6 +2,7 @@ export const quizPdfPreambule = () => {
     return `\\documentclass[a4paper, 8pt]{article}
 \\usepackage[dvipsnames,table]{xcolor}
 \\usepackage{tikz}
+\\usetikzlibrary{trees}
 \\usepackage{tkz-tab}
 \\usepackage[utf8]{inputenc}
 \\usepackage[T1]{fontenc}

package/lib/tests/pdfs/treeDiagramToLatex.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param tree string[][][][] stringified, avec des £ au lieu des dollars
+ * @returns
+ *
+ * [//arbre
+ *  [//etage
+ *   [//block
+ *    [proba, event]
+ *   ]
+ *  ]
+ * ]
+ */
+export declare const treeDiagramToLatex: (tree: string) => string;
+//# sourceMappingURL=treeDiagramToLatex.d.ts.map

package/lib/tests/pdfs/treeDiagramToLatex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeDiagramToLatex.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/treeDiagramToLatex.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,WAmC9C,CAAC"}

package/lib/tests/pdfs/treeDiagramToLatex.js

@@ -0,0 +1,49 @@
+import { dollarizeString } from "./dollarizeString.js";
+/**
+ *
+ * @param tree string[][][][] stringified, avec des £ au lieu des dollars
+ * @returns
+ *
+ * [//arbre
+ *  [//etage
+ *   [//block
+ *    [proba, event]
+ *   ]
+ *  ]
+ * ]
+ */
+export const treeDiagramToLatex = (tree) => {
+    const parsedTree = JSON.parse(tree.replaceAll("£", "$"));
+    const mainEvent = dollarizeString(parsedTree[0][0][0][1]);
+    const mainProba = dollarizeString(parsedTree[0][0][0][0]);
+    const oppMainEvent = dollarizeString(parsedTree[0][0][1][1]);
+    const oppMainProba = dollarizeString(parsedTree[0][0][1][0]);
+    const firstSubEvent = dollarizeString(parsedTree[1][0][0][1]);
+    const firstSubProba = dollarizeString(parsedTree[1][0][0][0]);
+    const firstOppSubEvent = dollarizeString(parsedTree[1][0][1][1]);
+    const firstOppSubProba = dollarizeString(parsedTree[1][0][1][0]);
+    const secondSubEvent = dollarizeString(parsedTree[1][1][0][1]);
+    const secondSubProba = dollarizeString(parsedTree[1][1][0][0]);
+    const secondOppSubEvent = dollarizeString(parsedTree[1][1][1][1]);
+    const secondOppSubProba = dollarizeString(parsedTree[1][1][1][0]);
+    return `
+    
+\\begin{tikzpicture}[
+  level 1/.style={sibling distance=4cm},
+  level 2/.style={sibling distance=2cm},
+  edge from parent/.style={draw, -latex}
+]
+\\node {}
+  child { node {${mainEvent}} }
+    child { node {${firstSubEvent}} edge from parent node[left] {${firstSubProba}} }
+    child { node {${firstOppSubEvent}} edge from parent node[right] {${firstOppSubProba}} }
+    edge from parent node[left] {${mainProba}}
+  }
+  child { node {${oppMainEvent}}
+    child { node {${secondSubEvent}} edge from parent node[left] {${secondSubProba}} }
+    child { node {${secondOppSubEvent}} edge from parent node[right] {${secondOppSubProba}} }
+    edge from parent node[right] {${oppMainProba}}
+  };
+\\end{tikzpicture}    
+`;
+};

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAqU3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AA0BjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAsU3B,CAAC"}

package/lib/tests/questionTest.js

@@ -1,6 +1,25 @@
 import { latexTester } from "../latexTester.js";
 import { assertJsonStringifiable } from "./assertJsonStringifiable.js";
 import { formatMarkdownToLatex } from "./pdfs/formatMdToLatex.js";
+/* //TODO
+- tester les touches du clavier (si touche manquante erreur)
+- tests sur les tableaux (ya-t-il bien au moins un input, la structure est-elle bonne, ...)
+- tests sur les arbres (ya-t-il bien au moins un input, la structure est-elle bonne, ...)
+-
+
+*/
+/*
+touches du clavier basiques :
+0-9
+,
++-* et /
+sqrt et square
+power
+( et )
+
+un test basique serait si l'exo n'a pas de touche mais la réponse contient n'importe quel symbole hors des précédents
+c'est basique car il faudrait aussi pouvoir tester les cas où y'a des touches mais certaines manquent
+*/
 export const questionTest = (exo, question) => {
     let qcmTime = -1;
     let veaTime = -1;

package/lib/tree/utilities/nodePrinter.d.ts

@@ -0,0 +1,7 @@
+import { AlgebraicNode } from "../nodes/algebraicNode.js";
+import { OperatorNode } from "../nodes/operators/operatorNode.js";
+export declare abstract class NodePrinter {
+    static toTexWithMaxWidth(node: AlgebraicNode, maxWidth: number): string;
+    static strSymbolForOperatorNode(operatorNode: OperatorNode): string;
+}
+//# sourceMappingURL=nodePrinter.d.ts.map

package/lib/tree/utilities/nodePrinter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodePrinter.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodePrinter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAGL,YAAY,EACb,MAAM,oCAAoC,CAAC;AAG5C,8BAAsB,WAAW;IAC/B,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAsBvE,MAAM,CAAC,wBAAwB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM;CAcpE"}

package/lib/tree/utilities/nodePrinter.js

@@ -0,0 +1,36 @@
+import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
+import { alignTex } from "../../utils/latex/alignTex.js";
+export class NodePrinter {
+    static toTexWithMaxWidth(node, maxWidth) {
+        const texRaw = node.toTex();
+        if (texRaw.length < maxWidth) {
+            return texRaw;
+        }
+        if (isOperatorNode(node)) {
+            return alignTex([
+                ["", this.toTexWithMaxWidth(node.leftChild, maxWidth)],
+                [
+                    this.strSymbolForOperatorNode(node),
+                    `( ${this.toTexWithMaxWidth(node.rightChild, maxWidth - 2)} )`,
+                ],
+            ], true);
+        }
+        else {
+            return texRaw;
+        }
+    }
+    static strSymbolForOperatorNode(operatorNode) {
+        switch (operatorNode.id) {
+            case OperatorIds.add:
+                return ` + `;
+            case OperatorIds.substract:
+                return ` - `;
+            case OperatorIds.multiply:
+                return ` \\times `;
+            case OperatorIds.divide:
+                return ` \\div `;
+            default:
+                throw new Error("Unimplemented operatorNode.id: " + operatorNode.id);
+        }
+    }
+}

package/package.json

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