math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/functions/composition/functionComposition.js

@@ -0,0 +1,238 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { realize } from "../../../../math/utils/latex/realize.js";
+import { isFunctionNode, } from "../../../../tree/nodes/functions/functionNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+// import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode } from "../../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex({ forceParenthesis: true }).replaceAll("x", `("${strVar}")`));
+};
+const functionNameForFunctionId = (functionId) => {
+    return [
+        "opposite",
+        "sqrt",
+        "cos",
+        "sin",
+        "tan",
+        "log",
+        "log10",
+        "exp",
+        "abs",
+        "arcsin",
+        "arccos",
+        "arctan",
+    ][functionId];
+};
+const extractElementaryFunctionNamesDict = (nodes, functionNamesDictIn = {}) => {
+    let functionNamesDict = functionNamesDictIn;
+    nodes.forEach((node) => {
+        if (isFunctionNode(node)) {
+            const functionId = node.id;
+            const functionName = functionNameForFunctionId(functionId);
+            if (!(functionName in functionNamesDict)) {
+                functionNamesDict[functionName] = functionName;
+            }
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.child], functionNamesDict));
+        }
+        else if (isOperatorNode(node)) {
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.leftChild, node.rightChild], functionNamesDict));
+        }
+    });
+    return functionNamesDict;
+};
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soient $u$ et $v$ deux fonctions telles que, pour tout $x$ réel :
+  
+$$
+u(x)=${nodeU.toTex()}
+$$
+
+$$
+v(x)=${nodeV.toTex()}
+$$
+
+Pour tout $x$ réel, donner l'expression de $u \\circ v(x)$.`;
+};
+const getHint = () => {
+    return `Pour tout $x$ réel on a: 
+  
+$$
+u \\circ v(x) = u(v(x))
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrayRHS = [
+        ...new Set([
+            ...(isOperatorNode(nodeV)
+                ? [`${nodeU.toTex().replaceAll("x", `(${nodeV.toTex()})`)}`]
+                : []),
+            getAnswer(identifiers),
+        ]).values(),
+    ];
+    return `Pour tout réel $x$, on a :
+  
+${alignTex([
+        [`u \\circ v(x)`, `=`, `u(v(x))`],
+        [``, `=`, `${nodeU.toTex().replaceAll("x", "v(x)")}`],
+        ...arrayRHS.map((rhs) => [``, `=`, rhs]),
+    ])}`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `${nodeBySubstitutingX(nodeU.simplify(), nodeV.simplify().toTex())
+        .simplify()
+        .toTex()}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    // return (
+    //   substract(nodeAns.simplify(), nodeAnswer.simplify())
+    //     .simplify()
+    //     .evaluate() === 0
+    // );
+    // return (
+    //   nodeAns.simplify().toMathString() === nodeAnswer.simplify().toMathString()
+    // );
+    //
+    //  Une façon de savoir que expr1(x) et expr2(x) sont équivalentes:
+    //  x|->expr1(expr2(x)) doit être la même fonction que x|->expr2(expr1(x))
+    const nodeAnsOfAnswer = nodeBySubstitutingX(nodeAns.simplify(), nodeAnswer.simplify().toTex()).simplify();
+    const nodeAnswerOfAns = nodeBySubstitutingX(nodeAnswer.simplify(), nodeAns.simplify().toTex()).simplify();
+    return [0, 1, 1000].every((x) => {
+        return (substract(nodeAnsOfAnswer.evaluate({ x }), nodeAnswerOfAns.evaluate({ x })).evaluate() === 0);
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const wrongTexs = [
+        //mauvais ordre
+        `${nodeBySubstitutingX(nodeV, nodeU.toTex()).toTex({
+            forceParenthesis: true,
+        })}`,
+        `${nodeBySubstitutingX(nodeV, nodeU.toTex()).simplify().toTex()}`,
+        //multiplication
+        `${multiply(nodeU, nodeV).toTex({
+            forceParenthesis: true,
+        })}`,
+        //\\circ is 0
+        `${multiply(nodeU, multiply(0, nodeV)).toTex({
+            forceTimesSign: true,
+            forceParenthesis: true,
+        })}`,
+        //substitution littéraire
+        `${nodeU
+            .toTex({ forceParenthesis: true })
+            .replaceAll("x", `${nodeV.toTex()}`)}`,
+        `${nodeU
+            .toTex({ forceParenthesis: true })
+            .replaceAll("x", `${nodeV.toTex()}`)}`,
+    ];
+    wrongTexs.forEach((wrongTex) => {
+        tryToAddWrongProp(propositions, wrongTex);
+    });
+    if (propositions.length < n) {
+        [
+            `${nodeBySubstitutingX(nodeU, nodeU.toTex()).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingX(nodeU, nodeU.toTex()).simplify().toTex()}`,
+            `${nodeBySubstitutingX(nodeV, nodeV.toTex()).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingX(nodeV, nodeV.toTex()).simplify().toTex()}`,
+        ].forEach((wrongTex) => {
+            tryToAddWrongProp(propositions, wrongTex);
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const functionNamesDict = extractElementaryFunctionNamesDict(nodes);
+    return [
+        "x",
+        ...Object.values(functionNamesDict).map((functionName) => {
+            return {
+                id: "custom",
+                label: functionName,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: functionName,
+                },
+            };
+        }),
+    ];
+};
+const getFunctionCompositionQuestion = (_) => {
+    function getRandomNode() {
+        return random([
+            ...[
+                `x`,
+                realize({ a: "I" })(`x+a`),
+                realize({ a: "I" })(`ax`),
+                realize({ a: "I", b: "I" })(`ax+b`),
+                realize({ a: "I", b: "I" })(`(ax+b)^2`),
+                realize({ a: "RI", b: "RI" })(`(x+a)(x+b)`),
+                `\\sin(x)`,
+                realize({ a: "I" })(`\\sin(ax)`),
+                `\\cos(x)`,
+                realize({ a: "I" })(`\\sin(ax)`),
+            ].map((tex) => parseAlgebraic(tex)),
+            //! TODO: simplify({maxSimplificationSteps: 100}) to allow using fracs
+            // frac(randomNodeWithType("I"), "x"),
+            // frac(1, "x"),
+        ]);
+    }
+    const [nodeU, nodeV] = [0, 1].map(() => getRandomNode());
+    const identifiers = {
+        nodeIds: [nodeU, nodeV].map((node) => node.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const functionComposition = {
+    id: "functionComposition",
+    label: "Déterminer l'expression d'une fonction composée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionCompositionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,2 @@
+export * from "./functionComposition.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/functions/composition/index.js

@@ -0,0 +1 @@
+export * from "./functionComposition.js";

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

@@ -14,4 +14,5 @@ export * from "./sign/index.js";
 export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
+export * from "./composition/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

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

@@ -14,3 +14,4 @@ export * from "./sign/index.js";
 export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
+export * from "./composition/index.js";

package/lib/exercises/math/functions/trinoms/roots/rootsFromDevForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4GF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsFromDevForm.js

@@ -2,9 +2,11 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exer
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
-import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { a, b, c } = identifiers;
     const trinom = new Trinom(a, b, c);
@@ -49,20 +51,43 @@ const getPropositions = (n, { answer }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { a, b, c }) => {
-    // try {
-    //   const parsed = discreteSetParser(ans);
-    //   if (!parsed) return false;
-    //   return (
-    //     "S=" + parsed.simplify({ decimalToFractions: true }).toTex() === answer
-    //   );
-    // } catch (err) {
-    //   return handleVEAError(err);
-    // }
-    const trinom = new Trinom(a, b, c);
-    const roots = trinom.getRootsNode();
-    const answer = new EquationSolutionNode(new DiscreteSetNode(roots));
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        const trinom = new Trinom(a, b, c);
+        const roots = trinom.getRootsNode();
+        return isArrayOfNodesValid(parsed.elements, roots);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const isArrayOfNodesValid = (arrAns, arrAnswer) => {
+    //tried with toAllValidTexs() but there is always an unhandled case
+    function isNodesEqual(node1, node2) {
+        return [1, 1_000, 1_000_000].every((factor) => substract(multiply(factor, node1), multiply(factor, node2)).evaluate() === 0);
+    }
+    const dictAnswer = Object.fromEntries(arrAnswer.map((node, i) => [i, node]));
+    let isValid = true;
+    for (let i = 0; i < arrAns.length; i++) {
+        const nodeAns = arrAns[i];
+        let isFound = false;
+        const keys = Object.keys(dictAnswer);
+        for (let j = 0; j < keys.length; j++) {
+            const key = keys[j];
+            const answerNode = dictAnswer[key];
+            if (isNodesEqual(nodeAns, answerNode)) {
+                isFound = true;
+                delete dictAnswer[key]; //one-to-one correspondence
+                break;
+            }
+        }
+        isValid = isValid && isFound;
+        if (!isValid)
+            break;
+    }
+    return isValid;
 };
 export const rootsFromDevForm = {
     id: "rootsFromDevForm",

package/lib/exercises/math/functions/trinoms/roots/rootsReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsReading.js

@@ -80,8 +80,9 @@ const isAnswerValid = (ans, { a, b, c }) => {
         return ans === "\\text{Aucun}";
     }
     const studentNumbers = ans
-        .replaceAll("\\text{ }", "")
-        .split("\\text{ et }")
+        .replaceAll("\\text{", "")
+        .replaceAll("}", "") //as long as there's no \\frac{}{} involved, it's ok
+        .split("et")
         .map((n) => Number(n.replace(",", ".")))
         .filter((n) => !isNaN(n))
         .sort((a, b) => a - b);

package/lib/exercises/math/functions/trinoms/sign/trinomSignFromFacto.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../../exercises/exercise.js";
 type Identifiers = {
     trinomCoeffs: number[];
     isAskingPositive: boolean;
+    isStrict: boolean;
 };
 export declare const trinomSignFromFacto: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/trinoms/sign/trinomSignFromFacto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinomSignFromFacto.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/trinomSignFromFacto.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAyHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAqBrD,CAAC"}
+{"version":3,"file":"trinomSignFromFacto.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/trinomSignFromFacto.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgJF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAqBrD,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/trinomSignFromFacto.js

@@ -8,11 +8,12 @@ import { UnionIntervalNode } from "../../../../../tree/nodes/sets/unionIntervalN
 import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { unionIntervalParser } from "../../../../../tree/parsers/unionIntervalParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
-const getPropositions = (n, { answer, trinomCoeffs, isAskingPositive }) => {
+const getPropositions = (n, { answer, trinomCoeffs, isAskingPositive, isStrict }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
-    tryToAddWrongProp(propositions, getAnswer({ trinomCoeffs, isAskingPositive: !isAskingPositive }));
+    tryToAddWrongProp(propositions, getAnswer({ trinomCoeffs, isAskingPositive: !isAskingPositive, isStrict }));
+    tryToAddWrongProp(propositions, getAnswer({ trinomCoeffs, isAskingPositive, isStrict: !isStrict }));
     tryToAddWrongProp(propositions, new IntervalNode(trinom.a, trinom.b, ClosureType.FF).toTex());
     propWhile(propositions, n, () => {
         const interval = IntervalNodeConstructor.random();
@@ -21,36 +22,41 @@ const getPropositions = (n, { answer, trinomCoeffs, isAskingPositive }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswerNode = (identifiers) => {
-    const trinom = TrinomNodeConstructor.fromCoeffs(identifiers.trinomCoeffs);
+    const { trinomCoeffs, isAskingPositive, isStrict } = identifiers;
+    const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
     const roots = trinom.getRoots();
-    const a = identifiers.trinomCoeffs[2];
-    return a > 0 === identifiers.isAskingPositive
+    const a = trinomCoeffs[2];
+    return a > 0 === isAskingPositive
         ? new UnionIntervalNode([
-            new IntervalNode(MinusInfinityNode, roots[0], ClosureType.OF),
-            new IntervalNode(roots[1], PlusInfinityNode, ClosureType.FO),
+            new IntervalNode(MinusInfinityNode, roots[0], isStrict ? ClosureType.OO : ClosureType.OF),
+            new IntervalNode(roots[1], PlusInfinityNode, isStrict ? ClosureType.OO : ClosureType.FO),
         ])
-        : new IntervalNode(roots[0], roots[1], ClosureType.FF);
+        : new IntervalNode(roots[0], roots[1], isStrict ? ClosureType.OO : ClosureType.FF);
 };
 const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).toTex();
 };
 const getInstruction = (identifiers) => {
-    const trinom = TrinomNodeConstructor.fromCoeffs(identifiers.trinomCoeffs);
+    const { trinomCoeffs, isAskingPositive, isStrict } = identifiers;
+    const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
     return `Soit $f$ une fonction polynôme de degré $2$ définie sur $\\mathbb{R}$ par :
   
 $$
 f(x) = ${trinom.toFactorized().toTex()}
 $$
 
-Sur quel(s) intervalle(s) les valeurs de la fonction $f$ sont-elles ${identifiers.isAskingPositive ? "positives" : "négatives"} ?`;
+Sur quel(s) intervalle(s) les valeurs de la fonction $f$ sont-elles 
+${isStrict ? "strictement" : ""} ${isAskingPositive ? "positives" : "négatives"} 
+?`;
 };
 const getHint = () => {
     return `Une fonction polynôme de degré $2$ est du signe de son coefficient $a$, sauf entre ses racines.`;
 };
 const getCorrection = (identifiers) => {
-    const trinom = TrinomNodeConstructor.fromCoeffs(identifiers.trinomCoeffs);
+    const { trinomCoeffs, isAskingPositive, isStrict } = identifiers;
+    const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
     const roots = trinom.getRoots();
-    const a = identifiers.trinomCoeffs[2];
+    const a = trinomCoeffs[2];
     const answer = getAnswer(identifiers);
     const ineqSign = a > 0 ? ">" : "<";
     const sign = a > 0 ? "positive" : "négative";
@@ -60,7 +66,7 @@ Ici, $a = ${a}${ineqSign}0$, et les racines de $f$ sont $${roots[0].toTex()}$ et
 
 $f$ est donc ${sign} sauf sur l'intervalle $${new IntervalNode(roots[0], roots[1], ClosureType.FF).toTex()}$.
 
-On en déduit que $f$ est ${identifiers.isAskingPositive ? "positive" : "négative"} sur : 
+On en déduit que $f$ est ${isStrict ? "strictement" : ""} ${isAskingPositive ? "positive" : "négative"} sur : 
   
 $$
 ${answer}
@@ -83,8 +89,10 @@ const isAnswerValid = (ans, { answer }) => {
 const getTrinomSignFromFactoQuestion = () => {
     const trinom = TrinomNodeConstructor.randomNiceRoots(2);
     const isAskingPositive = coinFlip();
+    const isStrict = coinFlip();
     const identifiers = {
         isAskingPositive,
+        isStrict,
         trinomCoeffs: trinom.getCoeffs(),
     };
     return getQuestionFromIdentifiers(identifiers);

package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.d.ts

@@ -0,0 +1,23 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { LineIdentifiers } from "../../../../math/geometry/line.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type IntersectionIds = {
+    center: PointIdentifiers;
+    lineH: LineIdentifiers;
+    lineV: LineIdentifiers;
+};
+type Identifiers = {
+    isParallel: boolean;
+    angleType: "alternes-internes" | "correspondants" | "alternes-externes" | "autres";
+    arrIntersectionIds: IntersectionIds[];
+    arrAngleIndex: number[];
+    arrAngleForLabel: number[] | undefined;
+};
+type Options = {
+    angleTypes: ("alternes-internes" | "correspondants" | "alternes-externes" | "autres")[];
+    isFakeDisplay: boolean;
+    nbDigits: 0 | 1 | 2;
+};
+export declare const anglesUsingIsParallel: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=anglesUsingIsParallel.d.ts.map

package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anglesUsingIsParallel.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/anglesUsingIsParallel.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuItC,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AA6HF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EACL,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CAAC;IAGb,kBAAkB,EAAE,eAAe,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,EAAE,CAAC;IAGxB,gBAAgB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CACxC,CAAC;AAwMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,CACR,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CACX,EAAE,CAAC;IACJ,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB,CAAC;AA2NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}