math-exercises 3.0.146 → 3.0.148

package/lib/index.d.ts

@@ -198,6 +198,10 @@ declare const mathExercises: (Exercise<{
 }, {
     quantityTypes: string[];
 }> | Exercise<{
+    rand: number;
+    a: number;
+    b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     type: number;
     a: number;
     b: number;
@@ -1045,9 +1049,12 @@ declare const mathExercises: (Exercise<{
     b: number;
     askingPositive: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    isLinear: boolean;
     b: number;
     secondPoint: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    isLinear: boolean;
+}> | Exercise<{
     b: number;
     secondPoint: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1084,7 +1091,9 @@ declare const mathExercises: (Exercise<{
     correctA: number;
     correctB: number;
     nameFunc: string;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    isLinear: boolean;
+}> | Exercise<{
     items: {
         fName: string;
         tex: string;
@@ -1593,6 +1602,13 @@ declare const mathExercises: (Exercise<{
         tex: string;
         isValid: boolean;
     }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationIndex: number;
+    x1: number;
+    y1: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationIndex: number;
+    numP: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coin: boolean;
     radius: number;
@@ -3575,9 +3591,12 @@ declare const pcExercises: (Exercise<{
     equaDiffIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isSolution: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    isLinear: boolean;
     b: number;
     secondPoint: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    isLinear: boolean;
+}> | Exercise<{
     tenthPower: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

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

@@ -0,0 +1,35 @@
+import { AlgebraicNode } from "../algebraicNode.js";
+import { NodeIds, NodeOptions, NodeType } from "../node.js";
+import { NodeIdentifiers } from "../nodeConstructor.js";
+export declare const notEqual: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => NotEqualNode;
+export type NotEqualNodeIdentifiers = {
+    id: NodeIds.notEqual;
+    leftChild: NodeIdentifiers;
+    rightChild: NodeIdentifiers;
+    opts?: NodeOptions;
+};
+export declare abstract class NotEqualNodeConstructor {
+    static fromIdentifiers(identifiers: NotEqualNodeIdentifiers): NotEqualNode;
+}
+export declare const isNotEqualNode: (node: AlgebraicNode) => node is NotEqualNode;
+export declare class NotEqualNode implements AlgebraicNode {
+    leftChild: AlgebraicNode;
+    rightChild: AlgebraicNode;
+    opts?: NodeOptions;
+    type: NodeType;
+    isNumeric: boolean;
+    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
+    toIdentifiers(): NotEqualNodeIdentifiers;
+    toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
+    toAllValidTexs(opts?: NodeOptions): string[];
+    toMathString(): string;
+    toTex(): string;
+    shuffle(): NotEqualNode;
+    reverse(): NotEqualNode;
+    evaluate(): number;
+    toDetailedEvaluation(): AlgebraicNode;
+    simplify(): AlgebraicNode;
+    equals(): boolean;
+    derivative(): AlgebraicNode;
+}
+//# sourceMappingURL=notEqualNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notEqualNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/notEqualNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAkB,MAAM,uBAAuB,CAAC;AAExE,eAAO,MAAM,QAAQ,GACnB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,iBAOnC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,uBAAuB;IAC3C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,uBAAuB,GAAG,YAAY;CAO3E;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,aAAa,KAAG,IAAI,IAAI,YACzB,CAAC;AAErC,qBAAa,YAAa,YAAW,aAAa;IAChD,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,uBAAuB;IAQxC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,OAAO;IAIP,OAAO;IAIP,QAAQ,IAAI,MAAM;IAGlB,oBAAoB,IAAI,aAAa;IAGrC,QAAQ,IAAI,aAAa;IAGzB,MAAM,IAAI,OAAO;IAGjB,UAAU,IAAI,aAAa;CAG5B"}

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

@@ -0,0 +1,84 @@
+// import { equal } from "mathjs";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { NodeIds, NodeType } from "../node.js";
+import { reifyAlgebraic } from "../nodeConstructor.js";
+export const notEqual = (a, b) => {
+    const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
+    const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
+    return new NotEqualNode(nodeA, nodeB);
+};
+export class NotEqualNodeConstructor {
+    static fromIdentifiers(identifiers) {
+        return new NotEqualNode(reifyAlgebraic(identifiers.leftChild), reifyAlgebraic(identifiers.rightChild), identifiers.opts);
+    }
+}
+export const isNotEqualNode = (node) => node.type === NodeType.notequality;
+export class NotEqualNode {
+    leftChild;
+    rightChild;
+    opts;
+    type;
+    isNumeric;
+    constructor(leftChild, rightChild, opts) {
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = NodeType.equality;
+        this.opts = opts;
+        this.isNumeric = false;
+    }
+    toIdentifiers() {
+        return {
+            id: NodeIds.notEqual,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+            opts: this.opts,
+        };
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes(options);
+        if (options?.allowRawRightChildAsSolution) {
+            res.push(...rightNodes);
+        }
+        const leftNodes = this.leftChild.toEquivalentNodes(options);
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new NotEqualNode(leftNode, rightNode, options));
+                res.push(new NotEqualNode(rightNode, leftNode, options));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs(opts) {
+        const options = opts ?? this.opts;
+        return this.toEquivalentNodes(options).map((node) => node.toTex());
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()} != ${this.rightChild.toMathString()}`;
+    }
+    toTex() {
+        return `${this.leftChild.toTex()} \\neq ${this.rightChild.toTex()}`;
+    }
+    shuffle() {
+        return coinFlip() ? this : this.reverse();
+    }
+    reverse() {
+        return new NotEqualNode(this.rightChild, this.leftChild, this.opts);
+    }
+    evaluate() {
+        throw new Error("unimplemented");
+    }
+    toDetailedEvaluation() {
+        throw new Error("unimplemented");
+    }
+    simplify() {
+        throw new Error("unimplemented");
+    }
+    equals() {
+        throw new Error("unimplemented");
+    }
+    derivative() {
+        throw new Error("unimplemented");
+    }
+}

package/lib/tree/utilities/nodeSimplifier.d.ts

@@ -0,0 +1,16 @@
+import { AlgebraicNode, SimplifyOptions } from "../nodes/algebraicNode.js";
+import { ToTexOptions } from "../nodes/node.js";
+export declare abstract class NodeSimplifier {
+    static getDepth: <T extends AlgebraicNode>(algebraicNode: T, simplifyOpts: SimplifyOptions, toTexOptions?: ToTexOptions) => number;
+    static getPEMDASPriority: (algebraicNode: AlgebraicNode) => 1 | 0 | 2 | 100 | -1 | 3 | 4 | 5;
+    static nodesSortedByPEMDASPriorityAsc: (nodes: AlgebraicNode[]) => AlgebraicNode[];
+    static nodesStepByStep: <T extends AlgebraicNode>(algebraicNode: T, simplifyOpts: SimplifyOptions, simplifierOpts?: {
+        isMultiTopLevel: boolean;
+    }, toTexOpts?: ToTexOptions) => AlgebraicNode[];
+    static arrTexStepByStep: (node: AlgebraicNode, simplifyOpts?: SimplifyOptions, simplifierOpts?: {
+        isMultiTopLevel: boolean;
+    }, toTexOpts?: ToTexOptions) => string[];
+    private static getCreateNodeFromChildrenFunction;
+    static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+}
+//# sourceMappingURL=nodeSimplifier.d.ts.map

package/lib/tree/utilities/nodeSimplifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeSimplifier.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeSimplifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAmC3E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhD,8BAAsB,cAAc;IAClC,MAAM,CAAC,QAAQ,GAAI,CAAC,SAAS,aAAa,EACxC,eAAe,CAAC,EAChB,cAAc,eAAe,EAC7B,eAAc,YAIb,KACA,MAAM,CAsBP;IAEF,MAAM,CAAC,iBAAiB,GAAI,eAAe,aAAa,sCAmCtD;IAEF,MAAM,CAAC,8BAA8B,GAAI,OAAO,aAAa,EAAE,qBAK7D;IAEF,MAAM,CAAC,eAAe,GAAI,CAAC,SAAS,aAAa,EAC/C,eAAe,CAAC,EAChB,cAAc,eAAe,EAC7B,iBAAgB;QACd,eAAe,EAAE,OAAO,CAAC;KAG1B,EACD,YAAW,YAIV,KACA,aAAa,EAAE,CA4JhB;IAEF,MAAM,CAAC,gBAAgB,GACrB,MAAM,aAAa,EACnB,eAAc,eAAoB,EAClC,iBAAgB;QACd,eAAe,EAAE,OAAO,CAAC;KAG1B,EACD,YAAW,YAIV,cAQD;IAEF,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAgF9C;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}

package/lib/tree/utilities/nodeSimplifier.js

@@ -0,0 +1,283 @@
+import { abs } from "../nodes/functions/absNode.js";
+import { arccos } from "../nodes/functions/arccosNode.js";
+import { CosNode } from "../nodes/functions/cosNode.js";
+import { FunctionsIds, isFunctionNode, } from "../nodes/functions/functionNode.js";
+import { AddNode, isAddNode } from "../nodes/operators/addNode.js";
+import { BinomialCoefficientNode } from "../nodes/operators/binomialCoefficientNode.js";
+import { DivideNode, isDivideNode } from "../nodes/operators/divideNode.js";
+import { FractionNode } from "../nodes/operators/fractionNode.js";
+import { isMultiplyNode, MultiplyNode, } from "../nodes/operators/multiplyNode.js";
+import { PowerNode } from "../nodes/operators/powerNode.js";
+import { isSubstractNode, SubstractNode, } from "../nodes/operators/substractNode.js";
+import { sin } from "../nodes/functions/sinNode.js";
+import { sqrt } from "../nodes/functions/sqrtNode.js";
+import { tan } from "../nodes/functions/tanNode.js";
+import { ArcsinNode } from "../nodes/functions/arcSinNode.js";
+import { ArctanNode } from "../nodes/functions/arctanNode.js";
+import { ExpNode } from "../nodes/functions/expNode.js";
+import { LogNode } from "../nodes/functions/logNode.js";
+import { Log10Node } from "../nodes/functions/log10Node.js";
+import { NodeConstructor } from "../nodes/nodeConstructor.js";
+import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
+import { opposite } from "../nodes/functions/oppositeNode.js";
+import { isNumberNode } from "../nodes/numbers/numberNode.js";
+export class NodeSimplifier {
+    static getDepth = (algebraicNode, simplifyOpts, toTexOptions = {
+        forceTimesSign: true,
+        forceParenthesis: true,
+        forceNoSimplification: true,
+    }) => {
+        const children = this.getChildren(algebraicNode);
+        if (children.length === 0) {
+            return 0;
+        }
+        else {
+            const nodeSimplified = algebraicNode.simplify(simplifyOpts);
+            if (nodeSimplified.toTex(toTexOptions) === algebraicNode.toTex(toTexOptions)) {
+                return 0;
+            }
+            else {
+                return (1 +
+                    Math.max(...children.map((nodeChild) => this.getDepth(nodeChild, simplifyOpts, toTexOptions))));
+            }
+        }
+    };
+    static getPEMDASPriority = (algebraicNode) => {
+        if (isOperatorNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case OperatorIds.power:
+                case OperatorIds.square:
+                    return 1;
+                case OperatorIds.multiply:
+                    return 2;
+                case OperatorIds.divide:
+                case OperatorIds.fraction:
+                    return 3;
+                case OperatorIds.add: {
+                    //sometimes add is substract
+                    const addNode = algebraicNode;
+                    if (isNumberNode(addNode.rightChild) &&
+                        addNode.rightChild.evaluate() < 0) {
+                        return 5;
+                    }
+                    return 4;
+                }
+                case OperatorIds.substract:
+                    return 5;
+                default:
+                    return 100;
+            }
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                default:
+                    return 0;
+            }
+        }
+        else {
+            return -1;
+        }
+    };
+    static nodesSortedByPEMDASPriorityAsc = (nodes) => {
+        return nodes.toSorted((node1, node2) => this.getPEMDASPriority(node1) - this.getPEMDASPriority(node2));
+    };
+    static nodesStepByStep = (algebraicNode, simplifyOpts, simplifierOpts = {
+        isMultiTopLevel: false,
+    }, toTexOpts = {
+        forceTimesSign: true,
+        forceParenthesis: true,
+        forceNoSimplification: true,
+    }) => {
+        const depth = this.getDepth(algebraicNode, simplifyOpts, toTexOpts);
+        switch (depth) {
+            case 0:
+                return [algebraicNode];
+            case 1:
+                return [algebraicNode, algebraicNode.simplify(simplifyOpts)];
+            default:
+                return [
+                    ...(() => {
+                        const arrArrChild = this.getChildren(algebraicNode).map((nodeChild) => this.nodesStepByStep(nodeChild, simplifyOpts, simplifierOpts));
+                        const maxLength = Math.max(...arrArrChild.map((nodesSByS) => nodesSByS.length));
+                        //multi or single here
+                        let arrChildren;
+                        if (simplifierOpts.isMultiTopLevel) {
+                            //multi
+                            arrChildren = [...Array(maxLength - 1).keys()]
+                                .map((i) => i + 1)
+                                .map((i) => arrArrChild.map((nodesSByS) => nodesSByS[Math.min(i, nodesSByS.length - 1)]));
+                        }
+                        else {
+                            //single: follow priority
+                            const dictNodesSBySByPriority = arrArrChild.reduce((acc, nodesSByS, i) => {
+                                const pemdasPriority = this.getPEMDASPriority(nodesSByS[0]);
+                                if (!acc[pemdasPriority]) {
+                                    acc[pemdasPriority] = {};
+                                }
+                                acc[pemdasPriority][i] = nodesSByS;
+                                return acc;
+                            }, {});
+                            arrChildren = [...Array(maxLength - 1).keys()]
+                                .map((i) => i + 1)
+                                .flatMap((i) => {
+                                const indexes = Object.values(dictNodesSBySByPriority).reduce((acc, dict) => {
+                                    acc.push(...Object.keys(dict).map((k) => +k));
+                                    return acc;
+                                }, []);
+                                const arrDictIndex = indexes.reduce((acc, _, i) => {
+                                    const dict = indexes.reduce((acc, y, j) => {
+                                        acc[y] = j <= i;
+                                        return acc;
+                                    }, {});
+                                    acc.push(dict);
+                                    return acc;
+                                }, []);
+                                const arrArrWave = arrDictIndex.map((dictIndex) => {
+                                    return arrArrChild.map((nodesSByS, k) => {
+                                        if (dictIndex[k]) {
+                                            return nodesSByS[Math.min(i, nodesSByS.length - 1)];
+                                        }
+                                        else {
+                                            return nodesSByS[Math.min(i - 1, nodesSByS.length - 1)];
+                                        }
+                                    });
+                                });
+                                //keep distinct
+                                const dictDistinct = Object.fromEntries(arrArrWave.map((arrChild) => {
+                                    const strId = arrChild
+                                        .map((node) => node.toTex(toTexOpts))
+                                        .join("&&&");
+                                    return [strId, arrChild];
+                                }));
+                                return Object.values(dictDistinct);
+                            });
+                        }
+                        const isNeedsRewritingAddToSub = (algebraicNode, children) => {
+                            const isAdd = () => isAddNode(algebraicNode);
+                            const isAddXSub = () => {
+                                return isSubstractNode(children[1]);
+                            };
+                            const isAddXAddYNeg = () => {
+                                return (isAddNode(children[1]) &&
+                                    // isNumberNode(children[1].rightChild) &&
+                                    children[1].rightChild.evaluate() < 0);
+                            };
+                            return isAdd() && (isAddXSub() || isAddXAddYNeg());
+                        };
+                        const isNeedsRewritingMultToDiv = (algebraicNode, children) => {
+                            const isMult = () => isMultiplyNode(algebraicNode);
+                            const isMultXDiv = () => {
+                                return isDivideNode(children[1]);
+                            };
+                            return isMult() && isMultXDiv();
+                        };
+                        return arrChildren.map((childrenRefined) => {
+                            if (childrenRefined.length === 2) {
+                                if (isNeedsRewritingAddToSub(algebraicNode, childrenRefined)) {
+                                    //a + (b - c) -> (a + b) - c
+                                    if (isSubstractNode(childrenRefined[1])) {
+                                        const subNode = childrenRefined[1];
+                                        return new SubstractNode(new AddNode(childrenRefined[0], subNode.leftChild), subNode.rightChild);
+                                    }
+                                    else {
+                                        const addNode = childrenRefined[1];
+                                        return new SubstractNode(new AddNode(childrenRefined[0], addNode.leftChild), abs(addNode.rightChild).simplify());
+                                    }
+                                }
+                                else if (isNeedsRewritingMultToDiv(algebraicNode, childrenRefined)) {
+                                    //a * (b / c) -> (a * b) / c
+                                    const divNode = childrenRefined[1];
+                                    return new DivideNode(new MultiplyNode(childrenRefined[0], divNode.leftChild), divNode.rightChild);
+                                }
+                                else {
+                                    return this.getCreateNodeFromChildrenFunction(algebraicNode)(childrenRefined);
+                                }
+                            }
+                            else {
+                                return this.getCreateNodeFromChildrenFunction(algebraicNode)(childrenRefined);
+                            }
+                        });
+                    })(),
+                    algebraicNode.simplify(simplifyOpts),
+                ];
+        }
+    };
+    static arrTexStepByStep = (node, simplifyOpts = {}, simplifierOpts = {
+        isMultiTopLevel: false,
+    }, toTexOpts = {
+        forceTimesSign: true,
+        forceParenthesis: true,
+        forceNoSimplification: true,
+    }) => {
+        return this.nodesStepByStep(node, simplifyOpts, simplifierOpts, toTexOpts).map((node) => node.toTex(toTexOpts));
+    };
+    static getCreateNodeFromChildrenFunction = (algebraicNode) => {
+        if (isOperatorNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case OperatorIds.binomialCoefficient:
+                    return (children) => new BinomialCoefficientNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.divide:
+                    return (children) => new DivideNode(children[0], children[1]);
+                case OperatorIds.fraction:
+                    return (children) => new FractionNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.integral:
+                    //   throw new Error("unsupported node type: integral");  //need to do intelligent shuffle here
+                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
+                case OperatorIds.limit:
+                    //   throw new Error("unsupported node type: limit");   //need to do intelligent shuffle here
+                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
+                case OperatorIds.multiply:
+                    return (children) => new MultiplyNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.power:
+                case OperatorIds.square: //this is so nice
+                    return (children) => new PowerNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.substract:
+                    return (children) => new SubstractNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.add:
+                    return (children) => new AddNode(children[0], children[1], algebraicNode.opts);
+            }
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case FunctionsIds.arccos:
+                    return (children) => arccos(children[0]);
+                case FunctionsIds.arcsin:
+                    return (children) => new ArcsinNode(children[0]);
+                case FunctionsIds.arctan:
+                    return (children) => new ArctanNode(children[0]);
+                case FunctionsIds.cos:
+                    return (children) => new CosNode(children[0]);
+                case FunctionsIds.exp:
+                    return (children) => new ExpNode(children[0], algebraicNode.opts);
+                case FunctionsIds.log:
+                    return (children) => new LogNode(children[0], algebraicNode.opts);
+                case FunctionsIds.log10:
+                    return (children) => new Log10Node(children[0], algebraicNode.opts);
+                case FunctionsIds.opposite:
+                    return (children) => opposite(children[0]);
+                case FunctionsIds.sin:
+                    return (children) => sin(children[0]);
+                case FunctionsIds.sqrt:
+                    return (children) => sqrt(children[0]);
+                case FunctionsIds.tan:
+                    return (children) => tan(children[0]);
+                case FunctionsIds.abs:
+                    return (children) => abs(children[0]);
+            }
+        }
+        else {
+            return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
+        }
+    };
+    static getChildren(algebraicNode) {
+        if (isOperatorNode(algebraicNode)) {
+            return [algebraicNode.leftChild, algebraicNode.rightChild];
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            return [algebraicNode.child];
+        }
+        else {
+            return [];
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.146",
+  "version": "3.0.148",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [