1 /******************************************************************************
2 * Copyright 1998-2019 Lawrence Livermore National Security, LLC and other
3 * HYPRE Project Developers. See the top-level COPYRIGHT file for details.
4 *
5 * SPDX-License-Identifier: (Apache-2.0 OR MIT)
6 ******************************************************************************/
7
8 #include "_hypre_parcsr_ls.h"
9
10 /*--------------------------------------------------------------------------
11 * HYPRE_BoomerAMGCreate
12 *--------------------------------------------------------------------------*/
13
14 HYPRE_Int
HYPRE_BoomerAMGCreate(HYPRE_Solver * solver)15 HYPRE_BoomerAMGCreate( HYPRE_Solver *solver)
16 {
17 if (!solver)
18 {
19 hypre_error_in_arg(1);
20 return hypre_error_flag;
21 }
22 *solver = (HYPRE_Solver) hypre_BoomerAMGCreate( ) ;
23
24 return hypre_error_flag;
25 }
26
27 /*--------------------------------------------------------------------------
28 * HYPRE_BoomerAMGDestroy
29 *--------------------------------------------------------------------------*/
30
31 HYPRE_Int
HYPRE_BoomerAMGDestroy(HYPRE_Solver solver)32 HYPRE_BoomerAMGDestroy( HYPRE_Solver solver )
33 {
34 return( hypre_BoomerAMGDestroy( (void *) solver ) );
35 }
36
37 /*--------------------------------------------------------------------------
38 * HYPRE_BoomerAMGSetup
39 *--------------------------------------------------------------------------*/
40
41 HYPRE_Int
HYPRE_BoomerAMGSetup(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)42 HYPRE_BoomerAMGSetup( HYPRE_Solver solver,
43 HYPRE_ParCSRMatrix A,
44 HYPRE_ParVector b,
45 HYPRE_ParVector x )
46 {
47 return( hypre_BoomerAMGSetup( (void *) solver,
48 (hypre_ParCSRMatrix *) A,
49 (hypre_ParVector *) b,
50 (hypre_ParVector *) x ) );
51 }
52
53 /*--------------------------------------------------------------------------
54 * HYPRE_BoomerAMGSolve
55 *--------------------------------------------------------------------------*/
56
57 HYPRE_Int
HYPRE_BoomerAMGSolve(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)58 HYPRE_BoomerAMGSolve( HYPRE_Solver solver,
59 HYPRE_ParCSRMatrix A,
60 HYPRE_ParVector b,
61 HYPRE_ParVector x )
62 {
63
64
65 return( hypre_BoomerAMGSolve( (void *) solver,
66 (hypre_ParCSRMatrix *) A,
67 (hypre_ParVector *) b,
68 (hypre_ParVector *) x ) );
69 }
70
71 /*--------------------------------------------------------------------------
72 * HYPRE_BoomerAMGSolveT
73 *--------------------------------------------------------------------------*/
74
75 HYPRE_Int
HYPRE_BoomerAMGSolveT(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)76 HYPRE_BoomerAMGSolveT( HYPRE_Solver solver,
77 HYPRE_ParCSRMatrix A,
78 HYPRE_ParVector b,
79 HYPRE_ParVector x )
80 {
81
82
83 return( hypre_BoomerAMGSolveT( (void *) solver,
84 (hypre_ParCSRMatrix *) A,
85 (hypre_ParVector *) b,
86 (hypre_ParVector *) x ) );
87 }
88
89 /*--------------------------------------------------------------------------
90 * HYPRE_BoomerAMGSetRestriction
91 *--------------------------------------------------------------------------*/
92
93 HYPRE_Int
HYPRE_BoomerAMGSetRestriction(HYPRE_Solver solver,HYPRE_Int restr_par)94 HYPRE_BoomerAMGSetRestriction( HYPRE_Solver solver,
95 HYPRE_Int restr_par )
96 {
97 return( hypre_BoomerAMGSetRestriction( (void *) solver, restr_par ) );
98 }
99
100 /*--------------------------------------------------------------------------
101 * HYPRE_BoomerAMGSetIsTriangular
102 *--------------------------------------------------------------------------*/
103
104 HYPRE_Int
HYPRE_BoomerAMGSetIsTriangular(HYPRE_Solver solver,HYPRE_Int is_triangular)105 HYPRE_BoomerAMGSetIsTriangular( HYPRE_Solver solver,
106 HYPRE_Int is_triangular )
107 {
108 return( hypre_BoomerAMGSetIsTriangular( (void *) solver, is_triangular ) );
109 }
110
111 /*--------------------------------------------------------------------------
112 * HYPRE_BoomerAMGSetGMRESSwitchR
113 *--------------------------------------------------------------------------*/
114
115 HYPRE_Int
HYPRE_BoomerAMGSetGMRESSwitchR(HYPRE_Solver solver,HYPRE_Int gmres_switch)116 HYPRE_BoomerAMGSetGMRESSwitchR( HYPRE_Solver solver,
117 HYPRE_Int gmres_switch )
118 {
119 return( hypre_BoomerAMGSetGMRESSwitchR( (void *) solver, gmres_switch ) );
120 }
121
122 /*--------------------------------------------------------------------------
123 * HYPRE_BoomerAMGSetMaxLevels, HYPRE_BoomerAMGGetMaxLevels
124 *--------------------------------------------------------------------------*/
125
126 HYPRE_Int
HYPRE_BoomerAMGSetMaxLevels(HYPRE_Solver solver,HYPRE_Int max_levels)127 HYPRE_BoomerAMGSetMaxLevels( HYPRE_Solver solver,
128 HYPRE_Int max_levels )
129 {
130 return( hypre_BoomerAMGSetMaxLevels( (void *) solver, max_levels ) );
131 }
132
133 HYPRE_Int
HYPRE_BoomerAMGGetMaxLevels(HYPRE_Solver solver,HYPRE_Int * max_levels)134 HYPRE_BoomerAMGGetMaxLevels( HYPRE_Solver solver,
135 HYPRE_Int * max_levels )
136 {
137 return( hypre_BoomerAMGGetMaxLevels( (void *) solver, max_levels ) );
138 }
139
140 /*--------------------------------------------------------------------------
141 * HYPRE_BoomerAMGSetMaxCoarseSize, HYPRE_BoomerAMGGetMaxCoarseSize
142 *--------------------------------------------------------------------------*/
143
144 HYPRE_Int
HYPRE_BoomerAMGSetMaxCoarseSize(HYPRE_Solver solver,HYPRE_Int max_coarse_size)145 HYPRE_BoomerAMGSetMaxCoarseSize( HYPRE_Solver solver,
146 HYPRE_Int max_coarse_size )
147 {
148 return( hypre_BoomerAMGSetMaxCoarseSize( (void *) solver, max_coarse_size ) );
149 }
150
151 HYPRE_Int
HYPRE_BoomerAMGGetMaxCoarseSize(HYPRE_Solver solver,HYPRE_Int * max_coarse_size)152 HYPRE_BoomerAMGGetMaxCoarseSize( HYPRE_Solver solver,
153 HYPRE_Int * max_coarse_size )
154 {
155 return( hypre_BoomerAMGGetMaxCoarseSize( (void *) solver, max_coarse_size ) );
156 }
157
158 /*--------------------------------------------------------------------------
159 * HYPRE_BoomerAMGSetMinCoarseSize, HYPRE_BoomerAMGGetMinCoarseSize
160 *--------------------------------------------------------------------------*/
161
162 HYPRE_Int
HYPRE_BoomerAMGSetMinCoarseSize(HYPRE_Solver solver,HYPRE_Int min_coarse_size)163 HYPRE_BoomerAMGSetMinCoarseSize( HYPRE_Solver solver,
164 HYPRE_Int min_coarse_size )
165 {
166 return( hypre_BoomerAMGSetMinCoarseSize( (void *) solver, min_coarse_size ) );
167 }
168
169 HYPRE_Int
HYPRE_BoomerAMGGetMinCoarseSize(HYPRE_Solver solver,HYPRE_Int * min_coarse_size)170 HYPRE_BoomerAMGGetMinCoarseSize( HYPRE_Solver solver,
171 HYPRE_Int * min_coarse_size )
172 {
173 return( hypre_BoomerAMGGetMinCoarseSize( (void *) solver, min_coarse_size ) );
174 }
175
176 /*--------------------------------------------------------------------------
177 * HYPRE_BoomerAMGSetSeqThreshold, HYPRE_BoomerAMGGetSeqThreshold
178 *--------------------------------------------------------------------------*/
179
180 HYPRE_Int
HYPRE_BoomerAMGSetSeqThreshold(HYPRE_Solver solver,HYPRE_Int seq_threshold)181 HYPRE_BoomerAMGSetSeqThreshold( HYPRE_Solver solver,
182 HYPRE_Int seq_threshold )
183 {
184 return( hypre_BoomerAMGSetSeqThreshold( (void *) solver, seq_threshold ) );
185 }
186
187 HYPRE_Int
HYPRE_BoomerAMGGetSeqThreshold(HYPRE_Solver solver,HYPRE_Int * seq_threshold)188 HYPRE_BoomerAMGGetSeqThreshold( HYPRE_Solver solver,
189 HYPRE_Int * seq_threshold )
190 {
191 return( hypre_BoomerAMGGetSeqThreshold( (void *) solver, seq_threshold ) );
192 }
193
194 /*--------------------------------------------------------------------------
195 * HYPRE_BoomerAMGSetRedundant, HYPRE_BoomerAMGGetRedundant
196 *--------------------------------------------------------------------------*/
197
198 HYPRE_Int
HYPRE_BoomerAMGSetRedundant(HYPRE_Solver solver,HYPRE_Int redundant)199 HYPRE_BoomerAMGSetRedundant( HYPRE_Solver solver,
200 HYPRE_Int redundant )
201 {
202 return( hypre_BoomerAMGSetRedundant( (void *) solver, redundant ) );
203 }
204
205 HYPRE_Int
HYPRE_BoomerAMGGetRedundant(HYPRE_Solver solver,HYPRE_Int * redundant)206 HYPRE_BoomerAMGGetRedundant( HYPRE_Solver solver,
207 HYPRE_Int * redundant )
208 {
209 return( hypre_BoomerAMGGetRedundant( (void *) solver, redundant ) );
210 }
211
212 /*--------------------------------------------------------------------------
213 * HYPRE_BoomerAMGSetRedundant, HYPRE_BoomerAMGGetRedundant
214 *--------------------------------------------------------------------------*/
215
216 HYPRE_Int
HYPRE_BoomerAMGSetCoarsenCutFactor(HYPRE_Solver solver,HYPRE_Int coarsen_cut_factor)217 HYPRE_BoomerAMGSetCoarsenCutFactor( HYPRE_Solver solver,
218 HYPRE_Int coarsen_cut_factor )
219 {
220 return( hypre_BoomerAMGSetCoarsenCutFactor( (void *) solver, coarsen_cut_factor ) );
221 }
222
223 HYPRE_Int
HYPRE_BoomerAMGGetCoarsenCutFactor(HYPRE_Solver solver,HYPRE_Int * coarsen_cut_factor)224 HYPRE_BoomerAMGGetCoarsenCutFactor( HYPRE_Solver solver,
225 HYPRE_Int *coarsen_cut_factor )
226 {
227 return( hypre_BoomerAMGGetCoarsenCutFactor( (void *) solver, coarsen_cut_factor ) );
228 }
229
230 /*--------------------------------------------------------------------------
231 * HYPRE_BoomerAMGSetStrongThreshold, HYPRE_BoomerAMGGetStrongThreshold
232 *--------------------------------------------------------------------------*/
233
234 HYPRE_Int
HYPRE_BoomerAMGSetStrongThreshold(HYPRE_Solver solver,HYPRE_Real strong_threshold)235 HYPRE_BoomerAMGSetStrongThreshold( HYPRE_Solver solver,
236 HYPRE_Real strong_threshold )
237 {
238 return( hypre_BoomerAMGSetStrongThreshold( (void *) solver,
239 strong_threshold ) );
240 }
241
242 HYPRE_Int
HYPRE_BoomerAMGGetStrongThreshold(HYPRE_Solver solver,HYPRE_Real * strong_threshold)243 HYPRE_BoomerAMGGetStrongThreshold( HYPRE_Solver solver,
244 HYPRE_Real * strong_threshold )
245 {
246 return( hypre_BoomerAMGGetStrongThreshold( (void *) solver,
247 strong_threshold ) );
248 }
249
250 HYPRE_Int
HYPRE_BoomerAMGSetStrongThresholdR(HYPRE_Solver solver,HYPRE_Real strong_threshold)251 HYPRE_BoomerAMGSetStrongThresholdR( HYPRE_Solver solver,
252 HYPRE_Real strong_threshold )
253 {
254 return( hypre_BoomerAMGSetStrongThresholdR( (void *) solver,
255 strong_threshold ) );
256 }
257
258 HYPRE_Int
HYPRE_BoomerAMGGetStrongThresholdR(HYPRE_Solver solver,HYPRE_Real * strong_threshold)259 HYPRE_BoomerAMGGetStrongThresholdR( HYPRE_Solver solver,
260 HYPRE_Real * strong_threshold )
261 {
262 return( hypre_BoomerAMGGetStrongThresholdR( (void *) solver,
263 strong_threshold ) );
264 }
265
266 HYPRE_Int
HYPRE_BoomerAMGSetFilterThresholdR(HYPRE_Solver solver,HYPRE_Real filter_threshold)267 HYPRE_BoomerAMGSetFilterThresholdR( HYPRE_Solver solver,
268 HYPRE_Real filter_threshold )
269 {
270 return( hypre_BoomerAMGSetFilterThresholdR( (void *) solver,
271 filter_threshold ) );
272 }
273
274 HYPRE_Int
HYPRE_BoomerAMGGetFilterThresholdR(HYPRE_Solver solver,HYPRE_Real * filter_threshold)275 HYPRE_BoomerAMGGetFilterThresholdR( HYPRE_Solver solver,
276 HYPRE_Real * filter_threshold )
277 {
278 return( hypre_BoomerAMGGetFilterThresholdR( (void *) solver,
279 filter_threshold ) );
280 }
281
282
283 HYPRE_Int
HYPRE_BoomerAMGSetSabs(HYPRE_Solver solver,HYPRE_Int Sabs)284 HYPRE_BoomerAMGSetSabs( HYPRE_Solver solver,
285 HYPRE_Int Sabs )
286 {
287 return( hypre_BoomerAMGSetSabs( (void *) solver,
288 Sabs ) );
289 }
290
291 /*--------------------------------------------------------------------------
292 * HYPRE_BoomerAMGSetMaxRowSum, HYPRE_BoomerAMGGetMaxRowSum
293 *--------------------------------------------------------------------------*/
294
295 HYPRE_Int
HYPRE_BoomerAMGSetMaxRowSum(HYPRE_Solver solver,HYPRE_Real max_row_sum)296 HYPRE_BoomerAMGSetMaxRowSum( HYPRE_Solver solver,
297 HYPRE_Real max_row_sum )
298 {
299 return( hypre_BoomerAMGSetMaxRowSum( (void *) solver,
300 max_row_sum ) );
301 }
302
303 HYPRE_Int
HYPRE_BoomerAMGGetMaxRowSum(HYPRE_Solver solver,HYPRE_Real * max_row_sum)304 HYPRE_BoomerAMGGetMaxRowSum( HYPRE_Solver solver,
305 HYPRE_Real * max_row_sum )
306 {
307 return( hypre_BoomerAMGGetMaxRowSum( (void *) solver,
308 max_row_sum ) );
309 }
310
311 /*--------------------------------------------------------------------------
312 * HYPRE_BoomerAMGSetTruncFactor, HYPRE_BoomerAMGGetTruncFactor
313 *--------------------------------------------------------------------------*/
314
315 HYPRE_Int
HYPRE_BoomerAMGSetTruncFactor(HYPRE_Solver solver,HYPRE_Real trunc_factor)316 HYPRE_BoomerAMGSetTruncFactor( HYPRE_Solver solver,
317 HYPRE_Real trunc_factor )
318 {
319 return( hypre_BoomerAMGSetTruncFactor( (void *) solver,
320 trunc_factor ) );
321 }
322
323 HYPRE_Int
HYPRE_BoomerAMGGetTruncFactor(HYPRE_Solver solver,HYPRE_Real * trunc_factor)324 HYPRE_BoomerAMGGetTruncFactor( HYPRE_Solver solver,
325 HYPRE_Real * trunc_factor )
326 {
327 return( hypre_BoomerAMGGetTruncFactor( (void *) solver,
328 trunc_factor ) );
329 }
330
331 /*--------------------------------------------------------------------------
332 * HYPRE_BoomerAMGSetPMaxElmts, HYPRE_BoomerAMGGetPMaxElmts
333 *--------------------------------------------------------------------------*/
334
335 HYPRE_Int
HYPRE_BoomerAMGSetPMaxElmts(HYPRE_Solver solver,HYPRE_Int P_max_elmts)336 HYPRE_BoomerAMGSetPMaxElmts( HYPRE_Solver solver,
337 HYPRE_Int P_max_elmts )
338 {
339 return( hypre_BoomerAMGSetPMaxElmts( (void *) solver,
340 P_max_elmts ) );
341 }
342
343 HYPRE_Int
HYPRE_BoomerAMGGetPMaxElmts(HYPRE_Solver solver,HYPRE_Int * P_max_elmts)344 HYPRE_BoomerAMGGetPMaxElmts( HYPRE_Solver solver,
345 HYPRE_Int * P_max_elmts )
346 {
347 return( hypre_BoomerAMGGetPMaxElmts( (void *) solver,
348 P_max_elmts ) );
349 }
350
351 /*--------------------------------------------------------------------------
352 * HYPRE_BoomerAMGSetJacobiTruncThreshold, HYPRE_BoomerAMGGetJacobiTruncThreshold
353 *--------------------------------------------------------------------------*/
354
355 HYPRE_Int
HYPRE_BoomerAMGSetJacobiTruncThreshold(HYPRE_Solver solver,HYPRE_Real jacobi_trunc_threshold)356 HYPRE_BoomerAMGSetJacobiTruncThreshold( HYPRE_Solver solver,
357 HYPRE_Real jacobi_trunc_threshold )
358 {
359 return( hypre_BoomerAMGSetJacobiTruncThreshold( (void *) solver,
360 jacobi_trunc_threshold ) );
361 }
362
363 HYPRE_Int
HYPRE_BoomerAMGGetJacobiTruncThreshold(HYPRE_Solver solver,HYPRE_Real * jacobi_trunc_threshold)364 HYPRE_BoomerAMGGetJacobiTruncThreshold( HYPRE_Solver solver,
365 HYPRE_Real * jacobi_trunc_threshold )
366 {
367 return( hypre_BoomerAMGGetJacobiTruncThreshold( (void *) solver,
368 jacobi_trunc_threshold ) );
369 }
370
371 /*--------------------------------------------------------------------------
372 * HYPRE_BoomerAMGSetPostInterpType, HYPRE_BoomerAMGGetPostInterpType
373 * If >0, specifies something to do to improve a computed interpolation matrix.
374 * defaults to 0, for nothing.
375 *--------------------------------------------------------------------------*/
376
377 HYPRE_Int
HYPRE_BoomerAMGSetPostInterpType(HYPRE_Solver solver,HYPRE_Int post_interp_type)378 HYPRE_BoomerAMGSetPostInterpType( HYPRE_Solver solver,
379 HYPRE_Int post_interp_type )
380 {
381 return( hypre_BoomerAMGSetPostInterpType( (void *) solver,
382 post_interp_type ) );
383 }
384
385 HYPRE_Int
HYPRE_BoomerAMGGetPostInterpType(HYPRE_Solver solver,HYPRE_Int * post_interp_type)386 HYPRE_BoomerAMGGetPostInterpType( HYPRE_Solver solver,
387 HYPRE_Int * post_interp_type )
388 {
389 return( hypre_BoomerAMGGetPostInterpType( (void *) solver,
390 post_interp_type ) );
391 }
392
393
394 /*--------------------------------------------------------------------------
395 * HYPRE_BoomerAMGSetSCommPkgSwitch
396 *--------------------------------------------------------------------------*/
397
398 HYPRE_Int
HYPRE_BoomerAMGSetSCommPkgSwitch(HYPRE_Solver solver,HYPRE_Real S_commpkg_switch)399 HYPRE_BoomerAMGSetSCommPkgSwitch( HYPRE_Solver solver,
400 HYPRE_Real S_commpkg_switch )
401 {
402 return 0;
403 }
404
405 /*--------------------------------------------------------------------------
406 * HYPRE_BoomerAMGSetInterpType
407 *--------------------------------------------------------------------------*/
408
409 HYPRE_Int
HYPRE_BoomerAMGSetInterpType(HYPRE_Solver solver,HYPRE_Int interp_type)410 HYPRE_BoomerAMGSetInterpType( HYPRE_Solver solver,
411 HYPRE_Int interp_type )
412 {
413 return( hypre_BoomerAMGSetInterpType( (void *) solver, interp_type ) );
414 }
415
416 /*--------------------------------------------------------------------------
417 * HYPRE_BoomerAMGSetSepWeight
418 *--------------------------------------------------------------------------*/
419
420 HYPRE_Int
HYPRE_BoomerAMGSetSepWeight(HYPRE_Solver solver,HYPRE_Int sep_weight)421 HYPRE_BoomerAMGSetSepWeight( HYPRE_Solver solver,
422 HYPRE_Int sep_weight )
423 {
424 return( hypre_BoomerAMGSetSepWeight( (void *) solver, sep_weight ) );
425 }
426
427 /*--------------------------------------------------------------------------
428 * HYPRE_BoomerAMGSetMinIter
429 *--------------------------------------------------------------------------*/
430
431 HYPRE_Int
HYPRE_BoomerAMGSetMinIter(HYPRE_Solver solver,HYPRE_Int min_iter)432 HYPRE_BoomerAMGSetMinIter( HYPRE_Solver solver,
433 HYPRE_Int min_iter )
434 {
435 return( hypre_BoomerAMGSetMinIter( (void *) solver, min_iter ) );
436 }
437
438 /*--------------------------------------------------------------------------
439 * HYPRE_BoomerAMGSetMaxIter
440 *--------------------------------------------------------------------------*/
441
442 HYPRE_Int
HYPRE_BoomerAMGSetMaxIter(HYPRE_Solver solver,HYPRE_Int max_iter)443 HYPRE_BoomerAMGSetMaxIter( HYPRE_Solver solver,
444 HYPRE_Int max_iter )
445 {
446 return( hypre_BoomerAMGSetMaxIter( (void *) solver, max_iter ) );
447 }
448
449 HYPRE_Int
HYPRE_BoomerAMGGetMaxIter(HYPRE_Solver solver,HYPRE_Int * max_iter)450 HYPRE_BoomerAMGGetMaxIter( HYPRE_Solver solver,
451 HYPRE_Int * max_iter )
452 {
453 return( hypre_BoomerAMGGetMaxIter( (void *) solver, max_iter ) );
454 }
455
456 /*--------------------------------------------------------------------------
457 * HYPRE_BoomerAMGSetCoarsenType, HYPRE_BoomerAMGGetCoarsenType
458 *--------------------------------------------------------------------------*/
459
460 HYPRE_Int
HYPRE_BoomerAMGSetCoarsenType(HYPRE_Solver solver,HYPRE_Int coarsen_type)461 HYPRE_BoomerAMGSetCoarsenType( HYPRE_Solver solver,
462 HYPRE_Int coarsen_type )
463 {
464 return( hypre_BoomerAMGSetCoarsenType( (void *) solver, coarsen_type ) );
465 }
466
467 HYPRE_Int
HYPRE_BoomerAMGGetCoarsenType(HYPRE_Solver solver,HYPRE_Int * coarsen_type)468 HYPRE_BoomerAMGGetCoarsenType( HYPRE_Solver solver,
469 HYPRE_Int * coarsen_type )
470 {
471 return( hypre_BoomerAMGGetCoarsenType( (void *) solver, coarsen_type ) );
472 }
473
474 /*--------------------------------------------------------------------------
475 * HYPRE_BoomerAMGSetMeasureType, HYPRE_BoomerAMGGetMeasureType
476 *--------------------------------------------------------------------------*/
477
478 HYPRE_Int
HYPRE_BoomerAMGSetMeasureType(HYPRE_Solver solver,HYPRE_Int measure_type)479 HYPRE_BoomerAMGSetMeasureType( HYPRE_Solver solver,
480 HYPRE_Int measure_type )
481 {
482 return( hypre_BoomerAMGSetMeasureType( (void *) solver, measure_type ) );
483 }
484
485 HYPRE_Int
HYPRE_BoomerAMGGetMeasureType(HYPRE_Solver solver,HYPRE_Int * measure_type)486 HYPRE_BoomerAMGGetMeasureType( HYPRE_Solver solver,
487 HYPRE_Int * measure_type )
488 {
489 return( hypre_BoomerAMGGetMeasureType( (void *) solver, measure_type ) );
490 }
491
492 /*--------------------------------------------------------------------------
493 * HYPRE_BoomerAMGSetOldDefault
494 *--------------------------------------------------------------------------*/
495
496 HYPRE_Int
HYPRE_BoomerAMGSetOldDefault(HYPRE_Solver solver)497 HYPRE_BoomerAMGSetOldDefault( HYPRE_Solver solver)
498 {
499 HYPRE_BoomerAMGSetCoarsenType( solver, 6 );
500 HYPRE_BoomerAMGSetInterpType( solver, 0 );
501 HYPRE_BoomerAMGSetPMaxElmts( solver, 0 );
502 return hypre_error_flag;
503 }
504
505 /*--------------------------------------------------------------------------
506 * HYPRE_BoomerAMGSetSetupType
507 *--------------------------------------------------------------------------*/
508
509 HYPRE_Int
HYPRE_BoomerAMGSetSetupType(HYPRE_Solver solver,HYPRE_Int setup_type)510 HYPRE_BoomerAMGSetSetupType( HYPRE_Solver solver,
511 HYPRE_Int setup_type )
512 {
513 return( hypre_BoomerAMGSetSetupType( (void *) solver, setup_type ) );
514 }
515
516 /*--------------------------------------------------------------------------
517 * HYPRE_BoomerAMGSetCycleType, HYPRE_BoomerAMGGetCycleType
518 *--------------------------------------------------------------------------*/
519
520 HYPRE_Int
HYPRE_BoomerAMGSetCycleType(HYPRE_Solver solver,HYPRE_Int cycle_type)521 HYPRE_BoomerAMGSetCycleType( HYPRE_Solver solver,
522 HYPRE_Int cycle_type )
523 {
524 return( hypre_BoomerAMGSetCycleType( (void *) solver, cycle_type ) );
525 }
526
527 HYPRE_Int
HYPRE_BoomerAMGGetCycleType(HYPRE_Solver solver,HYPRE_Int * cycle_type)528 HYPRE_BoomerAMGGetCycleType( HYPRE_Solver solver,
529 HYPRE_Int * cycle_type )
530 {
531 return( hypre_BoomerAMGGetCycleType( (void *) solver, cycle_type ) );
532 }
533
534 /*--------------------------------------------------------------------------
535 * HYPRE_BoomerAMGSetFCycle, HYPRE_BoomerAMGGetFCycle
536 *--------------------------------------------------------------------------*/
537
538 HYPRE_Int
HYPRE_BoomerAMGSetFCycle(HYPRE_Solver solver,HYPRE_Int fcycle)539 HYPRE_BoomerAMGSetFCycle( HYPRE_Solver solver,
540 HYPRE_Int fcycle )
541 {
542 return( hypre_BoomerAMGSetFCycle( (void *) solver, fcycle ) );
543 }
544
545 HYPRE_Int
HYPRE_BoomerAMGGetFCycle(HYPRE_Solver solver,HYPRE_Int * fcycle)546 HYPRE_BoomerAMGGetFCycle( HYPRE_Solver solver,
547 HYPRE_Int *fcycle )
548 {
549 return( hypre_BoomerAMGGetFCycle( (void *) solver, fcycle ) );
550 }
551
552 /*--------------------------------------------------------------------------
553 * HYPRE_BoomerAMGSetConvergeType, HYPRE_BoomerAMGGetConvergeType
554 *--------------------------------------------------------------------------*/
555
556 HYPRE_Int
HYPRE_BoomerAMGSetConvergeType(HYPRE_Solver solver,HYPRE_Int type)557 HYPRE_BoomerAMGSetConvergeType( HYPRE_Solver solver,
558 HYPRE_Int type )
559 {
560 return( hypre_BoomerAMGSetConvergeType( (void *) solver, type ) );
561 }
562
563 HYPRE_Int
HYPRE_BoomerAMGGetConvergeType(HYPRE_Solver solver,HYPRE_Int * type)564 HYPRE_BoomerAMGGetConvergeType( HYPRE_Solver solver,
565 HYPRE_Int *type )
566 {
567 return( hypre_BoomerAMGGetConvergeType( (void *) solver, type ) );
568 }
569
570 /*--------------------------------------------------------------------------
571 * HYPRE_BoomerAMGSetTol, HYPRE_BoomerAMGGetTol
572 *--------------------------------------------------------------------------*/
573
574 HYPRE_Int
HYPRE_BoomerAMGSetTol(HYPRE_Solver solver,HYPRE_Real tol)575 HYPRE_BoomerAMGSetTol( HYPRE_Solver solver,
576 HYPRE_Real tol )
577 {
578 return( hypre_BoomerAMGSetTol( (void *) solver, tol ) );
579 }
580
581 HYPRE_Int
HYPRE_BoomerAMGGetTol(HYPRE_Solver solver,HYPRE_Real * tol)582 HYPRE_BoomerAMGGetTol( HYPRE_Solver solver,
583 HYPRE_Real * tol )
584 {
585 return( hypre_BoomerAMGGetTol( (void *) solver, tol ) );
586 }
587
588 /*--------------------------------------------------------------------------
589 * HYPRE_BoomerAMGSetNumGridSweeps
590 * DEPRECATED. There are memory management problems associated with the
591 * use of a user-supplied array (who releases it?).
592 * Use SetNumSweeps and SetCycleNumSweeps instead.
593 *--------------------------------------------------------------------------*/
594
595 HYPRE_Int
HYPRE_BoomerAMGSetNumGridSweeps(HYPRE_Solver solver,HYPRE_Int * num_grid_sweeps)596 HYPRE_BoomerAMGSetNumGridSweeps( HYPRE_Solver solver,
597 HYPRE_Int *num_grid_sweeps )
598 {
599 return( hypre_BoomerAMGSetNumGridSweeps( (void *) solver, num_grid_sweeps ) );
600 }
601
602 /*--------------------------------------------------------------------------
603 * HYPRE_BoomerAMGSetNumSweeps
604 * There is no corresponding Get function. Use GetCycleNumSweeps.
605 *--------------------------------------------------------------------------*/
606
607 HYPRE_Int
HYPRE_BoomerAMGSetNumSweeps(HYPRE_Solver solver,HYPRE_Int num_sweeps)608 HYPRE_BoomerAMGSetNumSweeps( HYPRE_Solver solver,
609 HYPRE_Int num_sweeps )
610 {
611 return( hypre_BoomerAMGSetNumSweeps( (void *) solver, num_sweeps ) );
612 }
613
614 /*--------------------------------------------------------------------------
615 * HYPRE_BoomerAMGSetCycleNumSweeps, HYPRE_BoomerAMGGetCycleNumSweeps
616 *--------------------------------------------------------------------------*/
617
618 HYPRE_Int
HYPRE_BoomerAMGSetCycleNumSweeps(HYPRE_Solver solver,HYPRE_Int num_sweeps,HYPRE_Int k)619 HYPRE_BoomerAMGSetCycleNumSweeps( HYPRE_Solver solver,
620 HYPRE_Int num_sweeps, HYPRE_Int k )
621 {
622 return( hypre_BoomerAMGSetCycleNumSweeps( (void *) solver, num_sweeps, k ) );
623 }
624
625 HYPRE_Int
HYPRE_BoomerAMGGetCycleNumSweeps(HYPRE_Solver solver,HYPRE_Int * num_sweeps,HYPRE_Int k)626 HYPRE_BoomerAMGGetCycleNumSweeps( HYPRE_Solver solver,
627 HYPRE_Int * num_sweeps, HYPRE_Int k )
628 {
629 return( hypre_BoomerAMGGetCycleNumSweeps( (void *) solver, num_sweeps, k ) );
630 }
631
632 /*--------------------------------------------------------------------------
633 * HYPRE_BoomerAMGInitGridRelaxation
634 *--------------------------------------------------------------------------*/
635
636 HYPRE_Int
HYPRE_BoomerAMGInitGridRelaxation(HYPRE_Int ** num_grid_sweeps_ptr,HYPRE_Int ** grid_relax_type_ptr,HYPRE_Int *** grid_relax_points_ptr,HYPRE_Int coarsen_type,HYPRE_Real ** relax_weights_ptr,HYPRE_Int max_levels)637 HYPRE_BoomerAMGInitGridRelaxation( HYPRE_Int **num_grid_sweeps_ptr,
638 HYPRE_Int **grid_relax_type_ptr,
639 HYPRE_Int ***grid_relax_points_ptr,
640 HYPRE_Int coarsen_type,
641 HYPRE_Real **relax_weights_ptr,
642 HYPRE_Int max_levels )
643 { HYPRE_Int i;
644 HYPRE_Int *num_grid_sweeps;
645 HYPRE_Int *grid_relax_type;
646 HYPRE_Int **grid_relax_points;
647 HYPRE_Real *relax_weights;
648
649 *num_grid_sweeps_ptr = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
650 *grid_relax_type_ptr = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
651 *grid_relax_points_ptr = hypre_CTAlloc(HYPRE_Int*, 4, HYPRE_MEMORY_HOST);
652 *relax_weights_ptr = hypre_CTAlloc(HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
653
654 num_grid_sweeps = *num_grid_sweeps_ptr;
655 grid_relax_type = *grid_relax_type_ptr;
656 grid_relax_points = *grid_relax_points_ptr;
657 relax_weights = *relax_weights_ptr;
658
659 if (coarsen_type == 5)
660 {
661 /* fine grid */
662 num_grid_sweeps[0] = 3;
663 grid_relax_type[0] = 3;
664 grid_relax_points[0] = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
665 grid_relax_points[0][0] = -2;
666 grid_relax_points[0][1] = -1;
667 grid_relax_points[0][2] = 1;
668
669 /* down cycle */
670 num_grid_sweeps[1] = 4;
671 grid_relax_type[1] = 3;
672 grid_relax_points[1] = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
673 grid_relax_points[1][0] = -1;
674 grid_relax_points[1][1] = 1;
675 grid_relax_points[1][2] = -2;
676 grid_relax_points[1][3] = -2;
677
678 /* up cycle */
679 num_grid_sweeps[2] = 4;
680 grid_relax_type[2] = 3;
681 grid_relax_points[2] = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
682 grid_relax_points[2][0] = -2;
683 grid_relax_points[2][1] = -2;
684 grid_relax_points[2][2] = 1;
685 grid_relax_points[2][3] = -1;
686 }
687 else
688 {
689 /* fine grid */
690 num_grid_sweeps[0] = 2;
691 grid_relax_type[0] = 3;
692 grid_relax_points[0] = hypre_CTAlloc(HYPRE_Int, 2, HYPRE_MEMORY_HOST);
693 grid_relax_points[0][0] = 1;
694 grid_relax_points[0][1] = -1;
695
696 /* down cycle */
697 num_grid_sweeps[1] = 2;
698 grid_relax_type[1] = 3;
699 grid_relax_points[1] = hypre_CTAlloc(HYPRE_Int, 2, HYPRE_MEMORY_HOST);
700 grid_relax_points[1][0] = 1;
701 grid_relax_points[1][1] = -1;
702
703 /* up cycle */
704 num_grid_sweeps[2] = 2;
705 grid_relax_type[2] = 3;
706 grid_relax_points[2] = hypre_CTAlloc(HYPRE_Int, 2, HYPRE_MEMORY_HOST);
707 grid_relax_points[2][0] = -1;
708 grid_relax_points[2][1] = 1;
709 }
710 /* coarsest grid */
711 num_grid_sweeps[3] = 1;
712 grid_relax_type[3] = 3;
713 grid_relax_points[3] = hypre_CTAlloc(HYPRE_Int, 1, HYPRE_MEMORY_HOST);
714 grid_relax_points[3][0] = 0;
715
716 for (i = 0; i < max_levels; i++)
717 relax_weights[i] = 1.;
718
719 return hypre_error_flag;
720 }
721
722 /*--------------------------------------------------------------------------
723 * HYPRE_BoomerAMGSetGridRelaxType
724 * DEPRECATED. There are memory management problems associated with the
725 * use of a user-supplied array (who releases it?).
726 * Use SetRelaxType and SetCycleRelaxType instead.
727 *--------------------------------------------------------------------------*/
728
729 HYPRE_Int
HYPRE_BoomerAMGSetGridRelaxType(HYPRE_Solver solver,HYPRE_Int * grid_relax_type)730 HYPRE_BoomerAMGSetGridRelaxType( HYPRE_Solver solver,
731 HYPRE_Int *grid_relax_type )
732 {
733 return( hypre_BoomerAMGSetGridRelaxType( (void *) solver, grid_relax_type ) );
734 }
735
736 /*--------------------------------------------------------------------------
737 * HYPRE_BoomerAMGSetRelaxType
738 *--------------------------------------------------------------------------*/
739
740 HYPRE_Int
HYPRE_BoomerAMGSetRelaxType(HYPRE_Solver solver,HYPRE_Int relax_type)741 HYPRE_BoomerAMGSetRelaxType( HYPRE_Solver solver,
742 HYPRE_Int relax_type )
743 {
744 return( hypre_BoomerAMGSetRelaxType( (void *) solver, relax_type ) );
745 }
746
747 /*--------------------------------------------------------------------------
748 * HYPRE_BoomerAMGSetCycleRelaxType, HYPRE_BoomerAMGetCycleRelaxType
749 *--------------------------------------------------------------------------*/
750
751 HYPRE_Int
HYPRE_BoomerAMGSetCycleRelaxType(HYPRE_Solver solver,HYPRE_Int relax_type,HYPRE_Int k)752 HYPRE_BoomerAMGSetCycleRelaxType( HYPRE_Solver solver,
753 HYPRE_Int relax_type, HYPRE_Int k )
754 {
755 return( hypre_BoomerAMGSetCycleRelaxType( (void *) solver, relax_type, k ) );
756 }
757
758 HYPRE_Int
HYPRE_BoomerAMGGetCycleRelaxType(HYPRE_Solver solver,HYPRE_Int * relax_type,HYPRE_Int k)759 HYPRE_BoomerAMGGetCycleRelaxType( HYPRE_Solver solver,
760 HYPRE_Int * relax_type, HYPRE_Int k )
761 {
762 return( hypre_BoomerAMGGetCycleRelaxType( (void *) solver, relax_type, k ) );
763 }
764
765 /*--------------------------------------------------------------------------
766 * HYPRE_BoomerAMGSetRelaxOrder
767 *--------------------------------------------------------------------------*/
768
769 HYPRE_Int
HYPRE_BoomerAMGSetRelaxOrder(HYPRE_Solver solver,HYPRE_Int relax_order)770 HYPRE_BoomerAMGSetRelaxOrder( HYPRE_Solver solver,
771 HYPRE_Int relax_order)
772 {
773 return( hypre_BoomerAMGSetRelaxOrder( (void *) solver, relax_order ) );
774 }
775
776 /*--------------------------------------------------------------------------
777 * HYPRE_BoomerAMGSetGridRelaxPoints
778 * DEPRECATED. There are memory management problems associated with the
779 * use of a user-supplied array (who releases it?).
780 * Ulrike Yang suspects that nobody uses this function.
781 *--------------------------------------------------------------------------*/
782
783 HYPRE_Int
HYPRE_BoomerAMGSetGridRelaxPoints(HYPRE_Solver solver,HYPRE_Int ** grid_relax_points)784 HYPRE_BoomerAMGSetGridRelaxPoints( HYPRE_Solver solver,
785 HYPRE_Int **grid_relax_points )
786 {
787 return( hypre_BoomerAMGSetGridRelaxPoints( (void *) solver, grid_relax_points ) );
788 }
789
790 /*--------------------------------------------------------------------------
791 * HYPRE_BoomerAMGSetRelaxWeight
792 * DEPRECATED. There are memory management problems associated with the
793 * use of a user-supplied array (who releases it?).
794 * Use SetRelaxWt and SetLevelRelaxWt instead.
795 *--------------------------------------------------------------------------*/
796
797 HYPRE_Int
HYPRE_BoomerAMGSetRelaxWeight(HYPRE_Solver solver,HYPRE_Real * relax_weight)798 HYPRE_BoomerAMGSetRelaxWeight( HYPRE_Solver solver,
799 HYPRE_Real *relax_weight )
800 {
801 return( hypre_BoomerAMGSetRelaxWeight( (void *) solver, relax_weight ) );
802 }
803
804 /*--------------------------------------------------------------------------
805 * HYPRE_BoomerAMGSetRelaxWt
806 *--------------------------------------------------------------------------*/
807
808 HYPRE_Int
HYPRE_BoomerAMGSetRelaxWt(HYPRE_Solver solver,HYPRE_Real relax_wt)809 HYPRE_BoomerAMGSetRelaxWt( HYPRE_Solver solver,
810 HYPRE_Real relax_wt )
811 {
812 return( hypre_BoomerAMGSetRelaxWt( (void *) solver, relax_wt ) );
813 }
814
815 /*--------------------------------------------------------------------------
816 * HYPRE_BoomerAMGSetLevelRelaxWt
817 *--------------------------------------------------------------------------*/
818
819 HYPRE_Int
HYPRE_BoomerAMGSetLevelRelaxWt(HYPRE_Solver solver,HYPRE_Real relax_wt,HYPRE_Int level)820 HYPRE_BoomerAMGSetLevelRelaxWt( HYPRE_Solver solver,
821 HYPRE_Real relax_wt,
822 HYPRE_Int level )
823 {
824 return( hypre_BoomerAMGSetLevelRelaxWt( (void *) solver, relax_wt, level ) );
825 }
826
827 /*--------------------------------------------------------------------------
828 * HYPRE_BoomerAMGSetOmega
829 *--------------------------------------------------------------------------*/
830
831 HYPRE_Int
HYPRE_BoomerAMGSetOmega(HYPRE_Solver solver,HYPRE_Real * omega)832 HYPRE_BoomerAMGSetOmega( HYPRE_Solver solver,
833 HYPRE_Real *omega )
834 {
835 return( hypre_BoomerAMGSetOmega( (void *) solver, omega ) );
836 }
837
838 /*--------------------------------------------------------------------------
839 * HYPRE_BoomerAMGSetOuterWt
840 *--------------------------------------------------------------------------*/
841
842 HYPRE_Int
HYPRE_BoomerAMGSetOuterWt(HYPRE_Solver solver,HYPRE_Real outer_wt)843 HYPRE_BoomerAMGSetOuterWt( HYPRE_Solver solver,
844 HYPRE_Real outer_wt )
845 {
846 return( hypre_BoomerAMGSetOuterWt( (void *) solver, outer_wt ) );
847 }
848
849 /*--------------------------------------------------------------------------
850 * HYPRE_BoomerAMGSetLevelOuterWt
851 *--------------------------------------------------------------------------*/
852
853 HYPRE_Int
HYPRE_BoomerAMGSetLevelOuterWt(HYPRE_Solver solver,HYPRE_Real outer_wt,HYPRE_Int level)854 HYPRE_BoomerAMGSetLevelOuterWt( HYPRE_Solver solver,
855 HYPRE_Real outer_wt,
856 HYPRE_Int level )
857 {
858 return( hypre_BoomerAMGSetLevelOuterWt( (void *) solver, outer_wt, level ) );
859 }
860
861 /*--------------------------------------------------------------------------
862 * HYPRE_BoomerAMGSetSmoothType, HYPRE_BoomerAMGGetSmoothType
863 *--------------------------------------------------------------------------*/
864
865 HYPRE_Int
HYPRE_BoomerAMGSetSmoothType(HYPRE_Solver solver,HYPRE_Int smooth_type)866 HYPRE_BoomerAMGSetSmoothType( HYPRE_Solver solver,
867 HYPRE_Int smooth_type )
868 {
869 return( hypre_BoomerAMGSetSmoothType( (void *) solver, smooth_type ) );
870 }
871
872 HYPRE_Int
HYPRE_BoomerAMGGetSmoothType(HYPRE_Solver solver,HYPRE_Int * smooth_type)873 HYPRE_BoomerAMGGetSmoothType( HYPRE_Solver solver,
874 HYPRE_Int * smooth_type )
875 {
876 return( hypre_BoomerAMGGetSmoothType( (void *) solver, smooth_type ) );
877 }
878
879 /*--------------------------------------------------------------------------
880 * HYPRE_BoomerAMGSetSmoothNumLevels, HYPRE_BoomerAMGGetSmoothNumLevels
881 *--------------------------------------------------------------------------*/
882
883 HYPRE_Int
HYPRE_BoomerAMGSetSmoothNumLevels(HYPRE_Solver solver,HYPRE_Int smooth_num_levels)884 HYPRE_BoomerAMGSetSmoothNumLevels( HYPRE_Solver solver,
885 HYPRE_Int smooth_num_levels )
886 {
887 return( hypre_BoomerAMGSetSmoothNumLevels((void *)solver,smooth_num_levels ));
888 }
889
890 HYPRE_Int
HYPRE_BoomerAMGGetSmoothNumLevels(HYPRE_Solver solver,HYPRE_Int * smooth_num_levels)891 HYPRE_BoomerAMGGetSmoothNumLevels( HYPRE_Solver solver,
892 HYPRE_Int * smooth_num_levels )
893 {
894 return( hypre_BoomerAMGGetSmoothNumLevels((void *)solver,smooth_num_levels ));
895 }
896
897 /*--------------------------------------------------------------------------
898 * HYPRE_BoomerAMGSetSmoothNumSweeps, HYPRE_BoomerAMGGetSmoothNumSweeps
899 *--------------------------------------------------------------------------*/
900
901 HYPRE_Int
HYPRE_BoomerAMGSetSmoothNumSweeps(HYPRE_Solver solver,HYPRE_Int smooth_num_sweeps)902 HYPRE_BoomerAMGSetSmoothNumSweeps( HYPRE_Solver solver,
903 HYPRE_Int smooth_num_sweeps )
904 {
905 return( hypre_BoomerAMGSetSmoothNumSweeps((void *)solver,smooth_num_sweeps ));
906 }
907
908 HYPRE_Int
HYPRE_BoomerAMGGetSmoothNumSweeps(HYPRE_Solver solver,HYPRE_Int * smooth_num_sweeps)909 HYPRE_BoomerAMGGetSmoothNumSweeps( HYPRE_Solver solver,
910 HYPRE_Int * smooth_num_sweeps )
911 {
912 return( hypre_BoomerAMGGetSmoothNumSweeps((void *)solver,smooth_num_sweeps ));
913 }
914
915 /*--------------------------------------------------------------------------
916 * HYPRE_BoomerAMGSetLogging, HYPRE_BoomerAMGGetLogging
917 *--------------------------------------------------------------------------*/
918
919 HYPRE_Int
HYPRE_BoomerAMGSetLogging(HYPRE_Solver solver,HYPRE_Int logging)920 HYPRE_BoomerAMGSetLogging( HYPRE_Solver solver,
921 HYPRE_Int logging )
922 {
923 /* This function should be called before Setup. Logging changes
924 may require allocation or freeing of arrays, which is presently
925 only done there.
926 It may be possible to support logging changes at other times,
927 but there is little need.
928 */
929 return( hypre_BoomerAMGSetLogging( (void *) solver, logging ) );
930 }
931
932 HYPRE_Int
HYPRE_BoomerAMGGetLogging(HYPRE_Solver solver,HYPRE_Int * logging)933 HYPRE_BoomerAMGGetLogging( HYPRE_Solver solver,
934 HYPRE_Int * logging )
935 {
936 return( hypre_BoomerAMGGetLogging( (void *) solver, logging ) );
937 }
938
939 /*--------------------------------------------------------------------------
940 * HYPRE_BoomerAMGSetPrintLevel, HYPRE_BoomerAMGGetPrintLevel
941 *--------------------------------------------------------------------------*/
942
943 HYPRE_Int
HYPRE_BoomerAMGSetPrintLevel(HYPRE_Solver solver,HYPRE_Int print_level)944 HYPRE_BoomerAMGSetPrintLevel( HYPRE_Solver solver,
945 HYPRE_Int print_level )
946 {
947 return( hypre_BoomerAMGSetPrintLevel( (void *) solver, print_level ) );
948 }
949
950 HYPRE_Int
HYPRE_BoomerAMGGetPrintLevel(HYPRE_Solver solver,HYPRE_Int * print_level)951 HYPRE_BoomerAMGGetPrintLevel( HYPRE_Solver solver,
952 HYPRE_Int * print_level )
953 {
954 return( hypre_BoomerAMGGetPrintLevel( (void *) solver, print_level ) );
955 }
956
957 /*--------------------------------------------------------------------------
958 * HYPRE_BoomerAMGSetPrintFileName
959 *--------------------------------------------------------------------------*/
960
961 HYPRE_Int
HYPRE_BoomerAMGSetPrintFileName(HYPRE_Solver solver,const char * print_file_name)962 HYPRE_BoomerAMGSetPrintFileName( HYPRE_Solver solver,
963 const char *print_file_name )
964 {
965 return( hypre_BoomerAMGSetPrintFileName( (void *) solver, print_file_name ) );
966 }
967
968 /*--------------------------------------------------------------------------
969 * HYPRE_BoomerAMGSetDebugFlag, HYPRE_BoomerAMGGetDebugFlag
970 *--------------------------------------------------------------------------*/
971
972 HYPRE_Int
HYPRE_BoomerAMGSetDebugFlag(HYPRE_Solver solver,HYPRE_Int debug_flag)973 HYPRE_BoomerAMGSetDebugFlag( HYPRE_Solver solver,
974 HYPRE_Int debug_flag )
975 {
976 return( hypre_BoomerAMGSetDebugFlag( (void *) solver, debug_flag ) );
977 }
978
979 HYPRE_Int
HYPRE_BoomerAMGGetDebugFlag(HYPRE_Solver solver,HYPRE_Int * debug_flag)980 HYPRE_BoomerAMGGetDebugFlag( HYPRE_Solver solver,
981 HYPRE_Int * debug_flag )
982 {
983 return( hypre_BoomerAMGGetDebugFlag( (void *) solver, debug_flag ) );
984 }
985
986 /*--------------------------------------------------------------------------
987 * HYPRE_BoomerAMGGetNumIterations
988 *--------------------------------------------------------------------------*/
989
990 HYPRE_Int
HYPRE_BoomerAMGGetNumIterations(HYPRE_Solver solver,HYPRE_Int * num_iterations)991 HYPRE_BoomerAMGGetNumIterations( HYPRE_Solver solver,
992 HYPRE_Int *num_iterations )
993 {
994 return( hypre_BoomerAMGGetNumIterations( (void *) solver, num_iterations ) );
995 }
996
997 /*--------------------------------------------------------------------------
998 * HYPRE_BoomerAMGGetCumNumIterations
999 *--------------------------------------------------------------------------*/
1000
1001 HYPRE_Int
HYPRE_BoomerAMGGetCumNumIterations(HYPRE_Solver solver,HYPRE_Int * cum_num_iterations)1002 HYPRE_BoomerAMGGetCumNumIterations( HYPRE_Solver solver,
1003 HYPRE_Int *cum_num_iterations )
1004 {
1005 return( hypre_BoomerAMGGetCumNumIterations( (void *) solver, cum_num_iterations ) );
1006 }
1007
1008 /*--------------------------------------------------------------------------
1009 * HYPRE_BoomerAMGGetResidual
1010 *--------------------------------------------------------------------------*/
1011
1012 HYPRE_Int
HYPRE_BoomerAMGGetResidual(HYPRE_Solver solver,HYPRE_ParVector * residual)1013 HYPRE_BoomerAMGGetResidual( HYPRE_Solver solver, HYPRE_ParVector * residual )
1014 {
1015 return hypre_BoomerAMGGetResidual( (void *) solver,
1016 (hypre_ParVector **) residual );
1017 }
1018
1019
1020 /*--------------------------------------------------------------------------
1021 * HYPRE_BoomerAMGGetFinalRelativeResidualNorm
1022 *--------------------------------------------------------------------------*/
1023
1024 HYPRE_Int
HYPRE_BoomerAMGGetFinalRelativeResidualNorm(HYPRE_Solver solver,HYPRE_Real * rel_resid_norm)1025 HYPRE_BoomerAMGGetFinalRelativeResidualNorm( HYPRE_Solver solver,
1026 HYPRE_Real *rel_resid_norm )
1027 {
1028 return( hypre_BoomerAMGGetRelResidualNorm( (void *) solver, rel_resid_norm ) );
1029 }
1030
1031 /*--------------------------------------------------------------------------
1032 * HYPRE_BoomerAMGSetVariant, HYPRE_BoomerAMGGetVariant
1033 *--------------------------------------------------------------------------*/
1034
1035 HYPRE_Int
HYPRE_BoomerAMGSetVariant(HYPRE_Solver solver,HYPRE_Int variant)1036 HYPRE_BoomerAMGSetVariant( HYPRE_Solver solver,
1037 HYPRE_Int variant )
1038 {
1039 return( hypre_BoomerAMGSetVariant( (void *) solver, variant ) );
1040 }
1041
1042 HYPRE_Int
HYPRE_BoomerAMGGetVariant(HYPRE_Solver solver,HYPRE_Int * variant)1043 HYPRE_BoomerAMGGetVariant( HYPRE_Solver solver,
1044 HYPRE_Int * variant )
1045 {
1046 return( hypre_BoomerAMGGetVariant( (void *) solver, variant ) );
1047 }
1048
1049 /*--------------------------------------------------------------------------
1050 * HYPRE_BoomerAMGSetOverlap, HYPRE_BoomerAMGGetOverlap
1051 *--------------------------------------------------------------------------*/
1052
1053 HYPRE_Int
HYPRE_BoomerAMGSetOverlap(HYPRE_Solver solver,HYPRE_Int overlap)1054 HYPRE_BoomerAMGSetOverlap( HYPRE_Solver solver,
1055 HYPRE_Int overlap )
1056 {
1057 return( hypre_BoomerAMGSetOverlap( (void *) solver, overlap ) );
1058 }
1059
1060 HYPRE_Int
HYPRE_BoomerAMGGetOverlap(HYPRE_Solver solver,HYPRE_Int * overlap)1061 HYPRE_BoomerAMGGetOverlap( HYPRE_Solver solver,
1062 HYPRE_Int * overlap )
1063 {
1064 return( hypre_BoomerAMGGetOverlap( (void *) solver, overlap ) );
1065 }
1066
1067 /*--------------------------------------------------------------------------
1068 * HYPRE_BoomerAMGSetDomainType, HYPRE_BoomerAMGGetDomainType
1069 *--------------------------------------------------------------------------*/
1070
1071 HYPRE_Int
HYPRE_BoomerAMGSetDomainType(HYPRE_Solver solver,HYPRE_Int domain_type)1072 HYPRE_BoomerAMGSetDomainType( HYPRE_Solver solver,
1073 HYPRE_Int domain_type )
1074 {
1075 return( hypre_BoomerAMGSetDomainType( (void *) solver, domain_type ) );
1076 }
1077
1078 HYPRE_Int
HYPRE_BoomerAMGGetDomainType(HYPRE_Solver solver,HYPRE_Int * domain_type)1079 HYPRE_BoomerAMGGetDomainType( HYPRE_Solver solver,
1080 HYPRE_Int * domain_type )
1081 {
1082 return( hypre_BoomerAMGGetDomainType( (void *) solver, domain_type ) );
1083 }
1084
1085 /*--------------------------------------------------------------------------
1086 * HYPRE_BoomerAMGSetSchwarzRlxWeight, HYPRE_BoomerAMGGetSchwarzRlxWeight
1087 *--------------------------------------------------------------------------*/
1088
1089 HYPRE_Int
HYPRE_BoomerAMGSetSchwarzRlxWeight(HYPRE_Solver solver,HYPRE_Real schwarz_rlx_weight)1090 HYPRE_BoomerAMGSetSchwarzRlxWeight( HYPRE_Solver solver,
1091 HYPRE_Real schwarz_rlx_weight)
1092 {
1093 return( hypre_BoomerAMGSetSchwarzRlxWeight( (void *) solver,
1094 schwarz_rlx_weight ) );
1095 }
1096
1097 HYPRE_Int
HYPRE_BoomerAMGGetSchwarzRlxWeight(HYPRE_Solver solver,HYPRE_Real * schwarz_rlx_weight)1098 HYPRE_BoomerAMGGetSchwarzRlxWeight( HYPRE_Solver solver,
1099 HYPRE_Real * schwarz_rlx_weight)
1100 {
1101 return( hypre_BoomerAMGGetSchwarzRlxWeight( (void *) solver,
1102 schwarz_rlx_weight ) );
1103 }
1104 /*--------------------------------------------------------------------------
1105 * HYPRE_BoomerAMGSetSchwarzUseNonSymm
1106 *--------------------------------------------------------------------------*/
1107
1108 HYPRE_Int
HYPRE_BoomerAMGSetSchwarzUseNonSymm(HYPRE_Solver solver,HYPRE_Int use_nonsymm)1109 HYPRE_BoomerAMGSetSchwarzUseNonSymm( HYPRE_Solver solver,
1110 HYPRE_Int use_nonsymm)
1111 {
1112 return( hypre_BoomerAMGSetSchwarzUseNonSymm( (void *) solver,
1113 use_nonsymm ) );
1114 }
1115 /*--------------------------------------------------------------------------
1116 * HYPRE_BoomerAMGSym
1117 *--------------------------------------------------------------------------*/
1118
1119 HYPRE_Int
HYPRE_BoomerAMGSetSym(HYPRE_Solver solver,HYPRE_Int sym)1120 HYPRE_BoomerAMGSetSym( HYPRE_Solver solver,
1121 HYPRE_Int sym)
1122 {
1123 return( hypre_BoomerAMGSetSym( (void *) solver, sym ) );
1124 }
1125
1126 /*--------------------------------------------------------------------------
1127 * HYPRE_BoomerAMGSetLevel
1128 *--------------------------------------------------------------------------*/
1129
1130 HYPRE_Int
HYPRE_BoomerAMGSetLevel(HYPRE_Solver solver,HYPRE_Int level)1131 HYPRE_BoomerAMGSetLevel( HYPRE_Solver solver,
1132 HYPRE_Int level)
1133 {
1134 return( hypre_BoomerAMGSetLevel( (void *) solver, level ) );
1135 }
1136
1137 /*--------------------------------------------------------------------------
1138 * HYPRE_BoomerAMGSetThreshold
1139 *--------------------------------------------------------------------------*/
1140
1141 HYPRE_Int
HYPRE_BoomerAMGSetThreshold(HYPRE_Solver solver,HYPRE_Real threshold)1142 HYPRE_BoomerAMGSetThreshold( HYPRE_Solver solver,
1143 HYPRE_Real threshold )
1144 {
1145 return( hypre_BoomerAMGSetThreshold( (void *) solver, threshold ) );
1146 }
1147
1148 /*--------------------------------------------------------------------------
1149 * HYPRE_BoomerAMGSetFilter
1150 *--------------------------------------------------------------------------*/
1151
1152 HYPRE_Int
HYPRE_BoomerAMGSetFilter(HYPRE_Solver solver,HYPRE_Real filter)1153 HYPRE_BoomerAMGSetFilter( HYPRE_Solver solver,
1154 HYPRE_Real filter )
1155 {
1156 return( hypre_BoomerAMGSetFilter( (void *) solver, filter ) );
1157 }
1158
1159 /*--------------------------------------------------------------------------
1160 * HYPRE_BoomerAMGSetDropTol
1161 *--------------------------------------------------------------------------*/
1162
1163 HYPRE_Int
HYPRE_BoomerAMGSetDropTol(HYPRE_Solver solver,HYPRE_Real drop_tol)1164 HYPRE_BoomerAMGSetDropTol( HYPRE_Solver solver,
1165 HYPRE_Real drop_tol )
1166 {
1167 return( hypre_BoomerAMGSetDropTol( (void *) solver, drop_tol ) );
1168 }
1169
1170 /*--------------------------------------------------------------------------
1171 * HYPRE_BoomerAMGSetMaxNzPerRow
1172 *--------------------------------------------------------------------------*/
1173
1174 HYPRE_Int
HYPRE_BoomerAMGSetMaxNzPerRow(HYPRE_Solver solver,HYPRE_Int max_nz_per_row)1175 HYPRE_BoomerAMGSetMaxNzPerRow( HYPRE_Solver solver,
1176 HYPRE_Int max_nz_per_row )
1177 {
1178 return( hypre_BoomerAMGSetMaxNzPerRow( (void *) solver, max_nz_per_row ) );
1179 }
1180
1181 /*--------------------------------------------------------------------------
1182 * HYPRE_BoomerAMGSetEuclidFile
1183 *--------------------------------------------------------------------------*/
1184
1185 HYPRE_Int
HYPRE_BoomerAMGSetEuclidFile(HYPRE_Solver solver,char * euclidfile)1186 HYPRE_BoomerAMGSetEuclidFile( HYPRE_Solver solver,
1187 char *euclidfile)
1188 {
1189 return( hypre_BoomerAMGSetEuclidFile( (void *) solver, euclidfile ) );
1190 }
1191
1192 /*--------------------------------------------------------------------------
1193 * HYPRE_BoomerAMGSetEuLevel
1194 *--------------------------------------------------------------------------*/
1195
1196 HYPRE_Int
HYPRE_BoomerAMGSetEuLevel(HYPRE_Solver solver,HYPRE_Int eu_level)1197 HYPRE_BoomerAMGSetEuLevel( HYPRE_Solver solver,
1198 HYPRE_Int eu_level)
1199 {
1200 return( hypre_BoomerAMGSetEuLevel( (void *) solver, eu_level ) );
1201 }
1202
1203 /*--------------------------------------------------------------------------
1204 * HYPRE_BoomerAMGSetEuSparseA
1205 *--------------------------------------------------------------------------*/
1206
1207 HYPRE_Int
HYPRE_BoomerAMGSetEuSparseA(HYPRE_Solver solver,HYPRE_Real eu_sparse_A)1208 HYPRE_BoomerAMGSetEuSparseA( HYPRE_Solver solver,
1209 HYPRE_Real eu_sparse_A )
1210 {
1211 return( hypre_BoomerAMGSetEuSparseA( (void *) solver, eu_sparse_A ) );
1212 }
1213
1214 /*--------------------------------------------------------------------------
1215 * HYPRE_BoomerAMGSetEuBJ
1216 *--------------------------------------------------------------------------*/
1217
1218 HYPRE_Int
HYPRE_BoomerAMGSetEuBJ(HYPRE_Solver solver,HYPRE_Int eu_bj)1219 HYPRE_BoomerAMGSetEuBJ( HYPRE_Solver solver,
1220 HYPRE_Int eu_bj)
1221 {
1222 return( hypre_BoomerAMGSetEuBJ( (void *) solver, eu_bj ) );
1223 }
1224
1225 /*--------------------------------------------------------------------------
1226 * HYPRE_BoomerAMGSetILUType
1227 *--------------------------------------------------------------------------*/
1228
1229 HYPRE_Int
HYPRE_BoomerAMGSetILUType(HYPRE_Solver solver,HYPRE_Int ilu_type)1230 HYPRE_BoomerAMGSetILUType( HYPRE_Solver solver,
1231 HYPRE_Int ilu_type)
1232 {
1233 return( hypre_BoomerAMGSetILUType( (void *) solver, ilu_type ) );
1234 }
1235
1236 /*--------------------------------------------------------------------------
1237 * HYPRE_BoomerAMGSetILULevel
1238 *--------------------------------------------------------------------------*/
1239
1240 HYPRE_Int
HYPRE_BoomerAMGSetILULevel(HYPRE_Solver solver,HYPRE_Int ilu_lfil)1241 HYPRE_BoomerAMGSetILULevel( HYPRE_Solver solver,
1242 HYPRE_Int ilu_lfil)
1243 {
1244 return( hypre_BoomerAMGSetILULevel( (void *) solver, ilu_lfil ) );
1245 }
1246
1247 /*--------------------------------------------------------------------------
1248 * HYPRE_BoomerAMGSetILUMaxRowNnz
1249 *--------------------------------------------------------------------------*/
1250
1251 HYPRE_Int
HYPRE_BoomerAMGSetILUMaxRowNnz(HYPRE_Solver solver,HYPRE_Int ilu_max_row_nnz)1252 HYPRE_BoomerAMGSetILUMaxRowNnz( HYPRE_Solver solver,
1253 HYPRE_Int ilu_max_row_nnz)
1254 {
1255 return( hypre_BoomerAMGSetILUMaxRowNnz( (void *) solver, ilu_max_row_nnz ) );
1256 }
1257
1258 /*--------------------------------------------------------------------------
1259 * HYPRE_BoomerAMGSetILUMaxIter
1260 *--------------------------------------------------------------------------*/
1261
1262 HYPRE_Int
HYPRE_BoomerAMGSetILUMaxIter(HYPRE_Solver solver,HYPRE_Int ilu_max_iter)1263 HYPRE_BoomerAMGSetILUMaxIter( HYPRE_Solver solver,
1264 HYPRE_Int ilu_max_iter)
1265 {
1266 return( hypre_BoomerAMGSetILUMaxIter( (void *) solver, ilu_max_iter ) );
1267 }
1268
1269 /*--------------------------------------------------------------------------
1270 * HYPRE_BoomerAMGSetILUDroptol
1271 *--------------------------------------------------------------------------*/
1272
1273 HYPRE_Int
HYPRE_BoomerAMGSetILUDroptol(HYPRE_Solver solver,HYPRE_Real ilu_droptol)1274 HYPRE_BoomerAMGSetILUDroptol( HYPRE_Solver solver,
1275 HYPRE_Real ilu_droptol)
1276 {
1277 return( hypre_BoomerAMGSetILUDroptol( (void *) solver, ilu_droptol ) );
1278 }
1279
1280 /*--------------------------------------------------------------------------
1281 * HYPRE_BoomerAMGSetILULocalReordering
1282 *--------------------------------------------------------------------------*/
1283
1284 HYPRE_Int
HYPRE_BoomerAMGSetILULocalReordering(HYPRE_Solver solver,HYPRE_Int ilu_reordering_type)1285 HYPRE_BoomerAMGSetILULocalReordering( HYPRE_Solver solver,
1286 HYPRE_Int ilu_reordering_type)
1287 {
1288 return( hypre_BoomerAMGSetILULocalReordering( (void *) solver, ilu_reordering_type ) );
1289 }
1290
1291 /*--------------------------------------------------------------------------
1292 * HYPRE_BoomerAMGSetNumFunctions, HYPRE_BoomerAMGGetNumFunctions
1293 *--------------------------------------------------------------------------*/
1294
1295 HYPRE_Int
HYPRE_BoomerAMGSetNumFunctions(HYPRE_Solver solver,HYPRE_Int num_functions)1296 HYPRE_BoomerAMGSetNumFunctions( HYPRE_Solver solver,
1297 HYPRE_Int num_functions )
1298 {
1299 return( hypre_BoomerAMGSetNumFunctions( (void *) solver, num_functions ) );
1300 }
1301
1302 HYPRE_Int
HYPRE_BoomerAMGGetNumFunctions(HYPRE_Solver solver,HYPRE_Int * num_functions)1303 HYPRE_BoomerAMGGetNumFunctions( HYPRE_Solver solver,
1304 HYPRE_Int * num_functions )
1305 {
1306 return( hypre_BoomerAMGGetNumFunctions( (void *) solver, num_functions ) );
1307 }
1308
1309 /*--------------------------------------------------------------------------
1310 * HYPRE_BoomerAMGSetNodal
1311 *--------------------------------------------------------------------------*/
1312
1313 HYPRE_Int
HYPRE_BoomerAMGSetNodal(HYPRE_Solver solver,HYPRE_Int nodal)1314 HYPRE_BoomerAMGSetNodal( HYPRE_Solver solver,
1315 HYPRE_Int nodal )
1316 {
1317 return( hypre_BoomerAMGSetNodal( (void *) solver, nodal ) );
1318 }
1319 /*--------------------------------------------------------------------------
1320 * HYPRE_BoomerAMGSetNodalLevels
1321 *--------------------------------------------------------------------------*/
1322
1323 HYPRE_Int
HYPRE_BoomerAMGSetNodalLevels(HYPRE_Solver solver,HYPRE_Int nodal_levels)1324 HYPRE_BoomerAMGSetNodalLevels( HYPRE_Solver solver,
1325 HYPRE_Int nodal_levels )
1326 {
1327 return( hypre_BoomerAMGSetNodalLevels( (void *) solver, nodal_levels ) );
1328 }
1329
1330
1331 /*--------------------------------------------------------------------------
1332 * HYPRE_BoomerAMGSetNodalDiag
1333 *--------------------------------------------------------------------------*/
1334
1335 HYPRE_Int
HYPRE_BoomerAMGSetNodalDiag(HYPRE_Solver solver,HYPRE_Int nodal)1336 HYPRE_BoomerAMGSetNodalDiag( HYPRE_Solver solver,
1337 HYPRE_Int nodal )
1338 {
1339 return( hypre_BoomerAMGSetNodalDiag( (void *) solver, nodal ) );
1340 }
1341
1342 /*--------------------------------------------------------------------------
1343 * HYPRE_BoomerAMGSetKeepSameSign
1344 *--------------------------------------------------------------------------*/
1345
1346 HYPRE_Int
HYPRE_BoomerAMGSetKeepSameSign(HYPRE_Solver solver,HYPRE_Int keep_same_sign)1347 HYPRE_BoomerAMGSetKeepSameSign( HYPRE_Solver solver,
1348 HYPRE_Int keep_same_sign )
1349 {
1350 return( hypre_BoomerAMGSetKeepSameSign( (void *) solver, keep_same_sign ) );
1351 }
1352 /*--------------------------------------------------------------------------
1353 * HYPRE_BoomerAMGSetDofFunc
1354 *--------------------------------------------------------------------------*/
1355
1356 HYPRE_Int
HYPRE_BoomerAMGSetDofFunc(HYPRE_Solver solver,HYPRE_Int * dof_func)1357 HYPRE_BoomerAMGSetDofFunc( HYPRE_Solver solver,
1358 HYPRE_Int *dof_func )
1359 /* Warning about a possible memory problem: When the BoomerAMG object is destroyed
1360 in hypre_BoomerAMGDestroy, dof_func aka DofFunc will be destroyed (currently
1361 line 246 of par_amg.c). Normally this is what we want. But if the user provided
1362 dof_func by calling HYPRE_BoomerAMGSetDofFunc, this could be an unwanted surprise.
1363 As hypre is currently commonly used, this situation is likely to be rare. */
1364 {
1365 return( hypre_BoomerAMGSetDofFunc( (void *) solver, dof_func ) );
1366 }
1367
1368 /*--------------------------------------------------------------------------
1369 * HYPRE_BoomerAMGSetNumPaths
1370 *--------------------------------------------------------------------------*/
1371
1372 HYPRE_Int
HYPRE_BoomerAMGSetNumPaths(HYPRE_Solver solver,HYPRE_Int num_paths)1373 HYPRE_BoomerAMGSetNumPaths( HYPRE_Solver solver,
1374 HYPRE_Int num_paths )
1375 {
1376 return( hypre_BoomerAMGSetNumPaths( (void *) solver, num_paths ) );
1377 }
1378
1379 /*--------------------------------------------------------------------------
1380 * HYPRE_BoomerAMGSetAggNumLevels
1381 *--------------------------------------------------------------------------*/
1382
1383 HYPRE_Int
HYPRE_BoomerAMGSetAggNumLevels(HYPRE_Solver solver,HYPRE_Int agg_num_levels)1384 HYPRE_BoomerAMGSetAggNumLevels( HYPRE_Solver solver,
1385 HYPRE_Int agg_num_levels )
1386 {
1387 return( hypre_BoomerAMGSetAggNumLevels( (void *) solver, agg_num_levels ) );
1388 }
1389
1390 /*--------------------------------------------------------------------------
1391 * HYPRE_BoomerAMGSetAggInterpType
1392 *--------------------------------------------------------------------------*/
1393
1394 HYPRE_Int
HYPRE_BoomerAMGSetAggInterpType(HYPRE_Solver solver,HYPRE_Int agg_interp_type)1395 HYPRE_BoomerAMGSetAggInterpType( HYPRE_Solver solver,
1396 HYPRE_Int agg_interp_type )
1397 {
1398 return( hypre_BoomerAMGSetAggInterpType( (void *) solver, agg_interp_type ) );
1399 }
1400
1401 /*--------------------------------------------------------------------------
1402 * HYPRE_BoomerAMGSetAggTruncFactor
1403 *--------------------------------------------------------------------------*/
1404
1405 HYPRE_Int
HYPRE_BoomerAMGSetAggTruncFactor(HYPRE_Solver solver,HYPRE_Real agg_trunc_factor)1406 HYPRE_BoomerAMGSetAggTruncFactor( HYPRE_Solver solver,
1407 HYPRE_Real agg_trunc_factor )
1408 {
1409 return( hypre_BoomerAMGSetAggTruncFactor( (void *) solver, agg_trunc_factor ) );
1410 }
1411
1412 /*--------------------------------------------------------------------------
1413 * HYPRE_BoomerAMGSetAddTruncFactor
1414 *--------------------------------------------------------------------------*/
1415
1416 HYPRE_Int
HYPRE_BoomerAMGSetAddTruncFactor(HYPRE_Solver solver,HYPRE_Real add_trunc_factor)1417 HYPRE_BoomerAMGSetAddTruncFactor( HYPRE_Solver solver,
1418 HYPRE_Real add_trunc_factor )
1419 {
1420 return( hypre_BoomerAMGSetMultAddTruncFactor( (void *) solver, add_trunc_factor ) );
1421 }
1422
1423 /*--------------------------------------------------------------------------
1424 * HYPRE_BoomerAMGSetMultAddTruncFactor
1425 *--------------------------------------------------------------------------*/
1426
1427 HYPRE_Int
HYPRE_BoomerAMGSetMultAddTruncFactor(HYPRE_Solver solver,HYPRE_Real add_trunc_factor)1428 HYPRE_BoomerAMGSetMultAddTruncFactor( HYPRE_Solver solver,
1429 HYPRE_Real add_trunc_factor )
1430 {
1431 return( hypre_BoomerAMGSetMultAddTruncFactor( (void *) solver, add_trunc_factor ) );
1432 }
1433
1434 /*--------------------------------------------------------------------------
1435 * HYPRE_BoomerAMGSetAddRelaxWt
1436 *--------------------------------------------------------------------------*/
1437
1438 HYPRE_Int
HYPRE_BoomerAMGSetAddRelaxWt(HYPRE_Solver solver,HYPRE_Real add_rlx_wt)1439 HYPRE_BoomerAMGSetAddRelaxWt( HYPRE_Solver solver,
1440 HYPRE_Real add_rlx_wt )
1441 {
1442 return( hypre_BoomerAMGSetAddRelaxWt( (void *) solver, add_rlx_wt ) );
1443 }
1444
1445 /*--------------------------------------------------------------------------
1446 * HYPRE_BoomerAMGSetAddRelaxType
1447 *--------------------------------------------------------------------------*/
1448
1449 HYPRE_Int
HYPRE_BoomerAMGSetAddRelaxType(HYPRE_Solver solver,HYPRE_Int add_rlx_type)1450 HYPRE_BoomerAMGSetAddRelaxType( HYPRE_Solver solver,
1451 HYPRE_Int add_rlx_type )
1452 {
1453 return( hypre_BoomerAMGSetAddRelaxType( (void *) solver, add_rlx_type ) );
1454 }
1455 /*--------------------------------------------------------------------------
1456 * HYPRE_BoomerAMGSetAggP12TruncFactor
1457 *--------------------------------------------------------------------------*/
1458
1459 HYPRE_Int
HYPRE_BoomerAMGSetAggP12TruncFactor(HYPRE_Solver solver,HYPRE_Real agg_P12_trunc_factor)1460 HYPRE_BoomerAMGSetAggP12TruncFactor( HYPRE_Solver solver,
1461 HYPRE_Real agg_P12_trunc_factor )
1462 {
1463 return( hypre_BoomerAMGSetAggP12TruncFactor( (void *) solver, agg_P12_trunc_factor ) );
1464 }
1465
1466 /*--------------------------------------------------------------------------
1467 * HYPRE_BoomerAMGSetAggPMaxElmts
1468 *--------------------------------------------------------------------------*/
1469
1470 HYPRE_Int
HYPRE_BoomerAMGSetAggPMaxElmts(HYPRE_Solver solver,HYPRE_Int agg_P_max_elmts)1471 HYPRE_BoomerAMGSetAggPMaxElmts( HYPRE_Solver solver,
1472 HYPRE_Int agg_P_max_elmts )
1473 {
1474 return( hypre_BoomerAMGSetAggPMaxElmts( (void *) solver, agg_P_max_elmts ) );
1475 }
1476
1477 /*--------------------------------------------------------------------------
1478 * HYPRE_BoomerAMGSetAddPMaxElmts
1479 *--------------------------------------------------------------------------*/
1480
1481 HYPRE_Int
HYPRE_BoomerAMGSetAddPMaxElmts(HYPRE_Solver solver,HYPRE_Int add_P_max_elmts)1482 HYPRE_BoomerAMGSetAddPMaxElmts( HYPRE_Solver solver,
1483 HYPRE_Int add_P_max_elmts )
1484 {
1485 return( hypre_BoomerAMGSetMultAddPMaxElmts( (void *) solver, add_P_max_elmts ) );
1486 }
1487
1488 /*--------------------------------------------------------------------------
1489 * HYPRE_BoomerAMGSetMultAddPMaxElmts
1490 *--------------------------------------------------------------------------*/
1491
1492 HYPRE_Int
HYPRE_BoomerAMGSetMultAddPMaxElmts(HYPRE_Solver solver,HYPRE_Int add_P_max_elmts)1493 HYPRE_BoomerAMGSetMultAddPMaxElmts( HYPRE_Solver solver,
1494 HYPRE_Int add_P_max_elmts )
1495 {
1496 return( hypre_BoomerAMGSetMultAddPMaxElmts( (void *) solver, add_P_max_elmts ) );
1497 }
1498
1499 /*--------------------------------------------------------------------------
1500 * HYPRE_BoomerAMGSetAggP12MaxElmts
1501 *--------------------------------------------------------------------------*/
1502
1503 HYPRE_Int
HYPRE_BoomerAMGSetAggP12MaxElmts(HYPRE_Solver solver,HYPRE_Int agg_P12_max_elmts)1504 HYPRE_BoomerAMGSetAggP12MaxElmts( HYPRE_Solver solver,
1505 HYPRE_Int agg_P12_max_elmts )
1506 {
1507 return( hypre_BoomerAMGSetAggP12MaxElmts( (void *) solver, agg_P12_max_elmts ) );
1508 }
1509
1510 /*--------------------------------------------------------------------------
1511 * HYPRE_BoomerAMGSetNumCRRelaxSteps
1512 *--------------------------------------------------------------------------*/
1513
1514 HYPRE_Int
HYPRE_BoomerAMGSetNumCRRelaxSteps(HYPRE_Solver solver,HYPRE_Int num_CR_relax_steps)1515 HYPRE_BoomerAMGSetNumCRRelaxSteps( HYPRE_Solver solver,
1516 HYPRE_Int num_CR_relax_steps )
1517 {
1518 return( hypre_BoomerAMGSetNumCRRelaxSteps( (void *) solver, num_CR_relax_steps ) );
1519 }
1520
1521 /*--------------------------------------------------------------------------
1522 * HYPRE_BoomerAMGSetCRRate
1523 *--------------------------------------------------------------------------*/
1524
1525 HYPRE_Int
HYPRE_BoomerAMGSetCRRate(HYPRE_Solver solver,HYPRE_Real CR_rate)1526 HYPRE_BoomerAMGSetCRRate( HYPRE_Solver solver,
1527 HYPRE_Real CR_rate )
1528 {
1529 return( hypre_BoomerAMGSetCRRate( (void *) solver, CR_rate ) );
1530 }
1531
1532 /*--------------------------------------------------------------------------
1533 * HYPRE_BoomerAMGSetCRStrongTh
1534 *--------------------------------------------------------------------------*/
1535
1536 HYPRE_Int
HYPRE_BoomerAMGSetCRStrongTh(HYPRE_Solver solver,HYPRE_Real CR_strong_th)1537 HYPRE_BoomerAMGSetCRStrongTh( HYPRE_Solver solver,
1538 HYPRE_Real CR_strong_th )
1539 {
1540 return( hypre_BoomerAMGSetCRStrongTh( (void *) solver, CR_strong_th ) );
1541 }
1542
1543 HYPRE_Int
HYPRE_BoomerAMGSetADropTol(HYPRE_Solver solver,HYPRE_Real A_drop_tol)1544 HYPRE_BoomerAMGSetADropTol( HYPRE_Solver solver,
1545 HYPRE_Real A_drop_tol )
1546 {
1547 return( hypre_BoomerAMGSetADropTol( (void *) solver, A_drop_tol ) );
1548 }
1549
1550 HYPRE_Int
HYPRE_BoomerAMGSetADropType(HYPRE_Solver solver,HYPRE_Int A_drop_type)1551 HYPRE_BoomerAMGSetADropType( HYPRE_Solver solver,
1552 HYPRE_Int A_drop_type )
1553 {
1554 return( hypre_BoomerAMGSetADropType( (void *) solver, A_drop_type ) );
1555 }
1556 /*--------------------------------------------------------------------------
1557 * HYPRE_BoomerAMGSetISType
1558 *--------------------------------------------------------------------------*/
1559
1560 HYPRE_Int
HYPRE_BoomerAMGSetISType(HYPRE_Solver solver,HYPRE_Int IS_type)1561 HYPRE_BoomerAMGSetISType( HYPRE_Solver solver,
1562 HYPRE_Int IS_type )
1563 {
1564 return( hypre_BoomerAMGSetISType( (void *) solver, IS_type ) );
1565 }
1566
1567 /*--------------------------------------------------------------------------
1568 * HYPRE_BoomerAMGSetCRUseCG
1569 *--------------------------------------------------------------------------*/
1570
1571 HYPRE_Int
HYPRE_BoomerAMGSetCRUseCG(HYPRE_Solver solver,HYPRE_Int CR_use_CG)1572 HYPRE_BoomerAMGSetCRUseCG( HYPRE_Solver solver,
1573 HYPRE_Int CR_use_CG )
1574 {
1575 return( hypre_BoomerAMGSetCRUseCG( (void *) solver, CR_use_CG ) );
1576 }
1577
1578 /*--------------------------------------------------------------------------
1579 * HYPRE_BoomerAMGSetGSMG
1580 *--------------------------------------------------------------------------*/
1581
1582 HYPRE_Int
HYPRE_BoomerAMGSetGSMG(HYPRE_Solver solver,HYPRE_Int gsmg)1583 HYPRE_BoomerAMGSetGSMG( HYPRE_Solver solver,
1584 HYPRE_Int gsmg )
1585 {
1586 return( hypre_BoomerAMGSetGSMG( (void *) solver, gsmg ) );
1587 }
1588
1589 /*--------------------------------------------------------------------------
1590 * HYPRE_BoomerAMGSetNumSamples
1591 *--------------------------------------------------------------------------*/
1592
1593 HYPRE_Int
HYPRE_BoomerAMGSetNumSamples(HYPRE_Solver solver,HYPRE_Int gsmg)1594 HYPRE_BoomerAMGSetNumSamples( HYPRE_Solver solver,
1595 HYPRE_Int gsmg )
1596 {
1597 return( hypre_BoomerAMGSetNumSamples( (void *) solver, gsmg ) );
1598 }
1599 /* BM Aug 25, 2006 */
1600
1601 /*--------------------------------------------------------------------------
1602 * HYPRE_BoomerAMGSetCGCIts
1603 *--------------------------------------------------------------------------*/
1604
1605 HYPRE_Int
HYPRE_BoomerAMGSetCGCIts(HYPRE_Solver solver,HYPRE_Int its)1606 HYPRE_BoomerAMGSetCGCIts (HYPRE_Solver solver,
1607 HYPRE_Int its)
1608 {
1609 return (hypre_BoomerAMGSetCGCIts ( (void *) solver, its ) );
1610 }
1611
1612 /* BM Oct 23, 2006 */
1613 /*--------------------------------------------------------------------------
1614 * HYPRE_BoomerAMGSetPlotGrids
1615 *--------------------------------------------------------------------------*/
1616
1617 HYPRE_Int
HYPRE_BoomerAMGSetPlotGrids(HYPRE_Solver solver,HYPRE_Int plotgrids)1618 HYPRE_BoomerAMGSetPlotGrids (HYPRE_Solver solver,
1619 HYPRE_Int plotgrids)
1620 {
1621 return (hypre_BoomerAMGSetPlotGrids ( (void *) solver, plotgrids ) );
1622 }
1623
1624 /*--------------------------------------------------------------------------
1625 * HYPRE_BoomerAMGSetPlotFileName
1626 *--------------------------------------------------------------------------*/
1627
1628 HYPRE_Int
HYPRE_BoomerAMGSetPlotFileName(HYPRE_Solver solver,const char * plotfilename)1629 HYPRE_BoomerAMGSetPlotFileName (HYPRE_Solver solver,
1630 const char *plotfilename)
1631 {
1632 return (hypre_BoomerAMGSetPlotFileName ( (void *) solver, plotfilename ) );
1633 }
1634
1635 /* BM Oct 17, 2006 */
1636
1637 /*--------------------------------------------------------------------------
1638 * HYPRE_BoomerAMGSetCoordDim
1639 *--------------------------------------------------------------------------*/
1640
1641 HYPRE_Int
HYPRE_BoomerAMGSetCoordDim(HYPRE_Solver solver,HYPRE_Int coorddim)1642 HYPRE_BoomerAMGSetCoordDim (HYPRE_Solver solver,
1643 HYPRE_Int coorddim)
1644 {
1645 return (hypre_BoomerAMGSetCoordDim ( (void *) solver, coorddim ) );
1646 }
1647
1648 /*--------------------------------------------------------------------------
1649 * HYPRE_BoomerAMGSetCoordinates
1650 *--------------------------------------------------------------------------*/
1651
1652 HYPRE_Int
HYPRE_BoomerAMGSetCoordinates(HYPRE_Solver solver,float * coordinates)1653 HYPRE_BoomerAMGSetCoordinates (HYPRE_Solver solver,
1654 float *coordinates)
1655 {
1656 return (hypre_BoomerAMGSetCoordinates ( (void *) solver, coordinates ) );
1657 }
1658
1659 /*--------------------------------------------------------------------------
1660 * HYPRE_BoomerAMGGetGridHierarchy
1661 *--------------------------------------------------------------------------*/
1662
1663 HYPRE_Int
HYPRE_BoomerAMGGetGridHierarchy(HYPRE_Solver solver,HYPRE_Int * cgrid)1664 HYPRE_BoomerAMGGetGridHierarchy(HYPRE_Solver solver,
1665 HYPRE_Int *cgrid )
1666 {
1667 return (hypre_BoomerAMGGetGridHierarchy ( (void *) solver, cgrid ) );
1668 }
1669
1670 /*--------------------------------------------------------------------------
1671 * HYPRE_BoomerAMGSetChebyOrder
1672 *--------------------------------------------------------------------------*/
1673
1674 HYPRE_Int
HYPRE_BoomerAMGSetChebyOrder(HYPRE_Solver solver,HYPRE_Int order)1675 HYPRE_BoomerAMGSetChebyOrder( HYPRE_Solver solver,
1676 HYPRE_Int order )
1677 {
1678 return( hypre_BoomerAMGSetChebyOrder( (void *) solver, order ) );
1679 }
1680 /*--------------------------------------------------------------------------
1681 * HYPRE_BoomerAMGSetChebyFraction
1682 *--------------------------------------------------------------------------*/
1683
1684 HYPRE_Int
HYPRE_BoomerAMGSetChebyFraction(HYPRE_Solver solver,HYPRE_Real ratio)1685 HYPRE_BoomerAMGSetChebyFraction( HYPRE_Solver solver,
1686 HYPRE_Real ratio )
1687 {
1688 return( hypre_BoomerAMGSetChebyFraction( (void *) solver, ratio ) );
1689 }
1690
1691 /*--------------------------------------------------------------------------
1692 * HYPRE_BoomerAMGSetChebyScale
1693 *--------------------------------------------------------------------------*/
1694
1695 HYPRE_Int
HYPRE_BoomerAMGSetChebyScale(HYPRE_Solver solver,HYPRE_Int scale)1696 HYPRE_BoomerAMGSetChebyScale( HYPRE_Solver solver,
1697 HYPRE_Int scale )
1698 {
1699 return( hypre_BoomerAMGSetChebyScale( (void *) solver, scale ) );
1700 }
1701
1702 /*--------------------------------------------------------------------------
1703 * HYPRE_BoomerAMGSetChebyVariant
1704 *--------------------------------------------------------------------------*/
1705
1706 HYPRE_Int
HYPRE_BoomerAMGSetChebyVariant(HYPRE_Solver solver,HYPRE_Int variant)1707 HYPRE_BoomerAMGSetChebyVariant( HYPRE_Solver solver,
1708 HYPRE_Int variant )
1709 {
1710 return( hypre_BoomerAMGSetChebyVariant( (void *) solver, variant ) );
1711 }
1712
1713 /*--------------------------------------------------------------------------
1714 * HYPRE_BoomerAMGSetChebyEigEst
1715 *--------------------------------------------------------------------------*/
1716
1717 HYPRE_Int
HYPRE_BoomerAMGSetChebyEigEst(HYPRE_Solver solver,HYPRE_Int eig_est)1718 HYPRE_BoomerAMGSetChebyEigEst( HYPRE_Solver solver,
1719 HYPRE_Int eig_est )
1720 {
1721 return( hypre_BoomerAMGSetChebyEigEst( (void *) solver, eig_est ) );
1722 }
1723
1724 /*--------------------------------------------------------------------------
1725 * HYPRE_BoomerAMGSetInterpVectors
1726 *--------------------------------------------------------------------------*/
1727 HYPRE_Int
HYPRE_BoomerAMGSetInterpVectors(HYPRE_Solver solver,HYPRE_Int num_vectors,HYPRE_ParVector * vectors)1728 HYPRE_BoomerAMGSetInterpVectors (HYPRE_Solver solver, HYPRE_Int num_vectors,
1729 HYPRE_ParVector *vectors)
1730 {
1731 return (hypre_BoomerAMGSetInterpVectors ( (void *) solver,
1732 num_vectors,
1733 (hypre_ParVector **) vectors ) );
1734 }
1735 /*--------------------------------------------------------------------------
1736 * HYPRE_BoomerAMGSetInterpVecVariant
1737 *--------------------------------------------------------------------------*/
1738
1739 HYPRE_Int
HYPRE_BoomerAMGSetInterpVecVariant(HYPRE_Solver solver,HYPRE_Int num)1740 HYPRE_BoomerAMGSetInterpVecVariant(HYPRE_Solver solver, HYPRE_Int num)
1741
1742 {
1743 return (hypre_BoomerAMGSetInterpVecVariant ( (void *) solver, num ) );
1744 }
1745 /*--------------------------------------------------------------------------
1746 * HYPRE_BoomerAMGSetInterpVecQMax
1747 *--------------------------------------------------------------------------*/
1748
1749 HYPRE_Int
HYPRE_BoomerAMGSetInterpVecQMax(HYPRE_Solver solver,HYPRE_Int q_max)1750 HYPRE_BoomerAMGSetInterpVecQMax( HYPRE_Solver solver,
1751 HYPRE_Int q_max )
1752 {
1753 return( hypre_BoomerAMGSetInterpVecQMax( (void *) solver,
1754 q_max ) );
1755 }
1756
1757 /*--------------------------------------------------------------------------
1758 * HYPRE_BoomerAMGSetInterpVecAbsQTrunc
1759 *--------------------------------------------------------------------------*/
1760 HYPRE_Int
HYPRE_BoomerAMGSetInterpVecAbsQTrunc(HYPRE_Solver solver,HYPRE_Real q_trunc)1761 HYPRE_BoomerAMGSetInterpVecAbsQTrunc( HYPRE_Solver solver,
1762 HYPRE_Real q_trunc )
1763 {
1764 return( hypre_BoomerAMGSetInterpVecAbsQTrunc( (void *) solver,
1765 q_trunc ) );
1766 }
1767 /*--------------------------------------------------------------------------
1768 * HYPRE_BoomerAMGSetSmoothInterpVectors
1769 *--------------------------------------------------------------------------*/
1770 HYPRE_Int
HYPRE_BoomerAMGSetSmoothInterpVectors(HYPRE_Solver solver,HYPRE_Int smooth_interp_vectors)1771 HYPRE_BoomerAMGSetSmoothInterpVectors( HYPRE_Solver solver,
1772 HYPRE_Int smooth_interp_vectors )
1773 {
1774 return( hypre_BoomerAMGSetSmoothInterpVectors( (void *) solver,
1775 smooth_interp_vectors) );
1776 }
1777 /*--------------------------------------------------------------------------
1778 * HYPRE_BoomerAMGSetInterpRefine
1779 *--------------------------------------------------------------------------*/
1780 HYPRE_Int
HYPRE_BoomerAMGSetInterpRefine(HYPRE_Solver solver,HYPRE_Int num_refine)1781 HYPRE_BoomerAMGSetInterpRefine( HYPRE_Solver solver,
1782 HYPRE_Int num_refine )
1783 {
1784 return( hypre_BoomerAMGSetInterpRefine( (void *) solver,
1785 num_refine ) );
1786 }
1787 /*--------------------------------------------------------------------------
1788 * HYPRE_BoomerAMGSetInterpVecFirstLevel(
1789 *--------------------------------------------------------------------------*/
1790 HYPRE_Int
HYPRE_BoomerAMGSetInterpVecFirstLevel(HYPRE_Solver solver,HYPRE_Int level)1791 HYPRE_BoomerAMGSetInterpVecFirstLevel( HYPRE_Solver solver,
1792 HYPRE_Int level )
1793 {
1794 return( hypre_BoomerAMGSetInterpVecFirstLevel( (void *) solver,
1795 level ) );
1796 }
1797 /*--------------------------------------------------------------------------
1798 * HYPRE_BoomerAMGSetAdditive, HYPRE_BoomerAMGGetAdditive
1799 *--------------------------------------------------------------------------*/
1800
1801 HYPRE_Int
HYPRE_BoomerAMGSetAdditive(HYPRE_Solver solver,HYPRE_Int additive)1802 HYPRE_BoomerAMGSetAdditive( HYPRE_Solver solver,
1803 HYPRE_Int additive )
1804 {
1805 return( hypre_BoomerAMGSetAdditive( (void *) solver, additive ) );
1806 }
1807
1808 HYPRE_Int
HYPRE_BoomerAMGGetAdditive(HYPRE_Solver solver,HYPRE_Int * additive)1809 HYPRE_BoomerAMGGetAdditive( HYPRE_Solver solver,
1810 HYPRE_Int * additive )
1811 {
1812 return( hypre_BoomerAMGGetAdditive( (void *) solver, additive ) );
1813 }
1814
1815 /*--------------------------------------------------------------------------
1816 * HYPRE_BoomerAMGSetMultAdditive, HYPRE_BoomerAMGGetMultAdditive
1817 *--------------------------------------------------------------------------*/
1818
1819 HYPRE_Int
HYPRE_BoomerAMGSetMultAdditive(HYPRE_Solver solver,HYPRE_Int mult_additive)1820 HYPRE_BoomerAMGSetMultAdditive( HYPRE_Solver solver,
1821 HYPRE_Int mult_additive )
1822 {
1823 return( hypre_BoomerAMGSetMultAdditive( (void *) solver, mult_additive ) );
1824 }
1825
1826 HYPRE_Int
HYPRE_BoomerAMGGetMultAdditive(HYPRE_Solver solver,HYPRE_Int * mult_additive)1827 HYPRE_BoomerAMGGetMultAdditive( HYPRE_Solver solver,
1828 HYPRE_Int *mult_additive )
1829 {
1830 return( hypre_BoomerAMGGetMultAdditive( (void *) solver, mult_additive ) );
1831 }
1832
1833 /*--------------------------------------------------------------------------
1834 * HYPRE_BoomerAMGSetSimple, HYPRE_BoomerAMGGetSimple
1835 *--------------------------------------------------------------------------*/
1836
1837 HYPRE_Int
HYPRE_BoomerAMGSetSimple(HYPRE_Solver solver,HYPRE_Int simple)1838 HYPRE_BoomerAMGSetSimple( HYPRE_Solver solver,
1839 HYPRE_Int simple )
1840 {
1841 return( hypre_BoomerAMGSetSimple( (void *) solver, simple ) );
1842 }
1843
1844 HYPRE_Int
HYPRE_BoomerAMGGetSimple(HYPRE_Solver solver,HYPRE_Int * simple)1845 HYPRE_BoomerAMGGetSimple( HYPRE_Solver solver,
1846 HYPRE_Int *simple )
1847 {
1848 return( hypre_BoomerAMGGetSimple( (void *) solver, simple ) );
1849 }
1850
1851 /*--------------------------------------------------------------------------
1852 * HYPRE_BoomerAMGSetAddLastLvl
1853 *--------------------------------------------------------------------------*/
1854
1855 HYPRE_Int
HYPRE_BoomerAMGSetAddLastLvl(HYPRE_Solver solver,HYPRE_Int add_last_lvl)1856 HYPRE_BoomerAMGSetAddLastLvl( HYPRE_Solver solver,
1857 HYPRE_Int add_last_lvl )
1858 {
1859 return( hypre_BoomerAMGSetAddLastLvl( (void *) solver, add_last_lvl ) );
1860 }
1861
1862 /*--------------------------------------------------------------------------
1863 * HYPRE_BoomerAMGSetNonGalerkinTol
1864 *--------------------------------------------------------------------------*/
1865
1866 HYPRE_Int
HYPRE_BoomerAMGSetNonGalerkinTol(HYPRE_Solver solver,HYPRE_Real nongalerkin_tol)1867 HYPRE_BoomerAMGSetNonGalerkinTol (HYPRE_Solver solver,
1868 HYPRE_Real nongalerkin_tol)
1869 {
1870 return (hypre_BoomerAMGSetNonGalerkinTol ( (void *) solver, nongalerkin_tol ) );
1871 }
1872
1873 /*--------------------------------------------------------------------------
1874 * HYPRE_BoomerAMGSetLevelNonGalerkinTol
1875 *--------------------------------------------------------------------------*/
1876
1877 HYPRE_Int
HYPRE_BoomerAMGSetLevelNonGalerkinTol(HYPRE_Solver solver,HYPRE_Real nongalerkin_tol,HYPRE_Int level)1878 HYPRE_BoomerAMGSetLevelNonGalerkinTol (HYPRE_Solver solver,
1879 HYPRE_Real nongalerkin_tol,
1880 HYPRE_Int level)
1881 {
1882 return (hypre_BoomerAMGSetLevelNonGalerkinTol ( (void *) solver, nongalerkin_tol , level ) );
1883 }
1884
1885 /*--------------------------------------------------------------------------
1886 * HYPRE_BoomerAMGSetNonGalerkTol
1887 *--------------------------------------------------------------------------*/
1888
1889 HYPRE_Int
HYPRE_BoomerAMGSetNonGalerkTol(HYPRE_Solver solver,HYPRE_Int nongalerk_num_tol,HYPRE_Real * nongalerk_tol)1890 HYPRE_BoomerAMGSetNonGalerkTol (HYPRE_Solver solver,
1891 HYPRE_Int nongalerk_num_tol,
1892 HYPRE_Real *nongalerk_tol)
1893 {
1894 return (hypre_BoomerAMGSetNonGalerkTol ( (void *) solver, nongalerk_num_tol , nongalerk_tol ) );
1895 }
1896
1897 /*--------------------------------------------------------------------------
1898 * HYPRE_BoomerAMGSetRAP2
1899 *--------------------------------------------------------------------------*/
1900
1901 HYPRE_Int
HYPRE_BoomerAMGSetRAP2(HYPRE_Solver solver,HYPRE_Int rap2)1902 HYPRE_BoomerAMGSetRAP2 (HYPRE_Solver solver,
1903 HYPRE_Int rap2)
1904 {
1905 return (hypre_BoomerAMGSetRAP2 ( (void *) solver, rap2 ) );
1906 }
1907
1908 /*--------------------------------------------------------------------------
1909 * HYPRE_BoomerAMGSetModuleRAP2
1910 *--------------------------------------------------------------------------*/
1911
1912 HYPRE_Int
HYPRE_BoomerAMGSetModuleRAP2(HYPRE_Solver solver,HYPRE_Int mod_rap2)1913 HYPRE_BoomerAMGSetModuleRAP2 (HYPRE_Solver solver,
1914 HYPRE_Int mod_rap2)
1915 {
1916 return (hypre_BoomerAMGSetModuleRAP2 ( (void *) solver, mod_rap2 ) );
1917 }
1918
1919 /*--------------------------------------------------------------------------
1920 * HYPRE_BoomerAMGSetKeepTranspose
1921 *--------------------------------------------------------------------------*/
1922
1923 HYPRE_Int
HYPRE_BoomerAMGSetKeepTranspose(HYPRE_Solver solver,HYPRE_Int keepTranspose)1924 HYPRE_BoomerAMGSetKeepTranspose (HYPRE_Solver solver,
1925 HYPRE_Int keepTranspose)
1926 {
1927 return (hypre_BoomerAMGSetKeepTranspose ( (void *) solver, keepTranspose ) );
1928 }
1929
1930 #ifdef HYPRE_USING_DSUPERLU
1931 /*--------------------------------------------------------------------------
1932 * HYPRE_BoomerAMGSetDSLUThreshold
1933 *--------------------------------------------------------------------------*/
1934
1935 HYPRE_Int
HYPRE_BoomerAMGSetDSLUThreshold(HYPRE_Solver solver,HYPRE_Int slu_threshold)1936 HYPRE_BoomerAMGSetDSLUThreshold (HYPRE_Solver solver,
1937 HYPRE_Int slu_threshold)
1938 {
1939 return (hypre_BoomerAMGSetDSLUThreshold ( (void *) solver, slu_threshold ) );
1940 }
1941 #endif
1942
1943 /*--------------------------------------------------------------------------
1944 * HYPRE_BoomerAMGSetCpointsToKeep
1945 *--------------------------------------------------------------------------*/
1946
1947 HYPRE_Int
HYPRE_BoomerAMGSetCpointsToKeep(HYPRE_Solver solver,HYPRE_Int cpt_coarse_level,HYPRE_Int num_cpt_coarse,HYPRE_BigInt * cpt_coarse_index)1948 HYPRE_BoomerAMGSetCpointsToKeep(HYPRE_Solver solver,
1949 HYPRE_Int cpt_coarse_level,
1950 HYPRE_Int num_cpt_coarse,
1951 HYPRE_BigInt *cpt_coarse_index)
1952 {
1953 return (hypre_BoomerAMGSetCPoints( (void *) solver, cpt_coarse_level, num_cpt_coarse, cpt_coarse_index));
1954 }
1955
1956 /*--------------------------------------------------------------------------
1957 * HYPRE_BoomerAMGSetCPoints
1958 *--------------------------------------------------------------------------*/
1959
1960 HYPRE_Int
HYPRE_BoomerAMGSetCPoints(HYPRE_Solver solver,HYPRE_Int cpt_coarse_level,HYPRE_Int num_cpt_coarse,HYPRE_BigInt * cpt_coarse_index)1961 HYPRE_BoomerAMGSetCPoints(HYPRE_Solver solver,
1962 HYPRE_Int cpt_coarse_level,
1963 HYPRE_Int num_cpt_coarse,
1964 HYPRE_BigInt *cpt_coarse_index)
1965 {
1966 return (hypre_BoomerAMGSetCPoints( (void *) solver, cpt_coarse_level, num_cpt_coarse, cpt_coarse_index));
1967 }
1968
1969 /*--------------------------------------------------------------------------
1970 * HYPRE_BoomerAMGSetFPoints
1971 *--------------------------------------------------------------------------*/
1972
1973 HYPRE_Int
HYPRE_BoomerAMGSetFPoints(HYPRE_Solver solver,HYPRE_Int num_fpt,HYPRE_BigInt * fpt_index)1974 HYPRE_BoomerAMGSetFPoints(HYPRE_Solver solver,
1975 HYPRE_Int num_fpt,
1976 HYPRE_BigInt *fpt_index)
1977 {
1978 return (hypre_BoomerAMGSetFPoints( (void *) solver,
1979 0, num_fpt,
1980 fpt_index) );
1981 }
1982
1983 /*--------------------------------------------------------------------------
1984 * HYPRE_BoomerAMGSetIsolatedFPoints
1985 *--------------------------------------------------------------------------*/
1986
1987 HYPRE_Int
HYPRE_BoomerAMGSetIsolatedFPoints(HYPRE_Solver solver,HYPRE_Int num_isolated_fpt,HYPRE_BigInt * isolated_fpt_index)1988 HYPRE_BoomerAMGSetIsolatedFPoints(HYPRE_Solver solver,
1989 HYPRE_Int num_isolated_fpt,
1990 HYPRE_BigInt *isolated_fpt_index)
1991 {
1992 return (hypre_BoomerAMGSetFPoints( (void *) solver,
1993 1, num_isolated_fpt,
1994 isolated_fpt_index) );
1995 }
1996
1997