/** @note Because of the virtual public inheritance, we create the Pdf baseclass ourselves */ CondGausAddNoise::CondGausAddNoise(const Gaussian& additiveNoise, int num_conditional_arguments) : AnalyticConditionalGaussian(additiveNoise.DimensionGet(), num_conditional_arguments) , _additiveNoise_Mu (additiveNoise.ExpectedValueGet()) , _additiveNoise_Sigma(additiveNoise.CovarianceGet()) {}
void SumFactor::_internal_update( Variable* var, std::vector<Gaussian*> y, std::vector<Gaussian*> fy, std::vector<double>* a) { double sum_pi = 0.0, sum_tau = 0.0, new_pi, new_tau, da; unsigned int i = 0, size = a->size(); Gaussian gy, gfy; for (i = 0; i < size; ++i) { da = (*a)[i]; gy = *y[i]; gfy = *fy[i]; sum_pi = sum_pi + ((da * da) / (gy.pi - gfy.pi)); sum_tau = sum_tau + (da * (gy.tau - gfy.tau) / (gy.pi - gfy.pi)); } new_pi = 1.0 / sum_pi; new_tau = new_pi * sum_tau; Gaussian* gaussian = new Gaussian(); gaussian->init_pi_tau(new_pi, new_tau); var->update_message(this, gaussian); }
//---------------------------------------------------------------------------------------------------------------------- void SMCEnvironmentViz::drawGaussian(const Gaussian& g) const { const int numPoints = 50; ci::Vec2f start, end; // Three sigmas cover approx. 99% of the gaussian float a = -3.0 * g.getW(); float inc = 6.0 * g.getW() / numPoints; ci::Path2d path; path.moveTo(g.getPointAt(a)); for(int i = 0; i < numPoints; ++i) { end = g.getPointAt((a+inc)); path.lineTo(end); a += inc; } path.close(); glColor4f(0.5,0.5,0.5,0.25); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); ci::gl::drawSolid(path); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); }
bool is_approx(const Gaussian<OtherVariate>& other) { return fl::are_similar(mean(), other.mean()) && fl::are_similar(covariance(), other.covariance()); }
// load the HMM from a file void HMMState::load(FileInput &file, unsigned char iEstimationMethod) { // phonetic symbol char strPhone[MAX_PHONETIC_SYMBOL_LENGTH+1]; IOBase::readBytes(file.getStream(),reinterpret_cast<char*>(strPhone),MAX_PHONETIC_SYMBOL_LENGTH+1); m_iPhone = m_phoneSet->getPhoneIndex(strPhone); assert(m_iPhone != UCHAR_MAX); // state IOBase::read(file.getStream(),&m_iState); assert(m_iState < NUMBER_HMM_STATES); // within word position (DEPRECATED) IOBase::read(file.getStream(),&m_iPosition); // Gaussian components int iGaussianComponents = -1; IOBase::read(file.getStream(),&iGaussianComponents); for(int iGaussian = 0 ; iGaussian < iGaussianComponents ; ++iGaussian) { Gaussian *gaussian = new Gaussian(m_iDim,m_iCovarianceModeling); IOBase::read(file.getStream(),&gaussian->weight()); gaussian->mean().readData(file.getStream()); if (m_iCovarianceModeling == COVARIANCE_MODELLING_TYPE_DIAGONAL) { gaussian->covarianceDiag().readData(file.getStream()); } else { gaussian->covarianceFull().readData(file.getStream()); } m_gaussianMixture->addGaussianComponent(gaussian); } }
// store the HMM into a file void HMMState::store(FileOutput &file) { // phonetic symbol char strPhone[MAX_PHONETIC_SYMBOL_LENGTH+1]; memset(strPhone,0,MAX_PHONETIC_SYMBOL_LENGTH+1); strcpy(strPhone,m_phoneSet->getStrPhone(m_iPhone)); IOBase::writeBytes(file.getStream(),reinterpret_cast<char*>(strPhone),MAX_PHONETIC_SYMBOL_LENGTH+1); // state IOBase::write(file.getStream(),m_iState); // within word position (DEPRECATED) IOBase::write(file.getStream(),m_iPosition); // Gaussian components int iGaussianComponents = m_gaussianMixture->getNumberComponents(); IOBase::write(file.getStream(),iGaussianComponents); for(int iGaussian = 0 ; iGaussian < iGaussianComponents ; ++iGaussian) { Gaussian *gaussian = (*m_gaussianMixture)(iGaussian); IOBase::write(file.getStream(),gaussian->weight()); gaussian->mean().writeData(file.getStream()); if (m_iCovarianceModeling == COVARIANCE_MODELLING_TYPE_DIAGONAL) { gaussian->covarianceDiag().writeData(file.getStream()); } else { gaussian->covarianceFull().writeData(file.getStream()); } } }
void OpenCLExecuter::ocl_filterGaussian_init(float sigma, float size) { Gaussian gauss; gauss.sigma = sigma; gauss.size = size; filter_width = (size-1)/2.0; filter_kernel = gauss.gaussianmask1Df(gauss.sigma, gauss.size); }
void testGaussianNumerics(){ std::cout.precision(16); std::cout << std::scientific; Gaussian g = Gaussian(5, 1); for(unsigned i = 0; i < 100; i++){ std::cout << i << ": L: " << g.likelihood((fracfloat_t)i) << " -LL: " << (-INV_LN_2 * log(g.likelihood(i))) << ", S: " << g.surprisal((fracfloat_t)i) << std::endl; } }
void GMMfitData::defaultAonly(Gaussian &g) { Vector2d mu; mu<< 1.0, 0.1; g.setMu(mu); Matrix2d sigma; sigma<< 0.020, -0.001, -0.001, 0.005; g.setSigma(sigma); }
void GMMfitData::defaultDonly(Gaussian &g) { Vector2d mu; mu<< 0.0, 0.98; g.setMu(mu); Matrix2d sigma; sigma<< 0.0012, 0.0000, 0.0000, 0.0015; g.setSigma(sigma); }
void GMMfitData::defaultLowFRET(Gaussian &g) { Vector2d mu; mu<< 0.15, 0.5; g.setMu(mu); Matrix2d sigma; sigma<< 0.050, 0.000, 0.000, 0.020; g.setSigma(sigma); }
void LikelihoodFactor::update_mean() { Gaussian x = *this->value->value; Gaussian fx = *this->value->get_message(this); double a = 1.0 / (1.0 + this->variance * (x.pi - fx.pi)); Gaussian* gaussian = new Gaussian(); gaussian->init_pi_tau( a * (x.pi - fx.pi), a * (x.tau - fx.tau) ); this->mean->update_message(this, gaussian); }
void vwcgauss (const RealArray& energy, const RealArray& parameter, /*@unused@*/ int spectrum, RealArray& flux, /*@unused@*/ RealArray& fluxError, /*@unused@*/ const string& init) { fluxError.resize (0); Real LineEnergy, Sigma; vwcgaussProcessParameter (parameter, LineEnergy, Sigma); Gaussian G (energy, LineEnergy, Sigma); G.getFlux (flux); return; }
void Test::RunCannyTest(const RGBImage* in) { Gaussian smoother; Sobel sobel; Canny canny; StudentPreProcessing converter; double sigma = 1.6; int kernelSize = 5; // Convert RGB to Intensity IntensityImage* grey = ImageFactory::newIntensityImage(in->getWidth(), in->getHeight()); grey = converter.stepToIntensityImage(*in); BaseTimer timer; int total = 0; for (int i = 0; i < 10; ++i) { timer.start(); /* Start of Canny */ // 1. Smooth Intensity with Gaussian IntensityImage* gaussian = ImageFactory::newIntensityImage(in->getWidth() - kernelSize, in->getHeight() - kernelSize); smoother.smoothImage(grey, gaussian, sigma, kernelSize); // 2. Find edges with Sobel (convolve X and Y separately for Canny) int sobelKernelSize = 3; IntensityImage* sobelX = ImageFactory::newIntensityImage(gaussian->getWidth() - sobelKernelSize, gaussian->getHeight() - sobelKernelSize); IntensityImage* sobelY = ImageFactory::newIntensityImage(gaussian->getWidth() - sobelKernelSize, gaussian->getHeight() - sobelKernelSize); sobel.filterXY(gaussian, sobelX, sobelY); // 3. Apply non-maximum suppresion IntensityImage* nonMaxSuppression = ImageFactory::newIntensityImage(sobelX->getWidth(), sobelX->getHeight()); canny.nonMaximumSurpression(sobelX, sobelY, nonMaxSuppression); // 4. Apply hysteresis threshold IntensityImage* hysteresisThreshold = ImageFactory::newIntensityImage(sobelX->getWidth(), sobelX->getHeight()); canny.threshold(nonMaxSuppression, hysteresisThreshold, 60, 70); timer.stop(); std::cout << timer.elapsedMilliSeconds() << " ms" << std::endl; total += timer.elapsedMilliSeconds(); timer.reset(); if (i == 9) ImageIO::saveIntensityImage(*hysteresisThreshold, ImageIO::getDebugFileName("Canny.png")); } std::cout << "Average time per Canny edge detection: " << (total / 10) << " ms" << std::endl; std::cout << "Press the X in the console window to exit program" << std::endl; }
/** * Create a time series of input data. * * Description:\n * Creates a time series of complex floats representing a signal at * a given frequency. */ ComplexFloat32 * createTdData(float64_t fMHz, float64_t driftHz, int32_t samples, float64_t noise) { size_t size = samples * sizeof(ComplexFloat32); ComplexFloat32 *td = static_cast<ComplexFloat32 *> (fftwf_malloc(size)); float64_t dfMHz = fMHz - centerFreqMHz; float64_t widthMHz = subchannels * subchannelWidthMHz; Gaussian gen; // no noise, just signal gen.setup(0, widthMHz, noise); gen.addCwSignal(dfMHz, driftHz, 1); gen.getSamples(td, samples); return (td); }
bool is_approx(const Gaussian<OtherVariate>& other, Real eps = 1.e-9, bool scale_with_size = false) { Real eps_mean = eps; Real eps_cov = eps; if (scale_with_size) { eps_mean *= mean().size(); eps_cov *= covariance().size(); } return fl::are_similar(mean(), other.mean(), eps_mean) && fl::are_similar(covariance(), other.covariance(), eps_cov); }
// constructor NonLinearAnalyticConditionalGaussian_Ginac::NonLinearAnalyticConditionalGaussian_Ginac (const GiNaC::matrix& func, const vector<GiNaC::symbol>& u, const vector<GiNaC::symbol>& x, const Gaussian& additiveNoise, const vector<GiNaC::symbol>& cond ) :AnalyticConditionalGaussianAdditiveNoise(additiveNoise,3), func_sym (func), cond_sym (cond), u_sym (u), x_sym (x), cond_size (cond_sym.size()), u_size (u_sym.size()), x_size (x_sym.size()), func_size (func_sym.rows()), dfunc_dcond (cond_size), dfunc_dx (x_size) { // test for consistent input assert (func_sym.cols() == 1); assert (additiveNoise.DimensionGet() == cond_size); // derive func to cond for (unsigned int i=0; i < cond_size; i++) dfunc_dcond[i] = func_sym.diff(cond_sym[i]); // derive func to x for (unsigned int i=0; i < x_size; i++) dfunc_dx[i] = func_sym.diff(x_sym[i]); }
/** * Generate next point * @param n space dimensionality * @param radius sphere radius * @param center sphere center (null for 0) * @param x resulting vector point */ static void nextPoint(int n, double radius, double * center, double* x) { double norm; Gaussian gauss; gauss.setSeqLen(n); norm = 0.; for(int j = 0; j < n; j ++) { x[j] = gauss.getRand(); norm += x[j] * x[j];; } double a; a = radius / sqrt(norm); for(int j = 0; j < n; j ++) { x[j] *= a; } if(center) { for(int j = 0; j < n; j ++) { x[j] += center[j]; } } }
// estimate the parameters of the given HMM-state void MAPEstimator::estimateParameters(HMMState *hmmState, Accumulator **accumulators, float fPriorKnowledgeWeight) { // (1) update the mean of each Gaussian component for(unsigned int g = 0 ; g < hmmState->getMixture().getNumberComponents() ; ++g) { Gaussian *gaussian = hmmState->getMixture()(g); Accumulator *accumulator = accumulators[g]; // if there occupation for this component? if (accumulator == NULL) { continue; } // mean (needs to be computed first in the case of full covariance) gaussian->mean().mul(fPriorKnowledgeWeight); gaussian->mean().add(accumulator->getObservation()); gaussian->mean().mul((float)(1.0f/(fPriorKnowledgeWeight+accumulator->getOccupation()))); } assert(hmmState->getMixture().getNumberComponents() > 0); }
void TruncateFactorDraw::update() { Gaussian* x = this->variable->value; Gaussian* fx = this->variable->get_message(this); double c, d, sqrt_c, V, W, t, e, mW; c = x->pi - fx->pi; d = x->tau = fx->tau; sqrt_c = sqrt(c); t = d / sqrt_c; e = epsilon * sqrt_c; V = Vdraw(t, e); W = Wdraw(t, e); mW = 1.0 - W; Gaussian* gaussian = new Gaussian(); gaussian->init_pi_tau(c / mW, (d + sqrt_c * V) / mW); this->variable->update_value(this, gaussian); }
void testDifferentialEntropy(){ std::cout << "Testing Differential Entropy." << std::endl; fracfloat_t samples[DE_TEST_SIZE]; std::default_random_engine generator; std::normal_distribution<fracfloat_t> distributions[DISTSIZE]; distributions[0] = std::normal_distribution<fracfloat_t>(0.0,1.0); distributions[1] = std::normal_distribution<fracfloat_t>(0.1,4.0); distributions[2] = std::normal_distribution<fracfloat_t>(2.0,1.0); distributions[3] = std::normal_distribution<fracfloat_t>(5.0,8.0); for(unsigned i = 0; i < DE_TEST_SIZE; i++){ samples[i] = distributions[i % DISTSIZE](generator); } Gaussian g = Gaussian(samples, DE_TEST_SIZE); MultiGaussian mg = MultiGaussian::fitGaussianKernel(samples, DE_TEST_SIZE, (unsigned)sqrt(DE_TEST_SIZE)); fracfloat_t supportStart = min<fracfloat_t>(samples, DE_TEST_SIZE) * 2; fracfloat_t supportEnd = max<fracfloat_t>(samples, DE_TEST_SIZE) * 2; std::cout << "Gaussian: " << g << std::endl; std::cout << "Multi Gaussian: " << mg << std::endl; std::cout << "Integral gaussian approximation: " << g.integrate(supportStart, supportEnd, 1000) << std::endl; std::cout << "Integral multigaussian approximation: " << mg.integrate(supportStart, supportEnd, 1000) << std::endl; std::cout << "Integral 10: " << mg.approximateDifferentialEntropyFromIntegral(supportStart, supportEnd, 10) << std::endl; std::cout << "Integral 100: " << mg.approximateDifferentialEntropyFromIntegral(supportStart, supportEnd, 100) << std::endl; std::cout << "Integral 1000: " << mg.approximateDifferentialEntropyFromIntegral(supportStart, supportEnd, 1000) << std::endl; std::cout << "Distribution Trick: " << mg.approximateDifferentialEntropyFromSamples(Array<fracfloat_t>(samples, DE_TEST_SIZE / 1)) << std::endl; std::cout << "Distribution Trick 1/2: " << mg.approximateDifferentialEntropyFromSamples(Array<fracfloat_t>(samples, DE_TEST_SIZE / 2)) << std::endl; std::cout << "Distribution Trick 1/4: " << mg.approximateDifferentialEntropyFromSamples(Array<fracfloat_t>(samples, DE_TEST_SIZE / 4)) << std::endl; std::cout << "Distribution Trick 1/8: " << mg.approximateDifferentialEntropyFromSamples(Array<fracfloat_t>(samples, DE_TEST_SIZE / 8)) << std::endl; std::cout << "Distribution Trick 1/16: " << mg.approximateDifferentialEntropyFromSamples(Array<fracfloat_t>(samples, DE_TEST_SIZE / 16)) << std::endl; }
Scalar minDistanceSquared( const Gaussian<Scalar, NDims>& model, const Matrix<Scalar, NDims, Dynamic>& bag, int* index ) { Scalar minDistance = numeric_limits<Scalar>::infinity(); int minIndex = -1; for (int p = 0; p < bag.cols(); p++) { Matrix<Scalar, NDims, 1> point(bag.col(p)); Scalar distance = model.distanceSquared(point); if (distance < minDistance) { minDistance = distance; minIndex = p; } } if (index) { *index = minIndex; } return minDistance; }
void TrueSkill::adjust_players(std::vector<Player*> players) { Constants constants; std::sort(players.begin(), players.end(), player_sorter()); std::vector<Variable*> ss, ps, ts, ds; unsigned int i = 0, size = players.size(); double gammasqr = constants.GAMMA * constants.GAMMA, betasqr = constants.BETA * constants.BETA; for (i = 0; i < size; ++i) { ss.push_back(new Variable()); ps.push_back(new Variable()); ts.push_back(new Variable()); } for (i = 0; i < size - 1; ++i) { ds.push_back(new Variable()); } std::vector<PriorFactor*> skill; for (i = 0; i < size; ++i) { Player* pl = players[i]; Variable* s = ss[i]; Gaussian* gaussian = new Gaussian(); gaussian->init_mu_sigma(pl->mu, sqrt((pl->sigma * pl->sigma) + gammasqr)); skill.push_back(new PriorFactor(s, gaussian)); } std::vector<LikelihoodFactor*> skill_to_perf; for (i = 0; i < size; ++i) { Variable* s = ss[i]; Variable* p = ps[i]; skill_to_perf.push_back(new LikelihoodFactor(s, p, betasqr)); } std::vector<SumFactor*> perf_to_team; for (i = 0; i < size; ++i) { std::vector<Variable*>* p = new std::vector<Variable*>(); std::vector<double>* c = new std::vector<double>; p->push_back(ps[i]); c->push_back(1.0); perf_to_team.push_back(new SumFactor(ts[i], p, c)); } std::vector<SumFactor*> team_diff; for (i = 0; i < size - 1; ++i) { std::vector<Variable*>* p = new std::vector<Variable*>(); p->push_back(ts[i]); p->push_back(ts[i + 1]); std::vector<double>* c = new std::vector<double>; c->push_back(1.0); c->push_back(-1.0); team_diff.push_back(new SumFactor(ds[i], p, c)); } std::vector<TruncateFactor*> trunc; for (i = 0; i < size - 1; ++i) { TruncateFactor* tf; if (players[i]->rank == players[i + 1]->rank) { tf = new TruncateFactorDraw(ds[i], constants.EPSILON); } else { tf = new TruncateFactorWin(ds[i], constants.EPSILON); } trunc.push_back(tf); } for(std::vector<PriorFactor*>::iterator it = skill.begin(); it != skill.end(); ++it) { (*it)->start(); } for(std::vector<LikelihoodFactor*>::iterator it = skill_to_perf.begin(); it != skill_to_perf.end(); ++it) { (*it)->update_value(); } for(std::vector<SumFactor*>::iterator it = perf_to_team.begin(); it != perf_to_team.end(); ++it) { (*it)->update_sum(); } for (i = 0; i < 5; ++i) { for(std::vector<SumFactor*>::iterator it = team_diff.begin(); it != team_diff.end(); ++it) { (*it)->update_sum(); } for(std::vector<TruncateFactor*>::iterator it = trunc.begin(); it != trunc.end(); ++it) { (*it)->update(); } for(std::vector<SumFactor*>::iterator it = team_diff.begin(); it != team_diff.end(); ++it) { (*it)->update_term(0); (*it)->update_term(1); } } for(std::vector<SumFactor*>::iterator it = perf_to_team.begin(); it != perf_to_team.end(); ++it) { (*it)->update_term(0); } for(std::vector<LikelihoodFactor*>::iterator it = skill_to_perf.begin(); it != skill_to_perf.end(); ++it) { (*it)->update_mean(); } for (i = 0; i < size; ++i) { players[i]->mu = ss[i]->value->get_mu(); players[i]->sigma = ss[i]->value->get_sigma(); } while(!skill.empty()) { delete skill.back(); skill.pop_back(); } while(!skill_to_perf.empty()) { delete skill_to_perf.back(); skill_to_perf.pop_back(); } while(!perf_to_team.empty()) { delete perf_to_team.back(); perf_to_team.pop_back(); } while(!team_diff.empty()) { delete team_diff.back(); team_diff.pop_back(); } while(!trunc.empty()) { delete trunc.back(); trunc.pop_back(); } while(!ss.empty()) { delete ss.back(); ss.pop_back(); } while(!ts.empty()) { delete ts.back(); ts.pop_back(); } while(!ds.empty()) { delete ds.back(); ds.pop_back(); } while(!ps.empty()) { delete ps.back(); ps.pop_back(); } }
bool Gaussian :: operator<(const Gaussian& gaussian) const { return (get_sort_parameter() > gaussian.get_sort_parameter()); }
void ClauseAllocator::updateAllOffsetsAndPointers( Solver* solver , const vector<ClOffset>& offsets ) { //Must be at toplevel, otherwise propBy reset will not work //and also, detachReattacher will fail assert(solver->decisionLevel() == 0); //We are at decision level 0, so we can reset all PropBy-s for (VarData& vdata: solver->varData) { vdata.reason = PropBy(); //vdata.level = 0; } //Detach long clauses CompleteDetachReatacher detachReattach(solver); detachReattach.detach_nonbins_nontris(); #ifdef USE_GAUSS for(size_t i = 0; i < solver->gauss_matrixes.size(); i++) { Gaussian* g = solver->gauss_matrixes[i]; g->assert_clauses_toclear_is_empty(); } #endif //Make sure all non-freed clauses were accessible from solver const size_t origNumClauses = solver->longIrredCls.size() + solver->longRedCls.size(); if (origNumClauses != offsets.size()) { std::cerr << "ERROR: Not all non-freed clauses are accessible from Solver" << endl << " This usually means that a clause was not freed, i.e. a mem leak" << endl << " no. clauses accessible from solver: " << origNumClauses << endl << " no. clauses non-freed: " << offsets.size() << endl; assert(origNumClauses == offsets.size()); std::exit(-1); } //Clear clauses solver->longIrredCls.clear(); solver->longRedCls.clear(); //Add back to the solver the correct red & irred clauses for(auto offset: offsets) { Clause* cl = ptr(offset); assert(!cl->freed()); //Put it in the right bucket if (cl->red()) { solver->longRedCls.push_back(offset); } else { solver->longIrredCls.push_back(offset); } } //Finally, reattach long clauses detachReattach.reattachLongsNoClean(); }
int main(int argc, char **argv) { parseArgs(argc, argv); if (beam) channel = 0; sndX = new MCSend(channel, mcPortX+channel, mcAddr); sndY = new MCSend(channel, mcPortY+channel, mcAddr); /** * initialize the sample generators */ genX.setup(seedX, bandwidth, power); genY.setup(seedY, bandwidth, power); /** * if we're writing to output, open the file */ if (packetFile.length()) openFile(packetFile); if (beam) { pkt = new BeamPacket(source, channel); xPkt = new BeamPacket(source, channel); yPkt = new BeamPacket(source, channel); ATADataPacketHeader hdr = pkt->getHeader(); complex<float> val(1, 1); for (uint32_t i = 0; i < hdr.len; ++i) { pkt->putSample(i, val); xPkt->putSample(i, val); yPkt->putSample(i, val); } /** * send packets with no valid bit to reset Channelizer */ createPackets(genX, genY, *xPkt, *yPkt); sendPackets(*xPkt, *yPkt); } else { pkt = new ChannelPacket(source, channel); xPkt = new ChannelPacket(source, channel); yPkt = new ChannelPacket(source, channel); ATADataPacketHeader hdr = pkt->getHeader(); complex<float> val(1, 1); for (uint32_t i = 0; i < hdr.len; ++i) { pkt->putSample(i, val); xPkt->putSample(i, val); yPkt->putSample(i, val); } } // // set the valid flag for all remaining packets // data_valid = ATADataPacketHeader::DATA_VALID; // // add signals // for (PacketSigList::iterator p = signals.begin(); p != signals.end(); ++p) { PacketSig sig = *p; if (sig.tOff == 0.0) { if (sig.pol == ATADataPacketHeader::XLINEAR || sig.pol == ATADataPacketHeader::BOTH ) genX.addCwSignal(sig.freq, sig.drift, sig.snr); if (sig.pol == ATADataPacketHeader::YLINEAR || sig.pol == ATADataPacketHeader::BOTH ) genY.addCwSignal(sig.freq, sig.drift, sig.snr); } else { if (sig.pol == ATADataPacketHeader::XLINEAR || sig.pol == ATADataPacketHeader::BOTH ) genX.addPulseSignal(sig.freq, sig.drift, sig.snr, sig.tStart, sig.tOn, sig.tOff); if (sig.pol == ATADataPacketHeader::YLINEAR || sig.pol == ATADataPacketHeader::BOTH ) genY.addPulseSignal(sig.freq, sig.drift, sig.snr, sig.tStart, sig.tOn, sig.tOff); } } gettimeofday(&start, NULL); // // now create and send packets at an interval or // continuously // if (alarmInterval) frameAlarm.set(&alarmHandler, alarmInterval, alarmInterval); else fullThrottle(); while (1) ; }
Perturbation(const Gaussian & p) : Gaussian(p), x_ct(p.size()), P_ct(p.size()) { x_ct.clear(); P_ct.clear(); }
/** * Discrete perturbation from continuous specifications. * - The variance integrates linearly with dt: * - P = Pct.P * _dt * - Therefore, the mean values integrate with time linearly with the square root of dt: * - x = Pct.x * sqrt(_dt) * * \param Pct a continuous-time Gaussian process noise. * \param _dt the time interval to integrate. */ void set_from_continuous(Gaussian & Pct, double _dt) { JFR_ASSERT(Pct.size() == size(), "Sizes mismatch"); set_x_continuous(Pct.x()); set_P_continuous(Pct.P()); set_from_continuous(_dt); }
/** * Create LCP and RCP packets with different noise and signals * */ void createPackets(Gaussian &xGen, Gaussian &yGen, ATAPacket &xPkt, ATAPacket &yPkt) { // // we're reusing the packets, so make sure they're in the right order // xPkt.putPacket(pkt->getPacket()); yPkt.putPacket(pkt->getPacket()); ATADataPacketHeader& hdr = xPkt.getHeader(); // // the following converts the timeval unix time into a 64-bit sec.frac // format; this requires converting tv_usec to a 32-bit fraction // of the form usec / 1e6, then conve[Brting it back to a 32-bit unsigned // integer by multiplying by 2^32. // timeval tp; gettimeofday(&tp, NULL); hdr.absTime = ATADataPacketHeader::timevalToAbsTime(tp); hdr.chan = channel; hdr.freq = cfreq; // hdr.sampleRate = bandwidth; // hdr.usableFraction = usable; hdr.seq = sequence++; hdr.flags |= data_valid; static ComplexFloat64 *samples = 0; // Copy the whole packet to get the header memcpy(&yPkt, &xPkt, xPkt.getSize()); // Now fill in the samples if (!samples) samples = new ComplexFloat64[hdr.len]; if (!local) { // // Only create samples for the pols to be sent // if ( !singlePol || (singlePol && xPol)) { xGen.getSamples(samples, hdr.len); // // store the samples in the X packet // for (uint32_t i = 0; i < hdr.len; ++i) { ComplexFloat32 s(samples[i]); if (swapri) s = ComplexFloat32(s.imag(), s.real()); xPkt.putSample(i, s); } } if ( !singlePol || (singlePol && !xPol)) { yGen.getSamples(samples, hdr.len); // // store the samples in the Y packet // for (uint32_t i = 0; i < hdr.len; ++i) { ComplexFloat32 s(samples[i]); if (swapri) s = ComplexFloat32(s.imag(), s.real()); yPkt.putSample(i, s); } } } switch (polarization) { case ATADataPacketHeader::XLINEAR: xPkt.getHeader().polCode = ATADataPacketHeader::XLINEAR; yPkt.getHeader().polCode = ATADataPacketHeader::YLINEAR; break; case ATADataPacketHeader::RCIRC: default: xPkt.getHeader().polCode = ATADataPacketHeader::RCIRC; yPkt.getHeader().polCode = ATADataPacketHeader::LCIRC; } }
/** * Print Statistics for the generated Packets * * Description:\n * Prints Total number of packets sent, the elapsed time, * the mean power, mean real and imaginary values for the samples * for both LCP and RCP * */ void printStatistics() { timeval end; gettimeofday(&end, NULL); int32_t sec = end.tv_sec - start.tv_sec; int32_t usec = end.tv_usec - start.tv_usec; if (usec < 0) { usec += 1000000; --sec; } cout << packet << " packets sent in " << sec << "." << usec << " seconds" << endl; int32_t maxQueue = sndX->getSendHWM(); cout << "maximum output queue X " << maxQueue << endl; maxQueue = sndY->getSendHWM(); cout << "maximum output queue Y " << maxQueue << endl; int64_t samples; float64_t total; ComplexFloat64 power; ComplexFloat64 fSum; ComplexInt64 iSum; /** * X pol Statistics */ samples = genX.getSampleCnt(); power = genX.getPower(); total = power.real() + power.imag(); cout << "X pol" << endl; cout << samples << " samples, average (float) sample power = "; cout << total / samples << endl; cout << "power (float): re = " << power.real() << ", im = " << power.imag(); cout << ", total = " << total << endl; #ifdef notdef power = genX.getIntegerPower(); total = power.real() + power.imag(); cout << samples << " samples, average (short) sample power = "; cout << total / samples << endl; cout << "power (integer): re = " << power.real() << ", im = "; cout << power.imag() << ", total = " << total << endl; #endif fSum = genX.getSum(); cout << "sum of amplitudes (float64) = (" << fSum.real(); cout << ", " << fSum.imag() << ")" << endl; cout << "avg of amplitudes (float64) = (" << fSum.real() / samples; cout << ", " << fSum.imag() / samples << ")" << endl; #ifdef notdef iSum = genX.getIntegerSum(); cout << "sum of amplitudes (short) = (" << iSum.real(); cout << ", " << iSum.imag() << ")" << endl; cout << "avg of amplitudes (short) = ("; cout << (float64_t) iSum.real() / samples; cout << ", " << (float64_t) iSum.imag() / samples << ")" << endl; #endif /** * Y pol Statistics */ samples = genY.getSampleCnt(); power = genY.getPower(); total = power.real() + power.imag(); cout << "Y pol" << endl; cout << samples << " samples, average (float) sample power = "; cout << total / samples << endl; cout << "power (float): re = " << power.real() << ", im = " << power.imag(); cout << ", total = " << total << endl; #ifdef notdef power = genY.getIntegerPower(); total = power.real() + power.imag(); cout << samples << " samples, average (short) sample power = "; cout << total / samples << endl; cout << "power (integer): re = " << power.real() << ", im = "; cout << power.imag() << ", total = " << total << endl; #endif fSum = genY.getSum(); cout << "sum of amplitudes (float64) = (" << fSum.real(); cout << ", " << fSum.imag() << ")" << endl; cout << "avg of amplitudes (float64) = (" << fSum.real() / samples; cout << ", " << fSum.imag() / samples << ")" << endl; #ifdef notdef iSum = genY.getIntegerSum(); cout << "sum of amplitudes (short) = (" << iSum.real(); cout << ", " << iSum.imag() << ")" << endl; cout << "avg of amplitudes (short) = ("; cout << (float64_t) iSum.real() / samples; cout << ", " << (float64_t) iSum.imag() / samples << ")" << endl; #endif }