////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// getErrorDerivative
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RealVector MultiLayerPerceptron::calcErrorAndGradient( const RealVector& input, const RealVector& target, double& error )
{
/// The current state on the nodes will be used for backpropagation.
error = calcError( input, target );
if ( m_deltaE.size() == 0 )
{
/// Calculate the gradient components with a single backward propagation if there are no hidden layers.
propagateBackward( m_deltaEOutput, m_deltaEInput, m_weights[ 0 ] );
for ( size_t iInput = 0; iInput < m_weights[ 0 ].size(); ++iInput )
{
for ( size_t iOutput = 0; iOutput < m_weights[ 0 ][ iInput ].size(); ++iOutput )
{
m_weightDerivatives[ 0 ][ iInput ][ iOutput ] = m_input[ iInput ] * m_deltaEOutput[ iOutput ];
}
}
}
else
{
/// Calculate the derivatives of the activation function on all the hidden nodes. This is independent of
/// backpropagation.
calcDerivativesActivationFunc();
/// Propagate output deltas to first hidden node.
propagateBackward( m_deltaEOutput, m_deltaE.back(), m_weights.back() );
for ( size_t i = 0; i < m_deltaE.back().size(); ++i )
{
m_deltaE.back()[ i ] *= m_dfdy.back()[ i ];
}
/// Calculate deltas for all hidden nodes.
/// delta_nk = f'(y_nk) * sum_i w_nki delta_(n+1)i
/// propageBackward calculates the sum.
for ( size_t iHiddenLayer = m_deltaE.size() - 1; iHiddenLayer > 0; --iHiddenLayer )
{
propagateBackward( m_deltaE[ iHiddenLayer ], m_deltaE[ iHiddenLayer - 1 ], m_weights[ iHiddenLayer ] );
for ( size_t iNeuron = 0; iNeuron < m_deltaE[ iHiddenLayer - 1 ].size(); ++iNeuron )
{
m_deltaE[ iHiddenLayer - 1 ][ iNeuron ] *= m_dfdy[ iHiddenLayer - 1 ][ iNeuron ];
}
}
/// Calculate the derivatives. dE/dw_nij = x_(n-1)j * delta_i
for ( size_t iLayer = 0; iLayer < m_weights.size(); ++iLayer )
{
const RealVector& sourceNeuronActivations = iLayer != 0 ? m_x[ iLayer - 1 ] : m_input;
const RealVector& deltaVec = iLayer < m_deltaE.size() ? m_deltaE[ iLayer ] : m_deltaEOutput;
for ( size_t iSourceNeuron = 0; iSourceNeuron < m_weights[ iLayer ].size(); ++iSourceNeuron )
{
for ( size_t iTargetNeuron = 0; iTargetNeuron < m_weights[ iLayer ][ iSourceNeuron ].size(); ++iTargetNeuron )
{
m_weightDerivatives[ iLayer ][ iSourceNeuron ][ iTargetNeuron ] = sourceNeuronActivations[ iSourceNeuron ] * deltaVec[ iTargetNeuron ];
}
}
}
}
/// @see composeGradient
return composeGradient();
}
void prob2b(){
std::cout << "Problem 2 Part B ======== " << std::endl;
Matrix data1(10000,std::vector<double>(2));
Matrix data2(10000,std::vector<double>(2));
loadFile(data1, "sample_data/output1");
loadFile(data2, "sample_data/output3");
Matrix points1 = randSample(data1, 1000);
Matrix points2 = randSample(data2, 1000);
std::vector<double> mean1 = getSampleMean(points1);
std::vector<double> mean2 = getSampleMean(points2);
std::cout << "sample_mean1 = ";
print_vec(mean1);
std::cout << "sample_mean2 = ";
print_vec(mean2);
Matrix cov1 = getSampleVar(points1, mean1);
Matrix cov2 = getSampleVar(points2, mean2);
std::cout << "sample_cov1 = ";
print_matrix(cov1);
std::cout << "sample_cov2 = ";
print_matrix(cov2);
std::cout << "With estimated params: " << std::endl;
QuadraticDiscriminant classifier1(mean1, mean2, cov1, cov2);
calcError(classifier1,data1,data2, "sample_data/labels1");
std::cout << std::endl;
}
lbfgsfloatval_t evaluate(void *instance, const lbfgsfloatval_t *x, lbfgsfloatval_t *g, const int n, const lbfgsfloatval_t step) {
LbfgsInput* inp = (LbfgsInput*)instance;
Matrix *w = formMatrixFromFloatVal(x, inp->y->nrow, inp->L);
double fx = calcError(inp->y, w, inp->target, inp->jobs);
Matrix *dedw = calcErrorGrad(inp->y, w, inp->target, inp->jobs);
for (size_t i=0; i<n; i++) {
g[i] = dedw->vals[i];
}
return fx;
}
real Optimizer::deconvolve(const TVReal &tlog, const TVComplex &v)
{
// _rm->dump("out");
real normak, normab;
updateNorma(tlog, v, normak, normab);
real initError = calcError(TVReal(), TVComplex(), tlog, v, normak, normab);
if(!initError)
{
initError = 1;
}
real error = 1;
int iters = _rm->solve_v(
tlog.size(), &tlog[0], &v[0],
_periodLogS.size(), &_periodLogS[0], &_valueS[0],
25, _work);
error = calcError(_periodLogS, _valueS, tlog, v, normak, normab) / initError;
return error;
}
void prob2a(){
std::cout << "Problem 2 Part A ======== " << std::endl;
Matrix points1(10000,std::vector<double>(2));
Matrix points2(10000,std::vector<double>(2));
loadFile(points1, "sample_data/output1");
loadFile(points2, "sample_data/output3");
std::vector<double> mean1 = getSampleMean(points1);
std::vector<double> mean2 = getSampleMean(points2);
std::cout << "sample_mean1 = ";
print_vec(mean1);
std::cout << "sample_mean2 = ";
print_vec(mean2);
Matrix cov1 = getSampleVar(points1, mean1);
Matrix cov2 = getSampleVar(points2, mean2);
std::cout << "sample_cov1 = ";
print_matrix(cov1);
std::cout << "sample_cov2 = ";
print_matrix(cov2);
std::cout << "With estimated params: " << std::endl;
QuadraticDiscriminant classifier1(mean1, mean2, cov1, cov2);
calcError(classifier1,points1,points2, "sample_data/labels1");
std::cout << "Given params: " << std::endl;
mean1 = {1.0,1.0};
mean2 = {6.0,6.0};
cov1 = {{2.0,0},{0,2.0}};
cov2 = {{4.0,0},{0,8.0}};
QuadraticDiscriminant classifier2(mean1, mean2, cov1, cov2);
calcError(classifier2,points1,points2, "sample_data/labels1");
std::cout << std::endl;
}
double BPLearning::run(std::vector <double> input,std::vector <double> output){
//ÕýÏò¼ÆËã
for(int i=0,n=(int)output.size();i<n;++i)
output[i] = network.fun->f(output[i]);
network.compute(input);
double sumError = calcError(output);
calcUpdate(input);
update();
return sumError;
}
/*!
main thread function. Get data buffer, perform fft and scaling,
write to spectrum buffer.
*/
void Spectrum::processData(unsigned char *data, unsigned char bptr)
{
unsigned int j = bptr * sizes.advance_size;
unsigned char *ptr = &data[j];
for (int i = 0; i < sizes.sample_length; i++) {
double tmpr;
double tmpi;
switch (bits) {
case 16:
{
// convert 16 bit
int ii = ptr[1];
ii = (ii << 8) | ptr[0];
if (ii & 0x8000) ii |= ~0xffff;
tmpr = ii / 32768.0;
ptr += 2;
ii = ptr[1];
ii = (ii << 8) | ptr[0];
if (ii & 0x8000) ii |= ~0xffff;
tmpi = ii / 32768.0;
ptr += 2;
j += 4;
}
break;
case 24:
{
// convert 24 bit signed integer sample to floating point by placing data into
// 32-bit signed int
// data is in ptr[0](LSB) ... ptr[2](MSB)
//
int ii = (ptr[2] << 24) | (ptr[1] << 16) | (ptr[0] << 8);
// divide by (2^31 - 1) - (2^8 -1) = 2147483647 - 255 = 2147483392
// actual float range then [1.0: -1.000000119]
tmpr = ii / 2147483392.0;
ptr += 3;
// repeat for other stereo channel sample
ii = (ptr[2] << 24) | (ptr[1] << 16) | (ptr[0] << 8);
tmpi = ii / 2147483392.0;
ptr += 3;
j += 6;
}
break;
case 32:
{
// convert 32 bit sample to floating point
// data is in ptr[0](LSB)..ptr[3](MSB)
// put data into 32-bit signed int
int ii = (ptr[3] << 24) | (ptr[2] << 16) | (ptr[1] << 8) | ptr[0];
// divide by (2^31 - 1) = 2147483647
tmpr = ii / 2147483647.0;
ptr += 4;
// repeat for other stereo channel sample
ii = (ptr[3] << 24) | (ptr[2] << 16) | (ptr[1] << 8) | ptr[0];
tmpi = ii / 2147483647.0;
ptr += 4;
j += 8;
}
break;
default:
tmpr = 0.;
tmpi = 0.;
break;
}
in[i][0] = tmpr * window[i];
in[i][1] = tmpi * window[i];
if (j == sizes.chunk_size) {
// make buffer circular
j = 0;
ptr = &data[0];
}
}
// done reading raw data, emit signal so audioReader can procede
emit(done());
#ifdef Q_OS_WIN
(fftw_executep) (plan);
#else
fftw_execute(plan);
#endif
if (settings.value(s_sdr_iqcorrect[nrig],s_sdr_iqcorrect_def[nrig]).toBool()) {
for (int i = 0; i < sizes.sample_length; i++) {
// correct IQ imbalance
int j = sizes.sample_length - i - 1;
double real = out[i][0] + out[j][0] - (out[i][1] + out[j][1]) * errfunc[i][1] + (out[i][0] - out[j][0]) * errfunc[i][0];
double imag = out[i][1] - out[j][1] + (out[i][1] + out[j][1]) * errfunc[i][0] + (out[i][0] - out[j][0]) * errfunc[i][1];
spec_tmp[i] = real * real + imag * imag;
}
} else {
for (int i = 0; i < sizes.sample_length; i++) {
spec_tmp[i] = (out[i][0] * out[i][0] + out[i][1] * out[i][1]);
}
}
double bga, sigma;
measureBackground(bga, sigma, spec_tmp);
if (settings.value(s_sdr_iqdata[nrig],s_sdr_iqdata_def[nrig]).toBool()) {
if (calibCnt == (SIG_CALIB_FREQ - 1)) {
measureIQError(bga, spec_tmp);
calibCnt = 0;
} else {
calibCnt++;
}
}
for (int i = 0; i < sizes.sample_length; i++) {
spec_tmp[i] = log(spec_tmp[i]);
#ifdef Q_OS_LINUX
if (isinf(spec_tmp[i])) spec_tmp[i] = -1.0e-16;
#endif
}
measureBackgroundLog(bga, sigma, spec_tmp);
// put upper limit on background. Prevents display "blacking out"
// from static crashes
if (bga > 0.0) bga = 0.0;
if (settings.value(s_sdr_peakdetect[nrig],s_sdr_peakdetect_def[nrig]).toBool()) {
detectPeaks(bga, sigma, spec_tmp);
}
if (settings.value(s_sdr_click[nrig],s_sdr_click_def[nrig]).toBool()) {
//if (clickFilter) {
clickRemove(bga, sigma, spec_tmp);
// re-measure background since click removal changes it
// measureBackgroundLog(bga,sigma,spec_tmp);
}
if (settings.value(s_sdr_scale[nrig],s_sdr_scale_def[nrig]).toInt() == 2) {
interp2(spec_tmp, tmp4, bga); // expand by 2 using linear interpolation
} else {
// IF offset included here
// for (int i=0;i<sizes.display_length;i++) {
double tmp = ((settings.value(s_sdr_offset[nrig],s_sdr_offset_def[nrig]).toInt()-addOffset) *
sizes.spec_length * settings.value(s_sdr_scale[nrig],s_sdr_scale_def[nrig]).toInt()) / (SAMPLE_FREQ * 1000.0);
int offsetPix = -(int) tmp;
for (int i = 0; i < sizes.spec_length; i++) {
unsigned int j = (sizes.spec_length - offsetPix - MAX_H / 2 + i) % sizes.spec_length;
spec_tmp[j] = (spec_tmp[j] - bga + 2.0) * 25.0;
if (spec_tmp[j] < 0.0) {
spec_tmp[j] = 0.0;
} else if (spec_tmp[j] > 255.0) {
spec_tmp[j] = 255.0;
}
tmp4[i] = spec_tmp[j];
}
}
unsigned int cnt = 0;
for (int i = 0; i < sizes.display_length; i++) {
output[i] = (unsigned char) tmp4[i];
cnt += output[i];
}
background = cnt / sizes.display_length; // background measurement
emit(spectrumReady(output, background));
if (calcErrorNext) {
calcError(false);
calcErrorNext = false;
}
}
void Spectrum::initialize(sampleSizes s, PaSampleFormat b, int nr, QString dir)
{
nrig = nr;
userDirectory = dir;
sizes = s;
sizeIQ = sizes.sample_length / 8; // 512 IQ phase/gain bins
// initialize FFTW
#ifdef Q_OS_WIN
if (!fftwWinInit()) {
return;
}
if (in) (fftw_freep) (in);
if (out) (fftw_freep) (out);
if (errfunc) (fftw_freep) (errfunc);
if (plan) (fftw_destroy_planp) (plan);
in = (fftw_complex *) (fftw_mallocp) (sizeof(fftw_complex) * sizes.sample_length);
out = (fftw_complex *) (fftw_mallocp) (sizeof(fftw_complex) * sizes.sample_length);
errfunc = (fftw_complex *) (fftw_mallocp) (sizeof(fftw_complex) * sizes.sample_length);
plan = (fftw_plan_dft_1dp) (sizes.sample_length, in, out, FFTW_FORWARD, FFTW_MEASURE);
#else
if (in) fftw_free(in);
if (out) fftw_free(out);
if (errfunc) fftw_free(errfunc);
if (plan) fftw_destroy_plan(plan);
in = (fftw_complex *) fftw_malloc(sizeof(fftw_complex) * sizes.sample_length);
out = (fftw_complex *) fftw_malloc(sizeof(fftw_complex) * sizes.sample_length);
errfunc = (fftw_complex *) fftw_malloc(sizeof(fftw_complex) * sizes.sample_length);
plan = fftw_plan_dft_1d(sizes.sample_length, in, out, FFTW_FORWARD, FFTW_MEASURE);
#endif
switch (b) {
case paInt16:
bits = 16;
break;
case paInt24:
bits = 24;
break;
case paInt32:
bits = 32;
break;
default:
bits = 16;
}
if (output) delete [] output;
output = new unsigned char[sizes.display_length];
for (int i = 0; i < SIG_N_AVG; i++) {
if (peakAvg[i]) delete [] peakAvg[i];
peakAvg[i] = new double[sizes.spec_length];
}
if (spec_smooth) delete [] spec_smooth;
spec_smooth = new double[sizes.sample_length];
if (spec_tmp) delete [] spec_tmp;
spec_tmp = new double[sizes.sample_length];
if (spec_tmp2) delete [] spec_tmp2;
spec_tmp2 = new double[sizes.sample_length];
for (int i = 0; i < sizes.sample_length; i++) {
spec_tmp[i] = 0.;
spec_smooth[i] = 0.;
spec_tmp2[i] = 0.;
}
if (tmp4) delete [] tmp4;
tmp4 = new double[sizes.spec_length];
if (window) delete [] window;
window = new double[sizes.sample_length];
makeWindow();
for (int i = 0; i < sizes.spec_length; i++) {
tmp4[i] = 0.;
}
if (sigOnCnt) delete [] sigOnCnt;
sigOnCnt = new int[sizes.sample_length];
if (sigOn) delete [] sigOn;
sigOn = new bool[sizes.sample_length];
for (int i = 0; i < sizes.sample_length; i++) {
sigOnCnt[i] = 2;
sigOn[i] = false;
}
if (calibSigList) delete [] calibSigList;
calibSigList = new CalibSignal[sizeIQ];
for (int i = 0; i < FIT_ORDER; i++) {
aGain[i] = 0.;
aPhase[i] = 0.;
}
addOffset=0;
// intialize to unit gain and zero phase
aGain[0] = 1.0;
makeGainPhase();
readError();
calcError(true);
}
void BpAlgSt::start(){
Q_ASSERT(net != NULL);
Q_ASSERT(data != NULL);
emit started();
//value initialization
running = true;
actIter = 1;
actTime = 0;
timer.restart();
double sumErr = 0;
for(int i = 0; i < data->minPatternCount(); i++){
output = net->layerOutput(data->inputVector(i));
sumErr += calcError(i);
}
actError = sumErr;
emit update(0, actTime, actError);
//learning main cycle
while(running){
for(int i = 0; i < data->minPatternCount(); i++){
//feedforward
output = net->layerOutput(data->inputVector(i));
//output layer delta calculation
calcOutputDelta(i);
//inner layer delta calculation
calcInnerDelta();
//weight adjustment
adjustWeight();
}
//current time
actTime = timer.elapsed();
//output error calculation
double sumErr = 0;
for(int i = 0; i < data->minPatternCount(); i++){
output = net->layerOutput(data->inputVector(i));
sumErr += calcError(i);
}
actError = sumErr;
//emits update signal once per each update interval
if(actIter % updateInterv == 0){
emit update(actIter, actTime, actError);
}
//stop conditions
if(actTime >= stopTimeVal) break;
if(actIter >= stopIter) break;
if(actError <= stopErrorVal) break;
actIter++;
}
//running flag to false
running = false;
//signal that tells that learning is finished
emit stoped();
}
void ModifierNPTRattleDetails::doExecute(Integrator* myTheIntegrator){
// estimate the current error in all velocity constraints
Real error = calcError();
// delta_t
Real dt = myTheIntegrator->getTimestep() / Constant::TIMEFACTOR;
// multiplicative constants for the box volume velocity and thermostat velocity
const Real pVol_term = 0.5 * myTheIntegrator->getTimestep() * getEpsilonVel();
const Real pEta_term = 0.5 * myTheIntegrator->getTimestep() * getEtaVel();
const Real OneOverN_term = 1.0 + 1.0 / app->topology->atoms.size();
int iter = 0;
while(error > myEpsilon) {
for(unsigned int i=0;i<myListOfConstraints->size();i++) {
// find the ID#s of the two atoms in the current constraint
int a1 = (*myListOfConstraints)[i].atom1;
int a2 = (*myListOfConstraints)[i].atom2;
// get the ID# of the molecule that this bond belongs to
int Mol = app->topology->atoms[a1].molecule;
// reciprocal atomic masses
Real rM1 = 1/app->topology->atoms[a1].scaledMass;
Real rM2 = 1/app->topology->atoms[a2].scaledMass;
Real m1_over_M = 1 / (rM1 * app->topology->molecules[Mol].mass);
Real m2_over_M = 1 / (rM2 * app->topology->molecules[Mol].mass);
// multiplicative constants due to change in box volume
// (for constant pressure simulations -- see Equation 56 of G. Kalibaeva,
// M. Ferrario, and G. Ciccotti, "Constant pressure-constant temperature molecular
// dynamics: a correct constrained NPT ensemble using the molecular virial", Mol. Phys.
// 101(6), 2003, p. 765-778)
Real Exp2_atom1 = (1 + pVol_term*OneOverN_term*m1_over_M) * exp( -pEta_term - pVol_term*OneOverN_term*m1_over_M);
Real Exp2_atom2 = (1 + pVol_term*OneOverN_term*m2_over_M) * exp( -pEta_term - pVol_term*OneOverN_term*m2_over_M);
// now lets compute the lambdas.
// compute the current bond vector
Vector3D rab = (app->positions)[a1] - (app->positions)[a2];
Real rabsq = rab.normSquared();
// compute the current velocity vector
Vector3D vab = (app->velocities)[a1] - (app->velocities)[a2];
// dot product of distance and velocity vectors
Real rvab = rab * vab;
// compute the change in lambda
Real gab = -rvab / (dt * (rM1 * Exp2_atom1 + rM2 * Exp2_atom2) * rabsq);
Vector3D dp = rab * gab;
// move the velocities based upon the multiplier
(app->velocities)[a1] += dp * dt * rM1 * Exp2_atom1;
(app->velocities)[a2] -= dp * dt * rM2 * Exp2_atom2;
// the constraint adds a force to each atom since their positions
// had to be changed. This constraint force therefore contributes
// to the atomic virial. Note that the molecular virial is independent of
// any intramolecular constraint forces.
if (app->energies.virial()) app->energies.addVirial(dp*2,rab);
}
// compute the error in all the velocity constraints after this RATTLE iteration
error = calcError();
iter ++;
if(iter > myMaxIter) {
report << warning << "Rattle maxIter = " << myMaxIter
<< " reached, but still not converged ... error is "<<error<<endr;
break;
}
}
}
cv::Mat ransac(const cv::Mat& samples, cv::TermCriteria termcrit, double thresh_outliar, double sampling_rate, double minimum_inliar_rate){
assert(0 < sampling_rate && sampling_rate <= 1);
assert(0 < minimum_inliar_rate && minimum_inliar_rate <= 1);
cv::Mat best_model(cv::Size(samples.cols,1),samples.type(),cv::Scalar(0));
size_t dim = samples.cols;
size_t sample_num = samples.rows;
size_t iterations = 0;
size_t sampling_num = sample_num * sampling_rate;
size_t minimum_inliar_num = sample_num * minimum_inliar_rate;
double best_error = DBL_MAX;
std::vector<size_t> sample_index(sample_num);
for(size_t i=0;i<sample_num;i++) sample_index[i] = i;
while( ( (termcrit.type & CV_TERMCRIT_ITER) == 0 || iterations < (size_t)termcrit.maxCount)
&& ( (termcrit.type & CV_TERMCRIT_EPS) == 0 || best_error > termcrit.epsilon) ){
// main loop
// random sampling (use first part as sampled data.)
std::random_shuffle(sample_index.begin(),sample_index.end());
std::vector<size_t> consensus_set(sampling_num);
std::copy(sample_index.begin(),sample_index.begin()+sampling_num,consensus_set.begin());
cv::Mat this_model = fitModel(samples,sample_index.begin(),sample_index.begin()+sampling_num);
// do process for not-sampled elements.
cv::Rect roi(0,0,dim,1);
for(size_t _i=sampling_num;_i<sample_num;_i++){
size_t idx = sample_index[_i];
roi.y = idx;
if(cv::norm(this_model,cv::Mat(samples,roi))<thresh_outliar){
consensus_set.push_back(idx);
}
}
// increment iteration before checking validity
iterations++;
// check validity
if(consensus_set.size() < minimum_inliar_num) continue;
if(consensus_set.size() > sampling_num){
cv::Mat refinement = fitModel(samples,consensus_set.begin()+sampling_num,consensus_set.end());
this_model = ( sampling_num * this_model + (consensus_set.size()-sampling_num) * refinement ) /consensus_set.size();
}
double this_error = calcError(samples, this_model, consensus_set.begin(),consensus_set.end());
if(this_error < best_error){
best_error = this_error;
best_model = this_model;
}
}
return best_model;
}
/******************** * remez *======= * Calculates the optimal (in the Chebyshev/minimax sense) * FIR filter impulse response given a set of band edges, * the desired reponse on those bands, and the weight given to * the error in those bands. * * INPUT: * ------ * int numtaps - Number of filter coefficients * int numband - Number of bands in filter specification * double[] bands - User-specified band edges [2 * numband] * double[] des - User-specified band responses [numband] * double[] weight - User-specified error weights [numband] * int type - Type of filter * * OUTPUT: * ------- * double[] h - Impulse response of final filter [numtaps] ************************************************************************** * Converted to C++ by Tony Kirke July 2001 ************************************************************************** * Copyright (C) 1995 Jake Janovetz ([email protected]) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Converted to Java by Iain A Robin, June 1998 *************************************************************************/ double* remez_fir::remez(int numtaps, int numband, double bands[], double des[], double weight[], int type) { double c; int i; int symmetry = (type == BANDPASS)? POSITIVE : NEGATIVE; int r = numtaps/2; // number of extrema if ((numtaps%2 != 0) && (symmetry == POSITIVE)) r++; // Predict dense grid size in advance for array sizes int gridSize = 0; for (i=0; i<numband; i++) { gridSize += (int)floor(0.5+2*r*GRIDDENSITY*(bands[2*i+1] - bands[2*i])); } if (symmetry == NEGATIVE) gridSize--; double* grid = new double[gridSize]; double* d = new double[gridSize]; double* w = new double[gridSize]; double* e = new double[gridSize]; double* x = new double[r+1]; double* y = new double[r+1]; double* ad = new double[r+1]; double* taps = new double[r+1]; int* ext = new int[r+1]; // Create dense frequency grid createDenseGrid(r, numtaps, numband, bands, des, weight, gridSize, grid, d, w, symmetry); initialGuess(r, ext, gridSize); // For Differentiator: (fix grid) if (type == DIFFERENTIATOR) { for (i=0; i<gridSize; i++) { if (d[i] > 0.0001) w[i] /= grid[i]; } } // For odd or Negative symmetry filters, alter the // d[] and w[] according to Parks McClellan if (symmetry == POSITIVE) { if (numtaps % 2 == 0) { for (i=0; i<gridSize; i++) { c = cos(PI * grid[i]); d[i] /= c; w[i] *= c; } } } else { if (numtaps % 2 != 0) { for (i=0; i<gridSize; i++) { c = sin(TWOPI * grid[i]); d[i] /= c; w[i] *= c; } } else { for (i=0; i<gridSize; i++) { c = sin(PI * grid[i]); d[i] /= c; w[i] *= c; } } } // Perform the Remez Exchange algorithm int iter; for (iter=0; iter<MAXITERATIONS; iter++) { calcParms(r, ext, grid, d, w, ad, x, y); calcError(r, ad, x, y, gridSize, grid, d, w, e); search(r, ext, gridSize, e); if (isDone(r, ext, e)) break; } if (iter == MAXITERATIONS) { cout << "Reached maximum iteration count.\n"; cout << "Results may be bad\n"; } calcParms(r, ext, grid, d, w, ad, x, y); // Find the 'taps' of the filter for use with Frequency // Sampling. If odd or Negative symmetry, fix the taps // according to Parks McClellan for (i=0; i<=numtaps/2; i++) { if (symmetry == POSITIVE) { if (numtaps%2 != 0) c = 1; else c = cos(PI * (double)i/numtaps); } else { if (numtaps%2 != 0) c = sin(TWOPI * (double)i/numtaps); else c = sin(PI * (double)i/numtaps); } taps[i] = computeA((double)i/numtaps, r, ad, x, y)*c; } // Frequency sampling design with calculated taps return freqSample(taps, numtaps, symmetry); }
/*
* newPeaks()
*
* Create initial fit data structures for spline fitting from the peak array. The
* format of the initial values is the same as what was used for 3D-DAOSTORM.
*
* peaks - pointer to the initial values for the parameters for each peak.
* 1. height
* 2. x-center
* 3. x-sigma
* 4. y-center
* 5. y-sigma
* 6. background
* 7. z-center
* 8. status
* 9. error
* .. repeat ..
* n_peaks - The number of parameters (peaks).
*/
void newPeaks(double *peaks, int n_peaks, int fit_type)
{
int i,j,n_fit_params,sx,sy,sz;
double temp;
if(fit_type == F2D){
n_fit_params = 4;
}
else{
n_fit_params = 5;
}
/* Delete old fit data structures, if they exist. */
freePeaks();
/* Reset the fit array. */
resetFit();
/* Allocate storage for fit data structure. */
n_fit_data = n_peaks;
new_fit_data = (fitData *)malloc(sizeof(fitData)*n_peaks);
old_fit_data = (fitData *)malloc(sizeof(fitData)*n_peaks);
sx = getXSize()/2 - 1;
sy = getYSize()/2 - 1;
sz = getZSize();
/* Note the assumption here that the splines are square. */
if((sx%2)==1){
xoff = (double)(sx/2) - 1.0;
yoff = (double)(sy/2) - 1.0;
}
else{
xoff = (double)(sx/2) - 1.5;
yoff = (double)(sy/2) - 1.5;
}
//zoff = -(double)(sz/2);
zoff = 0.0;
/* Initialize fit data structure. */
for(i=0;i<n_fit_data;i++){
new_fit_data[i].index = i;
new_fit_data[i].n_params = n_fit_params;
new_fit_data[i].size_x = sx;
new_fit_data[i].size_y = sy;
new_fit_data[i].size_z = sz;
new_fit_data[i].status = (int)(peaks[i*NRESULTSPAR+STATUS]);
new_fit_data[i].type = fit_type;
new_fit_data[i].lambda = 1.0;
mallocFitData(&(new_fit_data[i]), n_fit_params, sx*sy*(n_fit_params+1));
for(j=0;j<n_fit_params;j++){
new_fit_data[i].sign[j] = 0;
}
new_fit_data[i].clamp[CF_HEIGHT] = 100.0;
new_fit_data[i].clamp[CF_XCENTER] = 1.0;
new_fit_data[i].clamp[CF_YCENTER] = 1.0;
new_fit_data[i].clamp[CF_BACKGROUND] = 20.0;
if (fit_type == F3D){
new_fit_data[i].clamp[CF_ZCENTER] = 2.0;
}
if (DEBUG){
printf(" peaks: %.2f %.2f %.2f\n", peaks[i*NRESULTSPAR+XCENTER], peaks[i*NRESULTSPAR+YCENTER], peaks[i*NRESULTSPAR+ZCENTER]);
}
new_fit_data[i].params[CF_HEIGHT] = peaks[i*NRESULTSPAR+HEIGHT];
new_fit_data[i].params[CF_XCENTER] = peaks[i*NRESULTSPAR+XCENTER] - xoff;
new_fit_data[i].params[CF_YCENTER] = peaks[i*NRESULTSPAR+YCENTER] - yoff;
new_fit_data[i].params[CF_BACKGROUND] = peaks[i*NRESULTSPAR+BACKGROUND];
if (fit_type == F3D){
new_fit_data[i].params[CF_ZCENTER] = peaks[i*NRESULTSPAR+ZCENTER] - zoff;
}
new_fit_data[i].xi = (int)(new_fit_data[i].params[CF_XCENTER]);
new_fit_data[i].yi = (int)(new_fit_data[i].params[CF_YCENTER]);
if (fit_type == F3D){
new_fit_data[i].zi = (int)(new_fit_data[i].params[CF_ZCENTER]);
}
if (fit_type == F2D){
updateFitValues2D(&(new_fit_data[i]));
}
else{
updateFitValues3D(&(new_fit_data[i]));
}
/*
* The derivative with respect to background term is always 1.0
*/
for(j=0;j<(sx*sy);j++){
new_fit_data[i].values[(CF_BACKGROUND+1)*sx*sy+j] = 1.0;
}
addPeak(&(new_fit_data[i]));
mallocFitData(&(old_fit_data[i]), n_fit_params, sx*sy*(n_fit_params+1));
copyFitData(&(new_fit_data[i]), &(old_fit_data[i]));
if(new_fit_data[i].status == RUNNING){
if (TESTING){
temp = calcError(&(new_fit_data[i]), new_fit_data[i].params[CF_BACKGROUND]);
new_fit_data[i].error = temp;
}
else{
new_fit_data[i].error = 1.0e+12;
}
old_fit_data[i].error = 1.0e+13;
}
else{
new_fit_data[i].error = peaks[i*NRESULTSPAR+IERROR];
old_fit_data[i].error = new_fit_data[i].error;
}
}
}
/*
* iterateSpline()
*
* Perform one cycle of update of all the peaks.
*/
void iterateSpline(void)
{
int i;
fitData *new_peak, *old_peak;
for(i=0;i<n_fit_data;i++){
new_peak = &(new_fit_data[i]);
old_peak = &(old_fit_data[i]);
if (new_peak->status == RUNNING){
/* Add the peak & calculate the error. */
new_peak->error = calcError(new_peak, new_peak->params[CF_BACKGROUND]);
//printf("error: %f %f %f\n", new_peak->error, old_peak->error, new_peak->lambda);
if((fabs(new_peak->error - old_peak->error)/new_peak->error) < tolerance){
new_peak->status = CONVERGED;
}
else{
/*
* Check if the fit is getting worse. If it is then reset to the
* previous parameters & increase the lambda parameter. This will
* cause the search to move downhill with higher probability but
* less speed.
*/
if(new_peak->error > (1.5*old_peak->error)){
subtractPeak(new_peak);
copyFitData(old_peak, new_peak);
new_peak->lambda = 10.0 * new_peak->lambda;
addPeak(new_peak);
}
/*
* If the fit is getting better and lambda is greater than 1.0
* then we slowly decrease lambda.
*/
else if(new_peak->error < old_peak->error){
if(new_peak->lambda > 1.0){
new_peak->lambda = 0.8*new_peak->lambda;
if(new_peak->lambda < 1.0){
new_peak->lambda = 1.0;
}
}
}
/* Calculate updated fit values. */
updateFit(new_peak, new_peak->params[CF_BACKGROUND]);
/*
* Increase lambda in the event of Cholesky failure.
*/
if(new_peak->status == CHOLERROR){
new_peak->lambda = 10.0 * new_peak->lambda;
new_peak->status = RUNNING;
}
else{
subtractPeak(new_peak);
copyFitData(new_peak, old_peak);
updatePeakParameters(new_peak);
if(new_peak->type == F2D){
updateFitValues2D(new_peak);
}
else{
updateFitValues3D(new_peak);
}
if(new_peak->status != BADPEAK){
addPeak(new_peak);
}
}
}
}
}
}
double Neuron::getError() {
calcError();
return error;
}