math-exercises 2.1.25 → 2.1.26-beta.10

package/lib/exercises/powers/decimalToScientific.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimalToScientific = void 0;
+const decimal_1 = require("../../math/numbers/decimals/decimal");
+const integer_1 = require("../../math/numbers/integer/integer");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const probaFlip_1 = require("../../utils/probaFlip");
+const exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const getDecimalToScientificQuestion = () => {
+    const isZero = (0, probaFlip_1.probaFlip)(0.2);
+    let intPart, dec;
+    if (isZero) {
+        dec = decimal_1.DecimalConstructor.fromParts("0", decimal_1.DecimalConstructor.randomFracPart((0, randint_1.randint)(2, 5), (0, randint_1.randint)(1, 4)));
+    }
+    else {
+        intPart = integer_1.IntegerConstructor.random((0, randint_1.randint)(2, 5));
+        dec = decimal_1.DecimalConstructor.fromParts(intPart.toString(), decimal_1.DecimalConstructor.randomFracPart((0, randint_1.randint)(1, 5)));
+    }
+    const decTex = dec.toTree().toTex();
+    const answer = dec.toScientificNotation().toTex();
+    const question = {
+        instruction: `Donner l'écriture scientifique de : $${decTex}$`,
+        startStatement: decTex,
+        answer: answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { decimal: dec.value },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, decimal }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const dec = new decimal_1.Decimal(decimal);
+    while (propositions.length < n) {
+        const wrongAnswer = new multiplyNode_1.MultiplyNode(dec.toScientificPart(), new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode((0, randint_1.randint)(-5, 5, [0, 1])))).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { decimal }) => {
+    const answerTree = new decimal_1.Decimal(decimal).toScientificNotation();
+    const texs = answerTree.toAllValidTexs({ forbidPowerToProduct: true });
+    console.log(ans, texs);
+    return texs.includes(ans);
+};
+exports.decimalToScientific = {
+    id: "decimalToScientific",
+    connector: "=",
+    label: "Passer d'écriture décimale à écriture scientifique",
+    levels: [
+        "5ème",
+        "4ème",
+        "3ème",
+        "2nde",
+        "CAP",
+        "2ndPro",
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDecimalToScientificQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/powers/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./calculateNegativePower";
+export * from "./calculatePower";
+export * from "./decimalToScientific";
+export * from "./powerDefinition";
+export * from "./powersDivision";
+export * from "./powersOfTenToDecimal";
+export * from "./powersPower";
+export * from "./powersProduct";
+export * from "./scientificToDecimal";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/powers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/powers/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculateNegativePower"), exports);
+__exportStar(require("./calculatePower"), exports);
+__exportStar(require("./decimalToScientific"), exports);
+__exportStar(require("./powerDefinition"), exports);
+__exportStar(require("./powersDivision"), exports);
+__exportStar(require("./powersOfTenToDecimal"), exports);
+__exportStar(require("./powersPower"), exports);
+__exportStar(require("./powersProduct"), exports);
+__exportStar(require("./scientificToDecimal"), exports);

package/lib/exercises/powers/powerDefinition.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    int: number;
+    power: number;
+};
+export declare const powerDefinition: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=powerDefinition.d.ts.map

package/lib/exercises/powers/powerDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powerDefinition.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/powerDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqDF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/powers/powerDefinition.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powerDefinition = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const getPowerDefinitionQuestion = () => {
+    const int = (0, randint_1.randint)(2, 11);
+    const power = (0, randint_1.randint)(2, 6);
+    let statement = "";
+    for (let i = 0; i < power; i++) {
+        statement += int + "";
+        if (i < power - 1)
+            statement += "\\times";
+    }
+    const answer = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode(power)).toTex();
+    const question = {
+        answer,
+        instruction: `Écrire sous forme de puissance : $${statement}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { int, power },
+    };
+    return question;
+};
+const isAnswerValid = (ans, { int, power }) => {
+    const answer = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode(power)).toTex();
+    return ans === answer;
+};
+const getPropositions = (n, { answer, int, power }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${power}\\times${int}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${int}\\times${power}`);
+    while (propositions.length < n) {
+        const wrongAnswer = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode((0, randint_1.randint)(2, 7))).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+exports.powerDefinition = {
+    id: "powerDefinition",
+    connector: "=",
+    label: "Écrire un produit sous forme de puissance",
+    levels: ["4ème", "3ème", "2ndPro", "CAP"],
+    isSingleStep: true,
+    sections: ["Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPowerDefinitionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/powers/powersDivision.d.ts

@@ -0,0 +1,13 @@
+/**
+ * a^b/a^c
+ */
+import { MathExercise } from "../exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const powersDivision: MathExercise<Identifiers>;
+export declare const powersOfTenDivision: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=powersDivision.d.ts.map

package/lib/exercises/powers/powersDivision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powersDivision.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/powersDivision.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAGrB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmDF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CA2BpD,CAAC;AACF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAgBzD,CAAC"}

package/lib/exercises/powers/powersDivision.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * a^b/a^c
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powersOfTenDivision = exports.powersDivision = void 0;
+const power_1 = require("../../math/numbers/integer/power");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const shuffle_1 = require("../../utils/shuffle");
+const exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const getPowersDivisionQuestion = (opts) => {
+    let a = opts.useOnlyPowersOfTen ? 10 : (0, randint_1.randint)(-11, 11, [0]);
+    const [b, c] = [1, 2].map((el) => (0, randint_1.randint)(-11, 11));
+    const statement = new fractionNode_1.FractionNode(new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(c)));
+    const answerTree = new power_1.Power(a, b - c).simplify();
+    const answer = answerTree.toTex();
+    const question = {
+        instruction: `Simplifier : $${statement.toTex()}$`,
+        startStatement: statement.toTex(),
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a, b, c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongPower = b - c + (0, randint_1.randint)(-5, 6, [0, c - b]);
+        const wrongAnswerTree = new power_1.Power(a === 1 || a === -1 ? (0, randint_1.randint)(-3, 4, [-1, 1]) : a, wrongPower).simplify(); // pour éviter les 1 1 -1 1 dans propositions
+        const wrongAnswer = wrongAnswerTree.toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const power = new power_1.Power(a, b - c);
+    const answerTree = power.simplify();
+    const texs = answerTree.toAllValidTexs();
+    const rawTex = power.toTree().toTex();
+    if (!texs.includes(rawTex))
+        texs.push(rawTex);
+    return texs.includes(ans);
+};
+exports.powersDivision = {
+    id: "powersDivision",
+    connector: "=",
+    label: "Division de puissances",
+    levels: [
+        "4ème",
+        "3ème",
+        "2nde",
+        "2ndPro",
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};
+exports.powersOfTenDivision = {
+    id: "powersOfTenDivision",
+    connector: "=",
+    label: "Division de puissances de 10",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/powers/powersOfTenToDecimal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 10^(-x) into 0,0...1
+ */
+import { MathExercise } from "../exercise";
+type Identifiers = {
+    randPower: number;
+};
+export declare const powersOfTenToDecimal: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=powersOfTenToDecimal.d.ts.map

package/lib/exercises/powers/powersOfTenToDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powersOfTenToDecimal.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/powersOfTenToDecimal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAGrB,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4CF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CA2B1D,CAAC"}

package/lib/exercises/powers/powersOfTenToDecimal.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * 10^(-x) into 0,0...1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powersOfTenToDecimal = void 0;
+const power_1 = require("../../math/numbers/integer/power");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const shuffle_1 = require("../../utils/shuffle");
+const exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const getPowersOfTenToDecimalQuestion = () => {
+    const randPower = (0, randint_1.randint)(-9, 10);
+    const statement = new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(randPower));
+    const answerTree = new power_1.Power(10, randPower).toDecimalWriting().toTree();
+    const answer = answerTree.toTex().replace(".", ",");
+    const statementTex = statement.toTex();
+    const question = {
+        instruction: `Donner l'écriture décimale de : $${statementTex}$`,
+        startStatement: statementTex,
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { randPower },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randPower }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongPower = randPower + (0, randint_1.randint)(-3, 4, [0]);
+        const wrongAnswerTree = new power_1.Power(10, wrongPower)
+            .toDecimalWriting()
+            .toTree();
+        const wrongAnswer = wrongAnswerTree.toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.replace(".", ","));
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.powersOfTenToDecimal = {
+    id: "powersOfTenToDecimal",
+    connector: "=",
+    label: "Ecriture décimale d'une puissance de 10",
+    levels: [
+        "5ème",
+        "4ème",
+        "3ème",
+        "2nde",
+        "CAP",
+        "2ndPro",
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPowersOfTenToDecimalQuestion, nb, 19),
+    qcmTimer: 60,
+    freeTimer: 60,
+    maxAllowedQuestions: 19,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/powers/powersPower.d.ts

@@ -0,0 +1,13 @@
+/**
+ * (a^b)^c
+ */
+import { MathExercise } from "../exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const powersOfTenPower: MathExercise<Identifiers>;
+export declare const powersPower: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=powersPower.d.ts.map

package/lib/exercises/powers/powersPower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powersPower.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/powersPower.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,EACL,YAAY,EASb,MAAM,aAAa,CAAC;AAErB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyDF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CA4BtD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAgBjD,CAAC"}

package/lib/exercises/powers/powersPower.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * (a^b)^c
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powersPower = exports.powersOfTenPower = void 0;
+const power_1 = require("../../math/numbers/integer/power");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const getPowersPowerQuestion = (opts) => {
+    const a = opts?.useOnlyPowersOfTen ? 10 : (0, randint_1.randint)(-11, 11, [0, 1]);
+    const [b, c] = [1, 2].map((el) => (0, randint_1.randint)(-11, 11));
+    const statement = new powerNode_1.PowerNode(new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new numberNode_1.NumberNode(c));
+    let answerTree = new power_1.Power(a, b * c).simplify();
+    const answer = answerTree.toTex();
+    const statementTex = statement.toTex();
+    const question = {
+        instruction: `Simplifier : $${statementTex}$`,
+        startStatement: statementTex,
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a, b, c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    if (a === -1) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, "1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "-1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "-2");
+    }
+    while (propositions.length < n) {
+        console.log("heeeeeer", a, b, c);
+        const wrongExponent = b * c + (0, randint_1.randint)(-11, 11, [0]);
+        const wrongAnswerTree = new power_1.Power(a, wrongExponent).simplify();
+        const wrongAnswer = wrongAnswerTree.toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const power = new power_1.Power(a, b * c);
+    const answerTree = power.simplify();
+    const texs = answerTree.toAllValidTexs();
+    const rawTex = power.toTree().toTex();
+    if (!texs.includes(rawTex))
+        texs.push(rawTex);
+    return texs.includes(ans);
+};
+exports.powersOfTenPower = {
+    id: "powersOfTenPower",
+    connector: "=",
+    label: "Puissance d'une puissance de 10 ",
+    levels: [
+        "4ème",
+        "3ème",
+        "2nde",
+        "CAP",
+        "2ndPro",
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersPowerQuestion({ useOnlyPowersOfTen: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};
+exports.powersPower = {
+    id: "powersPower",
+    connector: "=",
+    label: "Puissance d'une puissance",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersPowerQuestion({ useOnlyPowersOfTen: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/powers/powersProduct.d.ts

@@ -0,0 +1,13 @@
+/**
+ * a^b*a^c
+ */
+import { MathExercise } from "../exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const powersOfTenProduct: MathExercise<Identifiers>;
+export declare const powersProduct: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=powersProduct.d.ts.map

package/lib/exercises/powers/powersProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAIrB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuDF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CA4BxD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/powers/powersProduct.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * a^b*a^c
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powersProduct = exports.powersOfTenProduct = void 0;
+const power_1 = require("../../math/numbers/integer/power");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const shuffle_1 = require("../../utils/shuffle");
+const exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const getPowersProductQuestion = (opts) => {
+    const a = opts?.useOnlyPowersOfTen ? 10 : (0, randint_1.randint)(-11, 11, [0]);
+    const [b, c] = [1, 2].map((el) => (0, randint_1.randint)(-11, 11));
+    const statement = new multiplyNode_1.MultiplyNode(new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(c)));
+    const answerTree = new power_1.Power(a, b + c).simplify();
+    const answer = answerTree.toTex();
+    const statmentTex = statement.toTex();
+    const question = {
+        instruction: `Calculer : $${statmentTex}$`,
+        startStatement: statmentTex,
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a, b, c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongExponent = b + c + (0, randint_1.randint)(-11, 11, [0, -b - c]);
+        const wrongAnswerTree = new power_1.Power(a === 1 || a === -1 ? (0, randint_1.randint)(-3, 4, [-1, 1]) : a, wrongExponent).simplify();
+        const wrongAnswer = wrongAnswerTree.toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const power = new power_1.Power(a, b + c);
+    const answerTree = power.simplify();
+    const texs = answerTree.toAllValidTexs();
+    const rawTex = power.toTree().toTex();
+    if (!texs.includes(rawTex))
+        texs.push(rawTex);
+    return texs.includes(ans);
+};
+exports.powersOfTenProduct = {
+    id: "powersOfTenProduct",
+    connector: "=",
+    label: "Multiplication de puissances de 10",
+    levels: [
+        "4ème",
+        "3ème",
+        "2nde",
+        "CAP",
+        "2ndPro",
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersProductQuestion({ useOnlyPowersOfTen: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};
+exports.powersProduct = {
+    id: "powersProduct",
+    connector: "=",
+    label: "Multiplication de puissances",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersProductQuestion({ useOnlyPowersOfTen: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/powers/scientificToDecimal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * a*10^x vers décimal
+ *  */
+import { MathExercise } from "../exercise";
+type Identifiers = {
+    tenPower: number;
+    decimal: number;
+};
+export declare const scientificToDecimal: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=scientificToDecimal.d.ts.map

package/lib/exercises/powers/scientificToDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../src/exercises/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAYN,OAAO,EACL,YAAY,EASb,MAAM,aAAa,CAAC;AAErB,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CA0BzD,CAAC"}