QUESO Namespace Reference

Classes
class	ArrayOfSequences
	Class for handling array samples (arrays of scalar sequences). More...
class	BoxSubset
	Class representing a subset of a vector space shaped like a hypercube. More...
class	ConcatenationSubset
	A templated class representing the concatenation of two vector subsets. More...
class	ConstantScalarFunction
	A class for handling scalar functions which image is a constant (real number). More...
class	ConstantVectorFunction
	A class for handling vector functions which image is constant. More...
class	DiscreteSubset
	A templated class representing the discrete vector subsets. More...
class	GenericScalarFunction
	A class for handling generic scalar functions. More...
class	GenericVectorFunction
	A class for handling generic vector functions. More...
class	IntersectionSubset
	A templated class representing the intersection of two vector sets. More...
class	BaseScalarFunction
	A templated (base) class for handling scalar functions. More...
class	BayesianJointPdf
	A class for handling Bayesian joint PDFs. More...
class	ScalarFunctionSynchronizer
	A templated class for synchronizing the calls of scalar functions (BaseScalarFunction and derived classes). More...
class	ScalarSequence
	Class for handling scalar samples. More...
class	SequenceOfVectors
	Class for handling vector samples (sequence of vectors). More...
class	BaseVectorFunction
	A templated (base) class for handling vector functions. More...
class	VectorFunctionSynchronizer
	A templated class for synchronizing the calls of vector-valued functions. More...
class	BaseVectorSequence
	Base class for handling vector and array samples (sequence of vectors or arrays). More...
class	VectorSpace
	A class representing a vector space. More...
class	VectorSet
	A templated class for handling sets. More...
class	VectorSubset
	A templated class for handling subsets. More...
class	AlgorithmFactory
class	AlgorithmFactoryImp
class	AlgorithmFactoryInitializer
class	BaseInputOptionsParser
class	BasicPdfsBase
	TODO: Base class for basic PDFs (via either GSL or Boost). More...
class	BasicPdfsBoost
	TODO: Base class for basic PDFs using Boost library. More...
class	BasicPdfsCXX11
	Base class for basic PDFs using C++ math functions. More...
class	BasicPdfsGsl
	TODO: Base class for basic PDFs using Gsl library. More...
class	BoostInputOptionsParser
class	DistArray
	A class for partitioning vectors and matrices. More...
struct	FilePtrSetStruct
	Struct for handling data input and output from files. More...
class	BaseEnvironment
	This (virtual) class sets up the environment underlying the use of the QUESO library by an executable. More...
class	EmptyEnvironment
	This class sets up the environment underlying the use of the QUESO library by an executable. More...
class	FullEnvironment
	This class sets up the full environment underlying the use of the QUESO library by an executable. More...
class	EnvOptionsValues
	This class provides a suite options one can pass to a QUESO environment. More...
class	EnvironmentOptions
	This class reads options one can pass to a QUESO environment through an input file. More...
class	LogicError
class	NotImplemented
class	FileError
class	Factory
class	FactoryImp
class	FunctionBase
	Abstract base class for function objects. More...
class	FunctionOperatorBuilder
class	GslBlockMatrix
	Class for representing block matrices using GSL library. More...
class	GslMatrix
	Class for matrix operations using GSL library. More...
class	GslOptimizer
	A base class for handling optimisation of scalar functions. More...
class	GslVector
	Class for vector operations using GSL library. More...
class	InfiniteDimensionalGaussian
	Class defining infinite dimensional Gaussian measures. More...
class	InfiniteDimensionalLikelihoodBase
	Abstract class representing the likelihood. Users must subclass this. More...
class	InfiniteDimensionalMCMCSampler
	Class representing the infinite dimensional Markov chain Monte Carlo sampler. More...
class	InfiniteDimensionalMCMCSamplerOptions
	This class defines the options that specify the behaviour of the MCMC sampler. More...
class	InfiniteDimensionalMeasureBase
	Abstract base class for infinite dimensional measures. More...
class	LibMeshFunction
	Function objects using libMesh for the backend. More...
class	LibMeshNegativeLaplacianOperator
	Class describing negative Laplacian operator using libmesh backend. More...
class	LibMeshOperatorBase
	Abstract base class for operator objects using libmesh in the backend. More...
class	Map
	A class for partitioning vectors and matrices. More...
class	Matrix
	Class for matrix operations (virtual). More...
struct	data_type
class	DataType
class	StandardType
class	MpiComm
	The QUESO MPI Communicator Class. More...
class	OperatorBase
	Abstract base class for operator objects. Operators are assumed to be symmetric and positive-definite. More...
class	BaseOptimizer
	A base class for handling optimisation of scalar functions. More...
class	OptimizerMonitor
	Object to monitor convergence of optimizers. More...
class	OptimizerOptions
	This class provides options for a Optimizer. More...
class	RngBase
	Class for random number generation (base class for either GSL or Boost RNG). More...
class	RngBoost
class	RngCXX11
class	RngGsl
struct	ScopedPtr
struct	SharedPtr
class	TeuchosMatrix
	Class for matrix operations using Teuchos (Trilinos). More...
class	TeuchosVector
	Class for vector operations using Teuchos (Trilinos). More...
class	TKFactoryInitializer
class	TKFactoryLogitRandomWalk
class	TKFactoryMALA
class	TKFactoryRandomWalk
class	TKFactoryStochasticNewton
class	TransitionKernelFactory
class	Vector
	Class for vector operations (virtual). More...
class	GPMSAEmulator
class	GPMSAFactory
class	GPMSAOptions
	This class defines the options that specify the behaviour of the Gaussian process emulator. More...
class	Base1D1DFunction
	Class for one-dimensional functions. More...
class	Generic1D1DFunction
	Class for generic one-dimensional functions. More...
class	Constant1D1DFunction
	Class for constant one-dimensional functions. More...
class	Linear1D1DFunction
	Class for linear one-dimensional functions. More...
class	PiecewiseLinear1D1DFunction
	Class for piecewise-linear one-dimensional functions. More...
class	Quadratic1D1DFunction
	Class for one-dimensional quadratic functions. More...
class	Sampled1D1DFunction
	Class for one-dimensional sampled functions. More...
class	ScalarTimesFunc1D1DFunction
	Class for multiplication of a one-dimensional function by a scalar. More...
class	FuncTimesFunc1D1DFunction
	Class for multiplication of a one-dimensional function by another. More...
class	FuncPlusFunc1D1DFunction
	Class for addition of a one-dimensional function with another. More...
class	LagrangePolynomial1D1DFunction
	Class for one-dimensional Lagrange polynomials. More...
class	LagrangeBasis1D1DFunction
	Class for Lagrange polynomial basis. More...
class	Base1DQuadrature
	Base class for one-dimensional quadrature rules (numerical integration of functions). More...
class	Generic1DQuadrature
	Class for one-dimensional generic quadrature rules (numerical integration of functions). More...
class	UniformLegendre1DQuadrature
	Class for Legendre-Gauss quadrature rule for one-dimensional functions. More...
class	GaussianHermite1DQuadrature
	Class for Hermite-Gauss quadrature rule for one-dimensional functions. More...
class	WignerInverseChebyshev1st1DQuadrature
	Class for first type Chebyshev-Gauss quadrature rule for one-dimensional functions. More...
class	WignerChebyshev2nd1DQuadrature
	Class for second type Chebyshev-Gauss quadrature rule for one-dimensional functions. More...
class	TwoDArray
	Class for handling arrays of generic data. More...
class	ArrayOfOneDGrids
	Class to accommodate arrays of one-dimensional grid. More...
class	ArrayOfOneDTables
	Class to accommodate arrays of one-dimensional tables. More...
class	AsciiTable
	Class for reading ASCII values from a table in a file. More...
class	BaseQuadrature
	Base class for quadrature rules. More...
class	Fft
	Class for a Fast Fourier Transform (FFT) algorithm. More...
class	MonteCarloQuadrature
	Numerical integration using Monte Carlo. More...
class	MultiDimensionalIndexing
class	MultiDQuadratureBase
	Base class for multi-dimensional quadrature rules. More...
class	BaseOneDGrid
	Base class for accommodating one-dimensional grids. More...
class	StdOneDGrid
	Class for accommodating standard one-dimensional grids. More...
class	StreamUtilities
class	TensorProductQuadrature
	Numerical quadrature using a tensor product of Base1DQuadrature rules. More...
class	UniformOneDGrid
	Class for accommodating uniform one-dimensional grids. More...
class	BaseTKGroup
	This base class allows the representation of a transition kernel. More...
class	Algorithm
class	BetaJointPdf
	A class for handling Beta joint PDFs. More...
class	BetaVectorRealizer
	A class for handling sampling from a Beta probability density distribution. More...
class	BetaVectorRV
	A class representing a vector RV constructed via Beta distribution. More...
class	ConcatenatedJointPdf
	A class for handling concatenated PDFs. More...
class	ConcatenatedVectorRealizer
	A class for handling sampling from concatenated probability density distributions. More...
class	ConcatenatedVectorRV
	A class representing concatenated vector RVs. More...
class	ExponentialMatrixCovarianceFunction
	A class for exponential covariance matrices. More...
class	ExponentialScalarCovarianceFunction
	A class for exponential covariances. More...
class	FiniteDistribution
	A templated class for a finite distribution. More...
class	GammaJointPdf
	A class for handling Gamma joint PDFs. More...
class	GammaVectorRealizer
	A class for handling sampling from a Gamma probability density distribution. More...
class	GammaVectorRV
	A class representing a vector RV constructed via Gamma distribution. More...
class	GaussianJointPdf
	A class for handling Gaussian joint PDFs. More...
class	GaussianLikelihoodBlockDiagonalCovariance
	A class representing a Gaussian likelihood with block-diagonal covariance matrix. More...
class	GaussianLikelihoodBlockDiagonalCovarianceRandomCoefficients
	A class representing a Gaussian likelihood with block-diagonal covariance matrix. More...
class	GaussianLikelihoodDiagonalCovariance
	A class that represents a Gaussian likelihood with diagonal covariance matrix. More...
class	GaussianLikelihoodFullCovariance
	A class that represents a Gaussian likelihood with full covariance. More...
class	GaussianLikelihoodFullCovarianceRandomCoefficient
	A class that represents a Gaussian likelihood with full covariance and random coefficient. More...
class	GaussianLikelihoodScalarCovariance
	A class that represents a Gaussian likelihood with scalar covariance. More...
class	GaussianVectorCdf
	TODO: A class for handling Gaussian CDFs. More...
class	GaussianVectorMdf
	TODO: A class for handling Gaussian MDFs. More...
class	GaussianVectorRealizer
	A class for handling sampling from Gaussian probability density distributions. More...
class	GaussianVectorRV
	A class representing a Gaussian vector RV. More...
class	GenericJointPdf
	A class for handling generic joint PDFs. More...
class	GenericMatrixCovarianceFunction
	A class for generic covariance matrices. More...
class	GenericScalarCovarianceFunction
	A class for generic covariances. More...
class	GenericVectorCdf
	A class for handling generic vector CDFs. More...
class	GenericVectorMdf
	A class for handling generic MDFs of vector functions. More...
class	GenericVectorRealizer
	A class for handling sampling from generic probability density distributions. More...
class	GenericVectorRV
	A templated class for handling generic vector RVs. More...
class	HessianCovMatricesTKGroup
	This class allows the representation of a transition kernel with Hessians. More...
class	InverseGammaJointPdf
	A class for handling Inverse Gamma joint PDFs. More...
class	InverseGammaVectorRealizer
	A class for handling sampling from an Inverse Gamma probability density distribution. More...
class	InverseGammaVectorRV
	A class representing a vector RV constructed via Inverse Gamma distribution. More...
class	InvLogitGaussianJointPdf
	A class for handling hybrid (transformed) Gaussians with bounds. More...
class	InvLogitGaussianVectorRealizer
	A class for handling sampling from (transformed) Gaussian probability density distributions with bounds. More...
class	InvLogitGaussianVectorRV
	A class representing a (transformed) Gaussian vector RV with bounds. More...
class	JeffreysJointPdf
	A class for handling jeffreys joint PDFs. More...
class	JeffreysVectorRealizer
	A class for handling sampling from a jeffreys probability density distribution. More...
class	JeffreysVectorRV
	A class representing a jeffreys vector RV. More...
class	BaseJointPdf
	A templated (base) class for handling joint PDFs. More...
class	LikelihoodBase
	Base class for canned Gaussian likelihoods. More...
class	LogNormalJointPdf
	A class for handling Log-Normal joint PDFs. More...
class	LogNormalVectorRealizer
	A class for handling sampling from a Log-Normal probability density distribution. More...
class	LogNormalVectorRV
	A class representing a LogNormal vector RV. More...
class	MarkovChainPositionData
	A templated class that represents a Markov Chain. More...
class	BaseMatrixCovarianceFunction
	A templated (base) class to accommodate covariance matrix of (random) vector functions. More...
class	BayseianJointPdf
class	MetropolisAdjustedLangevinTK
	This class allows the representation of the MALA transition kernel with a scaled covariance matrix for the purposes of delayed rejection. More...
struct	MHRawChainInfoStruct
	A struct that represents a Metropolis-Hastings sample. More...
class	MetropolisHastingsSG
	A templated class that represents a Metropolis-Hastings generator of samples. More...
class	MhOptionsValues
	This class provides options for the Metropolis-Hastings generator of samples if no input file is available. More...
class	MetropolisHastingsSGOptions
	This class reads the options for the Metropolis-Hastings generator of samples from an input file. More...
struct	BIP_routine_struct
struct	ExchangeInfoStruct
struct	BalancedLinkedChainControlStruct
struct	BalancedLinkedChainsPerNodeStruct
struct	UnbalancedLinkedChainControlStruct
struct	UnbalancedLinkedChainsPerNodeStruct
class	MLSampling
	A templated class that represents a Multilevel generator of samples. More...
class	MLSamplingLevelOptions
	This class provides options for each level of the Multilevel sequence generator if no input file is available. More...
class	MLSamplingOptions
	This class provides options for the Multilevel sequence generator if no input file is available. More...
class	ModelValidation
	A templated class for model validation of the example validationPyramid. More...
class	MonteCarloSG
	A templated class that implements a Monte Carlo generator of samples. More...
class	McOptionsValues
	This class provides options for the Monte Carlo sequence generator if no input file is available. More...
class	MonteCarloSGOptions
	This class reads the options for the Monte Carlo sequence generator from an input file. More...
class	PoweredJointPdf
	A class for handling a powered joint PDFs. More...
class	SampledScalarCdf
	A class for handling sampled CDFs. More...
class	SampledVectorCdf
	A class for handling sampled vector CDFs. More...
class	SampledVectorMdf
	A class for handling sampled vector MDFs. More...
class	BaseScalarCdf
	A templated (base) class for handling CDFs. More...
class	BaseScalarCovarianceFunction
	A templated (base) class to accommodate scalar covariance functions (of random variables). More...
class	ScalarGaussianRandomField
	A class for handling scalar Gaussian random fields (GRF). More...
class	ScaledCovMatrixTKGroup
	This class allows the representation of a transition kernel with a scaled covariance matrix. More...
class	SequentialVectorRealizer
	A class for handling sequential draws (sampling) from probability density distributions. More...
class	StatisticalForwardProblem
	This templated class represents a Statistical Forward Problem. More...
class	SfpOptionsValues
	This class provides options for a Statistical Forward Problem if no input file is available. More...
class	StatisticalForwardProblemOptions
	This class reads option values for a Statistical Forward Problem from an input file. More...
class	StatisticalInverseProblem
	This templated class represents a Statistical Inverse Problem. More...
class	SipOptionsValues
	This class provides options for a Statistical Inverse Problem if no input file is available. More...
class	StatisticalInverseProblemOptions
	This class reads option values for a Statistical Inverse Problem from an input file. More...
class	StdScalarCdf
	A class for handling standard CDFs. More...
class	TransformedScaledCovMatrixTKGroup
	This class represents a transition kernel with a scaled covariance matrix on hybrid bounded/unbounded state spaces. More...
class	UniformJointPdf
	A class for handling uniform joint PDFs. More...
class	UniformVectorRealizer
	A class for handling sampling from a Uniform probability density distribution. More...
class	UniformVectorRV
	A class representing a uniform vector RV. More...
class	ValidationCycle
	A templated class for validation cycle of the examples validationCycle and validationCycle2. More...
class	BaseVectorCdf
	A templated (base) class for handling CDFs of vector functions. More...
class	VectorGaussianRandomField
	A class for handling vector Gaussian random fields (GRF). More...
class	BaseVectorMdf
	A templated (base) class for handling MDFs of vector functions. More...
class	BaseVectorRealizer
	A templated (base) class for handling sampling from vector RVs. More...
class	BaseVectorRV
	A templated base class for handling vector RV. More...
class	WignerJointPdf
	A class for handling Wigner joint PDFs. More...
class	WignerVectorRealizer
	A class for handling sampling from a Wigner probability density distribution. More...
class	WignerVectorRV
	A class representing a vector RV constructed via Wigner distribution. More...
class	InterpolationSurrogateData
class	InterpolationSurrogateBase
	Base class for interpolation-based surrogates. More...
class	InterpolationSurrogateBuilder
	Build interpolation-based surrogate. More...
class	InterpolationSurrogateDataSet
	Container class for multiple, consistent InterpolationSurrogateData objects. More...
class	InterpolationSurrogateIOASCII
class	InterpolationSurrogateIOBase
class	LinearLagrangeInterpolationSurrogate
	Linear Lagrange interpolation surrogate. More...
class	SurrogateBase
	Base class for surrogates of models. More...
class	SurrogateBuilderBase
	Base class for builders of surrogates. More...

Typedefs
typedef MPI_Comm	RawType_MPI_Comm
typedef MPI_Group	RawType_MPI_Group
typedef MPI_Datatype	RawType_MPI_Datatype
typedef MPI_Datatype	data_type
typedef MPI_Op	RawType_MPI_Op
typedef MPI_Status	RawType_MPI_Status

Functions
template<class V , class M >
VectorSet< V, M > *	InstantiateIntersection (const VectorSet< V, M > &domain1, const VectorSet< V, M > &domain2)
	This method calculates the intersection of domain1 and domain2. More...
template<class T >
void	ComputeSubGaussian2dKde (const ScalarSequence< T > &scalarSeq1, const ScalarSequence< T > &scalarSeq2, unsigned int initialPos, double scaleValue1, double scaleValue2, const std::vector< T > &evaluationPositions1, const std::vector< T > &evaluationPositions2, std::vector< double > &densityValues)
template<class T >
void	ComputeUnifiedGaussian2dKde (bool useOnlyInter0Comm, const ScalarSequence< T > &scalarSeq1, const ScalarSequence< T > &scalarSeq2, unsigned int initialPos, double unifiedScaleValue1, double unifiedScaleValue2, const std::vector< T > &unifiedEvaluationPositions1, const std::vector< T > &unifiedEvaluationPositions2, std::vector< double > &unifiedDensityValues)
template<class T >
void	ComputeCovCorrBetweenScalarSequences (const ScalarSequence< T > &subPSeq, const ScalarSequence< T > &subQSeq, unsigned int subNumSamples, T &covValue, T &corrValue)
template<class P_V , class P_M , class Q_V , class Q_M >
void	ComputeCovCorrMatricesBetweenVectorSequences (const BaseVectorSequence< P_V, P_M > &subPSeq, const BaseVectorSequence< Q_V, Q_M > &subQSeq, unsigned int subNumSamples, P_M &pqCovMatrix, P_M &pqCorrMatrix)
std::ostream &	operator<< (std::ostream &os, const SequenceStatisticalOptions &obj)
int	MyWorldfullRank ()
	Returns the rank of the calling process in the communicator. More...
void	queso_terminate_handler ()
	Function for unhandled exceptions in Queso. More...
void	QUESO_version_print (std::ostream &os)
int	QUESO_get_numeric_version ()
std::ostream &	operator<< (std::ostream &os, const BaseEnvironment &obj)
std::ostream &	operator<< (std::ostream &os, const EnvironmentOptions &obj)
	Print values of the options chosen. More...
std::ostream &	operator<< (std::ostream &os, const GslBlockMatrix &obj)
GslMatrix	operator* (double a, const GslMatrix &mat)
GslVector	operator* (const GslMatrix &mat, const GslVector &vec)
GslMatrix	operator* (const GslMatrix &m1, const GslMatrix &m2)
GslMatrix	operator+ (const GslMatrix &m1, const GslMatrix &m2)
GslMatrix	operator- (const GslMatrix &m1, const GslMatrix &m2)
GslMatrix	matrixProduct (const GslVector &v1, const GslVector &v2)
GslMatrix	leftDiagScaling (const GslVector &vec, const GslMatrix &mat)
GslMatrix	rightDiagScaling (const GslMatrix &mat, const GslVector &vec)
std::ostream &	operator<< (std::ostream &os, const GslMatrix &obj)
GslVector	operator/ (double a, const GslVector &x)
GslVector	operator/ (const GslVector &x, const GslVector &y)
GslVector	operator* (double a, const GslVector &x)
GslVector	operator* (const GslVector &x, const GslVector &y)
double	scalarProduct (const GslVector &x, const GslVector &y)
GslVector	operator+ (const GslVector &x, const GslVector &y)
GslVector	operator- (const GslVector &x, const GslVector &y)
bool	operator== (const GslVector &lhs, const GslVector &rhs)
std::ostream &	operator<< (std::ostream &os, const GslVector &obj)
	QUESO_STANDARD_TYPE (char, MPI_CHAR)
	QUESO_STANDARD_TYPE (int, MPI_INT)
	QUESO_STANDARD_TYPE (unsigned int, MPI_UNSIGNED)
	QUESO_STANDARD_TYPE (double, MPI_DOUBLE)
TeuchosMatrix	operator* (double a, const TeuchosMatrix &mat)
TeuchosVector	operator* (const TeuchosMatrix &mat, const TeuchosVector &vec)
TeuchosMatrix	operator* (const TeuchosMatrix &m1, const TeuchosMatrix &m2)
TeuchosMatrix	operator+ (const TeuchosMatrix &m1, const TeuchosMatrix &m2)
TeuchosMatrix	operator- (const TeuchosMatrix &m1, const TeuchosMatrix &m2)
TeuchosMatrix	matrixProduct (const TeuchosVector &v1, const TeuchosVector &v2)
TeuchosMatrix	leftDiagScaling (const TeuchosVector &vec, const TeuchosMatrix &mat)
TeuchosMatrix	rightDiagScaling (const TeuchosMatrix &mat, const TeuchosVector &vec)
std::ostream &	operator<< (std::ostream &os, const TeuchosMatrix &obj)
TeuchosVector	operator/ (double a, const TeuchosVector &x)
TeuchosVector	operator/ (const TeuchosVector &x, const TeuchosVector &y)
TeuchosVector	operator* (double a, const TeuchosVector &x)
TeuchosVector	operator* (const TeuchosVector &x, const TeuchosVector &y)
double	scalarProduct (const TeuchosVector &x, const TeuchosVector &y)
TeuchosVector	operator+ (const TeuchosVector &x, const TeuchosVector &y)
TeuchosVector	operator- (const TeuchosVector &x, const TeuchosVector &y)
bool	operator== (const TeuchosVector &lhs, const TeuchosVector &rhs)
std::ostream &	operator<< (std::ostream &os, const TeuchosVector &obj)
template<>
void	BoostInputOptionsParser::getOption< std::vector< double, std::allocator< double > > > (const std::string &name, std::vector< double, std::allocator< double > > &value) const
std::ostream &	operator<< (std::ostream &os, const BoostInputOptionsParser &parser)
template void	BoostInputOptionsParser::registerOption< std::string > (const std::string &, const std::string &, const std::string &)
template void	BoostInputOptionsParser::getOption< std::string > (const std::string &, std::string &) const
template void	BoostInputOptionsParser::getOption< std::vector< unsigned int, std::allocator< unsigned int > > > (const std::string &, std::vector< unsigned int, std::allocator< unsigned int > > &) const
std::ostream &	operator<< (std::ostream &os, const EnvOptionsValues &obj)
double	c_evaluate (const gsl_vector *x, void *context)
void	c_evaluate_derivative (const gsl_vector *x, void *context, gsl_vector *derivative)
void	c_evaluate_with_derivative (const gsl_vector *x, void *context, double *f, gsl_vector *derivative)
std::ostream &	operator<< (std::ostream &os, const InfiniteDimensionalMCMCSamplerOptions &obj)
std::ostream &	operator<< (std::ostream &os, const OptimizerOptions &obj)
std::ostream &	operator<< (std::ostream &os, const GPMSAOptions &obj)
template<class T >
double	SubF1F2Gaussian2dKdeIntegral (const ScalarSequence< T > &scalarSeq1, const ScalarSequence< T > &scalarSeq2, unsigned int initialPos, double scaleValue1, double scaleValue2, const Base1D1DFunction &func1, const Base1D1DFunction &func2, unsigned int quadratureOrder)
	Calculates the integral of a 2D Gaussian KDE. More...
template<class V , class M >
void	CovCond (double condNumber, const V &direction, M &covMatrix, M &precMatrix)
template<typename T >
bool	queso_isnan (T arg)
template<typename T >
bool	queso_isfinite (T arg)
void	MiscReadDoublesFromString (const std::string &inputString, std::vector< double > &outputDoubles)
void	MiscReadWordsFromString (const std::string &inputString, std::vector< std::string > &outputWords)
void	MiscExtractDoubleFromString (std::string &inputString, double &outputDouble)
void	MiscExtractWordFromString (std::string &inputString, std::string &outputWord)
int	MiscReadStringAndDoubleFromFile (std::ifstream &ifs, std::string &termString, double *termValue)
int	MiscReadCharsAndDoubleFromFile (std::ifstream &ifs, std::string &termString, double *termValue, bool &endOfLineAchieved)
double	MiscGammar (double a, double b, const RngBase *rngObject)
double	MiscGetEllapsedSeconds (struct timeval *timeval0)
double	MiscHammingWindow (unsigned int N, unsigned int j)
double	MiscGaussianDensity (double x, double mu, double sigma)
unsigned int	MiscUintDebugMessage (unsigned int value, const char *message)
int	MiscIntDebugMessage (int value, const char *message)
double	MiscDoubleDebugMessage (double value, const char *message)
int	CheckFilePath (const char *path)
int	GRVY_CheckDir (const char *dirname)
template<class T >
bool	MiscCheckForSameValueInAllNodes (T &inputValue, double acceptableTreshold, const MpiComm &comm, const char *whereString)
template<class V >
void	MiscComputePositionsBetweenMinMax (V minValues, V maxValues, std::vector< V * > &positions)
template<class V1 , class V2 >
void	MiscCheckTheParallelEnvironment (const V1 &vec1, const V2 &vec2)
template<class V , class M >
std::ostream &	operator<< (std::ostream &os, const ArrayOfOneDTables< V, M > &obj)
template<class V , class M >
std::ostream &	operator<< (std::ostream &os, const AsciiTable< V, M > &obj)
template<class V , class M >
void	ComputeConditionalGaussianVectorRV (const V &muVec1, const V &muVec2, const M &sigmaMat11, const M &sigmaMat12, const M &sigmaMat21, const M &sigmaMat22, const V &sampleVec2, V &muVec1_cond_on_2, M &sigmaMat11_cond_on_2)
void	distANN_XY (const ANNpointArray dataX, const ANNpointArray dataY, double *distsXY, unsigned int dimX, unsigned int dimY, unsigned int xN, unsigned int yN, unsigned int k, double eps)
void	normalizeANN_XY (ANNpointArray dataXY, unsigned int dimXY, ANNpointArray dataX, unsigned int dimX, ANNpointArray dataY, unsigned int dimY, unsigned int N)
void	whiteningANN_X_Y (ANNpointArray dataX1, ANNpointArray dataX2, unsigned int dimX, unsigned int N1, unsigned int N2)
double	computeMI_ANN (ANNpointArray dataXY, unsigned int dimX, unsigned int dimY, unsigned int k, unsigned int N, double eps)
template<template< class P_V, class P_M > class RV, class P_V , class P_M >
double	estimateMI_ANN (const RV< P_V, P_M > &jointRV, const unsigned int xDimSel[], unsigned int dimX, const unsigned int yDimSel[], unsigned int dimY, unsigned int k, unsigned int N, double eps)
template<class P_V , class P_M , template< class P_V, class P_M > class RV_1, template< class P_V, class P_M > class RV_2>
double	estimateMI_ANN (const RV_1< P_V, P_M > &xRV, const RV_2< P_V, P_M > &yRV, const unsigned int xDimSel[], unsigned int dimX, const unsigned int yDimSel[], unsigned int dimY, unsigned int k, unsigned int N, double eps)
template<class P_V , class P_M , template< class P_V, class P_M > class RV_1, template< class P_V, class P_M > class RV_2>
double	estimateKL_ANN (RV_1< P_V, P_M > &xRV, RV_2< P_V, P_M > &yRV, unsigned int xDimSel[], unsigned int dimX, unsigned int yDimSel[], unsigned int dimY, unsigned int xN, unsigned int yN, unsigned int k, double eps)
template<class P_V , class P_M , template< class P_V, class P_M > class RV_1, template< class P_V, class P_M > class RV_2>
double	estimateCE_ANN (RV_1< P_V, P_M > &xRV, RV_2< P_V, P_M > &yRV, unsigned int xDimSel[], unsigned int dimX, unsigned int yDimSel[], unsigned int dimY, unsigned int xN, unsigned int yN, unsigned int k, double eps)
template<class V , class M >
std::ostream &	operator<< (std::ostream &os, const BaseJointPdf< V, M > &obj)
std::ostream &	operator<< (std::ostream &os, const MetropolisHastingsSGOptions &obj)
void	BIP_routine (glp_tree *tree, void *info)
std::ostream &	operator<< (std::ostream &os, const MonteCarloSGOptions &obj)
	Prints the object obj, overloading an operator. More...
template<class T >
double	horizontalDistance (const BaseScalarCdf< T > &cdf1, const BaseScalarCdf< T > &cdf2, double epsilon)
	It calculated the maximum horizontal distance between two CDFs. More...
std::ostream &	operator<< (std::ostream &os, const StatisticalForwardProblemOptions &obj)
	Prints the object obj, overloading an operator. More...
std::ostream &	operator<< (std::ostream &os, const StatisticalInverseProblemOptions &obj)
	Prints the object obj, overloading an operator. More...
template<class V , class M >
void	horizontalDistances (const BaseVectorCdf< V, M > &cdf1, const BaseVectorCdf< V, M > &cdf2, const V &epsilonVec, V &distances)
	It calculated the maximum horizontal distances between two vector CDFs. More...
template<class P_V , class P_M , class Q_V , class Q_M >
void	ComputeCovCorrMatricesBetweenVectorRvs (const BaseVectorRV< P_V, P_M > &paramRv, const BaseVectorRV< Q_V, Q_M > &qoiRv, unsigned int localNumSamples, P_M &pqCovMatrix, P_M &pqCorrMatrix)
std::ostream &	operator<< (std::ostream &os, const MhOptionsValues &obj)
template<class P_V , class P_M >
std::ostream &	operator<< (std::ostream &os, const MLSampling< P_V, P_M > &obj)
std::ostream &	operator<< (std::ostream &os, const MLSamplingLevelOptions &obj)
std::ostream &	operator<< (std::ostream &os, const MLSamplingOptions &obj)
std::ostream &	operator<< (std::ostream &os, const McOptionsValues &obj)
	if (m_env.subDisplayFile()!=NULL)
	if (m_ov.m_pseqComputeStats) m_pseqStatisticalOptionsObj
SfpOptionsValues::SfpOptionsValues() m_parser	registerOption< bool > (m_option_computeSolution, UQ_SFP_COMPUTE_SOLUTION_ODV,"compute solution process")
m_parser	registerOption< bool > (m_option_computeCovariances, UQ_SFP_COMPUTE_COVARIANCES_ODV,"compute pq covariances")
m_parser	registerOption< bool > (m_option_computeCorrelations, UQ_SFP_COMPUTE_CORRELATIONS_ODV,"compute pq correlations")
m_parser	registerOption< std::string > (m_option_dataOutputFileName, UQ_SFP_DATA_OUTPUT_FILE_NAME_ODV,"name of data output file")
m_parser	registerOption< std::string > (m_option_dataOutputAllowedSet, UQ_SFP_DATA_OUTPUT_ALLOWED_SET_ODV,"subEnvs that will write to data output file")
m_parser	registerOption< std::string > (m_option_solver, UQ_SFP_SOLVER_ODV,"algorithm for propagation")
m_parser	scanInputFile ()
m_parser	getOption< std::string > (m_option_help, m_help)
m_parser	getOption< bool > (m_option_computeSolution, m_computeSolution)
m_parser	getOption< bool > (m_option_computeCovariances, m_computeCovariances)
m_parser	getOption< bool > (m_option_computeCorrelations, m_computeCorrelations)
m_parser	getOption< std::string > (m_option_dataOutputFileName, m_dataOutputFileName)
m_parser	getOption< std::set< unsigned int > > (m_option_dataOutputAllowedSet, m_dataOutputAllowedSet)
m_parser	getOption< std::string > (m_option_solver, m_solver)
	for (unsigned int i=0;i< size;i++)
	checkOptions ()
std::ostream &	operator<< (std::ostream &os, const SfpOptionsValues &obj)
std::ostream &	operator<< (std::ostream &os, const SipOptionsValues &obj)

Variables
const int	UQ_UNAVAILABLE_RANK = -1
const int	UQ_OK_RC = 0
const int	UQ_INCOMPLETE_IMPLEMENTATION_RC = -1
const int	UQ_INVALID_PARAMETER_SPEC_RC = -2
const int	UQ_INVALID_OBSERVABLE_SPEC_RC = -3
const int	UQ_INVALID_QOI_SPEC_RC = -4
const int	UQ_INVALID_INTERNAL_RESULT_RC = -5
const int	UQ_INVALID_INTERNAL_STATE_RC = -6
const int	UQ_FAILED_TO_OPEN_FILE_RC = -7
const int	UQ_MATRIX_IS_NOT_POS_DEFINITE_RC = -8
const int	UQ_FAILED_READING_FILE_RC = -9
const int	UQ_INVALID_SPACE_COMPONENT_ID_RC = -10
const int	UQ_MATRIX_SVD_FAILED_RC = -11
template<typename T >
DistArray< T >::DistArray(const Map &inputMap, const int inputRowSize)	for (int i=0;i< m_Map.NumGlobalElements();++i)
std::terminate_handler	old_terminate_handler
McOptionsValues::McOptionsValues(#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS const SsOptionsValues *alternativePSsOptionsValues, const SsOptionsValues *alternativeQSsOptionsValues#endif	if )(m_alternativeQSsOptionsValues=*alternativeQSsOptionsValues)
MonteCarloSGOptions::MonteCarloSGOptions(const BaseEnvironment &env, const char *prefix	queso_require_not_equal_to_msg )(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the absence of an options input file"))
MonteCarloSGOptions::MonteCarloSGOptions(const BaseEnvironment &env, const char *prefix, const McOptionsValues &alternativeOptionsValues	queso_require_equal_to_msg )(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the existence of an options input file"))
	m_help = env->input()(m_option_help, UQ_SFP_HELP)
	m_computeSolution = env->input()(m_option_computeSolution, UQ_SFP_COMPUTE_SOLUTION_ODV)
	m_computeCovariances = env->input()(m_option_computeCovariances, UQ_SFP_COMPUTE_COVARIANCES_ODV)
	m_computeCorrelations = env->input()(m_option_computeCorrelations, UQ_SFP_COMPUTE_CORRELATIONS_ODV)
	m_dataOutputFileName = env->input()(m_option_dataOutputFileName, UQ_SFP_DATA_OUTPUT_FILE_NAME_ODV)
unsigned int	size = env->input().vector_variable_size(m_option_dataOutputAllowedSet)
	m_solver = env->input()(m_option_solver, UQ_SFP_SOLVER_ODV)

Typedef Documentation

typedef MPI_Datatype QUESO::data_type

Definition at line 44 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Comm

Definition at line 41 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Datatype

Definition at line 43 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Group

Definition at line 42 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Op

Definition at line 45 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Status

Definition at line 46 of file MpiComm.h.

Function Documentation

void QUESO::BIP_routine	(	glp_tree *	tree,
		void *	info
	)

Definition at line 39 of file MLSampling.C.

References QUESO::BaseEnvironment::displayVerbosity(), and QUESO::BaseEnvironment::subDisplayFile().

{
  const BaseEnvironment& env = *(((BIP_routine_struct *) info)->env);
  unsigned int currLevel            =   ((BIP_routine_struct *) info)->currLevel;

  int reason = glp_ios_reason(tree);

  if ((env.subDisplayFile()) && (env.displayVerbosity() >= 1)) {
    *env.subDisplayFile() << "In BIP_routine()"
                          << ", level " << currLevel+LEVEL_REF_ID
                          << ": glp_ios_reason() = " << reason
                          << std::endl;
  }
  std::cout << "In BIP_routine: reason = " << reason << std::endl;

  switch (reason) {
    case GLP_IROWGEN: // 0x01  /* request for row generation       */
      sleep(1);
    break;

    case GLP_IBINGO:  // 0x02  /* better integer solution found    */
      sleep(1);
    break;

    case GLP_IHEUR:   // 0x03  /* request for heuristic solution   */
      // Do nothing
    break;

    case GLP_ICUTGEN: // 0x04  /* request for cut generation       */
      // Do nothing
    break;

    case GLP_IBRANCH: // 0x05  /* request for branching            */
      // Do nothing
    break;

    case GLP_ISELECT: // 0x06  /* request for subproblem selection */
      // Do nothing
    break;

    case GLP_IPREPRO: // 0x07  /* request for preprocessing        */
      // Do nothing
    break;

    default:
      queso_error_msg("invalid glp_ios_readon");
    break;
  }

  return;
}

template void QUESO::BoostInputOptionsParser::getOption< std::string >	(	const std::string &	,
		std::string &
	)		const

template<>

void QUESO::BoostInputOptionsParser::getOption< std::vector< double, std::allocator< double > > >	(	const std::string &	name,
		std::vector< double, std::allocator< double > > &	value
	)		const

Definition at line 142 of file BoostInputOptionsParser.C.

References MiscReadDoublesFromString().

{
  queso_deprecated();
  if (m_scannedInputFile) {
    // Need to reset value?

    // Get the option as a string
    // DM:  Why do it this way?  Doesn't boost support vectors as input options?
    std::string optionValue;
    this->getOption<std::string>(name, optionValue);
    MiscReadDoublesFromString(optionValue, value);
  }
}

template void QUESO::BoostInputOptionsParser::getOption< std::vector< unsigned int, std::allocator< unsigned int > > >	(	const std::string &	,
		std::vector< unsigned int, std::allocator< unsigned int > > &
	)		const

template void QUESO::BoostInputOptionsParser::registerOption< std::string >	(	const std::string &	,
		const std::string &	,
		const std::string &
	)

double QUESO::c_evaluate	(	const gsl_vector *	x,
		void *	context
	)

Definition at line 43 of file GslOptimizer.C.

References QUESO::GslOptimizer::objectiveFunction().

Referenced by c_evaluate_with_derivative(), QUESO::GslOptimizer::minimize_no_gradient(), and QUESO::GslOptimizer::minimize_with_gradient().

                                                          {

    GslOptimizer * optimizer = static_cast<GslOptimizer * >(context);

    GslVector state(
        optimizer->objectiveFunction().domainSet().vectorSpace().zeroVector());

    // DM: Doing this copy sucks, but whatever.  It'll do for now.
    for (unsigned int i = 0; i < state.sizeLocal(); i++) {
      state[i] = gsl_vector_get(x, i);
    }

    // Bail early if GSL tries to evaluate outside of the domain
    if (!optimizer->objectiveFunction().domainSet().contains(state)) {
      return GSL_NAN;
    }

    // Should cache derivative here so we don't recompute stuff
    double result = -optimizer->objectiveFunction().lnValue(state);

    return result;
  }

void QUESO::c_evaluate_derivative	(	const gsl_vector *	x,
		void *	context,
		gsl_vector *	derivative
	)

Definition at line 67 of file GslOptimizer.C.

References QUESO::BaseOptimizer::getFiniteDifferenceStepSize(), and QUESO::GslOptimizer::objectiveFunction().

Referenced by c_evaluate_with_derivative(), and QUESO::GslOptimizer::minimize_with_gradient().

                               {
    GslOptimizer * optimizer = static_cast<GslOptimizer * >(context);

    GslVector state(
        optimizer->objectiveFunction().domainSet().vectorSpace().zeroVector());
    GslVector deriv(
        optimizer->objectiveFunction().domainSet().vectorSpace().zeroVector());

    // DM: Doing this copy sucks, but whatever.  It'll do for now.
    for (unsigned int i = 0; i < state.sizeLocal(); i++) {
      state[i] = gsl_vector_get(x, i);

      // We fill with GSL_NAN and use it as a flag to check later that the user
      // actually fills the derivative vector with stuff
      deriv[i] = GSL_NAN;
    }

    if (!optimizer->objectiveFunction().domainSet().contains(state)) {
      // Fill derivative with error codes if the point is outside of the
      // domain
      for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
        gsl_vector_set(derivative, i, GSL_NAN);
      }
    }
    else {
      // We should cache the return value here so we don't recompute stuff
      double fx = -optimizer->objectiveFunction().lnValue(state, deriv);

      // Decide whether or not we need to do a finite difference based on
      // whether the user actually filled deriv with values that are not
      // GSL_NAN
      //
      // We're currently doing this check every time this function gets called.
      // We could probably pull this logic out of here and put it somewhere
      // where it only happens once
      bool userComputedDerivative = true;
      for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
        // If the user missed out a derivative in any direction, fall back to
        // a finite difference
        if (gsl_isnan(deriv[i])) {
          userComputedDerivative = false;
          break;
        }
      }

      if (userComputedDerivative) {
        for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
          gsl_vector_set(derivative, i, -deriv[i]);  // We need the minus sign
        }
      }
      else {
        // Finite difference step-size
        double h = optimizer->getFiniteDifferenceStepSize();

        // User did not provide a derivative, so do a finite difference
        for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
          double tempState = state[i];
          state[i] += h;

          // User didn't provide a derivative, so we don't bother passing in
          // the derivative vector again
          double fxph = -optimizer->objectiveFunction().lnValue(state);

          // Reset the state back to what it was before
          state[i] = tempState;

          // Make sure we didn't do anything dumb and tell gsl if we did
          if (!gsl_isnan(fx) && !gsl_isnan(fxph)) {
            gsl_vector_set(derivative, i, (fxph - fx) / h);
          }
          else {
            gsl_vector_set(derivative, i, GSL_NAN);
          }
        }
      }
    }
  }

void QUESO::c_evaluate_with_derivative	(	const gsl_vector *	x,
		void *	context,
		double *	f,
		gsl_vector *	derivative
	)

Definition at line 147 of file GslOptimizer.C.

References c_evaluate(), and c_evaluate_derivative().

Referenced by QUESO::GslOptimizer::minimize_with_gradient().

                                           {
    // We don't need to call both of these
    *f = c_evaluate(x, context);
    c_evaluate_derivative(x, context, derivative);
  }

int QUESO::CheckFilePath

(

const char *

pathname

)

int CheckFilePath(const char *path) {

// verify parent directories in path exist (and create if not).

ifdef HAVE_GRVY return(grvy_check_file_path(path)); else

return 0; endif }

Definition at line 362 of file Miscellaneous.C.

References GRVY_CheckDir().

Referenced by QUESO::FullEnvironment::construct(), QUESO::InfiniteDimensionalMCMCSampler::InfiniteDimensionalMCMCSampler(), QUESO::BaseEnvironment::openInputFile(), QUESO::BaseEnvironment::openOutputFile(), QUESO::BaseEnvironment::openUnifiedInputFile(), and QUESO::BaseEnvironment::openUnifiedOutputFile().

  {

    // verify parent directories in path exist (and create if not).

#ifdef HAVE_GRVY
    return(grvy_check_file_path(pathname));
#else

    const int MAX_DEPTH = 50;

    char *pathlocal;
    char *parents;
    char *dirstring;
    char *token;
    int depth = 0;

    // Save a copy of pathname and look for the parent directories.

    pathlocal = strdup(pathname);
    dirstring = strdup(pathname);
    parents   = dirname(pathlocal);

    if(strcmp(parents,".") == 0)
      {
        free(pathlocal);
        free(dirstring);
        return 0;
      }

    // Deal with the possibility of an absolute path being provided

    bool abs_path = false;

    std::string leading_char("");
    std::string path_to_check;

    if(strncmp(parents,"/",1) == 0)
      {
        leading_char = "/";
        abs_path     = true;
      }

    // Verify existence of top-level directory

    if( (token = strtok(parents,"/")) != NULL )
      {
        path_to_check += leading_char + token;

        if ( GRVY_CheckDir(path_to_check.c_str()) )
          {
            free(pathlocal);
            free(dirstring);
            return -1;
          }

        // Now, search for any remaining parent directories.

        if(abs_path)
          sprintf(dirstring,"/%s",token);
        else
          sprintf(dirstring,"%s",token);

        while ( (token = strtok(0,"/")) && (depth < MAX_DEPTH) )
          {
            dirstring = strcat(dirstring,"/");

            if(GRVY_CheckDir(strcat(dirstring,token)))
              {
                free(pathlocal);
                free(dirstring);
                return -1;
              }
            depth++;
          };

        if(depth >= MAX_DEPTH )
          {
            std::cerr << __func__ << ": error - Max directory depth exceeded, limit =  " << MAX_DEPTH << std::endl;
            free(pathlocal);
            free(dirstring);
            return -1;
          }
      }

    // Clean Up
    free(pathlocal);
    free(dirstring);

    return 0;
#endif
  }

QUESO::checkOptions

(

)

template<class V , class M >

void QUESO::ComputeConditionalGaussianVectorRV	(	const V &	muVec1,
		const V &	muVec2,
		const M &	sigmaMat11,
		const M &	sigmaMat12,
		const M &	sigmaMat21,
		const M &	sigmaMat22,
		const V &	sampleVec2,
		V &	muVec1_cond_on_2,
		M &	sigmaMat11_cond_on_2
	)

Definition at line 207 of file GaussianVectorRV.C.

References queso_require_equal_to_msg, and QUESO::BaseEnvironment::subDisplayFile().

{
  const BaseEnvironment& env = muVec1.env();
  unsigned int dim1 = muVec1.sizeLocal();
  unsigned int dim2 = muVec2.sizeLocal();

  queso_require_msg(!((sigmaMat11.numRowsLocal() != dim1) || (sigmaMat11.numCols() != dim1)), "invalid sigmaMat11");

  queso_require_msg(!((sigmaMat12.numRowsLocal() != dim1) || (sigmaMat12.numCols() != dim2)), "invalid sigmaMat12");

  queso_require_msg(!((sigmaMat21.numRowsLocal() != dim2) || (sigmaMat21.numCols() != dim1)), "invalid sigmaMat21");

  queso_require_msg(!((sigmaMat22.numRowsLocal() != dim2) || (sigmaMat22.numCols() != dim2)), "invalid sigmaMat22");

  // Check transpose operation
  M mat_tt(sigmaMat12);
  mat_tt.cwSet(0.);
  mat_tt.fillWithTranspose(0,0,sigmaMat21,true,true);
  double auxNorm = (mat_tt - sigmaMat12).normFrob();
  if (auxNorm >= 1.e-12) {
    if (env.subDisplayFile()) {
      *env.subDisplayFile() << "In ComputeConditionalGaussianVectorRV()"
                            << ": WARNING, ||sigmaMat21^T - sigmaMat12||_2 = " << auxNorm
                            << std::endl;
    }
  }
  queso_require_less_msg(auxNorm, 1.e-12, "sigmaMat12 and sigmaMat21 are not transpose of each other");

  queso_require_equal_to_msg(sampleVec2.sizeLocal(), dim2, "invalid sampleVec2");

  queso_require_equal_to_msg(muVec1_cond_on_2.sizeLocal(), dim1, "invalid muVec1_cond_on_2");

  queso_require_msg(!((sigmaMat11_cond_on_2.numRowsLocal() != dim1) || (sigmaMat11_cond_on_2.numCols() != dim1)), "invalid sigmaMat11_cond_on_2");

  muVec1_cond_on_2     = muVec1     + sigmaMat12 * sigmaMat22.invertMultiply(sampleVec2 - muVec2);
  sigmaMat11_cond_on_2 = sigmaMat11 - sigmaMat12 * sigmaMat22.invertMultiply(sigmaMat21);

  return;
}

template<class T >

void QUESO::ComputeCovCorrBetweenScalarSequences	(	const ScalarSequence< T > &	subPSeq,
		const ScalarSequence< T > &	subQSeq,
		unsigned int	subNumSamples,
		T &	covValue,
		T &	corrValue
	)

Definition at line 4040 of file ScalarSequence.C.

References QUESO::ScalarSequence< T >::env(), QUESO::BaseEnvironment::inter0Comm(), QUESO::BaseEnvironment::inter0Rank(), QUESO::ScalarSequence< T >::subSequenceSize(), QUESO::ScalarSequence< T >::unifiedMeanExtra(), and QUESO::ScalarSequence< T >::unifiedSampleVarianceExtra().

Referenced by ComputeSubGaussian2dKde().

{
  // Check input data consistency
  const BaseEnvironment& env = subPSeq.env();

  queso_require_msg(!((subNumSamples > subPSeq.subSequenceSize()) || (subNumSamples > subQSeq.subSequenceSize())), "subNumSamples is too large");

  // For both P and Q vector sequences: fill them
  T tmpP = 0.;
  T tmpQ = 0.;

  // For both P and Q vector sequences: compute the unified mean
  T unifiedMeanP = subPSeq.unifiedMeanExtra(true,0,subNumSamples);
  T unifiedMeanQ = subQSeq.unifiedMeanExtra(true,0,subNumSamples);

  // Compute "sub" covariance matrix
  covValue = 0.;
  for (unsigned k = 0; k < subNumSamples; ++k) {
    // For both P and Q vector sequences: get the difference (wrt the unified mean) in them
    tmpP = subPSeq[k] - unifiedMeanP;
    tmpQ = subQSeq[k] - unifiedMeanQ;
    covValue += tmpP*tmpQ;
  }

  // For both P and Q vector sequences: compute the unified variance
  T unifiedSampleVarianceP = subPSeq.unifiedSampleVarianceExtra(true,
                                                                0,
                                                                subNumSamples,
                                                                unifiedMeanP);

  T unifiedSampleVarianceQ = subQSeq.unifiedSampleVarianceExtra(true,
                                                                0,
                                                                subNumSamples,
                                                                unifiedMeanQ);

  // Compute unified covariance
  if (env.inter0Rank() >= 0) {
    unsigned int unifiedNumSamples = 0;
    env.inter0Comm().template Allreduce<unsigned int>(&subNumSamples, &unifiedNumSamples, (int) 1, RawValue_MPI_SUM,
                               "ComputeCovCorrBetweenScalarSequences()",
                               "failed MPI.Allreduce() for subNumSamples");

    double aux = 0.;
    env.inter0Comm().template Allreduce<double>(&covValue, &aux, (int) 1, RawValue_MPI_SUM,
                               "ComputeCovCorrBetweenScalarSequences()",
                               "failed MPI.Allreduce() for a matrix position");
    covValue = aux/((double) (unifiedNumSamples-1)); // Yes, '-1' in order to compensate for the 'N-1' denominator factor in the calculations of sample variances above (whose square roots will be used below)

    corrValue = covValue/std::sqrt(unifiedSampleVarianceP)/std::sqrt(unifiedSampleVarianceQ);

    if ((corrValue < -1.) || (corrValue > 1.)) { // prudencio 2010-07-23
      std::cerr << "In ComputeCovCorrBetweenScalarSequences()"
                << ": computed correlation is out of range, corrValue = " << corrValue
                << std::endl;
    }

    //                    env.worldRank(),
    //                    "ComputeCovCorrBetweenScalarSequences()",
    //                    "computed correlation is out of range");
  }
  else {
    // Node not in the 'inter0' communicator: do nothing extra
  }

  return;
}

template<class P_V , class P_M , class Q_V , class Q_M >

void QUESO::ComputeCovCorrMatricesBetweenVectorRvs	(	const BaseVectorRV< P_V, P_M > &	paramRv,
		const BaseVectorRV< Q_V, Q_M > &	qoiRv,
		unsigned int	localNumSamples,
		P_M &	pqCovMatrix,
		P_M &	pqCorrMatrix
	)

Definition at line 209 of file VectorRV.C.

References ComputeCovCorrMatricesBetweenVectorSequences(), QUESO::BaseVectorRV< V, M >::imageSet(), QUESO::VectorSpace< V, M >::numOfProcsForStorage(), QUESO::BaseVectorRealizer< V, M >::realization(), QUESO::BaseVectorRV< V, M >::realizer(), QUESO::VectorSet< V, M >::vectorSpace(), and QUESO::VectorSpace< V, M >::zeroVector().

{
  // Check input data consistency
  bool useOnlyInter0Comm = (paramRv.imageSet().vectorSpace().numOfProcsForStorage() == 1) &&
                           (qoiRv.imageSet().vectorSpace().numOfProcsForStorage()   == 1);

  queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet");

  unsigned int numRows = paramRv.imageSet().vectorSpace().dim();
  unsigned int numCols = qoiRv.imageSet().vectorSpace().dim();

  queso_require_msg(!((numRows != pqCovMatrix.numRows()) || (numCols != pqCovMatrix.numCols())), "inconsistent dimensions for covariance matrix");

  queso_require_msg(!((numRows != pqCorrMatrix.numRows()) || (numCols != pqCorrMatrix.numCols())), "inconsistent dimensions for correlation matrix");

  queso_require_msg(!((localNumSamples > paramRv.realizer().period()) || (localNumSamples > qoiRv.realizer().period())), "localNumSamples is too large");

  // For both P and Q vector sequences: fill them
  P_V tmpP(paramRv.imageSet().vectorSpace().zeroVector());
  Q_V tmpQ(qoiRv.imageSet().vectorSpace().zeroVector());

  SequenceOfVectors<P_V,P_M> localWorkingPSeq(paramRv.imageSet().vectorSpace(),
                                                     localNumSamples,
                                                     "covTmpP");
  SequenceOfVectors<Q_V,Q_M> localWorkingQSeq(qoiRv.imageSet().vectorSpace(),
                                                     localNumSamples,
                                                     "covTmpQ");
  for (unsigned int k = 0; k < localNumSamples; ++k) {
    paramRv.realizer().realization(tmpP);
    localWorkingPSeq.setPositionValues(k,tmpP);

    qoiRv.realizer().realization(tmpQ);
    localWorkingQSeq.setPositionValues(k,tmpQ);
  }

  ComputeCovCorrMatricesBetweenVectorSequences(localWorkingPSeq,
                                                 localWorkingQSeq,
                                                 localNumSamples,
                                                 pqCovMatrix,
                                                 pqCorrMatrix);

  return;
}

template<class P_V , class P_M , class Q_V , class Q_M >

void QUESO::ComputeCovCorrMatricesBetweenVectorSequences	(	const BaseVectorSequence< P_V, P_M > &	subPSeq,
		const BaseVectorSequence< Q_V, Q_M > &	subQSeq,
		unsigned int	subNumSamples,
		P_M &	pqCovMatrix,
		P_M &	pqCorrMatrix
	)

Definition at line 2774 of file VectorSequence.C.

References QUESO::MpiComm::Barrier(), QUESO::VectorSpace< V, M >::dimGlobal(), QUESO::VectorSpace< V, M >::dimLocal(), QUESO::BaseVectorSequence< V, M >::getPositionValues(), QUESO::BaseEnvironment::inter0Comm(), QUESO::BaseEnvironment::inter0Rank(), QUESO::VectorSpace< V, M >::numOfProcsForStorage(), QUESO::BaseVectorSequence< V, M >::subSequenceSize(), QUESO::BaseVectorSequence< V, M >::unifiedMeanExtra(), QUESO::BaseVectorSequence< V, M >::unifiedSampleVarianceExtra(), QUESO::BaseVectorSequence< V, M >::vectorSpace(), QUESO::BaseEnvironment::worldRank(), and QUESO::VectorSpace< V, M >::zeroVector().

Referenced by QUESO::BaseVectorSequence< V, M >::computeCovCorrMatrices(), ComputeCovCorrMatricesBetweenVectorRvs(), and QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::solveWithMonteCarlo().

{
  queso_require_greater_equal_msg(subNumSamples, 2,
      "must provide at least 2 samples to compute correlation matrices");

  // Check input data consistency
  const BaseEnvironment& env = subPSeq.vectorSpace().zeroVector().env();

  bool useOnlyInter0Comm = (subPSeq.vectorSpace().numOfProcsForStorage() == 1) &&
                           (subQSeq.vectorSpace().numOfProcsForStorage() == 1);

  queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet");

  unsigned int numRowsLocal = subPSeq.vectorSpace().dimLocal();
  unsigned int numCols = subQSeq.vectorSpace().dimGlobal();

  queso_require_msg(!((numRowsLocal != pqCovMatrix.numRowsLocal()) || (numCols != pqCovMatrix.numCols())), "inconsistent dimensions for covariance matrix");

  queso_require_msg(!((numRowsLocal != pqCorrMatrix.numRowsLocal()) || (numCols != pqCorrMatrix.numCols())), "inconsistent dimensions for correlation matrix");

  queso_require_msg(!((subNumSamples > subPSeq.subSequenceSize()) || (subNumSamples > subQSeq.subSequenceSize())), "subNumSamples is too large");

  // For both P and Q vector sequences: fill them
  P_V tmpP(subPSeq.vectorSpace().zeroVector());
  Q_V tmpQ(subQSeq.vectorSpace().zeroVector());

  // For both P and Q vector sequences: compute the unified mean
  P_V unifiedMeanP(subPSeq.vectorSpace().zeroVector());
  subPSeq.unifiedMeanExtra(0,subNumSamples,unifiedMeanP);

  Q_V unifiedMeanQ(subQSeq.vectorSpace().zeroVector());
  subQSeq.unifiedMeanExtra(0,subNumSamples,unifiedMeanQ);

  // Compute "sub" covariance matrix
  for (unsigned i = 0; i < numRowsLocal; ++i) {
    for (unsigned j = 0; j < numCols; ++j) {
      pqCovMatrix(i,j) = 0.;
    }
  }
  for (unsigned k = 0; k < subNumSamples; ++k) {
    // For both P and Q vector sequences: get the difference (wrt the unified mean) in them
    subPSeq.getPositionValues(k,tmpP);
    tmpP -= unifiedMeanP;

    subQSeq.getPositionValues(k,tmpQ);
    tmpQ -= unifiedMeanQ;

    for (unsigned i = 0; i < numRowsLocal; ++i) {
      for (unsigned j = 0; j < numCols; ++j) {
        pqCovMatrix(i,j) += tmpP[i]*tmpQ[j];
      }
    }
  }

  // For both P and Q vector sequences: compute the unified variance
  P_V unifiedSampleVarianceP(subPSeq.vectorSpace().zeroVector());
  subPSeq.unifiedSampleVarianceExtra(0,
                                     subNumSamples,
                                     unifiedMeanP,
                                     unifiedSampleVarianceP);

  Q_V unifiedSampleVarianceQ(subQSeq.vectorSpace().zeroVector());
  subQSeq.unifiedSampleVarianceExtra(0,
                                     subNumSamples,
                                     unifiedMeanQ,
                                     unifiedSampleVarianceQ);

  // Check the variance is positive in every component
  double minSampleVarianceP;
  double minSampleVarianceQ;
  minSampleVarianceP = unifiedSampleVarianceP.getMinValue();
  minSampleVarianceQ = unifiedSampleVarianceQ.getMinValue();
  queso_require_greater_msg(minSampleVarianceP, 0.0, "sample variance is not positive");
  queso_require_greater_msg(minSampleVarianceQ, 0.0, "sample variance is not positive");

  // Compute unified covariance matrix
  if (useOnlyInter0Comm) {
    if (env.inter0Rank() >= 0) {
      unsigned int unifiedNumSamples = 0;
      env.inter0Comm().template Allreduce<unsigned int>(&subNumSamples, &unifiedNumSamples, (int) 1, RawValue_MPI_SUM,
                                 "ComputeCovCorrMatricesBetweenVectorSequences()",
                                 "failed MPI.Allreduce() for subNumSamples");

      for (unsigned i = 0; i < numRowsLocal; ++i) {
        for (unsigned j = 0; j < numCols; ++j) {
          double aux = 0.;
          env.inter0Comm().template Allreduce<double>(&pqCovMatrix(i,j), &aux, (int) 1, RawValue_MPI_SUM,
                                     "ComputeCovCorrMatricesBetweenVectorSequences()",
                                     "failed MPI.Allreduce() for a matrix position");
          pqCovMatrix(i,j) = aux/((double) (unifiedNumSamples-1)); // Yes, '-1' in order to compensate for the 'N-1' denominator factor in the calculations of sample variances above (whose square roots will be used below)
        }
      }

      for (unsigned i = 0; i < numRowsLocal; ++i) {
        for (unsigned j = 0; j < numCols; ++j) {
          pqCorrMatrix(i,j) = pqCovMatrix(i,j)/std::sqrt(unifiedSampleVarianceP[i])/std::sqrt(unifiedSampleVarianceQ[j]);
          if (((pqCorrMatrix(i,j) + 1.) < -1.e-8) ||
              ((pqCorrMatrix(i,j) - 1.) >  1.e-8)) {
            if (env.inter0Rank() == 0) {
              std::cerr << "In ComputeCovCorrMatricesBetweenVectorSequences()"
                        << ": worldRank = "            << env.worldRank()
                        << ", i = "                   << i
                        << ", j = "                   << j
                        << ", pqCorrMatrix(i,j)+1 = " << pqCorrMatrix(i,j)+1.
                        << ", pqCorrMatrix(i,j)-1 = " << pqCorrMatrix(i,j)-1.
                        << std::endl;
            }
            env.inter0Comm().Barrier();
          }
          queso_require_greater_equal_msg
            (pqCorrMatrix(i,j), -1. - 1.e-8,
             "computed correlation is out of range");
          queso_require_less_equal_msg
            (pqCorrMatrix(i,j), 1. + 1.e-8,
             "computed correlation is out of range");
        }
      }
    }
    else {
      // Node not in the 'inter0' communicator: do nothing extra
    }
  }
  else {
    queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet (2)");
  }

  return;
}

double QUESO::computeMI_ANN	(	ANNpointArray	dataXY,
		unsigned int	dimX,
		unsigned int	dimY,
		unsigned int	k,
		unsigned int	N,
		double	eps
	)

Computes the mutual information

Definition at line 161 of file InfoTheory_impl.h.

References annAllocPts(), annDeallocPts(), ANNkd_tree::annkFRSearch(), distANN_XY(), and normalizeANN_XY().

Referenced by estimateMI_ANN().

{

  ANNpointArray dataX, dataY;
  double* distsXY;
  double MI_est;
  ANNkd_tree* kdTreeX;
  ANNkd_tree* kdTreeY;

  unsigned int dimXY = dimX + dimY;

  // Allocate memory
  dataX = annAllocPts(N,dimX);
  dataY = annAllocPts(N,dimY);
  distsXY = new double[N];

  // Normalize data and populate the marginals dataX, dataY
  normalizeANN_XY( dataXY, dimXY, dataX, dimX, dataY, dimY, N);

  // Get distance to knn for each point
  kdTreeX = new ANNkd_tree( dataX, N, dimX );
  kdTreeY = new ANNkd_tree( dataY, N, dimY );
  distANN_XY( dataXY, dataXY, distsXY, dimXY, dimXY, N, N, k, eps );

  // Compute mutual information
  double marginal_contrib = 0.0;
  for( unsigned int i = 0; i < N; i++ ) {
    // get the number of points within a specified radius
    int no_pts_X = kdTreeX->annkFRSearch( dataX[ i ], distsXY[ i ], 0, NULL, NULL, eps);
    int no_pts_Y = kdTreeY->annkFRSearch( dataY[ i ], distsXY[ i ], 0, NULL, NULL, eps);
    // digamma evaluations
    marginal_contrib += gsl_sf_psi_int( no_pts_X+1 ) + gsl_sf_psi_int( no_pts_Y+1 );
  }
  MI_est = gsl_sf_psi_int( k ) + gsl_sf_psi_int( N ) - marginal_contrib / (double)N;

  // Deallocate memory
  delete kdTreeX;
  delete kdTreeY;
  delete [] distsXY;
  annDeallocPts( dataX );
  annDeallocPts( dataY );

  return MI_est;

}

template<class T >

void QUESO::ComputeSubGaussian2dKde	(	const ScalarSequence< T > &	scalarSeq1,
		const ScalarSequence< T > &	scalarSeq2,
		unsigned int	initialPos,
		double	scaleValue1,
		double	scaleValue2,
		const std::vector< T > &	evaluationPositions1,
		const std::vector< T > &	evaluationPositions2,
		std::vector< double > &	densityValues
	)

Definition at line 3931 of file ScalarSequence.C.

References ComputeCovCorrBetweenScalarSequences(), queso_require_equal_to_msg, and QUESO::ScalarSequence< T >::subSequenceSize().

Referenced by ComputeUnifiedGaussian2dKde().

{
  queso_require_equal_to_msg(initialPos, 0, "not implemented yet for initialPos != 0");

  double covValue  = 0.;
  double corrValue = 0.;
  ComputeCovCorrBetweenScalarSequences(scalarSeq1,
                                         scalarSeq2,
                                         scalarSeq1.subSequenceSize(),
                                         covValue,
                                         corrValue);

  bool bRC = ((initialPos                   <  scalarSeq1.subSequenceSize()) &&
              (scalarSeq1.subSequenceSize() == scalarSeq2.subSequenceSize()) &&
              (0                            <  evaluationPositions1.size() ) &&
              (evaluationPositions1.size()  == evaluationPositions2.size() ) &&
              (evaluationPositions1.size()  == densityValues.size()        ));
  queso_require_msg(bRC, "invalid input data");

  unsigned int dataSize = scalarSeq1.subSequenceSize() - initialPos;
  unsigned int numEvals = evaluationPositions1.size();

  double scale1Inv = 1./scaleValue1;
  double scale2Inv = 1./scaleValue2;
  //corrValue = 0.;
  double r = 1. - corrValue*corrValue;
  if (r <= 0.) { // prudencio 2010-07-23
    std::cerr << "In ComputeSubGaussian2dKde()"
              << ": WARNING, r = " << r
              << std::endl;
  }

  //                    scalarSeq1.env().worldRank(),
  //                    "ComputeSubGaussian2dKde()",
  //                    "negative r");
  for (unsigned int j = 0; j < numEvals; ++j) {
    double x1 = evaluationPositions1[j];
    double x2 = evaluationPositions2[j];
    double value = 0.;
    for (unsigned int k = 0; k < dataSize; ++k) {
      double d1k = scale1Inv*(x1 - scalarSeq1[initialPos+k]);
      double d2k = scale2Inv*(x2 - scalarSeq2[initialPos+k]);
      value += exp(-.5*( d1k*d1k + 2*corrValue*d1k*d2k + d2k*d2k )/r);
    }
    densityValues[j] = scale1Inv * scale2Inv * (value/(double) dataSize) / 2. / M_PI / sqrt(r);
  }

  return;
}

template<class T >

void QUESO::ComputeUnifiedGaussian2dKde	(	bool	useOnlyInter0Comm,
		const ScalarSequence< T > &	scalarSeq1,
		const ScalarSequence< T > &	scalarSeq2,
		unsigned int	initialPos,
		double	unifiedScaleValue1,
		double	unifiedScaleValue2,
		const std::vector< T > &	unifiedEvaluationPositions1,
		const std::vector< T > &	unifiedEvaluationPositions2,
		std::vector< double > &	unifiedDensityValues
	)

Definition at line 3990 of file ScalarSequence.C.

References ComputeSubGaussian2dKde(), QUESO::ScalarSequence< T >::env(), QUESO::BaseEnvironment::inter0Rank(), and QUESO::BaseEnvironment::numSubEnvironments().

{
  if (scalarSeq1.env().numSubEnvironments() == 1) {
    return ComputeSubGaussian2dKde(scalarSeq1,
                                     scalarSeq2,
                                     initialPos,
                                     unifiedScaleValue1,
                                     unifiedScaleValue2,
                                     unifiedEvaluationPositions1,
                                     unifiedEvaluationPositions2,
                                     unifiedDensityValues);
  }

  // As of 14/Nov/2009, this routine needs to be checked if it requires sub sequences to have equal size. Good.

  if (useOnlyInter0Comm) {
    if (scalarSeq1.env().inter0Rank() >= 0) {
      queso_error_msg("inter0 case not supported yet");
    }
    else {
      // Node not in the 'inter0' communicator
      ComputeSubGaussian2dKde(scalarSeq1,
                                scalarSeq2,
                                initialPos,
                                unifiedScaleValue1,
                                unifiedScaleValue2,
                                unifiedEvaluationPositions1,
                                unifiedEvaluationPositions2,
                                unifiedDensityValues);
    }
  }
  else {
    queso_error_msg("parallel vectors not supported yet");
  }

  //scalarSeq1.env().fullComm().Barrier();

  return;
}

template<class V , class M >

void QUESO::CovCond	(	double	condNumber,
		const V &	direction,
		M &	covMatrix,
		M &	precMatrix
	)

Definition at line 30 of file CovCond.C.

References leftDiagScaling(), and matrixProduct().

{
  //std::cout << "Entering CovCond()"
  //          << std::endl;

  V v1(direction);
  //std::cout << "In CovCond(), v1 contents are:"
  //          << std::endl
  //          << v1
  //          << std::endl;

  V v2(direction,condNumber,1.0); // MATLAB linspace
  v2.cwInvert();
  v2.sort();
  //std::cout << "In CovCond(), v2 contents are:"
  //          << std::endl
  //          << v2
  //          << std::endl;

  double v1Norm2 = v1.norm2();
  if (v1[0] >=0) v1[0] += v1Norm2;
  else           v1[0] -= v1Norm2;
  double v1Norm2Sq = v1.norm2Sq();

  M Z(direction,1.0);
  Z -= (2./v1Norm2Sq) * matrixProduct(v1,v1);
  //std::cout << "In CovCond(), Z contents are:"
  //          << std::endl
  //          << Z
  //          << std::endl;

  M Zt(Z.transpose());
  covMatrix  = Z * leftDiagScaling(v2,   Zt);
  precMatrix = Z * leftDiagScaling(1./v2,Zt);

  //std::cout << "Leaving CovCond()"
  //          << std::endl;
}

void QUESO::distANN_XY	(	const ANNpointArray	dataX,
		const ANNpointArray	dataY,
		double *	distsXY,
		unsigned int	dimX,
		unsigned int	dimY,
		unsigned int	xN,
		unsigned int	yN,
		unsigned int	k,
		double	eps
	)

For each point q in dataX, this performs a k-Nearest Neighbours search of the points in dataY closest to q. The array distsXY is filled with the distance from q to the k-th nearest neighbour.

Definition at line 40 of file InfoTheory_impl.h.

References annClose(), and ANNkd_tree::annkSearch().

Referenced by computeMI_ANN(), estimateCE_ANN(), QUESO::BaseVectorRV< V, M >::estimateENT_ANN(), and estimateKL_ANN().

{

  ANNkd_tree* kdTree;
  ANNdistArray nnDist;
  ANNidxArray nnIdx;

  // Allocate memory
  nnIdx = new ANNidx[ k+1 ];
  nnDist = new ANNdist[ k+1 ];
  kdTree = new ANNkd_tree( dataY, yN, dimY );

  // Get the distances to all the points
  for( unsigned int i = 0; i < xN ; i++ )
    {
      kdTree->annkSearch( dataX[ i ], k+1, nnIdx, nnDist, eps );

      double my_dist = nnDist[ k ];

      // check to see if the dist is zero (query point same as the kNN)
      // if so find the next k that gives the next positive distance
      if( my_dist == 0.0 )
        {
          ANNdistArray nnDist_tmp = new ANNdist[ yN ];
          ANNidxArray nnIdx_tmp = new ANNidx[ yN ];
          kdTree->annkSearch( dataX[ i ], yN, nnIdx_tmp, nnDist_tmp, eps );

          for( unsigned int my_k = k + 1; my_k < yN; ++my_k )
            if( nnDist_tmp[ my_k ] > 0.0 )
              {
                my_dist = nnDist_tmp[ my_k ];
                break;
              }
          delete [] nnIdx_tmp;
          delete [] nnDist_tmp;
        }

      distsXY[ i ] = my_dist;
    }

  // Deallocate memory
  delete [] nnIdx;
  delete [] nnDist;
  delete kdTree;
  annClose();

  return;
}

template<class P_V , class P_M , template< class P_V, class P_M > class RV_1, template< class P_V, class P_M > class RV_2>

double QUESO::estimateCE_ANN	(	RV_1< P_V, P_M > &	xRV,
		RV_2< P_V, P_M > &	yRV,
		unsigned int	xDimSel[],
		unsigned int	dimX,
		unsigned int	yDimSel[],
		unsigned int	dimY,
		unsigned int	xN,
		unsigned int	yN,
		unsigned int	k,
		double	eps
	)

Function: estimateCE_ANN (Cross Entropy)

Estimates the cross-entropy of two queso random variables xRV and yRV

Definition at line 385 of file InfoTheory_impl.h.

References annAllocPts(), annDeallocPts(), and distANN_XY().

{
  ANNpointArray dataX;
  ANNpointArray dataY;
  double* distsXY;
  double CE_est;

  // sanity check
  if( dimX != dimY ) {
    queso_error_msg("Error-CE: the dimensions should agree");
  }

  // Allocate memory
  dataX = annAllocPts( xN, dimX );
  dataY = annAllocPts( yN, dimY );
  distsXY = new double[xN];

  // Copy X samples in ANN data structure
  P_V xSmpRV( xRV.imageSet().vectorSpace().zeroVector() );
  for( unsigned int i = 0; i < xN; i++ ) {
    // get a sample from the distribution
    xRV.realizer().realization( xSmpRV );
    // copy the vector values in the ANN data structure
    for( unsigned int j = 0; j < dimX; j++ ) {
      dataX[ i ][ j ] = xSmpRV[ xDimSel[j] ];
    }
  }

  // Copy Y samples in ANN data structure
  P_V ySmpRV( yRV.imageSet().vectorSpace().zeroVector() );
  for( unsigned int i = 0; i < yN; i++ ) {
    // get a sample from the distribution
    yRV.realizer().realization( ySmpRV );
    // copy the vector values in the ANN data structure
    for( unsigned int j = 0; j < dimY; j++ ) {
      dataY[ i ][ j ] = ySmpRV[ yDimSel[j] ];
    }
  }

  // Get distance to knn for each point
  distANN_XY( dataX, dataY, distsXY, dimX, dimY, xN, yN, k, eps );

  // Compute cross entropy estimate
  double sum_log = 0.0;
  for( unsigned int i = 0; i < xN; i++ )
    {
      sum_log += log( distsXY[i] );
    }
  CE_est = (double)dimX/(double)xN * sum_log + log( (double)yN ) - gsl_sf_psi_int( k );

  // Deallocate memory
  annDeallocPts( dataX );
  annDeallocPts( dataY );
  delete [] distsXY;

  return CE_est;
}

template<class P_V , class P_M , template< class P_V, class P_M > class RV_1, template< class P_V, class P_M > class RV_2>

double QUESO::estimateKL_ANN	(	RV_1< P_V, P_M > &	xRV,
		RV_2< P_V, P_M > &	yRV,
		unsigned int	xDimSel[],
		unsigned int	dimX,
		unsigned int	yDimSel[],
		unsigned int	dimY,
		unsigned int	xN,
		unsigned int	yN,
		unsigned int	k,
		double	eps
	)

Function: estimateKL_ANN (Kullback-Leibler divergence)

Computes the Kullback-Leibler divergence between two queso random variables xRV and yRV.

Definition at line 310 of file InfoTheory_impl.h.

References annAllocPts(), annDeallocPts(), and distANN_XY().

{
  ANNpointArray dataX;
  ANNpointArray dataY;
  double* distsX;
  double* distsXY;
  double KL_est;

  // sanity check
  if( dimX != dimY ) {
    queso_error_msg("Error-KL: the dimensions should agree");
  }

  // Allocate memory
  dataX = annAllocPts( xN, dimX );
  dataY = annAllocPts( yN, dimY );
  distsX = new double[xN];
  distsXY = new double[xN];

  // Copy X samples in ANN data structure
  P_V xSmpRV( xRV.imageSet().vectorSpace().zeroVector() );
  for( unsigned int i = 0; i < xN; i++ ) {
    // get a sample from the distribution
    xRV.realizer().realization( xSmpRV );
    // copy the vector values in the ANN data structure
    for( unsigned int j = 0; j < dimX; j++ ) {
      dataX[ i ][ j ] = xSmpRV[ xDimSel[j] ];
    }
  }

  // Copy Y samples in ANN data structure
  P_V ySmpRV( yRV.imageSet().vectorSpace().zeroVector() );
  for( unsigned int i = 0; i < yN; i++ ) {
    // get a sample from the distribution
    yRV.realizer().realization( ySmpRV );
    // copy the vector values in the ANN data structure
    for( unsigned int j = 0; j < dimY; j++ ) {
      dataY[ i ][ j ] = ySmpRV[ yDimSel[j] ];
    }
  }

  // Get distance to knn for each point
  distANN_XY( dataX, dataX, distsX, dimX, dimX, xN, xN, k+1, eps ); // k+1 because the 1st nn is itself
  distANN_XY( dataX, dataY, distsXY, dimX, dimY, xN, yN, k, eps );

  // Compute KL-divergence estimate
  double sum_log_ratio = 0.0;
  for( unsigned int i = 0; i < xN; i++ )
    {
      sum_log_ratio += log( distsXY[i] / distsX[i] );
    }
  KL_est = (double)dimX/(double)xN * sum_log_ratio + log( (double)yN / ((double)xN-1.0 ) );

  // Deallocate memory
  annDeallocPts( dataX );
  annDeallocPts( dataY );
  delete [] distsX;
  delete [] distsXY;

  return KL_est;
}

template<template< class P_V, class P_M > class RV, class P_V , class P_M >

double QUESO::estimateMI_ANN	(	const RV< P_V, P_M > &	jointRV,
		const unsigned int	xDimSel[],
		unsigned int	dimX,
		const unsigned int	yDimSel[],
		unsigned int	dimY,
		unsigned int	k,
		unsigned int	N,
		double	eps
	)

Function: estimateMI_ANN (using a joint) (Mutual Information)

Computes the mutual information using a queso joint RV

Definition at line 214 of file InfoTheory_impl.h.

References annAllocPts(), annDeallocPts(), and computeMI_ANN().

{
  ANNpointArray dataXY;
  double MI_est;

  unsigned int dimXY = dimX + dimY;

  // Allocate memory
  dataXY = annAllocPts(N,dimXY);

  // Copy samples in ANN data structure
  P_V smpRV( jointRV.imageSet().vectorSpace().zeroVector() );
  for( unsigned int i = 0; i < N; i++ ) {
    // get a sample from the distribution
    jointRV.realizer().realization( smpRV );

    // copy the vector values in the ANN data structure
    for( unsigned int j = 0; j < dimX; j++ ) {
      dataXY[ i ][ j ] = smpRV[ xDimSel[j] ];
    }
    for( unsigned int j = 0; j < dimY; j++ ) {
      dataXY[ i ][ dimX + j ] = smpRV[ yDimSel[j] ];
    }
    // annPrintPt( dataXY[i], dimXY, std::cout ); std::cout << std::endl;
  }

  MI_est = computeMI_ANN( dataXY,
        dimX, dimY,
        k, N, eps );

  // Deallocate memory
  annDeallocPts( dataXY );

  return MI_est;
}

template<class P_V , class P_M , template< class P_V, class P_M > class RV_1, template< class P_V, class P_M > class RV_2>

double QUESO::estimateMI_ANN	(	const RV_1< P_V, P_M > &	xRV,
		const RV_2< P_V, P_M > &	yRV,
		const unsigned int	xDimSel[],
		unsigned int	dimX,
		const unsigned int	yDimSel[],
		unsigned int	dimY,
		unsigned int	k,
		unsigned int	N,
		double	eps
	)

Function: estimateMI_ANN (using two seperate RVs) (Mutual Information)

Definition at line 260 of file InfoTheory_impl.h.

References annAllocPts(), annDeallocPts(), and computeMI_ANN().

{
  ANNpointArray dataXY;
  double MI_est;

  unsigned int dimXY = dimX + dimY;

  // Allocate memory
  dataXY = annAllocPts(N,dimXY);

  // Copy samples in ANN data structure
  P_V smpRV_x( xRV.imageSet().vectorSpace().zeroVector() );
  P_V smpRV_y( yRV.imageSet().vectorSpace().zeroVector() );

  for( unsigned int i = 0; i < N; i++ ) {
    // get a sample from the distribution
    xRV.realizer().realization( smpRV_x );
    yRV.realizer().realization( smpRV_y );

    // copy the vector values in the ANN data structure
    for( unsigned int j = 0; j < dimX; j++ ) {
      dataXY[ i ][ j ] = smpRV_x[ xDimSel[j] ];
    }
    for( unsigned int j = 0; j < dimY; j++ ) {
      dataXY[ i ][ dimX + j ] = smpRV_y[ yDimSel[j] ];
    }
    // annPrintPt( dataXY[i], dimXY, std::cout ); std::cout << std::endl;
  }

  MI_est = computeMI_ANN( dataXY,
        dimX, dimY,
        k, N, eps );

  // Deallocate memory
  annDeallocPts( dataXY );

  return MI_est;
}

QUESO::for

(

)

Definition at line 123 of file StatisticalForwardProblemOptions.C.

                                          {
    // We default to empty set, so the default values are actually never
    // used here
    unsigned int allowed = env->input()(m_option_dataOutputAllowedSet, i, i);
    m_dataOutputAllowedSet.insert(allowed);
  }

m_parser QUESO::getOption< bool >	(	m_option_computeSolution	,
		m_computeSolution
	)

m_parser QUESO::getOption< bool >	(	m_option_computeCovariances	,
		m_computeCovariances
	)

m_parser QUESO::getOption< bool >	(	m_option_computeCorrelations	,
		m_computeCorrelations
	)

m_parser QUESO::getOption< std::set< unsigned int > >	(	m_option_dataOutputAllowedSet	,
		m_dataOutputAllowedSet
	)

m_parser QUESO::getOption< std::string >	(	m_option_help	,
		m_help
	)

m_parser QUESO::getOption< std::string >	(	m_option_dataOutputFileName	,
		m_dataOutputFileName
	)

m_parser QUESO::getOption< std::string >	(	m_option_solver	,
		m_solver
	)

int QUESO::GRVY_CheckDir

(

const char *

dirname

)

Definition at line 456 of file Miscellaneous.C.

Referenced by CheckFilePath().

{
  struct stat st;

  if(stat(dirname,&st) != 0)
    {
      if( mkdir(dirname,0700) != 0 )
        {
          std::cerr << __func__ << ": error - unable to create directory " << dirname << std::endl;
          return -1;
        }
    }
  else if (!S_ISDIR(st.st_mode))
    {
      std::cerr << __func__ << ": error - entry exists, but is not a directory " << dirname << std::endl;
      return -1;
    }

  return 0;
}

template<class T >

double QUESO::horizontalDistance	(	const BaseScalarCdf< T > &	cdf1,
		const BaseScalarCdf< T > &	cdf2,
		double	epsilon
	)

It calculated the maximum horizontal distance between two CDFs.

Definition at line 96 of file ScalarCdf.C.

References QUESO::BaseEnvironment::displayVerbosity(), QUESO::BaseScalarCdf< T >::env(), QUESO::BaseScalarCdf< T >::inverse(), QUESO::BaseScalarCdf< T >::prefix(), QUESO::BaseEnvironment::subDisplayFile(), and QUESO::BaseScalarCdf< T >::value().

Referenced by horizontalDistances().

{
  double maxDistance     = 0.;
  double xForMaxDistance = 0.;

  double x1 = cdf1.inverse(epsilon*.5);
  double x2 = cdf1.inverse(1.-epsilon*.5);
  if (cdf1.env().subDisplayFile()) {
    *cdf1.env().subDisplayFile() << "In horizontalDistance()"
                                 << ", cdf1.prefix() = " << cdf1.prefix()
                                 << ", cdf2.prefix() = " << cdf2.prefix()
                                 << ", epsilon = "       << epsilon
                                 << ": x1 = "            << x1
                                 << ", x2 = "            << x2
                                 << std::endl;
  }

  //if (cdf1.env().subDisplayFile()) {
  //  *cdf1.env().subDisplayFile() << "In horizontalDistance: x1 = " << x1
  //                              << ", x2 = " << x2
  //                              << std::endl;
  //}

  double numEvaluationPoints = 1001.;
  for (double i = 0.; i < numEvaluationPoints; ++i) {
    double ratio = i/(numEvaluationPoints-1.); // IMPORTANT: Yes, '-1.'
    double x = (1.-ratio)*x1 + ratio*x2;
    double y = cdf2.inverse(cdf1.value(x));
    double d = fabs(x-y);
    if ((cdf1.env().subDisplayFile()) && (cdf1.env().displayVerbosity() >= 3)) {
      *cdf1.env().subDisplayFile() << "In horizontalDistance"
                                   << ": i = "                  << i
                                   << ", x = "                  << x
                                   << ", cdf1.value(x) = "      << cdf1.value(x)
                                   << ", y = "                  << y
                                   << ", d = "                  << d
                                   << ", currentMaxDistance = " << maxDistance
                                   << std::endl;
    }
    if (maxDistance < d) {
      maxDistance     = d;
      xForMaxDistance = x;
      if ((cdf1.env().subDisplayFile()) && (cdf1.env().displayVerbosity() >= 3)) {
        *cdf1.env().subDisplayFile() << "In horizontalDistance"
                                     << ": i = "               << i
                                     << ", NOW maxDistance = " << maxDistance
                                     << ", xForMaxDistance = " << xForMaxDistance
                                     << std::endl;
      }
    }
  }

  if (cdf1.env().subDisplayFile()) {
    *cdf1.env().subDisplayFile() << "In horizontalDistance()"
                                 << ", cdf1.prefix() = "   << cdf1.prefix()
                                 << ", cdf2.prefix() = "   << cdf2.prefix()
                                 << ", epsilon = "         << epsilon
                                 << ": maxDistance = "     << maxDistance
                                 << ", xForMaxDistance = " << xForMaxDistance
                                 << std::endl;
  }

  return maxDistance;
}

template<class V , class M >

void QUESO::horizontalDistances	(	const BaseVectorCdf< V, M > &	cdf1,
		const BaseVectorCdf< V, M > &	cdf2,
		const V &	epsilonVec,
		V &	distances
	)

It calculated the maximum horizontal distances between two vector CDFs.

Definition at line 84 of file VectorCdf.C.

References QUESO::BaseVectorCdf< V, M >::cdf(), horizontalDistance(), and QUESO::BaseVectorCdf< V, M >::pdfSupport().

{
  for (unsigned int i = 0; i < cdf1.pdfSupport().vectorSpace().dimLocal(); ++i) {
    distances[i] = horizontalDistance(cdf1.cdf(i),
                                      cdf2.cdf(i),
                                      epsilonVec[i]);
  }

  return;
}

QUESO::if

(

m_env.subDisplayFile()!

= NULL

)

Definition at line 462 of file MonteCarloSGOptions.C.

References QUESO::BaseEnvironment::subDisplayFile().

                                      {
    *m_env.subDisplayFile() << "In MonteCarloSGOptions::constructor(2)"
                            << ": after setting values of options with prefix '" << m_prefix
                            << "', state of object is:"
                            << "\n" << *this
                            << std::endl;
  }

QUESO::if

(

m_ov.

m_pseqComputeStats

)

template<class V , class M >

VectorSet< V, M > * QUESO::InstantiateIntersection	(	const VectorSet< V, M > &	domain1,
		const VectorSet< V, M > &	domain2
	)

This method calculates the intersection of domain1 and domain2.

It is used, for instance, to calculate the domain of the Posterior PDF, which is the intersection of the domain of the Prior PDF and of the likelihood function.

Definition at line 37 of file InstantiateIntersection.C.

References QUESO::VectorSpace< V, M >::dimGlobal(), QUESO::VectorSpace< V, M >::env(), QUESO::BoxSubset< V, M >::maxValues(), QUESO::BoxSubset< V, M >::minValues(), QUESO::VectorSet< V, M >::prefix(), QUESO::VectorSubset< V, M >::vectorSpace(), and QUESO::VectorSet< V, M >::vectorSpace().

Referenced by QUESO::StatisticalInverseProblem< P_V, P_M >::solveWithBayesMetropolisHastings(), and QUESO::StatisticalInverseProblem< P_V, P_M >::solveWithBayesMLSampling().

{
  VectorSet<V,M>* result = NULL;

  unsigned int dim1 = domain1.vectorSpace().dimGlobal();
  unsigned int dim2 = domain2.vectorSpace().dimGlobal();

  if (result == NULL) {
    const VectorSpace<V,M>* tmp1 = dynamic_cast<const VectorSpace<V,M>* >(&domain1);
    const VectorSpace<V,M>* tmp2 = dynamic_cast<const VectorSpace<V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 < dim2) {
        result = new VectorSpace<V,M>(tmp1->env(),
                                             tmp1->prefix().c_str(),
                                             tmp1->dimGlobal(),
                                             NULL);//tmp1->componentsNames());
      }
      else if (dim1 == dim2) {
        result = new VectorSpace<V,M>(tmp1->env(),
                                             tmp1->prefix().c_str(),
                                             tmp1->dimGlobal(),
                                             NULL);//tmp1->componentsNames());
      }
      else {
        result = new VectorSpace<V,M>(tmp2->env(),
                                             tmp2->prefix().c_str(),
                                             tmp2->dimGlobal(),
                                             NULL);//tmp2->componentsNames());
      }
    }
  }

  if (result == NULL) {
    const VectorSubset<V,M>* tmp1 = dynamic_cast<const VectorSubset<V,M>* >(&domain1);
    const VectorSubset<V,M>* tmp2 = dynamic_cast<const VectorSubset<V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 == dim2) {
        const BoxSubset<V,M>* box1 = dynamic_cast<const BoxSubset<V,M>* >(&domain1);
        const BoxSubset<V,M>* box2 = dynamic_cast<const BoxSubset<V,M>* >(&domain2);

        if ((box1 != NULL) && (box2 != NULL)) {
          V minV(box1->minValues());
          V maxV(box1->maxValues());
          for (unsigned int i = 0; i < dim1; ++i) {
            minV[i] = std::max(box1->minValues()[i],
                               box2->minValues()[i]);
          }
          for (unsigned int i = 0; i < dim1; ++i) {
            maxV[i] = std::min(box1->maxValues()[i],
                               box2->maxValues()[i]);
          }
          result = new BoxSubset<V,M>(box1->prefix().c_str(),
                                             box1->vectorSpace(),
                                             minV,
                                             maxV);
        }
        else {
          result = new IntersectionSubset<V,M>(tmp1->prefix().c_str(),
                                                      tmp1->vectorSpace(),
                                                      0., // FIX ME
                                                      domain1,
                                                      domain2);
        }
      }
      else {
        queso_error_msg("situation 001");
      }
    }
  }

  if (result == NULL) {
    const VectorSubset<V,M>* tmp1 = dynamic_cast<const VectorSubset<V,M>* >(&domain1);
    const VectorSpace <V,M>* tmp2 = dynamic_cast<const VectorSpace <V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 == dim2) {
        const BoxSubset<V,M>* box1 = dynamic_cast<const BoxSubset<V,M>* >(&domain1);
        if (box1 != NULL) {
          result = new BoxSubset<V,M>(box1->prefix().c_str(),
                                             box1->vectorSpace(),
                                             box1->minValues(),
                                             box1->maxValues());
        }
        else {
          queso_error_msg("situation 002");
        }
      }
      else {
        queso_error_msg("situation 003");
      }
    }
  }

  if (result == NULL) {
    const VectorSpace <V,M>* tmp1 = dynamic_cast<const VectorSpace <V,M>* >(&domain1);
    const VectorSubset<V,M>* tmp2 = dynamic_cast<const VectorSubset<V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 == dim2) {
        const BoxSubset<V,M>* box2 = dynamic_cast<const BoxSubset<V,M>* >(&domain2);
        if (box2 != NULL) {
          result = new BoxSubset<V,M>(box2->prefix().c_str(),
                                             box2->vectorSpace(),
                                             box2->minValues(),
                                             box2->maxValues());
        }
        else {
          queso_error_msg("situation 004");
        }
      }
      else {
        queso_error_msg("situation 005");
      }
    }
  }

  if (result == NULL) {
    queso_error_msg("situation 006");
  }

  return result;
}

TeuchosMatrix QUESO::leftDiagScaling	(	const TeuchosVector &	vec,
		const TeuchosMatrix &	mat
	)

Definition at line 2137 of file TeuchosMatrix.C.

References QUESO::TeuchosMatrix::numCols(), QUESO::TeuchosMatrix::numRowsLocal(), queso_require_equal_to_msg, and QUESO::TeuchosVector::sizeLocal().

{
  unsigned int vSize = vec.sizeLocal();
  unsigned int mRows = mat.numRowsLocal();
  unsigned int mCols = mat.numCols();

  queso_require_equal_to_msg(vSize, mRows, "size of vector is different from the number of rows in matrix");

  queso_require_equal_to_msg(mCols, mRows, "routine currently works for square matrices only");

  TeuchosMatrix answer(mat);
  for (unsigned int i = 0; i < mRows; ++i) {
    double vecValue = vec[i];
    for (unsigned int j = 0; j < mCols; ++j) {
      answer(i,j) *= vecValue;
    }
  }

  return answer;
}

GslMatrix QUESO::leftDiagScaling	(	const GslVector &	vec,
		const GslMatrix &	mat
	)

Definition at line 2052 of file GslMatrix.C.

References QUESO::GslMatrix::numCols(), QUESO::GslMatrix::numRowsLocal(), queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

Referenced by CovCond().

{
  unsigned int vSize = vec.sizeLocal();
  unsigned int mRows = mat.numRowsLocal();
  unsigned int mCols = mat.numCols();

  queso_require_equal_to_msg(vSize, mRows, "size of vector is different from the number of rows in matrix");

  queso_require_equal_to_msg(mCols, mRows, "routine currently works for square matrices only");

  GslMatrix answer(mat);
  for (unsigned int i = 0; i < mRows; ++i) {
    double vecValue = vec[i];
    for (unsigned int j = 0; j < mCols; ++j) {
      answer(i,j) *= vecValue;
    }
  }

  return answer;
}

TeuchosMatrix QUESO::matrixProduct	(	const TeuchosVector &	v1,
		const TeuchosVector &	v2
	)

Definition at line 2120 of file TeuchosMatrix.C.

References QUESO::Vector::env(), QUESO::Vector::map(), and QUESO::TeuchosVector::sizeLocal().

{
  unsigned int nRows = v1.sizeLocal();
  unsigned int nCols = v2.sizeLocal();
  TeuchosMatrix answer(v1.env(),v1.map(),nCols);

  for (unsigned int i = 0; i < nRows; ++i) {
    double value1 = v1[i];
    for (unsigned int j = 0; j < nCols; ++j) {
      answer(i,j) = value1*v2[j];
    }
  }

  return answer;
}

GslMatrix QUESO::matrixProduct	(	const GslVector &	v1,
		const GslVector &	v2
	)

Definition at line 2036 of file GslMatrix.C.

References QUESO::Vector::env(), QUESO::Vector::map(), and QUESO::GslVector::sizeLocal().

Referenced by CovCond(), QUESO::SequenceOfVectors< V, M >::estimateConvBrooksGelman(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step04_inter0(), and QUESO::MetropolisHastingsSG< P_V, P_M >::updateAdaptedCovMatrix().

{
  unsigned int nRows = v1.sizeLocal();
  unsigned int nCols = v2.sizeLocal();
  GslMatrix answer(v1.env(),v1.map(),nCols);

  for (unsigned int i = 0; i < nRows; ++i) {
    double value1 = v1[i];
    for (unsigned int j = 0; j < nCols; ++j) {
      answer(i,j) = value1*v2[j];
    }
  }

  return answer;
}

template<class T >

bool QUESO::MiscCheckForSameValueInAllNodes	(	T &	inputValue,
		double	acceptableTreshold,
		const MpiComm &	comm,
		const char *	whereString
	)

Definition at line 479 of file Miscellaneous.C.

References QUESO::MpiComm::Allreduce(), QUESO::MpiComm::Barrier(), QUESO::MpiComm::Bcast(), QUESO::MpiComm::MyPID(), and QUESO::MpiComm::NumProc().

Referenced by QUESO::MLSampling< P_V, P_M >::generateSequence_Step03_inter0(), and QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all().

{
  // Filter out those nodes that should not participate
  if (comm.MyPID() < 0) return true;

  double localValue = (double) inputValue;
  double sumValue = 0.;
  comm.Allreduce<double>(&localValue, &sumValue, (int) 1, RawValue_MPI_SUM,
                 whereString,
                 "failed MPI on 'sumValue' inside MiscCheckForSameValueInAllNodes()");

  double totalNumNodes = (double) comm.NumProc();
  double testValue = fabs(1. - localValue/(sumValue/totalNumNodes));
  unsigned int boolSum = 0;
#if 1
  unsigned int boolResult = 0;
  if (testValue > acceptableTreshold) boolResult = 1;
  comm.Allreduce<unsigned int>(&boolResult, &boolSum, (int) 1, RawValue_MPI_SUM,
                 whereString,
                 "failed MPI on 'boolSum' inside MiscCheckForSameValueInAllNodes()");

  if (boolSum > 0) {
    comm.Barrier();
    for (int i = 0; i < comm.NumProc(); ++i) {
      if (i == comm.MyPID()) {
        std::cerr << "WARNING, "
                  << whereString
                  << ", inside MiscCheckForSameValueInAllNodes()"
                  << ", rank (in this communicator) = " << i
                  << ": boolSum = "       << boolSum
                  << ", localValue = "    << localValue
                  << ", sumValue = "      << sumValue
                  << ", totalNumNodes = " << totalNumNodes
                  << ", avgValue = "      << (sumValue/totalNumNodes)
                  << ", relativeTest = "  << testValue
                  << std::endl;
      }
      comm.Barrier();
    }
    comm.Barrier();

    comm.Bcast((void *) &localValue, (int) 1, RawValue_MPI_DOUBLE, 0,
               whereString,
               "failed MPI on 'boolSum' inside MiscCheckForSameValueInAllNodes()");
    inputValue = localValue; // IMPORTANT
  }
#else
  queso_require_less_equal_msg(testValue, acceptableTreshold, "not all nodes have the same value inside MiscCheckForSameValueInAllNodes()");
#endif

  return (boolSum == 0);
}

template<class V1 , class V2 >

void QUESO::MiscCheckTheParallelEnvironment	(	const V1 &	vec1,
		const V2 &	vec2
	)

Definition at line 564 of file Miscellaneous.C.

References QUESO::BaseEnvironment::fullComm(), QUESO::MpiComm::NumProc(), QUESO::BaseEnvironment::numSubEnvironments(), queso_require_equal_to_msg, QUESO::BaseEnvironment::subComm(), and QUESO::BaseEnvironment::subRank().

{
  const BaseEnvironment& env = vec1.env();

  if (env.numSubEnvironments() == (unsigned int) env.fullComm().NumProc()) {
    queso_require_equal_to_msg(env.subRank(), 0, "there should exist only one processor per sub environment");
    queso_require_equal_to_msg(vec1.numOfProcsForStorage(), 1,
      "only 1 processor (per sub environment) should be necessary for the storage of a parameter vector");
    queso_require_equal_to_msg(vec2.numOfProcsForStorage(), 1,
      "only 1 processor (per sub environment) should be necessary for the storage of a parameter vector");
  }
  else if (env.numSubEnvironments() < (unsigned int) env.fullComm().NumProc()) {
    queso_require_equal_to_msg(env.fullComm().NumProc()%env.numSubEnvironments(), 0, "total number of processors should be a multiple of the number of sub environments");
    unsigned int numProcsPerSubEnvironment = env.fullComm().NumProc()/env.numSubEnvironments();
    queso_require_equal_to_msg(env.subComm().NumProc(), (int) numProcsPerSubEnvironment, "inconsistent number of processors per sub environment");
    if ((vec1.numOfProcsForStorage() == 1) &&
        (vec2.numOfProcsForStorage() == 1)) {
      // Ok
    }
    else if ((vec1.numOfProcsForStorage() == numProcsPerSubEnvironment) &&
             (vec2.numOfProcsForStorage() == numProcsPerSubEnvironment)) {
      queso_error_msg("parallel vectors are not supported yet");
    }
    else {
      queso_error_msg("number of processors required for a vector storage should be equal to either 1 or to the number of processors in the sub environment");
    }
  }
  else {
    queso_error_msg("number of processors per sub environment is less than 1!");
  }

  return;
}

template<class V >

void QUESO::MiscComputePositionsBetweenMinMax	(	V	minValues,
		V	maxValues,
		std::vector< V * > &	positions
	)

Definition at line 537 of file Miscellaneous.C.

Referenced by QUESO::BaseVectorSequence< V, M >::computeHistCdfstaccKde().

{
  double factor = 0.5;
  switch (positions.size()) {
    case 0:
      // Do nothing
    break;

    case 1:
      positions[0] = new V((1. - factor) * minValues + factor * maxValues);
    break;

    default:
      for (unsigned int i = 0; i < positions.size(); ++i) {
        factor = ((double) i)/(((double) positions.size()) - 1.);
        positions[i] = new V((1. - factor) * minValues + factor * maxValues);
      }
    break;
  }

  return;
}

double QUESO::MiscDoubleDebugMessage	(	double	value,
		const char *	message
	)

Definition at line 334 of file Miscellaneous.C.

{
  if (message) {
    std::cout << "Passing in MiscDoubleDebugMessage(), value = " << value << ", message = " << message << std::endl;
  }
  return value;
}

void QUESO::MiscExtractDoubleFromString	(	std::string &	inputString,
		double &	outputDouble
	)

void QUESO::MiscExtractWordFromString	(	std::string &	inputString,
		std::string &	outputWord
	)

double QUESO::MiscGammar	(	double	a,
		double	b,
		const RngBase *	rngObject
	)

Definition at line 248 of file Miscellaneous.C.

References QUESO::RngBase::gaussianSample(), and QUESO::RngBase::uniformSample().

{
  double result = 0.;
  if (a < 1.) {
    result = MiscGammar(1.+a,b,rngObject)*std::pow( rngObject->uniformSample(),1./a );
  }
  else {
    double d = a-1./3.;
    double c = 1./std::sqrt(9.*d);
    double x = 0.;
    double w = 0.;
    while (1) {
      while (1) {
        x = rngObject->gaussianSample(1.);
        w = 1.+c*x;
        if (w > 0.) break;
      }
      w = std::pow(w,3.);
      double u = rngObject->uniformSample();
      double compValue = 1.-0.0331*std::pow(x,4.);
      if (u < compValue) break;
      compValue = 0.5*std::pow(x,2.)+d*(1.-w+log(w));
      if (log(u) < compValue) break;
    }
    result = b*d*w;
  }

  return result;
}

double QUESO::MiscGaussianDensity	(	double	x,
		double	mu,
		double	sigma
	)

Definition at line 306 of file Miscellaneous.C.

Referenced by QUESO::ArrayOfSequences< V, M >::gaussianKDE(), QUESO::ScalarSequence< T >::subGaussian1dKde(), and QUESO::ScalarSequence< T >::unifiedGaussian1dKde().

{
  double sigma2 = sigma*sigma;
  double diff   = x-mu;

  return (1./std::sqrt(2*M_PI*sigma2))*std::exp(-.5*diff*diff/sigma2);
}

double QUESO::MiscGetEllapsedSeconds

(

struct timeval *

timeval0

)

Definition at line 282 of file Miscellaneous.C.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::BaseVectorSequence< V, M >::computeAutoCorrViaDef(), QUESO::BaseVectorSequence< V, M >::computeAutoCorrViaFFT(), QUESO::BaseVectorSequence< V, M >::computeBMM(), QUESO::BaseVectorSequence< V, M >::computeFFT(), QUESO::BaseVectorSequence< V, M >::computeGeweke(), QUESO::BaseVectorSequence< V, M >::computeHistCdfstaccKde(), QUESO::BaseVectorSequence< V, M >::computeMeanEvolution(), QUESO::BaseVectorSequence< V, M >::computeMeanStacc(), QUESO::BaseVectorSequence< V, M >::computeMeanVars(), QUESO::BaseVectorSequence< V, M >::computePSD(), QUESO::BaseVectorSequence< V, M >::computePSDAtZero(), QUESO::BaseVectorSequence< V, M >::computeStatistics(), QUESO::MetropolisHastingsSG< P_V, P_M >::delayedRejection(), QUESO::MLSampling< P_V, P_M >::generateBalLinkedChains_all(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MLSampling< P_V, P_M >::generateSequence_Level0_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step01_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step03_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step04_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step05_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step06_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step07_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step08_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step10_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0(), QUESO::MLSampling< P_V, P_M >::generateUnbLinkedChains_all(), QUESO::MLSampling< P_V, P_M >::justBalance_proc0(), QUESO::MLSampling< P_V, P_M >::solveBIP_proc0(), QUESO::SequenceOfVectors< V, M >::unifiedReadContents(), QUESO::ScalarSequence< T >::unifiedReadContents(), QUESO::SequenceOfVectors< V, M >::unifiedWriteContents(), and QUESO::ScalarSequence< T >::unifiedWriteContents().

{
  double result = 0.;

  struct timeval timevalNow;
  /*int iRC;*/
  /*iRC = */gettimeofday(&timevalNow, NULL);

  result  = (double) (timevalNow.tv_sec  - timeval0->tv_sec );
  result *= 1.e+6;
  result += (double) (timevalNow.tv_usec - timeval0->tv_usec);
  result *= 1.e-6;

  return result;
}

double QUESO::MiscHammingWindow	(	unsigned int	N,
		unsigned int	j
	)

Definition at line 298 of file Miscellaneous.C.

Referenced by QUESO::ScalarSequence< T >::psd().

{
  double angle = 2.*M_PI*((double) j)/((double) N);
  double result = 0.53836 - 0.46164*cos(angle);

  return result;
}

int QUESO::MiscIntDebugMessage	(	int	value,
		const char *	message
	)

Definition at line 324 of file Miscellaneous.C.

{
  if (message) {
    std::cout << "Passing in MiscIntDebugMessage(), value = " << value << ", message = " << message << std::endl;
  }
  return value;
}

int QUESO::MiscReadCharsAndDoubleFromFile	(	std::ifstream &	ifs,
		std::string &	termString,
		double *	termValue,
		bool &	endOfLineAchieved
	)

Definition at line 191 of file Miscellaneous.C.

References UQ_FAILED_READING_FILE_RC, and UQ_OK_RC.

Referenced by QUESO::AsciiTable< V, M >::readColumnsFromFile().

{
  int iRC = UQ_OK_RC;
  endOfLineAchieved = false;

  char c = ' ';
  while (c == ' ') {
    ifs.get(c);
    if ((ifs.rdstate() & std::ifstream::failbit)) {
      iRC = UQ_FAILED_READING_FILE_RC;
      break;
    }
  };

  char term[512];
  unsigned int pos = 0;

  if (!iRC) {
    while ((pos < 512) && (c != '\n') && (c != '\0') && (c != ' ')) {
      term[pos++] = c;
      if ((ifs.rdstate() & std::ifstream::failbit)) {
        iRC = UQ_FAILED_READING_FILE_RC;
        break;
      }
      ifs.get(c);
    };
  }

  if (!iRC) {
    if (c == '\n') endOfLineAchieved = true;
    term[pos] = '\0';
    termString = term;
    //std::cout << "Read chars = " << termString << std::endl;
    if (termValue) {
      if (termString == std::string("inf")) {
        *termValue = INFINITY;
      }
      else if (termString == std::string("-inf")) {
        *termValue = -INFINITY;
      }
      else if (termString == std::string("nan")) {
        *termValue = nan("");
      }
      else {
        *termValue = strtod(termString.c_str(),NULL);
      }
    }
  }

  return iRC;
}

void QUESO::MiscReadDoublesFromString	(	const std::string &	inputString,
		std::vector< double > &	outputDoubles
	)

Definition at line 40 of file Miscellaneous.C.

References queso_require_not_equal_to_msg.

Referenced by BoostInputOptionsParser::getOption< std::vector< double, std::allocator< double > > >(), QUESO::StatisticalForwardProblemOptions::getMyOptionValues(), QUESO::StatisticalInverseProblemOptions::getMyOptionValues(), QUESO::MonteCarloSGOptions::getMyOptionValues(), QUESO::EnvironmentOptions::getMyOptionValues(), SequenceStatisticalOptions::getMyOptionValues(), QUESO::MetropolisHastingsSGOptions::getMyOptionValues(), and QUESO::BoostInputOptionsParser::getOption().

{
  //std::cout << "In MiscReadDoublesFromString()"
  //          << ": inputString = " << inputString
  //          << std::endl;
  outputDoubles.clear();
  bool aDoubleIsBeingRead = false;
  std::string::size_type positionOfFirstChar = 0;
  std::string::size_type numberOfChars = 0;
  for (std::string::size_type i = 0; i < inputString.size(); ++i) {
    queso_require_not_equal_to_msg(inputString[i], '\0', "character '\0' should not be found!");
    if (inputString[i] == ' ') {
      if (aDoubleIsBeingRead == true) {
        // We just finished reading the current string/double. Convert string to double now.
        char tmpVar[numberOfChars+1];
        for (std::string::size_type j = 0; j < numberOfChars; ++j) {
          tmpVar[j] = inputString[positionOfFirstChar+j];
        }
        tmpVar[numberOfChars] = '\0';
        outputDoubles.push_back(strtod(tmpVar,NULL));

        // Continue loop
        aDoubleIsBeingRead = false;
        positionOfFirstChar = 0;
        numberOfChars = 0;
      }
    }
    else {
      if (aDoubleIsBeingRead == false) {
        aDoubleIsBeingRead = true;
        positionOfFirstChar = i;
      }
      numberOfChars++;
    }
  } // for
  if (aDoubleIsBeingRead == true) {
    // We just finished reading the current string/double. Convert string to double now.
    char tmpVar[numberOfChars+1];
    for (std::string::size_type j = 0; j < numberOfChars; ++j) {
      tmpVar[j] = inputString[positionOfFirstChar+j];
    }
    tmpVar[numberOfChars] = '\0';
    outputDoubles.push_back(strtod(tmpVar,NULL));
  }
  std::vector<double>(outputDoubles).swap(outputDoubles);

  return;
}

int QUESO::MiscReadStringAndDoubleFromFile	(	std::ifstream &	ifs,
		std::string &	termString,
		double *	termValue
	)

Definition at line 160 of file Miscellaneous.C.

References UQ_FAILED_READING_FILE_RC, and UQ_OK_RC.

Referenced by QUESO::AsciiTable< V, M >::readColumnsFromFile().

{
  int iRC = UQ_OK_RC;

  ifs >> termString;
  if ((ifs.rdstate() & std::ifstream::failbit)) {
    iRC = UQ_FAILED_READING_FILE_RC;
  }
  else if (termValue) {
    if (termString == std::string("inf")) {
      *termValue = INFINITY;
    }
    else if (termString == std::string("-inf")) {
      *termValue = -INFINITY;
    }
    else if (termString == std::string("nan")) {
      *termValue = nan("");
    }
    else {
      *termValue = strtod(termString.c_str(),NULL);
    }
  }
  //if (!iRC) std::cout << "Read termString = " << termString << std::endl;

  return iRC;
}

void QUESO::MiscReadWordsFromString	(	const std::string &	inputString,
		std::vector< std::string > &	outputWords
	)

Definition at line 92 of file Miscellaneous.C.

References queso_require_not_equal_to_msg.

{
  //std::cout << "In MiscReadWordsFromString()"
  //          << ": inputString = " << inputString
  //          << std::endl;
  outputWords.clear();
  bool aWordIsBeingRead = false;
  std::string::size_type positionOfFirstChar = 0;
  std::string::size_type numberOfChars = 0;
  for (std::string::size_type i = 0; i < inputString.size(); ++i) {
    queso_require_not_equal_to_msg(inputString[i], '\0', "character '\0' should not be found!");
    if (inputString[i] == ' ') {
      if (aWordIsBeingRead == true) {
        // We just finished reading the current string/word.
        char tmpVar[numberOfChars+1];
        for (std::string::size_type j = 0; j < numberOfChars; ++j) {
          tmpVar[j] = inputString[positionOfFirstChar+j];
        }
        tmpVar[numberOfChars] = '\0';
        outputWords.push_back(tmpVar);

        // Continue loop
        aWordIsBeingRead = false;
        positionOfFirstChar = 0;
        numberOfChars = 0;
      }
    }
    else {
      if (aWordIsBeingRead == false) {
        aWordIsBeingRead = true;
        positionOfFirstChar = i;
      }
      numberOfChars++;
    }
  } // for
  if (aWordIsBeingRead == true) {
    // We just finished reading the current string/word.
    char tmpVar[numberOfChars+1];
    for (std::string::size_type j = 0; j < numberOfChars; ++j) {
      tmpVar[j] = inputString[positionOfFirstChar+j];
    }
    tmpVar[numberOfChars] = '\0';
    outputWords.push_back(tmpVar);
  }
  std::vector<std::string>(outputWords).swap(outputWords);

  return;
}

unsigned int QUESO::MiscUintDebugMessage	(	unsigned int	value,
		const char *	message
	)

Definition at line 314 of file Miscellaneous.C.

{
  if (message) {
    std::cout << "Passing in MiscUintDebugMessage(), value = " << value << ", message = " << message << std::endl;
  }
  return value;
}

int QUESO::MyWorldfullRank

(

)

Returns the rank of the calling process in the communicator.

Definition at line 33 of file Defines.C.

                      {
  int result = 0;
#ifdef QUESO_HAS_MPI
  int iRC;
  iRC = MPI_Comm_rank(MPI_COMM_WORLD,&result);
  if (iRC) {}; // just to remove compiler warning
#endif
  return result;
}

void QUESO::normalizeANN_XY	(	ANNpointArray	dataXY,
		unsigned int	dimXY,
		ANNpointArray	dataX,
		unsigned int	dimX,
		ANNpointArray	dataY,
		unsigned int	dimY,
		unsigned int	N
	)

Normalises dataXY by its sample mean and covariance. dataX and dataY are populated with the marginals of dataXY.

Definition at line 98 of file InfoTheory_impl.h.

References annAllocPt().

Referenced by computeMI_ANN().

{

  ANNpoint meanXY, stdXY;

  meanXY = annAllocPt(dimXY); // is init with 0
  stdXY = annAllocPt(dimXY); // is init with 0

  // get mean
  for( unsigned int i = 0; i < N; i++ ) {
    for( unsigned int j = 0; j < dimX; j++ ) {
      meanXY[ j ] += dataXY[ i ][ j ];
    }
    for( unsigned int j = 0; j < dimY; j++ ) {
      meanXY[ dimX + j ] += dataXY[ i ][ dimX + j ];
    }
  }
  for( unsigned int j = 0; j < dimXY; j++ ) {
    meanXY[ j ] = meanXY[ j ] / (double)N;
  }

  // get standard deviation
  for( unsigned int i = 0; i < N; i++ ) {
    for( unsigned int j = 0; j < dimXY; j++ ) {
      stdXY[ j ] += pow( dataXY[ i ][ j ] - meanXY[ j ], 2.0 );
    }
  }
  for( unsigned int j = 0; j < dimXY; j++ ) {
    stdXY[ j ] = sqrt( stdXY[ j ] / ((double)N-1.0) );
  }

  /*
  std::cout << "Mean RV - ";
  annPrintPt( meanXY, dimXY, std::cout );
  std::cout << std::endl << "Std RV - ";
  annPrintPt( stdXY, dimXY, std::cout );
  std::cout << std::endl;
  */

  // get normalized points and populate marginals
  for( unsigned int i = 0; i < N; i++ ) {
    // normalize joint
    for( unsigned int j = 0; j < dimXY; j++ ) {
      dataXY[ i ][ j ] = ( dataXY[ i ][ j ] - meanXY[ j ] ) / stdXY[ j ];
    }

    // populate marginals
    for( unsigned int j = 0; j < dimX; j++ ) {
      dataX[ i ][ j ] = dataXY[ i ][ j ];
    }
    for( unsigned int j = 0; j < dimY; j++ ) {
      dataY[ i ][ j ] = dataXY[ i ][ dimX + j ];
    }
  }

}

GslVector QUESO::operator*	(	double	a,
		const GslVector &	x
	)

Definition at line 1121 of file GslVector.C.

{
  GslVector answer(x);
  answer *= a;

  return answer;
}

GslVector QUESO::operator*	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1129 of file GslVector.C.

{
  GslVector answer(x);
  answer *= y;

  return answer;
}

TeuchosVector QUESO::operator*	(	double	a,
		const TeuchosVector &	x
	)

Definition at line 1187 of file TeuchosVector.C.

{
  TeuchosVector answer(x);
  answer *= a;
  return answer;
}

TeuchosVector QUESO::operator*	(	const TeuchosVector &	x,
		const TeuchosVector &	y
	)

Definition at line 1195 of file TeuchosVector.C.

{
  TeuchosVector answer(x);
  answer *= y;
  return answer;
}

TeuchosMatrix QUESO::operator*	(	double	a,
		const TeuchosMatrix &	mat
	)

Definition at line 2064 of file TeuchosMatrix.C.

{
  TeuchosMatrix answer(mat);
  answer *= a;
  return answer;
}

TeuchosVector QUESO::operator*	(	const TeuchosMatrix &	mat,
		const TeuchosVector &	vec
	)

Definition at line 2072 of file TeuchosMatrix.C.

References QUESO::TeuchosMatrix::multiply().

{
  return mat.multiply(vec);
}

TeuchosMatrix QUESO::operator*	(	const TeuchosMatrix &	m1,
		const TeuchosMatrix &	m2
	)

Definition at line 2078 of file TeuchosMatrix.C.

References QUESO::Matrix::env(), QUESO::Matrix::map(), QUESO::TeuchosMatrix::numCols(), QUESO::TeuchosMatrix::numRowsLocal(), and queso_require_equal_to_msg.

{
  unsigned int m1Rows = m1.numRowsLocal();
  unsigned int m1Cols = m1.numCols();
  unsigned int m2Rows = m2.numRowsLocal();
  unsigned int m2Cols = m2.numCols();

  queso_require_equal_to_msg(m1Cols, m2Rows, "different sizes m1Cols and m2Rows");

  TeuchosMatrix mat(m1.env(),m1.map(),m2Cols);
  unsigned int commonSize = m1Cols;

  for (unsigned int row1 = 0; row1 < m1Rows; ++row1) {
    for (unsigned int col2 = 0; col2 < m2Cols; ++col2) {
      double result = 0.;
      for (unsigned int k = 0; k < commonSize; ++k) {
        result += m1(row1,k)*m2(k,col2);
      }
      mat(row1,col2) = result;
    }
  }

  return mat;
}

GslMatrix QUESO::operator*	(	double	a,
		const GslMatrix &	mat
	)

Definition at line 1982 of file GslMatrix.C.

{
  GslMatrix answer(mat);
  answer *= a;
  return answer;
}

GslVector QUESO::operator*	(	const GslMatrix &	mat,
		const GslVector &	vec
	)

Definition at line 1989 of file GslMatrix.C.

References QUESO::GslMatrix::multiply().

{
  return mat.multiply(vec);
}

GslMatrix QUESO::operator*	(	const GslMatrix &	m1,
		const GslMatrix &	m2
	)

Definition at line 1994 of file GslMatrix.C.

References QUESO::Matrix::env(), QUESO::Matrix::map(), QUESO::GslMatrix::numCols(), QUESO::GslMatrix::numRowsLocal(), and queso_require_equal_to_msg.

{
  unsigned int m1Rows = m1.numRowsLocal();
  unsigned int m1Cols = m1.numCols();
  unsigned int m2Rows = m2.numRowsLocal();
  unsigned int m2Cols = m2.numCols();

  queso_require_equal_to_msg(m1Cols, m2Rows, "different sizes m1Cols and m2Rows");

  GslMatrix mat(m1.env(),m1.map(),m2Cols);

  //std::cout << "In GslMatrix(mat * mat): m1Cols = " << m1Cols << std::endl;

  unsigned int commonSize = m1Cols;
  for (unsigned int row1 = 0; row1 < m1Rows; ++row1) {
    for (unsigned int col2 = 0; col2 < m2Cols; ++col2) {
      double result = 0.;
      for (unsigned int k = 0; k < commonSize; ++k) {
        result += m1(row1,k)*m2(k,col2);
      }
      mat(row1,col2) = result;
    }
    //std::cout << "In GslMatrix(mat * mat): ended row " << row1 << std::endl;
  }

  return mat;
}

GslVector QUESO::operator+	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1151 of file GslVector.C.

{
  GslVector answer(x);
  answer += y;

  return answer;
}

TeuchosVector QUESO::operator+	(	const TeuchosVector &	x,
		const TeuchosVector &	y
	)

Definition at line 1218 of file TeuchosVector.C.

{
  TeuchosVector answer(x);
  answer += y;
  return answer;
}

TeuchosMatrix QUESO::operator+	(	const TeuchosMatrix &	m1,
		const TeuchosMatrix &	m2
	)

Definition at line 2104 of file TeuchosMatrix.C.

{
  TeuchosMatrix answer(m1);
  answer += m2;
  return answer;
}

GslMatrix QUESO::operator+	(	const GslMatrix &	m1,
		const GslMatrix &	m2
	)

Definition at line 2022 of file GslMatrix.C.

{
  GslMatrix answer(m1);
  answer += m2;
  return answer;
}

GslVector QUESO::operator-	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1159 of file GslVector.C.

{
  GslVector answer(x);
  answer -= y;

  return answer;
}

TeuchosVector QUESO::operator-	(	const TeuchosVector &	x,
		const TeuchosVector &	y
	)

Definition at line 1226 of file TeuchosVector.C.

{
  TeuchosVector answer(x);
  answer -= y;
  return answer;
}

TeuchosMatrix QUESO::operator-	(	const TeuchosMatrix &	m1,
		const TeuchosMatrix &	m2
	)

Definition at line 2112 of file TeuchosMatrix.C.

{
  TeuchosMatrix answer(m1);
  answer -= m2;
  return answer;
}

GslMatrix QUESO::operator-	(	const GslMatrix &	m1,
		const GslMatrix &	m2
	)

Definition at line 2029 of file GslMatrix.C.

{
  GslMatrix answer(m1);
  answer -= m2;
  return answer;
}

GslVector QUESO::operator/	(	double	a,
		const GslVector &	x
	)

Definition at line 1104 of file GslVector.C.

References QUESO::GslVector::cwInvert().

{
  GslVector answer(x);
  answer.cwInvert();
  answer *= a;

  return answer;
}

GslVector QUESO::operator/	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1113 of file GslVector.C.

{
  GslVector answer(x);
  answer /= y;

  return answer;
}

TeuchosVector QUESO::operator/	(	double	a,
		const TeuchosVector &	x
	)

Definition at line 1170 of file TeuchosVector.C.

References QUESO::TeuchosVector::cwInvert().

{
  TeuchosVector answer(x); //copy x to answer
  answer.cwInvert();
  answer *= a;
  return answer;
}

TeuchosVector QUESO::operator/	(	const TeuchosVector &	x,
		const TeuchosVector &	y
	)

Definition at line 1179 of file TeuchosVector.C.

{
  TeuchosVector answer(x);
  answer /= y;
  return answer;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const InfiniteDimensionalMCMCSamplerOptions &	obj
	)

Definition at line 106 of file InfiniteDimensionalMCMCSamplerOptions.C.

References QUESO::InfiniteDimensionalMCMCSamplerOptions::m_parser, and QUESO::InfiniteDimensionalMCMCSamplerOptions::print().

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  obj.print(os);
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GslBlockMatrix &	obj
	)

Definition at line 156 of file GslBlockMatrix.C.

References QUESO::GslBlockMatrix::print().

{
  obj.print(os);

  return os;
}

template<class V , class M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const ArrayOfOneDTables< V, M > &	obj
	)

Definition at line 112 of file ArrayOfOneDTables.C.

References QUESO::ArrayOfOneDTables< V, M >::print().

{
  obj.print(os);
  return os;
}

template<class V , class M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const BaseJointPdf< V, M > &	obj
	)

Definition at line 129 of file JointPdf.h.

{
  obj.print(os);
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const BoostInputOptionsParser &	parser
	)

Definition at line 157 of file BoostInputOptionsParser.C.

References QUESO::BoostInputOptionsParser::m_optionsDescription.

{
  queso_deprecated();
  os << *(parser.m_optionsDescription);
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const OptimizerOptions &	obj
	)

Definition at line 172 of file OptimizerOptions.C.

References QUESO::OptimizerOptions::m_fdfstepSize, QUESO::OptimizerOptions::m_finiteDifferenceStepSize, QUESO::OptimizerOptions::m_fstepSize, QUESO::OptimizerOptions::m_lineTolerance, QUESO::OptimizerOptions::m_maxIterations, QUESO::OptimizerOptions::m_option_fdfstepSize, QUESO::OptimizerOptions::m_option_finiteDifferenceStepSize, QUESO::OptimizerOptions::m_option_fstepSize, QUESO::OptimizerOptions::m_option_lineTolerance, QUESO::OptimizerOptions::m_option_maxIterations, QUESO::OptimizerOptions::m_option_solverType, QUESO::OptimizerOptions::m_option_tolerance, QUESO::OptimizerOptions::m_solverType, and QUESO::OptimizerOptions::m_tolerance.

{
  os << "\n" << obj.m_option_maxIterations << " = " << obj.m_maxIterations
     << "\n" << obj.m_option_tolerance << " = " << obj.m_tolerance;
  os << "\n" << obj.m_option_finiteDifferenceStepSize << " = "
             << obj.m_finiteDifferenceStepSize;
  os << "\n" << obj.m_option_solverType << " = " << obj.m_solverType;
  os << "\n" << obj.m_option_fstepSize << " = " << obj.m_fstepSize;
  os << "\n" << obj.m_option_fdfstepSize << " = " << obj.m_fdfstepSize;
  os << "\n" << obj.m_option_lineTolerance << " = " << obj.m_lineTolerance;
  os << std::endl;
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MLSamplingOptions &	obj
	)

Definition at line 173 of file MLSamplingOptions.C.

References QUESO::MLSamplingOptions::m_parser, and QUESO::MLSamplingOptions::print().

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS

  obj.print(os);
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const SipOptionsValues &	obj
	)

Definition at line 175 of file StatisticalInverseProblemOptions.C.

References QUESO::SipOptionsValues::m_computeSolution, QUESO::SipOptionsValues::m_dataOutputAllowedSet, QUESO::SipOptionsValues::m_dataOutputFileName, QUESO::SipOptionsValues::m_option_computeSolution, QUESO::SipOptionsValues::m_option_dataOutputAllowedSet, QUESO::SipOptionsValues::m_option_dataOutputFileName, QUESO::SipOptionsValues::m_option_solver, and QUESO::SipOptionsValues::m_solverString.

{
  os << "\n" << obj.m_option_computeSolution      << " = " << obj.m_computeSolution
     << "\n" << obj.m_option_dataOutputFileName   << " = " << obj.m_dataOutputFileName;
  os << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
#ifdef UQ_SIP_READS_SOLVER_OPTION
     << "\n" << obj.m_option_solver << " = " << obj.m_solverString
#endif
  os << std::endl;
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const SfpOptionsValues &	obj
	)

Definition at line 180 of file StatisticalForwardProblemOptions.C.

References QUESO::SfpOptionsValues::m_computeCorrelations, QUESO::SfpOptionsValues::m_computeCovariances, QUESO::SfpOptionsValues::m_computeSolution, QUESO::SfpOptionsValues::m_dataOutputAllowedSet, QUESO::SfpOptionsValues::m_dataOutputFileName, QUESO::SfpOptionsValues::m_option_computeCorrelations, QUESO::SfpOptionsValues::m_option_computeCovariances, QUESO::SfpOptionsValues::m_option_computeSolution, QUESO::SfpOptionsValues::m_option_dataOutputAllowedSet, QUESO::SfpOptionsValues::m_option_dataOutputFileName, QUESO::SfpOptionsValues::m_option_solver, QUESO::SfpOptionsValues::m_parser, and QUESO::SfpOptionsValues::m_solverString.

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS

  os <<         obj.m_option_computeSolution      << " = " << obj.m_computeSolution
     << "\n" << obj.m_option_computeCovariances   << " = " << obj.m_computeCovariances
     << "\n" << obj.m_option_computeCorrelations  << " = " << obj.m_computeCorrelations
     << "\n" << obj.m_option_dataOutputFileName   << " = " << obj.m_dataOutputFileName;
  os << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
#ifdef UQ_SFP_READS_SOLVER_OPTION
       << "\n" << obj.m_option_solver << " = " << obj.m_solverString
#endif
  os << std::endl;
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const StatisticalForwardProblemOptions &	obj
	)

Prints the object obj, overloading an operator.

Definition at line 400 of file StatisticalForwardProblemOptions.C.

References QUESO::StatisticalForwardProblemOptions::print().

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const StatisticalInverseProblemOptions &	obj
	)

Prints the object obj, overloading an operator.

Definition at line 379 of file StatisticalInverseProblemOptions.C.

References QUESO::StatisticalInverseProblemOptions::print().

{
  queso_deprecated();
  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const EnvOptionsValues &	obj
	)

Definition at line 235 of file EnvironmentOptions.C.

References QUESO::BaseEnvironment::input(), QUESO::EnvOptionsValues::m_checkingLevel, QUESO::EnvOptionsValues::m_displayVerbosity, QUESO::EnvOptionsValues::m_env, QUESO::EnvOptionsValues::m_identifyingString, QUESO::EnvOptionsValues::m_numSubEnvironments, QUESO::EnvOptionsValues::m_option_checkingLevel, QUESO::EnvOptionsValues::m_option_displayVerbosity, QUESO::EnvOptionsValues::m_option_identifyingString, QUESO::EnvOptionsValues::m_option_numSubEnvironments, QUESO::EnvOptionsValues::m_option_platformName, QUESO::EnvOptionsValues::m_option_rngType, QUESO::EnvOptionsValues::m_option_seed, QUESO::EnvOptionsValues::m_option_subDisplayAllowAll, QUESO::EnvOptionsValues::m_option_subDisplayAllowedSet, QUESO::EnvOptionsValues::m_option_subDisplayFileName, QUESO::EnvOptionsValues::m_option_syncVerbosity, QUESO::EnvOptionsValues::m_parser, QUESO::EnvOptionsValues::m_platformName, QUESO::EnvOptionsValues::m_rngType, QUESO::EnvOptionsValues::m_seed, QUESO::EnvOptionsValues::m_subDisplayAllowAll, QUESO::EnvOptionsValues::m_subDisplayAllowedSet, QUESO::EnvOptionsValues::m_subDisplayFileName, and QUESO::EnvOptionsValues::m_syncVerbosity.

{
  // Print the parser
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#else
  obj.m_env->input().print(os);
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS

  // Print the option names and current values
  os <<         obj.m_option_numSubEnvironments    << " = " << obj.m_numSubEnvironments
     << "\n" << obj.m_option_subDisplayFileName    << " = " << obj.m_subDisplayFileName
     << "\n" << obj.m_option_subDisplayAllowAll    << " = " << obj.m_subDisplayAllowAll
   //<< "\n" << obj.m_option_subDisplayAllowInter0 << " = " << obj.m_subDisplayAllowInter0
     << "\n" << obj.m_option_subDisplayAllowedSet  << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_subDisplayAllowedSet.begin(); setIt != obj.m_subDisplayAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_displayVerbosity  << " = " << obj.m_displayVerbosity
     << "\n" << obj.m_option_syncVerbosity     << " = " << obj.m_syncVerbosity
     << "\n" << obj.m_option_checkingLevel     << " = " << obj.m_checkingLevel
     << "\n" << obj.m_option_rngType           << " = " << obj.m_rngType
     << "\n" << obj.m_option_seed              << " = " << obj.m_seed
     << "\n" << obj.m_option_platformName      << " = " << obj.m_platformName
     << "\n" << obj.m_option_identifyingString << " = " << obj.m_identifyingString
   //<< "\n" << obj.m_option_numDebugParams    << " = " << obj.m_numDebugParams
     << std::endl;
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GslVector &	obj
	)

Definition at line 1097 of file GslVector.C.

References QUESO::GslVector::print().

{
  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const MonteCarloSGOptions &	obj
	)

Prints the object obj, overloading an operator.

Definition at line 710 of file MonteCarloSGOptions.C.

References QUESO::MonteCarloSGOptions::print().

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const TeuchosVector &	obj
	)

Definition at line 1255 of file TeuchosVector.C.

References QUESO::TeuchosVector::print().

{
  obj.print(os);

  return os;
}

template<class V , class M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const AsciiTable< V, M > &	obj
	)

Definition at line 301 of file AsciiTable.C.

{
  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const McOptionsValues &	obj
	)

Definition at line 330 of file MonteCarloSGOptions.C.

References QUESO::McOptionsValues::m_dataOutputAllowedSet, QUESO::McOptionsValues::m_dataOutputFileName, QUESO::McOptionsValues::m_option_dataOutputAllowedSet, QUESO::McOptionsValues::m_option_dataOutputFileName, QUESO::McOptionsValues::m_option_pseq_computeStats, QUESO::McOptionsValues::m_option_pseq_dataOutputAllowedSet, QUESO::McOptionsValues::m_option_pseq_dataOutputFileName, QUESO::McOptionsValues::m_option_pseq_dataOutputFileType, QUESO::McOptionsValues::m_option_pseq_dataOutputPeriod, QUESO::McOptionsValues::m_option_qseq_computeStats, QUESO::McOptionsValues::m_option_qseq_dataInputFileName, QUESO::McOptionsValues::m_option_qseq_dataInputFileType, QUESO::McOptionsValues::m_option_qseq_dataOutputAllowedSet, QUESO::McOptionsValues::m_option_qseq_dataOutputFileName, QUESO::McOptionsValues::m_option_qseq_dataOutputFileType, QUESO::McOptionsValues::m_option_qseq_dataOutputPeriod, QUESO::McOptionsValues::m_option_qseq_displayPeriod, QUESO::McOptionsValues::m_option_qseq_measureRunTimes, QUESO::McOptionsValues::m_option_qseq_size, QUESO::McOptionsValues::m_parser, QUESO::McOptionsValues::m_pseqComputeStats, QUESO::McOptionsValues::m_pseqDataOutputAllowedSet, QUESO::McOptionsValues::m_pseqDataOutputFileName, QUESO::McOptionsValues::m_pseqDataOutputFileType, QUESO::McOptionsValues::m_pseqDataOutputPeriod, QUESO::McOptionsValues::m_qseqComputeStats, QUESO::McOptionsValues::m_qseqDataInputFileName, QUESO::McOptionsValues::m_qseqDataInputFileType, QUESO::McOptionsValues::m_qseqDataOutputAllowedSet, QUESO::McOptionsValues::m_qseqDataOutputFileName, QUESO::McOptionsValues::m_qseqDataOutputFileType, QUESO::McOptionsValues::m_qseqDataOutputPeriod, QUESO::McOptionsValues::m_qseqDisplayPeriod, QUESO::McOptionsValues::m_qseqMeasureRunTimes, and QUESO::McOptionsValues::m_qseqSize.

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS

  os <<         obj.m_option_dataOutputFileName   << " = " << obj.m_dataOutputFileName
     << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_pseq_dataOutputPeriod     << " = " << obj.m_pseqDataOutputPeriod
     << "\n" << obj.m_option_pseq_dataOutputFileName   << " = " << obj.m_pseqDataOutputFileName
     << "\n" << obj.m_option_pseq_dataOutputFileType   << " = " << obj.m_pseqDataOutputFileType
     << "\n" << obj.m_option_pseq_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_pseqDataOutputAllowedSet.begin(); setIt != obj.m_pseqDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     << "\n" << obj.m_option_pseq_computeStats         << " = " << obj.m_pseqComputeStats
#endif
     << "\n" << obj.m_option_qseq_dataInputFileName    << " = " << obj.m_qseqDataInputFileName
     << "\n" << obj.m_option_qseq_dataInputFileType    << " = " << obj.m_qseqDataInputFileType
     << "\n" << obj.m_option_qseq_size                 << " = " << obj.m_qseqSize
     << "\n" << obj.m_option_qseq_displayPeriod        << " = " << obj.m_qseqDisplayPeriod
     << "\n" << obj.m_option_qseq_measureRunTimes      << " = " << obj.m_qseqMeasureRunTimes
     << "\n" << obj.m_option_qseq_dataOutputPeriod     << " = " << obj.m_qseqDataOutputPeriod
     << "\n" << obj.m_option_qseq_dataOutputFileName   << " = " << obj.m_qseqDataOutputFileName
     << "\n" << obj.m_option_qseq_dataOutputFileType   << " = " << obj.m_qseqDataOutputFileType
     << "\n" << obj.m_option_qseq_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_qseqDataOutputAllowedSet.begin(); setIt != obj.m_qseqDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  os << "\n" << obj.m_option_qseq_computeStats << " = " << obj.m_qseqComputeStats;
#endif

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const EnvironmentOptions &	obj
	)

Print values of the options chosen.

Definition at line 533 of file EnvironmentOptions.C.

References QUESO::EnvironmentOptions::print().

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const TeuchosMatrix &	obj
	)

Definition at line 2182 of file TeuchosMatrix.C.

References QUESO::TeuchosMatrix::print().

{
  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GslMatrix &	obj
	)

Definition at line 1975 of file GslMatrix.C.

References QUESO::GslMatrix::print().

{
  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const BaseEnvironment &	obj
	)

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const GPMSAOptions &	obj
	)

Definition at line 611 of file GPMSAOptions.C.

References QUESO::GPMSAOptions::m_parser, and QUESO::GPMSAOptions::print().

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  obj.print(os);
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MhOptionsValues &	obj
	)

Definition at line 743 of file MetropolisHastingsSGOptions.C.

References QUESO::MhOptionsValues::m_algorithm, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputAllowAll, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputAllowedSet, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputFileName, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputFileType, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputPeriod, QUESO::MhOptionsValues::m_amAdaptInterval, QUESO::MhOptionsValues::m_amEpsilon, QUESO::MhOptionsValues::m_amEta, QUESO::MhOptionsValues::m_amInitialNonAdaptInterval, QUESO::MhOptionsValues::m_amKeepInitialMatrix, QUESO::MhOptionsValues::m_BrooksGelmanLag, QUESO::MhOptionsValues::m_dataOutputAllowAll, QUESO::MhOptionsValues::m_dataOutputAllowedSet, QUESO::MhOptionsValues::m_dataOutputFileName, QUESO::MhOptionsValues::m_displayCandidates, QUESO::MhOptionsValues::m_doLogitTransform, QUESO::MhOptionsValues::m_drDuringAmNonAdaptiveInt, QUESO::MhOptionsValues::m_drMaxNumExtraStages, QUESO::MhOptionsValues::m_drScalesForExtraStages, QUESO::MhOptionsValues::m_enableBrooksGelmanConvMonitor, QUESO::MhOptionsValues::m_filteredChainComputeStats, QUESO::MhOptionsValues::m_filteredChainDataOutputAllowAll, QUESO::MhOptionsValues::m_filteredChainDataOutputAllowedSet, QUESO::MhOptionsValues::m_filteredChainDataOutputFileName, QUESO::MhOptionsValues::m_filteredChainDataOutputFileType, QUESO::MhOptionsValues::m_filteredChainDiscardedPortion, QUESO::MhOptionsValues::m_filteredChainGenerate, QUESO::MhOptionsValues::m_filteredChainLag, QUESO::MhOptionsValues::m_initialPositionDataInputFileName, QUESO::MhOptionsValues::m_initialPositionDataInputFileType, QUESO::MhOptionsValues::m_initialProposalCovMatrixDataInputFileName, QUESO::MhOptionsValues::m_initialProposalCovMatrixDataInputFileType, QUESO::MhOptionsValues::m_option_algorithm, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputFileName, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputFileType, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputPeriod, QUESO::MhOptionsValues::m_option_am_adaptInterval, QUESO::MhOptionsValues::m_option_am_epsilon, QUESO::MhOptionsValues::m_option_am_eta, QUESO::MhOptionsValues::m_option_am_initialNonAdaptInterval, QUESO::MhOptionsValues::m_option_am_keepInitialMatrix, QUESO::MhOptionsValues::m_option_BrooksGelmanLag, QUESO::MhOptionsValues::m_option_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_dataOutputFileName, QUESO::MhOptionsValues::m_option_displayCandidates, QUESO::MhOptionsValues::m_option_doLogitTransform, QUESO::MhOptionsValues::m_option_dr_duringAmNonAdaptiveInt, QUESO::MhOptionsValues::m_option_dr_listOfScalesForExtraStages, QUESO::MhOptionsValues::m_option_dr_maxNumExtraStages, QUESO::MhOptionsValues::m_option_enableBrooksGelmanConvMonitor, QUESO::MhOptionsValues::m_option_filteredChain_computeStats, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputFileName, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputFileType, QUESO::MhOptionsValues::m_option_filteredChain_discardedPortion, QUESO::MhOptionsValues::m_option_filteredChain_generate, QUESO::MhOptionsValues::m_option_filteredChain_lag, QUESO::MhOptionsValues::m_option_initialPosition_dataInputFileName, QUESO::MhOptionsValues::m_option_initialPosition_dataInputFileType, QUESO::MhOptionsValues::m_option_initialProposalCovMatrix_dataInputFileName, QUESO::MhOptionsValues::m_option_initialProposalCovMatrix_dataInputFileType, QUESO::MhOptionsValues::m_option_listOfDisabledParameters, QUESO::MhOptionsValues::m_option_outputLogLikelihood, QUESO::MhOptionsValues::m_option_outputLogTarget, QUESO::MhOptionsValues::m_option_putOutOfBoundsInChain, QUESO::MhOptionsValues::m_option_rawChain_computeStats, QUESO::MhOptionsValues::m_option_rawChain_dataInputFileName, QUESO::MhOptionsValues::m_option_rawChain_dataInputFileType, QUESO::MhOptionsValues::m_option_rawChain_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_rawChain_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_rawChain_dataOutputFileName, QUESO::MhOptionsValues::m_option_rawChain_dataOutputFileType, QUESO::MhOptionsValues::m_option_rawChain_dataOutputPeriod, QUESO::MhOptionsValues::m_option_rawChain_displayPeriod, QUESO::MhOptionsValues::m_option_rawChain_generateExtra, QUESO::MhOptionsValues::m_option_rawChain_measureRunTimes, QUESO::MhOptionsValues::m_option_rawChain_size, QUESO::MhOptionsValues::m_option_tk, QUESO::MhOptionsValues::m_option_tk_useLocalHessian, QUESO::MhOptionsValues::m_option_tk_useNewtonComponent, QUESO::MhOptionsValues::m_option_totallyMute, QUESO::MhOptionsValues::m_option_updateInterval, QUESO::MhOptionsValues::m_outputLogLikelihood, QUESO::MhOptionsValues::m_outputLogTarget, QUESO::MhOptionsValues::m_parameterDisabledSet, QUESO::MhOptionsValues::m_parser, QUESO::MhOptionsValues::m_putOutOfBoundsInChain, QUESO::MhOptionsValues::m_rawChainComputeStats, QUESO::MhOptionsValues::m_rawChainDataInputFileName, QUESO::MhOptionsValues::m_rawChainDataInputFileType, QUESO::MhOptionsValues::m_rawChainDataOutputAllowAll, QUESO::MhOptionsValues::m_rawChainDataOutputAllowedSet, QUESO::MhOptionsValues::m_rawChainDataOutputFileName, QUESO::MhOptionsValues::m_rawChainDataOutputFileType, QUESO::MhOptionsValues::m_rawChainDataOutputPeriod, QUESO::MhOptionsValues::m_rawChainDisplayPeriod, QUESO::MhOptionsValues::m_rawChainGenerateExtra, QUESO::MhOptionsValues::m_rawChainMeasureRunTimes, QUESO::MhOptionsValues::m_rawChainSize, QUESO::MhOptionsValues::m_tk, QUESO::MhOptionsValues::m_tkUseLocalHessian, QUESO::MhOptionsValues::m_tkUseNewtonComponent, QUESO::MhOptionsValues::m_totallyMute, and QUESO::MhOptionsValues::m_updateInterval.

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS

  os <<         obj.m_option_dataOutputFileName                         << " = " << obj.m_dataOutputFileName
     << "\n" << obj.m_option_dataOutputAllowAll                         << " = " << obj.m_dataOutputAllowAll
     << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_totallyMute                                << " = " << obj.m_totallyMute
     << "\n" << obj.m_option_initialPosition_dataInputFileName          << " = " << obj.m_initialPositionDataInputFileName
     << "\n" << obj.m_option_initialPosition_dataInputFileType          << " = " << obj.m_initialPositionDataInputFileType
     << "\n" << obj.m_option_initialProposalCovMatrix_dataInputFileName << " = " << obj.m_initialProposalCovMatrixDataInputFileName
     << "\n" << obj.m_option_initialProposalCovMatrix_dataInputFileType << " = " << obj.m_initialProposalCovMatrixDataInputFileType
     << "\n" << obj.m_option_listOfDisabledParameters                   << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_parameterDisabledSet.begin(); setIt != obj.m_parameterDisabledSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_rawChain_dataInputFileName                 << " = " << obj.m_rawChainDataInputFileName
     << "\n" << obj.m_option_rawChain_dataInputFileType                 << " = " << obj.m_rawChainDataInputFileType
     << "\n" << obj.m_option_rawChain_size                              << " = " << obj.m_rawChainSize
     << "\n" << obj.m_option_rawChain_generateExtra                     << " = " << obj.m_rawChainGenerateExtra
     << "\n" << obj.m_option_rawChain_displayPeriod                     << " = " << obj.m_rawChainDisplayPeriod
     << "\n" << obj.m_option_rawChain_measureRunTimes                   << " = " << obj.m_rawChainMeasureRunTimes
     << "\n" << obj.m_option_rawChain_dataOutputPeriod                  << " = " << obj.m_rawChainDataOutputPeriod
     << "\n" << obj.m_option_rawChain_dataOutputFileName                << " = " << obj.m_rawChainDataOutputFileName
     << "\n" << obj.m_option_rawChain_dataOutputFileType                << " = " << obj.m_rawChainDataOutputFileType
     << "\n" << obj.m_option_rawChain_dataOutputAllowAll                << " = " << obj.m_rawChainDataOutputAllowAll
     << "\n" << obj.m_option_rawChain_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_rawChainDataOutputAllowedSet.begin(); setIt != obj.m_rawChainDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     << "\n" << obj.m_option_rawChain_computeStats                      << " = " << obj.m_rawChainComputeStats
#endif
     << "\n" << obj.m_option_filteredChain_generate                     << " = " << obj.m_filteredChainGenerate
     << "\n" << obj.m_option_filteredChain_discardedPortion             << " = " << obj.m_filteredChainDiscardedPortion
     << "\n" << obj.m_option_filteredChain_lag                          << " = " << obj.m_filteredChainLag
     << "\n" << obj.m_option_filteredChain_dataOutputFileName           << " = " << obj.m_filteredChainDataOutputFileName
     << "\n" << obj.m_option_filteredChain_dataOutputFileType           << " = " << obj.m_filteredChainDataOutputFileType
     << "\n" << obj.m_option_filteredChain_dataOutputAllowAll           << " = " << obj.m_filteredChainDataOutputAllowAll
     << "\n" << obj.m_option_filteredChain_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_filteredChainDataOutputAllowedSet.begin(); setIt != obj.m_filteredChainDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     << "\n" << obj.m_option_filteredChain_computeStats                 << " = " << obj.m_filteredChainComputeStats
#endif
     << "\n" << obj.m_option_displayCandidates                          << " = " << obj.m_displayCandidates
     << "\n" << obj.m_option_putOutOfBoundsInChain                      << " = " << obj.m_putOutOfBoundsInChain
     << "\n" << obj.m_option_tk_useLocalHessian                         << " = " << obj.m_tkUseLocalHessian
     << "\n" << obj.m_option_tk_useNewtonComponent                      << " = " << obj.m_tkUseNewtonComponent
     << "\n" << obj.m_option_dr_maxNumExtraStages                       << " = " << obj.m_drMaxNumExtraStages
     << "\n" << obj.m_option_dr_listOfScalesForExtraStages << " = ";
  for (unsigned int i = 0; i < obj.m_drScalesForExtraStages.size(); ++i) {
    os << obj.m_drScalesForExtraStages[i] << " ";
  }
  os << "\n" << obj.m_option_dr_duringAmNonAdaptiveInt                  << " = " << obj.m_drDuringAmNonAdaptiveInt
     << "\n" << obj.m_option_am_keepInitialMatrix                       << " = " << obj.m_amKeepInitialMatrix
     << "\n" << obj.m_option_am_initialNonAdaptInterval                 << " = " << obj.m_amInitialNonAdaptInterval
     << "\n" << obj.m_option_am_adaptInterval                           << " = " << obj.m_amAdaptInterval
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputPeriod        << " = " << obj.m_amAdaptedMatricesDataOutputPeriod
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputFileName      << " = " << obj.m_amAdaptedMatricesDataOutputFileName
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputFileType      << " = " << obj.m_amAdaptedMatricesDataOutputFileType
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputAllowAll      << " = " << obj.m_amAdaptedMatricesDataOutputAllowAll
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_amAdaptedMatricesDataOutputAllowedSet.begin(); setIt != obj.m_amAdaptedMatricesDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_am_eta                                     << " = " << obj.m_amEta
     << "\n" << obj.m_option_am_epsilon                                 << " = " << obj.m_amEpsilon
     << "\n" << obj.m_option_enableBrooksGelmanConvMonitor              << " = " << obj.m_enableBrooksGelmanConvMonitor
     << "\n" << obj.m_option_BrooksGelmanLag                            << " = " << obj.m_BrooksGelmanLag
     << "\n" << obj.m_option_outputLogLikelihood                        << " = " << obj.m_outputLogLikelihood
     << "\n" << obj.m_option_outputLogTarget                            << " = " << obj.m_outputLogTarget
     << "\n" << obj.m_option_doLogitTransform                           << " = " << obj.m_doLogitTransform
     << "\n" << obj.m_option_algorithm                                  << " = " << obj.m_algorithm
     << "\n" << obj.m_option_tk                                         << " = " << obj.m_tk
     << "\n" << obj.m_option_updateInterval                             << " = " << obj.m_updateInterval
     << std::endl;

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MLSamplingLevelOptions &	obj
	)

Definition at line 842 of file MLSamplingLevelOptions.C.

References QUESO::MLSamplingLevelOptions::m_parser, and QUESO::MLSamplingLevelOptions::print().

{
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  obj.print(os);
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const MetropolisHastingsSGOptions &	obj
	)

Definition at line 1720 of file MetropolisHastingsSGOptions.C.

References QUESO::MetropolisHastingsSGOptions::print().

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const SequenceStatisticalOptions &	obj
	)

Definition at line 1457 of file SequenceStatisticalOptions.C.

References SequenceStatisticalOptions::print().

{
  queso_deprecated();

  obj.print(os);

  return os;
}

template<class P_V , class P_M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MLSampling< P_V, P_M > &	obj
	)

Definition at line 4822 of file MLSampling.C.

{
  obj.print(os);

  return os;
}

bool QUESO::operator==	(	const GslVector &	lhs,
		const GslVector &	rhs
	)

Definition at line 1168 of file GslVector.C.

References queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

{
  bool answer = true;

  unsigned int size1 = lhs.sizeLocal();
  unsigned int size2 = rhs.sizeLocal();
  queso_require_equal_to_msg(size1, size2, "different sizes of lhs and rhs");

  for (unsigned int i = 0; i < size1; ++i) {
    if (lhs[i] != rhs[i]) {
      answer = false;
      break;
    }
  }

  return answer;
}

bool QUESO::operator==	(	const TeuchosVector &	lhs,
		const TeuchosVector &	rhs
	)

Definition at line 1235 of file TeuchosVector.C.

References queso_require_equal_to_msg, and QUESO::TeuchosVector::sizeLocal().

{
  bool answer = true;
  unsigned int size1 = lhs.sizeLocal();
  unsigned int size2 = rhs.sizeLocal();

  queso_require_equal_to_msg(size1, size2, "different sizes of lhs and rhs");

  for (unsigned int i = 0; i < size1; ++i) {
    if (lhs[i] != rhs[i]) {
      answer = false;
      break;
    }
  }

  return answer;
}

int QUESO::QUESO_get_numeric_version

(

)

Definition at line 86 of file Environment.C.

Referenced by QUESO_version_print().

  {
    // Note: return format follows the versioning convention xx.yy.z where
    //
    // xx = major version number
    // yy = minor version number
    // zz = micro version number
    //
    // For example:
    // v.    0.23  -> 002300 = 2300
    // v.   0.23.1 -> 002301 = 2301
    // v.  10.23.2 -> 102302

    int major_version = 0;
    int minor_version = 0;
    int micro_version = 0;

#ifdef QUESO_MAJOR_VERSION
    major_version = QUESO_MAJOR_VERSION;
#endif

#ifdef QUESO_MINOR_VERSION
    minor_version = QUESO_MINOR_VERSION;
#endif

#ifdef QUESO_MICRO_VERSION
    micro_version = QUESO_MICRO_VERSION;
#endif

    return(major_version*10000 + minor_version*100 + micro_version);
  }

template<typename T >

bool QUESO::queso_isfinite

(

T

arg

)

Definition at line 51 of file math_macros.h.

Referenced by QUESO::InterpolationSurrogateData< V, M >::check_domain_bounds(), QUESO::InvLogitGaussianJointPdf< V, M >::lnValue(), QUESO::UniformVectorRealizer< V, M >::realization(), QUESO::InvLogitGaussianVectorRealizer< V, M >::realization(), QUESO::MetropolisHastingsSG< P_V, P_M >::transformInitialCovMatrixToGaussianSpace(), and QUESO::TransformedScaledCovMatrixTKGroup< V, M >::transformToGaussianSpace().

  {
#ifdef QUESO_HAVE_CXX11_ISFINITE
    return std::isfinite(arg);
#elif QUESO_HAVE_BOOST_MATH_SPECIAL_FUNCTIONS_HPP
    return (boost::math::isfinite)(arg);
#else
#     error "No valid definition for isfinite found!"
#endif
  }

template<typename T >

bool QUESO::queso_isnan

(

T

arg

)

Definition at line 39 of file math_macros.h.

Referenced by QUESO::Algorithm< V, M >::acceptance_ratio(), QUESO::UniformJointPdf< V, M >::actualValue(), QUESO::MetropolisHastingsSG< P_V, P_M >::alpha(), QUESO::BaseJointPdf< V, M >::commonComputeLogOfNormalizationFactor(), QUESO::PoweredJointPdf< V, M >::computeLogOfNormalizationFactor(), QUESO::BayesianJointPdf< V, M >::computeLogOfNormalizationFactor(), QUESO::ConcatenatedJointPdf< V, M >::computeLogOfNormalizationFactor(), QUESO::UniformJointPdf< V, M >::lnValue(), and QUESO::GPMSAEmulator< V, M >::lnValue().

  {
#ifdef QUESO_HAVE_CXX11_ISNAN
    return std::isnan(arg);
#elif QUESO_HAVE_BOOST_MATH_SPECIAL_FUNCTIONS_HPP
    return (boost::math::isnan)(arg);
#else
#     error "No valid definition for is_nan found!"
#endif
  }

QUESO::QUESO_STANDARD_TYPE	(	char	,
		MPI_CHAR
	)

QUESO::QUESO_STANDARD_TYPE	(	int	,
		MPI_INT
	)

QUESO::QUESO_STANDARD_TYPE	(	unsigned	int,
		MPI_UNSIGNED
	)

QUESO::QUESO_STANDARD_TYPE	(	double	,
		MPI_DOUBLE
	)

void QUESO::queso_terminate_handler

(

)

Function for unhandled exceptions in Queso.

queso_terminate_handler This function deals with unhandled exceptions encountered in Queso. It provides a call to MPI_abort using the global communicator.

Definition at line 1731 of file Environment.C.

References old_terminate_handler.

Referenced by QUESO::FullEnvironment::construct().

{
#ifdef QUESO_HAS_MPI
  int mpi_initialized;
  MPI_Initialized (&mpi_initialized);

  if (mpi_initialized)
    {
      //MPI_Abort(m_fullComm->Comm(), 1);
      MPI_Abort(MPI_COMM_WORLD, 1);
    }
  else
    {
      // The system terminate_handler may do useful things like printing
      // uncaught exception information, or the user may have created
      // their own terminate handler that we want to call.
      old_terminate_handler();
    }
#else
  old_terminate_handler();
#endif
  exit(1);
}

void QUESO::QUESO_version_print

(

std::ostream &

os

)

Definition at line 56 of file Environment.C.

References QUESO_get_numeric_version().

Referenced by QUESO::FullEnvironment::construct(), and main().

  {
    {
      os << "------------------------------------------------------------------------------------------" ;
      os << "--------------------" << std::endl;
      os << "QUESO Library: Version = " << QUESO_VERSION;
      os << " (" << QUESO_get_numeric_version() << ")" << std::endl << std::endl;

      os << QUESO_BUILD_DEVSTATUS << std::endl << std::endl;

      os << "Build Date   = " << QUESO_BUILD_DATE     << std::endl;
      os << "Build Host   = " << QUESO_BUILD_HOST     << std::endl;
      os << "Build User   = " << QUESO_BUILD_USER     << std::endl;
      os << "Build Arch   = " << QUESO_BUILD_ARCH     << std::endl;
      os << "Build Rev    = " << QUESO_BUILD_VERSION  << std::endl     << std::endl;

      os << "C++ Config   = " << QUESO_CXX << " " << QUESO_CXXFLAGS    << std::endl;
      os << std::endl;
      os << "Trilinos DIR = " << QUESO_TRILINOS_DIR << std::endl;
      os << "GSL Libs     = " << QUESO_GSL_DIR  << std::endl;
      os << "GRVY DIR     = " << QUESO_GRVY_DIR << std::endl;
      os << "GLPK DIR     = " << QUESO_GLPK_DIR << std::endl;
      os << "HDF5 DIR     = " << QUESO_HDF5_DIR << std::endl;
      os << "------------------------------------------------------------------------------------------" ;
      os << "--------------------" << std::endl;
    }

    return;
  }

SfpOptionsValues::SfpOptionsValues () m_parser QUESO::registerOption< bool >	(	m_option_computeSolution	,
		UQ_SFP_COMPUTE_SOLUTION_ODV	,
		"compute solution process"
	)

m_parser QUESO::registerOption< bool >	(	m_option_computeCovariances	,
		UQ_SFP_COMPUTE_COVARIANCES_ODV	,
		"compute pq covariances"
	)

m_parser QUESO::registerOption< bool >	(	m_option_computeCorrelations	,
		UQ_SFP_COMPUTE_CORRELATIONS_ODV	,
		"compute pq correlations"
	)

m_parser QUESO::registerOption< std::string >	(	m_option_dataOutputFileName	,
		UQ_SFP_DATA_OUTPUT_FILE_NAME_ODV	,
		"name of data output file"
	)

m_parser QUESO::registerOption< std::string >	(	m_option_dataOutputAllowedSet	,
		UQ_SFP_DATA_OUTPUT_ALLOWED_SET_ODV	,
		"subEnvs that will write to data output file"
	)

m_parser QUESO::registerOption< std::string >	(	m_option_solver	,
		UQ_SFP_SOLVER_ODV	,
		"algorithm for propagation"
	)

TeuchosMatrix QUESO::rightDiagScaling	(	const TeuchosMatrix &	mat,
		const TeuchosVector &	vec
	)

Definition at line 2159 of file TeuchosMatrix.C.

References QUESO::TeuchosMatrix::numCols(), QUESO::TeuchosMatrix::numRowsLocal(), queso_require_equal_to_msg, and QUESO::TeuchosVector::sizeLocal().

{
  unsigned int vSize = vec.sizeLocal();
  unsigned int mRows = mat.numRowsLocal();
  unsigned int mCols = mat.numCols();

  queso_require_equal_to_msg(vSize, mCols, "size of vector is different from the number of cols in matrix");

  queso_require_equal_to_msg(mCols, mRows, "routine currently works for square matrices only");

  TeuchosMatrix answer(mat);
  for (unsigned int j = 0; j < mCols; ++j) {
    double vecValue = vec[j];
    for (unsigned int i = 0; i < mRows; ++i) {
      answer(i,j) *= vecValue;
    }
  }

  return answer;
}

GslMatrix QUESO::rightDiagScaling	(	const GslMatrix &	mat,
		const GslVector &	vec
	)

Definition at line 2073 of file GslMatrix.C.

References QUESO::GslMatrix::numCols(), QUESO::GslMatrix::numRowsLocal(), queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

{
  unsigned int vSize = vec.sizeLocal();
  unsigned int mRows = mat.numRowsLocal();
  unsigned int mCols = mat.numCols();

  queso_require_equal_to_msg(vSize, mCols, "size of vector is different from the number of cols in matrix");

  queso_require_equal_to_msg(mCols, mRows, "routine currently works for square matrices only");

  GslMatrix answer(mat);
  for (unsigned int j = 0; j < mCols; ++j) {
    double vecValue = vec[j];
    for (unsigned int i = 0; i < mRows; ++i) {
      answer(i,j) *= vecValue;
    }
  }

  return answer;
}

double QUESO::scalarProduct	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1137 of file GslVector.C.

References queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

Referenced by QUESO::GslVector::norm2Sq(), and QUESO::GPMSAFactory< V, M >::setUpHyperpriors().

{
  unsigned int size1 = x.sizeLocal();
  unsigned int size2 = y.sizeLocal();
  queso_require_equal_to_msg(size1, size2, "different sizes of x and y");

  double result = 0.;
  for (unsigned int i = 0; i < size1; ++i) {
    result += x[i]*y[i];
  }

  return result;
}

double QUESO::scalarProduct	(	const TeuchosVector &	x,
		const TeuchosVector &	y
	)

Definition at line 1203 of file TeuchosVector.C.

References queso_require_equal_to_msg, and QUESO::TeuchosVector::sizeLocal().

{
  unsigned int size1 = x.sizeLocal();
  unsigned int size2 = y.sizeLocal();

  queso_require_equal_to_msg(size1, size2, "different sizes of x and y");
  double result = 0.;
  for (unsigned int i = 0; i < size1; ++i) {
    result += x[i]*y[i];
  }

  return result;
}

m_parser QUESO::scanInputFile

(

)

template<class T >

double QUESO::SubF1F2Gaussian2dKdeIntegral	(	const ScalarSequence< T > &	scalarSeq1,
		const ScalarSequence< T > &	scalarSeq2,
		unsigned int	initialPos,
		double	scaleValue1,
		double	scaleValue2,
		const Base1D1DFunction &	func1,
		const Base1D1DFunction &	func2,
		unsigned int	quadratureOrder
	)

Calculates the integral of a 2D Gaussian KDE.

This function performs numerical integration (via Hermite-Gauss quadrature, see GaussianHermite1DQuadrature), of a bi-variate Gaussian KDE (refer to ScalarSequence::subGaussian1dKde(), ArrayOfSequences::gaussianKDE(), or SequenceOfVectors::subGaussian1dKde().

Definition at line 875 of file 1D1DFunction.C.

References queso_require_equal_to_msg, QUESO::ScalarSequence< T >::subSequenceSize(), and QUESO::Base1D1DFunction::value().

{
  double resultValue = 0.;

  queso_require_equal_to_msg(initialPos, 0, "not implemented yet for initialPos != 0");
  queso_require_equal_to_msg(scalarSeq1.subSequenceSize(), scalarSeq2.subSequenceSize(), "different sizes");

  GaussianHermite1DQuadrature quadObj(0.,1.,quadratureOrder);
  const std::vector<double>& quadPositions = quadObj.positions();
  const std::vector<double>& quadWeights   = quadObj.weights  ();
  queso_require_equal_to_msg(quadPositions.size(), quadWeights.size(), "quadObj has invalid state");

  unsigned int numQuadraturePositions = quadPositions.size();
  unsigned int dataSize = scalarSeq1.subSequenceSize();
  for (unsigned int k = 0; k < dataSize; ++k) {
    double value1 = 0.;
    double value2 = 0.;
    double x1k = scalarSeq1[k];
    double x2k = scalarSeq2[k];
    for (unsigned int j = 0; j < numQuadraturePositions; ++j) {
      value1 += func1.value(scaleValue1*quadPositions[j]+x1k)*quadWeights[j];
      value2 += func2.value(scaleValue2*quadPositions[j]+x2k)*quadWeights[j];
    }
    resultValue += value1*value2;
  }
  resultValue *= 1./(2.*M_PI)/((double) dataSize);

  return resultValue;
}

void QUESO::whiteningANN_X_Y	(	ANNpointArray	dataX1,
		ANNpointArray	dataX2,
		unsigned int	dimX,
		unsigned int	N1,
		unsigned int	N2
	)

Not defined anywhere!

Variable Documentation

template<typename T >

DistArray<T>::DistArray (const Map& inputMap, const int inputRowSize) QUESO::for(int i=0;i< m_Map.NumGlobalElements();++i)

Definition at line 53 of file DistArray.C.

                                                      {
    m_elements[i].resize(m_rowSize);
  }

QUESO::if

Initial value:

=
    new SequenceStatisticalOptions(m_env,m_prefix + "qseq_",m_ov.m_alternativeQSsOptionsValues)

Definition at line 104 of file MonteCarloSGOptions.C.

Referenced by QUESO::MetropolisHastingsSG< P_V, P_M >::delayedRejection(), and QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain().

  :
    m_prefix                          ((std::string)(prefix) + "mc_"),
    m_help                       (UQ_MOC_SG_HELP),
    m_dataOutputFileName         (UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV     ),
  //m_dataOutputAllowedSet       (),
    m_pseqDataOutputPeriod       (UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV   ),
    m_pseqDataOutputFileName     (UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV),
    m_pseqDataOutputFileType     (UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV),
  //m_pseqDataOutputAllowedSet   (),
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
    m_pseqComputeStats           (UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV        ),
#endif
    m_qseqDataInputFileName      (UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV ),
    m_qseqDataInputFileType      (UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV ),
    m_qseqSize                   (UQ_MOC_SG_QSEQ_SIZE_ODV                 ),
    m_qseqDisplayPeriod          (UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV       ),
    m_qseqMeasureRunTimes        (UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV    ),
    m_qseqDataOutputPeriod       (UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV   ),
    m_qseqDataOutputFileName     (UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV),
    m_qseqDataOutputFileType     (UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV),
  //m_qseqDataOutputAllowedSet   (),
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
    m_qseqComputeStats           (UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV        ),
    m_alternativePSsOptionsValues(),
    m_alternativeQSsOptionsValues(),
#endif
#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
    m_parser(new BoostInputOptionsParser(env->optionsInputFileName())),
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
    m_option_help                     (m_prefix + "help"                       ),
    m_option_dataOutputFileName       (m_prefix + "dataOutputFileName"         ),
    m_option_dataOutputAllowedSet     (m_prefix + "dataOutputAllowedSet"       ),
    m_option_pseq_dataOutputPeriod    (m_prefix + "pseq_dataOutputPeriod"      ),
    m_option_pseq_dataOutputFileName  (m_prefix + "pseq_dataOutputFileName"    ),
    m_option_pseq_dataOutputFileType  (m_prefix + "pseq_dataOutputFileType"    ),
    m_option_pseq_dataOutputAllowedSet(m_prefix + "pseq_dataOutputAllowedSet"  ),
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
    m_option_pseq_computeStats        (m_prefix + "pseq_computeStats"          ),
#endif
    m_option_qseq_dataInputFileName   (m_prefix + "qseq_dataInputFileName"     ),
    m_option_qseq_dataInputFileType   (m_prefix + "qseq_dataInputFileType"     ),
    m_option_qseq_size                (m_prefix + "qseq_size"                  ),
    m_option_qseq_displayPeriod       (m_prefix + "qseq_displayPeriod"         ),
    m_option_qseq_measureRunTimes     (m_prefix + "qseq_measureRunTimes"       ),
    m_option_qseq_dataOutputPeriod    (m_prefix + "qseq_dataOutputPeriod"      ),
    m_option_qseq_dataOutputFileName  (m_prefix + "qseq_dataOutputFileName"    ),
    m_option_qseq_dataOutputFileType  (m_prefix + "qseq_dataOutputFileType"    ),
    m_option_qseq_dataOutputAllowedSet(m_prefix + "qseq_dataOutputAllowedSet"  )
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
    ,
    m_option_qseq_computeStats        (m_prefix + "qseq_computeStats"          )
#endif
{
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  if (alternativePSsOptionsValues) m_alternativePSsOptionsValues = *alternativePSsOptionsValues;
  if (alternativeQSsOptionsValues) m_alternativeQSsOptionsValues = *alternativeQSsOptionsValues;
#endif

#ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  m_parser->registerOption<std::string >(m_option_help,                      UQ_MOC_SG_HELP                            , "produce help message for Monte Carlo distribution calculator");
  m_parser->registerOption<std::string >(m_option_dataOutputFileName,        UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV       , "name of generic data output file"                            );
  m_parser->registerOption<std::string >(m_option_dataOutputAllowedSet,      UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV     , "subEnvs that will write to generic data output file"         );
  m_parser->registerOption<unsigned int>(m_option_pseq_dataOutputPeriod,     UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV     , "period of message display during param sequence generation"  );
  m_parser->registerOption<std::string >(m_option_pseq_dataOutputFileName,   UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV  , "name of data output file for parameters"                     );
  m_parser->registerOption<std::string >(m_option_pseq_dataOutputFileType,   UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV  , "type of data output file for parameters"                     );
  m_parser->registerOption<std::string >(m_option_pseq_dataOutputAllowedSet, UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV, "subEnvs that will write to data output file for parameters"  );
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_parser->registerOption<bool        >(m_option_pseq_computeStats,         UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV          , "compute statistics on sequence of parameter"                 );
#endif
  m_parser->registerOption<std::string >(m_option_qseq_dataInputFileName,    UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV   , "name of data input file for qois"                            );
  m_parser->registerOption<std::string >(m_option_qseq_dataInputFileType,    UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV   , "type of data input file for qois"                            );
  m_parser->registerOption<unsigned int>(m_option_qseq_size,                 UQ_MOC_SG_QSEQ_SIZE_ODV                   , "size of qoi sequence"                                        );
  m_parser->registerOption<unsigned int>(m_option_qseq_displayPeriod,        UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV         , "period of message display during qoi sequence generation"    );
  m_parser->registerOption<bool        >(m_option_qseq_measureRunTimes,      UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV      , "measure run times"                                           );
  m_parser->registerOption<unsigned int>(m_option_qseq_dataOutputPeriod,     UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV     , "period of message display during qoi sequence generation"    );
  m_parser->registerOption<std::string >(m_option_qseq_dataOutputFileName,   UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV  , "name of data output file for qois"                           );
  m_parser->registerOption<std::string >(m_option_qseq_dataOutputFileType,   UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV  , "type of data output file for qois"                           );
  m_parser->registerOption<std::string >(m_option_qseq_dataOutputAllowedSet, UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV, "subEnvs that will write to data output file for qois"        );
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_parser->registerOption<bool        >(m_option_qseq_computeStats,         UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV          , "compute statistics on sequence of qoi"                       );
#endif

  m_parser->scanInputFile();

  m_parser->getOption<std::string >(m_option_help,        m_help);
  m_parser->getOption<std::string >(m_option_dataOutputFileName,        m_dataOutputFileName);
  m_parser->getOption<std::set<unsigned int> >(m_option_dataOutputAllowedSet,      m_dataOutputAllowedSet);
  m_parser->getOption<unsigned int>(m_option_pseq_dataOutputPeriod,     m_pseqDataOutputPeriod);
  m_parser->getOption<std::string >(m_option_pseq_dataOutputFileName,   m_pseqDataOutputFileName);
  m_parser->getOption<std::string >(m_option_pseq_dataOutputFileType,   m_pseqDataOutputFileType);
  m_parser->getOption<std::set<unsigned int> >(m_option_pseq_dataOutputAllowedSet, m_pseqDataOutputAllowedSet);
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_parser->getOption<bool        >(m_option_pseq_computeStats,         m_pseq_computeStats);
#endif
  m_parser->getOption<std::string >(m_option_qseq_dataInputFileName,    m_qseqDataInputFileName);
  m_parser->getOption<std::string >(m_option_qseq_dataInputFileType,    m_qseqDataInputFileType);
  m_parser->getOption<unsigned int>(m_option_qseq_size,                 m_qseqSize);
  m_parser->getOption<unsigned int>(m_option_qseq_displayPeriod,        m_qseqDisplayPeriod);
  m_parser->getOption<bool        >(m_option_qseq_measureRunTimes,      m_qseqMeasureRunTimes);
  m_parser->getOption<unsigned int>(m_option_qseq_dataOutputPeriod,     m_qseqDataOutputPeriod);
  m_parser->getOption<std::string >(m_option_qseq_dataOutputFileName,   m_qseqDataOutputFileName);
  m_parser->getOption<std::string >(m_option_qseq_dataOutputFileType,   m_qseqDataOutputFileType);
  m_parser->getOption<std::set<unsigned int> >(m_option_qseq_dataOutputAllowedSet, m_qseqDataOutputAllowedSet);
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_parser->getOption<bool        >(m_option_qseq_computeStats,         m_qseq_computeStats);
#endif
#else
  m_help = env->input()(m_option_help, UQ_MOC_SG_HELP);
  m_dataOutputFileName = env->input()(m_option_dataOutputFileName, UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV);

  // UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV is the empty set (string) by default
  unsigned int size = env->input().vector_variable_size(m_option_dataOutputAllowedSet);
  for (unsigned int i = 0; i < size; i++) {
    // We default to empty set, so the default values are actually never
    // used here
    unsigned int allowed = env->input()(m_option_dataOutputAllowedSet, i, i);
    m_dataOutputAllowedSet.insert(allowed);
  }

  m_pseqDataOutputPeriod = env->input()(m_option_pseq_dataOutputPeriod, UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV);
  m_pseqDataOutputFileName = env->input()(m_option_pseq_dataOutputFileName, UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV);
  m_pseqDataOutputFileType = env->input()(m_option_pseq_dataOutputFileType, UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV);

  // UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV is the empty set (string) by default
  size = env->input().vector_variable_size(m_option_pseq_dataOutputAllowedSet);
  for (unsigned int i = 0; i < size; i++) {
    // We default to empty set, so the default values are actually never
    // used here
    unsigned int allowed = env->input()(m_option_pseq_dataOutputAllowedSet, i, i);
    m_pseqDataOutputAllowedSet.insert(allowed);
  }

#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_pseq_computeStats = env->input()(m_option_pseq_computeStats, UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV);
#endif
  m_qseqDataInputFileName = env->input()(m_option_qseq_dataInputFileName, UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV);
  m_qseqDataInputFileType = env->input()(m_option_qseq_dataInputFileType, UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV);
  m_qseqSize = env->input()(m_option_qseq_size, UQ_MOC_SG_QSEQ_SIZE_ODV);
  m_qseqDisplayPeriod = env->input()(m_option_qseq_displayPeriod, UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV);
  m_qseqMeasureRunTimes = env->input()(m_option_qseq_measureRunTimes, UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV);
  m_qseqDataOutputPeriod = env->input()(m_option_qseq_dataOutputPeriod, UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV);
  m_qseqDataOutputFileName = env->input()(m_option_qseq_dataOutputFileName, UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV);
  m_qseqDataOutputFileType = env->input()(m_option_qseq_dataOutputFileType, UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV);

  // UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV is the empty set (string) by default
  size = env->input().vector_variable_size(m_option_qseq_dataOutputAllowedSet);
  for (unsigned int i = 0; i < size; i++) {
    // We default to empty set, so the default values are actually never
    // used here
    unsigned int allowed = env->input()(m_option_qseq_dataOutputAllowedSet, i, i);
    m_qseqDataOutputAllowedSet.insert(allowed);
  }

#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_qseq_computeStats = env->input()(m_option_qseq_computeStats, UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV);
#endif
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
}

QUESO::m_computeCorrelations = env->input()(m_option_computeCorrelations, UQ_SFP_COMPUTE_CORRELATIONS_ODV)

Definition at line 118 of file StatisticalForwardProblemOptions.C.

QUESO::m_computeCovariances = env->input()(m_option_computeCovariances, UQ_SFP_COMPUTE_COVARIANCES_ODV)

Definition at line 117 of file StatisticalForwardProblemOptions.C.

QUESO::m_computeSolution = env->input()(m_option_computeSolution, UQ_SFP_COMPUTE_SOLUTION_ODV)

Definition at line 116 of file StatisticalForwardProblemOptions.C.

QUESO::m_dataOutputFileName = env->input()(m_option_dataOutputFileName, UQ_SFP_DATA_OUTPUT_FILE_NAME_ODV)

Definition at line 119 of file StatisticalForwardProblemOptions.C.

Referenced by QUESO::McOptionsValues::copy().

QUESO::m_help = env->input()(m_option_help, UQ_SFP_HELP)

Definition at line 115 of file StatisticalForwardProblemOptions.C.

QUESO::m_solver = env->input()(m_option_solver, UQ_SFP_SOLVER_ODV)

Definition at line 131 of file StatisticalForwardProblemOptions.C.

Referenced by QUESO::SipOptionsValues::SipOptionsValues().

std::terminate_handler QUESO::old_terminate_handler

Definition at line 139 of file Environment.C.

Referenced by QUESO::FullEnvironment::construct(), and queso_terminate_handler().

StatisticalForwardProblemOptions::StatisticalForwardProblemOptions ( const BaseEnvironment& env, const char* prefix, const SfpOptionsValues& alternativeOptionsValues QUESO::queso_require_equal_to_msg)(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the existence of an options input file"))

Definition at line 460 of file MonteCarloSGOptions.C.

Referenced by QUESO::UniformJointPdf< V, M >::actualValue(), QUESO::BetaJointPdf< V, M >::actualValue(), QUESO::WignerJointPdf< V, M >::actualValue(), QUESO::InverseGammaJointPdf< V, M >::actualValue(), QUESO::BayesianJointPdf< V, M >::actualValue(), QUESO::PoweredJointPdf< V, M >::actualValue(), QUESO::LogNormalJointPdf< V, M >::actualValue(), QUESO::GaussianJointPdf< V, M >::actualValue(), QUESO::ConcatenatedJointPdf< V, M >::actualValue(), QUESO::GammaJointPdf< V, M >::actualValue(), QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::MpiComm::Allreduce(), QUESO::MetropolisHastingsSG< P_V, P_M >::alpha(), QUESO::TeuchosVector::atLeastOneComponentBiggerOrEqualThan(), QUESO::GslVector::atLeastOneComponentBiggerOrEqualThan(), QUESO::TeuchosVector::atLeastOneComponentBiggerThan(), QUESO::GslVector::atLeastOneComponentBiggerThan(), QUESO::TeuchosVector::atLeastOneComponentSmallerOrEqualThan(), QUESO::GslVector::atLeastOneComponentSmallerOrEqualThan(), QUESO::TeuchosVector::atLeastOneComponentSmallerThan(), QUESO::GslVector::atLeastOneComponentSmallerThan(), QUESO::MpiComm::Barrier(), QUESO::MpiComm::Bcast(), QUESO::BoxSubset< V, M >::BoxSubset(), QUESO::VectorFunctionSynchronizer< P_V, P_M, Q_V, Q_M >::callFunction(), QUESO::ConcatenationSubset< V, M >::centroid(), QUESO::InfiniteDimensionalMCMCSamplerOptions::checkOptions(), QUESO::MhOptionsValues::checkOptions(), QUESO::MLSampling< P_V, P_M >::checkpointML(), QUESO::HessianCovMatricesTKGroup< V, M >::clearPreComputingPositions(), ComputeConditionalGaussianVectorRV(), ComputeSubGaussian2dKde(), QUESO::ConcatenatedJointPdf< V, M >::ConcatenatedJointPdf(), QUESO::FullEnvironment::construct(), QUESO::ConcatenationSubset< V, M >::contains(), QUESO::BaseVectorSequence< V, M >::copy(), QUESO::TeuchosVector::copy_from_std_vector(), QUESO::GenericMatrixCovarianceFunction< P_V, P_M, Q_V, Q_M >::covMatrix(), QUESO::ExponentialMatrixCovarianceFunction< P_V, P_M, Q_V, Q_M >::covMatrix(), QUESO::GslVector::cwSetBeta(), QUESO::TeuchosVector::cwSetBeta(), QUESO::GslVector::cwSetConcatenated(), QUESO::TeuchosVector::cwSetConcatenated(), QUESO::GslVector::cwSetGamma(), QUESO::TeuchosVector::cwSetGamma(), QUESO::GslVector::cwSetInverseGamma(), QUESO::TeuchosVector::cwSetInverseGamma(), QUESO::MLSampling< P_V, P_M >::decideOnBalancedChains_all(), QUESO::MetropolisHastingsSG< P_V, P_M >::delayedRejection(), QUESO::TeuchosMatrix::eigen(), QUESO::GslMatrix::eigen(), QUESO::EnvironmentOptions::EnvironmentOptions(), QUESO::SequenceOfVectors< V, M >::erasePositions(), QUESO::ScalarSequence< T >::erasePositions(), QUESO::ExponentialMatrixCovarianceFunction< P_V, P_M, Q_V, Q_M >::ExponentialMatrixCovarianceFunction(), QUESO::TeuchosMatrix::fillWithBlocksDiagonally(), QUESO::GslMatrix::fillWithBlocksDiagonally(), QUESO::TeuchosMatrix::fillWithBlocksHorizontally(), QUESO::GslMatrix::fillWithBlocksHorizontally(), QUESO::TeuchosMatrix::fillWithBlocksVertically(), QUESO::GslMatrix::fillWithBlocksVertically(), QUESO::TeuchosMatrix::fillWithTensorProduct(), QUESO::GslMatrix::fillWithTensorProduct(), QUESO::TeuchosMatrix::fillWithTranspose(), QUESO::GslMatrix::fillWithTranspose(), QUESO::FiniteDistribution::FiniteDistribution(), QUESO::MpiComm::Gather(), QUESO::MpiComm::Gatherv(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::generateSequence(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MLSampling< P_V, P_M >::generateSequence_Level0_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step05_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0(), QUESO::Generic1DQuadrature::Generic1DQuadrature(), QUESO::GslMatrix::getColumn(), QUESO::TeuchosMatrix::getColumn(), QUESO::EnvironmentOptions::getMyOptionValues(), QUESO::GslMatrix::getRow(), QUESO::TeuchosMatrix::getRow(), QUESO::SampledScalarCdf< T >::getSupport(), QUESO::ScalarSequence< T >::getUnifiedContentsAtProc0Only(), QUESO::GslVector::GslVector(), QUESO::ArrayOfSequences< V, M >::histogram(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence(), QUESO::TeuchosMatrix::inverse(), QUESO::GslMatrix::inverse(), QUESO::TeuchosMatrix::invertMultiply(), QUESO::GslMatrix::invertMultiply(), QUESO::TeuchosMatrix::invertMultiplyForceLU(), QUESO::GslMatrix::invertMultiplyForceLU(), QUESO::MLSampling< P_V, P_M >::justBalance_proc0(), QUESO::LagrangePolynomial1D1DFunction::LagrangePolynomial1D1DFunction(), leftDiagScaling(), QUESO::GslVector::matlabDiff(), QUESO::TeuchosVector::matlabDiff(), QUESO::GslVector::matlabLinearInterpExtrap(), QUESO::TeuchosVector::matlabLinearInterpExtrap(), QUESO::TeuchosMatrix::matlabLinearInterpExtrap(), QUESO::GslMatrix::matlabLinearInterpExtrap(), QUESO::MetropolisHastingsSG< P_V, P_M >::MetropolisHastingsSG(), QUESO::MetropolisHastingsSGOptions::MetropolisHastingsSGOptions(), MiscCheckTheParallelEnvironment(), QUESO::ConcatenationSubset< V, M >::moments(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::MonteCarloSG(), QUESO::GslVector::mpiAllQuantile(), QUESO::TeuchosVector::mpiAllQuantile(), QUESO::GslVector::mpiAllReduce(), QUESO::TeuchosVector::mpiAllReduce(), QUESO::GslVector::mpiBcast(), QUESO::TeuchosVector::mpiBcast(), QUESO::MpiComm::MpiComm(), QUESO::MLSampling< P_V, P_M >::mpiExchangePositions_inter0(), QUESO::TeuchosMatrix::mpiSum(), QUESO::TeuchosMatrix::multiply(), QUESO::GslMatrix::multiply(), operator*(), QUESO::GslVector::operator*=(), QUESO::TeuchosVector::operator*=(), QUESO::TeuchosVector::operator+=(), QUESO::TeuchosVector::operator-=(), QUESO::GslVector::operator/=(), QUESO::TeuchosVector::operator/=(), QUESO::GslVector::operator=(), QUESO::TeuchosVector::operator=(), operator==(), QUESO::PiecewiseLinear1D1DFunction::PiecewiseLinear1D1DFunction(), QUESO::MLSampling< P_V, P_M >::prepareBalLinkedChains_inter0(), QUESO::MLSampling< P_V, P_M >::prepareUnbLinkedChains_inter0(), QUESO::AsciiTable< V, M >::readColumnsFromFile(), QUESO::MpiComm::Recv(), QUESO::MLSampling< P_V, P_M >::restartML(), rightDiagScaling(), QUESO::ScalarGaussianRandomField< V, M >::sampleFunction(), QUESO::VectorGaussianRandomField< P_V, P_M, Q_V, Q_M >::sampleFunction(), scalarProduct(), QUESO::MpiComm::Send(), SequenceStatisticalOptions::SequenceStatisticalOptions(), QUESO::TeuchosMatrix::setColumn(), QUESO::GslMatrix::setColumn(), QUESO::SequenceOfVectors< V, M >::setPositionValues(), QUESO::HessianCovMatricesTKGroup< V, M >::setPreComputingPosition(), QUESO::TeuchosMatrix::setRow(), QUESO::GslMatrix::setRow(), QUESO::ScaledCovMatrixTKGroup< V, M >::setRVsWithZeroMean(), QUESO::TransformedScaledCovMatrixTKGroup< V, M >::setRVsWithZeroMean(), QUESO::GslVector::sizeGlobal(), QUESO::TeuchosVector::sizeGlobal(), QUESO::GslVector::sizeLocal(), QUESO::TeuchosVector::sizeLocal(), QUESO::MLSampling< P_V, P_M >::solveBIP_proc0(), QUESO::StatisticalInverseProblem< P_V, P_M >::solveWithBayesMetropolisHastings(), QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::StatisticalForwardProblem(), QUESO::StatisticalInverseProblem< P_V, P_M >::StatisticalInverseProblem(), QUESO::StatisticalInverseProblemOptions::StatisticalInverseProblemOptions(), SubF1F2Gaussian2dKdeIntegral(), QUESO::ScalarSequence< T >::subHistogram(), QUESO::ScalarSequence< T >::subInterQuantileRange(), QUESO::BaseVectorSequence< V, M >::subPositionsOfMaximum(), QUESO::ScalarSequence< T >::subPositionsOfMaximum(), QUESO::GslVector::subReadContents(), QUESO::TeuchosVector::subReadContents(), QUESO::TeuchosMatrix::subReadContents(), QUESO::GslMatrix::subReadContents(), QUESO::TeuchosMatrix::svd(), QUESO::GslMatrix::svd(), QUESO::TeuchosMatrix::svdSolve(), QUESO::GslMatrix::svdSolve(), QUESO::TensorProductQuadrature< V, M >::TensorProductQuadrature(), QUESO::TeuchosVector::TeuchosVector(), QUESO::TeuchosMatrix::transpose(), QUESO::ScalarSequence< T >::unifiedHistogram(), QUESO::ScalarSequence< T >::unifiedInterQuantileRange(), QUESO::BaseVectorSequence< V, M >::unifiedPositionsOfMaximum(), QUESO::ScalarSequence< T >::unifiedPositionsOfMaximum(), QUESO::SequenceOfVectors< V, M >::unifiedReadContents(), QUESO::ScalarSequence< T >::unifiedReadContents(), QUESO::ScalarSequence< T >::unifiedSort(), QUESO::VectorSpace< V, M >::VectorSpace(), QUESO::TeuchosMatrix::zeroLower(), QUESO::GslMatrix::zeroLower(), QUESO::TeuchosMatrix::zeroUpper(), and QUESO::GslMatrix::zeroUpper().

StatisticalForwardProblemOptions::StatisticalForwardProblemOptions ( const BaseEnvironment& env, const char* prefix QUESO::queso_require_not_equal_to_msg)(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the absence of an options input file"))

Definition at line 417 of file MonteCarloSGOptions.C.

Referenced by QUESO::MLSamplingOptions::checkOptions(), QUESO::TeuchosMatrix::eigen(), QUESO::GslMatrix::eigen(), QUESO::EnvironmentOptions::EnvironmentOptions(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), QUESO::Generic1DQuadrature::Generic1DQuadrature(), QUESO::SampledScalarCdf< T >::getSupport(), QUESO::InfiniteDimensionalMCMCSamplerOptions::InfiniteDimensionalMCMCSamplerOptions(), QUESO::TeuchosMatrix::invertMultiply(), QUESO::TeuchosMatrix::invertMultiplyForceLU(), QUESO::TeuchosMatrix::largestEigen(), QUESO::GslMatrix::largestEigen(), QUESO::MetropolisHastingsSGOptions::MetropolisHastingsSGOptions(), MiscReadDoublesFromString(), MiscReadWordsFromString(), QUESO::PiecewiseLinear1D1DFunction::PiecewiseLinear1D1DFunction(), QUESO::ScaledCovMatrixTKGroup< V, M >::rv(), QUESO::TransformedScaledCovMatrixTKGroup< V, M >::rv(), QUESO::BaseEnvironment::scanInputFileForMyOptions(), SequenceStatisticalOptions::SequenceStatisticalOptions(), QUESO::ScaledCovMatrixTKGroup< V, M >::setRVsWithZeroMean(), QUESO::TransformedScaledCovMatrixTKGroup< V, M >::setRVsWithZeroMean(), QUESO::TeuchosMatrix::smallestEigen(), QUESO::GslMatrix::smallestEigen(), QUESO::StatisticalInverseProblemOptions::StatisticalInverseProblemOptions(), QUESO::ScalarSequence< T >::unifiedReadContents(), and QUESO::Sampled1D1DFunction::value().

unsigned int QUESO::size = env->input().vector_variable_size(m_option_dataOutputAllowedSet)

Definition at line 122 of file StatisticalForwardProblemOptions.C.

Referenced by QUESO::TeuchosVector::abs(), QUESO::GslVector::abs(), QUESO::TeuchosVector::atLeastOneComponentBiggerOrEqualThan(), QUESO::GslVector::atLeastOneComponentBiggerOrEqualThan(), QUESO::TeuchosVector::atLeastOneComponentBiggerThan(), QUESO::GslVector::atLeastOneComponentBiggerThan(), QUESO::TeuchosVector::atLeastOneComponentSmallerOrEqualThan(), QUESO::GslVector::atLeastOneComponentSmallerOrEqualThan(), QUESO::TeuchosVector::atLeastOneComponentSmallerThan(), QUESO::GslVector::atLeastOneComponentSmallerThan(), QUESO::BaseScalarFunction< V, M >::BaseScalarFunction(), QUESO::MLSamplingLevelOptions::checkOptions(), QUESO::ConcatenatedJointPdf< V, M >::ConcatenatedJointPdf(), QUESO::TeuchosVector::copy_to_std_vector(), QUESO::GslVector::cwInvert(), QUESO::TeuchosVector::cwInvert(), QUESO::GslVector::cwSet(), QUESO::GslVector::cwSqrt(), QUESO::TeuchosVector::cwSqrt(), QUESO::EnvOptionsValues::EnvOptionsValues(), QUESO::GPMSAFactory< V, M >::experimentOutput(), QUESO::GPMSAFactory< V, M >::experimentScenario(), QUESO::MLSamplingLevelOptions::getAllOptions(), QUESO::TeuchosVector::getMaxValue(), QUESO::TeuchosVector::getMaxValueAndIndex(), QUESO::TeuchosVector::getMaxValueIndex(), QUESO::TeuchosVector::getMinValue(), QUESO::TeuchosVector::getMinValueAndIndex(), QUESO::TeuchosVector::getMinValueIndex(), QUESO::MLSampling< P_V, P_M >::justBalance_proc0(), lookUp(), QUESO::GslVector::matlabDiff(), QUESO::TeuchosVector::matlabDiff(), QUESO::GslOptimizer::minimize_no_gradient(), QUESO::MLSamplingOptions::MLSamplingOptions(), QUESO::GslVector::mpiAllQuantile(), QUESO::TeuchosVector::mpiAllQuantile(), QUESO::GslVector::mpiAllReduce(), QUESO::TeuchosVector::mpiAllReduce(), QUESO::TeuchosMatrix::mpiSum(), QUESO::GslMatrix::mpiSum(), QUESO::GslVector::norm1(), QUESO::TeuchosVector::norm1(), QUESO::GslVector::normInf(), QUESO::TeuchosVector::normInf(), QUESO::OptimizerMonitor::print(), QUESO::BaseOneDGrid< T >::print(), QUESO::GslVector::print(), QUESO::TeuchosVector::print(), QUESO::OptimizerMonitor::print_header(), QUESO::BaseScalarFunction< V, M >::setFiniteDifferenceStepSize(), QUESO::SipOptionsValues::SipOptionsValues(), QUESO::GslVector::sumOfComponents(), and QUESO::TeuchosVector::sumOfComponents().

const int QUESO::UQ_FAILED_READING_FILE_RC = -9

Definition at line 101 of file Defines.h.

Referenced by MiscReadCharsAndDoubleFromFile(), and MiscReadStringAndDoubleFromFile().

const int QUESO::UQ_FAILED_TO_OPEN_FILE_RC = -7

Definition at line 99 of file Defines.h.

const int QUESO::UQ_INCOMPLETE_IMPLEMENTATION_RC = -1

Definition at line 93 of file Defines.h.

Referenced by QUESO::MetropolisHastingsSG< P_V, P_M >::adapt().

const int QUESO::UQ_INVALID_INTERNAL_RESULT_RC = -5

Definition at line 97 of file Defines.h.

const int QUESO::UQ_INVALID_INTERNAL_STATE_RC = -6

Definition at line 98 of file Defines.h.

const int QUESO::UQ_INVALID_OBSERVABLE_SPEC_RC = -3

Definition at line 95 of file Defines.h.

const int QUESO::UQ_INVALID_PARAMETER_SPEC_RC = -2

Definition at line 94 of file Defines.h.

const int QUESO::UQ_INVALID_QOI_SPEC_RC = -4

Definition at line 96 of file Defines.h.

const int QUESO::UQ_INVALID_SPACE_COMPONENT_ID_RC = -10

Definition at line 102 of file Defines.h.

const int QUESO::UQ_MATRIX_IS_NOT_POS_DEFINITE_RC = -8

Definition at line 100 of file Defines.h.

Referenced by QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::TeuchosMatrix::chol(), and QUESO::GslMatrix::chol().

const int QUESO::UQ_MATRIX_SVD_FAILED_RC = -11

Definition at line 103 of file Defines.h.

Referenced by QUESO::GslMatrix::internalSvd().

const int QUESO::UQ_OK_RC = 0

Definition at line 92 of file Defines.h.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::BaseVectorSequence< V, M >::computeAutoCorrViaDef(), QUESO::BaseVectorSequence< V, M >::computeAutoCorrViaFFT(), QUESO::BaseVectorSequence< V, M >::computeBMM(), QUESO::BaseVectorSequence< V, M >::computeFFT(), QUESO::BaseVectorSequence< V, M >::computeGeweke(), QUESO::BaseVectorSequence< V, M >::computeHistCdfstaccKde(), QUESO::BaseVectorSequence< V, M >::computeMeanEvolution(), QUESO::BaseVectorSequence< V, M >::computeMeanStacc(), QUESO::BaseVectorSequence< V, M >::computeMeanVars(), QUESO::BaseVectorSequence< V, M >::computePSD(), QUESO::BaseVectorSequence< V, M >::computePSDAtZero(), QUESO::BaseVectorSequence< V, M >::computeStatistics(), QUESO::MetropolisHastingsSG< P_V, P_M >::delayedRejection(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), QUESO::MLSampling< P_V, P_M >::generateSequence_Level0_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step01_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step03_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step04_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step05_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step06_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step07_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step08_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step10_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0(), QUESO::MLSampling< P_V, P_M >::justBalance_proc0(), MiscReadCharsAndDoubleFromFile(), MiscReadStringAndDoubleFromFile(), QUESO::MLSampling< P_V, P_M >::solveBIP_proc0(), QUESO::SequenceOfVectors< V, M >::unifiedReadContents(), QUESO::ScalarSequence< T >::unifiedReadContents(), QUESO::SequenceOfVectors< V, M >::unifiedWriteContents(), QUESO::ScalarSequence< T >::unifiedWriteContents(), and QUESO::MetropolisHastingsSG< P_V, P_M >::writeInfo().

const int QUESO::UQ_UNAVAILABLE_RANK = -1

Definition at line 90 of file Defines.h.