GreensFunction3DRadInf::GreensFunction3DRadInf(Real D, Real kf, Real r0, Real Sigma)
: PairGreensFunction(D, kf, r0, Sigma),
kD(4.0 * M_PI * getSigma() * getD()),
alpha((1.0 + (getkf() / getkD())) * (sqrt(getD()) / getSigma()))
{
; // do nothing
}
float UpdaterPitBased::update(float iCdf,
const Obs& iRecentObs,
const Distribution::ptr iRecent,
const Distribution::ptr iDist,
const Parameters& iParameters) const {
float obs = iRecentObs.getValue();
if(!Global::isValid(obs))
return iCdf;
float recentPit = iRecent->getCdf(obs);
if(!Global::isValid(recentPit))
return iCdf;
float sigma0 = iParameters[0];
float sigma = getSigma(sigma0);
float returnValue = Global::MV;
int n = Global::getTimeDiff(iDist->getDate(), iDist->getInit(), iDist->getOffset(),
iRecentObs.getDate(), iRecentObs.getInit(), iRecentObs.getOffset());
// TODO
if(n == 0) {
if(iCdf < recentPit)
return 0;
else if(iCdf > recentPit)
return 1;
else
return recentPit;
}
n = 1;
if(sigma > 0.5) {
return iCdf;
}
else {
float accum = 0;
for(int i = -mNumIterations; i <= mNumIterations; i++) {
float mean = recentPit;
float std = sqrt((float) n)*sigma;
assert(std > 0);
boost::math::normal dist(mean, std);
float part1 = boost::math::cdf(dist, iCdf + 2*i) - boost::math::cdf(dist, 2*i);
float part2 = (1 - boost::math::cdf(dist, -iCdf + 2*i)) - (1 - boost::math::cdf(dist, 2*i));
float diff = part1 + part2;
if(diff < 0) diff = 0;
if(diff > 1) diff = 1;
accum += diff;
}
if(accum < 0) {
accum = 0;
assert(0);
}
else if(accum > 1) {
accum = 1;
//assert(0);
}
returnValue = accum;
}
return returnValue;
}
std::string SBShapelet::SBShapeletImpl::serialize() const
{
std::ostringstream oss(" ");
oss.precision(std::numeric_limits<double>::digits10 + 4);
oss << "galsim._galsim.SBShapelet("<<getSigma()<<", "<<getBVec().repr();
oss << ", galsim.GSParams("<<*gsparams<<"))";
return oss.str();
}
std::string SBGaussian::SBGaussianImpl::serialize() const
{
std::ostringstream oss(" ");
oss.precision(std::numeric_limits<double>::digits10 + 4);
oss << "galsim._galsim.SBGaussian("<<getSigma()<<", "<<getFlux();
oss << ", galsim.GSParams("<<*gsparams<<"))";
return oss.str();
}
std::string GaussianDeviate::make_repr(bool incl_seed)
{
std::ostringstream oss(" ");
oss << "galsim.GaussianDeviate(";
if (incl_seed) oss << seedstring(split(serialize(), ' ')) << ", ";
oss << "mean="<<getMean()<<", ";
oss << "sigma="<<getSigma()<<")";
return oss.str();
}
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: getBitPlane((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: getDisplayOption((*reinterpret_cast< int(*)>(_a[1]))); break;
case 2: getEdgeFilter((*reinterpret_cast< int(*)>(_a[1]))); break;
case 3: getImpulseNoise((*reinterpret_cast< int(*)>(_a[1]))); break;
case 4: getKLTQuality((*reinterpret_cast< double(*)>(_a[1]))); break;
case 5: getKLTMinDist((*reinterpret_cast< int(*)>(_a[1]))); break;
case 6: getKLTWindowSize((*reinterpret_cast< int(*)>(_a[1]))); break;
case 7: getKLTNumLevels((*reinterpret_cast< int(*)>(_a[1]))); break;
case 8: getLogarithmConstant((*reinterpret_cast< double(*)>(_a[1]))); break;
case 9: getOFAlgorithm((*reinterpret_cast< int(*)>(_a[1]))); break;
case 10: getPowerLawConstant((*reinterpret_cast< double(*)>(_a[1]))); break;
case 11: getPowerLawGamma((*reinterpret_cast< double(*)>(_a[1]))); break;
case 12: getR1((*reinterpret_cast< int(*)>(_a[1]))); break;
case 13: getK((*reinterpret_cast< int(*)>(_a[1]))); break;
case 14: getMinSize((*reinterpret_cast< int(*)>(_a[1]))); break;
case 15: getSharpeningAlgorithm((*reinterpret_cast< int(*)>(_a[1]))); break;
case 16: getSigma((*reinterpret_cast< double(*)>(_a[1]))); break;
case 17: getSmoothingFilter((*reinterpret_cast< int(*)>(_a[1]))); break;
case 18: getSmoothingMask((*reinterpret_cast< int(*)>(_a[1]))); break;
case 19: exitApplication(); break;
case 20: openImageDirectory(); break;
case 21: toggleAddGaussianNoise(); break;
case 22: toggleAddGammaNoise(); break;
case 23: toggleAddImpulseNoise(); break;
case 24: toggleBitPlaneSlicing(); break;
case 25: toggleContrastStretching(); break;
case 26: toggleFilter(); break;
case 27: toggleFitToWindow(); break;
case 28: toggleHistogramEqualization(); break;
case 29: toggleLogarithm(); break;
case 30: toggleNegative(); break;
case 31: toggleOpticalFlow(); break;
case 32: togglePowerLaw(); break;
case 33: toggleSegmentation(); break;
case 34: toggleSharpeningAlgorithm(); break;
case 35: toggleSmoothing(); break;
case 36: toggleSwapRedBlue(); break;
case 37: updateImageNumber((*reinterpret_cast< int(*)>(_a[1]))); break;
case 38: timerEvent((*reinterpret_cast< QTimerEvent*(*)>(_a[1]))); break;
case 39: on_pushButtonTrack_clicked(); break;
default: ;
}
_id -= 40;
}
return _id;
}
bool cvzMmcm_IDL::read(yarp::os::ConnectionReader& connection) {
yarp::os::idl::WireReader reader(connection);
reader.expectAccept();
if (!reader.readListHeader()) { reader.fail(); return false; }
yarp::os::ConstString tag = reader.readTag();
bool direct = (tag=="__direct__");
if (direct) tag = reader.readTag();
while (!reader.isError()) {
// TODO: use quick lookup, this is just a test
if (tag == "start") {
start();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(0)) return false;
}
reader.accept();
return true;
}
if (tag == "pause") {
pause();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(0)) return false;
}
reader.accept();
return true;
}
if (tag == "quit") {
bool _return;
_return = quit();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeBool(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "setLearningRate") {
double l;
if (!reader.readDouble(l)) {
reader.fail();
return false;
}
setLearningRate(l);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(0)) return false;
}
reader.accept();
return true;
}
if (tag == "getLearningRate") {
double _return;
_return = getLearningRate();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeDouble(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "setSigma") {
double s;
if (!reader.readDouble(s)) {
reader.fail();
return false;
}
setSigma(s);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(0)) return false;
}
reader.accept();
return true;
}
if (tag == "getSigma") {
double _return;
_return = getSigma();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeDouble(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "getActivity") {
int32_t x;
int32_t y;
int32_t z;
if (!reader.readI32(x)) {
reader.fail();
return false;
}
if (!reader.readI32(y)) {
reader.fail();
return false;
}
if (!reader.readI32(z)) {
reader.fail();
return false;
}
double _return;
_return = getActivity(x,y,z);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeDouble(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "saveWeightsToFile") {
std::string path;
if (!reader.readString(path)) {
reader.fail();
return false;
}
bool _return;
_return = saveWeightsToFile(path);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeBool(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "loadWeightsFromFile") {
std::string path;
if (!reader.readString(path)) {
reader.fail();
return false;
}
bool _return;
_return = loadWeightsFromFile(path);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeBool(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "saveRF") {
std::string path;
if (!reader.readString(path)) {
reader.fail();
return false;
}
bool _return;
_return = saveRF(path);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeBool(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "help") {
std::string functionName;
if (!reader.readString(functionName)) {
functionName = "--all";
}
std::vector<std::string> _return=help(functionName);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(2)) return false;
if (!writer.writeTag("many",1, 0)) return false;
if (!writer.writeListBegin(BOTTLE_TAG_INT, static_cast<uint32_t>(_return.size()))) return false;
std::vector<std::string> ::iterator _iterHelp;
for (_iterHelp = _return.begin(); _iterHelp != _return.end(); ++_iterHelp)
{
if (!writer.writeString(*_iterHelp)) return false;
}
if (!writer.writeListEnd()) return false;
}
reader.accept();
return true;
}
if (reader.noMore()) { reader.fail(); return false; }
yarp::os::ConstString next_tag = reader.readTag();
if (next_tag=="") break;
tag = tag + "_" + next_tag;
}
return false;
}
void StatV::dumpOn(ostream &strm)
{
strm << "MEAN: " << getMean() << " (" << smallest << "-" << biggest
<< ") SIGMA:" << getSigma()<< " ";
}
/**
* constructor
*/
SellCSigma_Matrix::SellCSigma_Matrix( MMreader mmMatrix, int C, int const sigma )
:C_(C), sigma_(sigma)
,M_(mmMatrix.getRows()), N_(mmMatrix.getCols())
,nz_(mmMatrix.getNonZeros()), numberOfChunks_((M_-1)/C+1)
,colInd_(nullptr)
,chunkPtr_(new int[numberOfChunks_]), chunkLength_(new int[numberOfChunks_])
,permute_(new int[M_]), antiPermute_(new int[M_])
,val_(nullptr)
{
// sort input Matrix by row ID
if( !mmMatrix.isRowSorted() )
sortByRow(mmMatrix);
std::vector< std::tuple<int,int,double> > & mmData = mmMatrix.getMatrx();
std::vector< std::tuple<int, int> > rowLengths = getRowLengths(mmMatrix);
// sort sigam chunks by row length
auto begin = rowLengths.begin();
auto end = rowLengths.begin() + getSigma();
for (; end <= rowLengths.end(); begin += getSigma(), end += getSigma() )
{
std::sort(begin, end,
[](std::tuple<int,int> const & a, std::tuple<int,int> const & b)
{return std::get<1>(a) < std::get<1>(b);}
);
}
begin -= getSigma();
std::sort(begin, rowLengths.end(),
[](std::tuple<int,int> const & a, std::tuple<int,int> const & b)
{return std::get<1>(a) < std::get<1>(b);}
);
// determine chunk length and size
// and set backword permutation
std::vector<int> valuesPerChunk( getNumberOfChunks() );
#ifdef _OPENMP
#pragma omp parallel for schedule(runtime)
#endif
for (int chunk=0; chunk < getNumberOfChunks(); ++chunk)
{
int maxRowLenghth = 0;
for (int i=0, row=chunk*getChunkSize();
i<getChunkSize() && row<getRows();
++i, ++row
)
{
if ( maxRowLenghth < std::get<1>(rowLengths[row]) )
maxRowLenghth = std::get<1>(rowLengths[row]);
// set backword permutation
antiPermute_[ std::get<0>(rowLengths[row]) ] = row;
}
chunkLength_[chunk] = maxRowLenghth;
valuesPerChunk[chunk] = maxRowLenghth * getChunkSize();
}
// calculate memory usage and allocate memmory for values and colum IDs
capasety_ = std::accumulate(std::begin(valuesPerChunk),
std::end(valuesPerChunk),
0
);
val_ = new double[capasety_];
colInd_ = new int [capasety_];
// calulate memory overhead
overhead_ = capasety_ - getNonZeros();
// creat Sell-C-sigma data
std::vector<int> chunkOffset = getOffsets(valuesPerChunk);
std::vector<int> rowOffset = getOffsets(getValsPerRow(mmMatrix));
#ifdef _OPENMP
#pragma omp parallel for schedule(runtime)
#endif
for (int chunk=0; chunk < getNumberOfChunks(); ++chunk)
{
chunkPtr_[chunk] = chunkOffset[chunk];
for (int j=0; j<chunkLength_[chunk]; ++j)
{
for (int i=0, row=chunk*getChunkSize();
i<getChunkSize();
++i, ++row
)
{
int col;
double val;
if (row<getRows())
{
// set permutation
permute_[row] = std::get<0>(rowLengths[row]);
// finde values and collumn index
if ( j < std::get<1>(rowLengths[row]) )
{ // fill with matrix values
int id = rowOffset[ permute_[row] ] + j;
val = std::get<2>( mmData[id] );
col = std::get<1>( mmData[id] );
}
else
{ // fill chunk with 0
val = 0.;
col = 0;
}
}
else
{ // add zero rows to end of matrix fill up last chunk
val = 0.;
col = 0;
}
val_ [chunkPtr_[chunk] + i + j*getChunkSize()] = val;
colInd_[chunkPtr_[chunk] + i + j*getChunkSize()] = antiPermute_[col];
}
}
}
/*
std::cout << "Sell-C-sigma constructed:"
<< "\nC: " << getChunkSize() << " sigma: " << getSigma()
<< "\n(" << getRows() << "," << getCols() << ") " << getNonZeros()
<< ":\n";
for (int i=0; i<valueMemoryUsage; ++i)
{
std::cout << getValues()[i] << " (" << getColInd()[i] << ")\n";
}
std::cout << std::endl;
*/
}
