@khanacademy/kas 0.2.3

package/src/__tests__/checking-form_test.js

@@ -0,0 +1,76 @@
+import _ from "underscore";
+
+import * as KAS from "../index.js";
+
+expect.extend({
+    toHaveNorm(input: string, reference: string) {
+        var actual = KAS.parse(input).expr.normalize().print();
+        var expected = KAS.parse(reference).expr.normalize().print();
+
+        return {
+            pass: actual === expected,
+            message: () => `${input} is the same as ${reference}`,
+        };
+    },
+    toHaveStripNorm(input: string, reference: string) {
+        var actual = KAS.parse(input).expr.strip().normalize().print();
+        var expected = KAS.parse(reference).expr.strip().normalize().print();
+
+        return {
+            pass: actual === expected,
+            message: () => `${input} is the same as ${reference}`,
+        };
+    },
+});
+
+describe("checking form", () => {
+    test("normalize", () => {
+        expect("ab").toHaveNorm("ba");
+        expect("(ab)c").toHaveNorm("(cb)a");
+
+        var forms = [
+            "(6x+1)(x-1)",
+            "(1+6x)(x-1)",
+            "(6x+1)(-1+x)",
+            "(1+6x)(-1+x)",
+            "(x-1)(6x+1)",
+            "(x-1)(1+6x)",
+            "(-1+x)(6x+1)",
+            "(-1+x)(1+6x)"
+        ];
+
+        _.each(forms, function(form) {
+            expect(forms[0]).toHaveNorm(form);
+        });
+    });
+
+    test("strip then normalize", () => {
+        expect("ab").toHaveStripNorm("ba");
+        expect("(ab)c").toHaveStripNorm("(cb)a");
+
+        var forms = [
+            "(6x+1)(x-1)",
+            "(1+6x)(x-1)",
+            "(6x+1)(-1+x)",
+            "(1+6x)(-1+x)",
+            "(-6x-1)(-x+1)",
+            "(-1-6x)(-x+1)",
+            "(-6x-1)(1-x)",
+            "(-1-6x)(1-x)",
+            "(x-1)(6x+1)",
+            "(x-1)(1+6x)",
+            "(-1+x)(6x+1)",
+            "(-1+x)(1+6x)",
+            "(-x+1)(-6x-1)",
+            "(-x+1)(-1-6x)",
+            "(1-x)(-6x-1)",
+            "(1-x)(-1-6x)",
+            "-(6x+1)(1-x)",
+            "-(-6x-1)(x-1)"
+        ];
+
+        _.each(forms, function(form) {
+            expect(forms[0]).toHaveStripNorm(form);
+        });
+    });
+});

package/src/__tests__/comparing_test.js

@@ -0,0 +1,322 @@
+import _ from "underscore";
+
+import * as KAS from "../index.js";
+
+expect.extend({
+    toEqualExpr(input: string, expected: string) {
+        const inputExpr = KAS.parse(input, {functions: ["f", "g", "h"]}).expr;
+        const expectedExpr = KAS.parse(expected, {
+            functions: ["f", "g", "h"],
+        }).expr;
+
+        const actual = KAS.compare(inputExpr, expectedExpr, {form: false});
+
+        if (this.isNot) {
+            return actual.equal
+                ? {pass: true}
+                : {
+                      pass: false,
+                      message: () => `${input} is NOT the same as ${expected}`,
+                  };
+        }
+        return actual.equal
+            ? {pass: true}
+            : {
+                  pass: false,
+                  message: () => `${input} is the same as ${expected}`,
+              };
+    },
+    toEqualExprAndForm(input: string, expected: string) {
+        const inputExpr = KAS.parse(input, {functions: ["f", "g", "h"]}).expr;
+        const expectedExpr = KAS.parse(expected, {
+            functions: ["f", "g", "h"],
+        }).expr;
+
+        const actual = KAS.compare(inputExpr, expectedExpr, {form: true});
+
+        if (this.isNot) {
+            return actual.equal
+                ? {pass: true}
+                : {
+                      pass: false,
+                      message: () => `${input} is NOT the same as ${expected}`,
+                  };
+        }
+        return actual.equal
+            ? {pass: true}
+            : {
+                  pass: false,
+                  message: () => `${input} is the same as ${expected}`,
+              };
+    },
+});
+
+describe("comparing", () => {
+    test("evaluate only", () => {
+        expect("2+2").toEqualExpr("4");
+        expect("a(b+c)").toEqualExpr("ab+ac");
+        expect("a/b").toEqualExpr("a*b^-1");
+
+        expect("1.2^2").toEqualExpr("1.44");
+        expect("1.3^2").toEqualExpr("1.69");
+        expect("1.4^2").toEqualExpr("1.96");
+        expect("1.5^2").toEqualExpr("2.25");
+
+        expect("1.2345^2").toEqualExpr("1.52399025");
+        expect("1.2345*1.2345").toEqualExpr("1.52399025");
+        expect("(1+.2345)^2").toEqualExpr("1.52399025");
+        expect("(-5)^(1/3)").toEqualExpr("-1.709975946");
+        expect("(-5)^(2/6)").toEqualExpr("-1.709975946");
+        expect("(-5)^(4/3)").toEqualExpr("8.549879733");
+        expect("(-5)^(-1/3)").toEqualExpr("-0.584803547");
+
+        expect("(-5)^(1/5)").toEqualExpr("-1.379729661");
+        expect("(-5)^(0.2)").toEqualExpr("-1.379729661");
+
+        expect("x^(1/5)").toEqualExpr("x^(0.2)");
+        expect("x^(8/5)").toEqualExpr("x^(1.6)");
+
+        expect("(1-x)(-1-6x)").toEqualExpr("(6x+1)(x-1)");
+        expect("y=x").not.toEqualExpr("x");
+        expect("x").not.toEqualExpr("y=x");
+        expect("y=x").toEqualExpr("y=x");
+        expect("y=x").toEqualExpr("x=y");
+        expect("y=x").toEqualExpr("-y=-x");
+        expect("y=x").toEqualExpr("-x=-y");
+        expect("y=x").not.toEqualExpr("y=-x");
+        expect("y=x").not.toEqualExpr("-y=x");
+        expect("y=x").not.toEqualExpr("y=/=x");
+        expect("y<x").toEqualExpr("x>y");
+        expect("y<=x").toEqualExpr("x>=y");
+        expect("y>x").toEqualExpr("x<y");
+        expect("y>x").not.toEqualExpr("x>y");
+        expect("y>=x").toEqualExpr("x<=y");
+        expect("a+b<c-d").toEqualExpr("a+b-c+d<0");
+
+        expect("y=mx+b").toEqualExpr("-b-mx=-y");
+        expect("y=mx+b").toEqualExpr("y-b=mx");
+
+        // all of these normalize to the same expression, set to zero
+        const forms = [
+            "y=2x-5",
+            "2x-5=y",
+            "2x-y=5",
+            "(y+5)/2=x",
+            "(y+5)/x=2",
+            "1/2(y+5)=x",
+            ".5(y+5)=x",
+            "y-3=2(x-4)",
+            "2y=4x-10",
+            "yz=2xz-5z",
+        ];
+
+        _.each(forms, (form) => {
+            expect(forms[0]).toEqualExpr(form);
+        });
+
+        expect("3y=2x-15").toEqualExpr("3/2(y+5)=x");
+
+        const forms2 = ["1/3p-3=114", "1/3p=117", "p=351", "p-351=0"];
+
+        _.each(forms2, (form) => {
+            expect(forms2[0]).toEqualExpr(form);
+        });
+
+        expect("x").toEqualExpr("xy/y");
+        expect("e^x").toEqualExpr("e^x");
+        expect("e^x").not.toEqualExpr("e^x + 1");
+
+        const forms3 = [
+            "x+x+x+6=12",
+            "x+2x+6=12",
+            "3x+6=12",
+            "x+2x=6",
+            "2x=6-x",
+            "3x=6",
+            "x=2",
+        ];
+
+        _.each(forms3, function (form) {
+            expect(forms3[0]).toEqualExpr(form);
+        });
+
+        expect("100/55.6=t").toEqualExpr("t=100/55.6");
+        expect("100/1.6^2=t").toEqualExpr("t=100/1.6^2");
+        expect("7/3x+x=15").toEqualExpr("(2+1/3)x+x=15");
+        expect("7/3x+x=15").not.toEqualExpr("(1+1/3)x+x=15");
+
+        // Symmetric equations
+        expect("x^2+y^2=r^2").toEqualExpr("r^2=x^2+y^2");
+        expect("23^1.5=110.304").toEqualExpr("110.304=23^1.5");
+
+        // TODO(alex): make sure that I have both positive and negative
+        // test cases for all functionality
+        expect("6.12*10^-2").toEqualExpr("6.12*10^-2");
+        expect("6.12*10^-2").not.toEqualExpr("6.12*10^-6");
+
+        expect("3^-x").toEqualExpr("(1/3)^x");
+        expect("(1/3)^-x").toEqualExpr("3^x");
+        expect("(3)^-x").not.toEqualExpr("3^x");
+
+        expect("5.6=x+0.4+5.2").toEqualExpr("5.6=x+0.4+5.2");
+
+        // Reciprocal trig functions
+        expect("csc x").toEqualExpr("1/sin x");
+        expect("sec x").toEqualExpr("1/cos x");
+        expect("cot x").toEqualExpr("1/tan x");
+        expect("arccsc x").toEqualExpr("arcsin (1/x)");
+        expect("arcsec x").toEqualExpr("arccos (1/x)");
+        expect("arccot x").toEqualExpr("arctan (1/x)");
+
+        // Reciprocal hyperbolic trig functions
+        expect("csch x").toEqualExpr("1/sinh x");
+        expect("sech x").toEqualExpr("1/cosh x");
+        expect("coth x").toEqualExpr("1/tanh x");
+
+        // Make sure trig functions that are the same for all integer values
+        // are not the same
+        expect("-2sin(pi x) + 4").not.toEqualExpr("4");
+        expect("2sin(pi x) + 4").not.toEqualExpr("-2sin(pi x) + 4");
+        expect("sin(pi x)").not.toEqualExpr("0");
+        expect("0").not.toEqualExpr("sin(pi x)");
+        expect("cos(pi x)").not.toEqualExpr("cos(2 pi x)");
+        expect("sin(pi x)").not.toEqualExpr("sin(500pi x)");
+        expect("sin(500pi x)").not.toEqualExpr("sin(pi x)");
+
+        // Check that floating point error isn't killing us
+        // TODO(jack): These don't seem to test much; make better tests
+        expect("0").toEqualExpr("sin(7pi)");
+        expect("sin(7pi)").toEqualExpr("0");
+        expect("0").toEqualExpr("sin(500pi)");
+        expect("sin(500pi)").toEqualExpr("0");
+
+        // Handle denominators the same way regardless of a fraction's format
+        expect("x=1.2^2").toEqualExpr("x=1.44");
+        expect("x=1.2^2").toEqualExpr("x=36/25");
+        expect("x=1.44").toEqualExpr("x=36/25");
+        expect("x=1.44").not.toEqualExpr("x=35/25");
+
+        expect("x=1.2^(2y)").toEqualExpr("x=1.44^y");
+        expect("x=1.2^(2y)").toEqualExpr("x=(36/25)^y");
+        expect("x=1.44^y").toEqualExpr("x=(36/25)^y");
+
+        expect("x=1.3^2").toEqualExpr("x=1.69");
+        expect("x=1.4^2").toEqualExpr("x=1.96");
+        expect("x=1.5^2").toEqualExpr("x=2.25");
+        expect("x=1.5^2").toEqualExpr("x=2.25");
+
+        expect("x=1.2345^2").toEqualExpr("x=1.52399025");
+        expect("x=1.2345*1.2345").toEqualExpr("x=1.52399025");
+        expect("x=(1+.2345)^2").toEqualExpr("x=1.52399025");
+        expect("x=(1+.2345)^2").not.toEqualExpr("x=1.52399022");
+
+        // Varying small and large comparisons
+        expect("1.1234567891235 * 10^200").toEqualExpr(
+            "1.1234567891234 * 10^200",
+        );
+        expect("1.1234567891235 * 10^200").not.toEqualExpr("0.10");
+        expect("0.10").not.toEqualExpr("1.1234567891235 * 10^200");
+        expect("0.50").not.toEqualExpr("0.51");
+        expect("0.51").not.toEqualExpr("0.50");
+
+        expect("1.00").toEqualExpr("1.00");
+        expect("0.9").not.toEqualExpr("1.1");
+        expect("1.1").not.toEqualExpr("0.9");
+
+        // Real-world examples of equivalent equations that are now accepted
+        expect("12(1-r)^2+58(1-r)=10").toEqualExpr("(1-r)(70-12r)=10");
+        expect("720m+480(m-5)=42000").toEqualExpr("720m+480m-2400=42000");
+        expect("2w+50/w=25").toEqualExpr("w(12.5-w)=25");
+        expect("(n*(8+4n))/2>19206").toEqualExpr("6n+2n(n-1)>19206");
+
+        // Correctly handle exponents with negative bases and variables in exponent
+        expect("( 2)^n").not.toEqualExpr("( 2)^(n-1)");
+        expect("( 2)^n").toEqualExpr("( 2)^(n)");
+        expect("( 2)^n").not.toEqualExpr("( 2)^(n+1)");
+
+        expect("(-2)^n").not.toEqualExpr("(-2)^(n-1)");
+        expect("(-2)^n").toEqualExpr("(-2)^(n)");
+        expect("(-2)^n").not.toEqualExpr("(-2)^(n+1)");
+
+        expect("(-2)^(a)").not.toEqualExpr("(-2)^(ab)");
+        expect("(-2)^(a)").not.toEqualExpr("(-2)^(a^b)");
+
+        // This is incorrect, but accurately captures the current behavior
+        // See comment in `Expr.compare()` for more details
+        expect("(-2)^(n+0.1)").toEqualExpr("(-2)^(n+1.1)");
+    });
+
+    test("simplify can't yet handle these", () => {
+        expect("sin(x + 2pi)").toEqualExpr("sin(x)");
+        expect("y = sin(x + 2pi)").toEqualExpr("y = sin(x)");
+        expect("sin^2(x)+cos^2(x)").toEqualExpr("x/x");
+        expect("y = sin^2(x)+cos^2(x)").toEqualExpr("y = x/x");
+    });
+
+    test("partially evaluating functions", () => {
+        expect("f(x)").toEqualExpr("f(x)");
+        expect("f(x)").not.toEqualExpr("g(x)");
+        expect("f(g(x))").toEqualExpr("f(g(x))");
+        expect("sin(f(3x-x))/cos(f(x+x))").toEqualExpr("tan(f(2x))");
+        expect("f(x) = sin(x + 2pi)").toEqualExpr("f(x) = sin(x)");
+        // NOTE(kevinb): This test is flaky, because Expr.prototype.compare
+        // is non-deterministic.  When comparing expressions this normally
+        // wouldn't be an issue because we could just evaluate the different
+        // variables at different point and then check that the difference
+        // between the expressions is always less than some very small number.
+        // In this case though, we convert equations to expressions, e.g.
+        // `f(x) = 1` is converted to `1-f(x)`, but because `f` is a function,
+        // we can't evaluate it.  One possible solution to this would be
+        // to isolate `f(x)` in each expression and then check that the
+        // expressions that they're equal to are equal.  In this case that
+        // would be `sin^2(x)+cos^2(x)` and `1`.
+        // TODO(TP-11651): Update compare to isolate functions on wide side
+        // before comparing expressions on the other side.
+        // expect("f(x) = sin^2(x)+cos^2(x)").toEqualExpr("f(x) = 1");
+        expect("f(x) = ln|x|+c").toEqualExpr("f(x)-ln|x|-c = 0");
+    });
+
+    test("evaluating and comparing form", () => {
+        expect("ab").toEqualExprAndForm("ba");
+        expect("(ab)c").toEqualExprAndForm("(cb)a");
+
+        const forms = [
+            "(6x+1)(x-1)",
+            "(1+6x)(x-1)",
+            "(6x+1)(-1+x)",
+            "(1+6x)(-1+x)",
+            "(-6x-1)(-x+1)",
+            "(-1-6x)(-x+1)",
+            "(-6x-1)(1-x)",
+            "(-1-6x)(1-x)",
+            "(x-1)(6x+1)",
+            "(x-1)(1+6x)",
+            "(-1+x)(6x+1)",
+            "(-1+x)(1+6x)",
+            "(-x+1)(-6x-1)",
+            "(-x+1)(-1-6x)",
+            "(1-x)(-6x-1)",
+            "(1-x)(-1-6x)",
+            "-(6x+1)(1-x)",
+            "-(-6x-1)(x-1)",
+        ];
+
+        _.each(forms, function (form) {
+            expect(forms[0]).toEqualExprAndForm(form);
+        });
+
+        expect("(6x+1)(x+1)").not.toEqualExprAndForm("(6x+1)(x-1)");
+        expect("a-b-c").not.toEqualExprAndForm("c+b+a");
+
+        expect("(6x+1)(x+1)").not.toEqualExprAndForm("(6x+1)(x-1)");
+        expect("a-b-c").not.toEqualExprAndForm("c+b+a");
+        expect("mx+b").toEqualExprAndForm("b+mx");
+
+        expect("y=mx+b").toEqualExprAndForm("-b-mx=-y");
+        expect("y=mx+b").not.toEqualExprAndForm("y-b=mx");
+
+        expect("y-3=2(x-4)").not.toEqualExprAndForm("y=2x-5");
+        expect("y-3=2(x-4)").not.toEqualExprAndForm("2x-y=5");
+        expect("y=2x-5").not.toEqualExprAndForm("2x-y=5");
+    });
+});

package/src/__tests__/compilation_test.js

@@ -0,0 +1,97 @@
+import _ from "underscore";
+
+import * as KAS from "../index.js";
+
+expect.extend({
+    toCompileAs(
+        input: string,
+        expected: number,
+        vars?: {[string]: string | number | (number) => number} = {},
+    ) {
+        const functions = Object.keys(vars).filter(k => typeof vars[k] === 'function');
+        const func = KAS.parse(input, {functions}).expr.compile();
+
+        const actual = func(vars);
+
+        return Math.abs(actual - expected) < 1e-9
+            ? {pass: true}
+            : {
+                  pass: false,
+                  message: () =>
+                      `${input} should evaluate to ${expected}, was ${actual}; by func: ${func.toString()}`,
+              };
+    },
+});
+
+describe("compilation", () => {
+    test("empty", () => {
+        expect("").toCompileAs(0);
+    });
+
+    test("simple expressions", () => {
+        expect("1+2+3+4").toCompileAs(10);
+        expect("1+2-3+4").toCompileAs(4);
+        expect("1*2*3*4").toCompileAs(24);
+        expect("1*2/3*4").toCompileAs(2 + 2 / 3);
+        expect("4^3^2^1").toCompileAs(262144);
+        expect("-1").toCompileAs(-1);
+        expect("--1").toCompileAs(1);
+        expect("---1").toCompileAs(-1);
+        expect("2^-2").toCompileAs(0.25);
+        expect("8^(1/3)").toCompileAs(2);
+        expect("0^0").toCompileAs(1);
+        expect(".25*4").toCompileAs(1);
+        expect("ln e").toCompileAs(1);
+        expect("log 10").toCompileAs(1);
+        expect("log_2 2").toCompileAs(1);
+    });
+
+    test("variable expressions", () => {
+        expect("x").toCompileAs(3, {x: 3});
+        expect("x^2").toCompileAs(9, {x: 3});
+        expect("(x^2+y^2)^.5").toCompileAs(5, {x: 3, y: 4});
+        expect("log x_0").toCompileAs(1, {x_0: 10});
+        expect("log x_0 + log x_1").toCompileAs(3, {x_0: 10, x_1: 100});
+        expect("log x_42").toCompileAs(1, {x_42: 10});
+        expect("x_a + x_bc").toCompileAs(7, {x_a: 1, x_b: 2, c: 3});
+    });
+
+    test("function expressions", () => {
+        expect("f(2)").toCompileAs(
+            4,
+            {
+                f: function (x) {
+                    return 2 * x;
+                },
+            },
+        );
+        expect("f(4+8)").toCompileAs(
+            48,
+            {
+                f: function (x) {
+                    return 4 * x;
+                },
+            },
+        );
+        expect("f(x-1)-f(x)").toCompileAs(
+            -7,
+            {
+                f: function (x) {
+                    return Math.pow(x, 3);
+                },
+                x: 2,
+            },
+        );
+    });
+
+    test("trig expressions", () => {
+        expect("-2sin(pi x) + 4").toCompileAs(4, {x: 32});
+        expect("sin(pi x)").toCompileAs(0, {x: 6});
+        expect("sin(x)").toCompileAs(1, {x: Math.PI / 2});
+        expect("sin(pi x)").toCompileAs(-1, {x: 3 / 2});
+        expect("cos(x)").toCompileAs(1, {x: 0});
+        expect("cos x").toCompileAs(-1, {x: Math.PI});
+        expect("tan(x)").toCompileAs(0, {x: 0});
+        expect("tan x").toCompileAs(1, {x: Math.PI / 4});
+    });
+});

package/src/__tests__/evaluating_test.js

@@ -0,0 +1,73 @@
+import _ from "underscore";
+
+import * as KAS from "../index.js";
+
+expect.extend({
+    toEvaluateAs(
+        input: string,
+        expected: number,
+        vars?: {[string]: string | number} = {},
+        functions?: $ReadOnlyArray<string>,
+    ) {
+        const actual = KAS.parse(input, {functions: functions}).expr.eval(
+            vars,
+            {functions: functions},
+        );
+
+        if (actual !== expected) {
+            return {
+                pass: actual !== expected,
+                message: () => `${input} evaluates as ${expected}`,
+            };
+        }
+
+        return {pass: !this.isNot};
+    },
+});
+
+describe("evaluating", () => {
+    test("empty", () => {
+        expect("").toEvaluateAs(0);
+    });
+
+    test("simple expressions", () => {
+        expect("1+2+3+4").toEvaluateAs(10);
+        expect("1+2-3+4").toEvaluateAs(4);
+        expect("1*2*3*4").toEvaluateAs(24);
+        expect("1*2/3*4").toEvaluateAs(2 + 2 / 3);
+        expect("4^3^2^1").toEvaluateAs(262144);
+        expect("-1").toEvaluateAs(-1);
+        expect("--1").toEvaluateAs(1);
+        expect("---1").toEvaluateAs(-1);
+        expect("2^-2").toEvaluateAs(0.25);
+        expect("8^(1/3)").toEvaluateAs(2);
+        expect("0^0").toEvaluateAs(1);
+        expect(".25*4").toEvaluateAs(1);
+        expect("ln e").toEvaluateAs(1);
+        expect("log 10").toEvaluateAs(1);
+        expect("log_2 2").toEvaluateAs(1);
+    });
+
+    test("hyperbolic expressions", () => {
+        expect("cosh(0.2)").toEvaluateAs(1.020066755619076);
+        expect("coth(0.2)").toEvaluateAs(5.066489563439473);
+        expect("csch(3 * 2)").toEvaluateAs(0.00495753481347936);
+    });
+
+    test("variable expressions", () => {
+        expect("x").toEvaluateAs(3, {x: 3});
+        expect("x^2").toEvaluateAs(9, {x: 3});
+        expect("(x^2+y^2)^.5").toEvaluateAs(5, {x: 3, y: 4});
+        expect("log x_0").toEvaluateAs(1, {x_0: 10});
+        expect("log x_0 + log x_1").toEvaluateAs(3, {x_0: 10, x_1: 100});
+        expect("log x_42").toEvaluateAs(1, {x_42: 10});
+        expect("x_a + x_bc").toEvaluateAs(7, {x_a: 1, x_b: 2, c: 3});
+    });
+
+    test("function expressions", () => {
+        expect("f(2)").toEvaluateAs(4, {f: "2x"}, ["f"]);
+        expect("f(4+8)").toEvaluateAs(48, {f: "4x"}, ["f"]);
+        expect("f(x-1)-f(x)").toEvaluateAs(-7, {f: "x^3", x: 2}, ["f"]);
+        expect("g(1)").toEvaluateAs(-1, {f: "x", g: "-f(x)"}, ["f", "g"]);
+    });
+});