math-exercises 3.0.53 → 3.0.55

package/lib/exercises/math/geometry/vectors/colinearity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/colinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyCF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}
+{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/colinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;CACrB,CAAC;AA4GF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}

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

@@ -1,16 +1,79 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.xu?.id)
+        return oldIds;
+    return {
+        xu: oldIds.xu.toTree().toIdentifiers(),
+        yu: oldIds.yu.toTree().toIdentifiers(),
+        xv: oldIds.xv.toTree().toIdentifiers(),
+        yv: oldIds.yv.toTree().toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    return `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
+  
+Les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont-ils colinéaires ?`;
+};
+const getHint = (identifiers) => {
+    const u = new Vector("u", "x".toTree(), "y".toTree());
+    const v = new Vector("v", "x'".toTree(), "y'".toTree());
+    return `Deux vecteurs sont colinéaires si et seulement si leur déterminant est nul. 
+  
+Le déterminant de deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$ est :
+
+$$
+\\det(${u.toTex()}, ${v.toTex()}) = ${u.determinant(v).simplify().toTex()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    const det = u.determinant(v);
+    const detSimp = det.simplify();
+    const isCol = detSimp.evaluate() === 0;
+    return `On calcule le déterminant de $${u.toTex()}$ et $${v.toTex()}$ : 
+
+${alignTex([
+        ["", `\\det(${u.toTex()}, ${v.toTex()})`],
+        ["=", det.toTex()],
+        ["=", detSimp.toTex()],
+    ])}
+
+${isCol
+        ? `Puisque le déterminant est nul, les vecteurs sont bien colinéaires.`
+        : `Puisque le déterminant n'est pas nul, les vecteurs ne sont pas colinéaires.`}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
 const getColinearityQuestion = () => {
     const u = VectorConstructor.random("u", false);
     const isColinear = coinFlip();
     let v;
     if (isColinear) {
-        const coeff = new NumberNode(randint(-5, 5));
+        const coeff = coinFlip()
+            ? new NumberNode(randint(-5, 5, [0, 1]))
+            : RationalConstructor.randomIrreductible(5).toTree();
         v = u.times(coeff, "v");
     }
     else {
@@ -18,25 +81,22 @@ const getColinearityQuestion = () => {
             v = VectorConstructor.random("v", false);
         } while (u.isColinear(v));
     }
-    // const isColinear = u.isColinear(v);
-    const answer = isColinear ? "Oui" : "Non";
-    const question = {
-        answer,
-        instruction: `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. $${u.toTex()}$ et $${v.toTex()}$ sont-ils colinéaires ?`,
-        keys: [],
-        answerFormat: "raw",
-        identifiers: {
-            xu: u.x.evaluate({}),
-            xv: v.x.evaluate({}),
-            yu: u.y.evaluate({}),
-            yv: v.y.evaluate({}),
-        },
+    const identifiers = {
+        xu: u.x.toIdentifiers(),
+        xv: v.x.toIdentifiers(),
+        yu: u.y.toIdentifiers(),
+        yv: v.y.toIdentifiers(),
     };
-    return question;
+    return getQuestionFromIdentifiers(identifiers);
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    addValidProp(propositions, answer, "raw");
+    // addValidProp(propositions, answer, "raw");
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    const isCol = u.isColinear(v);
+    addValidProp(propositions, isCol ? "Oui" : "Non", "raw");
     tryToAddWrongProp(propositions, "Oui", "raw");
     tryToAddWrongProp(propositions, "Non", "raw");
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
@@ -44,14 +104,15 @@ const getPropositions = (n, { answer }) => {
 };
 export const colinearity = {
     id: "colinearity",
-    label: "Déterminer si deux vecteurs sont colinéaires",
-    levels: ["2nde", "1reSpé"],
+    label: "Déterminer si deux vecteurs sont colinéaires (par les coordonnées)",
     isSingleStep: true,
-    sections: ["Vecteurs"],
     generator: (nb) => getDistinctQuestions(getColinearityQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     answerType: "QCU",
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/findCoordForAligment.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=findCoordForAligment.d.ts.map

package/lib/exercises/math/geometry/vectors/findCoordForAligment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findCoordForAligment.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/findCoordForAligment.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,92 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+// } from '../../../../exercises/exercise.js';
+// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
+// import { PointConstructor } from '../../../../math/geometry/point.js';
+// import { VectorConstructor } from '../../../../math/geometry/vector.js';
+// import { RationalConstructor } from '../../../../math/numbers/rationals/rational.js';
+// import { randint } from '../../../../math/utils/random/randint.js';
+// import { coinFlip } from '../../../../utils/alea/coinFlip.js';
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {
+//     throw Error("QCM not implemented")
+//   }
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer : GetAnswer<Identifiers> = (identifiers)=>{
+// }
+// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
+//   return `Les points $${}$, $${}$ et $${}$ sont alignés.
+// Déterminer $x$.`
+// }
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
+//   return []
+// }
+// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
+//   try {
+//     throw Error("VEA not implemented")
+//   } catch(err){
+//     return handleVEAError(err)
+//   }
+// }
+// const getFindCoordForAligmentQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
+//   const points = PointConstructor.randomDifferent(2, {names: ["A","B"]})
+//   const vec = VectorConstructor.fromPoints(points[0],points[1])
+//     const coeff = coinFlip()
+//       ? randint(-5, 5, [0, 1]).toTree()
+//       : RationalConstructor.randomIrreductible(5).toTree();
+//   const last = vec.times(coeff).getEndPoint(points[0])
+//   const identifiers: Identifiers = {}
+//   return getQuestionFromIdentifiers(identifiers);
+// }
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (identifiers)=>{
+//   return {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: 'tex',
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers)
+//   }
+// }
+// export const findCoordForAligment: Exercise<Identifiers> = {
+//   id: 'findCoordForAligment',
+//   connector: "=",
+//   label: "Déterminer une coordonnée manquante d'un point pour obtenir un alignement",
+//   isSingleStep: true,
+//   generator: (nb, opts) => getDistinctQuestions(()=>getFindCoordForAligmentQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswer,
+//   getQuestionFromIdentifiers
+// };

package/lib/exercises/math/powers/calculatePower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculatePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculatePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}
+{"version":3,"file":"calculatePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculatePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/powers/calculatePower.js

@@ -2,21 +2,76 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 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";
-const getCalculatePowerQuestion = () => {
-    const int = randint(-10, 11);
-    const power = randint(0, 6);
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { int, power } = identifiers;
     const statement = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
+    return `Calculer : 
+
+$$
+${statement}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { int, power } = identifiers;
     const answer = int ** power + "";
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { int, power } = identifiers;
+    return `L'écriture $a^b$ signifie : le nombre $a$ multiplié $b$ fois par lui-même.
+  
+D'autre part, pour tout nombre $a$, on a $a^0 = 1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { int, power } = identifiers;
+    const statement = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
+    if (power === 0) {
+        return `Pour tout nombre $a$, on a $a^0 = 1$. 
+    
+Ici, on a donc : 
+
+$$
+${statement} = ${getAnswer(identifiers)}
+$$`;
+    }
+    if (power === 1) {
+        return `Élever un nombre à la puissance $1$ ne change pas ce nombre. On a donc : 
+    
+$$
+${statement} = ${getAnswer(identifiers)}
+$$`;
+    }
+    const mul = operatorComposition(MultiplyNode, Array(power).fill(int.toTree()));
+    return `On multiplie $${int}$ par lui-même $${power}$ fois : 
+  
+${alignTex([
+        [statement, "=", mul.toTex({ forceNoSimplification: true })],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Calculer : $${statement}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { int, power },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getCalculatePowerQuestion = () => {
+    const int = randint(-10, 11);
+    const power = randint(0, 6);
+    const identifiers = { int, power };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, int, power }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -58,4 +113,6 @@ export const calculatePower = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/powers/powerDefinition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerDefinition.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powerDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"powerDefinition.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powerDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA6FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/powers/powerDefinition.js

@@ -3,25 +3,56 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
-const getPowerDefinitionQuestion = () => {
-    const int = randint(2, 11);
-    const power = randint(2, 6);
+const getInstruction = (identifiers) => {
+    const { int, power } = identifiers;
     let statement = "";
     for (let i = 0; i < power; i++) {
         statement += int + "";
         if (i < power - 1)
             statement += "\\times";
     }
+    return `Écrire sous forme de puissance : 
+  
+$$
+${statement}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { int, power } = identifiers;
     const answer = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "Une puissance du type $a^b$ signifie : $a$ multiplié $b$ fois par lui-même.";
+};
+const getCorrection = (identifiers) => {
+    const { int, power } = identifiers;
+    return `Le nombre $${int}$ est multiplié $${power}$ fois par lui-même.
+  
+Ce produit s'écrit donc sous forme de puissance : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Écrire sous forme de puissance : $${statement}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { int, power },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getPowerDefinitionQuestion = () => {
+    const int = randint(2, 11);
+    const power = randint(2, 6);
+    const identifiers = { int, power };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const isAnswerValid = (ans, { int, power }) => {
     const answer = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
     return ans === answer;
@@ -41,13 +72,13 @@ export const powerDefinition = {
     id: "powerDefinition",
     connector: "=",
     label: "Écrire un produit sous forme de puissance",
-    levels: ["4ème", "3ème", "2ndPro", "CAP"],
     isSingleStep: true,
-    sections: ["Puissances"],
     generator: (nb) => getDistinctQuestions(getPowerDefinitionQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/powers/powersOfTenToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersOfTenToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersOfTenToDecimal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"powersOfTenToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersOfTenToDecimal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

package/lib/exercises/math/powers/powersOfTenToDecimal.js

@@ -1,6 +1,7 @@
 /**
  * 10^(-x) into 0,0...1
  */
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 import { Power } from "../../../math/numbers/integer/power.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
@@ -60,7 +61,7 @@ const getPropositions = (n, { answer, randPower }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return numberVEA(ans, answer);
 };
 export const powersOfTenToDecimal = {
     id: "powersOfTenToDecimal",

package/lib/exercises/math/powers/powersPower.d.ts

@@ -7,7 +7,10 @@ type Identifiers = {
     b: number;
     c: number;
 };
-export declare const powersOfTenPower: Exercise<Identifiers>;
-export declare const powersPower: Exercise<Identifiers>;
+type Options = {
+    useOnlyPowersOfTen: boolean;
+};
+export declare const powersOfTenPower: Exercise<Identifiers, Options>;
+export declare const powersPower: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=powersPower.d.ts.map

package/lib/exercises/math/powers/powersPower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersPower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersPower.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CA6BlD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAiB7C,CAAC"}
+{"version":3,"file":"powersPower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersPower.ts"],"names":[],"mappings":"AAAA;;GAEG;AAWH,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AA6GF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB3D,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBtD,CAAC"}

package/lib/exercises/math/powers/powersPower.js

@@ -3,32 +3,74 @@
  */
 import { Power } from "../../../math/numbers/integer/power.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 { powerParser } from "../../../tree/parsers/powerParser.js";
 import { rationalParser } from "../../../tree/parsers/rationalParser.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
-const getPowersPowerQuestion = (opts) => {
-    const a = opts?.useOnlyPowersOfTen ? 10 : randint(-11, 11, [0, 1]);
-    const [b, c] = [1, 2].map((el) => randint(-11, 11));
+const getStartStatement = (identifiers) => {
+    const { a, b, c } = identifiers;
     const statement = power(power(a, b), c);
-    let answerTree = power(a, b * c).simplify();
-    const answer = answerTree.toTex();
     const statementTex = statement.toTex();
-    const question = {
-        instruction: `Simplifier : 
+    return statementTex;
+};
+const getInstruction = (identifiers) => {
+    return `Simplifier : 
     
 $$
-${statementTex}
-$$`,
-        startStatement: statementTex,
-        answer,
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    let answerTree = power(a, b * c).simplify();
+    const answer = answerTree.toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return `Si $a$, $b$ et $c$ sont trois nombres, alors : 
+  
+$$
+\\left(a^b\\right)^c = a^{b\\times c}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const statement = getStartStatement(identifiers);
+    return `On multiplie les puissances : 
+  
+${alignTex([
+        [
+            statement,
+            "=",
+            power(a, multiply(b, c)).toTex({ forceNoSimplification: true }),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { a, b, c },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getPowersPowerQuestion = (opts) => {
+    const a = opts?.useOnlyPowersOfTen ? 10 : randint(-10, 11, [0, 1]);
+    const [b, c] = [1, 2].map((el) => randint(-11, 11));
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
 const getPropositions = (n, { answer, a, b, c }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -38,6 +80,7 @@ const getPropositions = (n, { answer, a, b, c }) => {
         tryToAddWrongProp(propositions, "0");
         tryToAddWrongProp(propositions, "-2");
     }
+    tryToAddWrongProp(propositions, power(a, b + c).toTex());
     while (propositions.length < n) {
         const wrongExponent = b * c + randint(-11, 11, [0]);
         const wrongAnswerTree = new Power(a, wrongExponent).simplify();
@@ -62,20 +105,6 @@ export const powersOfTenPower = {
     id: "powersOfTenPower",
     connector: "=",
     label: "Puissance d'une puissance de $10$ ",
-    levels: [
-        "4ème",
-        "3ème",
-        "2nde",
-        "CAP",
-        "2ndPro",
-        "1reESM",
-        "1rePro",
-        "1reSpé",
-        "1reTech",
-        "TermPro",
-        "TermTech",
-    ],
-    sections: ["Puissances"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getPowersPowerQuestion({ useOnlyPowersOfTen: true }), nb),
     qcmTimer: 60,
@@ -83,13 +112,13 @@ export const powersOfTenPower = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };
 export const powersPower = {
     id: "powersPower",
     connector: "=",
     label: "Puissance d'une puissance",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Puissances"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getPowersPowerQuestion({ useOnlyPowersOfTen: false }), nb),
     qcmTimer: 60,
@@ -97,4 +126,6 @@ export const powersPower = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/trigonometry/calculateCosSinAndTan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateCosSinAndTan.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/calculateCosSinAndTan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAWvD,CAAC"}
+{"version":3,"file":"calculateCosSinAndTan.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/calculateCosSinAndTan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6FF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/math/trigonometry/calculateCosSinAndTan.js

@@ -8,6 +8,20 @@ import { SinNode } from "../../../tree/nodes/functions/sinNode.js";
 import { TanNode } from "../../../tree/nodes/functions/tanNode.js";
 import { DegreeNode } from "../../../tree/nodes/geometry/degree.js";
 import { random } from "../../../utils/alea/random.js";
+const getHint = (identifiers) => {
+    return "Utilise la calculatrice, réglée en mode degrés.";
+};
+const getCorrection = (identifiers) => {
+    const { degree, trigoFunct } = identifiers;
+    const node = trigoFunct === "tan" ? TanNode : trigoFunct === "sin" ? SinNode : CosNode;
+    return `On utilise la calculatrice, réglée en mode degrés.
+  
+On obtient : 
+
+$$
+${new node(new DegreeNode(degree)).toTex()} \\approx ${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { degree, trigoFunct } = identifiers;
     const node = trigoFunct === "tan" ? TanNode : trigoFunct === "sin" ? SinNode : CosNode;
@@ -44,12 +58,17 @@ const getCalculateCosSinAndTanQuestion = () => {
     const trigoFunct = random(trigo);
     const degree = randint(1, 180);
     const identifiers = { degree, trigoFunct };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -77,4 +96,6 @@ export const calculateCosSinAndTan = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/trigonometry/mainRemarkableValues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mainRemarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/mainRemarkableValues.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}
+{"version":3,"file":"mainRemarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/mainRemarkableValues.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}