//
// Limit check a MAX int limit
//
bool AclData::compareIntMax(const qpid::acl::SpecProperty theProperty,
const std::string theAclValue,
const std::string theLookupValue)
{
uint64_t aclMax (0);
uint64_t paramMax (0);
try
{
aclMax = boost::lexical_cast<uint64_t>(theAclValue);
}
catch(const boost::bad_lexical_cast&)
{
assert (false);
return false;
}
try
{
paramMax = boost::lexical_cast<uint64_t>(theLookupValue);
}
catch(const boost::bad_lexical_cast&)
{
QPID_LOG(error,"ACL: Error evaluating rule. "
<< "Illegal value given in lookup for property '"
<< AclHelper::getPropertyStr(theProperty)
<< "' : " << theLookupValue);
return false;
}
QPID_LOG(debug, "ACL: Numeric greater-than comparison for property "
<< AclHelper::getPropertyStr(theProperty)
<< " (value given in lookup = " << theLookupValue
<< ", value give in rule = " << theAclValue << " )");
if (( aclMax ) && ( paramMax == 0 || paramMax > aclMax))
{
QPID_LOG(debug, "ACL: Max limit exceeded for property '"
<< AclHelper::getPropertyStr(theProperty) << "'");
return false;
}
return true;
}
void GaussianMean1DRegressionCompute(const QUESO::BaseEnvironment& env,
double priorMean, double priorVar, const likelihoodData& dat)
{
// parameter space: 1-D on (-infinity, infinity)
QUESO::VectorSpace<P_V, P_M> paramSpace(
env, // queso environment
"param_", // name prefix
1, // dimensions
NULL); // names
P_V paramMin(paramSpace.zeroVector());
P_V paramMax(paramSpace.zeroVector());
paramMin[0] = -INFINITY;
paramMax[0] = INFINITY;
QUESO::BoxSubset<P_V, P_M> paramDomain(
"paramBox_", // name prefix
paramSpace, // vector space
paramMin, // min values
paramMax); // max values
// gaussian prior with user supplied mean and variance
P_V priorMeanVec(paramSpace.zeroVector());
P_V priorVarVec(paramSpace.zeroVector());
priorMeanVec[0] = priorMean;
priorVarVec[0] = priorVar;
QUESO::GaussianVectorRV<P_V, P_M> priorRv("prior_", paramDomain, priorMeanVec,
priorVarVec);
// likelihood is important
QUESO::GenericScalarFunction<P_V, P_M> likelihoodFunctionObj(
"like_", // name prefix
paramDomain, // image set
LikelihoodFunc<P_V, P_M>, // routine
(void *) &dat, // routine data ptr
true); // routineIsForLn
QUESO::GenericVectorRV<P_V, P_M> postRv(
"post_", // name prefix
paramSpace); // image set
// Initialize and solve the Inverse Problem with Bayes multi-level sampling
QUESO::StatisticalInverseProblem<P_V, P_M> invProb(
"", // name prefix
NULL, // alt options
priorRv, // prior RV
likelihoodFunctionObj, // likelihood fcn
postRv); // posterior RV
invProb.solveWithBayesMLSampling();
// compute mean and second moment of samples on each proc via Knuth online mean/variance algorithm
int N = invProb.postRv().realizer().subPeriod();
double subMean = 0.0;
double subM2 = 0.0;
double delta;
P_V sample(paramSpace.zeroVector());
for (int n = 1; n <= N; n++) {
invProb.postRv().realizer().realization(sample);
delta = sample[0] - subMean;
subMean += delta / n;
subM2 += delta * (sample[0] - subMean);
}
// gather all Ns, means, and M2s to proc 0
std::vector<int> unifiedNs(env.inter0Comm().NumProc());
std::vector<double> unifiedMeans(env.inter0Comm().NumProc());
std::vector<double> unifiedM2s(env.inter0Comm().NumProc());
MPI_Gather(&N, 1, MPI_INT, &(unifiedNs[0]), 1, MPI_INT, 0,
env.inter0Comm().Comm());
MPI_Gather(&subMean, 1, MPI_DOUBLE, &(unifiedMeans[0]), 1, MPI_DOUBLE, 0,
env.inter0Comm().Comm());
MPI_Gather(&subM2, 1, MPI_DOUBLE, &(unifiedM2s[0]), 1, MPI_DOUBLE, 0,
env.inter0Comm().Comm());
// get the total number of likelihood calls at proc 0
unsigned long totalLikelihoodCalls = 0;
MPI_Reduce(&likelihoodCalls, &totalLikelihoodCalls, 1, MPI_UNSIGNED_LONG,
MPI_SUM, 0, env.inter0Comm().Comm());
// compute global posterior mean and std via Chan algorithm, output results on proc 0
if (env.inter0Rank() == 0) {
int postN = unifiedNs[0];
double postMean = unifiedMeans[0];
double postVar = unifiedM2s[0];
for (unsigned int i = 1; i < unifiedNs.size(); i++) {
delta = unifiedMeans[i] - postMean;
postMean = (postN * postMean + unifiedNs[i] * unifiedMeans[i]) /
(postN + unifiedNs[i]);
postVar += unifiedM2s[i] + delta * delta *
(((double)postN * unifiedNs[i]) / (postN + unifiedNs[i]));
postN += unifiedNs[i];
}
postVar /= postN;
//compute exact answer - available in this case since the exact posterior is a gaussian
N = dat.dataSet.size();
double dataSum = 0.0;
for (int i = 0; i < N; i++)
dataSum += dat.dataSet[i];
double datMean = dataSum / N;
double postMeanExact = (N * priorVar / (N * priorVar + dat.samplingVar)) *
datMean + (dat.samplingVar / (N * priorVar + dat.samplingVar)) * priorMean;
double postVarExact = 1.0 / (N / dat.samplingVar + 1.0 / priorVar);
std::cout << "Number of posterior samples: " << postN << std::endl;
std::cout << "Estimated posterior mean: " << postMean << " +/- "
<< std::sqrt(postVar) << std::endl;
std::cout << "Likelihood function calls: " << totalLikelihoodCalls
<< std::endl;
std::cout << "\nExact posterior: Gaussian with mean " << postMeanExact
<< ", standard deviation " << std::sqrt(postVarExact) << std::endl;
}
}
