static double
nmsimplex_size (nmsimplex_state_t * state)
{
/* calculates simplex size as average sum of length of vectors
from simplex center to corner points:
( sum ( || y - y_middlepoint || ) ) / n
*/
gsl_vector *s = state->ws1;
gsl_vector *mp = state->ws2;
gsl_matrix *x1 = state->x1;
size_t i;
double ss = 0.0;
/* Calculate middle point */
nmsimplex_calc_center (state, mp);
for (i = 0; i < x1->size1; i++)
{
gsl_matrix_get_row (s, x1, i);
gsl_blas_daxpy (-1.0, mp, s);
ss += gsl_blas_dnrm2 (s);
}
return ss / (double) (x1->size1);
}
// get the row vector
vector< double > Matrix::getRow( int row ) const
{
gsl_vector* v = gsl_vector_alloc( nCols() );
gsl_matrix_get_row( v, data, row );
//qcheng75
vector<double> ret=gsl2vector( v, 0);
gsl_vector_free(v);
return ret;
//return gsl2vector( v );
}
void ccl_mat_transpose(const double* mat,int i, int j,double* mat_T){
gsl_matrix * mat_ = gsl_matrix_alloc(i,j);
memcpy(mat_->data,mat,i*j*sizeof(double));
gsl_matrix mat_T_ = gsl_matrix_view_array(mat_T,j,i).matrix;
gsl_vector * vec = gsl_vector_alloc(j);
int row, col;
for (row=0;row<i;row++){
gsl_matrix_get_row(vec,mat_,row);
gsl_matrix_set_col(&mat_T_,row,vec);
}
gsl_vector_free(vec);
gsl_matrix_free(mat_);
}
void GbA::compute_likelihood(double *data, int nstats, int nbands, int nsim,
double mean[2], double cov[2][2]){
int i, j, k, l, idx;
gsl_vector *lsq = gsl_vector_alloc (_td->get_noftraces());
gsl_vector *input = gsl_vector_alloc (nbands);
gsl_vector *trace = gsl_vector_alloc (nbands);
double *mags, *dists;
double misfit_l2;
size_t *indices = new size_t[nsim];
mags = new double[nsim];
dists = new double[nsim];
for (i=0; i<nstats; i++){
for (j=0; j<nbands; j++){
gsl_vector_set(input, j, std::log10(data[i*nbands+j]));
}
for (k=0; k<_td->get_noftraces(); k++){
gsl_matrix_get_row(trace, _td->_tdata_gsl, k);
gsl_vector_sub(trace,input);
misfit_l2 = gsl_blas_dnrm2(trace);
gsl_vector_set(lsq, k, misfit_l2*misfit_l2);
}
gsl_sort_vector_smallest_index(indices, nsim,lsq);
mean[0] = 0;
mean[1] = 0;
for(l=0; l<nsim; l++){
dists[l] = std::log10(gsl_vector_get(_td->_r_gsl, indices[l]));
mags[l] = gsl_vector_get(_td->_m_gsl, indices[l]);
//std::cout << gsl_vector_get(_td->_m_gsl,indices[l]) << std::endl;
}
mean[0] = gsl_stats_mean(dists,1,nsim);
mean[1] = gsl_stats_mean(mags,1,nsim);
cov[0][0] = gsl_stats_variance(dists, 1, nsim);
cov[1][1] = gsl_stats_variance(mags, 1, nsim);
cov[0][1] = gsl_stats_covariance_m(dists,1,mags,1,nsim,mean[0],mean[1]);
cov[1][0] = cov[0][1];
std::cout << "Distance: " << mean[0] << "; Magnitude: " << mean[1] << std::endl;
std::cout << "Covariance matrix:" << std::endl;
for(i=0; i<2; i++){
for(j=0;j<2;j++){
printf("%d, %d, %g\n",i,j,cov[i][j]);
}
}
}
}
int stack_matrix_array(gsl_matrix ** pieces, size_t N,gsl_matrix * m_assembled) {
/* First pieces fix the width */
size_t width = pieces[0]->size2;
gsl_vector * v_T = gsl_vector_calloc(width);
size_t i;
size_t offset = 0;
for(i = 0; i < N; i++) {
size_t j;
size_t height = pieces[i]->size1;
for(j = 0; j < height; j++) {
gsl_matrix_get_row(v_T,pieces[i],j); /* Take a slice */
gsl_matrix_set_row(m_assembled,offset+j,v_T);
}
offset += height;
}
gsl_vector_free(v_T);
}
void ccl_mat_var(const double* data_in,int row,int col,int axis,double * var){
int i;
gsl_matrix * m = gsl_matrix_alloc(row,col);
memcpy(m->data,data_in,row*col*sizeof(double));
if (axis==0){// for x axis
gsl_vector *v= gsl_vector_alloc(col);
for (i=0;i<row;i++){
gsl_matrix_get_row(v,m,i);
var[i] = gsl_stats_variance(v->data,1,v->size);
}
gsl_vector_free(v);
}
else if(axis==1){// for y axis
gsl_vector *v= gsl_vector_alloc(row);
for (i=0;i<col;i++){
gsl_matrix_get_col(v,m,i);
var[i] = gsl_stats_variance(v->data,1,v->size);
}
gsl_vector_free(v);
}
gsl_matrix_free(m);
}
void ccl_mat_mean(const double *mat,const int i, const int j,const int axis,double*val){
gsl_matrix * mat_ = gsl_matrix_alloc(i,j);
memcpy(mat_->data,mat,i*j*sizeof(double));
int k;
if (axis == 0){// x axis
gsl_vector * vec = gsl_vector_alloc(j);
for (k=0;k<i;k++){
gsl_matrix_get_row(vec,mat_,k);
val[k] = gsl_stats_mean(vec->data,1,j);
}
gsl_vector_free(vec);
}
if (axis == 1){// y axis
gsl_vector * vec = gsl_vector_alloc(i);
for (k=0;k<i;k++){
gsl_matrix_get_col(vec,mat_,k);
val[k] = gsl_stats_mean(vec->data,1,i);
}
gsl_vector_free(vec);
}
gsl_matrix_free(mat_);
}
void ccl_mat_sum(const double *mat, const int i, const int j,const int axis, double * ret){
int k;
gsl_matrix * mat_ = gsl_matrix_alloc(i,j);
memcpy(mat_->data,mat,i*j*sizeof(double));
if (axis == 0){// x axis sum
gsl_vector* vec = gsl_vector_alloc(j);
for (k = 0;k<i;k++){
gsl_matrix_get_row(vec,mat_,k);
ret[k] = ccl_vec_sum(vec->data,j);
}
gsl_vector_free(vec);
}
else {
gsl_vector* vec = gsl_vector_alloc(i);
for (k = 0;k<j;k++){
gsl_matrix_get_col(vec,mat_,k);
ret[k] = ccl_vec_sum(vec->data,i);
}
gsl_vector_free(vec);
}
gsl_matrix_free(mat_);
}
static int
nmsimplex_contract_by_best (nmsimplex_state_t * state, size_t best,
gsl_vector * xc, gsl_multimin_function * f)
{
/* Function contracts the simplex in respect to
best valued corner. That is, all corners besides the
best corner are moved. */
/* the xc vector is simply work space here */
gsl_matrix *x1 = state->x1;
gsl_vector *y1 = state->y1;
size_t i, j;
double newval;
for (i = 0; i < x1->size1; i++)
{
if (i != best)
{
for (j = 0; j < x1->size2; j++)
{
newval = 0.5 * (gsl_matrix_get (x1, i, j)
+ gsl_matrix_get (x1, best, j));
gsl_matrix_set (x1, i, j, newval);
}
/* evaluate function in the new point */
gsl_matrix_get_row (xc, x1, i);
newval = GSL_MULTIMIN_FN_EVAL (f, xc);
gsl_vector_set (y1, i, newval);
}
}
return GSL_SUCCESS;
}
pure_expr* wrap_gsl_multifit_linear(gsl_matrix* X, gsl_matrix* y)
{
int i;
double chisq;
pure_expr *cx[X->size1];
double *p;
gsl_vector* c = gsl_vector_alloc(X->size1);
gsl_vector* yt = gsl_vector_alloc(X->size1);
gsl_matrix_get_row(yt, y, 0);
gsl_matrix* cov = gsl_matrix_alloc(X->size1, X->size2);
gsl_multifit_linear_workspace* w;
w = gsl_multifit_linear_alloc(X->size1, X->size2);
gsl_multifit_linear(X, yt, c, cov, &chisq, w);
gsl_multifit_linear_free(w);
gsl_vector_free(yt);
p = c->data;
for (i = 0; i < X->size1; ++i) {
cx[i] = pure_double(*p);
++p;
}
return pure_listl(3, pure_matrix_columnsv(X->size1, cx),
pure_double_matrix(cov), pure_double(chisq));
}
void GetMVNpdf(const gsl_matrix * mat, const double * mu, const gsl_matrix * sigmaInv, const gsl_matrix * sigmaChol, const size_t nPoints, const size_t nDim, double * returnVal)
{
double normConst = - log(2*M_PI)*nDim/2.0;
for(size_t j = 0; j < nDim; j++)
normConst -= log(gsl_matrix_get(sigmaChol, j, j));
gsl_vector_const_view vecMu = gsl_vector_const_view_array(mu, nDim);
#pragma omp parallel for
for(size_t i = 0; i < nPoints; i++){
gsl_vector * x1 = gsl_vector_alloc(nDim); // Note: allocating and freeing these every loop is not ideal, but needed for threadsafe. There might be a better way.
gsl_vector * x2 = gsl_vector_alloc(nDim);
gsl_matrix_get_row(x1, mat, i);
gsl_vector_sub(x1, &vecMu.vector);
gsl_blas_dsymv(CblasUpper, 1.0, sigmaInv, x1, 0.0, x2);
gsl_blas_ddot(x1, x2, &returnVal[i]);
returnVal[i] = exp(normConst - 0.5*returnVal[i]);
gsl_vector_free(x1);
gsl_vector_free(x2);
}
return;
}
void ccl_mat_min(const double * mat,const int i,const int j,const int axis,double* val,int* indx){
int k;
gsl_matrix * mat_ = gsl_matrix_alloc(i,j);
memcpy(mat_->data,mat,i*j*sizeof(double));
if (axis == 0){// x axis min
gsl_vector * vec = gsl_vector_alloc(j);
for (k=0;k<i;k++){
gsl_matrix_get_row(vec,mat_,k);
val[k] = gsl_vector_min(vec);
indx[k] = gsl_vector_min_index(vec);
}
gsl_vector_free(vec);
}
else{ // y axis min
gsl_vector * vec = gsl_vector_alloc(i);
for (k=0;k<j;k++){
gsl_matrix_get_col(vec,mat_,k);
val[k] = gsl_vector_min(vec);
indx[k] = gsl_vector_min_index(vec);
}
gsl_vector_free(vec);
}
gsl_matrix_free(mat_);
}
// simplex routine
// f is n dimensional function to be minimised, lower and upper are bounds of coordinates for initial vertices
// simplex_goal_size is tolerance for convergene and W is workspace for simplex routine of dimension n
// out termination the vector W->ce will contain coordinates for lowest vertex
int simplex(double f(gsl_vector* x),double lower, double upper, double simplex_goal_size, simplex_workspace* W)
{
int steps = 0;
double fp1, fp2, flo, fhi;
// initialize system by generating vertices and
// finding their function values
simplex_generate(lower,upper,W);
simplex_initialize(f,W);
do
{
// make an update for higher, lower and centroid
simplex_update(W);
fhi = gsl_vector_get(W->fp,W->hi);
flo = gsl_vector_get(W->fp,W->lo);
// make reflection
reflection(W);
fp1 = f(W->p1);
if (fp1 < flo)
{
// if f(reflected) < f(lower) attempt expansion
expansion(W);
fp2 = f(W->p2);
if (fp2 < fp1)
{
// if f(expanded) < f(reflecred) accept expansion
gsl_matrix_set_row(W->simplex,W->hi,W->p2);
gsl_vector_set(W->fp,W->hi,fp2);
}
else
{
// if not, accept reflection
gsl_matrix_set_row(W->simplex,W->hi,W->p1);
gsl_vector_set(W->fp,W->hi,fp1);
}
}
else
{
if (fp1 < fhi)
{
// if f(reflected) < f(higher) accept reflection
gsl_matrix_set_row(W->simplex,W->hi,W->p1);
gsl_vector_set(W->fp,W->hi,fp1);
}
else
{
// if not, attempt contraction
contraction(W);
fp2 = f(W->p2);
if (fp2 < fhi)
{
// if f(contracted) < f(higher), accept contraction
gsl_matrix_set_row(W->simplex,W->hi,W->p2);
gsl_vector_set(W->fp,W->hi,fp2);
}
else
{
// if not, we must be in a valley, perform reduction
reduction(f,W);
}
}
}
steps++;
// if simplex has reduced sufficiently, that is size(simplex) < simplex_goal_size
// convergence is achieved. Return number of steps before convergence.
} while (simplex_size(W) > simplex_goal_size);
// copy lowest vertex to centroid vector
gsl_matrix_get_row(W->ce,W->simplex,W->lo);
return steps;
}
void CrossVal(const gsl_matrix* XTrainData, const gsl_matrix* YTrainData, const gsl_matrix* XTestData,
const gsl_matrix* YTestData, const int FOLD, const double* Lambda, const int sizelambda, int* layer_sizes, int num_layers,
const int num_iterations, const int batch_size, const double step_size)
{
int N_obs = XTrainData->size1;
int YFeatures = YTrainData->size2;
int XFeatures = XTrainData->size2;
int GroupSize = N_obs/FOLD;
int Nlambda = sizelambda;
printf("________");
int* seq_fold;
seq_fold = rand_fold(N_obs,FOLD);
for (int i = 0; i < N_obs; i++){
printf("%d\n",seq_fold[i]);
}
gsl_matrix* Xfolds[FOLD];
for (int d = 0; d < FOLD; d++)
Xfolds[d] = gsl_matrix_alloc(GroupSize,XFeatures);
gsl_matrix* Yfolds[FOLD];
for (int d = 0; d < FOLD; d++)
Yfolds[d] = gsl_matrix_alloc(GroupSize,YFeatures);
SplitFoldfunc(XTrainData, FOLD, seq_fold, Xfolds);
SplitFoldfunc(YTrainData, FOLD, seq_fold, Yfolds);
gsl_matrix* CvTrainX[FOLD];
for (int d = 0; d < FOLD; d++)
CvTrainX[d] = gsl_matrix_calloc(GroupSize*(FOLD-1), XFeatures);
gsl_matrix* CvTrainY[FOLD];
for (int d = 0; d < FOLD; d++)
CvTrainY[d] = gsl_matrix_calloc(GroupSize*(FOLD-1), YFeatures);
combinefold(Xfolds, Yfolds, N_obs, FOLD, GroupSize, XFeatures, YFeatures, CvTrainX, CvTrainY);
gsl_vector* results_lambda;
results_lambda = gsl_vector_alloc((size_t) Nlambda);
double results[Nlambda][FOLD];
#pragma omp parallel for collapse(2)
for (int i = 0; i < Nlambda; i++){
for (int j = 0; j < FOLD; j++){
printf("Lambda=%G\n", Lambda[i]);
printf("fold not included = %d\n", j);
gsl_vector* vec_cv_trainX[N_obs-GroupSize];
for (int u = 0; u < (N_obs-GroupSize); u++ ){
vec_cv_trainX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < (N_obs-GroupSize); c++){
gsl_matrix_get_row(vec_cv_trainX[c], CvTrainX[j], c);
}
//for (int a = 0; a < (N_obs-GroupSize); a++){
//printf("%G %G\n",gsl_vector_get(vec_cv_trainX[a],0), gsl_vector_get(vec_cv_trainX[a],1));
//printf("%d\n", a);
//}
gsl_vector* vec_cv_trainY;
vec_cv_trainY = gsl_vector_alloc(N_obs-GroupSize);
gsl_matrix_get_col(vec_cv_trainY, CvTrainY[j], 0);
//for (int y = 0; y < (N_obs-GroupSize); y++){
//printf("%G\n",gsl_vector_get(vec_cv_trainY,y));
//printf("%d\n",y);
//}
//Note that always Y will be 1 column, so well defined.
gsl_matrix* output_weights[num_layers-1];
gsl_vector* output_biases[num_layers-1];
init_bias_object(output_biases, (layer_sizes+1), num_layers-1);
init_weight_object(output_weights, layer_sizes, num_layers);
printf("Lambda = %G\n",Lambda[i]);
NeuralNets(layer_sizes, num_layers, vec_cv_trainX, vec_cv_trainY, num_iterations, batch_size,
step_size, output_weights, output_biases, (N_obs-GroupSize), XFeatures, Lambda[i]);
gsl_vector* vec_cv_valX[GroupSize];
for (int u = 0; u < (GroupSize); u++){
vec_cv_valX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < GroupSize; c++){
gsl_matrix_get_row(vec_cv_valX[c], Xfolds[j], c);
}
gsl_vector* vec_cv_valY;
vec_cv_valY = gsl_vector_alloc(GroupSize);
gsl_matrix_get_col(vec_cv_valY, Yfolds[j], 0);
results[i][j] = correct_guesses(vec_cv_valX, vec_cv_valY, output_biases, output_weights, GroupSize, num_layers, layer_sizes);
printf("Result=%G\n thread = %d\n",results[i][j],omp_get_thread_num());
gsl_vector_free(vec_cv_valY);
for (int u = 0; u < (GroupSize); u++){
gsl_vector_free(vec_cv_valX[u]);
}
gsl_vector_free(vec_cv_trainY);
for (int u = 0; u < (GroupSize); u++){
gsl_vector_free(vec_cv_trainX[u]);
}
printf("i=%d,j=%d,Fold=%d,Nlambda=%d\n",i , j, FOLD, Nlambda);
}
}
//gsl_vector* results_lambda;
//results_lambda = gsl_vector_alloc((size_t) Nlambda);
double results_mean_fold[Nlambda];
for (int w = 0; w < Nlambda; w++)
results_mean_fold[w] = 0;
for (int s = 0; s < Nlambda ; s++){
for (int m = 0; m < FOLD ; m++){
printf("Result = %G\n", results[s][m]);
}
}
for (int s = 0; s < Nlambda ; s++){
for (int m = 0; m < FOLD ; m++){
results_mean_fold[s] = results[s][m]+ results_mean_fold[s];
}
gsl_vector_set(results_lambda, s, results_mean_fold[s]/(FOLD));
}
for (int s = 0; s < Nlambda ; s++){
printf("Lambda = %G, Success = %G\n", Lambda[s], gsl_vector_get(results_lambda, s));
}
double OptimalLambda = gsl_vector_max(results_lambda);
printf("Optimal Lambda = %G\n", OptimalLambda);
gsl_matrix* output_weights_all[num_layers-1];
gsl_vector* output_biases_all[num_layers-1];
init_bias_object(output_biases_all, (layer_sizes+1), num_layers-1);
init_weight_object(output_weights_all, layer_sizes, num_layers);
gsl_vector* vec_cv_trainX_all[N_obs];
for (int u = 0; u < (N_obs); u++){
vec_cv_trainX_all[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < N_obs; c++){
gsl_matrix_get_row(vec_cv_trainX_all[c], XTrainData, c);
}
gsl_vector* vec_cv_trainY_all;
vec_cv_trainY_all = gsl_vector_alloc(N_obs);
gsl_matrix_get_col(vec_cv_trainY_all, YTrainData, 0);
NeuralNets(layer_sizes, num_layers, vec_cv_trainX_all, vec_cv_trainY_all, num_iterations, batch_size,
step_size, output_weights_all, output_biases_all, N_obs, XFeatures, OptimalLambda);
int N_obs_test = XTestData->size1;
gsl_vector* vec_cv_testX[N_obs_test];
for (int u = 0; u < (N_obs_test); u++){
vec_cv_testX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < N_obs_test; c++){
gsl_matrix_get_row(vec_cv_testX[c], XTestData, c);
}
gsl_vector* vec_cv_testY;
vec_cv_testY = gsl_vector_alloc(N_obs_test);
gsl_matrix_get_col(vec_cv_testY, YTestData, 0);
//Note that always Y will be 1 column, so well defined.
double Test_error = correct_guesses(vec_cv_testX, vec_cv_testY, output_biases_all, output_weights_all, N_obs_test, num_layers, layer_sizes);
printf("Test Error =%G\n",1.0-Test_error);
}
void checkSLE(const gsl_matrix* A, const gsl_vector* x,
const gsl_vector* b, const int N) {
// TODO - make complete logging to the file
// print("Checking the solution of the SLE ... ");
// Checking on condition number of matrix A
int signum;
gsl_permutation *perm = gsl_permutation_alloc(N);
gsl_matrix *LU = gsl_matrix_alloc(N, N);
gsl_matrix *invA = gsl_matrix_alloc(N, N);
gsl_matrix_memcpy(LU, A);
gsl_linalg_LU_decomp(LU, perm, &signum);
gsl_linalg_LU_invert(LU, perm, invA);
gsl_matrix_free(LU);
gsl_permutation_free(perm);
gsl_vector *row = gsl_vector_alloc(N);
double normA = 0;
double normInvA = 0;
for(int i = 0; i < N; i++) {
gsl_matrix_get_row(row, A, i);
double dasum = gsl_blas_dasum(row);
if (dasum > normA) normA = dasum;
gsl_matrix_get_row(row, invA, i);
dasum = gsl_blas_dasum(row);
if (dasum > normInvA) normInvA = dasum;
}
double conditionNumber = normA * normInvA;
if (conditionNumber > 1000)
//print("Condition number of matrix of SLE is ", conditionNumber);
gsl_vector_free(row);
// Checking on Ax == b
gsl_vector *tmp = gsl_vector_alloc(N);
gsl_vector_memcpy(tmp, b);
// tmp = A*x - b, i.e. error
gsl_blas_dgemv(CblasNoTrans, 1, A, x, -1, tmp);
for(int i = 0; i < N; i++) {
if (fabs(gsl_vector_get(tmp, i) / gsl_vector_get(b, i)) > 1e-8) {
if (gsl_vector_get(b, i) == 0) {
if (fabs(gsl_vector_get(tmp, i)) > 1e-8)
print("Ax =", gsl_vector_get(tmp, i), "at string", i,
". But b = 0 here.");
} else {
print("( Ax - b ) / b =",
gsl_vector_get(tmp, i) / gsl_vector_get(b, i),
"at string", i);
}
}
}
// Checking on inv(A)b == x
gsl_vector_memcpy(tmp, x);
// tmp = inv(A)*b - x, i.e. error
gsl_blas_dgemv(CblasNoTrans, 1, invA, b, -1, tmp);
for(int i = 0; i < N; i++) {
if (fabs(gsl_vector_get(tmp, i) / gsl_vector_get(x, i)) > 1e-8)
print("( inv(A)b - x ) / x =",
gsl_vector_get(tmp, i) / gsl_vector_get(x, i),
"at string ", i);
}
gsl_vector_free(tmp);
gsl_matrix_free(invA);
// TODO - make complete logging to the file
// print("Checking is done.");
}
int lseShurComplement(gsl_matrix * A, gsl_matrix * C,
gsl_vector * b, gsl_vector * d,
gsl_vector * x, gsl_vector * lambda, double * sigma)
{
int i;
double xi;
gsl_vector *c0, *S, *tau;
gsl_matrix *CT, *U;
gsl_permutation *perm;
gsl_vector_view row, cp;
gsl_matrix_view R;
if (A->size2 != C->size2) return -1;
if (A->size2 != x->size) return -1;
if (A->size1 < A->size2) return -1;
if (b != NULL && A->size1 != b->size) return -1;
if (C->size1 != d->size) return -1;
if (C->size1 != lambda->size) return -1;
c0 = gsl_vector_alloc(x->size);
gsl_matrix_get_row(c0, C, 0);
/* Cholesky factorization of A^T A = R^T R via QRPT decomposition */
perm = gsl_permutation_alloc(x->size);
tau = gsl_vector_alloc(x->size);
gsl_linalg_QRPT_decomp(A, tau, perm, &i, x);
/* cp = R^{-T} P A^T b = Q^T b */
if (b != NULL) {
gsl_linalg_QR_QTvec(A, tau, b);
cp = gsl_vector_subvector(b, 0, x->size);
}
gsl_vector_free(tau);
/* C P -> C */
R = gsl_matrix_submatrix(A, 0, 0, A->size2, A->size2);
for (i = 0; i < C->size1; ++i) {
row = gsl_matrix_row(C, i);
gsl_permute_vector(perm, &row.vector);
}
/* Compute C inv(R) -> C */
gsl_blas_dtrsm(CblasRight, CblasUpper, CblasNoTrans, CblasNonUnit, 1.0,
&R.matrix, C);
/* The Schur complement D = C C^T,
Compute SVD of D = U S^2 U^T by SVD of C^T = V S U^T */
CT = gsl_matrix_alloc(C->size2, C->size1);
gsl_matrix_transpose_memcpy(CT, C);
U = gsl_matrix_alloc(CT->size2, CT->size2);
S = gsl_vector_alloc(CT->size2);
gsl_linalg_SV_decomp(CT, U, S, lambda);
/* Right hand side of the Shur complement system
d - C (A^T A)^-1 A^T b = d - C cp -> d
(with C P R^-1 -> C and R^-T P^T A^T b -> cp) */
if (b != NULL) {
gsl_blas_dgemv(CblasNoTrans, -1.0, C, &cp.vector, 1.0, d);
}
/* Calculate S U^T lambda, where -lambda is the Lagrange multiplier */
gsl_blas_dgemv(CblasTrans, 1.0, U, d, 0.0, lambda);
gsl_vector_div(lambda, S);
/* Calculate sigma = || A x ||_2 = || x ||_2 (before inv(R) x -> x) */
*sigma = gsl_blas_dnrm2(lambda);
/* Compute inv(R)^T C^T lambda = C^T lambda (with C inv(R) ->C) */
gsl_blas_dgemv(CblasNoTrans, 1.0, CT, lambda, 0.0, x);
/* x = inv(A^T A) C^T lambda = inv(R) [inv(R)^T C^T lambda] */
if (R.matrix.data[R.matrix.size1 * R.matrix.size2 - 1] != 0.0) {
gsl_blas_dtrsv(CblasUpper, CblasNoTrans, CblasNonUnit, &R.matrix, x);
}
else { /* Special case when A is singular */
gsl_vector_set_basis(x, x->size - 1);
*sigma = 0.0;
}
/* Permute back, 1-step iterative refinement on first constraint */
gsl_permute_vector_inverse(perm, x);
gsl_blas_ddot(x, c0, &xi);
gsl_vector_scale(x, d->data[0] / xi);
/* get the real lambda from S U^T lambda previously stored in lambda */
gsl_vector_div(lambda, S);
gsl_vector_memcpy(S, lambda);
gsl_blas_dgemv(CblasNoTrans, 1.0, U, S, 0.0, lambda);
gsl_vector_free(c0);
gsl_vector_free(S);
gsl_matrix_free(U);
gsl_matrix_free(CT);
gsl_permutation_free(perm);
return 0;
}
static int
nmsimplex_iterate (void *vstate, gsl_multimin_function * f,
gsl_vector * x, double *size, double *fval)
{
/* Simplex iteration tries to minimize function f value */
/* Includes corrections from Ivo Alxneit <*****@*****.**> */
nmsimplex_state_t *state = (nmsimplex_state_t *) vstate;
/* xc and xc2 vectors store tried corner point coordinates */
gsl_vector *xc = state->ws1;
gsl_vector *xc2 = state->ws2;
gsl_vector *y1 = state->y1;
gsl_matrix *x1 = state->x1;
size_t n = y1->size;
size_t i;
size_t hi = 0, s_hi = 0, lo = 0;
double dhi, ds_hi, dlo;
int status;
double val, val2;
/* get index of highest, second highest and lowest point */
dhi = ds_hi = dlo = gsl_vector_get (y1, 0);
for (i = 1; i < n; i++)
{
val = (gsl_vector_get (y1, i));
if (val < dlo)
{
dlo = val;
lo = i;
}
else if (val > dhi)
{
ds_hi = dhi;
s_hi = hi;
dhi = val;
hi = i;
}
else if (val > ds_hi)
{
ds_hi = val;
s_hi = i;
}
}
/* reflect the highest value */
val = nmsimplex_move_corner (-1.0, state, hi, xc, f);
if (val < gsl_vector_get (y1, lo))
{
/* reflected point becomes lowest point, try expansion */
val2 = nmsimplex_move_corner (-2.0, state, hi, xc2, f);
if (val2 < gsl_vector_get (y1, lo))
{
gsl_matrix_set_row (x1, hi, xc2);
gsl_vector_set (y1, hi, val2);
}
else
{
gsl_matrix_set_row (x1, hi, xc);
gsl_vector_set (y1, hi, val);
}
}
/* reflection does not improve things enough */
else if (val > gsl_vector_get (y1, s_hi))
{
if (val <= gsl_vector_get (y1, hi))
{
/* if trial point is better than highest point, replace
highest point */
gsl_matrix_set_row (x1, hi, xc);
gsl_vector_set (y1, hi, val);
}
/* try one dimensional contraction */
val2 = nmsimplex_move_corner (0.5, state, hi, xc2, f);
if (val2 <= gsl_vector_get (y1, hi))
{
gsl_matrix_set_row (state->x1, hi, xc2);
gsl_vector_set (y1, hi, val2);
}
else
{
/* contract the whole simplex in respect to the best point */
status = nmsimplex_contract_by_best (state, lo, xc, f);
if (status != 0)
{
GSL_ERROR ("nmsimplex_contract_by_best failed", GSL_EFAILED);
}
}
}
else
{
/* trial point is better than second highest point.
Replace highest point by it */
gsl_matrix_set_row (x1, hi, xc);
gsl_vector_set (y1, hi, val);
}
/* return lowest point of simplex as x */
lo = gsl_vector_min_index (y1);
gsl_matrix_get_row (x, x1, lo);
*fval = gsl_vector_get (y1, lo);
/* Update simplex size */
*size = nmsimplex_size (state);
return GSL_SUCCESS;
}
void ccl_learn_lambda(const double * Un,const double *X,void (*J_func)(const double*,const int,double*),const int dim_b,const int dim_r,const int dim_n,const int dim_x,const int dim_u,LEARN_A_MODEL optimal){
LEARN_A_MODEL model;
double * centres,*var_tmp,*vec, *BX, *RnVn,*Rn,*Vn;
double variance;
int i,lambda_id;
gsl_matrix *Un_,*X_;
// J_fun = &Jacobian;
model.dim_b = dim_b;
model.dim_r = dim_r;
model.dim_x = dim_x;
model.dim_n = dim_n;
model.dim_t = dim_r-1;
model.dim_u = dim_u;
// calculate model.var
var_tmp = malloc(dim_u*sizeof(double));
ccl_mat_var(Un,dim_u,dim_n,0,var_tmp);
model.var = ccl_vec_sum(var_tmp,dim_u);
free(var_tmp);
Un_ = gsl_matrix_alloc(dim_u,dim_n);
memcpy(Un_->data,Un,dim_u*dim_n*sizeof(double));
X_ = gsl_matrix_alloc(dim_x,dim_n);
memcpy(X_->data,X,dim_x*dim_n*sizeof(double));
optimal.nmse = 1000000;
gsl_vector* X_col = gsl_vector_alloc(dim_x);
gsl_vector* Un_col = gsl_vector_alloc(dim_u);
gsl_matrix* Vn_container = gsl_matrix_alloc(dim_r,dim_n);
gsl_matrix_set_zero(Vn_container);
double* norm = malloc(dim_n*sizeof(double));
double* J_x = malloc(dim_r*dim_u*sizeof(double));
gsl_vector* Jx_Un = gsl_vector_alloc(dim_r);
int* id_keep = malloc(dim_n*sizeof(double));
for (i=0;i<dim_n;i++){
gsl_matrix_get_col(X_col,X_,i);
gsl_matrix_get_col(Un_col,Un_,i);
J_func(X_col->data,dim_x,J_x);
ccl_dot_product(J_x,dim_r,dim_u,Un_col->data,dim_u,1,Jx_Un->data);
gsl_matrix_set_col(Vn_container,i,Jx_Un);
norm[i] = gsl_blas_dnrm2(Jx_Un);
}
// here dim_n maybe change.
int new_dim_n = ccl_find_index_double(norm,dim_n,2,1E-3,id_keep);
model.dim_n = new_dim_n;
Vn = malloc(dim_r*model.dim_n*sizeof(double));
gsl_matrix Vn_ = gsl_matrix_view_array(Vn,dim_r,model.dim_n).matrix;
gsl_matrix*X_new = gsl_matrix_alloc(dim_x,model.dim_n);
gsl_matrix*Un_new = gsl_matrix_alloc(dim_u,model.dim_n);
for (i=0;i<new_dim_n;i++){
gsl_vector* Vn_tmp = gsl_vector_alloc(dim_r);
gsl_matrix_get_col(Vn_tmp,Vn_container,id_keep[i]);
gsl_matrix_set_col(&Vn_,i,Vn_tmp);
gsl_vector_free(Vn_tmp);
Vn_tmp = gsl_vector_alloc(dim_x);
gsl_matrix_get_col(Vn_tmp,X_,id_keep[i]);
gsl_matrix_set_col(X_new,i,Vn_tmp);
gsl_vector_free(Vn_tmp);
Vn_tmp = gsl_vector_alloc(dim_u);
gsl_matrix_get_col(Vn_tmp,Un_,id_keep[i]);
gsl_matrix_set_col(Un_new,i,Vn_tmp);
gsl_vector_free(Vn_tmp);
}
gsl_vector_free(Jx_Un);
gsl_vector_free(X_col);
gsl_vector_free(Un_col);
gsl_matrix_free(Vn_container);
gsl_matrix_free(Un_);
free(J_x);
free(norm);
free(id_keep);
// prepare for BX
centres = malloc(dim_x*dim_b*sizeof(double));
generate_kmeans_centres(X_new->data,dim_x,model.dim_n,dim_b,centres);
var_tmp = malloc(dim_b*dim_b*sizeof(double));
vec = malloc(dim_b*sizeof(double));
ccl_mat_distance(centres,dim_x,dim_b,centres,dim_x,dim_b,var_tmp);
for (i=0;i<dim_b*dim_b;i++){
var_tmp[i] = sqrt(var_tmp[i]);
}
ccl_mat_mean(var_tmp,dim_b,dim_b,1,vec);
variance = pow(gsl_stats_mean(vec,1,dim_b),2);
BX = malloc(dim_b*model.dim_n*sizeof(double));
ccl_gaussian_rbf(X_new->data,dim_x,model.dim_n,centres,dim_x,dim_b,variance,BX);
gsl_matrix_free(X_new);
gsl_matrix_free(Un_new);
free(var_tmp);
free(vec);
Rn = malloc(dim_r*dim_r*sizeof(double));
gsl_matrix Rn_ = gsl_matrix_view_array(Rn,dim_r,dim_r).matrix;
gsl_matrix_set_identity(&Rn_);
RnVn = malloc(dim_r*model.dim_n*sizeof(double));
memcpy(RnVn,Vn,dim_r*model.dim_n*sizeof(double));
model.dim_u = model.dim_r;
ccl_learn_alpha_model_alloc(&model);
memcpy(model.c,centres,model.dim_x*model.dim_b*sizeof(double));
model.s2 = variance;
clock_t t = clock();
for(lambda_id=0;lambda_id<dim_r;lambda_id++){
model.dim_k = lambda_id+1;
// model.w[lambda_id] = malloc((dim_u-model.dim_k)*dim_b*sizeof(double*));
if(dim_r-model.dim_k==0){
model.dim_k = lambda_id;
break;
}
else{
search_learn_alpha(BX,RnVn,&model);
double* theta = malloc(model.dim_n*model.dim_t*sizeof(double));
double *W_BX = malloc((dim_r-model.dim_k)*model.dim_n*sizeof(double));
double *W_BX_T = malloc(model.dim_n*(dim_r-model.dim_k)*sizeof(double));
ccl_dot_product(model.w[lambda_id],dim_r-model.dim_k,dim_b,BX,dim_b,model.dim_n,W_BX);
ccl_mat_transpose(W_BX,dim_r-model.dim_k,model.dim_n,W_BX_T);
if (model.dim_k ==1){
memcpy(theta,W_BX_T,model.dim_n*(dim_r-model.dim_k)*sizeof(double));
}
else{
gsl_matrix* ones = gsl_matrix_alloc(model.dim_n,model.dim_k-1);
gsl_matrix_set_all(ones,1);
gsl_matrix_scale(ones,M_PI/2);
mat_hotz_app(ones->data,model.dim_n,model.dim_k-1,W_BX_T,model.dim_n,dim_r-model.dim_k,theta);
gsl_matrix_free(ones);
}
for(i=0;i<model.dim_n;i++){
gsl_matrix theta_mat = gsl_matrix_view_array(theta,model.dim_n,model.dim_t).matrix;
gsl_vector *vec = gsl_vector_alloc(model.dim_t);
gsl_matrix_get_row(vec,&theta_mat,i);
ccl_get_rotation_matrix(vec->data,Rn,&model,lambda_id,Rn);
gsl_vector_free(vec);
vec = gsl_vector_alloc(dim_r);
gsl_matrix_get_col(vec,&Vn_,i);
ccl_dot_product(Rn,dim_r,dim_r,vec->data,dim_r,1,vec->data);
gsl_matrix RnVn_ = gsl_matrix_view_array(RnVn,dim_r,model.dim_n).matrix;
gsl_matrix_set_col(&RnVn_,i,vec);
gsl_vector_free(vec);
}
if(model.nmse > optimal.nmse && model.nmse > 1E-5){
model.dim_k = lambda_id;
printf("\n I am out...\n");//optimal;
break;
}
else{
printf("\n copy model -> optimal\n");//optimal;
}
free(W_BX);
free(W_BX_T);
free(theta);
}
}
t = clock()-t;
printf("\n learning lambda used: %f second \n",((float)t)/CLOCKS_PER_SEC);
double* A = malloc(model.dim_k*model.dim_r*sizeof(double));
gsl_matrix* Iu = gsl_matrix_alloc(model.dim_r,model.dim_r);
gsl_matrix_set_identity(Iu);
gsl_vector* x = gsl_vector_alloc(model.dim_x);
gsl_matrix_get_col(x,X_,5);
// predict_proj_lambda(x->data, model,Jacobian,centres,variance,Iu->data,A);
// print_mat_d(A,model.dim_k,dim_r);
ccl_write_learn_lambda_model("/home/yuchen/Desktop/ccl-1.1.0/data/learn_lambda_model_l.txt", &model);
free(A);
gsl_matrix_free(Iu);
gsl_vector_free(x);
free(Vn);
free(Rn);
free(BX);
free(RnVn);
free(centres);
gsl_matrix_free(X_);
ccl_learn_alpha_model_free(&model);
}
main (int argc,char *argv[])
{
int ia,ib,ic,id,it,inow,ineigh,icont;
int in,ia2,ia3,irun,icurrent,ORTOGONALFLAG;
int RP, P,L,N,NRUNS,next,sweep,SHOWFLAG;
double u,field1,field2,field0,q,aux1,aux2;
double alfa,aux,Q1,Q2,QZ,RZQ,rho,R;
double pm,D,wmax,mQ,wx,wy,h_sigma,h_mean;
double TOL,MINLOGF,E;
double DELTA;
double E_new,Ex,DeltaE,ER;
double EW,meanhist,hvalue,wE,aratio;
double logG_old,logG_new,lf;
size_t i_old,i_new;
long seed;
double lGvR,lGv,DlG;
size_t iL,iR,i1,i2;
int I_endpoint[NBINS];
double lower,upper;
size_t i0;
FILE * wlsrange;
FILE * dos;
FILE * thermodynamics;
FILE * canonical;
FILE * logfile;
//FILE * pajek;
//***********************************
// Help
//***********************************
if (argc<15){
help();
return(1);
}
else{
DELTA = atof(argv[1]);
P = atoi(argv[2]);
RP = atoi(argv[3]);
L = atoi(argv[4]);
N = atoi(argv[5]);
TOL = atof(argv[6]);
MINLOGF = atof(argv[7]);
}
wlsrange=fopen(argv[8],"w");
dos=fopen(argv[9],"w");
thermodynamics=fopen(argv[10],"w");
canonical=fopen(argv[11],"w");
logfile=fopen(argv[12],"w");
SHOWFLAG = atoi(argv[13]);
ORTOGONALFLAG = atoi(argv[14]);
if ((ORTOGONALFLAG==1) && (P>L)) P=L;
//maximum number of orthogonal issues
if (SHOWFLAG==1){
printf("# parameters are DELTA=%1.2f P=%d ",DELTA,P);
printf("D=%d L=%d M=%d TOL=%1.2f MINLOGF=%g \n",L,N,RP,TOL,MINLOGF);
}
fprintf(logfile,"# parameters are DELTA=%1.2f P=%d D=%d",DELTA,P,L);
fprintf(logfile,"L=%d M=%d TOL=%1.2f MINLOGF=%g\n",L,RP,TOL,MINLOGF);
//**********************************************************************
// Alocate matrices
//**********************************************************************
gsl_matrix * sociedade = gsl_matrix_alloc(SIZE,L);
gsl_matrix * issue = gsl_matrix_alloc(P,L);
gsl_vector * current_issue = gsl_vector_alloc(L);
gsl_vector * v0 = gsl_vector_alloc(L);
gsl_vector * v1 = gsl_vector_alloc(L);
gsl_vector * Z = gsl_vector_alloc(L);
gsl_vector * E_borda = gsl_vector_alloc(NBINS);
//**********************************************************************
// Inicialization
//**********************************************************************
const gsl_rng_type * T;
gsl_rng * r;
gsl_rng_env_setup();
T = gsl_rng_default;
r=gsl_rng_alloc (T);
seed = time (NULL) * getpid();
//seed = 13188839657852;
gsl_rng_set(r,seed);
igraph_t graph;
igraph_vector_t neighbors;
igraph_vector_t result;
igraph_vector_t dim_vector;
igraph_real_t res;
igraph_bool_t C;
igraph_vector_init(&neighbors,1000);
igraph_vector_init(&result,0);
igraph_vector_init(&dim_vector,DIMENSION);
for(ic=0;ic<DIMENSION;ic++) VECTOR(dim_vector)[ic]=N;
gsl_histogram * HE = gsl_histogram_alloc (NBINS);
gsl_histogram * logG = gsl_histogram_alloc (NBINS);
gsl_histogram * LG = gsl_histogram_alloc (NBINS);
//********************************************************************
// Social Graph
//********************************************************************
//Barabasi-Alberts network
igraph_barabasi_game(&graph,SIZE,RP,&result,1,0);
/* for (inow=0;inow<SIZE;inow++){
igraph_neighbors(&graph,&neighbors,inow,IGRAPH_OUT);
printf("%d ",inow);
for(ic=0;ic<igraph_vector_size(&neighbors);ic++)
{
ineigh=(int)VECTOR(neighbors)[ic];
printf("%d ",ineigh);
}
printf("\n");
}*/
//pajek=fopen("graph.xml","w");
// igraph_write_graph_graphml(&graph,pajek);
//igraph_write_graph_pajek(&graph, pajek);
//fclose(pajek);
//**********************************************************************
//Quenched issues set and Zeitgeist
//**********************************************************************
gsl_vector_set_zero(Z);
gera_config(Z,issue,P,L,r,1.0);
if (ORTOGONALFLAG==1) gsl_matrix_set_identity(issue);
for (ib=0;ib<P;ib++)
{
gsl_matrix_get_row(current_issue,issue,ib);
gsl_blas_ddot(current_issue,current_issue,&Q1);
gsl_vector_scale(current_issue,1/sqrt(Q1));
gsl_vector_add(Z,current_issue);
}
gsl_blas_ddot(Z,Z,&QZ);
gsl_vector_scale(Z,1/sqrt(QZ));
//**********************************************************************
// Ground state energy
//**********************************************************************
double E0;
gera_config(Z,sociedade,SIZE,L,r,0);
E0 = hamiltoneana(sociedade,issue,SIZE,L,P,DELTA,graph);
double EMIN=E0;
double EMAX=-E0;
double E_old=E0;
gsl_histogram_set_ranges_uniform (HE,EMIN,EMAX);
gsl_histogram_set_ranges_uniform (logG,EMIN,EMAX);
if (SHOWFLAG==1) printf("# ground state: %3.0f\n",E0);
fprintf(logfile,"# ground state: %3.0f\n",E0);
//**********************************************************************
// Find sampling interval
//**********************************************************************
//printf("#finding the sampling interval...\n");
lf=1;
sweep=0;
icont=0;
int iflag=0;
int TMAX=NSWEEPS;
while(sweep<=TMAX){
if (icont==10000) {
//printf("%d sweeps\n",sweep);
icont=0;
}
for(it=0;it<SIZE;it++){
igraph_vector_init(&neighbors,SIZE);
//choose a random site
do{
inow=gsl_rng_uniform_int(r,SIZE);
}while((inow<0)||(inow>=SIZE));
gsl_matrix_get_row(v1,sociedade,inow);
igraph_neighbors(&graph,&neighbors,inow,IGRAPH_OUT);
//generates a random vector v1
gsl_vector_memcpy(v0,v1);
gera_vetor(v1,L,r);
//calculates energy change when v0->v1
// in site inow
DeltaE=variacaoE(v0,v1,inow,sociedade,
issue,N,L,P,DELTA,graph,neighbors);
E_new=E_old+DeltaE;
//WL: accepts in [EMIN,EMAX]
if ((E_new>EMIN) && (E_new<EMAX))
{
gsl_histogram_find(logG,E_old,&i_old);
logG_old=gsl_histogram_get(logG,i_old);
gsl_histogram_find(logG,E_new,&i_new);
logG_new=gsl_histogram_get(logG,i_new);
wE = GSL_MIN(exp(logG_old-logG_new),1);
if (gsl_rng_uniform(r)<wE){
E_old=E_new;
gsl_matrix_set_row(sociedade,inow,v1);
}
}
//WL: update histograms
gsl_histogram_increment(HE,E_old);
gsl_histogram_accumulate(logG,E_old,lf);
igraph_vector_destroy(&neighbors);
}
sweep++;
icont++;
}
gsl_histogram_fprintf(wlsrange,HE,"%g","%g");
double maxH=gsl_histogram_max_val(HE);
//printf("ok\n");
Ex=0;
hvalue=maxH;
while((hvalue>TOL*maxH)&&(Ex>EMIN)){
gsl_histogram_find(HE,Ex,&i0);
hvalue=gsl_histogram_get(HE,i0);
Ex-=1;
if(Ex<=EMAX)TMAX+=10000;
}
EMIN=Ex;
Ex=0;
hvalue=maxH;
while((hvalue>TOL*maxH)&&(Ex<EMAX)) {
gsl_histogram_find(HE,Ex,&i0);
hvalue=gsl_histogram_get(HE,i0);
Ex+=1;
if(Ex>=EMAX)TMAX+=10000;
}
EMAX=Ex;
EMAX=GSL_MIN(10.0,Ex);
if (SHOWFLAG==1)
printf("# the sampling interval is [%3.0f,%3.0f] found in %d sweeps \n\n"
,EMIN,EMAX,sweep);
fprintf(logfile,
"# the sampling interval is [%3.0f,%3.0f] found in %d sweeps \n\n"
,EMIN,EMAX,sweep);
gsl_histogram_set_ranges_uniform (HE,EMIN-1,EMAX+1);
gsl_histogram_set_ranges_uniform (logG,EMIN-1,EMAX+1);
gsl_histogram_set_ranges_uniform (LG,EMIN-1,EMAX+1);
//**********************************************************************
// WLS
//**********************************************************************
int iE,itera=0;
double endpoints[NBINS];
double w = WINDOW; //(EMAX-EMIN)/10.0;
//printf("W=%f\n",w);
lf=1;
//RESOLUTION ----> <------RESOLUTION*****
do{
int iverify=0,iborda=0,flat=0;
sweep=0;
Ex=EMAX;
EW=EMAX;
E_old=EMAX+1;
iE=0;
endpoints[iE]=EMAX;
iE++;
gsl_histogram_reset(LG);
//WINDOWS --> <--WINDOWS*******
while((Ex>EMIN)&&(sweep<MAXSWEEPS)){
//initial config
gera_config(Z,sociedade,SIZE,L,r,0);
E_old = hamiltoneana(sociedade,issue,SIZE,L,P,DELTA,graph);
while( (E_old<EMIN+1)||(E_old>Ex) ){
//printf("%d %3.1f\n",E_old);
do{
inow=gsl_rng_uniform_int(r,SIZE);
}while((inow<0)||(inow>=SIZE));
gsl_matrix_get_row(v0,sociedade,inow);
gera_vetor(v1,L,r);
gsl_matrix_set_row(sociedade,inow,v1);
E_old = hamiltoneana(sociedade,issue,SIZE,L,P,DELTA,graph);
if (E_old>Ex){
gsl_matrix_set_row(sociedade,inow,v0);
E_old = hamiltoneana(sociedade,issue,SIZE,L,P,DELTA,graph);
}
//printf("%3.1f %3.1f %3.1f\n",EMIN+1,E_old, Ex);
}
if (SHOWFLAG==1){
printf("# sampling [%f,%f]\n",EMIN,Ex);
printf("# walking from E=%3.0f\n",E_old);
}
fprintf(logfile,"# sampling [%f,%f]\n",EMIN,Ex);
fprintf(logfile,"# walking from E=%3.0f\n",E_old);
do{ //FLAT WINDOW------> <------FLAT WINDOW*****
//MC sweep ----> <------MC sweep********
for(it=0;it<SIZE;it++){
igraph_vector_init(&neighbors,SIZE);
//escolhe sítio aleatoriamente
do{
inow=gsl_rng_uniform_int(r,SIZE);
}while((inow<0)||(inow>=SIZE));
gsl_matrix_get_row(v1,sociedade,inow);
igraph_neighbors(&graph,&neighbors,inow,IGRAPH_OUT);
//gera vetor aleatorio v1
gsl_vector_memcpy(v0,v1);
gera_vetor(v1,L,r);
//calculates energy change when
//v0->v1 in site inow
DeltaE=variacaoE(v0,v1,inow,sociedade,issue,
N,L,P,DELTA,graph,neighbors);
E_new=E_old+DeltaE;
//WL: accepts in [EMIN,Ex]
if ((E_new>EMIN) && (E_new<Ex))
{
gsl_histogram_find(logG,E_old,&i_old);
logG_old=gsl_histogram_get(logG,i_old);
gsl_histogram_find(logG,E_new,&i_new);
logG_new=gsl_histogram_get(logG,i_new);
wE = GSL_MIN(exp(logG_old-logG_new),1);
if (gsl_rng_uniform(r)<wE){
E_old=E_new;
gsl_matrix_set_row(sociedade,inow,v1);
}
}
//WL: updates histograms
gsl_histogram_increment(HE,E_old);
gsl_histogram_accumulate(logG,E_old,lf);
itera++;
igraph_vector_destroy(&neighbors);
}
//MC sweep ----> <--------MC sweep****
sweep++; iverify++;
if( (EMAX-EMIN)<NDE*DE ) {
EW=EMIN;
}else{
EW=GSL_MAX(Ex-w,EMIN);
}
if (iverify==CHECK){//Verify flatness
if (SHOWFLAG==1)
printf(" #verificando flatness em [%f,%f]\n",EW,Ex);
fprintf(logfile," #verificando flatness em [%f,%f]\n"
,EW,Ex);
iverify=0;
flat=flatness(HE,EW,Ex,TOL,itera,meanhist,hvalue);
if (SHOWFLAG==1)
printf("#minH= %8.0f\t k<H>=%8.0f\t %d sweeps\t ",
hvalue,TOL*meanhist,sweep,flat);
fprintf(logfile,
"#minH= %8.0f\t k<H>=%8.0f\t %d sweeps\t ",
hvalue,TOL*meanhist,sweep,flat);
}
}while(flat==0);// <------FLAT WINDOW******
flat=0;
//Find ER
//printf("# EMAX=%f EMIN = %f Ex =%f\n",EMAX, EMIN, Ex);
if( (EMAX-EMIN)<NDE*DE ) {
Ex=EMIN;
endpoints[iE]=EMIN;
}
else {
if (EW>EMIN){
ER=flatwindow(HE,EW,TOL,meanhist);
if (SHOWFLAG==1)
printf("# extending flatness to[%f,%f]\n",ER,Ex);
fprintf(logfile,
"# extending flatness to [%f,%f]\n",ER,Ex);
if((ER-EMIN)<1){
ER=EMIN;
Ex=EMIN;
endpoints[iE]=EMIN;
}else{
endpoints[iE]=GSL_MIN(ER+DE,EMAX);
Ex=GSL_MIN(ER+2*DE,EMAX);
}
}
else{
endpoints[iE]=EMIN;
Ex=EMIN;
ER=EMIN;
}
}
if (SHOWFLAG==1)
printf("# window %d [%3.0f,%3.0f] is flat after %d sweeps \n",
iE,endpoints[iE],endpoints[iE-1],sweep);
fprintf(logfile,"# window %d [%3.0f,%3.0f] is flat after %d sweeps\n",
iE,endpoints[iE],endpoints[iE-1],sweep);
//saves histogram
if (iE==1){
gsl_histogram_find(logG,endpoints[iE],&i1);
gsl_histogram_find(logG,endpoints[iE-1],&i2);
for(i0=i1;i0<=i2;i0++){
lGv=gsl_histogram_get(logG,i0);
gsl_histogram_get_range(logG,i0,&lower,&upper);
E=0.5*(upper+lower);
gsl_histogram_accumulate(LG,E,lGv);
}
}else{
gsl_histogram_find(logG,endpoints[iE],&i1);
gsl_histogram_find(logG,endpoints[iE-1],&i2);
lGv=gsl_histogram_get(logG,i2);
lGvR=gsl_histogram_get(LG,i2);
DlG=lGvR-lGv;
//printf("i1=%d i2=%d lGv=%f lGvR=%f DlG=%f\n",i1,i2,lGv,lGvR,DlG);
for(i0=i1;i0<i2;i0++){
lGv=gsl_histogram_get(logG,i0);
lGv=lGv+DlG;
gsl_histogram_get_range(logG,i0,&lower,&upper);
E=(upper+lower)*0.5;
//printf("i0=%d E=%f lGv=%f\n",i0,E,lGv);
gsl_histogram_accumulate(LG,E,lGv);
}
}
//printf("#########################################\n");
//gsl_histogram_fprintf(stdout,LG,"%g","%g");
//printf("#########################################\n");
iE++;
if((Ex-EMIN)>NDE*DE) {
if (SHOWFLAG==1)
printf("# random walk is now restricted to [%3.0f,%3.0f]\n"
,EMIN,Ex);
fprintf(logfile,"# random walk is now restricted to [%3.0f,%3.0f]\n"
,EMIN,Ex);
}
gsl_histogram_reset(HE);
}
//WINDOWS -->
if(sweep<MAXSWEEPS){
if (SHOWFLAG==1)
printf("# log(f)=%f converged within %d sweeps\n\n",lf,sweep);
fprintf(logfile,"# log(f)=%f converged within %d sweeps\n\n",lf,sweep);
lf=lf/2.0;
gsl_histogram_reset(HE);
gsl_histogram_memcpy(logG,LG);
}else {
if (SHOWFLAG==1)
printf("# FAILED: no convergence has been attained.");
fprintf(logfile,
"# FAILED: no convergence has been attained. Simulation ABANDONED.");
return(1);
}
}while(lf>MINLOGF);
//RESOLUTION --> <-----RESOLUTION****
//*****************************************************************
//Density of states
//*****************************************************************
double minlogG=gsl_histogram_min_val(logG);
gsl_histogram_shift(logG,-minlogG);
gsl_histogram_fprintf(dos,logG,"%g","%g");
//*****************************************************************
//Thermodynamics
//*****************************************************************
double beta,A,wT,Zmin_beta;
double lGvalue,maxA,betaC,CTMAX=0;
double Z_beta,U,U2,CT,F,S;
for (beta=0.01;beta<=30;beta+=0.01)
{
//******************************************************************
//Energy, free-energy, entropy, specific heat and Tc
//******************************************************************
maxA=0;
for (ia2=0; ia2<NBINS;ia2++)
{
lGvalue=gsl_histogram_get(logG,ia2);
gsl_histogram_get_range(logG,ia2,&lower,&upper);
E=(lower+upper)/2;
A=lGvalue-beta*E;
if (A>maxA) maxA=A;
}
gsl_histogram_find(logG,EMIN,&i0);
Z_beta=0;U=0;U2=0;
for (ia2=0; ia2<NBINS;ia2++)
{
lGvalue=gsl_histogram_get(logG,ia2);
gsl_histogram_get_range(logG,ia2,&lower,&upper);
E=(lower+upper)/2;
A=lGvalue-beta*E-maxA;
Z_beta+=exp(A);
U+=E*exp(A);
U2+=E*E*exp(A);
if(ia2==i0) Zmin_beta=exp(A);
}
wT=Zmin_beta/Z_beta;
F=-log(Z_beta)/beta - maxA/beta;
U=U/Z_beta;
S= (U-F)*beta;
U2=U2/Z_beta;
CT=(U2-U*U)*beta*beta;
if(CT>CTMAX){
CTMAX=CT;
betaC=beta;
}
fprintf(thermodynamics,"%f %f %f %f %f %f %f \n"
,beta,1/beta,F/(double)(SIZE),S/(double)(SIZE),
U/(double)(SIZE),CT/(double)(SIZE),wT);
}
if (SHOWFLAG==1) printf("# BETAc: %f Tc:%f \n",betaC,1/betaC);
fprintf(logfile,"# BETAc: %f Tc:%f \n",betaC,1/betaC);
//******************************************************************
//canonical distribuition at Tc
//******************************************************************
beta=betaC;
double distr_canonica;
maxA=0;
for (ia2=0; ia2<NBINS;ia2++)
{
lGvalue=gsl_histogram_get(logG,ia2);
gsl_histogram_get_range(logG,ia2,&lower,&upper);
E=(lower+upper)/2;
A=lGvalue-beta*E;
if (A>maxA) maxA=A;
}
for (ia2=0; ia2<NBINS;ia2++)
{
lGvalue=gsl_histogram_get(logG,ia2);
gsl_histogram_get_range(logG,ia2,&lower,&upper);
E=(lower+upper)/2;
A=lGvalue-beta*E-maxA;
distr_canonica=exp(A);
fprintf(canonical,"%f %f %f\n",
E/(double)(SIZE),distr_canonica,A);
}
//*****************************************************************
// Finalization
//*****************************************************************
igraph_destroy(&graph);
igraph_vector_destroy(&neighbors);
igraph_vector_destroy(&result);
gsl_matrix_free(issue);
gsl_vector_free(current_issue);
gsl_vector_free(v1);
gsl_vector_free(v0);
gsl_matrix_free(sociedade);
gsl_rng_free(r);
fclose(wlsrange);
fclose(dos);
fclose(thermodynamics);
fclose(canonical);
fclose(logfile);
return(0);
}
// get the row vector
vector< double > Matrix::getRow( int row ) const
{
gsl_vector* v = gsl_vector_alloc( nCols() );
gsl_matrix_get_row( v, data, row );
return gsl2vector( v );
}
void CrossVal(const gsl_matrix* XTrainData, const gsl_matrix* YTrainData, const gsl_matrix* XTestData,
const gsl_matrix* YTestData, const int FOLD, const double* Lambda, const int sizelambda, const int* layer_sizes, const int num_layers,
const int num_iterations, const int core_size, const double step_size, const int trans_type, double* probs_test, int* predicted_test)
{
int* layer_sizes_2 = layer_sizes;
int ncat = layer_sizes_2[num_layers-1];
//int layer_sizes_2[3]={784,20,10};
int N_obs = XTrainData->size1;
int YFeatures = YTrainData->size2;
int XFeatures = XTrainData->size2;
int GroupSize = N_obs/FOLD;
int Nlambda = sizelambda;
int N_obs_test = XTestData->size1;
int* seq_fold;
seq_fold = rand_fold(N_obs,FOLD);
/*for (int i = 0; i < N_obs; i++){
printf("%d\n",seq_fold[i]);
}*/
gsl_matrix* Xfolds[FOLD];
for (int d = 0; d < FOLD; d++)
Xfolds[d] = gsl_matrix_alloc(GroupSize,XFeatures);
gsl_matrix* Yfolds[FOLD];
for (int d = 0; d < FOLD; d++)
Yfolds[d] = gsl_matrix_alloc(GroupSize,YFeatures);
SplitFoldfunc(XTrainData, FOLD, seq_fold, Xfolds);
SplitFoldfunc(YTrainData, FOLD, seq_fold, Yfolds);
/*
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold1 %G, %G\n",gsl_matrix_get(Xfolds[0],ss,0),gsl_matrix_get(Xfolds[0],ss,1));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold2 %G, %G\n",gsl_matrix_get(Xfolds[1],ss,0),gsl_matrix_get(Xfolds[1],ss,1));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold3 %G, %G\n",gsl_matrix_get(Xfolds[2],ss,0),gsl_matrix_get(Xfolds[2],ss,1));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold4 %G, %G\n",gsl_matrix_get(Xfolds[3],ss,0),gsl_matrix_get(Xfolds[3],ss,1));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold5 %G, %G\n",gsl_matrix_get(Xfolds[4],ss,0),gsl_matrix_get(Xfolds[4],ss,1));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold1 %G \n",gsl_matrix_get(Yfolds[0],ss,0));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold2 %G \n",gsl_matrix_get(Yfolds[1],ss,0));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold3 %G, \n",gsl_matrix_get(Yfolds[2],ss,0));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold4 %G, \n",gsl_matrix_get(Yfolds[3],ss,0));
for (int ss = 0; ss < GroupSize; ss++)
printf( "Fold5 %G, \n",gsl_matrix_get(Yfolds[4],ss,0));
*/
gsl_matrix* CvTrainX[FOLD];
for (int d = 0; d < FOLD; d++)
CvTrainX[d] = gsl_matrix_calloc(GroupSize*(FOLD-1), XFeatures);
gsl_matrix* CvTrainY[FOLD];
for (int d = 0; d < FOLD; d++)
CvTrainY[d] = gsl_matrix_calloc(GroupSize*(FOLD-1), YFeatures);
combinefold(Xfolds, Yfolds, N_obs, FOLD, GroupSize, XFeatures, YFeatures, CvTrainX, CvTrainY);
/*
for (int ss = 0; ss < N_obs-GroupSize; ss++)
printf( "Group1 %G, %G\n",gsl_matrix_get(CvTrainX[0],ss,0),gsl_matrix_get(CvTrainX[0],ss,1));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
printf( "GG2 %G, %G\n",gsl_matrix_get(CvTrainX[1],ss,0),gsl_matrix_get(CvTrainX[1],ss,1));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
printf( "GG3 %G, %G\n",gsl_matrix_get(CvTrainX[2],ss,0),gsl_matrix_get(CvTrainX[2],ss,1));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
printf( "GG4 %G, %G\n",gsl_matrix_get(CvTrainX[3],ss,0),gsl_matrix_get(CvTrainX[3],ss,1));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
printf( "G5 %G, %G\n",gsl_matrix_get(CvTrainX[4],ss,0),gsl_matrix_get(CvTrainX[4],ss,1));
*/
/*
for (int ss = 0; ss < N_obs-GroupSize; ss++)
Rprintf( "Group1 %G, \n",gsl_matrix_get(CvTrainY[0],ss,0));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
Rprintf( "GG2 %G, \n",gsl_matrix_get(CvTrainY[1],ss,0));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
Rprintf( "GG3 %G \n",gsl_matrix_get(CvTrainY[2],ss,0));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
Rprintf( "GG4 %G, \n",gsl_matrix_get(CvTrainY[3],ss,0));
for (int ss = 0; ss < N_obs-GroupSize; ss++)
Rprintf( "G5 %G, \n",gsl_matrix_get(CvTrainY[4],ss,0));
*/
gsl_vector* results_lambda;
results_lambda = gsl_vector_alloc((size_t) Nlambda);
double results[Nlambda][FOLD];
//private(i, j, vec_cv_trainX, vec_cv_trainY, output_weights, output_biases, vec_cv_valX, vec_cv_valY) collapse(2)
#pragma omp parallel for collapse(2)
for (int i = 0; i < Nlambda; i++){
for (int j = 0; j < FOLD; j++){
gsl_vector* vec_cv_trainX[N_obs-GroupSize];
gsl_vector* vec_cv_trainY;
gsl_matrix* output_weights[num_layers-1];
gsl_vector* output_biases[num_layers-1];
gsl_vector* vec_cv_valX[GroupSize];
gsl_vector* vec_cv_valY;
// Rprintf("Lambda=%G\n", Lambda[i]);
// Rprintf("fold not included = %d\n", j);
//gsl_vector* vec_cv_trainX[N_obs-GroupSize];
for (int u = 0; u < (N_obs-GroupSize); u++ ){
vec_cv_trainX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < (N_obs-GroupSize); c++){
gsl_matrix_get_row(vec_cv_trainX[c], CvTrainX[j], c);
}
//for (int a = 0; a < (N_obs-GroupSize); a++){
//printf("%G %G\n",gsl_vector_get(vec_cv_trainX[a],0), gsl_vector_get(vec_cv_trainX[a],1));
//printf("%d\n", a);
//}
//gsl_vector* vec_cv_trainY;
vec_cv_trainY = gsl_vector_alloc(N_obs-GroupSize);
gsl_matrix_get_col(vec_cv_trainY, CvTrainY[j], 0);
//for (int y = 0; y < (N_obs-GroupSize); y++){
//printf("%G\n",gsl_vector_get(vec_cv_trainY,y));
//printf("%d\n",y);
//}
//Note that always Y will be 1 column, so well defined.
//gsl_matrix* output_weights[num_layers-1];
//gsl_vector* output_biases[num_layers-1];
init_bias_object(output_biases, (layer_sizes_2+1), num_layers-1);
init_weight_object(output_weights, layer_sizes_2, num_layers);
//printf(" Lambda = %G\n",Lambda[i]);
double cost_hist[num_iterations];
NeuralNets(layer_sizes_2, num_layers, vec_cv_trainX, vec_cv_trainY, num_iterations, 1,
step_size, output_weights, output_biases, (N_obs-GroupSize), XFeatures, Lambda[i], cost_hist, trans_type);
//gsl_vector* vec_cv_valX[GroupSize];
for (int u = 0; u < (GroupSize); u++){
vec_cv_valX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < GroupSize; c++){
gsl_matrix_get_row(vec_cv_valX[c], Xfolds[j], c);
// for (int s = 0; s < (N_obs-GroupSize); s++){
// if((gsl_vector_get(vec_cv_valX[c],1))==(gsl_vector_get(vec_cv_trainX[s],1))){
// printf("ERROR!!!!\n%G",gsl_vector_get(vec_cv_valX[c],1));
// }
// }
}
//gsl_vector* vec_cv_valY;
vec_cv_valY = gsl_vector_alloc(GroupSize);
gsl_matrix_get_col(vec_cv_valY, Yfolds[j], 0);
double probs[(GroupSize*ncat)];
int predicted_val[GroupSize];
for (int d = 0; d < (GroupSize*ncat); d++)
probs[d] = 0;
for (int s = 0; s < GroupSize; s++)
predicted_val[s] = 0;
results[i][j] = evaluate_results(vec_cv_valX, vec_cv_valY, output_biases, output_weights, GroupSize,ncat, num_layers, layer_sizes_2, trans_type, probs, predicted_val);
/*
gsl_vector* vec_cv_testX[N_obs_test];
for (int u = 0; u < (N_obs_test); u++){
vec_cv_testX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < N_obs_test; c++){
gsl_matrix_get_row(vec_cv_testX[c], XTestData, c);
}
*/
//gsl_vector* vec_cv_testY;
//vec_cv_testY = gsl_vector_alloc(N_obs_test);
//gsl_matrix_get_col(vec_cv_testY, YTestData, 0);
//for (int ss = 0; ss < N_obs_test; ss++)
// Rprintf( "GG3 %G\n",gsl_vector_get(vec_cv_testY, ss));
//Note that always Y will be 1 column, so well defined.
//double success_test_check = correct_guesses(vec_cv_testX, vec_cv_testY, output_biases, output_weights, N_obs_test, num_layers, layer_sizes_2);
//printf("Check = %G\n", success_test_check);
// gsl_vector* vec_cv_valX[GroupSize];
//printf("\n-------------------------------\n Lambda = %G \n i = %d, j = %d \n", Lambda[i] ,i , j);
//printf("Result = %G \n Thread = %d\n--------------------------------\n",results[i][j],omp_get_thread_num());
gsl_vector_free(vec_cv_valY);
for (int u = 0; u < (GroupSize); u++){
gsl_vector_free(vec_cv_valX[u]);
}
gsl_vector_free(vec_cv_trainY);
for (int u = 0; u < (GroupSize); u++){
gsl_vector_free(vec_cv_trainX[u]);
}
}
}
//gsl_vector* results_lambda;
//results_lambda = gsl_vector_alloc((size_t) Nlambda);
double results_mean_fold[Nlambda];
for (int w = 0; w < Nlambda; w++)
results_mean_fold[w] = 0;
for (int s = 0; s < Nlambda ; s++){
for (int m = 0; m < FOLD ; m++){
printf("Lambda = %G, Result = %G\n",Lambda[s], results[s][m]);
}
}
for (int s = 0; s < Nlambda ; s++){
for (int m = 0; m < FOLD ; m++){
results_mean_fold[s] = results[s][m]+ results_mean_fold[s];
}
gsl_vector_set(results_lambda, s, results_mean_fold[s]/(FOLD));
}
for (int s = 0; s < Nlambda ; s++){
printf("Lambda = %G, Success = %G\n", Lambda[s], gsl_vector_get(results_lambda, s));
}
int OptimalLambda_index = gsl_vector_max_index(results_lambda);
double Optimal_lambda = Lambda[OptimalLambda_index];
gsl_vector_free(results_lambda);
gsl_matrix* output_weights_all[num_layers-1];
gsl_vector* output_biases_all[num_layers-1];
init_bias_object(output_biases_all, (layer_sizes_2+1), num_layers-1);
init_weight_object(output_weights_all, layer_sizes_2, num_layers);
gsl_vector* vec_cv_trainX_all[N_obs];
for (int u = 0; u < (N_obs); u++){
vec_cv_trainX_all[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < N_obs; c++){
gsl_matrix_get_row(vec_cv_trainX_all[c], XTrainData, c);
}
gsl_vector* vec_cv_trainY_all;
vec_cv_trainY_all = gsl_vector_alloc(N_obs);
gsl_matrix_get_col(vec_cv_trainY_all, YTrainData, 0);
// for (int ss = 0; ss < N_obs; ss++)
// printf( "GG3 %G\n",gsl_vector_get(vec_cv_trainY_all,ss));
printf("Optimal Lambda = %G\n", Optimal_lambda);
double cost_hist_test[num_iterations];
NeuralNets(layer_sizes_2, num_layers, vec_cv_trainX_all, vec_cv_trainY_all, num_iterations, core_size,
step_size, output_weights_all, output_biases_all, N_obs, XFeatures, Optimal_lambda, cost_hist_test, trans_type);
gsl_vector_free(vec_cv_trainY_all);
for (int u = 0; u < (N_obs); u++){
gsl_vector_free(vec_cv_trainX_all[u]);
}
//printf("Optimal Lambda = %G\n", Optimal_lambda);
gsl_vector* vec_cv_testX[N_obs_test];
for (int u = 0; u < (N_obs_test); u++){
vec_cv_testX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < N_obs_test; c++){
gsl_matrix_get_row(vec_cv_testX[c], XTestData, c);
}
gsl_vector* vec_cv_testY;
vec_cv_testY = gsl_vector_alloc(N_obs_test);
gsl_matrix_get_col(vec_cv_testY, YTestData, 0);
// for (int ss = 0; ss < N_obs_test; ss++)
// printf( "GG %G\n",gsl_vector_get(vec_cv_testY, ss));
//Note that always Y will be 1 column, so well defined.
double success_test = evaluate_results(vec_cv_testX, vec_cv_testY, output_biases_all, output_weights_all, N_obs_test,ncat, num_layers, layer_sizes_2, trans_type, probs_test, predicted_test);
gsl_vector_free(vec_cv_testY);
for (int u = 0; u < (N_obs_test); u++){
gsl_vector_free(vec_cv_testX[u]);
}
/*gsl_vector* vec_cv_valX[GroupSize];
for (int u = 0; u < (GroupSize); u++){
vec_cv_valX[u] = gsl_vector_alloc(XFeatures);
}
for (int c = 0; c < GroupSize; c++){
gsl_matrix_get_row(vec_cv_valX[c], Xfolds[0], c);
}
gsl_vector* vec_cv_valY;
vec_cv_valY = gsl_vector_alloc(GroupSize);
gsl_matrix_get_col(vec_cv_valY, Yfolds[0], 0);
double success_test = correct_guesses(vec_cv_valX, vec_cv_valY, output_biases_all, output_weights_all, GroupSize, num_layers, layer_sizes);
*/
printf("Test Success = %G \n",success_test);
}
void GbA::process(double *data, int nbands, float time, int cmpnt){
assert(nbands == _nbands);
pthread_mutex_lock(&_process_lock);
int i, j, k, timeidx=0;
double timemin=std::numeric_limits<double>::max();
gsl_vector *lsq = gsl_vector_alloc (_td->get_noftraces());
gsl_vector *input = gsl_vector_alloc (nbands);
gsl_vector *trace = gsl_vector_alloc (nbands);
gsl_matrix *tdata;
double misfit_l2, terror;
size_t *indices = new size_t[_nsim];
TData::Component _c = static_cast<TData::Component>(cmpnt);
_status[_c] = true;
// Find time index
for(i=0;i<_td->get_noftimes();i++){
terror = gsl_vector_get(_td->get_times(),i) - time;
if(abs(terror)< timemin){
timeidx = i;
timemin = abs(terror);
}
}
tdata = _td->get_amps(timeidx,_c);
for (i=0; i<nbands; i++){
gsl_vector_set(input, i, std::log10(data[i]));
}
for (j=0; j<_td->get_noftraces(); j++){
gsl_matrix_get_row(trace, tdata, j);
gsl_vector_sub(trace,input);
misfit_l2 = gsl_blas_dnrm2(trace);
gsl_vector_set(lsq, j, misfit_l2*misfit_l2);
}
gsl_sort_vector_smallest_index(indices, _nsim,lsq);
for(k=0; k<_nsim; k++){
gsl_vector_set(&_r[_c].vector,k, std::log10(gsl_vector_get(_td->get_dist(), indices[k])));
gsl_vector_set(&_m[_c].vector,k, gsl_vector_get(_td->get_mag(), indices[k]));
}
if (_status[TData::vertical] && _status[TData::horizontal]){
_mv = gsl_vector_subvector(_mags,0,_mags->size);
_rv = gsl_vector_subvector(_dists,0,_dists->size);
} else if(_status[TData::vertical]){
_mv = gsl_vector_subvector(_mags,0,_nsim);
_rv = gsl_vector_subvector(_dists,0,_nsim);
} else if(_status[TData::horizontal]){
_mv = gsl_vector_subvector(_mags,_nsim,_nsim);
_rv = gsl_vector_subvector(_dists,_nsim,_nsim);
}
_mn[0] = gsl_stats_mean(_rv.vector.data,1,_rv.vector.size);
_mn[1] = gsl_stats_mean(_mv.vector.data,1,_mv.vector.size);
_cov[0][0] = gsl_stats_variance(_rv.vector.data, 1, _rv.vector.size);
_cov[1][1] = gsl_stats_variance(_mv.vector.data, 1, _mv.vector.size);
_cov[0][1] = gsl_stats_covariance_m(_rv.vector.data,1,_mv.vector.data,1,
_rv.vector.size,_mn[0],_mn[1]);
_cov[1][0] = _cov[0][1];
delete[] indices;
pthread_mutex_unlock(&_process_lock);
}
/* Function interpolating the data in matrix/vector form produces an interpolated data in the form of SplineLists */
static INT4 Interpolate_Spline_Data(const EOBNRHMROMdata *data, EOBNRHMROMdata_interp *data_interp) {
gsl_set_error_handler(&err_handler);
SplineList* splinelist;
gsl_spline* spline;
gsl_interp_accel* accel;
gsl_vector* matrixline;
gsl_vector* vector;
INT4 j;
/* Interpolating Camp */
splinelist = data_interp->Camp_interp;
for (j = 0; j<nk_amp; j++) {
matrixline = gsl_vector_alloc(nbwf);
gsl_matrix_get_row(matrixline, data->Camp, j);
accel = gsl_interp_accel_alloc();
spline = gsl_spline_alloc(gsl_interp_cspline, nbwf);
gsl_spline_init(spline, gsl_vector_const_ptr(data->q, 0), gsl_vector_const_ptr(matrixline, 0), nbwf);
splinelist = SplineList_AddElementNoCopy(splinelist, spline, accel, j);
gsl_vector_free(matrixline);
}
data_interp->Camp_interp = splinelist;
/* Interpolating Cphi */
splinelist = data_interp->Cphi_interp;
for (j = 0; j<nk_phi; j++) {
matrixline = gsl_vector_alloc(nbwf);
gsl_matrix_get_row(matrixline, data->Cphi, j);
accel = gsl_interp_accel_alloc();
spline = gsl_spline_alloc(gsl_interp_cspline, nbwf);
gsl_spline_init(spline, gsl_vector_const_ptr(data->q, 0), gsl_vector_const_ptr(matrixline, 0), nbwf);
splinelist = SplineList_AddElementNoCopy(splinelist, spline, accel, j);
gsl_vector_free(matrixline);
}
data_interp->Cphi_interp = splinelist;
/* Interpolating shifttime */
splinelist = data_interp->shifttime_interp;
vector = data->shifttime;
accel = gsl_interp_accel_alloc();
spline = gsl_spline_alloc(gsl_interp_cspline, nbwf);
gsl_spline_init(spline, gsl_vector_const_ptr(data->q, 0), gsl_vector_const_ptr(vector, 0), nbwf);
splinelist = SplineList_AddElementNoCopy(NULL, spline, accel, 0); /* This SplineList has only 1 element */
data_interp->shifttime_interp = splinelist;
/* Interpolating shiftphase */
splinelist = data_interp->shiftphase_interp;
vector = data->shiftphase;
accel = gsl_interp_accel_alloc();
spline = gsl_spline_alloc(gsl_interp_cspline, nbwf);
gsl_spline_init(spline, gsl_vector_const_ptr(data->q, 0), gsl_vector_const_ptr(vector, 0), nbwf);
splinelist = SplineList_AddElementNoCopy(NULL, spline, accel, 0); /* This SplineList has only 1 element */
data_interp->shiftphase_interp = splinelist;
return XLAL_SUCCESS;
}