inline size_t RStarTreeDescentHeuristic::ChooseDescentNode(
const TreeType* node,
const TreeType* insertedNode)
{
// Convenience typedef.
typedef typename TreeType::ElemType ElemType;
std::vector<ElemType> scores(node->NumChildren());
std::vector<ElemType> vols(node->NumChildren());
ElemType minScore = std::numeric_limits<ElemType>::max();
size_t bestIndex = 0;
bool tied = false;
for (size_t i = 0; i < node->NumChildren(); i++)
{
ElemType v1 = 1.0;
ElemType v2 = 1.0;
for (size_t j = 0; j < node->Children()[i]->Bound().Dim(); j++)
{
v1 *= node->Children()[i]->Bound()[j].Width();
v2 *= node->Children()[i]->Bound()[j].Contains(insertedNode->Bound()[j]) ? node->Children()[i]->Bound()[j].Width() :
(insertedNode->Bound()[j].Contains(node->Children()[i]->Bound()[j]) ? insertedNode->Bound()[j].Width() : (insertedNode->Bound()[j].Lo() < node->Children()[i]->Bound()[j].Lo() ? (node->Children()[i]->Bound()[j].Hi() - insertedNode->Bound()[j].Lo()) : (insertedNode->Bound()[j].Hi() - node->Children()[i]->Bound()[j].Lo())));
}
assert(v2 - v1 >= 0);
vols[i] = v1;
scores[i] = v2 - v1;
if (v2 - v1 < minScore)
{
minScore = v2 - v1;
bestIndex = i;
}
else if (v2 - v1 == minScore)
{
tied = true;
}
}
if (tied)
{
// We break ties by choosing the smallest bound.
ElemType minVol = std::numeric_limits<ElemType>::max();
bestIndex = 0;
for (size_t i = 0; i < scores.size(); i++)
{
if (scores[i] == minScore)
{
if (vols[i] < minVol)
{
minVol = vols[i];
bestIndex = i;
}
}
}
}
return bestIndex;
}
void compute( const FUNC& f, const X & ranges, const o_t & o)
{
init(o);
itab_t facts = ranges(nt2::_,begin_+1, nt2::_)-ranges(nt2::_,begin_, nt2::_);
itab_t vols = nt2::prod(facts);
input_t total_vol = globalasum1(vols);
itab_t coefs = real_t(maxfunccnt_)*nt2::abs(vols)*nt2::rec(total_vol);
BOOST_ASSERT_MSG(size(ranges, 2) == 2, "ranges must be a nx2xm expression");
size_t l = size(ranges, 3);
res_ = nt2::Zero<value_t>();
for(size_t i=1; i <= l; ++i)
{
nbpts_ = coefs(i);
res_ += compute(f, ranges(nt2::_,nt2::_,i), vols(i), facts(i));
fcnt_+= nbpts_;
}
}
std::vector<Volatility> SabrVolSurface::volatilitySpreads(const Date& d) const {
Size nOptionsTimes = optionTimes_.size();
Size nAtmRateSpreads = atmRateSpreads_.size();
std::vector<Volatility> interpolatedVols(nAtmRateSpreads);
std::vector<Volatility> vols(nOptionsTimes); // the volspread at a given strike
for (Size i=0; i<nAtmRateSpreads; ++i) {
for (Size j=0; j<nOptionsTimes; ++j) {
vols[j] = (**volSpreads_[j][i]).value();
}
LinearInterpolation interpolator(optionTimes_.begin(), optionTimes_.end(),
vols.begin());
interpolatedVols[i] = interpolator(timeFromReference(d),true);
}
return interpolatedVols;
}
typename PFP::REAL totalVolume(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3, typename PFP::MAP>& position)
{
// allocate a vector of 1 accumulator for each thread
std::vector<typename PFP::REAL> vols(CGoGN::Parallel::NumberOfThreads-1, 0.0);
// foreach volume
CGoGN::Parallel::foreach_cell<VOLUME>(map, [&] (Vol v, unsigned int thr)
{
// add volume to the thread accumulator
vols[thr-1] += convexPolyhedronVolume<PFP>(map, v, position) ;
});
// compute the sum of volumes
typename PFP::REAL total(0);
for (int i=0; i< CGoGN::Parallel::NumberOfThreads-1; ++i )
total += vols[i];
return total;
}
void testVolSort()
{
vector< unsigned int > findVolOrder( const vector< double >& vols );
vector< double > vols( 8 );
vols[0] = 7;
vols[1] = 8;
vols[2] = 6;
vols[3] = 5;
vols[4] = 1;
vols[5] = 2;
vols[6] = 3;
vols[7] = 4;
vector< unsigned int > order = findVolOrder( vols );
// The order is the rank of the volume entry, largest should be 0.
assert( order[0] == 1 );
assert( order[1] == 0 );
assert( order[2] == 2 );
assert( order[3] == 3 );
assert( order[4] == 7 );
assert( order[5] == 6 );
assert( order[6] == 5 );
assert( order[7] == 4 );
// This is a sequence which failed in a model test, despite the
// above test working.
vols.resize(5);
vols[0] = 1e-15;
vols[1] = 3e-15;
vols[2] = -1;
vols[3] = 2e-15;
vols[4] = 5e-15;
order = findVolOrder( vols );
assert( order[0] == 4 );
assert( order[1] == 1 );
assert( order[2] == 3 );
assert( order[3] == 0 );
assert( order[4] == 2 );
}
inline size_t RStarTreeDescentHeuristic::ChooseDescentNode(
const TreeType* node,
const arma::vec& point)
{
// Convenience typedef.
typedef typename TreeType::ElemType ElemType;
bool tiedOne = false;
std::vector<ElemType> originalScores(node->NumChildren());
ElemType origMinScore = std::numeric_limits<ElemType>::max();
if (node->Children()[0]->IsLeaf())
{
// If its children are leaf nodes, use minimum overlap to choose.
size_t bestIndex = 0;
for (size_t i = 0; i < node->NumChildren(); i++)
{
ElemType sc = 0;
for (size_t j = 0; j < node->NumChildren(); j++)
{
if (j != i)
{
ElemType overlap = 1.0;
ElemType newOverlap = 1.0;
for (size_t k = 0; k < node->Bound().Dim(); k++)
{
ElemType newHigh = std::max(point[k],
node->Children()[i]->Bound()[k].Hi());
ElemType newLow = std::min(point[k],
node->Children()[i]->Bound()[k].Lo());
overlap *= node->Children()[i]->Bound()[k].Hi() < node->Children()[j]->Bound()[k].Lo() || node->Children()[i]->Bound()[k].Lo() > node->Children()[j]->Bound()[k].Hi() ? 0 : std::min(node->Children()[i]->Bound()[k].Hi(), node->Children()[j]->Bound()[k].Hi()) - std::max(node->Children()[i]->Bound()[k].Lo(), node->Children()[j]->Bound()[k].Lo());
newOverlap *= newHigh < node->Children()[j]->Bound()[k].Lo() || newLow > node->Children()[j]->Bound()[k].Hi() ? 0 : std::min(newHigh, node->Children()[j]->Bound()[k].Hi()) - std::max(newLow, node->Children()[j]->Bound()[k].Lo());
}
sc += newOverlap - overlap;
}
}
originalScores[i] = sc;
if (sc < origMinScore)
{
origMinScore = sc;
bestIndex = i;
}
else if (sc == origMinScore)
{
tiedOne = true;
}
}
if (!tiedOne)
return bestIndex;
}
// We do this if it is not on the second level or if there was a tie.
std::vector<ElemType> scores(node->NumChildren());
if (tiedOne)
{
// If the first heuristic was tied, we need to eliminate garbage values.
for (size_t i = 0; i < scores.size(); i++)
scores[i] = std::numeric_limits<ElemType>::max();
}
std::vector<ElemType> vols(node->NumChildren());
ElemType minScore = std::numeric_limits<ElemType>::max();
size_t bestIndex = 0;
bool tied = false;
for (size_t i = 0; i < node->NumChildren(); i++)
{
if (!tiedOne || originalScores[i] == origMinScore)
{
ElemType v1 = 1.0;
ElemType v2 = 1.0;
for (size_t j = 0; j < node->Bound().Dim(); j++)
{
v1 *= node->Children()[i]->Bound()[j].Width();
v2 *= node->Children()[i]->Bound()[j].Contains(point[j]) ? node->Children()[i]->Bound()[j].Width() : (node->Children()[i]->Bound()[j].Hi() < point[j] ? (point[j] - node->Children()[i]->Bound()[j].Lo()) :
(node->Children()[i]->Bound()[j].Hi() - point[j]));
}
assert(v2 - v1 >= 0);
vols[i] = v1;
scores[i] = v2 - v1;
if (v2 - v1 < minScore)
{
minScore = v2 - v1;
bestIndex = i;
}
else if (v2 - v1 == minScore)
{
tied = true;
}
}
}
if (tied)
{
// We break ties by choosing the smallest bound.
ElemType minVol = std::numeric_limits<ElemType>::max();
bestIndex = 0;
for (size_t i = 0; i < scores.size(); i++)
{
if (scores[i] == minScore)
{
if (vols[i] < minVol)
{
minVol = vols[i];
bestIndex = i;
}
}
}
}
return bestIndex;
}
