Bug #11533, #11652 and #11653: Fix typos in messages of eigs, update eigs help page... 25/8725/3
Adeline CARNIS [Fri, 17 Aug 2012 09:13:05 +0000 (11:13 +0200)]
test_run('arnoldi','eigs')
test_run('arnoldi','bug_11653')
Change-Id: I4c2aaba8e756903ceb12a4e0b4035b0782bf235d

scilab/CHANGES_5.4.X
scilab/modules/arnoldi/help/en_US/eigs.xml
scilab/modules/arnoldi/macros/eigs.sci
scilab/modules/arnoldi/sci_gateway/c/sci_eigs.c
scilab/modules/arnoldi/tests/nonreg_tests/bug_11653.dia.ref [new file with mode: 0644]
scilab/modules/arnoldi/tests/nonreg_tests/bug_11653.tst [new file with mode: 0644]
scilab/modules/arnoldi/tests/unit_tests/eigs.dia.ref
scilab/modules/arnoldi/tests/unit_tests/eigs.tst

index 8c81560..7c85e16 100644 (file)
@@ -57,6 +57,10 @@ Bug Fixes
 
 * Bug #11509 fixed - A progression bar was missing during Atoms operations.
 
+* Bug #11533, #11652 and #11653 fixed - typos in messages of eigs function fixed,
+                     eigs help page updated and optional booleans in eigs are boolean by
+                     default to be consistent with Scilab's own data types.
+
 * Bug #11554 fixed - After using xcosPalAdd, a message was printed on 'quit'.
 
 * Bug #11592 fixed - In the documentation, example of bessel failed.
index 8ff895c..440bd06 100644 (file)
@@ -273,7 +273,7 @@ function y = A ( x )
                             <para>
                                 <term>cholB</term>
                                 <para>
-                                    if <literal>chol(B)</literal> is passed rather than <literal>B</literal>. By default, <literal>cholB</literal> is 0.
+                                    if <literal>chol(B)</literal> is passed rather than <literal>B</literal>. By default, <literal>cholB</literal> is %f.
                                 </para>
                             </para>
                         </listitem>
@@ -281,7 +281,7 @@ function y = A ( x )
                             <para>
                                 <term>isreal</term>
                                 <para>
-                                    if <literal>Af</literal> is given, <literal>isreal</literal> can be defined. By default, <literal>isreal</literal> is 1.
+                                    if <literal>Af</literal> is given, <literal>isreal</literal> can be defined. By default, <literal>isreal</literal> is %t.
                                     This argument should not be indicated if <literal>A</literal> is a matrix.
                                 </para>
                             </para>
@@ -290,7 +290,7 @@ function y = A ( x )
                             <para>
                                 <term>issym</term>
                                 <para>
-                                    if <literal>Af</literal> is given, <literal>issym</literal> can be defined. By default, <literal>isreal</literal> is 0.
+                                    if <literal>Af</literal> is given, <literal>issym</literal> can be defined. By default, <literal>issym</literal> is %f.
                                     This argument should not be indicated if <literal>A</literal> is a matrix.
                                 </para>
                             </para>
@@ -328,7 +328,7 @@ A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(9,1));
 B = eye(10,10);
 k = 8;
 sigma = 'SM';
-opts.cholB = 1;
+opts.cholB = %t;
 
 d = eigs(A)
 [d, v] = eigs(A)
@@ -358,8 +358,8 @@ function y = fn(x)
    y = A * x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d = eigs(fn, 10, [], k, 'LM', opts)
 
@@ -388,7 +388,7 @@ d = eigs(fn, 10, [], k, 4, opts)
     B = eye(10,10);
     k = 8;
     sigma = 'SM';
-    opts.cholB = 1;
+    opts.cholB = %t;
     
     d = eigs(A)
 [d, v] = eigs(A)
@@ -417,8 +417,8 @@ function y = fn(x)
    y = A * x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d = eigs(fn, 10, [], k, 'LM', opts)
 
@@ -447,7 +447,7 @@ d = eigs(fn, 10, [], k, 4, opts)
     B = eye(10,10);
     k = 8;
     sigma = 'LM';
-    opts.cholB = 1;
+    opts.cholB = %t;
     
     d = eigs(A)
 [d, v] = eigs(A)
@@ -476,8 +476,8 @@ function y = fn(x)
    y = A * x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d = eigs(fn, 10, [], k, 'LM', opts)
 
index 10d368d..d1ae8e0 100644 (file)
@@ -28,7 +28,7 @@ function [d, v] = eigs(varargin)
             resid = rand(size(varargin(1), "r"), 1).* %i;
         end
     end
-    
+
     if(rhs > 1 & typeof(varargin(1)) ==  "function")
         if(size(varargin(2)) <> 1)
             error(msprintf(gettext("%s: Wrong type for input argument #%d: A positive integer expected if the first input argument is a function."), "eigs",2));
@@ -326,7 +326,7 @@ function [d, v] = eigs(varargin)
 
 endfunction
 
-function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, resid, info)
+function [res_d, res_v] = speigs(A, %_B, nev, which, maxiter, tol, ncv, cholB, resid, info)
     lhs = argn(1);
     rvec = 0;
     if(lhs > 1)
@@ -340,7 +340,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
 
     //check if A is a square matrix
     if(mA * nA < 2 | mA <> nA)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: a square matrix expected.\n"), "speigs", 1));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1));
     end
 
     //check if A is complex
@@ -352,48 +352,40 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     //*************************
     //Second variable B :
     //*************************
-    if((typeof(B) <> "constant") & (typeof(B) <> "sparse"))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "speigs", 2));
+    if((typeof(%_B) <> "constant") & (typeof(%_B) <> "sparse"))
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2));
     end
-    [mB, nB] = size(B);
+    [mB, nB] = size(%_B);
 
     //Check if B is a square matrix
     if(mB * nB == 1 | mB <> nB)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "speigs", 2));
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2));
     end
 
     //check if B is complex
-    Breal = isreal(B);
+    Breal = isreal(%_B);
     matB = mB * nB;
 
     //*************************
     //NEV :
     //*************************
     //verification du type de nev
-    if(typeof(nev) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: an integer expected.\n"), "speigs", 3));
-    end
-
     //check if nev is complex?
-    if(~isreal(nev))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: an integer expected.\n"), "speigs", 3));
-    end
-
-    if(size(nev, "*") <> 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: k must be 1 by 1 size.\n"), "speigs", 3));
+    if(typeof(nev) <> "constant") | (~isreal(nev)) | (size(nev,"*") <> 1)
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3));
     end
 
     if(nev <> floor(nev) | (nev<=0))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "speigs", 3));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3));
     end
 
     if(Asym & Areal & Breal)
         if(nev >= nA)
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: For real symmetric problems, k must be in the range 1 to N - 1.\n"), "speigs", 3));
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: For real symmetric problems, k must be an integer in the range 1 to N - 1.\n"), "eigs", 3));
         end
     else
         if(nev >= nA - 1)
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: For real non symmetric or complex problems, k must be in the range 1 to N - 2.\n"), "speigs", 3));
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: For real non symmetric or complex problems, k must be an integer in the range 1 to N - 2.\n"), "eigs", 3));
         end
     end
 
@@ -404,31 +396,33 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     select type(which)
     case 1 then
         if(typeof(which) <> "constant" | which == [] | isnan(which))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: a scalar expected.\n"), "speigs", 4));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4));
         end
         sigma = which;
         which = 'LM';
+
     case 10 then
         [mWHICH, nWHICH] = size(which);
         if(mWHICH * nWHICH <> 1)
-            error(msprintf(gettext("%s: Wrong dimension for input argument #%d: A string expected.\n"), "speigs", 4));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: A string expected.\n"), "eigs", 4));
         end
         if(strcmp(which,'LM') ~= 0 & strcmp(which,'SM') ~= 0  & strcmp(which,'LR') ~= 0 & strcmp(which,'SR') ~= 0 & strcmp(which,'LI') ~= 0 & strcmp(which,'SI') ~= 0 & strcmp(which,'LA') ~= 0 & strcmp(which,'SA') ~= 0 & strcmp(which,'BE') ~= 0)
             if(Areal & Breal & Asym)
-                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of %s, %s, %s, %s or %s.\n"), "speigs", 4, "LM", "SM", "LA", "SA", "BE"));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE"));
             else
-                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of %s, %s, %s, %s, %s or %s.\n"), "speigs", 4, "LM", "SM", "LR", "SR", "LI", "SI"));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LR", "SR", "LI", "SI"));
             end
         end
         if((~Areal | ~Breal | ~Asym) & (strcmp(which,'LA') == 0 | strcmp(which,'SA') == 0 | strcmp(which,'BE') == 0))
-            error(msprintf(gettext("%s: Invalid sigma value for complex or non symmetric problem.\n"), "speigs"));
+            error(msprintf(gettext("%s: Invalid sigma value for complex or non symmetric problem.\n"), "eigs"));
         end
         if(Areal & Breal & Asym & (strcmp(which,'LR') == 0 | strcmp(which,'SR') == 0 | strcmp(which,'LI') == 0 | strcmp(which,'SI') == 0))
-            error(msprintf(gettext("%s: Invalid sigma value for real symmetric problem.\n"), "speigs"));
+            error(msprintf(gettext("%s: Invalid sigma value for real symmetric problem.\n"), "eigs"));
         end
         sigma = 0;
+
     else
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "speigs", 4));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "eigs", 4));
     end
 
     if(~Areal | ~Breal)
@@ -438,53 +432,34 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     //*************************
     //MAXITER :
     //*************************
-    if(typeof(maxiter) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "speigs", 5, "opts.maxiter"));
-    end
-
-    //check if maxiter is complex?
-    if(~isreal(maxiter))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "speigs", 5, "opts.maxiter"));
-    end
-
-    if(size(maxiter, "*") <> 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument(s) #%d: %s must be a scalar.\n"), "speigs", 5, "opts.maxiter"));
+    if(typeof(maxiter) <> "constant" | ~isreal(maxiter) | size(maxiter, "*") <> 1)
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter"));
     end
 
     if((maxiter <> floor(maxiter)) | (maxiter <= 0) )
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "speigs", 5, "opts.maxiter"));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter"));
     end
 
     //*************************
     //TOL :
     //*************************
-    if(typeof(tol) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "speigs", 6, "opts.tol"));
-    end
-
-    //check if tol is complex?
-    if(~isreal(tol) | isnan(tol))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "speigs", 6, "opts.tol"));
+    if(typeof(tol) <> "constant" | ~isreal(tol) | isnan(tol))
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol"));
     end
 
     if(size(tol, "*") <> 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be 1 by 1 size.\n"), "speigs", 6, "opts.tol"));
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be 1 by 1 size.\n"), "eigs", 6, "opts.tol"));
     end
 
     //*************************
     //NCV :
     //*************************
-    if(typeof(ncv) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "speigs", 7, "opts.ncv"));
-    end
-
-    //check if ncv is complex?
-    if(~isreal(ncv))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "speigs", 7, "opts.ncv"));
+    if(typeof(ncv) <> "constant" | ~isreal(ncv))
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv"));
     end
 
     if(size(ncv, "*") > 1 | ncv <> floor(ncv) | (ncv <> [] & ncv <= 0))
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be an integer scalar.\n"), "speigs", 7, "opts.ncv"));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv"));
     end
 
     if(isempty(ncv))
@@ -496,11 +471,11 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     else
         if(ncv <= nev | ncv > nA)
             if(Asym & Areal & Breal)
-                error(msprintf(gettext("%s: Wrong type for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "speigs", 7));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7));
             elseif(~Asym & Areal & Breal)
-                error(msprintf(gettext("%s: Wrong type for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV < N.\n"), "speigs", 7));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV < N.\n"), "eigs", 7));
             else
-                error(msprintf(gettext("%s: Wrong type for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "speigs", 7));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "eigs", 7));
             end
         end
     end
@@ -508,43 +483,43 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     //*************************
     //CHOL :
     //*************************
-    if(typeof(cholB) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "speigs", 8, "opts.cholB"));
-    end
-
-    //check if chol is complex?
-    if(~isreal(cholB))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "speigs", 8, "opts.cholB"));
-    end
-
-    if(size(cholB, "*") <> 1 | cholB <> floor(cholB) | cholB > 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be between 0 and 1 .\n"), "speigs", 8, "opts.cholB"));
-    end
+    select typeof(cholB)
+    case "boolean"
+        if and(opts.cholB <> [%f %t]) then
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB","%f", "%t"));
+        end
+    case "constant"
+        //check if chol is complex?
+        if(~isreal(cholB) | size(cholB, "*") <> 1)
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"));
+        end
 
-    if(cholB <> floor(cholB) | cholB > 1)
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "speigs", 8, "opts.cholB"));
+        if(and(cholB <> [0 1]))
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB","%f", "%t"));
+        end
+    else
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"));
     end
 
     //*************************
     //RESID :
     //*************************
     if(typeof(resid) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "speigs", 9));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9));
     end
 
-    [mRESID, nRESID] = size(resid);
-    if(mRESID * nRESID ~= nA)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "speigs", 9, "opts.resid"));
+    if(size(resid, "*") ~= nA)
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid"));
     end
 
     if(Areal & Breal)
         //resid complexe ?
         if(~isreal(resid))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector %s must be real for real problems.\n"), "speigs", 9, "opts.resid"));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector %s must be real for real problems.\n"), "eigs", 9, "opts.resid"));
         end
     else
         if(isreal(resid))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector %s must be complex for complex problems.\n"), "speigs", 9, "opts.resid"));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector %s must be complex for complex problems.\n"), "eigs", 9, "opts.resid"));
         end
     end
 
@@ -569,18 +544,18 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     end
 
     if(cholB)
-        if(~and(triu(B) == B))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: B must be symmetric or hermitian, definite, semi positive.\n"), "speigs", 2));
+        if(~and(triu(%_B) == %_B))
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: B must be symmetric or hermitian, definite, semi positive.\n"), "eigs", 2));
         end
-        R = B;
+        R = %_B;
         Rprime = R';
     end
 
     if(~cholB & matB <> 0 & iparam(7) == 1)
         if(~Breal)
-            error(msprintf(gettext("%s: Impossible to use the Cholesky factorisation with complex sparse matrices.\n"), "speigs"));
+            error(msprintf(gettext("%s: Impossible to use the Cholesky factorisation with complex sparse matrices.\n"), "eigs"));
         else
-            [R,P] = spchol(B);
+            [R,P] = spchol(%_B);
         end
         Rprime = R';
     end
@@ -597,7 +572,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
             if(cholB)
                 AMSB = A - (sigma * Rprime * R);
             else
-                AMSB = A - sigma * B;
+                AMSB = A - sigma * %_B;
             end
         end
         if(~isreal(AMSB))
@@ -652,18 +627,18 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
             if(Asym)
                 [ido, resid, v, iparam, ipntr, workd, workl, info] = dsaupd(ido, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info);
                 if(info < 0)
-                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "speigs", "DSAUPD", info));
+                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DSAUPD", info));
                 end
             else
                 [ido, resid, v, iparam, ipntr, workd, workl, info] = dnaupd(ido, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info);
                 if(info < 0)
-                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "speigs", "DNAUPD", info));
+                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DNAUPD", info));
                 end
             end
         else
             [ido, resid, v, iparam, ipntr, workd, workl, rwork, info] = znaupd(ido, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, rwork, info);
             if(info < 0)
-                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "speigs", "ZNAUPD", info));
+                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "ZNAUPD", info));
             end
         end
 
@@ -683,7 +658,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
                             workd(ipntr(2):ipntr(2)+nA-1) = inv(Q) * inv(U) * inv(L) * inv(P) *workd(ipntr(1):ipntr(1)+nA-1);
                         else
                             if(~isreal(L) | ~isreal(U))
-                                error(msprintf(gettext("%s: Impossible to invert complex sparse matrix.\n"), "speigs"));
+                                error(msprintf(gettext("%s: Impossible to invert complex sparse matrix.\n"), "eigs"));
                             else
                                 workd(ipntr(2):ipntr(2)+nA-1) = Q * inv(U) * inv(L) * P * inv(R) * workd(ipntr(1):ipntr(1)+nA-1);
                             end
@@ -694,19 +669,19 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
                         if(cholB)
                             workd(ipntr(2):ipntr(2)+nA-1) = Rprime * R * workd(ipntr(1):ipntr(1)+nA-1);
                         else
-                            workd(ipntr(2):ipntr(2)+nA-1) = B * workd(ipntr(1):ipntr(1)+nA-1);
+                            workd(ipntr(2):ipntr(2)+nA-1) = %_B * workd(ipntr(1):ipntr(1)+nA-1);
                         end
                     elseif(ido == -1)
                         if(cholB)
                             workd(ipntr(2):ipntr(2)+nA-1) = Rprime * R * workd(ipntr(1):ipntr(1)+nA-1);
                         else
-                            workd(ipntr(2):ipntr(2)+nA-1) = B * workd(ipntr(1):ipntr(1)+nA-1);
+                            workd(ipntr(2):ipntr(2)+nA-1) = %_B * workd(ipntr(1):ipntr(1)+nA-1);
                         end
                         if(Areal & Breal)
                             workd(ipntr(2):ipntr(2)+nA-1) = inv(Q) * inv(U) * inv(L) * inv(P) *workd(ipntr(2):ipntr(2)+nA-1);
                         else
                             if(~isreal(L) | ~isreal(U))
-                                error(msprintf(gettext("%s: Impossible to invert complex sparse matrix.\n"), "speigs"));
+                                error(msprintf(gettext("%s: Impossible to invert complex sparse matrix.\n"), "eigs"));
                             else
                                 workd(ipntr(2):ipntr(2)+nA-1) = Q * inv(U) * inv(L) * P * inv(R) * workd(ipntr(2):ipntr(2)+nA-1);
                             end
@@ -716,7 +691,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
                             workd(ipntr(2):ipntr(2)+nA-1) = inv(Q) * inv(U) * inv(L) * inv(P) * workd(ipntr(3):ipntr(3)+nA-1);
                         else
                             if(~isreal(L) | ~isreal(U))
-                                error(msprintf(gettext("%s: Impossible to invert complex sparse matrix.\n"), "speigs"));
+                                error(msprintf(gettext("%s: Impossible to invert complex sparse matrix.\n"), "eigs"));
                             else
                                 workd(ipntr(2):ipntr(2)+nA-1) = Q * inv(U) * inv(L) * P * inv(R) * workd(ipntr(3):ipntr(3)+nA-1);
                             end
@@ -726,12 +701,12 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
             else
                 if(Areal & Breal)
                     if(Asym)
-                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "speigs", "DSAUPD"));
+                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "eigs", "DSAUPD"));
                     else
-                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "speigs", "DNAUPD"));
+                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "eigs", "DNAUPD"));
                     end
                 else
-                    error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "speigs", "ZNAUPD"));
+                    error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "eigs", "ZNAUPD"));
                 end
             end
         end
@@ -741,7 +716,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
         if(Asym)
             [d, z, resid, v, iparam, iptnr, workd, workl, info_eupd] = dseupd(rvec, howmny, _select, d, z, sigma, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info_eupd);
             if(info_eupd <> 0)
-                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "speigs", "DSEUPD", info_eupd));
+                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DSEUPD", info_eupd));
             else
                 res_d = d;
                 if(rvec)
@@ -754,7 +729,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
             sigmai = imag(sigma);
             [dr, di, z, resid, v, iparam, ipntr, workd, workl, info_eupd] = dneupd(rvec, howmny, _select, dr, di, z, sigmar, sigmai, workev, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info_eupd);
             if(info_eupd <> 0)
-                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "speigs", "DNEUPD", info_eupd));
+                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DNEUPD", info_eupd));
             else
                 res_d = complex(dr,di);
                 res_d(nev+1) = [];
@@ -774,7 +749,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
     else
         [d, z, resid, iparam, ipntr, workd, workl, rwork, info_eupd] = zneupd(rvec, howmny, _select, d, z, sigma, workev, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, rwork, info_eupd);
         if(info_eupd <> 0)
-            error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "speigs", "ZNEUPD", info_eupd));
+            error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "ZNEUPD", info_eupd));
         else
             d(nev+1) = []
             res_d = d;
@@ -787,7 +762,7 @@ function [res_d, res_v] = speigs(A, B, nev, which, maxiter, tol, ncv, cholB, res
 endfunction
 
 
-function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cholB, resid, info, a_real, a_sym)
+function [res_d, res_v] = feigs(A_fun, nA, %_B, nev, which, maxiter, tol, ncv, cholB, resid, info, a_real, a_sym)
     lhs = argn(1);
     rvec = 0;
     if(lhs > 1)
@@ -798,58 +773,50 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
     //Second variable nA :
     //**************************
     if(size(nA,'*') <> 1 | ~isreal(nA) | typeof(nA) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: n must be a positive integer.\n"), "feigs", 2));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: n must be a positive integer.\n"), "eigs", 2));
     end
 
     if(floor(nA) <> nA | nA <= 0)
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: n must be a positive integer.\n"), "feigs", 2));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: n must be a positive integer.\n"), "eigs", 2));
     end
 
     //*************************
     //Third variable B :
     //*************************
-    if((typeof(B) <> "constant") & (typeof(B) <> "sparse"))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "feigs", 3));
+    if((typeof(%_B) <> "constant") & (typeof(%_B) <> "sparse"))
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 3));
     end
-    [mB, nB] = size(B);
+    [mB, nB] = size(%_B);
 
     //Check if B is a square matrix
     if(mB * nB == 1 | mB <> nB)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "feigs", 3));
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 3));
     end
 
     //check if B is complex
-    Breal = isreal(B);
+    Breal = isreal(%_B);
     matB = mB * nB;
 
     //*************************
     //NEV :
     //*************************
-    //Check nev type
-    if(typeof(nev) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: an integer expected.\n"), "feigs", 4));
-    end
-
+    //verification du type de nev
     //check if nev is complex?
-    if(~isreal(nev))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: an integer expected.\n"), "feigs", 4));
-    end
-
-    if(size(nev,'*') <> 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: k must be 1 by 1 size.\n"), "feigs", 3));
+    if(typeof(nev) <> "constant") | (~isreal(nev)) | (size(nev,"*") <> 1)
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3));
     end
 
     if(nev <> floor(nev) | (nev<=0))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "feigs", 4));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 4));
     end
 
     if(a_sym & a_real & Breal)
         if(nev >= nA)
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: For real symmetric problems, k must be in the range 1 to N - 1.\n"), "feigs", 4));
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: For real symmetric problems, k must be in the range 1 to N - 1.\n"), "eigs", 4));
         end
     else
         if(nev >= nA - 1)
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: For real non symmetric or complex problems, k must be in the range 1 to N - 2.\n"), "feigs", 4));
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: For real non symmetric or complex problems, k must be in the range 1 to N - 2.\n"), "eigs", 4));
         end
     end
 
@@ -860,31 +827,31 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
     select type(which)
     case 1 then
         if(typeof(which) <> "constant" | which == [] | isnan(which))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: a scalar expected.\n"), "feigs", 5));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: a scalar expected.\n"), "eigs", 5));
         end
         sigma = which;
         which = 'LM';
     case 10 then
         [mWHICH, nWHICH] = size(which);
         if(mWHICH * nWHICH <> 1)
-            error(msprintf(gettext("%s: Wrong dimension for input argument(s) #%d: a string expected.\n"), "feigs", 5));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: a string expected.\n"), "eigs", 5));
         end
         if(strcmp(which,'LM') ~= 0 & strcmp(which,'SM') ~= 0  & strcmp(which,'LR') ~= 0 & strcmp(which,'SR') ~= 0 & strcmp(which,'LI') ~= 0 & strcmp(which,'SI') ~= 0 & strcmp(which,'LA') ~= 0 & strcmp(which,'SA') ~= 0 & strcmp(which,'BE') ~= 0)
             if(a_real & Breal & a_sym)
-                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of %s, %s, %s, %s or %s.\n"), "feigs", 5, "LM", "SM", "LA", "SA", "BE"));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of %s, %s, %s, %s or %s.\n"), "eigs", 5, "LM", "SM", "LA", "SA", "BE"));
             else
-                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of %s, %s, %s, %s, %s or %s.\n"), "feigs", 5, "LM", "SM", "LR", "SR", "LI", "SI"));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of %s, %s, %s, %s, %s or %s.\n"), "eigs", 5, "LM", "SM", "LR", "SR", "LI", "SI"));
             end
         end
         if((~a_real | ~Breal | ~a_sym) & (strcmp(which,'LA') == 0 | strcmp(which,'SA') == 0 | strcmp(which,'BE') == 0))
-            error(msprintf(gettext("%s: Invalid sigma value for complex or non symmetric problem.\n"), "feigs"));
+            error(msprintf(gettext("%s: Invalid sigma value for complex or non symmetric problem.\n"), "eigs"));
         end
         if(a_real & Breal & a_sym & (strcmp(which,'LR') == 0 | strcmp(which,'SR') == 0 | strcmp(which,'LI') == 0 | strcmp(which,'SI') == 0))
-            error(msprintf(gettext("%s: Invalid sigma value for real symmetric problem.\n"), "feigs"));
+            error(msprintf(gettext("%s: Invalid sigma value for real symmetric problem.\n"), "eigs"));
         end
         sigma = 0;
     else
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "feigs", 5));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "eigs", 5));
     end
 
     if(~a_real | ~Breal)
@@ -894,55 +861,35 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
     //*************************
     //MAXITER :
     //*************************
-    if(typeof(maxiter) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "feigs", 6, "opts.maxiter"));
-    end
-
-    //check if maxiter is complex?
-    if(~isreal(maxiter))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "feigs", 6, "opts.maxiter"));
-    end
-
-    if(size(maxiter,'*') <> 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be a scalar.\n"), "feigs", 6, "opts.maxiter"));
+    if(typeof(maxiter) <> "constant" | ~isreal(maxiter) | size(maxiter,'*') <> 1)
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 6, "opts.maxiter"));
     end
 
     if((maxiter <> floor(maxiter)) | (maxiter <= 0) )
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "feigs", 6, "opts.maxiter"));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 6, "opts.maxiter"));
     end
 
     //*************************
     //TOL :
     //*************************
-    if(typeof(tol) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "feigs", 7, "opts.tol"));
-    end
-
-    //check if tol is complex?
-    if(~isreal(tol) | isnan(tol))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "feigs", 7, "opts.tol"));
+    if(typeof(tol) <> "constant" | ~isreal(tol) | isnan(tol))
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 7, "opts.tol"));
     end
 
     if(size(tol,'*') <> 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be 1 by 1 size.\n"), "feigs", 7, "opts.tol"));
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be 1 by 1 size.\n"), "eigs", 7, "opts.tol"));
     end
 
     //*************************
     //NCV :
     //*************************
-    if(typeof(ncv) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "feigs", 8, "opts.ncv"));
-    end
-
-    //check if ncv is complex?
-    if(~isreal(ncv))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "feigs", 8, "opts.ncv"));
+    if(typeof(ncv) <> "constant" | ~isreal(ncv))
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 8, "opts.ncv"));
     end
 
     if(size(ncv,'*') > 1 | ncv <> floor(ncv) | (ncv <> [] & ncv <= 0))
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be an integer scalar.\n"), "feigs", 8, "opts.ncv"));
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be an integer scalar.\n"), "eigs", 8, "opts.ncv"));
     end
-       
 
     if(isempty(ncv))
         if(~a_sym & a_real & Breal)
@@ -953,55 +900,56 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
     else
         if(ncv <= nev | ncv > nA)
             if(a_sym & a_real & Breal)
-                error(msprintf(gettext("%s: Wrong type for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "feigs", 8));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 8));
             elseif(~a_sym & a_real & Breal)
-                error(msprintf(gettext("%s: Wrong type for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV < N.\n"), "feigs", 8));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV < N.\n"), "eigs", 8));
 
             else
-                error(msprintf(gettext("%s: Wrong type for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "feigs", 8));
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "eigs", 8));
             end
         end
     end
-    if(ncv == nA & rvec & ~a_sym & Areal & Breal)
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: For real non symmetric problems, %s must be less than N.\n"), "feigs", 7, "NCV"));
-    end
-
 
     //*************************
     //CHOL :
     //*************************
-    if(typeof(cholB) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "feigs", 9, "opts.cholB"));
-    end
-
-    //check if chol is complex?
-    if(~isreal(cholB))
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "feigs", 9, "opts.cholB"));
-    end
+    select typeof(cholB)
+    case "boolean"
+        if and(cholB <> [%f %t]) then
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB","%f", "%t"));
+        end
+    case "constant"
+        //check if chol is complex?
+        if(~isreal(cholB) | size(cholB, "*") <> 1)
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"));
+        end
 
-    if(size(cholB,'*') <> 1 | cholB <> floor(cholB) | cholB > 1)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: %s must be between 0 and 1 .\n"), "feigs", 9, "opts.cholB"));
+        if(and(cholB <> [0 1]))
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB","%f", "%t"));
+        end
+    else
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"));
     end
 
     //*************************
     //RESID :
     //*************************
     if(typeof(resid) <> "constant")
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "feigs", 10));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 10));
     end
 
     if(size(resid,'*') ~= nA)
-        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: Start vector opts.resid must be N by 1.\n"), "feigs", 10));
+        error(msprintf(gettext("%s: Wrong dimension for input argument #%d: Start vector opts.resid must be N by 1.\n"), "eigs", 10));
     end
 
     if(a_real & Breal)
         //resid complexe ?
         if(~isreal(resid))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector opts.resid must be real for real problems.\n"), "feigs", 10));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector opts.resid must be real for real problems.\n"), "eigs", 10));
         end
     else
         if(isreal(resid))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector opts.resid must be complex for complex problems.\n"), "feigs", 10));
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: Start vector opts.resid must be complex for complex problems.\n"), "eigs", 10));
         end
     end
 
@@ -1026,21 +974,21 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
     end
 
     if(cholB)
-        if(~and(triu(B) == B))
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: B must be symmetric or hermitian, definite, semi positive.\n"), "feigs", 2));
+        if(~and(triu(%_B) == %_B))
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: B must be symmetric or hermitian, definite, semi positive.\n"), "eigs", 2));
         end
-        R = B;
+        R = %_B;
         Rprime = R';
     end
 
     if(~cholB & matB <> 0 & iparam(7) == 1)
         if(~Breal)
-            error(msprintf(gettext("%s: Impossible to use the Cholesky factorisation with complex sparse matrices.\n"), "feigs"));
+            error(msprintf(gettext("%s: Impossible to use the Cholesky factorisation with complex sparse matrices.\n"), "eigs"));
         else
-            if(issparse(B))
-                [R,P] = spchol(B);
+            if(issparse(%_B))
+                [R,P] = spchol(%_B);
             else
-                R = chol(B);
+                R = chol(%_B);
             end
             Rprime = R';
         end
@@ -1080,24 +1028,23 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
         z = zeros(nA, nev) + 0 * %i;
         workev = zeros(2 * ncv, 1) + 0 * %i;
     end
-
     while(ido <> 99)
         if(a_real & Breal)
             if(a_sym)
                 [ido, resid, v, iparam, ipntr, workd, workl, info] = dsaupd(ido, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info_aupd);
                 if(info_aupd <0)
-                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "feigs", "DSAUPD", info_aupd));
+                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DSAUPD", info_aupd));
                 end
             else
                 [ido, resid, v, iparam, ipntr, workd, workl, info] = dnaupd(ido, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info_aupd);
                 if(info_aupd <0)
-                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "feigs", "DNAUPD", info_aupd));
+                    error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DNAUPD", info_aupd));
                 end
             end
         else
             [ido, resid, v, iparam, ipntr, workd, workl, rwork, info] = znaupd(ido, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, rwork, info_aupd);
             if(info_aupd <0)
-                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "feigs", "ZNAUPD", info_aupd));
+                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "ZNAUPD", info_aupd));
             end
         end
 
@@ -1132,13 +1079,13 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
                         if(cholB)
                             workd(ipntr(2):ipntr(2)+nA-1) = Rprime * R * workd(ipntr(1):ipntr(1)+nA-1);
                         else
-                            workd(ipntr(2):ipntr(2)+nA-1) = B * workd(ipntr(1):ipntr(1)+nA-1);
+                            workd(ipntr(2):ipntr(2)+nA-1) = %_B * workd(ipntr(1):ipntr(1)+nA-1);
                         end
                     elseif(ido == -1)
                         if(cholB)
                             workd(ipntr(2):ipntr(2)+nA-1) = Rprime * R * workd(ipntr(1):ipntr(1)+nA-1);
                         else
-                            workd(ipntr(2):ipntr(2)+nA-1) = B * workd(ipntr(1):ipntr(1)+nA-1);
+                            workd(ipntr(2):ipntr(2)+nA-1) = %_B * workd(ipntr(1):ipntr(1)+nA-1);
                         end
                         ierr = execstr('A_fun(workd(ipntr(2):ipntr(2)+nA-1))', 'errcatch');
                         if(ierr <> 0)
@@ -1156,12 +1103,12 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
             else
                 if(a_real & Breal)
                     if(a_sym)
-                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "feigs", "DSAUPD"));
+                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "eigs", "DSAUPD"));
                     else
-                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "feigs", "DNAUPD"));
+                        error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "eigs", "DNAUPD"));
                     end
                 else
-                    error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "feigs", "ZNAUPD"));
+                    error(msprintf(gettext("%s: Error with %s: unknown mode returned.\n"), "eigs", "ZNAUPD"));
                 end
             end
         end
@@ -1169,16 +1116,16 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
 
     if(ierr <> 0)
         if(ierr == 10)
-            error(msprintf(gettext("%s: Wrong type for input argument #%d: n does not match rows number of matrix A.\n"), "feigs", 2));
+            error(msprintf(gettext("%s: Wrong value for input argument #%d: n does not match rows number of matrix A.\n"), "eigs", 2));
         end
-        error(msprintf(gettext("%s: Wrong type or value for input arguments.\n"), "feigs"));
+        error(msprintf(gettext("%s: Wrong type or value for input arguments.\n"), "eigs"));
     end
 
     if(a_real & Breal)
         if(a_sym)
             [d, z, resid, v, iparam, iptnr, workd, workl, info_eupd] = dseupd(rvec, howmny, _select, d, z, sigma, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info);
             if(info <> 0)
-                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "feigs", "DSEUPD", info));
+                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DSEUPD", info));
             else
                 res_d = d;
 
@@ -1192,7 +1139,7 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
             sigmai = imag(sigma);
             [dr, di, z, resid, v, iparam, ipntr, workd, workl, info_eupd] = dneupd(rvec, howmny, _select, dr, di, z, sigmar, sigmai, workev, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, info);
             if(info <> 0)
-                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "feigs", "DNEUPD", info));
+                error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "DNEUPD", info));
             else
                 res_d = complex(dr,di);
                 res_d(nev+1) = [];
@@ -1212,7 +1159,7 @@ function [res_d, res_v] = feigs(A_fun, nA, B, nev, which, maxiter, tol, ncv, cho
     else
         [d, z, resid, iparam, ipntr, workd, workl, rwork, info_eupd] = zneupd(rvec, howmny, _select, d, z, sigma, workev, bmat, nA, which, nev, tol, resid, ncv, v, iparam, ipntr, workd, workl, rwork, info);
         if(info <> 0)
-            error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "feigs", "ZNEUPD", info));
+            error(msprintf(gettext("%s: Error with %s: info = %d.\n"), "eigs", "ZNEUPD", info));
         else
             d(nev+1) = []
             res_d = d;
index e0763dc..d70651a 100644 (file)
@@ -73,7 +73,9 @@ int sci_eigs(char *fname, unsigned long fname_len)
     double* dblNCV                     = NULL;
 
     int *piAddressVarEight     = NULL;
+    int iTypeVarEight       = 0;
     double dblCHOLB                    = 0;
+    int iCHOLB              = 0;
 
     int *piAddressVarNine      = NULL;
     int iTypeVarNine           = 0;
@@ -116,7 +118,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
     //check if A is a square matrix
     if (iRowsOne * iColsOne == 1 || iRowsOne != iColsOne)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: A square matrix expected.\n"), fname, 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
         return 0;
     }
 
@@ -166,14 +168,14 @@ int sci_eigs(char *fname, unsigned long fname_len)
     if (sciErr.iErr || iTypeVarTwo != sci_matrix)
     {
         printError(&sciErr, 0);
-        Scierror(999, _("%s: Wrong type for input argument #%d: A full or sparse matrix expected\n"), fname, 2);
+        Scierror(999, _("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
         return 0;
     }
 
     sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo);
     if (iRowsTwo * iColsTwo == 1 || iRowsTwo != iColsTwo)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), fname, 2);
+        Scierror(999, _("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
         return 0;
     }
 
@@ -228,19 +230,19 @@ int sci_eigs(char *fname, unsigned long fname_len)
     iErr = getScalarDouble(pvApiCtx, piAddressVarThree, &dblNEV);
     if (iErr)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: A scalar expected.\n"), fname, 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
         return 0;
     }
 
     if (dblNEV != floor(dblNEV) || (dblNEV <= 0))
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), fname, 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
         return 0;
     }
 
     if (!finite(dblNEV))
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d: k must be in the range 1 to N.\n"), fname, 3);
+        Scierror(999, _("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3);
         return 0;
     }
 
@@ -261,7 +263,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
     sciErr = getVarType(pvApiCtx, piAddressVarFour, &iTypeVarFour);
     if (sciErr.iErr || (iTypeVarFour != sci_matrix && iTypeVarFour != sci_strings))
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d: a scalar expected \n"), fname, 4);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
         return 0;
     }
 
@@ -278,25 +280,27 @@ int sci_eigs(char *fname, unsigned long fname_len)
         {
             if (!Acomplex && Asym)
             {
-                Scierror(999, _("%s: Wrong input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s' or '%s'.\n" ), fname, 4, "LM", "SM", "LA", "SA", "BE");
+                Scierror(999, _("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s' or '%s'.\n" ),
+                    "eigs", 4, "LM", "SM", "LA", "SA", "BE");
                 return 0;
             }
             else
             {
-                Scierror(999, _("%s: Wrong input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s', '%s' or '%s'.\n " ), fname, 4, "LM", "SM", "LR", "SR", "LI", "SI");
+                Scierror(999, _("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s', '%s' or '%s'.\n " ), 
+                    "eigs", 4, "LM", "SM", "LR", "SR", "LI", "SI");
                 return 0;
             }
         }
 
         if ((Acomplex || !Asym) && (strcmp(pstData, "LA") == 0 || strcmp(pstData, "SA") == 0 || strcmp(pstData, "BE") == 0))
         {
-            Scierror(999, _("%s: Invalid sigma value for complex or non symmetric problem.\n"), fname, 4);
+            Scierror(999, _("%s: Invalid sigma value for complex or non symmetric problem.\n"), "eigs", 4);
             return 0;
         }
 
         if (!Acomplex && Asym && (strcmp(pstData, "LR") == 0 || strcmp(pstData, "SR") == 0 || strcmp(pstData, "LI") == 0 || strcmp(pstData, "SI") == 0))
         {
-            Scierror(999, _("%s: Invalid sigma value for real symmetric problem.\n"), fname, 4);
+            Scierror(999, _("%s: Invalid sigma value for real symmetric problem.\n"), "eigs", 4);
             return 0;
         }
 
@@ -310,7 +314,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
         sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &iRowsFour, &iColsFour);
         if (iRowsFour * iColsFour != 1)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 4);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
             return 0;
         }
 
@@ -325,7 +329,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
 
         if (C2F(isanan)(&SIGMA[0].r) || C2F(isanan)(&SIGMA[0].i))
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: sigma must be a real.\n"), fname, 4);
+            Scierror(999, _("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4);
             return 0;
         }
 
@@ -347,13 +351,13 @@ int sci_eigs(char *fname, unsigned long fname_len)
     iErr = getScalarDouble(pvApiCtx, piAddressVarFive, &dblMAXITER);
     if (iErr)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: %s must be a scalar.\n"), fname, 5, "opts.maxiter");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
         return 0;
     }
 
     if ((dblMAXITER != floor(dblMAXITER)) || (dblMAXITER <= 0))
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), fname, 5, "opts.maxiter");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
         return 0;
     }
 
@@ -371,13 +375,13 @@ int sci_eigs(char *fname, unsigned long fname_len)
     iErr = getScalarDouble(pvApiCtx, piAddressVarSix, &dblTOL);
     if (iErr)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: %s must be a real scalar.\n"), fname, 6, "opts.tol");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
         return 0;
     }
 
     if (C2F(isanan)(&dblTOL))
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), fname, 6, "opts.tol");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
         return 0;
     }
 
@@ -396,14 +400,14 @@ int sci_eigs(char *fname, unsigned long fname_len)
     if (sciErr.iErr || TypeVarSeven != sci_matrix)
     {
         printError(&sciErr, 0);
-        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), fname, 7, "opts.ncv");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
         return 0;
     }
     else
     {
         if (isVarComplex(pvApiCtx, piAddressVarSeven))
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), fname, 7, "opts.ncv");
+            Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
             0;
         }
         else
@@ -411,7 +415,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
             sciErr = getVarDimension(pvApiCtx, piAddressVarSeven, &RowsSeven, &ColsSeven);
             if (RowsSeven * ColsSeven > 1)
             {
-                Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), fname, 7, "opts.ncv");
+                Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
                 return 0;
             }
 
@@ -427,7 +431,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
 
                 if (dblNCV[0] != floor(dblNCV[0]))
                 {
-                    Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), fname, 7, "opts.ncv");
+                    Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
                     return 0;
                 }
             }
@@ -445,17 +449,44 @@ int sci_eigs(char *fname, unsigned long fname_len)
         return 0;
     }
 
-    iErr = getScalarDouble(pvApiCtx, piAddressVarEight, &dblCHOLB);
-    if (iErr)
+    sciErr = getVarType(pvApiCtx, piAddressVarEight, &iTypeVarEight);
+    if (sciErr.iErr || iTypeVarEight != sci_matrix && iTypeVarEight != sci_boolean)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: %s must be an integer scalar.\n"), fname, 8, "opts.cholB");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
         return 0;
     }
 
-    if (dblCHOLB != floor(dblCHOLB) || dblCHOLB > 1)
+    if(iTypeVarEight == sci_boolean)
     {
-        Scierror(999, _("%s: Wrong type for input argument #%d: %s must be between 0 and 1.\n"), fname, 8, "opts.cholB");
-        return 0;
+        iErr = getScalarBoolean(pvApiCtx, piAddressVarEight, &iCHOLB);
+        if (iErr)
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+            return 0;
+        }
+
+        if(iCHOLB != 1 && iCHOLB != 0)
+        {
+            Scierror(999, _("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB","%f","%t");
+            return 0;
+        }
+        dblCHOLB = (double) iCHOLB;
+    }
+    
+    if(iTypeVarEight == sci_matrix)
+    {
+        iErr = getScalarDouble(pvApiCtx, piAddressVarEight, &dblCHOLB);
+        if (iErr)
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+            return 0;
+        }
+        
+        if(dblCHOLB != 1 && dblCHOLB != 0)
+        {
+            Scierror(999, _("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB","%f","%t");
+            return 0;
+        }
     }
 
     /****************************************
@@ -473,7 +504,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
     if (sciErr.iErr || iTypeVarNine != sci_matrix)
     {
         printError(&sciErr, 0);
-        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), fname, 9);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
         return 0;
     }
     else
@@ -481,7 +512,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
         sciErr = getVarDimension(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine);
         if (iRowsNine*iColsNine == 1 || iRowsNine*iColsNine != N)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: Start vector %s must be N by 1.\n"), fname, 9, "opts.resid");
+            Scierror(999, _("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
             return 0;
         }
     }
@@ -490,7 +521,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
     {
         if (isVarComplex(pvApiCtx, piAddressVarNine))
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: Start vector %s must be real for real problems.\n"), fname, 9, "opts.resid");
+            Scierror(999, _("%s: Wrong type for input argument #%d: Start vector %s must be real for real problems.\n"), "eigs", 9, "opts.resid");
             return 0;
         }
         else
@@ -499,7 +530,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
             if (sciErr.iErr)
             {
                 printError(&sciErr, 0);
-                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 9);
+                Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9);
                 return 0;
             }
         }
@@ -510,7 +541,7 @@ int sci_eigs(char *fname, unsigned long fname_len)
         if (sciErr.iErr)
         {
             printError(&sciErr, 0);
-            Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 9);
+            Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9);
             return 0;
         }
     }
@@ -522,14 +553,14 @@ int sci_eigs(char *fname, unsigned long fname_len)
     if (sciErr.iErr)
     {
         printError(&sciErr, 0);
-        Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 9);
+        Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9);
         return 0;
     }
 
     iErr = getScalarInteger32(pvApiCtx, piAddressVarTen, &iINFO);
     if (iErr)
     {
-        Scierror(999, _("%s: Wrong dimension for input argument #%d: An integer expected.\n"), fname, 1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: An integer expected.\n"), "eigs", 1);
         return 0;
     }
 
@@ -554,17 +585,17 @@ int sci_eigs(char *fname, unsigned long fname_len)
         case -1 :
             if (Asym && !Acomplex && !Bcomplex)
             {
-                Scierror(999, _("%s: Wrong dimension for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), fname, 7);
+                Scierror(999, _("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
             }
             else
             {
                 if (!Asym && !Acomplex && !Bcomplex)
                 {
-                    Scierror(999, _("%s: Wrong dimension for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV <= N.\n"), fname, 7);
+                    Scierror(999, _("%s: Wrong value for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV <= N.\n"), "eigs", 7);
                 }
                 else
                 {
-                    Scierror(999, _("%s: Wrong dimension for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), fname, 7);
+                    Scierror(999, _("%s: Wrong value for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "eigs", 7);
                 }
             }
             PutLhsVar();
@@ -573,17 +604,17 @@ int sci_eigs(char *fname, unsigned long fname_len)
         case -2 :
             if (Asym && !Acomplex && !Bcomplex)
             {
-                Scierror(999, _("%s: Wrong dimension for input argument #%d: For real symmetric problems, k must be in the range 1 to N - 1.\n"), fname, 3);
+                Scierror(999, _("%s: Wrong value for input argument #%d: For real symmetric problems, k must be an integer in the range 1 to N - 1.\n"), "eigs", 3);
             }
             else
             {
-                Scierror(999, _("%s: Wrong dimension for input argument #%d: For real non symmetric or complex problems, k must be in the range 1 to N - 2.\n"), fname, 3);
+                Scierror(999, _("%s: Wrong value for input argument #%d: For real non symmetric or complex problems, k must be an integer in the range 1 to N - 2.\n"), "eigs", 3);
             }
             PutLhsVar();
             return 0;
 
         case -3 :
-            Scierror(999, _("%s: Wrong type for input argument(s) #%d: B must be symmetric or hermitian, definite, semi positive.\n"), fname, 2);
+            Scierror(999, _("%s: Wrong type for input argument #%d: B must be symmetric or hermitian, definite, semi positive.\n"), "eigs", 2);
             PutLhsVar();
             return 0;
 
@@ -592,16 +623,16 @@ int sci_eigs(char *fname, unsigned long fname_len)
             {
                 if (Asym)
                 {
-                    Scierror(999, _("%s: Error with %s: info = %d \n"), fname, "DSAUPD", iINFO);
+                    Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DSAUPD", iINFO);
                 }
                 else
                 {
-                    Scierror(999, _("%s: Error with %s: info = %d \n"), fname, "DNAUPD", iINFO);
+                    Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DNAUPD", iINFO);
                 }
             }
             else
             {
-                Scierror(999, _("%s: Error with %s: info = %d \n"), fname, "ZNAUPD", iINFO);
+                Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "ZNAUPD", iINFO);
             }
             PutLhsVar();
             return 0;
@@ -611,16 +642,16 @@ int sci_eigs(char *fname, unsigned long fname_len)
             {
                 if (Asym)
                 {
-                    Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), fname, "DSAUPD");
+                    Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "DSAUPD");
                 }
                 else
                 {
-                    Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), fname, "DNAUPD");
+                    Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "DNAUPD");
                 }
             }
             else
             {
-                Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), fname, "ZNAUPD");
+                Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "ZNAUPD");
             }
             PutLhsVar();
             return 0;
@@ -630,16 +661,16 @@ int sci_eigs(char *fname, unsigned long fname_len)
             {
                 if (Asym)
                 {
-                    Scierror(999, _("%s: Error with %s: info = %d \n"), fname, "DSEUPD", INFO_EUPD);
+                    Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DSEUPD", INFO_EUPD);
                 }
                 else
                 {
-                    Scierror(999, _("%s: Error with %s: info = %d \n"), fname, "DNEUPD", INFO_EUPD);
+                    Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DNEUPD", INFO_EUPD);
                 }
             }
             else
             {
-                Scierror(999, _("%s: Error with %s: info = %d \n"), fname, "ZNEUPD", INFO_EUPD);
+                Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "ZNEUPD", INFO_EUPD);
             }
             PutLhsVar();
             free(mat_eigenvalue);
diff --git a/scilab/modules/arnoldi/tests/nonreg_tests/bug_11653.dia.ref b/scilab/modules/arnoldi/tests/nonreg_tests/bug_11653.dia.ref
new file mode 100644 (file)
index 0000000..df3fce1
--- /dev/null
@@ -0,0 +1,105 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// <-- Non-regression test for bug 11653 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=11653
+//
+// <-- Short Description -->
+//    Optional booleans in eigs were doubles and are now booleans.
+// =============================================================================
+// REAL SYMMETRIC PROBLEM
+n = 10;
+k = 6;
+A            = diag(5*ones(n,1));
+A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
+A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
+A(1:$-3,4:$) = A(1:$-3,4:$) + diag(2*ones(n-3,1));
+A(4:$,1:$-3) = A(4:$,1:$-3) + diag(2*ones(n-3,1));
+A1 = sparse(A);
+opts.cholB = %t;
+d1 = eigs(A1, speye(n,n), k, 'LM', opts);
+d0 = spec(A);
+assert_checkalmostequal(gsort(d1,'g','i'), [d0(1);d0($-4:$)], [], %eps);
+d1 = eigs(A, eye(n,n), k, 'LM', opts);
+assert_checkalmostequal(gsort(real(d1),'g','i'), [d0(1);d0($-4:$)], [], %eps);
+// REAL NON SYMMETRIC PROBLEM
+B            = diag(5*ones(n,1));
+B(1:$-1,2:$) = B(1:$-1,2:$) + diag(-6*ones(n-1,1));
+B(2:$,1:$-1) = B(2:$,1:$-1) + diag(6*ones(n-1,1));
+B(1:$-3,4:$) = B(1:$-3,4:$) + diag(-2*ones(n-3,1));
+B(4:$,1:$-3) = B(4:$,1:$-3) + diag(2*ones(n-3,1));
+B1 = sparse(B);
+d0 = spec(B);
+d1 = eigs(B1, speye(n,n), k, 'LM', opts);
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+d1 = eigs(B, eye(n,n), k, 'LM', opts);
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+// COMPLEX PROBLEM
+C            = diag(5*ones(n,1)+%i*ones(n,1));
+C(1:$-1,2:$) = C(1:$-1,2:$) + diag(6*ones(n-1,1));
+C(2:$,1:$-1) = C(2:$,1:$-1) + diag(6*ones(n-1,1));
+C(1:$-3,4:$) = C(1:$-3,4:$) + diag(2*ones(n-3,1));
+C(4:$,1:$-3) = C(4:$,1:$-3) + diag(2*ones(n-3,1));
+C1 = sparse(C);
+d0= spec(C);
+d1 = eigs(C1, speye(n,n), k, 'LM', opts);
+d = gsort(abs(d0));
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
+d1 = eigs(C, eye(n,n), k, 'LM', opts);
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
+// FUNCTION :
+// REAL SYMMETRIC PROBLEM
+clear opts
+function y = fn(x)
+    y = A1 * x;
+endfunction
+opts.isreal = %t;
+opts.issym = %t;
+d1 = eigs(fn, n, [], k, 'LM', opts );
+d0 = spec(A);
+assert_checkalmostequal(gsort(d1,'g','i'), [d0(1);d0($-4:$)], [], %eps);
+clear fn
+function y = fn(x)
+    y = A * x;
+endfunction
+d1 = eigs(fn, n, [], k, 'LM', opts );
+assert_checkalmostequal(gsort(real(d1),'g','i'), [d0(1);d0($-4:$)], [], %eps);
+// REAL NON SYMMETRIC PROBLEM
+clear fn
+function y = fn(x)
+    y = B1 * x;
+endfunction
+opts.isreal = %t;
+opts.issym = %f;
+d1 = eigs(fn, n, [], k, 'LM', opts );
+d0 = spec(B);
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+clear fn
+function y = fn(x)
+    y = B * x;
+endfunction
+d1 = eigs(fn, n, [], k, 'LM', opts );
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+// COMPLEX PROBLEM
+clear fn
+function y = fn(x)
+    y = C1 * x;
+endfunction
+opts.isreal = %f;
+opts.issym = %f;
+d1 = eigs(fn, n, [], k, 'LM', opts );
+d0 = spec(C);
+d = gsort(abs(d0));
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
+clear fn
+function y = fn(x)
+    y = C * x;
+endfunction
+d1 = eigs(fn, n, [], k, 'LM', opts );
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
diff --git a/scilab/modules/arnoldi/tests/nonreg_tests/bug_11653.tst b/scilab/modules/arnoldi/tests/nonreg_tests/bug_11653.tst
new file mode 100644 (file)
index 0000000..dca5c53
--- /dev/null
@@ -0,0 +1,133 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+
+// <-- Non-regression test for bug 11653 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=11653
+//
+// <-- Short Description -->
+//    Optional booleans in eigs were doubles and are now booleans.
+// =============================================================================
+
+// REAL SYMMETRIC PROBLEM
+n = 10;
+k = 6;
+A            = diag(5*ones(n,1));
+A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
+A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
+A(1:$-3,4:$) = A(1:$-3,4:$) + diag(2*ones(n-3,1));
+A(4:$,1:$-3) = A(4:$,1:$-3) + diag(2*ones(n-3,1));
+A1 = sparse(A);
+
+opts.cholB = %t;
+d1 = eigs(A1, speye(n,n), k, 'LM', opts);
+d0 = spec(A);
+assert_checkalmostequal(gsort(d1,'g','i'), [d0(1);d0($-4:$)], [], %eps);
+
+d1 = eigs(A, eye(n,n), k, 'LM', opts);
+assert_checkalmostequal(gsort(real(d1),'g','i'), [d0(1);d0($-4:$)], [], %eps);
+
+// REAL NON SYMMETRIC PROBLEM
+B            = diag(5*ones(n,1));
+B(1:$-1,2:$) = B(1:$-1,2:$) + diag(-6*ones(n-1,1));
+B(2:$,1:$-1) = B(2:$,1:$-1) + diag(6*ones(n-1,1));
+B(1:$-3,4:$) = B(1:$-3,4:$) + diag(-2*ones(n-3,1));
+B(4:$,1:$-3) = B(4:$,1:$-3) + diag(2*ones(n-3,1));
+B1 = sparse(B);
+d0 = spec(B);
+
+d1 = eigs(B1, speye(n,n), k, 'LM', opts);
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+
+d1 = eigs(B, eye(n,n), k, 'LM', opts);
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+
+
+// COMPLEX PROBLEM
+C            = diag(5*ones(n,1)+%i*ones(n,1));
+C(1:$-1,2:$) = C(1:$-1,2:$) + diag(6*ones(n-1,1));
+C(2:$,1:$-1) = C(2:$,1:$-1) + diag(6*ones(n-1,1));
+C(1:$-3,4:$) = C(1:$-3,4:$) + diag(2*ones(n-3,1));
+C(4:$,1:$-3) = C(4:$,1:$-3) + diag(2*ones(n-3,1));
+C1 = sparse(C);
+d0= spec(C);
+
+d1 = eigs(C1, speye(n,n), k, 'LM', opts);
+d = gsort(abs(d0));
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
+
+d1 = eigs(C, eye(n,n), k, 'LM', opts);
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
+
+
+// FUNCTION :
+// REAL SYMMETRIC PROBLEM
+clear opts
+function y = fn(x)
+    y = A1 * x;
+endfunction
+
+opts.isreal = %t;
+opts.issym = %t;
+
+d1 = eigs(fn, n, [], k, 'LM', opts );
+d0 = spec(A);
+assert_checkalmostequal(gsort(d1,'g','i'), [d0(1);d0($-4:$)], [], %eps);
+
+clear fn
+function y = fn(x)
+    y = A * x;
+endfunction
+
+d1 = eigs(fn, n, [], k, 'LM', opts );
+assert_checkalmostequal(gsort(real(d1),'g','i'), [d0(1);d0($-4:$)], [], %eps);
+
+// REAL NON SYMMETRIC PROBLEM
+clear fn
+function y = fn(x)
+    y = B1 * x;
+endfunction
+
+opts.isreal = %t;
+opts.issym = %f;
+
+d1 = eigs(fn, n, [], k, 'LM', opts );
+d0 = spec(B);
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+
+clear fn
+function y = fn(x)
+    y = B * x;
+endfunction
+
+d1 = eigs(fn, n, [], k, 'LM', opts );
+assert_checkalmostequal(abs(d1), gsort(abs(d0($-5:$)),'g','i'), [], %eps);
+
+// COMPLEX PROBLEM
+clear fn
+function y = fn(x)
+    y = C1 * x;
+endfunction
+
+opts.isreal = %f;
+opts.issym = %f;
+
+d1 = eigs(fn, n, [], k, 'LM', opts );
+d0 = spec(C);
+d = gsort(abs(d0));
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
+
+clear fn
+function y = fn(x)
+    y = C * x;
+endfunction
+
+d1 = eigs(fn, n, [], k, 'LM', opts );
+assert_checkalmostequal(gsort(abs(d1)), d(1:k), [], %eps);
index 072db7a..a89f146 100644 (file)
 // Interface
 // =========
 assert_checkfalse(execstr("eigs()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s : Wrong number of input arguments : %d to %d expected.\n"), "eigs", 1, 6);
+assert_checkerror("eigs()", refMsg);
 assert_checkfalse(execstr("eigs(1)","errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(1)", refMsg);
 assert_checkfalse(execstr("eigs([])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
+assert_checkerror("eigs([])", refMsg);
 assert_checkfalse(execstr("eigs(%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(%nan)", refMsg);
 assert_checkfalse(execstr("eigs(%inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(%inf)", refMsg);
 assert_checkfalse(execstr("eigs(%eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(%eps)", refMsg);
 assert_checkfalse(execstr("eigs([%f %f])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
+assert_checkerror("eigs([%f %f])", refMsg);
 assert_checkfalse(execstr("eigs(sparse([%f %f]))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
+assert_checkerror("eigs(sparse([%f %f]))", refMsg);
 assert_checkfalse(execstr("eigs([1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs([1 2])", refMsg);
 assert_checkfalse(execstr("eigs([1; 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs([1; 2])", refMsg);
 assert_checkfalse(execstr("eigs(sparse([1 2]))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(sparse([1 2]))", refMsg);
 assert_checkfalse(execstr("eigs(sparse([1; 2]))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(sparse([1; 2]))", refMsg);
 n = 20;
 A            = diag(10*ones(n,1));
 A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
 assert_checkfalse(execstr("eigs(A, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %f)", refMsg);
 assert_checkfalse(execstr("eigs(A, %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %nan)", refMsg);
 assert_checkfalse(execstr("eigs(A, %inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %inf)", refMsg);
 assert_checkfalse(execstr("eigs(A, %eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %eps)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %f)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %nan)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), %inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %inf)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), %eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %eps)", refMsg);
 assert_checkfalse(execstr("eigs(A,[1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A,[1 2])", refMsg);
 assert_checkfalse(execstr("eigs(A,[1;2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A,[1;2])", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), [1 2])", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [1;2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), [1;2])", refMsg);
 assert_checkfalse(execstr("eigs(A, [], [])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], [])", refMsg);
 assert_checkfalse(execstr("eigs(A, [], %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %f)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], 2*%i)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], 2*%i)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], -15)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], -15)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], 5.6)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], 5.6)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], [1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], [1 2])", refMsg);
 assert_checkfalse(execstr("eigs(A, [], %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %nan)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], %eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %eps)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], %inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %inf)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], %f)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 2*%i)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], 2*%i)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], -15)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], -15)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 5.6)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], 5.6)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], [1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], [1 2])", refMsg);
 assert_checkfalse(execstr("eigs(A, [], 4, [])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(A, [], 4, [])", refMsg);
 assert_checkfalse(execstr("eigs(A, [], 4, %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4);
+assert_checkerror("eigs(A, [], 4, %nan)", refMsg);
 assert_checkfalse(execstr("eigs(A, [], 4, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(A, [], 4, %f)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, [])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(sparse(A), [], 4, [])", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(sparse(A), [], 4, %nan)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "eigs", 4);
+assert_checkerror("eigs(sparse(A), [], 4, %f)", refMsg);
 which = 'ahh';
 assert_checkfalse(execstr("eigs(A, [], 4, which)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE");
+assert_checkerror("eigs(A, [], 4, which)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE");
+assert_checkerror("eigs(sparse(A), [], 4, which)", refMsg);
 which = 'LM';
 assert_checkfalse(execstr("eigs(A, [], 4, which ,%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected\n"), "eigs", 5);
+assert_checkerror("eigs(A, [], 4, which ,%nan)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected\n"), "eigs", 5);
+assert_checkerror("eigs(sparse(A), [], 4, which, %nan)", refMsg);
 opts.var = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
-assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,optsn)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 clear opts
 opts.maxiter  = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be a scalar.\n"), "eigs", 5);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be a scalar.\n"), "eigs", 5);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.maxiter  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be an integer positive value.\n"), "eigs", 5);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be an integer positive value.\n"), "eigs", 5);
+assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
 opts.maxiter  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.maxiter  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.maxiter = 5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
 opts.maxiter = -5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
 clear opts
 opts.tol  = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.tol  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.tol  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.tol  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 clear opts
 opts.ncv  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.ncv  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.ncv  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.ncv  = %eps;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.ncv  = -5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.ncv  = 5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.ncv = n + 6;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 clear opts
 opts.cholB  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
-opts.cholB  = %f;
-assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
-assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.cholB  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.cholB  = %eps;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.cholB  = -5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.cholB  = 5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.cholB = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 clear opts
 opts.resid  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.resid  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.resid  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.resid  = %eps;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.resid  = [1 2];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.resid  = [1;2];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 opts.resid = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 clear opts
-opts.issym = 0;
+opts.issym = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 clear opts
-opts.isreal = 0;
+opts.isreal = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 clear opts
 n = 20;
 k = 5;
@@ -196,10 +417,10 @@ d1 = eigs(A, speye(n,n), k, 'LM');
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 d1 = eigs(A, speye(n,n), k, 2);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);  
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 'LM', opts); 
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 2, opts); 
 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
 [d1, v1] = eigs(A, [], k, 'LM');
@@ -239,10 +460,10 @@ d1 = eigs(A, speye(n,n), k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 d1 = eigs(A, speye(n,n), k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 2, opts);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 [d1, v1] = eigs(A, [], k, 'LM');
@@ -282,7 +503,7 @@ d1 = eigs(A, [], k, 'SI');
 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10); 
 d1 = eigs(A, speye(n,n), k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
 [d1, v1] = eigs(A, [], k, 'LM');
@@ -319,10 +540,10 @@ d1 = eigs(A, eye(n,n), k, 'LM');
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 d1 = eigs(A, eye(n,n), k, 2);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);  
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 'LM', opts); 
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts); 
 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
 [d1, v1] = eigs(A, [], k, 'LM');
@@ -361,10 +582,10 @@ d1 = eigs(A, eye(n,n), k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 d1 = eigs(A, eye(n,n), k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 [d1, v1] = eigs(A, [], k, 'LM');
@@ -405,10 +626,10 @@ d1 = eigs(A, [], k, 2);
 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
 d1 = eigs(A, eye(n,n), k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts);
 assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);  
 [d1, v1] = eigs(A, [], k, 'LM');
@@ -433,8 +654,8 @@ A = sparse(A);
 function y = fn(x)
     y = A * x;
 endfunction
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = spec(full(A));
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
@@ -442,16 +663,16 @@ clear fn
 function y = fn(x)
     y = A \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 clear fn
 function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 d1 = eigs(fn, n, [], k, 2, opts);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 n = 20;
@@ -464,8 +685,8 @@ clear fn
 function y = fn(x)
     y = A * x;
 endfunction
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(full(A)));
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
@@ -473,16 +694,16 @@ clear fn
 function y = fn(x)
     y = A \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 clear fn
 function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 n = 20;
@@ -495,8 +716,8 @@ clear fn
 function y = fn(x)
     y = A * x;
 endfunction
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(full(A)));
 r = gsort(real(d0));
@@ -506,16 +727,16 @@ clear fn
 function y = fn(x)
     y = A \x;
 endfunction
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
 clear fn
 function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
 clear opts
@@ -529,8 +750,8 @@ clear fn
 function y = fn(x)
     y = A * x;
 endfunction
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = spec(A);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
@@ -538,16 +759,16 @@ clear fn
 function y = fn(x)
     y = A \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 clear fn
 function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 d1 = eigs(fn, n, [], k, 2, opts);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 n = 20;
@@ -559,8 +780,8 @@ clear fn
 function y = fn(x)
     y = A * x;
 endfunction
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(A));
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
@@ -568,16 +789,16 @@ clear fn
 function y = fn(x)
     y = A \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 clear fn
 function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 n = 20;
@@ -589,8 +810,8 @@ clear fn
 function y = fn(x)
     y = A * x;
 endfunction
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(A));
 r = gsort(real(d0));
@@ -600,15 +821,15 @@ clear fn
 function y = fn(x)
     y = A \x;
 endfunction
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
 clear fn
 function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
index 848e8a5..5a68310 100644 (file)
 // Interface
 // =========
 assert_checkfalse(execstr("eigs()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s : Wrong number of input arguments : %d to %d expected.\n"), "eigs", 1, 6);
+assert_checkerror("eigs()", refMsg);
+
 assert_checkfalse(execstr("eigs(1)","errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(1)", refMsg);
+
 assert_checkfalse(execstr("eigs([])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
+assert_checkerror("eigs([])", refMsg);
+
 assert_checkfalse(execstr("eigs(%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(%nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(%inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(%inf)", refMsg);
+
 assert_checkfalse(execstr("eigs(%eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(%eps)", refMsg);
 
 assert_checkfalse(execstr("eigs([%f %f])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
+assert_checkerror("eigs([%f %f])", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse([%f %f]))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A full or sparse square matrix or a function expected"), "eigs", 1);
+assert_checkerror("eigs(sparse([%f %f]))", refMsg);
+
 assert_checkfalse(execstr("eigs([1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs([1 2])", refMsg);
+
 assert_checkfalse(execstr("eigs([1; 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs([1; 2])", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse([1 2]))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(sparse([1 2]))", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse([1; 2]))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
+assert_checkerror("eigs(sparse([1; 2]))", refMsg);
+
 
 n = 20;
 A            = diag(10*ones(n,1));
@@ -32,160 +67,449 @@ A(1:$-1,2:$) = A(1:$-1,2:$) + diag(6*ones(n-1,1));
 A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
 
 assert_checkfalse(execstr("eigs(A, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %f)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, %inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %inf)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, %eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A, %eps)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %f)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), %inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %inf)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), %eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), %eps)", refMsg);
+
 assert_checkfalse(execstr("eigs(A,[1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A,[1 2])", refMsg);
+
 assert_checkfalse(execstr("eigs(A,[1;2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(A,[1;2])", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), [1 2])", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [1;2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
+assert_checkerror("eigs(sparse(A), [1;2])", refMsg);
+
 
 assert_checkfalse(execstr("eigs(A, [], [])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], [])", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %f)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], 2*%i)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], 2*%i)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], -15)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], -15)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], 5.6)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], 5.6)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], [1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], [1 2])", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], %eps)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %eps)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], %inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3);
+assert_checkerror("eigs(A, [], %inf)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], %f)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 2*%i)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], 2*%i)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], -15)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], -15)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 5.6)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], 5.6)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], [1 2])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
+assert_checkerror("eigs(sparse(A), [], [1 2])", refMsg);
 
 assert_checkfalse(execstr("eigs(A, [], 4, [])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(A, [], 4, [])", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], 4, %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4);
+assert_checkerror("eigs(A, [], 4, %nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(A, [], 4, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(A, [], 4, %f)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, [])", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(sparse(A), [], 4, [])", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
+assert_checkerror("eigs(sparse(A), [], 4, %nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: a real scalar or a string expected.\n"), "eigs", 4);
+assert_checkerror("eigs(sparse(A), [], 4, %f)", refMsg);
+
 which = 'ahh';
 assert_checkfalse(execstr("eigs(A, [], 4, which)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE");
+assert_checkerror("eigs(A, [], 4, which)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of ''%s'', ''%s'', ''%s'', ''%s'' or ''%s''.\n"), "eigs", 4, "LM", "SM", "LA", "SA", "BE");
+assert_checkerror("eigs(sparse(A), [], 4, which)", refMsg);
 
 which = 'LM';
 assert_checkfalse(execstr("eigs(A, [], 4, which ,%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected\n"), "eigs", 5);
+assert_checkerror("eigs(A, [], 4, which ,%nan)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected\n"), "eigs", 5);
+assert_checkerror("eigs(sparse(A), [], 4, which, %nan)", refMsg);
+
 opts.var = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
-assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,optsn)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
+assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 
 clear opts
 opts.maxiter  = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be a scalar.\n"), "eigs", 5);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be a scalar.\n"), "eigs", 5);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.maxiter  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be an integer positive value.\n"), "eigs", 5);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: opts.maxiter must be an integer positive value.\n"), "eigs", 5);
+assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
+
 opts.maxiter  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.maxiter  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.maxiter = 5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
+
 opts.maxiter = -5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
+assert_checkerror("eigs(sparse(A), [], 4, which ,opts)", refMsg);
 
 clear opts
 opts.tol  = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.tol  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.tol  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.tol  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 
 clear opts
 opts.ncv  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.ncv  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.ncv  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.ncv  = %eps;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.ncv  = -5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.ncv  = 5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.ncv = n + 6;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 
 clear opts
 opts.cholB  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
-opts.cholB  = %f;
-assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
-assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.cholB  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.cholB  = %eps;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.cholB  = -5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.cholB  = 5.1;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
+
+
 opts.cholB = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 
 clear opts
 opts.resid  = %nan;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.resid  = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.resid  = "ahh";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.resid  = %eps;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.resid  = [1 2];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.resid  = [1;2];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
+
 opts.resid = [];
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
+
 assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
+assert_checkerror("eigs(sparse(A), [], 4, which, opts)", refMsg);
 
 clear opts
-opts.issym = 0;
+opts.issym = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 
 clear opts
-opts.isreal = 0;
+opts.isreal = %f;
 assert_checkfalse(execstr("eigs(A, [], 4, which ,opts)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument: If A is a matrix, use opts with tol, maxiter, ncv, resid, cholB"), "eigs");
+assert_checkerror("eigs(A, [], 4, which, opts)", refMsg);
 
 clear opts
 n = 20;
@@ -223,11 +547,11 @@ assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 d1 = eigs(A, speye(n,n), k, 2);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);  
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 'LM', opts); 
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 2, opts); 
 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
 
@@ -286,11 +610,11 @@ assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 d1 = eigs(A, speye(n,n), k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 2, opts);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 
@@ -346,7 +670,7 @@ assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
 d1 = eigs(A, speye(n,n), k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, speye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
 
@@ -401,11 +725,11 @@ assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 d1 = eigs(A, eye(n,n), k, 2);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);  
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 'LM', opts); 
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts); 
 assert_checkalmostequal(eigs(A, [],k, 2), d0(3:3+k-1), 1.e-10);
 
@@ -462,11 +786,11 @@ assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 d1 = eigs(A, eye(n,n), k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 
@@ -526,11 +850,11 @@ assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
 d1 = eigs(A, eye(n,n), k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 'LM', opts);
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
 
-opts.cholB = 1;
+opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts);
 assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);  
 
@@ -563,8 +887,8 @@ function y = fn(x)
     y = A * x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = spec(full(A));
@@ -575,8 +899,8 @@ function y = fn(x)
     y = A \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
@@ -586,8 +910,8 @@ function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d1 = eigs(fn, n, [], k, 2, opts);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
@@ -604,8 +928,8 @@ function y = fn(x)
     y = A * x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(full(A)));
@@ -616,8 +940,8 @@ function y = fn(x)
     y = A \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
@@ -627,8 +951,8 @@ function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
@@ -646,8 +970,8 @@ function y = fn(x)
     y = A * x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(full(A)));
@@ -660,8 +984,8 @@ function y = fn(x)
     y = A \x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
@@ -671,8 +995,8 @@ function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
@@ -692,8 +1016,8 @@ function y = fn(x)
     y = A * x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = spec(A);
@@ -704,8 +1028,8 @@ function y = fn(x)
     y = A \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
@@ -715,8 +1039,8 @@ function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 1;
+opts.isreal = %t;
+opts.issym = %t;
 
 d1 = eigs(fn, n, [], k, 2, opts);
 assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
@@ -732,8 +1056,8 @@ function y = fn(x)
     y = A * x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(A));
@@ -744,8 +1068,8 @@ function y = fn(x)
     y = A \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
@@ -755,8 +1079,8 @@ function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
 
-opts.isreal = 1;
-opts.issym = 0;
+opts.isreal = %t;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
@@ -773,8 +1097,8 @@ function y = fn(x)
     y = A * x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'LM', opts );
 d0 = gsort(spec(A));
@@ -787,8 +1111,8 @@ function y = fn(x)
     y = A \x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 'SM', opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
@@ -798,11 +1122,8 @@ function y = fn(x)
     y = (A - 2 * speye(n,n)) \x;
 endfunction
 
-opts.isreal = 0;
-opts.issym = 0;
+opts.isreal = %f;
+opts.issym = %f;
 
 d1 = eigs(fn, n, [], k, 2, opts );
 assert_checkalmostequal(gsort(abs(d1)), gsort(abs(d0($-1:-1:$-k))), 1.e-10);
-
-
-