nerdamer 1.1.12 → 1.1.13

package/Algebra.js

@@ -2394,6 +2394,7 @@ if((typeof module) !== 'undefined') {
                 return symbol;
             },
             _factor: function (symbol, factors) {
+                var g = symbol.group;
                 //some items cannot be factored any further so return those right away
                 if(symbol.group === FN) {
                     var arg = symbol.args[0];
@@ -2575,11 +2576,20 @@ if((typeof module) !== 'undefined') {
 
                         //last minute clean up
                         symbol = _.parse(symbol, core.Utils.getFunctionsSubs(map));
-
+                        
+                        var addPower = factors.length === 1;
+                        
                         factors.add(_.pow(symbol, _.parse(p)));
 
                         var retval = factors.toSymbol();
-
+                        
+                        // We may have only factored out the symbol itself so we end up with a factor of one 
+                        // where the power needs to be placed back
+                        // e.g. factor((2*y+p)^2). Here we end up having a factor of 1 remaining and a p of 2.
+                        if(addPower && symbol.equals(1) && retval.isLinear()) {
+                            retval = _.pow(retval, _.parse(p));
+                        }
+                        
                         return retval;
                     }
 
@@ -2910,11 +2920,17 @@ if((typeof module) !== 'undefined') {
 
                                 var div = __.div(symbol, d.clone()),
                                         is_factor = div[1].equals(0);
-
+                                
+                                // Break infinite loop for factoring e^t*x-1
+                                if((symbol.equals(div[0]) && div[1].equals(0))) {
+                                    break;
+                                }
+                                
                                 if(div[0].isConstant()) {
                                     factors.add(div[0]);
                                     break;
                                 }
+                                
                             }
                             else
                                 is_factor = false;
@@ -4172,7 +4188,7 @@ if((typeof module) !== 'undefined') {
                     var symbols = symbol.collectSymbols();
                     //assumption 1.
                     //since it's a composite, it has a length of at least 1
-                    var retval, a, b, d1, d2, n1, n2, x, y, c, den, num;
+                    var retval, a, b, d1, d2, n1, n2, s, x, y, c, den, num;
                     a = symbols.pop(); //grab the first symbol
                     //loop through each term and make denominator common
                     while(symbols.length) {
@@ -4184,11 +4200,11 @@ if((typeof module) !== 'undefined') {
                         c = _.multiply(d1.clone(), d2.clone());
                         x = _.multiply(n1, d2);
                         y = _.multiply(n2, d1);
-                        a = _.divide(_.add(x, y), c);
+                        s = _.add(x, y);
+                        a = _.divide(s, c);
                     }
                     den = _.expand(a.getDenom());
                     num = _.expand(a.getNum());
-
                     //simplify imaginary
                     if(num.isImaginary() && den.isImaginary()) {
                         retval = __.Simplify.complexSimp(num, den);
@@ -4345,7 +4361,6 @@ if((typeof module) !== 'undefined') {
                 symbol = sym_array.pop();
                 //remove gcd from denominator
                 symbol = __.Simplify.fracSimp(symbol);
-
                 //nothing more to do
                 if(symbol.isConstant() || symbol.group === core.groups.S) {
                     sym_array.push(symbol);
@@ -4549,5 +4564,5 @@ if((typeof module) !== 'undefined') {
             }
         }
     ]);
-    nerdamer.api();
+    nerdamer.updateAPI();
 })();

package/Calculus.js

@@ -1223,6 +1223,10 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
                                     __.integration.stop();
                                 }
                             }
+                            else if(p === 1/2 && x.power.equals(2) && a.greaterThan(0)) {
+                                // TODO: Revisit
+                                __.integration.stop();
+                            }
                             else {
                                 if(x.isLinear() && x.group !== PL)
                                     retval = _.divide(__.integration.poly_integrate(symbol), a);
@@ -2666,6 +2670,6 @@ if((typeof module) !== 'undefined' && typeof nerdamer === 'undefined') {
         }
     ]);
     //link registered functions externally
-    nerdamer.api();
+    nerdamer.updateAPI();
 
 })();

package/Extra.js

@@ -613,7 +613,7 @@ if((typeof module) !== 'undefined') {
     ]);
 
     //link registered functions externally
-    nerdamer.api();
+    nerdamer.updateAPI();
 }());
 
 // Added for all.min.js

package/README.md

@@ -20,6 +20,25 @@ Load the library in your html page
 <script src="Solve.js"></script>
 <script src="Extra.js"></script>
 ```
+Or import everything
+```html
+<script src="all.min.js"></script>  <!-- assuming you've saved the file in the root -->
+```
+If you're using node.js install it using `npm i nerdamer` and then
+
+```javascript
+// const cannot be used since nerdamer gets modified when other modules are loaded  
+var nerdamer = require('nerdamer'); 
+// Load additional modules. These are not required.  
+require('nerdamer/Algebra'); 
+require('nerdamer/Calculus'); 
+require('nerdamer/Solve'); 
+require('nerdamer/Extra');
+```
+Or do a single import to import everything
+```javascript
+const nerdamer = require("nerdamer/all.min")
+```
 
 Some functions have dependencies from other add-ons. 
 
@@ -29,7 +48,7 @@ For full documentation go to http://nerdamer.com/documentation
 
 All operations are done using the 'nerdamer' object. 
 
-To add an expression just add it to the nerdamer object which will return a expression object.
+To add an expression just add it to the nerdamer object which will return a `Expression` object.
 
 ```javascript             
 var e = nerdamer('x^2+2*(cos(x)+x*x)');
@@ -38,6 +57,16 @@ console.log(e.text());
 //result: 
 //2*cos(x)+3*x^2
 ```            
+It is also possible to use `nerdamer` functions directly within the need for string manipulation of the input. The input will be parsed and the output will of type `Expression`. For example:
+```javascript
+var ans = nerdamer.expand('(x-1)^5');
+console.log(ans.text());
+// -1-10*x^2-5*x^4+10*x^3+5*x+x^5
+
+var sol = nerdamer.solve('x^2-4', 'x');
+console.log(sol.text())
+// [2,-2]
+```
 
 You can also pass in an object with known values as the second parameter.
 

package/Solve.js

@@ -97,7 +97,7 @@ if((typeof module) !== 'undefined') {
      * This is an equation that has a left hand side and a right hand side
      */
     function Equation(lhs, rhs) {
-        if(rhs.isConstant() && lhs.isConstant() && !lhs.equals(rhs) || lhs.equals(core.Settings.IMAGINARY) || rhs.equals(core.Settings.IMAGINARY))
+        if(rhs.isConstant() && lhs.isConstant() && !lhs.equals(rhs) || lhs.equals(core.Settings.IMAGINARY) && rhs.isConstant(true) || rhs.equals(core.Settings.IMAGINARY) && lhs.isConstant(true))
             throw new core.exceptions.NerdamerValueError(lhs.toString() + ' does not equal ' + rhs.toString());
         this.LHS = lhs; //left hand side
         this.RHS = rhs; //right and side
@@ -124,12 +124,19 @@ if((typeof module) !== 'undefined') {
             }
             var a = eqn.LHS;
             var b = eqn.RHS;
+            
             if(a.isConstant(true) && !b.isConstant(true)) {
                 // Swap them to avoid confusing parser and cause an infinite loop
                 [a, b] = [b, a];
             }
             var _t = _.subtract(a, b);
             var retval = expand ? _.expand(_t) : _t;
+            
+            // Quick workaround for issue #636
+            // This basically borrows the removeDenom method from the Equation class. 
+            // TODO: Make this function a stand-alone function
+            retval = new Equation(retval, new Symbol(0)).removeDenom().LHS;
+            
             return retval;
         },
         removeDenom: function () {
@@ -605,7 +612,43 @@ if((typeof module) !== 'undefined') {
                 }
 
                 vars = core.Utils.arrayGetVariables(eqns);
+                
+                // If the system only has one variable then we solve for the first one and 
+                // then test the remaining equations with that solution. If any of the remaining
+                // equation fails then the system has no solution
+                if(vars.length === 1) {
+                    var n = 0,
+                        sol, e;
+                    do {
+                        var e = eqns[n].clone();
+                        
+                        if(n > 0) {
+                            e = e.sub(vars[0], sol[0]);
+                        }
 
+                        sol = solve(e, vars[0]);
+                        // Skip the first one
+                        if(n === 0) 
+                            continue;
+                    }
+                    while(++n < eqns.length)
+                        
+                    // Format the output
+                    var solutions;
+                    if(Settings.SOLUTIONS_AS_OBJECT) {
+                        solutions = {};
+                        solutions[vars[0]] = sol;
+                    }
+                    else if(sol.length === 0) {
+                        solutions = sol; // No solutions
+                    }
+                    else {
+                        solutions = [vars[0], sol];
+                    }
+                        
+                    return solutions;
+                }
+                
                 // Deal with redundant equations as expressed in #562
                 // The fix is to remove all but the number of equations equal to the number
                 // of variables. We then solve those and then evaluate the remaining equations
@@ -748,6 +791,8 @@ if((typeof module) !== 'undefined') {
          */
         quad: function (c, b, a) {
             var discriminant = _.subtract(_.pow(b.clone(), Symbol(2)), _.multiply(_.multiply(a.clone(), c.clone()), Symbol(4)))/*b^2 - 4ac*/;
+            // Fix for #608
+            discriminant = _.expand(discriminant);
             var det = _.pow(discriminant, Symbol(0.5));
             var den = _.parse(_.multiply(new Symbol(2), a.clone()));
             var retval = [
@@ -1357,6 +1402,7 @@ if((typeof module) !== 'undefined') {
             return symbol;
         };
 
+
         //separate the equation
         var separate = function (eq) {
             var lhs = new Symbol(0),
@@ -1561,8 +1607,11 @@ if((typeof module) !== 'undefined') {
                                 var separated = separate(eq);
                                 var lhs = separated[0],
                                         rhs = separated[1];
+                                
                                 if(lhs.group === core.groups.EX) {
-                                    add_to_result(_.parse(core.Utils.format(core.Settings.LOG + '(({0})/({2}))/' + core.Settings.LOG + '({1})', rhs, lhs.value, lhs.multiplier)));
+                                    var log = core.Settings.LOG;
+                                    var expr_str = `${log}((${rhs})/(${lhs.multiplier}))/${log}(${lhs.value})/${lhs.power.multiplier}`;
+                                    add_to_result(_.parse(expr_str));
                                 }
                                 break;
                             case 1:
@@ -1730,5 +1779,5 @@ if((typeof module) !== 'undefined') {
             }
         }
     ]);
-    nerdamer.api();
+    nerdamer.updateAPI();
 })();