math-exercises 3.0.57 → 3.0.59

package/lib/exercises/math/derivation/derivative/trigo/cosCompositionDerivation.js

@@ -0,0 +1,81 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { OppositeNode } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { SinNode } from "../../../../../tree/nodes/functions/sinNode.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 CosNode(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 deriv = new MultiplyNode((-affine.a).toTree(), new SinNode(affine.toTree()));
+    return deriv.toTex();
+};
+const getCosCompositionDerivationQuestion = () => {
+    const affine = AffineConstructor.random(undefined, { excludes: [0] });
+    const identifiers = { affineA: affine.a, affineB: affine.b };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affineA, affineB }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new Affine(affineA, affineB);
+    const affineTree = affine.toTree();
+    const fct = new CosNode(affineTree);
+    const sin = new SinNode(affineTree);
+    tryToAddWrongProp(propositions, new MultiplyNode(affineA.toTree(), sin).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affineA.toTree(), fct).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode((-affineA).toTree(), fct).toTex());
+    tryToAddWrongProp(propositions, sin.toTex());
+    tryToAddWrongProp(propositions, new OppositeNode(sin).toTex());
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, affineA, affineB }) => {
+    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 cosCompositionDerivation = {
+    id: "cosCompositionDerivation",
+    connector: "=",
+    label: "Dérivée de $\\cos(ax+b)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCosCompositionDerivationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"cosSecondDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/cosSecondDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA+HF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/derivation/derivative/trigo/cosSecondDegreeDerivative.js

@@ -0,0 +1,103 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { SinNode } from "../../../../../tree/nodes/functions/sinNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { AddNode } from "../../../../../tree/nodes/operators/addNode.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";
+const getInstruction = (identifiers) => {
+    const { affinecoeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affinecoeffs);
+    const func = new CosNode(affine.toTree().simplify({ forbidFactorize: true })).toTex();
+    return `Calculez la dérivée seconde de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${func}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affinecoeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affinecoeffs);
+    const ans = new MultiplyNode(new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new NumberNode(-1)), new CosNode(affine.toTree().simplify({ forbidFactorize: true })))
+        .simplify({ forbidFactorize: true })
+        .toTex();
+    return ans;
+};
+const getCosSecondDegreeDerivativeQuestion = () => {
+    const affine = AffineConstructor.random();
+    const affinecoeffs = affine.coefficients;
+    const identifiers = { affinecoeffs };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affinecoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new AddNode(new MultiplyNode(new NumberNode(affinecoeffs[1]), new VariableNode("x")), new NumberNode(affinecoeffs[0])).simplify({ forbidFactorize: true });
+    const wronganswer1 = new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new CosNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer2 = new MultiplyNode(new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new NumberNode(-1)), new SinNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer3 = new MultiplyNode(affinecoeffs[1].toTree(), new SinNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer4 = new MultiplyNode(affinecoeffs[1].toTree(), new CosNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer5 = affine.toTex();
+    tryToAddWrongProp(propositions, wronganswer1);
+    tryToAddWrongProp(propositions, wronganswer2);
+    tryToAddWrongProp(propositions, wronganswer3);
+    tryToAddWrongProp(propositions, wronganswer4);
+    tryToAddWrongProp(propositions, wronganswer5);
+    while (propositions.length < n) {
+        const random = AffineConstructor.random();
+        const randomwronganswer = new MultiplyNode(random.a.toTree(), new SinNode(random.toTree().simplify({ forbidFactorize: true })))
+            .simplify()
+            .toTex();
+        tryToAddWrongProp(propositions, randomwronganswer);
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, affinecoeffs }) => {
+    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 cosSecondDegreeDerivative = {
+    id: "cosSecondDegreeDerivative",
+    label: "Dérivée seconde de $\\cos(u)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCosSecondDegreeDerivativeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

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

@@ -0,0 +1,5 @@
+export * from "./cosCompositionDerivation.js";
+export * from "./sinCompositionDerivation.js";
+export * from "./sinSecondDegreeDerivative.js";
+export * from "./cosSecondDegreeDerivative.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./cosCompositionDerivation.js";
+export * from "./sinCompositionDerivation.js";
+export * from "./sinSecondDegreeDerivative.js";
+export * from "./cosSecondDegreeDerivative.js";

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

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

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

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

package/lib/exercises/math/derivation/derivative/trigo/sinCompositionDerivation.js

@@ -0,0 +1,70 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { OppositeNode } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { SinNode } from "../../../../../tree/nodes/functions/sinNode.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+const getInstruction = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    const fct = new SinNode(affine.toTree());
+    return `Déterminer la dérivée de la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${fct.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    const deriv = new MultiplyNode(affine.a.toTree(), new CosNode(affine.toTree()));
+    return deriv.toTex();
+};
+const getSinCompositionDerivationQuestion = () => {
+    const affine = AffineConstructor.random(undefined, { excludes: [0] });
+    const identifiers = { affineA: affine.a, affineB: affine.b };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affineA, affineB }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new Affine(affineA, affineB);
+    const affineTree = affine.toTree();
+    const sin = new SinNode(affineTree);
+    const cos = new CosNode(affineTree);
+    tryToAddWrongProp(propositions, new MultiplyNode(affineA.toTree(), sin).toTex());
+    tryToAddWrongProp(propositions, cos.toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode((-affineA).toTree(), cos).toTex());
+    tryToAddWrongProp(propositions, new OppositeNode(cos).toTex());
+    tryToAddWrongProp(propositions, new SinNode(affineA.toTree()).simplify().toTex());
+    tryToAddWrongProp(propositions, new CosNode(affineA.toTree()).simplify().toTex());
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, affineA, affineB }) => {
+    const affine = new Affine(affineA, affineB);
+    const deriv = new MultiplyNode(affineA.toTree(), new CosNode(affine.toTree()));
+    const texs = deriv.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const sinCompositionDerivation = {
+    id: "sinCompositionDerivation",
+    connector: "=",
+    label: "Dérivée de $\\sin(ax+b)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSinCompositionDerivationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sinSecondDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/sinSecondDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/derivation/derivative/trigo/sinSecondDegreeDerivative.js

@@ -0,0 +1,91 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { SinNode } from "../../../../../tree/nodes/functions/sinNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { AddNode } from "../../../../../tree/nodes/operators/addNode.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";
+const getAnswer = (identifiers) => {
+    const { affinecoeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affinecoeffs);
+    const ans = new MultiplyNode(new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new NumberNode(-1)), new SinNode(affine.toTree().simplify({ forbidFactorize: true })))
+        .simplify()
+        .toTex();
+    return ans;
+};
+const getInstruction = (identifiers) => {
+    const { affinecoeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affinecoeffs);
+    const func = new SinNode(affine.toTree().simplify({ forbidFactorize: true })).toTex();
+    return `Calculez la dérivée seconde de la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${func}
+$$`;
+};
+const getSinSecondDegreeDerivativeQuestion = () => {
+    const affine = AffineConstructor.random();
+    const affinecoeffs = affine.coefficients;
+    const identifiers = { affinecoeffs };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, affinecoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new AddNode(new MultiplyNode(new NumberNode(affinecoeffs[1]), new VariableNode("x")), new NumberNode(affinecoeffs[0])).simplify({ forbidFactorize: true });
+    const wronganswer1 = new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new SinNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer2 = new MultiplyNode(new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new NumberNode(-1)), new CosNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer3 = new MultiplyNode(affinecoeffs[1].toTree(), new CosNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer4 = new MultiplyNode(affinecoeffs[1].toTree(), new SinNode(affine))
+        .simplify()
+        .toTex();
+    const wronganswer5 = affine.toTex();
+    tryToAddWrongProp(propositions, wronganswer1);
+    tryToAddWrongProp(propositions, wronganswer2);
+    tryToAddWrongProp(propositions, wronganswer3);
+    tryToAddWrongProp(propositions, wronganswer4);
+    tryToAddWrongProp(propositions, wronganswer5);
+    while (propositions.length < n) {
+        const random = AffineConstructor.random();
+        const randomwronganswer = new MultiplyNode(random.a.toTree(), new CosNode(random.toTree().simplify({ forbidFactorize: true })))
+            .simplify()
+            .toTex();
+        tryToAddWrongProp(propositions, randomwronganswer);
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, affinecoeffs }) => {
+    const affine = new AddNode(new MultiplyNode(new NumberNode(affinecoeffs[1]), new VariableNode("x")), new NumberNode(affinecoeffs[0])).simplify({ forbidFactorize: true });
+    const validanswer = new MultiplyNode(new MultiplyNode(new PowerNode(new NumberNode(affinecoeffs[1]), new NumberNode(2)), new NumberNode(-1)), new SinNode(affine)).simplify();
+    const latexs = validanswer.toAllValidTexs();
+    return latexs.includes(ans);
+};
+export const sinSecondDegreeDerivative = {
+    id: "sinSecondDegreeDerivative",
+    label: "Dérivée seconde de $\\sin(u)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSinSecondDegreeDerivativeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/derivation/derivativeNumberCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeNumberCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/derivativeNumberCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"derivativeNumberCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/derivativeNumberCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8DF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

package/lib/exercises/math/derivation/derivativeNumberCalcul.js

@@ -24,6 +24,9 @@ const getDerivativeNumberCalculQuestion = () => {
     const x = randint(-9, 10);
     const trinom = PolynomialConstructor.randomWithOrder(2);
     const identifiers = { x, coeffs: trinom.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -61,6 +64,5 @@ export const derivativeNumberCalcul = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    getInstruction,
-    getAnswer,
+    getQuestionFromIdentifiers,
 };

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

@@ -1,4 +1,6 @@
 export * from "./derivative/index.js";
 export * from "./derivativeNumberCalcul.js";
 export * from "./tangent/index.js";
+export * from "./variations/index.js";
+export * from "./convexity/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC"}

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

@@ -1,3 +1,5 @@
 export * from "./derivative/index.js";
 export * from "./derivativeNumberCalcul.js";
 export * from "./tangent/index.js";
+export * from "./variations/index.js";
+export * from "./convexity/index.js";

package/lib/exercises/math/derivation/variations/index.d.ts

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

package/lib/exercises/math/derivation/variations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/derivation/variations/index.js

@@ -0,0 +1 @@
+export * from "./thirdDegreeFunctionVariation.js";

package/lib/exercises/math/derivation/variations/thirdDegreeFunctionVariation.d.ts

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

package/lib/exercises/math/derivation/variations/thirdDegreeFunctionVariation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwKF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}

package/lib/exercises/math/derivation/variations/thirdDegreeFunctionVariation.js

@@ -0,0 +1,168 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { UnionIntervalNode } from "../../../../tree/nodes/sets/unionIntervalNode.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.c !== undefined)
+        return oldIds;
+    return {
+        ...oldIds,
+        c: randint(-2, 3),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
+    return `Soit $f$ la fonction représentée ci-dessous. 
+    
+Sur quel(s) intervalle(s) la fonction dérivée $f'$ de $f$ est-elle ${coin < 0 ? "négative" : "positive"} ?`;
+};
+const getHint = (identifiers) => {
+    return `Si la fonction $f$ est croissante sur un intervalle, alors sa fonction dérivée $f'$ sera positive sur cet intervalle.
+  
+À l'inverse, si la fonction $f$ est décroissante sur un intervalle, alors sa fonction dérivée $f'$ sera négative sur cet intervalle.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
+    const variation = coin < 0 ? "décroissante" : "croissante";
+    const sign = coin < 0 ? "négative" : "positive";
+    const intervals = getIntervalsSolution(identifiers);
+    return `Si la fonction $f$ est ${variation} sur un intervalle, alors sa fonction dérivée $f'$ sera ${sign} sur cet intervalle. 
+  
+Ici, on lit graphiquement que $f$ est ${variation} sur $${intervals[0].toTex()}$${intervals[1] ? ` et sur $${intervals[1].toTex()}$` : ""}.
+
+On en déduit que $f'$ est donc ${sign} sur : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getIntervalsSolution = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
+    const racine1Tree = new NumberNode(racine1);
+    const racine2Tree = new NumberNode(racine2);
+    const intervals = coin * a < 0
+        ? [new IntervalNode(racine1Tree, racine2Tree, ClosureType.FF)]
+        : [
+            new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF),
+            new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO),
+        ];
+    return intervals;
+};
+const getAnswer = (identifiers) => {
+    const intervals = getIntervalsSolution(identifiers);
+    if (intervals.length === 1)
+        return intervals[0].toTex();
+    else
+        return new UnionIntervalNode(intervals).toTex();
+};
+const getGGBOptions = (identifiers) => {
+    const { a, coin, racine1, racine2, c } = identifiers;
+    const coefs = [
+        c,
+        a * racine1 * racine2,
+        (-a * (racine1 + racine2)) / 2,
+        a / 3,
+    ];
+    const polynome = new Polynomial(coefs);
+    const y1 = polynome.calculate(racine1);
+    const y2 = polynome.calculate(racine2);
+    const commands = [
+        `f(x) = ${polynome.toMathString()}`,
+        `SetColor(f, "${randomColor()}")`,
+    ];
+    const yMax = Math.max(y1, y2);
+    const yMin = Math.min(y1, y2);
+    const xMax = Math.max(racine1, racine2);
+    const xMin = Math.min(racine1, racine2);
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+        gridDistance: false,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getThirdDegreeFunctionVariation = () => {
+    const a = randint(-3, 4, [0]);
+    const c = randint(-2, 3);
+    const racine1 = randint(-5, 4);
+    const racine2 = randint(racine1 + 1, 6);
+    const coin = coinFlip() ? -1 : 1;
+    const identifiers = { racine1, racine2, coin, a, c };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: "S",
+        answer: getAnswer(identifiers),
+        keys: ["lbracket", "rbracket", "semicolon", "infty", "cup"],
+        answerFormat: "tex",
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, racine1, racine2 }) => {
+    const racine1Tree = new NumberNode(racine1);
+    const racine2Tree = new NumberNode(racine2);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO).toTex());
+    tryToAddWrongProp(propositions, new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF).toTex());
+    tryToAddWrongProp(propositions, new UnionIntervalNode([
+        new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF),
+        new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO),
+    ]).toTex());
+    while (propositions.length < n) {
+        const root1 = randint(-5, 4);
+        const root2 = randint(root1 + 1, 6);
+        const root1Tree = new NumberNode(racine1);
+        const root2Tree = new NumberNode(racine2);
+        const wrongAnswer = new IntervalNode(root1Tree, root2Tree, ClosureType.FF).toTex();
+        tryToAddWrongProp(propositions, wrongAnswer);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, racine1, racine2, coin, a }) => {
+    try {
+        const parsed = unionIntervalParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const thirdDegreeFunctionVariation = {
+    id: "thirdDegreeFunctionVariation",
+    connector: "=",
+    label: "Lecture du signe de la dérivée via les variations d'une fonction",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getThirdDegreeFunctionVariation, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    rebuildIdentifiers,
+    hasHintAndCorrection: true,
+    getHint,
+    getCorrection,
+};

package/lib/exercises/math/equaDiff/equaDiffAyPlusB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equaDiffAyPlusB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/equaDiff/equaDiffAyPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8GF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"equaDiffAyPlusB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/equaDiff/equaDiffAyPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}