math-exercises 3.0.76 → 3.0.77

package/lib/exercises/math/calcul/arithmetics/compareInverseValues.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    isMinusInside: boolean;
+};
+export declare const compareInverseValues: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareInverseValues.d.ts.map

package/lib/exercises/math/calcul/arithmetics/compareInverseValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareInverseValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/compareInverseValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAuIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/compareInverseValues.js

@@ -0,0 +1,136 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    const symbols = ["<", "=", ">"];
+    addValidProp(propositions, answer);
+    const remaining = symbols.filter((s) => s !== answer);
+    for (const sym of remaining) {
+        tryToAddWrongProp(propositions, sym);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ a, b }) => {
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    const aVal = aNode.simplify().evaluate();
+    const bVal = bNode.simplify().evaluate();
+    return aVal === bVal ? "=" : aVal < bVal ? ">" : "<";
+};
+const getInstruction = ({ a, b, isMinusInside, }) => {
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    return `Compléter par le bon symbole : 
+  
+$$
+${frac(1, aNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })}\\ \\ldots \\ ${frac(1, bNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })}
+$$`;
+};
+const getHint = ({ a, b }) => {
+    return `Si $a$ et $b$ sont deux nombres non nuls et de même signe, alors la fonction inverse ne conserve pas l'ordre : 
+  
+- $\\frac{1}{a} < \\frac{1}{b}$ si et seulement si $a>b$ ; 
+- $\\frac{1}{a} > \\frac{1}{b}$ si et seulement si $a<b$ ; 
+- $\\frac{1}{a} = \\frac{1}{b}$ si et seulement si $a=b$ ; `;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isMinusInside } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    const aVal = aNode.simplify().evaluate();
+    const bVal = bNode.simplify().evaluate();
+    const signe = aVal < bVal ? "<" : aVal > bVal ? ">" : "=";
+    const answer = getAnswer(identifiers);
+    // return aVal === bVal ? "=" : aVal < bVal ? ">" : "<";
+    return `Puisque $${aNode.toTex()} ${signe} ${bNode.toTex()}$, et puisque ce sont deux nombres de même signe, leurs inverses sont dans l'ordre contraire : 
+
+$$
+${frac(1, aNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })} ${answer} ${frac(1, bNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })}
+$$
+`;
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+function randBetween(isInteger, min, max, roundTo, excludes) {
+    if (isInteger) {
+        return randint(min, max, excludes);
+    }
+    else {
+        return randfloat(min, max, roundTo, excludes);
+    }
+}
+const getCompareInverseValuesQuestion = () => {
+    const min = 2;
+    const max = 50;
+    const roundTo = 2;
+    const isInteger = coinFlip();
+    let x;
+    let y;
+    if (coinFlip()) {
+        // tous deux positifs
+        x = randBetween(isInteger, min, max, roundTo);
+        y = randBetween(isInteger, min, max, roundTo, [x]);
+    }
+    else {
+        // tous deux négatifs
+        x = -randBetween(isInteger, min, max, roundTo);
+        y = -randBetween(isInteger, min, max, roundTo, [Math.abs(x)]);
+    }
+    const isMinusOutside = coinFlip();
+    const identifiers = {
+        a: x.toTree().toIdentifiers(),
+        b: y.toTree().toIdentifiers(),
+        isMinusInside: coinFlip(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareInverseValues = {
+    id: "compareInverseValues",
+    label: "Comparer des inverses",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareInverseValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calcul/arithmetics/compareSquaredValues.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+};
+export declare const compareSquaredValues: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareSquaredValues.d.ts.map

package/lib/exercises/math/calcul/arithmetics/compareSquaredValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareSquaredValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/compareSquaredValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/compareSquaredValues.js

@@ -0,0 +1,143 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    const symbols = ["<", "=", ">"];
+    addValidProp(propositions, answer);
+    let remaining = symbols.filter((s) => s !== answer);
+    while (remaining.length > 0) {
+        tryToAddWrongProp(propositions, remaining[remaining.length - 1]);
+        remaining.pop();
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const aNode = square(reifyAlgebraic(a));
+    const bNode = square(reifyAlgebraic(b));
+    const aValue = aNode.simplify({ calculatePowers: true }).evaluate();
+    const bValue = bNode.simplify({ calculatePowers: true }).evaluate();
+    const res = aValue === bValue ? "=" : aValue < bValue ? "<" : ">";
+    return res;
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    const aNode = square(reifyAlgebraic(a));
+    const bNode = square(reifyAlgebraic(b));
+    return `Compléter par le bon symbole : 
+  
+$$
+${aNode.toTex()} \\ \\ldots \\ ${bNode.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    return `Pour tous nombres $a$ et $b$ tels que $a<b$ : 
+
+- Si $a$ et $b$ sont positifs, alors $a^2 <b^2$ ;
+- Si $a$ et $b$ sont négatifs, alors $a^2 > b^2$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    const simplifiedA = aNode.simplify({
+        calculatePowers: true,
+    });
+    const simplifiedB = bNode.simplify({ calculatePowers: true });
+    const valueA = simplifiedA.evaluate();
+    const valueB = simplifiedB.evaluate();
+    const sign = valueA < 0 ? "négatif" : "positif";
+    const symbol = valueA < valueB ? "<" : valueA > valueB ? ">" : "=";
+    const answer = getAnswer(identifiers);
+    return `Puisque $${aNode.toTex()}$ et $${bNode.toTex()}$ sont ${sign}s, et puisque $${aNode.toTex()} ${symbol} ${bNode.toTex()}$, on a : 
+  
+$$
+${square(aNode).toTex()} ${answer} ${square(bNode).toTex()}
+$$
+
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const randCase = () => Math.floor(Math.random() * 2);
+function randBetween(isInteger, min, max, roundTo, excludes) {
+    if (isInteger) {
+        return randint(min, max, excludes);
+    }
+    else {
+        return randfloat(min, max, roundTo, excludes);
+    }
+}
+const getCompareSquaredValuesQuestion = (ops) => {
+    const min = 0;
+    const max = 50;
+    const roundTo = 2;
+    const caseType = randCase();
+    const isInteger = coinFlip();
+    let a;
+    let b;
+    switch (caseType) {
+        case 0:
+            // tous deux positifs
+            a = randBetween(isInteger, min, max, roundTo);
+            b = randBetween(isInteger, min, max, roundTo, [a]);
+            break;
+        case 1:
+            // tous deux négatifs
+            a = -randBetween(isInteger, min, max, roundTo);
+            b = -randBetween(isInteger, min, max, roundTo, [-a]);
+            break;
+    }
+    const identifiers = {
+        a: a.toTree().toIdentifiers(),
+        b: b.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareSquaredValues = {
+    id: "compareSquaredValues",
+    label: "Comparer des nombres élevés au carré",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareSquaredValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calcul/arithmetics/index.d.ts

@@ -17,5 +17,7 @@ export * from "./isPointOnReciprocalFunction.js";
 export * from "./isPointOnFunction.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
+export * from "./compareInverseValues.js";
 export * from "./calculateDistanceBetweenNumbers.js";
+export * from "./compareSquaredValues.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/arithmetics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/calcul/arithmetics/index.js

@@ -17,4 +17,6 @@ export * from "./isPointOnReciprocalFunction.js";
 export * from "./isPointOnFunction.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
+export * from "./compareInverseValues.js";
 export * from "./calculateDistanceBetweenNumbers.js";
+export * from "./compareSquaredValues.js";

package/lib/exercises/math/functions/cube/compareCubeValues.d.ts

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

package/lib/exercises/math/functions/cube/compareCubeValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareCubeValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/compareCubeValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}

package/lib/exercises/math/functions/cube/compareCubeValues.js

@@ -0,0 +1,113 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `>`);
+    tryToAddWrongProp(propositions, `<`);
+    tryToAddWrongProp(propositions, `=`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    if (a > b) {
+        return `>`;
+    }
+    else if (a < b) {
+        return `<`;
+    }
+    else {
+        return `=`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Compléter par le bon symbole : 
+  
+$$
+${power(a, 3).toTex()}\\ \\ldots \\ ${power(b, 3).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `La fonction cube conserve l'ordre : pour tous $a$ et $b$ réels,
+  
+- $a^3 > b^3$ si et seulement si $a > b$ ;
+
+- $a^3 < b^3$ si et seulement si $a < b$ ;
+
+- $a^3 = b^3$ si et seulement si $a = b$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const signe = a < b ? "<" : a > b ? ">" : "=";
+    return `La fonction cube conserve l'ordre. 
+  
+Puisque $${a.frenchify()} ${signe} ${b.frenchify()}$, alors $${power(a, 3).toTex()} ${getAnswer(identifiers)} ${power(b, 3).toTex()}$.`;
+};
+const getCompareCubeValuesQuestion = (ops) => {
+    const randomNumberOrDecimal = (min, max, excl) => {
+        const isDecimal = coinFlip();
+        return isDecimal ? randfloat(min, max, 2, excl) : randint(min, max, excl);
+    };
+    let a = null;
+    let b = null;
+    const bound = 10;
+    switch (randint(0, 3)) {
+        case 0:
+            a = randomNumberOrDecimal(0, bound);
+            b = randomNumberOrDecimal(0, bound, [a]);
+            break;
+        case 1:
+            a = randomNumberOrDecimal(-bound, 0);
+            b = randomNumberOrDecimal(-bound, 0, [a]);
+            break;
+        case 2:
+        default:
+            if (coinFlip()) {
+                a = randomNumberOrDecimal(-bound, 0);
+                b = randomNumberOrDecimal(0, bound);
+            }
+            else {
+                a = randomNumberOrDecimal(0, bound);
+                b = randomNumberOrDecimal(-bound, 0);
+            }
+            break;
+    }
+    const identifiers = {
+        a,
+        b,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareCubeValues = {
+    id: "compareCubeValues",
+    label: "Comparer des nombres élevés au cube",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareCubeValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/cube/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./cubicEquation.js";
 export * from "./imageOfCubeFunction.js";
+export * from "./compareCubeValues.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/cube/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/functions/cube/index.js

@@ -1,2 +1,3 @@
 export * from "./cubicEquation.js";
 export * from "./imageOfCubeFunction.js";
+export * from "./compareCubeValues.js";

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

@@ -12,4 +12,5 @@ export * from "./integral/index.js";
 export * from "./exponentials/index.js";
 export * from "./sign/index.js";
 export * from "./variations/index.js";
+export * from "./sqrt/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}

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

@@ -12,3 +12,4 @@ export * from "./integral/index.js";
 export * from "./exponentials/index.js";
 export * from "./sign/index.js";
 export * from "./variations/index.js";
+export * from "./sqrt/index.js";

package/lib/exercises/math/functions/sqrt/compareSqrtValues.d.ts

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

package/lib/exercises/math/functions/sqrt/compareSqrtValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareSqrtValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sqrt/compareSqrtValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2EF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}

package/lib/exercises/math/functions/sqrt/compareSqrtValues.js

@@ -0,0 +1,83 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `>`);
+    tryToAddWrongProp(propositions, `<`);
+    tryToAddWrongProp(propositions, `=`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const signe = a > b ? ">" : a < b ? "<" : "=";
+    return `${signe}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Compléter par le bon symbole : 
+  
+$$
+${sqrt(a).toTex()} \\ \\ldots \\ ${sqrt(b).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `La racine carré conserve l'ordre : pour tous $a$ et $b$ positifs,
+  
+- $a > b \\iff ${sqrt("a").toTex()} > ${sqrt("b").toTex()}$
+- $a < b \\iff ${sqrt("a").toTex()} < ${sqrt("b").toTex()}$
+- $a = b \\iff ${sqrt("a").toTex()} = ${sqrt("b").toTex()}$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const signe = a > b ? ">" : a < b ? "<" : "=";
+    return `La racine carrée conserve l'ordre. 
+  
+Puisque $${a.frenchify()} ${signe} ${b.frenchify()}$, alors $${sqrt(a).toTex()} ${signe} ${sqrt(b).toTex()}$.`;
+};
+const getCompareSqrtValuesQuestion = (ops) => {
+    const randomNumberOrDecimal = (min, max, excl) => {
+        const isDecimal = coinFlip();
+        return isDecimal ? randfloat(min, max, 2, excl) : randint(min, max, excl);
+    };
+    const bound = 10;
+    const a = randomNumberOrDecimal(0, bound);
+    const b = randomNumberOrDecimal(0, bound, [a]);
+    const identifiers = {
+        a,
+        b,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareSqrtValues = {
+    id: "compareSqrtValues",
+    label: "Comparer des racines carrés",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareSqrtValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/sqrt/index.d.ts

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

package/lib/exercises/math/functions/sqrt/index.d.ts.map

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

package/lib/exercises/math/functions/sqrt/index.js

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

package/lib/exercises/math/geometry/cartesian/placeAbscissOnLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"placeAbscissOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAa1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAgBpD,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnLine.js

@@ -9,8 +9,10 @@ import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
 const getInstruction = ({ abscissTex }) => {
     return `Placer le point d'abscisse $${abscissTex}$ sur la droite graduée ci-dessous :`;
 };
@@ -108,6 +110,28 @@ const getPlaceAbscissOnLineQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { absciss, axisUnit, oneUnitTex, abscissType, abscissTex, coeff } = identifiers;
+    return `Il faut compter le nombre de graduations entre les points $O$ et $A$. Puis on utilise le fait qu'une graduation vaut $${oneUnitTex}$. 
+  
+D'autre part, si $A$ est placé à gauche de $O$, alors son abscisse est négative.`;
+};
+const getCorrection = (identifiers) => {
+    const { absciss, axisUnit, oneUnitTex, abscissType, abscissTex, coeff } = identifiers;
+    const absCoeff = Math.abs(coeff);
+    const oneUnitNode = parseAlgebraic(oneUnitTex);
+    return `Il y a $${absCoeff}$ ${pluralize("graduation", absCoeff)} entre $O$ et $A$. Puisqu'une graduation vaut $${oneUnitTex}$, cela représente un écart de  :
+  
+$$
+${multiply(absCoeff, oneUnitNode).toTex({
+        forceNoSimplification: true,
+    })} = ${multiply(absCoeff, oneUnitNode).simplify().toTex()}
+$$ 
+  
+${coeff < 0
+        ? `Puisque $A$ est placé à gauche du point $O$, son abscisse est négative. L'abscisse du point $A$ est donc $${abscissTex}$.`
+        : `L'abscisse du point $A$ est donc $${abscissTex}$.`}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
@@ -133,4 +157,5 @@ export const placeAbscissOnLine = {
     getStudentGGBOptions,
     answerType: "GGB",
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AAqPF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAuBnD,CAAC"}
+{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA4RF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAuBnD,CAAC"}