math-exercises 2.0.6 → 2.0.7

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"}
+{"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"}

package/lib/exercises/functions/index.js

@@ -20,3 +20,5 @@ __exportStar(require("./basics"), exports);
 __exportStar(require("./cube"), exports);
 __exportStar(require("./rationalFraction"), exports);
 __exportStar(require("./trinoms"), exports);
+__exportStar(require("./exponential"), exports);
+__exportStar(require("./logarithm"), exports);

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

@@ -0,0 +1,4 @@
+export * from "./logEquation";
+export * from "./logSimplifiying";
+export * from "./log10PowerSimplifying";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC"}

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

@@ -0,0 +1,20 @@
+"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("./logEquation"), exports);
+__exportStar(require("./logSimplifiying"), exports);
+__exportStar(require("./log10PowerSimplifying"), exports);
+// export * from "./logPowerEquation";

package/lib/exercises/functions/logarithm/log10PowerSimplifying.d.ts

@@ -0,0 +1,7 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    tenthPower: number;
+};
+export declare const log10PowerSimplifying: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=log10PowerSimplifying.d.ts.map

package/lib/exercises/functions/logarithm/log10PowerSimplifying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqCF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/functions/logarithm/log10PowerSimplifying.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log10PowerSimplifying = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const randint_1 = require("../../../math/utils/random/randint");
+const log10Node_1 = require("../../../tree/nodes/functions/log10Node");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const probaFlip_1 = require("../../../utils/probaFlip");
+const getLog10PowerSimplifyingQuestion = () => {
+    const tenthPower = (0, randint_1.randint)(-5, 6, [0]);
+    const shouldEvaluate = (0, probaFlip_1.probaFlip)(0.7);
+    const nb = shouldEvaluate
+        ? new decimal_1.Decimal(1).multiplyByPowerOfTen(tenthPower).toTree()
+        : new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(tenthPower));
+    const answer = tenthPower + "";
+    const question = {
+        answer,
+        instruction: `Calculer : $${new log10Node_1.Log10Node(nb).toTex()}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { tenthPower },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, tenthPower }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "10");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower + 1 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower + 2 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower - 1 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower - 2 + "");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, tenthPower }) => {
+    return ans === answer;
+};
+exports.log10PowerSimplifying = {
+    id: "log10PowerSimplifying",
+    connector: "=",
+    label: "Calculer un logarithme décimal",
+    levels: ["TermTech", "MathComp"],
+    isSingleStep: true,
+    sections: ["Logarithme décimal", "Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLog10PowerSimplifyingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/logarithm/logEquation.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+/**aln(x)=k */
+type Identifiers = {
+    a: number;
+    k: number;
+};
+export declare const logEquation: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=logEquation.d.ts.map

package/lib/exercises/functions/logarithm/logEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/logEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAclC,cAAc;AACd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/functions/logarithm/logEquation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEquation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const expNode_1 = require("../../../tree/nodes/functions/expNode");
+const logNode_1 = require("../../../tree/nodes/functions/logNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getLnEquation = () => {
+    const a = (0, randint_1.randint)(-9, 20, [0]);
+    const k = (0, randint_1.randint)(-9, 20, [0]);
+    const equation = new equalNode_1.EqualNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new logNode_1.LogNode(new variableNode_1.VariableNode("x"))), new numberNode_1.NumberNode(k));
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([new expNode_1.ExpNode(new rational_1.Rational(k, a).simplify().toTree())])).toTex();
+    const question = {
+        instruction: `Résoudre l'équation $${equation.toTex()}$.`,
+        answer,
+        keys: [
+            "x",
+            "equal",
+            "ln",
+            "e",
+            "epower",
+            "exp",
+            "lbrace",
+            "S",
+            "semicolon",
+            "rbrace",
+        ],
+        answerFormat: "tex",
+        identifiers: { a, k },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const randomA = (0, randint_1.randint)(1, 10);
+        const randomK = (0, randint_1.randint)(1, 20);
+        (0, exercise_1.tryToAddWrongProp)(propositions, new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+            new expNode_1.ExpNode(new rational_1.Rational(randomK, randomA).simplify().toTree()),
+        ])).toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, k }) => {
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new expNode_1.ExpNode(new rational_1.Rational(k, a).simplify().toTree({ allowFractionToDecimal: true })),
+    ]));
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.logEquation = {
+    id: "logEquation",
+    connector: "=",
+    label: "Résoudre des équations de type $a \\times \\ln(x) = k$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    sections: ["Logarithme népérien", "Exponentielle"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLnEquation, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+};

package/lib/exercises/functions/logarithm/logPowerEquation.d.ts

@@ -0,0 +1,6 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {};
+export declare const logPowerEquation: MathExercise<Identifiers>;
+export declare const log10PowerEquation: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=logPowerEquation.d.ts.map

package/lib/exercises/functions/logarithm/logPowerEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logPowerEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/logPowerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkDtB,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CAatD,CAAC;AACF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/functions/logarithm/logPowerEquation.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log10PowerEquation = exports.logPowerEquation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const log10Node_1 = require("../../../tree/nodes/functions/log10Node");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+/**a*b^x+c=d */
+const getLogPowerEquationQuestion = (opts) => {
+    const powered = (0, randint_1.randint)(2, 8);
+    const a = (0, randint_1.randint)(1, 10);
+    const c = (0, randint_1.randint)(-5, 5);
+    const k = (0, randint_1.randint)(5, 15, [powered, 10]);
+    const d = k * a + c;
+    const xNode = new variableNode_1.VariableNode("x");
+    const poweredNode = new numberNode_1.NumberNode(powered);
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new log10Node_1.Log10Node(new numberNode_1.NumberNode(k)), new log10Node_1.Log10Node(poweredNode)),
+    ])).toTex();
+    const equation = new equalNode_1.EqualNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new powerNode_1.PowerNode(poweredNode, xNode)), new numberNode_1.NumberNode(c)), new numberNode_1.NumberNode(d));
+    const question = {
+        answer,
+        instruction: `Résoudre : $${equation.toTex()}$`,
+        keys: ["log", "x", "equal", "lbrace", "semicolon", "rbrace"],
+        answerFormat: "tex",
+        identifiers: {},
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) { }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return true;
+};
+exports.logPowerEquation = {
+    id: "logPowerEquation",
+    connector: "\\iff",
+    label: "",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLogPowerEquationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};
+exports.log10PowerEquation = {
+    id: "log10PowerEquation",
+    connector: "\\iff",
+    label: "",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLogPowerEquationQuestion({ isLog10: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/logarithm/logSimplifiying.d.ts

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

package/lib/exercises/functions/logarithm/logSimplifiying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logSimplifiying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/logSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAYrD,CAAC"}

package/lib/exercises/functions/logarithm/logSimplifiying.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSimplifiying = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const logNode_1 = require("../../../tree/nodes/functions/logNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getExpSimplifiying = () => {
+    let expression;
+    let simplifiedExpression;
+    let pm = (0, coinFlip_1.coinFlip)() ? 1 : -1;
+    const a = (0, randint_1.randint)(1, 10);
+    let b;
+    do {
+        b = (0, randint_1.randint)(1, 10);
+    } while (pm === -1 && a === b);
+    const opts = { allowLnOfOne: true };
+    if (pm === 1) {
+        expression = new addNode_1.AddNode(new logNode_1.LogNode(new numberNode_1.NumberNode(a), opts), new logNode_1.LogNode(new numberNode_1.NumberNode(b), opts));
+        simplifiedExpression = new logNode_1.LogNode(new numberNode_1.NumberNode(a * b));
+    }
+    else {
+        expression = new substractNode_1.SubstractNode(new logNode_1.LogNode(new numberNode_1.NumberNode(a), opts), new logNode_1.LogNode(new numberNode_1.NumberNode(b), opts));
+        simplifiedExpression = new logNode_1.LogNode(new rational_1.Rational(a, b).simplify().toTree());
+    }
+    const answer = simplifiedExpression.toTex();
+    const question = {
+        instruction: `Simplifier l'expression suivante : $${expression.toTex()}$.`,
+        answer,
+        keys: ["ln"],
+        answerFormat: "tex",
+        identifiers: { pm, a, b },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, pm }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const a = (0, randint_1.randint)(1, 10);
+        const b = (0, randint_1.randint)(1, 10);
+        (0, exercise_1.tryToAddWrongProp)(propositions, pm > 0
+            ? new logNode_1.LogNode(new numberNode_1.NumberNode(a * b)).toTex()
+            : new logNode_1.LogNode(new rational_1.Rational(a, b).simplify().toTree()).toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, pm }) => {
+    let answer;
+    if (pm === 1) {
+        answer = new logNode_1.LogNode(new numberNode_1.NumberNode(a * b));
+    }
+    else {
+        answer = new logNode_1.LogNode(new rational_1.Rational(a, b).simplify().toTree({ allowFractionToDecimal: true }));
+    }
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.logSimplifiying = {
+    id: "logSimplifiying",
+    connector: "\\iff",
+    label: "Simplifier des expressions avec $\\ln$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    sections: ["Logarithme népérien"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExpSimplifiying, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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;AAkBlC,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmKF,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;AAalC,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmKF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/index.d.ts

@@ -2,14 +2,14 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     numbers: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    chosenNumbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     dividend: number;
     divisor: number;
     quotient: number;
     remainder: number;
 }> | import("./exercises/exercise").MathExercise<{}> | import("./exercises/exercise").MathExercise<{
-    chosenNumbers: number[];
-}> | import("./exercises/exercise").MathExercise<{
     integerFirst: boolean;
     integer: number;
     rational: [number, number];
@@ -110,9 +110,6 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: number;
     c: number;
     d: number;
-}> | import("./exercises/exercise").MathExercise<{
-    a: number;
-    k: number;
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     b: number;
@@ -121,9 +118,6 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: number;
     c: number;
     d: number;
-}> | import("./exercises/exercise").MathExercise<{
-    a: number;
-    k: number;
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     b: number;
@@ -166,15 +160,6 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     poly1: number[];
     poly2: number[];
     xValue: number;
-}> | import("./exercises/exercise").MathExercise<{
-    random: number;
-    a?: number | undefined;
-    uCoeffs: number[];
-    vCoeffs: number[];
-}> | import("./exercises/exercise").MathExercise<{
-    pm: number;
-    a: number;
-    b: number;
 }> | import("./exercises/exercise").MathExercise<{
     rand: number;
     polynome1Coeffs: number[];
@@ -355,6 +340,19 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     affineCoeffs?: number[] | undefined;
     trinomCoeffs?: number[] | undefined;
     isAffine: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    yValue: number;
+    splinePoints: [number, number][];
+}> | import("./exercises/exercise").MathExercise<{
+    yValue: number;
+    splinePoints: [number, number][];
+    isStrict: boolean;
+    isAskingSup: boolean;
+    intervals: {
+        a: number;
+        b: number;
+        closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    }[];
 }> | import("./exercises/exercise").MathExercise<{
     k: number;
 }> | import("./exercises/exercise").MathExercise<{
@@ -402,6 +400,23 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     a: number;
     b: number;
     c: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    k: number;
+}> | import("./exercises/exercise").MathExercise<{
+    random: number;
+    a?: number | undefined;
+    uCoeffs: number[];
+    vCoeffs: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    k: number;
+}> | import("./exercises/exercise").MathExercise<{
+    pm: number;
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").MathExercise<{
+    tenthPower: number;
 }> | import("./exercises/exercise").MathExercise<{
     coin: boolean;
     radius: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/math/complex/complex.d.ts

@@ -18,7 +18,7 @@ export declare class Complex {
     times(n: number): Complex;
     opposite(): Complex;
     conjugate(): Complex;
-    toArgumentTree(): NumberNode | FractionNode | OppositeNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | undefined;
+    toArgumentTree(): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | FractionNode | OppositeNode | undefined;
     toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
     toTree(): ComplexNode;
 }

package/lib/math/numbers/logarithms/ln.d.ts

@@ -0,0 +1,12 @@
+import { LogNode } from "../../../tree/nodes/functions/logNode";
+import { Nombre, NumberType } from "../nombre";
+export declare class Ln implements Nombre {
+    value: number;
+    tex: string;
+    type: NumberType;
+    operand: Nombre;
+    constructor(operand: Nombre);
+    toTree(): LogNode;
+    simplify(): void;
+}
+//# sourceMappingURL=ln.d.ts.map

package/lib/math/numbers/logarithms/ln.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ln.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/logarithms/ln.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,qBAAa,EAAG,YAAW,MAAM;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAM3B,MAAM;IAGN,QAAQ;CACT"}

package/lib/math/numbers/logarithms/ln.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ln = void 0;
+const logNode_1 = require("../../../tree/nodes/functions/logNode");
+const nombre_1 = require("../nombre");
+class Ln {
+    constructor(operand) {
+        this.type = nombre_1.NumberType.Real;
+        this.value = Math.log(operand.value);
+        this.tex = `\\ln(${operand})`;
+        this.operand = operand;
+    }
+    toTree() {
+        return new logNode_1.LogNode(this.operand.toTree());
+    }
+    simplify() { }
+}
+exports.Ln = Ln;

package/lib/tree/nodes/functions/functionNode.d.ts

@@ -7,8 +7,9 @@ export declare enum FunctionsIds {
     cos = 2,
     sin = 3,
     log = 4,
-    exp = 5,
-    abs = 6
+    log10 = 5,
+    exp = 6,
+    abs = 7
 }
 export interface FunctionNode extends AlgebraicNode {
     id: FunctionsIds;

package/lib/tree/nodes/functions/functionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/functionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,oBAAY,YAAY;IACtB,QAAQ,IAAA;IACR,IAAI,IAAA;IACJ,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;CACJ;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;CAOtB"}
+{"version":3,"file":"functionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/functionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,oBAAY,YAAY;IACtB,QAAQ,IAAA;IACR,IAAI,IAAA;IACJ,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;IACH,KAAK,IAAA;IACL,GAAG,IAAA;IACH,GAAG,IAAA;CACJ;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;CAOtB"}

package/lib/tree/nodes/functions/functionNode.js

@@ -13,6 +13,7 @@ var FunctionsIds;
     FunctionsIds[FunctionsIds["cos"] = 2] = "cos";
     FunctionsIds[FunctionsIds["sin"] = 3] = "sin";
     FunctionsIds[FunctionsIds["log"] = 4] = "log";
-    FunctionsIds[FunctionsIds["exp"] = 5] = "exp";
-    FunctionsIds[FunctionsIds["abs"] = 6] = "abs";
+    FunctionsIds[FunctionsIds["log10"] = 5] = "log10";
+    FunctionsIds[FunctionsIds["exp"] = 6] = "exp";
+    FunctionsIds[FunctionsIds["abs"] = 7] = "abs";
 })(FunctionsIds || (exports.FunctionsIds = FunctionsIds = {}));

package/lib/tree/nodes/functions/log10Node.d.ts

@@ -0,0 +1,18 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isLog10Node(a: Node): a is Log10Node;
+export declare class Log10Node implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
+    type: NodeType;
+    opts?: NodeOptions;
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
+    toMathString(): string;
+    toTex(): string;
+    toEquivalentNodes(): AlgebraicNode[];
+    toAllValidTexs(): string[];
+    simplify(): Node;
+    evaluate(vars: Record<string, number>): number;
+}
+//# sourceMappingURL=log10Node.d.ts.map

package/lib/tree/nodes/functions/log10Node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log10Node.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/log10Node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AACD,qBAAa,SAAU,YAAW,YAAY;IAC5C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,IAAI;IAGhB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGtC"}

package/lib/tree/nodes/functions/log10Node.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log10Node = exports.isLog10Node = void 0;
+// import { log } from "mathjs";
+const node_1 = require("../node");
+const functionNode_1 = require("./functionNode");
+const absNode_1 = require("./absNode");
+function isLog10Node(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.log10;
+}
+exports.isLog10Node = isLog10Node;
+class Log10Node {
+    constructor(child, opts) {
+        this.id = functionNode_1.FunctionsIds.log10;
+        this.child = child;
+        this.type = node_1.NodeType.function;
+        this.opts = opts;
+    }
+    toMathString() {
+        return `log_{10}(${this.child.toMathString()})`;
+    }
+    toTex() {
+        const tex = this.child.toTex();
+        if (!this.opts?.allowLnOfOne && tex === "1") {
+            return "0";
+        }
+        const shouldntUseBrackets = (0, absNode_1.isAbsNode)(this.child);
+        if (shouldntUseBrackets)
+            return `\\log${tex}`;
+        else
+            return `\\log\\left(${tex}\\right)`;
+    }
+    // toMathjs() {
+    //   return log(this.child.toMathjs());
+    // }
+    toEquivalentNodes() {
+        const res = [];
+        const childNodes = this.child.toEquivalentNodes();
+        childNodes.forEach((childNode) => {
+            res.push(new Log10Node(childNode));
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    simplify() {
+        return this;
+    }
+    evaluate(vars) {
+        return Math.log10(this.child.evaluate(vars));
+    }
+}
+exports.Log10Node = Log10Node;