[sparse] insertion with negativ or null index fixed
[scilab.git] / scilab / modules / sparse / sci_gateway / cpp / sci_spzeros.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 #include "sparse_gw.hxx"
17 #include "function.hxx"
18 #include "sparse.hxx"
19
20 extern "C"
21 {
22 #include "charEncoding.h"
23 #include "Scierror.h"
24 #include "localization.h"
25 }
26
27 types::Function::ReturnValue sci_spzeros(types::typed_list &in, int _iRetCount, types::typed_list &out)
28 {
29     types::Sparse *pSpOut = NULL;
30     if (in.size() < 1 || in.size() > 2)
31     {
32         Scierror(999, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "spzeros", 1, 2);
33         return types::Function::Error;
34     }
35
36     if (_iRetCount > 1)
37     {
38         Scierror(999, _("%s: Wrong number of output arguments: %d expected.\n"), "spzeros", 1);
39         return types::Function::Error;
40     }
41
42     if (in.size() == 2)
43     {
44         types::Double* pDblRows = NULL;
45         types::Double* pDblCols = NULL;
46
47         if (in[0]->isDouble() == false)
48         {
49             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "spzeros", 1);
50             return types::Function::Error;
51         }
52
53         if (in[1]->isDouble() == false)
54         {
55             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "spzeros", 2);
56             return types::Function::Error;
57         }
58
59         pDblRows = in[0]->getAs<types::Double>();
60         pDblCols = in[1]->getAs<types::Double>();
61
62         if (pDblRows->isScalar() == false)
63         {
64             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "spzeros", 1);
65             return types::Function::Error;
66         }
67
68         if (pDblCols->isScalar() == false)
69         {
70             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "spzeros", 2);
71             return types::Function::Error;
72         }
73
74         double dblRows = pDblRows->get(0);
75         double dblCols = pDblCols->get(0);
76         if (dblRows != (double) ((unsigned int) dblRows))
77         {
78             Scierror(999, _("%s: Wrong value for input argument #%d: Scalar positive integer expected.\n"), "spzeros", 1);
79             return types::Function::Error;
80         }
81
82         if (dblCols != (double) ((unsigned int) dblCols))
83         {
84             Scierror(999, _("%s: Wrong value for input argument #%d: Scalar positive integer expected.\n"), "spzeros", 2);
85             return types::Function::Error;
86         }
87
88         if (dblRows * dblCols > INT_MAX)
89         {
90             Scierror(999, _("%s: Wrong value for input arguments: The maximum total size expected is %d.\n"), "spzeros", INT_MAX);
91             return types::Function::Error;
92         }
93
94         if (pDblRows->get(0) == 0. || pDblCols->get(0) == 0.)
95         {
96             pSpOut = new types::Sparse(0, 0, false);
97         }
98         else
99         {
100             pSpOut = new types::Sparse((int)pDblRows->get(0), (int)pDblCols->get(0), false);
101         }
102
103     }
104     else // in.size() == 1
105     {
106         switch (in[0]->getType())
107         {
108             case types::InternalType::ScilabInt8 :
109             case types::InternalType::ScilabUInt8 :
110             case types::InternalType::ScilabInt16 :
111             case types::InternalType::ScilabUInt16 :
112             case types::InternalType::ScilabInt32 :
113             case types::InternalType::ScilabUInt32 :
114             case types::InternalType::ScilabInt64 :
115             case types::InternalType::ScilabUInt64 :
116             case types::InternalType::ScilabString :
117             case types::InternalType::ScilabDouble :
118             case types::InternalType::ScilabBool :
119             case types::InternalType::ScilabFloat :
120             case types::InternalType::ScilabPolynom :
121             case types::InternalType::ScilabSinglePolynom :
122             case types::InternalType::ScilabSparse :
123             case types::InternalType::ScilabSparseBool :
124                 break;
125             default :
126             {
127                 Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), "spzeros", 1);
128                 return types::Function::Error;
129             }
130         }
131
132         types::GenericType* pGT = in[0]->getAs<types::GenericType>();
133         pSpOut = new types::Sparse(pGT->getRows(), pGT->getCols(), false);
134
135     }
136
137     out.push_back(pSpOut);
138     return types::Function::OK;
139 }