MAGMA  magma-1.4.0
Matrix Algebra on GPU and Multicore Architectures
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
magma_types.h
Go to the documentation of this file.
1 /*
2  -- MAGMA (version 1.4.0) --
3  Univ. of Tennessee, Knoxville
4  Univ. of California, Berkeley
5  Univ. of Colorado, Denver
6  August 2013
7 */
8 
9 #ifndef MAGMA_TYPES_H
10 #define MAGMA_TYPES_H
11 
12 #include <stdint.h>
13 #include <assert.h>
14 
15 
16 // ========================================
17 // To use int64_t, link with mkl_intel_ilp64 or similar (instead of mkl_intel_lp64).
18 #ifdef MAGMA_ILP64
19 typedef int64_t magma_int_t;
20 typedef int64_t magma_err_t;
21 #else
22 typedef int magma_int_t;
23 typedef int magma_err_t;
24 #endif
25 
26 // Define new type that will not be changed by the generator (matches PLASMA)
27 typedef double real_Double_t;
28 
29 
30 // ========================================
31 // define types specific to implementation (CUDA, OpenCL, MIC)
32 // define macros to deal with complex numbers
33 #if HAVE_CUBLAS
34  #ifndef CUBLAS_V2_H_
35  #include <cublas.h>
36  #endif
37 
38  typedef cudaStream_t magma_queue_t;
39  typedef cudaEvent_t magma_event_t;
40  typedef int magma_device_t;
41 
42  typedef cuDoubleComplex magmaDoubleComplex;
43  typedef cuFloatComplex magmaFloatComplex;
44 
45  #define MAGMA_Z_MAKE(r,i) make_cuDoubleComplex(r, i)
46  #define MAGMA_Z_REAL(a) (a).x
47  #define MAGMA_Z_IMAG(a) (a).y
48  #define MAGMA_Z_SET2REAL(a,r) { (a).x = (r); (a).y = 0.0; }
49  #define MAGMA_Z_ADD(a, b) cuCadd(a, b)
50  #define MAGMA_Z_SUB(a, b) cuCsub(a, b)
51  #define MAGMA_Z_MUL(a, b) cuCmul(a, b)
52  #define MAGMA_Z_DIV(a, b) cuCdiv(a, b)
53  #define MAGMA_Z_ABS(a) cuCabs(a)
54  #define MAGMA_Z_CNJG(a) cuConj(a)
55  #define MAGMA_Z_DSCALE(v,t,s) {(v).x = (t).x/(s); (v).y = (t).y/(s);}
56 
57  #define MAGMA_C_MAKE(r,i) make_cuFloatComplex(r, i)
58  #define MAGMA_C_REAL(a) (a).x
59  #define MAGMA_C_IMAG(a) (a).y
60  #define MAGMA_C_SET2REAL(a,r) { (a).x = (r); (a).y = 0.0; }
61  #define MAGMA_C_ADD(a, b) cuCaddf(a, b)
62  #define MAGMA_C_SUB(a, b) cuCsubf(a, b)
63  #define MAGMA_C_MUL(a, b) cuCmulf(a, b)
64  #define MAGMA_C_DIV(a, b) cuCdivf(a, b)
65  #define MAGMA_C_ABS(a) cuCabsf(a)
66  #define MAGMA_C_CNJG(a) cuConjf(a)
67  #define MAGMA_C_SSCALE(v,t,s) {(v).x = (t).x/(s); (v).y = (t).y/(s);}
68 
69 #elif HAVE_clAmdBlas
70  #if defined(__APPLE__) || defined(__MACOSX)
71  #include "my_amdblas.h"
72  #else
73  #include <clAmdBlas.h>
74  #endif
75 
76  typedef cl_command_queue magma_queue_t;
77  typedef cl_event magma_event_t;
78  typedef cl_device_id magma_device_t;
79 
80  typedef DoubleComplex magmaDoubleComplex;
81  typedef FloatComplex magmaFloatComplex;
82 
83  #define MAGMA_Z_MAKE(r,i) doubleComplex(r,i)
84  #define MAGMA_Z_REAL(a) (a).x
85  #define MAGMA_Z_IMAG(a) (a).y
86  #define MAGMA_Z_SET2REAL(a,r) { (a).x = (r); (a).y = 0.0; }
87  #define MAGMA_Z_ADD(a, b) MAGMA_Z_MAKE((a).x+(b).x, (a).y+(b).y)
88  #define MAGMA_Z_SUB(a, b) MAGMA_Z_MAKE((a).x-(b).x, (a).y-(b).y)
89  #define MAGMA_Z_ABS(a) magma_cabs(a)
90  #define MAGMA_Z_CNJG(a) MAGMA_Z_MAKE((a).x, -(a).y)
91  #define MAGMA_Z_DSCALE(v,t,s) {(v).x = (t).x/(s); (v).y = (t).y/(s);}
92 
93  #define MAGMA_C_MAKE(r,i) floatComplex(r,i)
94  #define MAGMA_C_REAL(a) (a).x
95  #define MAGMA_C_IMAG(a) (a).y
96  #define MAGMA_C_SET2REAL(a,r) { (a).x = (r); (a).y = 0.0; }
97  #define MAGMA_C_ADD(a, b) MAGMA_C_MAKE((a).x+(b).x, (a).y+(b).y)
98  #define MAGMA_C_SUB(a, b) MAGMA_C_MAKE((a).x-(b).x, (a).y-(b).y)
99  #define MAGMA_C_ABS(a) magma_cabsf(a)
100  #define MAGMA_C_CNJG(a) MAGMA_C_MAKE((a).x, -(a).y)
101  #define MAGMA_C_SSCALE(v,t,s) {(v).x = (t).x/(s); (v).y = (t).y/(s);}
102 
103 #elif HAVE_MIC
104  #include <stdio.h>
105  #include <stdlib.h>
106  #include <stdint.h>
107  #include <unistd.h>
108  #include <fcntl.h>
109  #include <string.h>
110  #include <sys/mman.h>
111  #include <sys/ioctl.h>
112  #include <sys/time.h>
113  #include <scif.h>
114  //#include <mkl.h>
115 
116  typedef int magma_queue_t;
117  typedef int magma_event_t;
118  typedef int magma_device_t;
119 
120  #include <complex>
121  typedef std::complex<float> magmaFloatComplex;
122  typedef std::complex<double> magmaDoubleComplex;
123 
124  #define MAGMA_Z_MAKE(r, i) std::complex<double>(r,i)
125  #define MAGMA_Z_REAL(x) (x).real()
126  #define MAGMA_Z_IMAG(x) (x).imag()
127  #define MAGMA_Z_SET2REAL(a,r) { (a).real() = (r); (a).imag() = 0.0; }
128  #define MAGMA_Z_ADD(a, b) ((a)+(b))
129  #define MAGMA_Z_SUB(a, b) ((a)-(b))
130  #define MAGMA_Z_MUL(a, b) ((a)*(b))
131  #define MAGMA_Z_DIV(a, b) ((a)/(b))
132  #define MAGMA_Z_CNJG(a) conj(a)
133  #define MAGMA_Z_DSCALE(v,t,s) ((v) = (t)/(s))
134 
135  #define MAGMA_C_MAKE(r, i) std::complex<float> (r,i)
136  #define MAGMA_C_REAL(x) (x).real()
137  #define MAGMA_C_IMAG(x) (x).imag()
138  #define MAGMA_C_SET2REAL(a,r) { (a).real() = (r); (a).imag() = 0.0; }
139  #define MAGMA_C_ADD(a, b) ((a)+(b))
140  #define MAGMA_C_SUB(a, b) ((a)-(b))
141  #define MAGMA_C_MUL(a, b) ((a)*(b))
142  #define MAGMA_C_DIV(a, b) ((a)/(b))
143  #define MAGMA_C_CNJG(a) conj(a)
144  #define MAGMA_C_SSCALE(v,t,s) ((v) = (t)/(s))
145 #else
146  #error "One of HAVE_CUBLAS, HAVE_clAmdBlas, or HAVE_MIC must be defined. This typically happens in Makefile.internal."
147 #endif
148 
149 #define MAGMA_Z_EQUAL(a,b) (MAGMA_Z_REAL(a)==MAGMA_Z_REAL(b) && MAGMA_Z_IMAG(a)==MAGMA_Z_IMAG(b))
150 #define MAGMA_Z_NEGATE(a) MAGMA_Z_MAKE( -MAGMA_Z_REAL(a), -MAGMA_Z_IMAG(a))
151 
152 #define MAGMA_C_EQUAL(a,b) (MAGMA_C_REAL(a)==MAGMA_C_REAL(b) && MAGMA_C_IMAG(a)==MAGMA_C_IMAG(b))
153 #define MAGMA_C_NEGATE(a) MAGMA_C_MAKE( -MAGMA_C_REAL(a), -MAGMA_C_IMAG(a))
154 
155 #define MAGMA_D_MAKE(r,i) (r)
156 #define MAGMA_D_REAL(x) (x)
157 #define MAGMA_D_IMAG(x) (0.0)
158 #define MAGMA_D_SET2REAL(a,r) (a) = (r)
159 #define MAGMA_D_ADD(a, b) ((a) + (b))
160 #define MAGMA_D_SUB(a, b) ((a) - (b))
161 #define MAGMA_D_MUL(a, b) ((a) * (b))
162 #define MAGMA_D_DIV(a, b) ((a) / (b))
163 #define MAGMA_D_ABS(a) ((a)>0?(a):-(a))
164 #define MAGMA_D_CNJG(a) (a)
165 #define MAGMA_D_EQUAL(a,b) ((a) == (b))
166 #define MAGMA_D_NEGATE(a) (-a)
167 #define MAGMA_D_DSCALE(v, t, s) (v) = (t)/(s)
168 
169 #define MAGMA_S_MAKE(r,i) (r)
170 #define MAGMA_S_REAL(x) (x)
171 #define MAGMA_S_IMAG(x) (0.0)
172 #define MAGMA_S_SET2REAL(a,r) (a) = (r)
173 #define MAGMA_S_ADD(a, b) ((a) + (b))
174 #define MAGMA_S_SUB(a, b) ((a) - (b))
175 #define MAGMA_S_MUL(a, b) ((a) * (b))
176 #define MAGMA_S_DIV(a, b) ((a) / (b))
177 #define MAGMA_S_ABS(a) ((a)>0?(a):-(a))
178 #define MAGMA_S_CNJG(a) (a)
179 #define MAGMA_S_EQUAL(a,b) ((a) == (b))
180 #define MAGMA_S_NEGATE(a) (-a)
181 #define MAGMA_S_SSCALE(v, t, s) (v) = (t)/(s)
182 
183 #define MAGMA_Z_ZERO MAGMA_Z_MAKE( 0.0, 0.0)
184 #define MAGMA_Z_ONE MAGMA_Z_MAKE( 1.0, 0.0)
185 #define MAGMA_Z_HALF MAGMA_Z_MAKE( 0.5, 0.0)
186 #define MAGMA_Z_NEG_ONE MAGMA_Z_MAKE(-1.0, 0.0)
187 #define MAGMA_Z_NEG_HALF MAGMA_Z_MAKE(-0.5, 0.0)
188 
189 #define MAGMA_C_ZERO MAGMA_C_MAKE( 0.0, 0.0)
190 #define MAGMA_C_ONE MAGMA_C_MAKE( 1.0, 0.0)
191 #define MAGMA_C_HALF MAGMA_C_MAKE( 0.5, 0.0)
192 #define MAGMA_C_NEG_ONE MAGMA_C_MAKE(-1.0, 0.0)
193 #define MAGMA_C_NEG_HALF MAGMA_C_MAKE(-0.5, 0.0)
194 
195 #define MAGMA_D_ZERO ( 0.0)
196 #define MAGMA_D_ONE ( 1.0)
197 #define MAGMA_D_HALF ( 0.5)
198 #define MAGMA_D_NEG_ONE (-1.0)
199 #define MAGMA_D_NEG_HALF (-0.5)
200 
201 #define MAGMA_S_ZERO ( 0.0)
202 #define MAGMA_S_ONE ( 1.0)
203 #define MAGMA_S_HALF ( 0.5)
204 #define MAGMA_S_NEG_ONE (-1.0)
205 #define MAGMA_S_NEG_HALF (-0.5)
206 
207 #ifndef CBLAS_SADDR
208 #define CBLAS_SADDR(a) &(a)
209 #endif
210 
211 #if HAVE_clAmdBlas
212  // OpenCL uses opaque memory references on GPU
213  typedef cl_mem magma_ptr;
214  typedef cl_mem magmaInt_ptr;
215  typedef cl_mem magmaFloat_ptr;
216  typedef cl_mem magmaDouble_ptr;
217  typedef cl_mem magmaFloatComplex_ptr;
218  typedef cl_mem magmaDoubleComplex_ptr;
219 
220  typedef cl_mem magma_const_ptr;
221  typedef cl_mem magmaInt_const_ptr;
222  typedef cl_mem magmaFloat_const_ptr;
223  typedef cl_mem magmaDouble_const_ptr;
224  typedef cl_mem magmaFloatComplex_const_ptr;
225  typedef cl_mem magmaDoubleComplex_const_ptr;
226 #else
227  // MIC and CUDA use regular pointers on GPU
228  typedef void *magma_ptr;
230  typedef float *magmaFloat_ptr;
231  typedef double *magmaDouble_ptr;
232  typedef magmaFloatComplex *magmaFloatComplex_ptr;
233  typedef magmaDoubleComplex *magmaDoubleComplex_ptr;
234 
235  typedef void const *magma_const_ptr;
237  typedef float const *magmaFloat_const_ptr;
238  typedef double const *magmaDouble_const_ptr;
239  typedef magmaFloatComplex const *magmaFloatComplex_const_ptr;
240  typedef magmaDoubleComplex const *magmaDoubleComplex_const_ptr;
241 #endif
242 
243 
244 // ========================================
245 // MAGMA constants
246 
247 // ----------------------------------------
248 #define MAGMA_VERSION_MAJOR 1
249 #define MAGMA_VERSION_MINOR 4
250 #define MAGMA_VERSION_MICRO 0
251 
252 // stage is "svn", "beta#", "rc#" (release candidate), or blank ("") for final release
253 #define MAGMA_VERSION_STAGE ""
254 
255 #define MagmaMaxGPUs 8
256 
257 
258 // ----------------------------------------
259 // Return codes
260 // LAPACK argument errors are < 0 but > MAGMA_ERR.
261 // MAGMA errors are < MAGMA_ERR.
262 #define MAGMA_SUCCESS 0
263 #define MAGMA_ERR -100
264 #define MAGMA_ERR_NOT_INITIALIZED -101
265 #define MAGMA_ERR_REINITIALIZED -102
266 #define MAGMA_ERR_NOT_SUPPORTED -103
267 #define MAGMA_ERR_ILLEGAL_VALUE -104
268 #define MAGMA_ERR_NOT_FOUND -105
269 #define MAGMA_ERR_ALLOCATION -106
270 #define MAGMA_ERR_INTERNAL_LIMIT -107
271 #define MAGMA_ERR_UNALLOCATED -108
272 #define MAGMA_ERR_FILESYSTEM -109
273 #define MAGMA_ERR_UNEXPECTED -110
274 #define MAGMA_ERR_SEQUENCE_FLUSHED -111
275 #define MAGMA_ERR_HOST_ALLOC -112
276 #define MAGMA_ERR_DEVICE_ALLOC -113
277 #define MAGMA_ERR_CUDASTREAM -114
278 #define MAGMA_ERR_INVALID_PTR -115
279 #define MAGMA_ERR_UNKNOWN -116
280 
281 
282 // ----------------------------------------
283 // parameter constants
284 // [In the future, these will be numbered, as indicated by comments,
285 // [instead of character constants.]
286 // numbering is consistent with CBLAS and PLASMA; see plasma/include/plasma.h
287 #define MagmaRowMajor 'R' /* 101 */
288 #define MagmaColMajor 'C' /* 102 */
289 
290 #define MagmaNoTrans 'N' /* 111 */
291 #define MagmaTrans 'T' /* 112 */
292 #define MagmaConjTrans 'C' /* 113 */
293 
294 #define MagmaUpper 'U' /* 121 */
295 #define MagmaLower 'L' /* 122 */
296 #define MagmaUpperLower 'F' /* 123 */
297 #define MagmaFull 'F' /* 123 */
298 
299 #define MagmaNonUnit 'N' /* 131 */
300 #define MagmaUnit 'U' /* 132 */
301 
302 #define MagmaLeft 'L' /* 141 */
303 #define MagmaRight 'R' /* 142 */
304 
305 #define MagmaOneNorm '1' /* 171 */
306 #define MagmaRealOneNorm 172
307 #define MagmaTwoNorm '2' /* 173 */
308 #define MagmaFrobeniusNorm 'F' /* 174 */
309 #define MagmaInfNorm 'I' /* 175 */
310 #define MagmaRealInfNorm 176
311 #define MagmaMaxNorm 'M' /* 177 */
312 #define MagmaRealMaxNorm 178
313 
314 #define MagmaDistUniform 201
315 #define MagmaDistSymmetric 202
316 #define MagmaDistNormal 203
317 
318 #define MagmaHermGeev 241
319 #define MagmaHermPoev 242
320 #define MagmaNonsymPosv 243
321 #define MagmaSymPosv 244
322 
323 #define MagmaNoPacking 291
324 #define MagmaPackSubdiag 292
325 #define MagmaPackSupdiag 293
326 #define MagmaPackColumn 294
327 #define MagmaPackRow 295
328 #define MagmaPackLowerBand 296
329 #define MagmaPackUpeprBand 297
330 #define MagmaPackAll 298
331 
332 
333 
334 #define MagmaNoVec 'N' /* 301 */ /* geev, syev, gesvd */
335 #define MagmaVec 'V' /* 302 */ /* geev, syev */
336 #define MagmaIvec 'I' /* 303 */ /* stedc */
337 #define MagmaAllVec 'A' /* 304 */ /* gesvd */
338 #define MagmaSomeVec 'S' /* 305 */ /* gesvd */
339 #define MagmaOverwriteVec 'O' /* 306 */ /* gesvd */
340 
341 #define MagmaForward 'F' /* 391 */ /* larfb */
342 #define MagmaBackward 'B' /* 392 */ /* larfb */
343 
344 #define MagmaColumnwise 'C' /* 401 */ /* larfb */
345 #define MagmaRowwise 'R' /* 402 */ /* larfb */
346 
347 #define Magma_CSR 411
348 #define Magma_ELLPACK 412
349 #define Magma_ELLPACKT 413
350 #define Magma_DENSE 414
351 #define Magma_BCSR 415
352 
353 #define Magma_CPU 421
354 #define Magma_DEV 422
355 
356 #define Magma_CG 431
357 #define Magma_GMRES 432
358 #define Magma_BICGSTAB 433
359 #define Magma_JACOBI 434
360 #define Magma_GS 435
361 
362 #define Magma_DCOMPLEX 451
363 #define Magma_FCOMPLEX 452
364 #define Magma_DOUBLE 453
365 #define Magma_FLOAT 454
366 
367 
368 // remember to update min/max when adding constants!
369 #define MagmaMinConst 101
370 #define MagmaMaxConst 435
371 
372 
373 
374 // these could be enums, but that isn't portable in C++,
375 // e.g., if -fshort-enums is used
376 typedef char magma_major_t;
377 typedef char magma_trans_t;
378 typedef char magma_uplo_t;
379 typedef char magma_diag_t;
380 typedef char magma_side_t;
381 typedef char magma_norm_t;
382 typedef char magma_dist_t;
383 typedef char magma_pack_t;
384 typedef char magma_vec_t;
385 typedef char magma_direct_t;
386 typedef char magma_storev_t;
387 
388 // for sparse linear algebra
389 // properties of the magma_sparse_matrix
390 typedef int magma_storage_t;
391 typedef int magma_location_t;
392 // properties of the magma_precond_parameters
393 typedef int magma_precond_type;
394 typedef int magma_precision;
395 
396 // ----------------------------------------
397 // string constants for calling Fortran BLAS and LAPACK
398 // todo: use translators instead? lapack_trans_const( MagmaUpper )
399 #define MagmaRowMajorStr "Row"
400 #define MagmaColMajorStr "Col"
401 
402 #define MagmaNoTransStr "NoTrans"
403 #define MagmaTransStr "Trans"
404 #define MagmaConjTransStr "ConjTrans"
405 
406 #define MagmaUpperStr "Upper"
407 #define MagmaLowerStr "Lower"
408 #define MagmaUpperLowerStr "Full"
409 #define MagmaFullStr "Full"
410 
411 #define MagmaNonUnitStr "NonUnit"
412 #define MagmaUnitStr "Unit"
413 
414 #define MagmaLeftStr "Left"
415 #define MagmaRightStr "Right"
416 
417 #define MagmaForwardStr "Forward"
418 #define MagmaBackwardStr "Backward"
419 
420 #define MagmaColumnwiseStr "Columnwise"
421 #define MagmaRowwiseStr "Rowwise"
422 
423 #define MagmaNoVecStr "NoVec"
424 #define MagmaVecStr "Vec"
425 #define MagmaIVecStr "IVec"
426 #define MagmaAllVecStr "All"
427 #define MagmaSomeVecStr "Some"
428 #define MagmaOverwriteVecStr "Overwrite"
429 
430 #ifdef __cplusplus
431 extern "C" {
432 #endif
433 
434 // --------------------
435 // translators
436 magma_trans_t magma_trans_const ( char lapack_char );
437 magma_uplo_t magma_uplo_const ( char lapack_char );
438 magma_diag_t magma_diag_const ( char lapack_char );
439 magma_side_t magma_side_const ( char lapack_char );
440 magma_norm_t magma_norm_const ( char lapack_char );
441 magma_dist_t magma_dist_const ( char lapack_char );
442 magma_pack_t magma_pack_const ( char lapack_char );
443 magma_vec_t magma_vec_const ( char lapack_char );
444 magma_direct_t magma_direct_const( char lapack_char );
445 magma_storev_t magma_storev_const( char lapack_char );
446 
447 char lapacke_const( int magma_const );
448 const char* lapack_const ( int magma_const );
449 
450 #ifdef HAVE_clAmdBlas
451 int amdblas_const ( int magma_const );
452 clAmdBlasOrder amdblas_order_const( magma_order_t magma_const );
453 clAmdBlasTranspose amdblas_trans_const( magma_trans_t magma_const );
454 clAmdBlasSide amdblas_side_const ( magma_side_t magma_const );
455 clAmdBlasDiag amdblas_diag_const ( magma_diag_t magma_const );
456 clAmdBlasUplo amdblas_uplo_const ( magma_uplo_t magma_const );
457 #endif
458 
459 #ifdef CUBLAS_V2_H_
460 int cublas_const ( int magma_const );
461 cublasOperation_t cublas_trans_const ( magma_trans_t magma_const );
462 cublasSideMode_t cublas_side_const ( magma_side_t magma_const );
463 cublasDiagType_t cublas_diag_const ( magma_diag_t magma_const );
464 cublasFillMode_t cublas_uplo_const ( magma_uplo_t magma_const );
465 #endif
466 
467 #ifdef HAVE_CBLAS
468 #include "cblas.h"
469 enum CBLAS_ORDER cblas_order_const ( magma_order_t magma_const );
470 enum CBLAS_TRANSPOSE cblas_trans_const ( magma_trans_t magma_const );
471 enum CBLAS_SIDE cblas_side_const ( magma_side_t magma_const );
472 enum CBLAS_DIAG cblas_diag_const ( magma_diag_t magma_const );
473 enum CBLAS_UPLO cblas_uplo_const ( magma_uplo_t magma_const );
474 #endif
475 
476 // todo: above functions should all be inlined or macros for
477 // efficiency. Here's an example.
478 // In C99, static inline potentially wastes some space by
479 // emitting multiple definitions, but is portable.
480 static inline int cblas_const( int magma_const ) {
481  assert( magma_const >= MagmaMinConst );
482  assert( magma_const <= MagmaMaxConst );
483  return magma_const;
484 }
485 
486 #ifdef __cplusplus
487 }
488 #endif
489 
490 #endif // #ifndef MAGMA_TYPES_H
CBLAS_TRANSPOSE
Definition: cblas.h:11
magma_vec_t magma_vec_const(char lapack_char)
int magma_location_t
Definition: magma_types.h:391
int magma_precond_type
Definition: magma_types.h:393
magma_uplo_t magma_uplo_const(char lapack_char)
char magma_diag_t
Definition: magma_types.h:379
float * magmaFloat_ptr
Definition: magma_types.h:230
#define MagmaMinConst
Definition: magma_types.h:369
const char * lapack_const(int magma_const)
magmaFloatComplex * magmaFloatComplex_ptr
Definition: magma_types.h:232
int magma_int_t
Definition: magmablas.h:12
void * magma_ptr
Definition: magma_types.h:228
char magma_storev_t
Definition: magma_types.h:386
char magma_trans_t
Definition: magma_types.h:377
double * magmaDouble_ptr
Definition: magma_types.h:231
int magma_storage_t
Definition: magma_types.h:390
magma_trans_t magma_trans_const(char lapack_char)
double const * magmaDouble_const_ptr
Definition: magma_types.h:238
char magma_norm_t
Definition: magma_types.h:381
char magma_side_t
Definition: magma_types.h:380
char lapacke_const(int magma_const)
CBLAS_SIDE
Definition: cblas.h:14
magma_pack_t magma_pack_const(char lapack_char)
magmaDoubleComplex const * magmaDoubleComplex_const_ptr
Definition: magma_types.h:240
static int cblas_const(int magma_const)
Definition: magma_types.h:480
char magma_dist_t
Definition: magma_types.h:382
magma_diag_t magma_diag_const(char lapack_char)
float const * magmaFloat_const_ptr
Definition: magma_types.h:237
magma_dist_t magma_dist_const(char lapack_char)
magma_side_t magma_side_const(char lapack_char)
magma_direct_t magma_direct_const(char lapack_char)
char magma_vec_t
Definition: magma_types.h:384
#define MagmaMaxConst
Definition: magma_types.h:370
void const * magma_const_ptr
Definition: magma_types.h:235
magma_storev_t magma_storev_const(char lapack_char)
magma_norm_t magma_norm_const(char lapack_char)
char magma_pack_t
Definition: magma_types.h:383
int magma_precision
Definition: magma_types.h:394
char magma_major_t
Definition: magma_types.h:376
char magma_uplo_t
Definition: magma_types.h:378
CBLAS_ORDER
Definition: cblas.h:10
magmaDoubleComplex * magmaDoubleComplex_ptr
Definition: magma_types.h:233
int magma_err_t
Definition: magma_types.h:23
CBLAS_UPLO
Definition: cblas.h:12
magma_int_t * magmaInt_ptr
Definition: magma_types.h:229
magmaFloatComplex const * magmaFloatComplex_const_ptr
Definition: magma_types.h:239
char magma_direct_t
Definition: magma_types.h:385
double real_Double_t
Definition: magma_types.h:27
magma_int_t const * magmaInt_const_ptr
Definition: magma_types.h:236
CBLAS_DIAG
Definition: cblas.h:13