Actual source code: petsc.h
1: /* $Id: petsc.h,v 1.288 2001/04/13 14:10:22 bsmith Exp $ */
2: /*
3: This is the main PETSc include file (for C and C++). It is included by all
4: other PETSc include files, so it almost never has to be specifically included.
5: */
9: /* ========================================================================== */
10: /*
11: Current PETSc version number and release date
12: */
13: #include petscversion.h
15: /* ========================================================================== */
16: /*
17: The PETSc configuration file. Contains various definitions that
18: handle portability issues and the presence of machine features.
20: petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is
21: found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH}
22: in the bmake/common_variables definition of PETSC_INCLUDE
23: */
24: #include "petscconf.h"
26: /* ========================================================================== */
28: #include <stdio.h>
29: /*
30: Defines the interface to MPI allowing the use of all MPI functions.
31: */
32: #include "mpi.h"
34: /*
35: EXTERN indicates a PETSc function defined elsewhere
36: */
37: #define EXTERN extern
39: /*
40: Defines some elementary mathematics functions and constants.
41: */
42: #include petscmath.h
44: /*
45: Basic PETSc constants
46: */
48: /*E
49: PetscTruth - Logical variable. Actually an integer
51: Level: beginner
53: E*/
54: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth;
56: #define PETSC_NULL 0
57: #define PETSC_DECIDE -1
58: #define PETSC_DEFAULT -2
60: #define PETSC_YES PETSC_TRUE
61: #define PETSC_NO PETSC_FALSE
62: #define PETSC_IGNORE PETSC_NULL
63: #define PETSC_DETERMINE PETSC_DECIDE
66: extern MPI_Comm PETSC_COMM_WORLD;
67: extern MPI_Comm PETSC_COMM_SELF;
68: extern PetscTruth PetscInitializeCalled;
69: EXTERN int PetscSetCommWorld(MPI_Comm);
70: EXTERN int PetscSetHelpVersionFunctions(int (*)(MPI_Comm),int (*)(MPI_Comm));
72: /*MC
73: PetscMalloc - Allocates memory
75: Input Parameter:
76: . m - number of bytes to allocate
78: Output Parameter:
79: . result - memory allocated
81: Synopsis:
82: int PetscMalloc(int m,void **result)
84: Level: beginner
86: Notes: Memory is always allocated at least double aligned
88: .seealso: PetscFree(), PetscNew()
90: Concepts: memory allocation
92: M*/
93: /*MC
94: PetscNew - Allocates memory of a particular type
96: Input Parameter:
97: . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated
99: Output Parameter:
100: . result - memory allocated
102: Synopsis:
103: int PetscNew(struct type,((type *))result)
105: Level: beginner
107: .seealso: PetscFree(), PetscMalloc()
109: Concepts: memory allocation
111: M*/
112: #define PetscNew(A,b) PetscMalloc(sizeof(A),(b))
113: /*MC
114: PetscFree - Frees memory
116: Input Parameter:
117: . memory - memory to free
119: Synopsis:
120: int PetscFree(memory)
122: Level: beginner
124: Notes: Memory must have been obtained with PetscNew() or PetscMalloc()
126: .seealso: PetscNew(), PetscMalloc()
128: Concepts: memory allocation
130: M*/
131: EXTERN int (*PetscTrMalloc)(int,int,char*,char*,char*,void**);
132: EXTERN int (*PetscTrFree)(void *,int,char*,char*,char*);
133: EXTERN int PetscSetMalloc(int (*)(int,int,char*,char*,char*,void**),int (*)(void *,int,char*,char*,char*));
134: EXTERN int PetscClearMalloc(void);
136: /*
137: Routines for tracing memory corruption/bleeding with default PETSc
138: memory allocation
139: */
140: EXTERN int PetscTrDump(FILE *);
141: EXTERN int PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *);
142: EXTERN int PetscTrValid(int,const char[],const char[],const char[]);
143: EXTERN int PetscTrDebugLevel(int);
144: EXTERN int PetscTrLog(void);
145: EXTERN int PetscTrLogDump(FILE *);
146: EXTERN int PetscGetResidentSetSize(PetscLogDouble *);
148: /*
149: Variable type where we stash PETSc object pointers in Fortran.
150: Assumes that sizeof(long) == sizeof(void*)which is true on
151: all machines that we know.
152: */
153: #define PetscFortranAddr long
155: /*E
156: PetscDataType - Used for handling different basic data types.
158: Level: beginner
160: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
161: PetscDataTypeGetSize(), PetscDataTypeGetName()
163: E*/
164: typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2,
165: PETSC_LONG =3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5,
166: PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType;
167: #if defined(PETSC_USE_COMPLEX)
168: #define PETSC_SCALAR PETSC_COMPLEX
169: #else
170: #define PETSC_SCALAR PETSC_DOUBLE
171: #endif
172: #if defined(PETSC_USE_SINGLE)
173: #define PETSC_REAL PETSC_FLOAT
174: #else
175: #define PETSC_REAL PETSC_DOUBLE
176: #endif
177: #define PETSC_FORTRANADDR PETSC_LONG
179: EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*);
180: EXTERN int PetscDataTypeGetSize(PetscDataType,int*);
181: EXTERN int PetscDataTypeGetName(PetscDataType,char*[]);
183: /*
184: Basic memory and string operations. These are usually simple wrappers
185: around the basic Unix system calls, but a few of them have additional
186: functionality and/or error checking.
187: */
188: EXTERN int PetscMemcpy(void *,const void *,int);
189: EXTERN int PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType);
190: EXTERN int PetscMemmove(void *,void *,int);
191: EXTERN int PetscMemzero(void *,int);
192: EXTERN int PetscMemcmp(const void*,const void*,int,PetscTruth *);
193: EXTERN int PetscStrlen(const char[],int*);
194: EXTERN int PetscStrcmp(const char[],const char[],PetscTruth *);
195: EXTERN int PetscStrgrt(const char[],const char[],PetscTruth *);
196: EXTERN int PetscStrcasecmp(const char[],const char[],PetscTruth*);
197: EXTERN int PetscStrncmp(const char[],const char[],int,PetscTruth*);
198: EXTERN int PetscStrcpy(char[],const char[]);
199: EXTERN int PetscStrcat(char[],const char[]);
200: EXTERN int PetscStrncat(char[],const char[],int);
201: EXTERN int PetscStrncpy(char[],const char[],int);
202: EXTERN int PetscStrchr(const char[],char,char **);
203: EXTERN int PetscStrtolower(char[]);
204: EXTERN int PetscStrrchr(const char[],char,char **);
205: EXTERN int PetscStrstr(const char[],const char[],char **);
206: EXTERN int PetscStrtok(const char[],const char[],char **);
207: EXTERN int PetscStrallocpy(const char[],char **);
208: EXTERN int PetscStrreplace(MPI_Comm,const char[],char*,int);
209: #define PetscStrfree(a) ((a) ? PetscFree(a) : 0)
211: /*
212: These are MPI operations for MPI_Allreduce() etc
213: */
214: EXTERN MPI_Op PetscMaxSum_Op;
215: #if defined(PETSC_USE_COMPLEX)
216: EXTERN MPI_Op PetscSum_Op;
217: #else
218: #define PetscSum_Op MPI_SUM
219: #endif
221: /*
222: Each PETSc object class has it's own cookie (internal integer in the
223: data structure used for error checking). These are all defined by an offset
224: from the lowest one, PETSC_COOKIE.
225: */
226: #define PETSC_COOKIE 1211211
227: #define PETSC_MAX_COOKIES 60
228: #define PETSC_LARGEST_COOKIE_PREDEFINED PETSC_COOKIE + 30
229: #define PETSC_LARGEST_COOKIE_ALLOWED PETSC_COOKIE + PETSC_MAX_COOKIES
230: extern int PETSC_LARGEST_COOKIE;
232: /*S
233: PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc
235: Level: beginner
237: .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName()
238: S*/
239: typedef struct _p_PetscObject* PetscObject;
241: /*S
242: PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed
243: by string name
245: Level: advanced
247: .seealso: PetscFListAdd(), PetscFListDestroy()
248: S*/
249: typedef struct _PetscFList *PetscFList;
251: #include petscviewer.h
252: #include petscoptions.h
254: EXTERN int PetscShowMemoryUsage(PetscViewer,char*);
255: EXTERN int PetscGetTime(PetscLogDouble*);
256: EXTERN int PetscGetCPUTime(PetscLogDouble*);
257: EXTERN int PetscSleep(int);
259: /*
260: Initialization of PETSc
261: */
262: EXTERN int PetscInitialize(int*,char***,char[],const char[]);
263: EXTERN int PetscInitializeNoArguments(void);
264: EXTERN int PetscFinalize(void);
265: EXTERN int PetscInitializeFortran(void);
267: /*
268: Functions that can act on any PETSc object.
269: */
270: EXTERN int PetscObjectDestroy(PetscObject);
271: EXTERN int PetscObjectExists(PetscObject,PetscTruth*);
272: EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *);
273: EXTERN int PetscObjectGetCookie(PetscObject,int *);
274: EXTERN int PetscObjectGetType(PetscObject,int *);
275: EXTERN int PetscObjectSetName(PetscObject,const char[]);
276: EXTERN int PetscObjectGetName(PetscObject,char*[]);
277: EXTERN int PetscObjectReference(PetscObject);
278: EXTERN int PetscObjectGetReference(PetscObject,int*);
279: EXTERN int PetscObjectDereference(PetscObject);
280: EXTERN int PetscObjectGetNewTag(PetscObject,int *);
281: EXTERN int PetscCommGetNewTag(MPI_Comm,int *);
282: EXTERN int PetscObjectView(PetscObject,PetscViewer);
283: EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject);
284: EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *);
285: EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)());
286: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
287: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0)
288: #else
289: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)())(d))
290: #endif
291: EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)());
292: EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]);
293: EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]);
294: EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]);
295: EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]);
296: EXTERN int PetscObjectPublish(PetscObject);
297: EXTERN int PetscObjectChangeTypeName(PetscObject,char *);
298: EXTERN int PetscObjectRegisterDestroy(PetscObject);
299: EXTERN int PetscObjectRegisterDestroyAll(void);
300: EXTERN int PetscObjectName(PetscObject);
301: EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*);
303: /*
304: Defines PETSc error handling.
305: */
306: #include petscerror.h
308: /*S
309: PetscOList - Linked list of PETSc objects, accessable by string name
311: Level: advanced
313: .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind()
314: S*/
315: typedef struct _PetscOList *PetscOList;
317: EXTERN int PetscOListDestroy(PetscOList *);
318: EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*);
319: EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**);
320: EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject);
321: EXTERN int PetscOListDuplicate(PetscOList,PetscOList *);
323: /*
324: Dynamic library lists. Lists of names of routines in dynamic
325: link libraries that will be loaded as needed.
326: */
327: EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)());
328: EXTERN int PetscFListDestroy(PetscFList*);
329: EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)());
330: EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList);
331: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
332: #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0)
333: #else
334: #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)())c)
335: #endif
336: EXTERN int PetscFListDuplicate(PetscFList,PetscFList *);
337: EXTERN int PetscFListView(PetscFList,PetscViewer);
338: EXTERN int PetscFListConcat(const char [],const char [],char []);
339: EXTERN int PetscFListGet(PetscFList,char ***,int*);
341: /*S
342: PetscDLLibraryList - Linked list of dynamics libraries to search for functions
344: Level: advanced
346: PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries
348: .seealso: PetscDLLibraryOpen()
349: S*/
350: typedef struct _PetscDLLibraryList *PetscDLLibraryList;
351: extern PetscDLLibraryList DLLibrariesLoaded;
352: EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *);
353: EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **);
354: EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **);
355: EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]);
356: EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]);
357: EXTERN int PetscDLLibraryClose(PetscDLLibraryList);
358: EXTERN int PetscDLLibraryPrintPath(void);
359: EXTERN int PetscDLLibraryGetInfo(void *,char *,char **);
361: /*
362: Mechanism for translating PETSc object representations between languages
363: Not currently used.
364: */
365: typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage;
366: #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C
367: EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *);
368: EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **);
370: /*
371: Useful utility routines
372: */
373: EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*);
374: EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*);
375: EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int);
376: EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int);
377: EXTERN int PetscBarrier(PetscObject);
378: EXTERN int PetscMPIDump(FILE*);
380: #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE)
381: /*
382: Defines basic graphics available from PETSc.
383: */
384: #include petscdraw.h
386: /*
387: Defines the base data structures for all PETSc objects
388: */
389: #include petschead.h
391: /*
392: Defines PETSc profiling.
393: */
394: #include petsclog.h
396: /*
397: For locking, unlocking and destroying AMS memories associated with
398: PETSc objects
399: */
400: #if defined(PETSC_HAVE_AMS)
402: extern PetscTruth PetscAMSPublishAll;
403: #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0)
404: #define PetscObjectTakeAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem))
405: #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem))
406: #define PetscObjectDepublish(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem));
407: ((PetscObject)(obj))->amem = -1;
409: #else
411: #define PetscPublishAll(v) 0
412: #define PetscObjectTakeAccess(obj) 0
413: #define PetscObjectGrantAccess(obj) 0
414: #define PetscObjectDepublish(obj) 0
416: #endif
420: /*
421: This code allows one to pass a MPI communicator between
422: C and Fortran. MPI 2.0 defines a standard API for doing this.
423: The code here is provided to allow PETSc to work with MPI 1.1
424: standard MPI libraries.
425: */
426: EXTERN int MPICCommToFortranComm(MPI_Comm,int *);
427: EXTERN int MPIFortranCommToCComm(int,MPI_Comm*);
429: /*
430: Simple PETSc parallel IO for ASCII printing
431: */
432: EXTERN int PetscFixFilename(const char[],char[]);
433: EXTERN int PetscFOpen(MPI_Comm,const char[],const char[],FILE**);
434: EXTERN int PetscFClose(MPI_Comm,FILE*);
435: EXTERN int PetscFPrintf(MPI_Comm,FILE*,const char[],...);
436: EXTERN int PetscPrintf(MPI_Comm,const char[],...);
437: EXTERN int (*PetscErrorPrintf)(const char[],...);
438: EXTERN int (*PetscHelpPrintf)(MPI_Comm,const char[],...);
439: EXTERN int PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **);
440: EXTERN int PetscPClose(MPI_Comm,FILE*);
441: EXTERN int PetscSynchronizedPrintf(MPI_Comm,const char[],...);
442: EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...);
443: EXTERN int PetscSynchronizedFlush(MPI_Comm);
444: EXTERN int PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]);
445: EXTERN int PetscStartMatlab(MPI_Comm,char *,char*,FILE**);
446: EXTERN int PetscStartJava(MPI_Comm,char *,char*,FILE**);
448: EXTERN int PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*);
449: /*S
450: PetscObjectContainer - Simple PETSc object that contains a pointer to any required data
452: Level: advanced
454: .seealso: PetscObject, PetscObjectContainerCreate()
455: S*/
456: typedef struct _p_PetscObjectContainer* PetscObjectContainer;
457: EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **);
458: EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *);
459: EXTERN int PetscObjectContainerDestroy(PetscObjectContainer);
460: EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *);
462: /*
463: For incremental debugging
464: */
465: extern PetscTruth PetscCompare;
466: EXTERN int PetscCompareDouble(double);
467: EXTERN int PetscCompareScalar(Scalar);
468: EXTERN int PetscCompareInt(int);
470: /*
471: For use in debuggers
472: */
473: extern int PetscGlobalRank,PetscGlobalSize;
474: EXTERN int PetscIntView(int,int[],PetscViewer);
475: EXTERN int PetscDoubleView(int,double[],PetscViewer);
476: EXTERN int PetscScalarView(int,Scalar[],PetscViewer);
478: /*
479: Allows accessing Matlab Engine
480: */
481: #include petscengine.h
483: /*
484: C code optimization is often enhanced by telling the compiler
485: that certain pointer arguments to functions are not aliased to
486: to other arguments. This is not yet ANSI C standard so we define
487: the macro "restrict" to indicate that the variable is not aliased
488: to any other argument.
489: */
490: #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus)
491: #define restrict _Restrict
492: #else
493: #define restrict
494: #endif
496: /*
497: Determine if some of the kernel computation routines use
498: Fortran (rather than C) for the numerical calculations. On some machines
499: and compilers (like complex numbers) the Fortran version of the routines
500: is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS
501: would be set in the petscconf.h file
502: */
503: #if defined(PETSC_USE_FORTRAN_KERNELS)
505: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ)
506: #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ
507: #endif
509: #if !defined(PETSC_USE_FORTRAN_KERNEL_NORMSQR)
510: #define PETSC_USE_FORTRAN_KERNEL_NORMSQR
511: #endif
513: #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY)
514: #define PETSC_USE_FORTRAN_KERNEL_MAXPY
515: #endif
517: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ)
518: #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ
519: #endif
521: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ)
522: #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ
523: #endif
525: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ)
526: #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ
527: #endif
529: #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT)
530: #define PETSC_USE_FORTRAN_KERNEL_MDOT
531: #endif
533: #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY)
534: #define PETSC_USE_FORTRAN_KERNEL_XTIMESY
535: #endif
537: #endif
539: /*
540: Macros for indicating code that should be compiled with a C interface,
541: rather than a C++ interface. Any routines that are dynamically loaded
542: (such as the PCCreate_XXX() routines) must be wrapped so that the name
543: mangler does not change the functions symbol name. This just hides the
544: ugly extern "C" {} wrappers.
545: */
546: #if defined(__cplusplus)
547: #define EXTERN_C_BEGIN extern "C" {
548: #define EXTERN_C_END }
549: #else
550: #define EXTERN_C_BEGIN
551: #define EXTERN_C_END
552: #endif
554: /* --------------------------------------------------------------------*/
555: /*
556: DVF (win32) uses STDCALL calling convention by default.
557: The following is used by the fortran interface.
558: */
559: #if defined (PETSC_USE_FORTRAN_STDCALL)
560: #define PETSC_STDCALL __stdcall
561: #else
562: #define PETSC_STDCALL
563: #endif
565: #endif
567: /*M
568: size - integer variable used to contain the number of processors in
569: the relevent MPI_Comm
571: Level: beginner
573: .seealso: rank, comm
574: M*/
576: /*M
577: rank - integer variable used to contain the number of this processor relative
578: to all in the relevent MPI_Comm
580: Level: beginner
582: .seealso: size, comm
583: M*/
585: /*M
586: comm - MPI_Comm used in the current routine or object
588: Level: beginner
590: .seealso: size, rank
591: M*/
593: /*M
594: Scalar - PETSc type that represents either a double precision real number or
595: a double precision complex number if the code is compiled with BOPT=g_complex or O_complex
597: Level: beginner
599: M*/
601: /*
602: The IBM include files define hz, here we hide it so that it may be used
603: as a regular user variable.
604: */
605: #if defined(hz)
606: #undef hz
607: #endif