math-exercises 2.2.69 → 2.2.71

package/lib/tree/nodes/polynomials/monomNode.d.ts

@@ -0,0 +1,47 @@
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
+export declare const monom: (a: AlgebraicNode | number | string, degree: number, opts?: MonomNodeOptions) => MonomNode;
+export declare function isMonomNode(a: Node): a is MonomNode;
+export declare function parseToMonomNode(a: Node, variable?: string): false | MonomNode;
+type MonomNodeOptions = {
+    variable: string;
+};
+/**
+ * un monom est une expression du type ax^degree
+ * avec a réel !==0 et degree > 0 (convention)
+ */
+export declare class MonomNode implements AlgebraicNode {
+    a: AlgebraicNode;
+    degree: number;
+    isNumeric: boolean;
+    variable: string;
+    type: NodeType;
+    constructor(a: AlgebraicNode | number, degree: number, opts?: MonomNodeOptions);
+    derivative(varName?: string | undefined): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
+    evaluate(vars?: Record<string, number>): number;
+    toDetailedEvaluation(vars: Record<string, AlgebraicNode>): AlgebraicNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    toAllValidTexs(opts?: NodeOptions | undefined): string[];
+    toEquivalentNodes(opts?: NodeOptions | undefined): AlgebraicNode[];
+    toMathString(): string;
+    toTree(): AlgebraicNode;
+    toTex(): string;
+    toIdentifiers(): {
+        id: NodeIds;
+        a: {
+            id: NodeIds;
+        } & Record<string, any>;
+        degree: number;
+        opts: {
+            variable: string;
+        };
+    };
+}
+export declare const parseToMonom: (node: AlgebraicNode, { variable, maxDegree, minDegree }?: {
+    variable: string;
+    maxDegree: undefined;
+    minDegree: number;
+}) => false | MonomNode;
+export {};
+//# sourceMappingURL=monomNode.d.ts.map

package/lib/tree/nodes/polynomials/monomNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monomNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/polynomials/monomNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAO/D,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,UAC1B,MAAM,SACP,gBAAgB,cAMxB,CAAC;AACF,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,SAAM,qBAGvD;AACD,KAAK,gBAAgB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAO7C;;;GAGG;AACH,qBAAa,SAAU,YAAW,aAAa;IAC7C,CAAC,EAAE,aAAa,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAkB;gBAG9B,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,gBAAgB;IAUzB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;IAMvC,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAG/B,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAG7C,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAGhD,YAAY;IAIZ,MAAM;IAIN,KAAK;IAIL,aAAa;;;;;;;;;;CAQd;AAED,eAAO,MAAM,YAAY,SACjB,aAAa;;;;uBAyIpB,CAAC"}

package/lib/tree/nodes/polynomials/monomNode.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToMonom = exports.MonomNode = exports.parseToMonomNode = exports.isMonomNode = exports.monom = void 0;
+const algebraicNode_1 = require("../algebraicNode");
+const oppositeNode_1 = require("../functions/oppositeNode");
+const node_1 = require("../node");
+// import { NodeIdentifiers } from "../nodeConstructor";
+const multiplyNode_1 = require("../operators/multiplyNode");
+const powerNode_1 = require("../operators/powerNode");
+const variableNode_1 = require("../variables/variableNode");
+const monom = (a, degree, opts) => {
+    const coeff = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
+    return new MonomNode(coeff, degree, opts);
+};
+exports.monom = monom;
+function isMonomNode(a) {
+    return a.type === node_1.NodeType.monom;
+}
+exports.isMonomNode = isMonomNode;
+function parseToMonomNode(a, variable = "x") {
+    if (!(0, algebraicNode_1.isAlgebraicNode)(a))
+        return false;
+    return (0, exports.parseToMonom)(a, { variable, minDegree: 1, maxDegree: undefined });
+}
+exports.parseToMonomNode = parseToMonomNode;
+/**
+ * un monom est une expression du type ax^degree
+ * avec a réel !==0 et degree > 0 (convention)
+ */
+class MonomNode {
+    // roots: AlgebraicNode[];
+    constructor(a, degree, opts) {
+        this.type = node_1.NodeType.monom;
+        // super([c, b, a], opts?.variable ?? "x");
+        this.a = typeof a === "number" ? a.toTree() : a;
+        if (this.a.evaluate() === 0)
+            throw new Error("Monom with coeff null");
+        this.degree = degree;
+        this.isNumeric = false;
+        this.variable = opts?.variable ?? "x";
+    }
+    derivative(varName) {
+        return (0, multiplyNode_1.multiply)((0, multiplyNode_1.multiply)(this.a, this.degree), (0, powerNode_1.power)(this.variable, this.degree - 1)).simplify();
+    }
+    equals(node) {
+        return this.toTree().equals(node);
+    }
+    evaluate(vars) {
+        return this.toTree().evaluate(vars);
+    }
+    toDetailedEvaluation(vars) {
+        return this.toTree().toDetailedEvaluation(vars);
+    }
+    simplify(opts) {
+        return this.toTree().simplify(opts);
+    }
+    toAllValidTexs(opts) {
+        return this.toTree().toAllValidTexs(opts);
+    }
+    toEquivalentNodes(opts) {
+        return this.toTree().toEquivalentNodes(opts);
+    }
+    toMathString() {
+        return this.toTree().toMathString();
+    }
+    toTree() {
+        return (0, multiplyNode_1.multiply)(this.a, (0, powerNode_1.power)(this.variable, this.degree)).simplify();
+    }
+    toTex() {
+        return this.toTree().toTex();
+    }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.monom,
+            a: this.a.toIdentifiers(),
+            degree: this.degree,
+            opts: { variable: this.variable },
+        };
+    }
+}
+exports.MonomNode = MonomNode;
+const parseToMonom = (node, { variable, maxDegree, minDegree } = {
+    variable: "x",
+    maxDegree: undefined,
+    minDegree: 1,
+}) => {
+    variable = variable ?? "x";
+    maxDegree = maxDegree ?? undefined;
+    minDegree = minDegree ?? 1;
+    if (isMonomNode(node)) {
+        if (node.variable !== variable)
+            return false;
+        if (maxDegree && node.degree > maxDegree)
+            return false;
+        if (minDegree && node.degree < minDegree)
+            return false;
+        return node;
+    }
+    if (node.isNumeric)
+        return false;
+    if ((0, variableNode_1.isVariableNode)(node) && node.name === variable && minDegree < 2)
+        return new MonomNode(1, 1, { variable });
+    if ((0, oppositeNode_1.isOppositeNode)(node) &&
+        (0, variableNode_1.isVariableNode)(node.child) &&
+        node.child.name === variable &&
+        minDegree < 2)
+        return new MonomNode(-1, 1, { variable });
+    if ((0, powerNode_1.isSquareNode)(node)) {
+        if (minDegree > 2)
+            return false;
+        if (maxDegree && maxDegree < 2)
+            return false;
+        if (!(0, variableNode_1.isVariableNode)(node.leftChild) || node.leftChild.name !== variable)
+            return false;
+        return new MonomNode(1, 2, { variable });
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isSquareNode)(node.child)) {
+        if (minDegree > 2)
+            return false;
+        if (maxDegree && maxDegree < 2)
+            return false;
+        if (!(0, variableNode_1.isVariableNode)(node.child.leftChild) ||
+            node.child.leftChild.name !== variable)
+            return false;
+        return new MonomNode(-1, 2, { variable });
+    }
+    if ((0, powerNode_1.isPowerNode)(node)) {
+        if (!node.rightChild.isNumeric)
+            return false;
+        const powerEv = node.rightChild.evaluate();
+        if (maxDegree && powerEv > maxDegree)
+            return false;
+        if (minDegree && powerEv < minDegree)
+            return false;
+        if (!(0, variableNode_1.isVariableNode)(node.leftChild) || node.leftChild.name !== variable)
+            return false;
+        return new MonomNode(1, powerEv, { variable });
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isPowerNode)(node.child)) {
+        if (!node.child.rightChild.isNumeric)
+            return false;
+        const powerEv = node.child.rightChild.evaluate();
+        if (maxDegree && powerEv > maxDegree)
+            return false;
+        if (minDegree && powerEv < minDegree)
+            return false;
+        if (!(0, variableNode_1.isVariableNode)(node.child.leftChild) ||
+            node.child.leftChild.name !== variable)
+            return false;
+        return new MonomNode(-1, powerEv, { variable });
+    }
+    if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+        const numericChildPosition = node.leftChild.isNumeric
+            ? "left"
+            : node.rightChild.isNumeric
+                ? "right"
+                : undefined;
+        if (!numericChildPosition)
+            return false;
+        const numericChild = numericChildPosition === "left" ? node.leftChild : node.rightChild;
+        const varChild = numericChildPosition === "left" ? node.rightChild : node.leftChild;
+        if ((0, variableNode_1.isVariableNode)(varChild)) {
+            if (varChild.name !== variable || minDegree > 1)
+                return false;
+            else
+                return new MonomNode(numericChild, 1, { variable });
+        }
+        if ((0, powerNode_1.isSquareNode)(varChild)) {
+            if (minDegree > 2)
+                return false;
+            if (maxDegree && maxDegree < 2)
+                return false;
+            if (!(0, variableNode_1.isVariableNode)(varChild.leftChild) ||
+                varChild.leftChild.name !== variable)
+                return false;
+            return new MonomNode(numericChild, 2, { variable });
+        }
+        if ((0, oppositeNode_1.isOppositeNode)(varChild) && (0, powerNode_1.isSquareNode)(varChild.child)) {
+            if (minDegree > 2)
+                return false;
+            if (maxDegree && maxDegree < 2)
+                return false;
+            if (!(0, variableNode_1.isVariableNode)(varChild.child.leftChild) ||
+                varChild.child.leftChild.name !== variable)
+                return false;
+            return new MonomNode((0, oppositeNode_1.opposite)(numericChild), 2, { variable });
+        }
+        if ((0, powerNode_1.isPowerNode)(varChild) &&
+            (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
+            varChild.leftChild.name === variable &&
+            varChild.rightChild.isNumeric) {
+            const powerEv = varChild.rightChild.evaluate();
+            if (maxDegree && powerEv > maxDegree)
+                return false;
+            if (minDegree && powerEv < minDegree)
+                return false;
+            return new MonomNode(numericChild, powerEv, { variable });
+        }
+        if ((0, oppositeNode_1.isOppositeNode)(varChild) &&
+            (0, powerNode_1.isPowerNode)(varChild.child) &&
+            (0, variableNode_1.isVariableNode)(varChild.child.leftChild) &&
+            varChild.child.leftChild.name === variable &&
+            varChild.child.rightChild.isNumeric) {
+            const powerEv = varChild.child.rightChild.evaluate();
+            if (maxDegree && powerEv > maxDegree)
+                return false;
+            if (minDegree && powerEv < minDegree)
+                return false;
+            return new MonomNode((0, oppositeNode_1.opposite)(numericChild), powerEv, { variable });
+        }
+    }
+    return false;
+};
+exports.parseToMonom = parseToMonom;

package/lib/tree/nodes/polynomials/trinomNode.d.ts

@@ -0,0 +1,70 @@
+import { AlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode";
+import { NodeIds, NodeOptions, NodeType } from "../../../tree/nodes/node";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor";
+export declare abstract class TrinomNodeConstructor {
+    static random(aOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }, bOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }, cOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }): TrinomNode;
+    static randomCanonical(aOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+        from?: number[];
+    }, alphaOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }, betaOpts?: {
+        min?: number;
+        max?: number;
+        excludes?: number[];
+    }): TrinomNode;
+    static randomNiceRoots(nbOfRoots?: number): TrinomNode;
+    static fromCoeffs(coeffs: number[]): TrinomNode;
+    static fromIdentifiers(identifiers: TrinomNodeIdentifiers): TrinomNode;
+}
+export type TrinomNodeIdentifiers = {
+    id: NodeIds.trinom;
+    a: number | NodeIdentifiers;
+    b: number | NodeIdentifiers;
+    c: number | NodeIdentifiers;
+    opts?: TrinomNodeOptions;
+};
+type TrinomNodeOptions = {
+    variable: string;
+};
+export declare class TrinomNode implements AlgebraicNode {
+    a: AlgebraicNode;
+    b: AlgebraicNode;
+    c: AlgebraicNode;
+    isNumeric: boolean;
+    variable: string;
+    type: NodeType;
+    constructor(a: AlgebraicNode | number, b: AlgebraicNode | number, c: AlgebraicNode | number, opts?: TrinomNodeOptions);
+    getDelta(): AlgebraicNode;
+    derivative(varName?: string | undefined): import("../../../tree/nodes/operators/addNode").AddNode;
+    equals(node: AlgebraicNode): boolean;
+    evaluate(vars?: Record<string, number>): number;
+    toDetailedEvaluation(vars: Record<string, AlgebraicNode>): import("../../../tree/nodes/operators/addNode").AddNode | import("../../../tree/nodes/operators/multiplyNode").MultiplyNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    toAllValidTexs(opts?: NodeOptions | undefined): string[];
+    toEquivalentNodes(opts?: NodeOptions | undefined): AlgebraicNode[] | import("../../../tree/nodes/operators/multiplyNode").MultiplyNode[];
+    toMathString(): string;
+    getRoots(): AlgebraicNode[];
+    toTree(): import("../../../tree/nodes/operators/addNode").AddNode | import("../../../tree/nodes/operators/multiplyNode").MultiplyNode;
+    toTex(): string;
+    getCoeffs(): number[];
+    toIdentifiers(): TrinomNodeIdentifiers;
+}
+export {};
+//# sourceMappingURL=trinomNode.d.ts.map

package/lib/tree/nodes/polynomials/trinomNode.d.ts.map

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

package/lib/tree/nodes/polynomials/trinomNode.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrinomNode = exports.TrinomNodeConstructor = void 0;
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+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 oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/alea/random");
+const node_1 = require("../../../tree/nodes/node");
+const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
+class TrinomNodeConstructor {
+    static random(aOpts, bOpts, cOpts) {
+        const a = (0, randint_1.randint)(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
+        const b = (0, randint_1.randint)(bOpts?.min ?? -9, bOpts?.max ?? 10, bOpts?.excludes ?? []);
+        const c = (0, randint_1.randint)(cOpts?.min ?? -9, cOpts?.max ?? 10, cOpts?.excludes ?? []);
+        return new TrinomNode(a, b, c);
+    }
+    static randomCanonical(aOpts, alphaOpts, betaOpts) {
+        const a = aOpts?.from
+            ? (0, random_1.random)(aOpts.from)
+            : (0, randint_1.randint)(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
+        const alpha = (0, randint_1.randint)(alphaOpts?.min ?? -9, alphaOpts?.max ?? 10, alphaOpts?.excludes ?? []);
+        const beta = (0, randint_1.randint)(betaOpts?.min ?? -9, betaOpts?.max ?? 10, betaOpts?.excludes ?? []);
+        const b = -2 * a * alpha;
+        const c = a * alpha ** 2 + beta;
+        return new TrinomNode(a, b, c);
+    }
+    static randomNiceRoots(nbOfRoots = 2) {
+        if (nbOfRoots === 0) {
+            //canonical +c
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const root = (0, randint_1.randint)(-9, 10);
+            //a(x-root)^2 = ax^2 -2arootx + aroot^2
+            const c = a > 0 ? a * root ** 2 + (0, randint_1.randint)(1, 6) : a * root ** 2 - (0, randint_1.randint)(1, 6);
+            return new TrinomNode(a, -2 * a * root, c);
+        }
+        else if (nbOfRoots === 1) {
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const root = (0, randint_1.randint)(-9, 10);
+            //a(x-root)^2 = ax^2 -2arootx + aroot^2
+            return new TrinomNode(a, -2 * a * root, a * root ** 2);
+        }
+        else {
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const x1 = (0, randint_1.randint)(-9, 10, []);
+            const x2 = (0, randint_1.randint)(-9, 10, [x1]);
+            return new TrinomNode(a, -a * (x1 + x2), a * x1 * x2);
+        }
+    }
+    static fromCoeffs(coeffs) {
+        return new TrinomNode(coeffs[2], coeffs[1], coeffs[0]);
+    }
+    static fromIdentifiers(identifiers) {
+        return new TrinomNode(typeof identifiers.a === "number"
+            ? identifiers.a
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.a), typeof identifiers.b === "number"
+            ? identifiers.b
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.b), typeof identifiers.c === "number"
+            ? identifiers.c
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.c), identifiers.opts);
+    }
+}
+exports.TrinomNodeConstructor = TrinomNodeConstructor;
+class TrinomNode {
+    // roots: AlgebraicNode[];
+    constructor(a, b, c, opts) {
+        this.type = node_1.NodeType.trinom;
+        // super([c, b, a], opts?.variable ?? "x");
+        this.a = typeof a === "number" ? a.toTree() : a;
+        this.b = typeof b === "number" ? b.toTree() : b;
+        this.c = typeof c === "number" ? c.toTree() : c;
+        this.isNumeric = false;
+        this.variable = opts?.variable ?? "x";
+    }
+    getDelta() {
+        return (0, substractNode_1.substract)((0, powerNode_1.square)(this.b), (0, multiplyNode_1.multiply)(4, (0, multiplyNode_1.multiply)(this.a, this.c))).simplify();
+    }
+    //   getRoots() {
+    //     const delta = this.getDelta();
+    //     if (delta < 0) return [];
+    //     if (delta === 0) return [-this.b / (2 * this.a)];
+    //     return [
+    //       (-this.b - Math.sqrt(delta)) / (2 * this.a),
+    //       (-this.b + Math.sqrt(delta)) / (2 * this.a),
+    //     ].sort((a, b) => a - b);
+    //   }
+    derivative(varName) {
+        return (0, addNode_1.add)((0, multiplyNode_1.multiply)(2, (0, multiplyNode_1.multiply)(this.a, "x")), this.b);
+    }
+    equals(node) {
+        return this.toTree().equals(node);
+    }
+    evaluate(vars) {
+        return this.toTree().evaluate(vars);
+    }
+    toDetailedEvaluation(vars) {
+        return this.toTree().toDetailedEvaluation(vars);
+    }
+    simplify(opts) {
+        return this.toTree().simplify(opts);
+    }
+    toAllValidTexs(opts) {
+        return this.toTree().toAllValidTexs(opts);
+    }
+    toEquivalentNodes(opts) {
+        return this.toTree().toEquivalentNodes(opts);
+    }
+    toMathString() {
+        return this.toTree().toMathString();
+    }
+    getRoots() {
+        const delta = this.getDelta();
+        const deltaEv = delta.evaluate();
+        if (deltaEv < 0)
+            return [];
+        if (deltaEv === 0)
+            return [(0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(this.b), (0, multiplyNode_1.multiply)(2, this.a)).simplify()];
+        return [
+            (0, fractionNode_1.frac)((0, substractNode_1.substract)((0, oppositeNode_1.opposite)(this.b), (0, sqrtNode_1.sqrt)(delta)), (0, multiplyNode_1.multiply)(2, this.a)).simplify(),
+            (0, fractionNode_1.frac)((0, addNode_1.add)((0, oppositeNode_1.opposite)(this.b), (0, sqrtNode_1.sqrt)(delta)), (0, multiplyNode_1.multiply)(2, this.a)).simplify(),
+        ].sort((a, b) => a.evaluate() - b.evaluate());
+    }
+    toTree() {
+        const bEv = this.b.evaluate();
+        const cEv = this.c.evaluate();
+        const highMonom = (0, multiplyNode_1.multiply)(this.a, (0, powerNode_1.square)(this.variable));
+        const middleMonom = (0, multiplyNode_1.multiply)(this.b, this.variable);
+        if (!bEv && !cEv)
+            return highMonom;
+        if (!cEv)
+            return (0, addNode_1.add)(highMonom, middleMonom);
+        if (!bEv)
+            return (0, addNode_1.add)(highMonom, this.c);
+        return (0, addNode_1.add)(highMonom, (0, addNode_1.add)(middleMonom, this.c));
+    }
+    toTex() {
+        return this.toTree().toTex();
+    }
+    getCoeffs() {
+        return [this.c.evaluate(), this.b.evaluate(), this.a.evaluate()];
+    }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.trinom,
+            a: this.a.toIdentifiers(),
+            b: this.b.toIdentifiers(),
+            c: this.c.toIdentifiers(),
+            opts: { variable: this.variable },
+        };
+    }
+}
+exports.TrinomNode = TrinomNode;

package/lib/tree/nodes/variables/variableNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAIxB,aAAa;;;;IAMb,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAStC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAKxD"}
+{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAIxB,aAAa;;;;IAMb,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAKxD"}

package/lib/tree/nodes/variables/variableNode.js

@@ -36,7 +36,7 @@ class VariableNode {
     evaluate(vars) {
         const value = vars?.[this.name];
         if (value === undefined)
-            throw Error(`Can't evaluate variable ${this.name}`);
+            return Number.NaN;
         return value;
     }
     // simplify(): Node {

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":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAqBzD,CAAC"}
+{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAuBzD,CAAC"}

package/lib/tree/parsers/affineParser.js

@@ -7,6 +7,7 @@ const latexParser_1 = require("./latexParser");
 const monomParser_1 = require("./monomParser");
 const affineParser = (ans, variable = "x") => {
     try {
+        //double parse, pas opti
         const monom = (0, monomParser_1.monomParser)(ans, { variable, maxDegree: 1 });
         if (monom)
             return monom;
@@ -20,7 +21,7 @@ const affineParser = (ans, variable = "x") => {
             if (!numericChild)
                 return false;
             const varChild = numericChild === "left" ? parsed.rightChild : parsed.leftChild;
-            return (0, monomParser_1.isMonomNode)(varChild, { variable, maxDegree: 1 }) ? parsed : false;
+            return (0, monomParser_1.isMonom)(varChild, { variable, maxDegree: 1 }) ? parsed : false;
         }
         return false;
     }

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

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../nodes/algebraicNode";
+export declare const discreteSetParser: (str: string) => false | AlgebraicNode[];
+//# sourceMappingURL=discreteSetParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discreteSetParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/discreteSetParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAMxE,eAAO,MAAM,iBAAiB,QAAS,MAAM,4BAe5C,CAAC"}

package/lib/tree/parsers/discreteSetParser.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discreteSetParser = void 0;
+const latexParser_1 = require("./latexParser");
+const discreteSetParser = (str) => {
+    try {
+        const formated = str
+            .replace("S", "")
+            .replace("=", "")
+            .replace("\\left", "")
+            .replace("\\right", "")
+            .replace("\\{", "")
+            .replace("\\}", "");
+        const elements = formated.split(";").map((e) => (0, latexParser_1.parseAlgebraic)(e));
+        if (elements.some((e) => !e))
+            return false;
+        return elements;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.discreteSetParser = discreteSetParser;

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

@@ -1,3 +1,3 @@
 import { AlgebraicNode } from "../nodes/algebraicNode";
-export declare const equationSolutionParser: (str: string) => false | AlgebraicNode;
+export declare const equationSolutionParser: (str: string, variable?: string) => false | AlgebraicNode;
 //# sourceMappingURL=equationSolutionParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"equationSolutionParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/equationSolutionParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAKxE,eAAO,MAAM,sBAAsB,QAAS,MAAM,0BAgBjD,CAAC"}
+{"version":3,"file":"equationSolutionParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/equationSolutionParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAMxE,eAAO,MAAM,sBAAsB,QAAS,MAAM,6CAyBjD,CAAC"}

package/lib/tree/parsers/equationSolutionParser.js

@@ -3,19 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.equationSolutionParser = void 0;
 const algebraicNode_1 = require("../nodes/algebraicNode");
 const equalNode_1 = require("../nodes/equations/equalNode");
-const hasVariableNode_1 = require("../nodes/hasVariableNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
 const latexParser_1 = require("./latexParser");
-const equationSolutionParser = (str) => {
+const equationSolutionParser = (str, variable = "x") => {
     try {
         const parsed = (0, latexParser_1.parseLatex)(str);
         if ((0, equalNode_1.isEqualNode)(parsed)) {
             const children = [parsed.leftChild, parsed.rightChild];
-            const scalar = children.find((e) => !(0, hasVariableNode_1.hasVariableNode)(e));
-            if (!scalar)
+            const varNode = (0, variableNode_1.isVariableNode)(parsed.leftChild)
+                ? 0
+                : (0, variableNode_1.isVariableNode)(parsed.rightChild)
+                    ? 1
+                    : undefined;
+            if (varNode === undefined)
+                return false;
+            if (children[varNode].name !== "x")
+                return false;
+            const scalar = children[(varNode + 1) % 2];
+            if (!(0, algebraicNode_1.isAlgebraicNode)(scalar) || !scalar.isNumeric)
                 return false;
             return scalar;
         }
         else if ((0, algebraicNode_1.isAlgebraicNode)(parsed)) {
+            if (!parsed.isNumeric)
+                return false;
             return parsed;
         }
         else {

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

@@ -2,6 +2,10 @@ import { AlgebraicNode } from "../nodes/algebraicNode";
 import { EqualNode } from "../nodes/equations/equalNode";
 import { InequationNode } from "../nodes/inequations/inequationNode";
 export declare const tokenize: (latex: string) => string[];
-export declare const parseAlgebraic: (latex: string) => AlgebraicNode;
+type ParserOptions = {
+    allowStartingPower?: boolean;
+};
+export declare const parseAlgebraic: (latex: string, opts?: ParserOptions) => AlgebraicNode;
 export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode;
+export {};
 //# sourceMappingURL=latexParser.d.ts.map

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;AAkDrE,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,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,cAAc,UAAW,MAAM,SAAS,aAAa,kBAyBjE,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}