math-exercises 3.0.189 → 3.0.191

package/lib/exercises/math/functions/exponentials/realPowersFraction.js

@@ -0,0 +1,125 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.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 { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../../utils/isInt.js";
+const getPropositions = (n, { answer, aIds, xIds, yIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    tryToAddWrongProp(propositions, power(a, add(x, y)).simplify().toTex());
+    tryToAddWrongProp(propositions, power(a, multiply(x, y)).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, power(a, randfloat(0.1, 5, 1)).simplify().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return power(a, substract(x, y)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Écrire sous la forme d'une seule puissance : 
+  
+$$
+${frac(power(a, x), power(a, y)).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Utilise la propriété suivante : pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+$$
+\\frac{a^x}{a^y}= a^{x-y}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+    
+$$
+\\frac{a^x}{a^y}= a^{x-y}
+$$
+  
+Ici, on a donc : 
+
+$$
+${frac(power(a, x), power(a, y)).toTex()} = ${power(a, substract(x, y)).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify({ forbidPowerDivision: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRealPowersFractionQuestion = () => {
+    const a = randfloat(0.1, 5, 1, [1]);
+    let x = doWhile(() => randfloat(0.1, 5, 1), (v) => isInt(v));
+    let y = randfloat(0.1, 5, 1);
+    if (coinFlip())
+        [x, y] = [y, x]; //comme ca l'éventuel entier est n'importe ou
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        xIds: x.toTree().toIdentifiers(),
+        yIds: y.toTree().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 realPowersFraction = {
+    id: "realPowersFraction",
+    connector: "=",
+    label: "Simplifier une division de puissances réelles",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRealPowersFractionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponentials/realPowersMixOperations.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    xIds: NodeIdentifiers;
+    yIds: NodeIdentifiers;
+    zIds: NodeIdentifiers;
+    tIds: NodeIdentifiers;
+};
+export declare const realPowersMixOperations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=realPowersMixOperations.d.ts.map

package/lib/exercises/math/functions/exponentials/realPowersMixOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realPowersMixOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/realPowersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAwIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

package/lib/exercises/math/functions/exponentials/realPowersMixOperations.js

@@ -0,0 +1,148 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../../utils/isInt.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, aIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, power(a, randfloat(0.1, 5, 1)).simplify().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const statement = getStatement(identifiers);
+    return statement.simplify().toTex();
+};
+const getStatement = (identifiers) => {
+    const { aIds, tIds, xIds, yIds, zIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    const z = reifyAlgebraic(zIds);
+    const t = reifyAlgebraic(tIds);
+    return frac(multiply(power(power(a, x), y), power(a, z)), power(a, t));
+};
+const getInstruction = (identifiers) => {
+    return `Écrire sous la forme d'une seule puissance :
+  
+$$
+${getStatement(identifiers).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Utilise les propriétés suivantes : pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+- $a^x\\times a^y = a^{x+y}$
+- $\\frac{a^x}{a^y}= a^{x-y}$
+- $\\left(a^x\\right)^y = a^{x\\times y}$`;
+};
+const getCorrection = (identifiers) => {
+    //(a^x)^y*a^z / a^t
+    const statement = getStatement(identifiers);
+    return `Pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+- $a^x\\times a^y = a^{x+y}$
+- $\\frac{a^x}{a^y}= a^{x-y}$
+- $\\left(a^x\\right)^y = a^{x\\times y}$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            statement.toTex(),
+            "=",
+            statement
+                .simplify({
+                forbidPowerDivision: true,
+                forbidPowerMultiply: true,
+            })
+                .toTex(),
+        ],
+        [
+            "",
+            "=",
+            statement
+                .simplify({
+                forbidPowerDivision: true,
+            })
+                .toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            forbidPowerDivision: true,
+            forbidPowerMultiply: true,
+            forbidPowerPower: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRealPowersMixOperationsQuestion = () => {
+    const a = randfloat(0.1, 5, 1, [1]);
+    let x = doWhile(() => randfloat(0.1, 5, 1), (v) => isInt(v));
+    let y = randfloat(0.1, 5, 1);
+    let z = randfloat(0.1, 5, 1);
+    let t = randfloat(0.1, 5, 1);
+    [x, y, z, t] = shuffle([x, y, z, t]);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        xIds: x.toTree().toIdentifiers(),
+        yIds: y.toTree().toIdentifiers(),
+        tIds: t.toTree().toIdentifiers(),
+        zIds: z.toTree().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 realPowersMixOperations = {
+    id: "realPowersMixOperations",
+    connector: "=",
+    label: "Simplifier un mélange de calculs avec des puissances réelles",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRealPowersMixOperationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponentials/realPowersPower.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    xIds: NodeIdentifiers;
+    yIds: NodeIdentifiers;
+};
+export declare const realPowersPower: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=realPowersPower.d.ts.map

package/lib/exercises/math/functions/exponentials/realPowersPower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realPowersPower.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/realPowersPower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA0HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

package/lib/exercises/math/functions/exponentials/realPowersPower.js

@@ -0,0 +1,128 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../../utils/isInt.js";
+const getPropositions = (n, { answer, aIds, xIds, yIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    tryToAddWrongProp(propositions, power(a, substract(x, y)).simplify().toTex());
+    tryToAddWrongProp(propositions, power(a, add(x, y)).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, power(a, randfloat(0.1, 5, 1)).simplify().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return power(a, multiply(x, y)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Écrire sous la forme d'une seule puissance : 
+  
+$$
+${power(power(a, x), y).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Utilise la propriété suivante : pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+$$
+\\left(a^x\\right)^y = a^{x\\times y}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+    
+$$
+\\left(a^x\\right)^y = a^{x\\times y}
+$$
+  
+Ici, on a donc : 
+
+$$
+${power(power(a, x), y).toTex()} = ${power(a, multiply(x, y)).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            forbidPowerPower: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRealPowersFractionQuestion = () => {
+    const a = randfloat(0.1, 5, 1, [1]);
+    let x = doWhile(() => randfloat(0.1, 5, 1), (v) => isInt(v));
+    let y = randfloat(0.1, 5, 1);
+    if (coinFlip())
+        [x, y] = [y, x]; //comme ca l'éventuel entier est n'importe ou
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        xIds: x.toTree().toIdentifiers(),
+        yIds: y.toTree().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 realPowersPower = {
+    id: "realPowersPower",
+    connector: "=",
+    label: "Simplifier une puissance de puissances réelles",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRealPowersFractionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponentials/realPowersProduct.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    xIds: NodeIdentifiers;
+    yIds: NodeIdentifiers;
+};
+export declare const realPowersProduct: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=realPowersProduct.d.ts.map

package/lib/exercises/math/functions/exponentials/realPowersProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realPowersProduct.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/realPowersProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAuHF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

package/lib/exercises/math/functions/exponentials/realPowersProduct.js

@@ -0,0 +1,128 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../../utils/isInt.js";
+const getPropositions = (n, { answer, aIds, xIds, yIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    tryToAddWrongProp(propositions, power(a, substract(x, y).simplify()).toTex());
+    tryToAddWrongProp(propositions, power(a, multiply(x, y).simplify()).toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, power(a, randfloat(0.1, 5, 1)).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return power(a, add(x, y)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Écrire sous la forme d'une seule puissance : 
+  
+$$
+${multiply(power(a, x), power(a, y)).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Utilise la propriété suivante : pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+$$
+a^x\\times a^y = a^{x+y}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+$$
+a^x\\times a^y = a^{x+y}
+$$
+
+Ici, on a donc : 
+
+$$
+${multiply(power(a, x), power(a, y)).toTex()} = ${power(a, add(x, y)).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            forbidPowerMultiply: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRealPowersProductQuestion = () => {
+    const a = randfloat(0.1, 5, 1, [1]);
+    let x = doWhile(() => randfloat(0.1, 5, 1), (v) => isInt(v));
+    let y = randfloat(0.1, 5, 1);
+    if (coinFlip())
+        [x, y] = [y, x]; //comme ca l'éventuel entier est n'importe ou
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        xIds: x.toTree().toIdentifiers(),
+        yIds: y.toTree().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 realPowersProduct = {
+    id: "realPowersProduct",
+    connector: "=",
+    label: "Simplifier un produit de puissances réelles",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRealPowersProductQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}
+{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.js

@@ -1,6 +1,7 @@
 import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
 import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
@@ -88,10 +89,10 @@ const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
             0.2 * axisUnitNode.evaluate());
 };
 const getPlaceAbscissOnSemiLineV2Question = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
     const opts = {
-        questionType: random(arrayedOptions.questionType),
-        numberType: random(arrayedOptions.numberType),
+        questionType: random(arrayedOpts.questionType),
+        numberType: random(arrayedOpts.numberType),
     };
     const abscissType = (() => {
         switch (opts.numberType) {
@@ -169,7 +170,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     questionType: ["standard", "éviter le comptage"],
     numberType: ["Entiers", "Rationnels", "Décimaux"],
 };
@@ -180,7 +181,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["standard", "éviter le comptage"],
-        defaultValue: optsDefault.questionType,
+        defaultValue: arrayedOptsDefault.questionType,
     },
     {
         id: "numberType",
@@ -188,7 +189,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["Entiers", "Rationnels", "Décimaux"],
-        defaultValue: optsDefault.numberType,
+        defaultValue: arrayedOptsDefault.numberType,
     },
 ];
 export const placeAbscissOnSemiLineV2 = {

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductAlKashiBH.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAwBnD,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAopBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BjE,CAAC"}
+{"version":3,"file":"scalarProductAlKashiBH.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAwBnD,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAmpBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BjE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.js

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../../../exercises/utils/options/arrayedOptions.js";
 import { greenMain, orange } from "../../../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../../../geogebra/geogebraConstructor.js";
 import { Angle } from "../../../../../../math/geometry/angle.js";
@@ -387,8 +388,8 @@ const isAnswerValid = (ans, { answer }) => {
     }
 };
 const getScalarProductAlKashiBHQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const sectorOfPointH = random(arrayedOptions.sectorOfPointH);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const sectorOfPointH = random(arrayedOpts.sectorOfPointH);
     function createRandomPoints() {
         const offsetBtoC = 10;
         const pointB = new Point("B", randfloat(0, 10), randfloat(0, 10));

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAqBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAmeF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}
+{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAqBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAkeF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}