//writes file in format: //x_1 y_m z_1_m //x_2 y_m z_1_m //x_3 y_m z_1_m // . // . //x_n y_m z_1_(m-1) //x_1 y_(m_1) z_1_(m-1) // . // . //x_n y_1 z_n_1 bool XYZ_Writer::writeToFile(const VEC &x, const VEC &y, const vector<VEC> &z) { ofstream fhandle(m_fileName.c_str(), ios::out); //get size from vectors size_t n = x.size(); size_t m = y.size(); double xVal, yVal, zVal; size_t xIdx, yIdx; for(size_t i = 0; i != m*n; ++i) { //write x value xIdx = i % n; xVal = x[xIdx]; fhandle << xVal << " "; //write y value yIdx = m - 1 - (i - (i%n))/n; yVal = y[yIdx]; fhandle << yVal << " "; //write z value zVal = isnan(z[yIdx][xIdx]) ? 0.0 : z[yIdx][xIdx]; fhandle << zVal << endl; } return true; }
static std::size_t choose_next(VEC const& weights, std::size_t present, RNG& rng){ double sum = *(std::max_element(weights.begin(), weights.end())); sum -= weights[present] * rng(); for (int i = 0; i < weights.size(); ++i) { int j = (present + i + 1) % weights.size(); if (sum <= weights[j]) return j; sum -= weights[j]; } return present; }
static void findLocalMinima ( const VEC& intData, vector<mz_uint>& minIndexes) { for (size_t i = 0; i < intData.size(); ++i) { if ( i == 0) { if (intData[i + 1] > intData[i]) minIndexes.push_back(i); } else if ( i == intData.size() - 1) { if ( intData[i - 1] > intData[i] ) minIndexes.push_back(i); } else { if (intData[i - 1] > intData[i] && intData[i + 1] > intData[i]) minIndexes.push_back(i); } } }
static void findLocalMaxima ( const VEC& intData, vector<mz_uint>& maxIndexes, float threshold) { for (size_t i = 0; i < intData.size(); ++i) { if ( i == 0) { if (intData[i + 1] < intData[i] && intData[i] > threshold) maxIndexes.push_back(i); } else if ( i == intData.size() - 1 && intData[i] > threshold) { if ( intData[i - 1] < intData[i] ) maxIndexes.push_back(i); } else { if (intData[i - 1] < intData[i] && intData[i + 1] < intData[i] && intData[i] > threshold) maxIndexes.push_back(i); } } }
void test_log_diff_exp_2_dv(double a, double b_val) { using std::exp; using std::log; using stan::math::log_diff_exp; AVAR b(b_val); AVEC x = createAVEC(b); AVAR f = log_diff_exp(a,b); VEC g; f.grad(x,g); double f_val = f.val(); AVAR b2(b_val); AVEC x2 = createAVEC(b2); AVAR f2 = log(exp(a) - exp(b2)); VEC g2; f2.grad(x2,g2); EXPECT_FLOAT_EQ(f2.val(), f_val); EXPECT_EQ(1U,g.size()); EXPECT_EQ(1U,g2.size()); EXPECT_FLOAT_EQ(g2[0],g[0]); }
void test_log1m_exp(double val) { using stan::math::log1m_exp; using stan::agrad::log1m_exp; using stan::agrad::exp; using std::exp; AVAR a(val); AVEC x = createAVEC(a); AVAR f = log1m_exp(a); EXPECT_FLOAT_EQ(log1m_exp(val), f.val()); VEC g; f.grad(x,g); double f_val = f.val(); AVAR a2(val); AVEC x2 = createAVEC(a2); AVAR f2 = log(1.0 - exp(a2)); VEC g2; f2.grad(x2,g2); EXPECT_EQ(1U,g.size()); EXPECT_EQ(1U,g2.size()); EXPECT_FLOAT_EQ(g2[0],g[0]); EXPECT_FLOAT_EQ(g2[0],-1/boost::math::expm1(-val)); // analytic deriv EXPECT_FLOAT_EQ(f2.val(),f_val); }
//---------------------------------------------------------------------- EEMD::EEMD( const VEC& input_array ) { signal_length = input_array.size(); input_signal = input_array; tools = new Tools(); }
void test_log_diff_exp_2_vv(double a_val, double b_val) { using std::exp; using std::log; using stan::math::log_diff_exp; AVAR a(a_val); AVAR b(b_val); AVEC x = createAVEC(a,b); AVAR f = log_diff_exp(a,b); VEC g; f.grad(x,g); double f_val = f.val(); stan::agrad::var a2(a_val); stan::agrad::var b2(b_val); AVEC x2 = createAVEC(a2,b2); AVAR f2 = log(exp(a2) - exp(b2)); VEC g2; f2.grad(x2,g2); EXPECT_FLOAT_EQ(f2.val(), f_val); EXPECT_EQ(2U,g.size()); EXPECT_EQ(2U,g2.size()); EXPECT_FLOAT_EQ(g2[0],g[0]); EXPECT_FLOAT_EQ(g2[1],g[1]); }
TEST(AgradRevMatrix,mdivide_left_ldlt_finite_diff_vv) { using stan::math::matrix_d; using stan::agrad::matrix_v; using stan::math::multiply; using stan::math::mdivide_left_spd; matrix_d Ad(2,2), Ad_tmp(2,2); matrix_d Bd(2,2), Bd_tmp(2,2); matrix_d Cd(2,2); Ad << 2.0, 3.0, 3.0, 7.0; Bd << 12.0, 13.0, 15.0, 17.0; stan::math::LDLT_factor<double,-1,-1> ldlt_Ad; ldlt_Ad.compute(Ad); ASSERT_TRUE(ldlt_Ad.success()); for (size_type i = 0; i < Bd.rows(); i++) { for (size_type j = 0; j < Bd.cols(); j++) { // compute derivatives matrix_v A(2,2), B(2,2), C; for (size_t k = 0; k < 4; k++) { A(k) = Ad(k); B(k) = Bd(k); } A(0,1) = A(1,0); stan::math::LDLT_factor<stan::agrad::var,-1,-1> ldlt_A; ldlt_A.compute(A); ASSERT_TRUE(ldlt_A.success()); C = mdivide_left_ldlt(ldlt_A,B); AVEC x = createAVEC(A(0,0),A(0,1),A(0,1),A(1,1), B(0,0),B(1,0),B(0,1),B(1,1)); VEC gradient; C(i,j).grad(x,gradient); // compute finite differences VEC finite_diffs = finite_differences(i, j, Ad, true, Bd, true); ASSERT_EQ(gradient.size(), finite_diffs.size()); for (size_t k = 0; k < gradient.size(); k++) EXPECT_NEAR(finite_diffs[k], gradient[k], 1e-4); } } }
//---------------------------------------------------------------------- VEC EEMD::addNoise(const VEC& signal, const float level) { int n = signal.size(); VEC rands = tools->getRands(n); VEC new_signal(n); new_signal = signal + level*rands; return(new_signal); }
void test_sort_indices_desc3(VEC val) { std::vector<fvar<fvar<double> > > x; for(size_t i=0U; i<val.size(); i++) x.push_back(fvar<fvar<double> >(val[i])); std::vector<int> val_sorted = sort_indices_desc(val); std::vector<int> x_sorted = sort_indices_desc(x); for(size_t i=0U; i<val.size(); i++) EXPECT_EQ(val_sorted[i],x_sorted[i]); for(size_t i=0U; i<val.size(); i++) for(size_t j=0U; j<val.size(); j++) if(val_sorted[i] == val[j]) EXPECT_EQ(x_sorted[i],x[j]); else EXPECT_FALSE(x_sorted[i]==x[j]); }
TEST(AgradRev,asin_out_of_bounds2) { AVAR a = -1.0 - stan::math::EPSILON; AVAR f = asin(a); AVEC x = createAVEC(a); VEC g; f.grad(x,g); EXPECT_TRUE(std::isnan(asin(a))); EXPECT_TRUE(g.size() == 1); EXPECT_TRUE(std::isnan(g[0])); }
void test_cumulative_sum2() { using stan::math::cumulative_sum; T c(1); c[0] = 1.7; c[0].d_ = 1.0; T d = cumulative_sum(c); EXPECT_EQ(c.size(), d.size()); EXPECT_FLOAT_EQ(c[0].val_.val(),d[0].val_.val()); EXPECT_FLOAT_EQ(1.0, d[0].d_.val()); T e(2); e[0] = 5.9; e[1] = -1.2; e[0].d_ = 2.0; e[1].d_ = 1.0; T f = cumulative_sum(e); EXPECT_EQ(e.size(), f.size()); EXPECT_FLOAT_EQ(e[0].val_.val(),f[0].val_.val()); EXPECT_FLOAT_EQ((e[0] + e[1]).val_.val(), f[1].val_.val()); EXPECT_FLOAT_EQ(2.0, f[0].d_.val()); EXPECT_FLOAT_EQ(3.0, f[1].d_.val()); VEC grad = cgrad(f[0].val(),e[0].val(),e[1].val()); EXPECT_EQ(2U,grad.size()); EXPECT_FLOAT_EQ(1.0,grad[0]); EXPECT_FLOAT_EQ(0.0,grad[1]); T g(3); g[0] = 5.9; g[1] = -1.2; g[2] = 192.13456; g[0].d_ = 4.0; g[1].d_ = 2.0; g[2].d_ = 3.0; T h = cumulative_sum(g); EXPECT_EQ(g.size(), h.size()); EXPECT_FLOAT_EQ(g[0].val_.val(),h[0].val_.val()); EXPECT_FLOAT_EQ((g[0] + g[1]).val_.val(), h[1].val_.val()); EXPECT_FLOAT_EQ((g[0] + g[1] + g[2]).val_.val(), h[2].val_.val()); EXPECT_FLOAT_EQ(4.0, h[0].d_.val()); EXPECT_FLOAT_EQ(6.0, h[1].d_.val()); EXPECT_FLOAT_EQ(9.0, h[2].d_.val()); grad = cgrad(h[2].val(),g[0].val(),g[1].val(),g[2].val()); EXPECT_EQ(3U,grad.size()); EXPECT_FLOAT_EQ(1.0,grad[0]); EXPECT_FLOAT_EQ(1.0,grad[1]); EXPECT_FLOAT_EQ(1.0,grad[2]); }
TEST(AgradRev,abs_var_3) { AVAR a = 0.0; AVAR f = abs(a); EXPECT_FLOAT_EQ(0.0, f.val()); AVEC x = createAVEC(a); VEC g; f.grad(x,g); EXPECT_EQ(1,g.size()); EXPECT_FLOAT_EQ(0.0, g[0]); }
void test_sort_indices_asc(VEC val) { using stan::math::sort_indices_asc; AVEC x; for(size_t i=0U; i<val.size(); i++) x.push_back(AVAR(val[i])); std::vector<int> val_sorted = sort_indices_asc(val); std::vector<int> x_sorted = sort_indices_asc(x); for(size_t i=0U; i<val.size(); i++) EXPECT_EQ(val_sorted[i],x_sorted[i]); for(size_t i=0U; i<val.size(); i++) for(size_t j=0U; j<val.size(); j++) if(val_sorted[i] == val[j]) EXPECT_EQ(x_sorted[i],x[j]); else EXPECT_FALSE(x_sorted[i]==x[j]); }
void test_sort_asc(VEC val) { using stan::math::sort_asc; using stan::agrad::sort_asc; AVEC x; for(size_t i=0U; i<val.size(); i++) x.push_back(AVAR(val[i])); VEC val_sorted = sort_asc(val); AVEC x_sorted = sort_asc(x); for(size_t i=0U; i<val.size(); i++) EXPECT_EQ(val_sorted[i],x_sorted[i].val()); for(size_t i=0U; i<val.size(); i++) for(size_t j=0U; j<val.size(); j++) if(val_sorted[i] == val[j]) EXPECT_EQ(x_sorted[i],x[j]); else EXPECT_FALSE(x_sorted[i]==x[j]); }
TEST(AgradRev,abs_NaN) { AVAR a = std::numeric_limits<double>::quiet_NaN(); AVAR f = abs(a); AVEC x = createAVEC(a); VEC g; f.grad(x,g); EXPECT_TRUE(boost::math::isnan(f.val())); ASSERT_EQ(1,g.size()); EXPECT_TRUE(boost::math::isnan(g[0])); }
static void findLocalMinima( const vector<mz_uint>& maxIndexes, const VEC& data, vector<PeakAsMaximaMinimaIndexes>& peaks ) { for (auto it = maxIndexes.begin(); it != maxIndexes.end(); ++it ) { mz_uint maxIndex = *it; //---leftval can not be less than 0, data never empty mz_uint leftVal = std::max<unsigned int>(maxIndex - 1, 0); int i = maxIndex - 2; while ( i >= 0 ){ if ( data[i] > data[leftVal] ) { break; } leftVal = i; i--; } //---rightval can not be greater than the data size less 1 mz_uint rightVal = std::min<unsigned int>(maxIndex + 1, data.size() - 1); i = maxIndex + 2; while( i < data.size() ) { if ( data[i] > data[rightVal] ) { break; } rightVal = i; i++; } PeakAsMaximaMinimaIndexes peakAsIndexes(maxIndex); if (leftVal != maxIndex) peakAsIndexes.leftMin = leftVal; if ( rightVal != maxIndex ) peakAsIndexes.rightMin = rightVal; peaks.push_back(peakAsIndexes); } }
TEST(AgradRevMatrix, meanStdVector) { using stan::math::mean; // should use arg-dep lookup AVEC x(0); EXPECT_THROW(mean(x), std::domain_error); x.push_back(1.0); EXPECT_FLOAT_EQ(1.0, mean(x).val()); x.push_back(2.0); EXPECT_FLOAT_EQ(1.5, mean(x).val()); AVEC y = createAVEC(1.0,2.0); AVAR f = mean(y); VEC grad = cgrad(f, y[0], y[1]); EXPECT_FLOAT_EQ(0.5, grad[0]); EXPECT_FLOAT_EQ(0.5, grad[1]); EXPECT_EQ(2U, grad.size()); }
void report_multiplication_error(const SparseKalmanMatrix *T, const SparseVector &Z, bool new_time, double fraction_in_initial_period, const VEC &v) { ostringstream err; int state_dim = T->nrow(); err << "incompatible sizes in AccumulatorTransitionMatrix multiplication" << endl << "T.nrow() = " << state_dim << endl << "Z.size() = " << Z.size() << endl << "v.size() = " << v.size() << endl << "The first two should match. The last should be two more " << "than the others" << endl; report_error(err.str()); }
static void generate_transition_matrix(VEC const& weights, MAT& tm) { using std::abs; typedef typename VEC::value_type value_type; std::size_t n = weights.size(); std::vector<double> accum(n+1, 0); double sum = std::accumulate(weights.begin(), weights.end(), 0.0); double shift = *(std::max_element(weights.begin(), weights.end())) / sum; accum[0] = 0; for (std::size_t i = 0; i < n; ++i) accum[i+1] = accum[i] + weights[i] / sum; for (std::size_t i = 0; i < n; ++i) { for (std::size_t j = 0; j < n; ++j) { tm[i][j] = (std::max(std::min(accum[i+1] + shift, accum[j+1]) - std::max(accum[i] + shift, accum[j]), 0.0) + std::max(std::min(accum[i+1] + shift, accum[j+1] + 1) - std::max(accum[i] + shift, accum[j] + 1), 0.0)) / (weights[i] / sum); } } }
static void generate_transition_matrix(VEC const& weights, MAT& tm) { using std::abs; typedef typename VEC::value_type value_type; std::size_t n = weights.size(); for (std::size_t i = 0; i < n; ++i) { tm[i][i] = 1; if (weights[i] > 0) { for (std::size_t j = 0; j < n; ++j) { if (i != j) { tm[i][j] = std::min(weights[i], weights[j]) / weights[i] / (n-1); tm[i][i] -= tm[i][j]; } } tm[i][i] = abs(tm[i][i]); } else { for (std::size_t j = 0; j < n; ++j) if (i != j) tm[i][j] = value_type(0); } } }
int main(void) { PROBLEMS problems; for (int index = 0; true; index++) { Mnd mnd; cin >> mnd.m >> mnd.n >> mnd.d; if (mnd.m == 0 && mnd.n == 0 && mnd.d == 0) { break; } vector<int> input; for (int i = 0; i < mnd.n*mnd.m; i++) { int number; cin >> number; input.push_back(number); } problems.insert(PROBLEMS::value_type(mnd, make_pair(input, index))); } VEC answers = solves(problems); for (int i = 0; i < answers.size(); i++) { cout << answers[i] << endl; } }
//---------------------------------------------------------------------- MAT EEMD::eemdf90( VEC input, float noise_amplitude, int num_imfs, int num_ensembles ) { // Obtain a pointer to the data in the input array for the Fortran function float* indata = input.memptr(); int length = input.size(); int seed = tools->getRand(); // C++ random seed for the F90 random number generator float* result = new float[length*(num_imfs+2)]; // Store the results // Call the Fortran subroutine eemd_( length, indata, noise_amplitude, num_ensembles, num_imfs, seed, result ); // Create the resulting armadillo structure to store the result MAT imfs(result,length,num_imfs+2); // The last column of the result is the residue (from F90 documentation // in file eemdf90/eemd.f90) residual = imfs.col(num_imfs+1); imfs.shed_col(num_imfs+1); // The Very first column is the original signal (from F90 documentation // in file eemdf90/eemd.f90) VEC f90_input = imfs.col(0); imfs.shed_col(0); // A sanity check to help see if the F90 result makes any sense float diff = norm( f90_input-input, 2 ); if( diff > .1 && false ) { printf( "\n\tFortran input signal differs from the C++ input signal by %f \n", diff); //for( int i=0; i<length; i++ ) { // printf( "C++[%d] = %f \t F90[%d] = %f\n", i, input[i], i, f90_input[i] ); //} exit(EXIT_FAILURE); } return imfs; }
TEST(StanAgradRevInternal, precomp_vv_vari) { double value, gradient1, gradient2; AVAR x1(2), x2(3); AVAR y; value = 1; gradient1 = 4; gradient2 = 5; AVEC vars = createAVEC(x1, x2); EXPECT_NO_THROW(y = stan::math::var(new stan::math::precomp_vv_vari(value, x1.vi_, x2.vi_, gradient1, gradient2))); EXPECT_FLOAT_EQ(value, y.val()); VEC g; EXPECT_NO_THROW(y.grad(vars, g)); ASSERT_EQ(2U, g.size()); EXPECT_FLOAT_EQ(gradient1, g[0]); EXPECT_FLOAT_EQ(gradient2, g[1]); stan::math::recover_memory(); }
TEST(AgradRevMatrix,log_determinant_ldlt) { using stan::math::matrix_v; stan::math::LDLT_factor<stan::math::var,-1,-1> ldlt_v; matrix_v v(2,2); v << 1, 0, 0, 3; ldlt_v.compute(v); ASSERT_TRUE(ldlt_v.success()); AVAR f; AVEC v_vec = createAVEC(v(0,0), v(0,1), v(1,0), v(1,1)); VEC grad; f = log_determinant_ldlt(ldlt_v); f.grad(v_vec, grad); // derivative is: 1/det(A) * adj(A) EXPECT_FLOAT_EQ(std::log(3.0), f.val()); ASSERT_EQ(4U, grad.size()); EXPECT_FLOAT_EQ(1.0, grad[0]); EXPECT_FLOAT_EQ(0, grad[1]); EXPECT_FLOAT_EQ(0, grad[2]); EXPECT_FLOAT_EQ(1.0/3.0, grad[3]); }
ConstVectorView subvector(const VEC &v, uint start){ return ConstVectorView(v.data()+ start, v.size()-start, v.stride()); }
static void generate_transition_matrix_resize(VEC const& weights, MAT& tm) { std::size_t n = weights.size(); tm.resize(n); for (std::size_t i = 0; i < n; ++i) tm[i].resize(n); generate_transition_matrix(weights, tm); }
static std::size_t choose_next(VEC const& weights, std::size_t present, RNG& rng) { std::size_t proposal = weights.size() * rng(); return (weights(present) * rng() < weights(proposal)) ? proposal : present; }
ConstVectorView subvector(const VEC &v, uint start, uint stop){ assert(start<=stop && start <v.size()); uint size = 1+stop-start; return ConstVectorView(v.data()+ start, size, v.stride()); }