From 7a4fe23465531bbb073c4768d4ed56c5af618130 Mon Sep 17 00:00:00 2001
From: Martin Donk <jiggzson@gmail.com>
Date: Mon, 30 Dec 2019 16:03:02 -0600
Subject: [PATCH 1/4] Revisiting roots

---
 Algebra.js        |  2 +-
 nerdamer.core.js  | 67 ++++++++++++++++++++++++++++++++++++-----------
 spec/core.spec.js |  2 +-
 3 files changed, 53 insertions(+), 18 deletions(-)

diff --git a/Algebra.js b/Algebra.js
index 42dfc181..ef2d67c5 100644
--- a/Algebra.js
+++ b/Algebra.js
@@ -3924,4 +3924,4 @@ if((typeof module) !== 'undefined') {
         }
     ]);
     nerdamer.api();
-})();
+})();
\ No newline at end of file
diff --git a/nerdamer.core.js b/nerdamer.core.js
index adc58908..095148cb 100644
--- a/nerdamer.core.js
+++ b/nerdamer.core.js
@@ -1133,7 +1133,10 @@ var nerdamer = (function (imports) {
 //Big ========================================================================== 
     var Big = {
         cos: function (x) {
-            return new Symbol(bigDec.cos(x.toString()));
+            return new Symbol(bigDec.cos(x.multiplier.toDecimal()));
+        },
+        sin: function (x) {
+            return new Symbol(bigDec.sin(x.multiplier.toDecimal()));
         }
     };
 //Math2 ======================================================================== 
@@ -5467,7 +5470,8 @@ var nerdamer = (function (imports) {
             'intersects': [intersects, 2],
             'is_subset': [is_subset, 2],
             //system support
-            'print': [print, -1]
+            'print': [print, -1],
+            'nroots': [nroots, 1]
         };
 
         //error handler
@@ -6945,7 +6949,38 @@ var nerdamer = (function (imports) {
         function degrees(symbol) {
             return _.parse(format('({0})*180/pi', symbol));
         }
-
+        
+        function nroots(symbol) {
+            var a, b;
+            if(symbol.group === FN && symbol.fname === '') {
+                a = Symbol.unwrapPARENS(_.parse(symbol).toLinear());
+                b = _.parse(symbol.power);
+            }
+            if(symbol.group === P) {
+                a = _.parse(symbol.value);
+                b = _.parse(symbol.power);
+            }
+            
+            if(a && b && a.group === N && b.group === N) {
+                var _roots = [];
+                var r = _.parse(a).abs().toString();
+                //https://en.wikipedia.org/wiki/De_Moivre%27s_formula
+                var x = arg(a).toString();
+                var n = b.multiplier.den.toString();
+                var p = b.multiplier.num.toString();
+                
+                var formula = "(({0})^({1})*(cos({3})+({2})*sin({3})))^({4})";
+                for(var i=0; i<n; i++) {
+                    var t = evaluate(_.parse(format("(({0})+2*pi*({1}))/({2})", x, i, n))).multiplier.toDecimal();
+                    _roots.push(evaluate(_.parse(format(formula, r, n, Settings.IMAGINARY, t, p))));
+                }
+                return Vector.fromArray(_roots);
+            }
+            else {
+                return Vector.fromArray([_.parse(symbol)]);
+            }
+        }
+        
         /**
          * The square root function
          * @param {Symbol} symbol
@@ -8983,19 +9018,19 @@ var nerdamer = (function (imports) {
                             result = _.multiply(_.pow(a, b), i);
                         }
                         else {
-                            if(a.equals(-1)) {
-                                var theta = _.multiply(b, _.parse('pi'));
-                                result = evaluate(_.add(trig.cos(theta), _.multiply(Symbol.imaginary(), trig.sin(theta))));
-                            }
-                            else {
-                                var aa = a.clone();
-                                aa.multiplier.negate();
-                                result = _.pow(_.symfunction(PARENTHESIS, [new Symbol(sign)]), b.clone());
-                                var _a = _.pow(new Symbol(aa.multiplier.num), b.clone());
-                                var _b = _.pow(new Symbol(aa.multiplier.den), b.clone());
-                                var r = _.divide(_a, _b);
-                                result = _.multiply(result, r);
-                            }  
+//                            if(a.equals(-1)) {
+//                                var theta = _.multiply(b, _.parse('pi'));
+//                                result = evaluate(_.add(trig.cos(theta), _.multiply(Symbol.imaginary(), trig.sin(theta))));
+//                            }
+//                            else {
+                            var aa = a.clone();
+                            aa.multiplier.negate();
+                            result = _.pow(_.symfunction(PARENTHESIS, [new Symbol(sign)]), b.clone());
+                            var _a = _.pow(new Symbol(aa.multiplier.num), b.clone());
+                            var _b = _.pow(new Symbol(aa.multiplier.den), b.clone());
+                            var r = _.divide(_a, _b);
+                            result = _.multiply(result, r);
+//                            }  
                         }
                     }
                     else if (Settings.PARSE2NUMBER && b.isImaginary()) {
diff --git a/spec/core.spec.js b/spec/core.spec.js
index 4188beb3..84c44bc2 100644
--- a/spec/core.spec.js
+++ b/spec/core.spec.js
@@ -191,7 +191,7 @@ describe('Nerdamer core', function () {
             },
             {
                 given: '(-1)^(3/4)',
-                expected: '(93222358/131836323)*i-93222358/131836323'
+                expected: '(-1)^(3/4)'
             }
         ];
 

From 76b1aadb9052611fe6f75f0d0877862492c071e1 Mon Sep 17 00:00:00 2001
From: Martin Donk <jiggzson@gmail.com>
Date: Mon, 30 Dec 2019 16:58:23 -0600
Subject: [PATCH 2/4] Update to nroots

---
 nerdamer.core.js | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/nerdamer.core.js b/nerdamer.core.js
index 095148cb..f67d1f60 100644
--- a/nerdamer.core.js
+++ b/nerdamer.core.js
@@ -6956,13 +6956,14 @@ var nerdamer = (function (imports) {
                 a = Symbol.unwrapPARENS(_.parse(symbol).toLinear());
                 b = _.parse(symbol.power);
             }
-            if(symbol.group === P) {
+            else if(symbol.group === P) {
                 a = _.parse(symbol.value);
                 b = _.parse(symbol.power);
             }
             
             if(a && b && a.group === N && b.group === N) {
                 var _roots = [];
+                var parts = Symbol.toPolarFormArray(symbol);
                 var r = _.parse(a).abs().toString();
                 //https://en.wikipedia.org/wiki/De_Moivre%27s_formula
                 var x = arg(a).toString();
@@ -6976,9 +6977,23 @@ var nerdamer = (function (imports) {
                 }
                 return Vector.fromArray(_roots);
             }
+            else if(symbol.isConstant(true)) {
+                var sign = symbol.sign();
+                var x = evaluate(symbol.abs());
+                var root = _.sqrt(x);
+                
+                var _roots = [root.clone(), root.negate()];
+                
+                if(sign < 0)
+                    _roots = _roots.map(function(x) {
+                        return _.multiply(x, Symbol.imaginary());
+                    });
+            }
             else {
-                return Vector.fromArray([_.parse(symbol)]);
+                _roots = [_.parse(symbol)];
             }
+            
+            return Vector.fromArray(_roots);
         }
         
         /**
@@ -11534,3 +11549,7 @@ var nerdamer = (function (imports) {
 if ((typeof module) !== 'undefined') {
     module.exports = nerdamer;
 };
+
+
+var x = nerdamer('nroots(4+2i)');
+console.log(x.text());
\ No newline at end of file

From 2b4e4a851afabd3d0a94ae77bcbe260d5a57430e Mon Sep 17 00:00:00 2001
From: Martin Donk <jiggzson@gmail.com>
Date: Mon, 30 Dec 2019 22:08:40 -0600
Subject: [PATCH 3/4] roots in progress

---
 Algebra.js       |   4 ++
 nerdamer.core.js | 144 +++++++++++++++++++++++++++--------------------
 2 files changed, 88 insertions(+), 60 deletions(-)

diff --git a/Algebra.js b/Algebra.js
index ef2d67c5..8efb79a0 100644
--- a/Algebra.js
+++ b/Algebra.js
@@ -1787,6 +1787,10 @@ if((typeof module) !== 'undefined') {
             } 
          },
         roots: function(symbol) {
+            
+            if(symbol.isConstant(true, true)) {
+                return core.Utils.nroots(symbol);
+            }
             var roots = __.proots(symbol).map(function(x) {
                 return _.parse(x);
             });
diff --git a/nerdamer.core.js b/nerdamer.core.js
index f67d1f60..4aaabc59 100644
--- a/nerdamer.core.js
+++ b/nerdamer.core.js
@@ -5,7 +5,7 @@
  * Source : https://github.com/jiggzson/nerdamer
  */
 
-/* global trig, trigh, Infinity, define, arguments2Array, NaN */
+/* global trig, trigh, Infinity, define, arguments2Array, NaN, evaluate */
 //externals ====================================================================
 /* BigInterger.js v1.6.40 https://github.com/peterolson/BigInteger.js/blob/master/LICENSE */
 //var nerdamerBigInt = typeof nerdamerBigInt !== 'undefined' ? nerdamerBigInt : require("big-integer");
@@ -709,7 +709,61 @@ var nerdamer = (function (imports) {
         return retval;
     };
 
+    /**
+     * Gets nth roots of a number
+     * @param {Symbol} symbol
+     * @returns {Vector}
+     */
+    var nroots = function(symbol) {
+        var a, b;
+
+        if(symbol.group === FN && symbol.fname === '') {
+            a = Symbol.unwrapPARENS(_.parse(symbol).toLinear());
+            b = _.parse(symbol.power);
+        }
+        else if(symbol.group === P) {
+            a = _.parse(symbol.value);
+            b = _.parse(symbol.power);
+        }
 
+        if(a && b && (a.group === N || a.group === CP) && b.group === N) {
+            var _roots = [];
+            var parts = Symbol.toPolarFormArray(evaluate(symbol));
+
+            var r = parts[0];
+
+            //https://en.wikipedia.org/wiki/De_Moivre%27s_formula
+            var x = _.arg(a);
+            var n = b.multiplier.den.toString();
+            var p = b.multiplier.num.toString();
+
+            var formula = '(({0})^({1})*(cos({3})+({2})*sin({3})))^({4})';
+
+            for(var i=0; i<n; i++) {
+                var t = evaluate(_.parse(format("(({0})+2*pi*({1}))/({2})", x, i, n))).multiplier.toDecimal();
+                _roots.push(evaluate(_.parse(format(formula, r, n, Settings.IMAGINARY, t, p))));
+            }
+            return Vector.fromArray(_roots);
+        }
+        else if(symbol.isConstant(true, true)) {
+            var sign = symbol.sign();
+            var x = evaluate(symbol.abs());
+            var root = _.sqrt(x);
+
+            var _roots = [root.clone(), root.negate()];
+
+            if(sign < 0)
+                _roots = _roots.map(function(x) {
+                    return _.multiply(x, Symbol.imaginary());
+                });
+        }
+        else {
+            _roots = [_.parse(symbol)];
+        }
+
+        return Vector.fromArray(_roots);
+    };
+    
     /**
      * Sorts and array given 2 parameters
      * @param {String} a
@@ -3112,17 +3166,14 @@ var nerdamer = (function (imports) {
         return symbol;
     };
     Symbol.hyp = function (a, b) {
-        if (a.equals(0))
-            return b.clone();
-        if (b.equals(0))
-            return a.clone();
+        a = a || new Symbol(0);
+        b = b || new Symbol(0);
         return _.sqrt(_.add(_.pow(a.clone(), new Symbol(2)), _.pow(b.clone(), new Symbol(2))));
     };
     //converts to polar form array
     Symbol.toPolarFormArray = function (symbol) {
         var re, im, r, theta;
         re = symbol.realpart();
-        im = symbol.imagpart();
         r = Symbol.hyp(re, im);
         theta = re.equals(0) ? _.parse('pi/2') : _.trig.atan(_.divide(im, re));
         return [r, theta];
@@ -3515,9 +3566,17 @@ var nerdamer = (function (imports) {
         isSQRT: function () {
             return this.fname === SQRT;
         },
-        isConstant: function (check_all) {
+        isConstant: function (check_all, check_symbols) {
+            if(check_symbols && this.group === CB) {
+                for(var x in this.symbols) {
+                    if(this.symbols[x].isConstant(true))
+                        return true;
+                }
+            }
+            
             if (check_all === 'all' && (this.isPi() || this.isE()))
                 return true;
+            
             if (check_all && this.group === FN) {
                 for (var i = 0; i < this.args.length; i++) {
                     if (!this.args[i].isConstant(check_all))
@@ -5470,8 +5529,7 @@ var nerdamer = (function (imports) {
             'intersects': [intersects, 2],
             'is_subset': [is_subset, 2],
             //system support
-            'print': [print, -1],
-            'nroots': [nroots, 1]
+            'print': [print, -1]
         };
 
         //error handler
@@ -6950,52 +7008,6 @@ var nerdamer = (function (imports) {
             return _.parse(format('({0})*180/pi', symbol));
         }
         
-        function nroots(symbol) {
-            var a, b;
-            if(symbol.group === FN && symbol.fname === '') {
-                a = Symbol.unwrapPARENS(_.parse(symbol).toLinear());
-                b = _.parse(symbol.power);
-            }
-            else if(symbol.group === P) {
-                a = _.parse(symbol.value);
-                b = _.parse(symbol.power);
-            }
-            
-            if(a && b && a.group === N && b.group === N) {
-                var _roots = [];
-                var parts = Symbol.toPolarFormArray(symbol);
-                var r = _.parse(a).abs().toString();
-                //https://en.wikipedia.org/wiki/De_Moivre%27s_formula
-                var x = arg(a).toString();
-                var n = b.multiplier.den.toString();
-                var p = b.multiplier.num.toString();
-                
-                var formula = "(({0})^({1})*(cos({3})+({2})*sin({3})))^({4})";
-                for(var i=0; i<n; i++) {
-                    var t = evaluate(_.parse(format("(({0})+2*pi*({1}))/({2})", x, i, n))).multiplier.toDecimal();
-                    _roots.push(evaluate(_.parse(format(formula, r, n, Settings.IMAGINARY, t, p))));
-                }
-                return Vector.fromArray(_roots);
-            }
-            else if(symbol.isConstant(true)) {
-                var sign = symbol.sign();
-                var x = evaluate(symbol.abs());
-                var root = _.sqrt(x);
-                
-                var _roots = [root.clone(), root.negate()];
-                
-                if(sign < 0)
-                    _roots = _roots.map(function(x) {
-                        return _.multiply(x, Symbol.imaginary());
-                    });
-            }
-            else {
-                _roots = [_.parse(symbol)];
-            }
-            
-            return Vector.fromArray(_roots);
-        }
-        
         /**
          * The square root function
          * @param {Symbol} symbol
@@ -7256,8 +7268,18 @@ var nerdamer = (function (imports) {
         function arg(symbol) {
             var re = symbol.realpart();
             var im = symbol.imagpart();
-            if (re.isConstant() && im.isConstant())
+            if (re.isConstant() && im.isConstant()) {
+//                if(im.equals(0) && re.equals(-1)) {
+//                    return _.parse('pi');
+//                }
+//                else if(im.equals(1) && re.equals(0)) {
+//                    return _.parse('pi/2');
+//                }
+//                else if(im.equals(1) && re.equals(1)) {
+//                    return _.parse('pi/4');
+//                }
                 return new Symbol(Math.atan2(im, re));
+            }
             return _.symfunction('atan2', [im, re]);
         }
 
@@ -8059,6 +8081,11 @@ var nerdamer = (function (imports) {
         this.sqrt = sqrt;
         this.log = log;
         this.nthroot = nthroot;
+        this.arg = arg;
+        this.conjugate = conjugate;
+        this.imagpart = imagpart;
+        this.realpart = realpart;
+        
 
 //Parser.methods ===============================================================
         this.addPreprocessor = function (name, action, order, shift_cells) {
@@ -11024,6 +11051,7 @@ var nerdamer = (function (imports) {
         isVariableSymbol: isVariableSymbol,
         isVector: isVector,
         keys: keys,
+        nroots: nroots,
         remove: remove,
         reserveNames: reserveNames,
         range: range,
@@ -11549,7 +11577,3 @@ var nerdamer = (function (imports) {
 if ((typeof module) !== 'undefined') {
     module.exports = nerdamer;
 };
-
-
-var x = nerdamer('nroots(4+2i)');
-console.log(x.text());
\ No newline at end of file

From 4b9992aca16601e4f98c5801c22521f50961d05f Mon Sep 17 00:00:00 2001
From: Martin Donk <jiggzson@gmail.com>
Date: Tue, 31 Dec 2019 10:35:33 -0600
Subject: [PATCH 4/4] Update roots

---
 nerdamer.core.js     | 92 ++++++++++++++++++++++++++++++++++++--------
 spec/algebra.spec.js |  5 +++
 2 files changed, 82 insertions(+), 15 deletions(-)

diff --git a/nerdamer.core.js b/nerdamer.core.js
index 4aaabc59..e331d151 100644
--- a/nerdamer.core.js
+++ b/nerdamer.core.js
@@ -5,7 +5,7 @@
  * Source : https://github.com/jiggzson/nerdamer
  */
 
-/* global trig, trigh, Infinity, define, arguments2Array, NaN, evaluate */
+/* global trig, trigh, Infinity, define, arguments2Array, NaN */
 //externals ====================================================================
 /* BigInterger.js v1.6.40 https://github.com/peterolson/BigInteger.js/blob/master/LICENSE */
 //var nerdamerBigInt = typeof nerdamerBigInt !== 'undefined' ? nerdamerBigInt : require("big-integer");
@@ -709,7 +709,7 @@ var nerdamer = (function (imports) {
         return retval;
     };
 
-    /**
+     /**
      * Gets nth roots of a number
      * @param {Symbol} symbol
      * @returns {Vector}
@@ -726,11 +726,13 @@ var nerdamer = (function (imports) {
             b = _.parse(symbol.power);
         }
 
-        if(a && b && (a.group === N || a.group === CP) && b.group === N) {
+        if(a && b && (a.group === N) && b.group === N && a.multiplier.isNegative()) {
             var _roots = [];
+            
             var parts = Symbol.toPolarFormArray(evaluate(symbol));
-
             var r = parts[0];
+            
+            //var r = _.parse(a).abs().toString();
 
             //https://en.wikipedia.org/wiki/De_Moivre%27s_formula
             var x = _.arg(a);
@@ -756,6 +758,7 @@ var nerdamer = (function (imports) {
                 _roots = _roots.map(function(x) {
                     return _.multiply(x, Symbol.imaginary());
                 });
+                
         }
         else {
             _roots = [_.parse(symbol)];
@@ -763,7 +766,7 @@ var nerdamer = (function (imports) {
 
         return Vector.fromArray(_roots);
     };
-    
+
     /**
      * Sorts and array given 2 parameters
      * @param {String} a
@@ -3174,6 +3177,7 @@ var nerdamer = (function (imports) {
     Symbol.toPolarFormArray = function (symbol) {
         var re, im, r, theta;
         re = symbol.realpart();
+        im = symbol.imagpart();
         r = Symbol.hyp(re, im);
         theta = re.equals(0) ? _.parse('pi/2') : _.trig.atan(_.divide(im, re));
         return [r, theta];
@@ -7008,6 +7012,52 @@ var nerdamer = (function (imports) {
             return _.parse(format('({0})*180/pi', symbol));
         }
         
+        function nroots(symbol) {
+            var a, b;
+            if(symbol.group === FN && symbol.fname === '') {
+                a = Symbol.unwrapPARENS(_.parse(symbol).toLinear());
+                b = _.parse(symbol.power);
+            }
+            else if(symbol.group === P) {
+                a = _.parse(symbol.value);
+                b = _.parse(symbol.power);
+            }
+            
+            if(a && b && a.group === N && b.group === N) {
+                var _roots = [];
+                var parts = Symbol.toPolarFormArray(symbol);
+                var r = _.parse(a).abs().toString();
+                //https://en.wikipedia.org/wiki/De_Moivre%27s_formula
+                var x = arg(a).toString();
+                var n = b.multiplier.den.toString();
+                var p = b.multiplier.num.toString();
+                
+                var formula = "(({0})^({1})*(cos({3})+({2})*sin({3})))^({4})";
+                for(var i=0; i<n; i++) {
+                    var t = evaluate(_.parse(format("(({0})+2*pi*({1}))/({2})", x, i, n))).multiplier.toDecimal();
+                    _roots.push(evaluate(_.parse(format(formula, r, n, Settings.IMAGINARY, t, p))));
+                }
+                return Vector.fromArray(_roots);
+            }
+            else if(symbol.isConstant(true)) {
+                var sign = symbol.sign();
+                var x = evaluate(symbol.abs());
+                var root = _.sqrt(x);
+                
+                var _roots = [root.clone(), root.negate()];
+                
+                if(sign < 0)
+                    _roots = _roots.map(function(x) {
+                        return _.multiply(x, Symbol.imaginary());
+                    });
+            }
+            else {
+                _roots = [_.parse(symbol)];
+            }
+            
+            return Vector.fromArray(_roots);
+        }
+        
         /**
          * The square root function
          * @param {Symbol} symbol
@@ -7260,6 +7310,19 @@ var nerdamer = (function (imports) {
             return _.add(re, _.multiply(im.negate(), Symbol.imaginary()));
         }
 
+        /**
+         * Returns the arugment of a complex number
+         * @param {Symbol} symbol
+         * @returns {Symbol}
+         */
+        function arg(symbol) {
+            var re = symbol.realpart();
+            var im = symbol.imagpart();
+            if (re.isConstant() && im.isConstant())
+                return new Symbol(Math.atan2(im, re));
+            return _.symfunction('atan2', [im, re]);
+        }
+
         /**
          * Returns the arugment of a complex number
          * @param {Symbol} symbol
@@ -7269,15 +7332,15 @@ var nerdamer = (function (imports) {
             var re = symbol.realpart();
             var im = symbol.imagpart();
             if (re.isConstant() && im.isConstant()) {
-//                if(im.equals(0) && re.equals(-1)) {
-//                    return _.parse('pi');
-//                }
-//                else if(im.equals(1) && re.equals(0)) {
-//                    return _.parse('pi/2');
-//                }
-//                else if(im.equals(1) && re.equals(1)) {
-//                    return _.parse('pi/4');
-//                }
+                if(im.equals(0) && re.equals(-1)) {
+                    return _.parse('pi');
+                }
+                else if(im.equals(1) && re.equals(0)) {
+                    return _.parse('pi/2');
+                }
+                else if(im.equals(1) && re.equals(1)) {
+                    return _.parse('pi/4');
+                }
                 return new Symbol(Math.atan2(im, re));
             }
             return _.symfunction('atan2', [im, re]);
@@ -8085,7 +8148,6 @@ var nerdamer = (function (imports) {
         this.conjugate = conjugate;
         this.imagpart = imagpart;
         this.realpart = realpart;
-        
 
 //Parser.methods ===============================================================
         this.addPreprocessor = function (name, action, order, shift_cells) {
diff --git a/spec/algebra.spec.js b/spec/algebra.spec.js
index 246c4672..3a499170 100644
--- a/spec/algebra.spec.js
+++ b/spec/algebra.spec.js
@@ -753,4 +753,9 @@ describe('Algebra', function () {
             expect(result.toString()).toEqual(testCases[i].expected);
         }
     });
+    
+    it('should calculate nth roots correctly', function() {
+        expect(nerdamer('roots((-1)^(1/5))').evaluate().text()).toEqual('[0.5877852522924731*i+0.8090169943749475,-0.3090169943749474+0.9510565162951536*i,-1+1.2246467991473532e-16*i,-0.30901699437494756-0.9510565162951535*i,-0.5877852522924734*i+0.8090169943749473]');
+        expect(nerdamer('roots((2)^(1/3))').evaluate().text()).toEqual('[1.1224620483093812,-1.1224620483093812]');
+    });
 });