std::string formatSuperAndSubscripts(const std::string& str, DocumentFormat fmt) {
if (fmt == DocumentFormat::LaTeX) {
std::string wStr(str);
wStr = boost::regex_replace(wStr, superscript(), "$1\\\\ensuremath{$2}");
wStr = boost::regex_replace(wStr, subscript(), "$1\\\\ensuremath{$2}");
return wStr;
}
if (fmt == DocumentFormat::XHTML) {
std::string wStr(str);
wStr = boost::regex_replace(wStr, superscript(), "$1<sup>$3$4</sup>");
wStr = boost::regex_replace(wStr, subscript(), "$1<sub>$3$4</sub>");
wStr = boost::regex_replace(wStr, underscore(), "_");
return wStr;
}
return str;
}
//-----------------------------------------------------------------------
void DynLib::load()
{
// Log library load
LogManager::getSingleton().logMessage("Loading library " + mName);
String name = mName;
#if OGRE_PLATFORM == OGRE_PLATFORM_EMSCRIPTEN
if (name.find(".js") == String::npos)
name += ".js";
#elif OGRE_PLATFORM == OGRE_PLATFORM_LINUX || OGRE_PLATFORM == OGRE_PLATFORM_NACL
// dlopen() does not add .so to the filename, like windows does for .dll
if (name.find(".so") == String::npos)
{
name += ".so.";
name += StringConverter::toString(OGRE_VERSION_MAJOR) + ".";
name += StringConverter::toString(OGRE_VERSION_MINOR) + ".";
name += StringConverter::toString(OGRE_VERSION_PATCH);
}
#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
// dlopen() does not add .dylib to the filename, like windows does for .dll
if (name.substr(name.find_last_of(".") + 1) != "dylib")
name += ".dylib";
#elif OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT
// Although LoadLibraryEx will add .dll itself when you only specify the library name,
// if you include a relative path then it does not. So, add it to be sure.
if (name.substr(name.find_last_of(".") + 1) != "dll")
name += ".dll";
#endif
#ifdef _UNICODE
std::wstring wStr(name.begin(), name.end());
mInst = (DYNLIB_HANDLE)DYNLIB_LOAD(wStr.c_str());
#else
mInst = (DYNLIB_HANDLE)DYNLIB_LOAD(name.c_str());
#endif
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
if (!mInst)
{
// Try again as a framework
mInst = (DYNLIB_HANDLE)FRAMEWORK_LOAD(mName);
}
#endif
if (!mInst)
OGRE_EXCEPT(
Exception::ERR_INTERNAL_ERROR,
"Could not load dynamic library " + mName +
". System Error: " + dynlibError(),
"DynLib::load");
}
void SearchIndex::addWord(const char *word,bool hiPriority)
{
//printf("SearchIndex::addWord(%s,%d)\n",word,hiPriority);
//QString wStr=QString(word).lower();
QString wStr(word);
if (wStr.isEmpty()) return;
wStr=wStr.lower();
IndexWord *w = m_words[wStr];
if (w==0)
{
int idx=charsToIndex(wStr);
if (idx<0) return;
w = new IndexWord(wStr);
//fprintf(stderr,"addWord(%s) at index %d\n",word,idx);
m_index[idx]->append(w);
m_words.insert(wStr,w);
}
w->addUrlIndex(m_urlIndex,hiPriority);
}
void SearchIndex::addWord(const char *word,bool hiPriority,bool recurse)
{
static QRegExp nextPart("[_a-z:][A-Z]");
//printf("SearchIndex::addWord(%s,%d)\n",word,hiPriority);
QCString wStr(word);
if (wStr.isEmpty()) return;
wStr=wStr.lower();
IndexWord *w = m_words[wStr];
if (w==0)
{
int idx=charsToIndex(wStr);
if (idx<0) return;
w = new IndexWord(wStr);
//fprintf(stderr,"addWord(%s) at index %d\n",word,idx);
m_index[idx]->append(w);
m_words.insert(wStr,w);
}
w->addUrlIndex(m_urlIndex,hiPriority);
int i;
bool found=FALSE;
if (!recurse) // the first time we check if we can strip the prefix
{
i=getPrefixIndex(word);
if (i>0)
{
addWord(word+i,hiPriority,TRUE);
found=TRUE;
}
}
if (!found) // no prefix stripped
{
if ((i=nextPart.match(word))>=1)
{
addWord(word+i+1,hiPriority,TRUE);
}
}
}
std::string formatUnderscore(const std::string& str) {
std::string wStr(str);
wStr = boost::regex_replace(wStr, boost::regex("_"), "\\\\_");
return wStr;
}
std::wstring ConvertToWString(const std::string &str)
{
std::wstring wStr(str.begin(), str.end());
return wStr;
}
int main(const int argc, const char* argv[]) {
//parameters for the system bath and computations
const Index numBathModes(8); //(17);
const Power maxGrade(2);
const size_t numBitsPrecision(96);
const std::string systemType("system-bath");
//create context
const Index numDof(1 + numBathModes);
const ClassicalLieAlgebra algebra(numDof);
const DefaultNumericalPrecision prec(numBitsPrecision);
//report on context
std::cerr << "SystemBath\n";
std::cerr << "numBathModes : " << numBathModes << "\n";
std::cerr << "numDof : " << numDof << "\n";
std::cerr << "numVars : " << algebra.getNumVars() << "\n";
std::cerr << "maxGrade : " << maxGrade << "\n";
std::cerr << "numBitsPrecision: " << numBitsPrecision << "\n";
std::cerr << std::endl;
//create file names and prefixes
std::stringstream dofStr;
dofStr << numDof;
const std::string systemPrefix(systemType + "--dof-" + dofStr.str());
const std::string hFromEPrefix(systemPrefix + "--h-from-e");
const std::string eFromDFileName(systemPrefix + "--e-from-d.vpol");
const std::string eFromDCFileName(systemPrefix + "--e-from-dc.vpol");
const std::string rFromCFileName(systemPrefix + "--r-from-c.vpol");
const std::string hFromDCPrefix(systemPrefix + "--h-from-dc");
const std::string kFromNCPrefix(systemPrefix + "--k-from-nc");
const std::string wPrefix(systemPrefix + "--w");
//load diagonalisation polynomials
std::ifstream eFromDRStr(eFromDFileName.c_str());
assert(eFromDRStr.is_open());
std::vector< Polynomial > eFromDR;
seReadVectorOfPolynomials(eFromDRStr, eFromDR);
eFromDRStr.close();
//sanity check: correct number of polynomials
assert(eFromDR.size() == algebra.getNumVars());
//sanity check: for each polynomial
for (std::vector< Polynomial >::const_iterator iterPoly = eFromDR.begin();
iterPoly != eFromDR.end();
++iterPoly) {
//sanity check: all polynomials belong to the algebra
assert(algebra.hasElt(*iterPoly));
//sanity check: all polynomials are non-zero
assert(!(iterPoly->isZero()));
//sanity check: all polynomials are grade 1 only
assert(algebra.isIsoGrade(*iterPoly, 1));
//sanity check: polys have correct precision, regardless of input
if (iterPoly->getNumTerms() > 0) {
PowersToCoeffMap::const_iterator iterTerm;
iterTerm = iterPoly->getPowersAndCoeffs().begin();
assert(iterTerm != iterPoly->getPowersAndCoeffs().end());
assert((iterTerm->second).real().get_prec() >= numBitsPrecision);
assert((iterTerm->second).imag().get_prec() >= numBitsPrecision);
}
}
//--------------------------------------------------------------------
//
// temporary: zero constant term on taylor series (special)
//
//--------------------------------------------------------------------
std::ifstream hFromE0Str((hFromEPrefix + "--grade-0.pol").c_str());
assert(hFromE0Str.is_open());
const Polynomial hFromE0(seReadPolynomial(hFromE0Str));
hFromE0Str.close();
assert(algebra.hasElt(hFromE0));
assert(hFromE0.isZero());
//--------------------------------------------------------------------
//
// temporary: zero linear term on taylor series (special)
//
//--------------------------------------------------------------------
std::ifstream hFromE1Str((hFromEPrefix + "--grade-1.pol").c_str());
assert(hFromE1Str.is_open());
const Polynomial hFromE1(seReadPolynomial(hFromE1Str));
hFromE1Str.close();
assert(algebra.hasElt(hFromE1));
assert(hFromE1.isZero());
//--------------------------------------------------------------------
//
// temporary: deal with quadratic part (special)
//
//--------------------------------------------------------------------
std::ifstream hFromE2Str((hFromEPrefix + "--grade-2.pol").c_str());
assert(hFromE2Str.is_open());
const Polynomial hFromE2(seReadPolynomial(hFromE2Str));
hFromE2Str.close();
assert(algebra.hasElt(hFromE2));
assert(!(hFromE2.isZero()));
assert(algebra.isIsoGrade(hFromE2, 2));
std::cerr << hFromE2 << std::endl;
//--------------------------------------------------------------------
//
// NOTE: Because the complexification involves sqrt(2), it would be
// better to import the equilibrium type and compute the maps here!
//
//--------------------------------------------------------------------
//for now, we import the complexification maps
std::cerr << "WARNING! for now, we use double precision complexifiers";
std::cerr << std::endl;
//
std::ifstream rFromCStr(rFromCFileName.c_str());
assert(rFromCStr.is_open());
std::vector< Polynomial > rFromC;
seReadVectorOfPolynomials(rFromCStr, rFromC);
rFromCStr.close();
assert(rFromC.size() == algebra.getNumVars());
for (std::vector< Polynomial >::const_iterator iterPoly = rFromC.begin();
iterPoly != rFromC.end();
++iterPoly) {
assert(algebra.hasElt(*iterPoly));
assert(!(iterPoly->isZero()));
assert(algebra.isIsoGrade(*iterPoly, 1));
}
//--------------------------------------------------------------------
//
// compose the complexification with the real-diagonal transform
//
//--------------------------------------------------------------------
std::cerr << "Composing the real-diagonal transformation with complex...";
std::cerr << std::endl;
//
std::vector< Polynomial > eFromDC;
for (std::vector< Polynomial >::const_iterator iterEFromDR = eFromDR.begin();
iterEFromDR != eFromDR.end();
++iterEFromDR) {
eFromDC.push_back((*iterEFromDR)(rFromC));
}
assert(eFromDC.size() == algebra.getNumVars());
std::cerr << "Writing E from DC..." << std::endl;
std::ofstream eFromDCStr(eFromDCFileName.c_str());
seWriteVectorOfPolynomials(eFromDCStr, eFromDC);
//--------------------------------------------------------------------
//
// back to dealing with the quadratic part (special)
//
//--------------------------------------------------------------------
//real-diagonalise the term by applying the transformation
std::cerr << "Diagonalising the quadratic term..." << std::endl;
const Polynomial hFromDC2(hFromE2(eFromDC));
assert(algebra.isIsoGrade(hFromDC2, 2));
//remove off-diagonal part and confirm complex diagonal form
std::pair< Polynomial, Polynomial > dAndN(algebra.zero(), algebra.zero());
algebra.diagonalAndNonDiagonal(hFromDC2, dAndN);
assert(algebra.isDiagonal(dAndN.first));
std::cerr << dAndN.first << std::endl;
std::cerr << "Infinity norm of off-diagonal complex part: ";
std::cerr << (dAndN.second.lInfinityNorm()) << std::endl;
const Polynomial& hFromDC2Diagonal(dAndN.first);
//--------------------------------------------------------------------
//
// Setup the Deprit triangle
//
// NOTE:
//
// The terms that the method computeNormalFormAndGenerator produces
// are all _OUTER_ terms. That is, they have been properly
// factorially-weighted for direct addition to the resulting
// polynomial. This is in contrast to the _INNER_ terms K_{i} and
// W_{i}, which are the terms inside the Deprit triangle. Such
// inner terms cannot be summed directly over i to make a
// polynomial; they are solely for use in the Deprit triangle
// algorithm. Hori's method would avoid such technicalities.
//
//--------------------------------------------------------------------
DepritTriangle normalisationTriangle(algebra, hFromDC2Diagonal);
// we want to keep the computation in pipeline form as much as
// possible. for now, we use a loop here. ultimately, these parts
// will reside on separate processors with communication?
for (Power row = 0; row < ((maxGrade - 2) + 1); ++row) {
//currentGrade is previous level of computation, we must add one!
const Power thisGrade(normalisationTriangle.getCurrentGrade() + 1);
//create placeholder terms
Polynomial zero(algebra.zero());
Polynomial kTerm(algebra.zero());
Polynomial wTerm(algebra.zero());
//encode the grade as a string for use in file names
std::stringstream gradeName;
gradeName << thisGrade;
//handle the quadratic part specially; we diagonalised it already
if (row == 0) {
//file output
std::cerr << "Writing H from DC..." << std::endl;
const std::string hName(hFromDCPrefix+"--grade-"+gradeName.str()+".pol");
std::ofstream hFromDCStr(hName.c_str());
seWritePolynomial(hFromDCStr, hFromDC2Diagonal);
hFromDCStr.close();
//normalisation
normalisationTriangle.computeNormalFormAndGenerator(hFromDC2Diagonal, kTerm, wTerm);
//file output
std::cerr << "Writing K from NC..." << std::endl;
const std::string kName(kFromNCPrefix+"--grade-"+gradeName.str()+".pol");
std::ofstream kFromNCStr(kName.c_str());
seWritePolynomial(kFromNCStr, kTerm);
kFromNCStr.close();
}
else {
for (int m = 0; m < 72; ++m)
std::cerr << "=";
std::cerr << std::endl;
std::cerr << "Diagonalising input terms..." << std::endl;
//diagonalisation
const std::string fName(hFromEPrefix+"--grade-"+gradeName.str()+".pol");
std::ifstream hFromEGStr(fName.c_str());
assert(hFromEGStr.is_open());
const Polynomial hFromEG(seReadPolynomial(hFromEGStr));
hFromEGStr.close();
assert(algebra.hasElt(hFromEG));
assert(algebra.isIsoGrade(hFromEG, thisGrade));
std::cerr << "Terms: " << hFromEG.getNumTerms() << std::endl;
const Polynomial hFromDCG(hFromEG(eFromDC));
std::cerr << "DiagTerms: " << hFromDCG.getNumTerms() << std::endl;
//file output
std::cerr << "Writing H from DC..." << std::endl;
const std::string hName(hFromDCPrefix+"--grade-"+gradeName.str()+".pol");
std::ofstream hFromDCStr(hName.c_str());
seWritePolynomial(hFromDCStr, hFromDCG);
hFromDCStr.close();
//normalisation
normalisationTriangle.computeNormalFormAndGenerator(hFromDCG, kTerm, wTerm);
//file output
std::cerr << "Writing K from NC..." << std::endl;
const std::string kName(kFromNCPrefix+"--grade-"+gradeName.str()+".pol");
std::ofstream kFromNCStr(kName.c_str());
seWritePolynomial(kFromNCStr, kTerm);
kFromNCStr.close();
}
//file output
std::cerr << "Writing W..." << std::endl;
std::stringstream rowStr;
rowStr << row;
const std::string wName(wPrefix+"--inner-"+rowStr.str()+".pol");
std::ofstream wStr(wName.c_str());
const Polynomial& wI(normalisationTriangle.getInnerGeneratorTerms().at(row));
seWritePolynomial(wStr, wI);
wStr.close();
}
//--------------------------------------------------------------------
//
// When memory is a problem, we need to look at:-
//
// [-2] extending vector< Polynomial >, for example, creates a copy
// of the whole structure each time. therefore, in the generator
// (and probably elsewhere), one should either pre-allocate with
// dummy values (but then take care with size()) or, better, use
// a different structure such as ::list. Read on the STL types
// to determine the best course of action.
//
// [-1] recursion will be using the stack. remove usage or ensure no
// non-reference statics within each stack context.
//
// [00] use equilibrium type to build C++ complexifier maps;
// this will remove some spurious extra terms.
//
// [01] more pass-by-reference for results;
// avoids temp copying.
//
// [02] provide a Polynomial::truncateSmallCoeffs(tolerance) method.
// truncation of small terms,
// avoids rounding issues (not so important with GMP).
//
// [03] store the Deprit triangle elements on disk and only read them
// at the point where they are needed. since poisson brackets
// are the time-consuming thing, the read/write reconstruction is
// most likely not significant overhead.
//
// [04] improve polynomial operations, especially poisson bracket,
// replacing them with dedicated reference-result based versions,
// especially avoiding the creation of temporary variables, and
// avoiding copying in the delivery of results.
//
// [05] reduce GMP precision (at first, it was 256; 96 seems okay),
// chiefly for speed, although there will be memory impact.
//
// [06] pass smart pointers (not so important?),
// avoids unnecessary copies.
//
// [07] make a system bath with less bath modes! (want this anyway),
// starts with a smaller system to begin with; binomial coeffs!
//
// [08] do the diagonalisation computation here (using NR< GMP >),
// to get maximum accuracy and hence avoid spurious terms.
//
// [09] change the power and index type to char (but this leads to
// read/write and range complexities).
//
// [10] move to a polynomial representation as a map from single
// integer to coefficient, where the integer is an index into
// a monomial basis table. The possible problem here is that
// one would need an efficient two-way mapping.
//
// Consider buying the following references:-
//
// [a] Large-scale C++ software design, Lakos.
//
// [b] Modern C++ design, Alexandrescu. (I already have this.)
//
//--------------------------------------------------------------------
//finish cleanly
return EXIT_SUCCESS;
}
