math-exercises 3.0.56 → 3.0.58

package/lib/exercises/math/derivation/derivative/polynomial/thirdDegreeDerivative.js

@@ -0,0 +1,134 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { polynomialParser } from "../../../../../tree/parsers/polynomialParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getHint = (identifiers) => {
+    return `Dérive chacun des termes de la somme, puis additionne les dérivées obtenues. 
+  
+On rappelle que la dérivée de la fonction $kx^n$ est : 
+
+$$
+k\\times n \\times x^{n-1}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const monoms = identifiers.coefficients
+        .map((c, i) => multiply(c, power("x", i)).simplify())
+        .filter((n) => n.evaluate() !== 0);
+    const answer = getAnswer(identifiers);
+    return `On dérive chacun des termes de la somme : 
+  
+${monoms
+        .reverse()
+        .map((n) => `- $${n.toTex()} \\to ${n.derivative().simplify().toTex()}$`)
+        .join(" \n ")}
+
+Puis, on additionne ces résultats pour obtenir la dérivée de la fonction $f$ :
+
+$$
+f'(x) = ${answer}
+$$
+`;
+};
+const getInstruction = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coefficients);
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par :
+  
+$$
+f(x) = ${polynomial.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coefficients);
+    const derivative = polynomial.derivate();
+    return derivative.toTree().toTex();
+};
+export const getThirdDegreeDerivative = () => {
+    const coefficients = [];
+    for (let i = 1; i <= 3; i++)
+        coefficients.push(randint(-9, 10));
+    coefficients.push(randint(-9, 10, [0]));
+    const identifiers = { coefficients };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: `f'(x)`,
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const getThirdDegreeDerivativePropositions = (n, { answer, coefficients }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (coefficients[2] !== 0)
+        tryToAddWrongProp(propositions, new Polynomial([coefficients[0], coefficients[1], coefficients[2]])
+            .toTree()
+            .toTex());
+    if (coefficients[2] !== 0)
+        tryToAddWrongProp(propositions, new Polynomial([
+            coefficients[0] + coefficients[1],
+            coefficients[1],
+            coefficients[2],
+        ])
+            .toTree()
+            .toTex());
+    while (propositions.length < n) {
+        const randomCoefficients = [];
+        for (let j = 1; j <= 3; j++)
+            randomCoefficients.push(randint(-9, 10));
+        randomCoefficients.push(randint(-9, 10, [0]));
+        const randomPolynomial = new Polynomial(randomCoefficients);
+        tryToAddWrongProp(propositions, randomPolynomial.derivate().toTree().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+export const isThirdDegreeDerivativeAnswerValid = (ans, { answer, coefficients }) => {
+    try {
+        const parsed = polynomialParser(ans);
+        if (!parsed)
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        return simp.toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const thirdDegreeDerivative = {
+    id: "thirdDegreeDerivative",
+    connector: "=",
+    label: "Dérivée d'un polynôme de degré $3$",
+    levels: [
+        "1reESM",
+        "1reSpé",
+        "1reTech",
+        "MathComp",
+        "1rePro",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Dérivation"],
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getThirdDegreeDerivative, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions: getThirdDegreeDerivativePropositions,
+    isAnswerValid: isThirdDegreeDerivativeAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getAnswer,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/polynomial/usualderivative.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercise.js";
+type Identifiers = {
+    type: number;
+    a?: number;
+    b?: number;
+    coefficients?: number[];
+    tex?: string;
+};
+export declare const usualDerivative: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=usualderivative.d.ts.map

package/lib/exercises/math/derivation/derivative/polynomial/usualderivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usualderivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/polynomial/usualderivative.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAMT,MAAM,yBAAyB,CAAC;AAuBjC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AA0FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/math/derivation/derivative/polynomial/usualderivative.js

@@ -0,0 +1,97 @@
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { getDistinctQuestions } from "../../../../utils/getDistinctQuestions.js";
+import { getConstanteDerivative, getConstanteDerivativePropositions, isConstanteDerivativeAnswerValid, } from "./constanteDerivative.js";
+import { getFirstDegreeDerivative, getFirstDegreeDerivativePropositions, isFirstDegreeDerivativeAnswerValid, } from "./firstDegreeDerivative.js";
+import { getSecondDegreeDerivative, getSecondDegreeDerivativePropositions, isSecondDegreeDerivativeAnswerValid, } from "./secondDegreeDerivative.js";
+import { getThirdDegreeDerivative, getThirdDegreeDerivativePropositions, isThirdDegreeDerivativeAnswerValid, } from "./thirdDegreeDerivative.js";
+const getUsualDerivative = () => {
+    const type = randint(1, 5);
+    let question;
+    let identifiers;
+    switch (type) {
+        case 1:
+            question = getFirstDegreeDerivative();
+            identifiers = { ...question.identifiers, type: 1 };
+            break;
+        case 2:
+            question = getSecondDegreeDerivative();
+            identifiers = { ...question.identifiers, type: 2 };
+            break;
+        case 3:
+            question = getThirdDegreeDerivative();
+            identifiers = { ...question.identifiers, type: 3 };
+            break;
+        case 4:
+            question = getConstanteDerivative();
+            identifiers = { ...question.identifiers, type: 4 };
+            break;
+        default:
+            throw Error("erreur");
+    }
+    return { ...question, identifiers };
+};
+const getPropositions = (n, { answer, type, a, b, coefficients, tex }) => {
+    let props;
+    switch (type) {
+        case 1:
+            props = getFirstDegreeDerivativePropositions(n, { a: a, answer, b: b });
+            break;
+        case 2:
+            props = getSecondDegreeDerivativePropositions(n, {
+                answer,
+                coefficients: coefficients,
+            });
+            break;
+        case 3:
+            props = getThirdDegreeDerivativePropositions(n, {
+                answer,
+                coefficients: coefficients,
+            });
+            break;
+        case 4:
+            props = getConstanteDerivativePropositions(n, { answer, tex: tex });
+            break;
+        default:
+            throw Error("erreur");
+    }
+    return props;
+};
+const isAnswerValid = (ans, { answer, type, coefficients, a, b, tex }) => {
+    let valid;
+    switch (type) {
+        case 1:
+            valid = isFirstDegreeDerivativeAnswerValid(ans, { answer, a: a, b: b });
+            break;
+        case 2:
+            valid = isSecondDegreeDerivativeAnswerValid(ans, {
+                coefficients: coefficients,
+                answer,
+            });
+            break;
+        case 3:
+            valid = isThirdDegreeDerivativeAnswerValid(ans, {
+                coefficients: coefficients,
+                answer,
+            });
+            break;
+        case 4:
+            valid = isConstanteDerivativeAnswerValid(ans, { answer, tex: tex });
+            break;
+        default:
+            throw Error("erreur");
+    }
+    return valid;
+};
+export const usualDerivative = {
+    id: "usualDerivative",
+    connector: "=",
+    label: "Dérivées des fonctions de référence",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getUsualDerivative, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/power/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./powerCompositionDerivation.js";
+export * from "./powerFunctionDerivative.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"powerCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/power/powerCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

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,
+};