* Bug #12678 fixed - nthroot() vectorizable 71/11671/7
Paul BIGNIER [Mon, 10 Jun 2013 09:06:12 +0000 (11:06 +0200)]
Allowing second argument of nthroot to be a vector or a matrix

Updated test and doc

Change-Id: I2aacd7076bcf82ad28dada6bc388ed81119a4914

SEP/SEP_078_nthroot.odt
scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/help/en_US/nthroot.xml
scilab/modules/elementary_functions/macros/nthroot.sci
scilab/modules/elementary_functions/tests/unit_tests/nthroot.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/nthroot.tst

index f2b2dea..48cdd1f 100644 (file)
Binary files a/SEP/SEP_078_nthroot.odt and b/SEP/SEP_078_nthroot.odt differ
index 1ce8627..fb1f947 100644 (file)
@@ -355,3 +355,4 @@ Bug fixes
 
 * Bug #12641 fixed - graypolarplot() was slow and has been fully vectorized.
 
+* Bug #12678 fixed - nthroot() now accepts vector/matrix as second argument
index b828232..443ad32 100644 (file)
@@ -33,7 +33,7 @@
             <varlistentry>
                 <term>n</term>
                 <listitem>
-                    <para>real scalar</para>
+                    <para>real scalar or vector/matrix</para>
                 </listitem>
             </varlistentry>
         </variablelist>
         <title>Description</title>
         <para>
             <literal>nthroot(x,n)</literal> is the real vector/matrix of the nth root of the
-            <literal>x</literal> elements. If <literal>x</literal> has negative elements, <literal>n</literal> must be an odd.
+            <literal>x</literal> elements. If <literal>x</literal> has negative elements, <literal>n</literal> must be odd.
+        </para>
+        <para>
+            If <literal>n</literal> is not a scalar, then the function proceeds elementwise.
         </para>
     </refsection>
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[ 
-       nthroot(2,3)    
-       nthroot(-2,3)   
-       nthroot(-2,-3)
-       nthroot(2,-3)
+nthroot(2, 3)
+nthroot(-2, 3)
+nthroot(-2, -3)
+nthroot(2, -3)
+nthroot([27 27], 3)
+nthroot([27 256], [3 4])
+nthroot([27 256; 3125 46656], [3 4; 5 6])
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
index 7543e50..a41ee14 100644 (file)
@@ -11,53 +11,66 @@ function y = nthroot(x,n)
 
     rhs = argn(2);
 
-    // if the number of input arguments is wrong
+    // If the number of input arguments is wrong
     if rhs <> 2 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"), "nthroot", 2));
     end
 
-    // if x or n are not real
+    // If x or n are not real
     if ((typeof(x) <> "constant" | ~isreal(x)) | (typeof(n) <> "constant" | ~isreal(n))) then
-        error(msprintf(gettext("%s: Wrong type for input argument(s) %d: real arguments expected.\n"),"nthroot",2));
+        error(msprintf(gettext("%s: Wrong type for input argument(s) #%d: Real arguments expected.\n"),"nthroot", 2));
     end
 
-    // if n is not scalar
-    if (size(n,"*")~=1) then
-        error(msprintf(gettext("%s: Wrong type for input argument(s) %d: n must be a scalar.\n"),"nthroot",1));
+    // If n is a vector which size is different from x's
+    if (size(n,"*")>1 & size(n,"*")<>size(x,"*")) then
+        error(msprintf(gettext("%s: Wrong size for input argument(s) #%d: vectors should have same size.\n"),"nthroot", 2));
     end
 
     reste = modulo(n,2);
+    // Making 'reste' one element
+    if (size(n,"*")>1) then
+        reste = or(reste(find(x<0))<>0);
+    end
     y = x;
 
-    // if n = %nan and x is positive then y = %nan
+    if (or(n==0) & (x>=0 | isnan(x))) then
+        // If n = 0 and x = 1 or x = %nan then y = %nan
+        y(find((x==1 | isnan(x)) & n==0)) = %nan;
+        // If n = 0 and x>1 then y = %inf
+        y(find(x>1 & n==0)) = %inf;
+        // If n = 0 and x = %eps then y = 0
+        y(find(x==%eps & n==0)) = 0;
+    end
+
+    // If n = %nan and x is positive then y = %nan
     if (isnan(n) & or(x >= 0)) then
         y(find(x>=0)) = %nan;
     elseif (x==[]) then
         y = [];
-    elseif (n==0 & (x>=0 | isnan(x))) then
-        // if n = 0 and x = 1 or x = %nan then y = %nan
-        y(find((x==1 | isnan(x)))) = %nan;
-        // if n = 0 and x>1 then y = %inf
-        y(find(x>1)) = %inf;
-        // if n = 0 and x = %eps then y = 0
-        y(find(x==%eps)) = 0;
-    elseif (or (or(x(:)<0) & (n~=fix(n) | reste ==0))) then
-        error(msprintf(gettext("%s: If x is negative, n must be an odd integer\n"),"nthroot"));
-        // if n ~=0 and n ~= %nan
-    elseif (n~=0 & ~isnan(n)) then
-        //if x = 0 and n is negative and n i~= %nan
+    elseif (n==[]) then
+        y = x;
+    elseif (or (or(x(:)<0) & (or(n~=fix(n)) | reste==0 | reste==%f))) then
+        error(msprintf(gettext("%s: If x is negative, then n must be odd integers\n"),"nthroot"));
+        // If n ~=0 and n ~= %nan
+    elseif (or(n~=0) & ~isnan(n)) then
+        // If x = 0 and n is negative and n i~= %nan
         [m1,m2] = size(x(find(x==0 & n<0 & ~isinf(n))));
         y(find(x==0 & n<0 & ~isinf(n))) = (x(find(x==0 & n<0 & ~isinf(n)))+ones(m1,m2)) .*%inf;
-        //if x = 0 and n is positive and n ~= %nan
-        y(find(x==0 & (n>0 |isinf(n)))) = x(find(x==0 & (n>0 |isinf(n)))).^(1 ./n);
-        // if x is positive
-        y(find(x>0)) = x(find(x>0)).^(1 ./n);
-        // if x is negative
-        y(find(x<0)) = sign(x(find(x<0))).*(abs(x(find(x<0)))).^(1 ./n);
+        if (size(n,"*") == 1) then
+            // If x = 0 and n is positive and n ~= %nan
+            y(find(x==0 & (n>0 |isinf(n)))) = x(find(x==0 & (n>0 |isinf(n)))).^(1 ./n(find(n<>0)));
+            // If x is positive
+            y(find(x>0)) = x(find(x>0)).^(1 ./n(find(n<>0)));
+            // If x is negative
+            y(find(x<0)) = sign(x(find(x<0))).*(abs(x(find(x<0)))).^(1 ./n(find(n<>0)));
+        else
+            // If x = 0 and n is positive and n ~= %nan
+            y(find(x==0 & (n>0 |isinf(n)))) = x(find(x==0 & (n>0 |isinf(n)))).^(1 ./n(find(x==0 & n<>0)));
+            // If x is positive
+            y(find(x>0 & n<>0)) = x(find(x>0 & n<>0)).^(1 ./n(find(x>0 & n<>0)));
+            // If x is negative
+            y(find(x<0 & n<>0)) = sign(x(find(x<0 & n<>0))).*(abs(x(find(x<0)))).^(1 ./n(find(x<0 & n<>0)));
+        end
     end
 
-
 endfunction
-
-
-
index eb699c1..1a6434b 100644 (file)
 // <-- CLI SHELL MODE -->
 // unit tests for nthroot() function 
 // =============================================================================
+// Run with test_run('elementary_functions', 'nthroot', ['no_check_error_output'])
 // 1. Interface
 // ============
-assert_checkfalse(execstr("nthroot()"   ,"errcatch") == 0);
+assert_checkfalse(execstr("nthroot()",          "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
  nthroot: Wrong number of input argument(s): 2 expected.   
-assert_checkfalse(execstr("nthroot(1)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(1)",         "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
  nthroot: Wrong number of input argument(s): 2 expected.   
-assert_checkfalse(execstr("nthroot(%i,1)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(%i, 1)",    "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: Wrong type for input argument(s) 2: real arguments expected.  
-assert_checkfalse(execstr("nthroot(%t,1)","errcatch") == 0);
+ nthroot: Wrong type for input argument(s) #2: Real arguments expected. 
+assert_checkfalse(execstr("nthroot(%t, 1)",    "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: Wrong type for input argument(s) 2: real arguments expected.  
-assert_checkfalse(execstr("nthroot(3,[])","errcatch") == 0);
+ nthroot: Wrong type for input argument(s) #2: Real arguments expected. 
+assert_checkfalse(execstr("nthroot(-2, %nan)", "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: Wrong type for input argument(s) 1: n must be a scalar.   
-assert_checkfalse(execstr("nthroot(-2,%nan)","errcatch") == 0);
+ nthroot: If x is negative, then n must be odd integers   
+assert_checkfalse(execstr("nthroot(-2, %eps)", "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: If x is negative, n must be an odd integer   
-assert_checkfalse(execstr("nthroot(-2,%eps)","errcatch") == 0);
+ nthroot: If x is negative, then n must be odd integers   
+assert_checkfalse(execstr("nthroot(-3, 6)",     "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: If x is negative, n must be an odd integer   
-assert_checkfalse(execstr("nthroot(-3,6)","errcatch") == 0);
+ nthroot: If x is negative, then n must be odd integers   
+assert_checkfalse(execstr("nthroot(-3, 0)",     "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: If x is negative, n must be an odd integer   
-assert_checkfalse(execstr("nthroot(-3,0)","errcatch") == 0);
+ nthroot: If x is negative, then n must be odd integers   
+assert_checkfalse(execstr("nthroot(-%inf, -2)", "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: If x is negative, n must be an odd integer   
-assert_checkfalse(execstr("nthroot(-%inf,-2)","errcatch") == 0);
+ nthroot: If x is negative, then n must be odd integers   
+assert_checkfalse(execstr("nthroot(-2, -2)",     "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: If x is negative, n must be an odd integer   
-assert_checkfalse(execstr("nthroot(-2,-2)","errcatch") == 0);
+ nthroot: If x is negative, then n must be odd integers   
+assert_checkfalse(execstr("nthroot(-2, 2)",      "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
  ans  =
  
- nthroot: If x is negative, n must be an odd integer   
-assert_checkfalse(execstr("nthroot(-2,2)","errcatch") == 0);
-lasterror(execstr("10000","errcatch") == 0)
- ans  =
- nthroot: If x is negative, n must be an odd integer   
+ nthroot: If x is negative, then n must be odd integers   
+assert_checktrue(nthroot(3, []) == 3);
 // 2. Singular Values
 // ==================
-assert_checkalmostequal(nthroot(2,-2),0.7071068, 1.e-5);
-assert_checkalmostequal(nthroot(2,2),1.4142136, 1.e-5);
-assert_checkalmostequal(nthroot(%eps,3),0.0000061, 1.e-2);
-assert_checkalmostequal(nthroot([1 2],2),[1 1.4142136], 1.e-5);
-assert_checkequal(nthroot(-2,%inf),-1);
-assert_checkequal(nthroot(3,%inf),1);
-assert_checkequal(nthroot(3,-%inf),1);
-assert_checkequal(nthroot(-3,%inf),-1);
-assert_checkequal(nthroot(3,%nan),%nan);
-assert_checkequal(nthroot(3,-%nan),%nan);
-assert_checkequal(nthroot(3,%eps),%inf);
-assert_checkequal(nthroot(3,-%eps),0);
-assert_checkequal(nthroot(3,0),%inf);
-assert_checkequal(nthroot(1,0),%nan);
-assert_checkequal(nthroot([1 2],%inf),[1 1]);
-assert_checkequal(nthroot([1 2],%nan),[%nan %nan]);
-assert_checkequal(nthroot([1 2],%eps),[1 %inf]);
-assert_checkequal(nthroot([1 2],0),[%nan %inf]);
-assert_checkequal(nthroot(0,0),0);
-assert_checkequal(nthroot(0,7),0);
-assert_checkequal(nthroot(0,-7),%inf);
-assert_checkequal(nthroot(0,%inf),1);
-assert_checkequal(nthroot(0,-%inf),1);
-assert_checkequal(nthroot(0,%nan),%nan);
-assert_checkequal(nthroot(0,%eps),0);
-assert_checkequal(nthroot(0,-%eps),%inf);
-assert_checkequal(nthroot([0;-1],%inf),[1;-1]);
-assert_checkequal(nthroot([0;1],0),[0;%nan]);
+assert_checkalmostequal(nthroot(2   ,-2), 0.7071068, 1.e-5);
+assert_checkalmostequal(nthroot(2   , 2), 1.4142136, 1.e-5);
+assert_checkalmostequal(nthroot(%eps, 3), 0.0000061, 1.e-2);
+assert_checkalmostequal(nthroot([1 2], 2)    , [1 1.4142136], 1.e-5);
+assert_checkalmostequal(nthroot([1 2], [2 2]), [1 1.4142136], 1.e-5);
+assert_checkequal(nthroot(-2,  %inf), -1);
+assert_checkequal(nthroot( 3 , %inf), 1);
+assert_checkequal(nthroot( 3 ,-%inf), 1);
+assert_checkequal(nthroot(-3,  %inf), -1);
+assert_checkequal(nthroot( 3 , %nan), %nan);
+assert_checkequal(nthroot( 3 ,-%nan), %nan);
+assert_checkequal(nthroot( 3 , %eps), %inf);
+assert_checkequal(nthroot( 3 ,-%eps), 0);
+assert_checkequal(nthroot( 3 , 0), %inf);
+assert_checkequal(nthroot( 1 , 0), %nan);
+assert_checkequal(nthroot([1 2], %inf), [1 1]);
+assert_checkequal(nthroot([1 2], %nan), [%nan %nan]);
+assert_checkequal(nthroot([1 2], %eps), [1 %inf]);
+assert_checkequal(nthroot([1 2], 0),    [%nan %inf]);
+assert_checkequal(nthroot([1 2], [%inf %inf]), [1 1]);
+assert_checkequal(nthroot([1 2], [%nan %nan]), [%nan %nan]);
+assert_checkequal(nthroot([1 2], [%eps %eps]), [1 %inf]);
+assert_checkequal(nthroot([1 2], [0 0]),       [%nan %inf]);
+assert_checkequal(nthroot(0, 0),    0);
+assert_checkequal(nthroot(0, 7),    0);
+assert_checkequal(nthroot(0,-7),    %inf);
+assert_checkequal(nthroot(0, %inf), 1);
+assert_checkequal(nthroot(0,-%inf), 1);
+assert_checkequal(nthroot(0, %nan), %nan);
+assert_checkequal(nthroot(0, %eps), 0);
+assert_checkequal(nthroot(0,-%eps), %inf);
+assert_checkequal(nthroot([0;-1], %inf), [1; -1]);
+assert_checkequal(nthroot([0; 1], 0),    [0; %nan]);
+assert_checkequal(nthroot([0;-1], [%inf; %inf]), [1; -1]);
+assert_checkequal(nthroot([0; 1], [0; 0]),       [0; %nan]);
 // 3. Empty Matrix
 //==================
-assert_checkequal(nthroot([],-2),[]);
-assert_checkequal(nthroot([],3),[]);
-assert_checkequal(nthroot([],%nan),[]);
-assert_checkequal(nthroot([],%inf),[]);
-assert_checkequal(nthroot([],-%inf),[]);
-assert_checkequal(nthroot([],%eps),[]);
-assert_checkequal(nthroot([],-%eps),[]);
-assert_checkequal(nthroot([],0),[]);
+assert_checkequal(nthroot([],-2),    []);
+assert_checkequal(nthroot([], 3),    []);
+assert_checkequal(nthroot([], %nan), []);
+assert_checkequal(nthroot([], %inf), []);
+assert_checkequal(nthroot([],-%inf), []);
+assert_checkequal(nthroot([], %eps), []);
+assert_checkequal(nthroot([],-%eps), []);
+assert_checkequal(nthroot([], 0),    []);
 // 4. Limit Values
 // ================
-assert_checkequal(nthroot(-%inf,-7),0);
-assert_checkequal(nthroot(-%inf,7),-%inf);
-assert_checkequal(nthroot(%inf,-7),0);
-assert_checkequal(nthroot(%inf,7),%inf);
-assert_checkequal(nthroot(%inf,%inf),1);
-assert_checkequal(nthroot(%inf,-%inf),1);
-assert_checkequal(nthroot(-%inf,%inf),-1);
-assert_checkequal(nthroot(-%inf,-%inf),-1);
-assert_checkequal(nthroot(%inf,%inf),1);
-assert_checkequal(nthroot(%inf,%nan),%nan);
-assert_checkequal(nthroot(%inf,%eps),%inf);
-assert_checkequal(nthroot(%inf,-%eps),0);
-assert_checkequal(nthroot(%inf,0),%inf);
-assert_checkequal(nthroot([%inf;%nan],3),[%inf;%nan]);
-assert_checkequal(nthroot([%inf;%nan],%nan),[%nan;%nan]);
-assert_checkequal(nthroot([%inf;%nan],0),[%inf;%nan]);
-assert_checkequal(nthroot([%inf;%eps],%eps),[%inf;0]);
-assert_checkequal(nthroot([%inf;%eps],%nan),[%nan;%nan]);
-assert_checkequal(nthroot([%inf;1],0),[%inf;%nan]);
+assert_checkequal(nthroot(-%inf,-7),    0);
+assert_checkequal(nthroot(-%inf, 7),   -%inf);
+assert_checkequal(nthroot( %inf,-7),    0);
+assert_checkequal(nthroot( %inf, 7),    %inf);
+assert_checkequal(nthroot( %inf, %inf), 1);
+assert_checkequal(nthroot( %inf,-%inf), 1);
+assert_checkequal(nthroot(-%inf, %inf), -1);
+assert_checkequal(nthroot(-%inf,-%inf), -1);
+assert_checkequal(nthroot( %inf, %inf), 1);
+assert_checkequal(nthroot( %inf, %nan), %nan);
+assert_checkequal(nthroot( %inf, %eps), %inf);
+assert_checkequal(nthroot( %inf,-%eps), 0);
+assert_checkequal(nthroot( %inf, 0),    %inf);
+assert_checkequal(nthroot([%inf; %nan], 3),    [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %nan], %nan), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; %nan], 0),    [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %nan], [3; 3]),       [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %nan], [%nan; %nan]), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; %nan], [0; 0]),       [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %eps], %eps), [%inf; 0]);
+assert_checkequal(nthroot([%inf; %eps], %nan), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; 1],    0),    [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %eps], [%eps; %eps]), [%inf; 0]);
+assert_checkequal(nthroot([%inf; %eps], [%nan; %nan]), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; 1],    [0; 0]),       [%inf; %nan]);
 // 5. Not A Number
 // =================
-assert_checkequal(nthroot(%nan,-2),%nan);
-assert_checkequal(nthroot(%nan,%inf),%nan);
-assert_checkequal(nthroot(%nan,-%inf),%nan);
-assert_checkequal(nthroot(%nan,-%eps),%nan);
-assert_checkequal(nthroot(%nan,0),%nan);
+assert_checkequal(nthroot(%nan,-2),   %nan);
+assert_checkequal(nthroot(%nan, %inf), %nan);
+assert_checkequal(nthroot(%nan,-%inf), %nan);
+assert_checkequal(nthroot(%nan,-%eps), %nan);
+assert_checkequal(nthroot(%nan, 0),    %nan);
 // 6. X = %eps
 // ===========
-assert_checkequal(nthroot(%eps,%inf),1);
-assert_checkequal(nthroot(%eps,-%inf),1);
-assert_checkequal(nthroot(-%eps,%inf),-1);
+assert_checkequal(nthroot( %eps, %inf), 1);
+assert_checkequal(nthroot( %eps,-%inf), 1);
+assert_checkequal(nthroot(-%eps, %inf),-1);
 assert_checkequal(nthroot(-%eps,-%inf),-1);
-assert_checkequal(nthroot(%eps,%inf),1);
-assert_checkequal(nthroot(%eps,%nan),%nan);
-assert_checkequal(nthroot(%eps,%eps),0);
-assert_checkequal(nthroot(%eps,-%eps),%inf);
-assert_checkequal(nthroot(%eps,0),0);
+assert_checkequal(nthroot( %eps, %inf), 1);
+assert_checkequal(nthroot( %eps, %nan), %nan);
+assert_checkequal(nthroot( %eps, %eps), 0);
+assert_checkequal(nthroot( %eps,-%eps), %inf);
+assert_checkequal(nthroot( %eps, 0),    0);
index 7ee431b..52f90be 100644 (file)
 
 // unit tests for nthroot() function 
 // =============================================================================
+// Run with test_run('elementary_functions', 'nthroot', ['no_check_error_output'])
 
 // 1. Interface
 // ============
-assert_checkfalse(execstr("nthroot()"   ,"errcatch") == 0);
+assert_checkfalse(execstr("nthroot()",          "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(1)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(1)",         "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(%i,1)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(%i, 1)",    "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(%t,1)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(%t, 1)",    "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(3,[])","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-2, %nan)", "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-2,%nan)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-2, %eps)", "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-2,%eps)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-3, 6)",     "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-3,6)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-3, 0)",     "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-3,0)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-%inf, -2)", "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-%inf,-2)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-2, -2)",     "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-2,-2)","errcatch") == 0);
+assert_checkfalse(execstr("nthroot(-2, 2)",      "errcatch") == 0);
 lasterror(execstr("10000","errcatch") == 0)
-assert_checkfalse(execstr("nthroot(-2,2)","errcatch") == 0);
-lasterror(execstr("10000","errcatch") == 0)
-
+assert_checktrue(nthroot(3, []) == 3);
 
 // 2. Singular Values
 // ==================
-assert_checkalmostequal(nthroot(2,-2),0.7071068, 1.e-5);
-assert_checkalmostequal(nthroot(2,2),1.4142136, 1.e-5);
-assert_checkalmostequal(nthroot(%eps,3),0.0000061, 1.e-2);
-assert_checkalmostequal(nthroot([1 2],2),[1 1.4142136], 1.e-5);
-assert_checkequal(nthroot(-2,%inf),-1);
-assert_checkequal(nthroot(3,%inf),1);
-assert_checkequal(nthroot(3,-%inf),1);
-assert_checkequal(nthroot(-3,%inf),-1);
-assert_checkequal(nthroot(3,%nan),%nan);
-assert_checkequal(nthroot(3,-%nan),%nan);
-assert_checkequal(nthroot(3,%eps),%inf);
-assert_checkequal(nthroot(3,-%eps),0);
-assert_checkequal(nthroot(3,0),%inf);
-assert_checkequal(nthroot(1,0),%nan);
+assert_checkalmostequal(nthroot(2   ,-2), 0.7071068, 1.e-5);
+assert_checkalmostequal(nthroot(2   , 2), 1.4142136, 1.e-5);
+assert_checkalmostequal(nthroot(%eps, 3), 0.0000061, 1.e-2);
+assert_checkalmostequal(nthroot([1 2], 2)    , [1 1.4142136], 1.e-5);
+assert_checkalmostequal(nthroot([1 2], [2 2]), [1 1.4142136], 1.e-5);
+assert_checkequal(nthroot(-2,  %inf), -1);
+assert_checkequal(nthroot( 3 , %inf), 1);
+assert_checkequal(nthroot( 3 ,-%inf), 1);
+assert_checkequal(nthroot(-3,  %inf), -1);
+assert_checkequal(nthroot( 3 , %nan), %nan);
+assert_checkequal(nthroot( 3 ,-%nan), %nan);
+assert_checkequal(nthroot( 3 , %eps), %inf);
+assert_checkequal(nthroot( 3 ,-%eps), 0);
+assert_checkequal(nthroot( 3 , 0), %inf);
+assert_checkequal(nthroot( 1 , 0), %nan);
 
-assert_checkequal(nthroot([1 2],%inf),[1 1]);
-assert_checkequal(nthroot([1 2],%nan),[%nan %nan]);
-assert_checkequal(nthroot([1 2],%eps),[1 %inf]);
-assert_checkequal(nthroot([1 2],0),[%nan %inf]);
+assert_checkequal(nthroot([1 2], %inf), [1 1]);
+assert_checkequal(nthroot([1 2], %nan), [%nan %nan]);
+assert_checkequal(nthroot([1 2], %eps), [1 %inf]);
+assert_checkequal(nthroot([1 2], 0),    [%nan %inf]);
+assert_checkequal(nthroot([1 2], [%inf %inf]), [1 1]);
+assert_checkequal(nthroot([1 2], [%nan %nan]), [%nan %nan]);
+assert_checkequal(nthroot([1 2], [%eps %eps]), [1 %inf]);
+assert_checkequal(nthroot([1 2], [0 0]),       [%nan %inf]);
 
-assert_checkequal(nthroot(0,0),0);
-assert_checkequal(nthroot(0,7),0);
-assert_checkequal(nthroot(0,-7),%inf);
-assert_checkequal(nthroot(0,%inf),1);
-assert_checkequal(nthroot(0,-%inf),1);
-assert_checkequal(nthroot(0,%nan),%nan);
-assert_checkequal(nthroot(0,%eps),0);
-assert_checkequal(nthroot(0,-%eps),%inf);
+assert_checkequal(nthroot(0, 0),    0);
+assert_checkequal(nthroot(0, 7),    0);
+assert_checkequal(nthroot(0,-7),    %inf);
+assert_checkequal(nthroot(0, %inf), 1);
+assert_checkequal(nthroot(0,-%inf), 1);
+assert_checkequal(nthroot(0, %nan), %nan);
+assert_checkequal(nthroot(0, %eps), 0);
+assert_checkequal(nthroot(0,-%eps), %inf);
 
-assert_checkequal(nthroot([0;-1],%inf),[1;-1]);
-assert_checkequal(nthroot([0;1],0),[0;%nan]);
+assert_checkequal(nthroot([0;-1], %inf), [1; -1]);
+assert_checkequal(nthroot([0; 1], 0),    [0; %nan]);
+assert_checkequal(nthroot([0;-1], [%inf; %inf]), [1; -1]);
+assert_checkequal(nthroot([0; 1], [0; 0]),       [0; %nan]);
 
 // 3. Empty Matrix
 //==================
-assert_checkequal(nthroot([],-2),[]);
-assert_checkequal(nthroot([],3),[]);
-assert_checkequal(nthroot([],%nan),[]);
-assert_checkequal(nthroot([],%inf),[]);
-assert_checkequal(nthroot([],-%inf),[]);
-assert_checkequal(nthroot([],%eps),[]);
-assert_checkequal(nthroot([],-%eps),[]);
-assert_checkequal(nthroot([],0),[]);
+assert_checkequal(nthroot([],-2),    []);
+assert_checkequal(nthroot([], 3),    []);
+assert_checkequal(nthroot([], %nan), []);
+assert_checkequal(nthroot([], %inf), []);
+assert_checkequal(nthroot([],-%inf), []);
+assert_checkequal(nthroot([], %eps), []);
+assert_checkequal(nthroot([],-%eps), []);
+assert_checkequal(nthroot([], 0),    []);
 
 // 4. Limit Values
 // ================
-assert_checkequal(nthroot(-%inf,-7),0);
-assert_checkequal(nthroot(-%inf,7),-%inf);
-assert_checkequal(nthroot(%inf,-7),0);
-assert_checkequal(nthroot(%inf,7),%inf);
-assert_checkequal(nthroot(%inf,%inf),1);
-assert_checkequal(nthroot(%inf,-%inf),1);
-assert_checkequal(nthroot(-%inf,%inf),-1);
-assert_checkequal(nthroot(-%inf,-%inf),-1);
-assert_checkequal(nthroot(%inf,%inf),1);
-assert_checkequal(nthroot(%inf,%nan),%nan);
-assert_checkequal(nthroot(%inf,%eps),%inf);
-assert_checkequal(nthroot(%inf,-%eps),0);
-assert_checkequal(nthroot(%inf,0),%inf);
+assert_checkequal(nthroot(-%inf,-7),    0);
+assert_checkequal(nthroot(-%inf, 7),   -%inf);
+assert_checkequal(nthroot( %inf,-7),    0);
+assert_checkequal(nthroot( %inf, 7),    %inf);
+assert_checkequal(nthroot( %inf, %inf), 1);
+assert_checkequal(nthroot( %inf,-%inf), 1);
+assert_checkequal(nthroot(-%inf, %inf), -1);
+assert_checkequal(nthroot(-%inf,-%inf), -1);
+assert_checkequal(nthroot( %inf, %inf), 1);
+assert_checkequal(nthroot( %inf, %nan), %nan);
+assert_checkequal(nthroot( %inf, %eps), %inf);
+assert_checkequal(nthroot( %inf,-%eps), 0);
+assert_checkequal(nthroot( %inf, 0),    %inf);
 
-assert_checkequal(nthroot([%inf;%nan],3),[%inf;%nan]);
-assert_checkequal(nthroot([%inf;%nan],%nan),[%nan;%nan]);
-assert_checkequal(nthroot([%inf;%nan],0),[%inf;%nan]);
+assert_checkequal(nthroot([%inf; %nan], 3),    [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %nan], %nan), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; %nan], 0),    [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %nan], [3; 3]),       [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %nan], [%nan; %nan]), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; %nan], [0; 0]),       [%inf; %nan]);
 
-assert_checkequal(nthroot([%inf;%eps],%eps),[%inf;0]);
-assert_checkequal(nthroot([%inf;%eps],%nan),[%nan;%nan]);
-assert_checkequal(nthroot([%inf;1],0),[%inf;%nan]);
+assert_checkequal(nthroot([%inf; %eps], %eps), [%inf; 0]);
+assert_checkequal(nthroot([%inf; %eps], %nan), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; 1],    0),    [%inf; %nan]);
+assert_checkequal(nthroot([%inf; %eps], [%eps; %eps]), [%inf; 0]);
+assert_checkequal(nthroot([%inf; %eps], [%nan; %nan]), [%nan; %nan]);
+assert_checkequal(nthroot([%inf; 1],    [0; 0]),       [%inf; %nan]);
 
 // 5. Not A Number
 // =================
-assert_checkequal(nthroot(%nan,-2),%nan);
-assert_checkequal(nthroot(%nan,%inf),%nan);
-assert_checkequal(nthroot(%nan,-%inf),%nan);
-assert_checkequal(nthroot(%nan,-%eps),%nan);
-assert_checkequal(nthroot(%nan,0),%nan);
+assert_checkequal(nthroot(%nan,-2),   %nan);
+assert_checkequal(nthroot(%nan, %inf), %nan);
+assert_checkequal(nthroot(%nan,-%inf), %nan);
+assert_checkequal(nthroot(%nan,-%eps), %nan);
+assert_checkequal(nthroot(%nan, 0),    %nan);
 
 // 6. X = %eps
 // ===========
-assert_checkequal(nthroot(%eps,%inf),1);
-assert_checkequal(nthroot(%eps,-%inf),1);
-assert_checkequal(nthroot(-%eps,%inf),-1);
+assert_checkequal(nthroot( %eps, %inf), 1);
+assert_checkequal(nthroot( %eps,-%inf), 1);
+assert_checkequal(nthroot(-%eps, %inf),-1);
 assert_checkequal(nthroot(-%eps,-%inf),-1);
-assert_checkequal(nthroot(%eps,%inf),1);
-assert_checkequal(nthroot(%eps,%nan),%nan);
-assert_checkequal(nthroot(%eps,%eps),0);
-assert_checkequal(nthroot(%eps,-%eps),%inf);
-assert_checkequal(nthroot(%eps,0),0);
+assert_checkequal(nthroot( %eps, %inf), 1);
+assert_checkequal(nthroot( %eps, %nan), %nan);
+assert_checkequal(nthroot( %eps, %eps), 0);
+assert_checkequal(nthroot( %eps,-%eps), %inf);
+assert_checkequal(nthroot( %eps, 0),    0);