//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());
}
