math-exercises 2.2.4 → 2.2.5

package/lib/index.d.ts

@@ -5,6 +5,9 @@ declare global {
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }
+    interface String {
+        toTree: () => AlgebraicNode;
+    }
 }
 /**
  * TODO
@@ -142,6 +145,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     nb: string;
     rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -235,6 +241,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     affinesCoeffs: number[][];
     operation: string;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    bOperand: number;
 }> | import("./exercises/exercise").Exercise<{
     b: number;
     c: number;
@@ -254,38 +266,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     c: number;
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
     d: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
@@ -692,6 +672,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     quadrinomial: number[];
     leftbound: number;
     rightbound: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    type: number;
+}> | import("./exercises/exercise").Exercise<{
+    coeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     k: number;
@@ -1209,6 +1195,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rank2: number;
     reason: number;
     value1: number;
+}> | import("./exercises/exercise").Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     firstValue: number;
     reason: number;
@@ -1267,43 +1259,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     type: number;
     nb: string;
 }> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+    z: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     sqrtOperand: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{
     type: number;
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
     a: number;
     x: number;
     b: number | undefined;

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/index.js

@@ -30,6 +30,10 @@ const MathExercises = __importStar(require("./exercises/math"));
 const PCExercises = __importStar(require("./exercises/pc"));
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
+String.prototype.toTree = function () {
+    return new variableNode_1.VariableNode(this.valueOf());
+};
 Number.prototype.toTree = function () {
     const value = this.valueOf();
     if (value === Infinity)

package/lib/math/geometry/spacePoint.d.ts

@@ -0,0 +1,27 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+type AleaBound = {
+    min?: number;
+    max?: number;
+    excludes?: number[];
+};
+export declare abstract class SpacePointConstructor {
+    static random(name: string, xOpts?: AleaBound, yOpts?: AleaBound, zOpts?: AleaBound): SpacePoint;
+    static randomDifferent(names: string[]): SpacePoint[];
+}
+export declare class SpacePoint {
+    name: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    z: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toTex(): string;
+    toTexWithCoords(): string;
+    toCoords(): string;
+    midpoint(B: SpacePoint, name?: string): SpacePoint;
+    distanceTo(B: SpacePoint): number;
+    equals(B: SpacePoint): boolean;
+    isAligned(B: SpacePoint, C: SpacePoint): void;
+    toGGBCommand(): string;
+}
+export {};
+//# sourceMappingURL=spacePoint.d.ts.map

package/lib/math/geometry/spacePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CA4BvC;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY;CAKb"}

package/lib/math/geometry/spacePoint.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacePoint = exports.SpacePointConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const randint_1 = require("../utils/random/randint");
+class SpacePointConstructor {
+    static random(name, xOpts, yOpts, zOpts) {
+        const x = (0, randint_1.randint)(xOpts?.min ?? -9, xOpts?.max ?? 10, xOpts?.excludes ?? []);
+        const y = (0, randint_1.randint)(yOpts?.min ?? -9, yOpts?.max ?? 10, yOpts?.excludes ?? []);
+        const z = (0, randint_1.randint)(zOpts?.min ?? -9, zOpts?.max ?? 10, zOpts?.excludes ?? []);
+        return new SpacePoint(name, new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y), new numberNode_1.NumberNode(z));
+    }
+    static randomDifferent(names) {
+        const res = [];
+        const points = [];
+        for (let i = 0; i < names.length; i++) {
+            let x;
+            let y;
+            let z;
+            do {
+                x = (0, randint_1.randint)(-10, 11);
+                y = (0, randint_1.randint)(-10, 11);
+                z = (0, randint_1.randint)(-10, 11);
+            } while (points.some((point) => point[0] === x && point[1] === y && point[2] === z));
+            points.push([x, y, z]);
+            res.push(new SpacePoint(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y), new numberNode_1.NumberNode(z)));
+        }
+        return res;
+    }
+}
+exports.SpacePointConstructor = SpacePointConstructor;
+class SpacePoint {
+    constructor(name, x, y, z) {
+        this.name = name;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toTexWithCoords() {
+        return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()};${this.z.toTex()}\\right)`;
+    }
+    toCoords() {
+        return `\\left(${this.x.toTex()};${this.y.toTex()};${this.z.toTex()}\\right)`;
+    }
+    midpoint(B, name = "I") {
+        // const types = [this.x.type, this.y.type, B.x.type, B.y.type];
+        // if (types.some((type) => type !== NodeType.number)) {
+        //   throw Error("general midpoint not implemented yet");
+        // }
+        // return new Point(
+        //   name,
+        //   new Rational((this.x as NumberNode).value + (B.x as NumberNode).value, 2)
+        //     .simplify()
+        //     .toTree(),
+        //   new Rational((this.y as NumberNode).value + (B.y as NumberNode).value, 2)
+        //     .simplify()
+        //     .toTree(),
+        // );
+        throw Error("unimplemented");
+    }
+    distanceTo(B) {
+        throw Error("unimplemented");
+    }
+    equals(B) {
+        return this.x.equals(B.x) && this.y.equals(B.y) && this.z.equals(B.z);
+    }
+    isAligned(B, C) {
+        // const AB = VectorConstructor.fromPoints(this, B);
+        // const AC = VectorConstructor.fromPoints(this, C);
+        // return AB.isColinear(AC);
+        throw Error("unimplemented");
+    }
+    toGGBCommand() {
+        return `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()}, ${this.z.toMathString()}})`;
+    }
+}
+exports.SpacePoint = SpacePoint;

package/lib/math/geometry/spaceVector.d.ts

@@ -0,0 +1,28 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { Node } from "../../tree/nodes/node";
+import { SpacePoint } from "./spacePoint";
+export declare abstract class SpaceVectorConstructor {
+    static fromPoints(origin: SpacePoint, end: SpacePoint): SpaceVector;
+    static random(name: string, allowNull?: boolean): SpaceVector;
+    static randomDifferents(names: string[], allowNull?: boolean): SpaceVector[];
+}
+export declare class SpaceVector {
+    name: string;
+    tex: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    z: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toTex(): string;
+    toInlineCoordsTex(): string;
+    toTexWithCoords(): string;
+    isColinear(v: SpaceVector): boolean;
+    determinant(v: SpaceVector): AlgebraicNode;
+    times(k: AlgebraicNode, name?: string): SpaceVector;
+    scalarProduct(v: SpaceVector): Node;
+    add(v: SpaceVector): SpaceVector;
+    getNorm(): AlgebraicNode;
+    getEndPoint(startPoint: SpacePoint, name?: string): SpacePoint;
+    equals(v: SpaceVector): boolean;
+}
+//# sourceMappingURL=spaceVector.d.ts.map

package/lib/math/geometry/spaceVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}

package/lib/math/geometry/spaceVector.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceVector = exports.SpaceVectorConstructor = void 0;
+const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+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 substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const randint_1 = require("../utils/random/randint");
+const spacePoint_1 = require("./spacePoint");
+class SpaceVectorConstructor {
+    static fromPoints(origin, end) {
+        return new SpaceVector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x).simplify(), new substractNode_1.SubstractNode(end.y, origin.y).simplify(), new substractNode_1.SubstractNode(end.z, origin.z).simplify());
+    }
+    static random(name, allowNull = true) {
+        let x;
+        let y;
+        let z;
+        do {
+            x = (0, randint_1.randint)(-10, 11);
+            y = (0, randint_1.randint)(-10, 11);
+            z = (0, randint_1.randint)(-10, 11);
+        } while (!allowNull && x === 0 && y === 0 && z === 0);
+        return new SpaceVector(name, x.toTree(), y.toTree(), z.toTree());
+    }
+    static randomDifferents(names, allowNull = true) {
+        const res = [];
+        for (let i = 0; i < names.length; i++) {
+            let vec;
+            do {
+                vec = SpaceVectorConstructor.random(names[i], allowNull);
+            } while (res.some((v) => v.equals(vec)));
+            res.push(vec);
+        }
+        return res;
+    }
+}
+exports.SpaceVectorConstructor = SpaceVectorConstructor;
+class SpaceVector {
+    constructor(name, x, y, z) {
+        this.name = name;
+        this.tex = `\\overrightarrow{${name}}`;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    toTex() {
+        return `\\overrightarrow{${this.name}}`;
+    }
+    toInlineCoordsTex() {
+        return `\\left(${this.x.simplify().toTex()};${this.y
+            .simplify()
+            .toTex()};${this.z.simplify().toTex()}\\right)`;
+    }
+    toTexWithCoords() {
+        return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\\\ ${this.z.toTex()} \\end{pmatrix}`;
+    }
+    isColinear(v) {
+        throw Error("unimplemented");
+    }
+    determinant(v) {
+        throw Error("unimplemented");
+    }
+    times(k, name) {
+        return new SpaceVector(name ?? "v", new multiplyNode_1.MultiplyNode(this.x, k).simplify(), new multiplyNode_1.MultiplyNode(this.y, k).simplify(), new multiplyNode_1.MultiplyNode(this.z, k).simplify());
+    }
+    scalarProduct(v) {
+        throw Error("unimplemented");
+    }
+    add(v) {
+        return new SpaceVector(`${this.name}+${v.name}`, new addNode_1.AddNode(this.x, v.x).simplify(), new addNode_1.AddNode(this.y, v.y).simplify(), new addNode_1.AddNode(this.z, v.z).simplify());
+    }
+    getNorm() {
+        return new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.SquareNode(this.x), new addNode_1.AddNode(new powerNode_1.SquareNode(this.y), new powerNode_1.SquareNode(this.z)))).simplify();
+    }
+    getEndPoint(startPoint, name) {
+        return new spacePoint_1.SpacePoint(name ?? "B", new addNode_1.AddNode(startPoint.x, this.x).simplify(), new addNode_1.AddNode(startPoint.y, this.y).simplify(), new addNode_1.AddNode(startPoint.z, this.z).simplify());
+    }
+    equals(v) {
+        return this.x.equals(v.x) && this.y.equals(v.y) && this.z.equals(v.z);
+    }
+}
+exports.SpaceVector = SpaceVector;

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

@@ -28,6 +28,7 @@ export declare class Decimal implements Nombre {
     multiplyByPowerOfTen(power: number): Decimal;
     toScientificPart(): number;
     toScientificNotation(decimals?: number): NumberNode | MultiplyNode;
+    getDigitAtRank(rank: number): number;
     toRational(): Rational | import("../integer/integer").Integer;
     toTree(): NumberNode;
     toPercentNode(): PercentNode;

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":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,UAAU;IAMV,MAAM;IAIN,aAAa;CAGd"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU;IAMV,MAAM;IAIN,aAAa;CAGd"}

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

@@ -154,6 +154,14 @@ 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)));
     }
+    getDigitAtRank(rank) {
+        if (rank >= 0) {
+            return Number(this.intPart.toString()[this.intPart.toString().length - 1 - rank]);
+        }
+        else {
+            return Number(this.decimalPart[-rank - 1]);
+        }
+    }
     toRational() {
         return new rational_1.Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision).simplify();
     }

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

@@ -23,6 +23,7 @@ export declare class Rational implements Nombre {
     toTex(): string;
     add(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;
+    reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
     toTree(opts?: NodeOptions): FractionNode | OppositeNode;

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":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAIvE,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,0BAA0B,CAAC,GAAG,GAAE,MAAW;CAQnD;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,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;CAS/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAIvE,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,0BAA0B,CAAC,GAAG,GAAE,MAAW;CAQnD;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;CAS/B"}

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

@@ -96,6 +96,10 @@ class Rational {
         }
         throw Error("not implemented yet");
     }
+    reverse(shouldSimplify) {
+        const frac = new Rational(this.denum, this.num);
+        return shouldSimplify ? frac.simplify() : frac;
+    }
     divide(nb) {
         switch (nb.type) {
             case nombre_1.NumberType.Integer: {

package/lib/playground.d.ts

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

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playground = void 0;
+const affine_1 = require("./math/polynomials/affine");
+const addNode_1 = require("./tree/nodes/operators/addNode");
+const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
+const random_1 = require("./utils/random");
+const shuffle_1 = require("./utils/shuffle");
+const playground = () => {
+    const affines = affine_1.AffineConstructor.differentRandoms(3);
+    const permut = [
+        (0, shuffle_1.shuffle)([affines[0], affines[1]]),
+        (0, shuffle_1.shuffle)([affines[0], affines[2]]),
+    ];
+    const operation = (0, random_1.random)(["add", "substract"]);
+    const statementTree = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()));
+    console.log(statementTree.simplify().toTex());
+};
+exports.playground = playground;

package/lib/server.d.ts

@@ -5,5 +5,8 @@ declare global {
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }
+    interface String {
+        toTree: () => AlgebraicNode;
+    }
 }
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAkC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAuC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF"}

package/lib/server.js

@@ -36,10 +36,14 @@ const cors_1 = __importDefault(require("cors"));
 const numberNode_1 = require("./tree/nodes/numbers/numberNode");
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
 const jsonParser = body_parser_1.default.json();
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
 const allExercises = [...mathExercises, ...pcExercises];
+String.prototype.toTree = function () {
+    return new variableNode_1.VariableNode(this.valueOf());
+};
 Number.prototype.toTree = function () {
     const value = this.valueOf();
     if (value === Infinity)
@@ -59,7 +63,9 @@ const runServer = () => {
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
     console.log("math exos", mathExercises.length);
+    console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
     console.log("pc exos", pcExercises.length);
+    // playground();
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/lib/tree/nodes/equations/equationSolutionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,2BAA2B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC7E,qBAAa,oBAAqB,YAAW,IAAI;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,YAAY,EAAE,eAAe,EAC7B,MAAM,CAAC,EAAE,2BAA2B;IActC,cAAc;IAId,SAAS;IAUT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}
+{"version":3,"file":"equationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,2BAA2B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC7E,qBAAa,oBAAqB,YAAW,IAAI;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,YAAY,EAAE,eAAe,EAC7B,MAAM,CAAC,EAAE,2BAA2B;IActC,cAAc;IAId,SAAS;IAiBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}

package/lib/tree/nodes/equations/equationSolutionNode.js

@@ -25,6 +25,14 @@ class EquationSolutionNode {
             if (this.opts?.allowRawRightChildAsSolution)
                 res.push(solTex);
         }
+        else {
+            const solTex = this.solutionsSet.elements.map((e) => e.toTex());
+            res.push(solTex.map((e) => `${this.variable}=${e}`).join("\\text{ ou }"));
+            if (this.opts?.allowRawRightChildAsSolution) {
+                res.push(solTex.join(";"));
+                res.push(solTex.join("\\text{ ou }"));
+            }
+        }
         return res;
     }
     toEquivalentNodes(opts) {

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

@@ -29,6 +29,7 @@ export type ToTexOptions = {
     scientific?: number;
     hideUnit?: boolean;
     notScientific?: boolean;
+    forceNoSimplification?: boolean;
 };
 export interface Node {
     type: NodeType;

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

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAIA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,GAAG,IAAA;IACH,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,KAAA;IACP,MAAM,KAAA;CACP;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC;CAGxC;AAED,eAAO,MAAM,eAAe,MAAO,IAAI,KAAG,OAMzC,CAAC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAIA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,GAAG,IAAA;IACH,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,KAAA;IACP,MAAM,KAAA;CACP;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AACF,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC;CAGxC;AAED,eAAO,MAAM,eAAe,MAAO,IAAI,KAAG,OAMzC,CAAC"}

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,YAAY,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,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,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA2DlC,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,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqH/C,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,YAAY,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,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,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA4DlC,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,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA0H/C,MAAM,CAAC,IAAI,EAAE,aAAa;CAU3B"}

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

@@ -52,7 +52,8 @@ class MultiplyNode {
     toTex(opts) {
         let leftTex = this.leftChild.toTex(opts);
         let rightTex = this.rightChild.toTex(opts);
-        if ((0, numberNode_1.isNumberNode)(this.leftChild) &&
+        if (!opts?.forceNoSimplification &&
+            (0, numberNode_1.isNumberNode)(this.leftChild) &&
             this.leftChild.value === 1 &&
             opts?.scientific === undefined) {
             return rightTex;
@@ -68,7 +69,7 @@ class MultiplyNode {
         }
         if (needBrackets)
             rightTex = `\\left(${rightTex}\\right)`;
-        if (leftTex === "-1") {
+        if (leftTex === "-1" && !opts?.forceNoSimplification) {
             // if (!isNumberNode(this.rightChild)) {
             return "-" + rightTex;
             // }
@@ -271,6 +272,11 @@ class MultiplyNode {
                 return new fractionNode_1.FractionNode(numNode, denumNode).simplify(opts);
             }
         const simplifyExternalNodes = (a, b) => {
+            if ((0, variableNode_1.isVariableNode)(a) && (0, variableNode_1.isVariableNode)(b)) {
+                if (a.name === b.name) {
+                    return new powerNode_1.SquareNode(a);
+                }
+            }
             if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
                 return new numberNode_1.NumberNode((0, round_1.round)(a.value * b.value, 12));
             }

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

@@ -171,7 +171,7 @@ class PowerNode {
             return new PowerNode(leftSimplified.leftChild, new multiplyNode_1.MultiplyNode(rightSimplified, leftSimplified.rightChild).simplify(opts)).simplify(opts);
         }
         if ((0, multiplyNode_1.isMultiplyNode)(leftSimplified)) {
-            return new multiplyNode_1.MultiplyNode(new PowerNode(leftSimplified.leftChild, rightSimplified), new PowerNode(leftSimplified.rightChild, rightSimplified));
+            return new multiplyNode_1.MultiplyNode(new PowerNode(leftSimplified.leftChild, rightSimplified), new PowerNode(leftSimplified.rightChild, rightSimplified)).simplify(opts);
         }
         if (!opts?.keepPowers &&
             (0, numberNode_1.isNumberNode)(copy.rightChild) &&

package/lib/utils/alignTex.d.ts

@@ -0,0 +1,2 @@
+export declare function alignTex(arr: string[][] | string): string;
+//# sourceMappingURL=alignTex.d.ts.map

package/lib/utils/alignTex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignTex.d.ts","sourceRoot":"","sources":["../../src/utils/alignTex.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,UAehD"}