tatami
C++ API for different matrix representations
Loading...
Searching...
No Matches
Matrix.hpp
Go to the documentation of this file.
1#ifndef TATAMI_MATRIX_H
2#define TATAMI_MATRIX_H
3
4#include "Extractor.hpp"
5#include "Options.hpp"
6#include "Oracle.hpp"
7#include <algorithm>
8#include <numeric>
9#include <memory>
10
17namespace tatami {
18
25template<typename Index_>
26using VectorPtr = std::shared_ptr<const std::vector<Index_> >;
27
58template <typename Value_, typename Index_>
59class Matrix {
60public:
64 Matrix() = default;
65 Matrix(const Matrix&) = default;
66 Matrix& operator=(const Matrix&) = default;
67 Matrix(Matrix&&) = default;
68 Matrix& operator=(Matrix&&) = default;
69 virtual ~Matrix() = default;
77 typedef Value_ value_type;
78
82 typedef Index_ index_type;
83
84 /*******************************
85 **** Basic virtual methods ****
86 *******************************/
87public:
95 virtual Index_ nrow() const = 0;
96
104 virtual Index_ ncol() const = 0;
105
111 virtual bool is_sparse() const = 0;
112
116 // Back-compatibility only.
117 bool sparse() const {
118 return is_sparse();
119 }
120
121 bool sparse_proportion() const {
122 return is_sparse_proportion();
123 }
136 virtual double is_sparse_proportion() const = 0;
137
142 virtual bool prefer_rows() const = 0;
143
152 virtual double prefer_rows_proportion() const = 0;
153
161 virtual bool uses_oracle(bool row) const = 0;
162
163 /******************************
164 **** Myopic dense methods ****
165 ******************************/
166public:
174 virtual std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense(bool row, const Options& opt) const = 0;
175
185 virtual std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense(bool row, Index_ block_start, Index_ block_length, const Options& opt) const = 0;
186
196 virtual std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense(bool row, VectorPtr<Index_> indices_ptr, const Options& opt) const = 0;
197
198public: // ==== Convenience methods ====
205 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(const Options& opt) const {
206 return dense(true, opt);
207 }
208
217 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(Index_ block_start, Index_ block_length, const Options& opt) const {
218 return dense(true, block_start, block_length, opt);
219 }
220
229 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(VectorPtr<Index_> indices_ptr, const Options& opt) const {
230 return dense(true, std::move(indices_ptr), opt);
231 }
232
240 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(std::vector<Index_> indices, const Options& opt) const {
241 return dense_row(std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
242 }
243
250 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(const Options& opt) const {
251 return dense(false, opt);
252 }
253
262 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(Index_ block_start, Index_ block_length, const Options& opt) const {
263 return dense(false, block_start, block_length, opt);
264 }
265
274 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(VectorPtr<Index_> indices_ptr, const Options& opt) const {
275 return dense(false, std::move(indices_ptr), opt);
276 }
277
285 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(std::vector<Index_> indices, const Options& opt) const {
286 return dense_column(std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
287 }
288
289public: // ==== Default option overloads ====
295 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row() const {
296 return dense_row(Options());
297 }
298
306 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(Index_ block_start, Index_ block_length) const {
307 return dense_row(block_start, block_length, Options());
308 }
309
317 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(VectorPtr<Index_> indices_ptr) const {
318 return dense_row(std::move(indices_ptr), Options());
319 }
320
327 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_row(std::vector<Index_> indices) const {
328 return dense_row(std::move(indices), Options());
329 }
330
336 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column() const {
337 return dense_column(Options());
338 }
339
347 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(Index_ block_start, Index_ block_length) const {
348 return dense_column(block_start, block_length, Options());
349 }
350
358 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(VectorPtr<Index_> indices_ptr) const {
359 return dense_column(std::move(indices_ptr), Options());
360 }
361
368 std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense_column(std::vector<Index_> indices) const {
369 return dense_column(std::move(indices), Options());
370 }
371
372 /******************************
373 **** Myopic sparse access ****
374 ******************************/
375public:
383 virtual std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse(bool row, const Options& opt) const = 0;
384
394 virtual std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse(bool row, Index_ block_start, Index_ block_length, const Options& opt) const = 0;
395
405 virtual std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse(bool row, VectorPtr<Index_> indices_ptr, const Options& opt) const = 0;
406
407public: // ==== Convenience methods ====
414 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(const Options& opt) const {
415 return sparse(true, opt);
416 }
417
426 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(Index_ block_start, Index_ block_length, const Options& opt) const {
427 return sparse(true, block_start, block_length, opt);
428 }
429
438 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(VectorPtr<Index_> indices_ptr, const Options& opt) const {
439 return sparse(true, std::move(indices_ptr), opt);
440 }
441
449 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(std::vector<Index_> indices, const Options& opt) const {
450 return sparse_row(std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
451 }
452
459 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(const Options& opt) const {
460 return sparse(false, opt);
461 }
462
471 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(Index_ block_start, Index_ block_length, const Options& opt) const {
472 return sparse(false, block_start, block_length, opt);
473 }
474
483 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(VectorPtr<Index_> indices_ptr, const Options& opt) const {
484 return sparse(false, std::move(indices_ptr), opt);
485 }
486
494 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(std::vector<Index_> indices, const Options& opt) const {
495 return sparse_column(std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
496 }
497
498public: // ==== Default option overloads ====
504 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row() const {
505 return sparse_row(Options());
506 }
507
515 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(Index_ block_start, Index_ block_length) const {
516 return sparse_row(block_start, block_length, Options());
517 }
518
526 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(VectorPtr<Index_> indices_ptr) const {
527 return sparse_row(std::move(indices_ptr), Options());
528 }
529
536 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_row(std::vector<Index_> indices) const {
537 return sparse_row(std::move(indices), Options());
538 }
539
545 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column() const {
546 return sparse_column(Options());
547 }
548
556 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(Index_ block_start, Index_ block_length) const {
557 return sparse_column(block_start, block_length, Options());
558 }
559
567 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(VectorPtr<Index_> indices_ptr) const {
568 return sparse_column(std::move(indices_ptr), Options());
569 }
570
577 std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse_column(std::vector<Index_> indices) const {
578 return sparse_column(std::move(indices), Options());
579 }
580
581 /*******************************
582 **** Oracular dense access ****
583 *******************************/
584public:
593 virtual std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense(bool row, std::shared_ptr<const Oracle<Index_> > oracle, const Options& opt) const = 0;
594
605 virtual std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense(bool row, std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length, const Options& opt) const = 0;
606
617 virtual std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense(bool row, std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const = 0;
618
619public: // ==== Convenience methods ====
627 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, const Options& opt) const {
628 return dense(true, std::move(oracle), opt);
629 }
630
640 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
641 return dense(true, std::move(oracle), block_start, block_length, opt);
642 }
643
653 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
654 return dense(true, std::move(oracle), std::move(indices_ptr), opt);
655 }
656
665 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices, const Options& opt) const {
666 return dense_row(std::move(oracle), std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
667 }
668
676 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, const Options& opt) const {
677 return dense(false, std::move(oracle), opt);
678 }
679
689 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
690 return dense(false, std::move(oracle), block_start, block_length, opt);
691 }
692
702 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
703 return dense(false, std::move(oracle), std::move(indices_ptr), opt);
704 }
705
714 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices, const Options& opt) const {
715 return dense_column(std::move(oracle), std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
716 }
717
718public: // ==== Default option overloads ====
725 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle) const {
726 return dense_row(std::move(oracle), Options());
727 }
728
737 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length) const {
738 return dense_row(std::move(oracle), block_start, block_length, Options());
739 }
740
749 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr) const {
750 return dense_row(std::move(oracle), std::move(indices_ptr), Options());
751 }
752
760 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_row(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices) const {
761 return dense_row(std::move(oracle), std::move(indices), Options());
762 }
763
770 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle) const {
771 return dense_column(std::move(oracle), Options());
772 }
773
782 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length) const {
783 return dense_column(std::move(oracle), block_start, block_length, Options());
784 }
785
794 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr) const {
795 return dense_column(std::move(oracle), std::move(indices_ptr), Options());
796 }
797
805 std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense_column(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices) const {
806 return dense_column(std::move(oracle), std::move(indices), Options());
807 }
808
809 /*********************************
810 **** Oracular sparse methods ****
811 *********************************/
812public:
821 virtual std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse(bool row, std::shared_ptr<const Oracle<Index_> > oracle, const Options& opt) const = 0;
822
833 virtual std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse(bool row, std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length, const Options& opt) const = 0;
834
845 virtual std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse(bool row, std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const = 0;
846
847public: // ==== Convenience methods ====
855 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, const Options& opt) const {
856 return sparse(true, std::move(oracle), opt);
857 }
858
868 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
869 return sparse(true, std::move(oracle), block_start, block_length, opt);
870 }
871
880 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
881 return sparse(true, std::move(oracle), std::move(indices_ptr), opt);
882 }
883
892 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices, const Options& opt) const {
893 return sparse_row(std::move(oracle), std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
894 }
895
903 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, const Options& opt) const {
904 return sparse(false, std::move(oracle), opt);
905 }
906
916 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
917 return sparse(false, std::move(oracle), block_start, block_length, opt);
918 }
919
929 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
930 return sparse(false, std::move(oracle), std::move(indices_ptr), opt);
931 }
932
941 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices, const Options& opt) const {
942 return sparse_column(std::move(oracle), std::make_shared<std::vector<Index_> >(std::move(indices)), opt);
943 }
944
945public: // ==== Default option overloads ====
952 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle) const {
953 return sparse_row(std::move(oracle), Options());
954 }
955
964 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length) const {
965 return sparse_row(std::move(oracle), block_start, block_length, Options());
966 }
967
975 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr) const {
976 return sparse_row(std::move(oracle), std::move(indices_ptr), Options());
977 }
978
986 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_row(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices) const {
987 return sparse_row(std::move(oracle), std::move(indices), Options());
988 }
989
996 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle) const {
997 return sparse_column(std::move(oracle), Options());
998 }
999
1008 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, Index_ block_start, Index_ block_length) const {
1009 return sparse_column(std::move(oracle), block_start, block_length, Options());
1010 }
1011
1019 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, VectorPtr<Index_> indices_ptr) const {
1020 return sparse_column(std::move(oracle), std::move(indices_ptr), Options());
1021 }
1022
1030 std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse_column(std::shared_ptr<const Oracle<Index_> > oracle, std::vector<Index_> indices) const {
1031 return sparse_column(std::move(oracle), std::move(indices), Options());
1032 }
1033};
1034
1039
1040}
1041
1042#endif
Virtual classes for extracting matrix data.
Options for data access.
Oracle for data access.
Virtual class for a matrix.
Definition Matrix.hpp:59
virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense(bool row, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle) const
Definition Matrix.hpp:770
virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense(bool row, const Options &opt) const =0
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(const Options &opt) const
Definition Matrix.hpp:205
virtual Index_ ncol() const =0
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:689
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
Definition Matrix.hpp:903
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:737
virtual double prefer_rows_proportion() const =0
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(std::vector< Index_ > indices) const
Definition Matrix.hpp:536
Value_ value_type
Definition Matrix.hpp:77
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:749
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:317
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:782
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:794
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:217
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(std::vector< Index_ > indices) const
Definition Matrix.hpp:327
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:975
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:929
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:892
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:347
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(const Options &opt) const
Definition Matrix.hpp:250
virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense(bool row, std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const =0
virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense(bool row, std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:229
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row() const
Definition Matrix.hpp:295
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:494
virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense(bool row, Index_ block_start, Index_ block_length, const Options &opt) const =0
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:556
virtual Index_ nrow() const =0
virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse(bool row, std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const =0
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:240
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:916
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:714
virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse(bool row, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
Definition Matrix.hpp:986
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
Definition Matrix.hpp:805
virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense(bool row, std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const =0
virtual bool uses_oracle(bool row) const =0
virtual bool prefer_rows() const =0
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
Definition Matrix.hpp:760
Index_ index_type
Definition Matrix.hpp:82
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(std::vector< Index_ > indices) const
Definition Matrix.hpp:368
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle) const
Definition Matrix.hpp:996
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
Definition Matrix.hpp:676
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:274
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:702
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:358
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:1019
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:1008
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
Definition Matrix.hpp:855
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:262
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:483
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle) const
Definition Matrix.hpp:725
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column() const
Definition Matrix.hpp:336
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
Definition Matrix.hpp:627
virtual double is_sparse_proportion() const =0
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row(Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:306
virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse(bool row, std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const =0
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column() const
Definition Matrix.hpp:545
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:653
virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse(bool row, std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0
virtual bool is_sparse() const =0
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:438
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle) const
Definition Matrix.hpp:952
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:526
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:640
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column(std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:285
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:941
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:515
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
Definition Matrix.hpp:1030
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:471
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row(std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:665
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:426
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(VectorPtr< Index_ > indices_ptr) const
Definition Matrix.hpp:567
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
Definition Matrix.hpp:964
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(std::vector< Index_ > indices) const
Definition Matrix.hpp:577
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column(const Options &opt) const
Definition Matrix.hpp:459
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row() const
Definition Matrix.hpp:504
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
Definition Matrix.hpp:868
virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse(bool row, Index_ block_start, Index_ block_length, const Options &opt) const =0
virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse(bool row, const Options &opt) const =0
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row(std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
Definition Matrix.hpp:880
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(std::vector< Index_ > indices, const Options &opt) const
Definition Matrix.hpp:449
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row(const Options &opt) const
Definition Matrix.hpp:414
Predict future access requests on the target dimension.
Definition Oracle.hpp:29
Flexible representations for matrix data.
Definition Extractor.hpp:15
std::shared_ptr< const std::vector< Index_ > > VectorPtr
Definition Matrix.hpp:26
Options for accessing data from a Matrix instance.
Definition Options.hpp:30