math-exercises 2.0.9 → 2.0.10

package/lib/exercises/calcul/fractions/index.d.ts

@@ -6,4 +6,5 @@ export * from "./fractionsDivision";
 export * from "./fractionsProduct";
 export * from "./fractionsSum";
 export * from "./simplifyFraction";
+export * from "./periodicWritingToFraction";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/calcul/fractions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC"}

package/lib/exercises/calcul/fractions/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./fractionsDivision"), exports);
 __exportStar(require("./fractionsProduct"), exports);
 __exportStar(require("./fractionsSum"), exports);
 __exportStar(require("./simplifyFraction"), exports);
+__exportStar(require("./periodicWritingToFraction"), exports);

package/lib/exercises/calcul/fractions/periodicWritingToFraction.d.ts

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

package/lib/exercises/calcul/fractions/periodicWritingToFraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"periodicWritingToFraction.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calcul/fractions/periodicWritingToFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA2EF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAa/D,CAAC"}

package/lib/exercises/calcul/fractions/periodicWritingToFraction.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.periodicWritingToFraction = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+/**
+ * méthode : x = 0,123123123
+ * 1000x = 123,123123
+ * 999x = 123
+ */
+const getPeriodicWritingToFractionQuestion = () => {
+    const periodicPartLength = (0, randint_1.randint)(1, 4);
+    const periodicPart = [];
+    for (let i = 0; i < periodicPartLength; i++) {
+        periodicPart.push((0, randint_1.randint)(periodicPartLength === 1 ? 1 : 0, 10, periodicPart));
+    }
+    const num = Number("0." + periodicPart.join("")) * 10 ** periodicPartLength;
+    let denumString = "";
+    for (let i = 0; i < periodicPartLength; i++) {
+        denumString += "9";
+    }
+    const denum = Number(denumString);
+    const leadingPart = decimal_1.DecimalConstructor.random(0, 10, (0, randint_1.randint)(0, 3));
+    let x = leadingPart.toTree().toTex();
+    if (!x.includes(","))
+        x += ",";
+    for (let i = 0; i < 4; i++) {
+        x += periodicPart.join("");
+    }
+    x += "\\ldots";
+    const answer = new rational_1.Rational(num, denum * 10 ** leadingPart.precision)
+        .add(leadingPart.toRational())
+        .toTree()
+        .toTex();
+    const question = {
+        answer,
+        instruction: `Ecrire sous forme de fraction : $${x}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { num, denum, leadingPart: leadingPart.value },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, num, denum, leadingPart }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const leadingPartDec = new decimal_1.Decimal(leadingPart);
+    const increments = [-1, 1, 2];
+    for (const i of increments) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(num, denum * 10 ** (leadingPartDec.precision + i))
+            .add(leadingPartDec.toRational())
+            .toTree()
+            .toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { denum, leadingPart, num }) => {
+    const leadingPartDec = new decimal_1.Decimal(leadingPart);
+    const answer = new rational_1.Rational(num, denum * 10 ** leadingPartDec.precision)
+        .add(leadingPartDec.toRational())
+        .toTree();
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.periodicWritingToFraction = {
+    id: "periodicWritingToFraction",
+    connector: "=",
+    label: "Passer de l'écriture décimale périodique à l'écriture fractionnaire",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fractions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPeriodicWritingToFractionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/calculLitteral/factorisation/factoIdRmq3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoIdRmq3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/factorisation/factoIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA6EF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"factoIdRmq3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/factorisation/factoIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA8EF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/calculLitteral/factorisation/factoIdRmq3.js

@@ -11,7 +11,8 @@ const randint_1 = require("../../../math/utils/random/randint");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const getFactoType1Question = () => {
     const interval = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)]));
-    const affine = affine_1.AffineConstructor.random(interval, interval);
+    const intervalPlus = new intervals_1.Interval("[[1; 10]]");
+    const affine = affine_1.AffineConstructor.random(intervalPlus, interval);
     const affine2 = new affine_1.Affine(affine.a, -affine.b);
     const statementTree = affine.multiply(affine2).toTree();
     const answerTree = new multiplyNode_1.MultiplyNode(affine.toTree(), affine2.toTree());

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

@@ -2,4 +2,5 @@ export * from "./logEquation";
 export * from "./logSimplifiying";
 export * from "./log10PowerSimplifying";
 export * from "./logPowerEquation";
+export * from "./log10Simplifying";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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;AACxC,cAAc,oBAAoB,CAAC"}
+{"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;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

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

@@ -18,3 +18,4 @@ __exportStar(require("./logEquation"), exports);
 __exportStar(require("./logSimplifiying"), exports);
 __exportStar(require("./log10PowerSimplifying"), exports);
 __exportStar(require("./logPowerEquation"), exports);
+__exportStar(require("./log10Simplifying"), exports);

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

@@ -0,0 +1,11 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    nb: number;
+    powers: number[];
+    signs: number[];
+    isLog10: boolean;
+};
+export declare const log10SumSimplifying: MathExercise<Identifiers>;
+export declare const logSumSimplifying: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=log10Simplifying.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log10Simplifying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/log10Simplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAsFF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAgBzD,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSumSimplifying = exports.log10SumSimplifying = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const log10Node_1 = require("../../../tree/nodes/functions/log10Node");
+const logNode_1 = require("../../../tree/nodes/functions/logNode");
+const oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
+const random_1 = require("../../../utils/random");
+const getLog10SumSimplifyingQuestion = (opts) => {
+    const nb = (0, randint_1.randint)(2, 10);
+    const nbTerms = (0, randint_1.randint)(2, 4);
+    const powers = [];
+    const signs = [];
+    for (let i = 0; i < nbTerms; i++) {
+        const power = (0, randint_1.randint)(powers.includes(1) ? 2 : 1, 6, powers);
+        powers.push(power);
+        signs.push((0, random_1.random)([-1, 1]));
+    }
+    const nbNode = new numberNode_1.NumberNode(nb);
+    const LNode = opts?.isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const logs = powers.map((power, index) => nb ** power < 100
+        ? signs[index] > 0
+            ? new LNode(new numberNode_1.NumberNode(nb ** power))
+            : new oppositeNode_1.OppositeNode(new LNode(new numberNode_1.NumberNode(nb ** power)))
+        : signs[index] > 0
+            ? new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))
+            : new oppositeNode_1.OppositeNode(new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))));
+    const statement = (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, logs);
+    const answer = statement.simplify();
+    const question = {
+        answer: answer.toTex(),
+        instruction: `Simplifier le plus possible l'expression suivante : $${statement.toTex()}$`,
+        keys: [opts?.isLog10 ? "log" : "ln"],
+        answerFormat: "tex",
+        identifiers: { nb, powers, signs, isLog10: opts?.isLog10 ?? false },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nb, isLog10 }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(1, 10)), new LNode(new numberNode_1.NumberNode(nb)))
+            .simplify()
+            .toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { nb, powers, signs, isLog10 }) => {
+    const nbNode = new numberNode_1.NumberNode(nb);
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const logs = powers.map((power, index) => nb ** power < 100
+        ? signs[index] > 0
+            ? new LNode(new numberNode_1.NumberNode(nb ** power))
+            : new oppositeNode_1.OppositeNode(new LNode(new numberNode_1.NumberNode(nb ** power)))
+        : signs[index] > 0
+            ? new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))
+            : new oppositeNode_1.OppositeNode(new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))));
+    const statement = (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, logs);
+    const answer = statement.simplify();
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.log10SumSimplifying = {
+    id: "log10SumSimplifying",
+    connector: "=",
+    label: "Simplifer une somme de logarithmes décimaux",
+    levels: ["TermTech"],
+    isSingleStep: true,
+    sections: ["Logarithme décimal"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLog10SumSimplifyingQuestion({ isLog10: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};
+exports.logSumSimplifying = {
+    id: "logSumSimplifying",
+    connector: "=",
+    label: "Simplifer une somme de logarithmes népériens",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Logarithme népérien"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLog10SumSimplifyingQuestion({ isLog10: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -1 +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"}
+{"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;AAoEF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}

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

@@ -56,7 +56,6 @@ const isAnswerValid = (ans, { a, k }) => {
         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 = {

package/lib/index.d.ts

@@ -35,6 +35,10 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     num: number;
     denum: number;
+}> | import("./exercises/exercise").MathExercise<{
+    num: number;
+    denum: number;
+    leadingPart: number;
 }> | import("./exercises/exercise").MathExercise<{
     numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
@@ -425,6 +429,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     c: number;
     k: number;
     isLog10: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    nb: number;
+    powers: number[];
+    signs: number[];
+    isLog10: boolean;
 }> | 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/numbers/decimals/decimal.d.ts

@@ -1,6 +1,8 @@
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
+import { Integer } from "../integer/integer";
 import { Nombre, NumberType } from "../nombre";
+import { Rational } from "../rationals/rational";
 export declare abstract class DecimalConstructor {
     static randomFracPart(precision: number, leadingZeros?: number): string;
     static random(min: number, max: number, precision?: number): Decimal;
@@ -24,6 +26,7 @@ export declare class Decimal implements Nombre {
     multiplyByPowerOfTen(power: number): Decimal;
     toScientificPart(): NumberNode;
     toScientificNotation(): NumberNode | MultiplyNode;
+    toRational(): Rational | Integer;
     toTree(): NumberNode;
 }
 //# sourceMappingURL=decimal.d.ts.map

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAGvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAI/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA2BlC,gBAAgB;IAgBhB,oBAAoB;IAmBpB,MAAM;CAGP"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA4BlC,gBAAgB;IAgBhB,oBAAoB;IAmBpB,UAAU;IAMV,MAAM;CAGP"}

package/lib/math/numbers/decimals/decimal.js

@@ -7,6 +7,7 @@ const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
 const integer_1 = require("../integer/integer");
 const nombre_1 = require("../nombre");
+const rational_1 = require("../rationals/rational");
 class DecimalConstructor {
     static randomFracPart(precision, leadingZeros = 0) {
         let decimals = "";
@@ -27,6 +28,8 @@ class DecimalConstructor {
         return DecimalConstructor.fromParts(int, decimals);
     }
     static fromParts(intPart, decimalPart) {
+        if (decimalPart.length === 0)
+            return new Decimal(Number("" + intPart));
         return new Decimal(Number("" + intPart + "." + decimalPart));
     }
     //returns X.YYYY where X € [0, 9] and first Y is not zero if X is zero
@@ -127,6 +130,8 @@ class Decimal {
         return DecimalConstructor.fromParts(newIntPart, newFracPart);
     }
     multiplyByPowerOfTen(power) {
+        if (power === 0)
+            return this;
         let newIntPart = "", newFracPart = "";
         if (power > -1) {
             newIntPart = this.intPart + "";
@@ -180,6 +185,9 @@ class Decimal {
             return new multiplyNode_1.MultiplyNode(decNode, new numberNode_1.NumberNode(10));
         return new multiplyNode_1.MultiplyNode(decNode, new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(power)));
     }
+    toRational() {
+        return new rational_1.Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision).simplify();
+    }
     toTree() {
         return new numberNode_1.NumberNode(this.value);
     }

package/lib/math/numbers/integer/integer.d.ts

@@ -16,6 +16,6 @@ export declare class Integer implements Nombre {
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;
     opposite(): Integer;
-    add(nb: Nombre): Nombre | Integer;
+    add(nb: Nombre): Integer | Nombre;
 }
 //# sourceMappingURL=integer.d.ts.map

package/lib/math/numbers/nombre.d.ts

@@ -14,6 +14,6 @@ export interface Nombre {
     toTree: (opts?: NodeOptions) => AlgebraicNode;
 }
 export declare abstract class NombreConstructor {
-    static random(): import("./decimals/decimal").Decimal | Integer | import("./rationals/rational").Rational | import("./reals/real").Real;
+    static random(): import("./rationals/rational").Rational | Integer | import("./decimals/decimal").Decimal | import("./reals/real").Real;
 }
 //# sourceMappingURL=nombre.d.ts.map

package/lib/math/polynomials/rationalFrac.d.ts

@@ -7,6 +7,6 @@ export declare class RationalFrac {
     denum: Polynomial;
     constructor(num: Polynomial, denum: Polynomial);
     toTree(): FractionNode;
-    simplify(): Integer | Rational | RationalFrac;
+    simplify(): Rational | Integer | RationalFrac;
 }
 //# sourceMappingURL=rationalFrac.d.ts.map

package/lib/server.js

@@ -42,6 +42,7 @@ const runServer = () => {
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
     console.log(exercises.length + " exercices");
+    console.log(exercises.filter((exo) => exo.isSingleStep).length);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

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

@@ -19,7 +19,7 @@ export declare class OppositeNode implements FunctionNode {
      */
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars: Record<string, number>): number;
-    simplify(): this;
+    simplify(): OppositeNode;
     equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=oppositeNode.d.ts.map

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

@@ -70,7 +70,7 @@ class OppositeNode {
         return -this.child.evaluate(vars);
     }
     simplify() {
-        return this;
+        return new OppositeNode(this.child.simplify());
     }
     equals(node) {
         return isOppositeNode(node) && node.child.equals(this.child);

package/lib/tree/nodes/operators/addNode.js

@@ -207,12 +207,12 @@ class AddNode {
                 ? new numberNode_1.NumberNode(1)
                 : aSubExternals.length === 1
                     ? aSubExternals[0]
-                    : (0, operatorComposition_1.operatorComposition)(AddNode, aSubExternals);
+                    : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, aSubExternals);
             const bNode = bSubExternals.length === 0
                 ? new numberNode_1.NumberNode(1)
                 : bSubExternals.length === 1
                     ? bSubExternals[0]
-                    : (0, operatorComposition_1.operatorComposition)(AddNode, bSubExternals);
+                    : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, bSubExternals);
             const addNode = new AddNode(aNode, bNode);
             return new multiplyNode_1.MultiplyNode(addNode, factorsNode).simplify();
         };

package/lib/tree/nodes/operators/fractionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAIjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,IAAI,aAAa;IA6EzB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAIjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,IAAI,aAAa;IA2EzB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

package/lib/tree/nodes/operators/fractionNode.js

@@ -102,7 +102,6 @@ class FractionNode {
         const simplifyExternalNodes = (num, denum) => {
             if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
                 const frac = new rational_1.Rational(num.value, denum.value);
-                console.log(frac.isIrreductible());
                 if (frac.isIrreductible())
                     return null;
                 return frac.simplify().toTree();
@@ -113,7 +112,6 @@ class FractionNode {
                 return new numberNode_1.NumberNode(1);
             return null;
         };
-        console.log(externalsNums, externalsDenums);
         const simplifyIteration = () => {
             for (let i = 0; i < externalsNums.length; i++) {
                 const num = externalsNums[i];

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAkDf,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAwFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrC,IAAI;IAGJ,QAAQ,IAAI,aAAa;IAqGzB,MAAM,CAAC,IAAI,EAAE,aAAa;CAU3B"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAkDf,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAwFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrC,IAAI;IAGJ,QAAQ,IAAI,aAAa;IAoGzB,MAAM,CAAC,IAAI,EAAE,aAAa;CAU3B"}

package/lib/tree/nodes/operators/multiplyNode.js

@@ -262,7 +262,6 @@ class MultiplyNode {
             return new fractionNode_1.FractionNode(numNode, denumNode).simplify();
         }
         (0, exports.sortMultiplyNodes)(externals);
-        console.log(externals.map((n) => n.toTex()));
         const simplifyExternalNodes = (a, b) => {
             if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
                 return new numberNode_1.NumberNode(a.value * b.value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [