License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / api_scilab / src / cpp / template / api_double.hpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
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 #include "gatewaystruct.hxx"
16 #include "double.hxx"
17
18 extern "C"
19 {
20 #include "doublecomplex.h"
21 #include "api_scilab.h"
22 }
23 /* Scilab 6 API*/
24 scilabVar API_PROTO(createEmptyMatrix)(scilabEnv env)
25 {
26     scilabVar var = (scilabVar)types::Double::Empty();
27 #ifdef __API_SCILAB_SAFE__
28     if (var == nullptr)
29     {
30         scilab_setInternalError(env, L"createEmptyMatrix", _W("memory allocation error"));
31         return nullptr;
32     }
33 #endif
34     return var;
35 }
36
37 scilabVar API_PROTO(createDoubleMatrix)(scilabEnv env, int dim, const int* dims, int complex)
38 {
39 #ifdef __API_SCILAB_SAFE__
40     if (dims == nullptr)
41     {
42         scilab_setInternalError(env, L"createDoubleMatrix", _W("dims array cannot be NULL"));
43         return nullptr;
44     }
45
46     for (int i = 0; i < dim; ++i)
47     {
48         if (dims[i] < 0)
49         {
50             scilab_setInternalError(env, L"createDoubleMatrix", _W("dimensions cannot be negative"));
51             return nullptr;
52         }
53     }
54 #endif
55     types::Double* d = new types::Double(dim, dims, complex == 1);
56 #ifdef __API_SCILAB_SAFE__
57     if (d == nullptr)
58     {
59         scilab_setInternalError(env, L"createDoubleMatrix", _W("memory allocation error"));
60         return nullptr;
61     }
62 #endif
63     return (scilabVar)d;
64 }
65
66 scilabVar API_PROTO(createDoubleMatrix2d)(scilabEnv env, int row, int col, int complex)
67 {
68     int dims[2] = {row, col};
69 #ifdef __API_SCILAB_SAFE__
70     for (int i = 0; i < 2; ++i)
71     {
72         if (dims[i] < 0)
73         {
74             scilab_setInternalError(env, L"createDoubleMatrix2d", _W("dimensions cannot be negative"));
75             return nullptr;
76         }
77     }
78 #endif
79     types::Double* d = new types::Double(2, dims, complex == 1);
80 #ifdef __API_SCILAB_SAFE__
81     if (d == nullptr)
82     {
83         scilab_setInternalError(env, L"createDoubleMatrix2d", _W("memory allocation error"));
84         return nullptr;
85     }
86 #endif
87     return (scilabVar)d;
88 }
89
90 scilabVar API_PROTO(createDouble)(scilabEnv env, double val)
91 {
92     types::Double* d = new types::Double(val);
93 #ifdef __API_SCILAB_SAFE__
94     if (d == nullptr)
95     {
96         scilab_setInternalError(env, L"createDouble", _W("memory allocation error"));
97         return nullptr;
98     }
99 #endif
100     return (scilabVar)d;
101 }
102
103 scilabVar API_PROTO(createDoubleComplex)(scilabEnv env, double real, double img)
104 {
105     types::Double* d = new types::Double(real, img);
106 #ifdef __API_SCILAB_SAFE__
107     if (d == nullptr)
108     {
109         scilab_setInternalError(env, L"createDoubleComplex", _W("memory allocation error"));
110         return nullptr;
111     }
112 #endif
113     return (scilabVar)d;
114 }
115
116 scilabStatus API_PROTO(getDoubleArray)(scilabEnv env, scilabVar var, double** real)
117 {
118     types::Double* d = (types::Double*)var;
119 #ifdef __API_SCILAB_SAFE__
120     if (d->isDouble() == false)
121     {
122         scilab_setInternalError(env, L"getDoubleArray", _W("var must be a double variable"));
123         return STATUS_ERROR;
124     }
125 #endif
126     *real = d->get();
127     return STATUS_OK;
128 }
129
130 scilabStatus API_PROTO(getDoubleComplexArray)(scilabEnv env, scilabVar var, double** real, double** img)
131 {
132     types::Double* d = (types::Double*)var;
133 #ifdef __API_SCILAB_SAFE__
134     if (d->isDouble() == false || d->isComplex() == false)
135     {
136         scilab_setInternalError(env, L"getDoubleComplexArray", _W("var must be a double complex variable"));
137         return STATUS_ERROR;
138     }
139 #endif
140     *real = d->get();
141     *img = d->getImg();
142     return STATUS_OK;
143 }
144
145 scilabStatus API_PROTO(getDouble)(scilabEnv env, scilabVar var, double* real)
146 {
147     types::Double* d = (types::Double*)var;
148 #ifdef __API_SCILAB_SAFE__
149     if (d->isDouble() == false || d->isScalar() == false)
150     {
151         scilab_setInternalError(env, L"getDouble", _W("var must be a scalar double variable"));
152         return STATUS_ERROR;
153     }
154 #endif
155     *real = d->get()[0];
156     return STATUS_OK;
157 }
158
159 scilabStatus API_PROTO(getDoubleComplex)(scilabEnv env, scilabVar var, double* real, double* img)
160 {
161     types::Double* d = (types::Double*)var;
162 #ifdef __API_SCILAB_SAFE__
163     if (d->isDouble() == false || d->isScalar() == false || d->isComplex() == false)
164     {
165         scilab_setInternalError(env, L"getDoubleComplex", _W("var must be a scalar double complex variable"));
166         return STATUS_ERROR;
167     }
168 #endif
169     *real = d->get()[0];
170     *img = d->getImg()[0];
171     return STATUS_OK;
172 }
173
174 scilabStatus API_PROTO(setDoubleArray)(scilabEnv env, scilabVar var, const double* real)
175 {
176     types::Double* d = (types::Double*)var;
177 #ifdef __API_SCILAB_SAFE__
178     if (d->isDouble() == false)
179     {
180         scilab_setInternalError(env, L"setBooleanArray", _W("var must be a double variable"));
181         return STATUS_ERROR;
182     }
183 #endif
184     d->set(real);
185     return STATUS_OK;
186 }
187
188 scilabStatus API_PROTO(setDoubleComplexArray)(scilabEnv env, scilabVar var, const double* real, const double* img)
189 {
190     types::Double* d = (types::Double*)var;
191 #ifdef __API_SCILAB_SAFE__
192     if (d->isDouble() == false || d->isComplex() == false)
193     {
194         scilab_setInternalError(env, L"setDoubleComplexArray", _W("var must be a double complex variable"));
195         return STATUS_ERROR;
196     }
197 #endif
198     d->set(real);
199     d->setImg(img);
200     return STATUS_OK;
201 }
202
203 scilabStatus API_PROTO(setDouble)(scilabEnv env, scilabVar var, double real)
204 {
205     types::Double* d = (types::Double*)var;
206 #ifdef __API_SCILAB_SAFE__
207     if (d->isDouble() == false || d->isScalar() == false)
208     {
209         scilab_setInternalError(env, L"setDouble", _W("var must be a scalar double variable"));
210         return STATUS_ERROR;
211     }
212 #endif
213     d->get()[0] = real;
214     return STATUS_OK;
215 }
216
217 scilabStatus API_PROTO(setDoubleComplex)(scilabEnv env, scilabVar var, double real, double img)
218 {
219     types::Double* d = (types::Double*)var;
220 #ifdef __API_SCILAB_SAFE__
221     if (d->isDouble() == false || d->isScalar() == false || d->isComplex() == false)
222     {
223         scilab_setInternalError(env, L"setDoubleComplex", _W("var must be a scalar double complex variable"));
224         return STATUS_ERROR;
225     }
226 #endif
227     d->get()[0] = real;
228     d->getImg()[0] = img;
229     return STATUS_OK;
230 }
231