math-exercises 3.0.125 → 3.0.126

package/lib/exercises/pc/optics/lensFormula.js

@@ -0,0 +1,415 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { EqualNode } from "../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { InfinityNode, MinusInfinityNode, } from "../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../utils/alea/random.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const optsDefault = {
+    typeDistance: [
+        "distance focale",
+        "distance objet",
+        "distance image",
+    ],
+    typeImage: [
+        "réelle finie",
+        "réelle infinie",
+        "imaginaire finie",
+        "imaginaire infinie",
+    ],
+    unit: ["cm", "m"],
+    roundTo: [0, 1, 2],
+};
+const options = [
+    {
+        id: "typeDistance",
+        label: "Distance à calculer",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.typeDistance,
+        values: ["distance focale", "distance objet", "distance image"],
+    },
+    {
+        id: "typeImage",
+        label: "Type d'image",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.typeImage,
+        values: [
+            "réelle finie",
+            "réelle infinie",
+            "imaginaire finie",
+            "imaginaire infinie",
+        ],
+    },
+    {
+        id: "unit",
+        label: "unité de mesure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.unit,
+        values: ["cm", "m"],
+    },
+    {
+        id: "roundTo",
+        label: "Arrondir à (nombre de décimales)",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: optsDefault.roundTo,
+        values: [0, 1, 2],
+    },
+];
+const getLensFormulaEqualNode = () => {
+    const equation = new EqualNode(frac(1, "\\overline {OA'}"), add(frac(1, "\\overline {OF'}"), frac(1, "\\overline {OA}")));
+    return equation;
+};
+const getInstruction = (identifiers) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    const strRounTo = (() => {
+        switch (opts.roundTo) {
+            case 0:
+                return "à l'unité";
+            case 1:
+                return "au dixième";
+            case 2:
+                return "au centième";
+        }
+    })();
+    let strOAPrime = `$${nodeOAPrime.simplify().toTex()}${opts.unit}$`;
+    let strOA = `$${nodeOA.simplify().toTex()}${opts.unit}$`;
+    const strOFPrime = `$${nodeOFPrime.simplify().toTex()}${opts.unit}$`;
+    if (strOAPrime.includes("\\infty")) {
+        strOAPrime = "à l'infini";
+    }
+    if (strOA.includes("\\infty")) {
+        strOA = "à l'infini";
+    }
+    const strLensType = nodeOFPrime.evaluate() >= 0 ? "convergente" : "divergente";
+    switch (opts.typeDistance) {
+        case "distance focale": {
+            return `Calculer la distance focale algébrique de la lentille, en $${opts.unit}$, arrondie ${strRounTo}, 
+sachant que la position algébrique de l'objet de l'objet $AB$ est ${strOA}, 
+et que la position algébrique de l'image $A'$ est ${strOAPrime}.`;
+        }
+        case "distance image": {
+            return `Calculer la position algébrique de l'image $A'$ de l'objet $AB$, en $${opts.unit}$, arrondie ${strRounTo}, 
+situé algébriquement à ${strOA} 
+d'une lentille ${strLensType} ayant une distance focale de ${strOFPrime}.`;
+        }
+        case "distance objet": {
+            return `Calculer la position algébrique $A$ de l'objet $AB$, en $${opts.unit}$, arrondie ${strRounTo}, 
+sachant que la position algébrique de l'image $A'$ est ${strOAPrime}, 
+et que la distance focale algébrique est ${strOFPrime}.`;
+        }
+    }
+};
+const getHint = () => {
+    return `Relation de conjugaison de Descartes : 
+  
+$$
+${getLensFormulaEqualNode().toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    const answer = getAnswer(identifiers);
+    return `La relation de conjugaison de Descartes s'écrit : 
+  
+$$
+${getLensFormulaEqualNode().toTex()}
+$$
+
+Dans notre cas : 
+
+${(() => {
+        switch (opts.typeDistance) {
+            case "distance focale":
+                return alignTex([
+                    [
+                        `\\frac{1}{\\overline {OF'}}`,
+                        `=`,
+                        `\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OA}}`,
+                    ],
+                    [
+                        `\\overline {OF'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OA}}}`,
+                    ],
+                    [
+                        `\\overline {OF'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{${nodeOAPrime.toTex()}} - \\frac{1}{${nodeOA.toTex()}}}`,
+                    ],
+                    [`\\overline {OF'}`, `=`, answer.replaceAll("$", "")],
+                ]);
+            case "distance image":
+                return alignTex([
+                    [
+                        `\\overline {OA'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{\\overline {OF'}} + \\frac{1}{\\overline {OA}}}`,
+                    ],
+                    [
+                        `\\overline {OA'}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{${nodeOFPrime.toTex()}} + \\frac{1}{${nodeOA.toTex()}}}`,
+                    ],
+                    [`\\overline {OA'}`, `=`, answer.replaceAll("$", "")],
+                ]);
+            case "distance objet":
+                return alignTex([
+                    [
+                        `\\frac{1}{\\overline {OA}}`,
+                        `=`,
+                        `\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OF'}}`,
+                    ],
+                    [
+                        `\\overline {OA}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{\\overline {OA'}} - \\frac{1}{\\overline {OF'}}}`,
+                    ],
+                    [
+                        `\\overline {OA}`,
+                        `=`,
+                        `\\frac{1} {\\frac{1}{${nodeOAPrime.toTex()}} - \\frac{1}{${nodeOFPrime.toTex()}}}`,
+                    ],
+                    [`\\overline {OA}`, `=`, answer.replaceAll("$", "")],
+                ]);
+        }
+    })()}`;
+};
+const getAnswer = (identifiers) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    return `${round((() => {
+        switch (opts.typeDistance) {
+            case "distance focale":
+                return nodeOFPrime;
+            case "distance image":
+                return nodeOAPrime;
+            case "distance objet":
+                return nodeOA;
+        }
+    })().evaluate(), opts.roundTo).frenchify()}${opts.unit}`;
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { opts } = identifiers;
+    if (!ans.endsWith(opts.unit))
+        return false;
+    const ansNumber = parseFloat(ans.replace(opts.unit, ""));
+    const answerNumber = parseFloat(answer.replace(opts.unit, ""));
+    return ansNumber === answerNumber;
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { OFPrime, OA, OAPrime, opts } = identifiers;
+    const nodeOFPrime = NodeConstructor.fromIdentifiers(OFPrime);
+    const nodeOA = NodeConstructor.fromIdentifiers(OA);
+    const nodeOAPrime = NodeConstructor.fromIdentifiers(OAPrime);
+    let propositions = [];
+    function toUnitedTex(tex) {
+        return `${tex}${opts.unit}`;
+    }
+    addValidProp(propositions, answer, "tex");
+    switch (opts.typeDistance) {
+        case "distance focale":
+            {
+                function tryToAddWrongProps(roundTo) {
+                    //x = A + B
+                    tryToAddWrongProp(propositions, toUnitedTex(round(add(nodeOAPrime, nodeOA).evaluate(), roundTo).frenchify()));
+                    //erreur d'inverse
+                    tryToAddWrongProp(propositions, toUnitedTex(round(nodeOFPrime.rightChild.evaluate(), roundTo).frenchify()));
+                    //erreur de signe
+                    tryToAddWrongProp(propositions, toUnitedTex(round(frac(1, add(frac(1, nodeOAPrime.evaluate()), frac(1, nodeOA.evaluate()))).evaluate(), roundTo).frenchify()));
+                }
+                //erreurs d'arrondis
+                [0, 1, 2].forEach((roundTo) => {
+                    tryToAddWrongProps(roundTo);
+                });
+            }
+            break;
+        case "distance image":
+            {
+                function tryToAddWrongProps(roundTo) {
+                    //x = A + B
+                    tryToAddWrongProp(propositions, toUnitedTex(round(add(nodeOFPrime, nodeOA).evaluate(), roundTo).frenchify()));
+                    //erreur d'inverse
+                    tryToAddWrongProp(propositions, toUnitedTex(round(frac(1, nodeOAPrime).evaluate(), roundTo).frenchify()));
+                    //erreur de signe
+                    tryToAddWrongProp(propositions, toUnitedTex(round(substract(frac(1, nodeOFPrime.evaluate()), frac(1, nodeOA.evaluate())).evaluate(), roundTo).frenchify()));
+                }
+                //erreurs d'arrondis
+                [0, 1, 2].forEach((roundTo) => {
+                    tryToAddWrongProps(roundTo);
+                });
+            }
+            break;
+        case "distance objet":
+            {
+                function tryToAddWrongProps(roundTo) {
+                    //x = A + B
+                    tryToAddWrongProp(propositions, toUnitedTex(round(add(nodeOAPrime, nodeOFPrime).evaluate(), roundTo).frenchify()));
+                    //erreur d'inverse
+                    tryToAddWrongProp(propositions, toUnitedTex(round(nodeOA.rightChild.evaluate(), roundTo).frenchify()));
+                    //erreur de signe
+                    tryToAddWrongProp(propositions, toUnitedTex(round(frac(1, add(frac(1, nodeOAPrime.evaluate()), frac(1, nodeOFPrime.evaluate()))).evaluate(), roundTo).frenchify()));
+                }
+                //erreurs d'arrondis
+                [0, 1, 2].forEach((roundTo) => {
+                    tryToAddWrongProps(roundTo);
+                });
+            }
+            break;
+    }
+    propositions = propositions.filter((proposition) => !proposition.statement.includes("NaN"));
+    return shuffleProps(propositions, nbProps);
+};
+const getLensFormulaQuestion = (optsIn) => {
+    const optsInRetyped = optsIn
+        ? {
+            typeDistance: optsIn?.typeDistance,
+            typeImage: optsIn?.typeImage,
+            unit: optsIn?.unit,
+            roundTo: (optsIn?.roundTo)
+                .filter((a) => typeof a === "string")
+                .map((str) => +str),
+        }
+        : undefined;
+    console.log("optsIn", optsIn);
+    console.log("optsInRetyped", optsInRetyped);
+    let nodeOFPrime = NaN.toTree();
+    let nodeOA = NaN.toTree();
+    let nodeOAPrime = NaN.toTree();
+    let opts;
+    function getRandomNodes() {
+        opts = optsInRetyped
+            ? {
+                typeDistance: random(optsInRetyped.typeDistance),
+                typeImage: random(optsInRetyped.typeImage),
+                unit: random(optsInRetyped.unit),
+                roundTo: random(optsInRetyped.roundTo),
+            }
+            : {
+                typeDistance: random(optsDefault.typeDistance),
+                typeImage: random(optsDefault.typeImage),
+                unit: random(optsDefault.unit),
+                roundTo: random(optsDefault.roundTo),
+            };
+        console.log("opts", opts);
+        //objet réel:    \\overline {OA}  < 0
+        //image réelle : \\overline {OA'} > 0
+        function factorNodeForTypeImage(typeImage) {
+            let factorNode;
+            switch (typeImage) {
+                case "réelle finie":
+                    factorNode = (+1).toTree();
+                    break;
+                case "réelle infinie":
+                    factorNode = (-1).toTree();
+                    break;
+                case "imaginaire finie":
+                    factorNode = InfinityNode;
+                    break;
+                case "imaginaire infinie":
+                    factorNode = MinusInfinityNode;
+                    break;
+            }
+            return factorNode;
+        }
+        switch (opts.typeDistance) {
+            case "distance focale":
+                {
+                    nodeOA = (-randint(1, 10)).toTree();
+                    nodeOAPrime = multiply(factorNodeForTypeImage(opts.typeImage), randint(1, 10, [-nodeOA.evaluate()]).toTree()).simplify();
+                    const equalNode = getLensFormulaEqualNode();
+                    nodeOFPrime = frac(1, substract(equalNode.leftChild.evaluate({
+                        "\\overline {OA'}": nodeOA.evaluate(),
+                    }), equalNode.rightChild.rightChild.evaluate({
+                        "\\overline {OA}": nodeOAPrime.evaluate(),
+                    })));
+                }
+                break;
+            case "distance image":
+                {
+                    nodeOA = (-randint(1, 10)).toTree();
+                    nodeOFPrime = multiply(factorNodeForTypeImage(opts.typeImage), randint(1, 10, [-nodeOA.evaluate()]).toTree()).simplify();
+                    const equalNode = getLensFormulaEqualNode();
+                    nodeOAPrime = frac(1, equalNode.rightChild.evaluate({
+                        "\\overline {OA}": nodeOA.evaluate(),
+                        "\\overline {OF'}": nodeOFPrime.evaluate(),
+                    }));
+                }
+                break;
+            case "distance objet":
+                {
+                    nodeOAPrime = multiply(factorNodeForTypeImage(opts.typeImage), randint(1, 10).toTree()).simplify();
+                    nodeOFPrime = randint(1, 10, [-nodeOAPrime.evaluate()]).toTree();
+                    const equalNode = getLensFormulaEqualNode();
+                    nodeOA = frac(1, substract(equalNode.leftChild.evaluate({
+                        "\\overline {OA'}": nodeOAPrime.evaluate(),
+                    }), equalNode.rightChild.leftChild.evaluate({
+                        "\\overline {OF'}": nodeOFPrime.evaluate(),
+                    })));
+                }
+                break;
+        }
+    }
+    function checkValidNodes() {
+        const isContainingNaN = [nodeOA, nodeOAPrime, nodeOFPrime].some((node) => isNaN(node.evaluate()));
+        const valueOFPrime = nodeOFPrime.evaluate();
+        const isFocalInfinite = valueOFPrime === -Infinity || valueOFPrime == Infinity;
+        return !isContainingNaN && !isFocalInfinite;
+    }
+    do {
+        getRandomNodes();
+    } while (!checkValidNodes());
+    return getQuestionFromIdentifiers({
+        OFPrime: nodeOFPrime.toIdentifiers(),
+        OA: nodeOA.toIdentifiers(),
+        OAPrime: nodeOAPrime.toIdentifiers(),
+        opts: opts,
+    }, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        answer: getAnswer(identifiers),
+    };
+    return question;
+};
+export const lensFormula = {
+    id: "lensFormula",
+    label: "Exploiter la relation de conjugaison de Descartes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLensFormulaQuestion(opts), nb, 30, () => false),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/weight/calculateWeight.d.ts

@@ -1,7 +1,14 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     mass: number;
+    optsIdent: Options;
 };
-export declare const calculateWeight: Exercise<Identifiers>;
+type InputType = "decimal" | "sci";
+type NbDigitsType = 0 | 1 | 2;
+type Options = {
+    inputType: InputType;
+    nbDigits: NbDigitsType;
+};
+export declare const calculateWeight: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=calculateWeight.d.ts.map

package/lib/exercises/pc/weight/calculateWeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA+FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,SAAS,GAAG,SAAS,GAAG,KAAK,CAAC;AACnC,KAAK,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE9B,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,YAAY,CAAC;CACxB,CAAC;AAuMF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc1D,CAAC"}

package/lib/exercises/pc/weight/calculateWeight.js

@@ -1,21 +1,62 @@
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
 import { earthGravity } from "../../../pc/constants/gravity.js";
+import { random } from "../../../utils/alea/random.js";
 const g = +earthGravity.measure.significantPart.toFixed(2);
+const optsDefault = {
+    inputType: "sci",
+    nbDigits: 2,
+};
+const options = [
+    {
+        id: "inputType",
+        label: "Format de la réponse",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["decimal", "sci"],
+        defaultValue: [optsDefault.inputType],
+    },
+    {
+        id: "nbDigits",
+        label: "Nombre de décimales",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [0, 1, 2],
+        defaultValue: [optsDefault.nbDigits],
+    },
+];
 const getInstruction = (identifiers) => {
-    const { mass } = identifiers;
+    const { mass, optsIdent } = identifiers;
     const instruction = `Soit un objet avec une masse de $${mass}\\ \\textrm{kg}$.
+
+L'accélération due à la gravité vaut $${g.frenchify()}$ $\\textrm{m} \\cdot \\textrm{s}^{${-2}}$. 
   
-Calculer le poids de cet objet.`;
+Calculer le poids de cet objet en Newtons.
+Donner le résultat 
+${(() => {
+        switch (optsIdent.inputType) {
+            case "decimal":
+                return `en écriture décimale`;
+            case "sci":
+                return `en écriture scientifique`;
+        }
+    })()}
+${(() => {
+        switch (optsIdent.nbDigits) {
+            case 0:
+                return `arrondie à l'unité`;
+            case 1:
+                return `arrondie à une décimale`;
+            case 2:
+                return `arrondie à deux décimales`;
+        }
+    })()}.
+`;
     return instruction;
 };
-const getAnswer = (identifiers) => {
-    const { mass } = identifiers;
-    const answer = (mass * g).toScientific(2);
-    return answer.toTex();
-};
 const getHint = () => {
     const hint = `Le poids $P$ se calcule en utilisant la formule :
   
@@ -27,7 +68,7 @@ où
 
 - m est la masse de l'objet (en $\\textrm{kg}$).
 
-- g est l'accélération due à la gravité (en $\\textrm{m} \\cdot \\textrm{s}^${-1}$).`;
+- g est l'accélération due à la gravité (en $\\textrm{m} \\cdot \\textrm{s}^{${-2}}$).`;
     return hint;
 };
 const getCorrection = (identifiers) => {
@@ -42,52 +83,85 @@ $$
 On a : 
 
 $$
-P = ${mass.frenchify()} \\times ${g.frenchify()} \\Rightarrow P=${answer}\\ \\textrm{N}
+P = ${mass.frenchify()} \\times ${g.frenchify()} \\Rightarrow P=${answer}
 $$`;
     return correction;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getAnswer = (identifiers) => {
+    const { mass, optsIdent } = identifiers;
+    switch (optsIdent.inputType) {
+        case "decimal": {
+            const answer = round(mass * g, optsIdent.nbDigits);
+            return `${answer.frenchify()}N`;
+        }
+        case "sci": {
+            const answer = (mass * g).toScientific(optsIdent.nbDigits);
+            return `${answer.toTex()}N`;
+        }
+    }
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getPropositions = (n, { answer, mass, optsIdent }) => {
+    const propositions = [];
+    const weight = mass * g;
+    addValidProp(propositions, answer);
+    switch (optsIdent.inputType) {
+        case "decimal":
+            {
+                tryToAddWrongProp(propositions, `${round(weight * 10, optsIdent.nbDigits).frenchify()}N`);
+                tryToAddWrongProp(propositions, `${round(randfloat(weight - 100, weight + 100, 2, [weight]) / 10, optsIdent.nbDigits).frenchify()}N`);
+                propWhile(propositions, n, () => {
+                    const random = randfloat(weight - 50, weight + 50, 2, [weight]);
+                    tryToAddWrongProp(propositions, `${round(random, optsIdent.nbDigits).frenchify()}N`);
+                });
+            }
+            break;
+        case "sci":
+            {
+                tryToAddWrongProp(propositions, `${(weight * 10).toScientific(optsIdent.nbDigits).toTex()}N`);
+                tryToAddWrongProp(propositions, `${(randfloat(weight - 100, weight + 100, 2, [weight]) / 10)
+                    .toScientific(optsIdent.nbDigits)
+                    .toTex()}N`);
+                propWhile(propositions, n, () => {
+                    const random = randfloat(weight - 50, weight + 50, 2, [weight]);
+                    tryToAddWrongProp(propositions, `${random.toScientific(optsIdent.nbDigits).toTex()}N`);
+                });
+            }
+            break;
+    }
+    return shuffleProps(propositions, n);
+};
+const getCalculateWeightQuestion = (optsIn) => {
+    const opts = optsIn
+        ? Object.assign(optsDefault, {
+            inputType: random(optsIn.inputType),
+            nbDigits: +random(optsIn.nbDigits),
+        })
+        : optsDefault;
+    const mass = randint(30, 151);
+    const identifiers = { mass: mass, optsIdent: opts };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: [],
+        keys: ["N"],
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
         answerFormat: "tex",
         identifiers,
+        options: opts,
     };
     return question;
 };
-const getCalculateWeightQuestion = () => {
-    const mass = randint(30, 151);
-    const identifiers = { mass: mass };
-    return getQuestionFromIdentifiers(identifiers);
-};
-const getPropositions = (n, { answer, mass }) => {
-    const propositions = [];
-    const weight = mass * g;
-    addValidProp(propositions, answer);
-    generatePropositions(mass).forEach((value) => tryToAddWrongProp(propositions, value));
-    propWhile(propositions, n, () => {
-        const random = randfloat(weight - 50, weight + 50, 2, [weight]);
-        tryToAddWrongProp(propositions, random.toScientific(2).toTex());
-    });
-    return shuffleProps(propositions, n);
-};
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-const generatePropositions = (mass) => {
-    const weight = mass * g;
-    const first = (weight * 10).toScientific(2);
-    const second = (randfloat(weight - 100, weight + 100, 2, [weight]) / 10).toScientific(2);
-    return [first.toTex(), second.toTex()];
-};
 export const calculateWeight = {
     id: "calculateWeight",
     label: "Calculer le poids d'un objet",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getCalculateWeightQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateWeightQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -95,4 +169,5 @@ export const calculateWeight = {
     subject: "Physique",
     hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
+    options,
 };

package/lib/geogebra/parsers/geogebraParser.d.ts

@@ -3,5 +3,9 @@ export declare class GeogebraParser {
     constructor(studentCommands: string[]);
     pointCoords(name: string): number[] | undefined;
     vectors(): number[][];
+    objectDict(): {
+        [k: string]: string;
+    };
+    static pointNamesForLineObj(lineObj: string): string[];
 }
 //# sourceMappingURL=geogebraParser.d.ts.map

package/lib/geogebra/parsers/geogebraParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraParser.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/geogebraParser.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACP,eAAe,EAAE,MAAM,EAAE;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM;IAWxB,OAAO;CAwCR"}
+{"version":3,"file":"geogebraParser.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/geogebraParser.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACP,eAAe,EAAE,MAAM,EAAE;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM;IAWxB,OAAO;IAyCP,UAAU;;;IAWV,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM;CAS5C"}

package/lib/geogebra/parsers/geogebraParser.js

@@ -56,4 +56,21 @@ export class GeogebraParser {
         }
         return res;
     }
+    objectDict() {
+        return Object.fromEntries(this.commands
+            .filter((command) => command.includes("="))
+            .map((definitionCommand) => {
+            const [name, obj] = definitionCommand.split("=");
+            return [name, obj];
+        }));
+    }
+    static pointNamesForLineObj(lineObj) {
+        const reLine = /^Line\[\s*([^,\]]+)\s*,\s*([^,\]]+)\s*\]$/;
+        const match = lineObj.match(reLine);
+        if (!match) {
+            return [];
+        }
+        const [, nameA, nameB] = match;
+        return [nameA, nameB];
+    }
 }