scilab/modules/boolean/sci_gateway/cpp/sci_bool2s.cpp

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 * Copyright (C) 2011 - DIGITEO - Antoine ELIAS
   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
  14 #include "boolean_gw.hxx"
  15 #include "function.hxx"
  16 #include "double.hxx"
  17 #include "sparse.hxx"
  18 #include "bool.hxx"
  19 #include "overload.hxx"
  20
  21 extern "C"
  22 {
  23 #include "localization.h"
  24 #include "Scierror.h"
  25 }
  26 /*--------------------------------------------------------------------------*/
  27
  28 types::Function::ReturnValue sci_bool2s(types::typed_list &in, int _iRetCount, types::typed_list &out)
  29 {
  30     types::InternalType* pOut = NULL;
  31     if (in.size() != 1)
  32     {
  33         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "bool2s", 1);
  34         return types::Function::Error;
  35     }
  36
  37     if (in[0]->isDouble())
  38     {
  39         types::Double* pIn = in[0]->getAs<types::Double>();
  40
  41         if (pIn->isComplex())
  42         {
  43             std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_bool2s";
  44             return Overload::call(wstFuncName, in, _iRetCount, out);
  45         }
  46
  47         types::Double* pD = new types::Double(pIn->getDims(), pIn->getDimsArray());
  48
  49         double* pdblIn  = pIn->get();
  50         double* pdblOut = pD->get();
  51
  52         for (int i = 0 ; i < pIn->getSize() ; i++)
  53         {
  54             pdblOut[i] = static_cast<double>(pdblIn[i] != 0);
  55         }
  56         pOut = pD;
  57     }
  58     else if (in[0]->isBool())
  59     {
  60         types::Bool* pIn = in[0]->getAs<types::Bool>();
  61         types::Double* pD = new types::Double(pIn->getDims(), pIn->getDimsArray());
  62
  63         int* piIn = pIn->get();
  64         double* pdblOut = pD->get();
  65
  66         for (int i = 0 ; i < pIn->getSize() ; i++)
  67         {
  68             pdblOut[i] = static_cast<double>(piIn[i]);
  69         }
  70         pOut = pD;
  71     }
  72     else if (in[0]->isSparse())
  73     {
  74         types::Sparse* pSpIn = in[0]->getAs<types::Sparse>();
  75
  76         if (pSpIn->isComplex())
  77         {
  78             std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_bool2s";
  79             return Overload::call(wstFuncName, in, _iRetCount, out);
  80         }
  81
  82         types::Sparse* pSpOut = new types::Sparse(pSpIn->getRows(), pSpIn->getCols());
  83
  84         int iNonZeros = static_cast<int>(pSpIn->nonZeros());
  85
  86         //coords
  87         int* pRows = new int[iNonZeros * 2];
  88         pSpIn->outputRowCol(pRows);
  89         int* pCols = pRows + iNonZeros;
  90
  91         //values
  92         double* pNonZeroR = new double[iNonZeros];
  93         double* pNonZeroI = new double[iNonZeros];
  94         pSpIn->outputValues(pNonZeroR, pNonZeroI);
  95
  96         for (int i = 0; i < iNonZeros; i++)
  97         {
  98             pSpOut->set(pRows[i] - 1, pCols[i] - 1, static_cast<double>(pNonZeroR[i] != 0));
  99         }
 100
 101         pOut = pSpOut;
 102     }
 103     else if (in[0]->isSparseBool())
 104     {
 105         types::SparseBool* pSpbIn = in[0]->getAs<types::SparseBool>();
 106         types::Sparse* pSpOut = new types::Sparse(pSpbIn ->getRows(), pSpbIn ->getCols());
 107
 108         int iNonZeros = static_cast<int>(pSpbIn->nbTrue());
 109
 110         //coords
 111         int* pRows = new int[iNonZeros * 2];
 112         pSpbIn->outputRowCol(pRows);
 113         int* pCols = pRows + iNonZeros;
 114
 115         for (int i = 0; i < iNonZeros; i++)
 116         {
 117             pSpOut->set(pRows[i] - 1, pCols[i] - 1, 1);
 118         }
 119
 120         pOut = pSpOut;
 121         delete[] pRows;
 122     }
 123     else
 124     {
 125         std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_bool2s";
 126         return Overload::call(wstFuncName, in, _iRetCount, out);
 127     }
 128
 129     out.push_back(pOut);
 130     return types::Function::OK;
 131 }
 132 /*--------------------------------------------------------------------------*/