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