tatami_chunked
Helpers to create custom chunked tatami matrices
Loading...
Searching...
No Matches
CustomDenseChunkedMatrix.hpp
Go to the documentation of this file.
1#ifndef TATAMI_CHUNKED_CUSTOM_DENSE_CHUNKED_MATRIX_HPP
2#define TATAMI_CHUNKED_CUSTOM_DENSE_CHUNKED_MATRIX_HPP
3
4#include "tatami/tatami.hpp"
5#include "custom_internals.hpp"
6#include "SlabCacheStats.hpp"
8#include "LruSlabCache.hpp"
11
12#include <type_traits>
13#include <vector>
14#include <cstddef>
15
16#include "sanisizer/sanisizer.hpp"
17
23namespace tatami_chunked {
24
34 std::size_t maximum_cache_size = sanisizer::cap<std::size_t>(100000000);
35
42
47 bool cache_subset = false;
48};
49
55template<typename ChunkValue_, typename Index_>
57public:
66 virtual ~CustomDenseChunkedMatrixWorkspace() = default;
102 virtual void extract(
103 Index_ chunk_row_id,
104 Index_ chunk_column_id,
105 bool row,
106 Index_ target_start,
107 Index_ target_length,
108 Index_ non_target_start,
109 Index_ non_target_length,
110 ChunkValue_* output,
111 Index_ stride
112 ) = 0;
113
143 virtual void extract(
144 Index_ chunk_row_id,
145 Index_ chunk_column_id,
146 bool row,
147 Index_ target_start,
148 Index_ target_length,
149 const std::vector<Index_>& non_target_indices,
150 ChunkValue_* output,
151 Index_ stride
152 ) = 0;
153
181 virtual void extract(
182 Index_ chunk_row_id,
183 Index_ chunk_column_id,
184 bool row,
185 const std::vector<Index_>& target_indices,
186 Index_ non_target_start,
187 Index_ non_target_length,
188 ChunkValue_* output,
189 Index_ stride
190 ) = 0;
191
218 virtual void extract(
219 Index_ chunk_row_id,
220 Index_ chunk_column_id,
221 bool row,
222 const std::vector<Index_>& target_indices,
223 const std::vector<Index_>& non_target_indices,
224 ChunkValue_* output,
225 Index_ stride
226 ) = 0;
227};
228
234template<typename ChunkValue_, typename Index_>
236public:
245 virtual ~CustomDenseChunkedMatrixManager() = default;
253 virtual std::unique_ptr<CustomDenseChunkedMatrixWorkspace<ChunkValue_, Index_> > new_workspace() const = 0;
254
262 std::unique_ptr<CustomDenseChunkedMatrixWorkspace<ChunkValue_, Index_> > new_workspace_exact() const {
263 return new_workspace();
264 }
265
269 virtual bool prefer_rows() const = 0;
270
276 virtual const ChunkDimensionStats<Index_>& row_stats() const = 0;
277
283 virtual const ChunkDimensionStats<Index_>& column_stats() const = 0;
284};
285
289namespace CustomChunkedMatrix_internal {
290
291/*********************
292 **** Base classes ***
293 *********************/
294
295template<bool oracle_, typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
296class SoloDenseCore {
297private:
298 WorkspacePtr_ my_chunk_workspace;
299 const ChunkCoordinator<false, ChunkValue_, Index_>& my_coordinator;
300
302 typename std::conditional<oracle_, tatami::PredictionIndex, bool>::type my_counter = 0;
303
305 typedef typename decltype(my_factory)::Slab Slab;
306
307 // These two instances are not fully allocated Slabs; rather, tmp_solo just
308 // holds the content for a single chunk, while final_solo holds the content
309 // across chunks but only for the requested dimension element. Both cases
310 // are likely to be much smaller than a full Slab, so we're already more
311 // memory-efficient than 'require_minimum_cache = true`.
312 DenseSingleWorkspace<ChunkValue_> my_tmp_solo;
313 Slab my_final_solo;
314
315 typedef decltype(my_tmp_solo.size()) TmpSize;
316
317public:
318 SoloDenseCore(
319 WorkspacePtr_ chunk_workspace,
320 const ChunkCoordinator<false, ChunkValue_, Index_>& coordinator,
321 [[maybe_unused]] const SlabCacheStats<Index_>& slab_stats, // for consistency with the other base classes.
323 Index_ non_target_length
324 ) :
325 my_chunk_workspace(std::move(chunk_workspace)),
326 my_coordinator(coordinator),
327 my_oracle(std::move(oracle)),
328 my_factory(non_target_length, 1),
329 my_tmp_solo(static_cast<TmpSize>(my_coordinator.get_chunk_nrow()) * static_cast<TmpSize>(my_coordinator.get_chunk_ncol())),
330 my_final_solo(my_factory.create())
331 {}
332
333 template<typename ... Args_>
334 std::pair<const Slab*, Index_> fetch_raw(bool row, Index_ i, Args_&& ... args) {
335 if constexpr(oracle_) {
336 i = my_oracle->get(my_counter++);
337 }
338 return my_coordinator.fetch_single(row, i, std::forward<Args_>(args)..., *my_chunk_workspace, my_tmp_solo, my_final_solo);
339 }
340};
341
342template<typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
343class MyopicDenseCore {
344private:
345 WorkspacePtr_ my_chunk_workspace;
346 const ChunkCoordinator<false, ChunkValue_, Index_>& my_coordinator;
347
348 DenseSlabFactory<ChunkValue_> my_factory;
349 typedef typename decltype(my_factory)::Slab Slab;
350
351 LruSlabCache<Index_, Slab> my_cache;
352
353public:
354 MyopicDenseCore(
355 WorkspacePtr_ chunk_workspace,
356 const ChunkCoordinator<false, ChunkValue_, Index_>& coordinator,
357 const SlabCacheStats<Index_>& slab_stats,
358 [[maybe_unused]] tatami::MaybeOracle<false, Index_> ora, // for consistency with the other base classes
359 [[maybe_unused]] Index_ non_target_length
360 ) :
361 my_chunk_workspace(std::move(chunk_workspace)),
362 my_coordinator(coordinator),
363 my_factory(slab_stats),
364 my_cache(slab_stats.max_slabs_in_cache)
365 {}
366
367 template<typename ... Args_>
368 std::pair<const Slab*, Index_> fetch_raw(bool row, Index_ i, Args_&& ... args) {
369 return my_coordinator.fetch_myopic(row, i, std::forward<Args_>(args)..., *my_chunk_workspace, my_cache, my_factory);
370 }
371};
372
373template<bool use_subset_, typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
374class OracularDenseCore {
375private:
376 WorkspacePtr_ my_chunk_workspace;
377 const ChunkCoordinator<false, ChunkValue_, Index_>& my_coordinator;
378
379 DenseSlabFactory<ChunkValue_> my_factory;
380 typedef typename decltype(my_factory)::Slab Slab;
381
382 typename std::conditional<use_subset_, OracularSubsettedSlabCache<Index_, Index_, Slab>, OracularSlabCache<Index_, Index_, Slab> >::type my_cache;
383
384public:
385 OracularDenseCore(
386 WorkspacePtr_ chunk_workspace,
387 const ChunkCoordinator<false, ChunkValue_, Index_>& coordinator,
388 const SlabCacheStats<Index_>& slab_stats,
390 [[maybe_unused]] Index_ non_target_length
391 ) :
392 my_chunk_workspace(std::move(chunk_workspace)),
393 my_coordinator(coordinator),
394 my_factory(slab_stats),
395 my_cache(std::move(oracle), slab_stats.max_slabs_in_cache)
396 {}
397
398 template<typename ... Args_>
399 std::pair<const Slab*, Index_> fetch_raw(bool row, [[maybe_unused]] Index_ i, Args_&& ... args) {
400 if constexpr(use_subset_) {
401 return my_coordinator.fetch_oracular_subsetted(row, std::forward<Args_>(args)..., *my_chunk_workspace, my_cache, my_factory);
402 } else {
403 return my_coordinator.fetch_oracular(row, std::forward<Args_>(args)..., *my_chunk_workspace, my_cache, my_factory);
404 }
405 }
406};
407
408template<bool solo_, bool oracle_, bool use_subset_, typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
409using DenseCore = typename std::conditional<solo_,
410 SoloDenseCore<oracle_, Value_, Index_, ChunkValue_, WorkspacePtr_>,
411 typename std::conditional<oracle_,
412 OracularDenseCore<use_subset_, Value_, Index_, ChunkValue_, WorkspacePtr_>,
413 MyopicDenseCore<Value_, Index_, ChunkValue_, WorkspacePtr_>
414 >::type
415>::type;
416
417/***********************
418 **** Actual classes ***
419 ***********************/
420
421template<class Slab_, typename Index_, typename Value_>
422const Value_* process_dense_slab(const std::pair<const Slab_*, Index_>& fetched, Value_* buffer, Index_ non_target_length) {
423 auto ptr = fetched.first->data + static_cast<std::size_t>(fetched.second) * static_cast<std::size_t>(non_target_length); // cast to size_t to avoid overflow.
424 std::copy_n(ptr, non_target_length, buffer);
425 return buffer;
426}
427
428template<bool solo_, bool oracle_, bool use_subset_, typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
429class DenseFull : public tatami::DenseExtractor<oracle_, Value_, Index_> {
430public:
431 DenseFull(
432 WorkspacePtr_ chunk_workspace,
433 const ChunkCoordinator<false, ChunkValue_, Index_>& coordinator,
434 const SlabCacheStats<Index_>& slab_stats,
435 bool row,
437 ) :
438 my_row(row),
439 my_non_target_dim(coordinator.get_non_target_dim(row)),
440 my_core(
441 std::move(chunk_workspace),
442 coordinator,
443 slab_stats,
444 std::move(oracle),
445 my_non_target_dim
446 )
447 {}
448
449 const Value_* fetch(Index_ i, Value_* buffer) {
450 auto fetched = my_core.fetch_raw(my_row, i, 0, my_non_target_dim);
451 return process_dense_slab(fetched, buffer, my_non_target_dim);
452 }
453
454private:
455 bool my_row;
456 Index_ my_non_target_dim;
457 DenseCore<solo_, oracle_, use_subset_, Value_, Index_, ChunkValue_, WorkspacePtr_> my_core;
458};
459
460template<bool solo_, bool oracle_, bool use_subset_, typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
461class DenseBlock : public tatami::DenseExtractor<oracle_, Value_, Index_> {
462public:
463 DenseBlock(
464 WorkspacePtr_ chunk_workspace,
465 const ChunkCoordinator<false, ChunkValue_, Index_>& coordinator,
466 const SlabCacheStats<Index_>& slab_stats,
467 bool row,
469 Index_ block_start,
470 Index_ block_length
471 ) :
472 my_row(row),
473 my_block_start(block_start),
474 my_block_length(block_length),
475 my_core(
476 std::move(chunk_workspace),
477 coordinator,
478 slab_stats,
479 std::move(ora),
480 block_length
481 )
482 {}
483
484 const Value_* fetch(Index_ i, Value_* buffer) {
485 auto fetched = my_core.fetch_raw(my_row, i, my_block_start, my_block_length);
486 return process_dense_slab(fetched, buffer, my_block_length);
487 }
488
489private:
490 bool my_row;
491 Index_ my_block_start, my_block_length;
492 DenseCore<solo_, oracle_, use_subset_, Value_, Index_, ChunkValue_, WorkspacePtr_> my_core;
493};
494
495template<bool solo_, bool oracle_, bool use_subset_, typename Value_, typename Index_, typename ChunkValue_, class WorkspacePtr_>
496class DenseIndex : public tatami::DenseExtractor<oracle_, Value_, Index_> {
497public:
498 DenseIndex(
499 WorkspacePtr_ chunk_workspace,
500 const ChunkCoordinator<false, ChunkValue_, Index_>& coordinator,
501 const SlabCacheStats<Index_>& slab_stats,
502 bool row,
504 tatami::VectorPtr<Index_> indices_ptr) :
505 my_row(row),
506 my_indices_ptr(std::move(indices_ptr)),
507 my_core(
508 std::move(chunk_workspace),
509 coordinator,
510 slab_stats,
511 std::move(oracle),
512 my_indices_ptr->size()
513 )
514 {}
515
516 const Value_* fetch(Index_ i, Value_* buffer) {
517 auto fetched = my_core.fetch_raw(my_row, i, *my_indices_ptr, my_tmp_indices);
518 return process_dense_slab(fetched, buffer, static_cast<Index_>(my_indices_ptr->size()));
519 }
520
521private:
522 bool my_row;
523 tatami::VectorPtr<Index_> my_indices_ptr;
524 std::vector<Index_> my_tmp_indices;
525 DenseCore<solo_, oracle_, use_subset_, Value_, Index_, ChunkValue_, WorkspacePtr_> my_core;
526};
527
528}
548template<typename Value_, typename Index_, typename ChunkValue_, class Manager_ = CustomDenseChunkedMatrixManager<ChunkValue_, Index_> >
549class CustomDenseChunkedMatrix : public tatami::Matrix<Value_, Index_> {
550public:
555 CustomDenseChunkedMatrix(std::shared_ptr<Manager_> manager, const CustomDenseChunkedMatrixOptions& opt) :
556 my_manager(std::move(manager)),
557 my_coordinator(my_manager->row_stats(), my_manager->column_stats()),
558 my_cache_size_in_elements(opt.maximum_cache_size / sizeof(ChunkValue_)),
559 my_require_minimum_cache(opt.require_minimum_cache),
560 my_cache_subset(opt.cache_subset)
561 {}
562
563private:
564 std::shared_ptr<Manager_> my_manager;
565 CustomChunkedMatrix_internal::ChunkCoordinator<false, ChunkValue_, Index_> my_coordinator;
566 std::size_t my_cache_size_in_elements;
567 bool my_require_minimum_cache;
568 bool my_cache_subset;
569
570public:
571 Index_ nrow() const {
572 return my_coordinator.get_nrow();
573 }
574
575 Index_ ncol() const {
576 return my_coordinator.get_ncol();
577 }
578
579 bool prefer_rows() const {
580 return my_manager->prefer_rows();
581 }
582
583 bool uses_oracle(bool) const {
584 return true;
585 }
586
587 double prefer_rows_proportion() const {
588 return static_cast<double>(my_manager->prefer_rows());
589 }
590
591 bool is_sparse() const {
592 return false;
593 }
594
595 double is_sparse_proportion() const {
596 return 0;
597 }
598
599 using tatami::Matrix<Value_, Index_>::dense;
600
601 using tatami::Matrix<Value_, Index_>::sparse;
602
603 /********************
604 *** Myopic dense ***
605 ********************/
606private:
607 template<bool oracle_, template<bool, bool, bool, typename, typename, typename, class> class Extractor_, typename ... Args_>
608 std::unique_ptr<tatami::DenseExtractor<oracle_, Value_, Index_> > raw_dense_internal(bool row, Index_ non_target_length, Args_&& ... args) const {
609 auto stats = [&]{
610 if (row) {
611 // Remember, the num_chunks_per_column is the number of slabs needed to divide up all the *rows* of the matrix.
612 return SlabCacheStats<Index_>(my_coordinator.get_chunk_nrow(), non_target_length, my_coordinator.get_num_chunks_per_column(), my_cache_size_in_elements, my_require_minimum_cache);
613 } else {
614 // Remember, the num_chunks_per_row is the number of slabs needed to divide up all the *columns* of the matrix.
615 return SlabCacheStats<Index_>(my_coordinator.get_chunk_ncol(), non_target_length, my_coordinator.get_num_chunks_per_row(), my_cache_size_in_elements, my_require_minimum_cache);
616 }
617 }();
618
619 auto wrk = my_manager->new_workspace_exact();
620 if (stats.max_slabs_in_cache == 0) {
621 return std::make_unique<Extractor_<true, oracle_, false, Value_, Index_, ChunkValue_, decltype(wrk)> >(std::move(wrk), my_coordinator, stats, row, std::forward<Args_>(args)...);
622 } else if constexpr(oracle_) {
623 if (my_cache_subset) {
624 return std::make_unique<Extractor_<false, true, true, Value_, Index_, ChunkValue_, decltype(wrk)> >(std::move(wrk), my_coordinator, stats, row, std::forward<Args_>(args)...);
625 } else {
626 return std::make_unique<Extractor_<false, true, false, Value_, Index_, ChunkValue_, decltype(wrk)> >(std::move(wrk), my_coordinator, stats, row, std::forward<Args_>(args)...);
627 }
628 } else {
629 return std::make_unique<Extractor_<false, false, false, Value_, Index_, ChunkValue_, decltype(wrk)> >(std::move(wrk), my_coordinator, stats, row, std::forward<Args_>(args)...);
630 }
631 }
632
633 template<bool oracle_>
634 std::unique_ptr<tatami::DenseExtractor<oracle_, Value_, Index_> > dense_internal(bool row, tatami::MaybeOracle<oracle_, Index_> oracle, const tatami::Options&) const {
635 auto non_target = (row ? my_coordinator.get_ncol() : my_coordinator.get_nrow());
636 return raw_dense_internal<oracle_, CustomChunkedMatrix_internal::DenseFull>(row, non_target, std::move(oracle));
637 }
638
639 template<bool oracle_>
640 std::unique_ptr<tatami::DenseExtractor<oracle_, Value_, Index_> > dense_internal(
641 bool row,
643 Index_ block_start,
644 Index_ block_length,
645 const tatami::Options&)
646 const {
647 return raw_dense_internal<oracle_, CustomChunkedMatrix_internal::DenseBlock>(row, block_length, std::move(oracle), block_start, block_length);
648 }
649
650 template<bool oracle_>
651 std::unique_ptr<tatami::DenseExtractor<oracle_, Value_, Index_> > dense_internal(
652 bool row,
654 tatami::VectorPtr<Index_> indices_ptr,
655 const tatami::Options&)
656 const {
657 auto num_indices = indices_ptr->size();
658 return raw_dense_internal<oracle_, CustomChunkedMatrix_internal::DenseIndex>(row, num_indices, std::move(oracle), std::move(indices_ptr));
659 }
660
661public:
662 std::unique_ptr<tatami::MyopicDenseExtractor<Value_, Index_> > dense(bool row, const tatami::Options& opt) const {
663 return dense_internal<false>(row, false, opt);
664 }
665
666 std::unique_ptr<tatami::MyopicDenseExtractor<Value_, Index_> > dense(bool row, Index_ block_start, Index_ block_length, const tatami::Options& opt) const {
667 return dense_internal<false>(row, false, block_start, block_length, opt);
668 }
669
670 std::unique_ptr<tatami::MyopicDenseExtractor<Value_, Index_> > dense(bool row, tatami::VectorPtr<Index_> indices_ptr, const tatami::Options& opt) const {
671 return dense_internal<false>(row, false, std::move(indices_ptr), opt);
672 }
673
674 /**********************
675 *** Oracular dense ***
676 **********************/
677public:
678 std::unique_ptr<tatami::OracularDenseExtractor<Value_, Index_> > dense(
679 bool row,
680 std::shared_ptr<const tatami::Oracle<Index_> > oracle,
681 const tatami::Options& opt)
682 const {
683 return dense_internal<true>(row, std::move(oracle), opt);
684 }
685
686 std::unique_ptr<tatami::OracularDenseExtractor<Value_, Index_> > dense(
687 bool row,
688 std::shared_ptr<const tatami::Oracle<Index_> > oracle,
689 Index_ block_start,
690 Index_ block_length,
691 const tatami::Options& opt)
692 const {
693 return dense_internal<true>(row, std::move(oracle), block_start, block_length, opt);
694 }
695
696 std::unique_ptr<tatami::OracularDenseExtractor<Value_, Index_> > dense(
697 bool row,
698 std::shared_ptr<const tatami::Oracle<Index_> > oracle,
699 tatami::VectorPtr<Index_> indices_ptr,
700 const tatami::Options& opt)
701 const {
702 return dense_internal<true>(row, std::move(oracle), std::move(indices_ptr), opt);
703 }
704
705 /*********************
706 *** Myopic sparse ***
707 *********************/
708public:
709 std::unique_ptr<tatami::MyopicSparseExtractor<Value_, Index_> > sparse(bool row, const tatami::Options& opt) const {
710 return std::make_unique<tatami::FullSparsifiedWrapper<false, Value_, Index_> >(dense(row, opt), my_coordinator.get_non_target_dim(row), opt);
711 }
712
713 std::unique_ptr<tatami::MyopicSparseExtractor<Value_, Index_> > sparse(bool row, Index_ block_start, Index_ block_length, const tatami::Options& opt) const {
714 return std::make_unique<tatami::BlockSparsifiedWrapper<false, Value_, Index_> >(dense(row, block_start, block_length, opt), block_start, block_length, opt);
715 }
716
717 std::unique_ptr<tatami::MyopicSparseExtractor<Value_, Index_> > sparse(bool row, tatami::VectorPtr<Index_> indices_ptr, const tatami::Options& opt) const {
718 auto d = dense(row, indices_ptr, opt);
719 return std::make_unique<tatami::IndexSparsifiedWrapper<false, Value_, Index_> >(std::move(d), std::move(indices_ptr), opt);
720 }
721
722 /***********************
723 *** Oracular sparse ***
724 ***********************/
725public:
726 std::unique_ptr<tatami::OracularSparseExtractor<Value_, Index_> > sparse(
727 bool row,
728 std::shared_ptr<const tatami::Oracle<Index_> > oracle,
729 const tatami::Options& opt)
730 const {
731 return std::make_unique<tatami::FullSparsifiedWrapper<true, Value_, Index_> >(dense(row, std::move(oracle), opt), my_coordinator.get_non_target_dim(row), opt);
732 }
733
734 std::unique_ptr<tatami::OracularSparseExtractor<Value_, Index_> > sparse(
735 bool row,
736 std::shared_ptr<const tatami::Oracle<Index_> > oracle,
737 Index_ block_start,
738 Index_ block_length,
739 const tatami::Options& opt)
740 const {
741 return std::make_unique<tatami::BlockSparsifiedWrapper<true, Value_, Index_> >(dense(row, std::move(oracle), block_start, block_length, opt), block_start, block_length, opt);
742 }
743
744 std::unique_ptr<tatami::OracularSparseExtractor<Value_, Index_> > sparse(
745 bool row,
746 std::shared_ptr<const tatami::Oracle<Index_> > oracle,
747 tatami::VectorPtr<Index_> indices_ptr,
748 const tatami::Options& opt)
749 const {
750 auto d = dense(row, std::move(oracle), indices_ptr, opt);
751 return std::make_unique<tatami::IndexSparsifiedWrapper<true, Value_, Index_> >(std::move(d), std::move(indices_ptr), opt);
752 }
753};
754
755}
756
757#endif
Factory for dense slabs.
Create a LRU cache of slabs.
Create a oracle-aware cache for slabs.
Create a oracle-aware cache with subsets.
Slab cache statistics.
Manager of chunks for a CustomDenseChunkedMatrix.
Definition CustomDenseChunkedMatrix.hpp:235
virtual const ChunkDimensionStats< Index_ > & row_stats() const =0
std::unique_ptr< CustomDenseChunkedMatrixWorkspace< ChunkValue_, Index_ > > new_workspace_exact() const
Definition CustomDenseChunkedMatrix.hpp:262
virtual const ChunkDimensionStats< Index_ > & column_stats() const =0
virtual std::unique_ptr< CustomDenseChunkedMatrixWorkspace< ChunkValue_, Index_ > > new_workspace() const =0
Workspace for extracting data from a CustomDenseChunkedMatrixManager.
Definition CustomDenseChunkedMatrix.hpp:56
virtual void extract(Index_ chunk_row_id, Index_ chunk_column_id, bool row, Index_ target_start, Index_ target_length, const std::vector< Index_ > &non_target_indices, ChunkValue_ *output, Index_ stride)=0
virtual void extract(Index_ chunk_row_id, Index_ chunk_column_id, bool row, const std::vector< Index_ > &target_indices, const std::vector< Index_ > &non_target_indices, ChunkValue_ *output, Index_ stride)=0
virtual void extract(Index_ chunk_row_id, Index_ chunk_column_id, bool row, const std::vector< Index_ > &target_indices, Index_ non_target_start, Index_ non_target_length, ChunkValue_ *output, Index_ stride)=0
virtual void extract(Index_ chunk_row_id, Index_ chunk_column_id, bool row, Index_ target_start, Index_ target_length, Index_ non_target_start, Index_ non_target_length, ChunkValue_ *output, Index_ stride)=0
Matrix of custom dense chunks.
Definition CustomDenseChunkedMatrix.hpp:549
CustomDenseChunkedMatrix(std::shared_ptr< Manager_ > manager, const CustomDenseChunkedMatrixOptions &opt)
Definition CustomDenseChunkedMatrix.hpp:555
Methods to handle chunked tatami matrices.
Definition ChunkDimensionStats.hpp:4
std::shared_ptr< const std::vector< Index_ > > VectorPtr
typename std::conditional< oracle_, std::shared_ptr< const Oracle< Index_ > >, bool >::type MaybeOracle
typename std::conditional< oracle_, OracularDenseExtractor< Value_, Index_ >, MyopicDenseExtractor< Value_, Index_ > >::type DenseExtractor
Statistics for regular chunks along a dimension.
Definition ChunkDimensionStats.hpp:35
Options for data extraction from a CustomDenseChunkedMatrix.
Definition CustomDenseChunkedMatrix.hpp:28
bool require_minimum_cache
Definition CustomDenseChunkedMatrix.hpp:41
std::size_t maximum_cache_size
Definition CustomDenseChunkedMatrix.hpp:34
bool cache_subset
Definition CustomDenseChunkedMatrix.hpp:47
Factory for dense slabs.
Definition DenseSlabFactory.hpp:29
Slab create()
Definition DenseSlabFactory.hpp:84
Statistics for slab caching.
Definition SlabCacheStats.hpp:26