1 /* Copyright (C) 2005 The Scalable Software Infrastructure Project. All rights reserved. 2 3 Redistribution and use in source and binary forms, with or without 4 modification, are permitted provided that the following conditions are met: 5 1. Redistributions of source code must retain the above copyright 6 notice, this list of conditions and the following disclaimer. 7 2. Redistributions in binary form must reproduce the above copyright 8 notice, this list of conditions and the following disclaimer in the 9 documentation and/or other materials provided with the distribution. 10 3. Neither the name of the project nor the names of its contributors 11 may be used to endorse or promote products derived from this software 12 without specific prior written permission. 13 14 THIS SOFTWARE IS PROVIDED BY THE SCALABLE SOFTWARE INFRASTRUCTURE PROJECT 15 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 16 TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 17 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE SCALABLE SOFTWARE INFRASTRUCTURE 18 PROJECT BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 19 OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 20 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 21 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 22 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 23 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 24 POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #ifndef __LIS_H__ 28 #define __LIS_H__ 29 30 #ifdef __cplusplus 31 #undef HAVE_COMPLEX_H 32 extern "C" { 33 #endif 34 35 /**************************************/ 36 #define LIS_VERSION "2.0.30" 37 /**************************************/ 38 #include <stdio.h> 39 #ifdef USE_COMPLEX 40 #ifdef HAVE_COMPLEX_H 41 #include <complex.h> 42 #endif 43 #else 44 #ifdef HAVE_COMPLEX_H 45 #undef HAVE_COMPLEX_H 46 #endif 47 #endif 48 #ifdef HAVE_QUADMATH_H 49 #include <quadmath.h> 50 #endif 51 52 #define _max(a,b) ((a) >= (b) ? (a) : (b)) 53 #define _min(a,b) ((a) <= (b) ? (a) : (b)) 54 55 #define LIS_FMT_AUTO 0 56 #define LIS_FMT_PLAIN 1 57 #define LIS_FMT_MM 2 58 #define LIS_FMT_LIS 3 59 #define LIS_FMT_LIS_ASCII 3 60 #define LIS_FMT_LIS_BINARY 4 61 #define LIS_FMT_FREE 5 62 #define LIS_FMT_ITBL 6 63 #define LIS_FMT_HB 7 64 #define LIS_FMT_MMB 8 65 66 #define LIS_BINARY_BIG 0 67 #define LIS_BINARY_LITTLE 1 68 69 70 #define LIS_OPTIONS_LEN 27 71 #define LIS_OPTIONS_SOLVER 0 72 #define LIS_OPTIONS_PRECON 1 73 #define LIS_OPTIONS_MAXITER 2 74 #define LIS_OPTIONS_OUTPUT 3 75 #define LIS_OPTIONS_RESTART 4 76 #define LIS_OPTIONS_ELL 5 77 #define LIS_OPTIONS_SCALE 6 78 #define LIS_OPTIONS_FILL 7 79 #define LIS_OPTIONS_M 8 80 #define LIS_OPTIONS_PSOLVER 9 81 #define LIS_OPTIONS_PMAXITER 10 82 #define LIS_OPTIONS_PRESTART 11 83 #define LIS_OPTIONS_PELL 12 84 #define LIS_OPTIONS_PPRECON 13 85 #define LIS_OPTIONS_ISLEVEL 14 86 #define LIS_OPTIONS_INITGUESS_ZEROS 15 87 #define LIS_OPTIONS_ADDS 16 88 #define LIS_OPTIONS_ADDS_ITER 17 89 #define LIS_OPTIONS_PRECISION 18 90 #define LIS_OPTIONS_USE_AT 19 91 #define LIS_OPTIONS_SWITCH_MAXITER 20 92 #define LIS_OPTIONS_SAAMG_UNSYM 21 93 #define LIS_OPTIONS_STORAGE 22 94 #define LIS_OPTIONS_STORAGE_BLOCK 23 95 #define LIS_OPTIONS_CONV_COND 24 96 #define LIS_OPTIONS_INIT_SHADOW_RESID 25 97 #define LIS_OPTIONS_IDRS_RESTART 26 98 99 #define LIS_EOPTIONS_LEN 13 100 #define LIS_EOPTIONS_ESOLVER 0 101 #define LIS_EOPTIONS_MAXITER 1 102 #define LIS_EOPTIONS_SUBSPACE 2 103 #define LIS_EOPTIONS_MODE 3 104 #define LIS_EOPTIONS_OUTPUT 4 105 #define LIS_EOPTIONS_INITGUESS_ONES 5 106 #define LIS_EOPTIONS_INNER_ESOLVER 6 107 #define LIS_EOPTIONS_INNER_GENERALIZED_ESOLVER 7 108 #define LIS_EOPTIONS_STORAGE 8 109 #define LIS_EOPTIONS_STORAGE_BLOCK 9 110 #define LIS_EOPTIONS_PRECISION 10 111 #define LIS_EOPTIONS_SWITCH_MAXITER 11 112 #define LIS_EOPTIONS_RVAL 12 113 114 #define LIS_PARAMS_LEN 15 115 #define LIS_PARAMS_RESID LIS_OPTIONS_LEN+0 116 #define LIS_PARAMS_OMEGA LIS_OPTIONS_LEN+1 117 #define LIS_PARAMS_RELAX LIS_OPTIONS_LEN+2 118 #define LIS_PARAMS_DROP LIS_OPTIONS_LEN+3 119 #define LIS_PARAMS_ALPHA LIS_OPTIONS_LEN+4 120 #define LIS_PARAMS_TAU LIS_OPTIONS_LEN+5 121 #define LIS_PARAMS_SIGMA LIS_OPTIONS_LEN+6 122 #define LIS_PARAMS_GAMMA LIS_OPTIONS_LEN+7 123 #define LIS_PARAMS_SSOR_OMEGA LIS_OPTIONS_LEN+8 124 #define LIS_PARAMS_PRESID LIS_OPTIONS_LEN+9 125 #define LIS_PARAMS_POMEGA LIS_OPTIONS_LEN+10 126 #define LIS_PARAMS_SWITCH_RESID LIS_OPTIONS_LEN+11 127 #define LIS_PARAMS_RATE LIS_OPTIONS_LEN+12 128 #define LIS_PARAMS_RESID_WEIGHT LIS_OPTIONS_LEN+13 129 #define LIS_PARAMS_SAAMG_THETA LIS_OPTIONS_LEN+14 130 131 #define LIS_EPARAMS_LEN 3 132 #define LIS_EPARAMS_RESID LIS_EOPTIONS_LEN+0 133 #define LIS_EPARAMS_SHIFT LIS_EOPTIONS_LEN+1 134 #define LIS_EPARAMS_SHIFT_IM LIS_EOPTIONS_LEN+2 135 136 #define LIS_OPTIONS_FILE -1 137 #define LIS_OPTIONS_HELP -2 138 #define LIS_OPTIONS_VER -3 139 140 141 #define LIS_PRINT_NONE 0 142 #define LIS_PRINT_MEM 1 143 #define LIS_PRINT_OUT 2 144 #define LIS_PRINT_ALL 3 145 146 #define LIS_EPRINT_NONE 0 147 #define LIS_EPRINT_MEM 1 148 #define LIS_EPRINT_OUT 2 149 #define LIS_EPRINT_ALL 3 150 151 #define LIS_SCALE_NONE 0 152 #define LIS_SCALE_JACOBI 1 153 #define LIS_SCALE_SYMM_DIAG 2 154 155 #define LIS_CONV_COND_DEFAULT 0 156 #define LIS_CONV_COND_NRM2_R 0 157 #define LIS_CONV_COND_NRM2_B 1 158 #define LIS_CONV_COND_NRM1_B 2 159 160 #define LIS_SOLVER_LEN 25 161 #define LIS_SOLVER_CG 1 162 #define LIS_SOLVER_BICG 2 163 #define LIS_SOLVER_CGS 3 164 #define LIS_SOLVER_BICGSTAB 4 165 #define LIS_SOLVER_BICGSTABL 5 166 #define LIS_SOLVER_GPBICG 6 167 #define LIS_SOLVER_QMR 7 168 #define LIS_SOLVER_TFQMR 7 169 #define LIS_SOLVER_ORTHOMIN 8 170 #define LIS_SOLVER_GMRES 9 171 #define LIS_SOLVER_JACOBI 10 172 #define LIS_SOLVER_GS 11 173 #define LIS_SOLVER_SOR 12 174 #define LIS_SOLVER_BICGSAFE 13 175 #define LIS_SOLVER_CR 14 176 #define LIS_SOLVER_BICR 15 177 #define LIS_SOLVER_CRS 16 178 #define LIS_SOLVER_BICRSTAB 17 179 #define LIS_SOLVER_GPBICR 18 180 #define LIS_SOLVER_BICRSAFE 19 181 #define LIS_SOLVER_FGMRES 20 182 #define LIS_SOLVER_IDRS 21 183 #define LIS_SOLVER_IDR1 22 184 #define LIS_SOLVER_MINRES 23 185 #define LIS_SOLVER_COCG 24 186 #define LIS_SOLVER_COCR 25 187 188 #define LIS_ESOLVER_LEN 16 189 #define LIS_ESOLVER_PI 1 190 #define LIS_ESOLVER_II 2 191 #define LIS_ESOLVER_RQI 3 192 #define LIS_ESOLVER_CG 4 193 #define LIS_ESOLVER_CR 5 194 #define LIS_ESOLVER_SI 6 195 #define LIS_ESOLVER_LI 7 196 #define LIS_ESOLVER_AI 8 197 #define LIS_ESOLVER_GPI 9 198 #define LIS_ESOLVER_GII 10 199 #define LIS_ESOLVER_GRQI 11 200 #define LIS_ESOLVER_GCG 12 201 #define LIS_ESOLVER_GCR 13 202 #define LIS_ESOLVER_GSI 14 203 #define LIS_ESOLVER_GLI 15 204 #define LIS_ESOLVER_GAI 16 205 206 #define LIS_INS_VALUE 0 207 #define LIS_ADD_VALUE 1 208 #define LIS_SUB_VALUE 2 209 210 #define LIS_MATRIX_LOWER 0 211 #define LIS_MATRIX_UPPER 1 212 #define LIS_MATRIX_SSOR 2 213 214 #define LIS_ORIGIN_0 0 215 #define LIS_ORIGIN_1 1 216 217 #define LIS_RESID 0 218 #define LIS_RANDOM 1 219 220 #define LIS_PRECISION_DEFAULT 0 221 #define LIS_PRECISION_DOUBLE 0 222 #define LIS_PRECISION_QUAD 1 223 #define LIS_PRECISION_SWITCH 2 224 225 #define LIS_LABEL_VECTOR 0 226 #define LIS_LABEL_MATRIX 1 227 228 #define LIS_VEC_TMP_PADD 128 229 230 #define LIS_VECTOR_NULL -1 231 #define LIS_VECTOR_ASSEMBLING 0 232 #define LIS_VECTOR_ASSEMBLED 1 233 234 #define LIS_PRECONNAME_MAX 10 235 #define LIS_PRECON_REGISTER_MAX 10 236 237 #define LIS_PRECON_TYPE_LEN 12 238 #define LIS_PRECON_TYPE_NONE 0 239 #define LIS_PRECON_TYPE_JACOBI 1 240 #define LIS_PRECON_TYPE_ILU 2 241 #define LIS_PRECON_TYPE_SSOR 3 242 #define LIS_PRECON_TYPE_HYBRID 4 243 #define LIS_PRECON_TYPE_IS 5 244 #define LIS_PRECON_TYPE_SAI 6 245 #define LIS_PRECON_TYPE_SAAMG 7 246 #define LIS_PRECON_TYPE_ILUC 8 247 #define LIS_PRECON_TYPE_ILUT 9 248 #define LIS_PRECON_TYPE_BJACOBI 10 249 #define LIS_PRECON_TYPE_ADDS 11 250 #define LIS_PRECON_TYPE_USERDEF LIS_PRECON_TYPE_LEN 251 252 #define LIS_MATRIX_ASSEMBLING 0 253 #define LIS_MATRIX_CSR 1 254 #define LIS_MATRIX_CSC 2 255 #define LIS_MATRIX_MSR 3 256 #define LIS_MATRIX_DIA 4 257 #define LIS_MATRIX_CDS 4 258 #define LIS_MATRIX_ELL 5 259 #define LIS_MATRIX_JAD 6 260 #define LIS_MATRIX_BSR 7 261 #define LIS_MATRIX_BSC 8 262 #define LIS_MATRIX_VBR 9 263 #define LIS_MATRIX_COO 10 264 #define LIS_MATRIX_DENSE 11 265 #define LIS_MATRIX_DNS 11 266 #define LIS_MATRIX_RCO 255 267 268 #define LIS_MATRIX_TJAD 12 269 #define LIS_MATRIX_BJAD 13 270 #define LIS_MATRIX_BCR 14 271 #define LIS_MATRIX_CJAD 15 272 #define LIS_MATRIX_PCSR 16 273 #define LIS_MATRIX_LCSR 17 274 #define LIS_MATRIX_LJAD 18 275 #define LIS_MATRIX_LBSR 19 276 #define LIS_MATRIX_CDIA 20 277 #define LIS_MATRIX_MSC 21 278 #define LIS_MATRIX_DECIDING_SIZE -(LIS_MATRIX_RCO+1) 279 #define LIS_MATRIX_NULL -(LIS_MATRIX_RCO+2) 280 281 #define LIS_MATRIX_DEFAULT LIS_MATRIX_CSR 282 #define LIS_MATRIX_POINT LIS_MATRIX_CSR 283 #define LIS_MATRIX_BLOCK LIS_MATRIX_BSR 284 285 286 #if defined(_DEBUG) 287 #define LIS_DEBUG_FUNC_IN lis_debug_trace_func(1,__FUNC__) 288 #define LIS_DEBUG_FUNC_OUT lis_debug_trace_func(0,__FUNC__) 289 #else 290 #define LIS_DEBUG_FUNC_IN 291 #define LIS_DEBUG_FUNC_OUT 292 #endif 293 /****************************************/ 294 /****************************************/ 295 typedef struct 296 { 297 double hi; 298 double lo; 299 } LIS_DOUBLE_DOUBLE; 300 301 typedef struct 302 { 303 double hi[2]; 304 double lo[2]; 305 } LIS_DOUBLE_DOUBLE_PD; 306 307 typedef struct 308 { 309 double *hi; 310 double *lo; 311 } LIS_DOUBLE_DOUBLE_PTR; 312 313 #if defined(_LONG__DOUBLE) 314 #ifdef HAVE_COMPLEX_H 315 typedef long double complex LIS_COMPLEX; 316 #else 317 typedef long double LIS_COMPLEX[2]; 318 #endif 319 #ifdef _COMPLEX 320 #ifdef HAVE_QUADMATH_H 321 typedef __complex128 LIS_SCALAR; 322 typedef __float128 LIS_REAL; 323 #define creal(x) crealq(x) 324 #define cimag(x) cimagq(x) 325 #define acos(x) cacosq(x) 326 #define acosh(x) cacoshq(x) 327 #define asin(x) casinq(x) 328 #define asinh(x) casinhq(x) 329 #define atan(x) catanq(x) 330 #define atanh(x) catanhq(x) 331 #define cos(x) ccosq(x) 332 #define cosh(x) ccoshq(x) 333 #define exp(x) cexpq(x) 334 #define fabs(x) cabsq(x) 335 #define log(x) clogq(x) 336 #define conj(x) conjq(x) 337 #define pow(x,y) cpowq(x,y) 338 #define proj(x) cprojq(x) 339 #define sin(x) csinq(x) 340 #define sinh(x) csinhq(x) 341 #define sqrt(x) csqrtq(x) 342 #define tan(x) ctanq(x) 343 #define tanh(x) ctanhq(x) 344 #define LIS_MPI_SCALAR MPI_C_LONG_DOUBLE_COMPLEX 345 #define LIS_MPI_REAL MPI_LONG_DOUBLE 346 #else 347 typedef LIS_COMPLEX LIS_SCALAR; 348 typedef long double LIS_REAL; 349 #define creal(x) creall(x) 350 #define cimag(x) cimagl(x) 351 #define acos(x) cacosl(x) 352 #define acosh(x) cacoshl(x) 353 #define asin(x) casinl(x) 354 #define asinh(x) casinhl(x) 355 #define atan(x) catanl(x) 356 #define atanh(x) catanhl(x) 357 #define cos(x) ccosl(x) 358 #define cosh(x) ccoshl(x) 359 #define exp(x) cexpl(x) 360 #define fabs(x) cabsl(x) 361 #define log(x) clogl(x) 362 #define conj(x) conjl(x) 363 #define pow(x,y) cpowl(x,y) 364 #define proj(x) cprojl(x) 365 #define sin(x) csinl(x) 366 #define sinh(x) csinhl(x) 367 #define sqrt(x) csqrtl(x) 368 #define tan(x) ctanl(x) 369 #define tanh(x) ctanhl(x) 370 #define LIS_MPI_SCALAR MPI_C_LONG_DOUBLE_COMPLEX 371 #define LIS_MPI_REAL MPI_LONG_DOUBLE 372 #endif 373 #else 374 #ifdef HAVE_QUADMATH_H 375 typedef __float128 LIS_SCALAR; 376 typedef __float128 LIS_REAL; 377 #define sin(x) sinq(x) 378 #define cos(x) cosq(x) 379 #define tan(x) tanq(x) 380 #define asin(x) asinq(x) 381 #define acos(x) acosq(x) 382 #define atan(x) atanq(x) 383 #define atan2(x,y) atan2q((x),(y)) 384 #define fmod(x,y) fmodq((x),(y)) 385 #define fabs(x) fabsq(x) 386 #define sqrt(x) sqrtq(x) 387 #define log(x) logq(x) 388 #define log10(x) log10q(x) 389 #define conj(x) x 390 #define exp(x) expq(x) 391 #define pow(x,y) powq((x),(y)) 392 #define LIS_MPI_SCALAR MPI_LONG_DOUBLE 393 #define LIS_MPI_REAL MPI_LONG_DOUBLE 394 #else 395 typedef long double LIS_SCALAR; 396 typedef long double LIS_REAL; 397 #define sin(x) sinl(x) 398 #define cos(x) cosl(x) 399 #define tan(x) tanl(x) 400 #define asin(x) asinl(x) 401 #define acos(x) acosl(x) 402 #define atan(x) atanl(x) 403 #define atan2(x,y) atan2l((x),(y)) 404 #define fmod(x,y) fmodl((x),(y)) 405 #define fabs(x) fabsl(x) 406 #define sqrt(x) sqrtl(x) 407 #define log(x) logl(x) 408 #define log10(x) log10l(x) 409 #define conj(x) x 410 #define exp(x) expl(x) 411 #define pow(x,y) powl((x),(y)) 412 #define LIS_MPI_SCALAR MPI_LONG_DOUBLE 413 #define LIS_MPI_REAL MPI_LONG_DOUBLE 414 #endif 415 #endif 416 #else 417 #ifdef HAVE_COMPLEX_H 418 typedef double complex LIS_COMPLEX; 419 #else 420 typedef double LIS_COMPLEX[2]; 421 #endif 422 #ifdef _COMPLEX 423 typedef LIS_COMPLEX LIS_SCALAR; 424 typedef double LIS_REAL; 425 #define acos(x) cacos(x) 426 #define acosh(x) cacosh(x) 427 #define asin(x) casin(x) 428 #define asinh(x) casinh(x) 429 #define atan(x) catan(x) 430 #define atanh(x) catanh(x) 431 #define cos(x) ccos(x) 432 #define cosh(x) ccosh(x) 433 #define exp(x) cexp(x) 434 #define fabs(x) cabs(x) 435 #define log(x) clog(x) 436 #define pow(x,y) cpow(x,y) 437 #define proj(x) cproj(x) 438 #define sin(x) csin(x) 439 #define sinh(x) csinh(x) 440 #define sqrt(x) csqrt(x) 441 #define tan(x) ctan(x) 442 #define tanh(x) ctanh(x) 443 #define LIS_MPI_SCALAR MPI_C_DOUBLE_COMPLEX 444 #define LIS_MPI_REAL MPI_DOUBLE 445 #else 446 typedef double LIS_SCALAR; 447 typedef double LIS_REAL; 448 #define conj(x) x 449 #define LIS_MPI_SCALAR MPI_DOUBLE 450 #define LIS_MPI_REAL MPI_DOUBLE 451 #endif 452 #endif 453 typedef LIS_DOUBLE_DOUBLE LIS_QUAD; 454 typedef LIS_DOUBLE_DOUBLE_PD LIS_QUAD_PD; 455 typedef LIS_DOUBLE_DOUBLE_PTR LIS_QUAD_PTR; 456 457 #if defined(_LONG__LONG) 458 typedef long long int LIS_INT; 459 typedef unsigned long long int LIS_UNSIGNED_INT; 460 #else 461 typedef int LIS_INT; 462 typedef unsigned int LIS_UNSIGNED_INT; 463 #endif 464 465 #ifdef USE_MAIN__ 466 #define main MAIN__ 467 #endif 468 469 #ifdef _OPENMP 470 #include <omp.h> 471 #endif 472 473 #ifdef USE_MPI 474 #include <mpi.h> 475 typedef MPI_Comm LIS_Comm; 476 #define LIS_COMM_WORLD ((LIS_Comm)MPI_COMM_WORLD) 477 #if defined(_LONG__LONG) 478 #define LIS_MPI_INT MPI_LONG_LONG_INT 479 #define LIS_MPI_Fint MPI_Fint 480 #else 481 #define LIS_MPI_INT MPI_INT 482 #define LIS_MPI_Fint MPI_Fint 483 #endif 484 #else 485 typedef LIS_INT LIS_Comm; 486 #define LIS_COMM_WORLD ((LIS_Comm)0x1) 487 #endif 488 489 struct LIS_COMMTABLE_STRUCT 490 { 491 LIS_Comm comm; 492 LIS_INT pad; 493 LIS_INT neibpetot; 494 LIS_INT imnnz; 495 LIS_INT exnnz; 496 LIS_INT wssize; 497 LIS_INT wrsize; 498 LIS_INT *neibpe; 499 LIS_INT *import_ptr; 500 LIS_INT *import_index; 501 LIS_INT *export_ptr; 502 LIS_INT *export_index; 503 LIS_SCALAR *ws; 504 LIS_SCALAR *wr; 505 #ifdef USE_MPI 506 MPI_Request *req1,*req2; 507 MPI_Status *sta1,*sta2; 508 #endif 509 }; 510 511 typedef struct LIS_COMMTABLE_STRUCT *LIS_COMMTABLE; 512 513 struct LIS_VECTOR_STRUCT 514 { 515 LIS_INT label; 516 LIS_INT status; 517 LIS_INT precision; 518 LIS_INT gn; 519 LIS_INT n; 520 LIS_INT np; 521 LIS_INT pad; 522 LIS_INT origin; 523 LIS_INT is_copy; 524 LIS_INT is_destroy; 525 LIS_INT is_scaled; 526 LIS_INT my_rank; 527 LIS_INT nprocs; 528 LIS_Comm comm; 529 LIS_INT is; 530 LIS_INT ie; 531 LIS_INT *ranges; 532 LIS_SCALAR *value; 533 LIS_SCALAR *value_lo; 534 LIS_SCALAR *work; 535 LIS_INT intvalue; 536 }; 537 typedef struct LIS_VECTOR_STRUCT *LIS_VECTOR; 538 539 struct LIS_VECTOR_S_STRUCT 540 { 541 LIS_INT label; 542 LIS_INT status; 543 LIS_INT precision; 544 LIS_INT gn; 545 LIS_INT n; 546 LIS_INT np; 547 LIS_INT pad; 548 LIS_INT origin; 549 LIS_INT is_copy; 550 LIS_INT is_destroy; 551 LIS_INT is_scaled; 552 LIS_INT my_rank; 553 LIS_INT nprocs; 554 LIS_Comm comm; 555 LIS_INT is; 556 LIS_INT ie; 557 LIS_INT *ranges; 558 LIS_SCALAR *value; 559 LIS_SCALAR *value_lo; 560 LIS_QUAD_PTR value_hl; 561 LIS_SCALAR *work; 562 LIS_INT *index; 563 LIS_INT nnz; 564 }; 565 typedef struct LIS_VECTOR_S_STRUCT *LIS_VECTOR_S; 566 567 #define LIS_MATRIX_OPTION_LEN 10 568 569 struct LIS_MATRIX_CORE_STRUCT 570 { 571 LIS_INT nnz; 572 LIS_INT ndz; 573 LIS_INT bnr; 574 LIS_INT bnc; 575 LIS_INT nr; 576 LIS_INT nc; 577 LIS_INT bnnz; 578 LIS_INT nnd; 579 LIS_INT maxnzr; 580 LIS_INT *ptr; 581 LIS_INT *row; 582 LIS_INT *col; 583 LIS_INT *index; 584 LIS_INT *bptr; 585 LIS_INT *bindex; 586 LIS_SCALAR *value; 587 LIS_SCALAR *work; 588 }; 589 typedef struct LIS_MATRIX_CORE_STRUCT *LIS_MATRIX_CORE; 590 591 struct LIS_MATRIX_DIAG_STRUCT 592 { 593 LIS_INT label; 594 LIS_INT status; 595 LIS_INT precision; 596 LIS_INT gn; 597 LIS_INT n; 598 LIS_INT np; 599 LIS_INT pad; 600 LIS_INT origin; 601 LIS_INT is_copy; 602 LIS_INT is_destroy; 603 LIS_INT is_scaled; 604 LIS_INT my_rank; 605 LIS_INT nprocs; 606 LIS_Comm comm; 607 LIS_INT is; 608 LIS_INT ie; 609 LIS_INT *ranges; 610 LIS_SCALAR *value; 611 LIS_SCALAR *work; 612 613 LIS_INT bn; 614 LIS_INT nr; 615 LIS_INT *bns; 616 LIS_INT *ptr; 617 LIS_SCALAR **v_value; 618 }; 619 typedef struct LIS_MATRIX_DIAG_STRUCT *LIS_MATRIX_DIAG; 620 621 struct LIS_MATRIX_STRUCT 622 { 623 LIS_INT label; 624 LIS_INT status; 625 LIS_INT precision; 626 LIS_INT gn; 627 LIS_INT n; 628 LIS_INT np; 629 LIS_INT pad; 630 LIS_INT origin; 631 LIS_INT is_copy; 632 LIS_INT is_destroy; 633 LIS_INT is_scaled; 634 LIS_INT my_rank; 635 LIS_INT nprocs; 636 LIS_Comm comm; 637 LIS_INT is; 638 LIS_INT ie; 639 LIS_INT *ranges; 640 641 LIS_INT matrix_type; 642 LIS_INT nnz; /* CSR,CSC,MSR,JAD,VBR,COO */ 643 LIS_INT ndz; /* MSR */ 644 LIS_INT bnr; /* BSR,BSC */ 645 LIS_INT bnc; /* BSR,BSC */ 646 LIS_INT nr; /* BSR,BSC,VBR */ 647 LIS_INT nc; /* BSR,BSC,VBR */ 648 LIS_INT bnnz; /* BSR,BSC,VBR */ 649 LIS_INT nnd; /* DIA */ 650 LIS_INT maxnzr; /* ELL,JAD */ 651 LIS_INT *ptr; /* CSR,CSC,JAD */ 652 LIS_INT *row; /* JAD,VBR,COO */ 653 LIS_INT *col; /* JAD,VBR,COO */ 654 LIS_INT *index; /* CSR,CSC,MSR,DIA,ELL,JAD */ 655 LIS_INT *bptr; /* BSR,BSC,VBR */ 656 LIS_INT *bindex; /* BSR,BSC,VBR */ 657 LIS_SCALAR *value; /* CSR,CSC,MSR,DIA,ELL,JAD,BSR,BSC,VBR,DNS,COO */ 658 LIS_SCALAR *work; 659 660 LIS_MATRIX_CORE L; 661 LIS_MATRIX_CORE U; 662 LIS_MATRIX_DIAG D; 663 LIS_MATRIX_DIAG WD; 664 665 LIS_INT is_block; 666 LIS_INT pad_comm; 667 LIS_INT is_pmat; 668 LIS_INT is_sorted; 669 LIS_INT is_splited; 670 LIS_INT is_save; 671 LIS_INT is_comm; 672 LIS_INT is_fallocated; 673 LIS_INT use_wd; 674 LIS_INT conv_bnr; 675 LIS_INT conv_bnc; 676 LIS_INT *conv_row; 677 LIS_INT *conv_col; 678 LIS_INT options[LIS_MATRIX_OPTION_LEN]; 679 680 LIS_INT w_annz; 681 LIS_INT *w_nnz; 682 LIS_INT *w_row; 683 LIS_INT **w_index; 684 LIS_SCALAR **w_value; 685 LIS_SCALAR ***v_value; 686 687 LIS_INT *l2g_map; 688 LIS_COMMTABLE commtable; 689 }; 690 typedef struct LIS_MATRIX_STRUCT *LIS_MATRIX; 691 692 693 struct LIS_MATRIX_ILU_STRUCT 694 { 695 LIS_INT n; 696 LIS_INT bs; 697 LIS_INT *nnz_ma; 698 LIS_INT *nnz; 699 LIS_INT *bsz; 700 LIS_INT **index; 701 LIS_SCALAR **value; 702 LIS_SCALAR ***values; 703 }; 704 typedef struct LIS_MATRIX_ILU_STRUCT *LIS_MATRIX_ILU; 705 706 struct LIS_PRECON_STRUCT 707 { 708 LIS_INT precon_type; 709 LIS_MATRIX A; /* SSOR */ 710 LIS_MATRIX Ah; 711 LIS_MATRIX_ILU L; /* ilu(k),ilut,iluc,sainv */ 712 LIS_MATRIX_ILU U; /* ilu(k),ilut,iluc,sainv */ 713 LIS_MATRIX_DIAG WD; /* bilu(k),bilut,biluc,bjacobi */ 714 LIS_VECTOR D; /* ilu(k),ilut,iluc,jacobi,sainv */ 715 LIS_VECTOR Pb; /* i+s */ 716 LIS_VECTOR temp; /* saamg */ 717 LIS_REAL theta; /* saamg */ 718 LIS_VECTOR *work; /* adds */ 719 struct LIS_SOLVER_STRUCT *solver; /* hybrid */ 720 LIS_INT worklen; /* adds */ 721 LIS_INT level_num; /* saamg */ 722 LIS_INT wsize; /* saamg */ 723 LIS_INT solver_comm; /* saamg */ 724 LIS_INT my_rank; /* saamg */ 725 LIS_INT nprocs; /* saamg */ 726 LIS_INT is_copy; 727 LIS_COMMTABLE commtable; /* saamg */ 728 }; 729 typedef struct LIS_PRECON_STRUCT *LIS_PRECON; 730 731 732 struct LIS_SOLVER_STRUCT 733 { 734 LIS_MATRIX A,Ah; 735 LIS_VECTOR b,x,xx,d; 736 LIS_MATRIX_DIAG WD; 737 LIS_PRECON precon; 738 LIS_VECTOR *work; 739 LIS_REAL *rhistory; 740 LIS_INT worklen; 741 LIS_INT options[LIS_OPTIONS_LEN]; 742 LIS_SCALAR params[LIS_PARAMS_LEN]; 743 LIS_INT retcode; 744 LIS_INT iter; 745 LIS_INT iter2; 746 LIS_REAL resid; 747 double time; 748 double itime; 749 double ptime; 750 double p_c_time; 751 double p_i_time; 752 LIS_INT precision; 753 LIS_REAL bnrm; 754 LIS_REAL tol; 755 LIS_REAL tol_switch; 756 LIS_INT setup; 757 }; 758 typedef struct LIS_SOLVER_STRUCT *LIS_SOLVER; 759 760 struct LIS_ESOLVER_STRUCT 761 { 762 LIS_MATRIX A,B; 763 LIS_VECTOR x,xx,d; 764 LIS_SCALAR *evalue; 765 LIS_VECTOR *evector; 766 LIS_REAL *resid; 767 LIS_VECTOR *work; 768 LIS_REAL *rhistory; 769 LIS_INT worklen; 770 LIS_INT options[LIS_EOPTIONS_LEN]; 771 LIS_SCALAR params[LIS_EPARAMS_LEN]; 772 LIS_INT retcode; 773 LIS_INT *iter; 774 LIS_INT *iter2; 775 double time; 776 LIS_INT *nesol; 777 double itime; 778 double ptime; 779 double p_c_time; 780 double p_i_time; 781 LIS_INT eprecision; 782 LIS_SCALAR ishift; 783 LIS_REAL nrm2; 784 LIS_REAL tol; 785 }; 786 typedef struct LIS_ESOLVER_STRUCT *LIS_ESOLVER; 787 788 struct LIS_CONV_OPTIONS_STRUCT 789 { 790 LIS_INT bnr; 791 LIS_INT bnc; 792 LIS_INT *row; 793 LIS_INT *col; 794 }; 795 typedef struct LIS_CONV_OPTIONS_STRUCT LIS_CONV_OPTIONS; 796 797 typedef LIS_INT (*LIS_PRECON_CREATE_XXX)(LIS_SOLVER solver, LIS_PRECON precon); 798 /*NEH support for extended "solve_kernel" workflow*/ 799 typedef LIS_INT (*LIS_PRECON_PSD_CREATE_XXX)(LIS_SOLVER solver, LIS_PRECON precon); 800 /*NEH support for extended "solve_kernel" workflow*/ 801 typedef LIS_INT (*LIS_PRECON_PSD_UPDATE_XXX)(LIS_SOLVER solver, LIS_PRECON precon); 802 typedef LIS_INT (*LIS_PSOLVE_XXX)(LIS_SOLVER solver, LIS_VECTOR b, LIS_VECTOR x); 803 typedef LIS_INT (*LIS_PSOLVEH_XXX)(LIS_SOLVER solver, LIS_VECTOR b, LIS_VECTOR x); 804 805 typedef struct LIS_PRECON_REGISTER_STRUCT 806 { 807 LIS_INT precon_type; 808 char name[LIS_PRECONNAME_MAX+1]; 809 LIS_PRECON_CREATE_XXX pcreate; 810 LIS_PSOLVE_XXX psolve; 811 LIS_PSOLVEH_XXX psolveh; 812 } LIS_PRECON_REGISTER; 813 814 815 #ifdef __cplusplus 816 extern "C" 817 { 818 #endif 819 820 /****************************/ 821 /* Vector Operations */ 822 /****************************/ 823 824 extern LIS_INT lis_vector_create(LIS_Comm comm, LIS_VECTOR *vec); 825 extern LIS_INT lis_vector_set_size(LIS_VECTOR vec, LIS_INT local_n, LIS_INT global_n); 826 /*NEH support for extended "solve_kernel" workflow*/ 827 extern LIS_INT lis_vector_psd_reset_scale(LIS_VECTOR vec); 828 extern LIS_INT lis_vector_destroy(LIS_VECTOR vec); 829 extern LIS_INT lis_vector_duplicate(void *vin, LIS_VECTOR *vout); 830 extern LIS_INT lis_vector_get_size(LIS_VECTOR v, LIS_INT *local_n, LIS_INT *global_n); 831 extern LIS_INT lis_vector_get_range(LIS_VECTOR v, LIS_INT *is, LIS_INT *ie); 832 extern LIS_INT lis_vector_get_value(LIS_VECTOR v, LIS_INT i, LIS_SCALAR *value); 833 extern LIS_INT lis_vector_get_values(LIS_VECTOR v, LIS_INT start, LIS_INT count, LIS_SCALAR value[]); 834 extern LIS_INT lis_vector_set_value(LIS_INT flag, LIS_INT i, LIS_SCALAR value, LIS_VECTOR v); 835 extern LIS_INT lis_vector_set_values(LIS_INT flag, LIS_INT count, LIS_INT index[], LIS_SCALAR value[], LIS_VECTOR v); 836 extern LIS_INT lis_vector_set_values2(LIS_INT flag, LIS_INT start, LIS_INT count, LIS_SCALAR value[], LIS_VECTOR v); 837 extern LIS_INT lis_vector_print(LIS_VECTOR x); 838 extern LIS_INT lis_vector_scatter(LIS_SCALAR value[], LIS_VECTOR v); 839 extern LIS_INT lis_vector_gather(LIS_VECTOR v, LIS_SCALAR value[]); 840 extern LIS_INT lis_vector_is_null(LIS_VECTOR v); 841 extern LIS_INT lis_vector_swap(LIS_VECTOR vsrc, LIS_VECTOR vdst); 842 extern LIS_INT lis_vector_copy(LIS_VECTOR vsrc, LIS_VECTOR vdst); 843 extern LIS_INT lis_vector_axpy(LIS_SCALAR alpha, LIS_VECTOR vx, LIS_VECTOR vy); 844 extern LIS_INT lis_vector_xpay(LIS_VECTOR vx, LIS_SCALAR alpha, LIS_VECTOR vy); 845 extern LIS_INT lis_vector_axpyz(LIS_SCALAR alpha, LIS_VECTOR vx, LIS_VECTOR vy, LIS_VECTOR vz); 846 extern LIS_INT lis_vector_scale(LIS_SCALAR alpha, LIS_VECTOR vx); 847 extern LIS_INT lis_vector_pmul(LIS_VECTOR vx,LIS_VECTOR vy,LIS_VECTOR vz); 848 extern LIS_INT lis_vector_pdiv(LIS_VECTOR vx,LIS_VECTOR vy,LIS_VECTOR vz); 849 extern LIS_INT lis_vector_set_all(LIS_SCALAR alpha, LIS_VECTOR vx); 850 extern LIS_INT lis_vector_abs(LIS_VECTOR vx); 851 extern LIS_INT lis_vector_reciprocal(LIS_VECTOR vx); 852 extern LIS_INT lis_vector_conjugate(LIS_VECTOR vx); 853 extern LIS_INT lis_vector_shift(LIS_SCALAR sigma, LIS_VECTOR vx); 854 extern LIS_INT lis_vector_dot(LIS_VECTOR vx, LIS_VECTOR vy, LIS_SCALAR *value); 855 extern LIS_INT lis_vector_nhdot(LIS_VECTOR vx, LIS_VECTOR vy, LIS_SCALAR *value); 856 extern LIS_INT lis_vector_nrm1(LIS_VECTOR vx, LIS_REAL *value); 857 extern LIS_INT lis_vector_nrm2(LIS_VECTOR vx, LIS_REAL *value); 858 extern LIS_INT lis_vector_nrmi(LIS_VECTOR vx, LIS_REAL *value); 859 extern LIS_INT lis_vector_sum(LIS_VECTOR vx, LIS_SCALAR *value); 860 861 /****************************/ 862 /* Matrix Operations */ 863 /****************************/ 864 865 extern LIS_INT lis_matrix_create(LIS_Comm comm, LIS_MATRIX *Amat); 866 extern LIS_INT lis_matrix_destroy(LIS_MATRIX Amat); 867 extern LIS_INT lis_matrix_assemble(LIS_MATRIX A); 868 extern LIS_INT lis_matrix_is_assembled(LIS_MATRIX A); 869 extern LIS_INT lis_matrix_duplicate(LIS_MATRIX Ain, LIS_MATRIX *Aout); 870 extern LIS_INT lis_matrix_set_size(LIS_MATRIX A, LIS_INT local_n, LIS_INT global_n); 871 extern LIS_INT lis_matrix_get_size(LIS_MATRIX A, LIS_INT *local_n, LIS_INT *global_n); 872 extern LIS_INT lis_matrix_get_range(LIS_MATRIX A, LIS_INT *is, LIS_INT *ie); 873 extern LIS_INT lis_matrix_get_nnz(LIS_MATRIX A, LIS_INT *nnz); 874 extern LIS_INT lis_matrix_set_type(LIS_MATRIX A, LIS_INT matrix_type); 875 extern LIS_INT lis_matrix_get_type(LIS_MATRIX A, LIS_INT *matrix_type); 876 extern LIS_INT lis_matrix_set_value(LIS_INT flag, LIS_INT i, LIS_INT j, LIS_SCALAR value, LIS_MATRIX A); 877 extern LIS_INT lis_matrix_set_value_new(LIS_INT flag, LIS_INT i, LIS_INT j, LIS_SCALAR value, LIS_MATRIX A); 878 extern LIS_INT lis_matrix_set_values(LIS_INT flag, LIS_INT n, LIS_SCALAR value[], LIS_MATRIX A); 879 extern LIS_INT lis_matrix_psd_set_value(LIS_INT flag, LIS_INT i, LIS_INT j, LIS_SCALAR value, LIS_MATRIX A); 880 extern LIS_INT lis_matrix_malloc(LIS_MATRIX A, LIS_INT nnz_row, LIS_INT nnz[]); 881 extern LIS_INT lis_matrix_get_diagonal(LIS_MATRIX A, LIS_VECTOR d); 882 extern LIS_INT lis_matrix_scale(LIS_MATRIX A, LIS_VECTOR B, LIS_VECTOR D, LIS_INT action); 883 /*NEH support for extended "solve_kernel" workflow*/ 884 extern LIS_INT lis_matrix_psd_reset_scale(LIS_MATRIX A); 885 extern LIS_INT lis_matrix_convert(LIS_MATRIX Ain, LIS_MATRIX Aout); 886 extern LIS_INT lis_matrix_copy(LIS_MATRIX Ain, LIS_MATRIX Aout); 887 extern LIS_INT lis_matrix_set_blocksize(LIS_MATRIX A, LIS_INT bnr, LIS_INT bnc, LIS_INT row[], LIS_INT col[]); 888 extern LIS_INT lis_matrix_unset(LIS_MATRIX A); 889 890 extern LIS_INT lis_matrix_malloc_csr(LIS_INT n, LIS_INT nnz, LIS_INT **ptr, LIS_INT **index, LIS_SCALAR **value); 891 extern LIS_INT lis_matrix_set_value_csr(LIS_INT flag, LIS_INT i, LIS_INT j, LIS_SCALAR value, LIS_MATRIX A); 892 extern LIS_INT lis_matrix_psd_set_value_csr(LIS_INT flag, LIS_INT i, LIS_INT j, LIS_SCALAR value, LIS_MATRIX A); 893 extern LIS_INT lis_matrix_set_csr(LIS_INT nnz, LIS_INT *row, LIS_INT *index, LIS_SCALAR *value, LIS_MATRIX A); 894 extern LIS_INT lis_matrix_malloc_csc(LIS_INT n, LIS_INT nnz, LIS_INT **ptr, LIS_INT **index, LIS_SCALAR **value); 895 extern LIS_INT lis_matrix_set_csc(LIS_INT nnz, LIS_INT *row, LIS_INT *index, LIS_SCALAR *value, LIS_MATRIX A); 896 extern LIS_INT lis_matrix_malloc_bsr(LIS_INT n, LIS_INT bnr, LIS_INT bnc, LIS_INT bnnz, LIS_INT **bptr, LIS_INT **bindex, LIS_SCALAR **value); 897 extern LIS_INT lis_matrix_set_bsr(LIS_INT bnr, LIS_INT bnc, LIS_INT bnnz, LIS_INT *bptr, LIS_INT *bindex, LIS_SCALAR *value, LIS_MATRIX A); 898 extern LIS_INT lis_matrix_set_msr(LIS_INT nnz, LIS_INT ndz, LIS_INT *index, LIS_SCALAR *value, LIS_MATRIX A); 899 extern LIS_INT lis_matrix_malloc_msr(LIS_INT n, LIS_INT nnz, LIS_INT ndz, LIS_INT **index, LIS_SCALAR **value); 900 extern LIS_INT lis_matrix_set_ell(LIS_INT maxnzr, LIS_INT *index, LIS_SCALAR *value, LIS_MATRIX A); 901 extern LIS_INT lis_matrix_malloc_ell(LIS_INT n, LIS_INT maxnzr, LIS_INT **index, LIS_SCALAR **value); 902 extern LIS_INT lis_matrix_set_jad(LIS_INT nnz, LIS_INT maxnzr, LIS_INT *perm, LIS_INT *ptr, LIS_INT *index, LIS_SCALAR *value, LIS_MATRIX A); 903 extern LIS_INT lis_matrix_malloc_jad(LIS_INT n, LIS_INT nnz, LIS_INT maxnzr, LIS_INT **perm, LIS_INT **ptr, LIS_INT **index, LIS_SCALAR **value); 904 extern LIS_INT lis_matrix_set_dia(LIS_INT nnd, LIS_INT *index, LIS_SCALAR *value, LIS_MATRIX A); 905 extern LIS_INT lis_matrix_malloc_dia(LIS_INT n, LIS_INT nnd, LIS_INT **index, LIS_SCALAR **value); 906 extern LIS_INT lis_matrix_malloc_bsc(LIS_INT n, LIS_INT bnr, LIS_INT bnc, LIS_INT bnnz, LIS_INT **bptr, LIS_INT **bindex, LIS_SCALAR **value); 907 extern LIS_INT lis_matrix_set_bsc(LIS_INT bnr, LIS_INT bnc, LIS_INT bnnz, LIS_INT *bptr, LIS_INT *bindex, LIS_SCALAR *value, LIS_MATRIX A); 908 extern LIS_INT lis_matrix_get_vbr_rowcol(LIS_MATRIX Ain, LIS_INT *nr, LIS_INT *nc, LIS_INT **row, LIS_INT **col); 909 extern LIS_INT lis_matrix_malloc_vbr(LIS_INT n, LIS_INT nnz, LIS_INT nr, LIS_INT nc, LIS_INT bnnz, LIS_INT **row, LIS_INT **col, LIS_INT **ptr, LIS_INT **bptr, LIS_INT **bindex, LIS_SCALAR **value); 910 extern LIS_INT lis_matrix_set_vbr(LIS_INT nnz, LIS_INT nr, LIS_INT nc, LIS_INT bnnz, LIS_INT *row, LIS_INT *col, LIS_INT *ptr, LIS_INT *bptr, LIS_INT *bindex, LIS_SCALAR *value, LIS_MATRIX A); 911 extern LIS_INT lis_matrix_malloc_coo(LIS_INT nnz, LIS_INT **row, LIS_INT **col, LIS_SCALAR **value); 912 extern LIS_INT lis_matrix_set_coo(LIS_INT nnz, LIS_INT *row, LIS_INT *col, LIS_SCALAR *value, LIS_MATRIX A); 913 extern LIS_INT lis_matrix_set_dns(LIS_SCALAR *value, LIS_MATRIX A); 914 extern LIS_INT lis_matrix_malloc_dns(LIS_INT n, LIS_INT gn, LIS_SCALAR **value); 915 916 /****************************/ 917 /* Matrix-Vector Operations */ 918 /****************************/ 919 920 extern LIS_INT lis_matvec(LIS_MATRIX A, LIS_VECTOR x, LIS_VECTOR y); 921 extern LIS_INT lis_matvech(LIS_MATRIX A, LIS_VECTOR x, LIS_VECTOR y); 922 923 /****************************/ 924 /* Array Operations */ 925 /****************************/ 926 927 extern LIS_INT lis_array_swap(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *y); 928 extern LIS_INT lis_array_copy(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *y); 929 extern LIS_INT lis_array_axpy(LIS_INT n, LIS_SCALAR alpha, LIS_SCALAR *x, LIS_SCALAR *y); 930 extern LIS_INT lis_array_xpay(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR alpha, LIS_SCALAR *y); 931 extern LIS_INT lis_array_axpyz(LIS_INT n, LIS_SCALAR alpha, LIS_SCALAR *x, LIS_SCALAR *y, LIS_SCALAR *z); 932 extern LIS_INT lis_array_scale(LIS_INT n, LIS_SCALAR alpha, LIS_SCALAR *x); 933 extern LIS_INT lis_array_pmul(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *y, LIS_SCALAR *z); 934 extern LIS_INT lis_array_pdiv(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *y, LIS_SCALAR *z); 935 extern LIS_INT lis_array_set_all(LIS_INT n, LIS_SCALAR alpha, LIS_SCALAR *x); 936 extern LIS_INT lis_array_abs(LIS_INT n, LIS_SCALAR *x); 937 extern LIS_INT lis_array_reciprocal(LIS_INT n, LIS_SCALAR *x); 938 extern LIS_INT lis_array_conjugate(LIS_INT n, LIS_SCALAR *x); 939 extern LIS_INT lis_array_shift(LIS_INT n, LIS_SCALAR sigma, LIS_SCALAR *x); 940 extern LIS_INT lis_array_dot(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *y, LIS_SCALAR *value); 941 extern LIS_INT lis_array_nhdot(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *y, LIS_SCALAR *value); 942 extern LIS_INT lis_array_nrm1(LIS_INT n, LIS_SCALAR *x, LIS_REAL *value); 943 extern LIS_INT lis_array_nrm2(LIS_INT n, LIS_SCALAR *x, LIS_REAL *value); 944 extern LIS_INT lis_array_nrmi(LIS_INT n, LIS_SCALAR *x, LIS_REAL *value); 945 extern LIS_INT lis_array_sum(LIS_INT n, LIS_SCALAR *x, LIS_SCALAR *value); 946 extern LIS_INT lis_array_matvec(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *x, LIS_SCALAR *y, LIS_INT op); 947 extern LIS_INT lis_array_matvech(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *x, LIS_SCALAR *y, LIS_INT op); 948 extern LIS_INT lis_array_matvec_ns(LIS_INT m, LIS_INT n, LIS_SCALAR *a, LIS_INT lda, LIS_SCALAR *x, LIS_SCALAR *y, LIS_INT op); 949 extern LIS_INT lis_array_matmat(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *b, LIS_SCALAR *c, LIS_INT op); 950 extern LIS_INT lis_array_matmat_ns(LIS_INT m, LIS_INT n, LIS_INT k, LIS_SCALAR *a, LIS_INT lda, LIS_SCALAR *b, LIS_INT ldb, LIS_SCALAR *c, LIS_INT ldc, LIS_INT op); 951 extern LIS_INT lis_array_ge(LIS_INT n, LIS_SCALAR *a); 952 extern LIS_INT lis_array_solve(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *b, LIS_SCALAR *x, LIS_SCALAR *w); 953 extern LIS_INT lis_array_cgs(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *q, LIS_SCALAR *r); 954 extern LIS_INT lis_array_mgs(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *q, LIS_SCALAR *r); 955 extern LIS_INT lis_array_qr(LIS_INT n, LIS_SCALAR *a, LIS_SCALAR *q, LIS_SCALAR *r, LIS_INT *qriter, LIS_REAL *qrerr); 956 957 /****************************/ 958 /* Linear Solvers */ 959 /****************************/ 960 961 extern LIS_INT lis_solver_create(LIS_SOLVER *solver); 962 extern LIS_INT lis_solver_destroy(LIS_SOLVER solver); 963 extern LIS_INT lis_solver_get_iter(LIS_SOLVER solver, LIS_INT *iter); 964 extern LIS_INT lis_solver_get_iterex(LIS_SOLVER solver, LIS_INT *iter, LIS_INT *iter_double, LIS_INT *iter_quad); 965 extern LIS_INT lis_solver_get_time(LIS_SOLVER solver, double *time); 966 extern LIS_INT lis_solver_get_timeex(LIS_SOLVER solver, double *time, double *itime, double *ptime, double *p_c_time, double *p_i_time); 967 extern LIS_INT lis_solver_get_residualnorm(LIS_SOLVER solver, LIS_REAL *residual); 968 extern LIS_INT lis_solver_get_solver(LIS_SOLVER solver, LIS_INT *nsol); 969 extern LIS_INT lis_solver_get_precon(LIS_SOLVER solver, LIS_INT *precon_type); 970 extern LIS_INT lis_solver_get_status(LIS_SOLVER solver, LIS_INT *status); 971 extern LIS_INT lis_solver_get_rhistory(LIS_SOLVER solver, LIS_VECTOR v); 972 extern LIS_INT lis_solver_set_option(char *text, LIS_SOLVER solver); 973 extern LIS_INT lis_solver_set_optionC(LIS_SOLVER solver); 974 /*NEH support for extended "solve_kernel" workflow*/ 975 extern LIS_INT lis_solver_set_matrix(LIS_MATRIX A, LIS_SOLVER solver); 976 extern LIS_INT lis_solve(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_SOLVER solver); 977 extern LIS_INT lis_solve_setup(LIS_MATRIX A, LIS_SOLVER solver); 978 extern LIS_INT lis_solve_kernel(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_SOLVER solver, LIS_PRECON precon); 979 extern LIS_PRECON_REGISTER *precon_register_top; 980 extern LIS_INT precon_register_type; 981 extern LIS_INT lis_precon_register(char *name, LIS_PRECON_CREATE_XXX pcreate, LIS_PSOLVE_XXX psolve, LIS_PSOLVEH_XXX psolveh); 982 extern LIS_INT lis_precon_register_free(void); 983 extern LIS_INT lis_solver_get_solvername(LIS_INT solver, char *solvername); 984 extern LIS_INT lis_solver_get_preconname(LIS_INT precon_type, char *preconname); 985 986 /****************************/ 987 /* Eigensolvers */ 988 /****************************/ 989 990 extern LIS_INT lis_esolver_create(LIS_ESOLVER *esolver); 991 extern LIS_INT lis_esolver_destroy(LIS_ESOLVER esolver); 992 extern LIS_INT lis_iesolver_destroy(LIS_ESOLVER esolver); 993 extern LIS_INT lis_esolver_set_option(char *text, LIS_ESOLVER esolver); 994 extern LIS_INT lis_esolver_set_optionC(LIS_ESOLVER esolver); 995 extern LIS_INT lis_esolve(LIS_MATRIX A, LIS_VECTOR x, LIS_SCALAR *evalue0, LIS_ESOLVER esolver); 996 extern LIS_INT lis_gesolve(LIS_MATRIX A, LIS_MATRIX B, LIS_VECTOR x, LIS_SCALAR *evalue0, LIS_ESOLVER esolver); 997 extern LIS_INT lis_esolver_get_iter(LIS_ESOLVER esolver, LIS_INT *iter); 998 extern LIS_INT lis_esolver_get_iterex(LIS_ESOLVER esolver, LIS_INT *iter, LIS_INT *iter_double, LIS_INT *iter_quad); 999 extern LIS_INT lis_esolver_get_time(LIS_ESOLVER esolver, double *time); 1000 extern LIS_INT lis_esolver_get_timeex(LIS_ESOLVER esolver, double *time, double *itime, double *ptime, double *p_c_time, double *p_i_time); 1001 extern LIS_INT lis_esolver_get_residualnorm(LIS_ESOLVER esolver, LIS_REAL *residual); 1002 extern LIS_INT lis_esolver_get_status(LIS_ESOLVER esolver, LIS_INT *status); 1003 extern LIS_INT lis_esolver_get_rhistory(LIS_ESOLVER esolver, LIS_VECTOR v); 1004 extern LIS_INT lis_esolver_get_evalues(LIS_ESOLVER esolver, LIS_VECTOR v); 1005 extern LIS_INT lis_esolver_get_specific_evalue(LIS_ESOLVER esolver, LIS_INT mode, LIS_SCALAR *evalue); 1006 extern LIS_INT lis_esolver_get_evectors(LIS_ESOLVER esolver, LIS_MATRIX M); 1007 extern LIS_INT lis_esolver_get_specific_evector(LIS_ESOLVER esolver, LIS_INT mode, LIS_VECTOR x); 1008 extern LIS_INT lis_esolver_get_residualnorms(LIS_ESOLVER esolver, LIS_VECTOR v); 1009 extern LIS_INT lis_esolver_get_specific_residualnorm(LIS_ESOLVER esolver, LIS_INT mode, LIS_REAL *residual); 1010 extern LIS_INT lis_esolver_get_iters(LIS_ESOLVER esolver, LIS_VECTOR v); 1011 extern LIS_INT lis_esolver_get_specific_iter(LIS_ESOLVER esolver, LIS_INT mode, LIS_INT *iter); 1012 extern LIS_INT lis_esolver_get_esolver(LIS_ESOLVER esolver, LIS_INT *nesol); 1013 extern LIS_INT lis_esolver_get_esolvername(LIS_INT esolver, char *esolvername); 1014 1015 /****************************/ 1016 /* I/O Functions */ 1017 /****************************/ 1018 1019 extern LIS_INT lis_input(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, char *filename); 1020 extern LIS_INT lis_input_matrix(LIS_MATRIX A, char *filename); 1021 extern LIS_INT lis_input_vector(LIS_VECTOR v, char *filename); 1022 extern LIS_INT lis_output(LIS_MATRIX A, LIS_VECTOR b, LIS_VECTOR x, LIS_INT mode, char *path); 1023 extern LIS_INT lis_output_matrix(LIS_MATRIX A, LIS_INT mode, char *path); 1024 extern LIS_INT lis_output_vector(LIS_VECTOR v, LIS_INT format, char *filename); 1025 extern LIS_INT lis_solver_output_rhistory(LIS_SOLVER solver, char *filename); 1026 extern LIS_INT lis_esolver_output_rhistory(LIS_ESOLVER esolver, char *filename); 1027 1028 /****************************/ 1029 /* Utilities */ 1030 /****************************/ 1031 1032 extern LIS_INT lis_initialize(int *argc, char** argv[]); 1033 extern LIS_INT lis_finalize(void); 1034 extern double lis_wtime(void); 1035 extern void CHKERR(LIS_INT err); 1036 extern LIS_INT lis_debug_trace_func(LIS_INT flag, char *func); 1037 extern void *lis_malloc( size_t size, char *tag ); 1038 extern void *lis_calloc( size_t size, char *tag ); 1039 extern void *lis_realloc( void *p, size_t size ); 1040 extern void lis_free(void *p); 1041 extern void lis_free2(LIS_INT n, ...); 1042 extern LIS_INT lis_is_malloc( void *p ); 1043 extern void lis_date(char *date); 1044 extern LIS_INT lis_printf(LIS_Comm comm, const char *mess, ...); 1045 1046 1047 #ifdef __cplusplus 1048 } 1049 #endif 1050 1051 #define LIS_TRUE 1 1052 #define LIS_FALSE 0 1053 #define LIS_FAILS -1 1054 #define LIS_SUCCESS 0 1055 #define LIS_ILL_OPTION 1 1056 #define LIS_ERR_ILL_ARG 1 1057 #define LIS_BREAKDOWN 2 1058 #define LIS_OUT_OF_MEMORY 3 1059 #define LIS_ERR_OUT_OF_MEMORY 3 1060 #define LIS_MAXITER 4 1061 #define LIS_ERR_NOT_IMPLEMENTED 5 1062 #define LIS_ERR_FILE_IO 6 1063 1064 1065 #if 1 1066 #define LIS_GET_ISIE(id,nprocs,n,is,ie) \ 1067 if( (id) < (n)%(nprocs) ) \ 1068 { \ 1069 (ie) = (n)/(nprocs)+1; \ 1070 (is) = (ie)*(id); \ 1071 } \ 1072 else \ 1073 { \ 1074 (ie) = (n)/(nprocs); \ 1075 (is) = (ie)*(id) + (n)%(nprocs); \ 1076 } \ 1077 (ie) = (ie)+(is); 1078 #else 1079 #define LIS_GET_ISIE(id,nprocs,n,is,ie) \ 1080 (ie) = (n)/(nprocs)+1; \ 1081 (is) = (id)*(ie)<((n)+1)?(id)*(ie):(n)+1; \ 1082 (ie) = (is)+(ie)-1<(n)?(is)+(ie)-1:(n); 1083 #endif 1084 1085 #ifdef __cplusplus 1086 } 1087 #endif 1088 1089 #endif 1090