Fix tests 81/8481/2
Adeline CARNIS [Thu, 2 Aug 2012 08:16:02 +0000 (10:16 +0200)]
Change-Id: I4f7c61d429398b20ba1ac4d3afa7626f8225ab06

scilab/modules/compatibility_functions/tests/nonreg_tests/bug_7763.dia.ref
scilab/modules/compatibility_functions/tests/nonreg_tests/bug_7763.tst
scilab/modules/optimization/sci_gateway/c/sci_qp_solve.c
scilab/modules/optimization/tests/nonreg_tests/bug_3244.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_3244.tst
scilab/modules/optimization/tests/unit_tests/qpsolve.dia.ref
scilab/modules/signal_processing/tests/nonreg_tests/bug_7881.dia.ref
scilab/modules/signal_processing/tests/nonreg_tests/bug_7881.tst
scilab/modules/sparse/tests/unit_tests/qmr.dia.ref
scilab/modules/sparse/tests/unit_tests/qmr.tst

index fdca711..6479fd5 100644 (file)
@@ -17,8 +17,8 @@ assert_checkequal(r, complex(1));
 r = mtlb_min(1 + %i * 0, 0);
 assert_checkequal(r, 0);
 assert_checkfalse(execstr("[r,k] = mtlb_max(1 + %i * 0, 0)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected."), "mtlb_max", 1); 
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "mtlb_max", 1); 
 assert_checkerror("[r,k] = mtlb_max(1 + %i * 0, 0)", refMsg);
 assert_checkfalse(execstr("[r,k] = mtlb_min(1 + %i * 0, 0)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected."), "mtlb_min", 1); 
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "mtlb_min", 1); 
 assert_checkerror("[r,k] = mtlb_min(1 + %i * 0, 0)", refMsg);
index 9bf6a56..e433f63 100644 (file)
@@ -22,13 +22,15 @@ r = mtlb_min(1 + %i * 0, 0);
 assert_checkequal(r, 0);\r
 \r
 assert_checkfalse(execstr("[r,k] = mtlb_max(1 + %i * 0, 0)", "errcatch") == 0);\r
-refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected."), "mtlb_max", 1); \r
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "mtlb_max", 1); \r
 assert_checkerror("[r,k] = mtlb_max(1 + %i * 0, 0)", refMsg);\r
 \r
 assert_checkfalse(execstr("[r,k] = mtlb_min(1 + %i * 0, 0)", "errcatch") == 0);\r
-refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected."), "mtlb_min", 1); \r
+refMsg = msprintf(_("%s: Wrong number of output argument(s): %d expected.\n"), "mtlb_min", 1); \r
 assert_checkerror("[r,k] = mtlb_min(1 + %i * 0, 0)", refMsg);\r
 \r
 \r
 \r
+\r
+\r
 \r\r
index 6346e6b..00f08d7 100644 (file)
@@ -70,14 +70,14 @@ int sci_qp_solve(char *fname, unsigned long fname_len)
     issparse =  (GetType(3) == 5);
     if (!issparse)
     {
-        GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &m, &nbis, &C);
+        GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &nbis, &m, &C);
     }
     else
     {
-        GetRhsVar(3, SPARSE_MATRIX_DATATYPE, &m, &nbis, &Sp);
+        GetRhsVar(3, SPARSE_MATRIX_DATATYPE, &nbis, &m, &Sp);
     }
 
-    if ( nbis != n )
+    if ( nbis != n ) // car C est passee en transposee dans la macro qpsolve
     {
         Scierror(999, _("%s: Wrong size for input argument #%d: %d column(s) expected for matrix %s.\n"), fname, 3, n, "C");
         return 0;
index 8dc3989..98705ec 100644 (file)
 //    Bad outputs for the qpsolve/qp_solve functions
 // =============================================================================
 assert_checkfalse(execstr("qpsolve", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve", refMsg);
 assert_checkfalse(execstr("qpsolve(1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve(1)", refMsg);
 assert_checkfalse(execstr("qpsolve(1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve(1, 1)", refMsg);
 assert_checkfalse(execstr("qpsolve(1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve(1, 1, 1)", refMsg);
 assert_checkfalse(execstr("qpsolve(1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve(1, 1, 1, 1)", refMsg);
 assert_checkfalse(execstr("qpsolve(1, 1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve(1, 1, 1, 1, 1)", refMsg);
 assert_checkfalse(execstr("qpsolve(1, 1, 1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);
 assert_checkerror("qpsolve(1, 1, 1, 1, 1, 1)", refMsg);
 assert_checkfalse(execstr("qp_solve", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);
 assert_checkerror("qp_solve", refMsg);
 assert_checkfalse(execstr("qp_solve(1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);
 assert_checkerror("qp_solve(1)", refMsg);
 assert_checkfalse(execstr("qp_solve(1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);
 assert_checkerror("qp_solve(1, 1)", refMsg);
 assert_checkfalse(execstr("qp_solve(1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);
 assert_checkerror("qp_solve(1, 1, 1)", refMsg);
 assert_checkfalse(execstr("qp_solve(1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);
 assert_checkerror("qp_solve(1, 1, 1, 1)", refMsg);
 assert_checkfalse(execstr("qp_solve(1, 1, [], 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong size for input argument #%d: %d column(s) expected for matrix C."), "qp_solve", 3, 1); 
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: %d column(s) expected for matrix %s.\n"), "qp_solve", 3, 1, "C");
 assert_checkerror("qp_solve(1, 1, [], 1, 1)", refMsg);
 assert_checkfalse(execstr("qp_solve(1, 2, 3, 4, 5)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong value for input argument #%d: me must be an integer in the range 0 to %d."), "qp_solve", 5, 1); 
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: me must be an integer in the range 0 to %d.\n"), "qp_solve", 5, 1);
 assert_checkerror("qp_solve(1, 2, 3, 4, 5)", refMsg);
index 2c5ac5f..6fa2a73 100644 (file)
@@ -1,76 +1,75 @@
-// =============================================================================
-// 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 3244 -->
-//
-// <-- Bugzilla URL -->
-// http://bugzilla.scilab.org/show_bug.cgi?id=3244
-//
-// <-- Short Description -->
-//    Bad outputs for the qpsolve/qp_solve functions
-// =============================================================================
-
-assert_checkfalse(execstr("qpsolve", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve", refMsg);
-
-assert_checkfalse(execstr("qpsolve(1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve(1)", refMsg);
-
-assert_checkfalse(execstr("qpsolve(1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve(1, 1)", refMsg);
-
-assert_checkfalse(execstr("qpsolve(1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve(1, 1, 1)", refMsg);
-
-assert_checkfalse(execstr("qpsolve(1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve(1, 1, 1, 1)", refMsg);
-
-assert_checkfalse(execstr("qpsolve(1, 1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve(1, 1, 1, 1, 1)", refMsg);
-
-assert_checkfalse(execstr("qpsolve(1, 1, 1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qsolve", 7); 
-assert_checkerror("qpsolve(1, 1, 1, 1, 1, 1)", refMsg);
-
-
-assert_checkfalse(execstr("qp_solve", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
-assert_checkerror("qp_solve", refMsg);
-
-assert_checkfalse(execstr("qp_solve(1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
-assert_checkerror("qp_solve(1)", refMsg);
-
-assert_checkfalse(execstr("qp_solve(1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
-assert_checkerror("qp_solve(1, 1)", refMsg);
-
-assert_checkfalse(execstr("qp_solve(1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
-assert_checkerror("qp_solve(1, 1, 1)", refMsg);
-
-assert_checkfalse(execstr("qp_solve(1, 1, 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected."), "qp_solve", 5); 
-assert_checkerror("qp_solve(1, 1, 1, 1)", refMsg);
-
-assert_checkfalse(execstr("qp_solve(1, 1, [], 1, 1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong size for input argument #%d: %d column(s) expected for matrix C."), "qp_solve", 3, 1); 
-assert_checkerror("qp_solve(1, 1, [], 1, 1)", refMsg);
-
-assert_checkfalse(execstr("qp_solve(1, 2, 3, 4, 5)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong value for input argument #%d: me must be an integer in the range 0 to %d."), "qp_solve", 5, 1); 
-assert_checkerror("qp_solve(1, 2, 3, 4, 5)", refMsg);
-
-
+// =============================================================================\r
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS\r
+//\r
+//  This file is distributed under the same license as the Scilab package.\r
+// =============================================================================\r
+\r
+// <-- CLI SHELL MODE -->\r
+\r
+// <-- Non-regression test for bug 3244 -->\r
+//\r
+// <-- Bugzilla URL -->\r
+// http://bugzilla.scilab.org/show_bug.cgi?id=3244\r
+//\r
+// <-- Short Description -->\r
+//    Bad outputs for the qpsolve/qp_solve functions\r
+// =============================================================================\r
+\r
+assert_checkfalse(execstr("qpsolve", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve", refMsg);\r
+\r
+assert_checkfalse(execstr("qpsolve(1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve(1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qpsolve(1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve(1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qpsolve(1, 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve(1, 1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qpsolve(1, 1, 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve(1, 1, 1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qpsolve(1, 1, 1, 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve(1, 1, 1, 1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qpsolve(1, 1, 1, 1, 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qsolve", 7);\r
+assert_checkerror("qpsolve(1, 1, 1, 1, 1, 1)", refMsg);\r
+\r
+\r
+assert_checkfalse(execstr("qp_solve", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);\r
+assert_checkerror("qp_solve", refMsg);\r
+\r
+assert_checkfalse(execstr("qp_solve(1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);\r
+assert_checkerror("qp_solve(1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qp_solve(1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);\r
+assert_checkerror("qp_solve(1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qp_solve(1, 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);\r
+assert_checkerror("qp_solve(1, 1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qp_solve(1, 1, 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "qp_solve", 5);\r
+assert_checkerror("qp_solve(1, 1, 1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qp_solve(1, 1, [], 1, 1)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: %d column(s) expected for matrix %s.\n"), "qp_solve", 3, 1, "C");\r
+assert_checkerror("qp_solve(1, 1, [], 1, 1)", refMsg);\r
+\r
+assert_checkfalse(execstr("qp_solve(1, 2, 3, 4, 5)", "errcatch") == 0);\r
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: me must be an integer in the range 0 to %d.\n"), "qp_solve", 5, 1);\r
+assert_checkerror("qp_solve(1, 2, 3, 4, 5)", refMsg);\r
+\r
index 3883a3e..c7a95b7 100644 (file)
@@ -4,6 +4,7 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
+// <-- CLI SHELL MODE -->
 //Find x in R^6 such that:
 //C1*x = b1 (3 equality constraints i.e me=3)
 C1= [1,-1,1,0,3,1;
@@ -41,7 +42,7 @@ x1=qpsolve(Q,p,C,b,[],[],me);
 if or(x1-[8;3]/11 >100*%eps) then bugmes();quit;end
 if abs(x1'*p+x1'*Q*x1/2-1/22)>100*%eps then bugmes();quit;end
 if abs(C*x1-b)>100*%eps then bugmes();quit;end
-//sparse
+//sparse 
 x1=qpsolve(Q,p,sparse(C),b,[],[],me);
 if or(x1-[8;3]/11 >100*%eps) then bugmes();quit;end
 if abs(x1'*p+x1'*Q*x1/2-1/22)>100*%eps then bugmes();quit;end
index c72dabd..6e0be7e 100644 (file)
@@ -15,9 +15,9 @@
 // =============================================================================
 c = rand(1:50);
 assert_checkfalse(execstr("lattn(10,[1 2], c)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar expected."), "lattn", 2); 
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"), "lattn", 2); 
 assert_checkerror("lattn(10,[1 2], c)", refMsg);
 c1 = rand(10,3);
 assert_checkfalse(execstr("lattn(2, 1, c1)", "errcatch") == 0);
-refMsg = msprintf(_("%s: Wrong values for input arguments #%d and #%d."), "lattn", 1,2); 
+refMsg = msprintf(_("%s: Wrong values for input arguments #%d and #%d.\n"), "lattn", 1,2); 
 assert_checkerror("lattn(2, 1, c1)", refMsg);
index 447d39f..d2ba33c 100644 (file)
 \r
 c = rand(1:50);\r
 assert_checkfalse(execstr("lattn(10,[1 2], c)", "errcatch") == 0);\r
-refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar expected."), "lattn", 2); \r
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"), "lattn", 2); \r
 assert_checkerror("lattn(10,[1 2], c)", refMsg);\r
 \r
 c1 = rand(10,3);\r
 assert_checkfalse(execstr("lattn(2, 1, c1)", "errcatch") == 0);\r
-refMsg = msprintf(_("%s: Wrong values for input arguments #%d and #%d."), "lattn", 1,2); \r
+refMsg = msprintf(_("%s: Wrong values for input arguments #%d and #%d.\n"), "lattn", 1,2); \r
 assert_checkerror("lattn(2, 1, c1)", refMsg);\r
 \r
-\r\r\r
+\r
+\r
+\r
+\r\r
index e91c160..21b0f0b 100644 (file)
@@ -117,10 +117,7 @@ function y = func_A(x)
     y = Amat*x;
 endfunction
 assert_checkfalse(execstr("qmr(func_A)","errcatch") == 0);
-lasterror(execstr("10000","errcatch") == 0)
- ans  =
- qmr: Wrong number of input arguments: At least 2 expected.   
+lasterror(execstr("10000","errcatch") == 0);
 // 2. Test with 2 input arguments and all output arguments
 // =======================================================
 function y = func_qmr(x,t)
index 5bab514..fc2a392 100644 (file)
-// =============================================================================
-// 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 -->
-
-// unit tests for qmr() function 
-// =============================================================================
-warning('off')
-
-// ----------------
-// If A is a matrix
-// ----------------
-
-// 1. Interface
-// ============
-assert_checkerror( "qmr()", "%s: Wrong number of input arguments: At least %d expected.\n", 10000, "qmr", 2);
-assert_checkerror( "qmr(1)", "%s: Wrong number of input arguments: At least %d expected.\n", 10000, "qmr", 2);
-assert_checkerror( "qmr([1 2;3 4])", "%s: Wrong number of input arguments: At least %d expected.\n", 10000, "qmr", 2);
-assert_checkerror( "qmr([1 2;3 4;5 6],[1;1;1])", "%s: Wrong size for input argument #%d: Square matrix expected.\n", 10000, "qmr", 1);
-assert_checkerror( "qmr([1 2;3 4;5 6],[1 1 1])", "%s: Wrong size for input argument #%d: Square matrix expected.\n", 10000, "qmr", 1);
-assert_checkerror( "qmr([1 2;3 4],[1 1])", "%s: Wrong size for input argument #%d: Column vector expected.\n", 10000, "qmr", 2);
-assert_checkerror( "qmr([%t %t;%t %t],[1;1])", "%s: Wrong type for input argument #%d : A real or complex matrix or a sparse matrix or a function expected.\n", 10000, "qmr", 1);
-assert_checkerror( "qmr([],[])", "%s: Wrong size for input argument #%d: Column vector expected.\n", 10000, "qmr", 2);
-
-// 2. Test with 2 input arguments and all output arguments
-// =======================================================
-A=[10,1;1,10];
-b=[11;11];
-[xcomputed, flag, err, iter, res]=qmr(A,b);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-assert_checkequal ( flag , 0);
-assert_checkequal ( err , 0);
-assert_checkequal ( iter, 1);
-
-// 3. Test with 3 input arguments and all output arguments
-// ======================================================
-A=[10,1;1,10];
-b=[11;11];
-x0=[1;1];
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 4. Test with 4 input arguments and all output arguments
-// ======================================================
-A=[10,1;1,10];
-b=[11;11];
-x0=[1;1];
-M1=[1,0;0,1];
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed,xexpected,%eps);
-
-// 5.Test with 5 input arguments and all output arguments
-// ======================================================
-A=[10,1;1,10];
-b=[11;11];
-x0=[1;1];
-M1=[1,0;0,1];
-M2=[1,0;0,1];
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,M2);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 6.Test with 6 input arguments and all output arguments
-// ======================================================
-A=[10,1;1,10];
-b=[11;11];
-x0 = [1;1];
-M1=[1,0;0,1];
-M2=[1,0;0,1];
-maxit = 10;
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,M2,maxit);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 7.Test with 7 input arguments and all output arguments
-// =======================================================
-A=[10,1;1,10];
-b=[11;11];
-tol = 100*%eps;
-maxit = 10;
-M1=[1,0;0,1];
-M2=[1,0;0,1];
-x0=[1;1];
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,M2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 8. Test with non-positionnal input parameters so that good initialization generates 0 iterations
-// =================================================================================================
-A=[100,1;1,10.];
-b=[101;11];
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0=[1.;1.]);
-assert_checkequal ( iter , 1 );
-
-// 9. Test the special case where b=0
-// ====================================
-A=[100,1;1,10.];
-b=[0;0];
-[xcomputed, flag, err, iter, res]=qmr(A,b);
-xexpected=[0;0];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-assert_checkequal ( flag , 0 );
-assert_checktrue ( err <= %eps );
-assert_checkequal ( iter , 1 );
-
-// 10. A is a sparse matrix
-// =========================
-A = sparse([10 1;1 10]);
-b = ones(2,1);
-[xcomputed, flag, err, iter, res]=qmr(A,b);
-xexpected=[0.0909091;0.0909091];
-assert_checkalmostequal ( xcomputed , xexpected , 1e-1);
-assert_checkequal ( flag , 0);
-assert_checkalmostequal ( err , 1.110d-16, 1e-1);
-assert_checkequal ( iter, 1);
-
-// --------------------
-// If A is a function 
-// -------------------
-
-// 1. Interface
-// =============
-function y = func_A(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-assert_checkfalse(execstr("qmr(func_A)","errcatch") == 0);
-lasterror(execstr("10000","errcatch") == 0)
-
-// 2. Test with 2 input arguments and all output arguments
-// =======================================================
-function y = func_qmr(x,t)
-    Amat = [10,1;1,10];
-    if (t == 'notransp') then
-        y = Amat*x;
-    elseif (t == 'transp') then
-        y = Amat'*x;
-    end
-endfunction
-b = [11;11];
-[xcomputed, flag, err, iter, res]=qmr(func_qmr,b);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-assert_checkequal ( flag , 0);
-assert_checkequal ( err , 0);
-assert_checkequal ( iter, 1);
-
-function y = funcA_notransp(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-
-function y = funcA_transp(x)
-    Amat = [10,1;1,10];
-    y = Amat'*x;
-endfunction
-b = [11;11];
-[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-assert_checkequal ( flag , 0);
-assert_checkequal ( err , 0);
-assert_checkequal ( iter, 1);
-
-// 3. Test with 3 input arguments and all output arguments
-// =======================================================
-function y = func_qmr(x,t)
-    Amat = [10,1;1,10];
-    if (t == 'notransp') then
-        y = Amat*x;
-    elseif (t == 'transp') then
-        y = Amat'*x;
-    end
-endfunction
-
-b = [11;11];
-x0=[1;1];
-[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = funcA_notransp(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-
-function y = funcA_transp(x)
-    Amat = [10,1;1,10];
-    y = Amat'*x;
-endfunction
-b = [11;11];
-x0=[1;1];
-[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 4. Test with 4 input arguments and all output arguments
-// =======================================================
-function y = func_qmr(x,t)
-    Amat = [10,1;1,10];
-    if (t == 'notransp') then
-        y = Amat*x;
-    elseif (t == 'transp') then
-        y = Amat'*x;
-    end
-endfunction
-b = [11;11];
-x0 = [1;1];
-M1=[1,0;0,1];
-[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = funcA_notransp(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-
-function y = funcA_transp(x)
-    Amat = [10,1;1,10];
-    y = Amat'*x;
-endfunction
-b = [11;11];
-x0 = [1;1];
-M1=[1,0;0,1];
-[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 5 Test with 5 input arguments and all output arguments
-// =======================================================
-function y = func_qmr(x,t)
-    Amat = [10,1;1,10];
-    if (t == 'notransp') then
-        y = Amat*x;
-    elseif (t == 'transp') then
-        y = Amat'*x;
-    end
-endfunction
-b = [11;11];
-x0 = [1;1];
-M1=[1,0;0,1];
-M2=[1,0;0,1];
-[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1,M2);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = funcA_notransp(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-
-function y = funcA_transp(x)
-    Amat = [10,1;1,10];
-    y = Amat'*x;
-endfunction
-b = [11;11];
-x0 = [1;1];
-M1=[1,0;0,1];
-M2 = [1 0; 0 1];
-[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1,M2);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 6 Test with 6 input arguments and all output arguments
-// =======================================================
-function y = func_qmr(x,t)
-    Amat = [10,1;1,10];
-    if (t == 'notransp') then
-        y = Amat*x;
-    elseif (t == 'transp') then
-        y = Amat'*x;
-    end
-endfunction
-b = [11;11];
-x0 = [1;1];
-M1=[1,0;0,1];
-M2 = eye(2,2);
-maxit = 10
-[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1,M2,maxit);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = funcA_notransp(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-
-function y = funcA_transp(x)
-    Amat = [10,1;1,10];
-    y = Amat'*x;
-endfunction
-b = [11;11];
-x0 = [1;1];
-maxit = 10;
-M1 = eye(2,2);
-M2 = eye(2,2);
-[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1,M2,maxit);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// 7 Test with 7 input arguments and all output arguments
-// =======================================================
-function y = func_qmr(x,t)
-    Amat = [10,1;1,10];
-    if (t == 'notransp') then
-        y = Amat*x;
-    elseif (t == 'transp') then
-        y = Amat'*x;
-    end
-endfunction
-b = [11;11];
-tol = 100*%eps;
-maxit = 10;
-M1=[1,0;0,1];
-M2 = eye(2,2);
-x0=[1;1];
-[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1,M2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = funcA_notransp(x)
-    Amat = [10,1;1,10];
-    y = Amat*x;
-endfunction
-
-function y = funcA_transp(x)
-    Amat = [10,1;1,10];
-    y = Amat'*x;
-endfunction
-b = [11;11];
-tol = 100*%eps;
-maxit = 10;
-M1 = eye(2,2);
-M2 = eye(2,2);
-x0 = [1;1];
-[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1,M2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-
-// Test : A is a matrix, M1 is a function, M2 is a matrix (default)
-// ===============================================================
-A = [10 1;1 10];
-b = [11;11];
-x0 = [1;1];
-
-function y = funM1(x,t)
-    M1 = eye(2,2);
-    if (t=="notransp") then
-        y = M1*x;
-    elseif (t=="transp") then
-        y = M1'*x;
-    end
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,funM1);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = functionM1(x)
-    M1 = eye(2,2);
-    y = M1*x;
-endfunction
-
-function y = functionM1t(x)
-    M1 = eye(2,2);
-    y = M1'*x;
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,functionM1,functionM1t);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// Test : A is a matrix, M1 is a function, M2 is a matrix 
-// ======================================================
-A = [10 1;1 10];
-b = [11;11];
-x0 = [1;1];
-M2 = eye(2,2);
-maxit = 10;
-tol = 100*%eps;
-
-function y = funM1(x,t)
-    M1 = eye(2,2);
-    if (t=="notransp") then
-        y = M1*x;
-    elseif (t=="transp") then
-        y = M1'*x;
-    end
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,funM1,M2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = functionM1(x)
-    M1 = eye(2,2);
-    y = M1*x;
-endfunction
-
-function y = functionM1t(x)
-    M1 = eye(2,2);
-    y = M1'*x;
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,functionM1,functionM1t,M2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// Test : A is a matrix, M1 is a matrix, M2 is a function
-// ======================================================
-A = [10 1;1 10];
-b = [11;11];
-x0 = [1;1];
-M1 = eye(2,2);
-maxit = 10;
-tol = 100*%eps;
-
-function y = funM2(x,t)
-    M2 = eye(2,2);
-    if (t=="notransp") then
-        y = M2*x;
-    elseif (t=="transp") then
-        y = M2'*x;
-    end
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,funM2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = functionM2(x)
-    M2 = eye(2,2);
-    y = M2*x;
-endfunction
-
-function y = functionM2t(x)
-    M2 = eye(2,2);
-    y = M2'*x;
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,functionM2,functionM2t,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// Test : A is a matrix, M1 and M2 are functions
-// ==============================================
-A = [10 1;1 10];
-b = [11;11];
-x0 = [1;1];
-maxit = 10;
-tol = 100*%eps;
-
-function y = funM1(x,t)
-    M1 = eye(2,2);
-    if (t=="notransp") then
-        y = M1*x;
-    elseif (t=="transp") then
-        y = M1'*x;
-    end
-endfunction
-
-function y = funM2(x,t)
-    M2 = eye(2,2);
-    if (t=="notransp") then
-        y = M2*x;
-    elseif (t=="transp") then
-        y = M2'*x;
-    end
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,funM1,funM2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = functionM1(x)
-    M1 = eye(2,2);
-    y = M1*x;
-endfunction
-
-function y = functionM1t(x)
-    M1 = eye(2,2);
-    y = M1'*x;
-endfunction
-
-function y = functionM2(x)
-    M2 = eye(2,2);
-    y = M2*x;
-endfunction
-
-function y = functionM2t(x)
-    M2 = eye(2,2);
-    y = M2'*x;
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(A,b,x0,functionM1,functionM1t,functionM2,functionM2t,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-// Test : A, M1 and M2 are functions
-// ==================================
-b = [11;11];
-x0 = [1;1];
-maxit = 10;
-tol = 100*%eps;
-
-function y = funA(x,t)
-    A = [10 1;1 10];
-    if (t=="notransp") then
-        y = A*x;
-    elseif (t=="transp") then
-        y = A'*x;
-    end
-endfunction
-
-function y = funM1(x,t)
-    M1 = eye(2,2);
-    if (t=="notransp") then
-        y = M1*x;
-    elseif (t=="transp") then
-        y = M1'*x;
-    end
-endfunction
-
-function y = funM2(x,t)
-    M2 = eye(2,2);
-    if (t=="notransp") then
-        y = M2*x;
-    elseif (t=="transp") then
-        y = M2'*x;
-    end
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,funM1,funM2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-function y = functionA(x)
-    A = [10 1;1 10];
-    y = A*x;
-endfunction
-
-function y = functionAt(x)
-    A = [10 1;1 10];
-    y = A1*x;
-endfunction
-
-function y = functionM1(x)
-    M1 = eye(2,2);
-    y = M1*x;
-endfunction
-
-function y = functionM1t(x)
-    M1 = eye(2,2);
-    y = M1'*x;
-endfunction
-
-function y = functionM2(x)
-    M2 = eye(2,2);
-    y = M2*x;
-endfunction
-
-function y = functionM2t(x)
-    M2 = eye(2,2);
-    y = M2'*x;
-endfunction
-
-[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,functionM1,functionM1t,functionM2,functionM2t,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,functionM1,functionM1t,functionM2,functionM2t,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,funM1,functionM2,functionM2t,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,funM1,functionM2,functionM2t,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,funM1,funM2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,functionM1,functionM1t,funM2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,functionM1,functionM1t,funM2,maxit,tol);
-xexpected=[1;1];
-assert_checkalmostequal ( xcomputed , xexpected , %eps);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+// =============================================================================\r
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2012 Scilab Enterprises  Adeline CARNIS\r
+//\r
+//  This file is distributed under the same license as the Scilab package.\r
+// =============================================================================\r
+// <-- CLI SHELL MODE -->\r
+\r
+// unit tests for qmr() function \r
+// =============================================================================\r
+warning('off')\r
+\r
+// ----------------\r
+// If A is a matrix\r
+// ----------------\r
+\r
+// 1. Interface\r
+// ============\r
+assert_checkerror( "qmr()", "%s: Wrong number of input arguments: At least %d expected.\n", 10000, "qmr", 2);\r
+assert_checkerror( "qmr(1)", "%s: Wrong number of input arguments: At least %d expected.\n", 10000, "qmr", 2);\r
+assert_checkerror( "qmr([1 2;3 4])", "%s: Wrong number of input arguments: At least %d expected.\n", 10000, "qmr", 2);\r
+assert_checkerror( "qmr([1 2;3 4;5 6],[1;1;1])", "%s: Wrong size for input argument #%d: Square matrix expected.\n", 10000, "qmr", 1);\r
+assert_checkerror( "qmr([1 2;3 4;5 6],[1 1 1])", "%s: Wrong size for input argument #%d: Square matrix expected.\n", 10000, "qmr", 1);\r
+assert_checkerror( "qmr([1 2;3 4],[1 1])", "%s: Wrong size for input argument #%d: Column vector expected.\n", 10000, "qmr", 2);\r
+assert_checkerror( "qmr([%t %t;%t %t],[1;1])", "%s: Wrong type for input argument #%d : A real or complex matrix or a sparse matrix or a function expected.\n", 10000, "qmr", 1);\r
+assert_checkerror( "qmr([],[])", "%s: Wrong size for input argument #%d: Column vector expected.\n", 10000, "qmr", 2);\r
+\r
+// 2. Test with 2 input arguments and all output arguments\r
+// =======================================================\r
+A=[10,1;1,10];\r
+b=[11;11];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+assert_checkequal ( flag , 0);\r
+assert_checkequal ( err , 0);\r
+assert_checkequal ( iter, 1);\r
+\r
+// 3. Test with 3 input arguments and all output arguments\r
+// ======================================================\r
+A=[10,1;1,10];\r
+b=[11;11];\r
+x0=[1;1];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 4. Test with 4 input arguments and all output arguments\r
+// ======================================================\r
+A=[10,1;1,10];\r
+b=[11;11];\r
+x0=[1;1];\r
+M1=[1,0;0,1];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed,xexpected,%eps);\r
+\r
+// 5.Test with 5 input arguments and all output arguments\r
+// ======================================================\r
+A=[10,1;1,10];\r
+b=[11;11];\r
+x0=[1;1];\r
+M1=[1,0;0,1];\r
+M2=[1,0;0,1];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,M2);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 6.Test with 6 input arguments and all output arguments\r
+// ======================================================\r
+A=[10,1;1,10];\r
+b=[11;11];\r
+x0 = [1;1];\r
+M1=[1,0;0,1];\r
+M2=[1,0;0,1];\r
+maxit = 10;\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,M2,maxit);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 7.Test with 7 input arguments and all output arguments\r
+// =======================================================\r
+A=[10,1;1,10];\r
+b=[11;11];\r
+tol = 100*%eps;\r
+maxit = 10;\r
+M1=[1,0;0,1];\r
+M2=[1,0;0,1];\r
+x0=[1;1];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,M2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 8. Test with non-positionnal input parameters so that good initialization generates 0 iterations\r
+// =================================================================================================\r
+A=[100,1;1,10.];\r
+b=[101;11];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0=[1.;1.]);\r
+assert_checkequal ( iter , 1 );\r
+\r
+// 9. Test the special case where b=0\r
+// ====================================\r
+A=[100,1;1,10.];\r
+b=[0;0];\r
+[xcomputed, flag, err, iter, res]=qmr(A,b);\r
+xexpected=[0;0];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+assert_checkequal ( flag , 0 );\r
+assert_checktrue ( err <= %eps );\r
+assert_checkequal ( iter , 1 );\r
+\r
+// 10. A is a sparse matrix\r
+// =========================\r
+A = sparse([10 1;1 10]);\r
+b = ones(2,1);\r
+[xcomputed, flag, err, iter, res]=qmr(A,b);\r
+xexpected=[0.0909091;0.0909091];\r
+assert_checkalmostequal ( xcomputed , xexpected , 1e-1);\r
+assert_checkequal ( flag , 0);\r
+assert_checkalmostequal ( err , 1.110d-16, 1e-1);\r
+assert_checkequal ( iter, 1);\r
+\r
+// --------------------\r
+// If A is a function \r
+// -------------------\r
+\r
+// 1. Interface\r
+// =============\r
+function y = func_A(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+assert_checkfalse(execstr("qmr(func_A)","errcatch") == 0);\r
+lasterror(execstr("10000","errcatch") == 0);\r
+\r
+// 2. Test with 2 input arguments and all output arguments\r
+// =======================================================\r
+function y = func_qmr(x,t)\r
+    Amat = [10,1;1,10];\r
+    if (t == 'notransp') then\r
+        y = Amat*x;\r
+    elseif (t == 'transp') then\r
+        y = Amat'*x;\r
+    end\r
+endfunction\r
+b = [11;11];\r
+[xcomputed, flag, err, iter, res]=qmr(func_qmr,b);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+assert_checkequal ( flag , 0);\r
+assert_checkequal ( err , 0);\r
+assert_checkequal ( iter, 1);\r
+\r
+function y = funcA_notransp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+\r
+function y = funcA_transp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat'*x;\r
+endfunction\r
+b = [11;11];\r
+[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+assert_checkequal ( flag , 0);\r
+assert_checkequal ( err , 0);\r
+assert_checkequal ( iter, 1);\r
+\r
+// 3. Test with 3 input arguments and all output arguments\r
+// =======================================================\r
+function y = func_qmr(x,t)\r
+    Amat = [10,1;1,10];\r
+    if (t == 'notransp') then\r
+        y = Amat*x;\r
+    elseif (t == 'transp') then\r
+        y = Amat'*x;\r
+    end\r
+endfunction\r
+\r
+b = [11;11];\r
+x0=[1;1];\r
+[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = funcA_notransp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+\r
+function y = funcA_transp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat'*x;\r
+endfunction\r
+b = [11;11];\r
+x0=[1;1];\r
+[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 4. Test with 4 input arguments and all output arguments\r
+// =======================================================\r
+function y = func_qmr(x,t)\r
+    Amat = [10,1;1,10];\r
+    if (t == 'notransp') then\r
+        y = Amat*x;\r
+    elseif (t == 'transp') then\r
+        y = Amat'*x;\r
+    end\r
+endfunction\r
+b = [11;11];\r
+x0 = [1;1];\r
+M1=[1,0;0,1];\r
+[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = funcA_notransp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+\r
+function y = funcA_transp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat'*x;\r
+endfunction\r
+b = [11;11];\r
+x0 = [1;1];\r
+M1=[1,0;0,1];\r
+[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 5 Test with 5 input arguments and all output arguments\r
+// =======================================================\r
+function y = func_qmr(x,t)\r
+    Amat = [10,1;1,10];\r
+    if (t == 'notransp') then\r
+        y = Amat*x;\r
+    elseif (t == 'transp') then\r
+        y = Amat'*x;\r
+    end\r
+endfunction\r
+b = [11;11];\r
+x0 = [1;1];\r
+M1=[1,0;0,1];\r
+M2=[1,0;0,1];\r
+[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1,M2);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = funcA_notransp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+\r
+function y = funcA_transp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat'*x;\r
+endfunction\r
+b = [11;11];\r
+x0 = [1;1];\r
+M1=[1,0;0,1];\r
+M2 = [1 0; 0 1];\r
+[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1,M2);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 6 Test with 6 input arguments and all output arguments\r
+// =======================================================\r
+function y = func_qmr(x,t)\r
+    Amat = [10,1;1,10];\r
+    if (t == 'notransp') then\r
+        y = Amat*x;\r
+    elseif (t == 'transp') then\r
+        y = Amat'*x;\r
+    end\r
+endfunction\r
+b = [11;11];\r
+x0 = [1;1];\r
+M1=[1,0;0,1];\r
+M2 = eye(2,2);\r
+maxit = 10\r
+[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1,M2,maxit);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = funcA_notransp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+\r
+function y = funcA_transp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat'*x;\r
+endfunction\r
+b = [11;11];\r
+x0 = [1;1];\r
+maxit = 10;\r
+M1 = eye(2,2);\r
+M2 = eye(2,2);\r
+[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1,M2,maxit);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// 7 Test with 7 input arguments and all output arguments\r
+// =======================================================\r
+function y = func_qmr(x,t)\r
+    Amat = [10,1;1,10];\r
+    if (t == 'notransp') then\r
+        y = Amat*x;\r
+    elseif (t == 'transp') then\r
+        y = Amat'*x;\r
+    end\r
+endfunction\r
+b = [11;11];\r
+tol = 100*%eps;\r
+maxit = 10;\r
+M1=[1,0;0,1];\r
+M2 = eye(2,2);\r
+x0=[1;1];\r
+[xcomputed, flag, err, iter, res]=qmr(func_qmr,b,x0,M1,M2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = funcA_notransp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat*x;\r
+endfunction\r
+\r
+function y = funcA_transp(x)\r
+    Amat = [10,1;1,10];\r
+    y = Amat'*x;\r
+endfunction\r
+b = [11;11];\r
+tol = 100*%eps;\r
+maxit = 10;\r
+M1 = eye(2,2);\r
+M2 = eye(2,2);\r
+x0 = [1;1];\r
+[xcomputed, flag, err, iter, res]=qmr(funcA_notransp,funcA_transp,b,x0,M1,M2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+\r
+// Test : A is a matrix, M1 is a function, M2 is a matrix (default)\r
+// ===============================================================\r
+A = [10 1;1 10];\r
+b = [11;11];\r
+x0 = [1;1];\r
+\r
+function y = funM1(x,t)\r
+    M1 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M1*x;\r
+    elseif (t=="transp") then\r
+        y = M1'*x;\r
+    end\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,funM1);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = functionM1(x)\r
+    M1 = eye(2,2);\r
+    y = M1*x;\r
+endfunction\r
+\r
+function y = functionM1t(x)\r
+    M1 = eye(2,2);\r
+    y = M1'*x;\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,functionM1,functionM1t);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// Test : A is a matrix, M1 is a function, M2 is a matrix \r
+// ======================================================\r
+A = [10 1;1 10];\r
+b = [11;11];\r
+x0 = [1;1];\r
+M2 = eye(2,2);\r
+maxit = 10;\r
+tol = 100*%eps;\r
+\r
+function y = funM1(x,t)\r
+    M1 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M1*x;\r
+    elseif (t=="transp") then\r
+        y = M1'*x;\r
+    end\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,funM1,M2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = functionM1(x)\r
+    M1 = eye(2,2);\r
+    y = M1*x;\r
+endfunction\r
+\r
+function y = functionM1t(x)\r
+    M1 = eye(2,2);\r
+    y = M1'*x;\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,functionM1,functionM1t,M2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// Test : A is a matrix, M1 is a matrix, M2 is a function\r
+// ======================================================\r
+A = [10 1;1 10];\r
+b = [11;11];\r
+x0 = [1;1];\r
+M1 = eye(2,2);\r
+maxit = 10;\r
+tol = 100*%eps;\r
+\r
+function y = funM2(x,t)\r
+    M2 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M2*x;\r
+    elseif (t=="transp") then\r
+        y = M2'*x;\r
+    end\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,funM2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = functionM2(x)\r
+    M2 = eye(2,2);\r
+    y = M2*x;\r
+endfunction\r
+\r
+function y = functionM2t(x)\r
+    M2 = eye(2,2);\r
+    y = M2'*x;\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,M1,functionM2,functionM2t,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// Test : A is a matrix, M1 and M2 are functions\r
+// ==============================================\r
+A = [10 1;1 10];\r
+b = [11;11];\r
+x0 = [1;1];\r
+maxit = 10;\r
+tol = 100*%eps;\r
+\r
+function y = funM1(x,t)\r
+    M1 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M1*x;\r
+    elseif (t=="transp") then\r
+        y = M1'*x;\r
+    end\r
+endfunction\r
+\r
+function y = funM2(x,t)\r
+    M2 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M2*x;\r
+    elseif (t=="transp") then\r
+        y = M2'*x;\r
+    end\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,funM1,funM2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = functionM1(x)\r
+    M1 = eye(2,2);\r
+    y = M1*x;\r
+endfunction\r
+\r
+function y = functionM1t(x)\r
+    M1 = eye(2,2);\r
+    y = M1'*x;\r
+endfunction\r
+\r
+function y = functionM2(x)\r
+    M2 = eye(2,2);\r
+    y = M2*x;\r
+endfunction\r
+\r
+function y = functionM2t(x)\r
+    M2 = eye(2,2);\r
+    y = M2'*x;\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(A,b,x0,functionM1,functionM1t,functionM2,functionM2t,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+// Test : A, M1 and M2 are functions\r
+// ==================================\r
+b = [11;11];\r
+x0 = [1;1];\r
+maxit = 10;\r
+tol = 100*%eps;\r
+\r
+function y = funA(x,t)\r
+    A = [10 1;1 10];\r
+    if (t=="notransp") then\r
+        y = A*x;\r
+    elseif (t=="transp") then\r
+        y = A'*x;\r
+    end\r
+endfunction\r
+\r
+function y = funM1(x,t)\r
+    M1 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M1*x;\r
+    elseif (t=="transp") then\r
+        y = M1'*x;\r
+    end\r
+endfunction\r
+\r
+function y = funM2(x,t)\r
+    M2 = eye(2,2);\r
+    if (t=="notransp") then\r
+        y = M2*x;\r
+    elseif (t=="transp") then\r
+        y = M2'*x;\r
+    end\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,funM1,funM2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+function y = functionA(x)\r
+    A = [10 1;1 10];\r
+    y = A*x;\r
+endfunction\r
+\r
+function y = functionAt(x)\r
+    A = [10 1;1 10];\r
+    y = A1*x;\r
+endfunction\r
+\r
+function y = functionM1(x)\r
+    M1 = eye(2,2);\r
+    y = M1*x;\r
+endfunction\r
+\r
+function y = functionM1t(x)\r
+    M1 = eye(2,2);\r
+    y = M1'*x;\r
+endfunction\r
+\r
+function y = functionM2(x)\r
+    M2 = eye(2,2);\r
+    y = M2*x;\r
+endfunction\r
+\r
+function y = functionM2t(x)\r
+    M2 = eye(2,2);\r
+    y = M2'*x;\r
+endfunction\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,functionM1,functionM1t,functionM2,functionM2t,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,functionM1,functionM1t,functionM2,functionM2t,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,funM1,functionM2,functionM2t,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,funM1,functionM2,functionM2t,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,funM1,funM2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(functionA,functionAt,b,x0,functionM1,functionM1t,funM2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+[xcomputed, flag, err, iter, res]=qmr(funA,b,x0,functionM1,functionM1t,funM2,maxit,tol);\r
+xexpected=[1;1];\r
+assert_checkalmostequal ( xcomputed , xexpected , %eps);\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r\r