fix comparison between sparse and sparse or sparsebool and sparsebool ( intel compile...
[scilab.git] / 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 &o);
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& o);
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__ */