math-exercises 2.2.78 → 2.2.80

package/lib/exercises/math/sequences/geometric/geometricVariations.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricVariations = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const nodeConstructor_1 = require("../../../../tree/nodes/nodeConstructor");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Strictement croissante", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Strictement décroissante", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Constante", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non monotone", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const qEv = (0, nodeConstructor_1.reifyAlgebraic)(identifiers.q).evaluate();
+    if (qEv > 1) {
+        return identifiers.a > 0
+            ? "Strictement croissante"
+            : "Strictement décroissante";
+    }
+    else {
+        return identifiers.a > 0
+            ? "Strictement décroissante"
+            : "Strictement croissante";
+    }
+};
+const getInstruction = (identifiers) => {
+    const q = (0, nodeConstructor_1.reifyAlgebraic)(identifiers.q);
+    const a = identifiers.a;
+    const statement = (0, multiplyNode_1.multiply)(a, (0, powerNode_1.power)(q, "n")).simplify();
+    return `Soit $u$ la suite définie sur $\\mathbb{N}$ par 
+
+$$
+u_n = ${statement.toTex()}
+$$
+
+Quel est le sens de variations de $u$ ?`;
+};
+const getHint = (identifiers) => {
+    return `La suite géométrique $u_n = q^n$ est : 
+  
+- strictement croissante si $q>1$;
+- strictement décroissante si $0<q<1$. 
+
+Puis, multiplier $u$ par un nombre positif ne change pas son sens de variations, tandis que multiplier par un nombre negatif inverse le sens de variations.
+`;
+};
+const getCorrection = (identifiers) => {
+    const q = (0, nodeConstructor_1.reifyAlgebraic)(identifiers.q);
+    const qEv = q.evaluate();
+    const qLessThanOne = qEv < 1;
+    const a = identifiers.a;
+    const answer = getAnswer(identifiers);
+    const statement = (0, multiplyNode_1.multiply)(a, (0, powerNode_1.power)(q, "x")).simplify();
+    return `Puisque $${qLessThanOne ? `0 < ${q.toTex()} < 1` : `${q.toTex()}>1`}$, la suite $${(0, powerNode_1.power)(q, "n").toTex()}$ est strictement ${qLessThanOne ? "décroissante" : " croissante"}.
+  
+En multipliant $${(0, powerNode_1.power)(q, "n").toTex()}$ par $${a.frenchify()} ${a < 0 ? "<0" : ">0"}$, ${a < 0
+        ? `on inverse son sens de variations.`
+        : `on ne change pas son sens de variation.`}
+
+Ainsi, la suite $u_n = ${statement.toTex()}$ est ${answer.toLocaleLowerCase()}.
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getGeometricVariationsQuestion = (ops) => {
+    const a = (0, randfloat_1.randfloat)(0.1, 3, 2, [1]) * ((0, coinFlip_1.coinFlip)() ? 1 : -1);
+    const qLessThanOne = (0, coinFlip_1.coinFlip)();
+    let q;
+    if (qLessThanOne) {
+        q = (0, coinFlip_1.coinFlip)()
+            ? (0, randfloat_1.randfloat)(0.1, 1, 2).toTree()
+            : rational_1.RationalConstructor.randomIrreductibleProba().toTree();
+    }
+    else {
+        q = (0, coinFlip_1.coinFlip)()
+            ? (0, randfloat_1.randfloat)(1.1, 10, 2).toTree()
+            : rational_1.RationalConstructor.randomIrreductible(11, {
+                onlySupOne: true,
+            }).toTree();
+    }
+    const identifiers = {
+        a,
+        q: q.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.geometricVariations = {
+    id: "geometricVariations",
+    label: "Déterminer le sens de variations d'une suite géométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getGeometricVariationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/index.d.ts

@@ -8,4 +8,5 @@ export * from "./geometricFindExplicitFormulaFirstTermRandom";
 export * from "./geometricFindTerm";
 export * from "./geometricRecognizeReasonFromFirstTerms";
 export * from "./geometricFirstTermsGeneralSum";
+export * from "./geometricVariations";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/sequences/geometric/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./geometricFindExplicitFormulaFirstTermRandom"), exports);
 __exportStar(require("./geometricFindTerm"), exports);
 __exportStar(require("./geometricRecognizeReasonFromFirstTerms"), exports);
 __exportStar(require("./geometricFirstTermsGeneralSum"), exports);
+__exportStar(require("./geometricVariations"), exports);

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

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AAwFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAO5D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AAkFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/sets/intervals/inequalityToInterval.js

@@ -4,8 +4,7 @@ exports.inequalityToInterval = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const intervals_1 = require("../../../../math/sets/intervals/intervals");
-const belongsNode_1 = require("../../../../tree/nodes/sets/belongsNode");
-const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+const intervalParser_1 = require("../../../../tree/parsers/intervalParser");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getInequalityToIntervalQuestion = () => {
     const interval = intervals_1.IntervalConstructor.random();
@@ -55,15 +54,16 @@ const getPropositions = (n, { answer, intervalClosure, intervalMax, intervalMin
     });
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin }) => {
-    const min = intervalMin === "-infty" ? -Infinity : intervalMin;
-    const max = intervalMax === "infty" ? Infinity : intervalMax;
-    const interval = new intervals_1.Interval(min.toTree(), max.toTree(), intervalClosure).toTree();
-    const answer = new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
-        allowRawRightChildAsSolution: true,
-    });
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin, answer }) => {
+    try {
+        const parsed = (0, intervalParser_1.intervalParser)(ans.replaceAll("x\\in", ""));
+        if (!parsed)
+            return false;
+        return "x\\in\\ " + parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.inequalityToInterval = {
     id: "inequalityToInterval",

package/lib/exercises/options/inequationSolutionFormat.d.ts

@@ -0,0 +1,3 @@
+import { GeneratorOption } from "../exercise";
+export declare const inequationSolutionFormat: GeneratorOption;
+//# sourceMappingURL=inequationSolutionFormat.d.ts.map

package/lib/exercises/options/inequationSolutionFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inequationSolutionFormat.d.ts","sourceRoot":"","sources":["../../../src/exercises/options/inequationSolutionFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAGhB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,wBAAwB,EAAE,eAOtC,CAAC"}

package/lib/exercises/options/inequationSolutionFormat.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inequationSolutionFormat = void 0;
+const exercise_1 = require("../exercise");
+exports.inequationSolutionFormat = {
+    id: "inequationSolutionFormat",
+    label: "Format de la solution",
+    target: exercise_1.GeneratorOptionTarget.answer,
+    type: exercise_1.GeneratorOptionType.select,
+    values: ["Intervalle (S = [a;b])", "Inégalité (x>a)"],
+    defaultValue: "Inégalité (x>a)",
+};

package/lib/exercises/pc/pH.js

@@ -24,7 +24,7 @@ const getpH = () => {
         answer,
         hint,
         correction,
-        keys: ["log"],
+        keys: ["logBrackets"],
         answerFormat: "tex",
         identifiers: { randomNumber, randomTenPower },
     };

package/lib/index.d.ts

@@ -341,11 +341,15 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     ineqType: import("./math/inequations/inequation").InegalitySymbols;
-}, {}> | Exercise<{
+}, {
+    inequationSolutionFormat: string;
+}> | Exercise<{
     a: number;
     b: number;
     ineqType: import("./math/inequations/inequation").InegalitySymbols;
-}, {}> | Exercise<{
+}, {
+    inequationSolutionFormat: string;
+}> | Exercise<{
     ineqType: import("./math/inequations/inequation").InegalitySymbols;
     a: number;
     b: number;
@@ -903,6 +907,9 @@ declare const mathExercises: (Exercise<{
     b: number;
     aU: number;
     bU: number;
+}, {}> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    a: number;
 }, {}> | Exercise<{
     coin: boolean;
     radius: number;
@@ -1308,6 +1315,9 @@ declare const mathExercises: (Exercise<{
     subPopulationEffectif: number;
     subPopulationPercent: number;
     contextType: number;
+}, {}> | Exercise<{
+    vd: number;
+    percentRate: number;
 }, {}> | Exercise<{
     int: number;
     power: number;
@@ -1342,6 +1352,12 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     tenPower: number;
     decimal: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    k: number;
+    l: number;
+    m: number;
 }, {}> | Exercise<{
     c: number;
 }, {}> | Exercise<{
@@ -1593,6 +1609,9 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     nbTerms: number;
+}, {}> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    a: number;
 }, {}> | Exercise<{
     rank: number;
     coeffs: number[];
@@ -1774,6 +1793,20 @@ declare const mathExercises: (Exercise<{
         n: number;
         p: number;
     };
+}, {}> | Exercise<{
+    p: number;
+    n: number;
+    wordingType: number;
+}, {}> | Exercise<{
+    k: number;
+    n: number;
+    wordingType: number;
+}, {}> | Exercise<{
+    p: number;
+    k: number;
+    n: number;
+    isRepresentative: boolean;
+    wordingType: number;
 }, {}>)[];
 declare const pcExercises: (Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -15,7 +15,7 @@ export declare class Integer implements Nombre {
     constructor(value: number, tex?: string);
     equals(n: Nombre): boolean;
     toTree(): NumberNode;
-    times(n: number | Nombre): Integer | Decimal;
+    times(n: number | Nombre): Decimal | Integer;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;

package/lib/math/numbers/rationals/rational.d.ts

@@ -8,7 +8,9 @@ export declare abstract class RationalConstructor {
      * @param maxGcd max number by which the fraction is simplifiable
      */
     static randomSimplifiable(maxGcd?: number): Rational;
-    static randomIrreductible(max?: number): Rational;
+    static randomIrreductible(max?: number, { onlySupOne }?: {
+        onlySupOne?: boolean;
+    }): Rational;
     static randomIrreductibleProba(maxDenum?: number): Rational | Integer;
     static randomIrreductibleWithSign(max?: number): Rational;
     static randomPureRational(max?: number): Rational;

package/lib/math/numbers/rationals/rational.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAMvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;IAO1C,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAgBzB,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAMvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAgBzB,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}

package/lib/math/numbers/rationals/rational.js

@@ -31,11 +31,13 @@ class RationalConstructor {
         }
         return new Rational(num, denum);
     }
-    static randomIrreductible(max = 11) {
+    static randomIrreductible(max = 11, { onlySupOne = false } = {}) {
         const a = (0, randint_1.randint)(2, max);
         const b = (0, random_1.random)([...(0, coprimesOf_1.coprimesOf)(a), 1]);
         if (b === 1)
             return new Rational(b, a);
+        if (onlySupOne)
+            return new Rational(a, b);
         const [num, denum] = (0, shuffle_1.shuffle)([a, b]);
         return new Rational(num, denum);
     }

package/lib/math/numbers/reals/real.d.ts

@@ -2,7 +2,7 @@ import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
 import { SqrtNode } from "../../../tree/nodes/functions/sqrtNode";
 import { Nombre, NumberType } from "../nombre";
 export declare abstract class RealConstructor {
-    static random(): Real | SquareRoot;
+    static random(): SquareRoot | Real;
 }
 export declare class Real implements Nombre {
     value: number;

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAKtB,CAAC"}

package/lib/playground.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const playground = () => { };
+const playground = () => {
+    // const a = multiply(-3, power("x", 2));
+    // console.log(isMonom(a));
+    // const a = "-3x^2";
+    // console.log(isMonom(parsed));
+};
 exports.playground = playground;
 const logIdentifiers = () => {
     const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';

package/lib/tree/nodes/algebraicNode.d.ts

@@ -6,6 +6,7 @@ export type SimplifyOptions = {
     scientific?: number;
     isDegree?: boolean;
     towardsDistribute?: boolean;
+    decimalToFractions?: boolean;
 };
 export interface AlgebraicNode extends Node {
     evaluate: (vars?: Record<string, number>) => number;

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}

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

@@ -1,7 +1,8 @@
 import { InegalitySymbols } from "../../../math/inequations/inequation";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { IntervalNode } from "../sets/intervalNode";
-import { AlgebraicNode } from "../algebraicNode";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+import { Affine } from "../../../math/polynomials/affine";
 export declare class InequationNode implements Node {
     opts?: NodeOptions | undefined;
     type: NodeType;
@@ -18,12 +19,14 @@ export declare class InequationNode implements Node {
     };
     toInterval(): IntervalNode;
     toReversed(): InequationNode;
+    toSwitched(): InequationNode;
     toAllValidTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions | undefined): InequationNode[];
     toMathString(): string;
     toMathjs(): string;
     toAllTexs(): string[];
     toTex(): string;
-    simplify(): this;
+    simplify(opts?: SimplifyOptions): InequationNode;
 }
+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,mCAAmC,CAAC;AAK3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,qBAAa,cAAe,YAAW,IAAI;IACzC,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;gBAE1B,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA6CV,UAAU;IAQV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;IAGL,QAAQ;CAGT"}
+{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAMvD,qBAAa,cAAe,YAAW,IAAI;IACzC,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;gBAE1B,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA6CV,UAAU;IAQV,UAAU;IAMV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;CAcjD;AAED,eAAO,MAAM,kCAAkC,WACrC,MAAM,SACP,gBAAgB,SAChB,aAAa,WAuBrB,CAAC"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InequationNode = void 0;
+exports.firstDegreeInequationResolutionTex = exports.InequationNode = void 0;
 const inequation_1 = require("../../../math/inequations/inequation");
 const cartesianProducts_1 = require("../../../utils/arrays/cartesianProducts");
 const isLetter_1 = require("../../../utils/strings/isLetter");
@@ -8,6 +8,9 @@ const node_1 = require("../node");
 const infiniteNode_1 = require("../numbers/infiniteNode");
 const closure_1 = require("../sets/closure");
 const intervalNode_1 = require("../sets/intervalNode");
+const alignTex_1 = require("../../../utils/latex/alignTex");
+const fractionNode_1 = require("../operators/fractionNode");
+const substractNode_1 = require("../operators/substractNode");
 class InequationNode {
     constructor(children, symbols) {
         if (children.length < 2)
@@ -81,6 +84,9 @@ class InequationNode {
         const newSymbols = this.symbols.map((el) => new inequation_1.InequationSymbol(el).reversed());
         return new InequationNode(newChildren, newSymbols);
     }
+    toSwitched() {
+        return new InequationNode(this.children, this.symbols.map((el) => new inequation_1.InequationSymbol(el).reversed()));
+    }
     toAllValidTexs() {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
@@ -108,8 +114,39 @@ class InequationNode {
     toTex() {
         return this.tex;
     }
-    simplify() {
-        return this;
+    simplify(opts) {
+        if (this.children.length === 2 &&
+            this.children[0].isNumeric &&
+            !this.children[1].isNumeric) {
+            return this.toReversed().simplify(opts);
+        }
+        return new InequationNode(this.children.map((el) => el.simplify(opts)), this.symbols);
     }
 }
 exports.InequationNode = InequationNode;
+const firstDegreeInequationResolutionTex = (affine, order, right) => {
+    if (!right.isNumeric)
+        throw Error("unimplemented general resolution");
+    const b = affine.b;
+    const a = affine.a;
+    if (a === 1 && b === 0)
+        return new InequationNode([affine.toTree(), right], [order]).toTex();
+    const steps = [[affine.toTex(), order, right.toTex()]];
+    if (b !== 0)
+        steps.push([
+            affine.add(-b).toTex(),
+            order,
+            (0, substractNode_1.substract)(right, b).simplify().toTex(),
+        ]);
+    if (a !== 1) {
+        if (a < 0)
+            order = new inequation_1.InequationSymbol(order).reversed();
+        steps.push([
+            affine.variable,
+            order,
+            (0, fractionNode_1.frac)((0, substractNode_1.substract)(right, b), a).simplify().toTex(),
+        ]);
+    }
+    return (0, alignTex_1.alignTex)(steps);
+};
+exports.firstDegreeInequationResolutionTex = firstDegreeInequationResolutionTex;

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -1,5 +1,5 @@
 import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node";
-import { AlgebraicNode } from "../algebraicNode";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 import { OppositeNode } from "../functions/oppositeNode";
 export declare function isNumberNode(a: Node): a is NumberNode;
 export declare function isNumberOrOppositeNumberNode(a: Node): a is NumberNode | OppositeNode<NumberNode>;
@@ -24,7 +24,7 @@ export declare class NumberNode implements AlgebraicNode {
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(): this;
+    simplify(opts?: SimplifyOptions): NumberNode | import("../operators/fractionNode").FractionNode | OppositeNode<import("../operators/fractionNode").FractionNode>;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): this;
     derivative(varName?: string | undefined): AlgebraicNode;

package/lib/tree/nodes/numbers/numberNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAE,YAAY,EAAkB,MAAM,2BAA2B,CAAC;AACzE,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAE5C;AACD,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAKrC,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;CAGxC"}
+{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,EAAE,YAAY,EAAkB,MAAM,2BAA2B,CAAC;AAEzE,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAE5C;AACD,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAKrC,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;CAGxC"}

package/lib/tree/nodes/numbers/numberNode.js

@@ -5,6 +5,7 @@ const node_1 = require("../node");
 const randint_1 = require("../../../math/utils/random/randint");
 const colorize_1 = require("../../../utils/latex/colorize");
 const oppositeNode_1 = require("../functions/oppositeNode");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
 function isNumberNode(a) {
     return a.type === node_1.NodeType.number;
 }
@@ -59,7 +60,12 @@ class NumberNode {
     evaluate(vars) {
         return this.value;
     }
-    simplify() {
+    simplify(opts) {
+        if (opts?.decimalToFractions) {
+            if (this.value % 1 !== 0) {
+                return new decimal_1.Decimal(this.value).toRational().toTree();
+            }
+        }
         return this;
     }
     equals(node) {

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

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAYlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAmI/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAWlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAmI/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

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

@@ -235,7 +235,7 @@ class AddNode {
             return new numberNode_1.NumberNode(0);
         if (externals.length === 1)
             return externals[0];
-        return (0, operatorComposition_1.operatorComposition)(AddNode, externals);
+        return (0, operatorComposition_1.operatorComposition)(AddNode, externals.sort(addSort));
     }
     toIdentifiers() {
         return {
@@ -260,6 +260,20 @@ class AddNode {
     }
 }
 exports.AddNode = AddNode;
+const addSort = (a, b) => {
+    //! this is super risky,
+    if (a.isNumeric !== b.isNumeric) {
+        return Number(a.isNumeric) - Number(b.isNumeric);
+    }
+    if ((0, monomNode_1.isMonom)(a) && (0, monomNode_1.isMonom)(b)) {
+        const parsedA = (0, monomNode_1.parseToMonomNode)(a);
+        const parsedB = (0, monomNode_1.parseToMonomNode)(b);
+        if (parsedA && parsedB) {
+            return Number(parsedB.degree) - Number(parsedA.degree);
+        }
+    }
+    return 0;
+};
 const addSimplifyFrac = (a, b, opts) => {
     if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a) && (0, fractionNode_1.isFractionNode)(b)) {
         //c/d + e/f   =  cf+ed / df

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,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,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;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAUT,KAAK,IAAI,MAAM;IA2Bf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;IAQtB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,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;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAUT,KAAK,IAAI,MAAM;IA2Bf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqK/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;IAQtB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

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

@@ -11,6 +11,7 @@ const multiplyNode_1 = require("./multiplyNode");
 const rational_1 = require("../../../math/numbers/rationals/rational");
 const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
 const addNode_1 = require("./addNode");
+const powerNode_1 = require("./powerNode");
 function isFractionNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.fraction;
 }
@@ -208,6 +209,13 @@ class FractionNode {
             }
             //!ya mieux à faire pour gérer tous les cas d'un coup
             //!s'insiprer de multiply
+            if ((0, powerNode_1.isPowerNode)(num) &&
+                (0, powerNode_1.isPowerNode)(denum) &&
+                num.rightChild.isNumeric &&
+                denum.rightChild.isNumeric &&
+                num.rightChild.evaluate() === denum.rightChild.evaluate()) {
+                return new powerNode_1.PowerNode(new FractionNode(num.leftChild, denum.leftChild), num.rightChild).simplify(opts);
+            }
             if (num.equals(denum))
                 return new numberNode_1.NumberNode(1);
             return null;