The functions of umfpack module returned API messages error. 14/13314/4
Adeline CARNIS [Wed, 4 Dec 2013 13:09:38 +0000 (14:09 +0100)]
Change-Id: I1583e6ba9d993ea0e79c1e4de43b29ddef92ae3e

16 files changed:
scilab/modules/umfpack/sci_gateway/c/sci_umf_ludel.c
scilab/modules/umfpack/sci_gateway/c/sci_umf_lufact.c
scilab/modules/umfpack/sci_gateway/c/sci_umf_luget.c
scilab/modules/umfpack/sci_gateway/c/sci_umf_luinfo.c
scilab/modules/umfpack/sci_gateway/c/sci_umf_lusolve.c
scilab/modules/umfpack/sci_gateway/c/sci_umfpack.c
scilab/modules/umfpack/tests/unit_tests/umf_lufact.dia.ref
scilab/modules/umfpack/tests/unit_tests/umf_lufact.tst
scilab/modules/umfpack/tests/unit_tests/umf_luget.dia.ref
scilab/modules/umfpack/tests/unit_tests/umf_luget.tst
scilab/modules/umfpack/tests/unit_tests/umf_luinfo.dia.ref
scilab/modules/umfpack/tests/unit_tests/umf_luinfo.tst
scilab/modules/umfpack/tests/unit_tests/umf_lusolve.dia.ref [new file with mode: 0644]
scilab/modules/umfpack/tests/unit_tests/umf_lusolve.tst [new file with mode: 0644]
scilab/modules/umfpack/tests/unit_tests/umfpack.dia.ref
scilab/modules/umfpack/tests/unit_tests/umfpack.tst

index 4844608..6e9ed7f 100644 (file)
@@ -65,6 +65,7 @@ int sci_umf_ludel(char* fname, unsigned long l)
     void * Numeric  = NULL;
     int* piAddr1    = NULL;
     CellAdr *Cell   = NULL;
+    int iType1      = 0;
 
     nbInputArgument(pvApiCtx) = Max(nbInputArgument(pvApiCtx), 0);
 
@@ -99,6 +100,15 @@ int sci_umf_ludel(char* fname, unsigned long l)
             return 1;
         }
 
+        /* Check if the first argument is a pointer */
+        sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
+        if (sciErr.iErr || iType1 != sci_pointer)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Wrong type for input argument #%d: A pointer expected.\n"), fname, 1);
+            return 1;
+        }
+
         sciErr = getPointer(pvApiCtx, piAddr1, &Numeric);
         if (sciErr.iErr)
         {
index 6f3d441..93e159d 100644 (file)
@@ -1,61 +1,61 @@
 /*
- *   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project
- *   <bruno.pincon@iecn.u-nancy.fr>
- *   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do
- *                 Espírito Santo, Brazil. <frasson@ele.ufes.br>.
- *
- *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
- *
- * PURPOSE: Scilab interfaces routines onto the UMFPACK sparse solver
- * (Tim Davis) and onto the TAUCS snmf choleski solver (Sivan Teledo)
- *
- * This software is governed by the CeCILL license under French law and
- * abiding by the rules of distribution of free software.  You can  use,
- * modify and/or redistribute the software under the terms of the CeCILL
- * license as circulated by CEA, CNRS and INRIA at the following URL
- * "http://www.cecill.info".
- *
- * As a counterpart to the access to the source code and  rights to copy,
- * modify and redistribute granted by the license, users are provided only
- * with a limited warranty  and the software's author,  the holder of the
- * economic rights,  and the successive licensors  have only  limited
- * liability.
- *
- * In this respect, the user's attention is drawn to the risks associated
- * with loading,  using,  modifying and/or developing or reproducing the
- * software by the user in light of its specific status of free software,
- * that may mean  that it is complicated to manipulate,  and  that  also
- * therefore means  that it is reserved for developers  and  experienced
- * professionals having in-depth computer knowledge. Users are therefore
- * encouraged to load and test the software's suitability as regards their
- * requirements in conditions enabling the security of their systems and/or
- * data to be ensured and,  more generally, to use and operate it in the
- * same conditions as regards security.
- *
- * The fact that you are presently reading this means that you have had
- * knowledge of the CeCILL license and that you accept its terms.
- *
- */
+*   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project
+*   <bruno.pincon@iecn.u-nancy.fr>
+*   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do
+*                 Espírito Santo, Brazil. <frasson@ele.ufes.br>.
+*
+*  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
+*
+* PURPOSE: Scilab interfaces routines onto the UMFPACK sparse solver
+* (Tim Davis) and onto the TAUCS snmf choleski solver (Sivan Teledo)
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited
+* liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+*
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+*/
 
 /*------------------------------------------------------------+
-  | 2) Interface code for the  LU factorization of A            |
-  |                                                             |
-  |    Scilab call                                              |
-  |    -----------                                              |
-  |        [LU_ptr] = umf_lufact(A)                             |
-  |                                                             |
-  |             A : a square real sparse matrix                 |
-  |        LU_ptr : a pointer to the LU fact                    |
-  |                                                             |
-  |   Var description (to complete...)                          |
-  |   ---------------                                           |
-  |      mA : number of rows of the matrix A                    |
-  |      nA : number of columns of A                            |
-  |       A : pointer to a sparse matrix struct                 |
-  |                                                             |
-  |      Require mA, nA  > 0                                    |
-  |                                                             |
-  +------------------------------------------------------------*/
+| 2) Interface code for the  LU factorization of A            |
+|                                                             |
+|    Scilab call                                              |
+|    -----------                                              |
+|        [LU_ptr] = umf_lufact(A)                             |
+|                                                             |
+|             A : a square real sparse matrix                 |
+|        LU_ptr : a pointer to the LU fact                    |
+|                                                             |
+|   Var description (to complete...)                          |
+|   ---------------                                           |
+|      mA : number of rows of the matrix A                    |
+|      nA : number of columns of A                            |
+|       A : pointer to a sparse matrix struct                 |
+|                                                             |
+|      Require mA, nA  > 0                                    |
+|                                                             |
++------------------------------------------------------------*/
 #include "api_scilab.h"
 #include "gw_umfpack.h"
 #include "sciumfpack.h"
@@ -94,6 +94,7 @@ int sci_umf_lufact(char* fname, unsigned long l)
 
     int* piAddr1 = NULL;
     int iComplex = 0;
+    int iType1   = 0;
 
     /* Check numbers of input/output arguments */
     CheckInputArgument(pvApiCtx, 1, 1);
@@ -107,6 +108,15 @@ int sci_umf_lufact(char* fname, unsigned long l)
         return 1;
     }
 
+    /* check if the first argument is a sparse matrix */
+    sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
+    if (sciErr.iErr || iType1 != sci_sparse)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
     if (isVarComplex(pvApiCtx, piAddr1))
     {
         iComplex = 1;
@@ -196,7 +206,7 @@ int sci_umf_lufact(char* fname, unsigned long l)
     if (! AddAdrToList(Numeric, A.it, &ListNumeric))
     {
         /* AddAdrToList return 0 if malloc have failed : as it is just
-           for storing 2 pointers this is unlikely to occurs but ... */
+        for storing 2 pointers this is unlikely to occurs but ... */
         if (A.it == 1)
         {
             umfpack_zi_free_numeric(&Numeric);
index c7df605..647cc70 100644 (file)
@@ -1,50 +1,50 @@
 /*
- *   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project
- *   <bruno.pincon@iecn.u-nancy.fr>
- *   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do
- *                 Espírito Santo, Brazil. <frasson@ele.ufes.br>.
- *
- *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
- *
- * PURPOSE: Scilab interfaces routines onto the UMFPACK sparse solver
- * (Tim Davis) and onto the TAUCS snmf choleski solver (Sivan Teledo)
- *
- * This software is governed by the CeCILL license under French law and
- * abiding by the rules of distribution of free software.  You can  use,
- * modify and/or redistribute the software under the terms of the CeCILL
- * license as circulated by CEA, CNRS and INRIA at the following URL
- * "http://www.cecill.info".
- *
- * As a counterpart to the access to the source code and  rights to copy,
- * modify and redistribute granted by the license, users are provided only
- * with a limited warranty  and the software's author,  the holder of the
- * economic rights,  and the successive licensors  have only  limited
- * liability.
- *
- * In this respect, the user's attention is drawn to the risks associated
- * with loading,  using,  modifying and/or developing or reproducing the
- * software by the user in light of its specific status of free software,
- * that may mean  that it is complicated to manipulate,  and  that  also
- * therefore means  that it is reserved for developers  and  experienced
- * professionals having in-depth computer knowledge. Users are therefore
- * encouraged to load and test the software's suitability as regards their
- * requirements in conditions enabling the security of their systems and/or
- * data to be ensured and,  more generally, to use and operate it in the
- * same conditions as regards security.
- *
- * The fact that you are presently reading this means that you have had
- * knowledge of the CeCILL license and that you accept its terms.
- *
- */
+*   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project
+*   <bruno.pincon@iecn.u-nancy.fr>
+*   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do
+*                 Espírito Santo, Brazil. <frasson@ele.ufes.br>.
+*
+*  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
+*
+* PURPOSE: Scilab interfaces routines onto the UMFPACK sparse solver
+* (Tim Davis) and onto the TAUCS snmf choleski solver (Sivan Teledo)
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited
+* liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+*
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+*/
 
 /*------------------------------------------------------------+
-  |   6) Interface code for getting the LU factors              |
-  |                                                             |
-  |   Scilab call                                               |
-  |   -----------                                               |
-  |   [L,U,p,q,R] = umf_luget(LU_ptr)                           |
-  |                                                             |
-  +------------------------------------------------------------*/
+|   6) Interface code for getting the LU factors              |
+|                                                             |
+|   Scilab call                                               |
+|   -----------                                               |
+|   [L,U,p,q,R] = umf_luget(LU_ptr)                           |
+|                                                             |
++------------------------------------------------------------*/
 #include "api_scilab.h"
 #include "sciumfpack.h"
 #include "gw_umfpack.h"
@@ -59,14 +59,14 @@ extern CellAdr *ListNumeric;
 int sci_umf_luget(char* fname, unsigned long l)
 {
     /*
-     *  LU_ptr is (a pointer to) a factorization of A, we have:
-     *             -1
-     *          P R  A Q = L U
-     *
-     *      A is n_row x n_col
-     *      L is n_row x n
-     *      U is n     x n_col     n = min(n_row, n_col)
-     */
+    *  LU_ptr is (a pointer to) a factorization of A, we have:
+    *             -1
+    *          P R  A Q = L U
+    *
+    *      A is n_row x n_col
+    *      L is n_row x n
+    *      U is n     x n_col     n = min(n_row, n_col)
+    */
 
     SciErr sciErr;
     void* Numeric = NULL;
@@ -76,6 +76,7 @@ int sci_umf_luget(char* fname, unsigned long l)
     int *p = NULL, *q = NULL, pl_miss = 0, error_flag = 0 ;
 
     int* piAddr1 = NULL;
+    int iType1   = 0;
 
     /* Check numbers of input/output arguments */
     CheckInputArgument(pvApiCtx, 1, 1);
@@ -89,6 +90,15 @@ int sci_umf_luget(char* fname, unsigned long l)
         return 1;
     }
 
+    /* Check if the first argument is a pointer */
+    sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
+    if (sciErr.iErr || iType1 != sci_pointer)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A pointer expected.\n"), fname, 1);
+        return 1;
+    }
+
     sciErr = getPointer(pvApiCtx, piAddr1, &Numeric);
     if (sciErr.iErr)
     {
index 084d3f5..8e53a29 100644 (file)
@@ -76,6 +76,7 @@ int sci_umf_luinfo(char* fname, unsigned long l)
     int it_flag     = 0;
     int* piAddr1    = NULL;
     int iErr        = 0;
+    int iType1      = 0;
 
     /* Check numbers of input/output arguments */
     CheckInputArgument(pvApiCtx, 1, 1);
@@ -89,6 +90,15 @@ int sci_umf_luinfo(char* fname, unsigned long l)
         return 1;
     }
 
+    /* Check if the first argument is a pointer */
+    sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
+    if (sciErr.iErr || iType1 != sci_pointer)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A pointer expected.\n"), fname, 1);
+        return 1;
+    }
+
     sciErr = getPointer(pvApiCtx, piAddr1, &Numeric);
     if (sciErr.iErr)
     {
index c2acbc1..8a5de2b 100644 (file)
@@ -108,6 +108,9 @@ int sci_umf_lusolve(char* fname, unsigned long l)
     int* piColPos       = NULL;
     double* pdblSpReal  = NULL;
     double* pdblSpImg   = NULL;
+    int iTypeVar1       = 0;
+    int iTypeVar2       = 0;
+    int iTypeVar4       = 0;
 
     /* Check numbers of input/output arguments */
     CheckInputArgument(pvApiCtx, 2, 4);
@@ -121,6 +124,15 @@ int sci_umf_lusolve(char* fname, unsigned long l)
         return 1;
     }
 
+    /* Check if the first argument is a pointer */
+    sciErr = getVarType(pvApiCtx, piAddr1, &iTypeVar1);
+    if (sciErr.iErr || iTypeVar1 != sci_pointer)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_lusolve", 1);
+        return 1;
+    }
+
     sciErr = getPointer(pvApiCtx, piAddr1, &Numeric);
     if (sciErr.iErr)
     {
@@ -166,6 +178,15 @@ int sci_umf_lusolve(char* fname, unsigned long l)
         return 1;
     }
 
+    /* Check if the second argument is a real or complex column vector or matrix */
+    sciErr = getVarType(pvApiCtx, piAddr2, &iTypeVar2);
+    if (sciErr.iErr || iTypeVar2 != sci_matrix)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real or complex column vector or matrix expected.\n"), "umf_lusolve", 2);
+        return 1;
+    }
+
     if (isVarComplex(pvApiCtx, piAddr2))
     {
         iComplex = 1;
@@ -248,6 +269,15 @@ int sci_umf_lusolve(char* fname, unsigned long l)
                 return 1;
             }
 
+            sciErr = getVarType(pvApiCtx, piAddr4, &iTypeVar4);
+            if (sciErr.iErr || iTypeVar4 != sci_sparse)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umf_lusolve", 4);
+                return 1;
+            }
+
+
             if (isVarComplex(pvApiCtx, piAddr4))
             {
                 AA.it = 1;
index 7fd5dd2..55e70f8 100644 (file)
@@ -117,6 +117,9 @@ int sci_umfpack(char* fname, unsigned long l)
     int* Wi         = NULL;
     double* W       = NULL;
     char* pStr      = NULL;
+    int iType2      = 0;
+    int iTypeA      = 0;
+    int iTypeB      = 0;
 
     /* Check numbers of input/output arguments */
     CheckInputArgument(pvApiCtx, 3, 3);
@@ -130,6 +133,14 @@ int sci_umfpack(char* fname, unsigned long l)
         return 1;
     }
 
+    sciErr = getVarType(pvApiCtx, piAddr2, &iType2);
+    if (sciErr.iErr || iType2 != sci_strings)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
+        return 1;
+    }
+
     getAllocatedSingleString(pvApiCtx, piAddr2, &pStr);
 
     /* select Case 1 or 2 depending (of the first char of) the string ... */
@@ -159,6 +170,14 @@ int sci_umfpack(char* fname, unsigned long l)
         return 1;
     }
 
+    sciErr = getVarType(pvApiCtx, piAddrA, &iTypeA);
+    if (sciErr.iErr || iTypeA != sci_sparse)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
     if (isVarComplex(pvApiCtx, piAddrA))
     {
         AA.it = 1;
@@ -200,6 +219,14 @@ int sci_umfpack(char* fname, unsigned long l)
         return 1;
     }
 
+    sciErr = getVarType(pvApiCtx, piAddrB, &iTypeB);
+    if (sciErr.iErr || iTypeB != sci_matrix)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), fname, 3);
+        return 1;
+    }
+
     if (isVarComplex(pvApiCtx, piAddrB))
     {
         iComplex = 1;
index 9db3ea9..62d4faa 100644 (file)
@@ -1,10 +1,17 @@
 // ============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2007-2008 - Bruno PINCON
+// Copyrigth (C) 2013 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 // <-- CLI SHELL MODE -->
+assert_checkfalse(execstr("umf_lufact()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umf_lufact", 1);
+assert_checkerror("umf_lufact()", refMsg);
+assert_checkfalse(execstr("umf_lufact(1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umf_lufact", 1);
+assert_checkerror("umf_lufact(1)", refMsg);
 // this is the small linear test system from UMFPACK
 // whom solution must be [1;2;3;4;5]
 A = sparse( [ 2  3  0  0  0;
@@ -15,10 +22,13 @@ A = sparse( [ 2  3  0  0  0;
 b = [8 ; 45; -3; 3; 19];
 Lup = umf_lufact(A);
 x = umf_lusolve(Lup,b);
-if or( (x-[ 1; 2; 3; 4; 5 ]) > %eps) then bugmes();quit;end
+assert_checkalmostequal(x, [1 2 3 4 5]');
 // solve now A'x=b
 x = umf_lusolve(Lup,b,"A''x=b");
-if norm(A'*x - b) <> 0, then bugmes();quit;end
+assert_checkequal(norm(A'*x-b), 0)
+ ans  =
+  T  
 // don't forget to clear memory with
 umf_ludel(Lup)
 // a real (but small)  example
@@ -33,6 +43,6 @@ firstNorm=norm(A*x - b);
 // now the same thing with iterative refiment
 x = umf_lusolve(Lup,b,"Ax=b",A);
 secondNorm=norm(A*x - b);
-if firstNorm <> secondNorm then bugmes();quit;end
+assert_checkfalse(firstNorm <> secondNorm);
 // don't forget to clear memory
 umf_ludel(Lup)
index e9c96ea..4c4498a 100644 (file)
@@ -1,12 +1,21 @@
 // ============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2007-2008 - Bruno PINCON
+// Copyrigth (C) 2013 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 
 // <-- CLI SHELL MODE -->
 
+assert_checkfalse(execstr("umf_lufact()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umf_lufact", 1);
+assert_checkerror("umf_lufact()", refMsg);
+
+assert_checkfalse(execstr("umf_lufact(1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umf_lufact", 1);
+assert_checkerror("umf_lufact(1)", refMsg);
+
 // this is the small linear test system from UMFPACK
 // whom solution must be [1;2;3;4;5]
 A = sparse( [ 2  3  0  0  0;
@@ -18,11 +27,11 @@ b = [8 ; 45; -3; 3; 19];
 Lup = umf_lufact(A);
 x = umf_lusolve(Lup,b);
 
-if or( (x-[ 1; 2; 3; 4; 5 ]) > %eps) then pause, end
+assert_checkalmostequal(x, [1 2 3 4 5]');
 
 // solve now A'x=b
 x = umf_lusolve(Lup,b,"A''x=b");
-if norm(A'*x - b) <> 0, then pause, end
+assert_checkequal(norm(A'*x-b), 0)
 
 // don't forget to clear memory with
 umf_ludel(Lup)
@@ -41,7 +50,7 @@ firstNorm=norm(A*x - b);
 x = umf_lusolve(Lup,b,"Ax=b",A);
 secondNorm=norm(A*x - b);
 
-if firstNorm <> secondNorm then pause, end
+assert_checkfalse(firstNorm <> secondNorm);
 
 // don't forget to clear memory
 umf_ludel(Lup)
index 742e75b..cd8923a 100644 (file)
@@ -1,45 +1,52 @@
 // ============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2007-2008 - Bruno PINCON
+// Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 // <-- CLI SHELL MODE -->
+assert_checkfalse(execstr("umf_luget()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umf_luget", 1);
+assert_checkerror("umf_luget()", refMsg);
+assert_checkfalse(execstr("umf_luget(1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_luget", 1);
+assert_checkerror("umf_luget(1)", refMsg);
 // this is the test matrix from UMFPACK
 A = sparse( [ 2  3  0  0  0;
-              3  0  4  0  6;
-              0 -1 -3  2  0;
-              0  0  1  0  0;
+              3  0  4  0  6; 
+              0 -1 -3  2  0; 
+              0  0  1  0  0; 
               0  4  2  0  1] );
 Lup = umf_lufact(A);
 [L,U,p,q,R] = umf_luget(Lup);
-if nnz(L) <> 9 then bugmes();quit;end
-if nnz(U) <> 9 then bugmes();quit;end
-if or(p <> [ 3; 4; 1; 5; 2 ]) then bugmes();quit;end
-if or(q <> [ 4; 3; 1; 5; 2 ]) then bugmes();quit;end
-if or(R <> [ 5; 13; 6; 1; 7 ]) then bugmes();quit;end
+assert_checkequal(nnz(L), 9);
+assert_checkequal(nnz(U), 9);
+assert_checkfalse(or(p <> [ 3; 4; 1; 5; 2 ]));
+assert_checkfalse(or(q <> [ 4; 3; 1; 5; 2 ]));
+assert_checkfalse(or(R <> [ 5; 13; 6; 1; 7 ]));
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 B(p,q) - L*U;  // must be a (quasi) nul matrix
-if nnz(L*U) <> 13 then bugmes();quit;end
-if nnz(B(p,q)) <> 12 then bugmes();quit;end
+assert_checkequal(nnz(L*U), 13);
+assert_checkequal(nnz(B(p,q)), 12);
 umf_ludel(Lup); // clear memory
 // the same with a complex matrix
 A = sparse( [ 2+%i  3+2*%i  0      0    0;
-              3-%i  0       4+%i   0    6-3*%i;
-              0    -1+%i   -3+6*%i 2-%i 0;
-              0     0       1-5*%i 0    0;
+              3-%i  0       4+%i   0    6-3*%i; 
+              0    -1+%i   -3+6*%i 2-%i 0; 
+              0     0       1-5*%i 0    0; 
               0     4       2-%i   0    1] );
 Lup = umf_lufact(A);
 [L,U,p,q,R] = umf_luget(Lup);
-if nnz(L) <> 9 then bugmes();quit;end
-if nnz(U) <> 9 then bugmes();quit;end
-if or(p <> [ 3; 4; 1; 5; 2 ]) then bugmes();quit;end
-if or(q <> [ 4; 3; 1; 5; 2 ]) then bugmes();quit;end
-if or(R <> [ 8; 18; 14; 6; 8 ]) then bugmes();quit;end
+assert_checkequal(nnz(L), 9);
+assert_checkequal(nnz(U), 9);
+assert_checkfalse(or(p <> [ 3; 4; 1; 5; 2 ]));
+assert_checkfalse(or(q <> [ 4; 3; 1; 5; 2 ]));
+assert_checkfalse(or(R <> [ 8; 18; 14; 6; 8 ]));
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 B(p,q) - L*U;  // must be a (quasi) nul matrix
-if nnz(B(p,q)) <> 12 then bugmes();quit;end
-if nnz(L*U) <> 13 then bugmes();quit;end
+assert_checkequal(nnz(B(p,q)), 12);
+assert_checkequal(nnz(L*U), 13);
 umf_ludel(Lup) // clear memory
index 0f39819..ced5087 100644 (file)
@@ -1,12 +1,21 @@
 // ============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2007-2008 - Bruno PINCON
+// Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 
 // <-- CLI SHELL MODE -->
 
+assert_checkfalse(execstr("umf_luget()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umf_luget", 1);
+assert_checkerror("umf_luget()", refMsg);
+
+assert_checkfalse(execstr("umf_luget(1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_luget", 1);
+assert_checkerror("umf_luget(1)", refMsg);
+
 // this is the test matrix from UMFPACK
 
 A = sparse( [ 2  3  0  0  0;
@@ -17,19 +26,19 @@ A = sparse( [ 2  3  0  0  0;
 Lup = umf_lufact(A);
 [L,U,p,q,R] = umf_luget(Lup);
 
-if nnz(L) <> 9 then pause, end
-if nnz(U) <> 9 then pause, end
+assert_checkequal(nnz(L), 9);
+assert_checkequal(nnz(U), 9);
 
-if or(p <> [ 3; 4; 1; 5; 2 ]) then pause, end
-if or(q <> [ 4; 3; 1; 5; 2 ]) then pause, end
-if or(R <> [ 5; 13; 6; 1; 7 ]) then pause, end
+assert_checkfalse(or(p <> [ 3; 4; 1; 5; 2 ]));
+assert_checkfalse(or(q <> [ 4; 3; 1; 5; 2 ]));
+assert_checkfalse(or(R <> [ 5; 13; 6; 1; 7 ]));
 
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 B(p,q) - L*U;  // must be a (quasi) nul matrix
 
-if nnz(L*U) <> 13 then pause, end
-if nnz(B(p,q)) <> 12 then pause, end
+assert_checkequal(nnz(L*U), 13);
+assert_checkequal(nnz(B(p,q)), 12);
 
 umf_ludel(Lup); // clear memory
 
@@ -42,17 +51,17 @@ A = sparse( [ 2+%i  3+2*%i  0      0    0;
 Lup = umf_lufact(A);
 [L,U,p,q,R] = umf_luget(Lup);
 
-if nnz(L) <> 9 then pause, end
-if nnz(U) <> 9 then pause, end
+assert_checkequal(nnz(L), 9);
+assert_checkequal(nnz(U), 9);
 
-if or(p <> [ 3; 4; 1; 5; 2 ]) then pause, end
-if or(q <> [ 4; 3; 1; 5; 2 ]) then pause, end
-if or(R <> [ 8; 18; 14; 6; 8 ]) then pause, end
+assert_checkfalse(or(p <> [ 3; 4; 1; 5; 2 ]));
+assert_checkfalse(or(q <> [ 4; 3; 1; 5; 2 ]));
+assert_checkfalse(or(R <> [ 8; 18; 14; 6; 8 ]));
 
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 B(p,q) - L*U;  // must be a (quasi) nul matrix
-if nnz(B(p,q)) <> 12 then pause, end
-if nnz(L*U) <> 13 then pause, end
+assert_checkequal(nnz(B(p,q)), 12);
+assert_checkequal(nnz(L*U), 13);
 
 umf_ludel(Lup) // clear memory
index 5c07eb4..0260402 100644 (file)
@@ -1,26 +1,33 @@
 // ============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - Bruno PINCON
+// Copyright (C) 2013 -  Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 // <-- CLI SHELL MODE -->
+assert_checkfalse(execstr("umf_luinfo()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umf_luinfo", 1);
+assert_checkerror("umf_luinfo()", refMsg);
+assert_checkfalse(execstr("umf_luinfo(1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_luinfo", 1);
+assert_checkerror("umf_luinfo(1)", refMsg);
 // this is the test matrix from UMFPACK
 A = sparse( [ 2  3  0  0  0;
-              3  0  4  0  6;
-              0 -1 -3  2  0;
-              0  0  1  0  0;
+              3  0  4  0  6; 
+              0 -1 -3  2  0; 
+              0  0  1  0  0; 
               0  4  2  0  1] );
 Lup = umf_lufact(A);
-[OK, nrow, ncol, lnz, unz, udiag_nz, it] = umf_luinfo(Lup);  // OK must be %t, nrow=ncol = 5,
-if OK <> %t then bugmes();quit;end
-if nrow <> 5 then bugmes();quit;end
-if ncol <> 5 then bugmes();quit;end
-if lnz <> 9 then bugmes();quit;end
-if unz <> 9 then bugmes();quit;end
-if udiag_nz <> 5 then bugmes();quit;end
-if it <> 0 then bugmes();quit;end
+[OK, nrow, ncol, lnz, unz, udiag_nz, it] = umf_luinfo(Lup);  // OK must be %t, nrow=ncol = 5, 
+assert_checkequal(OK, %t);
+assert_checkequal(nrow, 5);
+assert_checkequal(ncol, 5);
+assert_checkequal(lnz, 9);
+assert_checkequal(unz, 9);
+assert_checkequal(udiag_nz, 5);
+assert_checkequal(it, 0);
 [L,U,p,q,R] = umf_luget(Lup);
-if nnz(L) <> lnz then bugmes();quit;end
-if nnz(U) <> unz then bugmes();quit;end
+assert_checkequal(nnz(L), lnz);
+assert_checkequal(nnz(U), unz);
 umf_ludel(Lup) // clear memory
index a707a44..4d4a112 100644 (file)
@@ -1,12 +1,21 @@
 // ============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - Bruno PINCON
+// Copyright (C) 2013 -  Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
 
 // <-- CLI SHELL MODE -->
 
+assert_checkfalse(execstr("umf_luinfo()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umf_luinfo", 1);
+assert_checkerror("umf_luinfo()", refMsg);
+
+assert_checkfalse(execstr("umf_luinfo(1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_luinfo", 1);
+assert_checkerror("umf_luinfo(1)", refMsg);
+
 // this is the test matrix from UMFPACK
 A = sparse( [ 2  3  0  0  0;
               3  0  4  0  6; 
@@ -16,15 +25,15 @@ A = sparse( [ 2  3  0  0  0;
 Lup = umf_lufact(A);
 [OK, nrow, ncol, lnz, unz, udiag_nz, it] = umf_luinfo(Lup);  // OK must be %t, nrow=ncol = 5, 
 
-if OK <> %t then pause, end
-if nrow <> 5 then pause, end
-if ncol <> 5 then pause, end
-if lnz <> 9 then pause, end
-if unz <> 9 then pause, end
-if udiag_nz <> 5 then pause, end
-if it <> 0 then pause, end
+assert_checkequal(OK, %t);
+assert_checkequal(nrow, 5);
+assert_checkequal(ncol, 5);
+assert_checkequal(lnz, 9);
+assert_checkequal(unz, 9);
+assert_checkequal(udiag_nz, 5);
+assert_checkequal(it, 0);
 
 [L,U,p,q,R] = umf_luget(Lup);
-if nnz(L) <> lnz then pause, end
-if nnz(U) <> unz then pause, end
+assert_checkequal(nnz(L), lnz);
+assert_checkequal(nnz(U), unz);
 umf_ludel(Lup) // clear memory
diff --git a/scilab/modules/umfpack/tests/unit_tests/umf_lusolve.dia.ref b/scilab/modules/umfpack/tests/unit_tests/umf_lusolve.dia.ref
new file mode 100644 (file)
index 0000000..f711d9d
--- /dev/null
@@ -0,0 +1,48 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// unit tests for umf_lusolve function 
+// =============================================================================
+assert_checkfalse(execstr("umf_lusolve()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d to %d expected.\n"), "umf_lusolve", 2, 4);
+assert_checkerror("umf_lusolve()", refMsg);
+assert_checkfalse(execstr("umf_lusolve(1,1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_lusolve", 1);
+assert_checkerror("umf_lusolve(1,1)", refMsg);
+B = rand(3,3)*%i;
+Lup = umf_lufact(sparse(B))
+ Lup  =
+assert_checkfalse(execstr("umf_lusolve(Lup, speye(3,3))"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex column vector or matrix expected.\n"), "umf_lusolve", 2);
+assert_checkerror("umf_lusolve(Lup, speye(3,3))", refMsg);
+assert_checkfalse(execstr("umf_lusolve(Lup, eye(3,3), ""Cx=d"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong input argument #%d: ''Ax=b'' or ''A''x=b'' expected.\n"), "umf_lusolve", 3);
+assert_checkerror("umf_lusolve(Lup, eye(3,3), ""Cx=d"")", refMsg);
+assert_checkfalse(execstr("umf_lusolve(Lup, eye(3,3), ""Ax=b"", ""titi"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umf_lusolve", 4);
+assert_checkerror("umf_lusolve(Lup, eye(3,3), ""Ax=b"", ""titi"")", refMsg);
+x = umf_lusolve(Lup, eye(3,3));
+assert_checkalmostequal(x, inv(B))
+ ans  =
+  T  
+umf_ludel(Lup)
+spB = sparse(B);
+Lup = umf_lufact(spB);
+b = ones(size(spB,1),1);
+// use umf_lusolve for solving Ax=b
+x = umf_lusolve(Lup,b);
+firstNorm=norm(spB*x - b);
+// now the same thing with iterative refiment
+x = umf_lusolve(Lup,b,"Ax=b",spB);
+secondNorm=norm(spB*x - b);
+assert_checkalmostequal(firstNorm, secondNorm)
+ ans  =
+  T  
+umf_ludel(Lup)
diff --git a/scilab/modules/umfpack/tests/unit_tests/umf_lusolve.tst b/scilab/modules/umfpack/tests/unit_tests/umf_lusolve.tst
new file mode 100644 (file)
index 0000000..76cb121
--- /dev/null
@@ -0,0 +1,51 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+
+// unit tests for umf_lusolve function 
+// =============================================================================
+
+assert_checkfalse(execstr("umf_lusolve()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d to %d expected.\n"), "umf_lusolve", 2, 4);
+assert_checkerror("umf_lusolve()", refMsg);
+
+assert_checkfalse(execstr("umf_lusolve(1,1)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A pointer expected.\n"), "umf_lusolve", 1);
+assert_checkerror("umf_lusolve(1,1)", refMsg);
+
+B = rand(3,3)*%i;
+Lup = umf_lufact(sparse(B))
+assert_checkfalse(execstr("umf_lusolve(Lup, speye(3,3))"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A real or complex column vector or matrix expected.\n"), "umf_lusolve", 2);
+assert_checkerror("umf_lusolve(Lup, speye(3,3))", refMsg);
+
+assert_checkfalse(execstr("umf_lusolve(Lup, eye(3,3), ""Cx=d"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong input argument #%d: ''Ax=b'' or ''A''x=b'' expected.\n"), "umf_lusolve", 3);
+assert_checkerror("umf_lusolve(Lup, eye(3,3), ""Cx=d"")", refMsg);
+
+assert_checkfalse(execstr("umf_lusolve(Lup, eye(3,3), ""Ax=b"", ""titi"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umf_lusolve", 4);
+assert_checkerror("umf_lusolve(Lup, eye(3,3), ""Ax=b"", ""titi"")", refMsg);
+
+x = umf_lusolve(Lup, eye(3,3));
+assert_checkalmostequal(x, inv(B))
+umf_ludel(Lup)
+
+spB = sparse(B);
+Lup = umf_lufact(spB);
+b = ones(size(spB,1),1);
+// use umf_lusolve for solving Ax=b
+x = umf_lusolve(Lup,b);
+firstNorm=norm(spB*x - b);
+
+// now the same thing with iterative refiment
+x = umf_lusolve(Lup,b,"Ax=b",spB);
+secondNorm=norm(spB*x - b);
+
+assert_checkalmostequal(firstNorm, secondNorm)
+umf_ludel(Lup)
index 1b24d0e..4583f19 100644 (file)
@@ -4,31 +4,44 @@
 //
 //  This file is distributed under the same license as the Scilab package.
 // ============================================================================
+// <-- CLI SHELL MODE -->
+assert_checkfalse(execstr("umfpack()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umfpack", 3);
+assert_checkerror("umfpack()", refMsg);
+assert_checkfalse(execstr("umfpack(speye(3,3), 2, 2)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"), "umfpack", 2);
+assert_checkerror("umfpack(speye(3,3), 2, 2)", refMsg);
+assert_checkfalse(execstr("umfpack(1, ""\"", 2)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umfpack", 1);
+assert_checkerror("umfpack(1, ""\"", 2)", refMsg);
+assert_checkfalse(execstr("umfpack(speye(3,3), ""\"", %s)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "umfpack", 3);
+assert_checkerror("umfpack(speye(3,3), ""\"", %s)", refMsg);
 A = sparse( [ 2  3  0  0  0;
-              3  0  4  0  6;
-              0 -1 -3  2  0;
-              0  0  1  0  0;
+              3  0  4  0  6; 
+              0 -1 -3  2  0; 
+              0  0  1  0  0; 
               0  4  2  0  1] );
 b = [8 ; 45; -3; 3; 19];
 x = umfpack(A,"\",b);
-if norm(x - [1 2 3 4 5]')  < %eps then bugmes();quit;end
+assert_checkalmostequal(x, [1 2 3 4 5]');
 // test the other form x A = b
 b = [8  20  13  6  17];
 x = umfpack(b,"/",A);   // solution must be [1 2 3 4 5]
-if norm(x - [1 2 3 4 5])  < %eps then bugmes();quit;end
+assert_checkalmostequal(x, [1 2 3 4 5]);
 // test multiple rhs
 b = rand(5,3);
 x = umfpack(A,"\",b);
-if norm(A*x - b) < %eps  then bugmes();quit;end
+assert_checkfalse(norm(A*x-b) < %eps);
 // test multiple rhs for x A = b
 b = rand(3,5);
 x = umfpack(b,"/",A);
-if norm(x*A - b) > %eps  then bugmes();quit;end
+assert_checkfalse(norm(x*A - b) > %eps);
 // solve a complex system
 A = sparse( [ 2+%i  3+2*%i  0      0    0;
-              3-%i  0       4+%i   0    6-3*%i;
-              0    -1+%i   -3+6*%i 2-%i 0;
-              0     0       1-5*%i 0    0;
+              3-%i  0       4+%i   0    6-3*%i; 
+              0    -1+%i   -3+6*%i 2-%i 0; 
+              0     0       1-5*%i 0    0; 
               0     4       2-%i   0    1] );
 b = [ 3+13*%i ; 58+32*%i ; -19+13*%i ; 18-12*%i ; 22+16*%i ];
 x = umfpack(A,"\",b)  // x must be [1+i; 2+2i; 3+3i; 4 + 4i; 5+5i]
@@ -39,49 +52,52 @@ x = umfpack(A,"\",b)  // x must be [1+i; 2+2i; 3+3i; 4 + 4i; 5+5i]
     3. + 3.i  
     4. + 4.i  
     5. + 5.i  
-if norm(x - [1+%i; 2+2*%i; 3+3*%i; 4 + 4*%i; 5+5*%i]) < %eps then bugmes();quit;end
+assert_checkfalse(norm(x - [1+%i; 2+2*%i; 3+3*%i; 4 + 4*%i; 5+5*%i]) < %eps)
+ ans  =
+  T  
 A = sparse( [ 2  3  0  0  0;
-              3  0  4  0  6;
-              0 -1 -3  2  0;
-              0  0  1  0  0;
+              3  0  4  0  6; 
+              0 -1 -3  2  0; 
+              0  0  1  0  0; 
               0  4  2  0  1] );
 Lup = umf_lufact(A);
-[OK, nrow, ncol, lnz, unz, udiag_nz, it] = umf_luinfo(Lup);  // OK must be %t, nrow=ncol = 5,
+[OK, nrow, ncol, lnz, unz, udiag_nz, it] = umf_luinfo(Lup);  // OK must be %t, nrow=ncol = 5, 
 [L,U,p,q,R] = umf_luget(Lup);
 nnz(L)  // must be equal to lnz
  ans  =
  
     9.  
-if nnz(L) <> lnz then bugmes();quit;end
+assert_checkequal(nnz(L), lnz);
 nnz(U)  // must be equal to unz
  ans  =
  
     9.  
-if nnz(U) <> unz then bugmes();quit;end
+assert_checkequal(nnz(U), unz);
 umf_ludel(Lup); // clear memory
 // this is the test matrix from UMFPACK
 A = sparse( [ 2  3  0  0  0;
-              3  0  4  0  6;
-              0 -1 -3  2  0;
-              0  0  1  0  0;
+              3  0  4  0  6; 
+              0 -1 -3  2  0; 
+              0  0  1  0  0; 
               0  4  2  0  1] );
 Lup = umf_lufact(A);
 [L,U,p,q,R] = umf_luget(Lup);
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 // must be a (quasi) nul matrix
-if norm(B(p,q) - L*U) > %eps then bugmes();quit;end
+assert_checkfalse(norm(B(p,q) - L*U) > %eps);
 umf_ludel(Lup);// clear memory
 // the same with a complex matrix
 A = sparse( [ 2+%i  3+2*%i  0      0    0;
-              3-%i  0       4+%i   0    6-3*%i;
-              0    -1+%i   -3+6*%i 2-%i 0;
-              0     0       1-5*%i 0    0;
+              3-%i  0       4+%i   0    6-3*%i; 
+              0    -1+%i   -3+6*%i 2-%i 0; 
+              0     0       1-5*%i 0    0; 
               0     4       2-%i   0    1] );
 Lup = umf_lufact(A);
 [L,U,p,q,R] = umf_luget(Lup);
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 // must be a (quasi) nul matrix
-if norm(B(p,q) - L*U) > %eps then bugmes();quit;end
+assert_checkfalse(norm(B(p,q) - L*U) > %eps);
 umf_ludel(Lup); // clear memory
index 09f8cca..351b70c 100644 (file)
@@ -7,6 +7,22 @@
 
 // <-- CLI SHELL MODE -->
 
+assert_checkfalse(execstr("umfpack()"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"), "umfpack", 3);
+assert_checkerror("umfpack()", refMsg);
+
+assert_checkfalse(execstr("umfpack(speye(3,3), 2, 2)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"), "umfpack", 2);
+assert_checkerror("umfpack(speye(3,3), 2, 2)", refMsg);
+
+assert_checkfalse(execstr("umfpack(1, ""\"", 2)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "umfpack", 1);
+assert_checkerror("umfpack(1, ""\"", 2)", refMsg);
+
+assert_checkfalse(execstr("umfpack(speye(3,3), ""\"", %s)"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "umfpack", 3);
+assert_checkerror("umfpack(speye(3,3), ""\"", %s)", refMsg);
+
 A = sparse( [ 2  3  0  0  0;
               3  0  4  0  6; 
               0 -1 -3  2  0; 
@@ -15,25 +31,24 @@ A = sparse( [ 2  3  0  0  0;
 b = [8 ; 45; -3; 3; 19];
 x = umfpack(A,"\",b);
 
-
-if norm(x - [1 2 3 4 5]')  < %eps then pause,end
+assert_checkalmostequal(x, [1 2 3 4 5]');
 
 // test the other form x A = b
 b = [8  20  13  6  17];
 x = umfpack(b,"/",A);   // solution must be [1 2 3 4 5]
 
-if norm(x - [1 2 3 4 5])  < %eps then pause,end
+assert_checkalmostequal(x, [1 2 3 4 5]);
 
 // test multiple rhs
 b = rand(5,3);
 x = umfpack(A,"\",b);
 
-if norm(A*x - b) < %eps  then pause,end
+assert_checkfalse(norm(A*x-b) < %eps);
 
 // test multiple rhs for x A = b
 b = rand(3,5);
 x = umfpack(b,"/",A);
-if norm(x*A - b) > %eps  then pause,end
+assert_checkfalse(norm(x*A - b) > %eps);
 
 // solve a complex system
 A = sparse( [ 2+%i  3+2*%i  0      0    0;
@@ -44,8 +59,7 @@ A = sparse( [ 2+%i  3+2*%i  0      0    0;
 b = [ 3+13*%i ; 58+32*%i ; -19+13*%i ; 18-12*%i ; 22+16*%i ];
 x = umfpack(A,"\",b)  // x must be [1+i; 2+2i; 3+3i; 4 + 4i; 5+5i]
 
-if norm(x - [1+%i; 2+2*%i; 3+3*%i; 4 + 4*%i; 5+5*%i]) < %eps then pause,end
-
+assert_checkfalse(norm(x - [1+%i; 2+2*%i; 3+3*%i; 4 + 4*%i; 5+5*%i]) < %eps)
 
 A = sparse( [ 2  3  0  0  0;
               3  0  4  0  6; 
@@ -56,10 +70,10 @@ Lup = umf_lufact(A);
 [OK, nrow, ncol, lnz, unz, udiag_nz, it] = umf_luinfo(Lup);  // OK must be %t, nrow=ncol = 5, 
 [L,U,p,q,R] = umf_luget(Lup);
 nnz(L)  // must be equal to lnz
-if nnz(L) <> lnz then pause,end
+assert_checkequal(nnz(L), lnz);
 
 nnz(U)  // must be equal to unz
-if nnz(U) <> unz then pause,end
+assert_checkequal(nnz(U), unz);
 
 umf_ludel(Lup); // clear memory
 
@@ -76,7 +90,7 @@ Lup = umf_lufact(A);
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 // must be a (quasi) nul matrix
-if norm(B(p,q) - L*U) > %eps then pause,end
+assert_checkfalse(norm(B(p,q) - L*U) > %eps);
 umf_ludel(Lup);// clear memory
 
 
@@ -91,5 +105,6 @@ Lup = umf_lufact(A);
 B = A;
 for i=1:5, B(i,:) = B(i,:)/R(i); end // apply the row scaling
 // must be a (quasi) nul matrix
-if norm(B(p,q) - L*U) > %eps then pause,end
+assert_checkfalse(norm(B(p,q) - L*U) > %eps);
+
 umf_ludel(Lup); // clear memory