math-exercises 2.0.0 → 2.0.2

package/lib/tree/nodes/complex/complexNode.js

@@ -3,65 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComplexNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
-const complex_1 = require("../../../math/complex/complex");
-const numberNode_1 = require("../numbers/numberNode");
 const variableNode_1 = require("../variables/variableNode");
-const oppositeNode_1 = require("../functions/oppositeNode");
 const multiplyNode_1 = require("../operators/multiplyNode");
 const addNode_1 = require("../operators/addNode");
 class ComplexNode {
-    constructor(re, im, tex, mathString) {
+    constructor(re, im, opts) {
         this.type = node_1.NodeType.number;
         this.re = re;
         this.im = im;
-        const reTex = re === 0 ? '' : re.toString();
-        const imTex = im === 0
-            ? ''
-            : im === 1
-                ? re === 0
-                    ? 'i'
-                    : '+i'
-                : im === -1
-                    ? '-i'
-                    : im > 0
-                        ? re === 0
-                            ? `${im}i`
-                            : `+${im}i`
-                        : `${im}i`;
-        const formatedTex = re === 0 && im === 0 ? '0' : `${reTex}${imTex}`;
-        this.tex = tex || formatedTex;
-        this.mathString = mathString || this.tex;
+        this.opts = opts;
     }
-    toEquivalentNodes() {
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
         const res = [];
-        if (this.im === 0) {
-            return [new numberNode_1.NumberNode(this.re)];
+        if (this.im.toTex() === "0") {
+            return this.re.toEquivalentNodes(options);
         }
-        if (this.re === 0) {
-            if (this.im === 1) {
-                return [new variableNode_1.VariableNode('i')];
-            }
-            if (this.im === -1) {
-                return [new oppositeNode_1.OppositeNode(new variableNode_1.VariableNode('i'))];
-            }
-            return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.im), new variableNode_1.VariableNode('i')).toEquivalentNodes();
+        if (this.re.toTex() === "0") {
+            return new multiplyNode_1.MultiplyNode(this.im, new variableNode_1.VariableNode("i")).toEquivalentNodes(options);
         }
-        return new addNode_1.AddNode(new numberNode_1.NumberNode(this.re), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.im), new variableNode_1.VariableNode('i'))).toEquivalentNodes();
+        return new addNode_1.AddNode(this.re, new multiplyNode_1.MultiplyNode(this.im, new variableNode_1.VariableNode("i"))).toEquivalentNodes(options);
     }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
+    toAllValidTexs(opts) {
+        const options = opts ?? this.opts;
+        return this.toEquivalentNodes(options).map((node) => node.toTex());
     }
     toMathString() {
-        return `${this.mathString ? this.mathString : this.tex}`;
+        return this.toTex();
     }
     toTex() {
-        return `${this.tex}`;
+        if (this.im.toTex() === "0")
+            return this.re.toTex();
+        if (this.re.toTex() === "0") {
+            return new multiplyNode_1.MultiplyNode(this.im, new variableNode_1.VariableNode("i")).toTex();
+        }
+        return new addNode_1.AddNode(this.re, new multiplyNode_1.MultiplyNode(this.im, new variableNode_1.VariableNode("i"))).toTex();
     }
     toMathjs() {
-        return (0, mathjs_1.complex)(this.re, this.im);
-    }
-    toComplex() {
-        return new complex_1.Complex(this.re, this.im);
+        return (0, mathjs_1.complex)((0, mathjs_1.evaluate)(this.re.toMathjs()), (0, mathjs_1.evaluate)(this.im.toMathjs()));
     }
 }
 exports.ComplexNode = ComplexNode;

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

@@ -0,0 +1,14 @@
+import { Node, NodeOptions, NodeType } from "../node";
+export declare class EqualNode implements Node {
+    leftChild: Node;
+    rightChild: Node;
+    opts?: NodeOptions;
+    type: NodeType;
+    constructor(leftChild: Node, rightChild: Node, opts?: NodeOptions);
+    toEquivalentNodes(): Node[];
+    toAllValidTexs(): string[];
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): boolean | import("mathjs").MathCollection;
+}
+//# sourceMappingURL=equalNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,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,iBAAiB;IAiBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EqualNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+class EqualNode {
+    constructor(leftChild, rightChild, opts) {
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.equality;
+        this.opts = opts;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        if (this.opts?.allowRawRightChildAsSolution) {
+            res.push(...rightNodes);
+        }
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new EqualNode(leftNode, rightNode));
+                res.push(new EqualNode(rightNode, leftNode));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
+    }
+    toTex() {
+        return `${this.leftChild.toTex()}=${this.rightChild.toTex()}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.equal)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.EqualNode = EqualNode;

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

@@ -0,0 +1,21 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { DiscreteSetNode } from "../sets/discreteSetNode";
+type EquationSolutionNodeOptions = {
+    variable?: string;
+    opts?: NodeOptions;
+};
+export declare class EquationSolutionNode implements Node {
+    type: NodeType;
+    variable: string;
+    solutionsSet: DiscreteSetNode;
+    opts?: NodeOptions;
+    constructor(solutionsSet: DiscreteSetNode, params?: EquationSolutionNodeOptions);
+    toAllValidTexs(): string[];
+    toAllTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): EquationSolutionNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+export {};
+//# sourceMappingURL=equationSolutionNode.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EquationSolutionNode = void 0;
+const node_1 = require("../node");
+class EquationSolutionNode {
+    constructor(solutionsSet, params) {
+        this.type = node_1.NodeType.set;
+        this.solutionsSet = solutionsSet;
+        this.variable = params?.variable ?? "x";
+        this.opts = params?.opts
+            ? {
+                ...params.opts,
+                allowRawRightChildAsSolution: params.opts.allowRawRightChildAsSolution ?? true,
+            }
+            : { allowRawRightChildAsSolution: true };
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).flatMap((el) => el.toAllTexs());
+    }
+    toAllTexs() {
+        const res = [this.toTex(), this.solutionsSet.toTex()];
+        if (this.solutionsSet.elements.length === 1) {
+            const solTex = this.solutionsSet.elements[0].toTex();
+            res.push(`${this.variable}=${solTex}`);
+            if (this.opts?.allowRawRightChildAsSolution)
+                res.push(solTex);
+        }
+        return res;
+    }
+    toEquivalentNodes(opts) {
+        const equivs = this.solutionsSet.toEquivalentNodes(opts ?? this.opts);
+        return equivs.map((equiv) => new EquationSolutionNode(equiv, { variable: this.variable, opts }));
+    }
+    toMathString() {
+        return "";
+    }
+    toMathjs() {
+        return `S={${this.solutionsSet.toMathjs()}}`;
+    }
+    toTex() {
+        return `S=${this.solutionsSet.toTex()}`;
+    }
+}
+exports.EquationSolutionNode = EquationSolutionNode;

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

@@ -0,0 +1,14 @@
+import { Node, NodeOptions, NodeType } from "../node";
+export declare class MultiEqualNode implements Node {
+    children: Node[];
+    opts?: NodeOptions;
+    type: NodeType;
+    constructor(children: Node[], opts?: NodeOptions);
+    toEquivalentNodes(): MultiEqualNode[];
+    toAllTexs(): string[];
+    toAllValidTexs(): string[];
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): string;
+}
+//# sourceMappingURL=multiEqualNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"multiEqualNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/multiEqualNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAItD,qBAAa,cAAe,YAAW,IAAI;IACzC,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAMhD,iBAAiB;IAUjB,SAAS;IAMT,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiEqualNode = void 0;
+const node_1 = require("../node");
+const permutations_1 = require("../../../utils/permutations");
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+class MultiEqualNode {
+    constructor(children, opts) {
+        this.children = children;
+        this.type = node_1.NodeType.equality;
+        this.opts = opts;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const equivs = this.children.map((node) => node.toEquivalentNodes());
+        const cartesians = (0, cartesianProducts_1.getCartesiansProducts)(equivs);
+        cartesians.forEach((product) => {
+            res.push(new MultiEqualNode(product));
+        });
+        return res;
+    }
+    toAllTexs() {
+        const permutations = (0, permutations_1.permute)(this.children);
+        return permutations.flatMap((permutation) => `${permutation.map((node) => node.toTex()).join("=")}`);
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().flatMap((node) => node.toAllTexs());
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toTex() {
+        return `${this.children.map((node) => node.toTex()).join("=")}`;
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+}
+exports.MultiEqualNode = MultiEqualNode;

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

@@ -0,0 +1,17 @@
+import { Node, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isAbsNode(a: Node): a is AbsNode;
+export declare class AbsNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
+    type: NodeType;
+    constructor(child: AlgebraicNode);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): number;
+    toEquivalentNodes(): Node[];
+    toAllValidTexs(): string[];
+    simplify(): Node;
+}
+//# sourceMappingURL=absNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;gBAEH,KAAK,EAAE,aAAa;IAMhC,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,IAAI;CAGjB"}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbsNode = exports.isAbsNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+const functionNode_1 = require("./functionNode");
+function isAbsNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.abs;
+}
+exports.isAbsNode = isAbsNode;
+class AbsNode {
+    constructor(child) {
+        this.id = functionNode_1.FunctionsIds.abs;
+        this.child = child;
+        this.type = node_1.NodeType.function;
+    }
+    toMathString() {
+        return `abs(${this.child.toMathString()})`;
+    }
+    toTex() {
+        return `\\left|${this.child.toTex()}\\right|`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.abs)(this.child.toMathjs());
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const childNodes = this.child.toEquivalentNodes();
+        childNodes.forEach((childNode) => {
+            res.push(new AbsNode(childNode));
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    simplify() {
+        return this;
+    }
+}
+exports.AbsNode = AbsNode;

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

@@ -1,8 +1,12 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class CosNode extends FunctionNode implements Node {
+import { Node, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isCosNode(a: Node): a is CosNode;
+export declare class CosNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node);
+    constructor(child: AlgebraicNode);
     toMathString(): string;
     toEquivalentNodes(): Node[];
     toAllValidTexs(): string[];

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

@@ -1 +1 @@
-{"version":3,"file":"cosNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/cosNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,qBAAa,OAAQ,SAAQ,YAAa,YAAW,IAAI;IACvD,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,KAAK,EAAE,IAAI;IAIvB,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,QAAQ,IAAI,IAAI;CAGjB"}
+{"version":3,"file":"cosNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/cosNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;gBAEH,KAAK,EAAE,aAAa;IAMhC,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,QAAQ,IAAI,IAAI;CAGjB"}

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

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CosNode = void 0;
+exports.CosNode = exports.isCosNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class CosNode extends functionNode_1.FunctionNode {
+function isCosNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.cos;
+}
+exports.isCosNode = isCosNode;
+class CosNode {
     constructor(child) {
-        super(functionNode_1.FunctionsIds.cos, child, '\\cos');
+        this.id = functionNode_1.FunctionsIds.opposite;
+        this.child = child;
         this.type = node_1.NodeType.function;
     }
     toMathString() {

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

@@ -1,12 +1,13 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-type ExpNodeOptions = {
-    useExpNotation: boolean;
-};
-export declare class ExpNode extends FunctionNode implements Node {
-    opts?: ExpNodeOptions;
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isExpNode(a: Node): a is ExpNode;
+export declare class ExpNode implements FunctionNode {
+    opts?: NodeOptions;
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node, opts?: ExpNodeOptions);
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
     toMathjs(): number;
@@ -14,5 +15,4 @@ export declare class ExpNode extends FunctionNode implements Node {
     toAllValidTexs(): string[];
     simplify(): Node;
 }
-export {};
 //# sourceMappingURL=expNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"expNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/expNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,KAAK,cAAc,GAAG;IACpB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,qBAAa,OAAQ,SAAQ,YAAa,YAAW,IAAI;IACvD,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,cAAc;IAK9C,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IASf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAU3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,IAAI,IAAI;CAGjB"}
+{"version":3,"file":"expNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/expNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;gBACH,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAYf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAU3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,IAAI,IAAI;CAGjB"}

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

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpNode = void 0;
+exports.ExpNode = exports.isExpNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class ExpNode extends functionNode_1.FunctionNode {
+function isExpNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.exp;
+}
+exports.isExpNode = isExpNode;
+class ExpNode {
     constructor(child, opts) {
-        super(functionNode_1.FunctionsIds.exp, child, '\\exp');
+        this.id = functionNode_1.FunctionsIds.exp;
+        this.child = child;
         this.type = node_1.NodeType.function;
         this.opts = opts;
     }
@@ -15,12 +20,15 @@ class ExpNode extends functionNode_1.FunctionNode {
     }
     toTex() {
         const tex = this.child.toTex();
+        if (!this.opts?.allowPowerOne && tex === "1") {
+            return "e";
+        }
         if (this.opts?.useExpNotation) {
-            return `exp\\left(${this.child.toTex}\\right)`;
+            return `\\exp\\left(${tex}\\right)`;
         }
         const needBraces = tex.length > 1;
         if (needBraces)
-            return `e^{${this.child.toTex()}}`;
+            return `e^{${tex}}`;
         return `e^${tex}`;
     }
     toMathjs() {

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

@@ -1,17 +1,17 @@
-import { Node, NodeType } from '../node';
+import { AlgebraicNode } from "../algebraicNode";
+import { Node } from "../node";
+export declare function isFunctionNode(a: Node): a is FunctionNode;
 export declare enum FunctionsIds {
     opposite = 0,
     sqrt = 1,
     cos = 2,
     sin = 3,
     log = 4,
-    exp = 5
+    exp = 5,
+    abs = 6
 }
-export declare abstract class FunctionNode {
+export interface FunctionNode extends AlgebraicNode {
     id: FunctionsIds;
-    child: Node;
-    type: NodeType;
-    tex: string;
-    constructor(id: FunctionsIds, child: Node, tex: string);
+    child: AlgebraicNode;
 }
 //# sourceMappingURL=functionNode.d.ts.map

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

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

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

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionNode = exports.FunctionsIds = void 0;
+exports.FunctionsIds = exports.isFunctionNode = void 0;
 const node_1 = require("../node");
+function isFunctionNode(a) {
+    return a.type === node_1.NodeType.function;
+}
+exports.isFunctionNode = isFunctionNode;
 var FunctionsIds;
 (function (FunctionsIds) {
     FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
@@ -10,13 +14,5 @@ var FunctionsIds;
     FunctionsIds[FunctionsIds["sin"] = 3] = "sin";
     FunctionsIds[FunctionsIds["log"] = 4] = "log";
     FunctionsIds[FunctionsIds["exp"] = 5] = "exp";
+    FunctionsIds[FunctionsIds["abs"] = 6] = "abs";
 })(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
-class FunctionNode {
-    constructor(id, child, tex) {
-        this.type = node_1.NodeType.function;
-        this.id = id;
-        this.child = child;
-        this.tex = tex;
-    }
-}
-exports.FunctionNode = FunctionNode;

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

@@ -1,8 +1,13 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class LogNode extends FunctionNode implements Node {
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isLogNode(a: Node): a is LogNode;
+export declare class LogNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node);
+    opts?: NodeOptions;
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
     toMathjs(): any;

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

@@ -1 +1 @@
-{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,qBAAa,OAAQ,SAAQ,YAAa,YAAW,IAAI;IACvD,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,KAAK,EAAE,IAAI;IAIvB,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,IAAI;CAGjB"}
+{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IASf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,IAAI;CAGjB"}

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

@@ -1,19 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogNode = void 0;
+exports.LogNode = exports.isLogNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class LogNode extends functionNode_1.FunctionNode {
-    constructor(child) {
-        super(functionNode_1.FunctionsIds.log, child, '\\ln');
+const absNode_1 = require("./absNode");
+function isLogNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.log;
+}
+exports.isLogNode = isLogNode;
+class LogNode {
+    constructor(child, opts) {
+        this.id = functionNode_1.FunctionsIds.opposite;
+        this.child = child;
         this.type = node_1.NodeType.function;
+        this.opts = opts;
     }
     toMathString() {
         return `log(${this.child.toMathString()})`;
     }
     toTex() {
-        return `\\ln\\left(${this.child.toTex()}\\right)`;
+        const tex = this.child.toTex();
+        if (!this.opts?.allowLnOfOne && tex === "1") {
+            return "0";
+        }
+        const shouldntUseBrackets = (0, absNode_1.isAbsNode)(this.child);
+        if (shouldntUseBrackets)
+            return `\\ln${tex}`;
+        else
+            return `\\ln\\left(${tex}\\right)`;
     }
     toMathjs() {
         return (0, mathjs_1.log)(this.child.toMathjs());

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

@@ -1,11 +1,22 @@
-import { Node } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class OppositeNode extends FunctionNode implements Node {
-    constructor(child: Node);
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isOppositeNode(a: Node): a is OppositeNode;
+export declare class OppositeNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
+    type: NodeType;
+    opts?: NodeOptions;
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
-    toEquivalentNodes(): Node[];
-    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
+    /**
+     * start opposite node
+     * find all external child of multiply and fraction nodes
+     * add opposite to them
+     */
+    toAllValidTexs(opts?: NodeOptions): string[];
     toMathjs(): number;
 }
 //# sourceMappingURL=oppositeNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAG5D,qBAAa,YAAa,SAAQ,YAAa,YAAW,IAAI;gBAChD,KAAK,EAAE,IAAI;IAGvB,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAcf,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ;CAGT"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpD,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAqCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,QAAQ;CAGT"}