math-exercises 3.0.57 → 3.0.59

package/lib/exercises/math/derivation/derivative/power/powerCompositionDerivation.js

@@ -0,0 +1,122 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { MultiplyNode, multiply, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { PowerNode, power } 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 getInstruction = (identifiers) => {
+    const { affineA, affineB, power } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    const powerTree = power.toTree();
+    const affineTree = affine.toTree();
+    const fct = new PowerNode(affineTree, powerTree);
+    return `Déterminer la fonction dérivée de la fonction $f$ définie par : 
+
+$$
+f(x) = ${fct.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affineA, affineB, power } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    const affineTree = affine.toTree();
+    const deriv = new MultiplyNode((power * affine.a).toTree(), new PowerNode(affineTree, (power - 1).toTree()));
+    return deriv.toTex();
+};
+const getHint = (identifiers) => {
+    return `On rappelle la règle de dérivation suivante : 
+  
+$$
+\\left(u^n \\right)' = n \\times u' \\times u^{n-1} 
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { affineA, affineB, power: pow } = identifiers;
+    const affine = new Affine(affineA, affineB).toTree();
+    const affineTex = affine.toTex();
+    const answer = getAnswer(identifiers);
+    return `On sait que : 
+  
+$$
+\\left(u^n \\right)' = n \\times u' \\times u^{n-1} 
+$$
+
+Ici, on a $n = ${pow}$, et $u(x) = ${affineTex}$, donc $u'(x) = ${affineA}$.
+
+Ainsi, 
+
+${alignTex([
+        [
+            "f'(x)",
+            "=",
+            multiply(pow, multiply(affineA, power(affine, substract(pow, 1)))).toTex(),
+        ],
+        ["", "=", answer],
+    ])}
+`;
+};
+const getPowerCompositionDerivationQuestion = () => {
+    const affine = AffineConstructor.random(undefined, { excludes: [0] });
+    const power = randint(3, 10);
+    const identifiers = { affineA: affine.a, affineB: affine.b, power };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affineA, affineB, power }) => {
+    const propositions = [];
+    const affineTree = new Affine(affineA, affineB).toTree();
+    addValidProp(propositions, answer);
+    const powerN = new PowerNode(affineTree, power.toTree());
+    const powerNMinusOne = new PowerNode(affineTree, (power - 1).toTree());
+    tryToAddWrongProp(propositions, new MultiplyNode(power.toTree(), powerNMinusOne).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affineA.toTree(), powerN).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affineA.toTree(), powerNMinusOne).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode((power * affineA).toTree(), powerN).toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, new MultiplyNode(randint(-10, 10).toTree(), powerN).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, power, affineA, affineB }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify({ forbidFactorize: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const powerCompositionDerivation = {
+    id: "powerCompositionDerivation",
+    connector: "=",
+    label: "Dérivée de $\\left(ax+b\\right)^n$",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Dérivation"],
+    generator: (nb) => getDistinctQuestions(getPowerCompositionDerivationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/power/powerFunctionDerivative.d.ts

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

package/lib/exercises/math/derivation/derivative/power/powerFunctionDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powerFunctionDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/power/powerFunctionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}

package/lib/exercises/math/derivation/derivative/power/powerFunctionDerivative.js

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.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";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    return `On rappelle que la dérivée de la fonction $kx^n$ est : 
+
+$$
+k\\times n \\times x^{n-1}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, power } = identifiers;
+    return `La dérivée de la fonction $kx^n$ est : 
+
+$$
+k\\times n \\times x^{n-1}
+$$
+
+Ici, on a $k = ${a}$ et $n = ${power}$.
+
+On obtient donc : 
+
+${alignTex([
+        ["f'(x)", "=", `${a} \\times ${power} \\times x^{${power}-1}`],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, power } = identifiers;
+    const statement = new MultiplyNode(new NumberNode(a), new PowerNode(new VariableNode("x"), new NumberNode(power)));
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par : 
+  
+$$
+f(x)=${statement.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, power } = identifiers;
+    const answerStatement = power > 2
+        ? new MultiplyNode(new NumberNode(a * power), new PowerNode(new VariableNode("x"), new NumberNode(power - 1)))
+        : new MultiplyNode(new NumberNode(a * power), new VariableNode("x"));
+    const answer = answerStatement.toTex();
+    return answer;
+};
+const getPowerFunctionDerivative = () => {
+    const a = randint(-9, 10, [0]);
+    const power = randint(2, 10);
+    const identifiers = { a, power };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: `f'(x)`,
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, power }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (power === 2)
+        tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(a), new VariableNode("x")).toTex());
+    if (power > 2)
+        tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(a), new PowerNode(new VariableNode("x"), new NumberNode(power - 1))).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(a * power), new PowerNode(new VariableNode("x"), new NumberNode(power))).toTex());
+    if (a !== 1)
+        tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(a - 1), new PowerNode(new VariableNode("x"), new NumberNode(power))).toTex());
+    while (propositions.length < n) {
+        const wrongExponent = randint(2, 10);
+        if (wrongExponent === 2) {
+            tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(a * wrongExponent), new VariableNode("x")).toTex());
+        }
+        else {
+            tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(a * wrongExponent), new PowerNode(new VariableNode("x"), new NumberNode(wrongExponent - 1))).toTex());
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, power }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const powerFunctionDerivative = {
+    id: "powerFunctionDerivative",
+    connector: "=",
+    label: "Dérivée d'une fonction monôme",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getPowerFunctionDerivative, nb),
+    getPropositions,
+    isAnswerValid,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/sqrt/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sqrtCompositionDerivation.js";
+export * from "./rootFunctionDerivative.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/derivative/sqrt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/index.ts"],"names":[],"mappings":"AACA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/derivation/derivative/sqrt/index.js

@@ -0,0 +1,3 @@
+// export * from "./sqrtProductDerivative.js";
+export * from "./sqrtCompositionDerivation.js";
+export * from "./rootFunctionDerivative.js";

package/lib/exercises/math/derivation/derivative/sqrt/rootFunctionDerivative.d.ts

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

package/lib/exercises/math/derivation/derivative/sqrt/rootFunctionDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootFunctionDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/rootFunctionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+FF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

package/lib/exercises/math/derivation/derivative/sqrt/rootFunctionDerivative.js

@@ -0,0 +1,115 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.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 { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getStatementNode = (identifiers) => {
+    return multiply(identifiers.a, sqrt("x"));
+};
+const getInstruction = (identifiers) => {
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par :
+  
+$$
+f(x) = ${getStatementNode(identifiers).toTex()}
+$$ `;
+};
+const getAnswer = (identifiers) => {
+    return frac(identifiers.a, multiply(2, sqrt("x")))
+        .simplify()
+        .toTex();
+};
+const getHint = (identifiers) => {
+    return `La dérivée sur $]0; +\\infty[$ de la fonction $f(x) =\\sqrt{x}$ est : 
+  
+$$
+f'(x) = \\frac{1}{2\\sqrt{x}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const statement = getStatementNode(identifiers);
+    const answer = getAnswer(identifiers);
+    const a = identifiers.a;
+    return `La dérivée sur $]0; +\\infty[$ de la fonction $\\sqrt{x}$ est : 
+  
+$$
+\\frac{1}{2\\sqrt{x}}
+$$
+
+Ici, on a $f(x) = ${statement.toTex()}$. 
+
+On a donc : 
+
+${alignTex([
+        ["f'(x)", "=", multiply(a, frac(1, multiply(2, sqrt("x")))).toTex()],
+        ["", "=", answer],
+    ])}
+`;
+};
+const getRootFunctionDerivative = () => {
+    const a = randint(-19, 20, [0, 1]);
+    const identifiers = { a };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: `f'(x)`,
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `\\frac{${a}}{\\sqrt(x)}`);
+    tryToAddWrongProp(propositions, `${a}`);
+    tryToAddWrongProp(propositions, `\\frac{${a}}{x}`);
+    while (propositions.length < n) {
+        const randomA = randint(-9, 10, [0]);
+        const isEvenA = randomA / 2 === round(randomA / 2, 0);
+        if (isEvenA) {
+            tryToAddWrongProp(propositions, `\\frac{${randomA / 2}}{\\sqrt{x}}`);
+        }
+        else {
+            tryToAddWrongProp(propositions, `\\frac{${randomA}}{2\\sqrt{x}}`);
+        }
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, a }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        const simplified = parsed.simplify();
+        return simplified.toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const rootFunctionDerivative = {
+    id: "rootFunctionDerivative",
+    connector: "=",
+    label: "Dérivée d'une fonction racine carrée",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getRootFunctionDerivative, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    affineA: number;
+    affineB: number;
+};
+export declare const sqrtCompositionDerivation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sqrtCompositionDerivation.d.ts.map

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAqFF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.js

@@ -0,0 +1,77 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { SqrtNode } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { FractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    const fct = new SqrtNode(affine.toTree());
+    return `Déterminer la dérivée de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${fct.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    const fct = new SqrtNode(affine.toTree());
+    const fraction = new FractionNode(affine.a.toTree(), new MultiplyNode((2).toTree(), fct)).simplify();
+    return fraction.toTex();
+};
+const getSqrtCompositionDerivationQuestion = () => {
+    const affine = AffineConstructor.random();
+    const identifiers = { affineA: affine.a, affineB: affine.b };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affineA, affineB }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new Affine(affineA, affineB);
+    const fct = new SqrtNode(affine.toTree());
+    tryToAddWrongProp(propositions, new MultiplyNode(affineA.toTree(), fct).toTex());
+    tryToAddWrongProp(propositions, new FractionNode(affine.a.toTree(), fct).simplify().toTex());
+    tryToAddWrongProp(propositions, new SqrtNode(affineA.toTree()).simplify().toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, new FractionNode(randint(-10, 10).toTree(), new MultiplyNode((2).toTree(), fct))
+            .simplify()
+            .toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, affineA, affineB }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const simplified = parsed.simplify();
+        return simplified.toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const sqrtCompositionDerivation = {
+    id: "sqrtCompositionDerivation",
+    connector: "=",
+    label: "Dérivée de $\\sqrt{ax+b}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSqrtCompositionDerivationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/derivation/derivative/sqrt/sqrtProductDerivative.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const sqrtProductDerivative: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sqrtProductDerivative.d.ts.map

package/lib/exercises/math/derivation/derivative/sqrt/sqrtProductDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtProductDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/sqrtProductDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/derivation/derivative/sqrt/sqrtProductDerivative.js

@@ -0,0 +1,85 @@
+import { addValidProp, shuffleProps, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.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 { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    //asqrt(x) + (ax+b)/2sqrt(x) = (2ax+ ax+b)/2sqrt(x)
+    return frac(add(multiply(3 * a, "x"), b), multiply(2, sqrt("x")))
+        .simplify()
+        .toTex();
+};
+const getFunction = (identifiers) => {
+    const { a, b } = identifiers;
+    return multiply(add(multiply(a, "x"), b).simplify({ forbidFactorize: true }), sqrt("x"));
+};
+const getInstruction = (identifiers) => {
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie sur $[0; +\\infty[$ par : 
+  
+$$
+f(x) = ${getFunction(identifiers).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
+const getKeys = (identifiers) => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSqrtProductDerivativeQuestion = (ops) => {
+    const a = randint(-9, 10, [0]);
+    const b = randint(-9, 10);
+    const identifiers = { a, b };
+    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 sqrtProductDerivative = {
+    id: "sqrtProductDerivative",
+    connector: "=",
+    label: "Dérivée de $(ax+b)\\sqrt{x}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSqrtProductDerivativeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/derivation/derivative/trigo/cosCompositionDerivation.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    affineA: number;
+    affineB: number;
+};
+export declare const cosCompositionDerivation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cosCompositionDerivation.d.ts.map

package/lib/exercises/math/derivation/derivative/trigo/cosCompositionDerivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/cosCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}