-
Notifications
You must be signed in to change notification settings - Fork 15
/
Copy pathblas_sparse_proto.h
257 lines (209 loc) · 12.1 KB
/
blas_sparse_proto.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
#ifndef BLAS_SPARSE_PROTO_H
#define BLAS_SPARSE_PROTO_H
typedef int blas_sparse_matrix;
/* Level 1 Computational Routines */
void BLAS_susdot( enum blas_conj_type conj, int nz, const float *x,
const int *indx, const float *y, int incy, float *r,
enum blas_base_type index_base );
void BLAS_dusdot( enum blas_conj_type conj, int nz, const double *x,
const int *indx, const double *y, int incy, double *r,
enum blas_base_type index_base );
void BLAS_cusdot( enum blas_conj_type conj, int nz, const void *x,
const int *indx, const void *y, int incy, void *r,
enum blas_base_type index_base );
void BLAS_zusdot( enum blas_conj_type conj, int nz, const void *x,
const int *indx, const void *y, int incy, void *r,
enum blas_base_type index_base );
void BLAS_susaxpy( int nz, float alpha, const float *x, const int *indx,
float *y, int incy, enum blas_base_type index_base );
void BLAS_dusaxpy( int nz, double alpha, const double *x, const int *indx,
double *y, int incy, enum blas_base_type index_base );
void BLAS_cusaxpy( int nz, const void *alpha, const void *x, const int *indx,
void *y, int incy, enum blas_base_type index_base );
void BLAS_zusaxpy( int nz, const void *alpha, const void *x, const int *indx,
void *y, int incy, enum blas_base_type index_base );
void BLAS_susga( int nz, const float *y, int incy, float *x, const int *indx,
enum blas_base_type index_base );
void BLAS_dusga( int nz, const double *y, int incy, double *x, const int *indx,
enum blas_base_type index_base );
void BLAS_cusga( int nz, const void *y, int incy, void *x, const int *indx,
enum blas_base_type index_base );
void BLAS_zusga( int nz, const void *y, int incy, void *x, const int *indx,
enum blas_base_type index_base );
void BLAS_susgz( int nz, float *y, int incy, float *x, const int *indx,
enum blas_base_type index_base );
void BLAS_dusgz( int nz, double *y, int incy, double *x, const int *indx,
enum blas_base_type index_base );
void BLAS_cusgz( int nz, void *y, int incy, void *x, const int *indx,
enum blas_base_type index_base );
void BLAS_zusgz( int nz, void *y, int incy, void *x, const int *indx,
enum blas_base_type index_base );
void BLAS_sussc( int nz, const float *x, float *y, int incy, const int *indx,
enum blas_base_type index_base );
void BLAS_dussc( int nz, const double *x, double *y, int incy, const int *indx,
enum blas_base_type index_base );
void BLAS_cussc( int nz, const void *x, void *y, int incy, const int *indx,
enum blas_base_type index_base );
void BLAS_zussc( int nz, const void *x, void *y, int incy, const int *indx,
enum blas_base_type index_base );
/* Level 2 Computational Routines */
int BLAS_susmv( enum blas_trans_type transa, float alpha,
blas_sparse_matrix A, const float *x, int incx, float *y, int incy );
int BLAS_dusmv( enum blas_trans_type transa, double alpha,
blas_sparse_matrix A, const double *x, int incx, double *y, int incy );
int BLAS_cusmv( enum blas_trans_type transa, const void *alpha,
blas_sparse_matrix A, const void *x, int incx, void *y, int incy );
int BLAS_zusmv( enum blas_trans_type transa, const void *alpha,
blas_sparse_matrix A, const void *x, int incx, void *y, int incy );
int BLAS_sussv( enum blas_trans_type transt, float alpha,
blas_sparse_matrix T, float *x, int incx );
int BLAS_dussv( enum blas_trans_type transt, double alpha,
blas_sparse_matrix T, double *x, int incx );
int BLAS_cussv( enum blas_trans_type transt, const void *alpha,
blas_sparse_matrix T, void *x, int incx );
int BLAS_zussv( enum blas_trans_type transt, const void *alpha,
blas_sparse_matrix T, void *x, int incx );
/* Level 3 Computational Routines */
int BLAS_susmm( enum blas_order_type order, enum blas_trans_type transa,
int nrhs, float alpha, blas_sparse_matrix A, const float *b, int ldb,
float *c, int ldc );
int BLAS_dusmm( enum blas_order_type order, enum blas_trans_type transa,
int nrhs, double alpha, blas_sparse_matrix A, const double *b,
int ldb, double *c, int ldc );
int BLAS_cusmm( enum blas_order_type order, enum blas_trans_type transa,
int nrhs, const void *alpha, blas_sparse_matrix A, const void *b,
int ldb, void *c, int ldc );
int BLAS_zusmm( enum blas_order_type order, enum blas_trans_type transa,
int nrhs, const void *alpha, blas_sparse_matrix A, const void *b,
int ldb, void *c, int ldc );
int BLAS_sussm( enum blas_order_type order, enum blas_trans_type transt,
int nrhs, float alpha, int t, float *b, int ldb );
int BLAS_dussm( enum blas_order_type order, enum blas_trans_type transt,
int nrhs, double alpha, int t, double *b, int ldb );
int BLAS_cussm( enum blas_order_type order, enum blas_trans_type transt,
int nrhs, const void *alpha, int t, void *b, int ldb );
int BLAS_zussm( enum blas_order_type order, enum blas_trans_type transt,
int nrhs, const void *alpha, int t, void *b, int ldb );
/* Handle Management Routines */
/* Creation Routines */
blas_sparse_matrix BLAS_suscr_begin( int m, int n );
blas_sparse_matrix BLAS_duscr_begin( int m, int n );
blas_sparse_matrix BLAS_cuscr_begin( int m, int n );
blas_sparse_matrix BLAS_zuscr_begin( int m, int n );
blas_sparse_matrix BLAS_suscr_block_begin( int Mb, int Nb, int k, int l );
blas_sparse_matrix BLAS_duscr_block_begin( int Mb, int Nb, int k, int l );
blas_sparse_matrix BLAS_cuscr_block_begin( int Mb, int Nb, int k, int l );
blas_sparse_matrix BLAS_zuscr_block_begin( int Mb, int Nb, int k, int l );
blas_sparse_matrix BLAS_suscr_variable_block_begin( int Mb, int Nb,
const int *k, const int *l );
blas_sparse_matrix BLAS_duscr_variable_block_begin( int Mb, int Nb,
const int *k, const int *l );
blas_sparse_matrix BLAS_cuscr_variable_block_begin( int Mb, int Nb,
const int *k, const int *l );
blas_sparse_matrix BLAS_zuscr_variable_block_begin( int Mb, int Nb,
const int *k, const int *l );
/* Insertion Routines */
int BLAS_suscr_insert_entry( blas_sparse_matrix A, float val, int i, int j );
int BLAS_duscr_insert_entry( blas_sparse_matrix A, double val, int i, int j );
int BLAS_cuscr_insert_entry( blas_sparse_matrix A, const void *val, int i, int j );
int BLAS_zuscr_insert_entry( blas_sparse_matrix A, const void *val, int i, int j );
int BLAS_suscr_insert_entries( blas_sparse_matrix A, int nz, const float *val,
const int *indx, const int *jndx );
int BLAS_duscr_insert_entries( blas_sparse_matrix A, int nz, const double *val,
const int *indx, const int *jndx );
int BLAS_cuscr_insert_entries( blas_sparse_matrix A, int nz, const void *val,
const int *indx, const int *jndx );
int BLAS_zuscr_insert_entries( blas_sparse_matrix A, int nz, const void *val,
const int *indx, const int *jndx );
int BLAS_suscr_insert_col( blas_sparse_matrix A, int j, int nz,
const float *val, const int *indx );
int BLAS_duscr_insert_col( blas_sparse_matrix A, int j, int nz,
const double *val, const int *indx );
int BLAS_cuscr_insert_col( blas_sparse_matrix A, int j, int nz,
const void *val, const int *indx );
int BLAS_zuscr_insert_col( blas_sparse_matrix A, int j, int nz,
const void *val, const int *indx );
int BLAS_suscr_insert_row( blas_sparse_matrix A, int i, int nz,
const float *val, const int *indx );
int BLAS_duscr_insert_row( blas_sparse_matrix A, int i, int nz,
const double *val, const int *indx );
int BLAS_cuscr_insert_row( blas_sparse_matrix A, int i, int nz,
const void *val, const int *indx );
int BLAS_zuscr_insert_row( blas_sparse_matrix A, int i, int nz,
const void *val, const int *indx );
int BLAS_suscr_insert_clique( blas_sparse_matrix A, const int k, const int l,
const float *val, const int row_stride,
const int col_stride, const int *indx,
const int *jndx );
int BLAS_duscr_insert_clique( blas_sparse_matrix A, const int k, const int l,
const double *val, const int row_stride,
const int col_stride, const int *indx,
const int *jndx );
int BLAS_cuscr_insert_clique( blas_sparse_matrix A, const int k, const int l,
const void *val, const int row_stride,
const int col_stride, const int *indx,
const int *jndx );
int BLAS_zuscr_insert_clique( blas_sparse_matrix A, const int k, const int l,
const void *val, const int row_stride,
const int col_stride, const int *indx,
const int *jndx );
int BLAS_suscr_insert_block( blas_sparse_matrix A, const float *val,
int row_stride, int col_stride, int i, int j );
int BLAS_duscr_insert_block( blas_sparse_matrix A, const double *val,
int row_stride, int col_stride, int i, int j );
int BLAS_cuscr_insert_block( blas_sparse_matrix A, const void *val,
int row_stride, int col_stride, int i, int j );
int BLAS_zuscr_insert_block( blas_sparse_matrix A, const void *val,
int row_stride, int col_stride, int i, int j );
/* Completion of Construction Routines */
int BLAS_suscr_end( blas_sparse_matrix A );
int BLAS_duscr_end( blas_sparse_matrix A );
int BLAS_cuscr_end( blas_sparse_matrix A );
int BLAS_zuscr_end( blas_sparse_matrix A );
/* Matrix Property Routines */
int BLAS_usgp( blas_sparse_matrix A, int pname );
int BLAS_ussp( blas_sparse_matrix A, int pname );
/* Destruction Routine */
int BLAS_usds( blas_sparse_matrix A );
/* custom */
blas_sparse_matrix create(int row, int col);
void destroy(blas_sparse_matrix A);
/* column means and variances */
void scolmeans(blas_sparse_matrix A, float *means);
void scolvars(blas_sparse_matrix A, float *vars);
void srowmeans(blas_sparse_matrix A, float *means);
void srowvars(blas_sparse_matrix A, float *vars);
/* scale rows/cols */
void sscalecols(blas_sparse_matrix A, float *s);
void sscalerows(blas_sparse_matrix A, float *s);
/* select row subset */
blas_sparse_matrix srowsubset(blas_sparse_matrix A, int first_row, int nrow);
/* construct from CSR data */
blas_sparse_matrix suscr_csr(int m, int n, float *x, int *row, int *col);
/* set element (set to zero will delete entry) */
void ssetelement( blas_sparse_matrix A, int row, int col, float val );
void ssetelement( blas_sparse_matrix A, int idx, float val );
/* get element reference */
float &sgetelement( blas_sparse_matrix A, int row, int col);
float &sgetelement( blas_sparse_matrix A, int idx );
/* sgemm routines with sparse matrix being lhs (A) or rhs (B) of the product */
void susgemm(enum blas_side_type sidea, enum blas_trans_type transa, enum blas_trans_type transb,
int nohs, const float &alpha, blas_sparse_matrix A, const float *B, int ldB, const float &beta, float *C, int ldC);
void susgemma(enum blas_order_type order, enum blas_trans_type transa, enum blas_trans_type transb,
int nrhs, const float &alpha, blas_sparse_matrix A, const float *B, int ldB, const float &beta,
float *C, int ldC);
void susgemmb(enum blas_order_type order, enum blas_trans_type transa, enum blas_trans_type transb,
int nlhs, const float &alpha, const float *A, int ldA, blas_sparse_matrix B, const float &beta,
float *C, int ldC);
/* checks whether A is a valid handle */
bool handle_valid(blas_sparse_matrix A);
/* debug */
namespace NIST_SPBLAS
{void print(int A);}
#include <cstdio>
#define dbg_printf(...) do { \
printf(__VA_ARGS__); \
fflush(stdout); \
} while (0)
#endif
/* BLAS_SPARSE_PROTO_H */