Replace Min, Max and Abs by std::min, std::max and std::abs
[scilab.git] / scilab / modules / interpolation / sci_gateway / cpp / sci_bsplin3val.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
4 *
5 * This file must be used under the terms of the CeCILL.
6 * This source file is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution.  The terms
8 * are also available at
9 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12 /*--------------------------------------------------------------------------*/
13 #include "interpolation_gw.hxx"
14 #include "function.hxx"
15 #include "double.hxx"
16 #include "string.hxx"
17 #include "tlist.hxx"
18
19 extern "C"
20 {
21 #include "localization.h"
22 #include "Scierror.h"
23 #include "interpolation_functions.h"
24 }
25 /*--------------------------------------------------------------------------*/
26
27 types::Function::ReturnValue sci_bsplin3val(types::typed_list &in, int _iRetCount, types::typed_list &out)
28 {
29     // input
30     types::Double* pDblXYZ[3]       = {NULL, NULL, NULL};
31     types::Double* pDblDer          = NULL;
32     types::TList*  pTList           = NULL;
33     types::Double* pDblX            = NULL;
34     types::Double* pDblY            = NULL;
35     types::Double* pDblZ            = NULL;
36     types::Double* pDblOrder        = NULL;
37     types::Double* pDblCoef         = NULL;
38     types::Double* pDblXyzminmax    = NULL;
39
40     // output
41     types::Double* pDblDfp = NULL;
42
43     // *** check the minimal number of input args. ***
44     if (in.size() != 5)
45     {
46         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "bsplin3val", 5);
47         return types::Function::Error;
48     }
49
50     // *** check number of output args according the methode. ***
51     if (_iRetCount > 1)
52     {
53         Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "bsplin3val", 1);
54         return types::Function::Error;
55     }
56
57     // *** check type of input args and get it. ***
58     // xp yp zp
59     for (int i = 0; i < 3; i++)
60     {
61         if (in[i]->isDouble() == false)
62         {
63             Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bsplin3val", i + 1);
64             return types::Function::Error;
65         }
66
67         pDblXYZ[i] = in[i]->getAs<types::Double>();
68
69         if (pDblXYZ[i]->isComplex())
70         {
71             Scierror(999, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "bsplin3val", i + 1);
72             return types::Function::Error;
73         }
74
75         if (pDblXYZ[0]->getRows() != pDblXYZ[i]->getRows() || pDblXYZ[0]->getCols() != pDblXYZ[i]->getCols())
76         {
77             Scierror(999, _("%s: Wrong size for input argument #%d : Same size as argument %d expected.\n"), "bsplin3val", i + 1, 1);
78             return types::Function::Error;
79         }
80     }
81
82
83     if (in[3]->isTList() == false)
84     {
85         Scierror(999, _("%s: Wrong type for input argument #%d : A tlist of type bsplin3val expected.\n"), "bsplin3val", 4);
86     }
87
88     pTList = in[3]->getAs<types::TList>();
89
90     if (pTList->getTypeStr() != L"tensbs3d")
91     {
92         Scierror(999, _("%s: Wrong type for input argument #%d: A %s tlist expected.\n"), "bsplin3val", 4, "tensbs3d");
93         return types::Function::Error;
94     }
95
96     pDblX = pTList->getField(L"tx")->getAs<types::Double>();
97     pDblY = pTList->getField(L"ty")->getAs<types::Double>();
98     pDblZ = pTList->getField(L"tz")->getAs<types::Double>();
99     pDblOrder = pTList->getField(L"order")->getAs<types::Double>();
100     pDblCoef = pTList->getField(L"bcoef")->getAs<types::Double>();
101     pDblXyzminmax = pTList->getField(L"xyzminmax")->getAs<types::Double>();
102
103     if (in[4]->isDouble() == false)
104     {
105         Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "bsplin3val", 5);
106         return types::Function::Error;
107     }
108
109     pDblDer = in[4]->getAs<types::Double>();
110
111     if (pDblDer->getSize() != 3)
112     {
113         Scierror(999, _("%s: Wrong size for input argument #%d : A vector of size 3 expected.\n"), "bsplin3val", 5);
114         return types::Function::Error;
115     }
116
117     if (    pDblDer->get(0) != floor(pDblDer->get(0)) || pDblDer->get(0) < 0.0
118             || pDblDer->get(1) != floor(pDblDer->get(1)) || pDblDer->get(1) < 0.0
119             || pDblDer->get(2) != floor(pDblDer->get(2)) || pDblDer->get(2) < 0.0)
120     {
121         Scierror(999, _("%s: Wrong values for input argument #%d : A real positiv integer vector expected.\n"), "bsplin3val", 5);
122         return types::Function::Error;
123     }
124
125     // *** Perform operation. ***
126     pDblDfp = new types::Double(pDblXYZ[0]->getRows(), pDblXYZ[0]->getCols());
127
128     int der[3];
129     der[0] = static_cast<int>(pDblDer->get(0));
130     der[1] = static_cast<int>(pDblDer->get(1));
131     der[2] = static_cast<int>(pDblDer->get(2));
132
133     int order[3];
134     order[0] = static_cast<int>(pDblOrder->get(0));
135     order[1] = static_cast<int>(pDblOrder->get(1));
136     order[2] = static_cast<int>(pDblOrder->get(2));
137
138     int sizeOfX = pDblX->getRows() - order[0];
139     int sizeOfY = pDblY->getRows() - order[1];
140     int sizeOfZ = pDblZ->getRows() - order[2];
141
142     double* minmax = pDblXyzminmax->get();
143
144     int workSize = order[1] * order[2] + 3 * std::max(order[0], std::max(order[1], order[2])) + order[2];
145     double* work = new double[workSize];
146
147     for (int i = 0; i < pDblXYZ[0]->getSize(); i++)
148     {
149         double ret = C2F(db3val)(pDblXYZ[0]->get() + i, pDblXYZ[1]->get() + i, pDblXYZ[2]->get() + i,
150                                  &der[0], &der[1], &der[2], pDblX->get(), pDblY->get(), pDblZ->get(),
151                                  &sizeOfX, &sizeOfY, &sizeOfZ, &order[0], &order[1], &order[2], pDblCoef->get(), work);
152         pDblDfp->set(i, ret);
153     }
154
155     delete[] work;
156
157     // *** Return result in Scilab. ***
158     out.push_back(pDblDfp);
159
160     return types::Function::OK;
161 }
162