math-exercises 2.2.70 → 2.2.72

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

@@ -0,0 +1,216 @@
+"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({
+            forceDistributeFractions: true,
+        });
+    }
+    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,YAoHzC,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,32 @@ 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 &&
+            varChild.rightChild.isNumeric) {
+            const powerEv = varChild.rightChild.evaluate();
+            if (maxDegree && powerEv > maxDegree)
+                return false;
+            if (minDegree && powerEv < minDegree)
+                return false;
+            // new MonomNode(numericChild, powerEv, { variable });
+            return true;
+        }
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(node) && (0, multiplyNode_1.isMultiplyNode)(node.child)) {
+        const numericChild = node.child.leftChild.isNumeric
+            ? "left"
+            : node.child.rightChild.isNumeric
+                ? "right"
+                : undefined;
+        if (!numericChild)
+            return false;
+        const varChild = numericChild === "left" ? node.child.rightChild : node.child.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 +137,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/polynomialParser.d.ts

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../nodes/algebraicNode";
+export declare const polynomialParser: (ans: string) => false | AlgebraicNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/operators/substractNode").SubstractNode | import("../nodes/operators/addNode").AddNode;
+//# sourceMappingURL=polynomialParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAUvD,eAAO,MAAM,gBAAgB,QAAS,MAAM,8OAmC3C,CAAC"}

package/lib/tree/parsers/polynomialParser.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polynomialParser = void 0;
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const latexParser_1 = require("./latexParser");
+const monomParser_1 = require("./monomParser");
+const numberParser_1 = require("./numberParser");
+//!parses polynomes sous forme développée
+//minDegree = 0, max = undefined
+const polynomialParser = (ans) => {
+    try {
+        const nb = (0, numberParser_1.numberParser)(ans);
+        if (nb !== false) {
+            return nb.unfrenchify().toTree();
+        }
+        const monom = (0, monomParser_1.monomParser)(ans);
+        if (monom)
+            return monom;
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        if ((0, addNode_1.isAddNode)(parsed) || (0, substractNode_1.isSubstractNode)(parsed)) {
+            const externals = [];
+            const recursive = (node) => {
+                if ((0, addNode_1.isAddNode)(node)) {
+                    recursive(node.leftChild);
+                    recursive(node.rightChild);
+                }
+                else if ((0, substractNode_1.isSubstractNode)(node)) {
+                    recursive(node.leftChild);
+                    recursive(new oppositeNode_1.OppositeNode(node.rightChild));
+                }
+                else {
+                    externals.push(node);
+                }
+            };
+            recursive(parsed);
+            if (externals.every((node) => (0, monomParser_1.isMonom)(node))) {
+                return parsed;
+            }
+        }
+        return false;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.polynomialParser = polynomialParser;

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/lib/utils/average.d.ts

@@ -1,2 +1,3 @@
 export declare const average: (arr: number[]) => number;
+export declare const averageWithEffectifs: (values: number[], effectifs: number[]) => number;
 //# sourceMappingURL=average.d.ts.map

package/lib/utils/average.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"average.d.ts","sourceRoot":"","sources":["../../src/utils/average.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,QAAS,MAAM,EAAE,WAGpC,CAAC"}
+{"version":3,"file":"average.d.ts","sourceRoot":"","sources":["../../src/utils/average.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,QAAS,MAAM,EAAE,WAGpC,CAAC;AAEF,eAAO,MAAM,oBAAoB,WAAY,MAAM,EAAE,aAAa,MAAM,EAAE,WAOzE,CAAC"}

package/lib/utils/average.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.average = void 0;
+exports.averageWithEffectifs = exports.average = void 0;
 const average = (arr) => {
     if (!arr.length)
         return 0;
     return arr.reduce((acc, curr) => acc + curr) / arr.length;
 };
 exports.average = average;
+const averageWithEffectifs = (values, effectifs) => {
+    if (!values.length || !effectifs.length || values.length !== effectifs.length)
+        throw Error("Malformed data in average");
+    const N = effectifs.reduce((acc, curr) => acc + curr, 0);
+    const avg = values.reduce((acc, value, index) => acc + value * effectifs[index], 0) / N;
+    return avg;
+};
+exports.averageWithEffectifs = averageWithEffectifs;

package/lib/utils/latex/approxOrEqual.d.ts

@@ -0,0 +1,2 @@
+export declare const approxOrEqual: (value: number, roundTo: number) => string[];
+//# sourceMappingURL=approxOrEqual.d.ts.map

package/lib/utils/latex/approxOrEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approxOrEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/latex/approxOrEqual.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,UAAW,MAAM,WAAW,MAAM,aAI3D,CAAC"}

package/lib/utils/latex/approxOrEqual.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approxOrEqual = void 0;
+const round_1 = require("../../math/utils/round");
+const approxOrEqual = (value, roundTo) => {
+    const rounded = (0, round_1.round)(value, roundTo);
+    if (rounded === value)
+        return ["=", value.frenchify()];
+    return ["\\approx", rounded.frenchify()];
+};
+exports.approxOrEqual = approxOrEqual;

package/lib/utils/variance.d.ts

@@ -0,0 +1,2 @@
+export declare const variance: (arr: number[]) => number;
+//# sourceMappingURL=variance.d.ts.map

package/lib/utils/variance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variance.d.ts","sourceRoot":"","sources":["../../src/utils/variance.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,QAAS,MAAM,EAAE,WAMrC,CAAC"}

package/lib/utils/variance.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variance = void 0;
+const average_1 = require("./average");
+const variance = (arr) => {
+    if (!arr.length)
+        return 0;
+    const avg = (0, average_1.average)(arr);
+    const n = arr.length;
+    return arr.reduce((acc, curr) => acc + (curr - avg) ** 2) / n;
+};
+exports.variance = variance;

package/package.json

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