math-exercises 3.0.94 → 3.0.96

package/lib/exercises/math/functions/square/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/functions/square/imageOfSquareFunction.d.ts

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

package/lib/exercises/math/functions/square/imageOfSquareFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageOfSquareFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/imageOfSquareFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAwJF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/functions/square/imageOfSquareFunction.js

@@ -0,0 +1,152 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt, SqrtNode } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeIds } from "../../../../tree/nodes/node.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../../tree/nodes/operators/divideNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a } = identifiers;
+    if (a.id === NodeIds.fraction) {
+        const frac = reifyAlgebraic(a);
+        // Erreurs potentielles pour les fractions:
+        // - l'élève ne fait le carré que sur le nominateur et dénominateur
+        // - l'élève multiplie par 2 à la place de faire un carré
+        tryToAddWrongProp(propositions, new FractionNode(frac.leftChild, square(frac.rightChild))
+            .simplify()
+            .toTex());
+        tryToAddWrongProp(propositions, new FractionNode(square(frac.leftChild), frac.rightChild)
+            .simplify()
+            .toTex());
+        tryToAddWrongProp(propositions, new FractionNode(frac.leftChild, multiply(frac.rightChild, 2))
+            .simplify()
+            .toTex());
+        tryToAddWrongProp(propositions, new FractionNode(multiply(frac.leftChild, 2), frac.rightChild)
+            .simplify()
+            .toTex());
+        tryToAddWrongProp(propositions, multiply(frac, 2).simplify().toTex());
+    }
+    else if (a.id === NodeIds.number) {
+        const N = reifyAlgebraic(a);
+        // Erreurs potentielles pour les nombres:
+        // - Division par 2
+        // - Multiplication par 2 (sauf pour le cas N = 2)
+        // - Carre de N+1
+        // - Carre de N-1
+        if (N.value != 2)
+            tryToAddWrongProp(propositions, multiply(N, 2).simplify().toTex());
+        tryToAddWrongProp(propositions, divide(N, 2).simplify().toTex());
+        tryToAddWrongProp(propositions, square(substract(N, 1)).simplify().toTex());
+        tryToAddWrongProp(propositions, square(add(N, 1)).simplify().toTex());
+    }
+    else {
+        // Cas racine carre
+        // Multiplication de 2 dans la racine
+        // Multiplication de 2 en dehors de la racine
+        // N^2 pour sqrt(N) (carre effectue deux fois)
+        const N = reifyAlgebraic(a);
+        tryToAddWrongProp(propositions, sqrt(multiply(N.child, 2)).simplify().toTex());
+        tryToAddWrongProp(propositions, multiply(N, 2).simplify().toTex());
+        tryToAddWrongProp(propositions, square(N.child).simplify().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
+    const correctAnswer = square(reifyAlgebraic(a));
+    return correctAnswer.simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a } = identifiers;
+    const nNode = reifyAlgebraic(a);
+    return `Calculer l'image de $${nNode.toTex()}$ par la fonction carré.`;
+};
+const getHint = (identifiers) => {
+    return `La fonction carré est la fonction définie par:
+  
+$$
+f(x) = x^2
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    return `L'image de $${aNode.toTex()}$ par $f(x) = x^2$ est : 
+  
+$$
+f\\left(${aNode.toTex()}\\right) = ${square(aNode).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const studentAnswer = parseAlgebraic(ans);
+        const correctAnswer = parseAlgebraic(answer);
+        return studentAnswer
+            .simplify({ decimalToFractions: true })
+            .equals(correctAnswer.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getImageOfSquareFunctionQuestion = (ops) => {
+    let a = null;
+    // Soit un nombre, soit une fraction, soit une racine carre
+    const choice = randint(1, 4);
+    switch (choice) {
+        case 1:
+            a = new NumberNode(randint(-10, 10));
+            break;
+        case 2:
+            a = RationalConstructor.randomIrreductible().toTree();
+            break;
+        case 3:
+        default:
+            a = new SqrtNode(new NumberNode(randint(2, 100)));
+            break;
+    }
+    const identifiers = { a: a.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 imageOfSquareFunction = {
+    id: "imageOfSquareFunction",
+    label: "Calcul d'image par la fonction carré",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getImageOfSquareFunctionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,3 +1,4 @@
 export * from "./squareImageInterval.js";
-export * from "./getImageOfSquareRootFunction.js";
+export * from "./imageOfSquareFunction.js";
+export * from "./compareSquaredValues.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}

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

@@ -1,2 +1,4 @@
 export * from "./squareImageInterval.js";
-export * from "./getImageOfSquareRootFunction.js";
+export * from "./imageOfSquareFunction.js";
+export * from "./compareSquaredValues.js";
+// export * from "./sqaureImageIntervalWithGraph.js";

package/lib/exercises/math/functions/square/squareImageIntervalWithGraph.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    closure: ClosureType;
+    type: number;
+};
+export declare const squareImageIntervalWithGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=squareImageIntervalWithGraph.d.ts.map

package/lib/exercises/math/functions/square/squareImageIntervalWithGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareImageIntervalWithGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/squareImageIntervalWithGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAW,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAMxE,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8LF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

package/lib/exercises/math/functions/square/squareImageIntervalWithGraph.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, 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 { randint } from "../../../../math/utils/random/randint.js";
+import { Closure, ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+// a < x < b avec a > 0  ==> a^2 < x^2 < b^2
+// a < x < b avec b < 0  ==> b^2 < x^2 < a^2
+// a < x < b avec a<0 et b>0 ==> 0 < x^2 < max(|a|,|b|)^2
+const getAnswerNode = (identifiers) => {
+    const { a, b, closure, type } = identifiers;
+    switch (type) {
+        case 1:
+            return new IntervalNode((a ** 2).toTree(), (b ** 2).toTree(), closure);
+        case 2:
+            return new IntervalNode((b ** 2).toTree(), (a ** 2).toTree(), Closure.switch(closure));
+        case 3:
+        default:
+            const max = Math.max(Math.abs(a), Math.abs(b));
+            const maxClosure = Math.abs(a) === Math.abs(b)
+                ? closure !== ClosureType.OO
+                    ? "F"
+                    : "O"
+                : max === Math.abs(a)
+                    ? closure === ClosureType.FF || closure === ClosureType.FO
+                        ? "F"
+                        : "O"
+                    : closure === ClosureType.FF || closure === ClosureType.OF
+                        ? "F"
+                        : "O";
+            const ansClosure = maxClosure === "F" ? ClosureType.FF : ClosureType.FO;
+            return new IntervalNode((0).toTree(), (Math.max(Math.abs(a), Math.abs(b)) ** 2).toTree(), ansClosure);
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { type, a, b, closure } = identifiers;
+    let instruction = "";
+    switch (type) {
+        case 1:
+            instruction = new IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+        case 2:
+            instruction = new IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+        case 3:
+        default:
+            instruction = new IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+    }
+    return `Soit $x$ un nombre réel tel que : 
+  
+$$
+${instruction}
+$$
+
+On rappelle ci-dessous la courbe représentative de la fonction carré $f(x) = x^2$.
+
+À l'aide de la courbe, déterminer à quel intervalle appartient $x^2$.`;
+};
+const getSquareImageIntervalQuestion = () => {
+    let a;
+    let b;
+    let instruction = "";
+    let closure;
+    const type = randint(1, 4);
+    switch (type) {
+        case 1:
+            a = randint(0, 5);
+            b = randint(a + 1, a + 5);
+            closure = Closure.random();
+            break;
+        case 2:
+            b = randint(-5, 0);
+            a = randint(b - 5, b);
+            closure = Closure.random();
+            break;
+        case 3:
+        default:
+            a = randint(-9, 0);
+            b = randint(1, 10);
+            closure = Closure.random();
+            break;
+    }
+    const identifiers = { a, b, closure, type };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, closure, type } = identifiers;
+    const interval = new IntervalNode(a.toTree(), b.toTree(), closure);
+    return ``;
+};
+const getGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: ["f(x) = x^2", `SetColor(f, "${randomColor()}")`],
+        lockedAxesRatio: false,
+    });
+    const { a, b } = identifiers;
+    return ggb.getOptions({
+        // coords: [
+        //   Math.min(a - 1, -1),
+        //   Math.max(b + 1, 1),
+        //   -1,
+        //   Math.max(a ** 2, b ** 2) + 1,
+        // ],
+        coords: [-11, 11, -5, 110],
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["lbracket", "semicolon", "rbracket"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, type, closure }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new IntervalNode(a.toTree(), b.toTree(), closure).toTex());
+    if (type === 3) {
+        const min = Math.min(Math.abs(a), Math.abs(b)) ** 2;
+        const max = Math.max(Math.abs(a), Math.abs(b)) ** 2;
+        tryToAddWrongProp(propositions, new IntervalNode(min.toTree(), max.toTree(), closure).toTex());
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, getAnswer({ a, b, type, closure: Closure.random() }));
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, closure, type }) => {
+    try {
+        const parsed = intervalParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const squareImageIntervalWithGraph = {
+    id: "squareImageIntervalWithGraph",
+    label: "Passer une inégalité au carré (avec graphique)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSquareImageIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts

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

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts.map

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

package/lib/exercises/math/functions/variations/varTableFromSentences.js

@@ -0,0 +1,137 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+//   GetAnswerTable,
+//   TableVEA,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+// import {
+//   NodeIdentifiers,
+//   reifyAlgebraic,
+// } from "../../../../tree/nodes/nodeConstructor.js";
+// import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+// import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {
+//   vars: string[];
+//   xs: NodeIdentifiers[];
+// };
+// /**
+//  *
+//  * xs
+//  * [-10, -4, 3, 10]
+//  * [f(-10), "\\nearrow", f(-4), "\\searrow", "f(3)", "\\nearrow", f(10)]
+//  */
+// const getAnswerTable: GetAnswerTable<Identifiers> = (identifiers) => {
+//   const { vars, xs } = identifiers;
+//   const xsNodes = xs.map((x) => reifyAlgebraic(x));
+//   const secondLine: string[][] = [[], [], []];
+//   for (let i = 0; i < vars.length; i++) {
+//     if (i % 2 === 0) {
+//       let row = 0;
+//       if (i === 0) {
+//         row = vars[1] === "\\nearrow" ? 2 : 0;
+//       } else {
+//         row = vars[i - 1] === "\\nearrow" ? 0 : 2;
+//       }
+//       secondLine[row].push(vars[i]);
+//       secondLine[2 - row].push("\\ ");
+//       secondLine[1].push("\\ ");
+//     } else {
+//       secondLine[1].push(vars[i]);
+//       secondLine[0].push("\\ ");
+//       secondLine[2].push("\\ ");
+//     }
+//   }
+//   return [
+//     ["$x$", ...xsNodes.join("\\ ")],
+//     ["$\\ $", ...secondLine[0]],
+//     ["$f(x)$", ...secondLine[1]],
+//     ["$\\ $", ...secondLine[2]],
+//   ];
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//     const { vars, xs } = identifiers;
+//   const xsNodes = xs.map((x) => reifyAlgebraic(x));
+//   return `La fonction $f$ est définie sur ...
+// Elle est croissante sur ...
+// Elle est décroissante sur ...
+// De plus, on a $f()=...$`;
+// };
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return `La première ligne d'un tableau de variations contient les valeurs de $x$. La deuxième ligne donne les variations de la fonction en fonction des valeurs de $x$ de la premiere ligne.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return [];
+// };
+// const isAnswerTableValid: TableVEA<Identifiers> = (ans, { answerTable }) => {
+//   try {
+//     return ans.every((row, i) =>
+//       row.every((cell, j) => cell === answerTable[i][j]),
+//     );
+//   } catch (err) {
+//     return handleVEAError(err);
+//   }
+// };
+// const getVarTableFromSentencesQuestion: QuestionGenerator<Identifiers> = (
+//   ops,
+// ) => {
+//   const x = randTupleInt(4, {allDifferent: true, from: -10, to: 11})
+//   const xs = x.sort((a,b)=>a-b);
+//   const sens = coinFlip()
+//   const vars = [];
+//   const identifiers: Identifiers = {
+//     xs: xs.map((e)=>e.toTree().toIdentifiers()),
+//     vars,
+//   };
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   return {
+//     answerTable: getAnswerTable(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//   };
+// };
+// export const varTableFromSentences: Exercise<Identifiers> = {
+//   id: "varTableFromSentences",
+//   label:
+//     "Dresser le tableau de variations d'une fonction à partir de phrases descriptives",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(() => getVarTableFromSentencesQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   isAnswerTableValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswerTable,
+//   getQuestionFromIdentifiers,
+//   hasHintAndCorrection: true,
+//   answerType: "varTable",
+// };

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

@@ -9,4 +9,5 @@ export * from "./powersProduct.js";
 export * from "./scientificToDecimal.js";
 export * from "./powersMixOperations.js";
 export * from "./powersOfTenMixOperations.js";
+export * from "./powerNotation.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;AACzC,cAAc,+BAA+B,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;AAC9C,cAAc,oBAAoB,CAAC"}