RealVector realVector( double x0, double x1, double x2 ) { RealVector result; result.push_back( x0 ); result.push_back( x1 ); result.push_back( x2 ); return result; }
RealVector realVector( double x0, double x1, double x2, double x3, double x4, double x5 ) { RealVector result; result.push_back( x0 ); result.push_back( x1 ); result.push_back( x2 ); result.push_back( x3 ); result.push_back( x4 ); result.push_back( x5 ); return result; }
double evaluator(RealVector &v) { RealVector obj; for (int i = 0; i < 3; i++) { obj.push_back(5.0); } return v.distance(obj); }
int main(int argc, char **argv) { RealVector up; RealVector low; RealVector sp; double r0 = 0.1; double phi0 = 0.9; double population = 100; double iterations = 100; ArgumentData arg(argc, argv); if ( arg.isOption("r0") ) { arg.getOption("r0", r0); } if ( arg.isOption("phi0") ) { arg.getOption("phi0", phi0); } if ( arg.isOption("population") ) { arg.getOption("population", population); } if ( arg.isOption("iterations") ) { arg.getOption("iterations", iterations); } for (int i = 0; i < 3; i++) { up.push_back(10.0); low.push_back(0.0); sp.push_back(1.0); } boost::function1<double, RealVector> evalu(&evaluator); ParticleSwarm p ( population, iterations, up, low, sp, evalu , r0, phi0); std::cout << "Last population: " << p.populationToString() << endl; std::cout << "Result: " << p.toString()<< std::endl; return 0; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// devFundamentalFreqFinder //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void DevSuite::devFundamentalFreqFinder() { Logger msg( "devFundamentalFreqFinder" ); msg << Msg::Info << "Running devFundamentalFreqFinder..." << Msg::EndReq; RandomNumberGenerator rng( 1 ); double pDetect = 0.8; double baseFreq = 100; double freqBlur = 5; gPlotFactory().createPlot( "Toy model of detected Fourier frequencies" ); RealVector frequencies; for ( size_t i = 1; i < 40; ++i ) { bool isDetect = rng.uniform() < pDetect; if ( !isDetect ) { continue; } double freq = i * baseFreq + rng.uniform( -freqBlur, freqBlur ); frequencies.push_back( freq ); msg << Msg::Info << "Frequency: " << freq << Msg::EndReq; gPlotFactory().createGraph( realVector( freq, freq ), realVector( 0, 1 ) ); } Math::ApproximateGcdAlgorithm gcdAlg( 50 ); Math::ApproximateGcdAlgorithm::Result result = gcdAlg.execute( frequencies ); msg << Msg::Info << "Basefrequency = " << result.gcd << Msg::EndReq; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// studyTwinPeakPerformance //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void AnalysisSrpa::studyTwinPeakPerformance( const std::vector< double >& frequencies, const std::vector< double >& frequencyDifference, double amp2 ) { Synthesizer::SineGenerator generator1( m_samplingInfo ); Synthesizer::SineGenerator generator2( m_samplingInfo ); FeatureAlgorithm::SrSpecPeakAlgorithm peakAlg( 0.25, "PeakAlg", this ); WaveAnalysis::SpectralReassignmentTransform transform( m_samplingInfo, m_fourierSize, m_zeroPadSize, 1 ); generator1.setAmplitude( m_amplitude ); generator2.setAmplitude( amp2 ); Math::RegularAccumArray statusHist( 3, -0.5, NumHistStatusItems - 0.5 ); /// Loop over frequencies. for ( size_t iFreq = 0; iFreq < frequencies.size(); ++iFreq ) { double frequency = frequencies[ iFreq ]; generator1.setFrequency( frequency ); RawPcmData::Ptr data1 = generator1.generate( m_fourierSize ); RealVector freqDiffX; RealVector freqDiffYMin; RealVector freqDiffYMax; /// Loop over frequency differences. for ( size_t iFreqDiff = 0; iFreqDiff < frequencyDifference.size(); ++iFreqDiff ) { double frequency2 = generator1.getFrequency() + frequencyDifference[ iFreqDiff ]; generator2.setFrequency( frequency2 ); RawPcmData::Ptr data2 = generator2.generate( m_fourierSize ); RawPcmData data( *data1 ); data.mixAdd( *data2 ); WaveAnalysis::StftData::Ptr stftData = transform.execute( data ); const WaveAnalysis::SrSpectrum& spectrum = stftData->getSrSpectrum( 0 ); FeatureAlgorithm::SrSpecPeakAlgorithm::Monitor* monitor = 0; if ( iFreq == 0 && iFreqDiff == 2 ) { monitor = new FeatureAlgorithm::SrSpecPeakAlgorithm::Monitor(); } const std::vector< Feature::SrSpecPeak >& peaks = peakAlg.execute( spectrum, monitor ); if ( monitor ) { monitor->createSpectrumPlot( getName() + "/FreqProx/FreqMonitor" ); delete monitor; } getLogger() << Msg::Info << "----------------------------------------" << Msg::EndReq; getLogger() << Msg::Info << "iFreq = " << iFreq << ", iFreqDiff = " << iFreqDiff << Msg::EndReq; getLogger() << Msg::Info << "Truth sinusoid 1: frequency = " << generator1.getFrequency() << ", amplitude = " << generator1.getAmplitude() << Msg::EndReq; getLogger() << Msg::Info << "Truth sinusoid 2: frequency = " << generator2.getFrequency() << ", amplitude = " << generator2.getAmplitude() << Msg::EndReq; RealVector peakAmps( peaks.size() ); for ( size_t iPeak = 0; iPeak < peaks.size(); ++iPeak ) { peakAmps[ iPeak ] = peaks[ iPeak ].getHeight(); } SortCache peakAmpsSc( peakAmps ); if ( peakAmpsSc.getSize() >= 2 ) { double freqEstimate1 = peaks[ peakAmpsSc.getReverseSortedIndex( 0 ) ].getFrequency(); double freqEstimate2 = peaks[ peakAmpsSc.getReverseSortedIndex( 1 ) ].getFrequency(); double errDf1; double errDf2; int estimate1 = 2; int estimate2 = 2; if ( fabs( freqEstimate1 - frequency ) < fabs( freqEstimate1 - frequency2 ) ) { estimate1 = 1; errDf1 = freqEstimate1 - frequency; errDf2 = freqEstimate2 - frequency2; } if ( fabs( freqEstimate2 - frequency ) < fabs( freqEstimate2 - frequency2 ) ) { estimate2 = 1; errDf1 = freqEstimate2 - frequency; errDf2 = freqEstimate1 - frequency2; } if ( estimate1 != estimate2 ) { statusHist.add( PeaksCorrect, 1 ); freqDiffX.push_back( frequencyDifference[ iFreqDiff ] ); freqDiffYMin.push_back( std::min( errDf1, errDf2 ) ); freqDiffYMax.push_back( std::max( errDf1, errDf2 ) ); } else { statusHist.add( PeaksIncorrect, 1 ); } } else { statusHist.add( NotEnoughPeaks, 1 ); } for ( size_t iPeak = 0; iPeak < peaks.size(); ++iPeak ) { double recoAmp = peaks[ iPeak ].getHeight() / m_fourierSize; getLogger() << Msg::Info << "Peak " << iPeak << ": frequency = " << peaks[ iPeak ].getFrequency() << ", amplitude " << recoAmp << Msg::EndReq; } } /// Loop over frequency differences. std::ostringstream plotTitleFreqDifMin; plotTitleFreqDifMin << getName() + "/FreqProx/FreqError" << frequency; gPlotFactory().createPlot( plotTitleFreqDifMin.str() ); gPlotFactory().createGraph( freqDiffX, freqDiffYMin, Qt::blue ); gPlotFactory().createGraph( freqDiffX, freqDiffYMax, Qt::red ); } /// Loop over frequencies. gPlotFactory().createPlot( getName() + "/FroxProx/CategorisedCounts" ); gPlotFactory().createHistogram( statusHist ); }
void GreensFunction3DRadInf::makeRnTable(RealVector& RnTable, Real r, Real t) const { RnTable.clear(); const Real sigma(getSigma()); const Real D(getD()); const Real kf(getkf()); { // First, estimate the size of p_corr, and if it's small enough, // we don't need to calculate it in the first place. const Real pirr(p_irr(r, t, r0, kf, D, sigma)); const Real ipfree_max(ip_free(M_PI, r, t) * 2 * M_PI * r * r); if(fabs((pirr - ipfree_max) / ipfree_max) < 1e-8) { return; } } const Real pfreemax(p_free_max(r, r0, t, D)); gsl_integration_workspace* workspace(gsl_integration_workspace_alloc(2000)); Real Rn_prev(0.0); const Real RnFactor(1.0 / (4.0 * M_PI * sqrt(r * r0))); const Real integrationTolerance(pfreemax / RnFactor * THETA_TOLERANCE); const Real truncationTolerance(pfreemax * THETA_TOLERANCE * 1e-1); unsigned int n(0); for (;;) { const Real Rn(this->Rn(n, r, t, workspace, integrationTolerance)); RnTable.push_back(Rn); // truncate when converged enough. const Real absRn(fabs(Rn)); if(absRn * RnFactor < truncationTolerance && absRn < Rn_prev) { break; } if(n >= this->MAX_ORDER) { log_.info("GreensFunction3DRadInf: Rn didn't converge"); break; } Rn_prev = fabs(Rn); ++n; } gsl_integration_workspace_free(workspace); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// realVector //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// RealVector realVector( double x0 ) { RealVector result; result.push_back( x0 ); return result; }