scilab/modules/ast/includes/types/sparse.hxx

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2010-2010 - DIGITEO - Bernard Hugueney
   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 #ifndef __SPARSE_HH__
  14 #define __SPARSE_HH__
  15
  16 //#include <Eigen/Sparse>
  17 #include <complex>
  18 #include "double.hxx"
  19 #include "bool.hxx"
  20 #include "keepForSparse.hxx"
  21
  22 #define SPARSE_CONST
  23
  24 namespace Eigen
  25 {
  26 template<typename _Scalar, int _Flags, typename _Index>  class SparseMatrix;
  27 }
  28
  29 namespace types
  30 {
  31 /* Utility function to create a new var on the heap from another type
  32  */
  33 template<typename Dest, typename Arg>
  34 Dest* create_new(Arg const&);
  35
  36 struct SparseBool;
  37
  38 /**
  39    Sparse is a wrapper over Eigen sparse matrices templates for either double or std::complex<double> values.
  40  */
  41 struct EXTERN_AST Sparse : GenericType
  42 {
  43     virtual ~Sparse();
  44     /* @param src: Double matrix to copy into a new sparse matrix
  45     **/
  46     Sparse(Double SPARSE_CONST& src);
  47     /* @param src : Double matrix to copy into a new sparse matrix
  48        @param idx : Double matrix to use as indexes to get values from the src
  49     **/
  50     Sparse(Double SPARSE_CONST& src, Double SPARSE_CONST& idx);
  51     /* @param src : Double matrix to copy into a new sparse matrix
  52        @param idx : Double matrix to use as indexes to get values from the src
  53        @param dims : Double matrix containing the dimensions of the new matrix
  54     **/
  55     Sparse(Double SPARSE_CONST& src, Double SPARSE_CONST& idx, Double SPARSE_CONST& dims);
  56     /*
  57       @param rows : nb of rows of the new matrix
  58       @param rows : nb of columns of the new matrix
  59       @param cplx : if the new matrix contains complex numbers
  60     **/
  61     Sparse(int rows, int cols, bool cplx = false);
  62     Sparse(Sparse const& o);
  63     /* cf. adj2sp()
  64       @param xadj : adjacency matrix for the new matrix
  65       @param adjncy : adjacency matrix (row indexes) for the new matrix
  66       @param src : data for the new matrix
  67       @param r : nb of rows for the new matrix
  68       @param c : nb of columns for the new matrix
  69     **/
  70     Sparse(Double SPARSE_CONST& xadj, Double SPARSE_CONST& adjncy, Double SPARSE_CONST& src, std::size_t r, std::size_t c);
  71
  72     //constructor to create a sparse from value extract to another ( save / load operation typically)
  73     Sparse(int rows, int cols, int nonzeros, int* inner, int* outer, double* real, double* img);
  74
  75     bool isSparse()
  76     {
  77         return true;
  78     }
  79     void finalize();
  80
  81     /*data management member function defined for compatibility with the Double API*/
  82     bool set(int _iRows, int _iCols, double _dblReal, bool _bFinalize = true);
  83     bool set(int _iIndex, double _dblReal, bool _bFinalize = true)
  84     {
  85         return set(_iIndex % m_iRows, _iIndex / m_iRows, _dblReal, _bFinalize);
  86     }
  87
  88     bool set(int _iRows, int _iCols, std::complex<double> v, bool _bFinalize = true);
  89     bool set(int _iIndex, std::complex<double> v, bool _bFinalize = true)
  90     {
  91         return set(_iIndex % m_iRows, _iIndex / m_iRows, v, _bFinalize);
  92     }
  93     /*
  94       set non zero values to 1.
  95     **/
  96     bool one_set();
  97     /* get real value at coords (r,c)
  98     **/
  99     double getReal(int r, int c) const;
 100     double getReal(int _iIndex) const
 101     {
 102         return getReal(_iIndex % m_iRows, _iIndex / m_iRows);
 103     }
 104
 105     double* get();
 106     double get(int r, int c) const;
 107     double get(int _iIndex) const
 108     {
 109         return get(_iIndex % m_iRows, _iIndex / m_iRows);
 110     }
 111
 112     std::complex<double>* getImg();
 113     std::complex<double> getImg(int r, int c) const;
 114     std::complex<double> getImg(int _iIndex) const
 115     {
 116         return getImg(_iIndex % m_iRows, _iIndex / m_iRows);
 117     }
 118
 119     /* return true if matrix contains complex numbers, false otherwise.
 120     **/
 121     bool isComplex() const;
 122     // overload of GenericType methode.
 123     bool isComplex()
 124     {
 125         // force const to call isComplex const method.
 126         const Sparse* sp = this;
 127         return sp->isComplex();
 128     }
 129
 130     inline bool isScalar()
 131     {
 132         return (getRows() == 1 && getCols() == 1);
 133     }
 134     /* clear all the values of the matrix to 0. (or 0.+0.i if complex)
 135     **/
 136     bool zero_set();
 137
 138     /*
 139       Config management and GenericType methods overrides
 140     */
 141     void whoAmI() SPARSE_CONST;
 142     bool isExtract() const;
 143     Sparse* clone(void) const;
 144     Sparse* clone(void)
 145     {
 146         return const_cast<Sparse const*>(this)->clone();
 147     }
 148     bool toString(std::wostringstream& ostr) const;
 149     bool toString(std::wostringstream& ostr)
 150     {
 151         return const_cast<Sparse const*>(this)->toString(ostr);
 152     }
 153
 154     /* post condition: dimensions are at least _iNewRows, _iNewCols
 155        preserving existing data.
 156        If dimensions where already >=, this is a no-op.
 157
 158        @param _iNewRows new minimum nb of rows
 159        @param _iNewCols new minimum nb of cols
 160        @return true upon succes, false otherwise.
 161      */
 162     bool resize(int _iNewRows, int _iNewCols);
 163     /* post condition: new total size must be equal to the old size.
 164                        Two dimensions maximum.
 165
 166        @param _iNewRows new nb of rows
 167        @param _iNewCols new nb of cols
 168        @param _piNewDims new nb of dimension
 169        @param _iNewDims new size for each dimension
 170        @return true upon succes, false otherwise.
 171     */
 172     bool reshape(int* _piNewDims, int _iNewDims);
 173     bool reshape(int _iNewRows, int _iNewCols);
 174     /*
 175       insert _iSeqCount elements from _poSource at coords given by _piSeqCoord (max in _piMaxDim).
 176       coords are considered 1D if _bAsVector, 2D otherwise.
 177       @param _iSeqCount nb of elts to insert
 178       @param _piSeqCoord dest coords
 179       @param _poSource src
 180       @param  _bAsVector if _piSeqCoord contains 1D coords.
 181      */
 182     Sparse* insert(typed_list* _pArgs, InternalType* _pSource);
 183     Sparse* insert(typed_list* _pArgs, Sparse* _pSource);
 184
 185     Sparse* remove(typed_list* _pArgs);
 186
 187     static InternalType* insertNew(typed_list* _pArgs, InternalType* _pSource);
 188
 189     /* append _poSource from coords _iRows, _iCols
 190        @param _iRows row to append from
 191        @param _iCols col to append from
 192        @param _poSource src data to append
 193      */
 194     bool append(int r, int c, types::Sparse SPARSE_CONST* src);
 195
 196     /*
 197       extract a submatrix
 198       @param _iSeqCount nb of elts to extract
 199       @param _piSeqCoord src coords
 200       @param _piMaxDim max coords
 201       @param _piDimSize size of the extracted matrix
 202       @param  _bAsVector if _piSeqCoord contains 1D coords.
 203
 204      */
 205     InternalType* extract(typed_list* _pArgs);
 206
 207     virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, ast::ConstVisitor & /*execFunc*/, const ast::Exp & e)
 208     {
 209         if (in.size() == 0)
 210         {
 211             out.push_back(this);
 212         }
 213         else
 214         {
 215             InternalType * _out = extract(&in);
 216             if (!_out)
 217             {
 218                 std::wostringstream os;
 219                 os << _W("Invalid index.\n");
 220                 throw ast::ScilabError(os.str(), 999, e.getLocation());
 221             }
 222             out.push_back(_out);
 223         }
 224
 225         return true;
 226     }
 227
 228     virtual bool isInvokable() const
 229     {
 230         return true;
 231     }
 232
 233     virtual bool hasInvokeOption() const
 234     {
 235         return false;
 236     }
 237
 238     virtual int getInvokeNbIn()
 239     {
 240         return -1;
 241     }
 242
 243     virtual int getInvokeNbOut()
 244     {
 245         return 1;
 246     }
 247
 248     Sparse* extract(int _iSeqCount, int* _piSeqCoord, int* _piMaxDim, int* _piDimSize, bool _bAsVector) SPARSE_CONST;
 249
 250     /*
 251        change the sign (inplace).
 252      */
 253     void opposite();
 254
 255     /*
 256       compares with an other value for equality (same nb of elts, with same values)
 257       TODO: should it handle other types ?
 258      */
 259     bool operator==(const InternalType& it) SPARSE_CONST;
 260     /*
 261       compares with an other value for inequality (same nb of elts, with same values)
 262       TODO: should it handle other types ?
 263      */
 264     bool operator!=(const InternalType& it) SPARSE_CONST
 265     {
 266         return !(*this == it);
 267     }
 268
 269
 270     /* return type as string ( double, int, cell, list, ... )*/
 271     virtual std::wstring         getTypeStr() SPARSE_CONST {return std::wstring(L"sparse");}
 272     /* return type as short string ( s, i, ce, l, ... ), as in overloading macros*/
 273     virtual std::wstring         getShortTypeStr() SPARSE_CONST {return std::wstring(L"sp");}
 274
 275     /* create a new sparse matrix containing the result of an addition
 276        @param o other matrix to add
 277        @return ptr to the new matrix, 0 in case of failure
 278      */
 279     Sparse* add(Sparse const& o) const;
 280
 281     /* create a new sparse matrix containing the result of an addition
 282        @param d scalar to add
 283        @return ptr to the new matrix, 0 in case of failure
 284      */
 285     Double* add(double d) const;
 286
 287     /* create a new sparse matrix containing the result of an addition
 288        @param c complex  to add
 289        @return ptr to the new matrix, 0 in case of failure
 290      */
 291     Double* add(std::complex<double> c) const;
 292
 293
 294
 295
 296     /* create a new sparse matrix containing the result of a substraction
 297        @param o other matrix to substract
 298        @return ptr to the new matrix, 0 in case of failure
 299      */
 300     Sparse* substract(Sparse const& o) const;
 301
 302     /* create a new sparse matrix containing the result of an subtraction
 303        @param d scalar to subtract
 304        @return ptr to the new matrix, 0 in case of failure
 305      */
 306     Double* substract(double d) const;
 307
 308     /* create a new sparse matrix containing the result of an subtraction
 309        @param c scalar to subtract
 310        @return ptr to the new matrix, 0 in case of failure
 311      */
 312     Double* substract(std::complex<double> c) const;
 313
 314
 315     /* create a new sparse matrix containing the result of a multiplication
 316        @param o other matrix to substract
 317        @return ptr to the new matrix, 0 in case of failure
 318      */
 319     Sparse* multiply(Sparse const& o) const;
 320
 321     /* create a new sparse matrix containing the result of an multiplication
 322        @param s scalar to multiply by
 323        @return ptr to the new matrix, 0 in case of failure
 324      */
 325     Sparse* multiply(double s) const;
 326
 327     /* create a new sparse matrix containing the result of an multiplication
 328        @param c scalar to subtract
 329        @return ptr to the new matrix, 0 in case of failure
 330      */
 331     Sparse* multiply(std::complex<double> c) const;
 332
 333     /* create a new matrix containing the result of an .*
 334        @param o sparse matrix to .*
 335        @return ptr to the new matrix, 0 in case of failure
 336      */
 337     Sparse* dotMultiply(Sparse SPARSE_CONST& o) const;
 338
 339     /* create a new matrix containing the result of an ./
 340       @param o sparse matrix to ./
 341       @return ptr to the new matrix, 0 in case of failure
 342     */
 343     Sparse* dotDivide(Sparse SPARSE_CONST& o) const;
 344
 345     bool neg(InternalType *& out);
 346
 347     bool transpose(InternalType *& out);
 348     bool adjoint(InternalType *& out);
 349     int newCholLLT(Sparse** permut, Sparse** factor) const;
 350
 351     /** create a new sparse matrix containing the non zero values set to 1.
 352        equivalent but faster than calling one_set() on a new copy of the
 353        current matrix.
 354        @return ptr to the new matrix, 0 in case of failure
 355      */
 356     Sparse* newOnes() const;
 357
 358     Sparse* newReal() const;
 359     /** @return the nb of non zero values.
 360      */
 361     std::size_t nonZeros() const;
 362
 363     /* @param i row of the current sparse matrix
 364        @return the nb of non zero values in row i
 365      */
 366     std::size_t nonZeros(std::size_t i) const;
 367
 368     int* getNbItemByRow(int* _piNbItemByRows);
 369     int* getColPos(int* _piColPos);
 370     int* getInnerPtr(int* count);
 371     int* getOuterPtr(int* count);
 372
 373
 374     /**
 375        "in-place" cast into a sparse matrix of comlpex values
 376      */
 377     void toComplex();
 378
 379     /* coefficient wise relational operator < between *this sparse matrix and an other.
 380        Matrices must have the same dimensions except if one of them is of size (1,1)
 381        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 382
 383        @param o other sparse matrix
 384
 385        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 386         '<' between the elements of *this and those of o.
 387      */
 388     SparseBool* newLessThan(Sparse const&o) const;
 389
 390     /* coefficient wise relational operator > between *this sparse matrix and an other.
 391        Matrices must have the same dimensions except if one of them is of size (1,1)
 392        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 393
 394        @param o other sparse matrix
 395
 396        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 397         '>' between the elements of *this and those of o.
 398      */
 399     SparseBool* newGreaterThan(Sparse const&o) const;
 400
 401     /* coefficient wise relational operator != between *this sparse matrix and an other.
 402        Matrices must have the same dimensions except if one of them is of size (1,1)
 403        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 404
 405        @param o other sparse matrix
 406
 407        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 408         '!=' between the elements of *this and those of o.
 409      */
 410     SparseBool* newNotEqualTo(Sparse const&o) const;
 411
 412     /* coefficient wise relational operator <= between *this sparse matrix and an other.
 413        Matrices must have the same dimensions except if one of them is of size (1,1)
 414        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 415
 416        Do not use this function is possible as the result will be dense because
 417        0. <= 0. is true, hence the result matrix will hold a non default value (i.e. true)
 418        for each pair of default values (0.) of the sparse arguments !
 419
 420        @param o other sparse matrix
 421
 422        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 423         '<=' between the elements of *this and those of o.
 424      */
 425     SparseBool* newLessOrEqual(Sparse const&o) const;
 426
 427     /* coefficient wise relational operator >= between *this sparse matrix and an other.
 428        Matrices must have the same dimensions except if one of them is of size (1,1)
 429        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 430
 431        Do not use this function is possible as the result will be dense because
 432        0. >= 0. is true, hence the result matrix will hold a non default value (i.e. true)
 433        for each pair of default values (0.) of the sparse arguments !
 434
 435        @param o other sparse matrix
 436
 437        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 438         '>=' between the elements of *this and those of o.
 439      */
 440     SparseBool* newGreaterOrEqual(Sparse const&o) const;
 441
 442     /* coefficient wise relational operator == between *this sparse matrix and an other.
 443        Matrices must have the same dimensions except if one of them is of size (1,1)
 444        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 445
 446        Do not use this function is possible as the result will be dense because
 447        0. == 0. is true, hence the result matrix will hold a non default value (i.e. true)
 448        for each pair of default values (0.) of the sparse arguments !
 449
 450        @param o other sparse matrix
 451
 452        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 453         '==' between the elements of *this and those of o.
 454      */
 455     SparseBool* newEqualTo(Sparse const&o) const;
 456
 457     /**
 458        output 1-base column numbers of the non zero elements
 459        @param out : ptr used as an output iterator over double values
 460        @return past-the-end output iterator after ouput is done
 461      */
 462     double* outputCols(double* out) const;
 463
 464     /**
 465        output real and imaginary values of the non zero elements
 466        @param outReal : ptr used as an output iterator over double values for real values
 467        @param outImag : ptr used as an output iterator over double values for imaginary values if any
 468        @return pair of past-the-end output iterators after ouput is done
 469      */
 470     std::pair<double*, double*> outputValues(double* outReal, double* outImag)const;
 471
 472     /**
 473        ouput rows and afterwards columns of the non zero elements
 474        @param out : ptr used as an output iterator over double values
 475        @return past-the-end output iterators after ouput is done
 476      */
 477     int* outputRowCol(int* out)const;
 478
 479     /**
 480        @param dest Double to be filled with values from the current sparse matrix.
 481      */
 482     void fill(Double& dest, int r = 0, int c = 0) SPARSE_CONST;
 483
 484
 485     inline ScilabType  getType(void) SPARSE_CONST
 486     {
 487         return ScilabSparse;
 488     }
 489
 490     inline ScilabId    getId(void) SPARSE_CONST
 491     {
 492         if (isComplex())
 493         {
 494             return IdSparseComplex;
 495         }
 496         return IdSparse;
 497     }
 498
 499
 500
 501     SparseBool* newLesserThan(Sparse const&o);
 502
 503     typedef Eigen::SparseMatrix<double, 0x1, int>                   RealSparse_t;
 504     typedef Eigen::SparseMatrix<std::complex<double>, 0x1, int>     CplxSparse_t;
 505     /**
 506        One and only one of the args should be 0.
 507        @param realSp ptr to an Eigen sparse matrix of double values
 508        @param cplxSp ptr to an Eigen sparse matrix of std::complex<double> elements
 509      */
 510     Sparse(RealSparse_t* realSp, CplxSparse_t* cplxSp);
 511
 512     RealSparse_t* matrixReal;
 513     CplxSparse_t* matrixCplx;
 514
 515 protected :
 516 private :
 517
 518     /** utility function used by constructors
 519         @param rows : nb of rows
 520         @param cols : nb of columns
 521         @param src : Double matrix data source
 522         @param : iterator (cf MatrixIterator.hxx) with indices
 523         @param n : nb of elements to copy from data source.
 524      */
 525     template<typename DestIter>
 526     void create(int rows, int cols, Double SPARSE_CONST& src, DestIter o, std::size_t n);
 527     void create2(int rows, int cols, Double SPARSE_CONST& src, Double SPARSE_CONST& idx);
 528
 529     /** utility function used by insert functions conceptually : sp[destTrav]= src[srcTrav]
 530         @param src : data source
 531         @param SrcTrav : iterator over the data source
 532         @param n : nb of elements to copy
 533         @param sp : sparse destination matrix
 534         @param destTrav : iterator over the data sink (i.e. sp)
 535      */
 536     template<typename Src, typename SrcTraversal, typename Sz, typename DestTraversal>
 537     static bool copyToSparse(Src SPARSE_CONST& src, SrcTraversal srcTrav, Sz n, Sparse& sp, DestTraversal destTrav);
 538 };
 539
 540 template<typename T>
 541 void neg(const int r, const int c, const T * const in, Eigen::SparseMatrix<bool, 1, int> * const out);
 542
 543
 544 /*
 545   Implement sparse boolean matrix
 546  */
 547 struct EXTERN_AST SparseBool : GenericType
 548 {
 549     virtual ~SparseBool();
 550     /* @param src: Bool matrix to copy into a new sparse matrix
 551     **/
 552     SparseBool(Bool SPARSE_CONST& src);
 553     /* @param src : Bool matrix to copy into a new sparse matrix
 554        @param idx : Double matrix to use as indexes to get values from the src
 555     **/
 556     SparseBool(Bool SPARSE_CONST& src, Double SPARSE_CONST& idx);
 557     /* @param src : Bool matrix to copy into a new sparse matrix
 558        @param idx : Double matrix to use as indexes to get values from the src
 559        @param dims : Double matrix containing the dimensions of the new matrix
 560     **/
 561     SparseBool(Bool SPARSE_CONST& src, Double SPARSE_CONST& idx, Double SPARSE_CONST& dims);
 562     /*
 563        @param rows : nb of rows of the new matrix
 564        @param rows : nb of columns of the new matrix
 565     */
 566     SparseBool(int rows, int cols);
 567
 568     SparseBool(SparseBool const& o);
 569
 570     //constructor to create a sparse from value extract to another ( save / load operation typically)
 571     SparseBool(int rows, int cols, int trues, int* inner, int* outer);
 572
 573     bool isSparseBool()
 574     {
 575         return true;
 576     }
 577     void finalize();
 578
 579     bool toString(std::wostringstream& ostr) const;
 580     bool toString(std::wostringstream& ostr)
 581     {
 582         return const_cast<SparseBool const*>(this)->toString(ostr);
 583     }
 584
 585     /* Config management and GenericType methods overrides */
 586     SparseBool* clone(void) const;
 587     SparseBool* clone(void)
 588     {
 589         return const_cast<SparseBool const*>(this)->clone();
 590     }
 591     bool resize(int _iNewRows, int _iNewCols);
 592
 593     bool reshape(int* _piNewDims, int _iNewDims);
 594     bool reshape(int _iNewRows, int _iNewCols);
 595
 596     SparseBool* insert(typed_list* _pArgs, InternalType* _pSource);
 597     SparseBool* insert(typed_list* _pArgs, SparseBool* _pSource);
 598     SparseBool* remove(typed_list* _pArgs);
 599
 600     bool append(int _iRows, int _iCols, SparseBool SPARSE_CONST* _poSource);
 601
 602     static InternalType* insertNew(typed_list* _pArgs, InternalType* _pSource);
 603     SparseBool* extract(int _iSeqCount, int* _piSeqCoord, int* _piMaxDim, int* _piDimSize, bool _bAsVector) SPARSE_CONST;
 604     InternalType* extract(typed_list* _pArgs);
 605
 606     virtual bool invoke(typed_list & in, optional_list &/*opt*/, int /*_iRetCount*/, typed_list & out, ast::ConstVisitor & /*execFunc*/, const ast::Exp & e)
 607     {
 608         if (in.size() == 0)
 609         {
 610             out.push_back(this);
 611         }
 612         else
 613         {
 614             InternalType * _out = extract(&in);
 615             if (!_out)
 616             {
 617                 std::wostringstream os;
 618                 os << _W("Invalid index.\n");
 619                 throw ast::ScilabError(os.str(), 999, e.getLocation());
 620             }
 621             out.push_back(_out);
 622         }
 623
 624         return true;
 625     }
 626
 627     virtual bool isInvokable() const
 628     {
 629         return true;
 630     }
 631
 632     virtual bool hasInvokeOption() const
 633     {
 634         return false;
 635     }
 636
 637     virtual int getInvokeNbIn()
 638     {
 639         return -1;
 640     }
 641
 642     virtual int getInvokeNbOut()
 643     {
 644         return 1;
 645     }
 646
 647     bool transpose(InternalType *& out);
 648
 649     /** @return the nb of non zero values.
 650      */
 651     std::size_t nbTrue() const;
 652     /* @param i row of the current sparse matrix
 653        @return the nb of non zero values in row i
 654      */
 655     std::size_t nbTrue(std::size_t i) const;
 656
 657     void setTrue(bool finalize = true);
 658     void setFalse(bool finalize = true);
 659
 660     int* getNbItemByRow(int* _piNbItemByRows);
 661     int* getColPos(int* _piColPos);
 662     int* getInnerPtr(int* count);
 663     int* getOuterPtr(int* count);
 664     /**
 665        output 1-base column numbers of the non zero elements
 666        @param out : ptr used as an output iterator over double values
 667        @return past-the-end output iterator after ouput is done
 668      */
 669
 670     int* outputRowCol(int* out)const;
 671
 672     bool operator==(const InternalType& it) SPARSE_CONST;
 673     bool operator!=(const InternalType& it) SPARSE_CONST;
 674
 675     /* return type as string ( double, int, cell, list, ... )*/
 676     virtual std::wstring getTypeStr() SPARSE_CONST {return std::wstring(L"boolean sparse");}
 677     /* return type as short string ( s, i, ce, l, ... )*/
 678     virtual std::wstring getShortTypeStr() SPARSE_CONST {return std::wstring(L"spb");}
 679
 680     inline ScilabType getType(void) SPARSE_CONST
 681     {
 682         return ScilabSparseBool;
 683     }
 684
 685     inline ScilabId getId(void) SPARSE_CONST
 686     {
 687         return IdSparseBool;
 688     }
 689
 690     inline bool isScalar()
 691     {
 692         return (getRows() == 1 && getCols() == 1);
 693     }
 694
 695     bool isTrue()
 696     {
 697         if (nbTrue() == m_iSize)
 698         {
 699             return true;
 700         }
 701         return false;
 702     }
 703
 704     bool neg(InternalType *& out)
 705     {
 706         SparseBool * _out = new SparseBool(getRows(), getCols());
 707         types::neg(getRows(), getCols(), matrixBool, _out->matrixBool);
 708         _out->finalize();
 709         out = _out;
 710         return true;
 711     }
 712
 713     void whoAmI() SPARSE_CONST;
 714
 715     bool* get();
 716     bool get(int r, int c) SPARSE_CONST;
 717     bool get(int _iIndex) SPARSE_CONST
 718     {
 719         return get(_iIndex % m_iRows, _iIndex / m_iRows);
 720     }
 721
 722     bool set(int r, int c, bool b, bool _bFinalize = true) SPARSE_CONST;
 723     bool set(int _iIndex, bool b, bool _bFinalize = true) SPARSE_CONST
 724     {
 725         return set(_iIndex % m_iRows, _iIndex / m_iRows, b, _bFinalize);
 726     }
 727
 728     void fill(Bool& dest, int r = 0, int c = 0) SPARSE_CONST;
 729
 730     Sparse* newOnes() const;
 731     SparseBool* newNotEqualTo(SparseBool const&o) const;
 732     SparseBool* newEqualTo(SparseBool const&o) const;
 733
 734     SparseBool* newLogicalOr(SparseBool const&o) const;
 735     SparseBool* newLogicalAnd(SparseBool const&o) const;
 736
 737     typedef Eigen::SparseMatrix<bool, 0x1, int> BoolSparse_t;
 738     SparseBool(BoolSparse_t* o);
 739     BoolSparse_t* matrixBool;
 740
 741 private:
 742     void create2(int rows, int cols, Bool SPARSE_CONST& src, Double SPARSE_CONST& idx);
 743 };
 744
 745 template<typename T>
 746 struct SparseTraits
 747 {
 748     typedef types::Sparse type;
 749 };
 750 template<>
 751 struct SparseTraits<types::Bool>
 752 {
 753     typedef types::SparseBool type;
 754 };
 755 template<>
 756 struct SparseTraits<types::SparseBool>
 757 {
 758     typedef types::SparseBool type;
 759 };
 760
 761 }
 762
 763 #endif /* !__SPARSE_HH__ */