|
UQTk: Uncertainty Quantification Toolkit 3.1.3
|
Defines and initializes PC basis function set and provides functions to manipulate PC expansions defined on this basis set. More...
#include <PCSet.h>
Public Member Functions | |
| PCSet (const string sp_type, const int order, const int n_dim, const string pc_type, const double alpha=0.0, const double betta=1.0) | |
| Constructor: initializes the PC basis set for the order, number of dimensions and type that are passed in. More... | |
| PCSet (const string sp_type, const int order, const int n_dim, const string pc_type, const string pc_seq, const double alpha=0.0, const double betta=1.0) | |
| Constructor: initializes the PC basis set for the order, number of dimensions and type that are passed in. It also customizes the multiindex sequence ( lexicographical-lex, colexicographical-colex, reverse lexicographical-revlex, and reverse clexicographical-revcolex). More... | |
| PCSet (const string sp_type, const Array1D< int > &maxOrders, const int n_dim, const string pc_type, const double alpha=0.0, const double betta=1.0) | |
| Constructor: initializes the PC basis set ordered in an HDMR fashion given order per each HDMR rank (univariate, bivariate, etc...) More... | |
| PCSet (const string sp_type, const Array2D< int > &customMultiIndex, const string pc_type, const double alpha=0.0, const double betta=1.0) | |
| Constructor: initializes the PC basis set for a given custom multiIndex. More... | |
| ~PCSet () | |
| Destructor: cleans up all memory and destroys object. More... | |
| void | dPhi_alpha (Array1D< double > &x, Array1D< int > &alpha, Array1D< double > &grad) |
| Set Gradient and Hessian operators. More... | |
| void | dPhi (Array1D< double > &x, Array2D< int > &mindex, Array1D< double > &grad, Array1D< double > &ck) |
| Evaluate Gradient at a single d-dim point. More... | |
| void | dPhi (Array2D< double > &x, Array2D< int > &mindex, Array2D< double > &grad, Array1D< double > &ck) |
| Evaluate Gradient at a multiple d-dim x points. More... | |
| void | ddPhi_alpha (Array1D< double > &x, Array1D< int > &alpha, Array2D< double > &grad) |
| Evaluate Hessian at a single d-dim point and d-dim basis polynomial. More... | |
| void | ddPhi (Array1D< double > &x, Array2D< int > &mindex, Array2D< double > &grad, Array1D< double > &ck) |
| Evaluate Gradient at a single d-dim point. More... | |
| void | SetQd1d (Array1D< double > &qdpts1d, Array1D< double > &wghts1d, int nqd) |
| Set the quadrature rule. More... | |
| void | SetQuadRule (const string grid_type, const string fs_type, int param) |
| Set the quadrature points by specifying a grid type, a full/sparse indicator, and an integer parameter. More... | |
| void | SetQuadRule (Quad &quadRule) |
| Set a custom quadrature rule by pointing to the corresponding object. More... | |
| void | PrintMultiIndex () const |
| Print information on the screen. More... | |
| void | PrintMultiIndexNormSquared () const |
| For all terms, print their multi-index and norm^2 on the screen. More... | |
| string | GetPCType () const |
| Get and set variables/arrays inline. More... | |
| double | GetAlpha () const |
| Get the value of the parameter alpha. More... | |
| double | GetBeta () const |
| Get the value of the parameter beta. More... | |
| void | GetMultiIndex (Array2D< int > &mindex) const |
| Get the multiindex (return Array2D) More... | |
| void | GetMultiIndex (int *mindex) const |
| Get the multiindex (return double *) More... | |
| void | GetNormSq (Array1D< double > &normsq) const |
| Get the norm-squared. More... | |
| int | GetNumberPCTerms () const |
| Get the number of terms in a PC expansion of this order and dimension. More... | |
| int | GetNDim () const |
| Get the PC dimensionality. More... | |
| int | GetOrder () const |
| Get the PC order. More... | |
| int | GetNQuadPoints () const |
| Get the number of quadrature points. More... | |
| void | GetQuadPoints (Array2D< double > &quad) const |
| Get the quadrature points. More... | |
| void | GetQuadPointsWeights (Array2D< double > &quad, Array1D< double > &wghts) const |
| Get the quadrature points and weights. More... | |
| void | GetQuadPoints (double *quad) const |
| Get the quadrature points folded into a one-dimensional array quad. More... | |
| void | GetQuadWeights (Array1D< double > &wghts) const |
| Get the quadrature weights. More... | |
| void | GetQuadWeights (double *wghts) const |
| Get the quadrature weights folded into a one-dimensional array wghts. More... | |
| void | GetPsi (Array2D< double > &psi) const |
| Get the values of the basis polynomials evaluated at the quadrature points. More... | |
| void | GetPsi (double *psi) const |
| Get the polynomials evaluated at the quadrature points folded into a one-dimensional array psi. More... | |
| void | GetPsiSq (Array1D< double > &psisq) const |
| Get the basis polynomial norms-squared in an array class object psisq. More... | |
| void | GetPsiSq (double *psisq) const |
| Get the basis polynomial norms-squared in a double* array psisq. More... | |
| double | GetTaylorTolerance () const |
| Get relative tolerance for Taylor series approximations. More... | |
| void | SetTaylorTolerance (const double &rTol) |
| Set relative tolerance for Taylor series approximations. More... | |
| int | GetTaylorTermsMax () const |
| Get maximum number of terms in Taylor series approximations. More... | |
| void | SetTaylorTermsMax (const int &maxTerm) |
| Set maximum number of terms in Taylor series approximations. More... | |
| void | SetLogCompMethod (const LogCompMethod &logMethod) |
| Set method of computing the log function. More... | |
| double | GetGMRESDivTolerance () const |
| Get relative tolerance for GMRES in Div routine. More... | |
| void | SetGMRESDivTolerance (const double &rTol) |
| Set the relative tolerance for GMRES in Div routine. More... | |
| void | InitMeanStDv (const double &m, const double &s, double *p) const |
| Intrusive arithmetics. More... | |
| void | InitMeanStDv (const double &m, const double &s, Array1D< double > &p) const |
| Initializes a PC expansion p in Array1D<double> format to have the same distribution as the underlying PC germ, but with a specified mean m and standard deviation s. More... | |
| void | Copy (double *p1, const double *p2) const |
| Copy PC expansion p2 into p1 (i.e. p1 = p2). More... | |
| void | Copy (Array1D< double > &p1, const Array1D< double > &p2) const |
| Copy PC expansion p2 into p1 (i.e. p1 = p2). More... | |
| void | Add (const double *p1, const double *p2, double *p3) const |
| Add two PC expansions given by double* arguments p1 and p2, and return the result in p3. More... | |
| void | Add (const Array1D< double > &p1, const Array1D< double > &p2, Array1D< double > &p3) const |
| Add two PC expansions given by Array1D arguments p1 and p2, and return the result in p3. More... | |
| void | AddInPlace (double *p1, const double *p2) const |
| Add PC expansions given by double* argument p2 to p1 and return the result in p1. More... | |
| void | AddInPlace (Array1D< double > &p1, const Array1D< double > &p2) const |
| Add PC expansions given by Array1D argument p2 to p1 and return the result in p1. More... | |
| void | Multiply (const double *p1, const double &a, double *p2) const |
| Multiply PC expansion p1 with scalar a and return the result in p2. All PCEs are in double* format. More... | |
| void | Multiply (const Array1D< double > &p1, const double &a, Array1D< double > &p2) const |
| Multiply PC expansion p1 with scalar a and return the result in p2. All PCEs are in Array1D format. More... | |
| void | MultiplyInPlace (double *p1, const double &a) const |
| Multiply PC expansions given by double* argument p1 with scalar a and return the result in p1. More... | |
| void | MultiplyInPlace (Array1D< double > &p1, const double &a) const |
| Multiply PC expansions given by Array1D argument p1 with scalar a and return the result in p1. More... | |
| void | Subtract (const double *p1, const double *p2, double *p3) const |
| Subtract PC expansion p2 from p1, and return the result in p3, with all arguments given as double*. More... | |
| void | Subtract (const Array1D< double > &p1, const Array1D< double > &p2, Array1D< double > &p3) const |
| Subtract PC expansion p2 from p1, and return the result in p3, with all arguments given as Array1D structures. More... | |
| void | SubtractInPlace (double *p1, const double *p2) const |
| Subtract PC expansion p2 from p1, and return the result in p1, with all arguments given as double*. More... | |
| void | SubtractInPlace (Array1D< double > &p1, const Array1D< double > &p2) const |
| Subtract PC expansion p2 from p1, and return the result in p1, with all arguments given as Array1D structures. More... | |
| void | Prod (const double *p1, const double *p2, double *p3) const |
| Multiply two PC expansions given by double* arguments p1 and p2, and return the result in p3. More... | |
| void | Prod (const Array1D< double > &p1, const Array1D< double > &p2, Array1D< double > &p3) const |
| Multipy two PC expansions given by Array1D arguments p1 and p2, and return the result in p3. More... | |
| void | Prod3 (const double *p1, const double *p2, const double *p3, double *p4) const |
| Multiply three PC expansions given by double* arguments p1, p2, and p3, and return the result in p4. More... | |
| void | Prod3 (const Array1D< double > &p1, const Array1D< double > &p2, const Array1D< double > &p3, Array1D< double > &p4) const |
| Multipy three PC expansions given by Array1D arguments p1, p2, and p3, and return the result in p4. More... | |
| void | Polyn (const double *polycf, int npoly, const double *p1, double *p2) const |
| Evaluates a polynomial of PC that is given in double* argument p1. Polynomial coefficients are given in double* argument polycf of size npoly. The output PC is contained in double* argument p2. More... | |
| void | Polyn (const Array1D< double > &polycf, const Array1D< double > &p1, Array1D< double > &p2) const |
| Evaluates a polynomial of PC that is given by Array1D argument p1. Polynomial coefficients are given in the Array1D argument polycf. The output PC is contained in Array1D argument p2. More... | |
| void | PolynMulti (const Array1D< double > &polycf, const Array2D< int > &mindex, const Array2D< double > &p1, Array1D< double > &p2) const |
| Evaluates a multivariate polynomial of a set of PC inputs given by Array2D argument p1 (each column of p1 is a PC input). Polynomial coefficients are given in Array1D argument polycf. Multiindex set for the multivariate polynomial is given in Array2D argument mindex. The output PC is contained in Array1D argument p2. More... | |
| void | Exp (const double *p1, double *p2) const |
| Take the exp() of the PC expansion given by double* argument p1, and return the result in p2. More... | |
| void | Exp (const Array1D< double > &p1, Array1D< double > &p2) const |
| Take the exp() of the PC expansion given by Array1D argument p1, and return the result in p2. More... | |
| void | Log (const double *p1, double *p2) const |
| Take the natural logarithm log() of the PC expansion given by double* argument p1, and return the result in p2. The logarithm is evaluated either via Taylor series or via integration depending on the value of parameter logMethod_. More... | |
| void | Log (const Array1D< double > &p1, Array1D< double > &p2) const |
| Take the natural logarithm, log(), of the PC expansion given by Array1D argument p1, and return the result in Array1D argument p2. More... | |
| void | Log10 (const double *p1, double *p2) const |
| Take the logarithm to base 10 of the PC expansion given by double* argument p1, and return the result in p2. More... | |
| void | Log10 (const Array1D< double > &p1, Array1D< double > &p2) const |
| Take the logarithm to base 10 of the PC expansion given by Array1D argument p1, and return the result in Array1D argument p2. More... | |
| void | RPow (const double *p1, double *p2, const double &a) const |
| Evaluate power a (a real number) of PC expansion given by double* argument p1, and return the result in p2. The power is computed as p1^a = exp(a*log(p1)), where log(p1) is evaluated either via Taylor series or via integration depending on the value of parameter logMethod_. More... | |
| void | RPow (const Array1D< double > &p1, Array1D< double > &p2, const double &a) const |
| Evaluate power a (a real number) of PC expansion given by Array1D argument p1, and return the result in Array1D argument p2. More... | |
| void | IPow (const double *p1, double *p2, const int &ia) const |
| Evaluate power ia (an integer number) of PC expansion given by double* argument p1, and return the result in p2. More... | |
| void | IPow (const Array1D< double > &p1, Array1D< double > &p2, const int &ia) const |
| Evaluate power ia (an integer number) of PC expansion given by Array1D argument p1, and return the result in Array1D argument p2. More... | |
| void | Inv (const double *p1, double *p2) const |
| Evaluate the inverse of PC expansion given by double* argument p1, and return the result in p2. The inverse is computed using the division function. More... | |
| void | Inv (const Array1D< double > &p1, Array1D< double > &p2) const |
| Evaluate the inverse of PC expansion given by Array1D argument p1, and return the result in Array1D argument p2. More... | |
| void | Div (const double *p1, const double *p2, double *p3) const |
| Divide the PC expansion p1 by p2, and return the result in p3 (All arguments in double* format) More... | |
| void | Div (const Array1D< double > &p1, const Array1D< double > &p2, Array1D< double > &p3) const |
| Divide the PC expansion p1 by p2, and return the result in p3 (All arguments in Array1D<double> format) More... | |
| double | StDv (const double *p) const |
| Returns the standard deviation of PC expansion p in a double* format. More... | |
| double | StDv (const Array1D< double > &p) const |
| Returns the standard deviation of PC expansion p (Argument in Array1D<double> format) More... | |
| double | GetModesRMS (const double *p) const |
| Compute the rms average of the PC coefficients (i.e. the square root of the average of the square of the PC coefficients, not taking into account any basis functions). (Arguments in double* format) More... | |
| double | GetModesRMS (const Array1D< double > &p) const |
| Compute the rms average of the PC coefficients (i.e. the square root of the average of the square of the PC coefficients, not taking into account any basis functions). (Arguments in Array1D<double> format) More... | |
| void | Derivative (const double *p1, double *p2) const |
| Computes derivatives of univariate PC given by coefficients p1 returns coefficient vector of the derivative in p2. More... | |
| void | Derivative (const Array1D< double > &p1, Array1D< double > &p2) const |
| Computes derivatives of univariate PC given by coefficients p1 returns coefficient vector of the derivative in p2. More... | |
| int | GetNumTripleProd () const |
| Returns number of triple products. More... | |
| void | GetTripleProd (int *nTriple, int *iProd, int *jProd, double *Cijk) const |
| Returns triple products indices (int*/double* version) More... | |
| void | GetTripleProd (Array1D< int > &nTriple, Array1D< int > &iProd, Array1D< int > &jProd, Array1D< double > &Cijk) const |
| Returns triple products indices (Array version) More... | |
| int | GetNumQuadProd () const |
| Returns number of quad products. More... | |
| void | GetQuadProd (int *nQuad, int *iProd, int *jProd, int *kProd, double *Cijkl) const |
| Returns quad products indices (int*/double* version) More... | |
| void | GetQuadProd (Array1D< int > &nQuad, Array1D< int > &iProd, Array1D< int > &jProd, Array1D< int > &kProd, Array1D< double > &Cijkl) const |
| Returns quad products indices (Array version) More... | |
| void | SeedBasisRandNumGen (const int &seed) const |
| Random sample generator functions. More... | |
| void | DrawSampleSet (const Array1D< double > &p, Array1D< double > &samples) |
| Draw a set of samples from the PC expansion p, and return the result in the array samples. All arguments are in Array1D<double> format The number of samples requested is assumed to be the size of the samples array. More... | |
| void | DrawSampleSet (const double *p, double *samples, const int &nSamples) |
| Draw a set of samples from the PC expansion given in double* argument p, and return the result in double* array samples. The number of samples requested is the argument nSamples. More... | |
| void | DrawSampleVar (Array2D< double > &samples) const |
| Draw a set of samples of the underlying germ random variable. More... | |
| void | DrawSampleVar (double *samples, const int &nS, const int &nD) const |
| double | EvalPC (const Array1D< double > &p, Array1D< double > &randVarSamples) |
| PC evaluation functionalities. More... | |
| double | EvalPC (const double *p, const double *randVarSamples) |
| Evaluate the given PC expansion p, at the specified values of the random variables, randVarSamples. All arguments in const double* format. More... | |
| void | EvalPCAtCustPoints (Array1D< double > &xch, Array2D< double > &custPoints, Array1D< double > &p) |
| Evaluate the given PC expansion at given set of points with given coefficient vector and return the values in an 1D Array in the first argument. More... | |
| void | EvalBasisAtCustPts (const Array2D< double > &custPoints, Array2D< double > &psi) |
| Evaluate Basis Functions at given points custPoints and return in the array psi. More... | |
| void | EvalBasisAtCustPts (const double *custPoints, const int npts, double *psi) |
| void | GalerkProjection (const Array1D< double > &fcn, Array1D< double > &ck) |
| Galerkin projection functionalities. More... | |
| void | GalerkProjectionMC (const Array2D< double > &x, const Array1D< double > &fcn, Array1D< double > &ck) |
| Galerkin Projection via Monte-Carlo integration. More... | |
| int | ComputeOrders (Array1D< int > &orders) |
| Multiindex parsing functionalities. More... | |
| int | ComputeEffDims (int *effdim) |
| Computes the effective dimensionality of each basis term, i.e., the number of dimensions that enter with a non-zero degree. also returns the maximal dimensionality among all basis terms. More... | |
| int | ComputeEffDims (Array1D< int > &effdim) |
| Computes the effective dimensionality of each basis term, i.e., the number of dimensions that enter with a non-zero degree. also returns the maximal dimensionality among all basis terms. More... | |
| void | EncodeMindex (Array1D< Array2D< int > > &sp_mindex) |
| Encode multiIndex into a 'sparse' format where the bases are ordered by their effective dimensionality. The i-th element in sp_mindex stores all the bases that have effective dimensionality equal to i. Also, only non-zero components are stored. More... | |
| double | ComputeMean (const double *coef) |
| Moment/sensitivity extraction given coefficients. More... | |
| double | ComputeMean (Array1D< double > &coef) |
| Compute the mean of the PC given coefficient array coef(seeking the zero-th order multiindex) More... | |
| double | ComputeVarFrac (const double *coef, double *varfrac) |
| Compute the variance fractions of each basis term given coefficients in double *coef; returns the variance fractions in the double *varfrac. More... | |
| double | ComputeVarFrac (Array1D< double > &coef, Array1D< double > &varfrac) |
| Compute the variance fractions of each basis term given coefficient array coef; returns the variance fractions in the array varfrac. More... | |
| void | ComputeMainSens (Array1D< double > &coef, Array1D< double > &mainsens) |
| Compute main effect sensitivity (Sobol) indices given coefficient array coef; returns the indices in the array mainsens. More... | |
| void | ComputeTotSens (Array1D< double > &coef, Array1D< double > &totsens) |
| Compute total effect sensitivity (Sobol) indices given coefficient array coeff; returns the indices in the array totsens. More... | |
| void | ComputeJointSens (Array1D< double > &coef, Array2D< double > &jointsens) |
| Compute joint effect sensitivity (Sobol) indices given coefficient array coeff; returns the indices in the array jointsens. More... | |
| void | SetVerbosity (int verbosity) |
| Other. More... | |
| void | EvalNormSq (Array1D< double > &normsq) |
| Evaluate norms-squared of all bases and return in the array normsq. More... | |
| void | EvalNormSq (double *normsq, const int npc) |
| void | EvalNormSqExact (Array1D< double > &normsq) |
| Evaluate norms-squared analytically of all bases and return in the array normsq. More... | |
| bool | IsInDomain (double x) |
| Check if the point x is in the PC domain. More... | |
Private Types | |
| typedef std::map< int, PCSet * > | OMap_t |
| Definition of a map to connect integer indexes with pointers to this class. More... | |
Private Member Functions | |
| PCSet () | |
| Dummy default constructor, which should not be used as it is not well defined Therefore we make it private so it is not accessible. More... | |
| PCSet (const PCSet &obj) | |
| Dummy copy constructor, which should not be used as it is currently not well defined. Therefore we make it private so it is not accessible. More... | |
| void | ComputeMaxOrdPerDim () |
| Compute maximal order per dimension and fill in the array maxOrdPerDim_. More... | |
| void | Initialize (const string ordertype) |
| Initialization of the appropriate variables. More... | |
| void | InitISP () |
| Initialize quadrature for computing triple products(ISP) and orthogonal projection(NISP) More... | |
| void | InitNISP () |
| Initialize variables that are needed only in non-intrusive computations. More... | |
| void | EvalBasisProd3 () |
| Evaluate the expectation of product of three basis functions. More... | |
| void | EvalBasisProd4 () |
| Evaluate the expectation of product of four basis functions. More... | |
| void | GMRESMatrixVectorProd (const double *x, const double *a, double *y) const |
| Actual C++ implementation of the matric vector multiplication for GMRES for the division operation. More... | |
| void | LogTaylor (const double *p1, double *p2) const |
| Computes natural logarithm using Taylor expansion: N p2 = ln(p1) = ln(p1Mean) + sum d n=1 n. More... | |
| void | LogInt (const double *p1, double *p2) const |
| Computes natural logarithm by numerical integration: calculate p2=ln(p1) by integrating du=dx/x to get ln(x) More... | |
| int | LogIntRhs (realtype t, N_Vector y, N_Vector ydot, void *f_data) const |
| Evaluates rhs necessary to compute natural logarithm via integration. More... | |
| int | Check_CVflag (void *flagvalue, const char *funcname, int opt) const |
| Check cvode return for errors. More... | |
Static Private Member Functions | |
| static void | GMRESMatrixVectorProdWrapper (int *n, double *x, double *y, int *nelt, int *ia, int *ja, double *a, int *obj) |
| Wrapper for Matrix-vector multiplication routine to be called by GMRES. More... | |
| static void | GMRESPreCondWrapper (int *n, double *r, double *z, int *nelt, int *ia, int *ja, double *a, int *obj, double *rwork, int *iwork) |
| Wrapper for preconditioner routine to be called by GMRES. More... | |
| static int | LogIntRhsWrapper (realtype t, N_Vector y, N_Vector ydot, void *f_data) |
| Wrapper for LogIntRhs. The first component of f_data pointer carries an integer handle identifying the appropriate PC object. More... | |
Private Attributes | |
| int | uqtkverbose_ |
| Verbosity level. More... | |
| string | spType_ |
| String indicator of ISP or NISP implementation type. More... | |
| string | pcType_ |
| String indicator of PC type. More... | |
| string | pcSeq_ |
| String indicator of multiindex ordering. More... | |
| PCBasis * | p_basis_ |
| Pointer to the class that defines the basis type and functions. More... | |
| int | order_ |
| Order of the PC representation. More... | |
| int | maxorddim_ |
| Maximal order within all dimensions. More... | |
| Array1D< int > | maxOrders_ |
| Array of maximum orders requested if custom(HDMR) ordering is requested. More... | |
| Array1D< int > | maxOrdPerDim_ |
| Array of maximum orders per dimension. More... | |
| const int | nDim_ |
| Number of stochastic dimensions (degrees of freedom) in the PC representation. More... | |
| int | nQuadPoints_ |
| Number of quadrature points used. More... | |
| int | nPCTerms_ |
| Total number of terms in the PC expansions. More... | |
| double | rTolTaylor_ |
| Relative tolerance for Taylor series approximations. More... | |
| int | maxTermTaylor_ |
| Max number of terms in Taylor series approximations. More... | |
| double | SMALL_ |
| Tolerance to avoid floating-point errors. More... | |
| double | rTolGMRESDiv_ |
| GMRES tolerance in Div() More... | |
| Array2D< double > | psi_ |
| Array to store basis functions evaluated at quadrature points for each order: psi_(iqp,ipc) contains the value of the polynomial chaos ipc-th basis at the location of quadrature point iqp. More... | |
| Array1D< double > | psiSq_ |
| Array with the norms squared of the basis functions, corresponding to each term in the PC expansion. More... | |
| Array2D< double > | quadPoints_ |
| Array to store quadrature points. More... | |
| Array1D< double > | quadWeights_ |
| Array to store quadrature weights. More... | |
| Array2D< int > | quadIndices_ |
| Array to store quadrature point indexing; useful for nested rules. More... | |
| Array2D< int > | multiIndex_ |
| Array to store multi-index: multiIndex_(ipc,idim) contains the order of the basis function associated with dimension idim, for the ipc-th term in the PC expansion. More... | |
| Array1D< Array1D< int > > | iProd2_ |
| i-indices of <\Psi_i \Psi_j \Psi_k> terms that are not zero, for all k More... | |
| Array1D< Array1D< int > > | jProd2_ |
| j-indices of <\Psi_i \Psi_j \Psi_k> terms that are not zero, for all k More... | |
| Array1D< Array1D< double > > | psiIJKProd2_ |
| <\Psi_i \Psi_j \Psi_k> terms that are not zero, for all k More... | |
| Array1D< Array1D< int > > | iProd3_ |
| i-indices of <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l More... | |
| Array1D< Array1D< int > > | jProd3_ |
| j-indices of <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l More... | |
| Array1D< Array1D< int > > | kProd3_ |
| k-indices of <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l More... | |
| Array1D< Array1D< double > > | psiIJKLProd3_ |
| <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l More... | |
| LogCompMethod | logMethod_ |
| Flag for method to compute log: TaylorSeries or Integration. More... | |
| int | CVmaxord_ |
| CVODE parameter: maximal order. More... | |
| int | CVmaxnumsteps_ |
| CVODE parameter: maximal number of steps. More... | |
| double | CVinitstep_ |
| CVODE parameter: initial step size. More... | |
| double | CVmaxstep_ |
| CVODE parameter: maximal step size. More... | |
| double | CVrelt_ |
| CVODE parameter: relative tolerance. More... | |
| double | CVabst_ |
| CVODE parameter: absolute tolerance. More... | |
| int | my_index_ |
| Index of this class. More... | |
| int | narg_ |
| Number of free parameters to specify the basis. More... | |
| double | alpha_ |
| Parameter alpha for PCs that require a parameter (LG,SW,JB) More... | |
| double | beta_ |
| Parameter beta for PCs that require two parameters (SW,JB) More... | |
Static Private Attributes | |
| static int | next_index_ = 0 |
| index of next object in map More... | |
| static OMap_t * | omap_ = NULL |
| Map to connect integer indexes with pointers to this class. More... | |
Defines and initializes PC basis function set and provides functions to manipulate PC expansions defined on this basis set.
|
private |
Definition of a map to connect integer indexes with pointers to this class.
| PCSet::PCSet | ( | const string | sp_type, |
| const int | order, | ||
| const int | n_dim, | ||
| const string | pc_type, | ||
| const double | alpha = 0.0 , |
||
| const double | betta = 1.0 |
||
| ) |
Constructor: initializes the PC basis set for the order, number of dimensions and type that are passed in.
Implementation type sp_type has three options "ISP" (intrusive methods), "NISP" (non-intrusive), or "NISPnoq" (non-intrusive without quadrature initialization)
| PCSet::PCSet | ( | const string | sp_type, |
| const int | order, | ||
| const int | n_dim, | ||
| const string | pc_type, | ||
| const string | pc_seq, | ||
| const double | alpha = 0.0 , |
||
| const double | betta = 1.0 |
||
| ) |
Constructor: initializes the PC basis set for the order, number of dimensions and type that are passed in. It also customizes the multiindex sequence ( lexicographical-lex, colexicographical-colex, reverse lexicographical-revlex, and reverse clexicographical-revcolex).
Implementation type sp_type has three options "ISP" (intrusive methods), "NISP" (non-intrusive), or "NISPnoq" (non-intrusive without quadrature initialization)
| PCSet::PCSet | ( | const string | sp_type, |
| const Array1D< int > & | maxOrders, | ||
| const int | n_dim, | ||
| const string | pc_type, | ||
| const double | alpha = 0.0 , |
||
| const double | betta = 1.0 |
||
| ) |
Constructor: initializes the PC basis set ordered in an HDMR fashion given order per each HDMR rank (univariate, bivariate, etc...)
Implementation type sp_type has three options "ISP" (intrusive methods), "NISP" (non-intrusive), or "NISPnoq" (non-intrusive without quadrature initialization)
| PCSet::PCSet | ( | const string | sp_type, |
| const Array2D< int > & | customMultiIndex, | ||
| const string | pc_type, | ||
| const double | alpha = 0.0 , |
||
| const double | betta = 1.0 |
||
| ) |
Constructor: initializes the PC basis set for a given custom multiIndex.
Implementation type sp_type has three options "ISP" (intrusive methods), "NISP" (non-intrusive), or "NISPnoq" (non-intrusive without quadrature initialization)
| PCSet::~PCSet | ( | ) |
Destructor: cleans up all memory and destroys object.
|
inlineprivate |
Dummy default constructor, which should not be used as it is not well defined Therefore we make it private so it is not accessible.
|
inlineprivate |
Dummy copy constructor, which should not be used as it is currently not well defined. Therefore we make it private so it is not accessible.
| void PCSet::Add | ( | const Array1D< double > & | p1, |
| const Array1D< double > & | p2, | ||
| Array1D< double > & | p3 | ||
| ) | const |
Add two PC expansions given by Array1D arguments p1 and p2, and return the result in p3.
| void PCSet::Add | ( | const double * | p1, |
| const double * | p2, | ||
| double * | p3 | ||
| ) | const |
Add two PC expansions given by double* arguments p1 and p2, and return the result in p3.
Add PC expansions given by Array1D argument p2 to p1 and return the result in p1.
| void PCSet::AddInPlace | ( | double * | p1, |
| const double * | p2 | ||
| ) | const |
Add PC expansions given by double* argument p2 to p1 and return the result in p1.
|
private |
Check cvode return for errors.
| int PCSet::ComputeEffDims | ( | Array1D< int > & | effdim | ) |
Computes the effective dimensionality of each basis term, i.e., the number of dimensions that enter with a non-zero degree. also returns the maximal dimensionality among all basis terms.
| int PCSet::ComputeEffDims | ( | int * | effdim | ) |
Computes the effective dimensionality of each basis term, i.e., the number of dimensions that enter with a non-zero degree. also returns the maximal dimensionality among all basis terms.
Compute joint effect sensitivity (Sobol) indices given coefficient array coeff; returns the indices in the array jointsens.
Compute main effect sensitivity (Sobol) indices given coefficient array coef; returns the indices in the array mainsens.
|
private |
Compute maximal order per dimension and fill in the array maxOrdPerDim_.
| double PCSet::ComputeMean | ( | Array1D< double > & | coef | ) |
Compute the mean of the PC given coefficient array coef(seeking the zero-th order multiindex)
| double PCSet::ComputeMean | ( | const double * | coef | ) |
Moment/sensitivity extraction given coefficients.
Compute the mean of the PC given coefficients in double *coef (seeking the zero-th order multiindex)
| int PCSet::ComputeOrders | ( | Array1D< int > & | orders | ) |
Multiindex parsing functionalities.
Computes the order of each basis term and return it in the array orders, also returns the maximal order
Compute total effect sensitivity (Sobol) indices given coefficient array coeff; returns the indices in the array totsens.
Compute the variance fractions of each basis term given coefficient array coef; returns the variance fractions in the array varfrac.
| double PCSet::ComputeVarFrac | ( | const double * | coef, |
| double * | varfrac | ||
| ) |
Compute the variance fractions of each basis term given coefficients in double *coef; returns the variance fractions in the double *varfrac.
Copy PC expansion p2 into p1 (i.e. p1 = p2).
All arguments in Array format
| void PCSet::Copy | ( | double * | p1, |
| const double * | p2 | ||
| ) | const |
Copy PC expansion p2 into p1 (i.e. p1 = p2).
All arguments in double* format.
| void PCSet::ddPhi | ( | Array1D< double > & | x, |
| Array2D< int > & | mindex, | ||
| Array2D< double > & | grad, | ||
| Array1D< double > & | ck | ||
| ) |
Evaluate Gradient at a single d-dim point.
for a PCSet object
Evaluate Hessian at a single d-dim point and d-dim basis polynomial.
Computes derivatives of univariate PC given by coefficients p1 returns coefficient vector of the derivative in p2.
Supports LU and HG bases only
Supports only for 1d PCs
| void PCSet::Derivative | ( | const double * | p1, |
| double * | p2 | ||
| ) | const |
Computes derivatives of univariate PC given by coefficients p1 returns coefficient vector of the derivative in p2.
Supports LU and HG bases only
Supports only for 1d PCs
| void PCSet::Div | ( | const Array1D< double > & | p1, |
| const Array1D< double > & | p2, | ||
| Array1D< double > & | p3 | ||
| ) | const |
Divide the PC expansion p1 by p2, and return the result in p3 (All arguments in Array1D<double> format)
| void PCSet::Div | ( | const double * | p1, |
| const double * | p2, | ||
| double * | p3 | ||
| ) | const |
Divide the PC expansion p1 by p2, and return the result in p3 (All arguments in double* format)
The "division" p3 = p1/p2 is performed by solving the system of equations p2*p3 = p1 for the unknown p3.
| void PCSet::dPhi | ( | Array1D< double > & | x, |
| Array2D< int > & | mindex, | ||
| Array1D< double > & | grad, | ||
| Array1D< double > & | ck | ||
| ) |
Evaluate Gradient at a single d-dim point.
for a PCSet object
| void PCSet::dPhi | ( | Array2D< double > & | x, |
| Array2D< int > & | mindex, | ||
| Array2D< double > & | grad, | ||
| Array1D< double > & | ck | ||
| ) |
Evaluate Gradient at a multiple d-dim x points.
for a PCSet object
Set Gradient and Hessian operators.
Evaluate Gradient at a single d-dim point and d-dim basis polynomial
Draw a set of samples from the PC expansion p, and return the result in the array samples. All arguments are in Array1D<double> format The number of samples requested is assumed to be the size of the samples array.
| void PCSet::DrawSampleSet | ( | const double * | p, |
| double * | samples, | ||
| const int & | nSamples | ||
| ) |
Draw a set of samples from the PC expansion given in double* argument p, and return the result in double* array samples. The number of samples requested is the argument nSamples.
| void PCSet::DrawSampleVar | ( | Array2D< double > & | samples | ) | const |
Draw a set of samples of the underlying germ random variable.
| void PCSet::DrawSampleVar | ( | double * | samples, |
| const int & | nS, | ||
| const int & | nD | ||
| ) | const |
Encode multiIndex into a 'sparse' format where the bases are ordered by their effective dimensionality. The i-th element in sp_mindex stores all the bases that have effective dimensionality equal to i. Also, only non-zero components are stored.
Evaluate Basis Functions at given points custPoints and return in the array psi.
| void PCSet::EvalBasisAtCustPts | ( | const double * | custPoints, |
| const int | npts, | ||
| double * | psi | ||
| ) |
|
private |
Evaluate the expectation of product of three basis functions.
|
private |
Evaluate the expectation of product of four basis functions.
| void PCSet::EvalNormSq | ( | Array1D< double > & | normsq | ) |
Evaluate norms-squared of all bases and return in the array normsq.
| void PCSet::EvalNormSq | ( | double * | normsq, |
| const int | npc | ||
| ) |
| void PCSet::EvalNormSqExact | ( | Array1D< double > & | normsq | ) |
Evaluate norms-squared analytically of all bases and return in the array normsq.
PC evaluation functionalities.
Evaluate the given PC expansion p, at the specified values of the random variables, randVarSamples. All arguments in const Array1D<double> format
| double PCSet::EvalPC | ( | const double * | p, |
| const double * | randVarSamples | ||
| ) |
Evaluate the given PC expansion p, at the specified values of the random variables, randVarSamples. All arguments in const double* format.
| void PCSet::EvalPCAtCustPoints | ( | Array1D< double > & | xch, |
| Array2D< double > & | custPoints, | ||
| Array1D< double > & | p | ||
| ) |
Evaluate the given PC expansion at given set of points with given coefficient vector and return the values in an 1D Array in the first argument.
Take the exp() of the PC expansion given by Array1D argument p1, and return the result in p2.
| void PCSet::Exp | ( | const double * | p1, |
| double * | p2 | ||
| ) | const |
Take the exp() of the PC expansion given by double* argument p1, and return the result in p2.
Relies on Taylor series expansion: exp(x) = 1 + x + x^2/2! + x^3/3! + ... However, for efficiency and to avoid overflow, the terms are computed as d_i = d_{i-1}*x/i. Also, to reduce the number of terms needed in the series, we subtract the mean out of a random variable u as u = u_0 + (u-u_0) and exp(u) = exp(u_0)*exp(u-u_0), where exp(u_0) can be computed with the regular exp(double& ) function
Galerkin projection functionalities.
Performs (NISP) Galerkin projection, given function evaluations at quadrature points Returns in the coefficient vector in the second argument
Overload this with forward function pointers
There is no double* version of this function
| void PCSet::GalerkProjectionMC | ( | const Array2D< double > & | x, |
| const Array1D< double > & | fcn, | ||
| Array1D< double > & | ck | ||
| ) |
Galerkin Projection via Monte-Carlo integration.
Overload this with forward function pointers
There is no double* version of this function
|
inline |
Get the value of the parameter alpha.
|
inline |
Get the value of the parameter beta.
|
inline |
Get relative tolerance for GMRES in Div routine.
| double PCSet::GetModesRMS | ( | const Array1D< double > & | p | ) | const |
Compute the rms average of the PC coefficients (i.e. the square root of the average of the square of the PC coefficients, not taking into account any basis functions). (Arguments in Array1D<double> format)
| double PCSet::GetModesRMS | ( | const double * | p | ) | const |
Compute the rms average of the PC coefficients (i.e. the square root of the average of the square of the PC coefficients, not taking into account any basis functions). (Arguments in double* format)
|
inline |
Get the multiindex (return Array2D)
| void PCSet::GetMultiIndex | ( | int * | mindex | ) | const |
Get the multiindex (return double *)
|
inline |
Get the PC dimensionality.
|
inline |
Get the norm-squared.
|
inline |
Get the number of quadrature points.
|
inline |
Get the number of terms in a PC expansion of this order and dimension.
| int PCSet::GetNumQuadProd | ( | ) | const |
Returns number of quad products.
| int PCSet::GetNumTripleProd | ( | ) | const |
Returns number of triple products.
|
inline |
Get the PC order.
|
inline |
Get and set variables/arrays inline.
Get the PC type
|
inline |
Get the values of the basis polynomials evaluated at the quadrature points.
|
inline |
Get the polynomials evaluated at the quadrature points folded into a one-dimensional array psi.
|
inline |
Get the basis polynomial norms-squared in an array class object psisq.
|
inline |
Get the basis polynomial norms-squared in a double* array psisq.
|
inline |
Get the quadrature points.
|
inline |
Get the quadrature points folded into a one-dimensional array quad.
|
inline |
Get the quadrature points and weights.
| void PCSet::GetQuadProd | ( | Array1D< int > & | nQuad, |
| Array1D< int > & | iProd, | ||
| Array1D< int > & | jProd, | ||
| Array1D< int > & | kProd, | ||
| Array1D< double > & | Cijkl | ||
| ) | const |
Returns quad products indices (Array version)
| void PCSet::GetQuadProd | ( | int * | nQuad, |
| int * | iProd, | ||
| int * | jProd, | ||
| int * | kProd, | ||
| double * | Cijkl | ||
| ) | const |
Returns quad products indices (int*/double* version)
|
inline |
Get the quadrature weights.
|
inline |
Get the quadrature weights folded into a one-dimensional array wghts.
|
inline |
Get maximum number of terms in Taylor series approximations.
|
inline |
Get relative tolerance for Taylor series approximations.
| void PCSet::GetTripleProd | ( | Array1D< int > & | nTriple, |
| Array1D< int > & | iProd, | ||
| Array1D< int > & | jProd, | ||
| Array1D< double > & | Cijk | ||
| ) | const |
Returns triple products indices (Array version)
| void PCSet::GetTripleProd | ( | int * | nTriple, |
| int * | iProd, | ||
| int * | jProd, | ||
| double * | Cijk | ||
| ) | const |
Returns triple products indices (int*/double* version)
|
private |
Actual C++ implementation of the matric vector multiplication for GMRES for the division operation.
Given the structure of the problem, this boils down to the product between two PC variables.
|
inlinestaticprivate |
Wrapper for Matrix-vector multiplication routine to be called by GMRES.
As GMRES is a Fortran77 routine, this routine is defined as a static function. One of the function arguments (obj) was originally isym, a flag for matrix symmetry, but has been repurposed to carry an integer handle to identify this object.
|
inlinestaticprivate |
Wrapper for preconditioner routine to be called by GMRES.
As GMRES is a Fortran77 routine, this routine is defined as a static function. One of the function arguments (obj) was originally isym, a flag for matrix symmetry, but has been repurposed to carry an integer handle to identify this object.
|
private |
Initialization of the appropriate variables.
|
private |
Initialize quadrature for computing triple products(ISP) and orthogonal projection(NISP)
Initialize variables that are needed only in intrusive computations
| void PCSet::InitMeanStDv | ( | const double & | m, |
| const double & | s, | ||
| Array1D< double > & | p | ||
| ) | const |
Initializes a PC expansion p in Array1D<double> format to have the same distribution as the underlying PC germ, but with a specified mean m and standard deviation s.
| void PCSet::InitMeanStDv | ( | const double & | m, |
| const double & | s, | ||
| double * | p | ||
| ) | const |
Intrusive arithmetics.
Initializes a PC expansion p in a double* format to have the same distribution as the underlying PC germ, but with a specified mean m and standard deviation s
|
private |
Initialize variables that are needed only in non-intrusive computations.
| void PCSet::Inv | ( | const double * | p1, |
| double * | p2 | ||
| ) | const |
Evaluate the inverse of PC expansion given by double* argument p1, and return the result in p2. The inverse is computed using the division function.
| void PCSet::IPow | ( | const double * | p1, |
| double * | p2, | ||
| const int & | ia | ||
| ) | const |
Evaluate power ia (an integer number) of PC expansion given by double* argument p1, and return the result in p2.
| bool PCSet::IsInDomain | ( | double | x | ) |
Check if the point x is in the PC domain.
| void PCSet::Log | ( | const double * | p1, |
| double * | p2 | ||
| ) | const |
Take the natural logarithm log() of the PC expansion given by double* argument p1, and return the result in p2. The logarithm is evaluated either via Taylor series or via integration depending on the value of parameter logMethod_.
| void PCSet::Log10 | ( | const double * | p1, |
| double * | p2 | ||
| ) | const |
Take the logarithm to base 10 of the PC expansion given by double* argument p1, and return the result in p2.
First use Log() to compute the natural logarithm and then divide it by log(10)
|
private |
Computes natural logarithm by numerical integration: calculate p2=ln(p1) by integrating du=dx/x to get ln(x)
|
private |
Evaluates rhs necessary to compute natural logarithm via integration.
|
inlinestaticprivate |
Wrapper for LogIntRhs. The first component of f_data pointer carries an integer handle identifying the appropriate PC object.
|
private |
Computes natural logarithm using Taylor expansion: N p2 = ln(p1) = ln(p1Mean) + sum d n=1 n.
(n+1) (-1) n p1 where d = -— *x , and x = ---— - 1 n n p1Mean
| void PCSet::Multiply | ( | const Array1D< double > & | p1, |
| const double & | a, | ||
| Array1D< double > & | p2 | ||
| ) | const |
Multiply PC expansion p1 with scalar a and return the result in p2. All PCEs are in Array1D format.
| void PCSet::Multiply | ( | const double * | p1, |
| const double & | a, | ||
| double * | p2 | ||
| ) | const |
Multiply PC expansion p1 with scalar a and return the result in p2. All PCEs are in double* format.
| void PCSet::MultiplyInPlace | ( | Array1D< double > & | p1, |
| const double & | a | ||
| ) | const |
Multiply PC expansions given by Array1D argument p1 with scalar a and return the result in p1.
| void PCSet::MultiplyInPlace | ( | double * | p1, |
| const double & | a | ||
| ) | const |
Multiply PC expansions given by double* argument p1 with scalar a and return the result in p1.
| void PCSet::Polyn | ( | const double * | polycf, |
| int | npoly, | ||
| const double * | p1, | ||
| double * | p2 | ||
| ) | const |
Evaluates a polynomial of PC that is given in double* argument p1. Polynomial coefficients are given in double* argument polycf of size npoly. The output PC is contained in double* argument p2.
| void PCSet::PolynMulti | ( | const Array1D< double > & | polycf, |
| const Array2D< int > & | mindex, | ||
| const Array2D< double > & | p1, | ||
| Array1D< double > & | p2 | ||
| ) | const |
Evaluates a multivariate polynomial of a set of PC inputs given by Array2D argument p1 (each column of p1 is a PC input). Polynomial coefficients are given in Array1D argument polycf. Multiindex set for the multivariate polynomial is given in Array2D argument mindex. The output PC is contained in Array1D argument p2.
| void PCSet::PrintMultiIndex | ( | ) | const |
Print information on the screen.
Print the multi-indices for all terms on the screen
| void PCSet::PrintMultiIndexNormSquared | ( | ) | const |
For all terms, print their multi-index and norm^2 on the screen.
| void PCSet::Prod | ( | const Array1D< double > & | p1, |
| const Array1D< double > & | p2, | ||
| Array1D< double > & | p3 | ||
| ) | const |
Multipy two PC expansions given by Array1D arguments p1 and p2, and return the result in p3.
| void PCSet::Prod | ( | const double * | p1, |
| const double * | p2, | ||
| double * | p3 | ||
| ) | const |
Multiply two PC expansions given by double* arguments p1 and p2, and return the result in p3.
| void PCSet::Prod3 | ( | const Array1D< double > & | p1, |
| const Array1D< double > & | p2, | ||
| const Array1D< double > & | p3, | ||
| Array1D< double > & | p4 | ||
| ) | const |
Multipy three PC expansions given by Array1D arguments p1, p2, and p3, and return the result in p4.
| void PCSet::Prod3 | ( | const double * | p1, |
| const double * | p2, | ||
| const double * | p3, | ||
| double * | p4 | ||
| ) | const |
Multiply three PC expansions given by double* arguments p1, p2, and p3, and return the result in p4.
| void PCSet::RPow | ( | const double * | p1, |
| double * | p2, | ||
| const double & | a | ||
| ) | const |
Evaluate power a (a real number) of PC expansion given by double* argument p1, and return the result in p2. The power is computed as p1^a = exp(a*log(p1)), where log(p1) is evaluated either via Taylor series or via integration depending on the value of parameter logMethod_.
| void PCSet::SeedBasisRandNumGen | ( | const int & | seed | ) | const |
Random sample generator functions.
Reseed the random number generator used for the sampling of the PC variables and expansions
|
inline |
Set the relative tolerance for GMRES in Div routine.
|
inline |
Set method of computing the log function.
Use the argument TaylorSeries to select the Taylor series approach or Integration to select the integration method.
Set the quadrature rule.
Obtain 1d quadrature points and weights
| void PCSet::SetQuadRule | ( | const string | grid_type, |
| const string | fs_type, | ||
| int | param | ||
| ) |
Set the quadrature points by specifying a grid type, a full/sparse indicator, and an integer parameter.
Full/sparse switch fs_type can be either 'full' or 'sparse' The parameter param is the number of points per dimension for full quadrature, and the level for sparse quadrature Options for grid_type are, besides the standard PC types, 'CC' (Clenshaw-Curtis), 'CCO' (Clenshaw-Curtis open), 'NC' (Newton-Cotes), 'NCO' (Newton-Cotes open), where open means that endpoints are expluded
| void PCSet::SetQuadRule | ( | Quad & | quadRule | ) |
Set a custom quadrature rule by pointing to the corresponding object.
|
inline |
Set maximum number of terms in Taylor series approximations.
|
inline |
Set relative tolerance for Taylor series approximations.
|
inline |
Other.
Set the verbosity level
| double PCSet::StDv | ( | const Array1D< double > & | p | ) | const |
Returns the standard deviation of PC expansion p (Argument in Array1D<double> format)
| double PCSet::StDv | ( | const double * | p | ) | const |
Returns the standard deviation of PC expansion p in a double* format.
| void PCSet::Subtract | ( | const Array1D< double > & | p1, |
| const Array1D< double > & | p2, | ||
| Array1D< double > & | p3 | ||
| ) | const |
Subtract PC expansion p2 from p1, and return the result in p3, with all arguments given as Array1D structures.
| void PCSet::Subtract | ( | const double * | p1, |
| const double * | p2, | ||
| double * | p3 | ||
| ) | const |
Subtract PC expansion p2 from p1, and return the result in p3, with all arguments given as double*.
Subtract PC expansion p2 from p1, and return the result in p1, with all arguments given as Array1D structures.
| void PCSet::SubtractInPlace | ( | double * | p1, |
| const double * | p2 | ||
| ) | const |
Subtract PC expansion p2 from p1, and return the result in p1, with all arguments given as double*.
|
private |
Parameter alpha for PCs that require a parameter (LG,SW,JB)
|
private |
Parameter beta for PCs that require two parameters (SW,JB)
|
private |
CVODE parameter: absolute tolerance.
|
private |
CVODE parameter: initial step size.
|
private |
CVODE parameter: maximal number of steps.
|
private |
CVODE parameter: maximal order.
|
private |
CVODE parameter: maximal step size.
|
private |
CVODE parameter: relative tolerance.
i-indices of <\Psi_i \Psi_j \Psi_k> terms that are not zero, for all k
i-indices of <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l
j-indices of <\Psi_i \Psi_j \Psi_k> terms that are not zero, for all k
j-indices of <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l
k-indices of <\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l
|
private |
Flag for method to compute log: TaylorSeries or Integration.
|
private |
Maximal order within all dimensions.
|
private |
Array of maximum orders requested if custom(HDMR) ordering is requested.
|
private |
Array of maximum orders per dimension.
|
private |
Max number of terms in Taylor series approximations.
|
private |
Array to store multi-index: multiIndex_(ipc,idim) contains the order of the basis function associated with dimension idim, for the ipc-th term in the PC expansion.
|
private |
Index of this class.
|
private |
Number of free parameters to specify the basis.
|
private |
Number of stochastic dimensions (degrees of freedom) in the PC representation.
|
staticprivate |
index of next object in map
|
private |
Total number of terms in the PC expansions.
|
private |
Number of quadrature points used.
|
staticprivate |
Map to connect integer indexes with pointers to this class.
|
private |
Order of the PC representation.
|
private |
Pointer to the class that defines the basis type and functions.
|
private |
String indicator of multiindex ordering.
|
private |
String indicator of PC type.
|
private |
Array to store basis functions evaluated at quadrature points for each order: psi_(iqp,ipc) contains the value of the polynomial chaos ipc-th basis at the location of quadrature point iqp.
<\Psi_i \Psi_j \Psi_k \Psi_l> terms that are not zero, for all l
<\Psi_i \Psi_j \Psi_k> terms that are not zero, for all k
|
private |
Array with the norms squared of the basis functions, corresponding to each term in the PC expansion.
|
private |
Array to store quadrature point indexing; useful for nested rules.
|
private |
Array to store quadrature points.
|
private |
Array to store quadrature weights.
|
private |
GMRES tolerance in Div()
|
private |
Relative tolerance for Taylor series approximations.
|
private |
Tolerance to avoid floating-point errors.
|
private |
String indicator of ISP or NISP implementation type.
|
private |
Verbosity level.


rstWeb - Login
Create a New Login
Please enter your desired user name here (you will be notified if the name is already taken). Your password must be at least five characters long.
**new login form**


Description: Attach a handler to an event for the elements.
eventType: String A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
eventData: Object A map of data that will be passed to the event handler.
handler(eventObject): Function() A function to execute each time the event is triggered.
eventType: String A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
eventData: Object A map of data that will be passed to the event handler.
preventBubble: Boolean Setting the third argument to false will attach a function that prevents the default action from occurring and stops the event from bubbling. The default is true.
events: Object A map of one or more DOM event types and functions to execute for them.
As of jQuery 1.7, the .on()
method is the preferred method for attaching event handlers to a document. For earlier versions, the .bind()
method is used for attaching an event handler directly to elements. Handlers are attached to the currently selected elements in the jQuery object, so those elements must exist at the point the call to .bind()
occurs. For more flexible event binding, see the discussion of event delegation in .on()
or .delegate()
.
Any string is legal for eventType
; if the string is not the name of a native DOM event, then the handler is bound to a custom event. These events are never called by the browser, but may be triggered manually from other JavaScript code using .trigger()
or .triggerHandler()
.
If the eventType
string contains a period (.
) character, then the event is namespaced. The period character separates the event from its namespace. For example, in the call .bind('click.name', handler)
, the string click
is the event type, and the string name
is the namespace. Namespacing allows us to unbind or trigger some events of a type without affecting others. See the discussion of .unbind()
for more information.
There are shorthand methods for some standard browser events such as .click()
that can be used to attach or trigger event handlers. For a complete list of shorthand methods, see the events category.
When an event reaches an element, all handlers bound to that event type for the element are fired. If there are multiple handlers registered, they will always execute in the order in which they were bound. After all handlers have executed, the event continues along the normal event propagation path.
A basic usage of .bind()
is:
$('#foo').bind('click', function() {
alert('User clicked on "foo."');
});
This code will cause the element with an ID of foo
to respond to the click
event. When a user clicks inside this element thereafter, the alert will be shown.
Multiple event types can be bound at once by including each one separated by a space:
$('#foo').bind('mouseenter mouseleave', function() {
$(this).toggleClass('entered');
});
The effect of this on

(when it does not initially have the "entered" class) is to add the "entered" class when the mouse enters the

and remove the class when the mouse leaves.
As of jQuery 1.4 we can bind multiple event handlers simultaneously by passing a map of event type/handler pairs:
$('#foo').bind({
click: function() {
// do something on click
},
mouseenter: function() {
// do something on mouseenter
}
});
The handler
parameter takes a callback function, as shown above. Within the handler, the keyword this
refers to the DOM element to which the handler is bound. To make use of the element in jQuery, it can be passed to the normal $()
function. For example:
$('#foo').bind('click', function() {
alert($(this).text());
});
After this code is executed, when the user clicks inside the element with an ID of foo
, its text contents will be shown as an alert.
As of jQuery 1.4.2 duplicate event handlers can be bound to an element instead of being discarded. This is useful when the event data feature is being used, or when other unique data resides in a closure around the event handler function.
In jQuery 1.4.3 you can now pass in false
in place of an event handler. This will bind an event handler equivalent to: function(){ return false; }
. This function can be removed at a later time by calling: .unbind( eventName, false )
.
The handler
callback function can also take parameters. When the function is called, the event object will be passed to the first parameter.
The event object is often unnecessary and the parameter omitted, as sufficient context is usually available when the handler is bound to know exactly what needs to be done when the handler is triggered. However, at times it becomes necessary to gather more information about the user's environment at the time the event was initiated. View the full Event Object.
Returning false
from a handler is equivalent to calling both .preventDefault()
and .stopPropagation()
on the event object.
Using the event object in a handler looks like this:
$(document).ready(function() {
$('#foo').bind('click', function(event) {
alert('The mouse cursor is at ('
+ event.pageX + ', ' + event.pageY + ')');
});
});
Note the parameter added to the anonymous function. This code will cause a click on the element with ID foo
to report the page coordinates of the mouse cursor at the time of the click.
The optional eventData
parameter is not commonly used. When provided, this argument allows us to pass additional information to the handler. One handy use of this parameter is to work around issues caused by closures. For example, suppose we have two event handlers that both refer to the same external variable:
var message = 'Spoon!';
$('#foo').bind('click', function() {
alert(message);
});
message = 'Not in the face!';
$('#bar').bind('click', function() {
alert(message);
});
Because the handlers are closures that both have message
in their environment, both will display the message Not in the face! when triggered. The variable's value has changed. To sidestep this, we can pass the message in using eventData
:
var message = 'Spoon!';
$('#foo').bind('click', {msg: message}, function(event) {
alert(event.data.msg);
});
message = 'Not in the face!';
$('#bar').bind('click', {msg: message}, function(event) {
alert(event.data.msg);
});
This time the variable is not referred to directly within the handlers; instead, the variable is passed in by value through eventData
, which fixes the value at the time the event is bound. The first handler will now display Spoon! while the second will alert Not in the face!
Note that objects are passed to functions by reference, which further complicates this scenario.
If eventData
is present, it is the second argument to the .bind()
method; if no additional data needs to be sent to the handler, then the callback is passed as the second and final argument.
See the
.trigger()
method reference for a way to pass data to a handler at the time the event happens rather than when the handler is bound.
As of jQuery 1.4 we can no longer attach data (and thus, events) to object, embed, or applet elements because critical errors occur when attaching data to Java applets.
Note: Although demonstrated in the next example, it is inadvisable to bind handlers to both the click
and dblclick
events for the same element. The sequence of events triggered varies from browser to browser, with some receiving two click events before the dblclick
and others only one. Double-click sensitivity (maximum time between clicks that is detected as a double click) can vary by operating system and browser, and is often user-configurable.
<!DOCTYPE html>

Click or double click here.

$("p").bind("click", function(){
alert( $(this).text() );
});
function handler(event) {
alert(event.data.foo);
}
$("p").bind("click", {foo: "bar"}, handler)
$("form").bind("submit", function() { return false; })
$("form").bind("submit", function(event) {
event.preventDefault();
});
$("form").bind("submit", function(event) {
event.stopPropagation();
});
<!DOCTYPE html>

Has an attached custom event.

<button>Trigger custom event</button>

$("div.test").bind({
click: function(){
$(this).addClass("active");
},
mouseenter: function(){
$(this).addClass("inside");
},
mouseleave: function(){
$(this).removeClass("inside");
}
});


Moved to
http://jsfiddle.net/gh/get/jquery/1.7.2/highslide-software/highcharts.com/tree/master/samples/highcharts/map/election-map/


Arrays vs Hashes
november 14, 2014
Hi, the main goal of this blog is to explain people with no/or close to none background in coding what arrays and hashes are. Arrays and hashes are use to store data. That is it.
Let me jump right into it keeping it as simple as possible. When you want to tell your computer to remember something you declare a variable and assign it to what it is you want to remember. For example, age_ray= 20. So now you don't have to remember the Ray´s age, it is just sitting there stored in the value age_ray waiting for you to tell it to print it, modify it, erase it or anything you want to to with it.
But what if you want to assign a variable called my favorite numbers? Maybe these are the numbers you use in your lottery ticket? Should you set a variable name for number1= 8, number2=2 etc? The answer is no. You can use an array. To use an array you would do something like this. my_numbers= [8,2,23,26,14,18]. Now you have a variable called my_numbers that stores your lottery numbers. To set up an array you need your variable name, = sign also called assignment operator, brackets [] and commas to separate your list inside your brackets. Easy, right?
The great thing about arrays is that you can ask your computer to do tons of stuff. You can tell it to give you the first item of your list, the third, sum the values, insert values, the list goes on and on. One crucial thing to know about arrays is, that arrays store items counting from zero. In other words, if you want to see what is the first value of your list you would tell your computer print my_numbers[0]. Weird right? Arrays use an index, it starts from 0 and goes up for every value in the array. In our example above the 8 corresponds to index 0, 26 corresponds to index 3 and 2 corresponds to index _? You got this!
Now we have hashes and hashes are really similar to arrays. Remember that arrays use a numerical index that match the elements of an array. Hashes use keys and values. For example, capital_city = {:Texas => "Austin",:California => "Sacramento",}
Hashes work almost the same as arrays but instead of having a numbered index we define the key and value for each element. The keys in this example are Texas and California and the values Austin and Sacramento. If you want to access the capital city of Texas you would do print capital_city[:Texas].
If you want to read more about arrays and hashes here is the place to start
Arrays: http://ruby-doc.org/core-2.1.4/Array.html
Hashes: http://ruby-doc.org/core-2.1.4/Hash.html
Stay tuned for more,
Andy-dev —OVER AND OUT


Laurentius Tirtarahardja
About
(current)
Portfolio
Contact
Below Decks Podcast
Podcast Widget
Rose Tavern Website
RPG Game
Trivia Game
Rutgers Info Widget
Previous
Next
Connect With Me


Plugin Information |
|---|
No information for the plugin 'easyant' is available. It may have been removed from distribution. |
This plugin allows Jenkins to invoke Apache EasyAnt build script as the main build step.
Please Note
Support for Hudson has now been dropped, only Jenkins will be supported from now on.
Project Configurations
The plugin works much like Gant or Ant builder, and using it is very easy. You basically just need to specify a list of targets that you want to run.
If no targets are set, it will lauch the default target.
System Configurations
If 'easyant' binaries are not in PATH, or if you have multiple EasyAnt installations and you need to be able to configure which project uses which EasyAnt, then you can go to the system configuration and tell Jenkins where your EasyAnt are.
Changelog
Release 1.2 (unreleased)
- Update code for more recent jenkins
- Add auto installer feature
- Add new option on project configuration to specify buildModule, and buildFile
- Add console annotator
Release 1.1 (Jan 31, 2010)
- Update code for more recent Hudson
Release 1.0 (Mar 30, 2009)
- Initial release


Encapsulates the logical features of the Installer.
More...
#include <Installer.hpp>
|
| enum | ScreenEnums {
WELCOME_SCREEN,
AGREEMENT_SCREEN,
DIRECTORY_SCREEN,
Install_SCREEN,
FINISH_SCREEN,
FAIL_SCREEN,
SCREEN_COUNT
} |
| |
Encapsulates the logical features of the Installer.
◆ beginInstallation()
| void Installer::beginInstallation |
( |
| ) |
|
Install the Installer's package contents to the directory previously chosen.
◆ dumpErrorLog()
| void Installer::dumpErrorLog |
( |
| ) |
|
|
static |
◆ getDirectory()
| std::string Installer::getDirectory |
( |
| ) |
const |
Retrieves the current directory chosen for Installation.
- Returns
- active Installation directory.
◆ getDirectorySizeAvailable()
| size_t Installer::getDirectorySizeAvailable |
( |
| ) |
const |
Retrieves the remaining size of the drive used in the current directory.
- Returns
- the available size.
◆ getDirectorySizeCapacity()
| size_t Installer::getDirectorySizeCapacity |
( |
| ) |
const |
Retrieves the size of the drive used in the current directory.
- Returns
- the drive capacity.
◆ getDirectorySizeRequired()
| size_t Installer::getDirectorySizeRequired |
( |
| ) |
const |
Retrieves the required size of the uncompressed package to be Installed.
- Returns
- the (uncompressed) package size.
◆ getPackageName()
| std::string Installer::getPackageName |
( |
| ) |
const |
Retrieves the package name.
- Returns
- the package name.
◆ invalidate()
| void Installer::invalidate |
( |
| ) |
|
When called, invalidates the Installer, halting it from progressing.
◆ paint()
| void Installer::paint |
( |
| ) |
|
◆ setDirectory()
| void Installer::setDirectory |
( |
const std::string & |
directory | ) |
|
Sets a new Installation directory.
- Parameters
-
| directory | new Installation directory. |
◆ setScreen()
| void Installer::setScreen |
( |
const ScreenEnums & |
screenIndex | ) |
|
Make the screen identified by the supplied enum as active, deactivating the previous screen.
- Parameters
-
| screenIndex | the new screen to use. |
The documentation for this class was generated from the following files:
- examples/Installer/Installer.hpp
- examples/Installer/Installer.cpp


As I mentioned on my other blog, I really struggle to explain version control to non-programmers. In particular, I don't know how to communicate just how cool it is.
Rands has a go at it by explaining that it's all about capturing context. How do you explain Bazaar (or anything other version control) to the people you meet?
For programmers that are new to version control, I point them to http://www.ericsink.com/scm/source_control.html which is and excellent and comprehensive guide to version control. It is pre-dvcs, so it could do with an update.


llamatest
Home
Project Feed
New Project
About
Sign In
llamatest
Home
Project Feed
profile
New Project
About
Sign In
File
company Name
Project Name
Textarea
Publish


SABRIN NASREDDIN
I'm a front end engineer. Have a look at my projects to see what I've been working on
RESUME CONTACT
PROFILE
EXPERIENCE
EDUCATION
BLOGS
SOCIAL MEDIA
CONTACT
PORTFOLIO


You are not currently installing any applications, and now go to theapplication store to find practical, interesting application!
You are not currently installing any applications, and now go to theapplication store to find practical, interesting application!


Super Stock racing boats flip and crash simultaneously in dramatic video
KEY WEST, Fla. -- Spectators gasped as they watched two racing boats crash and flip over at the same time during the first day of the Race World Offshore World Championships in Key West, Florida.
The two powerful boats were racing side by side on the course when the double Super Stock crash occurred. Race teams for these boats consist of a two-person team - a driver who controls the boat's steering and a throttleman responsible for operating the engines.
According to Race World Offshore, everyone in the two teams involved are okay.
Race World Offshore also posted an injury update that confirms "All four racers extricated themselves from the boats following the accident and were all conscious and alert."


To view the report result, go to the Build Artifacts, download the zipped report, and unzip it.
In the HP Run Results Viewer select File > Open. Select "Results XML file" and navigate to the Results.xml file in the folder that you unzipped.
This is only valid when using the "Execute HP test from file system" build step.


So, since I got involved with bidbots I’ve had to also start talking a lot about curation. Curation is a hot topic item and it goes hand in hand with curation and delegation because all of these things impact the rewards that are paid out on a daily basis. There are people saying curation is broken, and it’s tough to know how to answer that… but I want to share a little about how curation works especially in an account lifecycle.
Dividends
One of my favorite ways to view curation rewards is through the lens of dividends. If you own certain types of stock (or crypto) they will pay you dividends. This is a return on your investment paid by the company as an incentive to continue to hold that investment. Steem has this through inflation. Every year a little less than 10% of total steem in existence will be added to the Steem economy. The blockchain generates new coins through inflation, and then distributes those new coins from inflation into the rewards pool. When you get post rewards you remove tokens from the (virtual) rewards pool and add them to your wallet.
By owning steem you control a certain amount of where all the new steem will go. Essentially your ownership of the block allows you to determine where inflation heads. Another way to look at this is you’re receiving dividends and you’re able to apply them however you want. You can self vote, circle jerk, not use, give to a bid bot, curate heavily, delegate, and probably a few other things I haven’t thought of. You’re essentially controlling how you spend your dividends and how to use them.
“Curation is broken”
One of the concerns I see is that curation for minnows is broken. I’d like to share that it’s currently working, but there isn’t much incentive for minnows to curate beyond using their curation to make friends as opposed to make a living. The argument that thoughtful curation doesn’t provide a lot of benefit is true (for minnows), but fails to take into account the fact that curation rewards are relative to how much stake you have.
Lifecyle
If you’re here for fun then ignore everything I’m about to say and do things for fun. If you’re here to make some rewards then let me share with you the most rewarding activities that you can do on the block.
Minnows (newer accounts)- Your best bet is to comment and socialize in offchain groups. If you post you’ll make next to nothing unless you hit the lottery. You don’t have enough followers most likely to see any returns. If you curate you have so little stake that it won’t make much impact. It’s like trying to live off of the dividends of 1 share of IBM. So, your best bet is to comment. Not many people will see your posts, but if you’re making good comments on a post with lots of views people may see and read those. You’ll make 10x what you could do other activities by commenting a lot, and the other main benefit is that you’ll also start to collect followers.
Good followers are the most important thing you can have around here as that determines how much money your posts will make. The more eyes with more stake that see your post the more likely it is you’ll be rewarded.
Dolphins 5k-50k SP - These folks need to spend the majority of their time authoring. You’re at the point where you get more views on a post than you do on a comment buried in someone elses post. You’re getting some serious followers and you’re starting to earn fairly steady and potentially growing rewards on your posts. You should be authoring to keep getting the word out, and making sure that you’re engaging with your audience to keep them coming back for more on your post. Minnows are investing their time to comment on you. You should be upvoting their comments and interacting with them if you’d like to preserve those interactions.
You still don’t make that much curating here. You might have 10k steem, but again just like a stock you can’t live off of the dividends of owning 500 shares of IBM (unless you’re living off the grid in a camper shitting in the woods).
Whales 50kSP or more - Now your life starts to look different. You have 10 votes a day that have post rewards of $6 or more, but those are denominated in rewards bucks which are a mix of SBD and steem. With SBD so high the number that shows up on a post isn’t really reflective of what you’re going to earn. A better estimate is to take that number and multiply by 5. So a newly minted whale can hit a post with a $30 (USD) upvote 10 times a day. So, that’s $300/day they can put on posts. If they are simply curating they could make $60USD/day which is $21,000 per year. This starts looking like some real money. because that is actually how much a mortgage might cost in a year on a $300k house or so.
If they self vote twice that’s $108/day. That’s now higher than the average family salary in the states or roughly near it. So, when you have some real stake in this place you can make some real money by curating. You also start getting followers just by having steem on the platform. You also start getting large votes from other whales because you have the ability to hit them back with a substantial vote. It’s not quite circle jerking because it isn’t quite planned, but many of the big votes come on the platform with a tip of the hat and a nod to a friend/fellow whale.
My point
The economics of curation don’t favor minnows. And if you’re here thinking you’re going to do well simply by curating you’re going to be sadly disappointed. That said, one of the things you can do as a minnow is to provide a curation service to whales. You can go through the 40k posts and find good ones, and make a page of that. @gmuxx has had some pretty incredible success doing that, and there are others as well. But you have to understand there is a difference in providing the service of finding good posts and actually curating them… you’re a minnow…. you vote doesn’t do shit, your curation rewards from your voting does even less, but that doesn’t mean you have no role in helping to discover good content.
Anyway
Curation takes an assload of time. It’s hard to find that time. I also have a ton of people in MSP that are extremely passionate about curating stuff. Currently we’re using @minnowsupport to curate, but that drains from all the newest accounts on the platform where that 10-50 cent vote is a large part of their post rewards. So, I’ve started @msp-curation and given access to @isaria and @juliakponsford. I’ll probably add a few others, but the intent is to stop curation from @minnowsupport once this account hit’s 10k or more.
So, I recently delegated 2500SP (it was matched by @ausbitbank). I’m delegating another 2kSP today. We’ll take curation off @minnowsupport hopefully before 2018 starts.
If you think that curation is important and don’t always have time to do it please consider delegating to msp-curation. Here’s a link to put 1k SP on the account: https://v2.steemconnect.com/sign/delegateVestingShares?delegator=&delegatee=msp-curation&vesting_shares=2051057.924655%20VESTS.
Unlike a lot of other msp accounts this one has ZERO automatic voting and is entirely manually curated and it’s specifically geared to be 100% human curated.
This page is synchronized from the post: ‘Thoughts on curation and a 2,000 SP delegation to msp-curation (it’’s now 7kSP total)’


Fast Track Teacher - passed threshold to UPS1 a year early.
Obtained PSHE certificate within 18 months of starting teaching.
Regularly rated 'Good' to 'Outstanding' in Lesson Observations.
Became Head of Department after two years teaching and was employed by Enfield and Haringey as a part time Advisory Teacher within three years.
Training
Finalist for Sexual Health Professional of the year in the Brook/FPA Sexual Health Awards 2014.
Roles within the PSHE Association and Sex Education Forum mean that knowledge and understanding of all aspects of PSHE (including SRE) is at the cutting edge of current legislation, guidance and practice.
Co-ordinating the activities of the RSE Hub led to the project becoming income generating. The role involved leading on the development of several materials to quality assure the provision and practitioners of RSE. Such materials are currently being trialled regionally and nationally and have been very well received.
Committed to lifelong learning and continuous professional development as evidenced by a PGCert in PSHE Education and an MSc in Sexual Health Education.
Considerable experience in teaching and training of PSHE Education especially Sex & Relationships Education both locally and nationally in the UK and experience teaching in South Africa.
Written many training schemes including SENSE CDs comprehensive training scheme about SRE which is being delivered nationwide as demand arises.
Managed successful "Healthy School Status" application.
Communicating
First Children’s book ‘Pretend Friends’ which explains schizophrenia to children was published in Feb 2015 by Jessica Kingsley Publishers.
Involved in the writing, development and implementation of many PSHE related policies both in school and for Enfield Local Education Authority, including Anti-Bullying, Healthy Schools, Sex and Relationships Education. Drug Education.
Worked on national campaigns for sexual health including the Sex Education Forum’s 'Blueprint' campaign and Brook Charity 'Stuff' Campaign.
Wrote the PSHE Association’s "Practical guidance for schools on addressing the impact of pornography and sex in the media".
Advised the PSHE Association on the Consent Scheme of Work, the SRE Policy Advice, and the National SRE Guidance Document.
Written many PSHE and SRE schemes of work, some of which have been published nationally. Wrote the Teachers booklet for "In Care, In School", a national PSHE resource about being in care.
Personally discovered Gender Identity had been omitted between the January and July 2013 drafts of the new national curriculum. A discovery that ensured the Department of Education put it back into the final draft.


Former Wolves managing director Laurie Dalrymple drops tribunal case against club
Former Wolves managing director Laurie Dalrymple has dropped plans to take the club to a tribunal over his departure.
by Richard GuttridgeThe 44-year-old had made legal claims at Birmingham Employment Tribunal against Wolves for unfair dismissal and for a "whistle blowing" allegation - known legally as a public interest disclosure.
It's understood the club was preparing to defend the claims.
Now tribunal Judge Harding has announced that Mr Dalrymple has withdrawn the case.
Documents associated with the case said "the proceedings are dismissed following a withdrawal of the claim by the claimant".
No details have been revealed why they were withdrawn.
Mr Dalrymple spent more than four years with the club - first in commercial affairs and then as managing director. He was a key figure in the Wolves hierarchy under Chinese owners Fosun as Wolves were promoted to the Premier League before qualifying for Europe last season.
He left the club in July amid reports of a breakdown in his relationship with chairman Jeff Shi and the Molineux board..
He has since turned his attentions to rugby and become chief executive of Premiership club Harlequins.


Typographic scale with pixel-perfect alignment
Type System is a general-purpose design system and stylesheet for beautiful, readable typesetting on the web. Following tried-and-true typographic principles and inspired by Robert Bringhurst, Type Systems offers smart defaults for consistently balanced hierarchy and effortless visual rhythm.
Using 32em as the max-width ensures line lengths never exceed roughly 66 characters, staying within the widely-regarded range of 45–75 characters.
“Anything from 45 to 75 characters is widely regarded as a satisfactory length of line for a single-column page set in a serifed text face in a text size. The 66-character line (counting both letters and spaces) is widely regarded as ideal.”
“The simplest scale is a single note, and sticking with a single note draws more attention to other parameters, such as rhythm and inflection...
In the sixteenth century, a series of common sizes developed among European typographers, and the series survived with little change and few additions for 400 years...
In the sixteenth century, a series of common sizes developed among European typographers, and the series survived with little change and few additions for 400 years...
In the sixteenth century, a series of common sizes developed among European typographers, and the series survived with little change and few additions for 400 years...
In the sixteenth century, a series of common sizes developed among European typographers, and the series survived with little change and few additions for 400 years...
| class | description |
|---|---|
.h0 | font size 0 on the type scale |
.h1 | font size 1 on the type scale |
.h2 | font size 2 on the type scale |
.h3 | font size 3 on the type scale |
.h4 | font size 4 on the type scale |
.h5 | font size 5 on the type scale |
.h6 | font size 6 on the type scale |
.xh0 | font size 0 above the breakpoint |
.xh1 | font size 1 above the breakpoint |
.xh2 | font size 2 above the breakpoint |
.xh3 | font size 3 above the breakpoint |
.xh4 | font size 4 above the breakpoint |
.xh5 | font size 5 above the breakpoint |
.xh6 | font size 6 above the breakpoint |
.mx | sets max-width to maintain a readable measure |
.bold | font weight bold |
.lh1 | line height 1 |
| class | description |
|---|---|
.mt0 | margin top 0 |
.mt1 | margin top 1 on the space scale |
.mt2 | margin top 2 on the space scale |
.mt3 | margin top 3 on the space scale |
.mt4 | margin top 4 on the space scale |
.mt5 | margin top 5 on the space scale |
.mt6 | margin top 6 on the space scale |
.mb0 | margin bottom 0 |
.mb1 | margin bottom 1 on the space scale |
.mb2 | margin bottom 2 on the space scale |
.mb3 | margin bottom 3 on the space scale |
.mb4 | margin bottom 4 on the space scale |
.mb5 | margin bottom 5 on the space scale |
.mb6 | margin bottom 6 on the space scale |
“White space is to be regarded as an active element, not a passive background.”
– Jan Tschichold


MyRacePass PHP SDK Documentation
The MyRacePass PHP SDK gives you a fluent interface to interact with the My Race Pass API V2. All endpoint's are supported and all of the request parameters are fully implemented. We return PHP Objects from the API for use inside of your application.
In order to install our package via Composer, please use the following command.
composer require robert430404/mrp-php-sdk
Or add these lines to a new composer.json
{
"require": {
"robert430404/mrp-php-sdk": "1.0.0"
}
}
Information About The MRP API V2
We have complete compatibility with The MRP API. The SDK will follow the same requirements that the API documentation describes for each endpoint.
Getting Started Quick Guide
Using the package in a standalone application is very simple. Instantiate an instance of the object and pass in your API key via the constructor. From there simply call methods from the object to create your call and get your data returned to you.
<?php
use mrpsdk\endpoints\points\PointsEndpoint;
class YourClass
{
/**
* @var PointsEndpoint
*/
protected $pointsEndpoint;
/**
* YourClass constructor.
*/
public function __construct()
{
$apiKey = 'XXXXXXX-XXXX-XXXXXX-XXXXXXXXXX';
$this->pointsEndpoint = new PointsEndpoint($apiKey);
}
/**
* Returns Data From The MRP API In Object Form From JSON
*
* @return mixed
*/
public function returnData()
{
$data = $this->pointsEndpoint // Your Object
->setScheduleId(1000) // Builds URL
->setClassId(1000) // Builds URL
->getRequest(); // Sends Request And Returns Data
return $data;
}
}


Climate change protest in Plymouth city centre - in pictures Noisy protesters have been marching to raise awareness of climate change in Plymouth today 29 Nov 2019, 14:01 by Penny Cross The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today(Image: Penny Cross) The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today The school strike for climate change march in Plymouth today


d3.boxplot() demo
Update data
Horizontal box plots (with/without transition)
Vertical box plots (with/without transition)


Isar735.github.io
CATHOLIC ENCYCLOPEDIA: Index for P - NEW ADVENT.
Amazon.com: Customer reviews: The Major Works of Alexander. This 19th Century engraving was made from the full-length portrait of Alexander Hamilton by John Trumbull, oil on canvas An Essay on Man: Epistle I By Alexander Pope About this Poet The acknowledged master of the heroic couplet and one of the primary tastemakers of the Augustan. A Time-line for the History of Mathematics (Many of the early dates are approximates) This work is under constant revision, so come back later. Please report.
An Essay on Man is a poem written by Alexander Pope in 1733–1734. It is a rationalistic effort to use philosophy in order to, as John Milton attempted, justify. Pope’s Poems and Prose An Essay on Man: Epistle I Summary. With plays inspired by the sciences growing into a full genre, I thought readers would find it helpful to have this annotated list of such plays reviewed.
The Essay on Man is a philosophical poem, written, characteristically, in heroic couplets, and published between 1732 and 1734. Pope intended it as the centerpiece. An Essay on Criticism - Wikipedia. Kolmogorov Complicity And The Parable Of Lightning Slate.
The Major Works (Oxford World's Classics) Alexander Pope, Pat Rogers on Amazon.com. FREE shipping on qualifying offers. Alexander Pope has often been termed. An Essay on Man: Epistle I by Alexander Pope Poetry. An Essay on Man is a philosophical poem, written in heroic couplets and published between The Works of Alexander Pope vol 3 vol 3 v 9 of 10 Pope, Alexander.
Alexander Pope (21 May 1688 – 30 May 1744) was an 18th-century English poet. He is best known for his satirical verse, including Essay on Criticism The Major Works (Oxford World's Classics): Alexander. Voltaire called it the most sublime didactic poem ever written in any language. Rousseau rhapsodized about its intellectual consolations. Kant recited. An Essay on the Slavery and Commerce of the Human Species.
The Writer in the Family - The New York Times. Critical analysis of “An Essay on Man” “An Essay on Man,” being well-structured and carefully thought out, has its own history. Alexander Pope’s oeuvre. Edition used: Thomas Clarkson, An Essay on the Slavery and Commerce of the Human Species, particularly the African, translated from a Latin Dissertation, which. So there I stood at the front of my granddaughter Jessica’s fourth-grade classroom, still as a glazed dog, while Jessie introduced me to her classmates. From the Magazine The Celebrity Surgeon Who Used Love, Money, and the Pope to Scam an NBC News Producer.
Alexander Pope s Essay on Man - Written by Teachers. An Essay on Man poem by Pope Britannica.com. An Essay on Man: An Essay on Man, philosophical essay written in heroic couplets of iambic pentameter by Alexander Pope, published in 1733–34. It was conceived. Alexander Pope’s “An Essay on Man” Summary and Analysis. Browse By Author: P - Project Gutenberg.
The Thomas Gray Archive is a collaborative digital archive and research project devoted to the life and work of eighteenth-century poet, letter-writer Pope Francis “takes aim” in “Gaudete et Exsultate”—and. Thomas Gray Archive : Texts : Poems : Elegy Written. Alexander Pope - An Essay on Man - press.princeton.edu.
Find helpful customer reviews and review ratings for The Major Works of Alexander Pope at Amazon.com. Read honest and unbiased product reviews from our users. An Annotated List of Science Math Related Plays Reviewed.
The Celebrity Surgeon Who Used Love, Money
The work that more than any other popularized the optimistic philosophy, not only in England but throughout Europe, was Alexander Pope s Essay This essay delves deeply into the origins of the Vietnam War, critiques U.S. justifications for intervention, examines the brutal conduct of the war, and discusses. Essay on man written by alexander. An Essay on Criticism is one of the first major poems written by the English writer Alexander Pope (1688–1744). It is the source of the famous quotations Well, that didn’t take long. Less than hour after Pope Francis’ apostolic exhortation Gaudete et Exsultate was presented in Rome, Fr. James Martin P. Please help support the mission of New Advent and get the full contents of this website as an instant download. Includes the Catholic Encyclopedia, Church Fathers.
Alexander Pope s Essay on Man: An Introduction. The first epistle of An Essay on Man is its most ambitious. Pope states . written primarily by students and provide critical analysis of Alexander Alexander Pope English author Britannica.com.
Did you know that you can help us produce ebooks by proof-reading just one page a day? Go to: Distributed Proofreaders.
The thunder-and-lightning example seems like a bad comparison for this kind of situation, in that the false claim is (1) easily observable to be untrue.


Davis, CA
<EMAIL_ADDRESS>Home
About
Our Team
Partners
FAQs
Students
Organizations
Professionals
Contact
Home
About
Our Team
Partners
FAQs
Contact
404
File not Found
We're sorry, but the page you were looking for doesn't exist.
Back To Home


Package com.compuware.api.topaz.jes
Interface IJob
-
public interface IJob
A job in the Job Entry Subsystem (JES).The state of this job is a snapshot from the time it was retrieved from the host. In order to retrieve the current state of this job, it will need to be re-retrieved from the host.
Examples:
To retrieve a list of jobs matching a job name filter and/or an owner filter:IJESCommandProvider commandProvider = ... String jobNameFilter = ... String ownerFilter = ... // jobs will be empty if no jobs match the filters List<IJob> jobs = commandProvider.findJobs(jobNameFilter, ownerFilter);
To retrieve a list of jobs matching a job name filter and/or an owner filter with a JES limit:IJESCommandProvider commandProvider = ... String jobNameFilter = ... String ownerFilter = ... int jesLimit = ... // jobs will be empty if no jobs match the filters // the number of returned jobs will be limited by jesLimit List<IJob> jobs = commandProvider.findJobs(jobNameFilter, ownerFilter, jesLimit);
To retrieve a list of jobs matching a job name filter and/or an owner filter on a specific JES queue:IJESCommandProvider commandProvider = ... String jobNameFilter = ... String ownerFilter = ... int jesLimit = ... boolean includePrintQueue = ... boolean includeExecutionQueue = ... // jobs will be empty if no jobs match the filters and JES queue // the number of returned jobs will be limited by jesLimit List<IJob> jobs = commandProvider.findJobs(jobNameFilter, ownerFilter, jesLimit, includePrintQueue, includeExecutionQueue);
For examples on how to obtain anIJESCommandProvider
seeIJESCommandProvider
.
For examples on how to retrieve a job'sISysoutDataDefinition
s seeISysoutDataDefinition
.- Since:
- 2.2.0
- Version:
- 2.2.0
- See Also:
IJESCommandProvider
,ISysoutDataDefinition
- Restriction:
- This interface is not intended to be extended by clients.
- Restriction:
- This interface is not intended to be implemented by clients.
-
-
Method Summary
All Methods Instance Methods Abstract Methods Modifier and Type Method Description List<ISysoutDataDefinition>
fetchSysoutDataDefinitions()
Retrieves the current list of sysout data definitions (DDs) for this job.String
getActiveSystem()
Returns the active system name for this jobString
getAsidx()
Retrieves the ASID of the job.Date
getEndDate()
Returns the date on which this job stopped executing.ExecutionStatus
getExecutionStatus()
Returns the execution status of this job.String
getID()
Returns the ID of this job.IZOSHostConnection
getIZOSHostConnection()
Returns the IZOSHostConnection associated with this jobJESQueue
getJESQueue()
Returns the JES queue of this job.String
getJobClass()
Returns the job class of this job.JobInfo
getJobInfo()
Returns a job information object that uniquely identifies this job.String
getName()
Returns the name of this job.String
getOwner()
Returns the owner of this job.String
getProgrammerName()
Returns the programmer name of this job, as specified in the job card.int
getQueuePosition()
Returns the position of this job in the JES queue.String
getReturnCode()
Returns the return code of this job.Date
getStartDate()
Returns the date on which this job started executing.Date
getSubmitDate()
Returns the date on which this job was submitted.String
getSystemName()
Returns the name of the system this job executed or is executing on.boolean
isBlockedByDuplicate()
Returns the this job is blocked from execution by another job, executing with the same name.boolean
isHeld()
Returns the this job is being held.
-
-
-
Method Detail
-
getJobInfo
JobInfo getJobInfo()
Returns a job information object that uniquely identifies this job.This
JobInfo
object can be used in other methods as a "handle" to this job.- Returns:
- the job info
- Since:
- 2.2.0
-
getName
String getName()
Returns the name of this job.- Returns:
- the job name
- Since:
- 2.2.0
-
getID
String getID()
Returns the ID of this job.- Returns:
- the job ID
- Since:
- 2.2.0
-
getOwner
String getOwner()
Returns the owner of this job.- Returns:
- the owner
- Since:
- 2.2.0
-
getReturnCode
String getReturnCode()
Returns the return code of this job.- Returns:
- the return code
- Since:
- 2.2.0
-
getJobClass
String getJobClass()
Returns the job class of this job.- Returns:
- the job class
- Since:
- 2.2.0
-
getJESQueue
JESQueue getJESQueue()
Returns the JES queue of this job.- Returns:
- the JES queue
- Since:
- 2.2.0
-
getExecutionStatus
ExecutionStatus getExecutionStatus()
Returns the execution status of this job.- Returns:
- the execution status
- Since:
- 2.2.0
- See Also:
ExecutionStatus
-
isHeld
boolean isHeld()
Returns the this job is being held.This method returns
true
both for jobs being held from execution and for jobs being held from output.- Returns:
true
if this job is being held, otherwisefalse
- Since:
- 2.2.0
-
isBlockedByDuplicate
boolean isBlockedByDuplicate()
Returns the this job is blocked from execution by another job, executing with the same name.- Returns:
true
if this job is blocked, otherwisefalse
- Since:
- 2.2.0
-
getSystemName
String getSystemName()
Returns the name of the system this job executed or is executing on.This method will return
null
if the job has not executed yet.- Returns:
- the system name or
null
if the job has not executed yet. - Since:
- 2.2.0
-
getActiveSystem
String getActiveSystem()
Returns the active system name for this jobThis method will return
null
if the job has not executed yet.- Returns:
- the active system name or
null
- Since:
- 2.3.0
-
getQueuePosition
int getQueuePosition()
Returns the position of this job in the JES queue.- Returns:
- the queue position
- Since:
- 2.2.0
-
getProgrammerName
String getProgrammerName()
Returns the programmer name of this job, as specified in the job card.- Returns:
- the programmer name
- Since:
- 2.2.0
-
getSubmitDate
Date getSubmitDate()
Returns the date on which this job was submitted.- Returns:
- the submit date
- Since:
- 2.2.0
-
getStartDate
Date getStartDate()
Returns the date on which this job started executing.This method will return
null
if the job has not started yet.- Returns:
- the start date, or
null
if the job has not started yet - Since:
- 2.2.0
-
getEndDate
Date getEndDate()
Returns the date on which this job stopped executing.This method will return
null
if the job has not ended yet.- Returns:
- the end date, or
null
if the job has not ended yet - Since:
- 2.2.0
-
getAsidx
String getAsidx()
Retrieves the ASID of the job. This may be null.- Returns:
- the
String
asid or null.
-
getIZOSHostConnection
IZOSHostConnection getIZOSHostConnection()
Returns the IZOSHostConnection associated with this job- Returns:
- the
IZOSHostConnection
- Since:
- 2.2.0
-
fetchSysoutDataDefinitions
List<ISysoutDataDefinition> fetchSysoutDataDefinitions()
Retrieves the current list of sysout data definitions (DDs) for this job.- Returns:
- the sysout data definitions
- Throws:
ZOSSystemException
- if a z/OS system error occursZOSAbendException
- if a z/OS ABEND occurs- Since:
- 2.2.0
-
-