@khanacademy/kas 0.2.3

package/src/__tests__/rendering_test.js

@@ -0,0 +1,272 @@
+import _ from "underscore";
+
+import * as KAS from "../index.js";
+
+expect.extend({
+    toRenderTex(input: sstring, expected: string, options: $FlowFixMe) {
+        const actual = KAS.parse(input, options).expr.tex();
+
+        if (actual !== expected) {
+            return {
+                pass: false,
+                message: () => `${input} renders as ${expected}`,
+            };
+        }
+
+        return {pass: !this.isNot};
+    },
+    toRenderTexOpt(
+        input: string,
+        expected: string,
+        ...optlist: $ReadOnlyArray<$FlowFixMe>
+    ) {
+        const options = {
+            display: false,
+            dynamic: false,
+            times: false,
+        };
+        _.each(optlist, function (opt) {
+            options[opt] = true;
+        });
+
+        const actual = KAS.parse(input).expr.asTex(options);
+
+        if (actual !== expected) {
+            return {
+                pass: false,
+                message: () => `${input} renders with options as ${expected}`,
+            };
+        }
+
+        return {pass: true};
+    },
+});
+
+
+describe("rendering", () => {
+    test("positive and negative primitives", () => {
+        expect("0").toRenderTex("0");
+        expect("-1").toRenderTex("-1");
+        expect("--1").toRenderTex("--1");
+        expect("-2").toRenderTex("-2");
+        expect("--2").toRenderTex("--2");
+        expect("x").toRenderTex("x");
+        expect("theta").toRenderTex("\\theta");
+        expect("1/2").toRenderTex("\\frac{1}{2}");
+        expect("-1/2").toRenderTex("-\\frac{1}{2}");
+        expect("1/-2").toRenderTex("-\\frac{1}{2}");
+        expect("-1/-2").toRenderTex("--\\frac{1}{2}");
+    });
+
+    test("addition", () => {
+        expect("1-2").toRenderTex("1-2");
+        expect("a+b").toRenderTex("a+b");
+        expect("a-b").toRenderTex("a-b");
+        expect("a-1b").toRenderTex("a-1b");
+        expect("a+-b").toRenderTex("a+-b");
+        expect("a+-1b").toRenderTex("a+-1b");
+    });
+
+    test("multiplication", () => {
+        expect("ab").toRenderTex("ab");
+        expect("a*b").toRenderTex("ab");
+        expect("a/b").toRenderTex("\\frac{a}{b}");
+        expect("a/bc/d").toRenderTex("\\frac{ac}{bd}");
+
+        expect("1/(x+y)").toRenderTex("\\frac{1}{x+y}");
+        expect("2/(x+y)").toRenderTex("\\frac{2}{x+y}");
+        expect("(z+2)/(x+y)").toRenderTex("\\frac{z+2}{x+y}");
+        expect("(z+2)/4").toRenderTex("\\frac{z+2}{4}");
+    });
+
+    test("rational expressions", () => {
+        expect("x+1/2").toRenderTex("x+\\frac{1}{2}");
+        expect("x-1/2").toRenderTex("x-\\frac{1}{2}");
+
+        expect("1/2x").toRenderTex("\\frac{1}{2}x");
+        expect("1/2x/y").toRenderTex("\\frac{1}{2}\\frac{x}{y}");
+        expect("5*1/2x/y").toRenderTex("\\frac{1}{2}\\frac{5x}{y}");
+        expect("1/2*4*x/y").toRenderTex("\\frac{1}{2}\\frac{4x}{y}");
+        expect("-1/2x").toRenderTex("-\\frac{1}{2}x");
+        expect("a-1/2x").toRenderTex("a-\\frac{1}{2}x");
+
+        expect("1/(2x)").toRenderTex("\\frac{1}{2x}");
+        expect("8/(7p^4)").toRenderTex("\\frac{8}{7p^{4}}");
+
+        expect("x/2").toRenderTex("\\frac{x}{2}");
+        expect("1x/2").toRenderTex("\\frac{1x}{2}");
+        expect("-x/2").toRenderTex("-\\frac{x}{2}");
+        expect("x/-2").toRenderTex("-\\frac{x}{2}");
+        expect("x/-2/-3").toRenderTex("--\\frac{x}{2 \\cdot 3}");
+        expect("--x/2/3").toRenderTex("--\\frac{x}{2 \\cdot 3}");
+        expect("a-x/2").toRenderTex("a-\\frac{x}{2}");
+
+        expect("1*-2").toRenderTex("1 \\cdot -2");
+        expect("1*-2*3").toRenderTex("1 \\cdot -2 \\cdot 3");
+        expect("1*-2*3/4").toRenderTex("1 \\cdot -2 \\cdot \\frac{3}{4}");
+        expect("1*-2*3/4/5").toRenderTex(
+            "1 \\cdot -2 \\cdot \\frac{3}{4} \\cdot \\frac{1}{5}",
+        );
+        expect("1/2*1/2").toRenderTex("\\frac{1}{2} \\cdot \\frac{1}{2}");
+    });
+
+    test("exponentiation", () => {
+        expect("x^y").toRenderTex("x^{y}");
+        expect("xy^z").toRenderTex("xy^{z}");
+        expect("(xy)^z").toRenderTex("(xy)^{z}");
+        expect("(x+y)^z").toRenderTex("(x+y)^{z}");
+        expect("x^(yz)").toRenderTex("x^{yz}");
+        expect("x^-(yz)").toRenderTex("x^{-yz}");
+        expect("x^(y+z)").toRenderTex("x^{y+z}");
+        expect("x^-(y+z)").toRenderTex("x^{-(y+z)}");
+        expect("(x^y)^z").toRenderTex("(x^{y})^{z}");
+        expect("pir^2").toRenderTex("\\pi r^{2}");
+    });
+
+    test("square root", () => {
+        expect("sqrt(x)").toRenderTex("\\sqrt{x}");
+        expect("sqrt(x)y").toRenderTex("\\sqrt{x}y");
+        expect("1/sqrt(x)").toRenderTex("\\frac{1}{\\sqrt{x}}");
+        expect("1/sqrt(x)y").toRenderTex("\\frac{y}{\\sqrt{x}}");
+
+        expect("sqrt(2)/2").toRenderTex("\\frac{\\sqrt{2}}{2}");
+        expect("sqrt(2)^2").toRenderTex("(\\sqrt{2})^{2}");
+    });
+
+    test("nth root", () => {
+        // This is an unfortunate case, but only nth degree roots with integer
+        // n's get nicely printed as tex.
+        expect("sqrt[z]{x}").toRenderTex("x^{\\frac{1}{z}}");
+
+        expect("sqrt[3]{x}").toRenderTex("\\sqrt[3]{x}");
+        expect("sqrt[3]{x}z").toRenderTex("\\sqrt[3]{x}z");
+        expect("1/sqrt[4]{x}").toRenderTex("\\frac{1}{\\sqrt[4]{x}}");
+        expect("1/sqrt[4]{x}y").toRenderTex("\\frac{y}{\\sqrt[4]{x}}");
+
+        expect("sqrt[9]{2}/2").toRenderTex("\\frac{\\sqrt[9]{2}}{2}");
+        expect("sqrt[9]{2}^2").toRenderTex("(\\sqrt[9]{2})^{2}");
+    });
+
+    test("absolute value", () => {
+        expect("|x|").toRenderTex("\\left|x\\right|");
+        expect("|x|y").toRenderTex("\\left|x\\right|y");
+    });
+
+    test("logarithms", () => {
+        expect("lnx").toRenderTex("\\ln(x)");
+        expect("logx").toRenderTex("\\log_{10}(x)");
+        expect("lnx^y").toRenderTex("\\ln(x^{y})");
+        expect("logx^y").toRenderTex("\\log_{10}(x^{y})");
+        expect("(lnx)^y").toRenderTex("[\\ln(x)]^{y}");
+        expect("(logx)^y").toRenderTex("[\\log_{10}(x)]^{y}");
+    });
+
+    test("trig functions", () => {
+        expect("sinx").toRenderTex("\\sin(x)");
+
+        expect("arcsin x").toRenderTex("\\arcsin(x)");
+        expect("sin^-1 x").toRenderTex("\\arcsin(x)");
+
+        expect("(sinx)^2").toRenderTex("\\sin^{2}(x)");
+        expect("sin^2 x").toRenderTex("\\sin^{2}(x)");
+
+        expect("1/(sinx)^2").toRenderTex("\\frac{1}{\\sin^{2}(x)}");
+        expect("1/sin^2x").toRenderTex("\\frac{1}{\\sin^{2}(x)}");
+
+        expect("sin^2 x + cos^2 x = 1").toRenderTex(
+            "\\sin^{2}(x)+\\cos^{2}(x) = 1",
+        );
+    });
+
+    test("hyperbolic functions", () => {
+        expect("sinhx").toRenderTex("\\sinh(x)");
+        expect("sinh^2 x").toRenderTex("\\sinh^{2}(x)");
+    });
+
+    test("multiplication with numbers", () => {
+        expect("4*10").toRenderTex("4 \\cdot 10");
+        expect("10^5").toRenderTex("10^{5}");
+        expect("4*10^5").toRenderTex("4 \\cdot 10^{5}");
+        expect("10^5x").toRenderTex("10^{5}x");
+        expect("4*10^5x").toRenderTex("4 \\cdot 10^{5}x");
+        expect("x*(10+4)^5").toRenderTex("x(10+4)^{5}");
+
+        expect("-1*2").toRenderTex("-1 \\cdot 2");
+        expect("1*-2").toRenderTex("1 \\cdot -2");
+        expect("-1*-2").toRenderTex("-1 \\cdot -2");
+        expect("-1*2*3").toRenderTex("-1 \\cdot 2 \\cdot 3");
+    });
+
+    test("inverses and division", () => {
+        expect("x^-1").toRenderTex("x^{-1}");
+        expect("2x^-1").toRenderTex("2x^{-1}");
+        expect("1/x").toRenderTex("\\frac{1}{x}");
+        expect("-1/x").toRenderTex("\\frac{-1}{x}");
+        expect("2/x").toRenderTex("\\frac{2}{x}");
+        expect("1/x^2").toRenderTex("\\frac{1}{x^{2}}");
+        expect("2/x^2").toRenderTex("\\frac{2}{x^{2}}");
+        expect("1/1/x").toRenderTex("\\frac{1}{x}");
+        expect("1/(1/x)").toRenderTex("\\frac{1}{\\frac{1}{x}}");
+        expect("1/x/x").toRenderTex("\\frac{1}{xx}");
+        expect("1/(x/x)").toRenderTex("\\frac{1}{\\frac{x}{x}}");
+        expect("-1/1/x").toRenderTex("\\frac{-1}{x}");
+        expect("-1/(1/x)").toRenderTex("\\frac{-1}{\\frac{1}{x}}");
+        expect("-1/x/x").toRenderTex("\\frac{-1}{xx}");
+        expect("-1/(x/x)").toRenderTex("\\frac{-1}{\\frac{x}{x}}");
+    });
+
+    test("distributive property", () => {
+        expect("ab+c").toRenderTex("ab+c");
+        expect("ab+ac").toRenderTex("ab+ac");
+        expect("a(b+c)").toRenderTex("a(b+c)");
+    });
+
+    test("numerical exponents", () => {
+        expect("9^4").toRenderTex("9^{4}");
+        expect("-9^4").toRenderTex("-9^{4}");
+        expect("1-9^4").toRenderTex("1-9^{4}");
+    });
+
+    test("negating a Mul", () => {
+        expect("-3x").toRenderTex("-3x");
+        expect("--3x").toRenderTex("--3x");
+        expect("-x*3").toRenderTex("-3x");
+        expect("--x*3").toRenderTex("--3x");
+    });
+
+    test("equations", () => {
+        expect("y=x").toRenderTex("y = x");
+        expect("y<x").toRenderTex("y < x");
+        expect("y>x").toRenderTex("y > x");
+        expect("y<>x").toRenderTex("y \\ne x");
+        expect("y=/=x").toRenderTex("y \\ne x");
+        expect("y<=x").toRenderTex("y \\le x");
+        expect("y>=x").toRenderTex("y \\ge x");
+    });
+
+    test("function variables", () => {
+        expect("f(x)").toRenderTex("fx");
+        expect("f(x)").toRenderTex("f(x)", {functions: ["f"]});
+        expect("f(sin x)").toRenderTex("f(\\sin(x))", {functions: ["f"]});
+        expect("sin f(x)").toRenderTex("\\sin(f(x))", {functions: ["f"]});
+    });
+
+    test("options", () => {
+        expect("x").toRenderTexOpt("x");
+        expect("x").toRenderTexOpt("\\displaystyle x", "display");
+        expect("a(b+c(d+e))").toRenderTexOpt("a(b+c(d+e))");
+        expect("a(b+c(d+e))").toRenderTexOpt(
+            "a\\left(b+c\\left(d+e\\right)\\right)",
+            "dynamic",
+        );
+        expect("2*2").toRenderTexOpt("2 \\cdot 2");
+        expect("2*2").toRenderTexOpt("2 \\times 2", "times");
+
+        expect("1*2(3+4)").toRenderTexOpt(
+            "\\displaystyle 1 \\times 2\\left(3+4\\right)",
+            "display",
+            "dynamic",
+            "times",
+        );
+    });
+});

package/src/__tests__/transforming_test.js

@@ -0,0 +1,331 @@
+import _ from "underscore";
+
+import * as KAS from "../index.js";
+
+expect.extend({
+    toFactorAs(input: string, reference: string) {
+        const actual = KAS.parse(input).expr.factor().normalize().repr();
+        const expected = KAS.parse(reference).expr.normalize().repr();
+
+        return actual === expected
+            ? {pass: true}
+            : {pass: false, message: () => `${input} factors as ${reference}`};
+    },
+    toExpandAs(input: string, reference: string) {
+        const actual = KAS.parse(input)
+            .expr.expand()
+            .normalize()
+            .print();
+        const expected = KAS.parse(reference).expr.normalize().print();
+
+        return actual === expected
+            ? {pass: true}
+            : {pass: false, message: () => `${input} expands as ${reference}`};
+    },
+    toExpandAsRepr(input: string, reference: string) {
+        const actual = KAS.parse(input).expr.expand().repr();
+
+        return actual === reference
+            ? {pass: true}
+            : {pass: false, message: () => `${input} expands as ${reference}`};
+    },
+    toExpandAsTex(input: string, reference: string) {
+        const actual = KAS.parse(input).expr.expand().tex();
+
+        return actual === reference
+            ? {pass: true}
+            : {pass: false, message: () => `${input} expands as ${reference}`};
+    },
+    toCollectAs(input: string, reference: string) {
+        const actual = KAS.parse(input)
+            .expr.collect()
+            .normalize()
+            .print();
+        const expected = KAS.parse(reference)
+            .expr.collect()
+            .normalize()
+            .print();
+
+        return actual === expected
+            ? {pass: true}
+            : {pass: false, message: () => `${input} collects as ${reference}`};
+    },
+    toCollectAsRepr(input: string, reference: string) {
+        const actual = KAS.parse(input).expr.collect().repr();
+
+        return actual === reference
+            ? {pass: true}
+            : {pass: false, message: () => `${input} collects as ${reference}`};
+    },
+    toCollectAsTex(input: string, reference: string) {
+        const actual = KAS.parse(input).expr.collect().tex();
+
+        return actual === reference
+            ? {pass: true}
+            : {pass: false, message: () => `${input} collects as ${reference}`};
+    },
+    toSimplifyAs(input: string, reference: string) {
+        var actual = KAS.parse(input).expr.simplify().normalize().print();
+        var expected = KAS.parse(reference).expr.normalize().print();
+
+        return actual === expected
+            ? {pass: true}
+            : {pass: false, message: () => `${input} simplifies as ${reference}`};
+    },
+});
+
+describe("transforming", () => {
+    test("factoring Adds", () => {
+        expect("2+2").toFactorAs("2(1+1)");
+        expect("-2-2").toFactorAs("-2(1+1)");
+        expect("2x+2").toFactorAs("2(x+1)");
+        expect("x^3+x^2").toFactorAs("x^2(x+1)");
+        expect("2x+xy").toFactorAs("x(2+y)");
+        expect("2xy+xy^2").toFactorAs("xy(2+y)");
+        expect("2+2/3").toFactorAs("2/3(3+1)"); // a little questionable, but 2/3 is what
+        // wolframalpha returns for the gcd, so
+        // we pull it out
+        expect("2x+1.1").toFactorAs("2x+1.1");
+    });
+
+    test("factoring Muls", () => {
+        expect("(2x+2)/(x+1)").toFactorAs("2 (x+1)/(x+1)");
+        expect("(x+1)/(2x+2)").toFactorAs("1/2 (x+1)/(x+1)");
+    });
+
+    test("factoring Pows", () => {
+        expect("x^y+x^(2y)").toFactorAs("x^y(1+x^y)");
+        expect("x^y+x^z").toFactorAs("x^y+x^z");
+    });
+
+    test("distribute over multiplication", () => {
+        expect("a(b+c)").toExpandAs("ab+ac");
+        expect("a(b+c)").toExpandAsTex("ab+ac");
+        expect("a(b+c)").toExpandAsRepr(
+            "Add(Mul(Var(a),Var(b)),Mul(Var(a),Var(c)))",
+        );
+
+        expect("a(b-c)").toExpandAs("ab-ac");
+        expect("a(b-c)").toExpandAsTex("ab-ac");
+        expect("a(b-c)").toExpandAsRepr(
+            "Add(Mul(Var(a),Var(b)),Mul(Var(a),-1,Var(c)))",
+        );
+
+        expect("a(b+c)d").toExpandAs("abd+acd");
+        expect("a(b+c)d").toExpandAsRepr(
+            "Add(Mul(Var(a),Var(d),Var(b)),Mul(Var(a),Var(d),Var(c)))",
+        );
+
+        expect("(a+b)(c+d)").toExpandAs("ac+ad+bc+bd");
+        expect("(a+b)(c+d)ef").toExpandAs("acef+adef+bcef+bdef");
+        expect("(a+b)c^d").toExpandAs("ac^d+bc^d");
+        expect("ab(c+d)e^f").toExpandAs("abce^f+abde^f");
+
+        expect("(a+b(c+d))e").toExpandAs("ae+bce+bde");
+        expect("(a+b(c+d))e").toExpandAsRepr(
+            "Add(Mul(Const(e),Var(a)),Mul(Const(e),Var(b),Var(c)),Mul(Const(e),Var(b),Var(d)))",
+        );
+    });
+
+    test("distribute over rational expressions", () => {
+        expect("(a+b)/(c+d)").toExpandAs("(a+b)/(c+d)");
+        expect("(a+b)/(c+d)*a").toExpandAs("(aa+ab)/(c+d)");
+        expect("(a+b)/(c+d)*1/e").toExpandAs("(a+b)/(ce+de)");
+        expect("(a+b)/(c+d)*a/e").toExpandAs("(aa+ab)/(ce+de)");
+    });
+
+    test("expand exponentiation", () => {
+        expect("(ab)^2").toExpandAs("a^2 b^2");
+        expect("2*(ab)^2").toExpandAs("2 a^2 b^2");
+        expect("(a+b)^2").toExpandAs("a^2+2ab+b^2");
+
+        expect("(ab)^-2").toExpandAs("a^-2 b^-2");
+        expect("2*(ab)^-2").toExpandAs("2 a^-2 b^-2");
+        expect("(a+b)^-2").toExpandAs("(a^2+2ab+b^2)^-1");
+    });
+
+    test("expand absolute value", () => {
+        expect("|a+b|").toExpandAs("|a+b|");
+        expect("|ab|").toExpandAs("|a|*|b|");
+    });
+
+    test("expand logarithms", () => {
+        expect("ln(xy)").toExpandAs("lnx+lny");
+        expect("log_b(x)").toExpandAs("lnx/lnb");
+        expect("log_b(xy)").toExpandAs("lnx/lnb+lny/lnb");
+        expect("ln(xy/z)").toExpandAs("lnx+lny-lnz");
+
+        expect("ln(x^y)").toExpandAs("ylnx");
+        expect("log_b(x^y)").toExpandAs("ylnx/lnb");
+        expect("ln(x^y^z)").toExpandAs("y^zlnx");
+
+        expect("ln(x^y/z)").toExpandAs("ylnx-lnz");
+
+        // ln((xy)^z) -> ln(x^z*y^z) -> z*ln(x)+z*ln(y)
+        expect("ln((xy)^z)").toExpandAs("zlnx+zlny");
+
+        expect("log_b(x)log_x(y)").toExpandAs("ln(x)/ln(b)*ln(y)/ln(x)");
+        expect("log_b(x)log_x(y)log_y(z)").toExpandAs(
+            "ln(x)/ln(b)*ln(y)/ln(x)*ln(z)/ln(y)",
+        );
+    });
+
+    test("expand trig functions", () => {
+        expect("sin(x)").toExpandAs("sin(x)");
+        expect("cos(x)").toExpandAs("cos(x)");
+        expect("tan(x)").toExpandAs("sin(x)/cos(x)");
+        expect("csc(x)").toExpandAs("1/sin(x)");
+        expect("sec(x)").toExpandAs("1/cos(x)");
+        expect("cot(x)").toExpandAs("cos(x)/sin(x)");
+    });
+
+    test("expand hyperbolic functions", () => {
+        expect("sinh(x)").toExpandAs("sinh(x)");
+        expect("cosh(x)").toExpandAs("cosh(x)");
+        expect("tanh(x)").toExpandAs("sinh(x)/cosh(x)");
+        expect("csch(x)").toExpandAs("1/sinh(x)");
+        expect("sech(x)").toExpandAs("1/cosh(x)");
+        expect("coth(x)").toExpandAs("cosh(x)/sinh(x)");
+    });
+
+    test("collect over addition", () => {
+        expect("").toCollectAs("0");
+        expect("0").toCollectAs("0");
+        expect("1+3").toCollectAs("4");
+        expect("x+3").toCollectAs("3+x");
+        expect("x+3x").toCollectAs("4x");
+        expect("x+3x").toCollectAsRepr("Mul(4,Var(x))");
+        expect("a+a+a").toCollectAs("3a");
+        expect("a+a+a").toCollectAsRepr("Mul(3,Var(a))");
+        expect("a+b+b+c").toCollectAs("a+2b+c");
+        expect("a+b+b+c").toCollectAsRepr("Add(Var(a),Mul(2,Var(b)),Var(c))");
+        expect("4x^2-x^2+8x+7-5x-4").toCollectAs("3+3x+3x^2");
+    });
+
+    test("collect over multiplication", () => {
+        expect("5*7").toCollectAs("35");
+        expect("5*7x+20x").toCollectAs("55x");
+        expect("3x*xy+2yx^2").toCollectAs("5x^2y");
+        expect("4/6").toCollectAs("2/3");
+        expect("1/1").toCollectAs("1");
+        expect("1/2+1/3").toCollectAs("5/6");
+        expect("1/2+1/3+1").toCollectAs("11/6");
+        expect("1.2+1/2").toCollectAs("1.7");
+        expect("1/2-1/2").toCollectAs("0");
+        expect("1/2-.5").toCollectAs("0");
+    });
+
+    test("collect over exponentiation", () => {
+        expect("x^0").toCollectAs("1");
+        expect("x^1").toCollectAs("x");
+        expect("x^(log_x y)").toCollectAs("y");
+        expect("(x^y)^z").toCollectAs("x^(yz)");
+        expect("0^0").toCollectAs("1");
+        expect("4^1.5").toCollectAs("8");
+        expect("(2/3)^2").toCollectAs("4/9");
+        expect("(2/3)^-2").toCollectAs("9/4");
+    });
+
+    test("collect over roots", () => {
+        expect("sqrt(2)^2").toCollectAs("2");
+        expect("sqrt[3]{3}^3").toCollectAs("3");
+        expect("(2^(1/3))^3").toCollectAs("2");
+    });
+
+    test("collect over absolute value", () => {
+        expect("|x|").toCollectAs("|x|");
+        expect("|2|").toCollectAs("2");
+        expect("|0|").toCollectAs("0");
+        expect("|-2|").toCollectAs("2");
+        expect("|pi|").toCollectAs("pi");
+        expect("|2^x|").toCollectAs("2^x");
+        expect("|x^2|").toCollectAs("x^2");
+        expect("|-2pix^2y^3|").toCollectAs("2pix^2*|y^3|");
+    });
+
+    test("collect over logarithms", () => {
+        expect("log(1)").toCollectAs("0");
+        expect("log_x(x)").toCollectAs("1");
+        expect("log_b(b^x)").toCollectAs("x");
+
+        expect("b^(2*y*log_b x)").toCollectAs("x^(2y)");
+        expect("b^(log_b a) b^(-log_b c)").toCollectAs("a/c");
+
+        expect("ln(x)/ln(b)").toCollectAs("log_b(x)");
+        expect("ln(x)/ln(b)*ln(y)/ln(x)").toCollectAs("log_b(y)");
+        expect("ln(x)/ln(b)*ln(y)/ln(x)*ln(z)/ln(y)").toCollectAs("log_b(z)");
+    });
+
+    test("collect trig functions", () => {
+        expect("sin(x)cos(x)").toCollectAs("sin(x)cos(x)");
+        expect("sin(x)/cos(x)").toCollectAs("tan(x)");
+
+        expect("sin^2(x)/cos^2(x)").toCollectAs("tan^2(x)");
+        expect("cos^2(x)/sin^2(x)").toCollectAs("cot^2(x)");
+
+        expect("sin^-2(x)/cos^-2(x)").toCollectAs("cot^2(x)");
+        expect("cos^-2(x)/sin^-2(x)").toCollectAs("tan^2(x)");
+
+        expect("sin^--2(x)/cos^--2(x)").toCollectAs("tan^2(x)");
+        expect("cos^--2(x)/sin^--2(x)").toCollectAs("cot^2(x)");
+
+        expect("sin^2(x)/cos(x)").toCollectAs("sin^2(x)/cos(x)");
+        expect("sin(x)/cos^2(x)").toCollectAs("sin(x)/cos^2(x)");
+
+        expect("sin(-x)").toCollectAs("-sin(x)");
+        expect("cos(-x)").toCollectAs("cos(x)");
+        expect("tan(-x)").toCollectAs("-tan(x)");
+        expect("csc(-x)").toCollectAs("-csc(x)");
+        expect("sec(-x)").toCollectAs("sec(x)");
+        expect("cot(-x)").toCollectAs("-cot(x)");
+
+        expect("sin(--x)").toCollectAs("sin(x)");
+        expect("arcsin(-x)").toCollectAs("arcsin(-x)");
+
+        expect("sin(-x)cos(-x)").toCollectAs("-sin(x)cos(x)");
+        expect("sin(-x)/cos(-x)").toCollectAs("-tan(x)");
+    });
+
+    test("collect then output tex", () => {
+        // user-friendly tex representation is not guaranteed after collect(assert, )
+        expect("-x").toCollectAs("-1x");
+        expect("-x").toCollectAsTex("-1x");
+        expect("a-b").toCollectAs("a+-1b");
+        expect("a-b").toCollectAsTex("a+-1b");
+        expect("a/b").toCollectAs("ab^-1");
+        expect("a/b").toCollectAsTex("ab^{-1}");
+    });
+
+    test("collect over an equation", () => {
+        // collect does not try to collect across both sides of an equation
+        expect("y+1-1=x*x").toCollectAs("y=x^(2)");
+        expect("1+y=1+x^2").toCollectAs("1+y=1+x^(2)");
+    });
+
+    test("simplify", () => {
+        expect("(a+b)^2").toSimplifyAs("(a+b)^2");
+        expect("(a+b)(a+b)").toSimplifyAs("(a+b)^2");
+
+        // (ab)^2 ->[factor]-> a^2 * b^2 ->[collect]-> a^2 * b^2
+        // (no change during collect, therefore factoring is rolled back)
+        expect("(ab)^2").toSimplifyAs("(ab)^2");
+
+        // (3x)^2 ->[factor]-> 3^2 * x^2 ->[collect]-> 9x^2
+        // (changed during collect, therefore factoring persists)
+        expect("(3x)^2").toSimplifyAs("9x^2");
+
+        expect("(2sqrt(2))^4").toSimplifyAs("64");
+        expect("(3sqrt[3]{3})^9").toSimplifyAs("531441");
+
+        // from "Simplifying expressions with exponents"
+        expect("((nx^5)^5)").toSimplifyAs("n^5 x^25");
+        expect("((nx^5)^5)/2").toSimplifyAs("1/2 n^5 x^25");
+        expect("((nx^5)^5)/(n^-2x^2)^-3").toSimplifyAs("n^-1 x^31");
+
+        expect("1/(xya)+1/(xyb)").toSimplifyAs("1/(xya)+1/(xyb)");
+
+        // Simplify rationals correctly
+        expect("2*(x+1/3)").toSimplifyAs("2*x+2/3");
+        expect("-1*(1/3+x)").toSimplifyAs("-1*x+-1/3");
+    });
+});