Actual source code: petscdt.h

  1: /*
  2:   Common tools for constructing discretizations
  3: */
  4: #ifndef PETSCDT_H
  5: #define PETSCDT_H

  7: #include <petscsys.h>
  8: #include <petscdmtypes.h>
  9: #include <petscistypes.h>

 11: /* SUBMANSEC = DT */

 13: PETSC_EXTERN PetscClassId PETSCQUADRATURE_CLASSID;

 15: /*S
 16:   PetscQuadrature - Quadrature rule for numerical integration.

 18:   Level: beginner

 20: .seealso: `PetscQuadratureCreate()`, `PetscQuadratureDestroy()`
 21: S*/
 22: typedef struct _p_PetscQuadrature *PetscQuadrature;

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

 27:   Values:
 28: +  `PETSCGAUSSLOBATTOLEGENDRE_VIA_LINEAR_ALGEBRA` - compute the nodes via linear algebra
 29: -  `PETSCGAUSSLOBATTOLEGENDRE_VIA_NEWTON` - compute the nodes by solving a nonlinear equation with Newton's method

 31:   Level: intermediate

 33: .seealso: `PetscQuadrature`
 34: E*/
 35: typedef enum {
 36:   PETSCGAUSSLOBATTOLEGENDRE_VIA_LINEAR_ALGEBRA,
 37:   PETSCGAUSSLOBATTOLEGENDRE_VIA_NEWTON
 38: } PetscGaussLobattoLegendreCreateType;

 40: /*E
 41:   PetscDTNodeType - A description of strategies for generating nodes (both
 42:   quadrature nodes and nodes for Lagrange polynomials)

 44:    Values:
 45: +  `PETSCDTNODES_DEFAULT` - Nodes chosen by PETSc
 46: .  `PETSCDTNODES_GAUSSJACOBI` - Nodes at either Gauss-Jacobi or Gauss-Lobatto-Jacobi quadrature points
 47: .  `PETSCDTNODES_EQUISPACED` - Nodes equispaced either including the endpoints or excluding them
 48: -  `PETSCDTNODES_TANHSINH` - Nodes at Tanh-Sinh quadrature points

 50:   Level: intermediate

 52:   Note:
 53:   A `PetscDTNodeType` can be paired with a `PetscBool` to indicate whether
 54:   the nodes include endpoints or not, and in the case of `PETSCDT_GAUSSJACOBI`
 55:   with exponents for the weight function.

 57: .seealso: `PetscQuadrature`
 58: E*/
 59: typedef enum {
 60:   PETSCDTNODES_DEFAULT = -1,
 61:   PETSCDTNODES_GAUSSJACOBI,
 62:   PETSCDTNODES_EQUISPACED,
 63:   PETSCDTNODES_TANHSINH
 64: } PetscDTNodeType;

 66: PETSC_EXTERN const char *const *const PetscDTNodeTypes;

 68: /*E
 69:   PetscDTSimplexQuadratureType - A description of classes of quadrature rules for simplices

 71:   Values:
 72: +  `PETSCDTSIMPLEXQUAD_DEFAULT` - Quadrature rule chosen by PETSc
 73: .  `PETSCDTSIMPLEXQUAD_CONIC`   - Quadrature rules constructed as
 74:                                 conically-warped tensor products of 1D
 75:                                 Gauss-Jacobi quadrature rules.  These are
 76:                                 explicitly computable in any dimension for any
 77:                                 degree, and the tensor-product structure can be
 78:                                 exploited by sum-factorization methods, but
 79:                                 they are not efficient in terms of nodes per
 80:                                 polynomial degree.
 81: -  `PETSCDTSIMPLEXQUAD_MINSYM`  - Quadrature rules that are fully symmetric
 82:                                 (symmetries of the simplex preserve the nodes
 83:                                 and weights) with minimal (or near minimal)
 84:                                 number of nodes.  In dimensions higher than 1
 85:                                 these are not simple to compute, so lookup
 86:                                 tables are used.

 88:   Level: intermediate

 90: .seealso: `PetscQuadrature`, `PetscDTSimplexQuadrature()`
 91: E*/
 92: typedef enum {
 93:   PETSCDTSIMPLEXQUAD_DEFAULT = -1,
 94:   PETSCDTSIMPLEXQUAD_CONIC   = 0,
 95:   PETSCDTSIMPLEXQUAD_MINSYM
 96: } PetscDTSimplexQuadratureType;

 98: PETSC_EXTERN const char *const *const PetscDTSimplexQuadratureTypes;

100: PETSC_EXTERN PetscErrorCode PetscQuadratureCreate(MPI_Comm, PetscQuadrature *);
101: PETSC_EXTERN PetscErrorCode PetscQuadratureDuplicate(PetscQuadrature, PetscQuadrature *);
102: PETSC_EXTERN PetscErrorCode PetscQuadratureGetCellType(PetscQuadrature, DMPolytopeType *);
103: PETSC_EXTERN PetscErrorCode PetscQuadratureSetCellType(PetscQuadrature, DMPolytopeType);
104: PETSC_EXTERN PetscErrorCode PetscQuadratureGetOrder(PetscQuadrature, PetscInt *);
105: PETSC_EXTERN PetscErrorCode PetscQuadratureSetOrder(PetscQuadrature, PetscInt);
106: PETSC_EXTERN PetscErrorCode PetscQuadratureGetNumComponents(PetscQuadrature, PetscInt *);
107: PETSC_EXTERN PetscErrorCode PetscQuadratureSetNumComponents(PetscQuadrature, PetscInt);
108: PETSC_EXTERN PetscErrorCode PetscQuadratureEqual(PetscQuadrature, PetscQuadrature, PetscBool *);
109: PETSC_EXTERN PetscErrorCode PetscQuadratureGetData(PetscQuadrature, PetscInt *, PetscInt *, PetscInt *, const PetscReal *[], const PetscReal *[]);
110: PETSC_EXTERN PetscErrorCode PetscQuadratureSetData(PetscQuadrature, PetscInt, PetscInt, PetscInt, const PetscReal[], const PetscReal[]);
111: PETSC_EXTERN PetscErrorCode PetscQuadratureView(PetscQuadrature, PetscViewer);
112: PETSC_EXTERN PetscErrorCode PetscQuadratureDestroy(PetscQuadrature *);

114: PETSC_EXTERN PetscErrorCode PetscDTTensorQuadratureCreate(PetscQuadrature, PetscQuadrature, PetscQuadrature *);
115: PETSC_EXTERN PetscErrorCode PetscQuadratureExpandComposite(PetscQuadrature, PetscInt, const PetscReal[], const PetscReal[], PetscQuadrature *);
116: PETSC_EXTERN PetscErrorCode PetscQuadratureComputePermutations(PetscQuadrature, PetscInt *, IS *[]);

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

120: PETSC_EXTERN PetscErrorCode PetscDTLegendreEval(PetscInt, const PetscReal *, PetscInt, const PetscInt *, PetscReal *, PetscReal *, PetscReal *);
121: PETSC_EXTERN PetscErrorCode PetscDTJacobiNorm(PetscReal, PetscReal, PetscInt, PetscReal *);
122: PETSC_EXTERN PetscErrorCode PetscDTJacobiEval(PetscInt, PetscReal, PetscReal, const PetscReal *, PetscInt, const PetscInt *, PetscReal *, PetscReal *, PetscReal *);
123: PETSC_EXTERN PetscErrorCode PetscDTJacobiEvalJet(PetscReal, PetscReal, PetscInt, const PetscReal[], PetscInt, PetscInt, PetscReal[]);
124: PETSC_EXTERN PetscErrorCode PetscDTPKDEvalJet(PetscInt, PetscInt, const PetscReal[], PetscInt, PetscInt, PetscReal[]);
125: PETSC_EXTERN PetscErrorCode PetscDTPTrimmedSize(PetscInt, PetscInt, PetscInt, PetscInt *);
126: PETSC_EXTERN PetscErrorCode PetscDTPTrimmedEvalJet(PetscInt, PetscInt, const PetscReal[], PetscInt, PetscInt, PetscInt, PetscReal[]);
127: PETSC_EXTERN PetscErrorCode PetscDTGaussQuadrature(PetscInt, PetscReal, PetscReal, PetscReal *, PetscReal *);
128: PETSC_EXTERN PetscErrorCode PetscDTGaussJacobiQuadrature(PetscInt, PetscReal, PetscReal, PetscReal, PetscReal, PetscReal *, PetscReal *);
129: PETSC_EXTERN PetscErrorCode PetscDTGaussLobattoJacobiQuadrature(PetscInt, PetscReal, PetscReal, PetscReal, PetscReal, PetscReal *, PetscReal *);
130: PETSC_EXTERN PetscErrorCode PetscDTGaussLobattoLegendreQuadrature(PetscInt, PetscGaussLobattoLegendreCreateType, PetscReal *, PetscReal *);
131: PETSC_EXTERN PetscErrorCode PetscDTReconstructPoly(PetscInt, PetscInt, const PetscReal *, PetscInt, const PetscReal *, PetscReal *);
132: PETSC_EXTERN PetscErrorCode PetscDTGaussTensorQuadrature(PetscInt, PetscInt, PetscInt, PetscReal, PetscReal, PetscQuadrature *);
133: PETSC_EXTERN PetscErrorCode PetscDTStroudConicalQuadrature(PetscInt, PetscInt, PetscInt, PetscReal, PetscReal, PetscQuadrature *);
134: PETSC_EXTERN PetscErrorCode PetscDTSimplexQuadrature(PetscInt, PetscInt, PetscDTSimplexQuadratureType, PetscQuadrature *);
135: PETSC_EXTERN PetscErrorCode PetscDTCreateDefaultQuadrature(DMPolytopeType, PetscInt, PetscQuadrature *, PetscQuadrature *);

137: PETSC_EXTERN PetscErrorCode PetscDTTanhSinhTensorQuadrature(PetscInt, PetscInt, PetscReal, PetscReal, PetscQuadrature *);
138: PETSC_EXTERN PetscErrorCode PetscDTTanhSinhIntegrate(void (*)(const PetscReal[], void *, PetscReal *), PetscReal, PetscReal, PetscInt, void *, PetscReal *);
139: PETSC_EXTERN PetscErrorCode PetscDTTanhSinhIntegrateMPFR(void (*)(const PetscReal[], void *, PetscReal *), PetscReal, PetscReal, PetscInt, void *, PetscReal *);

141: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreIntegrate(PetscInt, PetscReal *, PetscReal *, const PetscReal *, PetscReal *);
142: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementLaplacianCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
143: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementLaplacianDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
144: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementGradientCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***, PetscReal ***);
145: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementGradientDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***, PetscReal ***);
146: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementAdvectionCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
147: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementAdvectionDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
148: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementMassCreate(PetscInt, PetscReal *, PetscReal *, PetscReal ***);
149: PETSC_EXTERN PetscErrorCode PetscGaussLobattoLegendreElementMassDestroy(PetscInt, PetscReal *, PetscReal *, PetscReal ***);

151: PETSC_EXTERN PetscErrorCode PetscDTAltVApply(PetscInt, PetscInt, const PetscReal *, const PetscReal *, PetscReal *);
152: PETSC_EXTERN PetscErrorCode PetscDTAltVWedge(PetscInt, PetscInt, PetscInt, const PetscReal *, const PetscReal *, PetscReal *);
153: PETSC_EXTERN PetscErrorCode PetscDTAltVWedgeMatrix(PetscInt, PetscInt, PetscInt, const PetscReal *, PetscReal *);
154: PETSC_EXTERN PetscErrorCode PetscDTAltVPullback(PetscInt, PetscInt, const PetscReal *, PetscInt, const PetscReal *, PetscReal *);
155: PETSC_EXTERN PetscErrorCode PetscDTAltVPullbackMatrix(PetscInt, PetscInt, const PetscReal *, PetscInt, PetscReal *);
156: PETSC_EXTERN PetscErrorCode PetscDTAltVInterior(PetscInt, PetscInt, const PetscReal *, const PetscReal *, PetscReal *);
157: PETSC_EXTERN PetscErrorCode PetscDTAltVInteriorMatrix(PetscInt, PetscInt, const PetscReal *, PetscReal *);
158: PETSC_EXTERN PetscErrorCode PetscDTAltVInteriorPattern(PetscInt, PetscInt, PetscInt (*)[3]);
159: PETSC_EXTERN PetscErrorCode PetscDTAltVStar(PetscInt, PetscInt, PetscInt, const PetscReal *, PetscReal *);

161: PETSC_EXTERN PetscErrorCode PetscDTBaryToIndex(PetscInt, PetscInt, const PetscInt[], PetscInt *);
162: PETSC_EXTERN PetscErrorCode PetscDTIndexToBary(PetscInt, PetscInt, PetscInt, PetscInt[]);
163: PETSC_EXTERN PetscErrorCode PetscDTGradedOrderToIndex(PetscInt, const PetscInt[], PetscInt *);
164: PETSC_EXTERN PetscErrorCode PetscDTIndexToGradedOrder(PetscInt, PetscInt, PetscInt[]);

166: #if defined(PETSC_USE_64BIT_INDICES)
167:   #define PETSC_FACTORIAL_MAX 20
168:   #define PETSC_BINOMIAL_MAX  61
169: #else
170:   #define PETSC_FACTORIAL_MAX 12
171:   #define PETSC_BINOMIAL_MAX  29
172: #endif

174: /*MC
175:    PetscDTFactorial - Approximate n! as a real number

177:    Input Parameter:
178: .  n - a non-negative integer

180:    Output Parameter:
181: .  factorial - n!

183:    Level: beginner

185: .seealso: `PetscDTFactorialInt()`, `PetscDTBinomialInt()`, `PetscDTBinomial()`
186: M*/
187: static inline PetscErrorCode PetscDTFactorial(PetscInt n, PetscReal *factorial)
188: {
189:   PetscReal f = 1.0;

191:   PetscFunctionBegin;
192:   *factorial = -1.0;
193:   PetscCheck(n >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Factorial called with negative number %" PetscInt_FMT, n);
194:   for (PetscInt i = 1; i < n + 1; ++i) f *= (PetscReal)i;
195:   *factorial = f;
196:   PetscFunctionReturn(PETSC_SUCCESS);
197: }

199: /*MC
200:    PetscDTFactorialInt - Compute n! as an integer

202:    Input Parameter:
203: .  n - a non-negative integer

205:    Output Parameter:
206: .  factorial - n!

208:    Level: beginner

210:    Note:
211:    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.

213: .seealso: `PetscDTFactorial()`, `PetscDTBinomialInt()`, `PetscDTBinomial()`
214: M*/
215: static inline PetscErrorCode PetscDTFactorialInt(PetscInt n, PetscInt *factorial)
216: {
217:   PetscInt facLookup[13] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600};

219:   PetscFunctionBegin;
220:   *factorial = -1;
221:   PetscCheck(n >= 0 && n <= PETSC_FACTORIAL_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Number of elements %" PetscInt_FMT " is not in supported range [0,%d]", n, PETSC_FACTORIAL_MAX);
222:   if (n <= 12) {
223:     *factorial = facLookup[n];
224:   } else {
225:     PetscInt f = facLookup[12];
226:     PetscInt i;

228:     for (i = 13; i < n + 1; ++i) f *= i;
229:     *factorial = f;
230:   }
231:   PetscFunctionReturn(PETSC_SUCCESS);
232: }

234: /*MC
235:    PetscDTBinomial - Approximate the binomial coefficient "n choose k"

237:    Input Parameters:
238: +  n - a non-negative integer
239: -  k - an integer between 0 and n, inclusive

241:    Output Parameter:
242: .  binomial - approximation of the binomial coefficient n choose k

244:    Level: beginner

246: .seealso: `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomialInt()`, `PetscDTEnumPerm()`
247: M*/
248: static inline PetscErrorCode PetscDTBinomial(PetscInt n, PetscInt k, PetscReal *binomial)
249: {
250:   PetscFunctionBeginHot;
251:   *binomial = -1.0;
252:   PetscCheck(n >= 0 && k >= 0 && k <= n, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Binomial arguments (%" PetscInt_FMT " %" PetscInt_FMT ") must be non-negative, k <= n", n, k);
253:   if (n <= 3) {
254:     PetscInt binomLookup[4][4] = {
255:       {1, 0, 0, 0},
256:       {1, 1, 0, 0},
257:       {1, 2, 1, 0},
258:       {1, 3, 3, 1}
259:     };

261:     *binomial = (PetscReal)binomLookup[n][k];
262:   } else {
263:     PetscReal binom = 1.0;

265:     k = PetscMin(k, n - k);
266:     for (PetscInt i = 0; i < k; i++) binom = (binom * (PetscReal)(n - i)) / (PetscReal)(i + 1);
267:     *binomial = binom;
268:   }
269:   PetscFunctionReturn(PETSC_SUCCESS);
270: }

272: /*MC
273:    PetscDTBinomialInt - Compute the binomial coefficient "n choose k"

275:    Input Parameters:
276: +  n - a non-negative integer
277: -  k - an integer between 0 and n, inclusive

279:    Output Parameter:
280: .  binomial - the binomial coefficient n choose k

282:    Level: beginner

284:    Note:
285:    This is limited by integers that can be represented by `PetscInt`.

287:    Use `PetscDTBinomial()` for real number approximations of larger values

289: .seealso: `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomial()`, `PetscDTEnumPerm()`
290: M*/
291: static inline PetscErrorCode PetscDTBinomialInt(PetscInt n, PetscInt k, PetscInt *binomial)
292: {
293:   PetscInt bin;

295:   PetscFunctionBegin;
296:   *binomial = -1;
297:   PetscCheck(n >= 0 && k >= 0 && k <= n, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Binomial arguments (%" PetscInt_FMT " %" PetscInt_FMT ") must be non-negative, k <= n", n, k);
298:   PetscCheck(n <= PETSC_BINOMIAL_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Binomial elements %" PetscInt_FMT " is larger than max for PetscInt, %d", n, PETSC_BINOMIAL_MAX);
299:   if (n <= 3) {
300:     PetscInt binomLookup[4][4] = {
301:       {1, 0, 0, 0},
302:       {1, 1, 0, 0},
303:       {1, 2, 1, 0},
304:       {1, 3, 3, 1}
305:     };

307:     bin = binomLookup[n][k];
308:   } else {
309:     PetscInt binom = 1;

311:     k = PetscMin(k, n - k);
312:     for (PetscInt i = 0; i < k; i++) binom = (binom * (n - i)) / (i + 1);
313:     bin = binom;
314:   }
315:   *binomial = bin;
316:   PetscFunctionReturn(PETSC_SUCCESS);
317: }

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

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

326:    Output Parameters:
327: +  perm - the permuted list of the integers [0, ..., n-1]
328: -  isOdd - if not `NULL`, returns whether the permutation used an even or odd number of swaps.

330:    Level: intermediate

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

339:    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.

341: .seealso: `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomial()`, `PetscDTBinomialInt()`, `PetscDTPermIndex()`
342: M*/
343: static inline PetscErrorCode PetscDTEnumPerm(PetscInt n, PetscInt k, PetscInt *perm, PetscBool *isOdd)
344: {
345:   PetscInt  odd = 0;
346:   PetscInt  i;
347:   PetscInt  work[PETSC_FACTORIAL_MAX];
348:   PetscInt *w;

350:   PetscFunctionBegin;
351:   if (isOdd) *isOdd = PETSC_FALSE;
352:   PetscCheck(n >= 0 && n <= PETSC_FACTORIAL_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Number of elements %" PetscInt_FMT " is not in supported range [0,%d]", n, PETSC_FACTORIAL_MAX);
353:   w = &work[n - 2];
354:   for (i = 2; i <= n; i++) {
355:     *(w--) = k % i;
356:     k /= i;
357:   }
358:   for (i = 0; i < n; i++) perm[i] = i;
359:   for (i = 0; i < n - 1; i++) {
360:     PetscInt s    = work[i];
361:     PetscInt swap = perm[i];

363:     perm[i]     = perm[i + s];
364:     perm[i + s] = swap;
365:     odd ^= (!!s);
366:   }
367:   if (isOdd) *isOdd = odd ? PETSC_TRUE : PETSC_FALSE;
368:   PetscFunctionReturn(PETSC_SUCCESS);
369: }

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

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

378:    Output Parameters:
379: +  k - an integer in [0, n!)
380: -  isOdd - if not `NULL`, returns whether the permutation used an even or odd number of swaps.

382:    Level: beginner

384:    Note:
385:    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.

387: .seealso: `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomial()`, `PetscDTBinomialInt()`, `PetscDTEnumPerm()`
388: M*/
389: static inline PetscErrorCode PetscDTPermIndex(PetscInt n, const PetscInt *perm, PetscInt *k, PetscBool *isOdd)
390: {
391:   PetscInt odd = 0;
392:   PetscInt i, idx;
393:   PetscInt work[PETSC_FACTORIAL_MAX];
394:   PetscInt iwork[PETSC_FACTORIAL_MAX];

396:   PetscFunctionBeginHot;
397:   *k = -1;
398:   if (isOdd) *isOdd = PETSC_FALSE;
399:   PetscCheck(n >= 0 && n <= PETSC_FACTORIAL_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Number of elements %" PetscInt_FMT " is not in supported range [0,%d]", n, PETSC_FACTORIAL_MAX);
400:   for (i = 0; i < n; i++) work[i] = i;  /* partial permutation */
401:   for (i = 0; i < n; i++) iwork[i] = i; /* partial permutation inverse */
402:   for (idx = 0, i = 0; i < n - 1; i++) {
403:     PetscInt j    = perm[i];
404:     PetscInt icur = work[i];
405:     PetscInt jloc = iwork[j];
406:     PetscInt diff = jloc - i;

408:     idx = idx * (n - i) + diff;
409:     /* swap (i, jloc) */
410:     work[i]     = j;
411:     work[jloc]  = icur;
412:     iwork[j]    = i;
413:     iwork[icur] = jloc;
414:     odd ^= (!!diff);
415:   }
416:   *k = idx;
417:   if (isOdd) *isOdd = odd ? PETSC_TRUE : PETSC_FALSE;
418:   PetscFunctionReturn(PETSC_SUCCESS);
419: }

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

425:    Input Parameters:
426: +  n - a non-negative integer (see note about limits below)
427: .  k - an integer in [0, n]
428: -  j - an index in [0, n choose k)

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

433:    Level: beginner

435:    Note:
436:    Limited by arguments such that `n` choose `k` can be represented by `PetscInt`

438: .seealso: `PetscDTSubsetIndex()`, `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomial()`, `PetscDTBinomialInt()`, `PetscDTEnumPerm()`, `PetscDTPermIndex()`
439: M*/
440: static inline PetscErrorCode PetscDTEnumSubset(PetscInt n, PetscInt k, PetscInt j, PetscInt *subset)
441: {
442:   PetscInt Nk;

444:   PetscFunctionBeginHot;
445:   PetscCall(PetscDTBinomialInt(n, k, &Nk));
446:   for (PetscInt i = 0, l = 0; i < n && l < k; i++) {
447:     PetscInt Nminuskminus = (Nk * (k - l)) / (n - i);
448:     PetscInt Nminusk      = Nk - Nminuskminus;

450:     if (j < Nminuskminus) {
451:       subset[l++] = i;
452:       Nk          = Nminuskminus;
453:     } else {
454:       j -= Nminuskminus;
455:       Nk = Nminusk;
456:     }
457:   }
458:   PetscFunctionReturn(PETSC_SUCCESS);
459: }

461: /*MC
462:    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.
463:    This is the inverse of `PetscDTEnumSubset`.

465:    Input Parameters:
466: +  n - a non-negative integer (see note about limits below)
467: .  k - an integer in [0, n]
468: -  subset - an ordered subset of the integers [0, ..., n - 1]

470:    Output Parameter:
471: .  index - the rank of the subset in lexicographic order

473:    Level: beginner

475:    Note:
476:    Limited by arguments such that `n` choose `k` can be represented by `PetscInt`

478: .seealso: `PetscDTEnumSubset()`, `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomial()`, `PetscDTBinomialInt()`, `PetscDTEnumPerm()`, `PetscDTPermIndex()`
479: M*/
480: static inline PetscErrorCode PetscDTSubsetIndex(PetscInt n, PetscInt k, const PetscInt *subset, PetscInt *index)
481: {
482:   PetscInt j = 0, Nk;

484:   PetscFunctionBegin;
485:   *index = -1;
486:   PetscCall(PetscDTBinomialInt(n, k, &Nk));
487:   for (PetscInt i = 0, l = 0; i < n && l < k; i++) {
488:     PetscInt Nminuskminus = (Nk * (k - l)) / (n - i);
489:     PetscInt Nminusk      = Nk - Nminuskminus;

491:     if (subset[l] == i) {
492:       l++;
493:       Nk = Nminuskminus;
494:     } else {
495:       j += Nminuskminus;
496:       Nk = Nminusk;
497:     }
498:   }
499:   *index = j;
500:   PetscFunctionReturn(PETSC_SUCCESS);
501: }

503: /*MC
504:    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.

506:    Input Parameters:
507: +  n - a non-negative integer (see note about limits below)
508: .  k - an integer in [0, n]
509: -  j - an index in [0, n choose k)

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

515:    Level: beginner

517:    Note:
518:    Limited by arguments such that `n` choose `k` can be represented by `PetscInt`

520: .seealso: `PetscDTEnumSubset()`, `PetscDTSubsetIndex()`, `PetscDTFactorial()`, `PetscDTFactorialInt()`, `PetscDTBinomial()`, `PetscDTBinomialInt()`, `PetscDTEnumPerm()`,
521:           `PetscDTPermIndex()`
522: M*/
523: static inline PetscErrorCode PetscDTEnumSplit(PetscInt n, PetscInt k, PetscInt j, PetscInt *perm, PetscBool *isOdd)
524: {
525:   PetscInt  i, l, m, Nk, odd = 0;
526:   PetscInt *subcomp = perm + k;

528:   PetscFunctionBegin;
529:   if (isOdd) *isOdd = PETSC_FALSE;
530:   PetscCall(PetscDTBinomialInt(n, k, &Nk));
531:   for (i = 0, l = 0, m = 0; i < n && l < k; i++) {
532:     PetscInt Nminuskminus = (Nk * (k - l)) / (n - i);
533:     PetscInt Nminusk      = Nk - Nminuskminus;

535:     if (j < Nminuskminus) {
536:       perm[l++] = i;
537:       Nk        = Nminuskminus;
538:     } else {
539:       subcomp[m++] = i;
540:       j -= Nminuskminus;
541:       odd ^= ((k - l) & 1);
542:       Nk = Nminusk;
543:     }
544:   }
545:   for (; i < n; i++) subcomp[m++] = i;
546:   if (isOdd) *isOdd = odd ? PETSC_TRUE : PETSC_FALSE;
547:   PetscFunctionReturn(PETSC_SUCCESS);
548: }

550: struct _p_PetscTabulation {
551:   PetscInt    K;    /* Indicates a k-jet, namely tabulated derivatives up to order k */
552:   PetscInt    Nr;   /* The number of tabulation replicas (often 1) */
553:   PetscInt    Np;   /* The number of tabulation points in a replica */
554:   PetscInt    Nb;   /* The number of functions tabulated */
555:   PetscInt    Nc;   /* The number of function components */
556:   PetscInt    cdim; /* The coordinate dimension */
557:   PetscReal **T;    /* The tabulation T[K] of functions and their derivatives
558:                        T[0] = B[Nr*Np][Nb][Nc]:             The basis function values at quadrature points
559:                        T[1] = D[Nr*Np][Nb][Nc][cdim]:       The basis function derivatives at quadrature points
560:                        T[2] = H[Nr*Np][Nb][Nc][cdim][cdim]: The basis function second derivatives at quadrature points */
561: };
562: typedef struct _p_PetscTabulation *PetscTabulation;

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

566: typedef enum {
567:   DTPROB_DENSITY_CONSTANT,
568:   DTPROB_DENSITY_GAUSSIAN,
569:   DTPROB_DENSITY_MAXWELL_BOLTZMANN,
570:   DTPROB_NUM_DENSITY
571: } DTProbDensityType;
572: PETSC_EXTERN const char *const DTProbDensityTypes[];

574: PETSC_EXTERN PetscErrorCode PetscPDFMaxwellBoltzmann1D(const PetscReal[], const PetscReal[], PetscReal[]);
575: PETSC_EXTERN PetscErrorCode PetscCDFMaxwellBoltzmann1D(const PetscReal[], const PetscReal[], PetscReal[]);
576: PETSC_EXTERN PetscErrorCode PetscPDFMaxwellBoltzmann2D(const PetscReal[], const PetscReal[], PetscReal[]);
577: PETSC_EXTERN PetscErrorCode PetscCDFMaxwellBoltzmann2D(const PetscReal[], const PetscReal[], PetscReal[]);
578: PETSC_EXTERN PetscErrorCode PetscPDFMaxwellBoltzmann3D(const PetscReal[], const PetscReal[], PetscReal[]);
579: PETSC_EXTERN PetscErrorCode PetscCDFMaxwellBoltzmann3D(const PetscReal[], const PetscReal[], PetscReal[]);
580: PETSC_EXTERN PetscErrorCode PetscPDFGaussian1D(const PetscReal[], const PetscReal[], PetscReal[]);
581: PETSC_EXTERN PetscErrorCode PetscCDFGaussian1D(const PetscReal[], const PetscReal[], PetscReal[]);
582: PETSC_EXTERN PetscErrorCode PetscPDFSampleGaussian1D(const PetscReal[], const PetscReal[], PetscReal[]);
583: PETSC_EXTERN PetscErrorCode PetscPDFGaussian2D(const PetscReal[], const PetscReal[], PetscReal[]);
584: PETSC_EXTERN PetscErrorCode PetscPDFSampleGaussian2D(const PetscReal[], const PetscReal[], PetscReal[]);
585: PETSC_EXTERN PetscErrorCode PetscPDFGaussian3D(const PetscReal[], const PetscReal[], PetscReal[]);
586: PETSC_EXTERN PetscErrorCode PetscPDFSampleGaussian3D(const PetscReal[], const PetscReal[], PetscReal[]);
587: PETSC_EXTERN PetscErrorCode PetscPDFConstant1D(const PetscReal[], const PetscReal[], PetscReal[]);
588: PETSC_EXTERN PetscErrorCode PetscCDFConstant1D(const PetscReal[], const PetscReal[], PetscReal[]);
589: PETSC_EXTERN PetscErrorCode PetscPDFSampleConstant1D(const PetscReal[], const PetscReal[], PetscReal[]);
590: PETSC_EXTERN PetscErrorCode PetscPDFConstant2D(const PetscReal[], const PetscReal[], PetscReal[]);
591: PETSC_EXTERN PetscErrorCode PetscCDFConstant2D(const PetscReal[], const PetscReal[], PetscReal[]);
592: PETSC_EXTERN PetscErrorCode PetscPDFSampleConstant2D(const PetscReal[], const PetscReal[], PetscReal[]);
593: PETSC_EXTERN PetscErrorCode PetscPDFConstant3D(const PetscReal[], const PetscReal[], PetscReal[]);
594: PETSC_EXTERN PetscErrorCode PetscCDFConstant3D(const PetscReal[], const PetscReal[], PetscReal[]);
595: PETSC_EXTERN PetscErrorCode PetscPDFSampleConstant3D(const PetscReal[], const PetscReal[], PetscReal[]);
596: PETSC_EXTERN PetscErrorCode PetscProbCreateFromOptions(PetscInt, const char[], const char[], PetscProbFunc *, PetscProbFunc *, PetscProbFunc *);

598: #include <petscvec.h>

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

602: #endif