33#ifndef GKO_PUBLIC_CORE_MATRIX_CSR_HPP_
34#define GKO_PUBLIC_CORE_MATRIX_CSR_HPP_
37#include <ginkgo/core/base/array.hpp>
38#include <ginkgo/core/base/index_set.hpp>
39#include <ginkgo/core/base/lin_op.hpp>
40#include <ginkgo/core/base/math.hpp>
41#include <ginkgo/core/matrix/permutation.hpp>
42#include <ginkgo/core/matrix/scaled_permutation.hpp>
49template <
typename ValueType>
52template <
typename ValueType>
55template <
typename ValueType,
typename IndexType>
58template <
typename ValueType,
typename IndexType>
61template <
typename ValueType,
typename IndexType>
64template <
typename ValueType,
typename IndexType>
67template <
typename ValueType,
typename IndexType>
70template <
typename ValueType,
typename IndexType>
73template <
typename ValueType,
typename IndexType>
76template <
typename ValueType,
typename IndexType>
83template <
typename ValueType = default_precision,
typename IndexType =
int32>
128template <
typename ValueType = default_precision,
typename IndexType =
int32>
131 public ConvertibleTo<Csr<next_precision<ValueType>, IndexType>>,
145 remove_complex<Csr<ValueType, IndexType>>>,
149 friend class Coo<ValueType, IndexType>;
150 friend class Dense<ValueType>;
152 friend class Ell<ValueType, IndexType>;
153 friend class Hybrid<ValueType, IndexType>;
154 friend class Sellp<ValueType, IndexType>;
156 friend class Fbcsr<ValueType, IndexType>;
157 friend class CsrBuilder<ValueType, IndexType>;
181 using value_type = ValueType;
182 using index_type = IndexType;
238 virtual std::shared_ptr<strategy_type>
copy() = 0;
241 void set_name(std::string name) { name_ = name; }
275 max_length_per_row_ = 0;
277 max_length_per_row_ = std::max(max_length_per_row_,
286 return max_length_per_row_;
289 std::shared_ptr<strategy_type>
copy()
override
291 return std::make_shared<classical>();
295 index_type max_length_per_row_;
316 std::shared_ptr<strategy_type>
copy()
override
318 return std::make_shared<merge_path>();
341 std::shared_ptr<strategy_type>
copy()
override
343 return std::make_shared<cusparse>();
365 std::shared_ptr<strategy_type>
copy()
override
367 return std::make_shared<sparselib>();
393 :
load_balance(exec->get_num_warps(), exec->get_warp_size())
492 if (warp_size_ > 0) {
503 if (strategy_name_ ==
"intel") {
511#if GINKGO_HIP_PLATFORM_HCC
512 if (!cuda_strategy_) {
522 auto nwarps = nwarps_ * multiple;
529 std::shared_ptr<strategy_type>
copy()
override
531 return std::make_shared<load_balance>(
532 nwarps_, warp_size_, cuda_strategy_, strategy_name_);
539 std::string strategy_name_;
546 const index_type nvidia_row_len_limit = 1024;
549 const index_type nvidia_nnz_limit{
static_cast<index_type
>(1
e6)};
552 const index_type amd_row_len_limit = 768;
555 const index_type amd_nnz_limit{
static_cast<index_type
>(1
e8)};
558 const index_type intel_row_len_limit = 25600;
561 const index_type intel_nnz_limit{
static_cast<index_type
>(3
e8)};
581 :
automatical(exec->get_num_warps(), exec->get_warp_size())
623 max_length_per_row_(0)
634 if (strategy_name_ ==
"intel") {
638#if GINKGO_HIP_PLATFORM_HCC
639 if (!cuda_strategy_) {
658 cuda_strategy_, strategy_name_);
672 nwarps_, warp_size_, cuda_strategy_, strategy_name_);
683 max_length_per_row_ =
687 max_length_per_row_ =
697 return std::make_shared<load_balance>(
698 nwarps_, warp_size_, cuda_strategy_, strategy_name_)
704 return max_length_per_row_;
707 std::shared_ptr<strategy_type>
copy()
override
709 return std::make_shared<automatical>(
710 nwarps_, warp_size_, cuda_strategy_, strategy_name_);
717 std::string strategy_name_;
718 index_type max_length_per_row_;
802 bool invert =
false)
const;
834 bool invert =
false)
const;
871 bool is_sorted_by_column_index()
const;
985 strategy_ = std::move(strategy->copy());
998 GKO_ASSERT_EQUAL_DIMENSIONS(alpha,
dim<2>(1, 1));
1011 GKO_ASSERT_EQUAL_DIMENSIONS(alpha,
dim<2>(1, 1));
1029 std::shared_ptr<const Executor> exec,
const dim<2>& size,
1030 gko::detail::const_array_view<ValueType>&& values,
1031 gko::detail::const_array_view<IndexType>&& col_idxs,
1032 gko::detail::const_array_view<IndexType>&&
row_ptrs,
1033 std::shared_ptr<strategy_type> strategy)
1037 return std::unique_ptr<const Csr>(
new Csr{
1038 exec, size, gko::detail::array_const_cast(std::move(values)),
1039 gko::detail::array_const_cast(std::move(col_idxs)),
1040 gko::detail::array_const_cast(std::move(
row_ptrs)), strategy});
1047 std::shared_ptr<const Executor> exec,
const dim<2>& size,
1048 gko::detail::const_array_view<ValueType>&& values,
1049 gko::detail::const_array_view<IndexType>&& col_idxs,
1050 gko::detail::const_array_view<IndexType>&&
row_ptrs)
1053 std::move(col_idxs), std::move(
row_ptrs),
1054 Csr::make_default_strategy(exec));
1118 Csr(std::shared_ptr<const Executor> exec,
1119 std::shared_ptr<strategy_type> strategy)
1120 :
Csr(std::
move(exec),
dim<2>{}, {}, std::move(strategy))
1132 Csr(std::shared_ptr<const Executor> exec,
const dim<2>& size,
1134 : EnableLinOp<
Csr>(exec, size),
1137 row_ptrs_(exec, size[0] + 1),
1139 strategy_(strategy->copy())
1153 Csr(std::shared_ptr<const Executor> exec,
const dim<2>& size = dim<2>{},
1181 Csr(std::shared_ptr<const Executor> exec,
const dim<2>& size,
1183 std::shared_ptr<strategy_type> strategy)
1184 : EnableLinOp<
Csr>(exec, size),
1189 strategy_(strategy->copy())
1192 GKO_ASSERT_EQ(this->get_size()[0] + 1, row_ptrs_.
get_num_elems());
1205 Csr(std::shared_ptr<const Executor> exec,
const dim<2>& size,
1212 Csr::make_default_strategy(exec)}
1215 void apply_impl(
const LinOp* b, LinOp* x)
const override;
1217 void apply_impl(
const LinOp* alpha,
const LinOp* b,
const LinOp* beta,
1218 LinOp* x)
const override;
1221 static std::shared_ptr<strategy_type> make_default_strategy(
1222 std::shared_ptr<const Executor> exec)
1224 auto cuda_exec = std::dynamic_pointer_cast<const CudaExecutor>(exec);
1225 auto hip_exec = std::dynamic_pointer_cast<const HipExecutor>(exec);
1226 auto dpcpp_exec = std::dynamic_pointer_cast<const DpcppExecutor>(exec);
1241 template <
typename CsrType>
1245 std::shared_ptr<typename CsrType::strategy_type>
new_strat;
1246 if (
dynamic_cast<classical*
>(
strat)) {
1247 new_strat = std::make_shared<typename CsrType::classical>();
1248 }
else if (
dynamic_cast<merge_path*
>(
strat)) {
1249 new_strat = std::make_shared<typename CsrType::merge_path>();
1250 }
else if (
dynamic_cast<cusparse*
>(
strat)) {
1251 new_strat = std::make_shared<typename CsrType::cusparse>();
1252 }
else if (
dynamic_cast<sparselib*
>(
strat)) {
1253 new_strat = std::make_shared<typename CsrType::sparselib>();
1257 std::dynamic_pointer_cast<const CudaExecutor>(
rexec);
1258 auto hip_exec = std::dynamic_pointer_cast<const HipExecutor>(
rexec);
1260 std::dynamic_pointer_cast<const DpcppExecutor>(
rexec);
1261 auto lb =
dynamic_cast<load_balance*
>(
strat);
1265 std::make_shared<typename CsrType::load_balance>(
1268 new_strat = std::make_shared<typename CsrType::automatical>(
1274 std::make_shared<typename CsrType::load_balance>(
1277 new_strat = std::make_shared<typename CsrType::automatical>(
1283 std::make_shared<typename CsrType::load_balance>(
1286 new_strat = std::make_shared<typename CsrType::automatical>(
1292 std::dynamic_pointer_cast<const CudaExecutor>(
1295 std::dynamic_pointer_cast<const HipExecutor>(
1298 std::dynamic_pointer_cast<const DpcppExecutor>(
1303 std::make_shared<typename CsrType::load_balance>(
1307 std::make_shared<typename CsrType::automatical>(
1313 std::make_shared<typename CsrType::load_balance>(
1317 std::make_shared<typename CsrType::automatical>(
1323 std::make_shared<typename CsrType::load_balance>(
1327 std::make_shared<typename CsrType::automatical>(
1335 new_strat = std::make_shared<typename CsrType::classical>();
1348 strategy_->process(row_ptrs_, &srow_);
1357 virtual void scale_impl(
const LinOp* alpha);
1365 virtual void inv_scale_impl(
const LinOp* alpha);
1368 array<value_type> values_;
1369 array<index_type> col_idxs_;
1370 array<index_type> row_ptrs_;
1371 array<index_type> srow_;
1372 std::shared_ptr<strategy_type> strategy_;
1374 void add_scaled_identity_impl(
const LinOp*
a,
const LinOp* b)
override;
1387template <
typename ValueType,
typename IndexType>
1388void strategy_rebuild_helper(Csr<ValueType, IndexType>*
result)
1390 using load_balance =
typename Csr<ValueType, IndexType>::load_balance;
1391 using automatical =
typename Csr<ValueType, IndexType>::automatical;
1392 auto strategy =
result->get_strategy();
1394 if (std::dynamic_pointer_cast<load_balance>(strategy)) {
1396 std::dynamic_pointer_cast<const HipExecutor>(
executor)) {
1397 result->set_strategy(std::make_shared<load_balance>(exec));
1398 }
else if (
auto exec = std::dynamic_pointer_cast<const CudaExecutor>(
1400 result->set_strategy(std::make_shared<load_balance>(exec));
1402 }
else if (std::dynamic_pointer_cast<automatical>(strategy)) {
1404 std::dynamic_pointer_cast<const HipExecutor>(
executor)) {
1405 result->set_strategy(std::make_shared<automatical>(exec));
1406 }
else if (
auto exec = std::dynamic_pointer_cast<const CudaExecutor>(
1408 result->set_strategy(std::make_shared<automatical>(exec));
ConvertibleTo interface is used to mark that the implementer can be converted to the object of Result...
Definition polymorphic_object.hpp:499
This is the Executor subclass which represents the CUDA device.
Definition executor.hpp:1513
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:823
This mixin implements a static create() method on ConcreteType that dynamically allocates the memory,...
Definition polymorphic_object.hpp:776
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:908
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:691
Definition lin_op.hpp:146
This is the Executor subclass which represents the OpenMP device (typically CPU).
Definition executor.hpp:1366
Linear operators which support permutation should implement the Permutable interface.
Definition lin_op.hpp:513
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:263
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:634
Adds the operation M <- a I + b M for matrix M, identity operator I and scalars a and b,...
Definition lin_op.hpp:847
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:462
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:689
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:187
value_type * get_data() noexcept
Returns a pointer to the block of memory used to store the elements of the array.
Definition array.hpp:646
const value_type * get_const_data() const noexcept
Returns a constant pointer to the block of memory used to store the elements of the array.
Definition array.hpp:655
void resize_and_reset(size_type num_elems)
Resizes the array so it is able to hold the specified number of elements.
Definition array.hpp:603
void fill(const value_type value)
Fill the array with the given value.
size_type get_num_elems() const noexcept
Returns the number of elements in the array.
Definition array.hpp:637
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:63
An index set class represents an ordered set of intervals.
Definition index_set.hpp:85
COO stores a matrix in the coordinate matrix format.
Definition coo.hpp:87
std::shared_ptr< strategy_type > copy() override
Copy a strategy.
Definition csr.hpp:707
automatical(int64_t nwarps, int warp_size=32, bool cuda_strategy=true, std::string strategy_name="none")
Creates an automatical strategy with specified parameters.
Definition csr.hpp:615
automatical()
Creates an automatical strategy.
Definition csr.hpp:570
int64_t clac_size(const int64_t nnz) override
Computes the srow size according to the number of nonzeros.
Definition csr.hpp:695
automatical(std::shared_ptr< const CudaExecutor > exec)
Creates an automatical strategy with CUDA executor.
Definition csr.hpp:580
void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow) override
Computes srow according to row pointers.
Definition csr.hpp:626
automatical(std::shared_ptr< const DpcppExecutor > exec)
Creates an automatical strategy with Dpcpp executor.
Definition csr.hpp:600
automatical(std::shared_ptr< const HipExecutor > exec)
Creates an automatical strategy with HIP executor.
Definition csr.hpp:589
classical is a strategy_type which uses the same number of threads on each row.
Definition csr.hpp:253
void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow) override
Computes srow according to row pointers.
Definition csr.hpp:260
std::shared_ptr< strategy_type > copy() override
Copy a strategy.
Definition csr.hpp:289
classical()
Creates a classical strategy.
Definition csr.hpp:258
int64_t clac_size(const int64_t nnz) override
Computes the srow size according to the number of nonzeros.
Definition csr.hpp:282
cusparse is a strategy_type which uses the sparselib csr.
Definition csr.hpp:328
int64_t clac_size(const int64_t nnz) override
Computes the srow size according to the number of nonzeros.
Definition csr.hpp:339
std::shared_ptr< strategy_type > copy() override
Copy a strategy.
Definition csr.hpp:341
cusparse()
Creates a cusparse strategy.
Definition csr.hpp:333
void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow) override
Computes srow according to row pointers.
Definition csr.hpp:335
load_balance is a strategy_type which uses the load balance algorithm.
Definition csr.hpp:374
void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow) override
Computes srow according to row pointers.
Definition csr.hpp:437
std::shared_ptr< strategy_type > copy() override
Copy a strategy.
Definition csr.hpp:529
load_balance(std::shared_ptr< const HipExecutor > exec)
Creates a load_balance strategy with HIP executor.
Definition csr.hpp:401
load_balance()
Creates a load_balance strategy.
Definition csr.hpp:382
int64_t clac_size(const int64_t nnz) override
Computes the srow size according to the number of nonzeros.
Definition csr.hpp:490
load_balance(int64_t nwarps, int warp_size=32, bool cuda_strategy=true, std::string strategy_name="none")
Creates a load_balance strategy with specified parameters.
Definition csr.hpp:427
load_balance(std::shared_ptr< const CudaExecutor > exec)
Creates a load_balance strategy with CUDA executor.
Definition csr.hpp:392
load_balance(std::shared_ptr< const DpcppExecutor > exec)
Creates a load_balance strategy with DPCPP executor.
Definition csr.hpp:412
merge_path is a strategy_type which uses the merge_path algorithm.
Definition csr.hpp:303
int64_t clac_size(const int64_t nnz) override
Computes the srow size according to the number of nonzeros.
Definition csr.hpp:314
std::shared_ptr< strategy_type > copy() override
Copy a strategy.
Definition csr.hpp:316
merge_path()
Creates a merge_path strategy.
Definition csr.hpp:308
void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow) override
Computes srow according to row pointers.
Definition csr.hpp:310
sparselib is a strategy_type which uses the sparselib csr.
Definition csr.hpp:352
int64_t clac_size(const int64_t nnz) override
Computes the srow size according to the number of nonzeros.
Definition csr.hpp:363
void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow) override
Computes srow according to row pointers.
Definition csr.hpp:359
sparselib()
Creates a sparselib strategy.
Definition csr.hpp:357
std::shared_ptr< strategy_type > copy() override
Copy a strategy.
Definition csr.hpp:365
strategy_type is to decide how to set the csr algorithm.
Definition csr.hpp:196
virtual int64_t clac_size(const int64_t nnz)=0
Computes the srow size according to the number of nonzeros.
std::string get_name()
Returns the name of strategy.
Definition csr.hpp:214
virtual std::shared_ptr< strategy_type > copy()=0
Copy a strategy.
virtual void process(const array< index_type > &mtx_row_ptrs, array< index_type > *mtx_srow)=0
Computes srow according to row pointers.
strategy_type(std::string name)
Creates a strategy_type.
Definition csr.hpp:205
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:146
std::unique_ptr< LinOp > column_permute(const array< IndexType > *permutation_indices) const override
Returns a LinOp representing the column permutation of the Permutable object.
Csr & operator=(const Csr &)
Copy-assigns a Csr matrix.
std::unique_ptr< Csr > scale_permute(ptr_param< const ScaledPermutation< value_type, index_type > > permutation, permute_mode=permute_mode::symmetric) const
Creates a scaled and permuted copy of this matrix.
void write(mat_data &data) const override
Writes a matrix to a matrix_data structure.
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
const index_type * get_const_row_ptrs() const noexcept
Returns the row pointers of the matrix.
Definition csr.hpp:925
std::unique_ptr< Csr< ValueType, IndexType > > create_submatrix(const span &row_span, const span &column_span) const
Creates a submatrix from this Csr matrix given row and column spans.
void read(device_mat_data &&data) override
Reads a matrix from a device_matrix_data structure.
const index_type * get_const_srow() const noexcept
Returns the starting rows.
Definition csr.hpp:944
void set_strategy(std::shared_ptr< strategy_type > strategy)
Set the strategy.
Definition csr.hpp:983
void inv_scale(ptr_param< const LinOp > alpha)
Scales the matrix with the inverse of a scalar.
Definition csr.hpp:1008
void read(const device_mat_data &data) override
Reads a matrix from a device_matrix_data structure.
static std::unique_ptr< const Csr > create_const(std::shared_ptr< const Executor > exec, const dim< 2 > &size, gko::detail::const_array_view< ValueType > &&values, gko::detail::const_array_view< IndexType > &&col_idxs, gko::detail::const_array_view< IndexType > &&row_ptrs, std::shared_ptr< strategy_type > strategy)
Creates a constant (immutable) Csr matrix from a set of constant arrays.
Definition csr.hpp:1028
index_type * get_srow() noexcept
Returns the starting rows.
Definition csr.hpp:935
size_type get_num_srow_elements() const noexcept
Returns the number of the srow stored elements (involved warps)
Definition csr.hpp:954
std::unique_ptr< LinOp > inverse_permute(const array< IndexType > *inverse_permutation_indices) const override
Returns a LinOp representing the symmetric inverse row and column permutation of the Permutable objec...
std::unique_ptr< LinOp > row_permute(const array< IndexType > *permutation_indices) const override
Returns a LinOp representing the row permutation of the Permutable object.
std::unique_ptr< Csr< ValueType, IndexType > > create_submatrix(const index_set< IndexType > &row_index_set, const index_set< IndexType > &column_index_set) const
Creates a submatrix from this Csr matrix given row and column index_set objects.
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.
index_type * get_row_ptrs() noexcept
Returns the row pointers of the matrix.
Definition csr.hpp:916
std::unique_ptr< Csr > permute(ptr_param< const Permutation< index_type > > permutation, permute_mode mode=permute_mode::symmetric) const
Creates a permuted copy of this matrix with the given permutation .
Csr(const Csr &)
Copy-constructs a Csr matrix.
Csr & operator=(Csr &&)
Move-assigns a Csr matrix.
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
const value_type * get_const_values() const noexcept
Returns the values of the matrix.
Definition csr.hpp:887
std::unique_ptr< LinOp > inverse_column_permute(const array< IndexType > *inverse_permutation_indices) const override
Returns a LinOp representing the row permutation of the inverse permuted object.
std::unique_ptr< LinOp > inverse_row_permute(const array< IndexType > *inverse_permutation_indices) const override
Returns a LinOp representing the row permutation of the inverse permuted object.
void compute_absolute_inplace() override
Compute absolute inplace on each element.
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition csr.hpp:964
std::shared_ptr< strategy_type > get_strategy() const noexcept
Returns the strategy.
Definition csr.hpp:973
std::unique_ptr< LinOp > permute(const array< IndexType > *permutation_indices) const override
Returns a LinOp representing the symmetric row and column permutation of the Permutable object.
const index_type * get_const_col_idxs() const noexcept
Returns the column indexes of the matrix.
Definition csr.hpp:906
void read(const mat_data &data) override
Reads a matrix from a matrix_data structure.
void sort_by_column_index()
Sorts all (value, col_idx) pairs in each row by column index.
std::unique_ptr< Csr > scale_permute(ptr_param< const ScaledPermutation< value_type, index_type > > row_permutation, ptr_param< const ScaledPermutation< value_type, index_type > > column_permutation, bool invert=false) const
Creates a scaled and permuted copy of this matrix.
void scale(ptr_param< const LinOp > alpha)
Scales the matrix with a scalar.
Definition csr.hpp:995
value_type * get_values() noexcept
Returns the values of the matrix.
Definition csr.hpp:878
static std::unique_ptr< const Csr > create_const(std::shared_ptr< const Executor > exec, const dim< 2 > &size, gko::detail::const_array_view< ValueType > &&values, gko::detail::const_array_view< IndexType > &&col_idxs, gko::detail::const_array_view< IndexType > &&row_ptrs)
This is version of create_const with a default strategy.
Definition csr.hpp:1046
index_type * get_col_idxs() noexcept
Returns the column indexes of the matrix.
Definition csr.hpp:897
Csr(Csr &&)
Move-constructs a Csr matrix.
std::unique_ptr< Csr > permute(ptr_param< const Permutation< index_type > > row_permutation, ptr_param< const Permutation< index_type > > column_permutation, bool invert=false) const
Creates a non-symmetrically permuted copy of this matrix with the given row and column permutations...
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
Dense is a matrix format which explicitly stores all values of the matrix.
Definition dense.hpp:136
This class is a utility which efficiently implements the diagonal matrix (a linear operator which sca...
Definition diagonal.hpp:79
ELL is a matrix format where stride with explicit zeros is used such that all rows have the same numb...
Definition ell.hpp:89
Fixed-block compressed sparse row storage matrix format.
Definition fbcsr.hpp:138
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition hybrid.hpp:81
Permutation is a matrix format that represents a permutation matrix, i.e.
Definition permutation.hpp:142
ScaledPermutation is a matrix combining a permutation with scaling factors.
Definition scaled_permutation.hpp:67
SELL-P is a matrix format similar to ELL format.
Definition sellp.hpp:80
SparsityCsr is a matrix format which stores only the sparsity pattern of a sparse matrix by compressi...
Definition sparsity_csr.hpp:87
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:71
permute_mode
Specifies how a permutation will be applied to a matrix.
Definition permutation.hpp:71
@ symmetric
The rows and columns will be permuted.
The Ginkgo namespace.
Definition abstract_factory.hpp:48
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:803
typename detail::remove_complex_s< T >::type remove_complex
Obtain the type which removed the complex of complex/scalar type or the template parameter of class b...
Definition math.hpp:354
typename detail::next_precision_impl< T >::type next_precision
Obtains the next type in the singly-linked precision list.
Definition math.hpp:490
typename detail::to_complex_s< T >::type to_complex
Obtain the type which adds the complex of complex/scalar type or the template parameter of class by a...
Definition math.hpp:373
constexpr int64 ceildiv(int64 num, int64 den)
Performs integer division with rounding up.
Definition math.hpp:641
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:120
constexpr T min(const T &x, const T &y)
Returns the smaller of the arguments.
Definition math.hpp:891
detail::temporary_clone< detail::pointee< Ptr > > make_temporary_clone(std::shared_ptr< const Executor > exec, Ptr &&ptr)
Creates a temporary_clone.
Definition temporary_clone.hpp:207
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:55
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:155
A span is a lightweight structure used to create sub-ranges from other ranges.
Definition range.hpp:75