monolish  0.17.3-dev.23
MONOlithic LInear equation Solvers for Highly-parallel architecture
monolish_common.hpp
Go to the documentation of this file.
1 #pragma once
2 #if USE_SXAT
3 #undef _HAS_CPP17
4 #endif
5 #include "monolish_dense.hpp"
6 #include "monolish_logger.hpp"
7 #include "monolish_matrix.hpp"
8 #include "monolish_tensor.hpp"
9 #include "monolish_vector.hpp"
10 #include "monolish_view1D.hpp"
11 #include "monolish_view_dense.hpp"
12 #include "monolish_view_tensor_dense.hpp"
13 #include <initializer_list>
14 
15 // error code
16 #define MONOLISH_SOLVER_SUCCESS 0
17 #define MONOLISH_SOLVER_SIZE_ERROR -1
18 #define MONOLISH_SOLVER_MAXITER -2
19 #define MONOLISH_SOLVER_BREAKDOWN -3
20 #define MONOLISH_SOLVER_RESIDUAL_NAN -4
21 #define MONOLISH_SOLVER_NOT_IMPL -10
22 
26 namespace monolish {
30 namespace util {
42 int get_num_devices();
43 
49 bool set_default_device(size_t device_num);
50 
57 int get_default_device();
58 
75 double get_residual_l2(const matrix::Dense<double> &A, const vector<double> &x,
76  const vector<double> &y);
77 double get_residual_l2(const matrix::Dense<double> &A, const vector<double> &x,
78  const view1D<vector<double>, double> &y);
79 double get_residual_l2(const matrix::Dense<double> &A, const vector<double> &x,
80  const view1D<matrix::Dense<double>, double> &y);
81 double get_residual_l2(const matrix::Dense<double> &A, const vector<double> &x,
82  const view1D<tensor::tensor_Dense<double>, double> &y);
83 double get_residual_l2(const matrix::Dense<double> &A,
84  const view1D<vector<double>, double> &x,
85  const vector<double> &y);
86 double get_residual_l2(const matrix::Dense<double> &A,
87  const view1D<vector<double>, double> &x,
88  const view1D<vector<double>, double> &y);
89 double get_residual_l2(const matrix::Dense<double> &A,
90  const view1D<vector<double>, double> &x,
91  const view1D<matrix::Dense<double>, double> &y);
92 double get_residual_l2(const matrix::Dense<double> &A,
93  const view1D<vector<double>, double> &x,
94  const view1D<tensor::tensor_Dense<double>, double> &y);
95 double get_residual_l2(const matrix::Dense<double> &A,
96  const view1D<matrix::Dense<double>, double> &x,
97  const vector<double> &y);
98 double get_residual_l2(const matrix::Dense<double> &A,
99  const view1D<matrix::Dense<double>, double> &x,
100  const view1D<vector<double>, double> &y);
101 double get_residual_l2(const matrix::Dense<double> &A,
102  const view1D<matrix::Dense<double>, double> &x,
103  const view1D<matrix::Dense<double>, double> &y);
104 double get_residual_l2(const matrix::Dense<double> &A,
105  const view1D<matrix::Dense<double>, double> &x,
106  const view1D<tensor::tensor_Dense<double>, double> &y);
107 double get_residual_l2(const matrix::Dense<double> &A,
108  const view1D<tensor::tensor_Dense<double>, double> &x,
109  const vector<double> &y);
110 double get_residual_l2(const matrix::Dense<double> &A,
111  const view1D<tensor::tensor_Dense<double>, double> &x,
112  const view1D<vector<double>, double> &y);
113 double get_residual_l2(const matrix::Dense<double> &A,
114  const view1D<tensor::tensor_Dense<double>, double> &x,
115  const view1D<matrix::Dense<double>, double> &y);
116 double get_residual_l2(const matrix::Dense<double> &A,
117  const view1D<tensor::tensor_Dense<double>, double> &x,
118  const view1D<tensor::tensor_Dense<double>, double> &y);
119 
120 float get_residual_l2(const matrix::Dense<float> &A, const vector<float> &x,
121  const vector<float> &y);
122 float get_residual_l2(const matrix::Dense<float> &A, const vector<float> &x,
123  const view1D<vector<float>, float> &y);
124 float get_residual_l2(const matrix::Dense<float> &A, const vector<float> &x,
125  const view1D<matrix::Dense<float>, float> &y);
126 float get_residual_l2(const matrix::Dense<float> &A, const vector<float> &x,
127  const view1D<tensor::tensor_Dense<float>, float> &y);
128 float get_residual_l2(const matrix::Dense<float> &A,
129  const view1D<vector<float>, float> &x,
130  const vector<float> &y);
131 float get_residual_l2(const matrix::Dense<float> &A,
132  const view1D<vector<float>, float> &x,
133  const view1D<vector<float>, float> &y);
134 float get_residual_l2(const matrix::Dense<float> &A,
135  const view1D<vector<float>, float> &x,
136  const view1D<matrix::Dense<float>, float> &y);
137 float get_residual_l2(const matrix::Dense<float> &A,
138  const view1D<vector<float>, float> &x,
139  const view1D<tensor::tensor_Dense<float>, float> &y);
140 float get_residual_l2(const matrix::Dense<float> &A,
141  const view1D<matrix::Dense<float>, float> &x,
142  const vector<float> &y);
143 float get_residual_l2(const matrix::Dense<float> &A,
144  const view1D<matrix::Dense<float>, float> &x,
145  const view1D<vector<float>, float> &y);
146 float get_residual_l2(const matrix::Dense<float> &A,
147  const view1D<matrix::Dense<float>, float> &x,
148  const view1D<matrix::Dense<float>, float> &y);
149 float get_residual_l2(const matrix::Dense<float> &A,
150  const view1D<matrix::Dense<float>, float> &x,
151  const view1D<tensor::tensor_Dense<float>, float> &y);
152 float get_residual_l2(const matrix::Dense<float> &A,
153  const view1D<tensor::tensor_Dense<float>, float> &x,
154  const vector<float> &y);
155 float get_residual_l2(const matrix::Dense<float> &A,
156  const view1D<tensor::tensor_Dense<float>, float> &x,
157  const view1D<vector<float>, float> &y);
158 float get_residual_l2(const matrix::Dense<float> &A,
159  const view1D<tensor::tensor_Dense<float>, float> &x,
160  const view1D<matrix::Dense<float>, float> &y);
161 float get_residual_l2(const matrix::Dense<float> &A,
162  const view1D<tensor::tensor_Dense<float>, float> &x,
163  const view1D<tensor::tensor_Dense<float>, float> &y);
164 
176 double get_residual_l2(const matrix::CRS<double> &A, const vector<double> &x,
177  const vector<double> &y);
178 double get_residual_l2(const matrix::CRS<double> &A, const vector<double> &x,
179  const view1D<vector<double>, double> &y);
180 double get_residual_l2(const matrix::CRS<double> &A, const vector<double> &x,
181  const view1D<matrix::Dense<double>, double> &y);
182 double get_residual_l2(const matrix::CRS<double> &A, const vector<double> &x,
183  const view1D<tensor::tensor_Dense<double>, double> &y);
184 double get_residual_l2(const matrix::CRS<double> &A,
185  const view1D<vector<double>, double> &x,
186  const vector<double> &y);
187 double get_residual_l2(const matrix::CRS<double> &A,
188  const view1D<vector<double>, double> &x,
189  const view1D<vector<double>, double> &y);
190 double get_residual_l2(const matrix::CRS<double> &A,
191  const view1D<vector<double>, double> &x,
192  const view1D<matrix::Dense<double>, double> &y);
193 double get_residual_l2(const matrix::CRS<double> &A,
194  const view1D<vector<double>, double> &x,
195  const view1D<tensor::tensor_Dense<double>, double> &y);
196 double get_residual_l2(const matrix::CRS<double> &A,
197  const view1D<matrix::Dense<double>, double> &x,
198  const vector<double> &y);
199 double get_residual_l2(const matrix::CRS<double> &A,
200  const view1D<matrix::Dense<double>, double> &x,
201  const view1D<vector<double>, double> &y);
202 double get_residual_l2(const matrix::CRS<double> &A,
203  const view1D<matrix::Dense<double>, double> &x,
204  const view1D<matrix::Dense<double>, double> &y);
205 double get_residual_l2(const matrix::CRS<double> &A,
206  const view1D<matrix::Dense<double>, double> &x,
207  const view1D<tensor::tensor_Dense<double>, double> &y);
208 double get_residual_l2(const matrix::CRS<double> &A,
209  const view1D<tensor::tensor_Dense<double>, double> &x,
210  const vector<double> &y);
211 double get_residual_l2(const matrix::CRS<double> &A,
212  const view1D<tensor::tensor_Dense<double>, double> &x,
213  const view1D<vector<double>, double> &y);
214 double get_residual_l2(const matrix::CRS<double> &A,
215  const view1D<tensor::tensor_Dense<double>, double> &x,
216  const view1D<matrix::Dense<double>, double> &y);
217 double get_residual_l2(const matrix::CRS<double> &A,
218  const view1D<tensor::tensor_Dense<double>, double> &x,
219  const view1D<tensor::tensor_Dense<double>, double> &y);
220 
221 float get_residual_l2(const matrix::CRS<float> &A, const vector<float> &x,
222  const vector<float> &y);
223 float get_residual_l2(const matrix::CRS<float> &A, const vector<float> &x,
224  const view1D<vector<float>, float> &y);
225 float get_residual_l2(const matrix::CRS<float> &A, const vector<float> &x,
226  const view1D<matrix::Dense<float>, float> &y);
227 float get_residual_l2(const matrix::CRS<float> &A, const vector<float> &x,
228  const view1D<tensor::tensor_Dense<float>, float> &y);
229 float get_residual_l2(const matrix::CRS<float> &A,
230  const view1D<vector<float>, float> &x,
231  const vector<float> &y);
232 float get_residual_l2(const matrix::CRS<float> &A,
233  const view1D<vector<float>, float> &x,
234  const view1D<vector<float>, float> &y);
235 float get_residual_l2(const matrix::CRS<float> &A,
236  const view1D<vector<float>, float> &x,
237  const view1D<matrix::Dense<float>, float> &y);
238 float get_residual_l2(const matrix::CRS<float> &A,
239  const view1D<vector<float>, float> &x,
240  const view1D<tensor::tensor_Dense<float>, float> &y);
241 float get_residual_l2(const matrix::CRS<float> &A,
242  const view1D<matrix::Dense<float>, float> &x,
243  const vector<float> &y);
244 float get_residual_l2(const matrix::CRS<float> &A,
245  const view1D<matrix::Dense<float>, float> &x,
246  const view1D<vector<float>, float> &y);
247 float get_residual_l2(const matrix::CRS<float> &A,
248  const view1D<matrix::Dense<float>, float> &x,
249  const view1D<matrix::Dense<float>, float> &y);
250 float get_residual_l2(const matrix::CRS<float> &A,
251  const view1D<matrix::Dense<float>, float> &x,
252  const view1D<tensor::tensor_Dense<float>, float> &y);
253 float get_residual_l2(const matrix::CRS<float> &A,
254  const view1D<tensor::tensor_Dense<float>, float> &x,
255  const vector<float> &y);
256 float get_residual_l2(const matrix::CRS<float> &A,
257  const view1D<tensor::tensor_Dense<float>, float> &x,
258  const view1D<vector<float>, float> &y);
259 float get_residual_l2(const matrix::CRS<float> &A,
260  const view1D<tensor::tensor_Dense<float>, float> &x,
261  const view1D<matrix::Dense<float>, float> &y);
262 float get_residual_l2(const matrix::CRS<float> &A,
263  const view1D<tensor::tensor_Dense<float>, float> &x,
264  const view1D<tensor::tensor_Dense<float>, float> &y);
265 
277 double get_residual_l2(const matrix::LinearOperator<double> &A,
278  const vector<double> &x, const vector<double> &y);
279 double get_residual_l2(const matrix::LinearOperator<double> &A,
280  const vector<double> &x,
281  const view1D<vector<double>, double> &y);
282 double get_residual_l2(const matrix::LinearOperator<double> &A,
283  const vector<double> &x,
284  const view1D<matrix::Dense<double>, double> &y);
285 double get_residual_l2(const matrix::LinearOperator<double> &A,
286  const vector<double> &x,
287  const view1D<tensor::tensor_Dense<double>, double> &y);
288 double get_residual_l2(const matrix::LinearOperator<double> &A,
289  const view1D<vector<double>, double> &x,
290  const vector<double> &y);
291 double get_residual_l2(const matrix::LinearOperator<double> &A,
292  const view1D<vector<double>, double> &x,
293  const view1D<vector<double>, double> &y);
294 double get_residual_l2(const matrix::LinearOperator<double> &A,
295  const view1D<vector<double>, double> &x,
296  const view1D<matrix::Dense<double>, double> &y);
297 double get_residual_l2(const matrix::LinearOperator<double> &A,
298  const view1D<vector<double>, double> &x,
299  const view1D<tensor::tensor_Dense<double>, double> &y);
300 double get_residual_l2(const matrix::LinearOperator<double> &A,
301  const view1D<matrix::Dense<double>, double> &x,
302  const vector<double> &y);
303 double get_residual_l2(const matrix::LinearOperator<double> &A,
304  const view1D<matrix::Dense<double>, double> &x,
305  const view1D<vector<double>, double> &y);
306 double get_residual_l2(const matrix::LinearOperator<double> &A,
307  const view1D<matrix::Dense<double>, double> &x,
308  const view1D<matrix::Dense<double>, double> &y);
309 double get_residual_l2(const matrix::LinearOperator<double> &A,
310  const view1D<matrix::Dense<double>, double> &x,
311  const view1D<tensor::tensor_Dense<double>, double> &y);
312 double get_residual_l2(const matrix::LinearOperator<double> &A,
313  const view1D<tensor::tensor_Dense<double>, double> &x,
314  const vector<double> &y);
315 double get_residual_l2(const matrix::LinearOperator<double> &A,
316  const view1D<tensor::tensor_Dense<double>, double> &x,
317  const view1D<vector<double>, double> &y);
318 double get_residual_l2(const matrix::LinearOperator<double> &A,
319  const view1D<tensor::tensor_Dense<double>, double> &x,
320  const view1D<matrix::Dense<double>, double> &y);
321 double get_residual_l2(const matrix::LinearOperator<double> &A,
322  const view1D<tensor::tensor_Dense<double>, double> &x,
323  const view1D<tensor::tensor_Dense<double>, double> &y);
324 
339 [[nodiscard]] bool solver_check(const int err);
340 
341 // logger
342 
354 void set_log_level(const size_t Level);
355 
361 void set_log_filename(const std::string filename);
362 
363 // create typical data///////////////////////////
364 
377 template <typename T>
378 void random_vector(vector<T> &vec, const T min, const T max);
379 
393 template <typename T>
394 void random_vector(vector<T> &vec, const T min, const T max,
395  const std::uint32_t seed);
396 
397 // is_same //////////////////
398 
403 template <typename T, typename U>
404 [[nodiscard]] bool is_same_structure(const T A, const U B) {
405  return false;
406 }
407 
419 template <typename T>
420 [[nodiscard]] bool is_same_structure(const vector<T> &x, const vector<T> &y) {
421  return x.size() == y.size();
422 }
423 
435 template <typename T, typename U>
436 [[nodiscard]] bool is_same_structure(const view1D<T, U> &x,
437  const vector<U> &y) {
438  return x.size() == y.size();
439 }
440 
452 template <typename T, typename U>
453 [[nodiscard]] bool is_same_structure(const vector<U> &x,
454  const view1D<T, U> &y) {
455  return x.size() == y.size();
456 }
457 
469 template <typename T, typename U, typename V>
470 [[nodiscard]] bool is_same_structure(const view1D<T, V> &x,
471  const view1D<U, V> &y) {
472  return x.size() == y.size();
473 }
474 
486 template <typename T>
487 [[nodiscard]] bool is_same_structure(const matrix::Dense<T> &A,
488  const matrix::Dense<T> &B);
489 
501 template <typename T>
502 [[nodiscard]] bool is_same_structure(const matrix::COO<T> &A,
503  const matrix::COO<T> &B);
504 
516 template <typename T>
517 [[nodiscard]] bool is_same_structure(const matrix::CRS<T> &A,
518  const matrix::CRS<T> &B);
519 
531 template <typename T>
532 [[nodiscard]] bool is_same_structure(const matrix::LinearOperator<T> &A,
533  const matrix::LinearOperator<T> &B);
534 
546 template <typename T, typename U>
547 [[nodiscard]] bool is_same_structure(const view_Dense<T, U> &A,
548  const matrix::Dense<U> &B);
549 
561 template <typename T, typename U>
562 [[nodiscard]] bool is_same_structure(const matrix::Dense<U> &A,
563  const view_Dense<T, U> &B);
564 
576 template <typename T, typename U, typename V>
577 [[nodiscard]] bool is_same_structure(const view_Dense<T, V> &A,
578  const view_Dense<U, V> &B);
579 
591 template <typename T>
592 [[nodiscard]] bool is_same_structure(const tensor::tensor_Dense<T> &A,
593  const tensor::tensor_Dense<T> &B);
594 
606 template <typename T>
607 [[nodiscard]] bool is_same_structure(const tensor::tensor_COO<T> &A,
608  const tensor::tensor_COO<T> &B);
609 
621 template <typename T, typename U>
622 [[nodiscard]] bool is_same_structure(const view_tensor_Dense<T, U> &A,
623  const tensor::tensor_Dense<U> &B);
624 
636 template <typename T, typename U>
637 [[nodiscard]] bool is_same_structure(const tensor::tensor_Dense<U> &A,
638  const view_tensor_Dense<T, U> &B);
639 
651 template <typename T, typename U, typename V>
652 [[nodiscard]] bool is_same_structure(const view_tensor_Dense<T, V> &A,
653  const view_tensor_Dense<U, V> &B);
654 
666 template <typename T>
667 [[nodiscard]] bool is_same_structure(const tensor::tensor_CRS<T> &A,
668  const tensor::tensor_CRS<T> &B);
669 
674 template <typename T, typename U, typename V, typename... types>
675 [[nodiscard]] bool is_same_structure(const T &A, const U &B, const V &C,
676  const types &...args) {
677  return is_same_structure(A, B) && is_same_structure(A, C, args...);
678 }
679 
691 template <typename T, typename U>
692 [[nodiscard]] bool is_same_size(const T &x, const U &y) {
693  return x.size() == y.size();
694 }
695 
707 template <typename T>
708 [[nodiscard]] bool is_same_size(const matrix::Dense<T> &A,
709  const matrix::Dense<T> &B);
710 
722 template <typename T>
723 [[nodiscard]] bool is_same_size(const matrix::COO<T> &A,
724  const matrix::COO<T> &B);
725 
737 template <typename T>
738 [[nodiscard]] bool is_same_size(const matrix::CRS<T> &A,
739  const matrix::CRS<T> &B);
740 
752 template <typename T>
753 [[nodiscard]] bool is_same_size(const matrix::LinearOperator<T> &A,
754  const matrix::LinearOperator<T> &B);
755 
767 template <typename T, typename U>
768 [[nodiscard]] bool is_same_size(const view_Dense<T, U> &A,
769  const matrix::Dense<U> &B);
781 template <typename T, typename U>
782 [[nodiscard]] bool is_same_size(const matrix::Dense<U> &A,
783  const view_Dense<T, U> &B);
795 template <typename T, typename U, typename V>
796 [[nodiscard]] bool is_same_size(const view_Dense<T, V> &A,
797  const view_Dense<U, V> &B);
798 
810 template <typename T>
811 [[nodiscard]] bool is_same_size(const tensor::tensor_Dense<T> &A,
812  const tensor::tensor_Dense<T> &B);
813 
825 template <typename T>
826 [[nodiscard]] bool is_same_size(const tensor::tensor_COO<T> &A,
827  const tensor::tensor_COO<T> &B);
828 
840 template <typename T>
841 [[nodiscard]] bool is_same_size(const tensor::tensor_CRS<T> &A,
842  const tensor::tensor_CRS<T> &B);
843 
855 template <typename T, typename U>
856 [[nodiscard]] bool is_same_size(const view_tensor_Dense<T, U> &A,
857  const tensor::tensor_Dense<U> &B);
869 template <typename T, typename U>
870 [[nodiscard]] bool is_same_size(const tensor::tensor_Dense<U> &A,
871  const view_tensor_Dense<T, U> &B);
883 template <typename T, typename U, typename V>
884 [[nodiscard]] bool is_same_size(const view_tensor_Dense<T, V> &A,
885  const view_tensor_Dense<U, V> &B);
886 
891 template <typename T, typename U, typename V, typename... types>
892 [[nodiscard]] bool is_same_size(const T &arg1, const U &arg2, const V &arg3,
893  const types &...args) {
894  return is_same_size(arg1, arg2) && is_same_size(arg1, arg3, args...);
895 }
896 
905 template <typename T, typename U>
906 [[nodiscard]] bool is_same_device_mem_stat(const T &arg1, const U &arg2) {
907  return arg1.get_device_mem_stat() == arg2.get_device_mem_stat();
908 }
909 
918 template <typename T, typename U, typename... types>
919 [[nodiscard]] bool is_same_device_mem_stat(const T &arg1, const U &arg2,
920  const types &...args) {
921  return is_same_device_mem_stat(arg1, arg2) &&
922  is_same_device_mem_stat(arg1, args...);
923 }
924 
925 // create matrix //////////////////
926 
940 template <typename T>
941 [[nodiscard]] matrix::COO<T> band_matrix(const int M, const int N, const int W,
942  const T diag_val, const T val);
943 
958 template <typename T>
959 [[nodiscard]] matrix::COO<T> asym_band_matrix(const int M, const int N,
960  const int W, const T diag_val,
961  const T Uval, const T Lval);
962 
975 template <typename T>
976 [[nodiscard]] matrix::COO<T> random_structure_matrix(const int M, const int N,
977  const int nnzrow,
978  const T val);
979 
992 template <typename T>
993 [[nodiscard]] tensor::tensor_COO<T>
994 random_structure_tensor(const size_t M, const size_t N, const size_t nnzrow,
995  const T val);
996 
1010 template <typename T>
1011 [[nodiscard]] tensor::tensor_COO<T>
1012 random_structure_tensor(const size_t M, const size_t N, const size_t L,
1013  const size_t nnzrow, const T val);
1014 
1028 template <typename T>
1029 [[nodiscard]] tensor::tensor_COO<T>
1030 random_structure_tensor(const size_t K, const size_t M, const size_t N,
1031  const size_t L, const size_t nnzrow, const T val);
1032 
1042 template <typename T> [[nodiscard]] matrix::COO<T> eye(const int M);
1043 
1053 template <typename T> [[nodiscard]] matrix::COO<T> frank_matrix(const int &M);
1054 
1065 template <typename T>
1066 [[nodiscard]] T frank_matrix_eigenvalue(const int &M, const int &N);
1067 
1079 template <typename T>
1080 [[nodiscard]] matrix::COO<T> tridiagonal_toeplitz_matrix(const int &M, T a,
1081  T b);
1082 
1095 template <typename T>
1096 [[nodiscard]] T tridiagonal_toeplitz_matrix_eigenvalue(const int &M, int N, T a,
1097  T b);
1098 
1108 template <typename T>
1109 [[nodiscard]] matrix::COO<T> laplacian_matrix_1D(const int &M);
1110 
1121 template <typename T>
1122 [[nodiscard]] T laplacian_matrix_1D_eigenvalue(const int &M, int N);
1123 
1135 template <typename T>
1136 [[nodiscard]] matrix::COO<T> laplacian_matrix_2D_5p(const int M, const int N);
1137 
1152 template <typename T>
1153 [[nodiscard]] matrix::COO<T> toeplitz_plus_hankel_matrix(const int &M, T a0,
1154  T a1, T a2);
1155 
1169 template <typename T>
1170 [[nodiscard]] T toeplitz_plus_hankel_matrix_eigenvalue(const int &M, int N,
1171  T a0, T a1, T a2, T b0,
1172  T b1, T b2);
1173 
1174 // send///////////////////
1175 
1180 template <typename T> void send(T &x) { x.send(); }
1181 
1186 template <typename T, typename... Types> void send(T &x, Types &...args) {
1187  x.send();
1188  send(args...);
1189 }
1190 
1191 // recv///////////////////
1196 template <typename T> void recv(T &x) { x.recv(); }
1197 
1202 template <typename T, typename... Types> void recv(T &x, Types &...args) {
1203  x.recv();
1204  recv(args...);
1205 }
1206 
1207 // device_free///////////////////
1208 
1213 template <typename T> void device_free(T &x) { x.device_free(); }
1214 
1219 template <typename T, typename... Types>
1220 void device_free(T &x, Types &...args) {
1221  x.device_free();
1222  device_free(args...);
1223 }
1224 
1229 [[nodiscard]] bool build_with_avx();
1230 
1235 [[nodiscard]] bool build_with_avx2();
1236 
1241 [[nodiscard]] bool build_with_avx512();
1242 
1247 [[nodiscard]] bool build_with_mpi();
1248 
1253 [[nodiscard]] bool build_with_gpu();
1254 
1259 [[nodiscard]] bool build_with_mkl();
1260 
1266 [[nodiscard]] bool build_with_lapack();
1267 
1273 [[nodiscard]] bool build_with_cblas();
1276 } // namespace util
1277 } // namespace monolish
monolish::matrix::COO
Coodinate (COO) format Matrix (need to sort)
Definition: monolish_coo.hpp:47
monolish::matrix::CRS
Compressed Row Storage (CRS) format Matrix.
Definition: monolish_crs.hpp:39
monolish::matrix::Dense
Dense format Matrix.
Definition: monolish_dense.hpp:30
monolish::matrix::LinearOperator
Linear Operator imitating Matrix.
Definition: monolish_linearoperator.hpp:35
monolish::tensor::tensor_COO
Definition: monolish_tensor_coo.hpp:12
monolish::tensor::tensor_CRS
Definition: monolish_tensor_crs.hpp:12
monolish::tensor::tensor_Dense
Definition: monolish_tensor_dense.hpp:13
monolish::vector::size
size_t size() const
get vector size
Definition: monolish_vector.hpp:357
monolish::view1D::size
size_t size() const
get view1D size (range)
Definition: monolish_view1D.hpp:214
monolish::view_Dense
Dense view class.
Definition: monolish_view_dense.hpp:50
monolish::view_tensor_Dense
Dense view class.
Definition: monolish_view_tensor_dense.hpp:50
monolish::util::get_num_devices
int get_num_devices()
get the number of devices
monolish::util::set_default_device
bool set_default_device(size_t device_num)
set default device number
monolish::util::get_default_device
int get_default_device()
get default device number
monolish::util::send
void send(T &x)
send data to GPU
Definition: monolish_common.hpp:1180
monolish::util::recv
void recv(T &x)
recv. and free data from GPU
Definition: monolish_common.hpp:1196
monolish::util::device_free
void device_free(T &x)
free data of GPU
Definition: monolish_common.hpp:1213
monolish::util::get_residual_l2
double get_residual_l2(const matrix::Dense< double > &A, const vector< double > &x, const vector< double > &y)
get nrm |b-Ax|_2
monolish::util::build_with_mpi
bool build_with_mpi()
get build option (true: enable MPI, false: disable MPI)
monolish::util::build_with_gpu
bool build_with_gpu()
get build option (true: enable gpu, false: disable gpu)
monolish::util::build_with_avx2
bool build_with_avx2()
get build option (true: with avx2, false: without avx2)
monolish::util::build_with_lapack
bool build_with_lapack()
get build option (true: with lapack, false: without lapack (=with intel mkl))
monolish::util::build_with_cblas
bool build_with_cblas()
get build option (true: with cblas, false: without cblas (=with intel mkl))
monolish::util::build_with_avx
bool build_with_avx()
get build option (true: with avx, false: without avx)
monolish::util::build_with_mkl
bool build_with_mkl()
get build option (true: with intel mkl, false: without intel mkl)
monolish::util::build_with_avx512
bool build_with_avx512()
get build option (true: with avx512, false: without avx512)
monolish::util::is_same_structure
bool is_same_structure(const T A, const U B)
compare matrix structure
Definition: monolish_common.hpp:404
monolish::util::is_same_size
bool is_same_size(const T &x, const U &y)
compare size of vector or 1Dview (same as is_same_structure())
Definition: monolish_common.hpp:692
monolish::util::is_same_device_mem_stat
bool is_same_device_mem_stat(const T &arg1, const U &arg2)
compare same device memory status
Definition: monolish_common.hpp:906
monolish::util::solver_check
bool solver_check(const int err)
check error
monolish::util::random_structure_tensor
tensor::tensor_COO< T > random_structure_tensor(const size_t M, const size_t N, const size_t nnzrow, const T val)
create random structure tensor (index is decided by random)
monolish::util::random_vector
void random_vector(vector< T > &vec, const T min, const T max)
create random vector
monolish::util::tridiagonal_toeplitz_matrix
matrix::COO< T > tridiagonal_toeplitz_matrix(const int &M, T a, T b)
create tridiagonal Toeplitz matrix
monolish::util::laplacian_matrix_2D_5p
matrix::COO< T > laplacian_matrix_2D_5p(const int M, const int N)
create two dimensional Laplacian matrix using the five point central difference scheme
monolish::util::toeplitz_plus_hankel_matrix
matrix::COO< T > toeplitz_plus_hankel_matrix(const int &M, T a0, T a1, T a2)
create Toeplitz-plus-Hankel matrix
monolish::util::tridiagonal_toeplitz_matrix_eigenvalue
T tridiagonal_toeplitz_matrix_eigenvalue(const int &M, int N, T a, T b)
Nth smallest eigenvalue of MxM tridiagonal Toeplitz matrix.
monolish::util::laplacian_matrix_1D_eigenvalue
T laplacian_matrix_1D_eigenvalue(const int &M, int N)
Nth smallest eigenvalue of 1D Laplacian matrix.
monolish::util::laplacian_matrix_1D
matrix::COO< T > laplacian_matrix_1D(const int &M)
create 1D Laplacian matrix
monolish::util::asym_band_matrix
matrix::COO< T > asym_band_matrix(const int M, const int N, const int W, const T diag_val, const T Uval, const T Lval)
create asymmetric band matrix
monolish::util::random_structure_matrix
matrix::COO< T > random_structure_matrix(const int M, const int N, const int nnzrow, const T val)
create random structure matrix (column number is decided by random)
monolish::util::toeplitz_plus_hankel_matrix_eigenvalue
T toeplitz_plus_hankel_matrix_eigenvalue(const int &M, int N, T a0, T a1, T a2, T b0, T b1, T b2)
Nth smallest eigenvalue of GEVP Ax=lBx of Toeplitz-plus-Hankel matrixes A, B.
monolish::util::frank_matrix
matrix::COO< T > frank_matrix(const int &M)
create Frank matrix
monolish::util::band_matrix
matrix::COO< T > band_matrix(const int M, const int N, const int W, const T diag_val, const T val)
create band matrix
monolish::util::frank_matrix_eigenvalue
T frank_matrix_eigenvalue(const int &M, const int &N)
Nth eigenvalue from the bottom of MxM Frank matrix.
monolish::util::eye
matrix::COO< T > eye(const int M)
create band matrix
monolish::util::set_log_filename
void set_log_filename(const std::string filename)
Specifying the log finename.
monolish::util::set_log_level
void set_log_level(const size_t Level)
Specifying the log level.
monolish::vml::max
void max(const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
Create a new CRS matrix with greatest elements of two matrices (C[0:nnz] = max(A[0:nnz],...
monolish::vml::min
void min(const matrix::CRS< double > &A, const matrix::CRS< double > &B, matrix::CRS< double > &C)
Create a new CRS matrix with smallest elements of two matrices (C[0:nnz] = min(A[0:nnz],...
monolish_dense.hpp
monolish_logger.hpp
monolish_matrix.hpp
monolish_tensor.hpp
monolish_vector.hpp
monolish_view1D.hpp
monolish_view_dense.hpp
monolish_view_tensor_dense.hpp
monolish
monolish namespaces
Definition: monolish_matrix_blas.hpp:5
Generated by doxygen 1.9.1