Adding new expression tests.

common/test/math/expression.mjs

@@ -0,0 +1,181 @@
+/**
+ *  LogarithmPlotter - 2D plotter software to make BODE plots, sequences and distribution functions.
+ *  Copyright (C) 2021-2024  Ad5001
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// Load prior tests
+import "../basics/utils.mjs"
+import "../module/latex.mjs"
+import "../module/expreval.mjs"
+import "../module/objects.mjs"
+
+import { describe, it } from "mocha"
+import { expect } from "chai"
+
+import { executeExpression, Expression } from "../../src/math/expression.mjs"
+import ExprEval from "../../src/module/expreval.mjs"
+
+
+describe("Math/Expression", function() {
+    describe("#constructor", function() {
+        it("accepts strings", function() {
+            expect(() => new Expression("2+3")).to.not.throw
+            expect(() => new Expression("x+2")).to.not.throw
+        })
+
+        it("accepts already parsed expressions", function() {
+            expect(() => new Expression(ExprEval.parse("2+3"))).to.not.throw
+            expect(() => new Expression(ExprEval.parse("x+2"))).to.not.throw
+        })
+
+        it("doesn't accept anything else", function() {
+            expect(() => new Expression()).to.throw("Cannot create an expression with undefined.")
+            expect(() => new Expression(12)).to.throw("Cannot create an expression with a Number.")
+            expect(() => new Expression({})).to.throw("Cannot create an expression with a Object.")
+            expect(() => new Expression(true)).to.throw("Cannot create an expression with a Boolean.")
+        })
+    })
+
+    describe("#variables", function() {
+        it("returns a list of variables for non-constant expressions", function() {
+            expect(new Expression("x+1").variables()).to.deep.equal(["x"])
+            expect(new Expression("x+n").variables()).to.deep.equal(["x", "n"])
+            expect(new Expression("u[n] + A.x").variables()).to.deep.equal(["u", "n", "A"])
+        })
+
+        it("returns an empty array if the expression is constant", function() {
+            expect(new Expression("2+1").variables()).to.deep.equal([])
+            expect(new Expression("sin π").variables()).to.deep.equal([])
+            expect(new Expression("e^3").variables()).to.deep.equal([])
+        })
+    })
+
+    describe("#isConstant", function() {
+        it("returns true if neither x nor n are included into the expression", function() {
+            expect(new Expression("2+1").isConstant()).to.be.true
+            expect(new Expression("e^3").isConstant()).to.be.true
+            expect(new Expression("2+f(3)").isConstant()).to.be.true
+            expect(new Expression("sin A.x").isConstant()).to.be.true
+        })
+
+        it("returns false if either x or n are included into the expression", function() {
+            expect(new Expression("2+x").isConstant()).to.be.false
+            expect(new Expression("e^n").isConstant()).to.be.false
+            expect(new Expression("2+f(x)").isConstant()).to.be.false
+            expect(new Expression("n + sin x").isConstant()).to.be.false
+        })
+    })
+
+    describe("#requiredObjects", function() {
+        it("returns the list of objects that need to be registered for this expression", function() {
+            expect(new Expression("x^n").requiredObjects()).to.deep.equal([])
+            expect(new Expression("2+f(3)").requiredObjects()).to.deep.equal(["f"])
+            expect(new Expression("A.x+x").requiredObjects()).to.deep.equal(["A"])
+            expect(new Expression("2+f(sin A.x)+n").requiredObjects()).to.deep.equal(["f", "A"])
+        })
+    })
+
+    describe.skip("#allRequirementsFulfilled", function() {
+        // TODO: Make tests for objects
+    })
+
+    describe.skip("#undefinedVariables", function() {
+        // TODO: Make tests for objects
+    })
+
+    describe("#toEditableString", function() {
+        it("should return a readable expression", function() {
+            expect(new Expression("2+1").toEditableString()).to.equal("3")
+            expect(new Expression("2+x").toEditableString()).to.equal("(2 + x)")
+            expect(new Expression("x*2+x/3").toEditableString()).to.equal("((x * 2) + (x / 3))")
+        })
+
+        it("should be able to be reparsed and equal the same expression", function() {
+            const exprs = ["5", "x/2", "4/2", "sin x"]
+            for(const expr of exprs) {
+                const exprObj = new Expression(expr)
+                expect(new Expression(exprObj.toEditableString()).calc).to.deep.equal(exprObj.calc)
+            }
+        })
+    })
+
+    describe("#execute", function() {
+        it("returns the result of the computation of the expression", function() {
+            expect(new Expression("2+3").execute()).to.equal(5)
+            expect(new Expression("2+3").execute(10)).to.equal(5)
+            expect(new Expression("2+x").execute(10)).to.equal(12)
+            expect(new Expression("sin x").execute(Math.PI)).to.be.approximately(0, Number.EPSILON)
+        })
+
+        it("returns the cached value if the expression can be cached", function() {
+            const exprs = ["2+3", "x/2", "4/2", "sin x"]
+            for(const expr of exprs) {
+                const exprObj = new Expression(expr)
+                if(exprObj.canBeCached)
+                    expect(exprObj.execute()).to.equal(exprObj.cachedValue)
+                else
+                    expect(exprObj.execute()).to.not.equal(exprObj.cachedValue)
+            }
+        })
+
+        it("throws an error if some variables are undefined.", function() {
+            expect(() => new Expression("x+n").execute()).to.throw("Undefined variable n.")
+            expect(() => new Expression("sin A.t").execute()).to.throw("Undefined variable A.")
+            expect(() => new Expression("f(3)").execute()).to.throw("Undefined variable f.")
+        })
+    })
+
+    describe("#simplify", function() {
+        it("returns an expression with just the result when no constant or object are used", function() {
+            expect(new Expression("2+2").simplify(Math.PI/2)).to.deep.equal(new Expression("4"))
+            expect(new Expression("x+3").simplify(5)).to.deep.equal(new Expression("8"))
+            expect(new Expression("sin x").simplify(Math.PI/2)).to.deep.equal(new Expression("1"))
+            expect(new Expression("0*e^x").simplify(Math.PI/2)).to.deep.equal(new Expression("0"))
+        })
+
+        it("returns a simplified version of the expression if constants are used", function() {
+            const original = new Expression("e^x").simplify(2)
+            const to = new Expression("e^2")
+            expect(original.toEditableString()).to.deep.equal(to.toEditableString())
+        })
+    })
+
+    describe("#toString", function() {
+        it("returns a human readable string of the expression", function() {
+            expect(new Expression("-2-3").toString()).to.equal("-5")
+            expect(new Expression("0.2+0.1").toString()).to.equal("0.3")
+            expect(new Expression("sin x").toString()).to.equal("sin x")
+            expect(new Expression("sin π").toString()).to.equal("sin π")
+        })
+
+        it("should add a sign if the option is passed", function() {
+            expect(new Expression("-2-3").toString(true)).to.equal("-5")
+            expect(new Expression("2+3").toString(true)).to.equal("+5")
+        })
+    })
+
+    describe("#executeExpression", function() {
+        it("directly computes the result of the expression with no variable", function() {
+            expect(executeExpression("2+3")).to.equal(5)
+            expect(executeExpression("sin (π/2)")).to.equal(1)
+            expect(executeExpression("e^3")).to.be.approximately(Math.pow(Math.E, 3), Number.EPSILON)
+        })
+
+        it("throws an error if variables are employed", function() {
+            expect(() => executeExpression("x+n")).to.throw("Undefined variable n.")
+        })
+    })
+})