nerdamer 1.1.9 → 1.1.13

package/spec/core.spec.js

@@ -9,6 +9,7 @@ var _ = utils.toFixed;
 var run = utils.run;
 var core = nerdamer.getCore();
 var round = core.Utils.round;
+var block = core.Utils.block;
 
 
 //, x=2.1, y=3.3, z=1, a=7.42
@@ -918,6 +919,11 @@ describe('Nerdamer core', function () {
                 given: 'sqrt(2/x)',
                 expected: 'sqrt(2)*sqrt(x)^(-1)',
                 expectedValue: '0.9759000729485331'
+            },
+            {
+                given: 'sqrt(3^x)',
+                expected: 'sqrt(3^x)',
+                expectedValue: '3.169401925649'
             }
         ];
 
@@ -1881,7 +1887,15 @@ describe('Nerdamer core', function () {
     });
     it('should recognize the mod and percent operator', function() {
         expect(nerdamer('3*(a%%b%)').toString()).toEqual('3*mod((1/100)*a,(1/100)*b)')
-    })
+    });
+    it('should rewrite e as exp', function() {
+        block('E_TO_EXP', function() {
+            expect(nerdamer('(3*e^(e^(x))+tan(-e^x))+a').toString()).toEqual('3*exp(exp(x))+a+tan(-exp(x))');
+        });
+    });
+    it('should unwrap even abs', function() {
+        expect(nerdamer('(3*abs(x))^2').toString()).toEqual('3*x^2');
+    });
 });
 
 describe('Further arithmetic test cases', function () {
@@ -2541,6 +2555,15 @@ describe('trigonometric functions', function () {
             expect(round(value, 14)).toEqual(round(testCases[i].expectedValue),14);
         }
     });
+    it('should handle inverse trig in complex domain', function() {
+        expect(nerdamer('asin(2)').evaluate().text()).toEqual('-1.3169578969248164*i+1.570796326794896580');
+        expect(nerdamer('asin(2.19549352839451962743423602992)').evaluate().text()).toEqual('-1.423114269539483*i+1.570796326794896580');
+        expect(nerdamer('acos(2)').evaluate().text()).toEqual('1.3169578969248164*i');
+        expect(nerdamer('atan(i)').evaluate().text()).toEqual('Infinity*i');
+        
+        expect(nerdamer('asec(0.89)').evaluate().text()).toEqual('0.000000000000000250+0.4921996534425188*i'); // Has rounding errors
+        expect(nerdamer('acsc(0.23)').evaluate().text()).toEqual('-2.1493278111894223*i+1.570796326794897197'); // Has rounding errors
+    });
     it('should throw for wrong trigonometric arguments', function () {
         // given
         var testCases = [
@@ -2563,13 +2586,13 @@ describe('trigonometric functions', function () {
         }
     });
     it('should throw for malformed expression', function () {
-        expect(function(){nerdamer('+')}).toThrowError();
-        expect(function(){nerdamer('(+)')}).toThrowError();
-        expect(function(){nerdamer('cos(')}).toThrowError();
-        expect(function(){nerdamer('(x+1))')}).toThrowError();
-        expect(function(){nerdamer('/2')}).toThrowError();
-        expect(function(){nerdamer('()')}).toThrowError();
-        expect(function(){nerdamer('5+')}).toThrowError();
+        expect(function(){nerdamer('+');}).toThrowError();
+        expect(function(){nerdamer('(+)');}).toThrowError();
+        expect(function(){nerdamer('cos(');}).toThrowError();
+        expect(function(){nerdamer('(x+1))');}).toThrowError();
+        expect(function(){nerdamer('/2');}).toThrowError();
+        expect(function(){nerdamer('()');}).toThrowError();
+        expect(function(){nerdamer('5+');}).toThrowError();
     });
     it('should calculate correctly with variables', function () {
         // given
@@ -2714,6 +2737,10 @@ describe('trigonometric functions', function () {
             expect(parsed.toString()).toEqual(testCases[i].expected);
         }
     });
+    it('should handle known trig cases for `numer`', function() {
+        expect(nerdamer('tan(pi)', {}, 'numer').text()).toEqual('0');
+        expect(nerdamer('cot(90*pi/180)', {}, 'numer').text()).toEqual('0');
+    });
 });
 
 describe('hyperbolic trigonometric functions', function () {

package/spec/extra.spec.js

@@ -5,182 +5,50 @@
 var nerdamer = require('../nerdamer.core.js');
 require('../Extra');
 
-describe('calculus', function () {
-    
-    it('should transform Laplace correctly', function () {
-        // given
-        var testCases = [
-            {
-                given: 'laplace(5, t, s)',
-                expected: '5*s^(-1)'
-            },
-            {
-                given: 'laplace(a*t, t, s)',
-                expected: 'a*s^(-2)'
-            },
-            {
-                given: 'laplace(cos(a*t), t, s)',
-                expected: '(a^2+s^2)^(-1)*s'
-            },
-            {
-                given: 'laplace(cos(x), t, s)',
-                expected: 'cos(x)*s^(-1)'
-            },
-            {
-                given: 'laplace(sinh(a*t), t, s)',
-                expected: '(-a^2+s^2)^(-1)*a'
-            },
-            {
-                given: 'laplace(a*t^2, t, s)',
-                expected: '2*a*s^(-3)'
-            },
-            {
-                given: 'laplace(2*sqrt(t), t, s)',
-                expected: 's^(-3/2)*sqrt(pi)'
-            },
-            {
-                given: 'laplace(x*e^(a*t), t, s)',
-                expected: '(-a+s)^(-1)*x'
-            },
-            {
-                given: 'laplace(x*(sin(a*t)-a*t*cos(a*t)), t, s)',
-                expected: '((a^2+s^2)^(-1)*a-((1+a^2*s^(-2))^(-2)*s^(-2)-(1+a^2*s^(-2))^(-2)*a^2*s^(-4))*a)*x'
-            },
-            {
-                given: 'laplace(sin(a*t), t, s)',
-                expected: '(a^2+s^2)^(-1)*a'
-            },
-            {
-                given: 'laplace(t*sin(a*t), t, s)',
-                expected: '2*(1+a^2*s^(-2))^(-2)*a*s^(-3)'
-            },
-            {
-                given: 'laplace(sin(a*t+b), t, s)',
-                expected: '(1+a^2*s^(-2))^(-1)*a*cos(b)*s^(-2)+(1+a^2*s^(-2))^(-1)*s^(-1)*sin(b)'
-            },
-            {
-                given: 'laplace(t^2*e^(a*t), t, s)',
-                expected: '-2*(-s+a)^(-3)'
-            },
-            {
-                given: 'laplace(6*t*e^(-9*t)*sin(6*t), t, s)',
-                expected: '-72*(-9-s)^(-3)*(1+36*(-9-s)^(-2))^(-2)'
-            },
-            {
-                //NOTE: this unit test was incorrect before. I don't know how this was missed.
-                given: 'laplace(sinh(t)*e^t, t, s)',
-                expected: '(-1/2)*(-s+2)^(-1)+(-1/2)*s^(-1)'
-            }
-        ];
-
-        for (var i = 0; i < testCases.length; ++i) {
-            // when
-            var parsed = nerdamer(testCases[i].given);
+describe('Extra Calculus', function () {
 
-            // then
-            expect(parsed.toString()).toEqual(testCases[i].expected);
-        }
+    it('should transform Laplace correctly', function () {
+        expect(nerdamer('laplace(5, t, s)').toString()).toEqual('5*s^(-1)');
+        expect(nerdamer('laplace(a*t, t, s)').toString()).toEqual('a*s^(-2)');
+        expect(nerdamer('laplace(cos(a*t), t, s)').toString()).toEqual('(a^2+s^2)^(-1)*s');
+        expect(nerdamer('laplace(cos(x), t, s)').toString()).toEqual('cos(x)*s^(-1)');
+        expect(nerdamer('laplace(sinh(a*t), t, s)').toString()).toEqual('(-a^2+s^2)^(-1)*a');
+        expect(nerdamer('laplace(a*t^2, t, s)').toString()).toEqual('2*a*s^(-3)');
+        expect(nerdamer('laplace(2*sqrt(t), t, s)').toString()).toEqual('s^(-3/2)*sqrt(pi)');
+        expect(nerdamer('laplace(x*e^(a*t), t, s)').toString()).toEqual('(-a+s)^(-1)*x');
+        expect(nerdamer('laplace(x*(sin(a*t)-a*t*cos(a*t)), t, s)').toString()).toEqual('((a^2+s^2)^(-1)*a-((1+a^2*s^(-2))^(-2)*s^(-2)-(1+a^2*s^(-2))^(-2)*a^2*s^(-4))*a)*x');
+        expect(nerdamer('laplace(sin(a*t), t, s)').toString()).toEqual('(a^2+s^2)^(-1)*a');
+        expect(nerdamer('laplace(t*sin(a*t), t, s)').toString()).toEqual('2*(1+a^2*s^(-2))^(-2)*a*s^(-3)');
+        expect(nerdamer('laplace(sin(a*t+b), t, s)').toString()).toEqual('(1+a^2*s^(-2))^(-1)*a*cos(b)*s^(-2)+(1+a^2*s^(-2))^(-1)*s^(-1)*sin(b)');
+        expect(nerdamer('laplace(t^2*e^(a*t), t, s)').toString()).toEqual('-2*(-s+a)^(-3)');
+        expect(nerdamer('laplace(6*t*e^(-9*t)*sin(6*t), t, s)').toString()).toEqual('-72*(-9-s)^(-3)*(1+36*(-9-s)^(-2))^(-2)');
+        expect(nerdamer('laplace(sinh(t)*e^t, t, s)').toString()).toEqual('(-1/2)*(-s+2)^(-1)+(-1/2)*s^(-1)');
     });
-    
-    it('should invert a Laplace transform correctly', function () {
-        // given
-        var testCases = [
-            {
-                given: 'ilt(a/(b*x), x, t)',
-                expected: 'a*b^(-1)'
-            },
-            {
-                given: 'ilt(a*6/(b*s^6),s,t)',
-                expected: '(1/20)*a*b^(-1)*t^5'
-            },
-            {
-                given: 'ilt(3*s/(4*s^2+5),s,t)',
-                expected: '(3/4)*cos((1/2)*sqrt(5)*t)'
-            },
-            {
-                given: 'ilt(2/(3*s^2+1),s,t)',
-                expected: '2*sin((1/3)*sqrt(3)*t)*sqrt(3)^(-1)'
-            },
-            {
-                given: 'ilt(5*sqrt(pi)/(3*s^(3/2)),s,t)',
-                expected: '(10/3)*sqrt(t)'
-            },
-            {
-                given: 'ilt(3/(7*s^2+1)^2, s, t)',
-                expected: '(-3/14)*cos((1/7)*sqrt(7)*t)*t+(3/2)*sin((1/7)*sqrt(7)*t)*sqrt(7)^(-1)'
-            },
-            {
-                given: 'ilt(5*s/(s^2+4)^2, s, t)',
-                expected: '(5/4)*sin(2*t)*t'
-            },
-            {
-                given: 'ilt(8*s^2/(2*s^2+3)^2, s, t)',
-                expected: '2*sin((1/2)*sqrt(6)*t)*sqrt(6)^(-1)+cos((1/2)*sqrt(6)*t)*t'
-            },
-            {
-                given: 'ilt((6*s^2-1)/(4*s^2+1)^2, s, t)',
-                expected: '(1/8)*sin((1/2)*t)+(5/16)*cos((1/2)*t)*t'
-            },
-            {
-                given: 'ilt((5*(sin(1)*s+3*cos(1)))/(s^2+9),s, t)',
-                expected: '5*cos(1)*sin(3*t)+5*cos(3*t)*sin(1)'
-            },
-            {
-                //TODO: Although this is computed correctly we need to get rid of the silly factorial(0)^(-1)
-                given: 'ilt(((s+1)*(s+2)*(s+3))^(-1), s, t)',
-                expected: '(1/2)*e^(-3*t)*factorial(0)^(-1)+(1/2)*e^(-t)*factorial(0)^(-1)-e^(-2*t)*factorial(0)^(-1)'
-            }
-        ];
-
-        for (var i = 0; i < testCases.length; ++i) {
-            // when
-            var parsed = nerdamer(testCases[i].given);
 
-            // then
-            expect(parsed.toString()).toEqual(testCases[i].expected);
-        }
+    it('should invert a Laplace transform correctly', function () {
+        expect(nerdamer('ilt(a/(b*x), x, t)').toString()).toEqual('a*b^(-1)');
+        expect(nerdamer('ilt(a*6/(b*s^6),s,t)').toString()).toEqual('(1/20)*a*b^(-1)*t^5');
+        expect(nerdamer('ilt(3*s/(4*s^2+5),s,t)').toString()).toEqual('(3/4)*cos((1/2)*sqrt(5)*t)');
+        expect(nerdamer('ilt(2/(3*s^2+1),s,t)').toString()).toEqual('2*sin((1/3)*sqrt(3)*t)*sqrt(3)^(-1)');
+        expect(nerdamer('ilt(5*sqrt(pi)/(3*s^(3/2)),s,t)').toString()).toEqual('(10/3)*sqrt(t)');
+        expect(nerdamer('ilt(3/(7*s^2+1)^2, s, t)').toString()).toEqual('(-3/14)*cos((1/7)*sqrt(7)*t)*t+(3/2)*sin((1/7)*sqrt(7)*t)*sqrt(7)^(-1)');
+        expect(nerdamer('ilt(5*s/(s^2+4)^2, s, t)').toString()).toEqual('(5/4)*sin(2*t)*t');
+        expect(nerdamer('ilt(8*s^2/(2*s^2+3)^2, s, t)').toString()).toEqual('2*sin((1/2)*sqrt(6)*t)*sqrt(6)^(-1)+cos((1/2)*sqrt(6)*t)*t');
+        expect(nerdamer('ilt((6*s^2-1)/(4*s^2+1)^2, s, t)').toString()).toEqual('(1/8)*sin((1/2)*t)+(5/16)*cos((1/2)*t)*t');
+        expect(nerdamer('ilt((5*(sin(1)*s+3*cos(1)))/(s^2+9),s, t)').toString()).toEqual('5*cos(1)*sin(3*t)+5*cos(3*t)*sin(1)');
+        expect(nerdamer('ilt(((s+1)*(s+2)*(s+3))^(-1), s, t)').toString()).toEqual('(1/2)*e^(-3*t)+(1/2)*e^(-t)-e^(-2*t)');
+        expect(nerdamer('ilt(1/(s^2+s+1),s,t)').toString()).toEqual('2*e^((-1/2)*t)*sin((1/2)*sqrt(3)*t)*sqrt(3)^(-1)');
+        expect(nerdamer('ilt(1/(s^2+2s+1),s,t)').toString()).toEqual('e^(-t)*t');
     });
-    
-    it('should calculate mode correctly', function () {
-        // given
-        var testCases = [
-            {
-                given: 'mode(r,r,r,r)',
-                expected: 'r'
-            },
-            {
-                given: 'mode(1,2)',
-                expected: 'mode(1,2)'
-            },
-            {
-                given: 'mode(1,2,3,1,2)',
-                expected: 'mode(1,2)'
-            },
-            {
-                given: 'mode(1,1,2)',
-                expected: '1'
-            },
-            {
-                given: 'mode(a,a,b,c,a,b,d)',
-                expected: 'a'
-            },
-            {
-                given: 'mode(x, r+1, 21, tan(x), r+1)',
-                expected: '1+r'
-            },
-            {
-                given: 'mode(x, r+1, 21, tan(x), r+1, x)',
-                expected: 'mode(1+r,x)'
-            }
-        ];
 
-        for (var i = 0; i < testCases.length; ++i) {
-            // when
-            var parsed = nerdamer(testCases[i].given);
-
-            // then
-            expect(parsed.toString()).toEqual(testCases[i].expected);
-        }
+    it('should calculate mode correctly', function () {
+        expect(nerdamer('mode(r,r,r,r)').toString()).toEqual('r');
+        expect(nerdamer('mode(1,2)').toString()).toEqual('mode(1,2)');
+        expect(nerdamer('mode(1,2,3,1,2)').toString()).toEqual('mode(1,2)');
+        expect(nerdamer('mode(1,1,2)').toString()).toEqual('1');
+        expect(nerdamer('mode(a,a,b,c,a,b,d)').toString()).toEqual('a');
+        expect(nerdamer('mode(x, r+1, 21, tan(x), r+1)').toString()).toEqual('1+r');
+        expect(nerdamer('mode(x, r+1, 21, tan(x), r+1, x)').toString()).toEqual('mode(1+r,x)');
     });
 });