After an arpack update, eigs test has been updated. 94/15194/3
Adeline CARNIS [Wed, 10 Sep 2014 09:55:29 +0000 (11:55 +0200)]
Change-Id: Ic0e080362d8cea18df24d2fce66a9ae7b935eb4f

scilab/modules/arnoldi/tests/unit_tests/eigs.dia.ref
scilab/modules/arnoldi/tests/unit_tests/eigs.tst

index c06db79..dccdcc9 100644 (file)
@@ -5,7 +5,7 @@
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- CLI SHELL MODE -->
-// unit tests for eigs function 
+// unit tests for eigs function
 // =============================================================================
 // Interface
 // =========
@@ -145,14 +145,14 @@ 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';
+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';
+which = "LM";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,%nan)", "errcatch") == 0);
 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected"), "eigs", 5);
 assert_checkerror("eigs(A, [], 4, which ,%nan)", refMsg);
@@ -401,37 +401,37 @@ A = sparse(A);
 d1 = eigs(A, [], k);
 d0 = spec(full(A));
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 'SM');
-assert_checkalmostequal(d1, d0(1:k), 1.e-10); 
-d1 = eigs(A, [], k, 'LA');
+d1 = eigs(A, [], k, "SM");
+assert_checkalmostequal(d1, d0(1:k), 1.e-10);
+d1 = eigs(A, [], k, "LA");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 'SA');
+d1 = eigs(A, [], k, "SA");
 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
-d1 = eigs(A, [], k, 'BE');
-assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 2); 
-assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10); 
-d1 = eigs(A, speye(n,n), k, 'LM');
+d1 = eigs(A, [], k, "BE");
+assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
+d1 = eigs(A, [], k, 2);
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-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);  
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 opts.cholB = %t;
-d1 = eigs(A, speye(n,n), k, 'LM', opts); 
+d1 = eigs(A, speye(n,n), k, "LM", opts);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 opts.cholB = %t;
-d1 = eigs(A, speye(n,n), k, 2, opts); 
+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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LA');
+[d1, v1] = eigs(A, [], k, "LA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SA');
+[d1, v1] = eigs(A, [], k, "SA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'BE');
+[d1, v1] = eigs(A, [], k, "BE");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 n = 20;
 k = 5;
@@ -441,42 +441,42 @@ A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
 A = sparse(A);
 d1 = eigs(A, [], k);
 d0 = gsort(spec(full(A)));
-assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10); 
-d1 = eigs(A, [], k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
-d1 = eigs(A, [], k, 'SM');
+d1 = eigs(A, [], k, "LM");
+assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
+d1 = eigs(A, [], k, "SM");
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
-d1 = eigs(A, [], k, 'SR');
+d1 = eigs(A, [], k, "SR");
 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
-d1 = eigs(A, [], k, 'LI');
+d1 = eigs(A, [], k, "LI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
-d1 = eigs(A, [], k, 'SI');
+d1 = eigs(A, [], k, "SI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
-d1 = eigs(A, [], k, 2); 
+d1 = eigs(A, [], k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
-d1 = eigs(A, speye(n,n), k, 'LM');
+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 = %t;
-d1 = eigs(A, speye(n,n), k, 'LM', opts);
+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 = %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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 n = 20;
 k = 5;
@@ -489,32 +489,32 @@ d0 = gsort(spec(full(A)));
 r = gsort(real(d0));
 im = gsort(imag(d0));
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
-d1 = eigs(A, [], k, 'LM');
-assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
+d1 = eigs(A, [], k, "LM");
+assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 //d1 = eigs(A, [], k, 'SM');
 //assert_checkalmostequal(abs(d1), abs(d0(1:k)), 1.e-14); // error -> impossible to invert complex sparse matrix
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), real(d0(k:-1:1)), 1.e-10);
-d1 = eigs(A, [], k, 'SR');
+d1 = eigs(A, [], k, "SR");
 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
-d1 = eigs(A, [], k, 'LI');
-assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10); 
-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); 
+d1 = eigs(A, [], k, "LI");
+assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
+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 = %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');
+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");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 n = 20;
 k = 5;
@@ -524,37 +524,37 @@ A(2:$,1:$-1) = A(2:$,1:$-1) + diag(6*ones(n-1,1));
 d1 = eigs(A, [], k);
 d0 = spec(A);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 'SM');
-assert_checkalmostequal(d1, d0(1:k), 1.e-10); 
-d1 = eigs(A, [], k, 'LA');
+d1 = eigs(A, [], k, "SM");
+assert_checkalmostequal(d1, d0(1:k), 1.e-10);
+d1 = eigs(A, [], k, "LA");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 'SA');
+d1 = eigs(A, [], k, "SA");
 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
-d1 = eigs(A, [], k, 'BE');
-assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
-d1 = eigs(A, [], k, 2); 
-assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10); 
-d1 = eigs(A, eye(n,n), k, 'LM');
+d1 = eigs(A, [], k, "BE");
+assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
+d1 = eigs(A, [], k, 2);
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-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);  
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 opts.cholB = %t;
-d1 = eigs(A, eye(n,n), k, 'LM', opts); 
+d1 = eigs(A, eye(n,n), k, "LM", opts);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 opts.cholB = %t;
-d1 = eigs(A, eye(n,n), k, 2, opts); 
+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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LA');
+[d1, v1] = eigs(A, [], k, "LA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SA');
+[d1, v1] = eigs(A, [], k, "SA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'BE');
+[d1, v1] = eigs(A, [], k, "BE");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 n = 20;
 k = 5;
@@ -563,42 +563,42 @@ 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));
 d1 = eigs(A, [], k);
 d0 = gsort(spec(A));
-assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10); 
-d1 = eigs(A, [], k, 'LM');
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
-d1 = eigs(A, [], k, 'SM');
+d1 = eigs(A, [], k, "LM");
+assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
+d1 = eigs(A, [], k, "SM");
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
-d1 = eigs(A, [], k, 'SR');
+d1 = eigs(A, [], k, "SR");
 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
-d1 = eigs(A, [], k, 'LI');
+d1 = eigs(A, [], k, "LI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
-d1 = eigs(A, [], k, 'SI');
+d1 = eigs(A, [], k, "SI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
-d1 = eigs(A, [], k, 2); 
+d1 = eigs(A, [], k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
-d1 = eigs(A, eye(n,n), k, 'LM');
+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 = %t;
-d1 = eigs(A, eye(n,n), k, 'LM', opts);
+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 = %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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 n = 20;
 k = 5;
@@ -610,37 +610,37 @@ d0 = gsort(spec(A));
 r = gsort(real(d0));
 im = gsort(imag(d0));
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
-d1 = eigs(A, [], k, 'SM');
-assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "SM");
+assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), r(k:-1:1), 1.e-10);
-d1 = eigs(A, [], k, 'SR');
-assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);  
-d1 = eigs(A, [], k, 'LI');
-assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10); 
-d1 = eigs(A, [], k, 'SI');
+d1 = eigs(A, [], k, "SR");
+assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
+d1 = eigs(A, [], k, "LI");
+assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
+d1 = eigs(A, [], k, "SI");
 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
-d1 = eigs(A, [], k, 2); 
+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');
+d1 = eigs(A, eye(n,n), k, "LM");
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 opts.cholB = %t;
-d1 = eigs(A, eye(n,n), k, 'LM', opts);
-assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
+d1 = eigs(A, eye(n,n), k, "LM", opts);
+assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 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');
+assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
 clear opts
 // Tests : A is a function
@@ -656,7 +656,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %t;
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = spec(full(A));
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 clear fn
@@ -665,7 +665,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %t;
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 clear fn
 function y = fn(x)
@@ -687,7 +687,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'LM', opts );
+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);
 clear fn
@@ -696,7 +696,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 clear fn
 function y = fn(x)
@@ -718,7 +718,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %f;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = gsort(spec(full(A)));
 r = gsort(real(d0));
 im = gsort(imag(d0));
@@ -729,8 +729,8 @@ function y = fn(x)
 endfunction
 opts.isreal = %f;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'SM', opts );
-assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
+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;
@@ -752,7 +752,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %t;
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = spec(A);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 clear fn
@@ -761,7 +761,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %t;
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 clear fn
 function y = fn(x)
@@ -782,7 +782,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'LM', opts );
+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);
 clear fn
@@ -791,7 +791,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %t;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 clear fn
 function y = fn(x)
@@ -812,7 +812,7 @@ function y = fn(x)
 endfunction
 opts.isreal = %f;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = gsort(spec(A));
 r = gsort(real(d0));
 im = gsort(imag(d0));
@@ -823,8 +823,8 @@ function y = fn(x)
 endfunction
 opts.isreal = %f;
 opts.issym = %f;
-d1 = eigs(fn, n, [], k, 'SM', opts );
-assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
+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;
index 87e49ba..3c8cd40 100644 (file)
@@ -7,7 +7,7 @@
 
 // <-- CLI SHELL MODE -->
 
-// unit tests for eigs function 
+// unit tests for eigs function
 // =============================================================================
 
 // Interface
@@ -195,7 +195,7 @@ 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';
+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);
@@ -204,7 +204,7 @@ 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';
+which = "LM";
 assert_checkfalse(execstr("eigs(A, [], 4, which ,%nan)", "errcatch") == 0);
 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A structure expected"), "eigs", 5);
 assert_checkerror("eigs(A, [], 4, which ,%nan)", refMsg);
@@ -287,6 +287,8 @@ assert_checkfalse(execstr("eigs(sparse(A), [], 4, which ,opts)", "errcatch") ==
 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");
@@ -523,51 +525,51 @@ d1 = eigs(A, [], k);
 d0 = spec(full(A));
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-d1 = eigs(A, [], k, 'SM');
-assert_checkalmostequal(d1, d0(1:k), 1.e-10); 
+d1 = eigs(A, [], k, "SM");
+assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 
-d1 = eigs(A, [], k, 'LA');
+d1 = eigs(A, [], k, "LA");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-d1 = eigs(A, [], k, 'SA');
+d1 = eigs(A, [], k, "SA");
 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
 
-d1 = eigs(A, [], k, 'BE');
-assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
+d1 = eigs(A, [], k, "BE");
+assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
 
-d1 = eigs(A, [], k, 2); 
-assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10); 
+d1 = eigs(A, [], k, 2);
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 
-d1 = eigs(A, speye(n,n), k, 'LM');
+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);  
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 
 opts.cholB = %t;
-d1 = eigs(A, speye(n,n), k, 'LM', opts); 
+d1 = eigs(A, speye(n,n), k, "LM", opts);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
 opts.cholB = %t;
-d1 = eigs(A, speye(n,n), k, 2, opts); 
+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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LA');
+[d1, v1] = eigs(A, [], k, "LA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SA');
+[d1, v1] = eigs(A, [], k, "SA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'BE');
+[d1, v1] = eigs(A, [], k, "BE");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
 
@@ -581,59 +583,59 @@ A = sparse(A);
 d1 = eigs(A, [], k);
 d0 = gsort(spec(full(A)));
 
-assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10); 
+assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 
-d1 = eigs(A, [], k, 'SM');
+d1 = eigs(A, [], k, "SM");
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
 
-d1 = eigs(A, [], k, 'SR');
+d1 = eigs(A, [], k, "SR");
 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
 
-d1 = eigs(A, [], k, 'LI');
+d1 = eigs(A, [], k, "LI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
 
-d1 = eigs(A, [], k, 'SI');
+d1 = eigs(A, [], k, "SI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
 
-d1 = eigs(A, [], k, 2); 
+d1 = eigs(A, [], k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 
-d1 = eigs(A, speye(n,n), k, 'LM');
+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 = %t;
-d1 = eigs(A, speye(n,n), k, 'LM', opts);
+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 = %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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
 n = 20;
@@ -649,44 +651,44 @@ r = gsort(real(d0));
 im = gsort(imag(d0));
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LM');
-assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
+d1 = eigs(A, [], k, "LM");
+assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
 //d1 = eigs(A, [], k, 'SM');
 //assert_checkalmostequal(abs(d1), abs(d0(1:k)), 1.e-14); // error -> impossible to invert complex sparse matrix
 
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), real(d0(k:-1:1)), 1.e-10);
 
-d1 = eigs(A, [], k, 'SR');
+d1 = eigs(A, [], k, "SR");
 assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
 
-d1 = eigs(A, [], k, 'LI');
-assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10); 
+d1 = eigs(A, [], k, "LI");
+assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
 
-d1 = eigs(A, [], k, 'SI');
-assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10); 
+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); 
+d1 = eigs(A, speye(n,n), k, "LM");
+assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
 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 = 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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
 
@@ -701,51 +703,51 @@ d0 = spec(A);
 
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-d1 = eigs(A, [], k, 'SM');
-assert_checkalmostequal(d1, d0(1:k), 1.e-10); 
+d1 = eigs(A, [], k, "SM");
+assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 
-d1 = eigs(A, [], k, 'LA');
+d1 = eigs(A, [], k, "LA");
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
-d1 = eigs(A, [], k, 'SA');
+d1 = eigs(A, [], k, "SA");
 assert_checkalmostequal(d1, d0(k:-1:1), 1.e-10);
 
-d1 = eigs(A, [], k, 'BE');
-assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
+d1 = eigs(A, [], k, "BE");
+assert_checkalmostequal(d1, [d0(1:2); d0($-2:$)], 1.e-10);
 
-d1 = eigs(A, [], k, 2); 
-assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10); 
+d1 = eigs(A, [], k, 2);
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 
-d1 = eigs(A, eye(n,n), k, 'LM');
+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);  
+assert_checkalmostequal(d1, d0(3:3+k-1), 1.e-10);
 
 opts.cholB = %t;
-d1 = eigs(A, eye(n,n), k, 'LM', opts); 
+d1 = eigs(A, eye(n,n), k, "LM", opts);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
 opts.cholB = %t;
-d1 = eigs(A, eye(n,n), k, 2, opts); 
+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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LA');
+[d1, v1] = eigs(A, [], k, "LA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SA');
+[d1, v1] = eigs(A, [], k, "SA");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'BE');
+[d1, v1] = eigs(A, [], k, "BE");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
 n = 20;
@@ -757,59 +759,59 @@ A(2:$,1:$-1) = A(2:$,1:$-1) + diag(-6*ones(n-1,1));
 d1 = eigs(A, [], k);
 d0 = gsort(spec(A));
 
-assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10); 
+assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(abs(d1), abs(d0(k+2-1:-1:2)), 1.e-10);
 
-d1 = eigs(A, [], k, 'SM');
+d1 = eigs(A, [], k, "SM");
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), real(d0(k+2-1:-1:2)), 1.e-10);
 
-d1 = eigs(A, [], k, 'SR');
+d1 = eigs(A, [], k, "SR");
 assert_checkalmostequal(real(d1), gsort(real(d0([13 14 18 19 20]))), 1.e-10);
 
-d1 = eigs(A, [], k, 'LI');
+d1 = eigs(A, [], k, "LI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([3 4 2 1 18]))), 1.e-10);
 
-d1 = eigs(A, [], k, 'SI');
+d1 = eigs(A, [], k, "SI");
 assert_checkalmostequal(abs(imag(d1)), abs(imag(d0([9 10 11 12 15]))), 1.e-10);
 
-d1 = eigs(A, [], k, 2); 
+d1 = eigs(A, [], k, 2);
 assert_checkalmostequal(abs(d1), abs(d0([19 20 12 11 15])), 1.e-10);
 
-d1 = eigs(A, eye(n,n), k, 'LM');
+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 = %t;
-d1 = eigs(A, eye(n,n), k, 'LM', opts);
+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 = %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');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SM');
+[d1, v1] = eigs(A, [], k, "SM");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1,sqrt(%eps), 1.e-10);
 
 
@@ -826,51 +828,51 @@ im = gsort(imag(d0));
 
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LM');
+d1 = eigs(A, [], k, "LM");
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
-d1 = eigs(A, [], k, 'SM');
-assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
+d1 = eigs(A, [], k, "SM");
+assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
 
-d1 = eigs(A, [], k, 'LR');
+d1 = eigs(A, [], k, "LR");
 assert_checkalmostequal(real(d1), r(k:-1:1), 1.e-10);
 
-d1 = eigs(A, [], k, 'SR');
-assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);  
+d1 = eigs(A, [], k, "SR");
+assert_checkalmostequal(real(d1), r($-k+1:$), 1.e-10);
 
-d1 = eigs(A, [], k, 'LI');
-assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10); 
+d1 = eigs(A, [], k, "LI");
+assert_checkalmostequal(imag(d1), im(k:-1:1), 1.e-10);
 
-d1 = eigs(A, [], k, 'SI');
+d1 = eigs(A, [], k, "SI");
 assert_checkalmostequal(imag(d1), im($-k+1:$), 1.e-10);
 
-d1 = eigs(A, [], k, 2); 
+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');
+d1 = eigs(A, eye(n,n), k, "LM");
 assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
 opts.cholB = %t;
-d1 = eigs(A, eye(n,n), k, 'LM', opts);
-assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10); 
+d1 = eigs(A, eye(n,n), k, "LM", opts);
+assert_checkalmostequal(abs(d1), abs(d0(k:-1:1)), 1.e-10);
 
 opts.cholB = %t;
 d1 = eigs(A, eye(n,n), k, 2, opts);
-assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);  
+assert_checkalmostequal(abs(eigs(A, [], k, 2)), abs(d1), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LM');
+[d1, v1] = eigs(A, [], k, "LM");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LR');
+[d1, v1] = eigs(A, [], k, "LR");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SR');
+[d1, v1] = eigs(A, [], k, "SR");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'LI');
+[d1, v1] = eigs(A, [], k, "LI");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
 
-[d1, v1] = eigs(A, [], k, 'SI');
+[d1, v1] = eigs(A, [], k, "SI");
 assert_checkalmostequal(A*v1, v1*d1, sqrt(%eps), 1.e-10);
 
 clear opts
@@ -890,7 +892,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %t;
 
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = spec(full(A));
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
@@ -902,7 +904,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %t;
 
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 
 clear fn
@@ -931,7 +933,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'LM', opts );
+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);
 
@@ -943,7 +945,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 
 clear fn
@@ -973,7 +975,7 @@ endfunction
 opts.isreal = %f;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = gsort(spec(full(A)));
 r = gsort(real(d0));
 im = gsort(imag(d0));
@@ -987,8 +989,8 @@ endfunction
 opts.isreal = %f;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'SM', opts );
-assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
+d1 = eigs(fn, n, [], k, "SM", opts );
+assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
 
 clear fn
 function y = fn(x)
@@ -1019,7 +1021,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %t;
 
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = spec(A);
 assert_checkalmostequal(d1, d0(($-k+1):$), 1.e-10);
 
@@ -1031,7 +1033,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %t;
 
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(d1, d0(1:k), 1.e-10);
 
 clear fn
@@ -1059,7 +1061,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'LM', opts );
+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);
 
@@ -1071,7 +1073,7 @@ endfunction
 opts.isreal = %t;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'SM', opts );
+d1 = eigs(fn, n, [], k, "SM", opts );
 assert_checkalmostequal(abs(d1), abs(d0($-k:$-1)), 1.e-10);
 
 clear fn
@@ -1100,7 +1102,7 @@ endfunction
 opts.isreal = %f;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'LM', opts );
+d1 = eigs(fn, n, [], k, "LM", opts );
 d0 = gsort(spec(A));
 r = gsort(real(d0));
 im = gsort(imag(d0));
@@ -1114,8 +1116,8 @@ endfunction
 opts.isreal = %f;
 opts.issym = %f;
 
-d1 = eigs(fn, n, [], k, 'SM', opts );
-assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10); 
+d1 = eigs(fn, n, [], k, "SM", opts );
+assert_checkalmostequal(abs(d1), abs(d0($-k+1:$)), 1.e-10);
 
 clear fn
 function y = fn(x)