math-exercises 2.0.42 → 2.0.43

package/lib/exercises/functions/basics/twoFunctionsEquation.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.twoFunctionsEquation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const discreteSetKeys_1 = require("../../../exercises/utils/keys/discreteSetKeys");
+const colors_1 = require("../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const random_1 = require("../../../utils/random");
+const getTwoFunctionsEquationQuestion = () => {
+    const yValue = (0, randint_1.randint)(-5, 5);
+    let xSolutions = [];
+    const nb = (0, randint_1.randint)(2, 4);
+    for (let i = 0; i < nb; i++) {
+        xSolutions.push((0, randint_1.randint)(-9, 10, xSolutions));
+    }
+    xSolutions.sort((a, b) => a - b);
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(xSolutions.map((sol) => new numberNode_1.NumberNode(sol)))).toTex();
+    const fSplinePoints = [];
+    const gSplinePoints = [];
+    let prevYWasAbove = (0, coinFlip_1.coinFlip)();
+    fSplinePoints.push([
+        xSolutions[0] - (1 + Math.random() * 3),
+        yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    gSplinePoints.push([
+        xSolutions[0] - (1 + Math.random() * 3),
+        yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    prevYWasAbove = !prevYWasAbove;
+    for (let i = 0; i < xSolutions.length; i++) {
+        fSplinePoints.push([xSolutions[i], yValue]);
+        gSplinePoints.push([xSolutions[i], yValue]);
+        if (i < xSolutions.length - 1) {
+            const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+            const distance = xSolutions[i + 1] - xSolutions[i];
+            const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+            fSplinePoints.push([
+                x,
+                yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+            ]);
+            gSplinePoints.push([
+                x,
+                yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+            ]);
+            prevYWasAbove = !prevYWasAbove;
+        }
+    }
+    fSplinePoints.push([
+        xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+        yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    gSplinePoints.push([
+        xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+        yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    const xMin = Math.min(...[...fSplinePoints, ...gSplinePoints].map((point) => point[0]));
+    const yMin = Math.min(...[...fSplinePoints, ...gSplinePoints].map((point) => point[1]));
+    const xMax = Math.max(...[...fSplinePoints, ...gSplinePoints].map((point) => point[0]));
+    const yMax = Math.max(...[...fSplinePoints, ...gSplinePoints].map((point) => point[1]));
+    const fColor = (0, random_1.random)(colors_1.blues);
+    const gColor = (0, random_1.random)(colors_1.oranges);
+    const commands = [
+        `S = Spline(${fSplinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true)",
+        `SetColor(S, "${fColor}")`,
+        `SetCaption(S, "$f$")`,
+        `ShowLabel(S, true)`,
+        `T = Spline(${gSplinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(T, true)",
+        `SetColor(T, "${gColor}")`,
+        `SetCaption(T, "$g$")`,
+        `ShowLabel(T, true)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const question = {
+        answer,
+        instruction: `Déterminer graphiquement les solutions de l'équation $f(x) = g(x)$ où $f$ et $g$ sont les fonctions représentées ci-dessous.`,
+        keys: discreteSetKeys_1.discreteSetKeys,
+        answerFormat: "tex",
+        identifiers: { yValue, fSplinePoints, gSplinePoints },
+        commands: ggb.commands,
+        coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
+        options: ggb.getOptions(),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\varnothing`);
+    while (propositions.length < n) {
+        const nbs = [];
+        const nbSol = (0, randint_1.randint)(2, 4);
+        for (let i = 0; i < nbSol; i++) {
+            nbs.push((0, randint_1.randint)(-9, 10, nbs));
+        }
+        nbs.sort((a, b) => a - b);
+        const sol = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(nbs.map((nb) => new numberNode_1.NumberNode(nb))));
+        (0, exercise_1.tryToAddWrongProp)(propositions, sol.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, fSplinePoints, yValue }) => {
+    const xSolutions = fSplinePoints
+        .filter((p) => p[1] === yValue)
+        .map((p) => p[0]);
+    const answerTree = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(xSolutions.map((sol) => new numberNode_1.NumberNode(sol))));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.twoFunctionsEquation = {
+    id: "twoFunctionsEquation",
+    label: "Résoudre graphiquement une équation du type $f(x)=g(x)$",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTwoFunctionsEquationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/functions/basics/twoFunctionsInequation.d.ts

@@ -0,0 +1,17 @@
+import { MathExercise } from "../../../exercises/exercise";
+import { InegalitySymbols } from "../../../math/inequations/inequation";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
+type Identifiers = {
+    yValue: number;
+    fSplinePoints: number[][];
+    gSplinePoints: number[][];
+    ineqSymbol: InegalitySymbols;
+    intervals: {
+        a: number;
+        b: number;
+        closure: ClosureType;
+    }[];
+};
+export declare const twoFunctionsInequation: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=twoFunctionsInequation.d.ts.map

package/lib/exercises/functions/basics/twoFunctionsInequation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twoFunctionsInequation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/basics/twoFunctionsInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAQ5D,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE,EAAE,CAAC;CAC7D,CAAC;AA0MF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/functions/basics/twoFunctionsInequation.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.twoFunctionsInequation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const inequation_1 = require("../../../math/inequations/inequation");
+const randint_1 = require("../../../math/utils/random/randint");
+const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequationSolutionNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+const unionIntervalNode_1 = require("../../../tree/nodes/sets/unionIntervalNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const random_1 = require("../../../utils/random");
+const getTwoFunctionsInequationQuestion = () => {
+    const ineq = inequation_1.InequationSymbolConstructor.random();
+    const yValue = (0, randint_1.randint)(-5, 5);
+    let xSolutions = [];
+    const nb = (0, randint_1.randint)(2, 4);
+    for (let i = 0; i < nb; i++) {
+        xSolutions.push((0, randint_1.randint)(-9, 10, xSolutions));
+    }
+    xSolutions.sort((a, b) => a - b);
+    const fSplinePoints = [];
+    const gSplinePoints = [];
+    let prevYWasAbove = (0, coinFlip_1.coinFlip)();
+    const intervals = [];
+    const xStart = xSolutions[0] - (0, randint_1.randint)(1, 4);
+    fSplinePoints.push([
+        xStart,
+        yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    gSplinePoints.push([
+        xStart,
+        yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    if ((ineq.isSup && !prevYWasAbove) || (!ineq.isSup && prevYWasAbove))
+        intervals.push({
+            a: xStart,
+            b: xSolutions[0],
+            closure: ineq.isStrict ? closure_1.ClosureType.FO : closure_1.ClosureType.FF,
+        });
+    prevYWasAbove = !prevYWasAbove;
+    for (let i = 0; i < xSolutions.length; i++) {
+        fSplinePoints.push([xSolutions[i], yValue]);
+        gSplinePoints.push([xSolutions[i], yValue]);
+        if (i < xSolutions.length - 1) {
+            const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+            const distance = xSolutions[i + 1] - xSolutions[i];
+            const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+            if ((!prevYWasAbove && ineq.isSup) || (prevYWasAbove && !ineq.isSup)) {
+                intervals.push({
+                    a: xSolutions[i],
+                    b: xSolutions[i + 1],
+                    closure: ineq.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FF,
+                });
+            }
+            fSplinePoints.push([
+                x,
+                yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+            ]);
+            gSplinePoints.push([
+                x,
+                yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+            ]);
+            prevYWasAbove = !prevYWasAbove;
+        }
+    }
+    const xEnd = xSolutions[xSolutions.length - 1] + (0, randint_1.randint)(1, 4);
+    fSplinePoints.push([
+        xEnd,
+        yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    gSplinePoints.push([
+        xEnd,
+        yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    if ((ineq.isSup && !prevYWasAbove) || (!ineq.isSup && prevYWasAbove))
+        intervals.push({
+            a: xSolutions[xSolutions.length - 1],
+            b: xEnd,
+            closure: ineq.isStrict ? closure_1.ClosureType.OF : closure_1.ClosureType.FF,
+        });
+    const xMin = Math.min(...[...fSplinePoints, ...gSplinePoints].map((point) => point[0]));
+    const yMin = Math.min(...[...fSplinePoints, ...gSplinePoints].map((point) => point[1]));
+    const xMax = Math.max(...[...fSplinePoints, ...gSplinePoints].map((point) => point[0]));
+    const yMax = Math.max(...[...fSplinePoints, ...gSplinePoints].map((point) => point[1]));
+    const fColor = (0, random_1.random)(colors_1.blues);
+    const gColor = (0, random_1.random)(colors_1.oranges);
+    const commands = [
+        `S = Spline(${fSplinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true)",
+        `SetColor(S, "${fColor}")`,
+        `SetCaption(S, "$f$")`,
+        `ShowLabel(S, true)`,
+        `T = Spline(${gSplinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(T, true)",
+        `SetColor(T, "${gColor}")`,
+        `SetCaption(T, "$g$")`,
+        `ShowLabel(T, true)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const intervalsNodes = intervals.map((i) => new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(i.a), new numberNode_1.NumberNode(i.b), i.closure));
+    const answer = intervalsNodes.length === 1
+        ? `S=\\ ${intervalsNodes[0].toTex()}`
+        : `S=\\ ${new unionIntervalNode_1.UnionIntervalNode(intervalsNodes).toTex()}`;
+    const question = {
+        answer,
+        instruction: `Déterminer graphiquement les solutions de l'inéquation $f(x) ${ineq.symbol} g(x)$ où $f$ et $g$ sont les fonctions représentées ci-dessous.`,
+        keys: [
+            "S",
+            "equal",
+            "lbracket",
+            "semicolon",
+            "rbracket",
+            "cup",
+            "lbrace",
+            "rbrace",
+            "varnothing",
+        ],
+        answerFormat: "tex",
+        identifiers: {
+            yValue,
+            fSplinePoints,
+            gSplinePoints,
+            ineqSymbol: ineq.symbol,
+            intervals,
+        },
+        commands: ggb.commands,
+        coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
+        options: ggb.getOptions(),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, intervals, fSplinePoints, ineqSymbol }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\varnothing`);
+    while (propositions.length < n) {
+        const isStrict = ineqSymbol === "<" || ineqSymbol === ">";
+        const x1 = (0, randint_1.randint)(-10, -5);
+        const x2 = (0, randint_1.randint)(x1 + 1, x1 + 5);
+        const x3 = (0, randint_1.randint)(x2 + 3, x2 + 6);
+        const x4 = (0, randint_1.randint)(x3 + 1, x3 + 3);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new unionIntervalNode_1.UnionIntervalNode([
+            new intervalNode_1.IntervalNode(x1.toTree(), x2.toTree(), isStrict ? closure_1.ClosureType.FO : closure_1.ClosureType.FF),
+            new intervalNode_1.IntervalNode(x3.toTree(), x4.toTree(), isStrict ? closure_1.ClosureType.OF : closure_1.ClosureType.FF),
+        ]).toTex()}`);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, fSplinePoints, yValue, intervals }) => {
+    const intervalsNodes = intervals.map((n) => new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(n.a), new numberNode_1.NumberNode(n.b), n.closure));
+    const intervalsTree = intervalsNodes.length === 1
+        ? intervalsNodes[0]
+        : new unionIntervalNode_1.UnionIntervalNode(intervalsNodes);
+    const answerTree = new inequationSolutionNode_1.InequationSolutionNode(intervalsTree);
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.twoFunctionsInequation = {
+    id: "twoFunctionsInequation",
+    label: "Résoudre graphiquement une inéquation du type $f(x)<g(x)$",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTwoFunctionsInequationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

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

@@ -7,4 +7,5 @@ export * from "./trinoms";
 export * from "./exponential";
 export * from "./logarithm";
 export * from "./parity";
+export * from "./square";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/lib/exercises/functions/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./trinoms"), exports);
 __exportStar(require("./exponential"), exports);
 __exportStar(require("./logarithm"), exports);
 __exportStar(require("./parity"), exports);
+__exportStar(require("./square"), exports);

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

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

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./squareImageInterval"), exports);

package/lib/exercises/functions/square/squareImageInterval.d.ts

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

package/lib/exercises/functions/square/squareImageInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squareImageInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/square/squareImageInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAGrE,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;AAgIF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAYzD,CAAC"}

package/lib/exercises/functions/square/squareImageInterval.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareImageInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+// 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 getAnswer = (a, b, type, closure) => {
+    switch (type) {
+        case 1:
+            return new intervalNode_1.IntervalNode((a ** 2).toTree(), (b ** 2).toTree(), closure);
+        case 2:
+            return new intervalNode_1.IntervalNode((b ** 2).toTree(), (a ** 2).toTree(), closure_1.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 !== closure_1.ClosureType.OO
+                    ? "F"
+                    : "O"
+                : max === Math.abs(a)
+                    ? closure === closure_1.ClosureType.FF || closure === closure_1.ClosureType.FO
+                        ? "F"
+                        : "O"
+                    : closure === closure_1.ClosureType.FF || closure === closure_1.ClosureType.OF
+                        ? "F"
+                        : "O";
+            const ansClosure = maxClosure === "F" ? closure_1.ClosureType.FF : closure_1.ClosureType.FO;
+            return new intervalNode_1.IntervalNode((0).toTree(), (Math.max(Math.abs(a), Math.abs(b)) ** 2).toTree(), ansClosure);
+    }
+};
+const getSquareImageIntervalQuestion = () => {
+    let a;
+    let b;
+    let instruction = "";
+    let closure;
+    const type = (0, randint_1.randint)(1, 4);
+    switch (type) {
+        case 1:
+            a = (0, randint_1.randint)(0, 8);
+            b = (0, randint_1.randint)(a + 1, a + 5);
+            closure = closure_1.Closure.random();
+            instruction = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+        case 2:
+            b = (0, randint_1.randint)(-5, 0);
+            a = (0, randint_1.randint)(b - 5, b);
+            closure = closure_1.Closure.random();
+            instruction = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+        case 3:
+        default:
+            a = (0, randint_1.randint)(-9, 0);
+            b = (0, randint_1.randint)(1, 10);
+            closure = closure_1.Closure.random();
+            instruction = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+    }
+    const answer = getAnswer(a, b, type, closure).toTex();
+    const question = {
+        answer,
+        instruction: `Soit $${instruction}$. A quel intervalle appartient $x^2$ ?`,
+        keys: ["lbracket", "semicolon", "rbracket"],
+        answerFormat: "tex",
+        identifiers: { a, b, closure, type },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, type, closure }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.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;
+        (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(min.toTree(), max.toTree(), closure).toTex());
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer(a, b, type, closure_1.Closure.random()).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, closure, type }) => {
+    const interval = getAnswer(a, b, type, closure);
+    const texs = interval.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.squareImageInterval = {
+    id: "squareImageInterval",
+    label: "Passer une inégalité au carré",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions de référence", "Ensembles et intervalles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareImageIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/secondDegreeInequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAa3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAuHF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAuHF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/functions/trinoms/secondDegreeInequation.js

@@ -9,14 +9,15 @@ const randint_1 = require("../../../math/utils/random/randint");
 const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequationSolutionNode");
 const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
 const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
 const unionIntervalNode_1 = require("../../../tree/nodes/sets/unionIntervalNode");
 const getAnswer = ({ a, roots, ineqType }) => {
     const aPositive = a > 0;
-    const insideInterval = new intervalNode_1.IntervalNode(roots[0], roots[1], ineqType.isStrict ? intervalNode_1.ClosureType.OO : intervalNode_1.ClosureType.FF);
+    const insideInterval = new intervalNode_1.IntervalNode(roots[0], roots[1], ineqType.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FF);
     const outsideUnion = new unionIntervalNode_1.UnionIntervalNode([
-        new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, roots[0], ineqType.isStrict ? intervalNode_1.ClosureType.OO : intervalNode_1.ClosureType.OF),
-        new intervalNode_1.IntervalNode(roots[1], infiniteNode_1.PlusInfinityNode, ineqType.isStrict ? intervalNode_1.ClosureType.OO : intervalNode_1.ClosureType.FO),
+        new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, roots[0], ineqType.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.OF),
+        new intervalNode_1.IntervalNode(roots[1], infiniteNode_1.PlusInfinityNode, ineqType.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FO),
     ]);
     const tree = ineqType.isSup
         ? aPositive

package/lib/exercises/matrices/matrixInversibilityDomain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrixInversibilityDomain.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/matrixInversibilityDomain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAyBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0FF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAY/D,CAAC"}
+{"version":3,"file":"matrixInversibilityDomain.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/matrixInversibilityDomain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AA0BlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0FF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAY/D,CAAC"}

package/lib/exercises/matrices/matrixInversibilityDomain.js

@@ -11,6 +11,7 @@ const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const closure_1 = require("../../tree/nodes/sets/closure");
 const discreteSetNode_1 = require("../../tree/nodes/sets/discreteSetNode");
 const intervalNode_1 = require("../../tree/nodes/sets/intervalNode");
 const unionIntervalNode_1 = require("../../tree/nodes/sets/unionIntervalNode");
@@ -44,8 +45,8 @@ const getMatrixInversibilityDomainQuestion = () => {
         : isDZero
             ? "\\mathbb{R}"
             : new unionIntervalNode_1.UnionIntervalNode([
-                new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, x, intervalNode_1.ClosureType.OO),
-                new intervalNode_1.IntervalNode(x, infiniteNode_1.PlusInfinityNode, intervalNode_1.ClosureType.OO),
+                new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, x, closure_1.ClosureType.OO),
+                new intervalNode_1.IntervalNode(x, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.OO),
             ]).toTex();
     const question = {
         answer,

package/lib/exercises/sets/intervals/inequalityToInterval.d.ts

@@ -1,5 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
-import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
 type Identifiers = {
     isIntervalToInequality: boolean;
     intervalMin: number;

package/lib/exercises/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAKjE,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AA8KF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AA8KF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts

@@ -1,5 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
-import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
 type Identifiers = {
     int1Min: number;
     int1Max: number;

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAGjE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAwDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAwDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/sets/intervals/intervalsUnion.d.ts

@@ -1,5 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
-import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
 type Identifiers = {
     int1Min: number;
     int1Max: number;

package/lib/exercises/sets/intervals/intervalsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAGjE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6CF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6CF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}