math-exercises 3.0.173 → 3.0.175

package/lib/exercises/math/trigonometry/functions/readPeriodicityOnFunctionGraph.js

@@ -0,0 +1,159 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueDark, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const b = randint(1, 10);
+        tryToAddWrongProp(propositions, frac(multiply(2, PiNode), b).simplify().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { bIds } = identifiers;
+    return frac(multiply(2, PiNode), reifyAlgebraic(bIds)).simplify().toTex();
+};
+const getInstruction = () => {
+    return `On représente ci-dessous la courbe d'une fonction périodique $f$. 
+   
+Quelle est la période de $f$ ?`;
+};
+const getHint = () => {
+    return `Repère un motif de la courbe qui se repète à l'infini. La longueur en abscisse de ce motif est la période recherchée.`;
+};
+const buildFunction = (identifiers) => {
+    const { isCos, bIds, aIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    return multiply(a, (isCos ? cos : sin)(add(multiply(b, "x"), c)));
+};
+const getCorrection = (identifiers) => {
+    const { bIds } = identifiers;
+    const period = frac(multiply(2, PiNode), reifyAlgebraic(bIds))
+        .simplify()
+        .toTex();
+    return `On repère sur la courbe un motif de longueur $${period}$ qui se répète à l'infini. 
+  
+$f$ est donc une fonction périodique de période $${period}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const func = buildFunction(identifiers);
+    const commands = [`f(x) = ${func.toMathString()}`];
+    const a = reifyAlgebraic(aIds).evaluate();
+    const b = reifyAlgebraic(bIds).evaluate();
+    const step = b === 6 ? Math.PI / 3 : b === 4 ? Math.PI / 2 : Math.PI;
+    const period = frac(multiply(2, PiNode), reifyAlgebraic(bIds))
+        .simplify()
+        .evaluate();
+    for (let i = -2; i < 3; i++) {
+        commands.push(`f_{${i}}(x) = Function(f, ${i}*${period}, ${i + 1}*${period})`);
+        commands.push(`SetColor(f_{${i}}, "${i % 2 === 0 ? red : blueDark}")`);
+    }
+    const ggb = new GeogebraConstructor({
+        commands,
+        xAxis: {
+            steps: step,
+        },
+        gridDistance: [step, 1],
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: [-2 * period, 2 * period, -a - 0.1 * a, a + 0.1 * a],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds).evaluate();
+    const b = reifyAlgebraic(bIds).evaluate();
+    const func = buildFunction(identifiers);
+    const period = frac(multiply(2, PiNode), reifyAlgebraic(bIds)).evaluate();
+    const step = b === 6 ? Math.PI / 3 : b === 4 ? Math.PI / 2 : Math.PI;
+    const ggb = new GeogebraConstructor({
+        commands: [`f(x) = ${func.toMathString()}`],
+        xAxis: {
+            steps: step,
+        },
+        gridDistance: [step, 1],
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: [-2 * period, 2 * period, -a - 0.1 * a, a + 0.1 * a],
+    });
+};
+const getKeys = () => {
+    return ["pi"];
+};
+const isAnswerValid = (ans, { bIds }) => {
+    try {
+        const period = frac(multiply(2, PiNode), reifyAlgebraic(bIds)).evaluate();
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return Math.abs(parsed.evaluate() - period) < 0.1;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadPeriodicityOnFunctionGraphQuestion = () => {
+    const isCos = coinFlip();
+    const aIds = randfloat(0.5, 5, 1).toTree().toIdentifiers();
+    const bIds = random([1, 2, 4, 6]).toTree().toIdentifiers();
+    const cIds = randint(-8, 8).toTree().toIdentifiers();
+    const identifiers = {
+        aIds,
+        bIds,
+        cIds,
+        isCos,
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+export const readPeriodicityOnFunctionGraph = {
+    id: "readPeriodicityOnFunctionGraph",
+    label: "Déterminer graphiquement la périodicité d'une fonction trigonométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadPeriodicityOnFunctionGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/trigonometry/functions/sinInequationMainInterval.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { InegalitySymbols } from "../../../../math/inequations/inequation.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    sinIds: NodeIdentifiers;
+    ineqType: InegalitySymbols;
+};
+export declare const sinInequationMainInterval: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sinInequationMainInterval.d.ts.map

package/lib/exercises/math/trigonometry/functions/sinInequationMainInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sinInequationMainInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/sinInequationMainInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAI9C,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAkPF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAuB3D,CAAC"}

package/lib/exercises/math/trigonometry/functions/sinInequationMainInterval.js

@@ -0,0 +1,224 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { InequationSymbolConstructor, } from "../../../../math/inequations/inequation.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { UnionIntervalNode } from "../../../../tree/nodes/sets/unionIntervalNode.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ineqType, sinIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswer({
+        ineqType: InequationSymbolConstructor.reverse(ineqType),
+        sinIds: sinIds,
+    }));
+    propWhile(propositions, n, () => {
+        const value = random(mainTrigoValues.filter((v) => Math.abs(v.sin.evaluate()) !== 1));
+        tryToAddWrongProp(propositions, getAnswer({
+            ineqType: ineqType,
+            sinIds: value.sin.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { sinIds, ineqType } = identifiers;
+    const sinValue = reifyAlgebraic(sinIds);
+    //trouve la premiere value dans ]-pi; 0]
+    const values = mainTrigoValues
+        .filter((v) => Math.abs(v.sin.evaluate() - sinValue.evaluate()) < 0.0001)
+        .map((e) => e.angle);
+    const isPos = sinValue.evaluate() > 0;
+    const isNeg = sinValue.evaluate() < 0;
+    switch (ineqType) {
+        //sin(x)<1/2 -> ]-pi; pi/6]U[5PI/6; pi]
+        //sin(x)<-1/2 -> ]-5PI/6, -pi/6[
+        //sin(x)<0 : ]-pi; 0[
+        case "<":
+        case "\\le":
+            if (isPos)
+                return new UnionIntervalNode([
+                    new IntervalNode(opposite(PiNode), values[0], ineqType === "<" ? ClosureType.OO : ClosureType.FF),
+                    new IntervalNode(values[1], PiNode, ineqType === "<" ? ClosureType.OF : ClosureType.FF),
+                ]).toTex();
+            else
+                return new IntervalNode(values[0], values[1], ineqType === "<" ? ClosureType.OO : ClosureType.FF).toTex();
+        //sin(x)>1/2 -> [pi/6, 5PI/6]
+        //sin(x) > -1/2 -> ]-pi; -5PI/6]U[5PI/6; pi]
+        //sin(x)>0 : [0;Pi]
+        case ">":
+        case "\\ge":
+            if (isNeg)
+                return new UnionIntervalNode([
+                    new IntervalNode(opposite(PiNode), values[0], ineqType === ">" ? ClosureType.OO : ClosureType.FF),
+                    new IntervalNode(values[1], PiNode, ineqType === ">" ? ClosureType.OF : ClosureType.FF),
+                ]).toTex();
+            return new IntervalNode(values[0], values[1], ineqType === ">" ? ClosureType.OO : ClosureType.FF).toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { sinIds, ineqType } = identifiers;
+    const sinValue = reifyAlgebraic(sinIds);
+    return `Résoudre dans $]-\\pi; \\pi]$ l'inéquation suivante : 
+  
+$$
+\\sin(x)${ineqType}${sinValue.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { sinIds } = identifiers;
+    const sinValue = reifyAlgebraic(sinIds);
+    return `Commence par résoudre sur $]-\\pi; \\pi]$ l'équation :
+  
+$$
+\\sin(x)=${sinValue.toTex()}
+$$
+
+Puis, sers-toi du cercle trigonométrique pour en déduire l'ensemble des solutions de l'inéquation proposée.`;
+};
+const getCorrection = (identifiers) => {
+    const { sinIds, ineqType } = identifiers;
+    const sinValue = reifyAlgebraic(sinIds);
+    //trouve la premiere value dans ]-pi; 0]
+    const values = mainTrigoValues
+        .filter((v) => Math.abs(v.sin.evaluate() - sinValue.evaluate()) < 0.0001)
+        .map((e) => e.angle);
+    return `On commence par résoudre sur $]-\\pi; \\pi]$ l'équation :
+  
+$$
+\\sin(x)=${sinValue.toTex()}
+$$
+
+Les solutions sont $${values[0].toTex()}$ et $${values[1].toTex()}$.
+
+Puis on se sers du cercle trigonométrique ci-dessous, pour en déduire que l'ensemble des solutions de l'inéquation $\\sin(x)${ineqType}${sinValue.toTex()}$ est :
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { sinIds, ineqType } = identifiers;
+    const sinValue = reifyAlgebraic(sinIds);
+    const values = mainTrigoValues
+        .filter((v) => Math.abs(v.sin.evaluate() - sinValue.evaluate()) < 0.0001)
+        .map((e) => e.angle);
+    const commands = [
+        `C : x^2 + y^2 = 1`,
+        `O = (0,0)`,
+        `ShowLabel(O, false)`,
+        `SetVisibleInView(O, 1, false)`,
+        `ShowLabel(C, false)`,
+        `SetFixed(C, true ,false)`,
+        `d : y = ${sinValue.evaluate()}`,
+        `SetLineThickness(d, 1.7)`,
+        `SetLineStyle(d, 1)`,
+        `A = (cos(${values[0].evaluate()}), sin(${values[0].evaluate()}))`,
+        `ShowLabel(A, false)`,
+        `Text("$\\tiny ${values[0].toTex()}$", A+0.3*Vector(O,A), false, true, 0, 0)`,
+        `B = (cos(${values[1].evaluate()}), sin(${values[1].evaluate()}))`,
+        `Text("$\\tiny ${values[1].toTex()}$", B+0.3*Vector(O,B), false, true, 0, 0)`,
+        `ShowLabel(B, false)`,
+        `D = (0, ${sinValue.evaluate()})`,
+        `SetCaption(D, "$\\tiny ${sinValue.toTex()}$")`,
+        `Text("$\\tiny ${sinValue.toTex()}$", D, false, true, 0, 0)`,
+        `SetPointSize(D, 1.3)`,
+        `ShowLabel(D, false)`,
+        `E = (-1,0)`,
+        `I = (1,0)`,
+        `SetVisibleInView(E, 1, false)`,
+        `SetVisibleInView(I, 1, false)`,
+        `v = Vector(E, I)`,
+        `w = Vector((0, -1), (0, 1))`,
+        `SetLineThickness(v, 1.3)`,
+        `SetLineThickness(w, 1.3)`,
+        `N = (0, -1)`,
+        `SetVisibleInView(N, 1, false)`,
+        `M = (0, 1)`,
+        `SetVisibleInView(M, 1, false)`,
+    ];
+    const ineq = new InequationNode([(-1).toTree(), sinValue], ineqType);
+    if (ineq.isVerified()) {
+        commands.push(`S = CircumcircularArc(A,N,B)`);
+    }
+    else {
+        commands.push(`S = CircumcircularArc(A,M,B)`);
+    }
+    commands.push(`SetFixed(S, true, false)`);
+    commands.push(`SetColor(S, "${red}")`);
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: sinValue.evaluate() === 0
+            ? [-1.1, 1.1, -1.5, 1.5]
+            : [-1.1, 1.1, -1.3, 1.3],
+    });
+};
+const getKeys = () => {
+    return ["pi", "cup", "lbracket", "semicolon", "rbracket"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = unionIntervalParser(ans, {
+            allowCommaInsteadOfSemicolon: true,
+            allowNoBrackets: true,
+        });
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCosInequationMainIntervalQuestion = () => {
+    const value = random(mainTrigoValues.filter((v) => Math.abs(v.sin.evaluate()) !== 1));
+    const identifiers = {
+        sinIds: value.sin.toIdentifiers(),
+        ineqType: random(["<", ">", "\\le", "\\ge"]),
+    };
+    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),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+export const sinInequationMainInterval = {
+    id: "sinInequationMainInterval",
+    label: "Résoudre une inéquation du type $\\sin(x)\\leq k$ sur $]-\\pi; \\pi]$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCosInequationMainIntervalQuestion(opts), nb, 20),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 20,
+};

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

@@ -134,7 +134,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const trigoFundamentalEquation = {
     id: "trigoFundamentalEquation",
     connector: "=",
-    label: "Calculer le cosinus d'un angle à partir de son sinus (ou inversement)",
+    label: "Calculer le cosinus d'un angle à partir de son sinus (ou inversement) dans un triangle",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getTrigoFundamentalEquationQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/vea/treeTableVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const treeTableVEA: (ans: string[][][][], answerTable: string[][][][]) => boolean;
+//# sourceMappingURL=treeTableVEA.d.ts.map

package/lib/exercises/vea/treeTableVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAa5B,CAAC"}

package/lib/exercises/vea/treeTableVEA.js

@@ -0,0 +1,7 @@
+import { rationalVEA } from "./rationalVEA.js";
+// type Options = {
+// }
+export const treeTableVEA = (ans, answerTable) => {
+    return ans.every((step, i) => step.every((block, j) => block.every((branch, k) => branch.every((value, l) => value === answerTable[i][j][k][l] ||
+        rationalVEA(value, answerTable[i][j][k][l])))));
+};

package/lib/exercises/vea/varLineVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAmClE,CAAC"}
+{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAoClE,CAAC"}

package/lib/exercises/vea/varLineVEA.js

@@ -29,19 +29,22 @@ export const varLineVEA = (ans, answerTable) => {
         return false;
     for (let i = 0; i < flattenedAns.length; i++) {
         const value = flattenedAns[i];
-        if (value === "\\nearrow") {
-            if (flattenedAnswerTable[i] !== "\\nearrow")
+        if (flattenedAnswerTable[i] === "\\nearrow") {
+            if (value !== "\\nearrow")
                 return false;
             continue;
         }
-        else if (value === "\\searrow") {
-            if (flattenedAnswerTable[i] !== "\\searrow")
+        else if (flattenedAnswerTable[i] === "\\searrow") {
+            if (value !== "\\searrow")
                 return false;
             continue;
         }
         else {
-            return ((!isValue(value) && !isValue(flattenedAnswerTable[i])) ||
-                rationalVEA(value, flattenedAnswerTable[i]));
+            const isValid = (!isValue(value) && !isValue(flattenedAnswerTable[i])) ||
+                rationalVEA(value, flattenedAnswerTable[i]);
+            if (!isValid)
+                return false;
+            continue;
         }
     }
     return true;

package/lib/index.d.ts

@@ -3342,7 +3342,9 @@ declare const mathExercises: (Exercise<{
     reason: number;
     firstValue: number;
     firstRank: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    firstTermRankOne: boolean;
+}> | Exercise<{
     firstRank: number;
     firstTerm: number;
     reason: number;
@@ -3608,6 +3610,10 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     associateType: number;
     startPoint: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isCos: boolean;
+    valueIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    quadrant: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     trigFunction: string;
     trigValue: number;
@@ -3628,6 +3634,18 @@ declare const mathExercises: (Exercise<{
     isCos: boolean;
     value: number;
     associateType: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    cosIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    sinIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    axisStep?: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isCos: boolean;
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     degree: number;
     radianNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/tree/nodes/inequations/inequationNode.d.ts

@@ -35,6 +35,7 @@ export declare class InequationNode implements AlgebraicNode {
     equals(): boolean;
     evaluate(): number;
     toDetailedEvaluation(): AlgebraicNode;
+    isVerified(): boolean;
 }
 export declare const firstDegreeInequationResolutionTex: (affine: Affine, order: InegalitySymbols, right: AlgebraicNode) => string;
 //# sourceMappingURL=inequationNode.d.ts.map

package/lib/tree/nodes/inequations/inequationNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAM5D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAK1D,qBAAa,cAAe,YAAW,aAAa;IAClD,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;gBAEjB,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAwBhD,aAAa;;;;;;;IAOb,mBAAmB;IAOnB,UAAU;IA8CV,wBAAwB;IACxB,UAAU;IAQV,UAAU;IAMV,mBAAmB,IAAI,MAAM;IAG7B,oBAAoB;IAMpB,cAAc;IAGd,iBAAiB;IAYjB,YAAY;IAGZ,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;IAehD,UAAU,IAAI,aAAa;IAG3B,MAAM,IAAI,OAAO;IAGjB,QAAQ,IAAI,MAAM;IAGlB,oBAAoB,IAAI,aAAa;CAGtC;AAED,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,MAAM,EACd,OAAO,gBAAgB,EACvB,OAAO,aAAa,WAuBrB,CAAC"}
+{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAM5D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAK1D,qBAAa,cAAe,YAAW,aAAa;IAClD,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;gBAEjB,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAwBhD,aAAa;;;;;;;IAOb,mBAAmB;IAOnB,UAAU;IA8CV,wBAAwB;IACxB,UAAU;IAQV,UAAU;IAMV,mBAAmB,IAAI,MAAM;IAG7B,oBAAoB;IAMpB,cAAc;IAGd,iBAAiB;IAYjB,YAAY;IAGZ,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;IAehD,UAAU,IAAI,aAAa;IAG3B,MAAM,IAAI,OAAO;IAGjB,QAAQ,IAAI,MAAM;IAGlB,oBAAoB,IAAI,aAAa;IAGrC,UAAU,IAAI,OAAO;CAYtB;AAED,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,MAAM,EACd,OAAO,gBAAgB,EACvB,OAAO,aAAa,WAuBrB,CAAC"}

package/lib/tree/nodes/inequations/inequationNode.js

@@ -149,6 +149,22 @@ export class InequationNode {
     toDetailedEvaluation() {
         throw new Error("unimplemented");
     }
+    isVerified() {
+        const values = this.children.map((e) => e.evaluate());
+        for (let i = 0; i < this.symbols.length; i++) {
+            const curr = values[i];
+            const next = values[i + 1];
+            if (this.symbols[i] === "<" && curr >= next)
+                return false;
+            if (this.symbols[i] === ">" && curr <= next)
+                return false;
+            if (this.symbols[i] === "\\le" && curr > next)
+                return false;
+            if (this.symbols[i] === "\\ge" && curr < next)
+                return false;
+        }
+        return true;
+    }
 }
 export const firstDegreeInequationResolutionTex = (affine, order, right) => {
     if (!right.isNumeric)

package/lib/utils/latex/poundify.d.ts

@@ -0,0 +1,2 @@
+export declare const poundify: (s: string) => string;
+//# sourceMappingURL=poundify.d.ts.map

package/lib/utils/latex/poundify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poundify.d.ts","sourceRoot":"","sources":["../../../src/utils/latex/poundify.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,WAEjC,CAAC"}

package/lib/utils/latex/poundify.js

@@ -0,0 +1,3 @@
+export const poundify = (s) => {
+    return `£${s}£`;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.173",
+  "version": "3.0.175",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [