/usr/share/pyshared/PyTrilinos/AztecOO.py is in python-pytrilinos 10.4.0.dfsg-1ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 | # This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
"""
PyTrilinos.AztecOO is the python interface to the Trilinos iterative
linear solver package AztecOO:
http://trilinos.sandia.gov/packages/aztecoo
AztecOO is the object-oriented interface to Aztec, Sandia's venerable
Krylov-space linear system solver package. Note that the C++ version
of AztecOO uses the prefix 'AztecOO_' which has been stripped from the
python version. AztecOO requires the Epetra module. The IFPACK and ML
modules can extend the preconditioning capabilities of AztecOO.
AztecOO has a single class:
* AztecOO - Object-oriented interface to Aztec package
For examples of usage, please consult the following scripts in the
example subdirectory of the PyTrilinos package:
* exAztecOO.py
* exAztecOO_Operator.py
* exAztecOO_RowMatrix.py
* exAztecOO_BasicRowMatrix.py
"""
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module('_AztecOO', [dirname(__file__)])
except ImportError:
import _AztecOO
return _AztecOO
if fp is not None:
try:
_mod = imp.load_module('_AztecOO', fp, pathname, description)
finally:
fp.close()
return _mod
_AztecOO = swig_import_helper()
del swig_import_helper
else:
import _AztecOO
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
if (name == "thisown"): return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'SwigPyObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name,None)
if method: return method(self,value)
if (not static):
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self,class_type,name,value):
return _swig_setattr_nondynamic(self,class_type,name,value,0)
def _swig_getattr(self,class_type,name):
if (name == "thisown"): return self.this.own()
method = class_type.__swig_getmethods__.get(name,None)
if method: return method(self)
raise AttributeError(name)
def _swig_repr(self):
try: strthis = "proxy of " + self.this.__repr__()
except: strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0
try:
import weakref
weakref_proxy = weakref.proxy
except:
weakref_proxy = lambda x: x
AZ_NOT_MPI = _AztecOO.AZ_NOT_MPI
AZ_MSG_TYPE = _AztecOO.AZ_MSG_TYPE
AZ_NUM_MSGS = _AztecOO.AZ_NUM_MSGS
AZ_MAX_MEMORY_SIZE = _AztecOO.AZ_MAX_MEMORY_SIZE
AZ_MAX_MSG_BUFF_SIZE = _AztecOO.AZ_MAX_MSG_BUFF_SIZE
AZ_MAX_NEIGHBORS = _AztecOO.AZ_MAX_NEIGHBORS
AZ_MAX_MESSAGE_SIZE = _AztecOO.AZ_MAX_MESSAGE_SIZE
AZ_FALSE = _AztecOO.AZ_FALSE
AZ_TRUE = _AztecOO.AZ_TRUE
AZ_MAX_POLY_ORDER = _AztecOO.AZ_MAX_POLY_ORDER
AZ_default = _AztecOO.AZ_default
AZ_cg = _AztecOO.AZ_cg
AZ_gmres = _AztecOO.AZ_gmres
AZ_cgs = _AztecOO.AZ_cgs
AZ_tfqmr = _AztecOO.AZ_tfqmr
AZ_bicgstab = _AztecOO.AZ_bicgstab
AZ_slu = _AztecOO.AZ_slu
AZ_symmlq = _AztecOO.AZ_symmlq
AZ_GMRESR = _AztecOO.AZ_GMRESR
AZ_fixed_pt = _AztecOO.AZ_fixed_pt
AZ_analyze = _AztecOO.AZ_analyze
AZ_lu = _AztecOO.AZ_lu
AZ_cg_condnum = _AztecOO.AZ_cg_condnum
AZ_gmres_condnum = _AztecOO.AZ_gmres_condnum
AZ_BJacobi = _AztecOO.AZ_BJacobi
AZ_row_sum = _AztecOO.AZ_row_sum
AZ_sym_diag = _AztecOO.AZ_sym_diag
AZ_sym_row_sum = _AztecOO.AZ_sym_row_sum
AZ_equil = _AztecOO.AZ_equil
AZ_sym_BJacobi = _AztecOO.AZ_sym_BJacobi
AZ_none = _AztecOO.AZ_none
AZ_Jacobi = _AztecOO.AZ_Jacobi
AZ_sym_GS = _AztecOO.AZ_sym_GS
AZ_Neumann = _AztecOO.AZ_Neumann
AZ_ls = _AztecOO.AZ_ls
AZ_ilu = _AztecOO.AZ_ilu
AZ_bilu = _AztecOO.AZ_bilu
AZ_icc = _AztecOO.AZ_icc
AZ_ilut = _AztecOO.AZ_ilut
AZ_rilu = _AztecOO.AZ_rilu
AZ_recursive = _AztecOO.AZ_recursive
AZ_smoother = _AztecOO.AZ_smoother
AZ_dom_decomp = _AztecOO.AZ_dom_decomp
AZ_multilevel = _AztecOO.AZ_multilevel
AZ_user_precond = _AztecOO.AZ_user_precond
AZ_bilu_ifp = _AztecOO.AZ_bilu_ifp
AZ_r0 = _AztecOO.AZ_r0
AZ_rhs = _AztecOO.AZ_rhs
AZ_Anorm = _AztecOO.AZ_Anorm
AZ_sol = _AztecOO.AZ_sol
AZ_weighted = _AztecOO.AZ_weighted
AZ_expected_values = _AztecOO.AZ_expected_values
AZ_noscaled = _AztecOO.AZ_noscaled
AZTECOO_conv_test = _AztecOO.AZTECOO_conv_test
AZ_inf_noscaled = _AztecOO.AZ_inf_noscaled
AZ_all = _AztecOO.AZ_all
AZ_last = _AztecOO.AZ_last
AZ_summary = _AztecOO.AZ_summary
AZ_warnings = _AztecOO.AZ_warnings
AZ_input_form = _AztecOO.AZ_input_form
AZ_global_mat = _AztecOO.AZ_global_mat
AZ_explicit = _AztecOO.AZ_explicit
AZ_calc = _AztecOO.AZ_calc
AZ_recalc = _AztecOO.AZ_recalc
AZ_reuse = _AztecOO.AZ_reuse
AZ_sys_reuse = _AztecOO.AZ_sys_reuse
AZ_diag = _AztecOO.AZ_diag
AZ_full = _AztecOO.AZ_full
AZ_standard = _AztecOO.AZ_standard
AZ_symmetric = _AztecOO.AZ_symmetric
AZ_classic = _AztecOO.AZ_classic
AZ_modified = _AztecOO.AZ_modified
AZ_single_classic = _AztecOO.AZ_single_classic
AZ_single_modified = _AztecOO.AZ_single_modified
AZ_double_classic = _AztecOO.AZ_double_classic
AZ_double_modified = _AztecOO.AZ_double_modified
AZ_resid = _AztecOO.AZ_resid
AZ_rand = _AztecOO.AZ_rand
AZ_normal = _AztecOO.AZ_normal
AZ_param = _AztecOO.AZ_param
AZ_breakdown = _AztecOO.AZ_breakdown
AZ_maxits = _AztecOO.AZ_maxits
AZ_loss = _AztecOO.AZ_loss
AZ_ill_cond = _AztecOO.AZ_ill_cond
AZ_solver = _AztecOO.AZ_solver
AZ_scaling = _AztecOO.AZ_scaling
AZ_precond = _AztecOO.AZ_precond
AZ_conv = _AztecOO.AZ_conv
AZ_output = _AztecOO.AZ_output
AZ_pre_calc = _AztecOO.AZ_pre_calc
AZ_max_iter = _AztecOO.AZ_max_iter
AZ_poly_ord = _AztecOO.AZ_poly_ord
AZ_overlap = _AztecOO.AZ_overlap
AZ_type_overlap = _AztecOO.AZ_type_overlap
AZ_kspace = _AztecOO.AZ_kspace
AZ_orthog = _AztecOO.AZ_orthog
AZ_aux_vec = _AztecOO.AZ_aux_vec
AZ_reorder = _AztecOO.AZ_reorder
AZ_keep_info = _AztecOO.AZ_keep_info
AZ_recursion_level = _AztecOO.AZ_recursion_level
AZ_print_freq = _AztecOO.AZ_print_freq
AZ_graph_fill = _AztecOO.AZ_graph_fill
AZ_subdomain_solve = _AztecOO.AZ_subdomain_solve
AZ_init_guess = _AztecOO.AZ_init_guess
AZ_keep_kvecs = _AztecOO.AZ_keep_kvecs
AZ_apply_kvecs = _AztecOO.AZ_apply_kvecs
AZ_orth_kvecs = _AztecOO.AZ_orth_kvecs
AZ_ignore_scaling = _AztecOO.AZ_ignore_scaling
AZ_check_update_size = _AztecOO.AZ_check_update_size
AZ_extreme = _AztecOO.AZ_extreme
AZ_diagnostics = _AztecOO.AZ_diagnostics
AZ_tol = _AztecOO.AZ_tol
AZ_drop = _AztecOO.AZ_drop
AZ_ilut_fill = _AztecOO.AZ_ilut_fill
AZ_omega = _AztecOO.AZ_omega
AZ_rthresh = _AztecOO.AZ_rthresh
AZ_athresh = _AztecOO.AZ_athresh
AZ_update_reduction = _AztecOO.AZ_update_reduction
AZ_temp = _AztecOO.AZ_temp
AZ_ill_cond_thresh = _AztecOO.AZ_ill_cond_thresh
AZ_weights = _AztecOO.AZ_weights
AZ_matrix_type = _AztecOO.AZ_matrix_type
AZ_N_internal = _AztecOO.AZ_N_internal
AZ_N_border = _AztecOO.AZ_N_border
AZ_N_external = _AztecOO.AZ_N_external
AZ_N_int_blk = _AztecOO.AZ_N_int_blk
AZ_N_bord_blk = _AztecOO.AZ_N_bord_blk
AZ_N_ext_blk = _AztecOO.AZ_N_ext_blk
AZ_N_neigh = _AztecOO.AZ_N_neigh
AZ_total_send = _AztecOO.AZ_total_send
AZ_name = _AztecOO.AZ_name
AZ_internal_use = _AztecOO.AZ_internal_use
AZ_N_rows = _AztecOO.AZ_N_rows
AZ_neighbors = _AztecOO.AZ_neighbors
AZ_rec_length = _AztecOO.AZ_rec_length
AZ_send_length = _AztecOO.AZ_send_length
AZ_send_list = _AztecOO.AZ_send_list
SIZEOF_MPI_AZCOMM = _AztecOO.SIZEOF_MPI_AZCOMM
AZ_OPTIONS_SIZE = _AztecOO.AZ_OPTIONS_SIZE
AZ_FIRST_USER_OPTION = _AztecOO.AZ_FIRST_USER_OPTION
AZ_PARAMS_SIZE = _AztecOO.AZ_PARAMS_SIZE
AZ_FIRST_USER_PARAM = _AztecOO.AZ_FIRST_USER_PARAM
AZ_PROC_SIZE = _AztecOO.AZ_PROC_SIZE
AZ_STATUS_SIZE = _AztecOO.AZ_STATUS_SIZE
AZ_COMM_SIZE = _AztecOO.AZ_COMM_SIZE
AZ_CONV_INFO_SIZE = _AztecOO.AZ_CONV_INFO_SIZE
AZ_COMMLESS_DATA_ORG_SIZE = _AztecOO.AZ_COMMLESS_DATA_ORG_SIZE
AZ_its = _AztecOO.AZ_its
AZ_why = _AztecOO.AZ_why
AZ_r = _AztecOO.AZ_r
AZ_rec_r = _AztecOO.AZ_rec_r
AZ_scaled_r = _AztecOO.AZ_scaled_r
AZ_first_precond = _AztecOO.AZ_first_precond
AZ_solve_time = _AztecOO.AZ_solve_time
AZ_Aztec_version = _AztecOO.AZ_Aztec_version
AZ_condnum = _AztecOO.AZ_condnum
AZ_lambda_min = _AztecOO.AZ_lambda_min
AZ_lambda_max = _AztecOO.AZ_lambda_max
AZ_Comm_MPI = _AztecOO.AZ_Comm_MPI
AZ_node = _AztecOO.AZ_node
AZ_N_procs = _AztecOO.AZ_N_procs
AZ_dim = _AztecOO.AZ_dim
AZ_MPI_Tag = _AztecOO.AZ_MPI_Tag
AZ_Comm_Set = _AztecOO.AZ_Comm_Set
AZ_Done_by_User = _AztecOO.AZ_Done_by_User
AZ_linear = _AztecOO.AZ_linear
AZ_file = _AztecOO.AZ_file
AZ_box = _AztecOO.AZ_box
AZ_ALLOC = _AztecOO.AZ_ALLOC
AZ_CLEAR = _AztecOO.AZ_CLEAR
AZ_REALLOC = _AztecOO.AZ_REALLOC
AZ_SELECTIVE_CLEAR = _AztecOO.AZ_SELECTIVE_CLEAR
AZ_SPEC_REALLOC = _AztecOO.AZ_SPEC_REALLOC
AZ_RESET_STRING = _AztecOO.AZ_RESET_STRING
AZ_SUBSELECTIVE_CLEAR = _AztecOO.AZ_SUBSELECTIVE_CLEAR
AZ_EVERYBODY_BUT_CLEAR = _AztecOO.AZ_EVERYBODY_BUT_CLEAR
AZ_EMPTY = _AztecOO.AZ_EMPTY
AZ_LOOKFOR_PRINT = _AztecOO.AZ_LOOKFOR_PRINT
AZ_CLEAR_ALL = _AztecOO.AZ_CLEAR_ALL
AZ_SYS = _AztecOO.AZ_SYS
AZ_OLD_ADDRESS = _AztecOO.AZ_OLD_ADDRESS
AZ_NEW_ADDRESS = _AztecOO.AZ_NEW_ADDRESS
AZ_SPECIAL = _AztecOO.AZ_SPECIAL
AZ_SOLVER_PARAMS = _AztecOO.AZ_SOLVER_PARAMS
AZ_MSR_MATRIX = _AztecOO.AZ_MSR_MATRIX
AZ_VBR_MATRIX = _AztecOO.AZ_VBR_MATRIX
AZ_USER_MATRIX = _AztecOO.AZ_USER_MATRIX
AZ_SCALE_MAT_RHS_SOL = _AztecOO.AZ_SCALE_MAT_RHS_SOL
AZ_SCALE_RHS = _AztecOO.AZ_SCALE_RHS
AZ_INVSCALE_RHS = _AztecOO.AZ_INVSCALE_RHS
AZ_SCALE_SOL = _AztecOO.AZ_SCALE_SOL
AZ_INVSCALE_SOL = _AztecOO.AZ_INVSCALE_SOL
AZ_DESTROY_SCALING_DATA = _AztecOO.AZ_DESTROY_SCALING_DATA
AZ_NOT_FIRST = _AztecOO.AZ_NOT_FIRST
AZ_FIRST_TIME = _AztecOO.AZ_FIRST_TIME
AZ_QUIT = _AztecOO.AZ_QUIT
AZ_CONTINUE = _AztecOO.AZ_CONTINUE
AZ_PACK = _AztecOO.AZ_PACK
AZ_SEND = _AztecOO.AZ_SEND
AZ_CONVERT_TO_LOCAL = _AztecOO.AZ_CONVERT_TO_LOCAL
AZ_CONVERT_BACK_TO_GLOBAL = _AztecOO.AZ_CONVERT_BACK_TO_GLOBAL
AZ_NO_EXTRA_SPACE = _AztecOO.AZ_NO_EXTRA_SPACE
AZ_ZERO = _AztecOO.AZ_ZERO
AZ_NOT_ZERO = _AztecOO.AZ_NOT_ZERO
AZ_Nspace = _AztecOO.AZ_Nspace
AZ_Nkept = _AztecOO.AZ_Nkept
AZ_left_scaling = _AztecOO.AZ_left_scaling
AZ_right_scaling = _AztecOO.AZ_right_scaling
AZ_left_and_right_scaling = _AztecOO.AZ_left_and_right_scaling
AZ_call_scale_f = _AztecOO.AZ_call_scale_f
AZ_inv_scaling = _AztecOO.AZ_inv_scaling
AZ_low = _AztecOO.AZ_low
AZ_high = _AztecOO.AZ_high
AZ_TEST_ELE = _AztecOO.AZ_TEST_ELE
AZ_ALL = _AztecOO.AZ_ALL
AZ_EXTERNS = _AztecOO.AZ_EXTERNS
AZ_GLOBAL = _AztecOO.AZ_GLOBAL
AZ_LOCAL = _AztecOO.AZ_LOCAL
import Epetra
import Teuchos
def AztecOO_Version(*args):
"""
AztecOO_Version() -> string
string AztecOO_Version()
"""
return _AztecOO.AztecOO_Version(*args)
__version__ = AztecOO_Version().split()[3]
class AztecOO(_object):
"""
AztecOO: An object-oriented wrapper for Aztec.
Currently it accepts a Petra matrix, initial guess and RHS as separate
arguments, or alternatively, accepts a Epetra_LinearProblem. If
constructed using a Epetra_LinearProblem, AztecOO will infer some
solver/preconditioner, etc., options and parameters. Users may
override these choices and manually choose from among the full set of
Aztec options using the SetAztecOption() and SetAztecParam()
functions.
AztecOO will solve a linear systems of equations: $ AX=B $, using
Epetra objects and the Aztec solver library, where $A$ is an
Epetra_Operator or Epetra_RowMatrix (note that the Epetra_Operator
class is a base class for Epetra_RowMatrix so that Epetra_RowMatrix
isa Epetra_Operator.) $X$ and $B$ are Epetra_MultiVector objects.
WARNING: AztecOO does not presently support solution of more than
one simultaneous right-hand-side.
C++ includes: AztecOO.h
"""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, AztecOO, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, AztecOO, name)
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, Operator A, Epetra_MultiVector X, Epetra_MultiVector B) -> AztecOO
__init__(self, RowMatrix A, Epetra_MultiVector X, Epetra_MultiVector B) -> AztecOO
__init__(self, LinearProblem LinearProblem) -> AztecOO
__init__(self) -> AztecOO
__init__(self, AztecOO Solver) -> AztecOO
AztecOO::AztecOO(const
AztecOO &Solver)
AztecOO Copy Constructor.
Makes copy of an existing AztecOO instance.
"""
this = _AztecOO.new_AztecOO(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _AztecOO.delete_AztecOO
__del__ = lambda self : None;
def SetProblem(self, *args):
"""
SetProblem(self, LinearProblem prob, bool call_SetPrecMatrix = False) -> int
int
AztecOO::SetProblem(const Epetra_LinearProblem &prob, bool
call_SetPrecMatrix=false)
AztecOO Epetra_LinearProblem Set.
Associates an already defined Epetra_LinearProblem as the problem that
will be solved during iterations. This method allows the user to
change which problem is being solved by an existing AztecOO object.
Internally calls SetUserMatrix() if the Epetra_LinearProblem's
operator can be cast to Epetra_RowMatrix, otherwise calls
SetUserOperator().
IMPORTANT WARNING *** This method calls SetUserMatrix(), which also
sets the *preconditioner* matrix to the matrix passed in, by
internally calling SetPrecMatrix(), but *ONLY* if SetPrecMatrix()
hasn't previously been called. If the user wants to make sure that any
pre-existing preconditioner is replaced, they must set the optional
bool argument 'call_SetPrecMatrix' to true, which will force this
function to call SetPrecMatrix().
WARNING: If a preconditioner has been pre-built and associated with
this AztecOO object, the Epetra_LinearProblem being passed in to this
method must have compatible domain and range maps.
"""
return _AztecOO.AztecOO_SetProblem(self, *args)
def SetUserOperator(self, *args):
"""
SetUserOperator(self, Operator UserOperator) -> int
int
AztecOO::SetUserOperator(Epetra_Operator *UserOperator)
AztecOO User Operator Set.
Associates an already defined Epetra_Operator as the linear operator
for the linear system system that will be solved during iterations.
This set method allows the user to pass any type of linear operator to
AztecOO, as long as the operator implements the Epetra_Operator pure
virtual class, and has proper domain and range map dimensions.
Epetra_CrsMatrix and Epetra_VbrMatrix objects can be passed in through
this method.
"""
return _AztecOO.AztecOO_SetUserOperator(self, *args)
def SetUserMatrix(self, *args):
"""
SetUserMatrix(self, RowMatrix UserMatrix, bool call_SetPrecMatrix = False) -> int
int
AztecOO::SetUserMatrix(Epetra_RowMatrix *UserMatrix, bool
call_SetPrecMatrix=false)
AztecOO User Matrix Set.
Associates an already defined Epetra_Matrix as the matrix that will be
used by AztecOO as the linear operator when solving the linear system.
Epetra_CrsMatrix and Epetra_VbrMatrix objects can be passed in through
this method.
IMPORTANT WARNING *** This method sets the preconditioner matrix to
the matrix passed in here, by internally calling SetPrecMatrix(), but
*ONLY* if SetPrecMatrix() hasn't previously been called. If the user
wants to make sure that any pre-existing preconditioner is replaced,
they must set the optional bool argument 'call_SetPrecMatrix' to true,
which will force this function to call SetPrecMatrix().
"""
return _AztecOO.AztecOO_SetUserMatrix(self, *args)
def SetLHS(self, *args):
"""
SetLHS(self, Epetra_MultiVector X) -> int
int
AztecOO::SetLHS(Epetra_MultiVector *X)
AztecOO LHS Set.
Associates an already defined Epetra_MultiVector (or Epetra_Vector) as
the initial guess and location where the solution will be return.
"""
return _AztecOO.AztecOO_SetLHS(self, *args)
def SetRHS(self, *args):
"""
SetRHS(self, Epetra_MultiVector B) -> int
int
AztecOO::SetRHS(Epetra_MultiVector *B)
AztecOO RHS Set.
Associates an already defined Epetra_MultiVector (or Epetra_Vector) as
the right-hand-side of the linear system.
"""
return _AztecOO.AztecOO_SetRHS(self, *args)
def UnsetLHSRHS(self, *args):
"""UnsetLHSRHS(self) -> int"""
return _AztecOO.AztecOO_UnsetLHSRHS(self, *args)
def SetPrecMatrix(self, *args):
"""
SetPrecMatrix(self, RowMatrix PrecMatrix) -> int
int
AztecOO::SetPrecMatrix(Epetra_RowMatrix *PrecMatrix)
AztecOO Preconditioner Matrix Set.
Associates an already defined Epetra_Matrix as the matrix that will be
used by AztecOO when constructing native AztecOO preconditioners. By
default, if AztecOO native preconditioners are used, the original
operator matrix will be used as the source for deriving the
preconditioner. However, there are instances where a user would like
to have the preconditioner be defined using a different matrix than
the original operator matrix. Another common situation is where the
user may not have the operator in matrix form but has a matrix that
approximates the operator and can be used as the basis for an
incomplete factorization. This set method allows the user to pass any
Epetra_RowMatrix to AztecOO for use in constructing an AztecOO native
preconditioner, as long as the matrix implements the Epetra_RowMatrix
pure virtual class, and has proper domain and range map dimensions.
Epetra_CrsMatrix and Epetra_VbrMatrix objects can be passed in through
this method.
"""
return _AztecOO.AztecOO_SetPrecMatrix(self, *args)
def SetPrecOperator(self, *args):
"""
SetPrecOperator(self, Operator PrecOperator) -> int
int
AztecOO::SetPrecOperator(Epetra_Operator *PrecOperator)
AztecOO External Preconditioner Set.
Associates an already defined Epetra_Operator as the preconditioner
that will be called during iterations. This set method allows the user
to pass any type of preconditioner to AztecOO, as long as the
preconditioner implements the Epetra_Operator pure virtual class, and
has proper domain and range map dimensions. Ifpack preconditioners can
be passed in through this method.
"""
return _AztecOO.AztecOO_SetPrecOperator(self, *args)
def SetStatusTest(self, *args):
"""
SetStatusTest(self, AztecOO_StatusTest StatusTest) -> int
int
AztecOO::SetStatusTest(AztecOO_StatusTest *StatusTest)
AztecOO External Convergence/Status Test Set.
Assigns an already defined AztecOO_StatusTest object as the class that
will determine when iterations should stop, either because convergence
was reached or the iteration failed. This method allows a large
variety of convergence tests to be used with AztecOO. The
AztecOO_StatusTest class is a pure virtual class, so any class that
implements its interface can be passed in to this set method. A number
of pre-defined AztecOO_StatusTest derived classes are already
available, including AztecOO_StatusTestCombo, a class that allows
logical combinations of other status test objects for sophisticated
convergence testing.
"""
return _AztecOO.AztecOO_SetStatusTest(self, *args)
def SetOutputStream(self, *args):
"""
SetOutputStream(self, ostrm)
void
AztecOO::SetOutputStream(std::ostream &ostrm)
Set std::ostream for Aztec's screen output.
This sets the destination for output that Aztec would normally send to
stdout.
"""
return _AztecOO.AztecOO_SetOutputStream(self, *args)
def SetErrorStream(self, *args):
"""
SetErrorStream(self, errstrm)
void
AztecOO::SetErrorStream(std::ostream &errstrm)
Set std::ostream for Aztec's error output.
This sets the destination for output that Aztec would normally send to
stderr.
"""
return _AztecOO.AztecOO_SetErrorStream(self, *args)
def SetPreconditioner(self, *args):
"""
SetPreconditioner(self, AZ_PRECOND Prec) -> int
SetPreconditioner(self, AZ_PREC_FUN prec_function, void prec_data) -> int
int
AztecOO::SetPreconditioner(AZ_PREC_FUN prec_function, void *prec_data)
AztecOO External Preconditioner Set (function and data).
Associates an external function and data pointer with preconditioner
"""
return _AztecOO.AztecOO_SetPreconditioner(self, *args)
def SetScaling(self, *args):
"""
SetScaling(self, AZ_SCALING Scaling) -> int
int
AztecOO::SetScaling(struct AZ_SCALING *Scaling)
AztecOO External Scaling Set.
Associates an already defined Aztec scaling object with this solve.
"""
return _AztecOO.AztecOO_SetScaling(self, *args)
def SetMatrixName(self, *args):
"""
SetMatrixName(self, int label) -> int
int
AztecOO::SetMatrixName(int label)
AztecOO Label Matrix for Aztec.
This is used to label individual matrices within Aztec. This might be
useful if several Aztec invocations are involved corresponding to
different matrices.
"""
return _AztecOO.AztecOO_SetMatrixName(self, *args)
def SetLabel(self, *args):
"""
SetLabel(self, char Label)
void
AztecOO::SetLabel(const char *const Label)
Set Label this AztecOO object.
Defines the label used to describe the this object.
"""
return _AztecOO.AztecOO_SetLabel(self, *args)
def GetLabel(self, *args):
"""
GetLabel(self) -> char
const char *
AztecOO::GetLabel() const
Get the label describing this AztecOO object.
Returns the string used to define this object.
"""
return _AztecOO.AztecOO_GetLabel(self, *args)
def ConstructPreconditioner(self, *args):
"""
ConstructPreconditioner(self, double condest) -> int
int
AztecOO::ConstructPreconditioner(double &condest)
Forces explicit construction and retention of an AztecOO native
preconditioner.
AztecOO typically constructs the preconditioner on the first call to
the solve function. However, there are situations where we would like
to compute the preconditioner ahead of time. One particular case is
when we want to confirm that the preconditioner well-conditioned. This
method allows us to precompute the preconditioner. It also provides a
estimate of the condition number of the preconditioner. If condest is
large, e.g., > 1.0e+14, it is likely the preconditioner will fail. In
this case, using threshold values (available in the incomplete
factorizations) can be used to reduce the condition number.
Note: This method does not work for user-defined preconditioners
(defined via calls to SetPrecOperator(). It will return with an error
code of -1 for this case.
"""
return _AztecOO.AztecOO_ConstructPreconditioner(self, *args)
def DestroyPreconditioner(self, *args):
"""
DestroyPreconditioner(self) -> int
int
AztecOO::DestroyPreconditioner()
Destroys a preconditioner computed using ConstructPreconditioner().
The ConstructPreconditioner() method creates a persistent
preconditioner. In other words the preconditioner will be used by all
calls to the Iterate() method. DestroyPreconditioner() deletes the
current preconditioner and restores AztecOO to a state where the
preconditioner will computed on first use of the preconditioner solve.
"""
return _AztecOO.AztecOO_DestroyPreconditioner(self, *args)
def Condest(self, *args):
"""
Condest(self) -> double
double AztecOO::Condest()
const
Returns the condition number estimate for the current preconditioner,
if one exists, returns -1.0 if no estimate.
"""
return _AztecOO.AztecOO_Condest(self, *args)
def CheckInput(self, *args):
"""
CheckInput(self) -> int
int AztecOO::CheckInput()
const
Prints a summary of solver parameters, performs simple sanity checks.
"""
return _AztecOO.AztecOO_CheckInput(self, *args)
def GetProblem(self, *args):
"""
GetProblem(self) -> LinearProblem
Epetra_LinearProblem*
AztecOO::GetProblem() const
Get a pointer to the Linear Problem used to construct this solver;
returns zero if not available.
"""
return _AztecOO.AztecOO_GetProblem(self, *args)
def GetUserOperator(self, *args):
"""
GetUserOperator(self) -> Operator
Epetra_Operator*
AztecOO::GetUserOperator() const
Get a pointer to the user operator A.
"""
return _AztecOO.AztecOO_GetUserOperator(self, *args)
def GetUserMatrix(self, *args):
"""
GetUserMatrix(self) -> RowMatrix
Epetra_RowMatrix*
AztecOO::GetUserMatrix() const
Get a pointer to the user matrix A.
"""
return _AztecOO.AztecOO_GetUserMatrix(self, *args)
def GetPrecOperator(self, *args):
"""
GetPrecOperator(self) -> Operator
Epetra_Operator*
AztecOO::GetPrecOperator() const
Get a pointer to the preconditioner operator.
"""
return _AztecOO.AztecOO_GetPrecOperator(self, *args)
def GetPrecMatrix(self, *args):
"""
GetPrecMatrix(self) -> RowMatrix
Epetra_RowMatrix*
AztecOO::GetPrecMatrix() const
Get a pointer to the matrix used to construct the preconditioner.
"""
return _AztecOO.AztecOO_GetPrecMatrix(self, *args)
def GetLHS(self, *args):
"""
GetLHS(self) -> Epetra_MultiVector
Epetra_MultiVector*
AztecOO::GetLHS() const
Get a pointer to the left-hand-side X.
"""
return _AztecOO.AztecOO_GetLHS(self, *args)
def GetRHS(self, *args):
"""
GetRHS(self) -> Epetra_MultiVector
Epetra_MultiVector*
AztecOO::GetRHS() const
Get a pointer to the right-hand-side B.
"""
return _AztecOO.AztecOO_GetRHS(self, *args)
def PrintLinearSystem(self, *args):
"""
PrintLinearSystem(self, char name)
void
AztecOO::PrintLinearSystem(const char *name)
Print linear-system to files.
Parameters:
-----------
name: Print the matrix to the file A_'name', and print the solution
and rhs vectors to files X_'name' and B_'name', respectively. Will
only produce a matrix file if the run-time-type of the matrix is
either Epetra_CrsMatrix or Epetra_VbrMatrix.
"""
return _AztecOO.AztecOO_PrintLinearSystem(self, *args)
def SetParameters(self, *args):
"""SetParameters(self, ParameterList parameterlist, bool cerr_warning_if_unused = False) -> int"""
return _AztecOO.AztecOO_SetParameters(self, *args)
def SetAztecDefaults(self, *args):
"""
SetAztecDefaults(self) -> int
int
AztecOO::SetAztecDefaults()
AztecOO function to restore default options/parameter settings.
This function is called automatically within AztecOO's constructor,
but if constructed using a Epetra_LinearProblem object, some options
are reset based on the ProblemDifficultyLevel associated with the
Epetra_LinearProblem.
See the Aztec 2.1 User Guide for a complete list of these options.
WARNING: In AztecOO, the default value of options[AZ_poly_ord] is set
to 1. This is different than Aztec 2.1, but the preferred value since
Jacobi preconditioning is used much more often than polynomial
preconditioning and one step of Jacobi is far more effective than 3
steps.
"""
return _AztecOO.AztecOO_SetAztecDefaults(self, *args)
def SetAztecOption(self, *args):
"""
SetAztecOption(self, int option, int value) -> int
int
AztecOO::SetAztecOption(int option, int value)
AztecOO option setting function.
Set a specific Aztec option value. Example:
problem.SetAztecOption(AZ_precond, AZ_Jacobi)
See the Aztec 2.1 User Guide for a complete list of these options.
"""
return _AztecOO.AztecOO_SetAztecOption(self, *args)
def GetAztecOption(self, *args):
"""
GetAztecOption(self, int option) -> int
int
AztecOO::GetAztecOption(int option)
AztecOO option getting function.
Get a specific Aztec optioin value. Example:
problem.GetAztecOption(AZ_precond)
See the Aztec 2.1 User Guide for a complete list of these options.
"""
return _AztecOO.AztecOO_GetAztecOption(self, *args)
def SetAztecParam(self, *args):
"""
SetAztecParam(self, int param, double value) -> int
int
AztecOO::SetAztecParam(int param, double value)
AztecOO param setting function.
Set a specific Aztec parameter value. Example:
problem.SetAztecParam(AZ_drop, 1.0E-6)
See the Aztec 2.1 User Guide for a complete list of these parameters.
"""
return _AztecOO.AztecOO_SetAztecParam(self, *args)
def SetAllAztecOptions(self, *args):
"""
SetAllAztecOptions(self, int options) -> int
int
AztecOO::SetAllAztecOptions(const int *options)
AztecOO option setting function.
Set all Aztec option values using an existing Aztec options array.
"""
return _AztecOO.AztecOO_SetAllAztecOptions(self, *args)
def SetAllAztecParams(self, *args):
"""
SetAllAztecParams(self, double params) -> int
int
AztecOO::SetAllAztecParams(const double *params)
AztecOO param setting function.
Set all Aztec parameter values using an existing Aztec params array.
"""
return _AztecOO.AztecOO_SetAllAztecParams(self, *args)
def Iterate(self, *args):
"""
Iterate(self, int MaxIters, double Tolerance) -> int
Iterate(self, RowMatrix A, Epetra_MultiVector X, Epetra_MultiVector B,
int MaxIters, double Tolerance) -> int
int
AztecOO::Iterate(Epetra_RowMatrix *A, Epetra_MultiVector *X,
Epetra_MultiVector *B, int MaxIters, double Tolerance)
AztecOO iteration function.
Iterates on the specified matrix and vectors until MaxIters or
Tolerance is reached..
"""
return _AztecOO.AztecOO_Iterate(self, *args)
def recursiveIterate(self, *args):
"""
recursiveIterate(self, int MaxIters, double Tolerance) -> int
int
AztecOO::recursiveIterate(int MaxIters, double Tolerance)
AztecOO iteration functions.
Iterates on the current problem until MaxIters or Tolerance is
reached.. This one should be suitable for recursive invocations of
Aztec.
"""
return _AztecOO.AztecOO_recursiveIterate(self, *args)
def SetUseAdaptiveDefaultsTrue(self, *args):
"""
SetUseAdaptiveDefaultsTrue(self) -> int
int
AztecOO::SetUseAdaptiveDefaultsTrue()
Force the AdaptiveIterate() method to use default adaptive strategy.
"""
return _AztecOO.AztecOO_SetUseAdaptiveDefaultsTrue(self, *args)
def SetAdaptiveParams(self, *args):
"""
SetAdaptiveParams(self, int NumTrials, double athresholds, double rthresholds,
double condestThreshold, double maxFill,
int maxKspace) -> int
int
AztecOO::SetAdaptiveParams(int NumTrials, double *athresholds, double
*rthresholds, double condestThreshold, double maxFill, int maxKspace)
Set the parameter that control the AdaptiveIterate() method.
The AdaptiveIterate() method attempts to solve a given problem using
multiple preconditioner and iterative method tuning parameters. There
are defaults that are coded into AdaptiveIterate() method, but the
defaults can be over-ridden by the use of the SetAdaptiveParams()
method. Details of condition number management follow:
Parameters:
-----------
NumTrials: In The number of Athresh and Rthresh pairs that should be
tried when attempting to stabilize the preconditioner.
athresholds: In The list of absolute threshold values that should be
tried when attempting to stabilize the preconditioner.
rthresholds: In The list of relative threshold values that should be
tried when attempting to stabilize the preconditioner.
condestThreshold: In If the condition number estimate of the
preconditioner is above this number, no attempt will be made to try
iterations. Instead a new preconditioner will be computed using the
next threshold pair.
maxFill: In In addition to managing the condest, the
AdaptiveIterate() method will also try to increase the preconditioner
fill if it is determined that this might help. maxFill specifies the
maximum fill allowed.
maxKspace: In In addition to managing the condest, the
AdaptiveIterate() method will also try to increase the Krylov subspace
size if GMRES is being used and it is determined that this might help.
maxKspace specifies the maximum Krylov subspace allowed.
"""
return _AztecOO.AztecOO_SetAdaptiveParams(self, *args)
def AdaptiveIterate(self, *args):
"""
AdaptiveIterate(self, int MaxIters, int MaxSolveAttempts, double Tolerance) -> int
int
AztecOO::AdaptiveIterate(int MaxIters, int MaxSolveAttempts, double
Tolerance)
Attempts to solve the given linear problem using an adaptive strategy.
"""
return _AztecOO.AztecOO_AdaptiveIterate(self, *args)
def NumIters(self, *args):
"""
NumIters(self) -> int
int AztecOO::NumIters()
const
Returns the total number of iterations performed on this problem.
"""
return _AztecOO.AztecOO_NumIters(self, *args)
def TrueResidual(self, *args):
"""
TrueResidual(self) -> double
double
AztecOO::TrueResidual() const
Returns the true unscaled residual for this problem.
"""
return _AztecOO.AztecOO_TrueResidual(self, *args)
def ScaledResidual(self, *args):
"""
ScaledResidual(self) -> double
double
AztecOO::ScaledResidual() const
Returns the true scaled residual for this problem.
"""
return _AztecOO.AztecOO_ScaledResidual(self, *args)
def RecursiveResidual(self, *args):
"""
RecursiveResidual(self) -> double
double
AztecOO::RecursiveResidual() const
Returns the recursive residual for this problem.
"""
return _AztecOO.AztecOO_RecursiveResidual(self, *args)
def SolveTime(self, *args):
"""
SolveTime(self) -> double
double
AztecOO::SolveTime() const
Returns the solve time.
"""
return _AztecOO.AztecOO_SolveTime(self, *args)
def GetAllAztecOptions(self, *args):
"""
GetAllAztecOptions(self) -> PyObject
const int*
AztecOO::GetAllAztecOptions() const
AztecOO option setting function.
Return a pointer to an array (size AZ_OPTIONS_SIZE) of all of the
currently set aztec options.
"""
return _AztecOO.AztecOO_GetAllAztecOptions(self, *args)
def GetAllAztecParams(self, *args):
"""
GetAllAztecParams(self) -> PyObject
const double*
AztecOO::GetAllAztecParams() const
AztecOO param setting function.
Return a pointer to an array (size AZ_PARAMS_SIZE) of all of the
currently set aztec parameters.
"""
return _AztecOO.AztecOO_GetAllAztecParams(self, *args)
def GetAztecStatus(self, *args):
"""
GetAztecStatus(self) -> PyObject
const double*
AztecOO::GetAztecStatus() const
Return the Aztec status after iterating.
Returns pointer to the underlying Aztec Status array (of length
AZ_STATUS_SIZE). See the Aztec documenation.
"""
return _AztecOO.AztecOO_GetAztecStatus(self, *args)
AztecOO_swigregister = _AztecOO.AztecOO_swigregister
AztecOO_swigregister(AztecOO)
def Epetra_Aztec_matvec(*args):
"""
Epetra_Aztec_matvec(double x, double y, AZ_MATRIX Amat, int proc_config)
void
Epetra_Aztec_matvec(double x[], double y[], AZ_MATRIX *Amat, int
proc_config[])
"""
return _AztecOO.Epetra_Aztec_matvec(*args)
def Epetra_Aztec_matnorminf(*args):
"""
Epetra_Aztec_matnorminf(AZ_MATRIX Amat) -> double
double
Epetra_Aztec_matnorminf(AZ_MATRIX *Amat)
"""
return _AztecOO.Epetra_Aztec_matnorminf(*args)
def Epetra_Aztec_operatorvec(*args):
"""
Epetra_Aztec_operatorvec(double x, double y, AZ_MATRIX Amat, int proc_config)
void
Epetra_Aztec_operatorvec(double x[], double y[], AZ_MATRIX *Amat, int
proc_config[])
"""
return _AztecOO.Epetra_Aztec_operatorvec(*args)
def Epetra_Aztec_operatornorminf(*args):
"""
Epetra_Aztec_operatornorminf(AZ_MATRIX Amat) -> double
double
Epetra_Aztec_operatornorminf(AZ_MATRIX *Amat)
"""
return _AztecOO.Epetra_Aztec_operatornorminf(*args)
def Epetra_Aztec_precond(*args):
"""
Epetra_Aztec_precond(double x, int input_options, int proc_config, double input_params,
AZ_MATRIX Amat, AZ_PRECOND prec)
void
Epetra_Aztec_precond(double x[], int input_options[], int
proc_config[], double input_params[], AZ_MATRIX *Amat, AZ_PRECOND
*prec)
"""
return _AztecOO.Epetra_Aztec_precond(*args)
def Epetra_Aztec_getrow(*args):
"""
Epetra_Aztec_getrow(int columns, double values, int row_lengths, AZ_MATRIX Amat,
int N_requested_rows, int requested_rows,
int allocated_space) -> int
int
Epetra_Aztec_getrow(int columns[], double values[], int row_lengths[],
AZ_MATRIX *Amat, int N_requested_rows, int requested_rows[], int
allocated_space)
"""
return _AztecOO.Epetra_Aztec_getrow(*args)
def Epetra_Aztec_comm_wrapper(*args):
"""
Epetra_Aztec_comm_wrapper(double vec, AZ_MATRIX Amat) -> int
int
Epetra_Aztec_comm_wrapper(double vec[], AZ_MATRIX *Amat)
"""
return _AztecOO.Epetra_Aztec_comm_wrapper(*args)
def AztecOO_StatusTest_wrapper(*args):
"""
AztecOO_StatusTest_wrapper(void conv_test_obj, void res_vector_obj, int iteration,
double res_vector, int print_info, int sol_updated,
int converged, int isnan, double rnorm,
int r_avail)
void
AztecOO_StatusTest_wrapper(void *conv_test_obj, void *res_vector_obj,
int iteration, double *res_vector, int print_info, int sol_updated,
int *converged, int *isnan, double *rnorm, int *r_avail)
"""
return _AztecOO.AztecOO_StatusTest_wrapper(*args)
# This file is compatible with both classic and new-style classes.
|