gsl_odeiv_control *
gsl_odeiv_control_alloc(const gsl_odeiv_control_type * T)
{
gsl_odeiv_control * c =
(gsl_odeiv_control *) malloc(sizeof(gsl_odeiv_control));
if(c == 0)
{
GSL_ERROR_NULL ("failed to allocate space for control struct",
GSL_ENOMEM);
};
c->type = T;
c->state = c->type->alloc();
if (c->state == 0)
{
free (c); /* exception in constructor, avoid memory leak */
GSL_ERROR_NULL ("failed to allocate space for control state",
GSL_ENOMEM);
};
return c;
}
gsl_splinalg_itersolve *
gsl_splinalg_itersolve_alloc(const gsl_splinalg_itersolve_type *T,
const size_t n, const size_t m)
{
gsl_splinalg_itersolve *w;
w = calloc(1, sizeof(gsl_splinalg_itersolve));
if (w == NULL)
{
GSL_ERROR_NULL("failed to allocate space for itersolve struct",
GSL_ENOMEM);
}
w->type = T;
w->normr = 0.0;
w->state = w->type->alloc(n, m);
if (w->state == NULL)
{
gsl_splinalg_itersolve_free(w);
GSL_ERROR_NULL("failed to allocate space for itersolve state",
GSL_ENOMEM);
}
return w;
} /* gsl_splinalg_itersolve_alloc() */
gsl_eigen_gensymm_workspace *
gsl_eigen_gensymm_alloc(const size_t n)
{
gsl_eigen_gensymm_workspace *w;
if (n == 0)
{
GSL_ERROR_NULL ("matrix dimension must be positive integer",
GSL_EINVAL);
}
w = (gsl_eigen_gensymm_workspace *) calloc (1, sizeof (gsl_eigen_gensymm_workspace));
if (w == 0)
{
GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM);
}
w->size = n;
w->symm_workspace_p = gsl_eigen_symm_alloc(n);
if (!w->symm_workspace_p)
{
gsl_eigen_gensymm_free(w);
GSL_ERROR_NULL("failed to allocate space for symm workspace", GSL_ENOMEM);
}
return (w);
} /* gsl_eigen_gensymm_alloc() */
static void *
rk2imp_alloc (size_t dim)
{
rk2imp_state_t *state = (rk2imp_state_t *) malloc (sizeof (rk2imp_state_t));
if (state == 0)
{
GSL_ERROR_NULL ("failed to allocate space for rk2imp_state",
GSL_ENOMEM);
}
state->knu = (double *) malloc (dim * sizeof (double));
if (state->knu == 0)
{
free (state);
GSL_ERROR_NULL ("failed to allocate space for knu", GSL_ENOMEM);
}
state->ytmp = (double *) malloc (dim * sizeof (double));
if (state->ytmp == 0)
{
free (state->knu);
free (state);
GSL_ERROR_NULL ("failed to allocate space for ytmp", GSL_ENOMEM);
}
return state;
}
gsl_filter_gaussian_workspace *
gsl_filter_gaussian_alloc(const size_t K)
{
const size_t H = K / 2;
gsl_filter_gaussian_workspace *w;
size_t state_size;
w = calloc(1, sizeof(gsl_filter_gaussian_workspace));
if (w == 0)
{
GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM);
}
w->K = 2 * H + 1;
w->kernel = malloc(w->K * sizeof(double));
if (w->kernel == 0)
{
gsl_filter_gaussian_free(w);
GSL_ERROR_NULL ("failed to allocate space for kernel", GSL_ENOMEM);
return NULL;
}
state_size = gaussian_size(w->K);
w->movstat_workspace_p = gsl_movstat_alloc_with_size(state_size, H, H);
if (!w->movstat_workspace_p)
{
gsl_filter_gaussian_free(w);
GSL_ERROR_NULL ("failed to allocate space for movstat workspace", GSL_ENOMEM);
}
return w;
}
static void *
avl_spmalloc (size_t size, void *param)
{
gsl_spmatrix *m = (gsl_spmatrix *) param;
if (size != sizeof(struct avl_node))
{
GSL_ERROR_NULL("attemping to allocate incorrect node size", GSL_EBADLEN);
}
/*
* return the next available avl_node slot; index
* m->tree_data->n keeps track of next open slot
*/
if (m->tree_data->n < m->nzmax)
{
/* cast to char* for pointer arithmetic */
unsigned char *node_ptr = (unsigned char *) m->tree_data->node_array;
/* offset in bytes for next node slot */
size_t offset = (m->tree_data->n)++ * sizeof(struct avl_node);
return node_ptr + offset;
}
else
{
/*
* we should never get here - gsl_spmatrix_realloc() should
* be called before exceeding nzmax nodes
*/
GSL_ERROR_NULL("attemping to allocate tree node past nzmax", GSL_EINVAL);
}
}
gsl_odeiv_control *
gsl_odeiv_control_scaled_new(double eps_abs, double eps_rel,
double a_y, double a_dydt,
const double scale_abs[],
size_t dim)
{
gsl_odeiv_control * c =
gsl_odeiv_control_alloc (gsl_odeiv_control_scaled);
int status = gsl_odeiv_control_init (c, eps_abs, eps_rel, a_y, a_dydt);
if (status != GSL_SUCCESS)
{
gsl_odeiv_control_free (c);
GSL_ERROR_NULL ("error trying to initialize control", status);
}
{
sc_control_state_t * s = (sc_control_state_t *) c->state;
s->scale_abs = (double *)malloc(dim * sizeof(double));
if (s->scale_abs == 0)
{
free (s);
GSL_ERROR_NULL ("failed to allocate space for scale_abs",
GSL_ENOMEM);
}
memcpy(s->scale_abs, scale_abs, dim * sizeof(double));
}
return c;
}
gsl_odeiv2_evolve *
gsl_odeiv2_evolve_alloc (size_t dim)
{
gsl_odeiv2_evolve *e =
(gsl_odeiv2_evolve *) malloc (sizeof (gsl_odeiv2_evolve));
if (e == 0)
{
GSL_ERROR_NULL ("failed to allocate space for evolve struct",
GSL_ENOMEM);
}
e->y0 = (double *) malloc (dim * sizeof (double));
if (e->y0 == 0)
{
free (e);
GSL_ERROR_NULL ("failed to allocate space for y0", GSL_ENOMEM);
}
e->yerr = (double *) malloc (dim * sizeof (double));
if (e->yerr == 0)
{
free (e->y0);
free (e);
GSL_ERROR_NULL ("failed to allocate space for yerr", GSL_ENOMEM);
}
e->dydt_in = (double *) malloc (dim * sizeof (double));
if (e->dydt_in == 0)
{
free (e->yerr);
free (e->y0);
free (e);
GSL_ERROR_NULL ("failed to allocate space for dydt_in", GSL_ENOMEM);
}
e->dydt_out = (double *) malloc (dim * sizeof (double));
if (e->dydt_out == 0)
{
free (e->dydt_in);
free (e->yerr);
free (e->y0);
free (e);
GSL_ERROR_NULL ("failed to allocate space for dydt_out", GSL_ENOMEM);
}
e->dimension = dim;
e->count = 0;
e->failed_steps = 0;
e->last_step = 0.0;
e->driver = NULL;
return e;
}
double *
gsl_spmatrix_ptr(gsl_spmatrix *m, const size_t i, const size_t j)
{
if (i >= m->size1)
{
GSL_ERROR_NULL("first index out of range", GSL_EINVAL);
}
else if (j >= m->size2)
{
GSL_ERROR_NULL("second index out of range", GSL_EINVAL);
}
else
{
if (GSL_SPMATRIX_ISTRIPLET(m))
{
/* traverse binary tree to search for (i,j) element */
void *ptr = tree_find(m, i, j);
return (double *) ptr;
}
else if (GSL_SPMATRIX_ISCCS(m))
{
const size_t *mi = m->i;
const size_t *mp = m->p;
size_t p;
/* loop over column j and search for row index i */
for (p = mp[j]; p < mp[j + 1]; ++p)
{
if (mi[p] == i)
return &(m->data[p]);
}
}
else if (GSL_SPMATRIX_ISCRS(m))
{
const size_t *mj = m->i;
const size_t *mp = m->p;
size_t p;
/* loop over row i and search for column index j */
for (p = mp[i]; p < mp[i + 1]; ++p)
{
if (mj[p] == j)
return &(m->data[p]);
}
}
else
{
GSL_ERROR_NULL("unknown sparse matrix type", GSL_EINVAL);
}
/* element not found; return 0 */
return NULL;
}
} /* gsl_spmatrix_ptr() */
/* common initialization */
static void *
cspline_alloc (size_t size)
{
cspline_state_t * state = (cspline_state_t *) malloc (sizeof (cspline_state_t));
if (state == NULL)
{
GSL_ERROR_NULL("failed to allocate space for state", GSL_ENOMEM);
}
state->c = (double *) malloc (size * sizeof (double));
if (state->c == NULL)
{
free (state);
GSL_ERROR_NULL("failed to allocate space for c", GSL_ENOMEM);
}
state->g = (double *) malloc (size * sizeof (double));
if (state->g == NULL)
{
free (state->c);
free (state);
GSL_ERROR_NULL("failed to allocate space for g", GSL_ENOMEM);
}
state->diag = (double *) malloc (size * sizeof (double));
if (state->diag == NULL)
{
free (state->g);
free (state->c);
free (state);
GSL_ERROR_NULL("failed to allocate space for diag", GSL_ENOMEM);
}
state->offdiag = (double *) malloc (size * sizeof (double));
if (state->offdiag == NULL)
{
free (state->diag);
free (state->g);
free (state->c);
free (state);
GSL_ERROR_NULL("failed to allocate space for offdiag", GSL_ENOMEM);
}
return state;
}
/* common creation */
static void *
akima_alloc (size_t size)
{
akima_state_t *state = (akima_state_t *) malloc (sizeof (akima_state_t));
if (state == NULL)
{
GSL_ERROR_NULL("failed to allocate space for state", GSL_ENOMEM);
}
state->b = (double *) malloc (size * sizeof (double));
if (state->b == NULL)
{
free (state);
GSL_ERROR_NULL("failed to allocate space for b", GSL_ENOMEM);
}
state->c = (double *) malloc (size * sizeof (double));
if (state->c == NULL)
{
free (state->b);
free (state);
GSL_ERROR_NULL("failed to allocate space for c", GSL_ENOMEM);
}
state->d = (double *) malloc (size * sizeof (double));
if (state->d == NULL)
{
free (state->c);
free (state->b);
free (state);
GSL_ERROR_NULL("failed to allocate space for d", GSL_ENOMEM);
}
state->_m = (double *) malloc ((size + 4) * sizeof (double));
if (state->_m == NULL)
{
free (state->d);
free (state->c);
free (state->b);
free (state);
GSL_ERROR_NULL("failed to allocate space for _m", GSL_ENOMEM);
}
return state;
}
gsl_movstat_workspace *
gsl_movstat_alloc_with_size(const size_t accum_state_size, const size_t H, const size_t J)
{
gsl_movstat_workspace *w;
size_t state_size = accum_state_size;
w = calloc(1, sizeof(gsl_movstat_workspace));
if (w == 0)
{
GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM);
}
w->H = H;
w->J = J;
w->K = H + J + 1;
if (state_size == 0)
{
/*
* determine maximum number of bytes needed for the various accumulators;
* the accumulators will all share the same workspace
*/
state_size = GSL_MAX(state_size, (gsl_movstat_accum_mad->size)(w->K)); /* MAD accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_mean->size)(w->K)); /* mean/variance/sd accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_min->size)(w->K)); /* min/max accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_sum->size)(w->K)); /* sum accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_median->size)(w->K)); /* median accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_Qn->size)(w->K)); /* Q_n accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_qqr->size)(w->K)); /* QQR accumulator */
state_size = GSL_MAX(state_size, (gsl_movstat_accum_Sn->size)(w->K)); /* S_n accumulator */
}
w->state = malloc(state_size);
if (w->state == 0)
{
gsl_movstat_free(w);
GSL_ERROR_NULL ("failed to allocate space for accumulator state", GSL_ENOMEM);
}
w->work = malloc(w->K * sizeof(double));
if (w->work == 0)
{
gsl_movstat_free(w);
GSL_ERROR_NULL ("failed to allocate space for work", GSL_ENOMEM);
}
w->state_size = state_size;
return w;
}
gsl_eigen_nonsymm_workspace *
gsl_eigen_nonsymm_alloc(const size_t n)
{
gsl_eigen_nonsymm_workspace *w;
if (n == 0)
{
GSL_ERROR_NULL ("matrix dimension must be positive integer",
GSL_EINVAL);
}
w = (gsl_eigen_nonsymm_workspace *)
calloc (1, sizeof (gsl_eigen_nonsymm_workspace));
if (w == 0)
{
GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM);
}
w->size = n;
w->Z = NULL;
w->do_balance = 0;
w->diag = gsl_vector_alloc(n);
if (w->diag == 0)
{
gsl_eigen_nonsymm_free(w);
GSL_ERROR_NULL ("failed to allocate space for balancing vector", GSL_ENOMEM);
}
w->tau = gsl_vector_alloc(n);
if (w->tau == 0)
{
gsl_eigen_nonsymm_free(w);
GSL_ERROR_NULL ("failed to allocate space for hessenberg coefficients", GSL_ENOMEM);
}
w->francis_workspace_p = gsl_eigen_francis_alloc();
if (w->francis_workspace_p == 0)
{
gsl_eigen_nonsymm_free(w);
GSL_ERROR_NULL ("failed to allocate space for francis workspace", GSL_ENOMEM);
}
return (w);
} /* gsl_eigen_nonsymm_alloc() */
gsl_eigen_nonsymmv_workspace *
gsl_eigen_nonsymmv_alloc(const size_t n)
{
gsl_eigen_nonsymmv_workspace *w;
if (n == 0)
{
GSL_ERROR_NULL ("matrix dimension must be positive integer",
GSL_EINVAL);
}
w = (gsl_eigen_nonsymmv_workspace *)
calloc (1, sizeof (gsl_eigen_nonsymmv_workspace));
if (w == 0)
{
GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM);
}
w->size = n;
w->Z = NULL;
w->nonsymm_workspace_p = gsl_eigen_nonsymm_alloc(n);
if (w->nonsymm_workspace_p == 0)
{
gsl_eigen_nonsymmv_free(w);
GSL_ERROR_NULL ("failed to allocate space for nonsymm workspace", GSL_ENOMEM);
}
/*
* set parameters to compute the full Schur form T and balance
* the matrices
*/
gsl_eigen_nonsymm_params(1, 0, w->nonsymm_workspace_p);
w->work = gsl_vector_alloc(n);
w->work2 = gsl_vector_alloc(n);
w->work3 = gsl_vector_alloc(n);
if (w->work == 0 || w->work2 == 0 || w->work3 == 0)
{
gsl_eigen_nonsymmv_free(w);
GSL_ERROR_NULL ("failed to allocate space for nonsymmv additional workspace", GSL_ENOMEM);
}
return (w);
} /* gsl_eigen_nonsymmv_alloc() */
gsl_odeiv2_driver *
gsl_odeiv2_driver_alloc_scaled_new (const gsl_odeiv2_system * sys,
const gsl_odeiv2_step_type * T,
const double hstart,
const double epsabs, const double epsrel,
const double a_y, const double a_dydt,
const double scale_abs[])
{
/* Initializes an ODE driver system with control object of type
scaled_new.
*/
gsl_odeiv2_driver *state = driver_alloc (sys, hstart, T);
if (state == NULL)
{
GSL_ERROR_NULL ("failed to allocate driver object", GSL_ENOMEM);
}
if (epsabs >= 0.0 && epsrel >= 0.0)
{
state->c = gsl_odeiv2_control_scaled_new (epsabs, epsrel, a_y, a_dydt,
scale_abs, sys->dimension);
if (state->c == NULL)
{
gsl_odeiv2_driver_free (state);
GSL_ERROR_NULL ("failed to allocate control object", GSL_ENOMEM);
}
}
else
{
gsl_odeiv2_driver_free (state);
GSL_ERROR_NULL ("epsabs and epsrel must be positive", GSL_EINVAL);
}
/* Distribute pointer to driver object */
gsl_odeiv2_step_set_driver (state->s, state);
gsl_odeiv2_evolve_set_driver (state->e, state);
gsl_odeiv2_control_set_driver (state->c, state);
return state;
}
static void *
trust_alloc (const gsl_multilarge_nlinear_parameters * params,
const size_t n, const size_t p)
{
trust_state_t *state;
state = calloc(1, sizeof(trust_state_t));
if (state == NULL)
{
GSL_ERROR_NULL ("failed to allocate lm state", GSL_ENOMEM);
}
state->diag = gsl_vector_alloc(p);
if (state->diag == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for diag", GSL_ENOMEM);
}
state->workn = gsl_vector_alloc(n);
if (state->workn == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for workn", GSL_ENOMEM);
}
state->x_trial = gsl_vector_alloc(p);
if (state->x_trial == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for x_trial", GSL_ENOMEM);
}
state->f_trial = gsl_vector_alloc(n);
if (state->f_trial == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for f_trial", GSL_ENOMEM);
}
state->trs_state = (params->trs->alloc)(params, n, p);
if (state->trs_state == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for trs state", GSL_ENOMEM);
}
if (params->solver != gsl_multilarge_nlinear_solver_none)
{
state->solver_state = (params->solver->alloc)(n, p);
if (state->solver_state == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for solver state", GSL_ENOMEM);
}
}
state->n = n;
state->p = p;
state->delta = 0.0;
state->params = *params;
return state;
}
gsl_spmatrix *
gsl_spmatrix_ccs(const gsl_spmatrix *T)
{
if (!GSL_SPMATRIX_ISTRIPLET(T))
{
GSL_ERROR_NULL("matrix must be in triplet format", GSL_EINVAL);
}
else
{
const size_t *Tj; /* column indices of triplet matrix */
size_t *Cp; /* column pointers of compressed column matrix */
size_t *w; /* copy of column pointers */
gsl_spmatrix *m;
size_t n;
m = gsl_spmatrix_alloc_nzmax(T->size1, T->size2, T->nz,
GSL_SPMATRIX_CCS);
if (!m)
return NULL;
Tj = T->p;
Cp = m->p;
/* initialize column pointers to 0 */
for (n = 0; n < m->size2 + 1; ++n)
Cp[n] = 0;
/*
* compute the number of elements in each column:
* Cp[j] = # non-zero elements in column j
*/
for (n = 0; n < T->nz; ++n)
Cp[Tj[n]]++;
/* compute column pointers: p[j] = p[j-1] + nnz[j-1] */
gsl_spmatrix_cumsum(m->size2, Cp);
/* make a copy of the column pointers */
w = (size_t *) m->work;
for (n = 0; n < m->size2; ++n)
w[n] = Cp[n];
/* transfer data from triplet format to CCS */
for (n = 0; n < T->nz; ++n)
{
size_t k = w[Tj[n]]++;
m->i[k] = T->i[n];
m->data[k] = T->data[n];
}
m->nz = T->nz;
return m;
}
}
static void *
dogleg_alloc (const void * params, const size_t n, const size_t p)
{
const gsl_multifit_nlinear_parameters *mparams = (const gsl_multifit_nlinear_parameters *) params;
dogleg_state_t *state;
state = calloc(1, sizeof(dogleg_state_t));
if (state == NULL)
{
GSL_ERROR_NULL ("failed to allocate dogleg state", GSL_ENOMEM);
}
state->dx_gn = gsl_vector_alloc(p);
if (state->dx_gn == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for dx_gn", GSL_ENOMEM);
}
state->dx_sd = gsl_vector_alloc(p);
if (state->dx_sd == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for dx_sd", GSL_ENOMEM);
}
state->workp = gsl_vector_alloc(p);
if (state->workp == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for workp", GSL_ENOMEM);
}
state->workn = gsl_vector_alloc(n);
if (state->workn == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for workn", GSL_ENOMEM);
}
state->n = n;
state->p = p;
state->params = *mparams;
return state;
}
static void *
eulerplus_alloc (size_t dim)
{
eulerplus_state_t *state =
(eulerplus_state_t *) malloc (sizeof (eulerplus_state_t));
if (state == 0)
{
GSL_ERROR_NULL ("failed to allocate space for eulerplus_state",
GSL_ENOMEM);
}
state->k1 = (double *) malloc (dim * sizeof (double));
if (state->k1 == 0)
{
free (state);
GSL_ERROR_NULL ("failed to allocate space for k1", GSL_ENOMEM);
}
state->k2 = (double *) malloc (dim * sizeof (double));
if (state->k2 == 0)
{
free (state->k1);
free (state);
GSL_ERROR_NULL ("failed to allocate space for k2", GSL_ENOMEM);
}
state->ytmp = (double *) malloc (dim * sizeof (double));
if (state->ytmp == 0)
{
free (state->k2);
free (state->k1);
free (state);
GSL_ERROR_NULL ("failed to allocate space for ytmp", GSL_ENOMEM);
}
return state;
}
gsl_eigen_herm_workspace *
gsl_eigen_herm_alloc (const size_t n)
{
gsl_eigen_herm_workspace * w ;
if (n == 0)
{
GSL_ERROR_NULL ("matrix dimension must be positive integer", GSL_EINVAL);
}
w = (gsl_eigen_herm_workspace *) malloc (sizeof(gsl_eigen_herm_workspace));
if (w == 0)
{
GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM);
}
w->d = (double *) malloc (n * sizeof (double));
if (w->d == 0)
{
GSL_ERROR_NULL ("failed to allocate space for diagonal", GSL_ENOMEM);
}
w->sd = (double *) malloc (n * sizeof (double));
if (w->sd == 0)
{
GSL_ERROR_NULL ("failed to allocate space for subdiagonal", GSL_ENOMEM);
}
w->tau = (double *) malloc (2 * n * sizeof (double));
if (w->tau == 0)
{
GSL_ERROR_NULL ("failed to allocate space for tau", GSL_ENOMEM);
}
w->size = n;
return w;
}
gsl_spline *
gsl_spline_alloc (const gsl_interp_type * T, size_t size)
{
gsl_spline * spline = (gsl_spline *) malloc (sizeof(gsl_spline));
if (spline == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for spline struct",
GSL_ENOMEM);
}
spline->interp = gsl_interp_alloc (T, size);
if (spline->interp == NULL)
{
free (spline);
GSL_ERROR_NULL ("failed to allocate space for interp", GSL_ENOMEM);
};
spline->x = (double *) malloc (size * sizeof(double));
if (spline->x == NULL)
{
gsl_interp_free(spline->interp);
free(spline);
GSL_ERROR_NULL ("failed to allocate space for x", GSL_ENOMEM);
}
spline->y = (double *) malloc (size * sizeof(double));
if (spline->y == NULL)
{
free(spline->x);
gsl_interp_free(spline->interp);
free(spline);
GSL_ERROR_NULL ("failed to allocate space for y", GSL_ENOMEM);
}
spline->size = size;
return spline;
}
static void *
euler_alloc (size_t dim)
{
euler_state_t *state = (euler_state_t *) malloc (sizeof (euler_state_t));
if (state == 0)
{
GSL_ERROR_NULL ("failed to allocate space for euler_state", GSL_ENOMEM);
}
state->k = (double *) malloc (dim * sizeof (double));
if (state->k == 0)
{
free (state);
GSL_ERROR_NULL ("failed to allocate space for k", GSL_ENOMEM);
}
return state;
}
static void *
polynomial_alloc (size_t size)
{
polynomial_state_t *state =
(polynomial_state_t *) malloc (sizeof (polynomial_state_t));
if (state == 0)
{
GSL_ERROR_NULL ("failed to allocate space for polynomial state",
GSL_ENOMEM);
}
state->d = (double *) malloc (sizeof (double) * size);
if (state->d == 0)
{
free (state);
GSL_ERROR_NULL ("failed to allocate space for d", GSL_ENOMEM);
}
state->coeff = (double *) malloc (sizeof (double) * size);
if (state->coeff == 0)
{
free (state->d);
free (state);
GSL_ERROR_NULL ("failed to allocate space for d", GSL_ENOMEM);
}
state->work = (double *) malloc (sizeof (double) * size);
if (state->work == 0)
{
free (state->coeff);
free (state->d);
free (state);
GSL_ERROR_NULL ("failed to allocate space for d", GSL_ENOMEM);
}
return state;
}
int
gsl_odeiv2_driver_set_hmax (gsl_odeiv2_driver * d, const double hmax)
{
/* Sets maximum allowed step size fabs(hmax) for driver. It is
required that hmin <= fabs(h) <= hmax. */
if ((fabs (hmax) < fabs (d->h)) || (fabs (hmax) < d->hmin))
{
GSL_ERROR_NULL ("hmin <= fabs(h) <= hmax required", GSL_EINVAL);
}
if (hmax > 0.0 || hmax < 0.0)
{
d->hmax = fabs (hmax);
}
else
{
GSL_ERROR_NULL ("invalid hmax", GSL_EINVAL);
}
return GSL_SUCCESS;
}
static void *
bicubic_alloc(size_t xsize, size_t ysize)
{
bicubic_state_t *state;
state = calloc(1, sizeof (bicubic_state_t));
if (state == NULL)
{
GSL_ERROR_NULL("failed to allocate space for state", GSL_ENOMEM);
}
state->zx = (double *) malloc (xsize * ysize * sizeof (double));
if (state->zx == NULL)
{
bicubic_free(state);
GSL_ERROR_NULL("failed to allocate space for zx", GSL_ENOMEM);
}
state->zy = (double *) malloc (xsize * ysize * sizeof (double));
if (state->zy == NULL)
{
bicubic_free(state);
GSL_ERROR_NULL("failed to allocate space for zy", GSL_ENOMEM);
}
state->zxy = (double *) malloc (xsize * ysize * sizeof (double));
if (state->zxy == NULL)
{
bicubic_free(state);
GSL_ERROR_NULL("failed to allocate space for zxy", GSL_ENOMEM);
}
state->xsize = xsize;
state->ysize = ysize;
return state;
} /* bicubic_alloc() */
gsl_interp *
gsl_interp_alloc (const gsl_interp_type * T, size_t size)
{
gsl_interp * interp;
if (size < T->min_size)
{
GSL_ERROR_NULL ("insufficient number of points for interpolation type",
GSL_EINVAL);
}
interp = (gsl_interp *) malloc (sizeof(gsl_interp));
if (interp == NULL)
{
GSL_ERROR_NULL ("failed to allocate space for interp struct",
GSL_ENOMEM);
}
interp->type = T;
interp->size = size;
if (interp->type->alloc == NULL)
{
interp->state = NULL;
return interp;
}
interp->state = interp->type->alloc(size);
if (interp->state == NULL)
{
free (interp);
GSL_ERROR_NULL ("failed to allocate space for interp state", GSL_ENOMEM);
};
return interp;
}
interp2d* interp2d_alloc(const interp2d_type* T, size_t xsize, size_t ysize) {
interp2d* interp;
if (xsize < T->min_size || ysize < T->min_size) {
GSL_ERROR_NULL("insufficient number of points for interpolation type", GSL_EINVAL);
}
interp = (interp2d*)malloc(sizeof(interp2d));
if (interp == NULL) {
GSL_ERROR_NULL("failed to allocate space for interp2d struct", GSL_ENOMEM);
}
interp->type = T;
interp->xsize = xsize;
interp->ysize = ysize;
if (interp->type->alloc == NULL) {
interp->state = NULL;
return interp;
}
interp->state = interp->type->alloc(xsize, ysize);
if (interp->state == NULL) {
free(interp);
GSL_ERROR_NULL("failed to allocate space for interp2d state", GSL_ENOMEM);
}
return interp;
}
static void *
std_control_alloc (void)
{
std_control_state_t *s =
(std_control_state_t *) malloc (sizeof (std_control_state_t));
if (s == 0)
{
GSL_ERROR_NULL ("failed to allocate space for std_control_state",
GSL_ENOMEM);
}
return s;
}
int
gsl_odeiv2_step_set_driver (gsl_odeiv2_step * s, const gsl_odeiv2_driver * d)
{
if (d != NULL)
{
s->type->set_driver (s->state, d);
}
else
{
GSL_ERROR_NULL ("driver pointer is null", GSL_EFAULT);
}
return GSL_SUCCESS;
}
static void *
rk8pd_alloc (size_t dim)
{
rk8pd_state_t *state = (rk8pd_state_t *) malloc (sizeof (rk8pd_state_t));
int i, j;
if (state == 0)
{
GSL_ERROR_NULL ("failed to allocate space for rk8pd_state", GSL_ENOMEM);
}
state->ytmp = (double *) malloc (dim * sizeof (double));
if (state->ytmp == 0)
{
free (state);
GSL_ERROR_NULL ("failed to allocate space for ytmp", GSL_ENOMEM);
}
for (i = 0; i < 13; i++)
{
state->k[i] = (double *) malloc (dim * sizeof (double));
if (state->k[i] == 0)
{
for (j = 0; j < i; j++)
{
free (state->k[j]);
}
free (state->ytmp);
free (state);
GSL_ERROR_NULL ("failed to allocate space for k's", GSL_ENOMEM);
}
}
return state;
}
