Actual source code: petscmath.h
1: /*
2:
3: PETSc mathematics include file. Defines certain basic mathematical
4: constants and functions for working with single and double precision
5: floating point numbers as well as complex and integers.
7: This file is included by petsc.h and should not be used directly.
9: */
13: #include <math.h>
18: /*
20: Defines operations that are different for complex and real numbers;
21: note that one cannot really mix the use of complex and real in the same
22: PETSc program. All PETSc objects in one program are built around the object
23: PetscScalar which is either always a double or a complex.
25: */
27: #define PetscExpPassiveScalar(a) PetscExpScalar()
29: #if defined(PETSC_USE_COMPLEX)
31: /*
32: PETSc now only supports std::complex
33: */
34: #include <complex>
37: #define MPIU_SCALAR MPIU_COMPLEX
38: #if defined(PETSC_USE_MAT_SINGLE)
39: #define MPIU_MATSCALAR ??Notdone
40: #else
41: #define MPIU_MATSCALAR MPIU_COMPLEX
42: #endif
44: #define PetscRealPart(a) (a).real()
45: #define PetscImaginaryPart(a) (a).imag()
46: #define PetscAbsScalar(a) std::abs(a)
47: #define PetscConj(a) std::conj(a)
48: #define PetscSqrtScalar(a) std::sqrt(a)
49: #define PetscPowScalar(a,b) std::pow(a,b)
50: #define PetscExpScalar(a) std::exp(a)
51: #define PetscSinScalar(a) std::sin(a)
52: #define PetscCosScalar(a) std::cos(a)
54: typedef std::complex<double> PetscScalar;
56: /* Compiling for real numbers only */
57: #else
58: # if defined(PETSC_USE_SINGLE)
59: # define MPIU_SCALAR MPI_FLOAT
60: # else
61: # define MPIU_SCALAR MPI_DOUBLE
62: # endif
63: # if defined(PETSC_USE_MAT_SINGLE) || defined(PETSC_USE_SINGLE)
64: # define MPIU_MATSCALAR MPI_FLOAT
65: # else
66: # define MPIU_MATSCALAR MPI_DOUBLE
67: # endif
68: # define PetscRealPart(a) (a)
69: # define PetscImaginaryPart(a) (a)
70: # define PetscAbsScalar(a) (((a)<0.0) ? -(a) : (a))
71: # define PetscConj(a) (a)
72: # define PetscSqrtScalar(a) sqrt(a)
73: # define PetscPowScalar(a,b) pow(a,b)
74: # define PetscExpScalar(a) exp(a)
75: # define PetscSinScalar(a) sin(a)
76: # define PetscCosScalar(a) cos(a)
78: # if defined(PETSC_USE_SINGLE)
79: typedef float PetscScalar;
80: # else
81: typedef double PetscScalar;
82: # endif
83: #endif
85: #if defined(PETSC_USE_SINGLE)
86: # define MPIU_REAL MPI_FLOAT
87: #else
88: # define MPIU_REAL MPI_DOUBLE
89: #endif
91: #define PetscSign(a) (((a) >= 0) ? ((a) == 0 ? 0 : 1) : -1)
92: #define PetscAbs(a) (((a) >= 0) ? a : -a)
93: /*
94: Allows compiling PETSc so that matrix values are stored in
95: single precision but all other objects still use double
96: precision. This does not work for complex numbers in that case
97: it remains double
99: EXPERIMENTAL! NOT YET COMPLETELY WORKING
100: */
102: #if defined(PETSC_USE_MAT_SINGLE)
103: typedef float MatScalar;
104: #else
105: typedef PetscScalar MatScalar;
106: #endif
108: #if defined(PETSC_USE_COMPLEX)
109: typedef double MatReal;
110: #elif defined(PETSC_USE_MAT_SINGLE) || defined(PETSC_USE_SINGLE)
111: typedef float MatReal;
112: #else
113: typedef double MatReal;
114: #endif
116: #if defined(PETSC_USE_SINGLE)
117: typedef float PetscReal;
118: #else
119: typedef double PetscReal;
120: #endif
122: /* --------------------------------------------------------------------------*/
124: /*
125: Certain objects may be created using either single
126: or double precision.
127: */
128: typedef enum { PETSC_SCALAR_DOUBLE,PETSC_SCALAR_SINGLE } PetscScalarPrecision;
130: /* PETSC_i is the imaginary number, i */
133: /*MC
134: PetscMin - Returns minimum of two numbers
136: Input Parameter:
137: + v1 - first value to find minimum of
138: - v2 - second value to find minimum of
140: Synopsis:
141: type PetscMin(type v1,type v2)
143: Notes: type can be integer or floating point value
145: Level: beginner
148: .seealso: PetscMin(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
150: M*/
151: #define PetscMin(a,b) (((a)<(b)) ? (a) : (b))
153: /*MC
154: PetscMax - Returns maxium of two numbers
156: Input Parameter:
157: + v1 - first value to find maximum of
158: - v2 - second value to find maximum of
160: Synopsis:
161: type max PetscMax(type v1,type v2)
163: Notes: type can be integer or floating point value
165: Level: beginner
167: .seealso: PetscMin(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
169: M*/
170: #define PetscMax(a,b) (((a)<(b)) ? (b) : (a))
172: /*MC
173: PetscAbsInt - Returns the absolute value of an integer
175: Input Parameter:
176: . v1 - the integer
178: Synopsis:
179: int abs PetscAbsInt(int v1)
182: Level: beginner
184: .seealso: PetscMax(), PetscMin(), PetscAbsReal(), PetscSqr()
186: M*/
187: #define PetscAbsInt(a) (((a)<0) ? -(a) : (a))
189: /*MC
190: PetscAbsReal - Returns the absolute value of an real number
192: Input Parameter:
193: . v1 - the double
195: Synopsis:
196: int abs PetscAbsReal(PetscReal v1)
199: Level: beginner
201: .seealso: PetscMax(), PetscMin(), PetscAbsInt(), PetscSqr()
203: M*/
204: #define PetscAbsReal(a) (((a)<0) ? -(a) : (a))
206: /*MC
207: PetscSqr - Returns the square of a number
209: Input Parameter:
210: . v1 - the value
212: Synopsis:
213: type sqr PetscSqr(type v1)
215: Notes: type can be integer or floating point value
217: Level: beginner
219: .seealso: PetscMax(), PetscMin(), PetscAbsInt(), PetscAbsReal()
221: M*/
222: #define PetscSqr(a) ((a)*(a))
224: /* ----------------------------------------------------------------------------*/
225: /*
226: Basic constants
227: */
228: #define PETSC_PI 3.14159265358979323846264
229: #define PETSC_DEGREES_TO_RADIANS 0.01745329251994
230: #define PETSC_MAX_INT 1000000000
231: #define PETSC_MIN_INT -1000000000
233: #if defined(PETSC_USE_SINGLE)
234: # define PETSC_MAX 1.e30
235: # define PETSC_MIN -1.e30
236: # define PETSC_MACHINE_EPSILON 1.e-7
237: # define PETSC_SQRT_MACHINE_EPSILON 3.e-4
238: # define PETSC_SMALL 1.e-5
239: #else
240: # define PETSC_MAX 1.e300
241: # define PETSC_MIN -1.e300
242: # define PETSC_MACHINE_EPSILON 1.e-14
243: # define PETSC_SQRT_MACHINE_EPSILON 1.e-7
244: # define PETSC_SMALL 1.e-10
245: #endif
247: EXTERN PetscErrorCode PetscGlobalMax(PetscReal*,PetscReal*,MPI_Comm);
248: EXTERN PetscErrorCode PetscGlobalMin(PetscReal*,PetscReal*,MPI_Comm);
249: EXTERN PetscErrorCode PetscGlobalSum(PetscScalar*,PetscScalar*,MPI_Comm);
252: /* ----------------------------------------------------------------------------*/
253: /*
254: PetscLogDouble variables are used to contain double precision numbers
255: that are not used in the numerical computations, but rather in logging,
256: timing etc.
257: */
258: typedef double PetscLogDouble;
259: /*
260: Once PETSc is compiling with a ADIC enhanced version of MPI
261: we will create a new MPI_Datatype for the inactive double variables.
262: */
263: #if defined(AD_DERIV_H)
265: #else
266: #if !defined(_petsc_mpi_uni)
267: #define MPIU_PETSCLOGDOUBLE MPI_DOUBLE
268: #endif
269: #endif
271: #define PassiveReal PetscReal
272: #define PassiveScalar PetscScalar
274: #define PETSCMAP1_a(a,b) a ## _ ## b
275: #define PETSCMAP1_b(a,b) PETSCMAP1_a(a,b)
276: #define PETSCMAP1(a) PETSCMAP1_b(a,PetscScalar)
279: #endif