/**
* Get a summary statistic for the orbital elements; for instance,
* the median value calculated over all the elements of the list.
* @param kl List
* @param what Can be one of: STAT_MEAN, STAT_MEDIAN, STAT_STDDEV, STAT_MAD.
* Summary statistic is calculated correctly for angle parameters.
* @return A matrix whose entries are the summary statistic for the
* corresponding orbital element.
*/
gsl_matrix* KL_getElementsStats(const ok_list* kl, const int what) {
int npl = MROWS(kl->kernels[0]->elements);
if (npl == 0)
return NULL;
gsl_vector* v = gsl_vector_alloc(kl->size);
gsl_matrix* m = gsl_matrix_alloc(npl, ALL_ELEMENTS_SIZE);
gsl_matrix_set_all(m, 0.);
for (int i = 0; i < npl; i++)
for (int j = 0; j < ALL_ELEMENTS_SIZE; j++) {
for (int n = 0; n < kl->size; n++) {
VSET(v, n, MGET(kl->kernels[n]->elements, i, j));
}
switch (what) {
case STAT_MEAN:
if (j == MA || j == LOP || j == INC || j == NODE || j == TRUEANOMALY)
MSET(m, i, j, ok_average_angle(v->data, v->size, false));
else
MSET(m, i, j, gsl_stats_mean(v->data, 1, v->size));
break;
case STAT_STDDEV:
if (j == MA || j == LOP || j == INC || j == NODE || j == TRUEANOMALY) {
MSET(m, i, j, ok_stddev_angle(v->data, v->size, false));
}
else
MSET(m, i, j, gsl_stats_sd(v->data, 1, v->size));
break;
case STAT_MEDIAN:
if (j == MA || j == LOP || j == INC || j == NODE || j == TRUEANOMALY)
MSET(m, i, j, ok_median_angle(v->data, v->size, false));
else {
gsl_sort_vector(v);
MSET(m, i, j, gsl_stats_median_from_sorted_data(v->data, 1, v->size));
}
break;
case STAT_MAD:
if (j == MA || j == LOP || j == INC || j == NODE || j == TRUEANOMALY) {
double med = ok_median_angle(v->data, v->size, false);
MSET(m, i, j, 1.4826 * ok_mad_angle(v->data, v->size, med, false));
} else {
gsl_sort_vector(v);
double med = gsl_stats_median_from_sorted_data(v->data, 1, v->size);
MSET(m, i, j, 1.4826 * ok_mad(v->data, v->size, med));
}
break;
default:
// percentiles
gsl_sort_vector(v);
MSET(m, i, j, gsl_stats_quantile_from_sorted_data(v->data, 1, v->size, (double)(what)/100.));
};
}
gsl_vector_free(v);
return m;
}
void
test_eigen_herm_matrix(const gsl_matrix_complex * m, size_t count,
const char * desc)
{
const size_t N = m->size1;
gsl_matrix_complex * A = gsl_matrix_complex_alloc(N, N);
gsl_vector * eval = gsl_vector_alloc(N);
gsl_vector * evalv = gsl_vector_alloc(N);
gsl_vector * x = gsl_vector_alloc(N);
gsl_vector * y = gsl_vector_alloc(N);
gsl_matrix_complex * evec = gsl_matrix_complex_alloc(N, N);
gsl_eigen_herm_workspace * w = gsl_eigen_herm_alloc(N);
gsl_eigen_hermv_workspace * wv = gsl_eigen_hermv_alloc(N);
gsl_matrix_complex_memcpy(A, m);
gsl_eigen_hermv(A, evalv, evec, wv);
test_eigen_herm_results(m, evalv, evec, count, desc, "unsorted");
gsl_matrix_complex_memcpy(A, m);
gsl_eigen_herm(A, eval, w);
/* sort eval and evalv */
gsl_vector_memcpy(x, eval);
gsl_vector_memcpy(y, evalv);
gsl_sort_vector(x);
gsl_sort_vector(y);
test_eigenvalues_real(y, x, desc, "unsorted");
gsl_eigen_hermv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_ASC);
test_eigen_herm_results(m, evalv, evec, count, desc, "val/asc");
gsl_eigen_hermv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_DESC);
test_eigen_herm_results(m, evalv, evec, count, desc, "val/desc");
gsl_eigen_hermv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_ASC);
test_eigen_herm_results(m, evalv, evec, count, desc, "abs/asc");
gsl_eigen_hermv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_DESC);
test_eigen_herm_results(m, evalv, evec, count, desc, "abs/desc");
gsl_matrix_complex_free(A);
gsl_vector_free(eval);
gsl_vector_free(evalv);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_complex_free(evec);
gsl_eigen_herm_free(w);
gsl_eigen_hermv_free(wv);
} /* test_eigen_herm_matrix() */
void
GslVector::sort()
{
gsl_sort_vector(m_vec);
return;
}
void eig (Matrix& src, double* evals)
{
gsl_eigen_symm (src.get_gsl_matrix(), eigen_values, eig_work);
gsl_sort_vector (eigen_values);
for (guint i = 0; i < src.rows(); i++)
evals[i] = gsl_vector_get(eigen_values, i);
}
static double
robust_madsigma(const gsl_vector *r, gsl_multifit_robust_workspace *w)
{
size_t n = r->size;
const size_t p = w->p;
double sigma;
size_t i;
/* allow for the possibility that r->size < w->n */
gsl_vector_view v1 = gsl_vector_subvector(w->workn, 0, n);
gsl_vector_view v2;
/* copy |r| into workn */
for (i = 0; i < n; ++i)
{
gsl_vector_set(&v1.vector, i, fabs(gsl_vector_get(r, i)));
}
gsl_sort_vector(&v1.vector);
/*
* ignore the smallest p residuals when computing the median
* (see Street et al 1988)
*/
v2 = gsl_vector_subvector(&v1.vector, p - 1, n - p + 1);
sigma = gsl_stats_median_from_sorted_data(v2.vector.data, v2.vector.stride, v2.vector.size) / 0.6745;
return sigma;
} /* robust_madsigma() */
void
tridiag_eigenv(double *eig, double *a, double *b, int n)
{
gsl_matrix *A = gsl_matrix_calloc(n, n);
gsl_matrix_set (A, 0, 0, a[0]);
gsl_matrix_set (A, 0, 0+1, b[0]);
for(int i=1; i<n-1; i++)
{
gsl_matrix_set(A, i, i, a[i]);
gsl_matrix_set(A, i, i+1, b[i]);
gsl_matrix_set(A, i, i-1, b[i-1]);
}
gsl_matrix_set(A, n-1, n-1, a[n-1]);
gsl_matrix_set(A, n-1, n-1-1, b[n-1-1]);
gsl_vector *e = gsl_vector_alloc(n);
gsl_eigen_symm_workspace *w = gsl_eigen_symm_alloc(n);
gsl_eigen_symm(A, e, w);
gsl_eigen_symm_free(w);
gsl_matrix_free(A);
gsl_sort_vector(e);
for(int i=0; i<n; i++)
eig[i] = gsl_vector_get(e, i);
gsl_vector_free(e);
return;
}
void CumulativeVolume::computeMode1(Geometry *geometry, int timestep) {
QVector<float> &x = geometry->deltaXVector();
QVector<float> &y = geometry->deltaYVector();
QVector<float> &z = geometry->deltaZVector();
double totalVolume = 0;
for(int i=0; i<x.size(); i++) {
totalVolume += x[i]*x[i]*x[i];
totalVolume += y[i]*y[i]*y[i];
totalVolume += z[i]*z[i]*z[i];
}
double oneOverTotalVolume = 1.0 / totalVolume;
int numberOfPores = 3*x.size();
gsl_vector * poreVolumes = gsl_vector_alloc (numberOfPores);
gsl_vector * poreVolumesNormalized = gsl_vector_alloc (numberOfPores);
gsl_vector * poreLengths = gsl_vector_alloc(numberOfPores);
int poreIndex = 0;
for(int i=0; i<x.size(); i++) {
float pores[3];
pores[0] = x[i];
pores[1] = y[i];
pores[2] = z[i];
for(int a=0; a<3; a++) {
float poreLength = pores[a];
const float dV = poreLength*poreLength*poreLength;
gsl_vector_set(poreVolumes, poreIndex, dV);
gsl_vector_set(poreLengths, poreIndex, poreLength);
gsl_vector_set(poreVolumesNormalized, poreIndex, dV * oneOverTotalVolume);
poreIndex++;
}
}
gsl_sort_vector2(poreVolumes, poreLengths); // Sort both vectors based on the first
gsl_sort_vector(poreVolumesNormalized);
// Set the x values and be ready to make plot data
m_points.clear();
m_points.reserve(bins());
float dx = (max() - min()) / (bins() - 1);
for(int i=0; i<bins(); i++) {
float x = min() + i*dx;
m_points.push_back(QPointF(x,0));
}
for(int i=0; i<numberOfPores; i++) {
float dVN = gsl_vector_get(poreVolumesNormalized, i); // dVN deltaVolumeNormalized
float poreSize = gsl_vector_get(poreLengths, i);
int bin = poreSize / dx;
if(bin>=bins()) continue; // Some pore sizes might be larger than largest? Don't seg fault
m_points[bin].setY(m_points[bin].y() + dVN);
}
for(int i=1; i<bins(); i++) {
qreal newValue = m_points[i].y() + m_points[i-1].y();
m_points[i].setY(newValue);
}
}
void CumulativeVolume::computeMode0(Geometry *geometry, int timestep) {
QVector<float> &x = geometry->deltaXVector();
QVector<float> &y = geometry->deltaYVector();
QVector<float> &z = geometry->deltaZVector();
double totalVolume = geometry->totalVolume();
double oneOverTotalVolume = 1.0 / totalVolume;
int numberOfPores = x.size()*y.size()*z.size();
gsl_vector * poreVolumes = gsl_vector_alloc (numberOfPores);
gsl_vector * poreVolumesNormalized = gsl_vector_alloc (numberOfPores);
gsl_vector * poreLengths = gsl_vector_alloc(numberOfPores);
int poreIndex = 0;
for(int i=0; i<x.size(); i++) {
const float dx = x[i];
for(int j=0; j<y.size(); j++) {
const float dy = y[j];
for(int k=0; k<z.size(); k++) {
const float dz = z[k];
const float dV = dx*dy*dz;
float poreLength = std::min(std::min(dx, dy), dz);
#ifdef POREISCBRT
poreLength = cbrt(dV);
#endif
gsl_vector_set(poreVolumes, poreIndex, dV);
gsl_vector_set(poreLengths, poreIndex, poreLength);
gsl_vector_set(poreVolumesNormalized, poreIndex, dV * oneOverTotalVolume);
poreIndex++;
}
}
}
gsl_sort_vector2(poreVolumes, poreLengths); // Sort both vectors based on the first
gsl_sort_vector(poreVolumesNormalized);
// Set the x values and be ready to make plot data
m_points.clear();
m_points.reserve(bins());
float dx = (max() - min()) / (bins() - 1);
for(int i=0; i<bins(); i++) {
float x = min() + i*dx;
m_points.push_back(QPointF(x,0));
}
for(int i=0; i<numberOfPores; i++) {
float dVN = gsl_vector_get(poreVolumesNormalized, i); // dVN deltaVolumeNormalized
float poreSize = gsl_vector_get(poreLengths, i);
int bin = poreSize / dx;
if(bin>=bins()) continue; // Some pore sizes might be larger than largest? Don't seg fault
m_points[bin].setY(m_points[bin].y() + dVN);
}
for(int i=1; i<bins(); i++) {
qreal newValue = m_points[i].y() + m_points[i-1].y();
m_points[i].setY(newValue);
}
}
CAMLprim value
ml_gsl_sort_vector (value v)
{
_DECLARE_VECTOR(v);
_CONVERT_VECTOR(v);
gsl_sort_vector (&v_v);
return Val_unit;
}
/**
* Get a summary statistic for the parameters; for instance,
* the median value calculated over all the elements of the list.
* @param kl List
* @param what Can be one of: STAT_MEAN, STAT_MEDIAN, STAT_STDDEV, STAT_MAD.
* @return A vector whose entries are the summary statistic for the
* corresponding orbital parameter.
*/
gsl_vector* KL_getParsStats(const ok_list* kl, const int what) {
gsl_vector* v = gsl_vector_alloc(kl->size);
gsl_vector* ret = gsl_vector_calloc(PARAMS_SIZE + 1);
for (int j = 0; j < PARAMS_SIZE + 1; j++) {
if (j == PARAMS_SIZE)
for (int n = 0; n < kl->size; n++) {
VSET(v, n, kl->kernels[n]->merit);
}
else
for (int n = 0; n < kl->size; n++) {
VSET(v, n, VGET(kl->kernels[n]->params, j));
}
switch (what) {
case STAT_MEAN:
VSET(ret, j, gsl_stats_mean(v->data, 1, v->size));
break;
case STAT_STDDEV:
VSET(ret, j, gsl_stats_sd(v->data, 1, v->size));
break;
case STAT_MEDIAN:
gsl_sort_vector(v);
VSET(ret, j, gsl_stats_median_from_sorted_data(v->data, 1, v->size));
break;
case STAT_MAD:
gsl_sort_vector(v);
double med = gsl_stats_median_from_sorted_data(v->data, 1, v->size);
VSET(ret, j, 1.4826 * ok_mad(v->data, v->size, med));
break;
default:
// percentiles
gsl_sort_vector(v);
VSET(v , j, gsl_stats_quantile_from_sorted_data(v->data, 1, v->size, (double)(what)/100.));
};
};
gsl_vector_free(v);
return ret;
}
/* pseudo graphical display of sample chunk statistical properties,
only useful with one MPI worker as it prints to terminal.
*/
void print_chunk_graph(gsl_matrix *X,/*sub-sample of CHUNK rows*/ gsl_vector *lP)/*log-Posterior values, unnormalized*/{
int width=100; // we assume that the display can show $width characters
int i,j,k,n,nc;
int tmp;
double *x;
gsl_vector_view x_view;
double Q[5];
int q[5];
double max,min,range;
char s[32],c[32];
n=X->size2;
max=gsl_matrix_max(X);
min=gsl_matrix_min(X);
range=max-min;
printf("range: [%g,%g] (%g)\n",min,max,range);
for (i=0;i<X->size1;i++){
//sort each row:
x_view=gsl_matrix_row(X,i);
gsl_sort_vector(&(x_view.vector));
//determine eachquantile
x=gsl_matrix_ptr(X,i,0);
Q[0]=gsl_stats_quantile_from_sorted_data(x,1,n,0.01);
Q[1]=gsl_stats_quantile_from_sorted_data(x,1,n,0.25);
Q[2]=gsl_stats_quantile_from_sorted_data(x,1,n,0.50);
Q[3]=gsl_stats_quantile_from_sorted_data(x,1,n,0.75);
Q[4]=gsl_stats_quantile_from_sorted_data(x,1,n,0.99);
//printf("quantiles: %g\t%g\t%g\t%g\t%g\n",Q[0],Q[1],Q[2],Q[3],Q[4]);
for (j=0;j<5;j++) {
q[j]=(int) ((Q[j]-min)*width/range);
}
sprintf(s," -LU- ");
sprintf(c,"+{|}+ ");
tmp=0;
for (k=0;k<5;k++){
nc=q[k]-tmp;
for (j=0;j<nc;j++) {
printf("%c",s[k]);
}
tmp=q[k];
printf("%c",c[k]);
}
printf("\n\n");
}
printf("|");
for (j=0;j<width-2;j++) printf("-");
printf("|\n");
printf("%+4.4g",min);
for (j=0;j<width-8;j++) printf(" ");
printf("%+4.4g\n",max);
}
void TransformationModelBSpline::getQuantiles_(
const gsl_vector * x, const vector<double> & quantiles, gsl_vector * results)
{
gsl_vector * x_sort;
x_sort = gsl_vector_alloc(x->size);
gsl_vector_memcpy(x_sort, x);
gsl_sort_vector(x_sort);
for (Size i = 0; i < quantiles.size(); ++i)
{
double q = gsl_stats_quantile_from_sorted_data(x_sort->data, 1, x->size,
quantiles[i]);
gsl_vector_set(results, i, q);
}
gsl_vector_free(x_sort);
}
/*!
\fn VImage VMedianImage2d (VImage src, VImage dest, int dim, VBoolean ignore)
\param src input image
\param dest output image
\param dim kernel size
\param ignore whether to ignore zero voxels
*/
VImage
VMedianImage2d (VImage src, VImage dest, int dim, VBoolean ignore)
{
int nbands,nrows,ncols;
int i,len,b,r,c,rr,cc,d=0;
gsl_vector *vec=NULL;
double u,tiny=1.0e-10;
if (dim%2 == 0) VError("VMedianImage2d: dim (%d) must be odd",dim);
nrows = VImageNRows (src);
ncols = VImageNColumns (src);
nbands = VImageNBands (src);
d = dim/2;
len = dim * dim;
vec = gsl_vector_calloc(len);
dest = VCopyImage(src,dest,VAllBands);
for (b=0; b<nbands; b++) {
for (r=d; r<nrows-d; r++) {
for (c=d; c<ncols-d; c++) {
gsl_vector_set_zero(vec);
u = VGetPixel(src,b,r,c);
if ( !ignore || ABS(u) > tiny) {
i = 0;
for (rr=r-d; rr<=r+d; rr++) {
for (cc=c-d; cc<=c+d; cc++) {
u = VGetPixel(src,b,rr,cc);
if (ABS(u) > 0) {
gsl_vector_set(vec,i,u);
i++;
}
}
}
gsl_sort_vector(vec);
u = gsl_stats_median_from_sorted_data(vec->data,vec->stride,i);
VSetPixel(dest,b,r,c,u);
}
}
}
}
return dest;
}
/* Uses the GSL library to solve the GEVP */
int gevp(const double **a0, const double **a1, double *ev, int ms){
int i,j;
gsl_set_error_handler_off();
gsl_matrix *c0 = gsl_matrix_alloc(ms,ms);
gsl_matrix *c1 = gsl_matrix_alloc(ms,ms);
for (i = 0; i < ms; i++) {
for (j = 0; j < ms; j++) {
gsl_matrix_set(c0, i, j, a0[i][j]);
gsl_matrix_set(c1, i, j, a1[i][j]);
}
}
/* Run GEVP */
gsl_eigen_gen_workspace *gevp_ws = gsl_eigen_gen_alloc(ms);
gsl_vector_complex *al = gsl_vector_complex_alloc(ms);
gsl_vector *be = gsl_vector_alloc(ms);
int err = gsl_eigen_gen(c1, c0, al, be, gevp_ws);
if (err) {
fprintf(stderr, "GEVP had errors.\n");
return err;
}
/* Sort into descending order */
gsl_vector *evs = gsl_vector_alloc(ms);
for (i = 0; i < ms; i++) {
gsl_complex q = gsl_vector_complex_get(al,i);
double w = gsl_vector_get(be,i);
if (w == 0)
gsl_vector_set(evs,i,0);
else
gsl_vector_set(evs,i,GSL_REAL(q)/w);
}
gsl_sort_vector(evs);
for (i = 0; i < ms; i++) {
ev[i] = gsl_vector_get(evs,ms-i-1);
}
/* Clean up */
gsl_matrix_free(c0);
gsl_matrix_free(c1);
gsl_vector_complex_free(al);
gsl_vector_free(be);
gsl_vector_free(evs);
gsl_eigen_gen_free(gevp_ws);
return 0;
}
/** Returns an array of size 101, where \c returned_vector[95] gives the value of the 95th percentile, for example. \c Returned_vector[100] is always the maximum value, and \c returned_vector[0] is always the min (regardless of rounding rule).
\param data a gsl_vector of data. (No default, must not be \c NULL.)
\param rounding This will either be 'u', 'd', or 'a'. Unless your data is exactly a multiple of 101, some percentiles will be ambiguous. If 'u', then round up (use the next highest value); if 'd' (or anything else), round down to the next lowest value; if 'a', take the mean of the two nearest points. If 'u' or 'a', then you can say "5% or more of the sample is below \c returned_vector[5]"; if 'd' or 'a', then you can say "5% or more of the sample is above returned_vector[5]". (Default = 'd'.)
\li You may eventually want to \c free() the array returned by this function.
\li This function uses the \ref designated syntax for inputs.
*/
APOP_VAR_HEAD double * apop_vector_percentiles(gsl_vector *data, char rounding){
gsl_vector *apop_varad_var(data, NULL);
Apop_assert(data, "You gave me NULL data.");
char apop_varad_var(rounding, 'd');
APOP_VAR_ENDHEAD
gsl_vector *sorted = gsl_vector_alloc(data->size);
double *pctiles = malloc(sizeof(double) * 101);
gsl_vector_memcpy(sorted,data);
gsl_sort_vector(sorted);
for(int i=0; i<101; i++){
int index = i*(data->size-1)/100.0;
if (rounding == 'u' && index != i*(data->size-1)/100.0)
index ++; //index was rounded down, but should be rounded up.
if (rounding == 'a' && index != i*(data->size-1)/100.0)
pctiles[i] = (gsl_vector_get(sorted, index)+gsl_vector_get(sorted, index+1))/2.;
else pctiles[i] = gsl_vector_get(sorted, index);
}
gsl_vector_free(sorted);
return pctiles;
}
/*
Diese Funktion berechnet Nischenwerte für S Spezies. Dabei wird zunächst jeder Spezies eine Zufallszahl zugeordnet, der Nischenwert.
Dieser ist gleichverteilt auf ]0,1[. Ausgehend davon wird dann ein Fresszentrum und ein Fressbereich bestimmt.
Der Fressbereich wird mit einer Beta-Verteilung erwürfelt.
Eine Spezies kann eine andere Spezies fressen, wenn der Nischenwert der Beute im Fressbereich des Räubers liegt.
Rückgabewert: 3xS Matrix mit [0][S]: Nischenwert, [1][S]: Fressbereich, [2][S]: Fresszentrum.
*/
gsl_matrix *SetNicheValues(struct foodweb nicheweb, double C, gsl_rng* rng1, const gsl_rng_type* rng_T){
int S = nicheweb.S;
//printf("\nStarte Berechnung der Nischenwerte für %i Spezies\n", S);
gsl_matrix *NV = gsl_matrix_calloc(3, nicheweb.S);
gsl_vector *nv = gsl_vector_calloc(S);
//printf("nischenwert allokation");
double disbeta = (1-2*C)/(2*C); // Für den Fressbereich (Beta-Verteilung)
int i = 0;
//--Nischenwerte ausrechnen------------------------------------------------------------------------------------------------
for(i= 0; i<S; i++)
gsl_vector_set(nv, i, gsl_rng_uniform_pos(rng1)); // Nischenwerte gleichverteilt auf ]0,1[
gsl_sort_vector(nv); // Sortieren für Massenberechnung später
for(i = 0; i < S; i++)
{
double nvi = gsl_vector_get(nv, i);
double fri = gsl_ran_beta(rng1, 1, disbeta);
double rand = gsl_rng_uniform_pos(rng1);
double fci = nvi*fri*rand/2 + nvi*(1-rand); // Zufälliges Fresszentrum in [nv(i)*fr(i)/2, nv(i)]
gsl_matrix_set(NV, 0, i, nvi);
gsl_matrix_set(NV, 1, i, fri);
gsl_matrix_set(NV, 2, i, fci);
}
//--Zuweisung----------------------------------------------------------------------------------------------------
free(nv);
return NV;
}//end SetNicheValues
/*!
\fn VImage VMedianImage3d (VImage src, VImage dest, int dim, VBoolean ignore)
\param src input image
\param dest output image
\param dim kernel size (3,5,7...)
\param ignore whether to ignore zero voxels
*/
VImage
VMedianImage3d (VImage src, VImage dest, int dim, VBoolean ignore)
{
int nbands,nrows,ncols;
int i,len,len2,b,r,c,bb,rr,cc,b0,b1,r0,r1,c0,c1,d=0;
gsl_vector *vec=NULL;
double u,tiny=1.0e-10;
if (dim%2 == 0) VError("VMedianImage3d: dim (%d) must be odd",dim);
nrows = VImageNRows (src);
ncols = VImageNColumns (src);
nbands = VImageNBands (src);
if (nbands <= d) VError("VMedianImage3d: number of slices too small (%d)",nbands);
d = dim/2;
len = dim * dim * dim;
len2 = 10;
if (len < len2) len2 = len;
vec = gsl_vector_calloc(len);
dest = VCopyImage(src,dest,VAllBands);
for (b=d; b<nbands-d; b++) {
for (r=d; r<nrows-d; r++) {
for (c=d; c<ncols-d; c++) {
u = VGetPixel(src,b,r,c);
if ( !ignore || ABS(u) > tiny) {
i = 0;
b0 = b-d;
b1 = b+d;
for (bb=b0; bb<=b1; bb++) {
r0 = r-d;
r1 = r+d;
for (rr=r0; rr<=r1; rr++) {
c0 = c-d;
c1 = c+d;
for (cc=c0; cc<=c1; cc++) {
u = VGetPixel(src,bb,rr,cc);
if (ABS(u) > tiny) {
gsl_vector_set(vec,i,u);
i++;
}
}
}
}
if (i < len2) continue;
gsl_sort_vector(vec);
u = gsl_stats_median_from_sorted_data(vec->data,vec->stride,i);
VSetPixel(dest,b,r,c,u);
}
}
}
}
gsl_vector_free(vec);
return dest;
}
void posterior_summary(const gsl_matrix *theta, FILE *ofile, long M)
{
size_t T=theta->size1;
size_t npar=theta->size2;
gsl_vector *tmp=gsl_vector_alloc(T);
int i,j;
double median,lower,upper;
printf("\n Writing MCMC draws to out\n\n");
FILE *file = fopen("out","w");
for(i=0;i<T;i++){
for(j=0;j<npar;j++)
fprintf(file,"%14.6e ",mget(theta,i,j));
fprintf(file,"\n");
}
fprintf(ofile,"\n\n Posterior Summary \n");
fprintf(ofile,"\n T=%lu\n\n",T);
fprintf(ofile,"\n Mean Median Stdev 0.95 DI\n\n");
for(i=0;i<npar;i++){
gsl_matrix_get_col( tmp, theta, i);
gsl_sort_vector(tmp);
median=gsl_stats_median_from_sorted_data(tmp->data,tmp->stride,tmp->size);
lower=gsl_stats_quantile_from_sorted_data(tmp->data,tmp->stride,tmp->size,0.025);
upper=gsl_stats_quantile_from_sorted_data(tmp->data,tmp->stride,tmp->size,0.975);
fprintf(ofile,"%2d %14.7e %14.7e %14.7e (%14.7e,%14.7e)\n"
,i,mean(tmp),median,sqrt(var(tmp)),lower,upper);
}
long tau;
if( M < 0 )
tau=1000;
else
tau=M;
gsl_vector *rho=gsl_vector_alloc(tau);
fprintf(ofile,"\n ACF");
fprintf(ofile,"\n NSE Ineff 1 50 100 500\n");
for(i=0;i<npar;i++){
gsl_matrix_get_col( tmp, theta, i);
acf(tmp,tau,rho);
/* write out ACF for each parameter */
char file_name[20] = "acf.dat";
sprintf( &file_name[7],"%d",i);
FILE *fp_acf = fopen( file_name, "w");
for(j=0;j<tau;j++)
fprintf(fp_acf,"%g\n",vget(rho,j));
fclose(fp_acf);
/* get inefficiency factor using Newey-West estimate of Long-run var*/
double ineff=1.0;
for(j=0;j<tau-1;j++){
ineff += 2.0*(tau-j-1)/tau*vget(rho,j);
}
/* numerical standard error for posterior mean */
double nse=sqrt(var(tmp)*ineff/T);
fprintf(ofile,"%2d %12.5e %12.5e %12.5e %12.5e %12.5e %12.5e\n"
,i,nse,ineff,vget(rho,0),vget(rho,49),vget(rho,99),vget(rho,499));
/* produce kernel density plot for each parameter */
char file_name2[20] = "den.dat";
sprintf( &file_name2[7],"%d",i);
FILE *fp_den = fopen( file_name2, "w");
double stdev = sqrt(var(tmp));
lower = gsl_vector_min(tmp) - stdev;
upper = gsl_vector_max(tmp) + stdev;
den_est_file(tmp, lower , upper ,100, fp_den, -1.0);
}
fprintf(ofile,"\n\n");
gsl_vector_free(rho);
gsl_vector_free(tmp);
}
static void vSortDesc(gsl_vector* v) {
gsl_vector_scale(v, -1.0);
gsl_sort_vector(v);
gsl_vector_scale(v, -1.0);
}
void eig (Matrix& src, Vector& evals)
{
evals.allocate (src.rows());
gsl_eigen_symm (src.get_gsl_matrix(), evals.get_gsl_vector(), eig_work);
gsl_sort_vector (evals.get_gsl_vector());
}
void
test_eigen_genherm(void)
{
size_t N_max = 20;
size_t n, i;
gsl_rng *r = gsl_rng_alloc(gsl_rng_default);
for (n = 1; n <= N_max; ++n)
{
gsl_matrix_complex * A = gsl_matrix_complex_alloc(n, n);
gsl_matrix_complex * B = gsl_matrix_complex_alloc(n, n);
gsl_matrix_complex * ma = gsl_matrix_complex_alloc(n, n);
gsl_matrix_complex * mb = gsl_matrix_complex_alloc(n, n);
gsl_vector * eval = gsl_vector_alloc(n);
gsl_vector * evalv = gsl_vector_alloc(n);
gsl_vector * x = gsl_vector_alloc(n);
gsl_vector * y = gsl_vector_alloc(n);
gsl_vector_complex * work = gsl_vector_complex_alloc(n);
gsl_matrix_complex * evec = gsl_matrix_complex_alloc(n, n);
gsl_eigen_genherm_workspace * w = gsl_eigen_genherm_alloc(n);
gsl_eigen_genhermv_workspace * wv = gsl_eigen_genhermv_alloc(n);
for (i = 0; i < 5; ++i)
{
create_random_herm_matrix(A, r, -10, 10);
create_random_complex_posdef_matrix(B, r, work);
gsl_matrix_complex_memcpy(ma, A);
gsl_matrix_complex_memcpy(mb, B);
gsl_eigen_genhermv(ma, mb, evalv, evec, wv);
test_eigen_genherm_results(A, B, evalv, evec, i, "random", "unsorted");
gsl_matrix_complex_memcpy(ma, A);
gsl_matrix_complex_memcpy(mb, B);
gsl_eigen_genherm(ma, mb, eval, w);
/* eval and evalv have to be sorted? not sure why */
gsl_vector_memcpy(x, eval);
gsl_vector_memcpy(y, evalv);
gsl_sort_vector(x);
gsl_sort_vector(y);
test_eigenvalues_real(y, x, "genherm, random", "unsorted");
gsl_eigen_genhermv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_ASC);
test_eigen_genherm_results(A, B, evalv, evec, i, "random", "val/asc");
gsl_eigen_genhermv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_DESC);
test_eigen_genherm_results(A, B, evalv, evec, i, "random", "val/desc");
gsl_eigen_genhermv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_ASC);
test_eigen_genherm_results(A, B, evalv, evec, i, "random", "abs/asc");
gsl_eigen_genhermv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_DESC);
test_eigen_genherm_results(A, B, evalv, evec, i, "random", "abs/desc");
}
gsl_matrix_complex_free(A);
gsl_matrix_complex_free(B);
gsl_matrix_complex_free(ma);
gsl_matrix_complex_free(mb);
gsl_vector_free(eval);
gsl_vector_free(evalv);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_vector_complex_free(work);
gsl_matrix_complex_free(evec);
gsl_eigen_genherm_free(w);
gsl_eigen_genhermv_free(wv);
}
gsl_rng_free(r);
} /* test_eigen_genherm() */
FrequencyCountDialog::FrequencyCountDialog(Table *t, QWidget* parent, Qt::WFlags fl )
: QDialog( parent, fl ),
d_source_table(t),
d_result_table(NULL),
d_col_name(""),
d_col_values(NULL),
d_bins(10)
{
setObjectName( "FrequencyCountDialog" );
setWindowTitle(tr("QtiPlot - Frequency count"));
setSizeGripEnabled( true );
setAttribute(Qt::WA_DeleteOnClose);
QGroupBox *gb1 = new QGroupBox();
QGridLayout *gl1 = new QGridLayout(gb1);
ApplicationWindow *app = (ApplicationWindow *)parent;
double min = 0.0, max = 0.0, step = 0.0;
if (t){
int col = -1;
int sr = 0;
int er = t->numRows();
int ts = t->table()->currentSelection();
if (ts >= 0){
Q3TableSelection sel = t->table()->selection(ts);
sr = sel.topRow();
er = sel.bottomRow() + 1;
col = sel.leftCol();
d_col_name = t->colName(col);
}
int size = 0;
for (int i = sr; i < er; i++){
if (!t->text(i, col).isEmpty())
size++;
}
if (size > 1)
d_col_values = gsl_vector_alloc(size);
if (d_col_values){
int aux = 0;
for (int i = sr; i < er; i++){
if (!t->text(i, col).isEmpty()){
gsl_vector_set(d_col_values, aux, t->cell(i, col));
aux++;
}
}
gsl_sort_vector(d_col_values);
min = floor(gsl_vector_get(d_col_values, 0));
max = ceil(gsl_vector_get(d_col_values, size - 1));
step = (max - min)/(double)d_bins;
int p = app->d_decimal_digits;
double *data = d_col_values->data;
QLocale l = app->locale();
QString s = "[" + QDateTime::currentDateTime().toString(Qt::LocalDate)+ " \"" + t->objectName() + "\"]\n";
s += tr("Statistics on %1").arg(d_col_name) + ":\n";
s += tr("Mean") + " = " + l.toString(gsl_stats_mean (data, 1, size), 'f', p) + "\n";
s += tr("Standard Deviation") + " = " + l.toString(gsl_stats_sd(data, 1, size), 'f', p) + "\n";
s += tr("Median") + " = " + l.toString(gsl_stats_median_from_sorted_data(data, 1, size), 'f', p) + "\n";
s += tr("Size") + " = " + QString::number(size) + "\n";
s += "--------------------------------------------------------------------------------------\n";
app->updateLog(s);
}
}
gl1->addWidget(new QLabel(tr("From Minimum")), 0, 0);
boxStart = new DoubleSpinBox();
boxStart->setLocale(app->locale());
boxStart->setValue(min);
boxStart->setDecimals(app->d_decimal_digits);
gl1->addWidget(boxStart, 0, 1);
gl1->addWidget(new QLabel(tr("To Maximum")), 1, 0);
boxEnd = new DoubleSpinBox();
boxEnd->setLocale(app->locale());
boxEnd->setValue(max);
boxEnd->setDecimals(app->d_decimal_digits);
gl1->addWidget(boxEnd, 1, 1);
gl1->addWidget(new QLabel(tr("Step Size")), 2, 0);
boxStep = new DoubleSpinBox();
boxStep->setLocale(app->locale());
boxStep->setValue(step);
boxStep->setDecimals(app->d_decimal_digits);
gl1->addWidget(boxStep, 2, 1);
gl1->setRowStretch(3, 1);
gl1->setColumnStretch(1, 1);
buttonApply = new QPushButton(tr( "&Apply" ));
buttonApply->setDefault( true );
buttonCancel = new QPushButton(tr( "&Cancel" ));
buttonOk = new QPushButton(tr( "&Ok" ));
QVBoxLayout *vl = new QVBoxLayout();
vl->addWidget(buttonApply);
vl->addWidget(buttonOk);
vl->addWidget(buttonCancel);
vl->addStretch();
QHBoxLayout *hb = new QHBoxLayout(this);
hb->addWidget(gb1, 1);
hb->addLayout(vl);
connect( buttonApply, SIGNAL( clicked() ), this, SLOT( apply() ) );
connect( buttonCancel, SIGNAL( clicked() ), this, SLOT( reject() ) );
connect( buttonOk, SIGNAL( clicked() ), this, SLOT( accept() ) );
}
int
main(int argc, char *argv[])
{
gen_workspace *gen_workspace_p;
lapack_workspace *lapack_workspace_p;
size_t N;
int c;
int lower;
int upper;
int incremental;
size_t nmat;
gsl_matrix *A, *B;
gsl_rng *r;
int s;
int compute_schur;
size_t i;
gsl_ieee_env_setup();
gsl_rng_env_setup();
N = 30;
lower = -10;
upper = 10;
incremental = 0;
nmat = 0;
compute_schur = 0;
while ((c = getopt(argc, argv, "ic:n:l:u:z")) != (-1))
{
switch (c)
{
case 'i':
incremental = 1;
break;
case 'n':
N = strtol(optarg, NULL, 0);
break;
case 'l':
lower = strtol(optarg, NULL, 0);
break;
case 'u':
upper = strtol(optarg, NULL, 0);
break;
case 'c':
nmat = strtoul(optarg, NULL, 0);
break;
case 'z':
compute_schur = 1;
break;
case '?':
default:
printf("usage: %s [-i] [-z] [-n size] [-l lower-bound] [-u upper-bound] [-c num]\n", argv[0]);
exit(1);
break;
} /* switch (c) */
}
A = gsl_matrix_alloc(N, N);
B = gsl_matrix_alloc(N, N);
gen_workspace_p = gen_alloc(N, compute_schur);
lapack_workspace_p = lapack_alloc(N);
r = gsl_rng_alloc(gsl_rng_default);
if (incremental)
{
make_start_matrix(A, lower);
/* we need B to be non-singular */
make_random_integer_matrix(B, r, lower, upper);
}
fprintf(stderr, "testing N = %d", N);
if (incremental)
fprintf(stderr, " incrementally");
else
fprintf(stderr, " randomly");
fprintf(stderr, " on element range [%d, %d]", lower, upper);
if (compute_schur)
fprintf(stderr, ", with Schur vectors");
fprintf(stderr, "\n");
while (1)
{
if (nmat && (count >= nmat))
break;
++count;
if (!incremental)
{
make_random_matrix(A, r, lower, upper);
make_random_matrix(B, r, lower, upper);
}
else
{
s = inc_matrix(A, lower, upper);
if (s)
break; /* all done */
make_random_integer_matrix(B, r, lower, upper);
}
/*if (count != 89120)
continue;*/
/* make copies of matrices */
gsl_matrix_memcpy(gen_workspace_p->A, A);
gsl_matrix_memcpy(gen_workspace_p->B, B);
gsl_matrix_transpose_memcpy(lapack_workspace_p->A, A);
gsl_matrix_transpose_memcpy(lapack_workspace_p->B, B);
/* compute eigenvalues with LAPACK */
s = lapack_proc(lapack_workspace_p);
if (s != GSL_SUCCESS)
{
printf("LAPACK failed, case %lu\n", count);
exit(1);
}
#if 0
print_matrix(A, "A");
print_matrix(B, "B");
gsl_matrix_transpose(lapack_workspace_p->A);
gsl_matrix_transpose(lapack_workspace_p->B);
print_matrix(lapack_workspace_p->A, "S_lapack");
print_matrix(lapack_workspace_p->B, "T_lapack");
#endif
/* compute eigenvalues with GSL */
s = gen_proc(gen_workspace_p);
if (s != GSL_SUCCESS)
{
printf("=========== CASE %lu ============\n", count);
printf("Failed to converge: found %u eigenvalues\n",
gen_workspace_p->n_evals);
print_matrix(A, "A");
print_matrix(B, "B");
print_matrix(gen_workspace_p->A, "Af");
print_matrix(gen_workspace_p->B, "Bf");
print_matrix(lapack_workspace_p->A, "Ae");
print_matrix(lapack_workspace_p->B, "Be");
exit(1);
}
#if 0
print_matrix(gen_workspace_p->A, "S_gsl");
print_matrix(gen_workspace_p->B, "T_gsl");
#endif
/* compute alpha / beta vectors */
for (i = 0; i < N; ++i)
{
double beta;
gsl_complex alpha, z;
beta = gsl_vector_get(gen_workspace_p->beta, i);
if (beta == 0.0)
GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);
else
{
alpha = gsl_vector_complex_get(gen_workspace_p->alpha, i);
z = gsl_complex_div_real(alpha, beta);
}
gsl_vector_complex_set(gen_workspace_p->evals, i, z);
beta = gsl_vector_get(lapack_workspace_p->beta, i);
GSL_SET_COMPLEX(&alpha,
lapack_workspace_p->alphar[i],
lapack_workspace_p->alphai[i]);
if (beta == 0.0)
GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);
else
z = gsl_complex_div_real(alpha, beta);
gsl_vector_complex_set(lapack_workspace_p->evals, i, z);
gsl_vector_complex_set(lapack_workspace_p->alpha, i, alpha);
}
#if 0
gsl_sort_vector(gen_workspace_p->beta);
gsl_sort_vector(lapack_workspace_p->beta);
sort_complex_vector(gen_workspace_p->alpha);
sort_complex_vector(lapack_workspace_p->alpha);
s = test_alpha(gen_workspace_p->alpha,
lapack_workspace_p->alpha,
A,
B,
"gen",
"lapack");
s = test_beta(gen_workspace_p->beta,
lapack_workspace_p->beta,
A,
B,
"gen",
"lapack");
#endif
#if 1
sort_complex_vector(gen_workspace_p->evals);
sort_complex_vector(lapack_workspace_p->evals);
s = test_evals(gen_workspace_p->evals,
lapack_workspace_p->evals,
A,
B,
"gen",
"lapack");
#endif
if (compute_schur)
{
test_schur(A,
gen_workspace_p->A,
gen_workspace_p->Q,
gen_workspace_p->Z);
test_schur(B,
gen_workspace_p->B,
gen_workspace_p->Q,
gen_workspace_p->Z);
}
}
gsl_matrix_free(A);
gsl_matrix_free(B);
gen_free(gen_workspace_p);
lapack_free(lapack_workspace_p);
if (r)
gsl_rng_free(r);
return 0;
} /* main() */
