math-exercises 2.0.12 → 2.0.13

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

@@ -1,78 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DivideNode = exports.isDivideNode = void 0;
-// import { divide } from "mathjs";
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-function isDivideNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.divide;
-}
-exports.isDivideNode = isDivideNode;
-const divideNodeToTex = (leftChild, rightChild) => {
-    let rightTex = rightChild.toTex();
-    let leftTex = leftChild.toTex();
-    if ((0, operatorNode_1.isOperatorNode)(leftChild)) {
-        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
-            leftTex = `\\left(${leftTex}\\right)`;
-    }
-    let needBrackets = rightTex[0] === "-";
-    if ((0, operatorNode_1.isOperatorNode)(rightChild)) {
-        needBrackets ||= [
-            operatorNode_1.OperatorIds.add,
-            operatorNode_1.OperatorIds.substract,
-            operatorNode_1.OperatorIds.divide,
-        ].includes(rightChild.id);
-    }
-    if (needBrackets)
-        rightTex = `\\left(${rightTex}\\right)`;
-    const nextIsLetter = rightTex[0].toLowerCase() !== rightTex[0].toUpperCase();
-    return `${leftTex}\\div${nextIsLetter ? " " : ""}${rightTex}`;
-};
-class DivideNode {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild, rightChild) {
-        this.id = operatorNode_1.OperatorIds.divide;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.type = node_1.NodeType.operator;
-        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
-    }
-    toEquivalentNodes(opts) {
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new DivideNode(leftNode, rightNode));
-            });
-        });
-        return res;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
-    }
-    toTex() {
-        return divideNodeToTex(this.leftChild, this.rightChild);
-    }
-    evaluate(vars) {
-        return this.leftChild.evaluate(vars) / this.rightChild.evaluate(vars);
-    }
-    // toMathjs() {
-    //   return divide(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    // }
-    simplify() {
-        return this;
-    }
-    equals(node) {
-        return (isDivideNode(node) &&
-            node.leftChild.equals(this.leftChild) &&
-            node.rightChild.equals(this.rightChild));
-    }
-}
-exports.DivideNode = DivideNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivideNode = exports.isDivideNode = void 0;
+// import { divide } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+function isDivideNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.divide;
+}
+exports.isDivideNode = isDivideNode;
+const divideNodeToTex = (leftChild, rightChild) => {
+    let rightTex = rightChild.toTex();
+    let leftTex = leftChild.toTex();
+    if ((0, operatorNode_1.isOperatorNode)(leftChild)) {
+        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
+            leftTex = `\\left(${leftTex}\\right)`;
+    }
+    let needBrackets = rightTex[0] === "-";
+    if ((0, operatorNode_1.isOperatorNode)(rightChild)) {
+        needBrackets ||= [
+            operatorNode_1.OperatorIds.add,
+            operatorNode_1.OperatorIds.substract,
+            operatorNode_1.OperatorIds.divide,
+        ].includes(rightChild.id);
+    }
+    if (needBrackets)
+        rightTex = `\\left(${rightTex}\\right)`;
+    const nextIsLetter = rightTex[0].toLowerCase() !== rightTex[0].toUpperCase();
+    return `${leftTex}\\div${nextIsLetter ? " " : ""}${rightTex}`;
+};
+class DivideNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        this.id = operatorNode_1.OperatorIds.divide;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toEquivalentNodes(opts) {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new DivideNode(leftNode, rightNode));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toTex() {
+        return divideNodeToTex(this.leftChild, this.rightChild);
+    }
+    evaluate(vars) {
+        return this.leftChild.evaluate(vars) / this.rightChild.evaluate(vars);
+    }
+    // toMathjs() {
+    //   return divide(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return (isDivideNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
+}
+exports.DivideNode = DivideNode;

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

@@ -1,16 +1,9 @@
 import { Node } from '../node';
 import { OperatorNode } from './operatorNode';
-type EqualNodeOptions = {
-    isRightChildOnlyValid?: boolean;
-};
 export declare class EqualNode extends OperatorNode implements Node {
-    opts: EqualNodeOptions | undefined;
-    constructor(leftChild: Node, rightChild: Node, opts?: EqualNodeOptions);
-    toEquivalentNodes(): Node[];
-    toAllValidTexs(): string[];
+    constructor(leftChild: Node, rightChild: Node);
     toMathString(): string;
     toTex(): string;
     toMathjs(): boolean | import("mathjs").MathCollection;
 }
-export {};
 //# sourceMappingURL=equalNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3D,KAAK,gBAAgB,GAAG;IACtB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AACF,qBAAa,SAAU,SAAQ,YAAa,YAAW,IAAI;IACzD,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAAC;gBACvB,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAKtE,iBAAiB;IAiBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3D,qBAAa,SAAU,SAAQ,YAAa,YAAW,IAAI;gBAC7C,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAG7C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}

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

@@ -4,27 +4,8 @@ exports.EqualNode = void 0;
 const mathjs_1 = require("mathjs");
 const operatorNode_1 = require("./operatorNode");
 class EqualNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild, opts) {
+    constructor(leftChild, rightChild) {
         super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, '=');
-        this.opts = opts;
-    }
-    toEquivalentNodes() {
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        if (this.opts?.isRightChildOnlyValid) {
-            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()}`;

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

@@ -1,26 +1,26 @@
-import { Node, NodeOptions, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
-export declare function isFractionNode(a: Node): a is FractionNode;
-export declare class FractionNode implements OperatorNode {
-    opts?: NodeOptions;
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    id: OperatorIds;
-    leftChild: AlgebraicNode;
-    rightChild: AlgebraicNode;
-    type: NodeType;
-    isNumeric: boolean;
-    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
-    toMathString(): string;
-    toInversed(): FractionNode;
-    toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
-    toAllValidTexs(opts?: NodeOptions): string[];
-    toTex(): string;
-    evaluate(vars: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode;
-    equals(node: AlgebraicNode): boolean;
-}
+import { Node, NodeOptions, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+export declare function isFractionNode(a: Node): a is FractionNode;
+export declare class FractionNode implements OperatorNode {
+    opts?: NodeOptions;
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    id: OperatorIds;
+    leftChild: AlgebraicNode;
+    rightChild: AlgebraicNode;
+    type: NodeType;
+    isNumeric: boolean;
+    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
+    toMathString(): string;
+    toInversed(): FractionNode;
+    toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
+    toAllValidTexs(opts?: NodeOptions): string[];
+    toTex(): string;
+    evaluate(vars: Record<string, number>): number;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
+}
 //# sourceMappingURL=fractionNode.d.ts.map

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

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

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

@@ -1,154 +1,160 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FractionNode = exports.isFractionNode = void 0;
-// import { fraction } from "mathjs";
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const numberNode_1 = require("../numbers/numberNode");
-const round_1 = require("../../../math/utils/round");
-const oppositeNode_1 = require("../functions/oppositeNode");
-const multiplyNode_1 = require("./multiplyNode");
-const rational_1 = require("../../../math/numbers/rationals/rational");
-const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
-function isFractionNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.fraction;
-}
-exports.isFractionNode = isFractionNode;
-class FractionNode {
-    constructor(leftChild, rightChild, opts) {
-        this.id = operatorNode_1.OperatorIds.fraction;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.type = node_1.NodeType.operator;
-        this.opts = opts;
-        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
-    }
-    toInversed() {
-        return new FractionNode(this.rightChild, this.leftChild);
-    }
-    toEquivalentNodes(opts) {
-        const options = opts ?? this.opts;
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new FractionNode(leftNode, rightNode));
-                if (options?.allowFractionToDecimal &&
-                    (0, numberNode_1.isNumberNode)(leftNode) &&
-                    (0, numberNode_1.isNumberNode)(rightNode)) {
-                    const [num, denum] = [leftNode.value, rightNode.value];
-                    const decimal = (0, round_1.round)(num / denum, 12);
-                    //on ne push pas les non décimaux (limite arbitraire : partie décimale de 12 => non décimal)
-                    if ((decimal + "").split(".")[1].length > 11)
-                        return;
-                    res.push(new numberNode_1.NumberNode(decimal));
-                }
-            });
-        });
-        return res;
-        //! cas x/2 : doit on créer 1*x/2 ainsi que 0.5*x ??
-        //! si le num est un multiplynode, ex x*y/z , est ce qu'on créé x*(y/z), y*(x/z) ??
-        //! est ce qu'on gère le placement du moins n'importe où
-    }
-    toAllValidTexs(opts) {
-        return this.toEquivalentNodes(opts).map((node) => node.toTex());
-    }
-    toTex() {
-        if (!this.opts?.allowMinusAnywhereInFraction &&
-            ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||
-                ((0, numberNode_1.isNumberNode)(this.leftChild) && this.leftChild.value < 0))) {
-            return `-\\frac{${this.leftChild
-                .toTex()
-                .slice(1)}}{${this.rightChild.toTex()}}`;
-        }
-        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
-    }
-    evaluate(vars) {
-        return this.leftChild.evaluate(vars) / this.rightChild.evaluate(vars);
-    }
-    // toMathjs() {
-    //   return fraction(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    // }
-    simplify(opts) {
-        const simplifiedNum = this.leftChild.simplify(opts);
-        const simplifiedDenum = this.rightChild.simplify(opts);
-        const copy = new FractionNode(simplifiedNum, simplifiedDenum, this.opts);
-        const externalsNums = [];
-        const externalsDenums = [];
-        const recursiveNums = (node) => {
-            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
-                recursiveNums(node.leftChild);
-                recursiveNums(node.rightChild);
-            }
-            else {
-                externalsNums.push(node);
-            }
-        };
-        const recursiveDenums = (node) => {
-            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
-                recursiveDenums(node.leftChild);
-                recursiveDenums(node.rightChild);
-            }
-            else {
-                externalsDenums.push(node);
-            }
-        };
-        recursiveNums(copy.leftChild);
-        recursiveDenums(copy.rightChild);
-        const simplifyExternalNodes = (num, denum) => {
-            if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
-                const frac = new rational_1.Rational(num.value, denum.value);
-                if (frac.isIrreductible())
-                    return null;
-                return frac.simplify().toTree();
-            }
-            //!ya mieux à faire pour gérer tous les cas d'un coup
-            //! s'insiprer de multiply
-            if (num.equals(denum))
-                return new numberNode_1.NumberNode(1);
-            return null;
-        };
-        const simplifyIteration = () => {
-            for (let i = 0; i < externalsNums.length; i++) {
-                const num = externalsNums[i];
-                for (let j = 0; j < externalsDenums.length; j++) {
-                    const denum = externalsDenums[j];
-                    const simplified = simplifyExternalNodes(num, denum);
-                    if (simplified) {
-                        if (isFractionNode(simplified)) {
-                            externalsNums[i] = simplified.leftChild;
-                            externalsDenums[j] = simplified.rightChild;
-                        }
-                        else {
-                            externalsNums[i] = simplified;
-                            externalsDenums.splice(j, 1);
-                        }
-                        simplifyIteration();
-                        return;
-                    }
-                }
-            }
-        };
-        simplifyIteration();
-        const nums = externalsNums.length === 1
-            ? externalsNums[0]
-            : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsNums).simplify(opts);
-        if (externalsDenums.length === 0) {
-            return nums;
-        }
-        const denums = externalsDenums.length === 1
-            ? externalsDenums[0]
-            : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsDenums);
-        return new FractionNode(nums, denums);
-    }
-    equals(node) {
-        return (isFractionNode(node) &&
-            node.leftChild.equals(this.leftChild) &&
-            node.rightChild.equals(this.rightChild));
-    }
-}
-exports.FractionNode = FractionNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FractionNode = exports.isFractionNode = void 0;
+// import { fraction } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+const numberNode_1 = require("../numbers/numberNode");
+const round_1 = require("../../../math/utils/round");
+const oppositeNode_1 = require("../functions/oppositeNode");
+const multiplyNode_1 = require("./multiplyNode");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
+const addNode_1 = require("./addNode");
+function isFractionNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.fraction;
+}
+exports.isFractionNode = isFractionNode;
+class FractionNode {
+    constructor(leftChild, rightChild, opts) {
+        this.id = operatorNode_1.OperatorIds.fraction;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
+        this.opts = opts;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toInversed() {
+        return new FractionNode(this.rightChild, this.leftChild);
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new FractionNode(leftNode, rightNode));
+                if (options?.allowFractionToDecimal &&
+                    (0, numberNode_1.isNumberNode)(leftNode) &&
+                    (0, numberNode_1.isNumberNode)(rightNode)) {
+                    const [num, denum] = [leftNode.value, rightNode.value];
+                    const decimal = (0, round_1.round)(num / denum, 12);
+                    //on ne push pas les non décimaux (limite arbitraire : partie décimale de 12 => non décimal)
+                    if ((decimal + "").split(".")[1].length > 11)
+                        return;
+                    res.push(new numberNode_1.NumberNode(decimal));
+                }
+            });
+        });
+        return res;
+        //! cas x/2 : doit on créer 1*x/2 ainsi que 0.5*x ??
+        //! si le num est un multiplynode, ex x*y/z , est ce qu'on créé x*(y/z), y*(x/z) ??
+        //! est ce qu'on gère le placement du moins n'importe où
+    }
+    toAllValidTexs(opts) {
+        return this.toEquivalentNodes(opts).map((node) => node.toTex());
+    }
+    toTex() {
+        if (!this.opts?.allowMinusAnywhereInFraction &&
+            ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||
+                ((0, numberNode_1.isNumberNode)(this.leftChild) && this.leftChild.value < 0))) {
+            return `-\\frac{${this.leftChild
+                .toTex()
+                .slice(1)}}{${this.rightChild.toTex()}}`;
+        }
+        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
+    }
+    evaluate(vars) {
+        return this.leftChild.evaluate(vars) / this.rightChild.evaluate(vars);
+    }
+    // toMathjs() {
+    //   return fraction(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify(opts) {
+        const simplifiedNum = this.leftChild.simplify(opts);
+        const simplifiedDenum = this.rightChild.simplify(opts);
+        const copy = new FractionNode(simplifiedNum, simplifiedDenum, this.opts);
+        const externalsNums = [];
+        const externalsDenums = [];
+        const recursiveNums = (node) => {
+            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+                recursiveNums(node.leftChild);
+                recursiveNums(node.rightChild);
+            }
+            else {
+                externalsNums.push(node);
+            }
+        };
+        const recursiveDenums = (node) => {
+            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+                recursiveDenums(node.leftChild);
+                recursiveDenums(node.rightChild);
+            }
+            else {
+                externalsDenums.push(node);
+            }
+        };
+        recursiveNums(copy.leftChild);
+        recursiveDenums(copy.rightChild);
+        const simplifyExternalNodes = (num, denum) => {
+            if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
+                const frac = new rational_1.Rational(num.value, denum.value);
+                if (frac.isIrreductible())
+                    return null;
+                return frac.simplify().toTree();
+            }
+            //!ya mieux à faire pour gérer tous les cas d'un coup
+            //! s'insiprer de multiply
+            if (num.equals(denum))
+                return new numberNode_1.NumberNode(1);
+            return null;
+        };
+        const simplifyIteration = () => {
+            for (let i = 0; i < externalsNums.length; i++) {
+                const num = externalsNums[i];
+                for (let j = 0; j < externalsDenums.length; j++) {
+                    const denum = externalsDenums[j];
+                    const simplified = simplifyExternalNodes(num, denum);
+                    if (simplified) {
+                        if (isFractionNode(simplified)) {
+                            externalsNums[i] = simplified.leftChild;
+                            externalsDenums[j] = simplified.rightChild;
+                        }
+                        else {
+                            externalsNums[i] = simplified;
+                            externalsDenums.splice(j, 1);
+                        }
+                        simplifyIteration();
+                        return;
+                    }
+                }
+            }
+        };
+        simplifyIteration();
+        const nums = externalsNums.length === 1
+            ? externalsNums[0]
+            : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsNums).simplify(opts);
+        if (externalsDenums.length === 0) {
+            return nums;
+        }
+        const denums = externalsDenums.length === 1
+            ? externalsDenums[0]
+            : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsDenums);
+        if (opts?.forceDistributeFractions) {
+            if ((0, addNode_1.isAddNode)(nums)) {
+                return new addNode_1.AddNode(new FractionNode(nums.leftChild, denums).simplify(opts), new FractionNode(nums.rightChild, denums).simplify(opts));
+            }
+        }
+        return new FractionNode(nums, denums);
+    }
+    equals(node) {
+        return (isFractionNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
+}
+exports.FractionNode = FractionNode;