LCOV - code coverage report
Current view: top level - var/lib/buildbot/slaves/linux-gnu-gcov/petsc/include - petscmath.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 28 28 100.0 %
Date: 2019-08-24 05:55:29 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             : 
       3             :     PETSc mathematics include file. Defines certain basic mathematical
       4             :     constants and functions for working with single, double, and quad precision
       5             :     floating point numbers as well as complex single and double.
       6             : 
       7             :     This file is included by petscsys.h and should not be used directly.
       8             : 
       9             : */
      10             : 
      11             : #if !defined(PETSCMATH_H)
      12             : #define PETSCMATH_H
      13             : #include <math.h>
      14             : #include <petscsystypes.h>
      15             : 
      16             : /*
      17             : 
      18             :    Defines operations that are different for complex and real numbers.
      19             :    All PETSc objects in one program are built around the object
      20             :    PetscScalar which is either always a real or a complex.
      21             : 
      22             : */
      23             : 
      24             : /*
      25             :     Real number definitions
      26             :  */
      27             : #if defined(PETSC_USE_REAL_SINGLE)
      28             : #define PetscSqrtReal(a)    sqrtf(a)
      29             : #define PetscCbrtReal(a)    cbrtf(a)
      30             : #define PetscHypotReal(a,b) hypotf(a,b)
      31             : #define PetscAtan2Real(a,b) atan2f(a,b)
      32             : #define PetscPowReal(a,b)   powf(a,b)
      33             : #define PetscExpReal(a)     expf(a)
      34             : #define PetscLogReal(a)     logf(a)
      35             : #define PetscLog10Real(a)   log10f(a)
      36             : #define PetscLog2Real(a)    log2f(a)
      37             : #define PetscSinReal(a)     sinf(a)
      38             : #define PetscCosReal(a)     cosf(a)
      39             : #define PetscTanReal(a)     tanf(a)
      40             : #define PetscAsinReal(a)    asinf(a)
      41             : #define PetscAcosReal(a)    acosf(a)
      42             : #define PetscAtanReal(a)    atanf(a)
      43             : #define PetscSinhReal(a)    sinhf(a)
      44             : #define PetscCoshReal(a)    coshf(a)
      45             : #define PetscTanhReal(a)    tanhf(a)
      46             : #define PetscAsinhReal(a)   asinhf(a)
      47             : #define PetscAcoshReal(a)   acoshf(a)
      48             : #define PetscAtanhReal(a)   atanhf(a)
      49             : #define PetscRoundReal(a)   roundf(a)
      50             : #define PetscCeilReal(a)    ceilf(a)
      51             : #define PetscFloorReal(a)   floorf(a)
      52             : #define PetscFmodReal(a,b)  fmodf(a,b)
      53             : #define PetscTGamma(a)      tgammaf(a)
      54             : 
      55             : #elif defined(PETSC_USE_REAL_DOUBLE)
      56             : #define PetscSqrtReal(a)    sqrt(a)
      57             : #define PetscCbrtReal(a)    cbrt(a)
      58             : #define PetscHypotReal(a,b) hypot(a,b)
      59             : #define PetscAtan2Real(a,b) atan2(a,b)
      60             : #define PetscPowReal(a,b)   pow(a,b)
      61             : #define PetscExpReal(a)     exp(a)
      62             : #define PetscLogReal(a)     log(a)
      63             : #define PetscLog10Real(a)   log10(a)
      64             : #define PetscLog2Real(a)    log2(a)
      65             : #define PetscSinReal(a)     sin(a)
      66             : #define PetscCosReal(a)     cos(a)
      67             : #define PetscTanReal(a)     tan(a)
      68             : #define PetscAsinReal(a)    asin(a)
      69             : #define PetscAcosReal(a)    acos(a)
      70             : #define PetscAtanReal(a)    atan(a)
      71             : #define PetscSinhReal(a)    sinh(a)
      72             : #define PetscCoshReal(a)    cosh(a)
      73             : #define PetscTanhReal(a)    tanh(a)
      74             : #define PetscAsinhReal(a)   asinh(a)
      75             : #define PetscAcoshReal(a)   acosh(a)
      76             : #define PetscAtanhReal(a)   atanh(a)
      77             : #define PetscRoundReal(a)   round(a)
      78             : #define PetscCeilReal(a)    ceil(a)
      79             : #define PetscFloorReal(a)   floor(a)
      80             : #define PetscFmodReal(a,b)  fmod(a,b)
      81             : #define PetscTGamma(a)      tgamma(a)
      82             : 
      83             : #elif defined(PETSC_USE_REAL___FLOAT128)
      84             : #define PetscSqrtReal(a)    sqrtq(a)
      85             : #define PetscCbrtReal(a)    cbrtq(a)
      86             : #define PetscHypotReal(a,b) hypotq(a,b)
      87             : #define PetscAtan2Real(a,b) atan2q(a,b)
      88             : #define PetscPowReal(a,b)   powq(a,b)
      89             : #define PetscExpReal(a)     expq(a)
      90             : #define PetscLogReal(a)     logq(a)
      91             : #define PetscLog10Real(a)   log10q(a)
      92             : #define PetscLog2Real(a)    log2q(a)
      93             : #define PetscSinReal(a)     sinq(a)
      94             : #define PetscCosReal(a)     cosq(a)
      95             : #define PetscTanReal(a)     tanq(a)
      96             : #define PetscAsinReal(a)    asinq(a)
      97             : #define PetscAcosReal(a)    acosq(a)
      98             : #define PetscAtanReal(a)    atanq(a)
      99             : #define PetscSinhReal(a)    sinhq(a)
     100             : #define PetscCoshReal(a)    coshq(a)
     101             : #define PetscTanhReal(a)    tanhq(a)
     102             : #define PetscAsinhReal(a)   asinhq(a)
     103             : #define PetscAcoshReal(a)   acoshq(a)
     104             : #define PetscAtanhReal(a)   atanhq(a)
     105             : #define PetscRoundReal(a)   roundq(a)
     106             : #define PetscCeilReal(a)    ceilq(a)
     107             : #define PetscFloorReal(a)   floorq(a)
     108             : #define PetscFmodReal(a,b)  fmodq(a,b)
     109             : #define PetscTGamma(a)      tgammaq(a)
     110             : 
     111             : #elif defined(PETSC_USE_REAL___FP16)
     112             : #define PetscSqrtReal(a)    sqrtf(a)
     113             : #define PetscCbrtReal(a)    cbrtf(a)
     114             : #define PetscHypotReal(a,b) hypotf(a,b)
     115             : #define PetscAtan2Real(a,b) atan2f(a,b)
     116             : #define PetscPowReal(a,b)   powf(a,b)
     117             : #define PetscExpReal(a)     expf(a)
     118             : #define PetscLogReal(a)     logf(a)
     119             : #define PetscLog10Real(a)   log10f(a)
     120             : #define PetscLog2Real(a)    log2f(a)
     121             : #define PetscSinReal(a)     sinf(a)
     122             : #define PetscCosReal(a)     cosf(a)
     123             : #define PetscTanReal(a)     tanf(a)
     124             : #define PetscAsinReal(a)    asinf(a)
     125             : #define PetscAcosReal(a)    acosf(a)
     126             : #define PetscAtanReal(a)    atanf(a)
     127             : #define PetscSinhReal(a)    sinhf(a)
     128             : #define PetscCoshReal(a)    coshf(a)
     129             : #define PetscTanhReal(a)    tanhf(a)
     130             : #define PetscAsinhReal(a)   asinhf(a)
     131             : #define PetscAcoshReal(a)   acoshf(a)
     132             : #define PetscAtanhReal(a)   atanhf(a)
     133             : #define PetscRoundReal(a)   roundf(a)
     134             : #define PetscCeilReal(a)    ceilf(a)
     135             : #define PetscFloorReal(a)   floorf(a)
     136             : #define PetscFmodReal(a,b)  fmodf(a,b)
     137             : #define PetscTGamma(a)      tgammaf(a)
     138             : 
     139             : #endif /* PETSC_USE_REAL_* */
     140             : 
     141             : PETSC_STATIC_INLINE PetscReal PetscSignReal(PetscReal a)
     142             : {
     143             :   return (PetscReal)((a < (PetscReal)0) ? -1 : ((a > (PetscReal)0) ? 1 : 0));
     144             : }
     145             : 
     146             : #if !defined(PETSC_HAVE_LOG2)
     147             : #undef PetscLog2Real
     148             : PETSC_STATIC_INLINE PetscReal PetscLog2Real(PetscReal a)
     149             : {
     150             :   return PetscLogReal(a)/PetscLogReal((PetscReal)2);
     151             : }
     152             : #endif
     153             : 
     154             : #if defined(PETSC_USE_REAL___FLOAT128)
     155             : PETSC_EXTERN MPI_Datatype MPIU___FLOAT128 PetscAttrMPITypeTag(__float128);
     156             : #endif
     157             : #if defined(PETSC_USE_REAL___FP16)
     158             : PETSC_EXTERN MPI_Datatype MPIU___FP16 PetscAttrMPITypeTag(__fp16);
     159             : #endif
     160             : 
     161             : /*MC
     162             :    MPIU_REAL - MPI datatype corresponding to PetscReal
     163             : 
     164             :    Notes:
     165             :    In MPI calls that require an MPI datatype that matches a PetscReal or array of PetscReal values, pass this value.
     166             : 
     167             :    Level: beginner
     168             : 
     169             : .seealso: PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT
     170             : M*/
     171             : #if defined(PETSC_USE_REAL_SINGLE)
     172             : #  define MPIU_REAL MPI_FLOAT
     173             : #elif defined(PETSC_USE_REAL_DOUBLE)
     174             : #  define MPIU_REAL MPI_DOUBLE
     175             : #elif defined(PETSC_USE_REAL___FLOAT128)
     176             : #  define MPIU_REAL MPIU___FLOAT128
     177             : #elif defined(PETSC_USE_REAL___FP16)
     178             : #  define MPIU_REAL MPIU___FP16
     179             : #endif /* PETSC_USE_REAL_* */
     180             : 
     181             : /*
     182             :     Complex number definitions
     183             :  */
     184             : #if defined(PETSC_HAVE_COMPLEX)
     185             : #if defined(__cplusplus) && defined(PETSC_HAVE_CXX_COMPLEX) && !defined(PETSC_USE_REAL___FLOAT128)
     186             : /* C++ support of complex number */
     187             : 
     188             : #define PetscRealPartComplex(a)      (a).real()
     189             : #define PetscImaginaryPartComplex(a) (a).imag()
     190             : #define PetscAbsComplex(a)           petsccomplexlib::abs(a)
     191             : #define PetscArgComplex(a)           petsccomplexlib::arg(a)
     192             : #define PetscConjComplex(a)          petsccomplexlib::conj(a)
     193             : #define PetscSqrtComplex(a)          petsccomplexlib::sqrt(a)
     194             : #define PetscPowComplex(a,b)         petsccomplexlib::pow(a,b)
     195             : #define PetscExpComplex(a)           petsccomplexlib::exp(a)
     196             : #define PetscLogComplex(a)           petsccomplexlib::log(a)
     197             : #define PetscSinComplex(a)           petsccomplexlib::sin(a)
     198             : #define PetscCosComplex(a)           petsccomplexlib::cos(a)
     199             : #define PetscTanComplex(a)           petsccomplexlib::tan(a)
     200             : #define PetscAsinComplex(a)          petsccomplexlib::asin(a)
     201             : #define PetscAcosComplex(a)          petsccomplexlib::acos(a)
     202             : #define PetscAtanComplex(a)          petsccomplexlib::atan(a)
     203             : #define PetscSinhComplex(a)          petsccomplexlib::sinh(a)
     204             : #define PetscCoshComplex(a)          petsccomplexlib::cosh(a)
     205             : #define PetscTanhComplex(a)          petsccomplexlib::tanh(a)
     206             : #define PetscAsinhComplex(a)         petsccomplexlib::asinh(a)
     207             : #define PetscAcoshComplex(a)         petsccomplexlib::acosh(a)
     208             : #define PetscAtanhComplex(a)         petsccomplexlib::atanh(a)
     209             : 
     210             : /* TODO: Add configure tests
     211             : 
     212             : #if !defined(PETSC_HAVE_CXX_TAN_COMPLEX)
     213             : #undef PetscTanComplex
     214             : PETSC_STATIC_INLINE PetscComplex PetscTanComplex(PetscComplex z)
     215             : {
     216             :   return PetscSinComplex(z)/PetscCosComplex(z);
     217             : }
     218             : #endif
     219             : 
     220             : #if !defined(PETSC_HAVE_CXX_TANH_COMPLEX)
     221             : #undef PetscTanhComplex
     222             : PETSC_STATIC_INLINE PetscComplex PetscTanhComplex(PetscComplex z)
     223             : {
     224             :   return PetscSinhComplex(z)/PetscCoshComplex(z);
     225             : }
     226             : #endif
     227             : 
     228             : #if !defined(PETSC_HAVE_CXX_ASIN_COMPLEX)
     229             : #undef PetscAsinComplex
     230             : PETSC_STATIC_INLINE PetscComplex PetscAsinComplex(PetscComplex z)
     231             : {
     232             :   const PetscComplex j(0,1);
     233             :   return -j*PetscLogComplex(j*z+PetscSqrtComplex(1.0f-z*z));
     234             : }
     235             : #endif
     236             : 
     237             : #if !defined(PETSC_HAVE_CXX_ACOS_COMPLEX)
     238             : #undef PetscAcosComplex
     239             : PETSC_STATIC_INLINE PetscComplex PetscAcosComplex(PetscComplex z)
     240             : {
     241             :   const PetscComplex j(0,1);
     242             :   return j*PetscLogComplex(z-j*PetscSqrtComplex(1.0f-z*z));
     243             : }
     244             : #endif
     245             : 
     246             : #if !defined(PETSC_HAVE_CXX_ATAN_COMPLEX)
     247             : #undef PetscAtanComplex
     248             : PETSC_STATIC_INLINE PetscComplex PetscAtanComplex(PetscComplex z)
     249             : {
     250             :   const PetscComplex j(0,1);
     251             :   return 0.5f*j*PetscLogComplex((1.0f-j*z)/(1.0f+j*z));
     252             : }
     253             : #endif
     254             : 
     255             : #if !defined(PETSC_HAVE_CXX_ASINH_COMPLEX)
     256             : #undef PetscAsinhComplex
     257             : PETSC_STATIC_INLINE PetscComplex PetscAsinhComplex(PetscComplex z)
     258             : {
     259             :   return PetscLogComplex(z+PetscSqrtComplex(z*z+1.0f));
     260             : }
     261             : #endif
     262             : 
     263             : #if !defined(PETSC_HAVE_CXX_ACOSH_COMPLEX)
     264             : #undef PetscAcoshComplex
     265             : PETSC_STATIC_INLINE PetscComplex PetscAcoshComplex(PetscComplex z)
     266             : {
     267             :   return PetscLogComplex(z+PetscSqrtComplex(z*z-1.0f));
     268             : }
     269             : #endif
     270             : 
     271             : #if !defined(PETSC_HAVE_CXX_ATANH_COMPLEX)
     272             : #undef PetscAtanhComplex
     273             : PETSC_STATIC_INLINE PetscComplex PetscAtanhComplex(PetscComplex z)
     274             : {
     275             :   return 0.5f*PetscLogComplex((1.0f+z)/(1.0f-z));
     276             : }
     277             : #endif
     278             : 
     279             : */
     280             : 
     281             : #elif defined(PETSC_HAVE_C99_COMPLEX) && !defined(PETSC_USE_REAL___FP16)
     282             : /* C99 support of complex number */
     283             : 
     284             : #if defined(PETSC_USE_REAL_SINGLE) || defined(PETSC_USE_REAL___FP16)
     285             : #define PetscRealPartComplex(a)      crealf(a)
     286             : #define PetscImaginaryPartComplex(a) cimagf(a)
     287             : #define PetscAbsComplex(a)           cabsf(a)
     288             : #define PetscArgComplex(a)           cargf(a)
     289             : #define PetscConjComplex(a)          conjf(a)
     290             : #define PetscSqrtComplex(a)          csqrtf(a)
     291             : #define PetscPowComplex(a,b)         cpowf(a,b)
     292             : #define PetscExpComplex(a)           cexpf(a)
     293             : #define PetscLogComplex(a)           clogf(a)
     294             : #define PetscSinComplex(a)           csinf(a)
     295             : #define PetscCosComplex(a)           ccosf(a)
     296             : #define PetscTanComplex(a)           ctanf(a)
     297             : #define PetscAsinComplex(a)          casinf(a)
     298             : #define PetscAcosComplex(a)          cacosf(a)
     299             : #define PetscAtanComplex(a)          catanf(a)
     300             : #define PetscSinhComplex(a)          csinhf(a)
     301             : #define PetscCoshComplex(a)          ccoshf(a)
     302             : #define PetscTanhComplex(a)          ctanhf(a)
     303             : #define PetscAsinhComplex(a)         casinhf(a)
     304             : #define PetscAcoshComplex(a)         cacoshf(a)
     305             : #define PetscAtanhComplex(a)         catanhf(a)
     306             : 
     307             : #elif defined(PETSC_USE_REAL_DOUBLE)
     308             : #define PetscRealPartComplex(a)      creal(a)
     309             : #define PetscImaginaryPartComplex(a) cimag(a)
     310             : #define PetscAbsComplex(a)           cabs(a)
     311             : #define PetscArgComplex(a)           carg(a)
     312             : #define PetscConjComplex(a)          conj(a)
     313             : #define PetscSqrtComplex(a)          csqrt(a)
     314             : #define PetscPowComplex(a,b)         cpow(a,b)
     315             : #define PetscExpComplex(a)           cexp(a)
     316             : #define PetscLogComplex(a)           clog(a)
     317             : #define PetscSinComplex(a)           csin(a)
     318             : #define PetscCosComplex(a)           ccos(a)
     319             : #define PetscTanComplex(a)           ctan(a)
     320             : #define PetscAsinComplex(a)          casin(a)
     321             : #define PetscAcosComplex(a)          cacos(a)
     322             : #define PetscAtanComplex(a)          catan(a)
     323             : #define PetscSinhComplex(a)          csinh(a)
     324             : #define PetscCoshComplex(a)          ccosh(a)
     325             : #define PetscTanhComplex(a)          ctanh(a)
     326             : #define PetscAsinhComplex(a)         casinh(a)
     327             : #define PetscAcoshComplex(a)         cacosh(a)
     328             : #define PetscAtanhComplex(a)         catanh(a)
     329             : 
     330             : #elif defined(PETSC_USE_REAL___FLOAT128)
     331             : #define PetscRealPartComplex(a)      crealq(a)
     332             : #define PetscImaginaryPartComplex(a) cimagq(a)
     333             : #define PetscAbsComplex(a)           cabsq(a)
     334             : #define PetscArgComplex(a)           cargq(a)
     335             : #define PetscConjComplex(a)          conjq(a)
     336             : #define PetscSqrtComplex(a)          csqrtq(a)
     337             : #define PetscPowComplex(a,b)         cpowq(a,b)
     338             : #define PetscExpComplex(a)           cexpq(a)
     339             : #define PetscLogComplex(a)           clogq(a)
     340             : #define PetscSinComplex(a)           csinq(a)
     341             : #define PetscCosComplex(a)           ccosq(a)
     342             : #define PetscTanComplex(a)           ctanq(a)
     343             : #define PetscAsinComplex(a)          casinq(a)
     344             : #define PetscAcosComplex(a)          cacosq(a)
     345             : #define PetscAtanComplex(a)          catanq(a)
     346             : #define PetscSinhComplex(a)          csinhq(a)
     347             : #define PetscCoshComplex(a)          ccoshq(a)
     348             : #define PetscTanhComplex(a)          ctanhq(a)
     349             : #define PetscAsinhComplex(a)         casinhq(a)
     350             : #define PetscAcoshComplex(a)         cacoshq(a)
     351             : #define PetscAtanhComplex(a)         catanhq(a)
     352             : 
     353             : #endif /* PETSC_USE_REAL_* */
     354             : #endif /* (__cplusplus && PETSC_HAVE_CXX_COMPLEX) else-if (!__cplusplus && PETSC_HAVE_C99_COMPLEX) */
     355             : 
     356             : /*
     357             :    PETSC_i is the imaginary number, i
     358             : */
     359             : PETSC_EXTERN PetscComplex PETSC_i;
     360             : 
     361             : /*
     362             :    Try to do the right thing for complex number construction: see
     363             :    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1464.htm
     364             :    for details
     365             : */
     366             : PETSC_STATIC_INLINE PetscComplex PetscCMPLX(PetscReal x, PetscReal y)
     367             : {
     368             : #if   defined(__cplusplus) && defined(PETSC_HAVE_CXX_COMPLEX) && !defined(PETSC_USE_REAL___FLOAT128)
     369             :   return PetscComplex(x,y);
     370             : #elif defined(_Imaginary_I)
     371             :   return x + y * _Imaginary_I;
     372             : #else
     373             :   { /* In both C99 and C11 (ISO/IEC 9899, Section 6.2.5),
     374             : 
     375             :        "For each floating type there is a corresponding real type, which is always a real floating
     376             :        type. For real floating types, it is the same type. For complex types, it is the type given
     377             :        by deleting the keyword _Complex from the type name."
     378             : 
     379             :        So type punning should be portable. */
     380             :     union { PetscComplex z; PetscReal f[2]; } uz;
     381             : 
     382         900 :     uz.f[0] = x;
     383         900 :     uz.f[1] = y;
     384         900 :     return uz.z;
     385             :   }
     386             : #endif
     387             : }
     388             : 
     389             : #if defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX)
     390             : #define MPIU_C_COMPLEX MPI_C_COMPLEX
     391             : #define MPIU_C_DOUBLE_COMPLEX MPI_C_DOUBLE_COMPLEX
     392             : #else
     393             : # if defined(__cplusplus) && defined(PETSC_HAVE_CXX_COMPLEX) && !defined(PETSC_USE_REAL___FLOAT128)
     394             :   typedef petsccomplexlib::complex<double> petsc_mpiu_c_double_complex;
     395             :   typedef petsccomplexlib::complex<float> petsc_mpiu_c_complex;
     396             : # elif !defined(__cplusplus) && defined(PETSC_HAVE_C99_COMPLEX)
     397             :   typedef double _Complex petsc_mpiu_c_double_complex;
     398             :   typedef float _Complex petsc_mpiu_c_complex;
     399             : # else
     400             :   typedef struct {double real,imag;} petsc_mpiu_c_double_complex;
     401             :   typedef struct {float real,imag;} petsc_mpiu_c_complex;
     402             : # endif
     403             : PETSC_EXTERN MPI_Datatype MPIU_C_COMPLEX PetscAttrMPITypeTagLayoutCompatible(petsc_mpiu_c_complex);
     404             : PETSC_EXTERN MPI_Datatype MPIU_C_DOUBLE_COMPLEX PetscAttrMPITypeTagLayoutCompatible(petsc_mpiu_c_double_complex);
     405             : #endif /* PETSC_HAVE_MPI_C_DOUBLE_COMPLEX */
     406             : #if defined(PETSC_USE_REAL___FLOAT128)
     407             : PETSC_EXTERN MPI_Datatype MPIU___COMPLEX128 PetscAttrMPITypeTag(__complex128);
     408             : #endif /* PETSC_USE_REAL___FLOAT128 */
     409             : 
     410             : /*MC
     411             :    MPIU_COMPLEX - MPI datatype corresponding to PetscComplex
     412             : 
     413             :    Notes:
     414             :    In MPI calls that require an MPI datatype that matches a PetscComplex or array of PetscComplex values, pass this value.
     415             : 
     416             :    Level: beginner
     417             : 
     418             : .seealso: PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT, PETSC_i
     419             : M*/
     420             : #if defined(PETSC_USE_REAL_SINGLE)
     421             : #  define MPIU_COMPLEX MPIU_C_COMPLEX
     422             : #elif defined(PETSC_USE_REAL_DOUBLE)
     423             : #  define MPIU_COMPLEX MPIU_C_DOUBLE_COMPLEX
     424             : #elif defined(PETSC_USE_REAL___FLOAT128)
     425             : #  define MPIU_COMPLEX MPIU___COMPLEX128
     426             : #elif defined(PETSC_USE_REAL___FP16)
     427             : #  define MPIU_COMPLEX MPIU_C_COMPLEX
     428             : #endif /* PETSC_USE_REAL_* */
     429             : 
     430             : #endif /* PETSC_HAVE_COMPLEX */
     431             : 
     432             : /*
     433             :     Scalar number definitions
     434             :  */
     435             : #if defined(PETSC_USE_COMPLEX) && !defined(PETSC_SKIP_COMPLEX)
     436             : /*MC
     437             :    MPIU_SCALAR - MPI datatype corresponding to PetscScalar
     438             : 
     439             :    Notes:
     440             :    In MPI calls that require an MPI datatype that matches a PetscScalar or array of PetscScalar values, pass this value.
     441             : 
     442             :    Level: beginner
     443             : 
     444             : .seealso: PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_COMPLEX, MPIU_INT
     445             : M*/
     446             : #define MPIU_SCALAR MPIU_COMPLEX
     447             : 
     448             : /*MC
     449             :    PetscRealPart - Returns the real part of a PetscScalar
     450             : 
     451             :    Synopsis:
     452             :    #include <petscmath.h>
     453             :    PetscReal PetscRealPart(PetscScalar v)
     454             : 
     455             :    Not Collective
     456             : 
     457             :    Input Parameter:
     458             : .  v - value to find the real part of
     459             : 
     460             :    Level: beginner
     461             : 
     462             : .seealso: PetscScalar, PetscImaginaryPart(), PetscMax(), PetscClipInterval(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
     463             : 
     464             : M*/
     465             : #define PetscRealPart(a)      PetscRealPartComplex(a)
     466             : 
     467             : /*MC
     468             :    PetscImaginaryPart - Returns the imaginary part of a PetscScalar
     469             : 
     470             :    Synopsis:
     471             :    #include <petscmath.h>
     472             :    PetscReal PetscImaginaryPart(PetscScalar v)
     473             : 
     474             :    Not Collective
     475             : 
     476             :    Input Parameter:
     477             : .  v - value to find the imaginary part of
     478             : 
     479             :    Level: beginner
     480             : 
     481             :    Notes:
     482             :        If PETSc was configured for real numbers then this always returns the value 0
     483             : 
     484             : .seealso: PetscScalar, PetscRealPart(), PetscMax(), PetscClipInterval(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
     485             : 
     486             : M*/
     487             : #define PetscImaginaryPart(a) PetscImaginaryPartComplex(a)
     488             : 
     489             : #define PetscAbsScalar(a)     PetscAbsComplex(a)
     490             : #define PetscArgScalar(a)     PetscArgComplex(a)
     491             : #define PetscConj(a)          PetscConjComplex(a)
     492             : #define PetscSqrtScalar(a)    PetscSqrtComplex(a)
     493             : #define PetscPowScalar(a,b)   PetscPowComplex(a,b)
     494             : #define PetscExpScalar(a)     PetscExpComplex(a)
     495             : #define PetscLogScalar(a)     PetscLogComplex(a)
     496             : #define PetscSinScalar(a)     PetscSinComplex(a)
     497             : #define PetscCosScalar(a)     PetscCosComplex(a)
     498             : #define PetscTanScalar(a)     PetscTanComplex(a)
     499             : #define PetscAsinScalar(a)    PetscAsinComplex(a)
     500             : #define PetscAcosScalar(a)    PetscAcosComplex(a)
     501             : #define PetscAtanScalar(a)    PetscAtanComplex(a)
     502             : #define PetscSinhScalar(a)    PetscSinhComplex(a)
     503             : #define PetscCoshScalar(a)    PetscCoshComplex(a)
     504             : #define PetscTanhScalar(a)    PetscTanhComplex(a)
     505             : #define PetscAsinhScalar(a)   PetscAsinhComplex(a)
     506             : #define PetscAcoshScalar(a)   PetscAcoshComplex(a)
     507             : #define PetscAtanhScalar(a)   PetscAtanhComplex(a)
     508             : 
     509             : #else /* PETSC_USE_COMPLEX */
     510             : #define MPIU_SCALAR MPIU_REAL
     511             : #define PetscRealPart(a)      (a)
     512             : #define PetscImaginaryPart(a) ((PetscReal)0)
     513             : #define PetscAbsScalar(a)     PetscAbsReal(a)
     514             : #define PetscArgScalar(a)     (((a) < (PetscReal)0) ? PETSC_PI : (PetscReal)0)
     515             : #define PetscConj(a)          (a)
     516             : #define PetscSqrtScalar(a)    PetscSqrtReal(a)
     517             : #define PetscPowScalar(a,b)   PetscPowReal(a,b)
     518             : #define PetscExpScalar(a)     PetscExpReal(a)
     519             : #define PetscLogScalar(a)     PetscLogReal(a)
     520             : #define PetscSinScalar(a)     PetscSinReal(a)
     521             : #define PetscCosScalar(a)     PetscCosReal(a)
     522             : #define PetscTanScalar(a)     PetscTanReal(a)
     523             : #define PetscAsinScalar(a)    PetscAsinReal(a)
     524             : #define PetscAcosScalar(a)    PetscAcosReal(a)
     525             : #define PetscAtanScalar(a)    PetscAtanReal(a)
     526             : #define PetscSinhScalar(a)    PetscSinhReal(a)
     527             : #define PetscCoshScalar(a)    PetscCoshReal(a)
     528             : #define PetscTanhScalar(a)    PetscTanhReal(a)
     529             : #define PetscAsinhScalar(a)   PetscAsinhReal(a)
     530             : #define PetscAcoshScalar(a)   PetscAcoshReal(a)
     531             : #define PetscAtanhScalar(a)   PetscAtanhReal(a)
     532             : 
     533             : #endif /* PETSC_USE_COMPLEX */
     534             : 
     535             : /*
     536             :    Certain objects may be created using either single or double precision.
     537             :    This is currently not used.
     538             : */
     539             : typedef enum { PETSC_SCALAR_DOUBLE, PETSC_SCALAR_SINGLE, PETSC_SCALAR_LONG_DOUBLE, PETSC_SCALAR_HALF } PetscScalarPrecision;
     540             : 
     541             : /* --------------------------------------------------------------------------*/
     542             : 
     543             : /*MC
     544             :    PetscAbs - Returns the absolute value of a number
     545             : 
     546             :    Synopsis:
     547             :    #include <petscmath.h>
     548             :    type PetscAbs(type v)
     549             : 
     550             :    Not Collective
     551             : 
     552             :    Input Parameter:
     553             : .  v - the number
     554             : 
     555             :    Notes:
     556             :     type can be integer or real floating point value
     557             : 
     558             :    Level: beginner
     559             : 
     560             : .seealso: PetscAbsInt(), PetscAbsReal(), PetscAbsScalar()
     561             : 
     562             : M*/
     563             : #define PetscAbs(a)  (((a) >= 0) ? (a) : (-(a)))
     564             : 
     565             : /*MC
     566             :    PetscSign - Returns the sign of a number as an integer
     567             : 
     568             :    Synopsis:
     569             :    #include <petscmath.h>
     570             :    int PetscSign(type v)
     571             : 
     572             :    Not Collective
     573             : 
     574             :    Input Parameter:
     575             : .  v - the number
     576             : 
     577             :    Notes:
     578             :     type can be integer or real floating point value
     579             : 
     580             :    Level: beginner
     581             : 
     582             : M*/
     583             : #define PetscSign(a) (((a) >= 0) ? ((a) == 0 ? 0 : 1) : -1)
     584             : 
     585             : /*MC
     586             :    PetscMin - Returns minimum of two numbers
     587             : 
     588             :    Synopsis:
     589             :    #include <petscmath.h>
     590             :    type PetscMin(type v1,type v2)
     591             : 
     592             :    Not Collective
     593             : 
     594             :    Input Parameter:
     595             : +  v1 - first value to find minimum of
     596             : -  v2 - second value to find minimum of
     597             : 
     598             :    Notes:
     599             :     type can be integer or floating point value
     600             : 
     601             :    Level: beginner
     602             : 
     603             : .seealso: PetscMax(), PetscClipInterval(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
     604             : 
     605             : M*/
     606             : #define PetscMin(a,b)   (((a)<(b)) ?  (a) : (b))
     607             : 
     608             : /*MC
     609             :    PetscMax - Returns maxium of two numbers
     610             : 
     611             :    Synopsis:
     612             :    #include <petscmath.h>
     613             :    type max PetscMax(type v1,type v2)
     614             : 
     615             :    Not Collective
     616             : 
     617             :    Input Parameter:
     618             : +  v1 - first value to find maximum of
     619             : -  v2 - second value to find maximum of
     620             : 
     621             :    Notes:
     622             :     type can be integer or floating point value
     623             : 
     624             :    Level: beginner
     625             : 
     626             : .seealso: PetscMin(), PetscClipInterval(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
     627             : 
     628             : M*/
     629             : #define PetscMax(a,b)   (((a)<(b)) ?  (b) : (a))
     630             : 
     631             : /*MC
     632             :    PetscClipInterval - Returns a number clipped to be within an interval
     633             : 
     634             :    Synopsis:
     635             :    #include <petscmath.h>
     636             :    type clip PetscClipInterval(type x,type a,type b)
     637             : 
     638             :    Not Collective
     639             : 
     640             :    Input Parameter:
     641             : +  x - value to use if within interval (a,b)
     642             : .  a - lower end of interval
     643             : -  b - upper end of interval
     644             : 
     645             :    Notes:
     646             :     type can be integer or floating point value
     647             : 
     648             :    Level: beginner
     649             : 
     650             : .seealso: PetscMin(), PetscMax(), PetscAbsInt(), PetscAbsReal(), PetscSqr()
     651             : 
     652             : M*/
     653             : #define PetscClipInterval(x,a,b)   (PetscMax((a),PetscMin((x),(b))))
     654             : 
     655             : /*MC
     656             :    PetscAbsInt - Returns the absolute value of an integer
     657             : 
     658             :    Synopsis:
     659             :    #include <petscmath.h>
     660             :    int abs PetscAbsInt(int v1)
     661             : 
     662             :    Not Collective
     663             : 
     664             :    Input Parameter:
     665             : .   v1 - the integer
     666             : 
     667             :    Level: beginner
     668             : 
     669             : .seealso: PetscMax(), PetscMin(), PetscAbsReal(), PetscSqr()
     670             : 
     671             : M*/
     672             : #define PetscAbsInt(a)  (((a)<0)   ? (-(a)) : (a))
     673             : 
     674             : /*MC
     675             :    PetscAbsReal - Returns the absolute value of an real number
     676             : 
     677             :    Synopsis:
     678             :    #include <petscmath.h>
     679             :    Real abs PetscAbsReal(PetscReal v1)
     680             : 
     681             :    Not Collective
     682             : 
     683             :    Input Parameter:
     684             : .   v1 - the double
     685             : 
     686             : 
     687             :    Level: beginner
     688             : 
     689             : .seealso: PetscMax(), PetscMin(), PetscAbsInt(), PetscSqr()
     690             : 
     691             : M*/
     692             : #if defined(PETSC_USE_REAL_SINGLE)
     693             : #define PetscAbsReal(a) fabsf(a)
     694             : #elif defined(PETSC_USE_REAL_DOUBLE)
     695             : #define PetscAbsReal(a) fabs(a)
     696             : #elif defined(PETSC_USE_REAL___FLOAT128)
     697             : #define PetscAbsReal(a) fabsq(a)
     698             : #elif defined(PETSC_USE_REAL___FP16)
     699             : #define PetscAbsReal(a) fabsf(a)
     700             : #endif
     701             : 
     702             : /*MC
     703             :    PetscSqr - Returns the square of a number
     704             : 
     705             :    Synopsis:
     706             :    #include <petscmath.h>
     707             :    type sqr PetscSqr(type v1)
     708             : 
     709             :    Not Collective
     710             : 
     711             :    Input Parameter:
     712             : .   v1 - the value
     713             : 
     714             :    Notes:
     715             :     type can be integer or floating point value
     716             : 
     717             :    Level: beginner
     718             : 
     719             : .seealso: PetscMax(), PetscMin(), PetscAbsInt(), PetscAbsReal()
     720             : 
     721             : M*/
     722             : #define PetscSqr(a)     ((a)*(a))
     723             : 
     724             : /* ----------------------------------------------------------------------------*/
     725             : 
     726             : #if defined(PETSC_USE_REAL_SINGLE)
     727             : #define PetscRealConstant(constant) constant##F
     728             : #elif defined(PETSC_USE_REAL_DOUBLE)
     729             : #define PetscRealConstant(constant) constant
     730             : #elif defined(PETSC_USE_REAL___FLOAT128)
     731             : #define PetscRealConstant(constant) constant##Q
     732             : #elif defined(PETSC_USE_REAL___FP16)
     733             : #define PetscRealConstant(constant) constant##F
     734             : #endif
     735             : 
     736             : /*
     737             :      Basic constants
     738             : */
     739             : #define PETSC_PI    PetscRealConstant(3.1415926535897932384626433832795029)
     740             : #define PETSC_PHI   PetscRealConstant(1.6180339887498948482045868343656381)
     741             : #define PETSC_SQRT2 PetscRealConstant(1.4142135623730950488016887242096981)
     742             : 
     743             : #if !defined(PETSC_USE_64BIT_INDICES)
     744             : #define PETSC_MAX_INT            2147483647
     745             : #define PETSC_MIN_INT            (-PETSC_MAX_INT - 1)
     746             : #else
     747             : #define PETSC_MAX_INT            9223372036854775807L
     748             : #define PETSC_MIN_INT            (-PETSC_MAX_INT - 1)
     749             : #endif
     750             : 
     751             : #if defined(PETSC_USE_REAL_SINGLE)
     752             : #  define PETSC_MAX_REAL                3.40282346638528860e+38F
     753             : #  define PETSC_MIN_REAL                (-PETSC_MAX_REAL)
     754             : #  define PETSC_MACHINE_EPSILON         1.19209290e-07F
     755             : #  define PETSC_SQRT_MACHINE_EPSILON    3.45266983e-04F
     756             : #  define PETSC_SMALL                   1.e-5F
     757             : #elif defined(PETSC_USE_REAL_DOUBLE)
     758             : #  define PETSC_MAX_REAL                1.7976931348623157e+308
     759             : #  define PETSC_MIN_REAL                (-PETSC_MAX_REAL)
     760             : #  define PETSC_MACHINE_EPSILON         2.2204460492503131e-16
     761             : #  define PETSC_SQRT_MACHINE_EPSILON    1.490116119384766e-08
     762             : #  define PETSC_SMALL                   1.e-10
     763             : #elif defined(PETSC_USE_REAL___FLOAT128)
     764             : #  define PETSC_MAX_REAL                FLT128_MAX
     765             : #  define PETSC_MIN_REAL                (-FLT128_MAX)
     766             : #  define PETSC_MACHINE_EPSILON         FLT128_EPSILON
     767             : #  define PETSC_SQRT_MACHINE_EPSILON    1.38777878078144567552953958511352539e-17Q
     768             : #  define PETSC_SMALL                   1.e-20Q
     769             : #elif defined(PETSC_USE_REAL___FP16)
     770             : #  define PETSC_MAX_REAL                65504.0F
     771             : #  define PETSC_MIN_REAL                (-PETSC_MAX_REAL)
     772             : #  define PETSC_MACHINE_EPSILON         .0009765625F
     773             : #  define PETSC_SQRT_MACHINE_EPSILON    .03125F
     774             : #  define PETSC_SMALL                   5.e-3F
     775             : #endif
     776             : 
     777             : #define PETSC_INFINITY               (PETSC_MAX_REAL/4)
     778             : #define PETSC_NINFINITY              (-PETSC_INFINITY)
     779             : 
     780             : PETSC_EXTERN PetscBool PetscIsInfReal(PetscReal);
     781             : PETSC_EXTERN PetscBool PetscIsNanReal(PetscReal);
     782             : PETSC_EXTERN PetscBool PetscIsNormalReal(PetscReal);
     783           7 : PETSC_STATIC_INLINE PetscBool PetscIsInfOrNanReal(PetscReal v) {return PetscIsInfReal(v) || PetscIsNanReal(v) ? PETSC_TRUE : PETSC_FALSE;}
     784             : PETSC_STATIC_INLINE PetscBool PetscIsInfScalar(PetscScalar v) {return PetscIsInfReal(PetscAbsScalar(v));}
     785     1000377 : PETSC_STATIC_INLINE PetscBool PetscIsNanScalar(PetscScalar v) {return PetscIsNanReal(PetscAbsScalar(v));}
     786             : PETSC_STATIC_INLINE PetscBool PetscIsInfOrNanScalar(PetscScalar v) {return PetscIsInfOrNanReal(PetscAbsScalar(v));}
     787             : PETSC_STATIC_INLINE PetscBool PetscIsNormalScalar(PetscScalar v) {return PetscIsNormalReal(PetscAbsScalar(v));}
     788             : 
     789             : PETSC_EXTERN PetscBool PetscIsCloseAtTol(PetscReal,PetscReal,PetscReal,PetscReal);
     790             : PETSC_EXTERN PetscBool PetscEqualReal(PetscReal,PetscReal);
     791             : PETSC_EXTERN PetscBool PetscEqualScalar(PetscScalar,PetscScalar);
     792             : 
     793             : /*
     794             :     These macros are currently hardwired to match the regular data types, so there is no support for a different
     795             :     MatScalar from PetscScalar. We left the MatScalar in the source just in case we use it again.
     796             :  */
     797             : #define MPIU_MATSCALAR MPIU_SCALAR
     798             : typedef PetscScalar MatScalar;
     799             : typedef PetscReal MatReal;
     800             : 
     801             : struct petsc_mpiu_2scalar {PetscScalar a,b;};
     802             : PETSC_EXTERN MPI_Datatype MPIU_2SCALAR PetscAttrMPITypeTagLayoutCompatible(struct petsc_mpiu_2scalar);
     803             : 
     804             : #if defined(PETSC_USE_64BIT_INDICES)
     805             : struct petsc_mpiu_2int {PetscInt a,b;};
     806             : PETSC_EXTERN MPI_Datatype MPIU_2INT PetscAttrMPITypeTagLayoutCompatible(struct petsc_mpiu_2int);
     807             : #else
     808             : #define MPIU_2INT MPI_2INT
     809             : #endif
     810             : 
     811             : PETSC_STATIC_INLINE PetscInt PetscPowInt(PetscInt base,PetscInt power)
     812             : {
     813         128 :   PetscInt result = 1;
     814        4280 :   while (power) {
     815        2612 :     if (power & 1) result *= base;
     816        2612 :     power >>= 1;
     817        2612 :     base *= base;
     818             :   }
     819             :   return result;
     820             : }
     821             : 
     822             : PETSC_STATIC_INLINE PetscReal PetscPowRealInt(PetscReal base,PetscInt power)
     823             : {
     824        4465 :   PetscReal result = 1;
     825          67 :   if (power < 0) {
     826          28 :     power = -power;
     827          28 :     base  = ((PetscReal)1)/base;
     828             :   }
     829       13452 :   while (power) {
     830        8987 :     if (power & 1) result *= base;
     831        8987 :     power >>= 1;
     832        8987 :     base *= base;
     833             :   }
     834             :   return result;
     835             : }
     836             : 
     837             : PETSC_STATIC_INLINE PetscScalar PetscPowScalarInt(PetscScalar base,PetscInt power)
     838             : {
     839        4394 :   PetscScalar result = (PetscReal)1;
     840           2 :   if (power < 0) {
     841           2 :     power = -power;
     842           2 :     base  = ((PetscReal)1)/base;
     843             :   }
     844       13181 :   while (power) {
     845        8787 :     if (power & 1) result *= base;
     846        8787 :     power >>= 1;
     847        8787 :     base *= base;
     848             :   }
     849             :   return result;
     850             : }
     851             : 
     852             : PETSC_STATIC_INLINE PetscScalar PetscPowScalarReal(PetscScalar base,PetscReal power)
     853             : {
     854         152 :   PetscScalar cpower = power;
     855         152 :   return PetscPowScalar(base,cpower);
     856             : }
     857             : 
     858             : PETSC_EXTERN PetscErrorCode PetscLinearRegression(PetscInt,const PetscReal[],const PetscReal[],PetscReal*,PetscReal*);
     859             : #endif

Generated by: LCOV version 1.13