math-exercises 2.1.25 → 2.1.26

package/lib/exercises/powers/scientificToDecimal.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * a*10^x vers décimal
+ *  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scientificToDecimal = void 0;
+const decimal_1 = require("../../math/numbers/decimals/decimal");
+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 exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const getScientificToDecimalQuestion = () => {
+    const decScientific = decimal_1.DecimalConstructor.randomScientific((0, randint_1.randint)(1, 4));
+    const tenPower = (0, randint_1.randint)(-5, 6, [0, 1]);
+    const answer = decScientific.multiplyByPowerOfTen(tenPower).toTree().toTex();
+    const statement = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(decScientific.value), new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(tenPower)));
+    const statementTex = statement.toTex();
+    const question = {
+        instruction: `Donner l'écriture décimale de : $${statementTex}$`,
+        startStatement: statementTex,
+        answer: answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { decimal: decScientific.value, tenPower },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, tenPower, decimal }) => {
+    const propositions = [];
+    const decScientific = new decimal_1.Decimal(decimal);
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, decScientific.multiplyByPowerOfTen(-tenPower).toTree().toTex());
+    while (propositions.length < n) {
+        const wrongAnswerTree = decScientific
+            .multiplyByPowerOfTen((0, randint_1.randint)(-6, 6, [tenPower]))
+            .toTree();
+        const wrongAnswer = wrongAnswerTree.toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.scientificToDecimal = {
+    id: "scientificToDecimal",
+    connector: "=",
+    label: "Passer d'écriture scientifique à écriture décimale",
+    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)(getScientificToDecimalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/primitive/constantPrimitive.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise, QCMGenerator, QuestionGenerator, VEA } from "../../exercises/exercise";
+type Identifiers = {
+    c: number;
+};
+export declare const getConstantPrimitive: QuestionGenerator<Identifiers>;
+export declare const getConstantPrimitivePropositions: QCMGenerator<Identifiers>;
+export declare const isConstantPrimitiveAnswerValid: VEA<Identifiers>;
+export declare const constantPrimitive: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=constantPrimitive.d.ts.map

package/lib/exercises/primitive/constantPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,CAc/D,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CActE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,CAO3D,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAYvD,CAAC"}

package/lib/exercises/primitive/constantPrimitive.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constantPrimitive = exports.isConstantPrimitiveAnswerValid = exports.getConstantPrimitivePropositions = exports.getConstantPrimitive = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const monom_1 = require("../../math/polynomials/monom");
+const randint_1 = require("../../math/utils/random/randint");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const shuffle_1 = require("../../utils/shuffle");
+const getConstantPrimitive = () => {
+    const c = (0, randint_1.randint)(-19, 20, [0]);
+    const monom = new monom_1.Monom(1, c);
+    const answer = new addNode_1.AddNode(monom.toTree(), new variableNode_1.VariableNode("C")).toTex();
+    const question = {
+        instruction: `Déterminer la forme générale des primitives de la fonction constante $f$ définie par $f(x) = ${c}$.`,
+        startStatement: `F(x)`,
+        answer,
+        keys: ["x", "C"],
+        answerFormat: "tex",
+        identifiers: { c },
+    };
+    return question;
+};
+exports.getConstantPrimitive = getConstantPrimitive;
+const getConstantPrimitivePropositions = (n, { answer, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const cNode = new variableNode_1.VariableNode("C");
+    while (propositions.length < n) {
+        const monom = new monom_1.Monom(1, (0, randint_1.randint)(-9, 10, [-1, 0, 1]));
+        const wrongAnswer = new addNode_1.AddNode(monom.toTree(), cNode);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.getConstantPrimitivePropositions = getConstantPrimitivePropositions;
+const isConstantPrimitiveAnswerValid = (ans, { c }) => {
+    const answer = new addNode_1.AddNode(new monom_1.Monom(1, c).toTree(), new variableNode_1.VariableNode("C"));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.isConstantPrimitiveAnswerValid = isConstantPrimitiveAnswerValid;
+exports.constantPrimitive = {
+    id: "constantPrimitive",
+    connector: "=",
+    label: "Primitive d'une constante",
+    levels: ["TermSpé", "MathComp"],
+    sections: ["Primitives"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(exports.getConstantPrimitive, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: exports.getConstantPrimitivePropositions,
+    isAnswerValid: exports.isConstantPrimitiveAnswerValid,
+};

package/lib/exercises/primitive/expUPrimitive.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise, QCMGenerator, QuestionGenerator, VEA } from "../../exercises/exercise";
+type Identifiers = {
+    coeffs: number[];
+};
+export declare const getExpUPrimitive: QuestionGenerator<Identifiers>;
+export declare const getExpUPrimitivePropositions: QCMGenerator<Identifiers>;
+export declare const isExpUPrimitiveAnswerValid: VEA<Identifiers>;
+export declare const expUPrimitive: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=expUPrimitive.d.ts.map

package/lib/exercises/primitive/expUPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expUPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/expUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,iBAAiB,CAAC,WAAW,CAoB3D,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAiClE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,GAAG,CAAC,WAAW,CAYvD,CAAC;AACF,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,WAAW,CAYnD,CAAC"}

package/lib/exercises/primitive/expUPrimitive.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expUPrimitive = exports.isExpUPrimitiveAnswerValid = exports.getExpUPrimitivePropositions = exports.getExpUPrimitive = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const expNode_1 = require("../../tree/nodes/functions/expNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const getExpUPrimitive = () => {
+    const u = polynomial_1.PolynomialConstructor.randomWithOrder((0, randint_1.randint)(1, 3));
+    const integratedFuction = new expNode_1.ExpNode(u.toTree());
+    const selectedFunction = new multiplyNode_1.MultiplyNode(u.derivate().toTree(), integratedFuction);
+    const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C")).toTex();
+    const question = {
+        instruction: `Déterminer la forme générale des primitives de la fonction $f$ définie par $f(x) = ${selectedFunction.toTex()}$.`,
+        startStatement: `F(x)`,
+        answer,
+        keys: ["x", "C", "epower", "exp"],
+        answerFormat: "tex",
+        identifiers: { coeffs: u.coefficients },
+    };
+    return question;
+};
+exports.getExpUPrimitive = getExpUPrimitive;
+const getExpUPrimitivePropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const u = new polynomial_1.Polynomial(coeffs);
+    const uTree = u.toTree();
+    const expXTree = new expNode_1.ExpNode(new variableNode_1.VariableNode("x"));
+    const expUTree = new expNode_1.ExpNode(uTree);
+    const invUTree = new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), uTree);
+    const wrongIntegrals = [
+        new multiplyNode_1.MultiplyNode(uTree, expUTree),
+        new multiplyNode_1.MultiplyNode(u.derivate().toTree(), expUTree),
+        new multiplyNode_1.MultiplyNode(uTree, expXTree),
+        new multiplyNode_1.MultiplyNode(invUTree, expXTree),
+        new multiplyNode_1.MultiplyNode(invUTree, expUTree),
+        new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(-9, 10, [0])), expUTree),
+    ];
+    const cNode = new variableNode_1.VariableNode("c");
+    wrongIntegrals.forEach((node) => (0, exercise_1.tryToAddWrongProp)(propositions, new addNode_1.AddNode(node, cNode).toTex()));
+    while (propositions.length < n) {
+        let wrongIntegral = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10, [0])), expXTree), cNode).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongIntegral);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+exports.getExpUPrimitivePropositions = getExpUPrimitivePropositions;
+const isExpUPrimitiveAnswerValid = (ans, { coeffs }) => {
+    const u = new polynomial_1.Polynomial(coeffs);
+    const integratedFuction = new expNode_1.ExpNode(u.toTree({ forbidPowerToProduct: true }));
+    const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.isExpUPrimitiveAnswerValid = isExpUPrimitiveAnswerValid;
+exports.expUPrimitive = {
+    id: "expUPrimitive",
+    connector: "=",
+    label: "Primitive de $u'\\exp(u)$",
+    levels: ["TermSpé", "MathComp"],
+    sections: ["Primitives", "Exponentielle"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(exports.getExpUPrimitive, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: exports.getExpUPrimitivePropositions,
+    isAnswerValid: exports.isExpUPrimitiveAnswerValid,
+};

package/lib/exercises/primitive/exponentialPrimitive.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise, QCMGenerator, QuestionGenerator, VEA } from "../../exercises/exercise";
+type Identifiers = {
+    a: number;
+};
+export declare const getExponentialPrimitive: QuestionGenerator<Identifiers>;
+export declare const getExponentialPrimitivePropositions: QCMGenerator<Identifiers>;
+export declare const isExponentialPrimitiveAnswerValid: VEA<Identifiers>;
+export declare const exponentialPrimitive: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=exponentialPrimitive.d.ts.map

package/lib/exercises/primitive/exponentialPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,iBAAiB,CAAC,WAAW,CAmBlE,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,WAAW,CAgCzE,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,GAAG,CAAC,WAAW,CAY9D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAY1D,CAAC"}

package/lib/exercises/primitive/exponentialPrimitive.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exponentialPrimitive = exports.isExponentialPrimitiveAnswerValid = exports.getExponentialPrimitivePropositions = exports.getExponentialPrimitive = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const expNode_1 = require("../../tree/nodes/functions/expNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const getExponentialPrimitive = () => {
+    const a = (0, randint_1.randint)(-20, 20, [0]);
+    const integratedFuction = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new expNode_1.ExpNode(new variableNode_1.VariableNode("x")));
+    const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C")).toTex();
+    const question = {
+        instruction: `Déterminer la forme générale des primitives de la fonction $f$ définie par $f(x) = ${integratedFuction.toTex()}$.`,
+        startStatement: `F(x)`,
+        answer,
+        keys: ["x", "C", "epower", "exp"],
+        answerFormat: "tex",
+        identifiers: { a },
+    };
+    return question;
+};
+exports.getExponentialPrimitive = getExponentialPrimitive;
+const getExponentialPrimitivePropositions = (n, { answer, a }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const aNode = new numberNode_1.NumberNode(a);
+    const xNode = new variableNode_1.VariableNode("x");
+    const expXTree = new expNode_1.ExpNode(new variableNode_1.VariableNode("x"));
+    const wrongIntegrals = [
+        new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-a), expXTree),
+        new multiplyNode_1.MultiplyNode(aNode, new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(aNode, xNode))),
+        new multiplyNode_1.MultiplyNode(aNode, new expNode_1.ExpNode(new fractionNode_1.FractionNode(xNode, aNode))),
+        new multiplyNode_1.MultiplyNode(aNode, new expNode_1.ExpNode(new addNode_1.AddNode(xNode, aNode))),
+        new multiplyNode_1.MultiplyNode(aNode, new expNode_1.ExpNode(new powerNode_1.PowerNode(xNode, aNode))),
+        expXTree,
+    ];
+    const cNode = new variableNode_1.VariableNode("C");
+    wrongIntegrals.forEach((node) => (0, exercise_1.tryToAddWrongProp)(propositions, new addNode_1.AddNode(node, cNode).toTex()));
+    while (propositions.length < n) {
+        let wrongIntegral = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10, [0])), expXTree);
+        (0, exercise_1.tryToAddWrongProp)(propositions, new addNode_1.AddNode(wrongIntegral, cNode).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+exports.getExponentialPrimitivePropositions = getExponentialPrimitivePropositions;
+const isExponentialPrimitiveAnswerValid = (ans, { a }) => {
+    const integratedFuction = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new expNode_1.ExpNode(new variableNode_1.VariableNode("x")));
+    const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.isExponentialPrimitiveAnswerValid = isExponentialPrimitiveAnswerValid;
+exports.exponentialPrimitive = {
+    id: "exponentialPrimitive",
+    connector: "=",
+    label: "Primitive de la fonction exponentielle",
+    levels: ["TermSpé", "MathComp"],
+    sections: ["Primitives", "Exponentielle"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(exports.getExponentialPrimitive, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: exports.getExponentialPrimitivePropositions,
+    isAnswerValid: exports.isExponentialPrimitiveAnswerValid,
+};

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

@@ -0,0 +1,9 @@
+export { constantPrimitive } from "./constantPrimitive";
+export { expUPrimitive } from "./expUPrimitive";
+export { exponentialPrimitive } from "./exponentialPrimitive";
+export { logarithmePrimitive } from "./logarithmePrimitive";
+export { polynomialPrimitive } from "./polynomialPrimitive";
+export { sinCosPrimitive } from "./sinCosPrimitive";
+export { sinUCosUPrimitive } from "./sinUCosUPrimitive";
+export * from "./usualPrimitives";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,cAAc,mBAAmB,CAAC"}

package/lib/exercises/primitive/index.js

@@ -0,0 +1,32 @@
+"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 });
+exports.sinUCosUPrimitive = exports.sinCosPrimitive = exports.polynomialPrimitive = exports.logarithmePrimitive = exports.exponentialPrimitive = exports.expUPrimitive = exports.constantPrimitive = void 0;
+var constantPrimitive_1 = require("./constantPrimitive");
+Object.defineProperty(exports, "constantPrimitive", { enumerable: true, get: function () { return constantPrimitive_1.constantPrimitive; } });
+var expUPrimitive_1 = require("./expUPrimitive");
+Object.defineProperty(exports, "expUPrimitive", { enumerable: true, get: function () { return expUPrimitive_1.expUPrimitive; } });
+var exponentialPrimitive_1 = require("./exponentialPrimitive");
+Object.defineProperty(exports, "exponentialPrimitive", { enumerable: true, get: function () { return exponentialPrimitive_1.exponentialPrimitive; } });
+var logarithmePrimitive_1 = require("./logarithmePrimitive");
+Object.defineProperty(exports, "logarithmePrimitive", { enumerable: true, get: function () { return logarithmePrimitive_1.logarithmePrimitive; } });
+var polynomialPrimitive_1 = require("./polynomialPrimitive");
+Object.defineProperty(exports, "polynomialPrimitive", { enumerable: true, get: function () { return polynomialPrimitive_1.polynomialPrimitive; } });
+var sinCosPrimitive_1 = require("./sinCosPrimitive");
+Object.defineProperty(exports, "sinCosPrimitive", { enumerable: true, get: function () { return sinCosPrimitive_1.sinCosPrimitive; } });
+var sinUCosUPrimitive_1 = require("./sinUCosUPrimitive");
+Object.defineProperty(exports, "sinUCosUPrimitive", { enumerable: true, get: function () { return sinUCosUPrimitive_1.sinUCosUPrimitive; } });
+__exportStar(require("./usualPrimitives"), exports);

package/lib/exercises/primitive/logarithmePrimitive.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise, QCMGenerator, QuestionGenerator } from "../../exercises/exercise";
+type Identifiers = {
+    coeffs: number[];
+};
+export declare const getLogarithmePrimitive: QuestionGenerator<Identifiers>;
+export declare const getLogarithmePrimitivePropositions: QCMGenerator<Identifiers>;
+export declare const logarithmePrimitive: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=logarithmePrimitive.d.ts.map

package/lib/exercises/primitive/logarithmePrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logarithmePrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/logarithmePrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EAIlB,MAAM,0BAA0B,CAAC;AAgBlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAgBjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAsCxE,CAAC;AAeF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAYzD,CAAC"}

package/lib/exercises/primitive/logarithmePrimitive.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logarithmePrimitive = exports.getLogarithmePrimitivePropositions = exports.getLogarithmePrimitive = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const absNode_1 = require("../../tree/nodes/functions/absNode");
+const logNode_1 = require("../../tree/nodes/functions/logNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const shuffle_1 = require("../../utils/shuffle");
+const getLogarithmePrimitive = () => {
+    const u = polynomial_1.PolynomialConstructor.randomWithOrder((0, randint_1.randint)(1, 3));
+    const uTree = u.toTree();
+    const selectedFunction = new fractionNode_1.FractionNode(u.derivate().toTree(), uTree);
+    const integratedFuction = new logNode_1.LogNode(new absNode_1.AbsNode(uTree));
+    const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C")).toTex();
+    const question = {
+        instruction: `Déterminer la forme générale des primitives de la fonction $f$ définie par $f(x) = ${selectedFunction.toTex()}$.`,
+        startStatement: `F(x)`,
+        answer,
+        keys: ["x", "C", "ln", "abs"],
+        answerFormat: "tex",
+        identifiers: { coeffs: u.coefficients },
+    };
+    return question;
+};
+exports.getLogarithmePrimitive = getLogarithmePrimitive;
+const getLogarithmePrimitivePropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const u = new polynomial_1.Polynomial(coeffs);
+    const uTree = u.toTree();
+    const wrongIntegrals = [
+        new fractionNode_1.FractionNode(u.derivate().toTree(), new powerNode_1.PowerNode(uTree, new numberNode_1.NumberNode(2))),
+        new fractionNode_1.FractionNode(u.derivate().opposite().toTree(), new powerNode_1.PowerNode(uTree, new numberNode_1.NumberNode(2))),
+        new logNode_1.LogNode(new powerNode_1.PowerNode(uTree, new numberNode_1.NumberNode(2))),
+    ];
+    const cNode = new variableNode_1.VariableNode("C");
+    wrongIntegrals.forEach((int) => (0, exercise_1.tryToAddWrongProp)(propositions, new addNode_1.AddNode(int, cNode).toTex()));
+    // while (propositions.length < n) {
+    //  const wrongIntegral =
+    //     new PowerNode(u.toTree(), new NumberNode(2)).toTex(),
+    //     `ln\|${PolynomialConstructor.randomWithOrder(randint(1, 3)).toTex()}\|`,
+    //   );
+    //   let wrongIntegral;
+    //   wrongIntegral = wrongIntegrals[randint(0, wrongIntegrals.length)];
+    //   tryToAddWrongProp(propositions, `${wrongIntegral} + C`);
+    //   wrongIntegrals.pop();
+    // }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.getLogarithmePrimitivePropositions = getLogarithmePrimitivePropositions;
+const isLogarithmePrimitiveAnswerValid = (ans, { coeffs }) => {
+    const u = new polynomial_1.Polynomial(coeffs);
+    const uTree = u.toTree({ forbidPowerToProduct: true });
+    const integratedFuction = new logNode_1.LogNode(new absNode_1.AbsNode(uTree));
+    const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.logarithmePrimitive = {
+    id: "logarithmePrimitive",
+    connector: "=",
+    label: "Primitive de $\\frac{u'}{u}$",
+    levels: ["TermSpé", "MathComp"],
+    sections: ["Primitives", "Logarithme népérien"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(exports.getLogarithmePrimitive, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: exports.getLogarithmePrimitivePropositions,
+    isAnswerValid: isLogarithmePrimitiveAnswerValid,
+};

package/lib/exercises/primitive/polynomialPrimitive.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise, QCMGenerator, QuestionGenerator, VEA } from "../../exercises/exercise";
+type Identifiers = {
+    coeffs: number[];
+};
+export declare const getPolynomialPrimitive: QuestionGenerator<Identifiers>;
+export declare const getPolynomialPrimitivePropositions: QCMGenerator<Identifiers>;
+export declare const isPolynomialPrimitiveAnswerValid: VEA<Identifiers>;
+export declare const polynomialPrimitive: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=polynomialPrimitive.d.ts.map

package/lib/exercises/primitive/polynomialPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAiBjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAa7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAYzD,CAAC"}

package/lib/exercises/primitive/polynomialPrimitive.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polynomialPrimitive = exports.isPolynomialPrimitiveAnswerValid = exports.getPolynomialPrimitivePropositions = exports.getPolynomialPrimitive = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const shuffle_1 = require("../../utils/shuffle");
+const getPolynomialPrimitive = () => {
+    const degree = (0, randint_1.randint)(1, 4);
+    const polynomial = polynomial_1.PolynomialConstructor.randomWithOrder(degree);
+    const integralPolynomial = polynomial.integrateToNode();
+    const answer = `${integralPolynomial.toTex()}`;
+    const question = {
+        instruction: `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par $f(x) = ${polynomial.toTex()}$.`,
+        startStatement: `F(x)`,
+        answer,
+        keys: ["x", "C"],
+        answerFormat: "tex",
+        identifiers: { coeffs: polynomial.coefficients },
+    };
+    return question;
+};
+exports.getPolynomialPrimitive = getPolynomialPrimitive;
+const getPolynomialPrimitivePropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongPolynomial = polynomial_1.PolynomialConstructor.randomWithOrder(coeffs.length - 1);
+        const wrongIntegral = wrongPolynomial.integrateToNode();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongIntegral.toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.getPolynomialPrimitivePropositions = getPolynomialPrimitivePropositions;
+const isPolynomialPrimitiveAnswerValid = (ans, { coeffs }) => {
+    const opts = {
+        allowFractionToDecimal: true,
+        forbidPowerToProduct: true,
+    };
+    const polynomial = new polynomial_1.Polynomial(coeffs);
+    const integralPolynomial = polynomial.integrateToNode(opts);
+    const texs = integralPolynomial.toAllValidTexs(opts);
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.isPolynomialPrimitiveAnswerValid = isPolynomialPrimitiveAnswerValid;
+exports.polynomialPrimitive = {
+    id: "polynomialPrimitive",
+    connector: "=",
+    label: "Primitive d'une fonction polynomiale",
+    levels: ["TermSpé", "MathComp"],
+    sections: ["Primitives"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(exports.getPolynomialPrimitive, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: exports.getPolynomialPrimitivePropositions,
+    isAnswerValid: exports.isPolynomialPrimitiveAnswerValid,
+};

package/lib/exercises/primitive/sinCosPrimitive.d.ts

@@ -0,0 +1,11 @@
+import { MathExercise, QCMGenerator, QuestionGenerator, VEA } from "../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    isCos: boolean;
+};
+export declare const getSinCosPrimitive: QuestionGenerator<Identifiers>;
+export declare const getSinCosPrimitivePropositions: QCMGenerator<Identifiers>;
+export declare const isSinCosPrimitiveAnswerValid: VEA<Identifiers>;
+export declare const sinCosPrimitive: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=sinCosPrimitive.d.ts.map

package/lib/exercises/primitive/sinCosPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CA2B7D,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAYrD,CAAC"}