Amesos Package Browser (Single Doxygen Collection)
Development
src
SuiteSparse
CHOLMOD
Include
amesos_cholmod_blas.h
Go to the documentation of this file.
1
/* ========================================================================== */
2
/* === Include/cholmod_blas.h =============================================== */
3
/* ========================================================================== */
4
5
/* -----------------------------------------------------------------------------
6
* CHOLMOD/Include/cholmod_blas.h.
7
* Copyright (C) 2005-2006, Univ. of Florida. Author: Timothy A. Davis
8
* CHOLMOD/Include/cholmod_blas.h is licensed under Version 2.1 of the GNU
9
* Lesser General Public License. See lesser.txt for a text of the license.
10
* CHOLMOD is also available under other licenses; contact authors for details.
11
* http://www.cise.ufl.edu/research/sparse
12
* -------------------------------------------------------------------------- */
13
14
/* This does not need to be included in the user's program. */
15
16
#ifndef AMESOS_CHOLMOD_BLAS_H
17
#define AMESOS_CHOLMOD_BLAS_H
18
19
/* ========================================================================== */
20
/* === Architecture ========================================================= */
21
/* ========================================================================== */
22
23
#if defined (__sun) || defined (MSOL2) || defined (ARCH_SOL2)
24
#define CHOLMOD_SOL2
25
#define CHOLMOD_ARCHITECTURE "Sun Solaris"
26
27
#elif defined (__sgi) || defined (MSGI) || defined (ARCH_SGI)
28
#define CHOLMOD_SGI
29
#define CHOLMOD_ARCHITECTURE "SGI Irix"
30
31
#elif defined (__linux) || defined (MGLNX86) || defined (ARCH_GLNX86)
32
#define CHOLMOD_LINUX
33
#define CHOLMOD_ARCHITECTURE "Linux"
34
35
#elif defined (_AIX) || defined (MIBM_RS) || defined (ARCH_IBM_RS)
36
#define CHOLMOD_AIX
37
#define CHOLMOD_ARCHITECTURE "IBM AIX"
38
#define BLAS_NO_UNDERSCORE
39
40
#elif defined (__alpha) || defined (MALPHA) || defined (ARCH_ALPHA)
41
#define CHOLMOD_ALPHA
42
#define CHOLMOD_ARCHITECTURE "Compaq Alpha"
43
44
#elif defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64)
45
#if defined (__MINGW32__) || defined (__MINGW32__)
46
#define CHOLMOD_MINGW
47
#elif defined (__CYGWIN32__) || defined (__CYGWIN32__)
48
#define CHOLMOD_CYGWIN
49
#else
50
#define CHOLMOD_WINDOWS
51
#define BLAS_NO_UNDERSCORE
52
#endif
53
#define CHOLMOD_ARCHITECTURE "Microsoft Windows"
54
55
#elif defined (__hppa) || defined (__hpux) || defined (MHPUX) || defined (ARCH_HPUX)
56
#define CHOLMOD_HP
57
#define CHOLMOD_ARCHITECTURE "HP Unix"
58
#define BLAS_NO_UNDERSCORE
59
60
#elif defined (__hp700) || defined (MHP700) || defined (ARCH_HP700)
61
#define CHOLMOD_HP
62
#define CHOLMOD_ARCHITECTURE "HP 700 Unix"
63
#define BLAS_NO_UNDERSCORE
64
65
#else
66
/* If the architecture is unknown, and you call the BLAS, you may need to */
67
/* define BLAS_BY_VALUE, BLAS_NO_UNDERSCORE, and/or BLAS_CHAR_ARG yourself. */
68
#define CHOLMOD_ARCHITECTURE "unknown"
69
#endif
70
71
72
/* ========================================================================== */
73
/* === BLAS and LAPACK names ================================================ */
74
/* ========================================================================== */
75
76
/* Prototypes for the various versions of the BLAS. */
77
78
/* Determine if the 64-bit Sun Performance BLAS is to be used */
79
#if defined(CHOLMOD_SOL2) && !defined(NSUNPERF) && defined(LONG) && defined(LONGBLAS)
80
#define SUN64
81
#endif
82
83
#ifdef SUN64
84
85
#define BLAS_DTRSV dtrsv_64_
86
#define BLAS_DGEMV dgemv_64_
87
#define BLAS_DTRSM dtrsm_64_
88
#define BLAS_DGEMM dgemm_64_
89
#define BLAS_DSYRK dsyrk_64_
90
#define BLAS_DGER dger_64_
91
#define BLAS_DSCAL dscal_64_
92
#define LAPACK_DPOTRF dpotrf_64_
93
94
#define BLAS_ZTRSV ztrsv_64_
95
#define BLAS_ZGEMV zgemv_64_
96
#define BLAS_ZTRSM ztrsm_64_
97
#define BLAS_ZGEMM zgemm_64_
98
#define BLAS_ZHERK zherk_64_
99
#define BLAS_ZGER zgeru_64_
100
#define BLAS_ZSCAL zscal_64_
101
#define LAPACK_ZPOTRF zpotrf_64_
102
103
#elif defined (BLAS_NO_UNDERSCORE)
104
105
#define BLAS_DTRSV dtrsv
106
#define BLAS_DGEMV dgemv
107
#define BLAS_DTRSM dtrsm
108
#define BLAS_DGEMM dgemm
109
#define BLAS_DSYRK dsyrk
110
#define BLAS_DGER dger
111
#define BLAS_DSCAL dscal
112
#define LAPACK_DPOTRF dpotrf
113
114
#define BLAS_ZTRSV ztrsv
115
#define BLAS_ZGEMV zgemv
116
#define BLAS_ZTRSM ztrsm
117
#define BLAS_ZGEMM zgemm
118
#define BLAS_ZHERK zherk
119
#define BLAS_ZGER zgeru
120
#define BLAS_ZSCAL zscal
121
#define LAPACK_ZPOTRF zpotrf
122
123
#else
124
125
#define BLAS_DTRSV dtrsv_
126
#define BLAS_DGEMV dgemv_
127
#define BLAS_DTRSM dtrsm_
128
#define BLAS_DGEMM dgemm_
129
#define BLAS_DSYRK dsyrk_
130
#define BLAS_DGER dger_
131
#define BLAS_DSCAL dscal_
132
#define LAPACK_DPOTRF dpotrf_
133
134
#define BLAS_ZTRSV ztrsv_
135
#define BLAS_ZGEMV zgemv_
136
#define BLAS_ZTRSM ztrsm_
137
#define BLAS_ZGEMM zgemm_
138
#define BLAS_ZHERK zherk_
139
#define BLAS_ZGER zgeru_
140
#define BLAS_ZSCAL zscal_
141
#define LAPACK_ZPOTRF zpotrf_
142
143
#endif
144
145
/* ========================================================================== */
146
/* === BLAS and LAPACK integer arguments ==================================== */
147
/* ========================================================================== */
148
149
/* CHOLMOD can be compiled with -D'LONGBLAS=long' for the Sun Performance
150
* Library, or -D'LONGBLAS=long long' for SGI's SCSL BLAS. This defines the
151
* integer used in the BLAS for the cholmod_l_* routines.
152
*
153
* The "int" version of CHOLMOD always uses the "int" version of the BLAS.
154
*/
155
156
#if defined (LONGBLAS) && defined (LONG)
157
#define BLAS_INT LONGBLAS
158
#else
159
#define BLAS_INT int
160
#endif
161
162
/* If the BLAS integer is smaller than the basic CHOLMOD integer, then we need
163
* to check for integer overflow when converting from one to the other. If
164
* any integer overflows, the externally-defined blas_ok variable is set to
165
* FALSE. blas_ok should be set to TRUE before calling any BLAS_* macro.
166
*/
167
168
#define CHECK_BLAS_INT (sizeof (BLAS_INT) < sizeof (Int))
169
#define EQ(K,k) (((BLAS_INT) K) == ((Int) k))
170
171
/* ========================================================================== */
172
/* === BLAS and LAPACK prototypes and macros ================================ */
173
/* ========================================================================== */
174
175
void
BLAS_DGEMV
(
char
*trans,
BLAS_INT
*m,
BLAS_INT
*n,
double
*alpha,
176
double
*
A
,
BLAS_INT
*lda,
double
*X,
BLAS_INT
*incx,
double
*beta,
177
double
*Y,
BLAS_INT
*incy) ;
178
179
#define BLAS_dgemv(trans,m,n,alpha,A,lda,X,incx,beta,Y,incy) \
180
{ \
181
BLAS_INT M = m, N = n, LDA = lda, INCX = incx, INCY = incy ; \
182
if (CHECK_BLAS_INT) \
183
{ \
184
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (LDA,lda) && EQ (INCX,incx) \
185
&& EQ (INCY,incy) ; \
186
} \
187
if (blas_ok) \
188
{ \
189
BLAS_DGEMV (trans, &M, &N, alpha, A, &LDA, X, &INCX, beta, Y, &INCY) ; \
190
} \
191
}
192
193
void
BLAS_ZGEMV
(
char
*trans,
BLAS_INT
*m,
BLAS_INT
*n,
double
*alpha,
194
double
*
A
,
BLAS_INT
*lda,
double
*X,
BLAS_INT
*incx,
double
*beta,
195
double
*Y,
BLAS_INT
*incy) ;
196
197
#define BLAS_zgemv(trans,m,n,alpha,A,lda,X,incx,beta,Y,incy) \
198
{ \
199
BLAS_INT M = m, N = n, LDA = lda, INCX = incx, INCY = incy ; \
200
if (CHECK_BLAS_INT) \
201
{ \
202
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (LDA,lda) && EQ (INCX,incx) \
203
&& EQ (INCY,incy) ; \
204
} \
205
if (blas_ok) \
206
{ \
207
BLAS_ZGEMV (trans, &M, &N, alpha, A, &LDA, X, &INCX, beta, Y, &INCY) ; \
208
} \
209
}
210
211
void
BLAS_DTRSV
(
char
*uplo,
char
*trans,
char
*diag,
BLAS_INT
*n,
double
*
A
,
212
BLAS_INT
*lda,
double
*X,
BLAS_INT
*incx) ;
213
214
#define BLAS_dtrsv(uplo,trans,diag,n,A,lda,X,incx) \
215
{ \
216
BLAS_INT N = n, LDA = lda, INCX = incx ; \
217
if (CHECK_BLAS_INT) \
218
{ \
219
blas_ok &= EQ (N,n) && EQ (LDA,lda) && EQ (INCX,incx) ; \
220
} \
221
if (blas_ok) \
222
{ \
223
BLAS_DTRSV (uplo, trans, diag, &N, A, &LDA, X, &INCX) ; \
224
} \
225
}
226
227
void
BLAS_ZTRSV
(
char
*uplo,
char
*trans,
char
*diag,
BLAS_INT
*n,
double
*
A
,
228
BLAS_INT
*lda,
double
*X,
BLAS_INT
*incx) ;
229
230
#define BLAS_ztrsv(uplo,trans,diag,n,A,lda,X,incx) \
231
{ \
232
BLAS_INT N = n, LDA = lda, INCX = incx ; \
233
if (CHECK_BLAS_INT) \
234
{ \
235
blas_ok &= EQ (N,n) && EQ (LDA,lda) && EQ (INCX,incx) ; \
236
} \
237
if (blas_ok) \
238
{ \
239
BLAS_ZTRSV (uplo, trans, diag, &N, A, &LDA, X, &INCX) ; \
240
} \
241
}
242
243
void
BLAS_DTRSM
(
char
*side,
char
*uplo,
char
*transa,
char
*diag,
BLAS_INT
*m,
244
BLAS_INT
*n,
double
*alpha,
double
*
A
,
BLAS_INT
*lda,
double
*
B
,
245
BLAS_INT
*ldb) ;
246
247
#define BLAS_dtrsm(side,uplo,transa,diag,m,n,alpha,A,lda,B,ldb) \
248
{ \
249
BLAS_INT M = m, N = n, LDA = lda, LDB = ldb ; \
250
if (CHECK_BLAS_INT) \
251
{ \
252
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (LDA,lda) && EQ (LDB,ldb) ; \
253
} \
254
if (blas_ok) \
255
{ \
256
BLAS_DTRSM (side, uplo, transa, diag, &M, &N, alpha, A, &LDA, B, &LDB);\
257
} \
258
}
259
260
void
BLAS_ZTRSM
(
char
*side,
char
*uplo,
char
*transa,
char
*diag,
BLAS_INT
*m,
261
BLAS_INT
*n,
double
*alpha,
double
*
A
,
BLAS_INT
*lda,
double
*
B
,
262
BLAS_INT
*ldb) ;
263
264
#define BLAS_ztrsm(side,uplo,transa,diag,m,n,alpha,A,lda,B,ldb) \
265
{ \
266
BLAS_INT M = m, N = n, LDA = lda, LDB = ldb ; \
267
if (CHECK_BLAS_INT) \
268
{ \
269
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (LDA,lda) && EQ (LDB,ldb) ; \
270
} \
271
if (blas_ok) \
272
{ \
273
BLAS_ZTRSM (side, uplo, transa, diag, &M, &N, alpha, A, &LDA, B, &LDB);\
274
} \
275
}
276
277
void
BLAS_DGEMM
(
char
*transa,
char
*transb,
BLAS_INT
*m,
BLAS_INT
*n,
278
BLAS_INT
*k,
double
*alpha,
double
*
A
,
BLAS_INT
*lda,
double
*
B
,
279
BLAS_INT
*ldb,
double
*beta,
double
*
C
,
BLAS_INT
*ldc) ;
280
281
#define BLAS_dgemm(transa,transb,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) \
282
{ \
283
BLAS_INT M = m, N = n, K = k, LDA = lda, LDB = ldb, LDC = ldc ; \
284
if (CHECK_BLAS_INT) \
285
{ \
286
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (K,k) && EQ (LDA,lda) \
287
&& EQ (LDB,ldb) && EQ (LDC,ldc) ; \
288
} \
289
if (blas_ok) \
290
{ \
291
BLAS_DGEMM (transa, transb, &M, &N, &K, alpha, A, &LDA, B, &LDB, beta, \
292
C, &LDC) ; \
293
} \
294
}
295
296
void
BLAS_ZGEMM
(
char
*transa,
char
*transb,
BLAS_INT
*m,
BLAS_INT
*n,
297
BLAS_INT
*k,
double
*alpha,
double
*
A
,
BLAS_INT
*lda,
double
*
B
,
298
BLAS_INT
*ldb,
double
*beta,
double
*
C
,
BLAS_INT
*ldc) ;
299
300
#define BLAS_zgemm(transa,transb,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) \
301
{ \
302
BLAS_INT M = m, N = n, K = k, LDA = lda, LDB = ldb, LDC = ldc ; \
303
if (CHECK_BLAS_INT) \
304
{ \
305
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (K,k) && EQ (LDA,lda) \
306
&& EQ (LDB,ldb) && EQ (LDC,ldc) ; \
307
} \
308
if (blas_ok) \
309
{ \
310
BLAS_ZGEMM (transa, transb, &M, &N, &K, alpha, A, &LDA, B, &LDB, beta, \
311
C, &LDC) ; \
312
} \
313
}
314
315
void
BLAS_DSYRK
(
char
*uplo,
char
*trans,
BLAS_INT
*n,
BLAS_INT
*k,
316
double
*alpha,
double
*
A
,
BLAS_INT
*lda,
double
*beta,
double
*
C
,
317
BLAS_INT
*ldc) ;
318
319
#define BLAS_dsyrk(uplo,trans,n,k,alpha,A,lda,beta,C,ldc) \
320
{ \
321
BLAS_INT N = n, K = k, LDA = lda, LDC = ldc ; \
322
if (CHECK_BLAS_INT) \
323
{ \
324
blas_ok &= EQ (N,n) && EQ (K,k) && EQ (LDA,lda) && EQ (LDC,ldc) ; \
325
} \
326
if (blas_ok) \
327
{ \
328
BLAS_DSYRK (uplo, trans, &N, &K, alpha, A, &LDA, beta, C, &LDC) ; \
329
} \
330
} \
331
332
void
BLAS_ZHERK
(
char
*uplo,
char
*trans,
BLAS_INT
*n,
BLAS_INT
*k,
333
double
*alpha,
double
*
A
,
BLAS_INT
*lda,
double
*beta,
double
*
C
,
334
BLAS_INT
*ldc) ;
335
336
#define BLAS_zherk(uplo,trans,n,k,alpha,A,lda,beta,C,ldc) \
337
{ \
338
BLAS_INT N = n, K = k, LDA = lda, LDC = ldc ; \
339
if (CHECK_BLAS_INT) \
340
{ \
341
blas_ok &= EQ (N,n) && EQ (K,k) && EQ (LDA,lda) && EQ (LDC,ldc) ; \
342
} \
343
if (blas_ok) \
344
{ \
345
BLAS_ZHERK (uplo, trans, &N, &K, alpha, A, &LDA, beta, C, &LDC) ; \
346
} \
347
} \
348
349
void
LAPACK_DPOTRF
(
char
*uplo,
BLAS_INT
*n,
double
*
A
,
BLAS_INT
*lda,
350
BLAS_INT
*info) ;
351
352
#define LAPACK_dpotrf(uplo,n,A,lda,info) \
353
{ \
354
BLAS_INT N = n, LDA = lda, INFO = 1 ; \
355
if (CHECK_BLAS_INT) \
356
{ \
357
blas_ok &= EQ (N,n) && EQ (LDA,lda) ; \
358
} \
359
if (blas_ok) \
360
{ \
361
LAPACK_DPOTRF (uplo, &N, A, &LDA, &INFO) ; \
362
} \
363
info = INFO ; \
364
}
365
366
void
LAPACK_ZPOTRF
(
char
*uplo,
BLAS_INT
*n,
double
*
A
,
BLAS_INT
*lda,
367
BLAS_INT
*info) ;
368
369
#define LAPACK_zpotrf(uplo,n,A,lda,info) \
370
{ \
371
BLAS_INT N = n, LDA = lda, INFO = 1 ; \
372
if (CHECK_BLAS_INT) \
373
{ \
374
blas_ok &= EQ (N,n) && EQ (LDA,lda) ; \
375
} \
376
if (blas_ok) \
377
{ \
378
LAPACK_ZPOTRF (uplo, &N, A, &LDA, &INFO) ; \
379
} \
380
info = INFO ; \
381
}
382
383
/* ========================================================================== */
384
385
void
BLAS_DSCAL
(
BLAS_INT
*n,
double
*alpha,
double
*Y,
BLAS_INT
*incy) ;
386
387
#define BLAS_dscal(n,alpha,Y,incy) \
388
{ \
389
BLAS_INT N = n, INCY = incy ; \
390
if (CHECK_BLAS_INT) \
391
{ \
392
blas_ok &= EQ (N,n) && EQ (INCY,incy) ; \
393
} \
394
if (blas_ok) \
395
{ \
396
BLAS_DSCAL (&N, alpha, Y, &INCY) ; \
397
} \
398
}
399
400
void
BLAS_ZSCAL
(
BLAS_INT
*n,
double
*alpha,
double
*Y,
BLAS_INT
*incy) ;
401
402
#define BLAS_zscal(n,alpha,Y,incy) \
403
{ \
404
BLAS_INT N = n, INCY = incy ; \
405
if (CHECK_BLAS_INT) \
406
{ \
407
blas_ok &= EQ (N,n) && EQ (INCY,incy) ; \
408
} \
409
if (blas_ok) \
410
{ \
411
BLAS_ZSCAL (&N, alpha, Y, &INCY) ; \
412
} \
413
}
414
415
void
BLAS_DGER
(
BLAS_INT
*m,
BLAS_INT
*n,
double
*alpha,
416
double
*X,
BLAS_INT
*incx,
double
*Y,
BLAS_INT
*incy,
417
double
*
A
,
BLAS_INT
*lda) ;
418
419
#define BLAS_dger(m,n,alpha,X,incx,Y,incy,A,lda) \
420
{ \
421
BLAS_INT M = m, N = n, LDA = lda, INCX = incx, INCY = incy ; \
422
if (CHECK_BLAS_INT) \
423
{ \
424
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (LDA,lda) && EQ (INCX,incx) \
425
&& EQ (INCY,incy) ; \
426
} \
427
if (blas_ok) \
428
{ \
429
BLAS_DGER (&M, &N, alpha, X, &INCX, Y, &INCY, A, &LDA) ; \
430
} \
431
}
432
433
void
BLAS_ZGERU
(
BLAS_INT
*m,
BLAS_INT
*n,
double
*alpha,
434
double
*X,
BLAS_INT
*incx,
double
*Y,
BLAS_INT
*incy,
435
double
*
A
,
BLAS_INT
*lda) ;
436
437
#define BLAS_zgeru(m,n,alpha,X,incx,Y,incy,A,lda) \
438
{ \
439
BLAS_INT M = m, N = n, LDA = lda, INCX = incx, INCY = incy ; \
440
if (CHECK_BLAS_INT) \
441
{ \
442
blas_ok &= EQ (M,m) && EQ (N,n) && EQ (LDA,lda) && EQ (INCX,incx) \
443
&& EQ (INCY,incy) ; \
444
} \
445
if (blas_ok) \
446
{ \
447
BLAS_ZGER (&M, &N, alpha, X, &INCX, Y, &INCY, A, &LDA) ; \
448
} \
449
}
450
451
#endif
BLAS_INT
#define BLAS_INT
Definition:
amesos_cholmod_blas.h:159
B
BLAS_DGEMV
#define BLAS_DGEMV
Definition:
amesos_cholmod_blas.h:126
BLAS_DGEMM
#define BLAS_DGEMM
Definition:
amesos_cholmod_blas.h:128
BLAS_ZGEMV
#define BLAS_ZGEMV
Definition:
amesos_cholmod_blas.h:135
A
BLAS_DGER
#define BLAS_DGER
Definition:
amesos_cholmod_blas.h:130
BLAS_ZTRSM
#define BLAS_ZTRSM
Definition:
amesos_cholmod_blas.h:136
LAPACK_DPOTRF
#define LAPACK_DPOTRF
Definition:
amesos_cholmod_blas.h:132
BLAS_DTRSV
#define BLAS_DTRSV
Definition:
amesos_cholmod_blas.h:125
BLAS_ZSCAL
#define BLAS_ZSCAL
Definition:
amesos_cholmod_blas.h:140
BLAS_DSCAL
#define BLAS_DSCAL
Definition:
amesos_cholmod_blas.h:131
C
BLAS_ZGERU
void BLAS_ZGERU(BLAS_INT *m, BLAS_INT *n, double *alpha, double *X, BLAS_INT *incx, double *Y, BLAS_INT *incy, double *A, BLAS_INT *lda)
BLAS_DTRSM
#define BLAS_DTRSM
Definition:
amesos_cholmod_blas.h:127
BLAS_ZHERK
#define BLAS_ZHERK
Definition:
amesos_cholmod_blas.h:138
LAPACK_ZPOTRF
#define LAPACK_ZPOTRF
Definition:
amesos_cholmod_blas.h:141
BLAS_DSYRK
#define BLAS_DSYRK
Definition:
amesos_cholmod_blas.h:129
BLAS_ZGEMM
#define BLAS_ZGEMM
Definition:
amesos_cholmod_blas.h:137
BLAS_ZTRSV
#define BLAS_ZTRSV
Definition:
amesos_cholmod_blas.h:134
Generated by
1.8.14