gsl_utils_allocation.h

#ifndef GSL_UTILS_ALLOCATION_H
#define GSL_UTILS_ALLOCATION_H
 
#include <gsl/gsl_vector.h>
 
#include <vector>
 
/******************************************************************************/
/*********************************** double ***********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector* create_gsl_vector(const std::vector<double>& v) {
  gsl_vector* g = gsl_vector_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ float ***********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_float* create_gsl_vector(const std::vector<float>& v) {
  gsl_vector_float* g = gsl_vector_float_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_float_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/********************************* long double ********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_long_double* create_gsl_vector(
    const std::vector<long double>& v) {
  gsl_vector_long_double* g = gsl_vector_long_double_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_long_double_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ char ************************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_char* create_gsl_vector(const std::vector<char>& v) {
  gsl_vector_char* g = gsl_vector_char_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_char_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ int *************************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_int* create_gsl_vector(const std::vector<int>& v) {
  gsl_vector_int* g = gsl_vector_int_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_int_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ long ************************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_long* create_gsl_vector(const std::vector<long>& v) {
  gsl_vector_long* g = gsl_vector_long_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_long_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ short ***********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_short* create_gsl_vector(const std::vector<short>& v) {
  gsl_vector_short* g = gsl_vector_short_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_short_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ uchar ***********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_uchar* create_gsl_vector(
    const std::vector<unsigned char>& v) {
  gsl_vector_uchar* g = gsl_vector_uchar_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_uchar_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ uint ************************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_uint* create_gsl_vector(const std::vector<unsigned int>& v) {
  gsl_vector_uint* g = gsl_vector_uint_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_uint_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/************************************ ulong ***********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_ulong* create_gsl_vector(
    const std::vector<unsigned long>& v) {
  gsl_vector_ulong* g = gsl_vector_ulong_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_ulong_set(g, i, v[i]);
  return g;
}
 
/******************************************************************************/
/*********************************** ushort ***********************************/
/******************************************************************************/
[[maybe_unused]]
static gsl_vector_ushort* create_gsl_vector(
    const std::vector<unsigned short>& v) {
  gsl_vector_ushort* g = gsl_vector_ushort_alloc(v.size());
  if (g == nullptr) return nullptr;
  for (size_t i = 0; i < v.size(); ++i) gsl_vector_ushort_set(g, i, v[i]);
  return g;
}
 
#endif  // GSL_UTILS_ALLOCATION_H