OverlappingRowMatrix<MatrixType>::OverlappingRowMatrix(const Teuchos::RCP<const Tpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >& Matrix_in,
int OverlapLevel_in) :
A_(Matrix_in),
OverlapLevel_(OverlapLevel_in),
UseSubComm_(false)
{
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::Array;
// Short form names
typedef typename Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> MapType;
typedef typename Tpetra::Import<LocalOrdinal,GlobalOrdinal,Node> ImportType;
typedef typename Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> CrsMatrixType;
typedef typename Tpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> RowMatrixType;
TEUCHOS_TEST_FOR_EXCEPTION(OverlapLevel_ <= 0, std::runtime_error, "Ifpack2::OverlappingRowMatrix: OverlapLevel must be > 0.");
TEUCHOS_TEST_FOR_EXCEPTION(A_->getComm()->getSize() == 1, std::runtime_error, "Ifpack2::OverlappingRowMatrix: Matrix must be parallel.");
RCP<const CrsMatrixType> ACRS = Teuchos::rcp_dynamic_cast<const CrsMatrixType,const RowMatrixType>(A_);
TEUCHOS_TEST_FOR_EXCEPTION(ACRS == Teuchos::null, std::runtime_error, "Ifpack2::OverlappingRowMatrix: Matrix must be Tpetra::CrsMatrix.");
NumMyRowsA_ = A_->getNodeNumRows();
GlobalOrdinal global_invalid = Teuchos::OrdinalTraits<global_size_t>::invalid();
// Temp arrays
Array<GlobalOrdinal> ExtElements;
RCP<MapType> TmpMap;
RCP<CrsMatrixType> TmpMatrix;
RCP<ImportType> TmpImporter;
RCP<const MapType> RowMap, ColMap;
// The big import loop
for (int overlap = 0 ; overlap < OverlapLevel_ ; ++overlap) {
// Get the current maps
if(overlap==0){
RowMap = A_->getRowMap();
ColMap = A_->getColMap();
}
else {
RowMap = TmpMatrix->getRowMap();
ColMap = TmpMatrix->getColMap();
}
size_t size = ColMap->getNodeNumElements() - RowMap->getNodeNumElements();
Array<GlobalOrdinal> mylist(size);
size_t count = 0;
// define the set of rows that are in ColMap but not in RowMap
for (LocalOrdinal i = 0 ; (size_t) i < ColMap->getNodeNumElements() ; ++i) {
GlobalOrdinal GID = ColMap->getGlobalElement(i);
if (A_->getRowMap()->getLocalElement(GID) == global_invalid) {
typename Array<GlobalOrdinal>::iterator pos
= std::find(ExtElements.begin(),ExtElements.end(),GID);
if (pos == ExtElements.end()) {
ExtElements.push_back(GID);
mylist[count] = GID;
++count;
}
}
}
// Allocate & import new matrices, maps, etc.
TmpMap = rcp(new MapType(global_invalid,mylist(0,count),Teuchos::OrdinalTraits<GlobalOrdinal>::zero(),A_->getComm(),A_->getNode()));
TmpMatrix = rcp(new CrsMatrixType(TmpMap,0));
TmpImporter = rcp(new ImportType(A_->getRowMap(),TmpMap));
TmpMatrix->doImport(*ACRS,*TmpImporter,Tpetra::INSERT);
TmpMatrix->fillComplete(A_->getDomainMap(),TmpMap);
}
// build the map containing all the nodes (original
// matrix + extended matrix)
Array<GlobalOrdinal> mylist(NumMyRowsA_ + ExtElements.size());
for (LocalOrdinal i = 0 ; (size_t)i < NumMyRowsA_ ; ++i)
mylist[i] = A_->getRowMap()->getGlobalElement(i);
for (LocalOrdinal i = 0 ; i < ExtElements.size() ; ++i)
mylist[i + NumMyRowsA_] = ExtElements[i];
RowMap_= rcp(new MapType(global_invalid,mylist(),Teuchos::OrdinalTraits<GlobalOrdinal>::zero(),A_->getComm(),A_->getNode()));
ColMap_= RowMap_;
// now build the map corresponding to all the external nodes
// (with respect to A().RowMatrixRowMap().
ExtMap_ = rcp(new MapType(global_invalid,ExtElements(),Teuchos::OrdinalTraits<GlobalOrdinal>::zero(),A_->getComm(),A_->getNode()));
ExtMatrix_ = rcp(new CrsMatrixType(ExtMap_,ColMap_,0));
ExtImporter_ = rcp(new ImportType(A_->getRowMap(),ExtMap_));
RCP<CrsMatrixType> ExtMatrixCRS = Teuchos::rcp_dynamic_cast<CrsMatrixType,RowMatrixType>(ExtMatrix_);
ExtMatrixCRS->doImport(*ACRS,*ExtImporter_,Tpetra::INSERT);
ExtMatrixCRS->fillComplete(A_->getDomainMap(),RowMap_);
Importer_ = rcp(new ImportType(A_->getRowMap(),RowMap_));
// fix indices for overlapping matrix
NumMyRowsB_ = ExtMatrix_->getNodeNumRows();
NumMyRows_ = NumMyRowsA_ + NumMyRowsB_;
NumMyCols_ = NumMyRows_;
NumMyDiagonals_ = A_->getNodeNumDiags() + ExtMatrix_->getNodeNumDiags();
NumMyNonzeros_ = A_->getNodeNumEntries() + ExtMatrix_->getNodeNumEntries();
// FIXME: Fix this later when Teuchos::Comm gets redone
Tpetra::global_size_t NumMyNonzeros_tmp = NumMyNonzeros_;
Teuchos::reduceAll<int,Tpetra::global_size_t>(*A_->getComm(),Teuchos::REDUCE_SUM,NumMyNonzeros_tmp,Teuchos::outArg(NumGlobalNonzeros_));
Tpetra::global_size_t NumMyRows_tmp = NumMyRows_;
Teuchos::reduceAll<int,Tpetra::global_size_t>(*A_->getComm(),Teuchos::REDUCE_SUM,NumMyRows_tmp,Teuchos::outArg(NumGlobalRows_));
MaxNumEntries_ = A_->getNodeMaxNumRowEntries();
if (MaxNumEntries_ < ExtMatrix_->getNodeMaxNumRowEntries())
MaxNumEntries_ = ExtMatrix_->getNodeMaxNumRowEntries();
// Resize temp arrays
Indices_.resize(MaxNumEntries_);
Values_.resize(MaxNumEntries_);
}
SynthesiserVoice* Synthesiser::findVoiceToSteal (SynthesiserSound* soundToPlay,
int /*midiChannel*/, int midiNoteNumber) const
{
// This voice-stealing algorithm applies the following heuristics:
// - Re-use the oldest notes first
// - Protect the lowest & topmost notes, even if sustained, but not if they've been released.
// apparently you are trying to render audio without having any voices...
jassert (! voices.isEmpty());
// These are the voices we want to protect (ie: only steal if unavoidable)
SynthesiserVoice* low = nullptr; // Lowest sounding note, might be sustained, but NOT in release phase
SynthesiserVoice* top = nullptr; // Highest sounding note, might be sustained, but NOT in release phase
// this is a list of voices we can steal, sorted by how long they've been running
Array<SynthesiserVoice*> usableVoices;
usableVoices.ensureStorageAllocated (voices.size());
for (auto* voice : voices)
{
if (voice->canPlaySound (soundToPlay))
{
jassert (voice->isVoiceActive()); // We wouldn't be here otherwise
usableVoices.add (voice);
// NB: Using a functor rather than a lambda here due to scare-stories about
// compilers generating code containing heap allocations..
struct Sorter
{
bool operator() (const SynthesiserVoice* a, const SynthesiserVoice* b) const noexcept { return a->wasStartedBefore (*b); }
};
std::sort (usableVoices.begin(), usableVoices.end(), Sorter());
if (! voice->isPlayingButReleased()) // Don't protect released notes
{
auto note = voice->getCurrentlyPlayingNote();
if (low == nullptr || note < low->getCurrentlyPlayingNote())
low = voice;
if (top == nullptr || note > top->getCurrentlyPlayingNote())
top = voice;
}
}
}
// Eliminate pathological cases (ie: only 1 note playing): we always give precedence to the lowest note(s)
if (top == low)
top = nullptr;
// The oldest note that's playing with the target pitch is ideal..
for (auto* voice : usableVoices)
if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
return voice;
// Oldest voice that has been released (no finger on it and not held by sustain pedal)
for (auto* voice : usableVoices)
if (voice != low && voice != top && voice->isPlayingButReleased())
return voice;
// Oldest voice that doesn't have a finger on it:
for (auto* voice : usableVoices)
if (voice != low && voice != top && ! voice->isKeyDown())
return voice;
// Oldest voice that isn't protected
for (auto* voice : usableVoices)
if (voice != low && voice != top)
return voice;
// We've only got "protected" voices now: lowest note takes priority
jassert (low != nullptr);
// Duophonic synth: give priority to the bass note:
if (top != nullptr)
return top;
return low;
}
inline double DotProduct(const Array& v1, const Array& v2) {
QL_REQUIRE(v1.size() == v2.size(),
"arrays with different sizes cannot be multiplied");
return std::inner_product(v1.begin(),v1.end(),v2.begin(),0.0);
}
//==============================================================================
void Ssao::initInternal(const ConfigSet& config)
{
m_enabled = config.get("pps.ssao.enabled");
if(!m_enabled)
{
return;
}
m_blurringIterationsCount =
config.get("pps.ssao.blurringIterationsCount");
//
// Init the widths/heights
//
const F32 quality = config.get("pps.ssao.renderingQuality");
m_width = quality * (F32)m_r->getWidth();
alignRoundUp(16, m_width);
m_height = quality * (F32)m_r->getHeight();
alignRoundUp(16, m_height);
//
// create FBOs
//
createFb(m_hblurFb, m_hblurRt);
createFb(m_vblurFb, m_vblurRt);
//
// noise texture
//
GlCommandBufferHandle cmdb;
cmdb.create(&getGlDevice());
GlClientBufferHandle noise;
noise.create(
cmdb, sizeof(Vec3) * NOISE_TEX_SIZE * NOISE_TEX_SIZE, nullptr);
genNoise((Vec3*)noise.getBaseAddress(),
(Vec3*)((U8*)noise.getBaseAddress() + noise.getSize()));
GlTextureHandle::Initializer tinit;
tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
tinit.m_target = GL_TEXTURE_2D;
tinit.m_internalFormat = GL_RGB32F;
tinit.m_format = GL_RGB;
tinit.m_type = GL_FLOAT;
tinit.m_filterType = GlTextureHandle::Filter::NEAREST;
tinit.m_repeat = true;
tinit.m_mipmapsCount = 1;
tinit.m_data[0][0] = noise;
m_noiseTex.create(cmdb, tinit);
//
// Kernel
//
String kernelStr(getAllocator());
Array<Vec3, KERNEL_SIZE> kernel;
genKernel(kernel.begin(), kernel.end());
kernelStr = "vec3[](";
for(U i = 0; i < kernel.size(); i++)
{
String tmp(getAllocator());
tmp.sprintf("vec3(%f, %f, %f) %s",
kernel[i].x(), kernel[i].y(), kernel[i].z(),
(i != kernel.size() - 1) ? ", " : ")");
kernelStr += tmp;
}
//
// Shaders
//
m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER,
sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
String pps(getAllocator());
// main pass prog
pps.sprintf(
"#define NOISE_MAP_SIZE %u\n"
"#define WIDTH %u\n"
"#define HEIGHT %u\n"
"#define KERNEL_SIZE %u\n"
"#define KERNEL_ARRAY %s\n",
NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]);
m_ssaoFrag.loadToCache(&getResourceManager(),
"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_");
m_ssaoPpline = m_r->createDrawQuadProgramPipeline(
m_ssaoFrag->getGlProgram());
// blurring progs
const char* SHADER_FILENAME =
"shaders/VariableSamplingBlurGeneric.frag.glsl";
pps.sprintf(
"#define HPASS\n"
"#define COL_R\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES 7\n",
m_height);
m_hblurFrag.loadToCache(&getResourceManager(),
SHADER_FILENAME, pps.toCString(), "r_");
m_hblurPpline = m_r->createDrawQuadProgramPipeline(
m_hblurFrag->getGlProgram());
pps.sprintf(
"#define VPASS\n"
"#define COL_R\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES 7\n",
m_width);
m_vblurFrag.loadToCache(&getResourceManager(),
SHADER_FILENAME, pps.toCString(), "r_");
m_vblurPpline = m_r->createDrawQuadProgramPipeline(
m_vblurFrag->getGlProgram());
cmdb.flush();
}
void LoadSave::varToState(mopo::HelmEngine* synth,
std::map<std::string, String>& gui_state,
const CriticalSection& critical_section,
var state) {
if (!state.isObject())
return;
DynamicObject* object_state = state.getDynamicObject();
NamedValueSet properties = object_state->getProperties();
// Version 0.4.1 was the last build before we saved the version number.
String version = "0.4.1";
if (properties.contains("synth_version"))
version = properties["synth_version"];
// After 0.4.1 there was a patch file restructure.
if (compareVersionStrings(version, "0.4.1") <= 0) {
NamedValueSet new_properties;
new_properties.set("settings", object_state);
properties = new_properties;
}
var settings = properties["settings"];
DynamicObject* settings_object = settings.getDynamicObject();
NamedValueSet settings_properties = settings_object->getProperties();
Array<var>* modulations = settings_properties["modulations"].getArray();
// After 0.5.0 mixer was added and osc_mix was removed. And scaling of oscillators was changed.
if (compareVersionStrings(version, "0.5.0") <= 0) {
// Fix control control values.
if (settings_properties.contains("osc_mix")) {
mopo::mopo_float osc_mix = settings_properties["osc_mix"];
settings_properties.set("osc_1_volume", sqrt(1.0f - osc_mix));
settings_properties.set("osc_2_volume", sqrt(osc_mix));
settings_properties.remove("osc_mix");
}
// Fix modulation routing.
var* modulation = modulations->begin();
Array<var> old_modulations;
Array<DynamicObject*> new_modulations;
for (; modulation != modulations->end(); ++modulation) {
DynamicObject* mod = modulation->getDynamicObject();
String destination = mod->getProperty("destination").toString();
if (destination == "osc_mix") {
String source = mod->getProperty("source").toString();
mopo::mopo_float amount = mod->getProperty("amount");
old_modulations.add(mod);
DynamicObject* osc_1_mod = new DynamicObject();
osc_1_mod->setProperty("source", source);
osc_1_mod->setProperty("destination", "osc_1_volume");
osc_1_mod->setProperty("amount", -amount);
new_modulations.add(osc_1_mod);
DynamicObject* osc_2_mod = new DynamicObject();
osc_2_mod->setProperty("source", source);
osc_2_mod->setProperty("destination", "osc_2_volume");
osc_2_mod->setProperty("amount", amount);
new_modulations.add(osc_2_mod);
}
}
for (var old_modulation : old_modulations)
modulations->removeFirstMatchingValue(old_modulation);
for (DynamicObject* modulation : new_modulations)
modulations->add(modulation);
}
loadControls(synth, critical_section, settings_properties);
loadModulations(synth, critical_section, modulations);
loadGuiState(gui_state, properties);
}
/**
* This method will NOT check the type and dimension of the data field!
* \param dataPtr data set ( Scalar volume )
* \param kernel filter kernel
*/
TImagePtr CKernelFilter::applyKernel( TImagePtr dataPtr, Array<double, 3>& kernel ) throw()
{
BENCHSTART;
FBEGIN;
size_t usDims[] = { dataPtr->getExtent(0), dataPtr->getExtent(1),
dataPtr->getExtent(2) };
TImagePtr outputPtr ( new TImage( 3, dataPtr->getExtents(),
dataPtr->getDataDimension() ) );
outputPtr->getDataRange().setMinimum( dataPtr->getDataRange().getMinimum() );
outputPtr->getDataRange().setMaximum( dataPtr->getDataRange().getMaximum() );
ushort usRadius = ( kernel.cols() - 1 ) / 2; // Filter kernel size
DBG2("Starting filter BLITZ++");
PROG_MAX( dataPtr->getDataDimension() );
for ( ushort usChannels = 0; usChannels < dataPtr->getDataDimension();
++usChannels )
{
PROG_VAL( usChannels + 1 );
Array<short, 3> work ( dataPtr->getArray( usChannels ),
shape(usDims[0], usDims[1], usDims[2]), neverDeleteData, AIPSArray<3>() );
Array<short, 3> output ( outputPtr->getArray( usChannels ),
shape(usDims[0], usDims[1], usDims[2]), neverDeleteData, AIPSArray<3>() );
int lastpos = 0;
cerr << ">>>";
for ( Array<short, 3>::iterator it = work.begin(); it != work.end(); ++it )
{
TinyVector<int, 3> position = it.position();
/* if ( position[2] != lastpos )
{
cerr << position[2] << " ";
lastpos = position[2];
}*/
double dTmp = 0;
for ( int k = position[0] - usRadius; k < ( position[0] + usRadius + 1 ); ++k )
for ( int l = position[1] - usRadius; l < ( position[1] + usRadius + 1 ); ++l )
for ( int m = position[2] - usRadius; m < ( position[2] + usRadius + 1 ); ++m )
{
int i = k + usRadius - position[0];
int j = l + usRadius - position[1];
int n = m + usRadius - position[2];
if ( k < work.rows() && k > -1 && l < work.cols()
&& l > -1 && m < work.depth() && m > -1 )
dTmp += work( k, l, m ) * kernel( i, j, n );
}
output( position ) = static_cast<ushort>( std::abs( static_cast<long>( dTmp ) ) );
if ( output( position ) > outputPtr->getDataRange().getMaximum() )
outputPtr->getDataRange().setMaximum( output( position ) );
else if ( output( position ) < outputPtr->getDataRange().getMinimum() )
outputPtr->getDataRange().setMinimum( output( position ) );
}
cerr << "<<<" << endl;
}
PROG_RESET();
BENCHSTOP;
FEND;
return outputPtr;
}
void Gaussian1dCapFloorEngine::calculate() const {
for (Size i = 0; i < arguments_.spreads.size(); i++)
QL_REQUIRE(arguments_.spreads[i] == 0.0,
"Non zero spreads (" << arguments_.spreads[i]
<< ") are not allowed.");
Size optionlets = arguments_.startDates.size();
std::vector<Real> values(optionlets, 0.0);
std::vector<Real> forwards(optionlets, 0.0);
Real value = 0.0;
Date settlement = model_->termStructure()->referenceDate();
CapFloor::Type type = arguments_.type;
Array z = model_->yGrid(stddevs_, integrationPoints_);
Array p(z.size());
for (Size i = 0; i < optionlets; ++i) {
Date valueDate = arguments_.startDates[i];
Date paymentDate = arguments_.endDates[i];
boost::shared_ptr<IborIndex> iborIndex =
boost::dynamic_pointer_cast<IborIndex>(arguments_.indexes[i]);
// if we do not find an ibor index with associated forwarding curve
// we fall back on the model curve
if (paymentDate > settlement) {
Real f = arguments_.nominals[i] * arguments_.gearings[i];
Date fixingDate = arguments_.fixingDates[i];
Time fixingTime =
model_->termStructure()->timeFromReference(fixingDate);
Real strike;
if (type == CapFloor::Cap || type == CapFloor::Collar) {
strike = arguments_.capRates[i];
if (fixingDate <= settlement) {
values[i] =
std::max(arguments_.forwards[i] - strike, 0.0) * f *
arguments_.accrualTimes[i];
} else {
for (Size j = 0; j < z.size(); j++) {
Real floatingLegNpv;
if (iborIndex != NULL)
floatingLegNpv =
arguments_.accrualTimes[i] *
model_->forwardRate(fixingDate, fixingDate,
z[j], iborIndex) *
model_->zerobond(paymentDate, fixingDate,
z[j], discountCurve_);
else
floatingLegNpv =
(model_->zerobond(valueDate, fixingDate,
z[j]) -
model_->zerobond(paymentDate, fixingDate,
z[j]));
Real fixedLegNpv =
arguments_.capRates[i] *
arguments_.accrualTimes[i] *
model_->zerobond(paymentDate, fixingDate, z[j]);
p[j] =
std::max((floatingLegNpv - fixedLegNpv), 0.0) /
model_->numeraire(fixingTime, z[j],
discountCurve_);
}
CubicInterpolation payoff(
z.begin(), z.end(), p.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
Real price = 0.0;
for (Size j = 0; j < z.size() - 1; j++) {
price += model_->gaussianShiftedPolynomialIntegral(
0.0, payoff.cCoefficients()[j],
payoff.bCoefficients()[j],
payoff.aCoefficients()[j], p[j], z[j], z[j],
z[j + 1]);
}
if (extrapolatePayoff_) {
if (flatPayoffExtrapolation_) {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[z.size() - 2],
z[z.size() - 2], z[z.size() - 1],
100.0);
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[0], z[0], -100.0,
z[0]);
} else {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0,
payoff.cCoefficients()[z.size() - 2],
payoff.bCoefficients()[z.size() - 2],
payoff.aCoefficients()[z.size() - 2],
p[z.size() - 2], z[z.size() - 2],
z[z.size() - 1], 100.0);
}
}
values[i] =
price *
model_->numeraire(0.0, 0.0, discountCurve_) * f;
}
}
if (type == CapFloor::Floor || type == CapFloor::Collar) {
strike = arguments_.floorRates[i];
Real floorlet;
if (fixingDate <= settlement) {
floorlet =
std::max(-(arguments_.forwards[i] - strike), 0.0) *
f * arguments_.accrualTimes[i];
} else {
for (Size j = 0; j < z.size(); j++) {
Real floatingLegNpv;
if (iborIndex != NULL)
floatingLegNpv =
arguments_.accrualTimes[i] *
model_->forwardRate(fixingDate, fixingDate,
z[j], iborIndex) *
model_->zerobond(paymentDate, fixingDate,
z[j], discountCurve_);
else
floatingLegNpv =
(model_->zerobond(valueDate, fixingDate,
z[j]) -
model_->zerobond(paymentDate, fixingDate,
z[j]));
Real fixedLegNpv =
arguments_.floorRates[i] *
arguments_.accrualTimes[i] *
model_->zerobond(paymentDate, fixingDate, z[j]);
p[j] =
std::max(-(floatingLegNpv - fixedLegNpv), 0.0) /
model_->numeraire(fixingTime, z[j],
discountCurve_);
}
CubicInterpolation payoff(
z.begin(), z.end(), p.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
Real price = 0.0;
for (Size j = 0; j < z.size() - 1; j++) {
price += model_->gaussianShiftedPolynomialIntegral(
0.0, payoff.cCoefficients()[j],
payoff.bCoefficients()[j],
payoff.aCoefficients()[j], p[j], z[j], z[j],
z[j + 1]);
}
if (extrapolatePayoff_) {
if (flatPayoffExtrapolation_) {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[z.size() - 2],
z[z.size() - 2], z[z.size() - 1],
100.0);
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[0], z[0], -100.0,
z[0]);
} else {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, payoff.cCoefficients()[0],
payoff.bCoefficients()[0],
payoff.aCoefficients()[0], p[0], z[0],
-100.0, z[0]);
}
}
floorlet = price *
model_->numeraire(0.0, 0.0, discountCurve_) *
f;
}
if (type == CapFloor::Floor) {
values[i] = floorlet;
} else {
// a collar is long a cap and short a floor
values[i] -= floorlet;
}
}
value += values[i];
}
}
results_.value = value;
results_.additionalResults["optionletsPrice"] = values;
results_.additionalResults["optionletsAtmForward"] = forwards;
}
bool operator<(const Array<T, N>& left, const Array<T, N>& right) {
return std::lexicographical_compare(left.begin(),left.end(),
right.begin(),right.end());
}
//! @name Constructor/Destructor
//@{
AMGXOperator(const Teuchos::RCP<Tpetra::CrsMatrix<SC,LO,GO,NO> > &inA, Teuchos::ParameterList ¶mListIn) {
RCP<const Teuchos::Comm<int> > comm = inA->getRowMap()->getComm();
int numProcs = comm->getSize();
int myRank = comm->getRank();
RCP<Teuchos::Time> amgxTimer = Teuchos::TimeMonitor::getNewTimer("MueLu: AMGX: initialize");
amgxTimer->start();
// Initialize
AMGX_SAFE_CALL(AMGX_initialize());
AMGX_SAFE_CALL(AMGX_initialize_plugins());
/*system*/
//AMGX_SAFE_CALL(AMGX_register_print_callback(&print_callback));
AMGX_SAFE_CALL(AMGX_install_signal_handler());
Teuchos::ParameterList configs = paramListIn.sublist("amgx:params", true);
if (configs.isParameter("json file")) {
AMGX_SAFE_CALL(AMGX_config_create_from_file(&Config_, (const char *) &configs.get<std::string>("json file")[0]));
} else {
std::ostringstream oss;
oss << "";
ParameterList::ConstIterator itr;
for (itr = configs.begin(); itr != configs.end(); ++itr) {
const std::string& name = configs.name(itr);
const ParameterEntry& entry = configs.entry(itr);
oss << name << "=" << filterValueToString(entry) << ", ";
}
oss << "\0";
std::string configString = oss.str();
if (configString == "") {
//print msg that using defaults
//GetOStream(Warnings0) << "Warning: No configuration parameters specified, using default AMGX configuration parameters. \n";
}
AMGX_SAFE_CALL(AMGX_config_create(&Config_, configString.c_str()));
}
// TODO: we probably need to add "exception_handling=1" to the parameter list
// to switch on internal error handling (with no need for AMGX_SAFE_CALL)
#define NEW_COMM
#ifdef NEW_COMM
// NOTE: MPI communicator used in AMGX_resources_create must exist in the scope of AMGX_matrix_comm_from_maps_one_ring
// FIXME: fix for serial comm
RCP<const Teuchos::MpiComm<int> > tmpic = Teuchos::rcp_dynamic_cast<const Teuchos::MpiComm<int> >(comm->duplicate());
TEUCHOS_TEST_FOR_EXCEPTION(tmpic.is_null(), Exceptions::RuntimeError, "Communicator is not MpiComm");
RCP<const Teuchos::OpaqueWrapper<MPI_Comm> > rawMpiComm = tmpic->getRawMpiComm();
MPI_Comm mpiComm = *rawMpiComm;
#endif
// Construct AMGX resources
if (numProcs == 1) {
AMGX_resources_create_simple(&Resources_, Config_);
} else {
int numGPUDevices;
cudaGetDeviceCount(&numGPUDevices);
int device[] = {(comm->getRank() % numGPUDevices)};
AMGX_config_add_parameters(&Config_, "communicator=MPI");
#ifdef NEW_COMM
AMGX_resources_create(&Resources_, Config_, &mpiComm, 1/* number of GPU devices utilized by this rank */, device);
#else
AMGX_resources_create(&Resources_, Config_, MPI_COMM_WORLD, 1/* number of GPU devices utilized by this rank */, device);
#endif
}
AMGX_Mode mode = AMGX_mode_dDDI;
AMGX_solver_create(&Solver_, Resources_, mode, Config_);
AMGX_matrix_create(&A_, Resources_, mode);
AMGX_vector_create(&X_, Resources_, mode);
AMGX_vector_create(&Y_, Resources_, mode);
amgxTimer->stop();
amgxTimer->incrementNumCalls();
std::vector<int> amgx2muelu;
// Construct AMGX communication pattern
if (numProcs > 1) {
RCP<const Tpetra::Import<LO,GO> > importer = inA->getCrsGraph()->getImporter();
TEUCHOS_TEST_FOR_EXCEPTION(importer.is_null(), MueLu::Exceptions::RuntimeError, "The matrix A has no Import object.");
Tpetra::Distributor distributor = importer->getDistributor();
Array<int> sendRanks = distributor.getImagesTo();
Array<int> recvRanks = distributor.getImagesFrom();
std::sort(sendRanks.begin(), sendRanks.end());
std::sort(recvRanks.begin(), recvRanks.end());
bool match = true;
if (sendRanks.size() != recvRanks.size()) {
match = false;
} else {
for (int i = 0; i < sendRanks.size(); i++) {
if (recvRanks[i] != sendRanks[i])
match = false;
break;
}
}
TEUCHOS_TEST_FOR_EXCEPTION(!match, MueLu::Exceptions::RuntimeError, "AMGX requires that the processors that we send to and receive from are the same. "
"This is not the case: we send to {" << sendRanks << "} and receive from {" << recvRanks << "}");
int num_neighbors = sendRanks.size(); // does not include the calling process
const int* neighbors = &sendRanks[0];
// Later on, we'll have to organize the send and recv data by PIDs,
// i.e, a vector V of vectors, where V[i] is PID i's vector of data.
// Hence we need to be able to quickly look up an array index
// associated with each PID.
Tpetra::Details::HashTable<int,int> hashTable(3*num_neighbors);
for (int i = 0; i < num_neighbors; i++)
hashTable.add(neighbors[i], i);
// Get some information out
ArrayView<const int> exportLIDs = importer->getExportLIDs();
ArrayView<const int> exportPIDs = importer->getExportPIDs();
Array<int> importPIDs;
Tpetra::Import_Util::getPids(*importer, importPIDs, true/* make local -1 */);
// Construct the reordering for AMGX as in AMGX_matrix_upload_all documentation
RCP<const Map> rowMap = inA->getRowMap();
RCP<const Map> colMap = inA->getColMap();
int N = rowMap->getNodeNumElements(), Nc = colMap->getNodeNumElements();
muelu2amgx_.resize(Nc, -1);
int numUniqExports = 0;
for (int i = 0; i < exportLIDs.size(); i++)
if (muelu2amgx_[exportLIDs[i]] == -1) {
numUniqExports++;
muelu2amgx_[exportLIDs[i]] = -2;
}
int localOffset = 0, exportOffset = N - numUniqExports;
// Go through exported LIDs and put them at the end of LIDs
for (int i = 0; i < exportLIDs.size(); i++)
if (muelu2amgx_[exportLIDs[i]] < 0) // exportLIDs are not unique
muelu2amgx_[exportLIDs[i]] = exportOffset++;
// Go through all non-export LIDs, and put them at the beginning of LIDs
for (int i = 0; i < N; i++)
if (muelu2amgx_[i] == -1)
muelu2amgx_[i] = localOffset++;
// Go through the tail (imported LIDs), and order those by neighbors
int importOffset = N;
for (int k = 0; k < num_neighbors; k++)
for (int i = 0; i < importPIDs.size(); i++)
if (importPIDs[i] != -1 && hashTable.get(importPIDs[i]) == k)
muelu2amgx_[i] = importOffset++;
amgx2muelu.resize(muelu2amgx_.size());
for (int i = 0; i < muelu2amgx_.size(); i++)
amgx2muelu[muelu2amgx_[i]] = i;
// Construct send arrays
std::vector<std::vector<int> > sendDatas (num_neighbors);
std::vector<int> send_sizes(num_neighbors, 0);
for (int i = 0; i < exportPIDs.size(); i++) {
int index = hashTable.get(exportPIDs[i]);
sendDatas [index].push_back(muelu2amgx_[exportLIDs[i]]);
send_sizes[index]++;
}
// FIXME: sendDatas must be sorted (based on GIDs)
std::vector<const int*> send_maps(num_neighbors);
for (int i = 0; i < num_neighbors; i++)
send_maps[i] = &(sendDatas[i][0]);
// Debugging
printMaps(comm, sendDatas, amgx2muelu, neighbors, *importer->getTargetMap(), "send_map_vector");
// Construct recv arrays
std::vector<std::vector<int> > recvDatas (num_neighbors);
std::vector<int> recv_sizes(num_neighbors, 0);
for (int i = 0; i < importPIDs.size(); i++)
if (importPIDs[i] != -1) {
int index = hashTable.get(importPIDs[i]);
recvDatas [index].push_back(muelu2amgx_[i]);
recv_sizes[index]++;
}
// FIXME: recvDatas must be sorted (based on GIDs)
std::vector<const int*> recv_maps(num_neighbors);
for (int i = 0; i < num_neighbors; i++)
recv_maps[i] = &(recvDatas[i][0]);
// Debugging
printMaps(comm, recvDatas, amgx2muelu, neighbors, *importer->getTargetMap(), "recv_map_vector");
AMGX_SAFE_CALL(AMGX_matrix_comm_from_maps_one_ring(A_, 1, num_neighbors, neighbors, &send_sizes[0], &send_maps[0], &recv_sizes[0], &recv_maps[0]));
AMGX_vector_bind(X_, A_);
AMGX_vector_bind(Y_, A_);
}
RCP<Teuchos::Time> matrixTransformTimer = Teuchos::TimeMonitor::getNewTimer("MueLu: AMGX: transform matrix");
matrixTransformTimer->start();
ArrayRCP<const size_t> ia_s;
ArrayRCP<const int> ja;
ArrayRCP<const double> a;
inA->getAllValues(ia_s, ja, a);
ArrayRCP<int> ia(ia_s.size());
for (int i = 0; i < ia.size(); i++)
ia[i] = Teuchos::as<int>(ia_s[i]);
N_ = inA->getNodeNumRows();
int nnz = inA->getNodeNumEntries();
matrixTransformTimer->stop();
matrixTransformTimer->incrementNumCalls();
// Upload matrix
// TODO Do we need to pin memory here through AMGX_pin_memory?
RCP<Teuchos::Time> matrixTimer = Teuchos::TimeMonitor::getNewTimer("MueLu: AMGX: transfer matrix CPU->GPU");
matrixTimer->start();
if (numProcs == 1) {
AMGX_matrix_upload_all(A_, N_, nnz, 1, 1, &ia[0], &ja[0], &a[0], NULL);
} else {
// Transform the matrix
std::vector<int> ia_new(ia.size());
std::vector<int> ja_new(ja.size());
std::vector<double> a_new (a.size());
ia_new[0] = 0;
for (int i = 0; i < N_; i++) {
int oldRow = amgx2muelu[i];
ia_new[i+1] = ia_new[i] + (ia[oldRow+1] - ia[oldRow]);
for (int j = ia[oldRow]; j < ia[oldRow+1]; j++) {
int offset = j - ia[oldRow];
ja_new[ia_new[i] + offset] = muelu2amgx_[ja[j]];
a_new [ia_new[i] + offset] = a[j];
}
// Do bubble sort on two arrays
// NOTE: There are multiple possible optimizations here (even of bubble sort)
bool swapped;
do {
swapped = false;
for (int j = ia_new[i]; j < ia_new[i+1]-1; j++)
if (ja_new[j] > ja_new[j+1]) {
std::swap(ja_new[j], ja_new[j+1]);
std::swap(a_new [j], a_new [j+1]);
swapped = true;
}
} while (swapped == true);
}
AMGX_matrix_upload_all(A_, N_, nnz, 1, 1, &ia_new[0], &ja_new[0], &a_new[0], NULL);
}
matrixTimer->stop();
matrixTimer->incrementNumCalls();
domainMap_ = inA->getDomainMap();
rangeMap_ = inA->getRangeMap();
RCP<Teuchos::Time> realSetupTimer = Teuchos::TimeMonitor::getNewTimer("MueLu: AMGX: real setup");
realSetupTimer->start();
AMGX_solver_setup(Solver_, A_);
realSetupTimer->stop();
realSetupTimer->incrementNumCalls();
vectorTimer1_ = Teuchos::TimeMonitor::getNewTimer("MueLu: AMGX: transfer vectors CPU->GPU");
vectorTimer2_ = Teuchos::TimeMonitor::getNewTimer("MueLu: AMGX: transfer vector GPU->CPU");
}
void defaultGetPoints(
const Scalar& t_old, // required inArg
const Ptr<const VectorBase<Scalar> >& x_old, // optional inArg
const Ptr<const VectorBase<Scalar> >& xdot_old, // optional inArg
const Scalar& t, // required inArg
const Ptr<const VectorBase<Scalar> >& x, // optional inArg
const Ptr<const VectorBase<Scalar> >& xdot, // optional inArg
const Array<Scalar>& time_vec, // required inArg
const Ptr<Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > > >& x_vec, // optional outArg
const Ptr<Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > > >& xdot_vec, // optional outArg
const Ptr<Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> >& accuracy_vec, // optional outArg
const Ptr<InterpolatorBase<Scalar> > interpolator // optional inArg (note: not const)
)
{
typedef Teuchos::ScalarTraits<Scalar> ST;
assertTimePointsAreSorted(time_vec);
TimeRange<Scalar> tr(t_old, t);
TEUCHOS_ASSERT( tr.isValid() );
if (!is_null(x_vec)) {
x_vec->clear();
}
if (!is_null(xdot_vec)) {
xdot_vec->clear();
}
if (!is_null(accuracy_vec)) {
accuracy_vec->clear();
}
typename Array<Scalar>::const_iterator time_it = time_vec.begin();
RCP<const VectorBase<Scalar> > tmpVec;
RCP<const VectorBase<Scalar> > tmpVecDot;
for (; time_it != time_vec.end() ; time_it++) {
Scalar time = *time_it;
asssertInTimeRange(tr, time);
Scalar accuracy = ST::zero();
if (compareTimeValues(time,t_old)==0) {
if (!is_null(x_old)) {
tmpVec = x_old->clone_v();
}
if (!is_null(xdot_old)) {
tmpVecDot = xdot_old->clone_v();
}
} else if (compareTimeValues(time,t)==0) {
if (!is_null(x)) {
tmpVec = x->clone_v();
}
if (!is_null(xdot)) {
tmpVecDot = xdot->clone_v();
}
} else {
TEST_FOR_EXCEPTION(
is_null(interpolator), std::logic_error,
"Error, getPoints: This stepper only supports time values on the boundaries!\n"
);
// At this point, we know time != t_old, time != t, interpolator != null,
// and time in [t_old,t], therefore, time in (t_old,t).
// t_old != t at this point because otherwise it would have been caught above.
// Now use the interpolator to pass out the interior points
typename DataStore<Scalar>::DataStoreVector_t ds_nodes;
typename DataStore<Scalar>::DataStoreVector_t ds_out;
{
// t_old
DataStore<Scalar> ds;
ds.time = t_old;
ds.x = rcp(x_old.get(),false);
ds.xdot = rcp(xdot_old.get(),false);
ds_nodes.push_back(ds);
}
{
// t
DataStore<Scalar> ds;
ds.time = t;
ds.x = rcp(x.get(),false);
ds.xdot = rcp(xdot.get(),false);
ds_nodes.push_back(ds);
}
Array<Scalar> time_vec_in;
time_vec_in.push_back(time);
interpolate<Scalar>(*interpolator,rcp(&ds_nodes,false),time_vec_in,&ds_out);
Array<Scalar> time_vec_out;
Array<RCP<const VectorBase<Scalar> > > x_vec_out;
Array<RCP<const VectorBase<Scalar> > > xdot_vec_out;
Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> accuracy_vec_out;
dataStoreVectorToVector(ds_out,&time_vec_out,&x_vec_out,&xdot_vec_out,&accuracy_vec_out);
TEUCHOS_ASSERT( time_vec_out.length()==1 );
tmpVec = x_vec_out[0];
tmpVecDot = xdot_vec_out[0];
accuracy = accuracy_vec_out[0];
}
if (!is_null(x_vec)) {
x_vec->push_back(tmpVec);
}
if (!is_null(xdot_vec)) {
xdot_vec->push_back(tmpVecDot);
}
if (!is_null(accuracy_vec)) {
accuracy_vec->push_back(accuracy);
}
tmpVec = Teuchos::null;
tmpVecDot = Teuchos::null;
}
}
bool operator==(const Array<T, N>& left, const Array<T, N>& right) {
return std::equal(left.begin(), left.end(), right.begin());
}
void Gaussian1dSwaptionEngine::calculate() const {
QL_REQUIRE(arguments_.settlementType == Settlement::Physical,
"cash-settled swaptions not yet implemented ...");
Date settlement = model_->termStructure()->referenceDate();
if (arguments_.exercise->dates().back() <=
settlement) { // swaption is expired, possibly generated swap is not
// valued
results_.value = 0.0;
return;
}
int idx = static_cast<int>(arguments_.exercise->dates().size()) - 1;
int minIdxAlive = static_cast<int>(
std::upper_bound(arguments_.exercise->dates().begin(),
arguments_.exercise->dates().end(), settlement) -
arguments_.exercise->dates().begin());
VanillaSwap swap = *arguments_.swap;
Option::Type type =
arguments_.type == VanillaSwap::Payer ? Option::Call : Option::Put;
Schedule fixedSchedule = swap.fixedSchedule();
Schedule floatSchedule = swap.floatingSchedule();
Array npv0(2 * integrationPoints_ + 1, 0.0),
npv1(2 * integrationPoints_ + 1, 0.0);
Array z = model_->yGrid(stddevs_, integrationPoints_);
Array p(z.size(), 0.0);
Date expiry1 = Null<Date>(), expiry0;
Time expiry1Time = Null<Real>(), expiry0Time;
do {
if (idx == minIdxAlive - 1)
expiry0 = settlement;
else
expiry0 = arguments_.exercise->dates()[idx];
expiry0Time = std::max(
model_->termStructure()->timeFromReference(expiry0), 0.0);
Size j1 =
std::upper_bound(fixedSchedule.dates().begin(),
fixedSchedule.dates().end(), expiry0 - 1) -
fixedSchedule.dates().begin();
Size k1 =
std::upper_bound(floatSchedule.dates().begin(),
floatSchedule.dates().end(), expiry0 - 1) -
floatSchedule.dates().begin();
// a lazy object is not thread safe, neither is the caching
// in gsrprocess. therefore we trigger computations here such
// that neither lazy object recalculation nor write access
// during caching occurs in the parallized loop below.
// this is known to work for the gsr and markov functional
// model implementations of Gaussian1dModel
#ifdef _OPENMP
if (expiry0 > settlement) {
for (Size l = k1; l < arguments_.floatingCoupons.size(); l++) {
model_->forwardRate(arguments_.floatingFixingDates[l],
expiry0, 0.0,
arguments_.swap->iborIndex());
model_->zerobond(arguments_.floatingPayDates[l], expiry0,
0.0, discountCurve_);
}
for (Size l = j1; l < arguments_.fixedCoupons.size(); l++) {
model_->zerobond(arguments_.fixedPayDates[l], expiry0, 0.0,
discountCurve_);
}
model_->numeraire(expiry0Time, 0.0, discountCurve_);
}
#endif
#pragma omp parallel for default(shared) firstprivate(p) if(expiry0>settlement)
for (Size k = 0; k < (expiry0 > settlement ? npv0.size() : 1);
k++) {
Real price = 0.0;
if (expiry1Time != Null<Real>()) {
Array yg = model_->yGrid(stddevs_, integrationPoints_,
expiry1Time, expiry0Time,
expiry0 > settlement ? z[k] : 0.0);
CubicInterpolation payoff0(
z.begin(), z.end(), npv1.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < yg.size(); i++) {
p[i] = payoff0(yg[i], true);
}
CubicInterpolation payoff1(
z.begin(), z.end(), p.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < z.size() - 1; i++) {
price += model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[i],
payoff1.bCoefficients()[i],
payoff1.aCoefficients()[i], p[i], z[i], z[i],
z[i + 1]);
}
if (extrapolatePayoff_) {
if (flatPayoffExtrapolation_) {
price += model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[z.size() - 2],
z[z.size() - 2], z[z.size() - 1], 100.0);
price += model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[0], z[0], -100.0, z[0]);
} else {
if (type == Option::Call)
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0,
payoff1.cCoefficients()[z.size() - 2],
payoff1.bCoefficients()[z.size() - 2],
payoff1.aCoefficients()[z.size() - 2],
p[z.size() - 2], z[z.size() - 2],
z[z.size() - 1], 100.0);
if (type == Option::Put)
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[0],
payoff1.bCoefficients()[0],
payoff1.aCoefficients()[0], p[0], z[0],
-100.0, z[0]);
}
}
}
npv0[k] = price;
if (expiry0 > settlement) {
Real floatingLegNpv = 0.0;
for (Size l = k1; l < arguments_.floatingCoupons.size();
l++) {
floatingLegNpv +=
arguments_.nominal *
arguments_.floatingAccrualTimes[l] *
(arguments_.floatingSpreads[l] +
model_->forwardRate(
arguments_.floatingFixingDates[l], expiry0,
z[k], arguments_.swap->iborIndex())) *
model_->zerobond(arguments_.floatingPayDates[l],
expiry0, z[k], discountCurve_);
}
Real fixedLegNpv = 0.0;
for (Size l = j1; l < arguments_.fixedCoupons.size(); l++) {
fixedLegNpv +=
arguments_.fixedCoupons[l] *
model_->zerobond(arguments_.fixedPayDates[l],
expiry0, z[k], discountCurve_);
}
npv0[k] = std::max(npv0[k],
(type == Option::Call ? 1.0 : -1.0) *
(floatingLegNpv - fixedLegNpv) /
model_->numeraire(expiry0Time, z[k],
discountCurve_));
}
}
npv1.swap(npv0);
expiry1 = expiry0;
expiry1Time = expiry0Time;
} while (--idx >= minIdxAlive - 1);
results_.value = npv1[0] * model_->numeraire(0.0, 0.0, discountCurve_);
}
EndCriteria::Type DifferentialEvolution::minimize(Problem& P,
const EndCriteria& endCriteria) {
EndCriteria::Type ecType = EndCriteria::MaxIterations;
QL_REQUIRE(P.currentValue().size() == nParam_,
"Number of parameters mismatch between problem and DE optimizer");
P.reset();
init();
Real bestCost = QL_MAX_REAL;
Size bestPop = 0;
for (Size p = 0; p < nPop_; ++p) {
Array tmp(currGen_[p].pop_);
try {
currGen_[p].cost_ = P.costFunction().value(tmp);
} catch (Error&) {
currGen_[p].cost_ = QL_MAX_REAL;
}
if (currGen_[p].cost_ < bestCost) {
bestPop = p;
bestCost = currGen_[p].cost_;
}
}
Size lastChange = 0;
Size lastParamChange = 0;
for(Size i=0; i<endCriteria.maxIterations(); ++i) {
Size newBestPop = bestPop;
Real newBestCost = bestCost;
for (Size p=0; p<nPop_; ++p) {
// Find 3 different populations randomly
Size r1;
do {
r1 = static_cast <Size> (uniformRng_.nextInt32() % nPop_);
}
while(r1 == p || r1 == bestPop);
Size r2;
do {
r2 = static_cast <Size> (uniformRng_.nextInt32() % nPop_);
}
while ( r2 == p || r2 == bestPop || r2 == r1);
Size r3;
do {
r3 = static_cast <Size> (uniformRng_.nextInt32() % nPop_);
} while ( r3 == p || r3 == bestPop || r3 == r1 || r3 == r2);
for(Size j=0; j<nParam_; ++j) {
nextGen_[p].pop_[j] = currGen_[p].pop_[j];
}
Size j = static_cast <Size> (uniformRng_.nextInt32() % nParam_);
Size L = 0;
do {
const double tmp =
currGen_[ p].pop_[j] * a0_
+ currGen_[ r1].pop_[j] * a1_
+ currGen_[ r2].pop_[j] * a2_
+ currGen_[ r3].pop_[j] * a3_
+ currGen_[bestPop].pop_[j] * aBest_;
nextGen_[p].pop_[j] =
std::min(maxParams_[j], std::max(minParams_[j], tmp));
j = (j+1)%nParam_;
++L;
} while ((uniformRng_.nextReal() < CR_) && (L < nParam_));
// Evaluate the new population
Array tmp(nextGen_[p].pop_);
try {
nextGen_[p].cost_ = P.costFunction().value(tmp);
} catch (Error&) {
nextGen_[p].cost_ = QL_MAX_REAL;
}
// Not better, discard it and keep the old one.
if (nextGen_[p].cost_ >= currGen_[p].cost_) {
nextGen_[p] = currGen_[p];
}
// Better, keep it.
else {
// New best?
if (nextGen_[p].cost_ < newBestCost) {
newBestPop = p;
newBestCost = nextGen_[p].cost_;
}
}
}
if(std::abs(newBestCost-bestCost) > endCriteria.functionEpsilon()) {
lastChange = i;
}
const Array absDiff = Abs(nextGen_[newBestPop].pop_-currGen_[bestPop].pop_);
if(*std::max_element(absDiff.begin(), absDiff.end()) > endCriteria.rootEpsilon()) {
lastParamChange = i;
}
bestPop = newBestPop;
bestCost = newBestCost;
currGen_ = nextGen_;
if(i-lastChange > endCriteria.maxStationaryStateIterations()) {
ecType = EndCriteria::StationaryFunctionValue;
break;
}
if(i-lastParamChange > endCriteria.maxStationaryStateIterations()) {
ecType = EndCriteria::StationaryPoint;
break;
}
if (adaptive_) adaptParameters();
}
const Array res(currGen_[bestPop].pop_);
P.setCurrentValue(res);
P.setFunctionValue(bestCost);
return ecType;
}
Real accumulate (const Array &a) const {
return *std::max_element(a.begin(), a.end());
}
int main(int argc, char** argv)
{
int stat = 0;
try
{
bool bad = false;
GlobalMPISession session(&argc, &argv);
Out::os() << endl;
Array<int> tetVerts = tuple(234, 102, 371, 259);
Array<int> triVerts = tuple(71, 43, 183);
Array<Array<int> > testVerts = tuple(triVerts, tetVerts);
for (int test=0; test<testVerts.size(); test++)
{
bool more = true;
Array<int> exVerts = testVerts[test];
int dim = exVerts.size()-1;
while (more)
{
Out::os() << "exVerts = " << exVerts << endl;
Array<int> ufcVerts = exVerts;
int key = -1;
vertexSort(ufcVerts, &key);
Out::os() << "ufcVerts = " << ufcVerts << endl;
for (int i=0; i<exVerts.size(); i++)
{
int u = exVertPosToUFCVertPos(dim, key, i);
Out::os() << "ex vert=" << exVerts[i] << " is at pos="
<< u << " in UFC array and has vertID=" << ufcVerts[u] << endl;
}
for (int f=0; f<dim+1; f++)
{
Out::os() << endl << "------------------------ " << endl;
int missingEx = mapExSideToMissingVertex(dim, f);
int missingUfc = exVertPosToUFCVertPos(dim, key, missingEx);
Array<int> exFc = exSide(f, exVerts);
Array<int> ufcFc = ufcSide(missingUfc, ufcVerts);
Out::os() << "exodus face=" << f << ", missing vert pos="
<< missingEx << ", id=" << exVerts[missingEx]<< endl;
Out::os() << "verts = " << exFc << endl;
Out::os() << "missing ufc vertex pos = "
<< missingUfc << ", id=" << ufcVerts[missingUfc]
<< endl;
Out::os() << "ufc verts=" << ufcFc << endl;
bool ok = true;
insertionSort(exFc);
for (int j=0; j<ufcFc.size(); j++)
{
if (exFc[j] != ufcFc[j]) ok = false;
}
if (ok) Out::os() << "check OK" << endl;
else
{
Out::os() << "check FAILED: sort ex=" << exFc << ", ufc=" << ufcFc
<< endl;
bad = true;
}
}
Out::os() << endl << endl;
more = std::next_permutation(exVerts.begin(), exVerts.end());
}
}
if (!bad)
{
std::cerr << "all tests PASSED" << std::endl;
}
else
{
stat = -1;
std::cerr << "a test has FAILED" << std::endl;
}
}
catch(std::exception& e)
{
stat = -1;
std::cerr << "detected exception " << e.what() << std::endl;
}
return stat;
}
const Real Gaussian1dModel::zerobondOption(
const Option::Type &type, const Date &expiry, const Date &valueDate,
const Date &maturity, const Rate strike, const Date &referenceDate,
const Real y, const Handle<YieldTermStructure> &yts, const Real yStdDevs,
const Size yGridPoints, const bool extrapolatePayoff,
const bool flatPayoffExtrapolation) const {
calculate();
Time fixingTime = termStructure()->timeFromReference(expiry);
Time referenceTime =
referenceDate == Null<Date>()
? 0.0
: termStructure()->timeFromReference(referenceDate);
Array yg = yGrid(yStdDevs, yGridPoints, fixingTime, referenceTime, y);
Array z = yGrid(yStdDevs, yGridPoints);
Array p(yg.size());
for (Size i = 0; i < yg.size(); i++) {
Real expValDsc = zerobond(valueDate, expiry, yg[i], yts);
Real discount =
zerobond(maturity, expiry, yg[i], yts) / expValDsc;
p[i] =
std::max((type == Option::Call ? 1.0 : -1.0) * (discount - strike),
0.0) /
numeraire(fixingTime, yg[i], yts) * expValDsc;
}
CubicInterpolation payoff(
z.begin(), z.end(), p.begin(), CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0, CubicInterpolation::Lagrange, 0.0);
Real price = 0.0;
for (Size i = 0; i < z.size() - 1; i++) {
price += gaussianShiftedPolynomialIntegral(
0.0, payoff.cCoefficients()[i], payoff.bCoefficients()[i],
payoff.aCoefficients()[i], p[i], z[i], z[i], z[i + 1]);
}
if (extrapolatePayoff) {
if (flatPayoffExtrapolation) {
price += gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[z.size() - 2], z[z.size() - 2],
z[z.size() - 1], 100.0);
price += gaussianShiftedPolynomialIntegral(0.0, 0.0, 0.0, 0.0, p[0],
z[0], -100.0, z[0]);
} else {
if (type == Option::Call)
price += gaussianShiftedPolynomialIntegral(
0.0, payoff.cCoefficients()[z.size() - 2],
payoff.bCoefficients()[z.size() - 2],
payoff.aCoefficients()[z.size() - 2], p[z.size() - 2],
z[z.size() - 2], z[z.size() - 1], 100.0);
if (type == Option::Put)
price += gaussianShiftedPolynomialIntegral(
0.0, payoff.cCoefficients()[0], payoff.bCoefficients()[0],
payoff.aCoefficients()[0], p[0], z[0], -100.0, z[0]);
}
}
return numeraire(referenceTime, y, yts) * price;
}
void Gaussian1dNonstandardSwaptionEngine::calculate() const {
QL_REQUIRE(arguments_.settlementType == Settlement::Physical,
"cash-settled swaptions not yet implemented ...");
Date settlement = model_->termStructure()->referenceDate();
if (arguments_.exercise->dates().back() <=
settlement) { // swaption is expired, possibly generated swap is not
// valued
results_.value = 0.0;
return;
}
boost::shared_ptr<RebatedExercise> rebatedExercise =
boost::dynamic_pointer_cast<RebatedExercise>(arguments_.exercise);
int idx = arguments_.exercise->dates().size() - 1;
int minIdxAlive = static_cast<int>(
std::upper_bound(arguments_.exercise->dates().begin(),
arguments_.exercise->dates().end(), settlement) -
arguments_.exercise->dates().begin());
NonstandardSwap swap = *arguments_.swap;
Option::Type type =
arguments_.type == VanillaSwap::Payer ? Option::Call : Option::Put;
Schedule schedule = swap.fixedSchedule();
Schedule floatSchedule = swap.floatingSchedule();
Array npv0(2 * integrationPoints_ + 1, 0.0),
npv1(2 * integrationPoints_ + 1, 0.0);
Array z = model_->yGrid(stddevs_, integrationPoints_);
Array p(z.size(), 0.0);
// for probability computation
std::vector<Array> npvp0, npvp1;
if (probabilities_ != None) {
for (Size i = 0; i < static_cast<Size>(idx - minIdxAlive + 2); ++i) {
Array npvTmp0(2 * integrationPoints_ + 1, 0.0);
Array npvTmp1(2 * integrationPoints_ + 1, 0.0);
npvp0.push_back(npvTmp0);
npvp1.push_back(npvTmp1);
}
}
// end probabkility computation
Date expiry1 = Null<Date>(), expiry0;
Time expiry1Time = Null<Real>(), expiry0Time;
do {
if (idx == minIdxAlive - 1)
expiry0 = settlement;
else
expiry0 = arguments_.exercise->dates()[idx];
expiry0Time = std::max(
model_->termStructure()->timeFromReference(expiry0), 0.0);
Size j1 = std::upper_bound(schedule.dates().begin(),
schedule.dates().end(), expiry0 - 1) -
schedule.dates().begin();
Size k1 =
std::upper_bound(floatSchedule.dates().begin(),
floatSchedule.dates().end(), expiry0 - 1) -
floatSchedule.dates().begin();
// todo add openmp support later on (as in gaussian1dswaptionengine)
for (Size k = 0; k < (expiry0 > settlement ? npv0.size() : 1);
k++) {
Real price = 0.0;
if (expiry1Time != Null<Real>()) {
Real zSpreadDf =
oas_.empty() ? 1.0
: std::exp(-oas_->value() *
(expiry1Time - expiry0Time));
Array yg = model_->yGrid(stddevs_, integrationPoints_,
expiry1Time, expiry0Time,
expiry0 > settlement ? z[k] : 0.0);
CubicInterpolation payoff0(
z.begin(), z.end(), npv1.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < yg.size(); i++) {
p[i] = payoff0(yg[i], true);
}
CubicInterpolation payoff1(
z.begin(), z.end(), p.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < z.size() - 1; i++) {
price += model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[i],
payoff1.bCoefficients()[i],
payoff1.aCoefficients()[i], p[i], z[i],
z[i], z[i + 1]) *
zSpreadDf;
}
if (extrapolatePayoff_) {
if (flatPayoffExtrapolation_) {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[z.size() - 2],
z[z.size() - 2], z[z.size() - 1], 100.0) *
zSpreadDf;
price += model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[0], z[0], -100.0,
z[0]) *
zSpreadDf;
} else {
if (type == Option::Call)
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0,
payoff1.cCoefficients()[z.size() - 2],
payoff1.bCoefficients()[z.size() - 2],
payoff1.aCoefficients()[z.size() - 2],
p[z.size() - 2], z[z.size() - 2],
z[z.size() - 1], 100.0) *
zSpreadDf;
if (type == Option::Put)
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[0],
payoff1.bCoefficients()[0],
payoff1.aCoefficients()[0], p[0], z[0],
-100.0, z[0]) *
zSpreadDf;
}
}
}
npv0[k] = price;
// for probability computation
if (probabilities_ != None) {
for (Size m = 0; m < npvp0.size(); m++) {
Real price = 0.0;
if (expiry1Time != Null<Real>()) {
Real zSpreadDf =
oas_.empty()
? 1.0
: std::exp(-oas_->value() *
(expiry1Time - expiry0Time));
Array yg = model_->yGrid(
stddevs_, integrationPoints_, expiry1Time,
expiry0Time, expiry0 > settlement ? z[k] : 0.0);
CubicInterpolation payoff0(
z.begin(), z.end(), npvp1[m].begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < yg.size(); i++) {
p[i] = payoff0(yg[i], true);
}
CubicInterpolation payoff1(
z.begin(), z.end(), p.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < z.size() - 1; i++) {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[i],
payoff1.bCoefficients()[i],
payoff1.aCoefficients()[i], p[i], z[i],
z[i], z[i + 1]) *
zSpreadDf;
}
if (extrapolatePayoff_) {
if (flatPayoffExtrapolation_) {
price +=
model_
->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0,
p[z.size() - 2],
z[z.size() - 2],
z[z.size() - 1], 100.0) *
zSpreadDf;
price +=
model_
->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[0],
z[0], -100.0, z[0]) *
zSpreadDf;
} else {
if (type == Option::Call)
price +=
model_
->gaussianShiftedPolynomialIntegral(
0.0,
payoff1.cCoefficients()
[z.size() - 2],
payoff1.bCoefficients()
[z.size() - 2],
payoff1.aCoefficients()
[z.size() - 2],
p[z.size() - 2],
z[z.size() - 2],
z[z.size() - 1], 100.0) *
zSpreadDf;
if (type == Option::Put)
price +=
model_
->gaussianShiftedPolynomialIntegral(
0.0,
payoff1
.cCoefficients()[0],
payoff1
.bCoefficients()[0],
payoff1
.aCoefficients()[0],
p[0], z[0], -100.0,
z[0]) *
zSpreadDf;
}
}
}
npvp0[m][k] = price;
}
}
// end probability computation
if (expiry0 > settlement) {
Real floatingLegNpv = 0.0;
for (Size l = k1; l < arguments_.floatingCoupons.size();
l++) {
Real zSpreadDf =
oas_.empty()
? 1.0
: std::exp(
-oas_->value() *
(model_->termStructure()
->dayCounter()
.yearFraction(
expiry0,
arguments_
.floatingPayDates[l])));
Real amount;
if (arguments_.floatingIsRedemptionFlow[l])
amount = arguments_.floatingCoupons[l];
else
amount = arguments_.floatingNominal[l] *
arguments_.floatingAccrualTimes[l] *
(arguments_.floatingGearings[l] *
model_->forwardRate(
arguments_.floatingFixingDates[l],
expiry0, z[k],
arguments_.swap->iborIndex()) +
arguments_.floatingSpreads[l]);
floatingLegNpv +=
amount *
model_->zerobond(arguments_.floatingPayDates[l],
expiry0, z[k], discountCurve_) *
zSpreadDf;
}
Real fixedLegNpv = 0.0;
for (Size l = j1; l < arguments_.fixedCoupons.size(); l++) {
Real zSpreadDf =
oas_.empty()
? 1.0
: std::exp(
-oas_->value() *
(model_->termStructure()
->dayCounter()
.yearFraction(
expiry0,
arguments_.fixedPayDates[l])));
fixedLegNpv +=
arguments_.fixedCoupons[l] *
model_->zerobond(arguments_.fixedPayDates[l],
expiry0, z[k], discountCurve_) *
zSpreadDf;
}
Real rebate = 0.0;
Real zSpreadDf = 1.0;
Date rebateDate = expiry0;
if (rebatedExercise != NULL) {
rebate = rebatedExercise->rebate(idx);
rebateDate = rebatedExercise->rebatePaymentDate(idx);
zSpreadDf =
oas_.empty()
? 1.0
: std::exp(
-oas_->value() *
(model_->termStructure()
->dayCounter()
.yearFraction(expiry0, rebateDate)));
}
Real exerciseValue =
((type == Option::Call ? 1.0 : -1.0) *
(floatingLegNpv - fixedLegNpv) +
rebate * model_->zerobond(rebateDate, expiry0, z[k],
discountCurve_) *
zSpreadDf) /
model_->numeraire(expiry0Time, z[k], discountCurve_);
// for probability computation
if (probabilities_ != None) {
if (idx == static_cast<int>(
arguments_.exercise->dates().size()) -
1) // if true we are at the latest date,
// so we init
// the no call probability
npvp0.back()[k] =
probabilities_ == Naive
? 1.0
: 1.0 / (model_->zerobond(expiry0Time, 0.0,
0.0,
discountCurve_) *
model_->numeraire(expiry0, z[k],
discountCurve_));
if (exerciseValue >= npv0[k]) {
npvp0[idx - minIdxAlive][k] =
probabilities_ == Naive
? 1.0
: 1.0 /
(model_->zerobond(expiry0Time, 0.0,
0.0,
discountCurve_) *
model_->numeraire(expiry0Time, z[k],
discountCurve_));
for (Size ii = idx - minIdxAlive + 1;
ii < npvp0.size(); ii++)
npvp0[ii][k] = 0.0;
}
}
// end probability computation
npv0[k] = std::max(npv0[k], exerciseValue);
}
}
npv1.swap(npv0);
// for probability computation
if (probabilities_ != None) {
for (Size i = 0; i < npvp0.size(); i++)
npvp1[i].swap(npvp0[i]);
}
// end probability computation
expiry1 = expiry0;
expiry1Time = expiry0Time;
} while (--idx >= minIdxAlive - 1);
results_.value = npv1[0] * model_->numeraire(0.0, 0.0, discountCurve_);
// for probability computation
if (probabilities_ != None) {
std::vector<Real> prob(npvp0.size());
for (Size i = 0; i < npvp0.size(); i++) {
prob[i] = npvp1[i][0] *
(probabilities_ == Naive
? 1.0
: model_->numeraire(0.0, 0.0, discountCurve_));
}
results_.additionalResults["probabilities"] = prob;
}
// end probability computation
}
//! method to overload to compute the cost function value in x
virtual Real value(const Array& x) const {
Array v = values(x);
std::transform(v.begin(), v.end(), v.begin(), square<Real>());
return std::sqrt(std::accumulate(v.begin(), v.end(), 0.0) /
static_cast<Real>(v.size()));
}
inline bool operator<(const Array &k) const throw() { return std::lexicographical_compare(begin(),end(),k.begin(),k.end()); }
Array(const Array<Data>& rhs)
: mCount(rhs.size())
, mData(rhs.size() != 0 ? Alloc().allocate(rhs.size()) : 0)
{
std::copy(rhs.begin(), rhs.end(), mData);
}
OverlappingRowMatrix<MatrixType>::
OverlappingRowMatrix (const Teuchos::RCP<const row_matrix_type>& A,
const int overlapLevel) :
A_ (A),
OverlapLevel_ (overlapLevel),
UseSubComm_ (false)
{
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::Array;
using Teuchos::outArg;
using Teuchos::rcp_const_cast;
using Teuchos::rcp_dynamic_cast;
using Teuchos::rcp_implicit_cast;
using Teuchos::REDUCE_SUM;
using Teuchos::reduceAll;
typedef Tpetra::global_size_t GST;
typedef Tpetra::CrsGraph<local_ordinal_type,
global_ordinal_type, node_type> crs_graph_type;
TEUCHOS_TEST_FOR_EXCEPTION(
OverlapLevel_ <= 0, std::runtime_error,
"Ifpack2::OverlappingRowMatrix: OverlapLevel must be > 0.");
TEUCHOS_TEST_FOR_EXCEPTION(
A_->getComm()->getSize() == 1, std::runtime_error,
"Ifpack2::OverlappingRowMatrix: Matrix must be "
"distributed over more than one MPI process.");
RCP<const crs_matrix_type> ACRS =
rcp_dynamic_cast<const crs_matrix_type, const row_matrix_type> (A_);
TEUCHOS_TEST_FOR_EXCEPTION(
ACRS.is_null (), std::runtime_error,
"Ifpack2::OverlappingRowMatrix: The input matrix must be a Tpetra::"
"CrsMatrix with matching template parameters. This class currently "
"requires that CrsMatrix's fifth template parameter be the default.");
RCP<const crs_graph_type> A_crsGraph = ACRS->getCrsGraph ();
const size_t numMyRowsA = A_->getNodeNumRows ();
const global_ordinal_type global_invalid =
Teuchos::OrdinalTraits<global_ordinal_type>::invalid ();
// Temp arrays
Array<global_ordinal_type> ExtElements;
RCP<map_type> TmpMap;
RCP<crs_graph_type> TmpGraph;
RCP<import_type> TmpImporter;
RCP<const map_type> RowMap, ColMap;
// The big import loop
for (int overlap = 0 ; overlap < OverlapLevel_ ; ++overlap) {
// Get the current maps
if (overlap == 0) {
RowMap = A_->getRowMap ();
ColMap = A_->getColMap ();
}
else {
RowMap = TmpGraph->getRowMap ();
ColMap = TmpGraph->getColMap ();
}
const size_t size = ColMap->getNodeNumElements () - RowMap->getNodeNumElements ();
Array<global_ordinal_type> mylist (size);
size_t count = 0;
// define the set of rows that are in ColMap but not in RowMap
for (local_ordinal_type i = 0 ; (size_t) i < ColMap->getNodeNumElements() ; ++i) {
const global_ordinal_type GID = ColMap->getGlobalElement (i);
if (A_->getRowMap ()->getLocalElement (GID) == global_invalid) {
typedef typename Array<global_ordinal_type>::iterator iter_type;
const iter_type end = ExtElements.end ();
const iter_type pos = std::find (ExtElements.begin (), end, GID);
if (pos == end) {
ExtElements.push_back (GID);
mylist[count] = GID;
++count;
}
}
}
// mfh 24 Nov 2013: We don't need TmpMap, TmpGraph, or
// TmpImporter after this loop, so we don't have to construct them
// on the last round.
if (overlap + 1 < OverlapLevel_) {
// Allocate & import new matrices, maps, etc.
//
// FIXME (mfh 24 Nov 2013) Do we always want to use index base
// zero? It doesn't really matter, since the actual index base
// (in the current implementation of Map) will always be the
// globally least GID.
TmpMap = rcp (new map_type (global_invalid, mylist (0, count),
Teuchos::OrdinalTraits<global_ordinal_type>::zero (),
A_->getComm (), A_->getNode ()));
TmpGraph = rcp (new crs_graph_type (TmpMap, 0));
TmpImporter = rcp (new import_type (A_->getRowMap (), TmpMap));
TmpGraph->doImport (*A_crsGraph, *TmpImporter, Tpetra::INSERT);
TmpGraph->fillComplete (A_->getDomainMap (), TmpMap);
}
}
// build the map containing all the nodes (original
// matrix + extended matrix)
Array<global_ordinal_type> mylist (numMyRowsA + ExtElements.size ());
for (local_ordinal_type i = 0; (size_t)i < numMyRowsA; ++i) {
mylist[i] = A_->getRowMap ()->getGlobalElement (i);
}
for (local_ordinal_type i = 0; i < ExtElements.size (); ++i) {
mylist[i + numMyRowsA] = ExtElements[i];
}
RowMap_ = rcp (new map_type (global_invalid, mylist (),
Teuchos::OrdinalTraits<global_ordinal_type>::zero (),
A_->getComm (), A_->getNode ()));
ColMap_ = RowMap_;
// now build the map corresponding to all the external nodes
// (with respect to A().RowMatrixRowMap().
ExtMap_ = rcp (new map_type (global_invalid, ExtElements (),
Teuchos::OrdinalTraits<global_ordinal_type>::zero (),
A_->getComm (), A_->getNode ()));
ExtMatrix_ = rcp (new crs_matrix_type (ExtMap_, ColMap_, 0));
ExtImporter_ = rcp (new import_type (A_->getRowMap (), ExtMap_));
RCP<crs_matrix_type> ExtMatrixCRS =
rcp_dynamic_cast<crs_matrix_type, row_matrix_type> (ExtMatrix_);
ExtMatrixCRS->doImport (*ACRS, *ExtImporter_, Tpetra::INSERT);
ExtMatrixCRS->fillComplete (A_->getDomainMap (), RowMap_);
Importer_ = rcp (new import_type (A_->getRowMap (), RowMap_));
// fix indices for overlapping matrix
const size_t numMyRowsB = ExtMatrix_->getNodeNumRows ();
GST NumMyNonzeros_tmp = A_->getNodeNumEntries () + ExtMatrix_->getNodeNumEntries ();
GST NumMyRows_tmp = numMyRowsA + numMyRowsB;
{
GST inArray[2], outArray[2];
inArray[0] = NumMyNonzeros_tmp;
inArray[1] = NumMyRows_tmp;
outArray[0] = 0;
outArray[1] = 0;
reduceAll<int, GST> (* (A_->getComm ()), REDUCE_SUM, 2, inArray, outArray);
NumGlobalNonzeros_ = outArray[0];
NumGlobalRows_ = outArray[1];
}
// reduceAll<int, GST> (* (A_->getComm ()), REDUCE_SUM, NumMyNonzeros_tmp,
// outArg (NumGlobalNonzeros_));
// reduceAll<int, GST> (* (A_->getComm ()), REDUCE_SUM, NumMyRows_tmp,
// outArg (NumGlobalRows_));
MaxNumEntries_ = A_->getNodeMaxNumRowEntries ();
if (MaxNumEntries_ < ExtMatrix_->getNodeMaxNumRowEntries ()) {
MaxNumEntries_ = ExtMatrix_->getNodeMaxNumRowEntries ();
}
// Create the graph (returned by getGraph()).
typedef Details::OverlappingRowGraph<row_graph_type> row_graph_impl_type;
RCP<row_graph_impl_type> graph =
rcp (new row_graph_impl_type (A_->getGraph (),
ExtMatrix_->getGraph (),
RowMap_,
ColMap_,
NumGlobalRows_,
NumGlobalRows_, // # global cols == # global rows
NumGlobalNonzeros_,
MaxNumEntries_,
rcp_const_cast<const import_type> (Importer_),
rcp_const_cast<const import_type> (ExtImporter_)));
graph_ = rcp_const_cast<const row_graph_type> (rcp_implicit_cast<row_graph_type> (graph));
// Resize temp arrays
Indices_.resize (MaxNumEntries_);
Values_.resize (MaxNumEntries_);
}
// This test works (and exercises the interesting case) in serial mode
// or for 1 MPI process, but it was originally written for 2 MPI
// processes.
TEUCHOS_UNIT_TEST( Map, Bug5822_StartWithZeroThenSkipTo3Billion )
{
int locallyThrew = 0;
int globallyThrew = 0;
RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm ();
const int myRank = comm->getRank ();
const int numProcs = comm->getSize ();
TEUCHOS_TEST_FOR_EXCEPTION(numProcs != 2, std::logic_error,
"This test only makes sense to run with 2 MPI processes.");
// Pick the global index type to have 64 bits.
#if ! defined (HAVE_TPETRA_INT_LONG_LONG) && ! defined (HAVE_TPETRA_INT_LONG)
typedef Tpetra::Map<>::global_ordinal_type GO; // just to make it compile
out << "This test only makes sense if GO = long or long long is enabled. "
"That is because the test is supposed to exercise global indices greater "
"than the maximum that int can represent (about 2 billion)." << endl;
return;
#else
# if defined (HAVE_TPETRA_INT_LONG_LONG)
typedef long long GO;
if (sizeof (long long) <= 4) {
out << "sizeof (long long) = " << sizeof (long long) << " <= 4. "
"This test only makes sense if sizeof (long long) >= 8. "
"That is because the test is supposed to exercise global indices "
"greater than the maximum that int can represent (about 2 billion)."
<< endl;
return;
}
# elif defined (HAVE_TPETRA_INT_LONG)
typedef long GO;
if (sizeof (long) <= 4) {
out << "sizeof (long) = " << sizeof (long) << " <= 4. "
"This test only makes sense if sizeof (long) >= 8. "
"That is because the test is supposed to exercise global indices "
"greater than the maximum that int can represent (about 2 billion)."
<< endl;
return;
}
# endif
#endif
typedef Tpetra::Map<>::local_ordinal_type LO;
typedef Tpetra::Map<>::node_type NT;
typedef Tpetra::Map<LO, GO, NT> map_type;
// Proc 0 gets [0, 3B, 3B+2, 3B+4, 3B+8, 3B+10] (6 GIDs).
// Proc 1 gets [3B+12, 3B+14, 3B+16, 3B+18, 3B+20] (5 GIDs).
//
// The GIDs are not contiguous in order to prevent Map from
// detecting contiguity and bypassing the noncontiguous Map
// case.
const size_t localNumElts = (myRank == 0) ? 6 : 5;
const global_size_t globalNumElts = 1 + 5*comm->getSize ();
const GO globalFirstGid = 1L;
const GO threeBillion = static_cast<GO> (3000000000L);
Array<GO> myGids (localNumElts);
// Make a copy, just to make sure that Map's constructor didn't
// sneakily change the input ArrayView.
Array<GO> myGidsExpected (localNumElts);
if (myRank == 0) {
myGids[0] = globalFirstGid;
myGidsExpected[0] = myGids[0];
myGids[1] = threeBillion;
myGidsExpected[1] = myGids[1];
for (size_t k = 2; k < localNumElts; ++k) {
myGids[k] = myGids[k-1] + 2;
myGidsExpected[k] = myGids[k];
}
} else {
myGids[0] = threeBillion + as<GO> ((localNumElts+1) * 2);
myGidsExpected[0] = myGids[0];
for (size_t k = 1; k < localNumElts; ++k) {
myGids[k] = myGids[k-1] + 2;
myGidsExpected[k] = myGids[k];
}
}
RCP<NT> node;
{
Teuchos::ParameterList defaultParams;
node = Teuchos::rcp (new NT (defaultParams));
}
// if (myRank == 0) {
// std::cout << "type '0' and hit enter" << std::endl;
// int zero;
// cin >> zero;
// }
// comm->barrier();
// Tpetra::Map requires that the index base is less than the minimum GID.
const GO indexBase = 0L;
out << "Constructing the Map" << endl;
RCP<const map_type> map;
try {
TEUCHOS_FUNC_TIME_MONITOR("Construct Map");
map = Teuchos::rcp (new map_type (globalNumElts, myGids (), indexBase, comm, node));
}
catch (std::exception& e) {
locallyThrew = 1;
std::ostringstream os;
os << "Proc " << myRank << ": At Map creation, locally threw exception: "
<< e.what () << endl;
cerr << os.str ();
}
globallyThrew = 0;
reduceAll<int, int> (*comm, REDUCE_MAX, locallyThrew, outArg (globallyThrew));
TEST_EQUALITY_CONST( globallyThrew, 0 );
cerr << myRank << ": Querying the Map for local elements" << endl;
{
TEUCHOS_FUNC_TIME_MONITOR("Querying the Map for local elements");
ArrayView<const GO> myGidsFound = map->getNodeElementList ();
TEST_COMPARE_ARRAYS( myGidsExpected (), myGidsFound () );
}
cerr << myRank << ": Querying the Map for remote elements" << endl;
// Proc 0 gets [0, 3B, 3B+2, 3B+4, 3B+8, 3B+10] (6 GIDs).
// Proc 1 gets [3B+12, 3B+14, 3B+16, 3B+18, 3B+20] (5 GIDs).
{
TEUCHOS_FUNC_TIME_MONITOR("Querying the Map for remote elements");
const int numRemoteGids = (myRank == 0) ? 5 : 6;
Array<GO> remoteGids (numRemoteGids);
Array<int> remotePids (numRemoteGids, -1);
Array<LO> remoteLids (numRemoteGids, Teuchos::OrdinalTraits<LO>::invalid ());
if (myRank == 0) {
try {
Array<int> expectedRemotePids (numRemoteGids);
std::fill (expectedRemotePids.begin (), expectedRemotePids.end (), 1);
Array<int> expectedRemoteLids (numRemoteGids);
expectedRemoteLids[0] = 0;
expectedRemoteLids[1] = 1;
expectedRemoteLids[2] = 2;
expectedRemoteLids[3] = 3;
expectedRemoteLids[4] = 4;
remoteGids[0] = threeBillion + 12;
remoteGids[1] = threeBillion + 14;
remoteGids[2] = threeBillion + 16;
remoteGids[3] = threeBillion + 18;
remoteGids[4] = threeBillion + 20;
comm->barrier ();
cerr << myRank << ": Calling getRemoteIndexList" << endl;
comm->barrier ();
map->getRemoteIndexList (remoteGids (), remotePids (), remoteLids ());
TEST_COMPARE_ARRAYS( remotePids (), expectedRemotePids () );
TEST_COMPARE_ARRAYS( remoteLids (), expectedRemoteLids () );
}
catch (std::exception& e) {
locallyThrew = 1;
std::ostringstream os;
os << "Proc " << myRank << ": getRemoteIndexList locally threw "
"exception: " << e.what () << endl;
cerr << os.str ();
}
}
else if (myRank == 1) {
try {
Array<int> expectedRemotePids (numRemoteGids);
std::fill (expectedRemotePids.begin (), expectedRemotePids.end (), 0);
Array<int> expectedRemoteLids (numRemoteGids);
expectedRemoteLids[0] = 0;
expectedRemoteLids[1] = 1;
expectedRemoteLids[2] = 2;
expectedRemoteLids[3] = 3;
expectedRemoteLids[4] = 4;
expectedRemoteLids[5] = 5;
remoteGids[0] = 0;
remoteGids[1] = threeBillion;
remoteGids[2] = threeBillion + 2;
remoteGids[3] = threeBillion + 4;
remoteGids[4] = threeBillion + 8;
remoteGids[5] = threeBillion + 10;
comm->barrier ();
cerr << myRank << ": Calling getRemoteIndexList" << endl;
comm->barrier ();
map->getRemoteIndexList (remoteGids (), remotePids (), remoteLids ());
TEST_COMPARE_ARRAYS( remotePids (), expectedRemotePids () );
TEST_COMPARE_ARRAYS( remoteLids (), expectedRemoteLids () );
}
catch (std::exception& e) {
locallyThrew = 1;
std::ostringstream os;
os << "Proc " << myRank << ": getRemoteIndexList locally threw "
"exception: " << e.what () << endl;
cerr << os.str ();
}
}
reduceAll<int, int> (*comm, REDUCE_MAX, locallyThrew, outArg (globallyThrew));
TEST_EQUALITY_CONST( globallyThrew, 0 );
}
cout << endl; // make TimeMonitor output neat on test line
Teuchos::TimeMonitor::summarize();
}
void operator()(SV **&sp, Array &result) {
EXTEND(sp, result.length());
for (ArrayIterator it = result.begin(); it != result.end(); ++it) {
PUSHs(*it);
}
}
int main() {
plan(65);
Interpreter universe;
Array array = universe.list();
is(array.length(), 0u, "array.length() == 0");
array.push(1);
note("array.push(1)");
is(array[0], 1, "array[0] == 1");
is(array[0], "1", "array[0] == \"1\"");
++array[0];
note("++array[0]");
is(array[0], 2, "array[0] == 1");
is(array[0], "2", "array[0] == \"1\"");
note("array.push(UV_MAX)");
array.push(UV_MAX);
is(array[1], UV_MAX, "array[1] == UV_MAX");
ok(array[1] > static_cast<UV>(IV_MAX), "array[1] > (unsigned)IV_MAX");
is(array[1], -1, "array[1] == -1");
array.push(NV_MAX);
note("array.push(NV_MAX)");
is(array[2], NV_MAX, "array[2] == NV_MAX");
array.push("test");
note("array.push(\"test\")");
is(array[3], "test", "array[3] == \"test\"");
array.push(Raw_string("test"));
note("array.push(Raw_string(\"test\"))");
is(array[4], "test", "array[4] == \"test\"");
array.push(universe.value_of(1));
note("array.push(universe.value_of(1))");
is(array[5], 1, "array[4] == 1");
array.clear();
note("array.clear()");
is(array.length(), 0u, "array.length() == 0");
array.push(1, UV_MAX, NV_MAX, "test", universe.undef());
note("array.push(1, UV_MAX, NV_MAX, \"test\")");
is(array[0], 1, "array[0] == 1");
is(array[1], UV_MAX, "array[1] == UV_MAX");
is(array[2], NV_MAX, "array[2] == NV_MAX");
is(array[3], "test", "array[3] == \"test\"");
ok(array.exists(4), "exists array[4]");
ok(!array[4].defined(), "not: defined array[4]");
array.push(array);
note("array.push(array)");
is(array[5], 1, "array[5] == 1");
is(array[6], UV_MAX, "array[6] == UV_MAX");
is(array[7], NV_MAX, "array[7] == NV_MAX");
is(array[8], "test", "array[8] == \"test\"");
ok(array.exists(9), "exists array[9]");
ok(!array[9].defined(), "not: defined array[9]");
array.clear();
array.unshift("test");
array.unshift(NV_MAX);
array.unshift(UV_MAX);
array.unshift(1);
note("array.unshift(1, UV_MAX, NV_MAX, \"test\")");
is(array[0], 1, "array[0] == 1");
is(array[1], UV_MAX, "array[1] == UV_MAX");
is(array[2], NV_MAX, "array[2] == NV_MAX");
is(array[3], "test", "array[3] == \"test\"");
ok(array.exists(3), "exists array[3]");
String string = array.remove(3);
note("string = array.remove(3)");
ok(string.length(), "string.length()");
ok(!array.exists(3), "not: exists array[3]");
is(array.length(), 3u, "array.length() == 3");
array.length() = 2;
note("array.length() = 2");
ok(!array.exists(2), "not: exists array[2]");
is(array.length(), 2u, "array.length() == 2");
array.extend(4);
note("array.extend(4)");
is(array.length(), 2u, "array.length == 2");
Array numbers = universe.list(1, 2, 3, 4);
Array squares = numbers.map( [](IV x) { return x * x; } );
for (int i = 0; i < 4; ++i) {
std::string num = boost::lexical_cast<std::string>(i);
is(squares[i], (IV)(numbers[i]) * numbers[i], std::string("squares[") + num + "] is numbers[" + num + "] ** 2");
}
Array big = squares.grep([](IV x){ return x > 8; });
note("Array big = squares.grep($_ > 8)");
is(big.length(), 2u, "big.length == 2");
is(big[0], 9, "big[0] == 9");
Array doubles = numbers.map([] (IV x) { return x * 2; } );
is(doubles[3], 8, "numbers.map(_1 * 2)[3] == 8");
IV sum = squares.reduce([] (IV left, IV right) { return left + right;}, 0);
note("sum = squares.reduce(_1 + _2, 0u)");
is(sum, 30, "sum == 30");
big.each([] (Scalar::Value& x) { x *= 2; });
note("big.each(_1 *= 2)");
is(big[0], 18, "big[0] == 18");
const Array forties = universe.list(46, 47, 48, 49);
pass(); //XXX
std::for_each(forties.begin(), forties.end(), [](IV x) { is(TAP::encountered(), x, "encountered == 4x");} );
ok(forties.any([](IV x) { return x == 48; }), "forties.any(_1 == 48)");
ok(forties.all([](IV x) { return x > 45; }), "forties.all(_1 > 45)");
ok(forties.none([](IV x) { return x == 30; }), "forties.none(_1 == 30)");
ok(forties.notall([](IV x) { return x < 48; }), "forties.notall(_1 < 48");
is_convertible<Ref<Array>, Ref<Any> >("Ref<Array> is convertible into a Ref<Any>");
is_inconvertible<Ref<Any>, Ref<Array> >("Ref<Any> is not convertible into a Ref<Array>");//XXX
is_convertible<Scalar::Temp, Ref<Array> >("Ref<Array> is convertible into a Ref<Any>");
is_inconvertible<Ref<Array>, Ref<Hash> >("Ref<Array> is not convertible into a Ref<Hash>");
Ref<Array> ref = forties.take_ref();
is(ref[0], 46, "ref[0] == 46");
Array fifties = *ref;
note("++ref[0]");
++ref[0];
is(ref[0], 47, "ref[0] == 47");
is(forties[0], 47, "forties[0] == 47");
is(fifties[0], 46, "fiftes[0] == 46");
*ref = fifties;
note("*ref = fifties");
is(ref[0], 46, "ref[0] == 46");
is(forties[0], 46, "forties[0] == 46");
Ref<Any> last = ref;
ok(true, "Ref<Any> last = ref");
return exit_status();
}
void HMM::em_loop(Perplexity& perp, SentenceHandler& sHandler1,
bool dump_alignment, const char* alignfile, Perplexity& viterbi_perp,
bool test,bool doInit,int) {
WordIndex i, j, l, m;
double cross_entropy;
int pair_no=0;
perp.clear();
viterbi_perp.clear();
ofstream of2;
// for each sentence pair in the corpus
if (dump_alignment||FEWDUMPS)
of2.open(alignfile);
SentencePair sent;
sHandler1.rewind();
while (sHandler1.getNextSentence(sent)) {
const Vector<WordIndex>& es = sent.get_eSent();
const Vector<WordIndex>& fs = sent.get_fSent();
const float so = sent.getCount();
l = es.size() - 1;
m = fs.size() - 1;
cross_entropy = log(1.0);
Vector<WordIndex> viterbi_alignment(fs.size());
unsigned int I=2*l,J=m;
bool DependencyOfJ=(CompareAlDeps&(16|8))||(g_prediction_in_alignments==2);
bool DependencyOfPrevAJ=(CompareAlDeps&(2|4))||(g_prediction_in_alignments==0);
HMMNetwork *net= makeHMMNetwork(es,fs,doInit);
Array<double> gamma;
Array<Array2<double> > epsilon(DependencyOfJ?(m-1):1);
double trainProb;
trainProb=ForwardBackwardTraining(*net,gamma,epsilon);
if (!test)
{
double *gp=conv<double>(gamma.begin());
for (unsigned int i2=0;i2<J;i2++)for (unsigned int i1=0;i1<I;++i1,++gp)
if (*gp>MINCOUNTINCREASE)
{
COUNT add= *gp*so;
if (i1>=l)
{
tTable.incCount(es[0],fs[1+i2],add);
aCountTable.getRef(0,i2+1,l,m)+=add;
}
else
{
tTable.incCount(es[1+i1],fs[1+i2],add);
aCountTable.getRef(1+i1,1+i2,l,m)+=add;
}
}
double p0c=0.0,np0c=0.0;
for (unsigned int jj=0;jj<epsilon.size();jj++)
{
int frenchClass=fwordclasses.getClass(fs[1+min(int(m)-1,int(jj)+1)]);
double *ep=epsilon[jj].begin();
if (ep)
{
//for (i=0;i<I;i++)
// normalize_if_possible_with_increment(ep+i,ep+i+I*I,I);
// for (i=0;i<I*I;++i)
// ep[i] *= I;
//if (DependencyOfJ)
// if (J-1)
// for (i=0;i<I*I;++i)
// ep[i] /= (J-1);
double mult=1.0;
mult*=l;
//if (DependencyOfJ && J-1)
// mult/=(J-1);
for (i=0;i<I;i++)
{
for (unsigned int i_bef=0;i_bef<I;i_bef++,ep++)
{
CLASSIFY(i,i_empty,ireal);
CLASSIFY2(i_bef,i_befreal);
if (i_empty)
p0c+=*ep * mult;
else
{
counts.addAlCount(i_befreal,ireal,l,m,ewordclasses.getClass(es[1+i_befreal]),
frenchClass ,jj+1,*ep * mult,0.0);
np0c+=*ep * mult;
}
MASSERT( &epsilon[jj](i,i_bef)== ep);
}
}
}
}
double *gp1=conv<double>(gamma.begin()),*gp2=conv<double>(gamma.end())-I;
Array<double>&ai=counts.doGetAlphaInit(I);
Array<double>&bi=counts.doGetBetaInit(I);
int firstFrenchClass=(fs.size()>1)?(fwordclasses.getClass(fs[1+0])):0;
for (i=0;i<I;i++,gp1++,gp2++)
{
CLASSIFY(i,i_empty,ireal);
ai[i]+= *gp1;
bi[i]+= *gp2;
if (DependencyOfPrevAJ==0)
{
if (i_empty)
p0c+=*gp1;
else
{
counts.addAlCount(-1,ireal,l,m,0,firstFrenchClass,0,*gp1,0.0);
np0c+=*gp1;
}
}
}
if (g_is_verbose)
cout << "l: " << l << "m: " << m << " p0c: " << p0c << " np0c: " << np0c << endl;
}
cross_entropy+=log(max(trainProb,1e-100))+log(max(net->finalMultiply,1e-100));
Array<int>vit;
double viterbi_score=1.0;
if ((g_hmm_training_special_flags&1))
HMMViterbi(*net,gamma,vit);
else
viterbi_score=HMMRealViterbi(*net,vit);
for (j=1;j<=m;j++)
{
viterbi_alignment[j]=vit[j-1]+1;
if (viterbi_alignment[j]>l)
viterbi_alignment[j]=0;
}
sHandler1.setProbOfSentence(sent,cross_entropy);
perp.addFactor(cross_entropy, so, l, m,1);
viterbi_perp.addFactor(log(viterbi_score)+log(max(net->finalMultiply,1e-100)), so, l, m,1);
if (g_is_verbose) {
cout << "Viterbi-perp: " << log(viterbi_score) << ' '
<< log(max(net->finalMultiply,1e-100)) << ' '
<< viterbi_score << ' ' << net->finalMultiply
<< ' ' << *net << "gamma: " << gamma << endl;
}
// TODO: Use more safe resource management like RAII.
delete net;
net = 0;
if (dump_alignment||(FEWDUMPS&&sent.getSentenceNo()<1000))
printAlignToFile(es, fs, Elist.getVocabList(), Flist.getVocabList(), of2, viterbi_alignment, sent.getSentenceNo(), viterbi_score);
addAL(viterbi_alignment,sent.getSentenceNo(),l);
pair_no++;
} /* of while */
sHandler1.rewind();
perp.record("HMM");
viterbi_perp.record("HMM");
errorReportAL(cout,"HMM");
}
gcc_pure
const_iterator end() const {
return data.end();
}
inline void Array::copy(const Array& from) {
std::copy(from.begin(),from.end(),begin());
}
ElfLoader::DebuggerHelper::DebuggerHelper(): dbg(nullptr), firstAdded(nullptr)
{
/* Find ELF auxiliary vectors.
*
* The kernel stores the following data on the stack when starting a
* program:
* argc
* argv[0] (pointer into argv strings defined below)
* argv[1] (likewise)
* ...
* argv[argc - 1] (likewise)
* nullptr
* envp[0] (pointer into environment strings defined below)
* envp[1] (likewise)
* ...
* envp[n] (likewise)
* nullptr
* ... (more NULLs on some platforms such as Android 4.3)
* auxv[0] (first ELF auxiliary vector)
* auxv[1] (second ELF auxiliary vector)
* ...
* auxv[p] (last ELF auxiliary vector)
* (AT_NULL, nullptr)
* padding
* argv strings, separated with '\0'
* environment strings, separated with '\0'
* nullptr
*
* What we are after are the auxv values defined by the following struct.
*/
struct AuxVector {
Elf::Addr type;
Elf::Addr value;
};
/* Pointer to the environment variables list */
extern char **environ;
/* The environment may have changed since the program started, in which
* case the environ variables list isn't the list the kernel put on stack
* anymore. But in this new list, variables that didn't change still point
* to the strings the kernel put on stack. It is quite unlikely that two
* modified environment variables point to two consecutive strings in memory,
* so we assume that if two consecutive environment variables point to two
* consecutive strings, we found strings the kernel put on stack. */
char **env;
for (env = environ; *env; env++)
if (*env + strlen(*env) + 1 == env[1])
break;
if (!*env)
return;
/* Next, we scan the stack backwards to find a pointer to one of those
* strings we found above, which will give us the location of the original
* envp list. As we are looking for pointers, we need to look at 32-bits or
* 64-bits aligned values, depening on the architecture. */
char **scan = reinterpret_cast<char **>(
reinterpret_cast<uintptr_t>(*env) & ~(sizeof(void *) - 1));
while (*env != *scan)
scan--;
/* Finally, scan forward to find the last environment variable pointer and
* thus the first auxiliary vector. */
while (*scan++);
/* Some platforms have more NULLs here, so skip them if we encounter them */
while (!*scan)
scan++;
AuxVector *auxv = reinterpret_cast<AuxVector *>(scan);
/* The two values of interest in the auxiliary vectors are AT_PHDR and
* AT_PHNUM, which gives us the the location and size of the ELF program
* headers. */
Array<Elf::Phdr> phdrs;
char *base = nullptr;
while (auxv->type) {
if (auxv->type == AT_PHDR) {
phdrs.Init(reinterpret_cast<Elf::Phdr*>(auxv->value));
/* Assume the base address is the first byte of the same page */
base = reinterpret_cast<char *>(PageAlignedPtr(auxv->value));
}
if (auxv->type == AT_PHNUM)
phdrs.Init(auxv->value);
auxv++;
}
if (!phdrs) {
DEBUG_LOG("Couldn't find program headers");
return;
}
/* In some cases, the address for the program headers we get from the
* auxiliary vectors is not mapped, because of the PT_LOAD segments
* definitions in the program executable. Trying to map anonymous memory
* with a hint giving the base address will return a different address
* if something is mapped there, and the base address otherwise. */
MappedPtr mem(MemoryRange::mmap(base, PageSize(), PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
if (mem == base) {
/* If program headers aren't mapped, try to map them */
int fd = open("/proc/self/exe", O_RDONLY);
if (fd == -1) {
DEBUG_LOG("Failed to open /proc/self/exe");
return;
}
mem.Assign(MemoryRange::mmap(base, PageSize(), PROT_READ, MAP_PRIVATE,
fd, 0));
/* If we don't manage to map at the right address, just give up. */
if (mem != base) {
DEBUG_LOG("Couldn't read program headers");
return;
}
}
/* Sanity check: the first bytes at the base address should be an ELF
* header. */
if (!Elf::Ehdr::validate(base)) {
DEBUG_LOG("Couldn't find program base");
return;
}
/* Search for the program PT_DYNAMIC segment */
Array<Elf::Dyn> dyns;
for (Array<Elf::Phdr>::iterator phdr = phdrs.begin(); phdr < phdrs.end();
++phdr) {
/* While the program headers are expected within the first mapped page of
* the program executable, the executable PT_LOADs may actually make them
* loaded at an address that is not the wanted base address of the
* library. We thus need to adjust the base address, compensating for the
* virtual address of the PT_LOAD segment corresponding to offset 0. */
if (phdr->p_type == PT_LOAD && phdr->p_offset == 0)
base -= phdr->p_vaddr;
if (phdr->p_type == PT_DYNAMIC)
dyns.Init(base + phdr->p_vaddr, phdr->p_filesz);
}
if (!dyns) {
DEBUG_LOG("Failed to find PT_DYNAMIC section in program");
return;
}
/* Search for the DT_DEBUG information */
for (Array<Elf::Dyn>::iterator dyn = dyns.begin(); dyn < dyns.end(); ++dyn) {
if (dyn->d_tag == DT_DEBUG) {
dbg = reinterpret_cast<r_debug *>(dyn->d_un.d_ptr);
break;
}
}
DEBUG_LOG("DT_DEBUG points at %p", static_cast<void *>(dbg));
}
inline Disposable<Array> operator-(const Array& v) {
Array result(v.size());
std::transform(v.begin(),v.end(),result.begin(),
std::negate<double>());
return result;
}
void ModelContainerView::onGraphics(RenderDevice* rd, Array<PosedModelRef> &posed3D, Array<PosedModel2DRef> &posed2D) {
Array<PosedModel::Ref> opaque, transparent;
LightingRef localLighting = toneMap->prepareLighting(iLighting);
SkyParameters localSky = toneMap->prepareSkyParameters(iSkyParameters);
toneMap->beginFrame(rd);
rd->setProjectionAndCameraMatrix(defaultCamera);
rd->setColorClearValue(Color3::black());
rd->clear();
//iSky->render(rd, localSky);
// Setup lighting
rd->enableLighting();
//rd->setLight(0, localLighting->lightArray[0]);
//rd->setAmbientLightColor(localLighting->ambientAverage());
GLight light =GLight::directional(defaultController.pointer()->position() + defaultController.pointer()->lookVector()*2,Color3::white());
rd->setLight(0,light);
rd->setColor(Color3::blue());
Array<std::string > keys = iTriVarTable.getKeys();
Array<std::string>::ConstIterator i = keys.begin();
while(i != keys.end()) {
VAR* var = iTriVarTable.get(*i);
Array<int> indexArray = iTriIndexTable.get(*i);
rd->beginIndexedPrimitives();
rd->setVertexArray(*var);
rd->sendIndices(RenderDevice::LINES, indexArray);
rd->endIndexedPrimitives();
++i;
}
for(int i=0; i<gBoxArray.size(); ++i) {
AABox b = gBoxArray[i];
Draw::box(b,rd,Color4(Color3::red(),0.9f));
}
//-------
//triangles
{
if(iTriDebugArray.size() > 0)
{
rd->setColor(Color3::red());
rd->beginIndexedPrimitives();
rd->setVertexArray(iTriDebugVar);
rd->sendIndices(RenderDevice::LINES, iTriDebugArray);
rd->endIndexedPrimitives();
}
}
//--------
if(iDrawLine) {
Draw::lineSegment(LineSegment::fromTwoPoints(iPos1, iPos2), rd, iColor, 3);
if(myfound) {
//Draw::lineSegment(LineSegment::fromTwoPoints(p1, p2), rd, iColor, 3);
//Draw::lineSegment(LineSegment::fromTwoPoints(p2, p3), rd, iColor, 3);
//Draw::lineSegment(LineSegment::fromTwoPoints(p3, p1), rd, iColor, 3);
Draw::sphere(Sphere(p4,0.5),rd, iColor);
//Draw::sphere(Sphere(p5,0.5),rd, Color3::green());
}
}
// Always render the posed models passed in or the Developer Window and
// other Widget features will not appear.
if (posed3D.size() > 0) {
Vector3 lookVector = renderDevice->getCameraToWorldMatrix().lookVector();
PosedModel::sort(posed3D, lookVector, opaque, transparent);
for (int i = 0; i < opaque.size(); ++i) {
opaque[i]->render(renderDevice);
}
for (int i = 0; i < transparent.size(); ++i) {
transparent[i]->render(renderDevice);
}
}
rd->disableLighting();
toneMap->endFrame(rd);
PosedModel2D::sortAndRender(rd, posed2D);
}
