math-exercises 2.2.65 → 2.2.67

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/complex/complex.d.ts

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

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

@@ -28,7 +28,7 @@ export declare class Rational implements Nombre {
     reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): FractionNode | OppositeNode;
+    toTree(opts?: NodeOptions): OppositeNode | FractionNode;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

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

@@ -13,6 +13,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | OppositeNode | MultiplyNode | AddNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode | AddNode | OppositeNode | MultiplyNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

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

@@ -0,0 +1,10 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare class GeneralAffine {
+    a: AlgebraicNode;
+    b: AlgebraicNode;
+    variable: string;
+    constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
+    getRoot(): AlgebraicNode;
+    toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
+}
+//# sourceMappingURL=generalAffine.d.ts.map

package/lib/math/polynomials/generalAffine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAWxB,OAAO,IAAI,aAAa;IAIxB,MAAM;CAKP"}

package/lib/math/polynomials/generalAffine.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneralAffine = void 0;
+const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+class GeneralAffine {
+    constructor(a, b, variable = "x") {
+        if (typeof a === "number")
+            this.a = a.toTree();
+        else
+            this.a = a;
+        if (this.a.evaluate() === 0)
+            throw new Error("Forbidden division by zero");
+        if (typeof b === "number")
+            this.b = b.toTree();
+        else
+            this.b = b;
+        this.variable = variable;
+    }
+    getRoot() {
+        return (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(this.b), this.a).simplify();
+    }
+    toTree() {
+        const monom = (0, multiplyNode_1.multiply)(this.a, this.variable);
+        if (this.b.evaluate() === 0)
+            return monom;
+        return (0, addNode_1.add)(monom, this.b);
+    }
+}
+exports.GeneralAffine = GeneralAffine;

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

@@ -51,7 +51,7 @@ export declare class GeneralTrinom {
     constructor(a: AlgebraicNode | number, b: AlgebraicNode | number, c: AlgebraicNode | number, opts?: GeneralTrinomOptions);
     getDelta(): AlgebraicNode;
     getRoots(): AlgebraicNode[];
-    toTree(): import("../../tree/nodes/operators/multiplyNode").MultiplyNode | import("../../tree/nodes/operators/addNode").AddNode;
+    toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
     toTex(): string;
     getCoeffs(): number[];
     toIdentifiers(): GeneralTrinomIdentifiers;

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

@@ -65,11 +65,11 @@ export declare class Trinom extends Polynomial {
     getRootsNode(): AlgebraicNode[];
     getRootsEquationSolutionTex(): string;
     getAlpha(): number;
-    getAlphaNode(): NumberNode | FractionNode | OppositeNode;
+    getAlphaNode(): NumberNode | OppositeNode | FractionNode;
     getBeta(): number;
-    getBetaNode(): NumberNode | FractionNode | OppositeNode;
+    getBetaNode(): NumberNode | OppositeNode | FractionNode;
     getFactorizedForm(): AlgebraicNode | MultiplyNode;
-    getCanonicalForm(): MultiplyNode | AddNode;
+    getCanonicalForm(): AddNode | MultiplyNode;
     getSommet(): Point;
     getCoords(): number[];
     toPython(): string;

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
+const affineParser_1 = require("./tree/parsers/affineParser");
 const playground = () => {
-    // logIdentifiers();
-    // const parsed = parseLatex("^{^3}");
-    // console.log(parsed.toTex());
+    console.log((0, affineParser_1.affineParser)("8"));
 };
 exports.playground = playground;
 const logIdentifiers = () => {

package/lib/prototypesEnhancement.d.ts

@@ -1,8 +1,10 @@
 import { AlgebraicNode } from "./tree/nodes/algebraicNode";
 import { NodeOptions } from "./tree/nodes/node";
+import { ConstantNode } from "./tree/nodes/numbers/constantNode";
+import { NumberNode } from "./tree/nodes/numbers/numberNode";
 declare global {
     interface Number {
-        toTree: (opts?: NodeOptions) => AlgebraicNode;
+        toTree: (opts?: NodeOptions) => NumberNode | ConstantNode;
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }

package/lib/prototypesEnhancement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAQ,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAStD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;QAC9C,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;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}
+{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAQ,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAKjE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAI7D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,UAAU,GAAG,YAAY,CAAC;QAC1D,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;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}

package/lib/tree/nodes/equations/equalNode.d.ts

@@ -1,6 +1,16 @@
 import { AlgebraicNode } from "../algebraicNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
+import { NodeIdentifiers } from "../nodeConstructor";
 export declare const equal: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => EqualNode;
+export type EqualNodeIdentifiers = {
+    id: NodeIds.equal;
+    leftChild: NodeIdentifiers;
+    rightChild: NodeIdentifiers;
+    opts?: NodeOptions;
+};
+export declare abstract class EqualNodeConstructor {
+    static fromIdentifiers(identifiers: EqualNodeIdentifiers): EqualNode;
+}
 export declare const isEqualNode: (node: Node) => node is EqualNode;
 export declare class EqualNode implements Node {
     leftChild: Node;
@@ -8,19 +18,13 @@ export declare class EqualNode implements Node {
     opts?: NodeOptions;
     type: NodeType;
     constructor(leftChild: Node, rightChild: Node, opts?: NodeOptions);
-    toIdentifiers(): {
-        id: NodeIds;
-        leftChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-        rightChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-    };
+    toIdentifiers(): EqualNodeIdentifiers;
     toEquivalentNodes(opts?: NodeOptions): Node[];
     toAllValidTexs(opts?: NodeOptions): string[];
     toMathString(): string;
     toTex(): string;
     simplify(): this;
+    shuffle(): EqualNode;
+    reverse(): EqualNode;
 }
 //# sourceMappingURL=equalNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,IAAI,sBACL,CAAC;AAElC,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa;;;;;;;;;IAOb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAUT"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAmB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEtE,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,IAAI,sBACL,CAAC;AAElC,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,OAAO;IAIP,OAAO;CAUR"}

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

@@ -1,13 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EqualNode = exports.isEqualNode = exports.equal = void 0;
+exports.EqualNode = exports.isEqualNode = exports.EqualNodeConstructor = exports.equal = void 0;
+// import { equal } from "mathjs";
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const node_1 = require("../node");
+const nodeConstructor_1 = require("../nodeConstructor");
 const equal = (a, b) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
     const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
     return new EqualNode(nodeA, nodeB);
 };
 exports.equal = equal;
+class EqualNodeConstructor {
+    static fromIdentifiers(identifiers) {
+        return new EqualNode(nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.leftChild), nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.rightChild), identifiers.opts);
+    }
+}
+exports.EqualNodeConstructor = EqualNodeConstructor;
 const isEqualNode = (node) => node.type === node_1.NodeType.equality;
 exports.isEqualNode = isEqualNode;
 class EqualNode {
@@ -22,6 +31,7 @@ class EqualNode {
             id: node_1.NodeIds.equal,
             leftChild: this.leftChild.toIdentifiers(),
             rightChild: this.rightChild.toIdentifiers(),
+            opts: this.opts,
         };
     }
     toEquivalentNodes(opts) {
@@ -53,5 +63,11 @@ class EqualNode {
     simplify() {
         return this;
     }
+    shuffle() {
+        return (0, coinFlip_1.coinFlip)() ? this : this.reverse();
+    }
+    reverse() {
+        return new EqualNode(this.rightChild, this.leftChild, this.opts);
+    }
 }
 exports.EqualNode = EqualNode;

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

@@ -18,7 +18,7 @@ export declare class AbsNode implements FunctionNode {
     toTex(): string;
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
-    simplify(): AlgebraicNode | AbsNode;
+    simplify(): AlgebraicNode | import("../numbers/numberNode").NumberNode | import("../numbers/constantNode").ConstantNode | AbsNode;
     evaluate(vars?: Record<string, number>): number;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): AbsNode;

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

@@ -22,7 +22,7 @@ export declare class InequationSolutionNode implements Node {
     };
     toAllTexs(): string[];
     toAllValidTexs(): string[];
-    toEquivalentNodes(opts?: NodeOptions): (InequationSolutionNode | import("./inequationNode").InequationNode)[];
+    toEquivalentNodes(opts?: NodeOptions): (import("./inequationNode").InequationNode | InequationSolutionNode)[];
     toMathString(): string;
     toMathjs(): string;
     toTex(): string;

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;AAQlE,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;IAoQ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAMzD"}
+{"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;AASlE,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;IAoQ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CAMzD"}

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

@@ -14,6 +14,7 @@ const numberNode_1 = require("../numbers/numberNode");
 const multiplyNode_1 = require("./multiplyNode");
 const fractionNode_1 = require("./fractionNode");
 const colorize_1 = require("../../../utils/latex/colorize");
+const round_1 = require("../../../math/utils/round");
 function isAddNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.add;
 }
@@ -203,7 +204,7 @@ class AddNode {
                 return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
             }
             if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
-                return new numberNode_1.NumberNode(a.value + b.value);
+                return new numberNode_1.NumberNode((0, round_1.round)(a.value + b.value, 12));
             }
             if ((0, oppositeNode_1.isOppositeNode)(a) && (0, numberNode_1.isNumberNode)(a.child) && (0, numberNode_1.isNumberNode)(b)) {
                 return new numberNode_1.NumberNode(-a.child.value + b.value);

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

@@ -1,8 +1,14 @@
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+import { NodeIdentifiers } from "../nodeConstructor";
 export declare function isFractionNode(a: Node): a is FractionNode;
 export declare const frac: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => FractionNode;
+export type FractionNodeIdentifiers = {
+    id: NodeIds.fraction;
+    leftChild: NodeIdentifiers;
+    rightChild: NodeIdentifiers;
+};
 export declare class FractionNode implements OperatorNode {
     opts?: NodeOptions;
     /**
@@ -16,18 +22,11 @@ export declare class FractionNode implements OperatorNode {
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
-    toIdentifiers(): {
-        id: NodeIds;
-        leftChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-        rightChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-    };
+    toIdentifiers(): FractionNodeIdentifiers;
     toInversed(): FractionNode;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
+    isDecimal(): boolean;
     toTex(): string;
     evaluate(vars?: Record<string, number>): number;
     simplify(opts?: SimplifyOptions): AlgebraicNode;

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,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,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;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAsBf,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;CAQvB"}
+{"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;IAsBf,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;CAQvB"}

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

@@ -77,6 +77,21 @@ class FractionNode {
     toAllValidTexs(opts) {
         return this.toEquivalentNodes(opts).map((node) => node.toTex());
     }
+    isDecimal() {
+        if (!(0, numberNode_1.isNumberNode)(this.leftChild))
+            return false;
+        if (!(0, numberNode_1.isNumberNode)(this.rightChild))
+            return false;
+        const simp = this.simplify();
+        if ((0, numberNode_1.isNumberNode)(simp))
+            return true;
+        let denum = simp.leftChild.evaluate();
+        while (denum % 2 === 0)
+            denum = denum / 2;
+        while (denum % 5 === 0)
+            denum = denum / 5;
+        return denum === 1;
+    }
     toTex() {
         if (!this.opts?.allowMinusAnywhereInFraction &&
             ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||

package/lib/tree/parsers/affineParser.d.ts

@@ -1,3 +1,2 @@
-import { Affine } from "../../math/polynomials/affine";
-export declare const affineParser: (ans: string, variable?: string) => false | import("../nodes/variables/variableNode").VariableNode | Affine | undefined;
+export declare const affineParser: (ans: string, variable?: string) => false | import("../nodes/algebraicNode").AlgebraicNode | import("../nodes/operators/substractNode").SubstractNode | import("../nodes/operators/addNode").AddNode;
 //# sourceMappingURL=affineParser.d.ts.map

package/lib/tree/parsers/affineParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAOvD,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,wFAiBzD,CAAC"}
+{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAqBzD,CAAC"}

package/lib/tree/parsers/affineParser.js

@@ -1,26 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.affineParser = void 0;
-const affine_1 = require("../../math/polynomials/affine");
-const numberNode_1 = require("../nodes/numbers/numberNode");
-const multiplyNode_1 = require("../nodes/operators/multiplyNode");
-const variableNode_1 = require("../nodes/variables/variableNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
 const latexParser_1 = require("./latexParser");
+const monomParser_1 = require("./monomParser");
 const affineParser = (ans, variable = "x") => {
-    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-    if ((0, variableNode_1.isVariableNode)(parsed)) {
-        if (parsed.name !== variable)
-            return false;
-        return parsed;
-    }
-    //!won't handle Affines à coefficients non entiers
-    if ((0, multiplyNode_1.isMultiplyNode)(parsed)) {
-        if ((0, variableNode_1.isVariableNode)(parsed.rightChild) &&
-            parsed.rightChild.name === variable &&
-            (0, numberNode_1.isNumberNode)(parsed.leftChild)) {
-            return new affine_1.Affine(parsed.leftChild.value, 0, variable);
+    try {
+        const monom = (0, monomParser_1.monomParser)(ans, { variable, maxDegree: 1 });
+        if (monom)
+            return monom;
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if ((0, addNode_1.isAddNode)(parsed) || (0, substractNode_1.isSubstractNode)(parsed)) {
+            const numericChild = parsed.leftChild.isNumeric
+                ? "left"
+                : parsed.rightChild.isNumeric
+                    ? "right"
+                    : undefined;
+            if (!numericChild)
+                return false;
+            const varChild = numericChild === "left" ? parsed.rightChild : parsed.leftChild;
+            return (0, monomParser_1.isMonomNode)(varChild, { variable, maxDegree: 1 }) ? parsed : false;
         }
+        return false;
+    }
+    catch (err) {
+        return false;
     }
-    //"x" ou a*x ou a*x+b ou x+b
 };
 exports.affineParser = affineParser;

package/lib/tree/parsers/latexParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AA8CrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,cAAc,UAAW,MAAM,kBAa3C,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}
+{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAkDrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,cAAc,UAAW,MAAM,kBAa3C,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -26,7 +26,9 @@ const functions = [
 const operators = ["+", "-", "\\div", "\\times", "^"];
 //cmds childless, like \\pi
 const symbols = [{ tex: "\\pi", node: piNode_1.PiNode }];
+//separators between trees
 const separators = ["=", "<", ">", "\\leq", "\\geq"];
+//le nombre de parentheses est il respecté
 const isDyck = (tokens) => {
     const brackets = tokens.filter((el) => el === "(" || el === ")");
     while (brackets.length) {
@@ -47,6 +49,8 @@ const isDyck = (tokens) => {
     }
     return true;
 };
+//?on push les nb, commands, variables, symboles dans un array de token
+//?ex [3 ; +  ; \\pi ; \\frac ; { ; 2 ; x ; } ; { 3 ; x ; }]
 const tokenize = (latex) => {
     const tokens = [];
     for (let i = 0; i < latex.length; i++) {
@@ -136,6 +140,9 @@ const parseLatex = (latex) => {
     }
 };
 exports.parseLatex = parseLatex;
+//? parcours en profondeur dans le sens où profondeur = ouverture d'un sous arbre math
+//? genre dans 3exp(x^2) , x^2 est à la profondeur 2 et ^2 est pronfondeur 3
+//
 const buildTree = (tokens) => {
     let currentDepth = 0;
     let maxDepth = 0;
@@ -152,7 +159,14 @@ const buildTree = (tokens) => {
         if (token === ")" || token === "}")
             currentDepth--;
     }
-    // console.log("depthed: ", depthedTokens);
+    //? on parcours en partant de profondeur max, pour chaque profondeur on build le tree de l'expression
+    //? ce tree remplace les tokens de cette profondeur
+    //? donc 3exp(x^2)
+    //?    -> via tokenize : [3, exp, x, ^, 2]
+    //?    -> to depthed: [{3, 0}, {exp, 0}, {x, 1}, {^, 1}, {2, 2}]
+    //?    -> itération 1 : [{3, 0}, {exp, 0}, {x, 1}, {^, 1}, {NumberNode(2), 1}]
+    //?    -> itération 2 : [{3, 0}, {exp, 0}, {SquareNode(x), 1}]
+    //?    -> itération 3 : Multiply(3, ExpNode(SquareNode(x)))
     while (true) {
         if (maxDepth === 0) {
             const tree = buildTreeForSameDepthTokens(depthedTokens.map((el) => el.token));
@@ -160,30 +174,33 @@ const buildTree = (tokens) => {
         }
         for (let i = 0; i < depthedTokens.length; i++) {
             const token = depthedTokens[i];
+            //? on commence par les tokens de depth max
             if (token.depth < maxDepth)
                 continue;
-            //le token est forcément ici ( ou {
-            //et on est sur qu'il n'y a aucun autre nestage à l'intérieur
+            //? le token est forcément ici ( ou {
+            //? et on est sur qu'il n'y a aucun autre nestage à l'intérieur
             const endIndex = depthedTokens.findIndex((el, index) => index > i && (el.token === ")" || el.token === "}"));
             const tree = buildTreeForSameDepthTokens(depthedTokens.slice(i + 1, endIndex).map((el) => el.token));
             depthedTokens.splice(i, endIndex - i + 1, {
                 token: tree,
                 depth: token.depth - 1,
             });
-            // console.log(`depthed after iter ${i}`, depthedTokens);
         }
         maxDepth--;
     }
 };
 const buildTreeForSameDepthTokens = (tokens) => {
-    // console.log("start: ", tokens);
+    //? à ce stade les tokens sont soit des charactères soit des nodes déjà build (par buildTree)
+    //? ici on n'est dans une profondeur unique
     let tempTokens = [];
     for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
+        //?buildTree a déjà pu build des expressions de profondeur plus grande
         if (typeof token !== "string") {
             tempTokens[i] = token;
             continue;
         }
+        //? les nombres, variables et symboles (pi) sont direct push en node
         if (token[0].match(/[0-9]/)) {
             tempTokens[i] = new numberNode_1.NumberNode(Number(token));
         }
@@ -203,8 +220,7 @@ const buildTreeForSameDepthTokens = (tokens) => {
         else
             throw Error(`token not implemented: ${token}`);
     }
-    // console.log("after parses : ", tempTokens);
-    //1 build les fct
+    //?1 build les fct
     for (let i = 0; i < tempTokens.length; i++) {
         if (typeof tempTokens[i] !== "string")
             continue;
@@ -223,7 +239,6 @@ const buildTreeForSameDepthTokens = (tokens) => {
             }
         }
         if (token === "^") {
-            console.log(tempTokens[i - 1]);
             if (!tempTokens[i - 1] ||
                 typeof tempTokens[i - 1] === "string" ||
                 !tempTokens[i + 1] ||
@@ -312,7 +327,17 @@ const buildTreeForSameDepthTokens = (tokens) => {
         const token = tempTokens[i];
         if (!currentAdd) {
             if (typeof token === "string") {
-                if (token === "+" || token === "-") {
+                //ici on accepte +3 (mais seulement en début de tree)
+                //donc +3 + X est ok
+                //mais pas x \\times +3
+                if (token === "+" &&
+                    !!tempTokens[i + 1] &&
+                    typeof tempTokens[i + 1] !== "string" &&
+                    (0, numberNode_1.isNumberNode)(tempTokens[i + 1])) {
+                    currentAdd = tempTokens[i + 1];
+                    i++;
+                }
+                else if (token === "+" || token === "-") {
                     throw Error("Addition with no first term");
                 }
                 else

package/lib/tree/parsers/monomParser.d.ts

@@ -1,2 +1,10 @@
-export declare const monomParser: (str: string) => void;
+import { AlgebraicNode } from "../nodes/algebraicNode";
+type Opts = {
+    variable: string;
+    maxDegree?: number;
+    minDegree?: number;
+};
+export declare const monomParser: (str: string, { variable, maxDegree, minDegree }?: Opts) => false | AlgebraicNode;
+export declare const isMonomNode: (node: AlgebraicNode, { variable, maxDegree, minDegree }?: Opts) => boolean;
+export {};
 //# sourceMappingURL=monomParser.d.ts.map

package/lib/tree/parsers/monomParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,QAAS,MAAM,SAAO,CAAC"}
+{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQvD,KAAK,IAAI,GAAG;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,eAAO,MAAM,WAAW,QACjB,MAAM,uCACyB,IAAI,0BAkBzC,CAAC;AAEF,eAAO,MAAM,WAAW,SAChB,aAAa,uCACiB,IAAI,YAsCzC,CAAC"}