Date: 2022-03-31T04:47:52+00:00

Actual source code: petscdt.h

      1: /*
      2:   Common tools for constructing discretizations
      3: */
      4: #if !defined(PETSCDT_H)
      5: #define PETSCDT_H

      7: #include <petscsys.h>

      9: PETSC_EXTERN PetscClassId PETSCQUADRATURE_CLASSID;

     11: /*S
     12:   PetscQuadrature - Quadrature rule for integration.

     14:   Level: beginner

     16: .seealso:  PetscQuadratureCreate(), PetscQuadratureDestroy()
     17: S*/
     18: typedef struct _p_PetscQuadrature *PetscQuadrature;

     20: /*E
     21:   PetscGaussLobattoLegendreCreateType - algorithm used to compute the Gauss-Lobatto-Legendre nodes and weights

     23:   Level: intermediate

     25: $  PETSCGAUSSLOBATTOLEGENDRE_VIA_LINEAR_ALGEBRA - compute the nodes via linear algebra
     26: $  PETSCGAUSSLOBATTOLEGENDRE_VIA_NEWTON - compute the nodes by solving a nonlinear equation with Newton's method

     28: E*/
     29: typedef enum {PETSCGAUSSLOBATTOLEGENDRE_VIA_LINEAR_ALGEBRA,PETSCGAUSSLOBATTOLEGENDRE_VIA_NEWTON} PetscGaussLobattoLegendreCreateType;

     31: /*E
     32:   PetscDTNodeType - A description of strategies for generating nodes (both
     33:   quadrature nodes and nodes for Lagrange polynomials)

     35:   Level: intermediate

     37: $  PETSCDTNODES_DEFAULT - Nodes chosen by PETSc
     38: $  PETSCDTNODES_GAUSSJACOBI - Nodes at either Gauss-Jacobi or Gauss-Lobatto-Jacobi quadrature points
     39: $  PETSCDTNODES_EQUISPACED - Nodes equispaced either including the endpoints or excluding them
     40: $  PETSCDTNODES_TANHSINH - Nodes at Tanh-Sinh quadrature points

     42:   Note: a PetscDTNodeType can be paired with a PetscBool to indicate whether
     43:   the nodes include endpoints or not, and in the case of PETSCDT_GAUSSJACOBI
     44:   with exponents for the weight function.

     46: E*/
     47: typedef enum {PETSCDTNODES_DEFAULT=-1, PETSCDTNODES_GAUSSJACOBI, PETSCDTNODES_EQUISPACED, PETSCDTNODES_TANHSINH} PetscDTNodeType;

     49: PETSC_EXTERN const char *const PetscDTNodeTypes[];

     51: PETSC_EXTERN PetscErrorCode PetscQuadratureCreate(MPI_Comm, PetscQuadrature *);
     52: PETSC_EXTERN PetscErrorCode PetscQuadratureDuplicate(PetscQuadrature, PetscQuadrature *);
     53: PETSC_EXTERN PetscErrorCode PetscQuadratureGetOrder(PetscQuadrature, PetscInt*);
     54: PETSC_EXTERN PetscErrorCode PetscQuadratureSetOrder(PetscQuadrature, PetscInt);
     55: PETSC_EXTERN PetscErrorCode PetscQuadratureGetNumComponents(PetscQuadrature, PetscInt*);
     56: PETSC_EXTERN PetscErrorCode PetscQuadratureSetNumComponents(PetscQuadrature, PetscInt);
     57: PETSC_EXTERN PetscErrorCode PetscQuadratureEqual(PetscQuadrature, PetscQuadrature, PetscBool*);
     58: PETSC_EXTERN PetscErrorCode PetscQuadratureGetData(PetscQuadrature, PetscInt*, PetscInt*, PetscInt*, const PetscReal *[], const PetscReal *[]);
     59: PETSC_EXTERN PetscErrorCode PetscQuadratureSetData(PetscQuadrature, PetscInt, PetscInt, PetscInt, const PetscReal [], const PetscReal []);
     60: PETSC_EXTERN PetscErrorCode PetscQuadratureView(PetscQuadrature, PetscViewer);
     61: PETSC_EXTERN PetscErrorCode PetscQuadratureDestroy(PetscQuadrature *);

     63: PETSC_EXTERN PetscErrorCode PetscDTTensorQuadratureCreate(PetscQuadrature, PetscQuadrature, PetscQuadrature *);
     64: PETSC_EXTERN PetscErrorCode PetscQuadratureExpandComposite(PetscQuadrature, PetscInt, const PetscReal[], const PetscReal[], PetscQuadrature *);

     66: PETSC_EXTERN PetscErrorCode PetscQuadraturePushForward(PetscQuadrature, PetscInt, const PetscReal[], const PetscReal[], const PetscReal[], PetscInt, PetscQuadrature *);

     68: PETSC_EXTERN PetscErrorCode PetscDTLegendreEval(PetscInt,const PetscReal*,PetscInt,const PetscInt*,PetscReal*,PetscReal*,PetscReal*);
     69: PETSC_EXTERN PetscErrorCode PetscDTJacobiNorm(PetscReal,PetscReal,PetscInt,PetscReal *);
     70: PETSC_EXTERN PetscErrorCode PetscDTJacobiEval(PetscInt,PetscReal,PetscReal,const PetscReal*,PetscInt,const PetscInt*,PetscReal*,PetscReal*,PetscReal*);
     71: PETSC_EXTERN PetscErrorCode PetscDTJacobiEvalJet(PetscReal,PetscReal,PetscInt,const PetscReal[],PetscInt,PetscInt,PetscReal[]);
     72: PETSC_EXTERN PetscErrorCode PetscDTPKDEvalJet(PetscInt,PetscInt,const PetscReal[],PetscInt,PetscInt,PetscReal[]);
     73: PETSC_EXTERN PetscErrorCode PetscDTPTrimmedSize(PetscInt,PetscInt,PetscInt,PetscInt*);
     74: PETSC_EXTERN PetscErrorCode PetscDTPTrimmedEvalJet(PetscInt,PetscInt,const PetscReal[],PetscInt,PetscInt,PetscInt,PetscReal[]);
     75: PETSC_EXTERN PetscErrorCode PetscDTGaussQuadrature(PetscInt,PetscReal,PetscReal,PetscReal*,PetscReal*);
     76: PETSC_EXTERN PetscErrorCode PetscDTGaussJacobiQuadrature(PetscInt,PetscReal,PetscReal,PetscReal,PetscReal,PetscReal*,PetscReal*);
     77: PETSC_EXTERN PetscErrorCode PetscDTGaussLobattoJacobiQuadrature(PetscInt,PetscReal,PetscReal,PetscReal,PetscReal,PetscReal*,PetscReal*);
     78: PETSC_EXTERN PetscErrorCode PetscDTGaussLobattoLegendreQuadrature(PetscInt,PetscGaussLobattoLegendreCreateType,PetscReal*,PetscReal*);
     79: PETSC_EXTERN PetscErrorCode PetscDTReconstructPoly(PetscInt,PetscInt,const PetscReal*,PetscInt,const PetscReal*,PetscReal*);
     80: PETSC_EXTERN PetscErrorCode PetscDTGaussTensorQuadrature(PetscInt,PetscInt,PetscInt,PetscReal,PetscReal,PetscQuadrature*);
     81: PETSC_EXTERN PetscErrorCode PetscDTStroudConicalQuadrature(PetscInt,PetscInt,PetscInt,PetscReal,PetscReal,PetscQuadrature*);

     83: PETSC_EXTERN PetscErrorCode PetscDTTanhSinhTensorQuadrature(PetscInt, PetscInt, PetscReal, PetscReal, PetscQuadrature *);
     84: PETSC_EXTERN PetscErrorCode PetscDTTanhSinhIntegrate(void (*)(const PetscReal[], void *, PetscReal *), PetscReal, PetscReal, PetscInt, void *, PetscReal *);
     85: PETSC_EXTERN PetscErrorCode PetscDTTanhSinhIntegrateMPFR(void (*)(const PetscReal[], void *, PetscReal *), PetscReal, PetscReal, PetscInt, void *, PetscReal *);

     87: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreIntegrate(PetscInt, PetscReal *, PetscReal *, const PetscReal *, PetscReal *);
     88: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementLaplacianCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
     89: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementLaplacianDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
     90: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementGradientCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***, PetscReal ***);
     91: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementGradientDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***, PetscReal ***);
     92: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementAdvectionCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
     93: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementAdvectionDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
     94: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementMassCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
     95: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementMassDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***);

     97: PETSC_EXTERN PetscErrorCode PetscDTAltVApply(PetscInt, PetscInt, const PetscReal *, const PetscReal *, PetscReal *);
     98: PETSC_EXTERN PetscErrorCode PetscDTAltVWedge(PetscInt, PetscInt, PetscInt, const PetscReal *, const PetscReal *, PetscReal *);
     99: PETSC_EXTERN PetscErrorCode PetscDTAltVWedgeMatrix(PetscInt, PetscInt, PetscInt, const PetscReal *, PetscReal *);
    100: PETSC_EXTERN PetscErrorCode PetscDTAltVPullback(PetscInt, PetscInt, const PetscReal *, PetscInt, const PetscReal *, PetscReal *);
    101: PETSC_EXTERN PetscErrorCode PetscDTAltVPullbackMatrix(PetscInt, PetscInt, const PetscReal *, PetscInt, PetscReal *);
    102: PETSC_EXTERN PetscErrorCode PetscDTAltVInterior(PetscInt, PetscInt, const PetscReal *, const PetscReal *, PetscReal *);
    103: PETSC_EXTERN PetscErrorCode PetscDTAltVInteriorMatrix(PetscInt, PetscInt, const PetscReal *, PetscReal *);
    104: PETSC_EXTERN PetscErrorCode PetscDTAltVInteriorPattern(PetscInt, PetscInt, PetscInt (*)[3]);
    105: PETSC_EXTERN PetscErrorCode PetscDTAltVStar(PetscInt, PetscInt, PetscInt, const PetscReal *, PetscReal *);

    107: PETSC_EXTERN PetscErrorCode PetscDTBaryToIndex(PetscInt,PetscInt,const PetscInt[],PetscInt*);
    108: PETSC_EXTERN PetscErrorCode PetscDTIndexToBary(PetscInt,PetscInt,PetscInt,PetscInt[]);
    109: PETSC_EXTERN PetscErrorCode PetscDTGradedOrderToIndex(PetscInt,const PetscInt[],PetscInt*);
    110: PETSC_EXTERN PetscErrorCode PetscDTIndexToGradedOrder(PetscInt,PetscInt,PetscInt[]);

    112: #if defined(PETSC_USE_64BIT_INDICES)
    113: #define PETSC_FACTORIAL_MAX 20
    114: #define PETSC_BINOMIAL_MAX  61
    115: #else
    116: #define PETSC_FACTORIAL_MAX 12
    117: #define PETSC_BINOMIAL_MAX  29
    118: #endif

    120: /*MC
    121:    PetscDTFactorial - Approximate n! as a real number

    123:    Input Parameter:
    124: .  n - a non-negative integer

    126:    Output Parameter:
    127: .  factorial - n!

    129:    Level: beginner
    130: M*/
    131: static inline PetscErrorCode PetscDTFactorial(PetscInt n, PetscReal *factorial)
    132: {
    133:   PetscReal f = 1.0;

    135:   *factorial = -1.0;
    137:   for (PetscInt i = 1; i < n+1; ++i) f *= (PetscReal)i;
    138:   *factorial = f;
    139:   return 0;
    140: }

    142: /*MC
    143:    PetscDTFactorialInt - Compute n! as an integer

    145:    Input Parameter:
    146: .  n - a non-negative integer

    148:    Output Parameter:
    149: .  factorial - n!

    151:    Level: beginner

    153:    Note: this is limited to n such that n! can be represented by PetscInt, which is 12 if PetscInt is a signed 32-bit integer and 20 if PetscInt is a signed 64-bit integer.
    154: M*/
    155: static inline PetscErrorCode PetscDTFactorialInt(PetscInt n, PetscInt *factorial)
    156: {
    157:   PetscInt facLookup[13] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600};

    159:   *factorial = -1;
    161:   if (n <= 12) {
    162:     *factorial = facLookup[n];
    163:   } else {
    164:     PetscInt f = facLookup[12];
    165:     PetscInt i;

    167:     for (i = 13; i < n+1; ++i) f *= i;
    168:     *factorial = f;
    169:   }
    170:   return 0;
    171: }

    173: /*MC
    174:    PetscDTBinomial - Approximate the binomial coefficient "n choose k"

    176:    Input Parameters:
    177: +  n - a non-negative integer
    178: -  k - an integer between 0 and n, inclusive

    180:    Output Parameter:
    181: .  binomial - approximation of the binomial coefficient n choose k

    183:    Level: beginner
    184: M*/
    185: static inline PetscErrorCode PetscDTBinomial(PetscInt n, PetscInt k, PetscReal *binomial)
    186: {
    188:   *binomial = -1.0;
    190:   if (n <= 3) {
    191:     PetscInt binomLookup[4][4] = {{1, 0, 0, 0}, {1, 1, 0, 0}, {1, 2, 1, 0}, {1, 3, 3, 1}};

    193:     *binomial = (PetscReal)binomLookup[n][k];
    194:   } else {
    195:     PetscReal binom = 1.0;

    197:     k = PetscMin(k, n - k);
    198:     for (PetscInt i = 0; i < k; i++) binom = (binom * (PetscReal)(n - i)) / (PetscReal)(i + 1);
    199:     *binomial = binom;
    200:   }
    201:   return 0;
    202: }

    204: /*MC
    205:    PetscDTBinomialInt - Compute the binomial coefficient "n choose k"

    207:    Input Parameters:
    208: +  n - a non-negative integer
    209: -  k - an integer between 0 and n, inclusive

    211:    Output Parameter:
    212: .  binomial - the binomial coefficient n choose k

    214:    Note: this is limited by integers that can be represented by PetscInt

    216:    Level: beginner
    217: M*/
    218: static inline PetscErrorCode PetscDTBinomialInt(PetscInt n, PetscInt k, PetscInt *binomial)
    219: {
    220:   PetscInt bin;

    222:   *binomial = -1;
    225:   if (n <= 3) {
    226:     PetscInt binomLookup[4][4] = {{1, 0, 0, 0}, {1, 1, 0, 0}, {1, 2, 1, 0}, {1, 3, 3, 1}};

    228:     bin = binomLookup[n][k];
    229:   } else {
    230:     PetscInt binom = 1;

    232:     k = PetscMin(k, n - k);
    233:     for (PetscInt i = 0; i < k; i++) binom = (binom * (n - i)) / (i + 1);
    234:     bin = binom;
    235:   }
    236:   *binomial = bin;
    237:   return 0;
    238: }

    240: /*MC
    241:    PetscDTEnumPerm - Get a permutation of n integers from its encoding into the integers [0, n!) as a sequence of swaps.

    243:    A permutation can be described by the operations that convert the lists [0, 1, ..., n-1] into the permutation,
    244:    by a sequence of swaps, where the ith step swaps whatever number is in ith position with a number that is in
    245:    some position j >= i.  This swap is encoded as the difference (j - i).  The difference d_i at step i is less than
    246:    (n - i).  This sequence of n-1 differences [d_0, ..., d_{n-2}] is encoded as the number
    247:    (n-1)! * d_0 + (n-2)! * d_1 + ... + 1! * d_{n-2}.

    249:    Input Parameters:
    250: +  n - a non-negative integer (see note about limits below)
    251: -  k - an integer in [0, n!)

    253:    Output Parameters:
    254: +  perm - the permuted list of the integers [0, ..., n-1]
    255: -  isOdd - if not NULL, returns wether the permutation used an even or odd number of swaps.

    257:    Note: this is limited to n such that n! can be represented by PetscInt, which is 12 if PetscInt is a signed 32-bit integer and 20 if PetscInt is a signed 64-bit integer.

    259:    Level: beginner
    260: M*/
    261: static inline PetscErrorCode PetscDTEnumPerm(PetscInt n, PetscInt k, PetscInt *perm, PetscBool *isOdd)
    262: {
    263:   PetscInt  odd = 0;
    264:   PetscInt  i;
    265:   PetscInt  work[PETSC_FACTORIAL_MAX];
    266:   PetscInt *w;

    268:   if (isOdd) *isOdd = PETSC_FALSE;
    270:   w = &work[n - 2];
    271:   for (i = 2; i <= n; i++) {
    272:     *(w--) = k % i;
    273:     k /= i;
    274:   }
    275:   for (i = 0; i < n; i++) perm[i] = i;
    276:   for (i = 0; i < n - 1; i++) {
    277:     PetscInt s = work[i];
    278:     PetscInt swap = perm[i];

    280:     perm[i] = perm[i + s];
    281:     perm[i + s] = swap;
    282:     odd ^= (!!s);
    283:   }
    284:   if (isOdd) *isOdd = odd ? PETSC_TRUE : PETSC_FALSE;
    285:   return 0;
    286: }

    288: /*MC
    289:    PetscDTPermIndex - Encode a permutation of n into an integer in [0, n!).  This inverts PetscDTEnumPerm.

    291:    Input Parameters:
    292: +  n - a non-negative integer (see note about limits below)
    293: -  perm - the permuted list of the integers [0, ..., n-1]

    295:    Output Parameters:
    296: +  k - an integer in [0, n!)
    297: -  isOdd - if not NULL, returns wether the permutation used an even or odd number of swaps.

    299:    Note: this is limited to n such that n! can be represented by PetscInt, which is 12 if PetscInt is a signed 32-bit integer and 20 if PetscInt is a signed 64-bit integer.

    301:    Level: beginner
    302: M*/
    303: static inline PetscErrorCode PetscDTPermIndex(PetscInt n, const PetscInt *perm, PetscInt *k, PetscBool *isOdd)
    304: {
    305:   PetscInt  odd = 0;
    306:   PetscInt  i, idx;
    307:   PetscInt  work[PETSC_FACTORIAL_MAX];
    308:   PetscInt  iwork[PETSC_FACTORIAL_MAX];

    311:   *k = -1;
    312:   if (isOdd) *isOdd = PETSC_FALSE;
    314:   for (i = 0; i < n; i++) work[i] = i;  /* partial permutation */
    315:   for (i = 0; i < n; i++) iwork[i] = i; /* partial permutation inverse */
    316:   for (idx = 0, i = 0; i < n - 1; i++) {
    317:     PetscInt j = perm[i];
    318:     PetscInt icur = work[i];
    319:     PetscInt jloc = iwork[j];
    320:     PetscInt diff = jloc - i;

    322:     idx = idx * (n - i) + diff;
    323:     /* swap (i, jloc) */
    324:     work[i] = j;
    325:     work[jloc] = icur;
    326:     iwork[j] = i;
    327:     iwork[icur] = jloc;
    328:     odd ^= (!!diff);
    329:   }
    330:   *k = idx;
    331:   if (isOdd) *isOdd = odd ? PETSC_TRUE : PETSC_FALSE;
    332:   return 0;
    333: }

    335: /*MC
    336:    PetscDTEnumSubset - Get an ordered subset of the integers [0, ..., n - 1] from its encoding as an integers in [0, n choose k).
    337:    The encoding is in lexicographic order.

    339:    Input Parameters:
    340: +  n - a non-negative integer (see note about limits below)
    341: .  k - an integer in [0, n]
    342: -  j - an index in [0, n choose k)

    344:    Output Parameter:
    345: .  subset - the jth subset of size k of the integers [0, ..., n - 1]

    347:    Note: this is limited by arguments such that n choose k can be represented by PetscInt

    349:    Level: beginner

    351: .seealso: PetscDTSubsetIndex()
    352: M*/
    353: static inline PetscErrorCode PetscDTEnumSubset(PetscInt n, PetscInt k, PetscInt j, PetscInt *subset)
    354: {
    355:   PetscInt Nk;

    358:   PetscDTBinomialInt(n, k, &Nk);
    359:   for (PetscInt i = 0, l = 0; i < n && l < k; i++) {
    360:     PetscInt Nminuskminus = (Nk * (k - l)) / (n - i);
    361:     PetscInt Nminusk = Nk - Nminuskminus;

    363:     if (j < Nminuskminus) {
    364:       subset[l++] = i;
    365:       Nk = Nminuskminus;
    366:     } else {
    367:       j -= Nminuskminus;
    368:       Nk = Nminusk;
    369:     }
    370:   }
    371:   return 0;
    372: }

    374: /*MC
    375:    PetscDTSubsetIndex - Convert an ordered subset of k integers from the set [0, ..., n - 1] to its encoding as an integers in [0, n choose k) in lexicographic order.  This is the inverse of PetscDTEnumSubset.

    377:    Input Parameters:
    378: +  n - a non-negative integer (see note about limits below)
    379: .  k - an integer in [0, n]
    380: -  subset - an ordered subset of the integers [0, ..., n - 1]

    382:    Output Parameter:
    383: .  index - the rank of the subset in lexicographic order

    385:    Note: this is limited by arguments such that n choose k can be represented by PetscInt

    387:    Level: beginner

    389: .seealso: PetscDTEnumSubset()
    390: M*/
    391: static inline PetscErrorCode PetscDTSubsetIndex(PetscInt n, PetscInt k, const PetscInt *subset, PetscInt *index)
    392: {
    393:   PetscInt j = 0, Nk;

    395:   *index = -1;
    396:   PetscDTBinomialInt(n, k, &Nk);
    397:   for (PetscInt i = 0, l = 0; i < n && l < k; i++) {
    398:     PetscInt Nminuskminus = (Nk * (k - l)) / (n - i);
    399:     PetscInt Nminusk = Nk - Nminuskminus;

    401:     if (subset[l] == i) {
    402:       l++;
    403:       Nk = Nminuskminus;
    404:     } else {
    405:       j += Nminuskminus;
    406:       Nk = Nminusk;
    407:     }
    408:   }
    409:   *index = j;
    410:   return 0;
    411: }

    413: /*MC
    414:    PetscDTEnumSubset - Split the integers [0, ..., n - 1] into two complementary ordered subsets, the first subset of size k and being the jth subset of that size in lexicographic order.

    416:    Input Parameters:
    417: +  n - a non-negative integer (see note about limits below)
    418: .  k - an integer in [0, n]
    419: -  j - an index in [0, n choose k)

    421:    Output Parameters:
    422: +  perm - the jth subset of size k of the integers [0, ..., n - 1], followed by its complementary set.
    423: -  isOdd - if not NULL, return whether perm is an even or odd permutation.

    425:    Note: this is limited by arguments such that n choose k can be represented by PetscInt

    427:    Level: beginner

    429: .seealso: PetscDTEnumSubset(), PetscDTSubsetIndex()
    430: M*/
    431: static inline PetscErrorCode PetscDTEnumSplit(PetscInt n, PetscInt k, PetscInt j, PetscInt *perm, PetscBool *isOdd)
    432: {
    433:   PetscInt i, l, m, Nk, odd = 0;
    434:   PetscInt *subcomp = perm+k;

    436:   if (isOdd) *isOdd = PETSC_FALSE;
    437:   PetscDTBinomialInt(n, k, &Nk);
    438:   for (i = 0, l = 0, m = 0; i < n && l < k; i++) {
    439:     PetscInt Nminuskminus = (Nk * (k - l)) / (n - i);
    440:     PetscInt Nminusk = Nk - Nminuskminus;

    442:     if (j < Nminuskminus) {
    443:       perm[l++] = i;
    444:       Nk = Nminuskminus;
    445:     } else {
    446:       subcomp[m++] = i;
    447:       j -= Nminuskminus;
    448:       odd ^= ((k - l) & 1);
    449:       Nk = Nminusk;
    450:     }
    451:   }
    452:   for (; i < n; i++) subcomp[m++] = i;
    453:   if (isOdd) *isOdd = odd ? PETSC_TRUE : PETSC_FALSE;
    454:   return 0;
    455: }

    457: struct _p_PetscTabulation {
    458:   PetscInt    K;    /* Indicates a k-jet, namely tabulated derivatives up to order k */
    459:   PetscInt    Nr;   /* The number of tabulation replicas (often 1) */
    460:   PetscInt    Np;   /* The number of tabulation points in a replica */
    461:   PetscInt    Nb;   /* The number of functions tabulated */
    462:   PetscInt    Nc;   /* The number of function components */
    463:   PetscInt    cdim; /* The coordinate dimension */
    464:   PetscReal **T;    /* The tabulation T[K] of functions and their derivatives
    465:                        T[0] = B[Nr*Np][Nb][Nc]:             The basis function values at quadrature points
    466:                        T[1] = D[Nr*Np][Nb][Nc][cdim]:       The basis function derivatives at quadrature points
    467:                        T[2] = H[Nr*Np][Nb][Nc][cdim][cdim]: The basis function second derivatives at quadrature points */
    468: };
    469: typedef struct _p_PetscTabulation *PetscTabulation;

    471: typedef PetscErrorCode (*PetscProbFunc)(const PetscReal[], const PetscReal[], PetscReal[]);

    473: typedef enum {DTPROB_DENSITY_CONSTANT, DTPROB_DENSITY_GAUSSIAN, DTPROB_DENSITY_MAXWELL_BOLTZMANN, DTPROB_NUM_DENSITY} DTProbDensityType;
    474: PETSC_EXTERN const char * const DTProbDensityTypes[];

    476: PETSC_EXTERN PetscErrorCode PetscPDFMaxwellBoltzmann1D(const PetscReal[], const PetscReal[], PetscReal[]);
    477: PETSC_EXTERN PetscErrorCode PetscCDFMaxwellBoltzmann1D(const PetscReal[], const PetscReal[], PetscReal[]);
    478: PETSC_EXTERN PetscErrorCode PetscPDFMaxwellBoltzmann2D(const PetscReal[], const PetscReal[], PetscReal[]);
    479: PETSC_EXTERN PetscErrorCode PetscCDFMaxwellBoltzmann2D(const PetscReal[], const PetscReal[], PetscReal[]);
    480: PETSC_EXTERN PetscErrorCode PetscPDFMaxwellBoltzmann3D(const PetscReal[], const PetscReal[], PetscReal[]);
    481: PETSC_EXTERN PetscErrorCode PetscCDFMaxwellBoltzmann3D(const PetscReal[], const PetscReal[], PetscReal[]);
    482: PETSC_EXTERN PetscErrorCode PetscPDFGaussian1D(const PetscReal[], const PetscReal[], PetscReal[]);
    483: PETSC_EXTERN PetscErrorCode PetscCDFGaussian1D(const PetscReal[], const PetscReal[], PetscReal[]);
    484: PETSC_EXTERN PetscErrorCode PetscPDFSampleGaussian1D(const PetscReal[], const PetscReal[], PetscReal[]);
    485: PETSC_EXTERN PetscErrorCode PetscPDFGaussian2D(const PetscReal[], const PetscReal[], PetscReal[]);
    486: PETSC_EXTERN PetscErrorCode PetscPDFSampleGaussian2D(const PetscReal[], const PetscReal[], PetscReal[]);
    487: PETSC_EXTERN PetscErrorCode PetscPDFConstant1D(const PetscReal[], const PetscReal[], PetscReal[]);
    488: PETSC_EXTERN PetscErrorCode PetscCDFConstant1D(const PetscReal[], const PetscReal[], PetscReal[]);
    489: PETSC_EXTERN PetscErrorCode PetscPDFSampleConstant1D(const PetscReal[], const PetscReal[], PetscReal[]);
    490: PETSC_EXTERN PetscErrorCode PetscProbCreateFromOptions(PetscInt, const char[], const char[], PetscProbFunc *, PetscProbFunc *, PetscProbFunc *);

    492: #include <petscvec.h>

    494: PETSC_EXTERN PetscErrorCode PetscProbComputeKSStatistic(Vec, PetscProbFunc, PetscReal *);

    496: #endif