math-exercises 3.0.49 → 3.0.51

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductIdentities.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    type: number;
+    normU: number;
+    normV: number;
+    udotv: number;
+};
+export declare const scalarProductIdentities: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductIdentities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIdentities.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductIdentities.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-30, 30) + "");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { type, normU, normV, udotv } = identifiers;
+    switch (type) {
+        case 0:
+            return add(square(normU), add(multiply(2, udotv), square(normV)))
+                .simplify()
+                .toTex();
+        case 1:
+            return add(square(normU), add(multiply(-2, udotv), square(normV)))
+                .simplify()
+                .toTex();
+        case 2:
+        default:
+            return substract(square(normU), square(normV)).simplify().toTex();
+    }
+};
+const getStatementNode = (identifiers) => {
+    const { type, normU, normV, udotv } = identifiers;
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    switch (type) {
+        case 0:
+            return square(add(u, v));
+        case 1:
+            return square(substract(u, v));
+        case 2:
+        default:
+            return multiply(add(u, v), substract(u, v));
+    }
+};
+const getInstruction = (identifiers) => {
+    const { type, normU, normV, udotv } = identifiers;
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    return `Soit $${u}$ et $${v}$ deux vecteurs tels que $\\lVert ${u}\\rVert = ${normU}$, $\\lVert ${v}\\rVert = ${normV}$ et $${u} \\cdot ${v} = ${udotv}$. 
+  
+Calculer : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `Utilise une identité remarquable, puis utilise le fait que pour tout vecteur $\\overrightarrow{u}$ : 
+  
+$$
+\\overrightarrow{u}^2 = \\lVert \\overrightarrow{u} \\rVert^2
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { type, normU, normV, udotv } = identifiers;
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    const vertU = `\\lVert \\overrightarrow{u} \\rVert`;
+    const vertV = `\\lVert \\overrightarrow{v} \\rVert`;
+    const ps = `${u}\\cdot ${v}`;
+    const statement = getStatementNode(identifiers);
+    const steps = type === 0
+        ? [
+            ["", statement.toTex()],
+            ["=", add(square(u), add(multiply(2, ps), square(v))).toTex()],
+            [
+                "=",
+                add(square(vertU), add(multiply(2, ps), square(vertV))).toTex(),
+            ],
+            [
+                "=",
+                add(square(normU), add(multiply(2, udotv), square(normV))).toTex(),
+            ],
+            ["=", getAnswer(identifiers)],
+        ]
+        : type === 1
+            ? [
+                ["", statement.toTex()],
+                ["=", add(square(u), add(multiply(-2, ps), square(v))).toTex()],
+                [
+                    "=",
+                    add(square(vertU), add(multiply(-2, ps), square(vertV))).toTex(),
+                ],
+                [
+                    "=",
+                    add(square(normU), add(multiply(-2, udotv), square(normV))).toTex(),
+                ],
+                ["=", getAnswer(identifiers)],
+            ]
+            : [
+                ["", statement.toTex()],
+                ["=", substract(square(u), square(v)).toTex()],
+                ["=", substract(square(vertU), square(vertV)).toTex()],
+                ["=", substract(square(normU), square(normV)).toTex()],
+                ["=", getAnswer(identifiers)],
+            ];
+    return `On utilies une identité remarquable, ainsi que le fait que pour tout vecteur $\\overrightarrow{u}$ : 
+  
+$$
+\\overrightarrow{u}^2 = \\lVert \\overrightarrow{u} \\rVert^2
+$$
+
+Cela donne : 
+
+${alignTex(steps)}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductIdentitiesQuestion = (ops) => {
+    const type = randint(0, 3);
+    const normU = randint(1, 10);
+    const normV = randint(1, 10);
+    const udotv = randint(-9, 10);
+    const identifiers = {
+        normU,
+        normV,
+        type,
+        udotv,
+    };
+    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 scalarProductIdentities = {
+    id: "scalarProductIdentities",
+    connector: "=",
+    label: "Identités remarquables avec des vecteurs (produit scalaire)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductIdentitiesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/vectorLinearCombination.js

@@ -7,8 +7,8 @@ import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 const getVectorLinearCombinationQuestion = () => {
-    const u = VectorConstructor.random("u", true);
-    const v = VectorConstructor.random("v", true);
+    const u = VectorConstructor.random("u");
+    const v = VectorConstructor.random("v");
     const a = randint(-10, 11, [0]);
     const b = randint(-10, 11, [0]);
     const uCoords = {

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

@@ -1 +1 @@
-{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAER,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAQrC,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,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoBF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,CAI/D,CAAC;AAgBF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CActE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,CAO3D,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAcnD,CAAC"}

package/lib/exercises/math/primitive/constantPrimitive.js

@@ -5,17 +5,33 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-export const getConstantPrimitive = () => {
-    const c = randint(-19, 20, [0]);
+const getInstruction = (identifiers) => {
+    const { c } = identifiers;
+    return `Déterminer la forme générale des primitives de la fonction constante $f$ définie par : 
+  
+$$
+f(x) = ${c}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { c } = identifiers;
     const monom = new Monom(1, c);
     const answer = new AddNode(monom.toTree(), new VariableNode("C")).toTex();
+    return answer;
+};
+export const getConstantPrimitive = () => {
+    const c = randint(-19, 20, [0]);
+    const identifiers = { c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Déterminer la forme générale des primitives de la fonction constante $f$ définie par $f(x) = ${c}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: `F(x)`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x", "C"],
         answerFormat: "tex",
-        identifiers: { c },
+        identifiers,
     };
     return question;
 };
@@ -48,4 +64,5 @@ export const constantPrimitive = {
     getPropositions: getConstantPrimitivePropositions,
     isAnswerValid: isConstantPrimitiveAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"expUPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/expUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAER,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAcrC,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,QAAQ,CAAC,WAAW,CAc/C,CAAC"}
+{"version":3,"file":"expUPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/expUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA0BF,eAAO,MAAM,gBAAgB,EAAE,iBAAiB,CAAC,WAAW,CAK3D,CAAC;AAgBF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAiClE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,GAAG,CAAC,WAAW,CAYvD,CAAC;AACF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}

package/lib/exercises/math/primitive/expUPrimitive.js

@@ -8,18 +8,37 @@ import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
-export const getExpUPrimitive = () => {
-    const u = PolynomialConstructor.randomWithOrder(randint(1, 3));
+const getInstruction = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs);
     const integratedFuction = new ExpNode(u.toTree());
     const selectedFunction = new MultiplyNode(u.derivate().toTree(), integratedFuction);
+    return `Déterminer la forme générale des primitives de la fonction $f$ définie par :
+  
+$$
+f(x) = ${selectedFunction.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs);
+    const integratedFuction = new ExpNode(u.toTree());
     const answer = new AddNode(integratedFuction, new VariableNode("C")).toTex();
+    return answer;
+};
+export const getExpUPrimitive = () => {
+    const u = PolynomialConstructor.randomWithOrder(randint(1, 3));
+    const identifiers = { coeffs: u.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Déterminer la forme générale des primitives de la fonction $f$ définie par $f(x) = ${selectedFunction.toTex()}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: `F(x)`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x", "C", "epower", "exp"],
         answerFormat: "tex",
-        identifiers: { coeffs: u.coefficients },
+        identifiers,
     };
     return question;
 };
@@ -58,8 +77,6 @@ export const expUPrimitive = {
     id: "expUPrimitive",
     connector: "=",
     label: "Primitive de $u'\\exp(u)$",
-    levels: ["TermSpé", "MathComp"],
-    sections: ["Primitives", "Exponentielle"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getExpUPrimitive, nb),
     qcmTimer: 60,
@@ -68,4 +85,5 @@ export const expUPrimitive = {
     isAnswerValid: isExpUPrimitiveAnswerValid,
     subject: "Mathématiques",
     pdfOptions: { shouldSpreadPropositions: true },
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAER,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAYrC,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,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwBF,eAAO,MAAM,uBAAuB,EAAE,iBAAiB,CAAC,WAAW,CAIlE,CAAC;AAiBF,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,WAAW,CAgCzE,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,GAAG,CAAC,WAAW,CAY9D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/primitive/exponentialPrimitive.js

@@ -8,17 +8,34 @@ import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
-export const getExponentialPrimitive = () => {
-    const a = randint(-20, 20, [0]);
+const getInstruction = (identifiers) => {
+    const { a } = identifiers;
+    const integratedFuction = new MultiplyNode(new NumberNode(a), new ExpNode(new VariableNode("x")));
+    return `Déterminer la forme générale des primitives de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${integratedFuction.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
     const integratedFuction = new MultiplyNode(new NumberNode(a), new ExpNode(new VariableNode("x")));
     const answer = new AddNode(integratedFuction, new VariableNode("C")).toTex();
+    return answer;
+};
+export const getExponentialPrimitive = () => {
+    const a = randint(-20, 20, [0]);
+    const identifiers = { a };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Déterminer la forme générale des primitives de la fonction $f$ définie par $f(x) = ${integratedFuction.toTex()}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: `F(x)`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x", "C", "epower", "exp"],
         answerFormat: "tex",
-        identifiers: { a },
+        identifiers,
     };
     return question;
 };
@@ -64,4 +81,5 @@ export const exponentialPrimitive = {
     isAnswerValid: isExponentialPrimitiveAnswerValid,
     subject: "Mathématiques",
     pdfOptions: { shouldSpreadPropositions: true },
+    getQuestionFromIdentifiers,
 };

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

@@ -6,4 +6,6 @@ export { polynomialPrimitive } from "./polynomialPrimitive.js";
 export { sinCosPrimitive } from "./sinCosPrimitive.js";
 export { sinUCosUPrimitive } from "./sinUCosUPrimitive.js";
 export * from "./usualPrimitives.js";
+export * from "./kexpUPrimitive.js";
+export * from "./klogUPrimitive.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

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

@@ -6,3 +6,5 @@ export { polynomialPrimitive } from "./polynomialPrimitive.js";
 export { sinCosPrimitive } from "./sinCosPrimitive.js";
 export { sinUCosUPrimitive } from "./sinUCosUPrimitive.js";
 export * from "./usualPrimitives.js";
+export * from "./kexpUPrimitive.js";
+export * from "./klogUPrimitive.js";

package/lib/exercises/math/primitive/kexpUPrimitive.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    kIds: NodeIdentifiers;
+    uCoeffs: number[];
+};
+export declare const kexpUPrimitive: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=kexpUPrimitive.d.ts.map

package/lib/exercises/math/primitive/kexpUPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kexpUPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/kexpUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4HF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAiBhD,CAAC"}

package/lib/exercises/math/primitive/kexpUPrimitive.js

@@ -0,0 +1,130 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { Polynomial, } from "../../../math/polynomials/polynomial.js";
+import { Trinom, TrinomConstructor } from "../../../math/polynomials/trinom.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { exp, ExpNode } from "../../../tree/nodes/functions/expNode.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 { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+//k u' e^u --> k e^u
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { uCoeffs, kIds } = identifiers;
+    const k = reifyAlgebraic(kIds);
+    const u = new Polynomial(uCoeffs);
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const kRand = coinFlip()
+            ? randint(-5, 6, [0, 1, -1]).toTree()
+            : RationalConstructor.randomIrreductibleProba().toTree();
+        tryToAddWrongProp(propositions, multiply(kRand, exp(u.toTree())).toTex() + "+C");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { uCoeffs, kIds } = identifiers;
+    const k = reifyAlgebraic(kIds);
+    const u = new Polynomial(uCoeffs);
+    const integratedFuction = new ExpNode(u.toTree());
+    const answer = add(multiply(k, integratedFuction), "C").toTex();
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { uCoeffs, kIds } = identifiers;
+    const u = new Polynomial(uCoeffs).toTree();
+    const uprime = u.derivative().simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const k = reifyAlgebraic(kIds);
+    const fct = multiply(multiply(k, uprime).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    }), new ExpNode(u));
+    return `Déterminer la forme générale des primitives de la fonction $f$ définie par :
+  
+$$
+f(x) = ${fct.toTex()}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return ["epower", "x", "C"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+            forceDistributeFractions: true,
+            decimalToFractions: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getKexpUPrimitiveQuestion = (ops) => {
+    const kIsInt = coinFlip();
+    let k;
+    let u;
+    if (kIsInt) {
+        k = randint(-4, 5, [0, 1, -1]).toTree();
+        u = TrinomConstructor.random();
+    }
+    else {
+        const denum = randint(2, 6);
+        k = frac(1, denum);
+        u = new Trinom(denum * randint(1, 4), denum * randint(1, 4), randint(-9, 10));
+    }
+    // const k = coinFlip()
+    //   ? randint(-9, 10, [0, 1, -1]).toTree()
+    //   : RationalConstructor.randomIrreductibleProba().toTree();
+    // const u = TrinomConstructor.random();
+    const identifiers = {
+        kIds: k.toIdentifiers(),
+        uCoeffs: u.coefficients,
+    };
+    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 kexpUPrimitive = {
+    id: "kexpUPrimitive",
+    connector: "=",
+    label: "Primitive du type $k u'\\exp(u)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getKexpUPrimitiveQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/primitive/klogUPrimitive.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    kIds: NodeIdentifiers;
+    uCoeffs: number[];
+};
+export declare const klogUPrimitive: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=klogUPrimitive.d.ts.map

package/lib/exercises/math/primitive/klogUPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"klogUPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/klogUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAiBhD,CAAC"}