自学教程：C++ GSL_ERROR_VAL函数代码示例

gsl_wavelet_workspace *gsl_wavelet_workspace_alloc (size_t n){  gsl_wavelet_workspace *work;  if (n == 0)    {      GSL_ERROR_VAL ("length n must be positive integer", GSL_EDOM, 0);    }  work = (gsl_wavelet_workspace *) malloc (sizeof (gsl_wavelet_workspace));  if (work == NULL)    {      GSL_ERROR_VAL ("failed to allocate struct", GSL_ENOMEM, 0);    }  work->n = n;  work->scratch = (double *) malloc (n * sizeof (double));  if (work->scratch == NULL)    {      /* error in constructor, prevent memory leak */      free (work);      GSL_ERROR_VAL ("failed to allocate scratch space", GSL_ENOMEM, 0);    }  return work;}

gsl_rng *gsl_rng_alloc (const gsl_rng_type * T){  gsl_rng *r = (gsl_rng *) malloc (sizeof (gsl_rng));  if (r == 0)    {      GSL_ERROR_VAL ("failed to allocate space for rng struct",                        GSL_ENOMEM, 0);    };  r->state = calloc (1, T->size);  if (r->state == 0)    {      free (r);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for rng state",                        GSL_ENOMEM, 0);    };  r->type = T;  gsl_rng_set (r, gsl_rng_default_seed);        /* seed the generator */  return r;}

FUNCTION (gsl_matrix, view_array) (QUALIFIER ATOMIC * array,                                    const size_t n1, const size_t n2){  QUALIFIED_VIEW (_gsl_matrix,view) view = NULL_MATRIX_VIEW;  if (n1 == 0)    {      GSL_ERROR_VAL ("matrix dimension n1 must be positive integer",                     GSL_EINVAL, view);    }  else if (n2 == 0)    {      GSL_ERROR_VAL ("matrix dimension n2 must be positive integer",                     GSL_EINVAL, view);    }  {    TYPE(gsl_matrix) m = NULL_MATRIX;    m.data = (ATOMIC *)array;    m.size1 = n1;    m.size2 = n2;    m.tda = n2;     m.block = 0;    m.owner = 0;    view.matrix = m;        return view;  }}

int gsl_histogram2d_set_ranges_uniform (gsl_histogram2d * h,                                     double xmin, double xmax,                                    double ymin, double ymax){  size_t i;  const size_t nx = h->nx, ny = h->ny;  if (xmin >= xmax)    {      GSL_ERROR_VAL ("xmin must be less than xmax", GSL_EINVAL, 0);    }  if (ymin >= ymax)    {      GSL_ERROR_VAL ("ymin must be less than ymax", GSL_EINVAL, 0);    }  /* initialize ranges */  make_uniform (h->xrange, nx, xmin, xmax);  make_uniform (h->yrange, ny, ymin, ymax);  /* clear contents */  for (i = 0; i < nx * ny; i++)    {      h->bin[i] = 0;    }  return GSL_SUCCESS;}

gsl_wavelet *gsl_wavelet_alloc (const gsl_wavelet_type * T, size_t k){  int status;  gsl_wavelet *w = (gsl_wavelet *) malloc (sizeof (gsl_wavelet));  if (w == NULL)    {      GSL_ERROR_VAL ("failed to allocate space for wavelet struct",                     GSL_ENOMEM, 0);    };  w->type = T;  status = (T->init) (&(w->h1), &(w->g1), &(w->h2), &(w->g2),                      &(w->nc), &(w->offset), k);  if (status)    {      free (w);      GSL_ERROR_VAL ("invalid wavelet member", GSL_EINVAL, 0);    }  return w;}

gsl_rng *gsl_rng_clone (const gsl_rng * q){  gsl_rng *r = (gsl_rng *) malloc (sizeof (gsl_rng));  if (r == 0)    {      GSL_ERROR_VAL ("failed to allocate space for rng struct",                        GSL_ENOMEM, 0);    };  r->state = malloc (q->type->size);  if (r->state == 0)    {      free (r);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for rng state",                        GSL_ENOMEM, 0);    };  r->type = q->type;  memcpy (r->state, q->state, q->type->size);  return r;}

/* This function initializes a vector of length n, returning a pointer to a  * newly initialized vector struct. A new block is allocated for the elements  * of the vector, and stored in the block component of the vector struct. * The size of the vector is set to zero while the size of the block is set * to the argument n. The size of block indicates the capacity of the vector. * Argument: * n - size of the elements * Return: * A point to the vector struct if successful. * A null pointer is returned if insufficient memory is available to  * create the vector. */alder_vector_interval_t *alder_vector_interval_init (const size_t n){    alder_vector_interval_block_t * b;    alder_vector_interval_t * v;        v = (alder_vector_interval_t *) malloc (sizeof (alder_vector_interval_t));        if (v == 0)    {        GSL_ERROR_VAL ("failed to allocate space for vector struct",                       GSL_ENOMEM, 0);    }        b = alder_vector_interval_block_t_alloc (n);;        if (b == 0)    {        free (v) ;        GSL_ERROR_VAL ("failed to allocate space for block",                       GSL_ENOMEM, 0);    }        v->data = b->data;    v->size = 0;    v->block = b;        return v;}

gsl_cheb_series * gsl_cheb_alloc(const size_t order){  gsl_cheb_series * cs = (gsl_cheb_series *) malloc(sizeof(gsl_cheb_series));    if(cs == 0) {    GSL_ERROR_VAL("failed to allocate gsl_cheb_series struct", GSL_ENOMEM, 0);  }    cs->order    = order;  cs->order_sp = order;  cs->c = (double *) malloc((order+1) * sizeof(double));  if(cs->c == 0) {    GSL_ERROR_VAL("failed to allocate cheb coefficients", GSL_ENOMEM, 0);  }  cs->f = (double *) malloc((order+1) * sizeof(double));  if(cs->f == 0) {    GSL_ERROR_VAL("failed to allocate cheb function space", GSL_ENOMEM, 0);  }  return cs;}

gsl_ntuple *gsl_ntuple_open (char *filename, void *ntuple_data, size_t size){  gsl_ntuple *ntuple = malloc (sizeof (gsl_ntuple));  if (ntuple == 0)    {      GSL_ERROR_VAL ("failed to allocate space for ntuple struct",		     GSL_ENOMEM, 0);    }  ntuple->ntuple_data = ntuple_data;  ntuple->size = size;  ntuple->file = fopen (filename, "rb");  if (ntuple->file == 0)    {      free (ntuple);      GSL_ERROR_VAL ("unable to open ntuple file for reading",                      GSL_EFAILED, 0);    }  return ntuple;}

gsl_histogram2d *gsl_histogram2d_calloc_uniform (const size_t nx, const size_t ny,                                const double xmin, const double xmax,                                const double ymin, const double ymax){  gsl_histogram2d *h;  if (xmin >= xmax)    {      GSL_ERROR_VAL ("xmin must be less than xmax", GSL_EINVAL, 0);    }  if (ymin >= ymax)    {      GSL_ERROR_VAL ("ymin must be less than ymax", GSL_EINVAL, 0);    }  h = gsl_histogram2d_calloc (nx, ny);  if (h == 0)    {      return h;    }  make_uniform (h->xrange, nx, xmin, xmax);  make_uniform (h->yrange, ny, ymin, ymax);  return h;}

gsl_qrng *gsl_qrng_clone (const gsl_qrng * q){  gsl_qrng * r = (gsl_qrng *) malloc (sizeof (gsl_qrng));  if (r == 0)    {      GSL_ERROR_VAL ("failed to allocate space for rng struct",                        GSL_ENOMEM, 0);    };  r->dimension = q->dimension;  r->state_size = q->state_size;  r->state = malloc (r->state_size);  if (r->state == 0)    {      free (r);      GSL_ERROR_VAL ("failed to allocate space for rng state",                        GSL_ENOMEM, 0);    };  r->type = q->type;  memcpy (r->state, q->state, q->state_size);  return r;}

_gsl_vector_match_const_viewgsl_vector_match_const_subvector (const gsl_vector_match * v, size_t offset, size_t n){    _gsl_vector_match_const_view view = {{0, 0, 0, 0, 0}};        if (n == 0)    {        GSL_ERROR_VAL ("vector length n must be positive integer",                       GSL_EINVAL, view);    }        if (offset + (n - 1) >= v->size)    {        GSL_ERROR_VAL ("view would extend past end of vector",                       GSL_EINVAL, view);    }        {        gsl_vector_match s = {0, 0, 0, 0, 0};                s.data = v->data + 1 * v->stride * offset ;        s.size = n;        s.stride = v->stride;        s.block = v->block;        s.owner = 0;                view.vector = s;        return view;    }}

gsl_monte_plain_state *gsl_monte_plain_alloc (size_t dim){  gsl_monte_plain_state *s =    (gsl_monte_plain_state *) malloc (sizeof (gsl_monte_plain_state));  if (s == 0)    {      GSL_ERROR_VAL ("failed to allocate space for state struct",		     GSL_ENOMEM, 0);    }  s->x = (double *) malloc (dim * sizeof (double));  if (s->x == 0)    {      free (s);      GSL_ERROR_VAL ("failed to allocate space for working vector",		     GSL_ENOMEM, 0);    }  s->dim = dim;  return s;}

gsl_min_fminimizer *gsl_min_fminimizer_alloc (const gsl_min_fminimizer_type * T) {  gsl_min_fminimizer * s =     (gsl_min_fminimizer *) malloc (sizeof (gsl_min_fminimizer));  if (s == 0)    {      GSL_ERROR_VAL ("failed to allocate space for minimizer struct",                        GSL_ENOMEM, 0);    };  s->state = malloc (T->size);  if (s->state == 0)    {      free (s);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for minimizer state",                        GSL_ENOMEM, 0);    };  s->type = T ;  s->function = NULL;  return s;}

gsl_permutation *gsl_permutation_alloc (const size_t n){  gsl_permutation * p;  if (n == 0)    {      GSL_ERROR_VAL ("permutation length n must be positive integer",                        GSL_EDOM, 0);    }  p = (gsl_permutation *) malloc (sizeof (gsl_permutation));  if (p == 0)    {      GSL_ERROR_VAL ("failed to allocate space for permutation struct",                        GSL_ENOMEM, 0);    }  p->data = (size_t *) malloc (n * sizeof (size_t));  if (p->data == 0)    {      free (p);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for permutation data",                        GSL_ENOMEM, 0);    }  p->size = n;  return p;}

_gsl_vector_match_const_viewgsl_vector_match_const_view_array_with_stride (const gsl_vector_match * base,                                               size_t stride,                                               size_t n){    _gsl_vector_match_const_view view = {{0, 0, 0, 0, 0}};        if (n == 0)    {        GSL_ERROR_VAL ("vector length n must be positive integer",                       GSL_EINVAL, view);    }        if (stride == 0)    {        GSL_ERROR_VAL ("stride must be positive integer",                       GSL_EINVAL, view);    }        {        gsl_vector_match v = {0, 0, 0, 0, 0};                v.data = (alder_match_t *)base ;        v.size = n;        v.stride = stride;        v.block = 0;        v.owner = 0;                view.vector = v;        return view;    }}

/* This function allocates memory for a block of n elements of  * alder_vector_interval_data_t, returning a pointer to the block struct.  * The block is not initialized and so the values of its elements are  * undefined. Use the function  * alder_vector_interval_data_t_calloc if you want to ensure that all the  * elements are initialized to zero. * Argument:  * n - size of the elements * Return: * A point to the block struct if successful. * A null pointer is returned if insufficient memory is available to  * create the block. */alder_vector_interval_block_t *alder_vector_interval_block_t_alloc (const size_t n){    alder_vector_interval_block_t * b;        if (n == 0)    {        GSL_ERROR_VAL ("block length n must be positive integer",                       GSL_EINVAL, 0);    }        b = (alder_vector_interval_block_t *) malloc (sizeof (alder_vector_interval_block_t));        if (b == 0)    {        GSL_ERROR_VAL ("failed to allocate space for block struct",                       GSL_ENOMEM, 0);    }        b->data = (alder_vector_interval_data_t *) calloc (1, 1 * n * sizeof (alder_vector_interval_data_t));        if (b->data == 0)    {        free (b);        GSL_ERROR_VAL ("failed to allocate space for block data",                       GSL_ENOMEM, 0);    }        b->size = n;        return b;}

gsl_vector_match *gsl_vector_match_init (){    gsl_block_match * block;    gsl_vector_match * v;        v = (gsl_vector_match *) malloc (sizeof (gsl_vector_match));        if (v == 0)    {        GSL_ERROR_VAL ("failed to allocate space for vector struct",                       GSL_ENOMEM, 0);    }        block = gsl_block_match_alloc (GSLVECTORMATCHINITSIZE);        if (block == 0)    {        free (v) ;                GSL_ERROR_VAL ("failed to allocate space for block",                       GSL_ENOMEM, 0);    }        v->data = block->data ;    v->size = 0;    v->stride = 1;    v->block = block;    v->owner = 1;        return v;}

gsl_qrng *gsl_qrng_alloc (const gsl_qrng_type * T, unsigned int dimension){  gsl_qrng * q = (gsl_qrng *) malloc (sizeof (gsl_qrng));  if (q == 0)    {      GSL_ERROR_VAL ("allocation failed for qrng struct",                        GSL_ENOMEM, 0);    };  q->dimension = dimension;  q->state_size = T->state_size(dimension);  q->state = malloc (q->state_size);  if (q->state == 0)    {      free (q);      GSL_ERROR_VAL ("allocation failed for qrng state",                        GSL_ENOMEM, 0);    };  q->type = T;  T->init_state(q->state, q->dimension);  return q;}

gsl_histogram2d_pdf *gsl_histogram2d_pdf_alloc (const size_t nx, const size_t ny){  const size_t n = nx * ny;  gsl_histogram2d_pdf *p;  if (n == 0)    {      GSL_ERROR_VAL ("histogram2d pdf length n must be positive integer",                        GSL_EDOM, 0);    }  p = (gsl_histogram2d_pdf *) malloc (sizeof (gsl_histogram2d_pdf));  if (p == 0)    {      GSL_ERROR_VAL ("failed to allocate space for histogram2d pdf struct",                        GSL_ENOMEM, 0);    }  p->xrange = (double *) malloc ((nx + 1) * sizeof (double));  if (p->xrange == 0)    {      free (p);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for histogram2d pdf xranges",                        GSL_ENOMEM, 0);    }  p->yrange = (double *) malloc ((ny + 1) * sizeof (double));  if (p->yrange == 0)    {      free (p->xrange);      free (p);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for histogram2d pdf yranges",                        GSL_ENOMEM, 0);    }  p->sum = (double *) malloc ((n + 1) * sizeof (double));  if (p->sum == 0)    {      free (p->yrange);      free (p->xrange);      free (p);         /* exception in constructor, avoid memory leak */      GSL_ERROR_VAL ("failed to allocate space for histogram2d pdf sums",                        GSL_ENOMEM, 0);    }  p->nx = nx;  p->ny = ny;  return p;}

doublegsl_spmatrix_get(const gsl_spmatrix *m, const size_t i, const size_t j){  if (i >= m->size1)    {      GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0.0);    }  else if (j >= m->size2)    {      GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0.0);    }  else    {      if (GSL_SPMATRIX_ISTRIPLET(m))        {          /* traverse binary tree to search for (i,j) element */          void *ptr = tree_find(m, i, j);          double x = ptr ? *(double *) ptr : 0.0;          return x;        }      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 *mi = 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 (mi[p] == j)                return m->data[p];            }        }      else        {          GSL_ERROR_VAL("unknown sparse matrix type", GSL_EINVAL, 0.0);        }      /* element not found; return 0 */      return 0.0;    }} /* gsl_spmatrix_get() */

gsl_integration_qawo_table *gsl_integration_qawo_table_alloc (double omega, double L,                                   enum gsl_integration_qawo_enum sine,                                  size_t n){  gsl_integration_qawo_table *t;  double * chebmo;  if (n == 0)    {      GSL_ERROR_VAL ("table length n must be positive integer",                        GSL_EDOM, 0);    }  t = (gsl_integration_qawo_table *)    malloc (sizeof (gsl_integration_qawo_table));  if (t == 0)    {      GSL_ERROR_VAL ("failed to allocate space for qawo_table struct",                        GSL_ENOMEM, 0);    }  chebmo = (double *)  malloc (25 * n * sizeof (double));  if (chebmo == 0)    {      free (t);      GSL_ERROR_VAL ("failed to allocate space for chebmo block",                        GSL_ENOMEM, 0);    }  t->n = n;  t->sine = sine;  t->omega = omega;  t->L = L;  t->par = 0.5 * omega * L;  t->chebmo = chebmo;  /* precompute the moments */  {     size_t i;    double scale = 1.0;    for (i = 0 ; i < t->n; i++)      {        compute_moments (t->par * scale, t->chebmo + 25*i);        scale *= 0.5;      }  }  return t;}

gsl_sum_levin_utrunc_workspace * gsl_sum_levin_utrunc_alloc (size_t n){  gsl_sum_levin_utrunc_workspace * w;  if (n == 0)    {      GSL_ERROR_VAL ("length n must be positive integer", GSL_EDOM, 0);    }  w = (gsl_sum_levin_utrunc_workspace *) malloc(sizeof(gsl_sum_levin_utrunc_workspace));  if (w == NULL)    {      GSL_ERROR_VAL ("failed to allocate struct", GSL_ENOMEM, 0);    }  w->q_num = (double *) malloc (n * sizeof (double));  if (w->q_num == NULL)    {      free(w) ; /* error in constructor, prevent memory leak */      GSL_ERROR_VAL ("failed to allocate space for q_num", GSL_ENOMEM, 0);    }  w->q_den = (double *) malloc (n * sizeof (double));  if (w->q_den == NULL)    {      free (w->q_num);      free (w) ; /* error in constructor, prevent memory leak */      GSL_ERROR_VAL ("failed to allocate space for q_den", GSL_ENOMEM, 0);    }  w->dsum = (double *) malloc (n * sizeof (double));  if (w->dsum == NULL)    {      free (w->q_den);      free (w->q_num);      free (w) ; /* error in constructor, prevent memory leak */      GSL_ERROR_VAL ("failed to allocate space for dsum", GSL_ENOMEM, 0);    }  w->size = n;  w->terms_used = 0;  w->sum_plain = 0;  return w;}

quasi_monte_state* quasi_monte_alloc(size_t dim) {    quasi_monte_state* s = (quasi_monte_state*)malloc(sizeof(quasi_monte_state));    if (s == NULL) {        GSL_ERROR_VAL("failed to allocate space for quasi_monte_state", GSL_ENOMEM, 0);    }    s->x = (double*)malloc(dim * sizeof(double));    if (s->x == NULL) {        free(s);        GSL_ERROR_VAL("failed to allocate space for working vector", GSL_ENOMEM, 0);    }    s->dim = dim;    return s;}

double mygsl_histogram3d_get(const mygsl_histogram3d * h, const size_t i,                             const size_t j, const size_t k){    const size_t nx = h->nx;    const size_t ny = h->ny;    const size_t nz = h->nz;    if (i >= nx) GSL_ERROR_VAL ("index i lies outside valid range of 0 .. nx - 1",                                    GSL_EDOM, 0);    if (j >= ny) GSL_ERROR_VAL ("index j lies outside valid range of 0 .. ny - 1",                                    GSL_EDOM, 0);    if (k >= nz) GSL_ERROR_VAL ("index k lies outside valid range of 0 .. nz - 1",                                    GSL_EDOM, 0);    return h->bin[i*ny*nz + j*nz + k];}

gsl_multimin_fminimizer *gsl_multimin_fminimizer_alloc (const gsl_multimin_fminimizer_type * T,                               size_t n){  int status;  gsl_multimin_fminimizer *s =    (gsl_multimin_fminimizer *) malloc (sizeof (gsl_multimin_fminimizer));  if (s == 0)    {      GSL_ERROR_VAL ("failed to allocate space for minimizer struct",                     GSL_ENOMEM, 0);    }  s->type = T;  s->x = gsl_vector_calloc (n);  if (s->x == 0)     {      free (s);      GSL_ERROR_VAL ("failed to allocate space for x", GSL_ENOMEM, 0);    }  s->state = malloc (T->size);  if (s->state == 0)    {      gsl_vector_free (s->x);      free (s);      GSL_ERROR_VAL ("failed to allocate space for minimizer state",                     GSL_ENOMEM, 0);    }  status = (T->alloc) (s->state, n);  if (status != GSL_SUCCESS)    {      free (s->state);      gsl_vector_free (s->x);      free (s);      GSL_ERROR_VAL ("failed to initialize minimizer state", GSL_ENOMEM, 0);    }  return s;}

int gsl_cheb_init(gsl_cheb_series * cs, const gsl_function *func,                  const double a, const double b){  size_t k, j;  if(a >= b) {    GSL_ERROR_VAL("null function interval [a,b]", GSL_EDOM, 0);  }  cs->a = a;  cs->b = b;  /* cs->err = 0.0; */  {     double bma = 0.5 * (cs->b - cs->a);    double bpa = 0.5 * (cs->b + cs->a);    double fac = 2.0/(cs->order +1.0);    for(k = 0; k<=cs->order; k++) {      double y = cos(M_PI * (k+0.5)/(cs->order+1));      cs->f[k] = GSL_FN_EVAL(func, (y*bma + bpa));    }        for(j = 0; j<=cs->order; j++) {      double sum = 0.0;      for(k = 0; k<=cs->order; k++)         sum += cs->f[k]*cos(M_PI * j*(k+0.5)/(cs->order+1));      cs->c[j] = fac * sum;    }      }  return GSL_SUCCESS;}

doublegsl_histogram_pdf_sample (const gsl_histogram_pdf * p, double r){  size_t i;  int status;/* Wrap the exclusive top of the bin down to the inclusive bottom of   the bin. Since this is a single point it should not affect the   distribution. */  if (r == 1.0)    {      r = 0.0;    }  status = find (p->n, p->sum, r, &i);  if (status)    {      GSL_ERROR_VAL ("cannot find r in cumulative pdf", GSL_EDOM, 0);    }  else    {      double delta = (r - p->sum[i]) / (p->sum[i + 1] - p->sum[i]);      double x = p->range[i] + delta * (p->range[i + 1] - p->range[i]);      return x;    }}

FUNCTION(gsl_matrix, view_array_with_tda) (QUALIFIER ATOMIC * base,                                           const size_t n1,                                            const size_t n2,                                           const size_t tda){  QUALIFIED_VIEW (_gsl_matrix,view) view = NULL_MATRIX_VIEW;  if (n2 > tda)    {      GSL_ERROR_VAL ("matrix dimension n2 must not exceed tda",                     GSL_EINVAL, view);    }  {    TYPE(gsl_matrix) m = NULL_MATRIX;    m.data = (ATOMIC *)base;    m.size1 = n1;    m.size2 = n2;    m.tda = tda;    m.block = 0;    m.owner = 0;    view.matrix = m;        return view;  }}

gsl_multiset *gsl_multiset_alloc (const size_t n, const size_t k){  gsl_multiset * c;  if (n == 0)    {      GSL_ERROR_VAL ("multiset parameter n must be positive integer",                        GSL_EDOM, 0);    }  if (k > n)    {      GSL_ERROR_VAL ("multiset length k must be an integer less than or equal to n",                        GSL_EDOM, 0);    }  c = (gsl_multiset *) malloc (sizeof (gsl_multiset));  if (c == 0)    {      GSL_ERROR_VAL ("failed to allocate space for multiset struct",                        GSL_ENOMEM, 0);    }  if (k > 0)    {      c->data = (size_t *) malloc (k * sizeof (size_t));      if (c->data == 0)        {          free (c);             /* exception in constructor, avoid memory leak */          GSL_ERROR_VAL ("failed to allocate space for multiset data",                         GSL_ENOMEM, 0);        }    }  else    {      c->data = 0;    }  c->n = n;  c->k = k;  return c;}