int main()
{
double rate = 0.0;
double vol = 0.1;
int N = 3;
int M = 1;
int b = 700;
double maturity = 1.0;
double initialSpot = 100.0;
double timeStep = (maturity / (double)N);
double m = timeStep*(rate - vol*vol / 2.0);
//std::ofstream fichier("C:\\Users\\Lucien\\Desktop\\e.txt", std::ios::out | std::ios::trunc);
for (int i = 0; i < 40; i++)
{
double initialSpots[1]{80 + (double)i};
//False ditribution in the estimator
lognormal f(m, vol*sqrt(timeStep));
lognormal g(0.0, 5.0*vol);
normalGen gGenerator(ENG(time(0)), normalDist(0.0, 5.0*vol));
RandomGenerationTool kit(f, gGenerator, g);
BlackScholesPathGenerator paths(rate, vol, N, b, M, maturity, kit);
BlackScholesRate rates(N, maturity, rate);
AmericanPutPayoff payoff(100.0, maturity, N, b, M);
Estimator estimator(paths, payoff, rates);
std::cout << estimator.computePrice(initialSpots) << std::endl;
}
//fichier.close();
system("pause");
}
void symbolConverter::stationsToRUS()
{
QString ENG("ABCEHKMOPTX");
QString RUS("АВСЕНКМОРТХ");
QString src;//читаем с файла
QString dest;
QSqlQuery queryRead(QSqlDatabase::database());
queryRead.exec("SELECT pn, sk FROM stations");
qDebug() << "Number of rows: " << queryRead.numRowsAffected();
while(queryRead.next()) {
src = queryRead.value(0).toString();
while(!src.isEmpty()) {
dest += convertChar(src[0]);
src.remove(0, 1);
}
dest = dest.toUtf8();
//записываем dest в БД
QSqlQuery queryWrite(QSqlDatabase::database());
QString strQueryWrite = QString("UPDATE stations SET pn = \'") + dest + QString("\' WHERE sk = \'") + queryRead.value(1).toString() + QString("\'");
queryWrite.exec(strQueryWrite);
dest = "";
}
qDebug() << "src = " << src;
qDebug() << "dest = " << dest;
}
// [[Rcpp::export]]
DataFrame random_impl(DataFrame genome, int length, int n, int seed = 0) {
CharacterVector chroms = genome["chrom"] ;
NumericVector sizes = genome["size"] ;
int nchrom = chroms.size() ;
if (seed == 0)
seed = round(R::runif(0, RAND_MAX)) ;
// seed the generator
auto generator = ENG(seed) ;
// calculate weights for chrom distribution
float mass = sum(sizes) ;
NumericVector weights = sizes / mass ;
Range chromidx(0, nchrom) ;
PDIST chrom_dist(chromidx.begin(), chromidx.end(), weights.begin()) ;
// make and store a DIST for each chrom size
std::vector< UDIST > size_rngs ;
for (int i=0; i<nchrom; ++i) {
auto size = sizes[i] ;
// sub length to avoid off-chrom coordinates
UDIST size_dist(1, size - length) ;
size_rngs.push_back(size_dist) ;
}
CharacterVector rand_chroms(n) ;
IntegerVector rand_starts(n) ;
for (int i=0; i<n; ++i) {
auto chrom_idx = chrom_dist(generator) ;
rand_chroms[i] = chroms[chrom_idx] ;
UDIST size_dist = size_rngs[chrom_idx] ;
auto rand_start = size_dist(generator) ;
rand_starts[i] = rand_start ;
}
IntegerVector rand_ends = rand_starts + length ;
return DataFrame::create( Named("chrom") = rand_chroms,
Named("start") = rand_starts,
Named("end") = rand_ends,
Named("stringsAsFactors") = false) ;
}
Request symbolConverter::requestToRUS(Request r)
{
QString ENG("ABCEHKMOPTX");
QString RUS("АВСЕНКМОРТХ");
QStringList OMList;
foreach (int OMi, r.OM) {
OMList.append(QString::number(OMi));
}
r.NA = symbolConverter::convertString(r.NA.toUtf8().toUpper().simplified());
r.SH = symbolConverter::convertString(r.SH.toUtf8().toUpper().simplified());
r.OT = symbolConverter::convertString(r.OT.toUtf8().toUpper().simplified());
r.PY = symbolConverter::convertString(r.PY.toUtf8().toUpper().simplified());
OMList = symbolConverter::convertString(OMList.join(',').toUtf8().toUpper().simplified()).split(',');
QList<int> OMIntList;
foreach (QString OMstr, OMList) {
OMIntList.append(OMstr.toInt());
}
//[[Rcpp::export]]
DataFrame shuffle_impl(DataFrame df, DataFrame incl, bool within = false,
int max_tries = 1000, int seed = 0) {
// seed for reproducible intervals
if (seed == 0) seed = round(R::runif(0, RAND_MAX)) ;
// seed the generator
auto generator = ENG(seed) ;
// data on incoming df
CharacterVector df_chroms = df["chrom"] ;
IntegerVector df_starts = df["start"] ;
IntegerVector df_ends = df["end"] ;
IntegerVector df_sizes = df_ends - df_starts ;
// RNG weighted by chromosome masses
auto chrom_rng = makeChromRNG(incl) ;
// map of chrom to intervals
auto interval_map = makeIntervalMap(incl) ;
// maps chroms to RNGs for interval index positions
auto interval_rngs = makeIntervalWeights(interval_map) ;
// maps chroms to RNGs for start dists
auto start_rngs = makeStartRNGs(interval_map) ;
// make a map of chrom to interval tree for each set of included intervals
auto interval_trees = makeIntervalTrees(incl, interval_map) ;
// storage for output
int nr = df.nrows() ;
CharacterVector chroms_out(nr) ;
IntegerVector starts_out(nr) ;
IntegerVector ends_out(nr) ;
CharacterVector incl_chroms = incl["chrom"] ;
// sort in lexographic order
CharacterVector chrom_names = unique(incl_chroms).sort() ;
for (int i = 0; i<nr; ++i) {
// select a chromosome
if (within) {
chroms_out[i] = df_chroms[i] ;
} else {
// pick a random chrom index.
int rand_idx = chrom_rng(generator) ;
chroms_out[i] = chrom_names[rand_idx] ;
}
// get tree from map
auto chrom = as<std::string>(chroms_out[i]) ;
auto chrom_tree = interval_trees[chrom] ;
bool inbounds = false ;
int niter = 0 ;
// get the interval rng
auto interval_rng = interval_rngs[chrom] ;
while (!inbounds) {
niter++ ;
if (niter > max_tries) {
// tried too many times to find an overlap, bail
stop("maximum iterations exceeded in bed_shuffle") ;
}
// get a random interval index
int rand_ivl_idx = interval_rng(generator) ;
// get the start rng and pick a start
UDIST start_rng = start_rngs[chrom][rand_ivl_idx] ;
int rand_start = start_rng(generator) ;
auto rand_end = rand_start + df_sizes[i] ;
intervalVector overlaps = chrom_tree.findOverlapping(rand_start, rand_end) ;
// didn't find an overlap, keep going
if (overlaps.empty()) continue ;
// check that the chosen end is <= the end of the overlapping interval
bool enclosed = true ;
for(intervalVector::const_iterator j = overlaps.begin(); j<overlaps.end(); ++j) {
if (rand_start >= j->start) {
if (rand_end > j->stop) {
enclosed = false ;
}
}
}
if (!enclosed) continue ;
// if we get here, all checks pass. keep the interval.
inbounds = true ;
starts_out[i] = rand_start ;
ends_out[i] = rand_end ;
}
}
return DataFrame::create( Named("chrom") = chroms_out,
Named("start") = starts_out,
Named("end") = ends_out) ;
}
