math-exercises 3.0.56 → 3.0.57

package/lib/exercises/math/geometry/lines/cartesianEquationsIntersection.js

@@ -56,8 +56,59 @@ $$
 
 Déterminer les coordonnées du point d'intersection de $d_1$ et $d_2$.`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    const { cartesianCoeffs1, cartesianCoeffs2 } = identifiers;
+    const coeffs1 = cartesianCoeffs1.map((c) => reifyAlgebraic(c));
+    const coeffs2 = cartesianCoeffs2.map((c) => reifyAlgebraic(c));
+    const equa1 = getEquation(coeffs1).toTex();
+    const equa2 = getEquation(coeffs2).toTex();
+    return `Le point d'intersection de $d_1$ et $d_2$, s'il existe, est le point dont les coordonnées $(x;y)$ est une solution du système :
+  
+$$
+\\left\\{\\begin{matrix}
+${equa1} \\\\
+${equa2}
+\\end{matrix}\\right.
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { cartesianCoeffs1, cartesianCoeffs2 } = identifiers;
+    const coeffs1 = cartesianCoeffs1.map((c) => reifyAlgebraic(c));
+    const coeffs2 = cartesianCoeffs2.map((c) => reifyAlgebraic(c));
+    let equa1 = getEquation(coeffs1);
+    let equa2 = getEquation(coeffs2);
+    let corr = `On doit résoudre le système : 
+  
+$$
+\\left\\{\\begin{matrix}
+${equa1.toTex()} \\\\
+${equa2.toTex()}
+\\end{matrix}\\right.
+$$`;
+    coeffs1[2] = opposite(coeffs1[2].simplify());
+    coeffs2[2] = opposite(coeffs2[2].simplify());
+    const sys = new GeneralSystem([coeffs1, coeffs2]);
+    [equa1, equa2] = sys.getEqualNodes();
+    corr += `
+  
+c'est à dire : 
+
+$$
+${sys.toTex()}
+$$
+
+`;
+    corr += sys.toCorrectionTex();
+    corr += `
+
+Le point d'intersection de $d_1$ et $d_2$ a donc pour coordonnées : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+    return corr;
+};
 const getKeys = (identifiers) => {
     return ["semicolon"];
 };
@@ -93,8 +144,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 export const cartesianEquationsIntersection = {
@@ -112,4 +163,5 @@ export const cartesianEquationsIntersection = {
     // getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/lines/drawLineFromCartesianEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drawLineFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/drawLineFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAQvC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AA+HF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}
+{"version":3,"file":"drawLineFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/drawLineFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAMvC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AA4KF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/geometry/lines/drawLineFromCartesianEquation.js

@@ -5,7 +5,10 @@ import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js
 import { Line, LineConstructor } from "../../../../math/geometry/line.js";
 import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
 import { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getCartesianEquation = (identifiers) => {
     const { pointIds, vectorIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
@@ -20,11 +23,61 @@ $$
 ${getCartesianEquation(identifiers).toTex()}
 $$`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    const u = new Vector("u", opposite("b"), "a".toTree());
+    return `On peut commencer par chercher les coordonnées d'un point appartenant à la droite. Pour cela, on peut remplacer par exemple $x$ par $0$ et en déduire l'ordonnée $y$ du point d'abscisse $0$ de la droite.
+  
+Ensuite, on détermine les coordonnées d'un vecteur directeur de la droite. Une droite admettant une équation cartésienne de la forme :
+
+$$
+ax+by+c=0
+$$
+
+admet le vecteur $${u.toTexWithCoords()}$ comme vecteur directeur.
+`;
+};
+const getCorrection = (identifiers) => {
+    const equa = getCartesianEquation(identifiers);
+    const detailed = equa.toDetailedEvaluation({ x: (0).toTree() });
+    const detailedSimp = detailed.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const y = detailedSimp.isolate("y");
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const u = new Vector("u", opposite("b"), "a".toTree());
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    return `On remplace $x$ par $0$ dans l'équation de la droite pour déterminer l'ordonnée $y$ du point d'abscisse $0$ de la droite :
+  
+${alignTex([[detailed.toTex()], [detailedSimp.toTex()], [y.toTex()]])}
+
+Le point $${point.toTexWithCoords()}$ appartient donc à la droite $d$ : on peut le placer sur le graphique.
+
+Puis, on détermine les coordonnées d'un vecteur directeur de $d$. On sait qu'une droite admettant une équation cartésienne de la forme :
+
+$$
+ax+by+c=0
+$$
+
+admet le vecteur $${u.toTexWithCoords()}$ comme vecteur directeur. 
+
+Ici, un vecteur directeur de $d$ est donc $${vector.toTexWithCoords()}$.
+
+Pour tracer la droite $d$, on peut donc partir du point $A$, puis tracer le vecteur $${vector.toTex()}$. Cela nous donne un deuxième point $B$. On relie alors les points $A$ et $B$ pour obtenir la droite $d$.`;
+};
 const getGGBAnswer = (identifiers) => {
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const B = vector.getEndPoint(point, "B");
     const equa = getCartesianEquation(identifiers).toMathString();
-    return [`d: ${equa}`, `SetFixed(d, true)`];
+    return [
+        ...point.toGGBCommand(),
+        ...B.toGGBCommand(),
+        `d = Line(A,B)`,
+        `SetFixed(d, true)`,
+    ];
 };
 const getStudentGGBOptions = (identifiers) => {
     // throw new Error("vea devrait accepter arrondis");
@@ -72,24 +125,16 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
     return line.includes(point, 0.5) && line.includes(B, 0.5);
 };
 const getDrawLineFromCartesianEquationQuestion = () => {
-    const A = new Point("A", (0).toTree(), randint(-6, 7).toTree());
-    // let B: Point;
-    // const isVertical = probaFlip(0.1);
-    // const isHorizontal = probaFlip(0.1);
-    // if (isVertical) {
-    //   B = new Point("B", A.x, add(A.y, 2));
-    // } else if (isHorizontal) {
-    //   B = new Point("B", add(A.x, 2), A.y);
-    // } else {
-    //   B = new Point(
-    //     "B",
-    //     add(A.x, randint(-3, 4, [0])),
-    //     add(A.y, randint(-3, 4, [0])),
-    //   );
-    // }
-    const x = randint(-3, 4);
-    const y = randint(-3, 4, x === 0 ? [0] : undefined);
-    const vec = new Vector("u", x.toTree(), y.toTree());
+    let a;
+    let b;
+    let c;
+    do {
+        a = randint(-9, 10, [0]);
+        b = randint(-9, 10, [0]);
+        c = randint(-4, 5, [0]) * b; //pour que (0;y)=> y entier
+    } while (gcd(a, b, c) !== 1 || (a <= 0 && b <= 0 && c <= 0));
+    const A = new Point("A", (0).toTree(), -c / b);
+    const vec = new Vector("u", (-b).toTree(), a.toTree());
     const identifiers = {
         pointIds: A.toIdentifiers(),
         vectorIds: vec.toIdentifiers(),
@@ -102,8 +147,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         instruction: getInstruction(identifiers),
         studentGgbOptions: getStudentGGBOptions(identifiers),
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 export const drawLineFromCartesianEquation = {
@@ -114,11 +159,12 @@ export const drawLineFromCartesianEquation = {
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
-    // getHint,
+    getHint,
     getInstruction,
-    // getCorrection,
+    getCorrection,
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/limits/polynomLimit.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     coeffs: number[];
-    to: string;
+    to: "+\\infty" | "-\\infty";
 };
 export declare const polynomLimit: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/limits/polynomLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/polynomLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwCF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"polynomLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/polynomLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,UAAU,GAAG,UAAU,CAAC;CAC7B,CAAC;AA6DF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}

package/lib/exercises/math/limits/polynomLimit.js

@@ -1,24 +1,42 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
+import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getPolynomLimitQuestion = () => {
-    const poly = PolynomialConstructor.random(4);
-    const to = coinFlip() ? "+\\infty" : "-\\infty";
+const getInstruction = (identifiers) => {
+    const { coeffs, to } = identifiers;
+    const poly = new Polynomial(coeffs);
+    return `Déterminer la limite en $${to}$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${poly.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { coeffs, to } = identifiers;
+    const poly = new Polynomial(coeffs);
     const answer = poly.getLimit(to);
+    return answer;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answer,
-        instruction: `Déterminer la limite en $${to}$ de la fonction $f$ définie par : $f(x) = ${poly
-            .toTree()
-            .toTex()}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["infty"],
         answerFormat: "tex",
-        identifiers: { coeffs: poly.coefficients, to },
+        identifiers,
     };
     return question;
 };
+const getPolynomLimitQuestion = () => {
+    const poly = PolynomialConstructor.random(4);
+    const to = coinFlip() ? "+\\infty" : "-\\infty";
+    const identifiers = { coeffs: poly.coefficients, to };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, coeffs }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -48,4 +66,5 @@ export const polynomLimit = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/limits/polynomLimitNoFI.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     coeffs: number[];
-    to: string;
+    to: "+\\infty" | "-\\infty";
 };
 export declare const polynomLimitNoFI: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/limits/polynomLimitNoFI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomLimitNoFI.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/polynomLimitNoFI.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4CF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"polynomLimitNoFI.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/polynomLimitNoFI.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,UAAU,GAAG,UAAU,CAAC;CAC7B,CAAC;AAgEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/limits/polynomLimitNoFI.js

@@ -1,25 +1,43 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { PolynomialConstructor } from "../../../math/polynomials/polynomial.js";
+import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getSequencePolynomNoFILimitQuestion = () => {
-    const length = randint(2, 5);
-    const to = coinFlip() ? "+\\infty" : "-\\infty";
-    const poly = PolynomialConstructor.randomNoFI(4, to, length);
+const getInstruction = (identifiers) => {
+    const { coeffs, to } = identifiers;
+    const poly = new Polynomial(coeffs);
+    return `Déterminer la limite en $${to}$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${poly.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { coeffs, to } = identifiers;
+    const poly = new Polynomial(coeffs);
     const answer = poly.getLimit(to);
+    return answer;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answer,
-        instruction: `Déterminer la limite en $${to}$ de la fonction $f$ définie par : $f(x) = ${poly
-            .toTree()
-            .toTex()}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["infty"],
         answerFormat: "tex",
-        identifiers: { coeffs: poly.coefficients, to },
+        identifiers,
     };
     return question;
 };
+const getSequencePolynomNoFILimitQuestion = () => {
+    const length = randint(2, 5);
+    const to = coinFlip() ? "+\\infty" : "-\\infty";
+    const poly = PolynomialConstructor.randomNoFI(4, to, length);
+    const identifiers = { coeffs: poly.coefficients, to };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, coeffs }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -48,4 +66,5 @@ export const polynomLimitNoFI = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAYxD,CAAC"}
+{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -1,28 +1,65 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { Power } from "../../../math/numbers/integer/power.js";
 import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
-import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
-import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
+import { isNumberNode, NumberNode, } from "../../../tree/nodes/numbers/numberNode.js";
+import { frac, isFractionNode, } from "../../../tree/nodes/operators/fractionNode.js";
 import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
-const getCalculatePowerQuestion = () => {
-    const int = randint(1, 11);
-    const power = randint(-5, 0);
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { int, power } = identifiers;
     const statement = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
+    return `Calculer et donner le résultat sous la forme d'une fraction ou d'un entier : 
+
+$$
+${statement}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { int, power } = identifiers;
     const answer = new Rational(1, int ** Math.abs(power))
         .simplify()
         .toTree()
         .toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { int, power } = identifiers;
+    return `Pour tous nombre $a$ et tout nombre $x$ positif, on a : 
+  
+$$
+a^{-x} = \\frac{1}{a^x}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { int, power } = identifiers;
+    const statement = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
+    const fraction = frac(1, new PowerNode(int.toTree(), Math.abs(power).toTree()));
+    return `Puisque $a^{-x} = \\frac{1}{a^x}$, on a : 
+  
+$$
+${statement} = ${fraction.toSimplificationTex()}
+$$`;
+};
+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(1, 11);
+    const power = randint(-5, 0);
+    const identifiers = { int, power };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, int, power }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -46,13 +83,17 @@ const getPropositions = (n, { answer, int, power }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { int, power }) => {
-    const answerTree = new Rational(1, int ** Math.abs(power))
-        .simplify()
-        .toTree({ allowFractionToDecimal: true });
-    const secondTree = new FractionNode(new NumberNode(1), new Power(int, -power).simplify());
-    const texs = [...answerTree.toAllValidTexs(), ...secondTree.toAllValidTexs()];
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, int, power }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!isNumberNode(parsed) && !isFractionNode(parsed)) {
+            return false;
+        }
+        return parsed.simplify({ calculatePowers: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const calculateNegativePower = {
     id: "calculateNegativePower",
@@ -65,4 +106,6 @@ export const calculateNegativePower = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAoDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAqGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

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

@@ -5,8 +5,59 @@ 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 { probaFlip } from "../../../utils/alea/probaFlip.js";
+import { pluralize } from "../../../utils/strings/pluralize.js";
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
+const getInstruction = (identifiers) => {
+    const { decimal } = identifiers;
+    return `Donner l'écriture scientifique du nombre suivant : 
+  
+$$
+${decimal.frenchify()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { decimal } = identifiers;
+    const dec = new Decimal(decimal);
+    const answer = dec.toScientificNotation().toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Pour écrire un nombre en notation scientifique, il faut qu'il soit sous la forme :
+
+$$
+a\\times 10^n
+$$
+
+où $a$ est un nombre compris entre $1$ et $10$ (exclus). Repère où placer la virgule pour que $a$ soit correct, puis compte combien de fois il faut déplacer la virgule.`;
+};
+const getCorrection = (identifiers) => {
+    const { decimal } = identifiers;
+    const isZero = decimal < 1;
+    const order = isZero ? "droite" : "gauche";
+    const dec = new Decimal(decimal);
+    const absExp = Math.abs(dec.tenthExponentBelow);
+    return `On déplace la virgule après le premier chiffre non nul :
+
+$$
+${decimal.frenchify()} = ${getAnswer(identifiers)}
+$$
+
+On a déplacé la virgule de $${absExp}$ ${pluralize("rang", absExp)} vers la ${order}, donc l'exposant est $${dec.tenthExponentBelow}$.`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: identifiers.decimal.frenchify(),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
 const getDecimalToScientificQuestion = () => {
     const isZero = probaFlip(0.2);
     let intPart, dec;
@@ -17,17 +68,8 @@ const getDecimalToScientificQuestion = () => {
         intPart = IntegerConstructor.random(randint(2, 5));
         dec = DecimalConstructor.fromParts(intPart.toString(), DecimalConstructor.randomFracPart(randint(1, 3)));
     }
-    const decTex = dec.toTree().toTex().replace(".", ",");
-    const answer = dec.toScientificNotation().toTex();
-    const question = {
-        instruction: `Donner l'écriture scientifique de : $${decTex}$`,
-        startStatement: decTex,
-        answer: answer,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { decimal: dec.value },
-    };
-    return question;
+    const identifiers = { decimal: dec.value };
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer, decimal }) => {
     const propositions = [];
@@ -55,4 +97,6 @@ export const decimalToScientific = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -8,4 +8,5 @@ export * from "./powersPower.js";
 export * from "./powersProduct.js";
 export * from "./scientificToDecimal.js";
 export * from "./powersMixOperations.js";
+export * from "./powersOfTenMixOperations.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC"}

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

@@ -8,3 +8,4 @@ export * from "./powersPower.js";
 export * from "./powersProduct.js";
 export * from "./scientificToDecimal.js";
 export * from "./powersMixOperations.js";
+export * from "./powersOfTenMixOperations.js";

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"powersDivision.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersDivision.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAK3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8FF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CA6BhD,CAAC;AACF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}
+{"version":3,"file":"powersDivision.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersDivision.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAK3B,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;AA6HF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC;AACF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB9D,CAAC"}