int main(int argc, char ** argv) {
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL);
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"space_", 3, NULL);
QUESO::GslVector minBound(paramSpace.zeroVector());
minBound[0] = -10.0;
minBound[1] = -10.0;
minBound[2] = -10.0;
QUESO::GslVector maxBound(paramSpace.zeroVector());
maxBound[0] = 10.0;
maxBound[1] = 10.0;
maxBound[2] = 10.0;
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> domain("", paramSpace,
minBound, maxBound);
ObjectiveFunction<QUESO::GslVector, QUESO::GslMatrix> objectiveFunction(
"", domain);
QUESO::GslVector initialPoint(paramSpace.zeroVector());
initialPoint[0] = 9.0;
initialPoint[1] = -9.0;
initialPoint[1] = -1.0;
QUESO::GslOptimizer optimizer(objectiveFunction);
double tol = 1.0e-10;
optimizer.setTolerance(tol);
optimizer.set_solver_type(QUESO::GslOptimizer::STEEPEST_DESCENT);
QUESO::OptimizerMonitor monitor(env);
monitor.set_display_output(true,true);
std::cout << "Solving with Steepest Decent" << std::endl;
optimizer.minimize(&monitor);
if (std::abs( optimizer.minimizer()[0] - 1.0) > tol) {
std::cerr << "GslOptimize failed. Found minimizer at: " << optimizer.minimizer()[0]
<< std::endl;
std::cerr << "Actual minimizer is 1.0" << std::endl;
queso_error();
}
std::string nm = "nelder_mead2";
optimizer.set_solver_type(nm);
monitor.reset();
monitor.set_display_output(true,true);
std::cout << std::endl << "Solving with Nelder Mead" << std::endl;
optimizer.minimize(&monitor);
monitor.print(std::cout,false);
return 0;
}
int main(int argc, char ** argv) {
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL);
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"space_", 1, NULL);
QUESO::GslVector minBound(paramSpace.zeroVector());
minBound[0] = -10.0;
QUESO::GslVector maxBound(paramSpace.zeroVector());
maxBound[0] = 10.0;
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> domain("", paramSpace,
minBound, maxBound);
QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> prior("", domain);
Likelihood<QUESO::GslVector, QUESO::GslMatrix> likelihood("", domain);
QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> posterior("",
domain);
QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("",
NULL, prior, likelihood, posterior);
QUESO::GslVector initialValues(paramSpace.zeroVector());
initialValues[0] = 9.0;
QUESO::GslMatrix proposalCovarianceMatrix(paramSpace.zeroVector());
proposalCovarianceMatrix(0, 0) = 1.0;
ip.seedWithMAPEstimator();
ip.solveWithBayesMetropolisHastings(NULL, initialValues,
&proposalCovarianceMatrix);
// The first sample should be the seed
QUESO::GslVector first_sample(paramSpace.zeroVector());
posterior.realizer().realization(first_sample);
// Looser tolerance for the derivative calculated by using a finite
// difference
if (std::abs(first_sample[0]) > 1e-5) {
std::cerr << "seedWithMAPEstimator failed. Seed was: " << first_sample[0]
<< std::endl;
std::cerr << "Actual seed should be 0.0" << std::endl;
queso_error();
}
return 0;
}
bool Projectile::CheckDespawn()
{
if (sprite.get())
{
Vector2 minBound(x - sprite.get()->GetWidth() * 0.5f, y - sprite.get()->GetHeight() * 0.5f);
Vector2 maxBound(x + sprite.get()->GetWidth() * 0.5f, y + sprite.get()->GetHeight() * 0.5f);
if (maxBound.x < 0.f ||
minBound.x > Application::S_SCREEN_WIDTH ||
maxBound.y < 0.f ||
minBound.y > Application::S_SCREEN_HEIGHT)
{
return true;
}
return false;
}
}
inline
CollisionBox<ScalarT, dimN>::CollisionBox(
const typename CollisionBox<ScalarT, dimN>::Box& sBoundaries,
typename CollisionBox<ScalarT, dimN>::Scalar sParticleRadius,
typename CollisionBox<ScalarT, dimN>::Scalar sSphereRadius)
:boundaries(sBoundaries),
numNeighbors(0),neighborOffsets(0),cellChangeMasks(0),
particleRadius(sParticleRadius),particleRadius2(Math::sqr(particleRadius)),
attenuation(1),
numParticles(0),
spherePosition(Point::origin),
sphereVelocity(Vector::zero),
sphereRadius(sSphereRadius),sphereRadius2(Math::sqr(sphereRadius)),
sphereTimeStamp(0),
latentForce(0),
boxFriction(0),
intraParticleGravitation(false)
{
/* Calculate optimal number of cells and cell sizes: */
Index numOuterCells;
for (int i=0;i<dimension;++i)
{
numCells[i]=int(Math::floor(boundaries.getSize(i)/(particleRadius*Scalar(2))));
cellSize[i]=boundaries.getSize(i)/Scalar(numCells[i]);
numOuterCells[i]=numCells[i]+2; // Create a layer of "ghost cells" in all directions
}
/* Create the cell array: */
cells.resize(numOuterCells);
for (Index index(0);index[0]<numOuterCells[0];cells.preInc(index))
{
/* Initialize the cell: */
Point min,max;
for (int i=0;i<dimension;++i)
{
min[i]=boundaries.min[i]+cellSize[i]*Scalar(index[i]-1);
max[i]=boundaries.min[i]+cellSize[i]*Scalar(index[i]-0);
}
cells(index).boundaries=Box(min,max);
cells(index).particlesHead=0;
cells(index).particlesTail=0;
}
/* Initialize the direct neighbor offsets: */
for (int i=0;i<dimension;++i)
{
directNeighborOffsets[2*i+0]=-cells.getIncrement(i);
directNeighborOffsets[2*i+1]=cells.getIncrement(i);
}
/* Initialize the neighbor array: */
numNeighbors=1;
for (int i=0;i<dimension;++i)
numNeighbors*=3;
neighborOffsets=new ssize_t[numNeighbors];
cellChangeMasks=new int[numNeighbors];
Index minBound(-1);
Index maxBound(2);
int neighborIndex=0;
for (Index index=minBound;index[0]<maxBound[0];index.preInc(minBound,maxBound),++neighborIndex)
{
neighborOffsets[neighborIndex]=0;
cellChangeMasks[neighborIndex]=0x0;
for (int i=0;i<dimension;++i)
{
neighborOffsets[neighborIndex]+=cells.getIncrement(i)*index[i];
if (index[i]==-1)
cellChangeMasks[neighborIndex]|=1<<(2*i+0);
else if (index[i]==1)
cellChangeMasks[neighborIndex]|=1<<(2*i+1);
}
}
/* Position the spherical obstacle: */
spherePosition[0]=boundaries.min[0]-sphereRadius-Scalar(10);
for (int i=1;i<dimension;++i)
spherePosition[i]=Math::div2(boundaries.min[i]+boundaries.max[i]);
sphereVelocity[0]=Scalar(5);
}
/*!
* Calculate the x,y,z range between bounds (i.e. for a hull, length, beam and depth)
*/
odPoint odMesh::range(){
return maxBound()-minBound();
}
