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 &o);
 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* newNotEqualTo(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        Do not use this function is possible as the result will be dense because
 406        0. <= 0. is true, hence the result matrix will hold a non default value (i.e. true)
 407        for each pair of default values (0.) of the sparse arguments !
 408
 409        @param o other sparse matrix
 410
 411        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 412         '<=' between the elements of *this and those of o.
 413      */
 414     SparseBool* newLessOrEqual(Sparse &o);
 415
 416     /* coefficient wise relational operator == between *this sparse matrix and an other.
 417        Matrices must have the same dimensions except if one of them is of size (1,1)
 418        (i.e. a scalar) : it is then treated as a constant matrix of thre required dimensions.
 419
 420        Do not use this function is possible as the result will be dense because
 421        0. == 0. is true, hence the result matrix will hold a non default value (i.e. true)
 422        for each pair of default values (0.) of the sparse arguments !
 423
 424        @param o other sparse matrix
 425
 426        @return ptr to a new Sparse matrix where each element is the result of the logical operator
 427         '==' between the elements of *this and those of o.
 428      */
 429     SparseBool* newEqualTo(Sparse &o);
 430
 431     /**
 432        output 1-base column numbers of the non zero elements
 433        @param out : ptr used as an output iterator over double values
 434        @return past-the-end output iterator after ouput is done
 435      */
 436     double* outputCols(double* out) const;
 437
 438     /**
 439        output real and imaginary values of the non zero elements
 440        @param outReal : ptr used as an output iterator over double values for real values
 441        @param outImag : ptr used as an output iterator over double values for imaginary values if any
 442        @return pair of past-the-end output iterators after ouput is done
 443      */
 444     std::pair<double*, double*> outputValues(double* outReal, double* outImag)const;
 445
 446     /**
 447        ouput rows and afterwards columns of the non zero elements
 448        @param out : ptr used as an output iterator over double values
 449        @return past-the-end output iterators after ouput is done
 450      */
 451     int* outputRowCol(int* out)const;
 452
 453     /**
 454        @param dest Double to be filled with values from the current sparse matrix.
 455      */
 456     void fill(Double& dest, int r = 0, int c = 0) SPARSE_CONST;
 457
 458
 459     inline ScilabType  getType(void) SPARSE_CONST
 460     {
 461         return ScilabSparse;
 462     }
 463
 464     inline ScilabId    getId(void) SPARSE_CONST
 465     {
 466         if (isComplex())
 467         {
 468             return IdSparseComplex;
 469         }
 470         return IdSparse;
 471     }
 472
 473
 474
 475     SparseBool* newLesserThan(Sparse const&o);
 476
 477     typedef Eigen::SparseMatrix<double, 0x1, int>                   RealSparse_t;
 478     typedef Eigen::SparseMatrix<std::complex<double>, 0x1, int>     CplxSparse_t;
 479     /**
 480        One and only one of the args should be 0.
 481        @param realSp ptr to an Eigen sparse matrix of double values
 482        @param cplxSp ptr to an Eigen sparse matrix of std::complex<double> elements
 483      */
 484     Sparse(RealSparse_t* realSp, CplxSparse_t* cplxSp);
 485
 486     RealSparse_t* matrixReal;
 487     CplxSparse_t* matrixCplx;
 488
 489 protected :
 490 private :
 491
 492     /** utility function used by constructors
 493         @param rows : nb of rows
 494         @param cols : nb of columns
 495         @param src : Double matrix data source
 496         @param : iterator (cf MatrixIterator.hxx) with indices
 497         @param n : nb of elements to copy from data source.
 498      */
 499     template<typename DestIter>
 500     void create(int rows, int cols, Double SPARSE_CONST& src, DestIter o, std::size_t n);
 501     void create2(int rows, int cols, Double SPARSE_CONST& src, Double SPARSE_CONST& idx);
 502
 503     /** utility function used by insert functions conceptually : sp[destTrav]= src[srcTrav]
 504         @param src : data source
 505         @param SrcTrav : iterator over the data source
 506         @param n : nb of elements to copy
 507         @param sp : sparse destination matrix
 508         @param destTrav : iterator over the data sink (i.e. sp)
 509      */
 510     template<typename Src, typename SrcTraversal, typename Sz, typename DestTraversal>
 511     static bool copyToSparse(Src SPARSE_CONST& src, SrcTraversal srcTrav, Sz n, Sparse& sp, DestTraversal destTrav);
 512 };
 513
 514 template<typename T>
 515 void neg(const int r, const int c, const T * const in, Eigen::SparseMatrix<bool, 1, int> * const out);
 516
 517
 518 /*
 519   Implement sparse boolean matrix
 520  */
 521 struct EXTERN_AST SparseBool : GenericType
 522 {
 523     virtual ~SparseBool();
 524     /* @param src: Bool matrix to copy into a new sparse matrix
 525     **/
 526     SparseBool(Bool SPARSE_CONST& src);
 527     /* @param src : Bool matrix to copy into a new sparse matrix
 528        @param idx : Double matrix to use as indexes to get values from the src
 529     **/
 530     SparseBool(Bool SPARSE_CONST& src, Double SPARSE_CONST& idx);
 531     /* @param src : Bool matrix to copy into a new sparse matrix
 532        @param idx : Double matrix to use as indexes to get values from the src
 533        @param dims : Double matrix containing the dimensions of the new matrix
 534     **/
 535     SparseBool(Bool SPARSE_CONST& src, Double SPARSE_CONST& idx, Double SPARSE_CONST& dims);
 536     /*
 537        @param rows : nb of rows of the new matrix
 538        @param rows : nb of columns of the new matrix
 539     */
 540     SparseBool(int rows, int cols);
 541
 542     SparseBool(SparseBool const& o);
 543
 544     //constructor to create a sparse from value extract to another ( save / load operation typically)
 545     SparseBool(int rows, int cols, int trues, int* inner, int* outer);
 546
 547     bool isSparseBool()
 548     {
 549         return true;
 550     }
 551     void finalize();
 552
 553     bool toString(std::wostringstream& ostr) const;
 554     bool toString(std::wostringstream& ostr)
 555     {
 556         return const_cast<SparseBool const*>(this)->toString(ostr);
 557     }
 558
 559     /* Config management and GenericType methods overrides */
 560     SparseBool* clone(void) const;
 561     SparseBool* clone(void)
 562     {
 563         return const_cast<SparseBool const*>(this)->clone();
 564     }
 565     bool resize(int _iNewRows, int _iNewCols);
 566
 567     bool reshape(int* _piNewDims, int _iNewDims);
 568     bool reshape(int _iNewRows, int _iNewCols);
 569
 570     SparseBool* insert(typed_list* _pArgs, InternalType* _pSource);
 571     SparseBool* insert(typed_list* _pArgs, SparseBool* _pSource);
 572     SparseBool* remove(typed_list* _pArgs);
 573
 574     bool append(int _iRows, int _iCols, SparseBool SPARSE_CONST* _poSource);
 575
 576     static InternalType* insertNew(typed_list* _pArgs, InternalType* _pSource);
 577     SparseBool* extract(int _iSeqCount, int* _piSeqCoord, int* _piMaxDim, int* _piDimSize, bool _bAsVector) SPARSE_CONST;
 578     InternalType* extract(typed_list* _pArgs);
 579
 580     virtual bool invoke(typed_list & in, optional_list &/*opt*/, int /*_iRetCount*/, typed_list & out, ast::ConstVisitor & /*execFunc*/, const ast::Exp & e)
 581     {
 582         if (in.size() == 0)
 583         {
 584             out.push_back(this);
 585         }
 586         else
 587         {
 588             InternalType * _out = extract(&in);
 589             if (!_out)
 590             {
 591                 std::wostringstream os;
 592                 os << _W("Invalid index.\n");
 593                 throw ast::ScilabError(os.str(), 999, e.getLocation());
 594             }
 595             out.push_back(_out);
 596         }
 597
 598         return true;
 599     }
 600
 601     virtual bool isInvokable() const
 602     {
 603         return true;
 604     }
 605
 606     virtual bool hasInvokeOption() const
 607     {
 608         return false;
 609     }
 610
 611     virtual int getInvokeNbIn()
 612     {
 613         return -1;
 614     }
 615
 616     virtual int getInvokeNbOut()
 617     {
 618         return 1;
 619     }
 620
 621     bool transpose(InternalType *& out);
 622
 623     /** @return the nb of non zero values.
 624      */
 625     std::size_t nbTrue() const;
 626     /* @param i row of the current sparse matrix
 627        @return the nb of non zero values in row i
 628      */
 629     std::size_t nbTrue(std::size_t i) const;
 630
 631     void setTrue(bool finalize = true);
 632     void setFalse(bool finalize = true);
 633
 634     int* getNbItemByRow(int* _piNbItemByRows);
 635     int* getColPos(int* _piColPos);
 636     int* getInnerPtr(int* count);
 637     int* getOuterPtr(int* count);
 638     /**
 639        output 1-base column numbers of the non zero elements
 640        @param out : ptr used as an output iterator over double values
 641        @return past-the-end output iterator after ouput is done
 642      */
 643
 644     int* outputRowCol(int* out)const;
 645
 646     bool operator==(const InternalType& it) SPARSE_CONST;
 647     bool operator!=(const InternalType& it) SPARSE_CONST;
 648
 649     /* return type as string ( double, int, cell, list, ... )*/
 650     virtual std::wstring getTypeStr() SPARSE_CONST {return std::wstring(L"boolean sparse");}
 651     /* return type as short string ( s, i, ce, l, ... )*/
 652     virtual std::wstring getShortTypeStr() SPARSE_CONST {return std::wstring(L"spb");}
 653
 654     inline ScilabType getType(void) SPARSE_CONST
 655     {
 656         return ScilabSparseBool;
 657     }
 658
 659     inline ScilabId getId(void) SPARSE_CONST
 660     {
 661         return IdSparseBool;
 662     }
 663
 664     inline bool isScalar()
 665     {
 666         return (getRows() == 1 && getCols() == 1);
 667     }
 668
 669     bool isTrue()
 670     {
 671         if (nbTrue() == m_iSize)
 672         {
 673             return true;
 674         }
 675         return false;
 676     }
 677
 678     bool neg(InternalType *& out)
 679     {
 680         SparseBool * _out = new SparseBool(getRows(), getCols());
 681         types::neg(getRows(), getCols(), matrixBool, _out->matrixBool);
 682         _out->finalize();
 683         out = _out;
 684         return true;
 685     }
 686
 687     void whoAmI() SPARSE_CONST;
 688
 689     bool* get();
 690     bool get(int r, int c) SPARSE_CONST;
 691     bool get(int _iIndex) SPARSE_CONST
 692     {
 693         return get(_iIndex % m_iRows, _iIndex / m_iRows);
 694     }
 695
 696     bool set(int r, int c, bool b, bool _bFinalize = true) SPARSE_CONST;
 697     bool set(int _iIndex, bool b, bool _bFinalize = true) SPARSE_CONST
 698     {
 699         return set(_iIndex % m_iRows, _iIndex / m_iRows, b, _bFinalize);
 700     }
 701
 702     void fill(Bool& dest, int r = 0, int c = 0) SPARSE_CONST;
 703
 704     Sparse* newOnes() const;
 705     SparseBool* newNotEqualTo(SparseBool const&o) const;
 706     SparseBool* newEqualTo(SparseBool& o);
 707
 708     SparseBool* newLogicalOr(SparseBool const&o) const;
 709     SparseBool* newLogicalAnd(SparseBool const&o) const;
 710
 711     typedef Eigen::SparseMatrix<bool, 0x1, int> BoolSparse_t;
 712     SparseBool(BoolSparse_t* o);
 713     BoolSparse_t* matrixBool;
 714
 715 private:
 716     void create2(int rows, int cols, Bool SPARSE_CONST& src, Double SPARSE_CONST& idx);
 717 };
 718
 719 template<typename T>
 720 struct SparseTraits
 721 {
 722     typedef types::Sparse type;
 723 };
 724 template<>
 725 struct SparseTraits<types::Bool>
 726 {
 727     typedef types::SparseBool type;
 728 };
 729 template<>
 730 struct SparseTraits<types::SparseBool>
 731 {
 732     typedef types::SparseBool type;
 733 };
 734
 735 }
 736
 737 #endif /* !__SPARSE_HH__ */