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_ParCSRHybridCreate
12 *--------------------------------------------------------------------------*/
13
14 HYPRE_Int
HYPRE_ParCSRHybridCreate(HYPRE_Solver * solver)15 HYPRE_ParCSRHybridCreate( HYPRE_Solver *solver )
16 {
17 if (!solver)
18 {
19 hypre_error_in_arg(2);
20 return hypre_error_flag;
21 }
22 *solver = ( (HYPRE_Solver) hypre_AMGHybridCreate( ) );
23 return hypre_error_flag;
24 }
25
26 /*--------------------------------------------------------------------------
27 * HYPRE_ParCSRHybridDestroy
28 *--------------------------------------------------------------------------*/
29
30 HYPRE_Int
HYPRE_ParCSRHybridDestroy(HYPRE_Solver solver)31 HYPRE_ParCSRHybridDestroy( HYPRE_Solver solver )
32 {
33 return( hypre_AMGHybridDestroy( (void *) solver ) );
34 }
35
36 /*--------------------------------------------------------------------------
37 * HYPRE_ParCSRHybridSetup
38 *--------------------------------------------------------------------------*/
39
40 HYPRE_Int
HYPRE_ParCSRHybridSetup(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)41 HYPRE_ParCSRHybridSetup( HYPRE_Solver solver,
42 HYPRE_ParCSRMatrix A,
43 HYPRE_ParVector b,
44 HYPRE_ParVector x )
45 {
46 return( hypre_AMGHybridSetup( (void *) solver,
47 (hypre_ParCSRMatrix *) A,
48 (hypre_ParVector *) b,
49 (hypre_ParVector *) x ) );
50 }
51
52 /*--------------------------------------------------------------------------
53 * HYPRE_ParCSRHybridSolve
54 *--------------------------------------------------------------------------*/
55
56 HYPRE_Int
HYPRE_ParCSRHybridSolve(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)57 HYPRE_ParCSRHybridSolve( HYPRE_Solver solver,
58 HYPRE_ParCSRMatrix A,
59 HYPRE_ParVector b,
60 HYPRE_ParVector x )
61 {
62 return( hypre_AMGHybridSolve( (void *) solver,
63 (hypre_ParCSRMatrix *) A,
64 (hypre_ParVector *) b,
65 (hypre_ParVector *) x ) );
66 }
67
68 /*--------------------------------------------------------------------------
69 * HYPRE_ParCSRHybridSetTol
70 *--------------------------------------------------------------------------*/
71
72 HYPRE_Int
HYPRE_ParCSRHybridSetTol(HYPRE_Solver solver,HYPRE_Real tol)73 HYPRE_ParCSRHybridSetTol( HYPRE_Solver solver,
74 HYPRE_Real tol )
75 {
76 return( hypre_AMGHybridSetTol( (void *) solver, tol ) );
77 }
78 /*--------------------------------------------------------------------------
79 * HYPRE_ParCSRHybridSetAbsoluteTol
80 *--------------------------------------------------------------------------*/
81
82 HYPRE_Int
HYPRE_ParCSRHybridSetAbsoluteTol(HYPRE_Solver solver,HYPRE_Real tol)83 HYPRE_ParCSRHybridSetAbsoluteTol( HYPRE_Solver solver,
84 HYPRE_Real tol )
85 {
86 return( hypre_AMGHybridSetAbsoluteTol( (void *) solver, tol ) );
87 }
88
89 /*--------------------------------------------------------------------------
90 * HYPRE_ParCSRHybridSetConvergenceTol
91 *--------------------------------------------------------------------------*/
92
93 HYPRE_Int
HYPRE_ParCSRHybridSetConvergenceTol(HYPRE_Solver solver,HYPRE_Real cf_tol)94 HYPRE_ParCSRHybridSetConvergenceTol( HYPRE_Solver solver,
95 HYPRE_Real cf_tol )
96 {
97 return( hypre_AMGHybridSetConvergenceTol( (void *) solver, cf_tol ) );
98 }
99
100 /*--------------------------------------------------------------------------
101 * HYPRE_ParCSRHybridSetDSCGMaxIter
102 *--------------------------------------------------------------------------*/
103
104 HYPRE_Int
HYPRE_ParCSRHybridSetDSCGMaxIter(HYPRE_Solver solver,HYPRE_Int dscg_max_its)105 HYPRE_ParCSRHybridSetDSCGMaxIter( HYPRE_Solver solver,
106 HYPRE_Int dscg_max_its )
107 {
108 return( hypre_AMGHybridSetDSCGMaxIter( (void *) solver, dscg_max_its ) );
109 }
110
111 /*--------------------------------------------------------------------------
112 * HYPRE_ParCSRHybridSetPCGMaxIter
113 *--------------------------------------------------------------------------*/
114
115 HYPRE_Int
HYPRE_ParCSRHybridSetPCGMaxIter(HYPRE_Solver solver,HYPRE_Int pcg_max_its)116 HYPRE_ParCSRHybridSetPCGMaxIter( HYPRE_Solver solver,
117 HYPRE_Int pcg_max_its )
118 {
119 return( hypre_AMGHybridSetPCGMaxIter( (void *) solver, pcg_max_its ) );
120 }
121
122 /*--------------------------------------------------------------------------
123 * HYPRE_ParCSRHybridSetSetupType
124 *--------------------------------------------------------------------------*/
125
126 HYPRE_Int
HYPRE_ParCSRHybridSetSetupType(HYPRE_Solver solver,HYPRE_Int setup_type)127 HYPRE_ParCSRHybridSetSetupType( HYPRE_Solver solver,
128 HYPRE_Int setup_type )
129 {
130 return( hypre_AMGHybridSetSetupType( (void *) solver, setup_type ) );
131 }
132
133 /*--------------------------------------------------------------------------
134 * HYPRE_ParCSRHybridSetSolverType
135 *--------------------------------------------------------------------------*/
136
137 HYPRE_Int
HYPRE_ParCSRHybridSetSolverType(HYPRE_Solver solver,HYPRE_Int solver_type)138 HYPRE_ParCSRHybridSetSolverType( HYPRE_Solver solver,
139 HYPRE_Int solver_type )
140 {
141 return( hypre_AMGHybridSetSolverType( (void *) solver, solver_type ) );
142 }
143
144 /*--------------------------------------------------------------------------
145 *--------------------------------------------------------------------------*/
146
147 HYPRE_Int
HYPRE_ParCSRHybridSetRecomputeResidual(HYPRE_Solver solver,HYPRE_Int recompute_residual)148 HYPRE_ParCSRHybridSetRecomputeResidual( HYPRE_Solver solver,
149 HYPRE_Int recompute_residual )
150 {
151 return( hypre_AMGHybridSetRecomputeResidual( (void *) solver, recompute_residual ) );
152 }
153
154 HYPRE_Int
HYPRE_ParCSRHybridGetRecomputeResidual(HYPRE_Solver solver,HYPRE_Int * recompute_residual)155 HYPRE_ParCSRHybridGetRecomputeResidual( HYPRE_Solver solver,
156 HYPRE_Int *recompute_residual )
157 {
158 return( hypre_AMGHybridGetRecomputeResidual( (void *) solver, recompute_residual ) );
159 }
160
161 /*--------------------------------------------------------------------------
162 *--------------------------------------------------------------------------*/
163
164 HYPRE_Int
HYPRE_ParCSRHybridSetRecomputeResidualP(HYPRE_Solver solver,HYPRE_Int recompute_residual_p)165 HYPRE_ParCSRHybridSetRecomputeResidualP( HYPRE_Solver solver,
166 HYPRE_Int recompute_residual_p )
167 {
168 return( hypre_AMGHybridSetRecomputeResidualP( (void *) solver, recompute_residual_p ) );
169 }
170
171 HYPRE_Int
HYPRE_ParCSRHybridGetRecomputeResidualP(HYPRE_Solver solver,HYPRE_Int * recompute_residual_p)172 HYPRE_ParCSRHybridGetRecomputeResidualP( HYPRE_Solver solver,
173 HYPRE_Int *recompute_residual_p )
174 {
175 return( hypre_AMGHybridGetRecomputeResidualP( (void *) solver, recompute_residual_p ) );
176 }
177
178 /*--------------------------------------------------------------------------
179 * HYPRE_ParCSRHybridSetKDim
180 *--------------------------------------------------------------------------*/
181
182 HYPRE_Int
HYPRE_ParCSRHybridSetKDim(HYPRE_Solver solver,HYPRE_Int k_dim)183 HYPRE_ParCSRHybridSetKDim( HYPRE_Solver solver,
184 HYPRE_Int k_dim )
185 {
186 return( hypre_AMGHybridSetKDim( (void *) solver, k_dim ) );
187 }
188
189 /*--------------------------------------------------------------------------
190 * HYPRE_ParCSRHybridSetTwoNorm
191 *--------------------------------------------------------------------------*/
192
193 HYPRE_Int
HYPRE_ParCSRHybridSetTwoNorm(HYPRE_Solver solver,HYPRE_Int two_norm)194 HYPRE_ParCSRHybridSetTwoNorm( HYPRE_Solver solver,
195 HYPRE_Int two_norm )
196 {
197 return( hypre_AMGHybridSetTwoNorm( (void *) solver, two_norm ) );
198 }
199
200 /*--------------------------------------------------------------------------
201 * HYPRE_ParCSRHybridSetStopCrit
202 *--------------------------------------------------------------------------*/
203
204 HYPRE_Int
HYPRE_ParCSRHybridSetStopCrit(HYPRE_Solver solver,HYPRE_Int stop_crit)205 HYPRE_ParCSRHybridSetStopCrit( HYPRE_Solver solver,
206 HYPRE_Int stop_crit )
207 {
208 return( hypre_AMGHybridSetStopCrit( (void *) solver, stop_crit ) );
209 }
210
211 /*--------------------------------------------------------------------------
212 * HYPRE_ParCSRHybridSetRelChange
213 *--------------------------------------------------------------------------*/
214
215 HYPRE_Int
HYPRE_ParCSRHybridSetRelChange(HYPRE_Solver solver,HYPRE_Int rel_change)216 HYPRE_ParCSRHybridSetRelChange( HYPRE_Solver solver,
217 HYPRE_Int rel_change )
218 {
219 return( hypre_AMGHybridSetRelChange( (void *) solver, rel_change ) );
220 }
221
222 /*--------------------------------------------------------------------------
223 * HYPRE_ParCSRHybridSetPrecond
224 *--------------------------------------------------------------------------*/
225
226 HYPRE_Int
HYPRE_ParCSRHybridSetPrecond(HYPRE_Solver solver,HYPRE_PtrToParSolverFcn precond,HYPRE_PtrToParSolverFcn precond_setup,HYPRE_Solver precond_solver)227 HYPRE_ParCSRHybridSetPrecond( HYPRE_Solver solver,
228 HYPRE_PtrToParSolverFcn precond,
229 HYPRE_PtrToParSolverFcn precond_setup,
230 HYPRE_Solver precond_solver )
231 {
232 return( hypre_AMGHybridSetPrecond( (void *) solver,
233 (HYPRE_Int (*)(void*, void*, void*, void*) ) precond,
234 (HYPRE_Int (*)(void*, void*, void*, void*) ) precond_setup,
235 (void *) precond_solver ) );
236 }
237
238 /*--------------------------------------------------------------------------
239 * HYPRE_ParCSRHybridSetLogging
240 *--------------------------------------------------------------------------*/
241
242 HYPRE_Int
HYPRE_ParCSRHybridSetLogging(HYPRE_Solver solver,HYPRE_Int logging)243 HYPRE_ParCSRHybridSetLogging( HYPRE_Solver solver,
244 HYPRE_Int logging )
245 {
246 return( hypre_AMGHybridSetLogging( (void *) solver, logging ) );
247 }
248
249 /*--------------------------------------------------------------------------
250 * HYPRE_ParCSRHybridSetPrintLevel
251 *--------------------------------------------------------------------------*/
252
253 HYPRE_Int
HYPRE_ParCSRHybridSetPrintLevel(HYPRE_Solver solver,HYPRE_Int print_level)254 HYPRE_ParCSRHybridSetPrintLevel( HYPRE_Solver solver,
255 HYPRE_Int print_level )
256 {
257 return( hypre_AMGHybridSetPrintLevel( (void *) solver, print_level ) );
258 }
259
260 /*--------------------------------------------------------------------------
261 * HYPRE_ParCSRHybridSetStrongThreshold
262 *--------------------------------------------------------------------------*/
263
264 HYPRE_Int
HYPRE_ParCSRHybridSetStrongThreshold(HYPRE_Solver solver,HYPRE_Real strong_threshold)265 HYPRE_ParCSRHybridSetStrongThreshold( HYPRE_Solver solver,
266 HYPRE_Real strong_threshold )
267 {
268 return( hypre_AMGHybridSetStrongThreshold( (void *) solver,
269 strong_threshold ) );
270 }
271
272 /*--------------------------------------------------------------------------
273 * HYPRE_ParCSRHybridSetMaxRowSum
274 *--------------------------------------------------------------------------*/
275
276 HYPRE_Int
HYPRE_ParCSRHybridSetMaxRowSum(HYPRE_Solver solver,HYPRE_Real max_row_sum)277 HYPRE_ParCSRHybridSetMaxRowSum( HYPRE_Solver solver,
278 HYPRE_Real max_row_sum )
279 {
280 return( hypre_AMGHybridSetMaxRowSum( (void *) solver, max_row_sum ) );
281 }
282
283 /*--------------------------------------------------------------------------
284 * HYPRE_ParCSRHybridSetTruncFactor
285 *--------------------------------------------------------------------------*/
286
287 HYPRE_Int
HYPRE_ParCSRHybridSetTruncFactor(HYPRE_Solver solver,HYPRE_Real trunc_factor)288 HYPRE_ParCSRHybridSetTruncFactor( HYPRE_Solver solver,
289 HYPRE_Real trunc_factor )
290 {
291 return( hypre_AMGHybridSetTruncFactor( (void *) solver, trunc_factor ) );
292 }
293
294 /*--------------------------------------------------------------------------
295 * HYPRE_ParCSRHybridSetPMaxElmts
296 *--------------------------------------------------------------------------*/
297
298 HYPRE_Int
HYPRE_ParCSRHybridSetPMaxElmts(HYPRE_Solver solver,HYPRE_Int p_max)299 HYPRE_ParCSRHybridSetPMaxElmts( HYPRE_Solver solver,
300 HYPRE_Int p_max )
301 {
302 return( hypre_AMGHybridSetPMaxElmts( (void *) solver, p_max ) );
303 }
304
305 /*--------------------------------------------------------------------------
306 * HYPRE_ParCSRHybridSetMaxLevels
307 *--------------------------------------------------------------------------*/
308
309 HYPRE_Int
HYPRE_ParCSRHybridSetMaxLevels(HYPRE_Solver solver,HYPRE_Int max_levels)310 HYPRE_ParCSRHybridSetMaxLevels( HYPRE_Solver solver,
311 HYPRE_Int max_levels )
312 {
313 return( hypre_AMGHybridSetMaxLevels( (void *) solver, max_levels ) );
314 }
315
316 /*--------------------------------------------------------------------------
317 * HYPRE_ParCSRHybridSetMeasureType
318 *--------------------------------------------------------------------------*/
319
320 HYPRE_Int
HYPRE_ParCSRHybridSetMeasureType(HYPRE_Solver solver,HYPRE_Int measure_type)321 HYPRE_ParCSRHybridSetMeasureType( HYPRE_Solver solver,
322 HYPRE_Int measure_type )
323 {
324 return( hypre_AMGHybridSetMeasureType( (void *) solver, measure_type ) );
325 }
326
327 /*--------------------------------------------------------------------------
328 * HYPRE_ParCSRHybridSetCoarsenType
329 *--------------------------------------------------------------------------*/
330
331 HYPRE_Int
HYPRE_ParCSRHybridSetCoarsenType(HYPRE_Solver solver,HYPRE_Int coarsen_type)332 HYPRE_ParCSRHybridSetCoarsenType( HYPRE_Solver solver,
333 HYPRE_Int coarsen_type )
334 {
335 return( hypre_AMGHybridSetCoarsenType( (void *) solver, coarsen_type ) );
336 }
337
338 /*--------------------------------------------------------------------------
339 * HYPRE_ParCSRHybridSetInterpType
340 *--------------------------------------------------------------------------*/
341
342 HYPRE_Int
HYPRE_ParCSRHybridSetInterpType(HYPRE_Solver solver,HYPRE_Int interp_type)343 HYPRE_ParCSRHybridSetInterpType( HYPRE_Solver solver,
344 HYPRE_Int interp_type )
345 {
346 return( hypre_AMGHybridSetInterpType( (void *) solver, interp_type ) );
347 }
348
349 /*--------------------------------------------------------------------------
350 * HYPRE_ParCSRHybridSetCycleType
351 *--------------------------------------------------------------------------*/
352
353 HYPRE_Int
HYPRE_ParCSRHybridSetCycleType(HYPRE_Solver solver,HYPRE_Int cycle_type)354 HYPRE_ParCSRHybridSetCycleType( HYPRE_Solver solver,
355 HYPRE_Int cycle_type )
356 {
357 return( hypre_AMGHybridSetCycleType( (void *) solver, cycle_type ) );
358 }
359
360 /*--------------------------------------------------------------------------
361 * HYPRE_ParCSRHybridSetNumGridSweeps
362 *--------------------------------------------------------------------------*/
363
364 HYPRE_Int
HYPRE_ParCSRHybridSetNumGridSweeps(HYPRE_Solver solver,HYPRE_Int * num_grid_sweeps)365 HYPRE_ParCSRHybridSetNumGridSweeps( HYPRE_Solver solver,
366 HYPRE_Int *num_grid_sweeps )
367 {
368 return( hypre_AMGHybridSetNumGridSweeps( (void *) solver, num_grid_sweeps ) );
369 }
370
371 /*--------------------------------------------------------------------------
372 * HYPRE_ParCSRHybridSetGridRelaxType
373 *--------------------------------------------------------------------------*/
374
375 HYPRE_Int
HYPRE_ParCSRHybridSetGridRelaxType(HYPRE_Solver solver,HYPRE_Int * grid_relax_type)376 HYPRE_ParCSRHybridSetGridRelaxType( HYPRE_Solver solver,
377 HYPRE_Int *grid_relax_type )
378 {
379 return( hypre_AMGHybridSetGridRelaxType( (void *) solver, grid_relax_type ) );
380 }
381
382 /*--------------------------------------------------------------------------
383 * HYPRE_ParCSRHybridSetGridRelaxPoints
384 *--------------------------------------------------------------------------*/
385
386 HYPRE_Int
HYPRE_ParCSRHybridSetGridRelaxPoints(HYPRE_Solver solver,HYPRE_Int ** grid_relax_points)387 HYPRE_ParCSRHybridSetGridRelaxPoints( HYPRE_Solver solver,
388 HYPRE_Int **grid_relax_points )
389 {
390 return( hypre_AMGHybridSetGridRelaxPoints( (void *) solver, grid_relax_points ) );
391 }
392
393 /*--------------------------------------------------------------------------
394 * HYPRE_ParCSRHybridSetNumSweeps
395 *--------------------------------------------------------------------------*/
396
397 HYPRE_Int
HYPRE_ParCSRHybridSetNumSweeps(HYPRE_Solver solver,HYPRE_Int num_sweeps)398 HYPRE_ParCSRHybridSetNumSweeps( HYPRE_Solver solver,
399 HYPRE_Int num_sweeps )
400 {
401 return( hypre_AMGHybridSetNumSweeps( (void *) solver, num_sweeps ) );
402 }
403
404 /*--------------------------------------------------------------------------
405 * HYPRE_ParCSRHybridSetCycleNumSweeps
406 *--------------------------------------------------------------------------*/
407
408 HYPRE_Int
HYPRE_ParCSRHybridSetCycleNumSweeps(HYPRE_Solver solver,HYPRE_Int num_sweeps,HYPRE_Int k)409 HYPRE_ParCSRHybridSetCycleNumSweeps( HYPRE_Solver solver,
410 HYPRE_Int num_sweeps ,
411 HYPRE_Int k )
412 {
413 return( hypre_AMGHybridSetCycleNumSweeps( (void *) solver, num_sweeps, k ) );
414 }
415
416 /*--------------------------------------------------------------------------
417 * HYPRE_ParCSRHybridSetRelaxType
418 *--------------------------------------------------------------------------*/
419
420 HYPRE_Int
HYPRE_ParCSRHybridSetRelaxType(HYPRE_Solver solver,HYPRE_Int relax_type)421 HYPRE_ParCSRHybridSetRelaxType( HYPRE_Solver solver,
422 HYPRE_Int relax_type )
423 {
424 return( hypre_AMGHybridSetRelaxType( (void *) solver, relax_type ) );
425 }
426
427 /*--------------------------------------------------------------------------
428 * HYPRE_ParCSRHybridSetCycleRelaxType
429 *--------------------------------------------------------------------------*/
430
431 HYPRE_Int
HYPRE_ParCSRHybridSetCycleRelaxType(HYPRE_Solver solver,HYPRE_Int relax_type,HYPRE_Int k)432 HYPRE_ParCSRHybridSetCycleRelaxType( HYPRE_Solver solver,
433 HYPRE_Int relax_type ,
434 HYPRE_Int k )
435 {
436 return( hypre_AMGHybridSetCycleRelaxType( (void *) solver, relax_type, k ) );
437 }
438
439 /*--------------------------------------------------------------------------
440 * HYPRE_ParCSRHybridSetRelaxOrder
441 *--------------------------------------------------------------------------*/
442
443 HYPRE_Int
HYPRE_ParCSRHybridSetRelaxOrder(HYPRE_Solver solver,HYPRE_Int relax_order)444 HYPRE_ParCSRHybridSetRelaxOrder( HYPRE_Solver solver,
445 HYPRE_Int relax_order )
446 {
447 return( hypre_AMGHybridSetRelaxOrder( (void *) solver, relax_order ) );
448 }
449
450 /*--------------------------------------------------------------------------
451 * HYPRE_ParCSRHybridSetKeepTranspose
452 *--------------------------------------------------------------------------*/
453
454 HYPRE_Int
HYPRE_ParCSRHybridSetKeepTranspose(HYPRE_Solver solver,HYPRE_Int keepT)455 HYPRE_ParCSRHybridSetKeepTranspose( HYPRE_Solver solver,
456 HYPRE_Int keepT )
457 {
458 return( hypre_AMGHybridSetKeepTranspose( (void *) solver, keepT ) );
459 }
460
461 /*--------------------------------------------------------------------------
462 * HYPRE_ParCSRHybridSetMaxCoarseSize
463 *--------------------------------------------------------------------------*/
464
465 HYPRE_Int
HYPRE_ParCSRHybridSetMaxCoarseSize(HYPRE_Solver solver,HYPRE_Int max_coarse_size)466 HYPRE_ParCSRHybridSetMaxCoarseSize( HYPRE_Solver solver,
467 HYPRE_Int max_coarse_size )
468 {
469 return( hypre_AMGHybridSetMaxCoarseSize( (void *) solver, max_coarse_size ) );
470 }
471
472 /*--------------------------------------------------------------------------
473 * HYPRE_ParCSRHybridSetMinCoarseSize
474 *--------------------------------------------------------------------------*/
475
476 HYPRE_Int
HYPRE_ParCSRHybridSetMinCoarseSize(HYPRE_Solver solver,HYPRE_Int min_coarse_size)477 HYPRE_ParCSRHybridSetMinCoarseSize( HYPRE_Solver solver,
478 HYPRE_Int min_coarse_size )
479 {
480 return( hypre_AMGHybridSetMinCoarseSize( (void *) solver, min_coarse_size ) );
481 }
482
483 /*--------------------------------------------------------------------------
484 * HYPRE_ParCSRHybridSetSeqThreshold
485 *--------------------------------------------------------------------------*/
486
487 HYPRE_Int
HYPRE_ParCSRHybridSetSeqThreshold(HYPRE_Solver solver,HYPRE_Int seq_threshold)488 HYPRE_ParCSRHybridSetSeqThreshold( HYPRE_Solver solver,
489 HYPRE_Int seq_threshold )
490 {
491 return( hypre_AMGHybridSetSeqThreshold( (void *) solver, seq_threshold ) );
492 }
493
494 /*--------------------------------------------------------------------------
495 * HYPRE_ParCSRHybridSetRelaxWt
496 *--------------------------------------------------------------------------*/
497
498 HYPRE_Int
HYPRE_ParCSRHybridSetRelaxWt(HYPRE_Solver solver,HYPRE_Real relax_wt)499 HYPRE_ParCSRHybridSetRelaxWt( HYPRE_Solver solver,
500 HYPRE_Real relax_wt )
501 {
502 return( hypre_AMGHybridSetRelaxWt( (void *) solver, relax_wt ) );
503 }
504
505 /*--------------------------------------------------------------------------
506 * HYPRE_ParCSRHybridSetLevelRelaxWt
507 *--------------------------------------------------------------------------*/
508
509 HYPRE_Int
HYPRE_ParCSRHybridSetLevelRelaxWt(HYPRE_Solver solver,HYPRE_Real relax_wt,HYPRE_Int level)510 HYPRE_ParCSRHybridSetLevelRelaxWt( HYPRE_Solver solver,
511 HYPRE_Real relax_wt,
512 HYPRE_Int level )
513 {
514 return( hypre_AMGHybridSetLevelRelaxWt( (void *) solver, relax_wt, level ) );
515 }
516
517 /*--------------------------------------------------------------------------
518 * HYPRE_ParCSRHybridSetOuterWt
519 *--------------------------------------------------------------------------*/
520
521 HYPRE_Int
HYPRE_ParCSRHybridSetOuterWt(HYPRE_Solver solver,HYPRE_Real outer_wt)522 HYPRE_ParCSRHybridSetOuterWt( HYPRE_Solver solver,
523 HYPRE_Real outer_wt )
524 {
525 return( hypre_AMGHybridSetOuterWt( (void *) solver, outer_wt ) );
526 }
527
528 /*--------------------------------------------------------------------------
529 * HYPRE_ParCSRHybridSetLevelOuterWt
530 *--------------------------------------------------------------------------*/
531
532 HYPRE_Int
HYPRE_ParCSRHybridSetLevelOuterWt(HYPRE_Solver solver,HYPRE_Real outer_wt,HYPRE_Int level)533 HYPRE_ParCSRHybridSetLevelOuterWt( HYPRE_Solver solver,
534 HYPRE_Real outer_wt,
535 HYPRE_Int level )
536 {
537 return( hypre_AMGHybridSetLevelOuterWt( (void *) solver, outer_wt, level ) );
538 }
539
540 /*--------------------------------------------------------------------------
541 * HYPRE_ParCSRHybridSetRelaxWeight
542 *--------------------------------------------------------------------------*/
543
544 HYPRE_Int
HYPRE_ParCSRHybridSetRelaxWeight(HYPRE_Solver solver,HYPRE_Real * relax_weight)545 HYPRE_ParCSRHybridSetRelaxWeight( HYPRE_Solver solver,
546 HYPRE_Real *relax_weight )
547 {
548 return( hypre_AMGHybridSetRelaxWeight( (void *) solver, relax_weight ) );
549 }
550
551 /*--------------------------------------------------------------------------
552 * HYPRE_ParCSRHybridSetOmega
553 *--------------------------------------------------------------------------*/
554
555 HYPRE_Int
HYPRE_ParCSRHybridSetOmega(HYPRE_Solver solver,HYPRE_Real * omega)556 HYPRE_ParCSRHybridSetOmega( HYPRE_Solver solver,
557 HYPRE_Real *omega )
558 {
559 return( hypre_AMGHybridSetOmega( (void *) solver, omega ) );
560 }
561
562 /*--------------------------------------------------------------------------
563 * HYPRE_ParCSRHybridSetAggNumLevels
564 *--------------------------------------------------------------------------*/
565
566 HYPRE_Int
HYPRE_ParCSRHybridSetAggNumLevels(HYPRE_Solver solver,HYPRE_Int agg_num_levels)567 HYPRE_ParCSRHybridSetAggNumLevels( HYPRE_Solver solver,
568 HYPRE_Int agg_num_levels )
569 {
570 return( hypre_AMGHybridSetAggNumLevels( (void *) solver, agg_num_levels ) );
571 }
572
573 /*--------------------------------------------------------------------------
574 * HYPRE_ParCSRHybridSetAggInterpType
575 *--------------------------------------------------------------------------*/
576
577 HYPRE_Int
HYPRE_ParCSRHybridSetAggInterpType(HYPRE_Solver solver,HYPRE_Int agg_interp_type)578 HYPRE_ParCSRHybridSetAggInterpType( HYPRE_Solver solver,
579 HYPRE_Int agg_interp_type )
580 {
581 return( hypre_AMGHybridSetAggInterpType( (void *) solver, agg_interp_type ) );
582 }
583
584 /*--------------------------------------------------------------------------
585 * HYPRE_ParCSRHybridSetNumPaths
586 *--------------------------------------------------------------------------*/
587
588 HYPRE_Int
HYPRE_ParCSRHybridSetNumPaths(HYPRE_Solver solver,HYPRE_Int num_paths)589 HYPRE_ParCSRHybridSetNumPaths( HYPRE_Solver solver,
590 HYPRE_Int num_paths )
591 {
592 return( hypre_AMGHybridSetNumPaths( (void *) solver, num_paths ) );
593 }
594
595 /*--------------------------------------------------------------------------
596 * HYPRE_ParCSRHybridSetNumFunctions
597 *--------------------------------------------------------------------------*/
598
599 HYPRE_Int
HYPRE_ParCSRHybridSetNumFunctions(HYPRE_Solver solver,HYPRE_Int num_functions)600 HYPRE_ParCSRHybridSetNumFunctions( HYPRE_Solver solver,
601 HYPRE_Int num_functions )
602 {
603 return( hypre_AMGHybridSetNumFunctions( (void *) solver, num_functions ) );
604 }
605
606 /*--------------------------------------------------------------------------
607 * HYPRE_ParCSRHybridSetNodal
608 *--------------------------------------------------------------------------*/
609
610 HYPRE_Int
HYPRE_ParCSRHybridSetNodal(HYPRE_Solver solver,HYPRE_Int nodal)611 HYPRE_ParCSRHybridSetNodal( HYPRE_Solver solver,
612 HYPRE_Int nodal )
613 {
614 return( hypre_AMGHybridSetNodal( (void *) solver, nodal ) );
615 }
616
617 /*--------------------------------------------------------------------------
618 * HYPRE_ParCSRHybridSetDofFunc
619 *--------------------------------------------------------------------------*/
620
621 HYPRE_Int
HYPRE_ParCSRHybridSetDofFunc(HYPRE_Solver solver,HYPRE_Int * dof_func)622 HYPRE_ParCSRHybridSetDofFunc( HYPRE_Solver solver,
623 HYPRE_Int *dof_func )
624 {
625 return( hypre_AMGHybridSetDofFunc( (void *) solver, dof_func ) );
626 }
627
628 /*--------------------------------------------------------------------------
629 * HYPRE_ParCSRHybridSetNonGalerkTol
630 *--------------------------------------------------------------------------*/
631
632 HYPRE_Int
HYPRE_ParCSRHybridSetNonGalerkinTol(HYPRE_Solver solver,HYPRE_Int nongalerk_num_tol,HYPRE_Real * nongalerkin_tol)633 HYPRE_ParCSRHybridSetNonGalerkinTol( HYPRE_Solver solver,
634 HYPRE_Int nongalerk_num_tol,
635 HYPRE_Real *nongalerkin_tol)
636 {
637 return( hypre_AMGHybridSetNonGalerkinTol( (void *) solver, nongalerk_num_tol, nongalerkin_tol ) );
638 }
639
640
641 /*--------------------------------------------------------------------------
642 * HYPRE_ParCSRHybridGetNumIterations
643 *--------------------------------------------------------------------------*/
644
645 HYPRE_Int
HYPRE_ParCSRHybridGetNumIterations(HYPRE_Solver solver,HYPRE_Int * num_its)646 HYPRE_ParCSRHybridGetNumIterations( HYPRE_Solver solver,
647 HYPRE_Int *num_its )
648 {
649 return( hypre_AMGHybridGetNumIterations( (void *) solver, num_its ) );
650 }
651
652 /*--------------------------------------------------------------------------
653 * HYPRE_ParCSRHybridGetDSCGNumIterations
654 *--------------------------------------------------------------------------*/
655
656 HYPRE_Int
HYPRE_ParCSRHybridGetDSCGNumIterations(HYPRE_Solver solver,HYPRE_Int * dscg_num_its)657 HYPRE_ParCSRHybridGetDSCGNumIterations( HYPRE_Solver solver,
658 HYPRE_Int *dscg_num_its )
659 {
660 return( hypre_AMGHybridGetDSCGNumIterations( (void *) solver, dscg_num_its ) );
661 }
662
663 /*--------------------------------------------------------------------------
664 * HYPRE_ParCSRHybridGetPCGNumIterations
665 *--------------------------------------------------------------------------*/
666
667 HYPRE_Int
HYPRE_ParCSRHybridGetPCGNumIterations(HYPRE_Solver solver,HYPRE_Int * pcg_num_its)668 HYPRE_ParCSRHybridGetPCGNumIterations( HYPRE_Solver solver,
669 HYPRE_Int *pcg_num_its )
670 {
671 return( hypre_AMGHybridGetPCGNumIterations( (void *) solver, pcg_num_its ) );
672 }
673
674 /*--------------------------------------------------------------------------
675 * HYPRE_ParCSRHybridGetFinalRelativeResidualNorm
676 *--------------------------------------------------------------------------*/
677
678 HYPRE_Int
HYPRE_ParCSRHybridGetFinalRelativeResidualNorm(HYPRE_Solver solver,HYPRE_Real * norm)679 HYPRE_ParCSRHybridGetFinalRelativeResidualNorm( HYPRE_Solver solver,
680 HYPRE_Real *norm )
681 {
682 return( hypre_AMGHybridGetFinalRelativeResidualNorm( (void *) solver, norm ) );
683 }
684
685
686 HYPRE_Int
HYPRE_ParCSRHybridGetSetupSolveTime(HYPRE_Solver solver,HYPRE_Real * time)687 HYPRE_ParCSRHybridGetSetupSolveTime( HYPRE_Solver solver,
688 HYPRE_Real *time )
689 {
690 return( hypre_AMGHybridGetSetupSolveTime( (void *) solver, time ) );
691 }
692