void EvecCache_MinMaxVals(EvecCache *evCache, double *emin, double *emax) {
int na = evCache->na;
int nb = evCache->nb;
int nc = evCache->nc;
double minval = 0.0;
double maxval = 0.0;
double this_min, this_max;
gsl_vector *energies;
int i, j, k;
for (k = 0; k < nc+1; k++) {
for (j = 0; j < nb+1; j++) {
for (i = 0; i < na+1; i++) {
int kN = submesh_ijk_index(na, nb, nc, i, j, k);
energies = evCache->energies[kN];
gsl_vector_minmax(energies, &this_min, &this_max);
if (i == 0 && j == 0 && k == 0) {
minval = this_min;
maxval = this_max;
} else {
if (this_min < minval) {
minval = this_min;
}
if (this_max > maxval) {
maxval = this_max;
}
}
}
}
}
*emin = minval;
*emax = maxval;
}
size_t
gsl_linalg_QRPT_rank (const gsl_matrix * QR, const double tol)
{
const size_t M = QR->size1;
const size_t N = QR->size2;
gsl_vector_const_view diag = gsl_matrix_const_diagonal(QR);
double eps;
size_t i;
size_t r = 0;
if (tol < 0.0)
{
double min, max, absmax;
int ee;
gsl_vector_minmax(&diag.vector, &min, &max);
absmax = GSL_MAX(fabs(min), fabs(max));
ee = (int) (log(absmax) / log(2.0));
eps = 20.0 * (M + N) * pow(2.0, (double) ee) * GSL_DBL_EPSILON;
}
else
eps = tol;
/* count number of diagonal elements with |di| > eps */
for (i = 0; i < GSL_MIN(M, N); ++i)
{
double di = gsl_vector_get(&diag.vector, i);
if (fabs(di) > eps)
++r;
}
return r;
}
int
lls_lcurve(gsl_vector *reg_param, gsl_vector *rho, gsl_vector *eta,
lls_workspace *w)
{
const size_t N = rho->size; /* number of points on L-curve */
if (N != reg_param->size)
{
GSL_ERROR("size of reg_param and rho do not match", GSL_EBADLEN);
}
else if (N != eta->size)
{
GSL_ERROR("size of eta and rho do not match", GSL_EBADLEN);
}
else
{
int s;
double smax, smin;
size_t i;
/* compute eigenvalues of A^T W A */
gsl_matrix_transpose_memcpy(w->work_A, w->ATA);
s = gsl_eigen_symm(w->work_A, w->eval, w->eigen_p);
if (s)
return s;
/* find largest and smallest eigenvalues */
gsl_vector_minmax(w->eval, &smin, &smax);
/* singular values are square roots of eigenvalues */
smax = sqrt(smax);
if (smin > GSL_DBL_EPSILON)
smin = sqrt(fabs(smin));
gsl_multifit_linear_lreg(smin, smax, reg_param);
for (i = 0; i < N; ++i)
{
double r2;
double lambda = gsl_vector_get(reg_param, i);
lls_solve(lambda, w->c, w);
/* store ||c|| */
gsl_vector_set(eta, i, gsl_blas_dnrm2(w->c));
/* compute: A^T A c - 2 A^T y */
gsl_vector_memcpy(w->work_b, w->ATb);
gsl_blas_dsymv(CblasUpper, 1.0, w->ATA, w->c, -2.0, w->work_b);
/* compute: c^T A^T A c - 2 c^T A^T y */
gsl_blas_ddot(w->c, w->work_b, &r2);
r2 += w->bTb;
gsl_vector_set(rho, i, sqrt(r2));
}
return GSL_SUCCESS;
}
} /* lls_lcurve() */
gsl_histogram * calc_hist(const gsl_vector * v, int nbins) {
double max;
double min;
unsigned int i;
double binwidth;
double sum = 0;
double val;
gsl_histogram * h;
gsl_vector_minmax(v, &min, &max);
binwidth = (max - min) / nbins;
dump_d("min", min);
dump_d("max", max);
debug("allocating the histogram");
h = gsl_histogram_alloc(v->size);
debug("setting range");
require(gsl_histogram_set_ranges_uniform (h, min, max));
/* with out the following, the max element doesn't fall in the last bin */
h->range[h->n] += 1;
debug("summing up");
for (i = 0; i < v->size; i++) {
val = gsl_vector_get(v, i);
sum += val;
require(gsl_histogram_increment (h, val));
}
debug("scaling");
/* double gsl_histogram_sum (const gsl_histogram * h) */
require(gsl_histogram_scale (h, 1/sum));
debug("done");
return h;
}
// Scale each row in a matrix to have values in a given range [a,b]
// f(x) = a + (b-a)(x-min)/(max-min)
void shapeAlign::scaleMatrix(gsl_matrix *M, double min, double max){
for (size_t i = 0; i < M->size1; i++){
double rmin,rmax; // row max and min
gsl_vector_view row = gsl_matrix_row(M,i);
gsl_vector_minmax(&row.vector,&rmin,&rmax);
gsl_vector_add_constant(&row.vector,-1*rmin);
gsl_vector_scale(&row.vector,(max-min)/(rmax-rmin));
gsl_vector_add_constant(&row.vector,min);
}
return;
}
void QwtHistogram::initData(double *Y, int size)
{
if(size<2 || (size == 2 && Y[0] == Y[1]))
{//non valid histogram data
double x[2], y[2];
for (int i = 0; i<2; i++ ){
y[i] = 0;
x[i] = 0;
}
setData(x, y, 2);
return;
}
int n = 10;//default value
QVarLengthArray<double> x(n), y(n);//double x[n], y[n]; //store ranges (x) and bins (y)
gsl_histogram * h = gsl_histogram_alloc (n);
if (!h)
return;
gsl_vector *v;
v = gsl_vector_alloc (size);
for (int i = 0; i<size; i++ )
gsl_vector_set (v, i, Y[i]);
double min, max;
gsl_vector_minmax (v, &min, &max);
gsl_vector_free (v);
d_begin = floor(min);
d_end = ceil(max);
gsl_histogram_set_ranges_uniform (h, floor(min), ceil(max));
for (int i = 0; i<size; i++ )
gsl_histogram_increment (h, Y[i]);
for (int i = 0; i<n; i++ ){
y[i] = gsl_histogram_get (h, i);
double lower, upper;
gsl_histogram_get_range (h, i, &lower, &upper);
x[i] = lower;
}
setData(x.data(), y.data(), n);//setData(x, y, n);
d_bin_size = (d_end - d_begin)/(double)n;
d_autoBin = true;
d_mean = gsl_histogram_mean(h);
d_standard_deviation = gsl_histogram_sigma(h);
d_min = gsl_histogram_min_val(h);
d_max = gsl_histogram_max_val(h);
gsl_histogram_free (h);
}
void SigmoidalFit::guessInitialValues() {
gsl_vector_view x = gsl_vector_view_array(d_x, d_n);
gsl_vector_view y = gsl_vector_view_array(d_y, d_n);
double min_out, max_out;
gsl_vector_minmax(&y.vector, &min_out, &max_out);
gsl_vector_set(d_param_init, 0, min_out);
gsl_vector_set(d_param_init, 1, max_out);
gsl_vector_set(d_param_init, 2, gsl_vector_get(&x.vector, d_n / 2));
gsl_vector_set(d_param_init, 3, 1.0);
}
void QwtHistogram::loadData()
{
if (d_matrix){
loadDataFromMatrix();
return;
}
int r = abs(d_end_row - d_start_row) + 1;
QVarLengthArray<double> Y(r);
int ycol = d_table->colIndex(title().text());
int size = 0;
for (int i = 0; i<r; i++ ){
QString yval = d_table->text(i, ycol);
if (!yval.isEmpty()){
bool valid_data = true;
Y[size] = ((Graph *)plot())->locale().toDouble(yval, &valid_data);
if (valid_data)
size++;
}
}
if(size < 2 || (size==2 && Y[0] == Y[1])){//non valid histogram
double X[2];
Y.resize(2);
for (int i = 0; i<2; i++ ){
Y[i] = 0;
X[i] = 0;
}
setData(X, Y.data(), 2);
return;
}
int n;
gsl_histogram *h;
if (d_autoBin){
n = 10;
h = gsl_histogram_alloc (n);
if (!h)
return;
gsl_vector *v = gsl_vector_alloc (size);
for (int i = 0; i<size; i++ )
gsl_vector_set (v, i, Y[i]);
double min, max;
gsl_vector_minmax (v, &min, &max);
gsl_vector_free (v);
d_begin = floor(min);
d_end = ceil(max);
d_bin_size = (d_end - d_begin)/(double)n;
gsl_histogram_set_ranges_uniform (h, floor(min), ceil(max));
} else {
n = int((d_end - d_begin)/d_bin_size + 1);
h = gsl_histogram_alloc (n);
if (!h)
return;
double *range = new double[n+2];
for (int i = 0; i<= n+1; i++ )
range[i] = d_begin + i*d_bin_size;
gsl_histogram_set_ranges (h, range, n+1);
delete[] range;
}
for (int i = 0; i<size; i++ )
gsl_histogram_increment (h, Y[i]);
#ifdef Q_CC_MSVC
QVarLengthArray<double> X(n); //stores ranges (x) and bins (y)
#else
double X[n]; //stores ranges (x) and bins (y)
#endif
Y.resize(n);
for (int i = 0; i<n; i++ ){
Y[i] = gsl_histogram_get (h, i);
double lower, upper;
gsl_histogram_get_range (h, i, &lower, &upper);
X[i] = lower;
}
#ifdef Q_CC_MSVC
setData(X.data(), Y.data(), n);
#else
setData(X, Y.data(), n);
#endif
d_mean = gsl_histogram_mean(h);
d_standard_deviation = gsl_histogram_sigma(h);
d_min = gsl_histogram_min_val(h);
d_max = gsl_histogram_max_val(h);
gsl_histogram_free (h);
}
TransformationModelBSpline::TransformationModelBSpline(
const TransformationModel::DataPoints & data, const Param & params)
{
params_ = params;
Param defaults;
getDefaultParameters(defaults);
params_.setDefaults(defaults);
if (data.size() < 4) // TODO: check number
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__, "'b_spline' model needs at least four data points");
}
Size num_breakpoints = params_.getValue("num_breakpoints");
String break_positions = params_.getValue("break_positions");
if ((break_positions != "uniform") && (break_positions != "quantiles"))
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__, "parameter 'break_positions' for 'b_spline' model must be 'uniform' or 'quantiles'");
}
size_ = data.size();
x_ = gsl_vector_alloc(size_);
y_ = gsl_vector_alloc(size_);
w_ = gsl_vector_alloc(size_);
for (size_t i = 0; i < size_; ++i)
{
gsl_vector_set(x_, i, data[i].first);
gsl_vector_set(y_, i, data[i].second);
gsl_vector_set(w_, i, 1.0); // TODO: non-uniform weights
}
gsl_vector_minmax(x_, &xmin_, &xmax_);
// set up cubic (k = 4) spline workspace:
if (num_breakpoints < 2)
{
num_breakpoints = 2;
LOG_WARN << "Warning: Increased parameter 'num_breakpoints' to 2 (minimum)." << endl;
}
else if (num_breakpoints > size_ - 2)
{
num_breakpoints = size_ - 2;
LOG_WARN << "Warning: Decreased parameter 'num_breakpoints' to " + String(num_breakpoints) + " (maximum for this number of data points)." << endl;
}
workspace_ = gsl_bspline_alloc(4, num_breakpoints);
if (break_positions == "uniform")
{
gsl_bspline_knots_uniform(xmin_, xmax_, workspace_);
}
else
{
vector<double> quantiles(num_breakpoints, 1.0);
double step = 1.0 / (num_breakpoints - 1);
for (Size i = 0; i < num_breakpoints - 1; ++i)
{
quantiles[i] = i * step;
}
gsl_vector * breakpoints;
breakpoints = gsl_vector_alloc(num_breakpoints);
getQuantiles_(x_, quantiles, breakpoints);
gsl_bspline_knots(breakpoints, workspace_);
gsl_vector_free(breakpoints);
}
ncoeffs_ = gsl_bspline_ncoeffs(workspace_);
gsl_vector_minmax(workspace_->knots, &xmin_, &xmax_);
computeFit_();
}
int
lls_complex_lcurve(gsl_vector *reg_param, gsl_vector *rho, gsl_vector *eta,
lls_complex_workspace *w)
{
const size_t N = rho->size; /* number of points on L-curve */
if (N != reg_param->size)
{
GSL_ERROR("size of reg_param and rho do not match", GSL_EBADLEN);
}
else if (N != eta->size)
{
GSL_ERROR("size of eta and rho do not match", GSL_EBADLEN);
}
else
{
int s;
const gsl_complex negtwo = gsl_complex_rect(-2.0, 0.0);
/* smallest regularization parameter */
const double smin_ratio = 16.0 * GSL_DBL_EPSILON;
double s1, sp, ratio, tmp;
size_t i;
/* compute eigenvalues of A^H A */
gsl_matrix_complex_transpose_memcpy(w->work_A, w->AHA);
s = gsl_eigen_herm(w->work_A, w->eval, w->eigen_p);
if (s)
return s;
/* find largest and smallest eigenvalues */
gsl_vector_minmax(w->eval, &sp, &s1);
/* singular values are square roots of eigenvalues */
s1 = sqrt(s1);
if (sp > GSL_DBL_EPSILON)
sp = sqrt(fabs(sp));
tmp = GSL_MAX(sp, s1*smin_ratio);
gsl_vector_set(reg_param, N - 1, tmp);
/* ratio so that reg_param(1) = s(1) */
ratio = pow(s1 / tmp, 1.0 / (N - 1.0));
/* calculate the regularization parameters */
for (i = N - 1; i > 0 && i--; )
{
double rp1 = gsl_vector_get(reg_param, i + 1);
gsl_vector_set(reg_param, i, ratio * rp1);
}
for (i = 0; i < N; ++i)
{
double r2;
double lambda = gsl_vector_get(reg_param, i);
gsl_complex val;
lls_complex_solve(lambda, w->c, w);
/* store ||c|| */
gsl_vector_set(eta, i, gsl_blas_dznrm2(w->c));
/* compute: A^H A c - 2 A^H b */
gsl_vector_complex_memcpy(w->work_b, w->AHb);
gsl_blas_zhemv(CblasUpper, GSL_COMPLEX_ONE, w->AHA, w->c, negtwo, w->work_b);
/* compute: c^T A^T A c - 2 c^T A^T b */
gsl_blas_zdotc(w->c, w->work_b, &val);
r2 = GSL_REAL(val) + w->bHb;
gsl_vector_set(rho, i, sqrt(r2));
}
return GSL_SUCCESS;
}
} /* lls_complex_lcurve() */
void TableStatistics::update(Table *t, const QString& colName)
{
if (t != d_base) return;
int j;
if (d_type == row)
for (unsigned r=0; r < d_targets.size(); r++)
{
int cols=d_base->tableCols();
int i = d_targets[r];
int m = 0;
for (j = 0; j < cols; j++)
if (!d_base->text(i, j).isEmpty() && d_base->columnType(j) == Numeric)
m++;
if (!m)
{//clear row statistics
for (j = 1; j<9; j++)
setText(r, j, QString::null);
}
if (m > 0)
{
double *dat = new double[m];
gsl_vector *y = gsl_vector_alloc (m);
int aux = 0;
for (j = 0; j<cols; j++)
{
QString text = d_base->text(i,j);
if (!text.isEmpty() && d_base->columnType(j) == Numeric)
{
double val = text.toDouble();
gsl_vector_set (y, aux, val);
dat[aux] = val;
aux++;
}
}
double mean = gsl_stats_mean (dat, 1, m);
double min, max;
gsl_vector_minmax (y, &min, &max);
setText(r, 1, QString::number(d_base->tableCols()));
setText(r, 2, QString::number(mean));
setText(r, 3, QString::number(gsl_stats_sd(dat, 1, m)));
setText(r, 4, QString::number(gsl_stats_variance(dat, 1, m)));
setText(r, 5, QString::number(mean*m));
setText(r, 6, QString::number(max));
setText(r, 7, QString::number(min));
setText(r, 8, QString::number(m));
gsl_vector_free (y);
delete[] dat;
}
}
else if (d_type == column)
for (unsigned c=0; c < d_targets.size(); c++)
if (colName == QString(d_base->name())+"_"+text(c, 0))
{
int i = d_base->colIndex(colName);
if (d_base->columnType(i) != Numeric) return;
int rows = d_base->tableRows();
int start = -1, m = 0;
for (j=0; j<rows; j++)
if (!d_base->text(j,i).isEmpty())
{
m++;
if (start<0) start=j;
}
if (!m)
{//clear col statistics
for (j = 1; j<11; j++)
setText(c, j, QString::null);
return;
}
if (start<0) return;
double *dat = new double[m];
gsl_vector *y = gsl_vector_alloc (m);
int aux = 0, min_index = start, max_index = start;
double val = d_base->text(start, i).toDouble();
gsl_vector_set (y, 0, val);
dat[0] = val;
double min = val, max = val;
for (j = start + 1; j<rows; j++)
{
if (!d_base->text(j, i).isEmpty())
{
aux++;
val = d_base->text(j, i).toDouble();
gsl_vector_set (y, aux, val);
dat[aux] = val;
if (val < min)
{
min = val;
min_index = j;
}
if (val > max)
{
max = val;
max_index = j;
}
}
}
double mean=gsl_stats_mean (dat, 1, m);
setText(c, 1, "[1:"+QString::number(rows)+"]");
setText(c, 2, QString::number(mean));
setText(c, 3, QString::number(gsl_stats_sd(dat, 1, m)));
setText(c, 4, QString::number(gsl_stats_variance(dat, 1, m)));
setText(c, 5, QString::number(mean*m));
setText(c, 6, QString::number(max_index + 1));
setText(c, 7, QString::number(max));
setText(c, 8, QString::number(min_index + 1));
setText(c, 9, QString::number(min));
setText(c, 10, QString::number(m));
gsl_vector_free (y);
delete[] dat;
}
for (int i=0; i<worksheet->numCols(); i++)
emit modifiedData(this, Table::colName(i));
}
