elementary_functions module.
[scilab.git] / scilab / modules / elementary_functions / sci_gateway / cpp / sci_cos.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - 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 "elem_func_gw.hxx"
14 #include "function.hxx"
15 #include "double.hxx"
16 #include "overload.hxx"
17 #include "execvisitor.hxx"
18
19
20 extern "C"
21 {
22 #include "Scierror.h"
23 #include "localization.h"
24 #include "elem_common.h"
25 #include "cos.h"
26 }
27
28 /*--------------------------------------------------------------------------*/
29 types::Function::ReturnValue sci_cos(types::typed_list &in, int _iRetCount, types::typed_list &out)
30 {
31     types::Double* pDblIn   = NULL;
32     types::Double* pDblOut  = NULL;
33
34     if (in.size() != 1)
35     {
36         ScierrorW(77, _W("%ls: Wrong number of input argument(s): %d expected.\n"), L"cos", 1);
37         return types::Function::Error;
38     }
39
40     if (_iRetCount > 1)
41     {
42         ScierrorW(78, _W("%ls: Wrong number of output argument(s): %d expected.\n"), L"cos", 1);
43         return types::Function::Error;
44     }
45
46     if (in[0]->isDouble())
47     {
48         pDblIn = in[0]->getAs<types::Double>();
49         pDblOut = new types::Double(pDblIn->getDims(), pDblIn->getDimsArray(), pDblIn->isComplex());
50
51         if (pDblIn->isComplex())
52         {
53             for (int i = 0 ; i < pDblIn->getSize() ; i++)
54             {
55                 zcoss(pDblIn->get(i), pDblIn->getImg(i), pDblOut->get() + i, pDblOut->getImg() + i);
56             }
57         }
58         else
59         {
60             for (int i = 0 ; i < pDblIn->getSize() ; i++)
61             {
62                 pDblOut->set(i, dcoss(pDblIn->get(i)));
63             }
64         }
65
66         out.push_back(pDblOut);
67     }
68     else if (in[0]->isSparse())
69     {
70         types::Sparse* pSparseIn = in[0]->getAs<types::Sparse>();
71         types::Double* pDblOut = new types::Double(pSparseIn->getRows(), pSparseIn->getCols(), pSparseIn->isComplex());
72
73         int const nonZeros = static_cast<int>(pSparseIn->nonZeros());
74         double* pRows = new double[nonZeros * 2];
75         pSparseIn->outputRowCol(pRows);
76         double* pCols = pRows + nonZeros;
77
78         double* pNonZeroR = new double[nonZeros];
79         double* pNonZeroI = new double[nonZeros];
80         pSparseIn->outputValues(pNonZeroR, pNonZeroI);
81
82         int iSize = pSparseIn->getSize();
83         int iOne    = 1;
84         double dOne = 1;
85         int iZero   = 0;
86
87         C2F(dcopy)(&iSize, &dOne, &iZero, pDblOut->get(), &iOne);
88
89         if (pSparseIn->isComplex())
90         {
91             for (int i = 0 ; i < nonZeros ; i++)
92             {
93                 int iPos = (pCols[i] - 1) * pSparseIn->getRows() + (pRows[i] - 1);
94                 zcoss(pNonZeroR[i], pNonZeroI[i], pDblOut->get() + iPos, pDblOut->getImg() + iPos);
95             }
96         }
97         else
98         {
99             for (int i = 0 ; i < nonZeros ; i++)
100             {
101                 int iPos = (pCols[i] - 1) * pSparseIn->getRows() + (pRows[i] - 1);
102                 pDblOut->set(iPos, dcoss(pNonZeroR[i]));
103             }
104         }
105
106         delete[] pRows;
107         delete[] pNonZeroR;
108         delete[] pNonZeroI;
109
110         out.push_back(pDblOut);
111     }
112     else
113     {
114         std::wstring wstFuncName = L"%"  + in[0]->getShortTypeStr() + L"_cos";
115         return Overload::call(wstFuncName, in, _iRetCount, out, new ExecVisitor());
116     }
117
118     return types::Function::OK;
119 }
120 /*--------------------------------------------------------------------------*/