math-exercises 2.2.70 → 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/parsers/affineParser.js

@@ -21,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/monomParser.d.ts

@@ -1,10 +1,10 @@
 import { AlgebraicNode } from "../nodes/algebraicNode";
 type Opts = {
-    variable: string;
+    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 declare const isMonom: (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,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"}
+{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAUvD,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,eAAO,MAAM,WAAW,QACjB,MAAM,uCACyB,IAAI,0BAgBzC,CAAC;AAEF,eAAO,MAAM,OAAO,SACZ,aAAa,uCACiB,IAAI,YAyFzC,CAAC"}

package/lib/tree/parsers/monomParser.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMonomNode = exports.monomParser = void 0;
+exports.isMonom = exports.monomParser = void 0;
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
 const fractionNode_1 = require("../nodes/operators/fractionNode");
 const multiplyNode_1 = require("../nodes/operators/multiplyNode");
 const powerNode_1 = require("../nodes/operators/powerNode");
+const monomNode_1 = require("../nodes/polynomials/monomNode");
 const variableNode_1 = require("../nodes/variables/variableNode");
 const latexParser_1 = require("./latexParser");
 const monomParser = (str, { variable, maxDegree, minDegree } = {
@@ -13,9 +15,7 @@ const monomParser = (str, { variable, maxDegree, minDegree } = {
 }) => {
     try {
         const parsed = (0, latexParser_1.parseAlgebraic)(str);
-        return (0, exports.isMonomNode)(parsed, { variable, maxDegree, minDegree })
-            ? parsed
-            : false;
+        return (0, exports.isMonom)(parsed, { variable, maxDegree, minDegree }) ? parsed : false;
         if ((0, fractionNode_1.isFractionNode)(parsed)) {
             //!unimplemented
             return false;
@@ -28,7 +28,7 @@ const monomParser = (str, { variable, maxDegree, minDegree } = {
     }
 };
 exports.monomParser = monomParser;
-const isMonomNode = (node, { variable, maxDegree, minDegree } = {
+const isMonom = (node, { variable, maxDegree, minDegree } = {
     variable: "x",
     maxDegree: undefined,
     minDegree: 0,
@@ -36,10 +36,61 @@ const isMonomNode = (node, { variable, maxDegree, minDegree } = {
     variable = variable ?? "x";
     maxDegree = maxDegree ?? undefined;
     minDegree = minDegree ?? 0;
+    if ((0, monomNode_1.isMonomNode)(node)) {
+        if (node.variable !== variable)
+            return false;
+        if (maxDegree && node.degree > maxDegree)
+            return false;
+        if (minDegree && node.degree < minDegree)
+            return false;
+        return true;
+    }
     if (node.isNumeric && minDegree === 0)
         return true;
+    //not monom
     if ((0, variableNode_1.isVariableNode)(node) && node.name === variable && minDegree < 2)
         return true;
+    //new MonomNode(1, 1, { variable });
+    if ((0, oppositeNode_1.isOppositeNode)(node) &&
+        (0, variableNode_1.isVariableNode)(node.child) &&
+        node.child.name === variable &&
+        minDegree < 2)
+        return true;
+    // new MonomNode(-1, 1, {variable})
+    if ((0, powerNode_1.isSquareNode)(node)) {
+        if (minDegree > 2)
+            return false;
+        if (maxDegree && maxDegree < 2)
+            return false;
+        return (0, variableNode_1.isVariableNode)(node.leftChild) && node.leftChild.name === "x";
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isSquareNode)(node.child)) {
+        if (minDegree > 2)
+            return false;
+        if (maxDegree && maxDegree < 2)
+            return false;
+        return ((0, variableNode_1.isVariableNode)(node.child.leftChild) && node.child.leftChild.name === "x");
+    }
+    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;
+        return (0, variableNode_1.isVariableNode)(node.leftChild) && node.leftChild.name === "x";
+    }
+    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;
+        return ((0, variableNode_1.isVariableNode)(node.child.leftChild) && node.child.leftChild.name === "x");
+    }
     if ((0, multiplyNode_1.isMultiplyNode)(node)) {
         const numericChild = node.leftChild.isNumeric
             ? "left"
@@ -51,6 +102,7 @@ const isMonomNode = (node, { variable, maxDegree, minDegree } = {
         const varChild = numericChild === "left" ? node.rightChild : node.leftChild;
         if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === variable && minDegree < 2)
             return true;
+        //new MonomNode(numericChild, 1, {variable});
         if ((0, powerNode_1.isPowerNode)(varChild) &&
             (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
             varChild.leftChild.name === variable &&
@@ -60,9 +112,10 @@ const isMonomNode = (node, { variable, maxDegree, minDegree } = {
                 return false;
             if (minDegree && powerEv < minDegree)
                 return false;
+            // new MonomNode(numericChild, powerEv, { variable });
             return true;
         }
     }
     return false;
 };
-exports.isMonomNode = isMonomNode;
+exports.isMonom = isMonom;

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

@@ -1,2 +1,2 @@
-export declare const powerParser: (ans: string) => false | import("../nodes/operators/fractionNode").FractionNode | import("../nodes/operators/powerNode").PowerNode;
+export declare const powerParser: (ans: string) => false | import("../nodes/operators/powerNode").PowerNode | import("../nodes/operators/fractionNode").FractionNode;
 //# sourceMappingURL=powerParser.d.ts.map

package/lib/tree/parsers/trinomParser.js

@@ -13,7 +13,7 @@ const trinomParser = (ans, variable = "x") => {
         const parsed = (0, latexParser_1.parseAlgebraic)(ans);
         if (!parsed)
             return false;
-        if ((0, monomParser_1.isMonomNode)(parsed, { variable, maxDegree: 2, minDegree: 2 }))
+        if ((0, monomParser_1.isMonom)(parsed, { variable, maxDegree: 2, minDegree: 2 }))
             return parsed;
         if ((0, addNode_1.isAddNode)(parsed) || (0, substractNode_1.isSubstractNode)(parsed)) {
             const children = [parsed.leftChild, parsed.rightChild];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.70",
+  "version": "2.2.71",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [