/home/runner/work/gslcpp/gslcpp/include/gslcpp/vec/v-iface.hpp

Source
/// \dir        include/gslcpp/vec
/// \brief      Types and functions specific to interface to GSL's vectors.

/// \file       include/gslcpp/vec/v-iface.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition for gsl::v_iface.

#pragma once

#include "../wrap/add-constant.hpp" // add_constant
#include "../wrap/add.hpp" // add
#include "../wrap/axpby.hpp" // axpby
#include "../wrap/div.hpp" // div
#include "../wrap/element.hpp" // element_t
#include "../wrap/equal.hpp" // equal
#include "../wrap/fprintf.hpp" // fprintf
#include "../wrap/fread.hpp" // fread
#include "../wrap/fscanf.hpp" // fscanf
#include "../wrap/fwrite.hpp" // fwrite
#include "../wrap/get.hpp" // get
#include "../wrap/imag.hpp" // imag
#include "../wrap/isneg.hpp" // isneg
#include "../wrap/isnonneg.hpp" // isnonneg
#include "../wrap/isnull.hpp" // isnull
#include "../wrap/ispos.hpp" // ispos
#include "../wrap/max-index.hpp" // max_index
#include "../wrap/max.hpp" // max
#include "../wrap/memcpy.hpp" // memcpy
#include "../wrap/min-index.hpp" // min_index
#include "../wrap/min.hpp" // min
#include "../wrap/minmax-index.hpp" // minmax_index
#include "../wrap/minmax.hpp" // minmax
#include "../wrap/mul.hpp" // mul
#include "../wrap/ptr.hpp" // ptr
#include "../wrap/real.hpp" // real
#include "../wrap/reverse.hpp" // reverse
#include "../wrap/scale.hpp" // scale
#include "../wrap/set-all.hpp" // set_all
#include "../wrap/set-basis.hpp" // set_basis
#include "../wrap/set-zero.hpp" // set_zero
#include "../wrap/set.hpp" // set
#include "../wrap/sub.hpp" // sub
#include "../wrap/subvector.hpp" // subvector
#include "../wrap/sum.hpp" // sum
#include "../wrap/swap-elements.hpp" // swap_elements
#include "../wrap/swap.hpp" // swap
#include "v-iterator.hpp" // iterator
#include "v-view.hpp" // view
#include <iostream> // ostream

namespace gsl {


using std::is_const_v;


/// Interface for every kind of vector.
/// \tparam T  Type of each element in vector.
/// \tparam N  Compile-time number of elements (0 means set at run-time).
/// \tparam S  Type specifying interface to storage of elements.
template<typename T, size_t N, template<typename, size_t> class S>
struct v_iface: public S<T, N> {
  /// Inherit constructors.
  using S<T, N>::S;

  /// Reference to instance of w_vector<T>, which is gsl_vector,
  /// gsl_vector_float, or the like.
  using S<T, N>::v;

  enum { SIZE= N /**< Size at compile-time. */ };

  /// Element-type needed by gsl::v_iterator<v_iface>.
  using E= T;

  /// Type of iterator that points to mutable element.
  using iterator= v_iterator<v_iface>;

  /// Type of iterator that points to immutable element.
  using const_iterator= v_iterator<v_iface const>;

  /// Iterator that points to first element.
  /// @return  Iterator that points to first element.
  iterator begin() { return iterator(*this, 0); }

  /// Iterator that points to element just past last element.
  /// @return  Iterator that points to element just past last element.
  iterator end() { return iterator(*this, size()); }

  /// Iterator that points to first element.
  /// @return  Iterator that points to first element.
  const_iterator begin() const { return const_iterator(*this, 0); }

  /// Iterator that points to element just past last element.
  /// @return  Iterator that points to element just past last element.
  const_iterator end() const { return const_iterator(*this, size()); }

  /// Size of vector.
  /// @return  Size of vector.
  size_t size() const { return v()->size; }

  /// Pointer to first element in vector.
  /// - Be careful to check `v()->stride` in case data be not contiguous.
  /// @return  Pointer to first element.
  T *data() { return (T *)v()->data; /* Cast for complex. */ }

  /// Pointer to first element in immutable vector.
  /// - Be careful to check `v()->stride` in case data be not contiguous.
  /// @return  Pointer to first immutable element.
  T const *data() const {
    return (T const *)v()->data; /* Cast for complex. */
  }

  /// Read element with bounds-checking.
  /// @param i  Offset of element.
  /// @return  Value of element.
  T get(size_t i) const { return w_get(v(), i); }

  /// Write element with bounds-checking.
  /// @param i  Offset of element.
  /// @param x  New value for element.
  void set(size_t i, T const &x) { w_set(v(), i, x); }

  /// Read element without bounds-checking.
  /// @param i  Offset of element.
  /// @return  Reference to immutable element.
  T const &operator[](size_t i) const { return data()[i * v()->stride]; }

  /// Write element without bounds-checking.
  /// @param i  Offset of element.
  /// @return  Reference to mutable element.
  T &operator[](size_t i) { return data()[i * v()->stride]; }

  /// Retrieve pointer to `i`th element with bounds-checking.
  /// This could be useful if stride unknown.
  /// @param i  Offset of element.
  /// @return  Pointer to mutable element.
  T *ptr(size_t i) { return w_ptr(v(), i); }

  /// Retrieve pointer to `i`th element with bounds-checking.
  /// This could be useful if stride unknown.
  /// @param i  Offset of element.
  /// @return  Pointer to immutable element.
  T const *ptr(size_t i) const { return w_ptr(v(), i); }

  /// Set every element.
  /// @param x  Value to which each element should be set.
  void set_all(T const &x) { w_set_all(v(), x); }

  /// Set every element to zero.
  void set_zero() { w_set_zero(v()); }

  /// Set element at offset `i` to unity and every other element to zero.
  /// @param i  Offset of element set to unity.
  /// @return  TBD: GSL's documentation does not specify.
  int set_basis(size_t i) { return w_set_basis(v(), i); }

  /// Write non-portable binary-image of vector to file.
  /// @param f  Pointer to structure for buffered interface.
  /// @return  Zero only on success.
  int fwrite(FILE *f) const { return w_fwrite(f, v()); }

  /// Read non-portable binary-image of vector from file.
  /// @param f  Pointer to structure for buffered interface.
  /// @return  Zero only on success.
  int fread(FILE *f) { return w_fread(f, v()); };

  /// Write ASCII-formatted representation of vector to file.
  /// @param flp  Pointer to structure for buffered interface.
  /// @param fmt  printf()-style format-string.
  /// @return  Zero only on success.
  int fprintf(FILE *flp, char const *fmt) const {
    return w_fprintf(flp, v(), fmt);
  }

  /// Read ASCII-formatted representation of vector from file.
  /// @param f  Pointer to structure for buffered interface.
  /// @return  Zero only on success.
  int fscanf(FILE *f) { return w_fscanf(f, v()); }

  /// View of real-part of complex vector.
  /// \return  View of real-part of complex vector.
  v_iface<element_t<T>, N, v_view> real() { return w_real(v()); }

  /// View of real-part of complex vector.
  /// \return  View of real-part of complex vector.
  v_iface<element_t<T> const, N, v_view> real() const { return w_real(v()); }

  /// View of imaginary-part of complex vector.
  /// \return  View of imaginary-part of complex vector.
  v_iface<element_t<T>, N, v_view> imag() { return w_imag(v()); }

  /// View of imaginary-part of complex vector.
  /// \return  View of imaginary-part of complex vector.
  v_iface<element_t<T> const, N, v_view> imag() const { return w_imag(v()); }

  /// View of subvector of vector.  Arguments are reordered from those given to
  /// gsl_vector_subvector_with_stride().  Putting initial offset and stride at
  /// end allows each to have good default (0 for initial offset and 1 for
  /// stride).
  /// @param n  Number of elements in view.
  /// @param i  Offset in vector of first element in view.
  /// @param s  Stride of view relative to vector.
  /// @return  View of subvector.
  v_iface<T, N, v_view> subvector(size_t n, size_t i= 0, size_t s= 1) {
    return w_subvector(v(), i, s, n);
  }

  /// View of subvector of vector.  Arguments are reordered from those given to
  /// gsl_vector_subvector_with_stride().  Putting initial offset and stride at
  /// end allows each to have good default (0 for initial offset and 1 for
  /// stride).
  /// @param n  Number of elements in view.
  /// @param i  Offset in vector of first element in view.
  /// @param s  Stride of view relative to vector.
  /// @return  View of subvector.
  v_iface<T const, N, v_view>
  subvector(size_t n, size_t i= 0, size_t s= 1) const {
    return w_subvector(v(), i, s, n);
  }

  /// View of vector.
  /// @return  View of vector.
  v_iface<T, N, v_view> view() { return w_subvector(v(), 0, 1, size()); }

  /// View of vector.
  /// @return  View of vector.
  v_iface<T const, N, v_view> view() const {
    return w_subvector(v(), 0, 1, size());
  }

  /// Swap elements within this vector.
  /// @param i  Offset of one element.
  /// @param j  Offset of other element.
  /// @return  TBD: GSL's documentation does not specify.
  int swap_elements(size_t i, size_t j) { return w_swap_elements(v(), i, j); }

  /// Reverse order of elements.
  /// @return  TBD: GSL's documentation does not specify.
  int reverse() { return w_reverse(v()); }

  /// Add contents of `b` into this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be added into this.
  /// \return  TBD: GSL's documentation does not specify.
  template<size_t ON, template<typename, size_t> class OV>
  int add(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    return w_add(v(), b.v());
  }

  /// Subtract contents of `b` from this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be subtracted from this.
  /// \return  TBD: GSL's documentation does not specify.
  template<size_t ON, template<typename, size_t> class OV>
  int sub(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    return w_sub(v(), b.v());
  }

  /// Multiply contents of `b` into this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be multiplied into this.
  /// \return  TBD: GSL's documentation does not specify.
  template<size_t ON, template<typename, size_t> class OV>
  int mul(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    return w_mul(v(), b.v());
  }

  /// Divide contents of `b` into this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be divided into this.
  /// \return  TBD: GSL's documentation does not specify.
  template<size_t ON, template<typename, size_t> class OV>
  int div(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    return w_div(v(), b.v());
  }

  /// Add contents of `b` into this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be added into this.
  /// \return  Reference to this vector after modification.
  template<size_t ON, template<typename, size_t> class OV>
  v_iface &operator+=(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    add(b);
    return *this;
  }

  /// Subtract contents of `b` from this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be subtracted from this.
  /// \return  Reference to this vector after modification.
  template<size_t ON, template<typename, size_t> class OV>
  v_iface &operator-=(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    sub(b);
    return *this;
  }

  /// Multiply contents of `b` into this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be multiplied into this.
  /// \return  Reference to this vector after modification.
  template<size_t ON, template<typename, size_t> class OV>
  v_iface &operator*=(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    mul(b);
    return *this;
  }

  /// Divide contents of `b` into this vector in place.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Vector whose contents should be divided into this.
  /// @return  Reference to this vector after modification.
  template<size_t ON, template<typename, size_t> class OV>
  v_iface &operator/=(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    div(b);
    return *this;
  }

  /// Copy contents of `b` into this vector.
  /// \tparam ON  Compile-time number of elements in `b`.
  /// \tparam OV  Type of interface to storage for `b`.
  /// \param b  Reference to vector whose data will be copied.
  /// \return  Reference to this instance after assignment.
  template<size_t ON, template<typename, size_t> class OV>
  v_iface &operator=(v_iface<T, ON, OV> const &b) {
    static_assert(N == ON || N == 0 || ON == 0);
    memcpy(*this, b);
    return *this;
  }

  /// Copy contents of `b` into this vector.
  /// \param b  Reference to vector whose data will be copied.
  /// \return  Reference to this instance after assignment.
  v_iface &operator=(v_iface const &b) {
    memcpy(*this, b);
    return *this;
  }

  /// Enable move-constructor in gsl::v_stor to work.
  v_iface(v_iface &&)= default;

  /// Multiply scalar into this vector in place.
  /// @param x  Scalar to multiply into this.
  /// @return  TBD: GSL's documentation does not specify.
  int scale(T const &x) { return w_scale(v(), x); }

  /// Multiply scalar into this vector in place.
  /// @param x  Scalar to multiply into this.
  /// @return  Reference to this vector after modification.
  v_iface &operator*=(T const &x) {
    scale(x);
    return *this;
  }

  /// Add constant into each element of this vector in place.
  /// @param x  Constant to add into this vector.
  /// @return  TBD: GSL's documentation does not specify.
  int add_constant(T const &x) { return w_add_constant(v(), x); }

  /// Add constant into each element of this vector in place.
  /// @param x  Constant to add into this vector.
  /// @return  Reference to this vector after modification.
  v_iface &operator+=(T const &x) {
    add_constant(x);
    return *this;
  }

  /// Sum of elements.
  /// @return  Sum of elements.
  T sum() const { return w_sum(v()); }

  /// Greatest value of any element.
  /// @return  Greatest value of any element.
  T max() const { return w_max(v()); }

  /// Least value of any element.
  /// @return  Least value of any element.
  T min() const { return w_min(v()); }

  /// Greatest value and least value of any element.
  /// @param min  On return, least value.
  /// @param max  On return, greatest value.
  void minmax(T &min, T &max) const { w_minmax(v(), &min, &max); }

  /// Offset of greatest value.
  /// @return  Offset of greatest value.
  size_t max_index() const { return w_max_index(v()); }

  /// Offset of least value.
  /// @return  Offset of least value.
  size_t min_index() const { return w_min_index(v()); }

  /// Offset of least value and offset of greatest value.
  /// @param imin  On return, offset of least value.
  /// @param imax  On return, offset of greatest value.
  void minmax_index(size_t &imin, size_t &imax) const {
    w_minmax_index(v(), &imin, &imax);
  }

  /// True only if every element have zero value.
  /// @return  True only if every element be zero.
  bool isnull() const { return w_isnull(v()); }

  /// True only if every element be positive.
  /// @return  True only if every element be positive.
  bool ispos() const { return w_ispos(v()); }

  /// True only if every element be negative.
  /// @return  True only if every element be negative.
  bool isneg() const { return w_isneg(v()); }

  /// True only if every element be non-negative.
  /// @return  True only if every element be non-negative.
  bool isnonneg() const { return w_isnonneg(v()); }
};


/// Test equality of two vectors.
/// @tparam T1  Type of element in first vector.
/// @tparam T2  Type of element in second vector.
/// @tparam N1  Compile-time number of elements in first vector.
/// @tparam N2  Compile-time number of elements in second vector.
/// @tparam V1  Type of storage for first vector.
/// @tparam V2  Type of storage for second vector.
/// @param v1  Reference to first vector.
/// @param v2  Reference to second vector.
/// @return  True only if vectors be equal.
template<
      typename T1,
      typename T2,
      size_t N1,
      size_t N2,
      template<typename, size_t>
      class V1,
      template<typename, size_t>
      class V2>
bool equal(v_iface<T1, N1, V1> const &v1, v_iface<T2, N2, V2> const &v2) {
  static_assert(N1 == N2 || N1 == 0 || N2 == 0);
  return w_equal(v1.v(), v2.v());
}


/// Test equality of two vectors.
/// @tparam T1  Type of element in first vector.
/// @tparam T2  Type of element in second vector.
/// @tparam N1  Compile-time number of elements in first vector.
/// @tparam N2  Compile-time number of elements in second vector.
/// @tparam V1  Type of storage for first vector.
/// @tparam V2  Type of storage for second vector.
/// @param u  Reference to first vector.
/// @param v  Reference to second vector.
/// @return  True only if vectors be equal.
template<
      typename T1,
      typename T2,
      size_t N1,
      size_t N2,
      template<typename, size_t>
      class V1,
      template<typename, size_t>
      class V2>
bool operator==(v_iface<T1, N1, V1> const &u, v_iface<T2, N2, V2> const &v) {
  static_assert(
        N1 == N2 || N1 == 0 || N2 == 0, "incompatible size at compile-time");
  return equal(u, v);
}


/// Test inequality of two vectors.
/// @tparam T1  Type of element in first vector.
/// @tparam T2  Type of element in second vector.
/// @tparam N1  Compile-time number of elements in first vector.
/// @tparam N2  Compile-time number of elements in second vector.
/// @tparam V1  Type of storage for first vector.
/// @tparam V2  Type of storage for second vector.
/// @param u  Reference to first vector.
/// @param v  Reference to second vector.
/// @return  True only if vectors be unequal.
template<
      typename T1,
      typename T2,
      size_t N1,
      size_t N2,
      template<typename, size_t>
      class V1,
      template<typename, size_t>
      class V2>
bool operator!=(v_iface<T1, N1, V1> const &u, v_iface<T2, N2, V2> const &v) {
  static_assert(N1 == N2 || N1 == 0 || N2 == 0);
  return !equal(u, v);
}


/// Print vector to output-stream.
/// @tparam T  Type of element in vector.
/// @tparam N  Number of elements in vector.
/// @tparam V  Type of storage for vector.
/// @param os  Reference to output-stream.
/// @param u  Reference to vector.
/// @return  Reference to modified output-stream.
template<typename T, size_t N, template<typename, size_t> class V>
std::ostream &operator<<(std::ostream &os, v_iface<T, N, V> const &u) {
  os << "[";
  int const last= int(u.size()) - 1;
  for(int i= 0; i < last; ++i) os << u[i] << ",";
  if(last >= 0) os << u[last];
  os << "]";
  return os;
}


/// Linearly combine vector `x` into vector `y` in place.
/// @tparam T1  Type of element in `x`.
/// @tparam T2  Type of element in `y`.
/// @tparam N1  Compile-time number of elements in `x`.
/// @tparam N2  Compile-time number of elements in `y`.
/// @tparam V1  Type of storage for `x`.
/// @tparam V2  Type of storage for `y`.
/// @param alpha  Coeffient of `x`.
/// @param x  First vector (source).
/// @param beta  Coefficient of `y`.
/// @param y  Second vector and (source and destination).
/// @return  TBD: GSL's documentation does not specify.
template<
      typename T1,
      typename T2,
      size_t N1,
      size_t N2,
      template<typename, size_t>
      class V1,
      template<typename, size_t>
      class V2>
int axpby(
      T1 const &alpha,
      v_iface<T1, N1, V1> const &x,
      T2 const &beta,
      v_iface<T2, N2, V2> &y) {
  static_assert(N1 == N2 || N1 == 0 || N2 == 0);
  return w_axpby(alpha, x.v(), beta, y.v());
}


/// Copy data from `src`, whose length must be same as that of `dst`.
/// @tparam T1  Type of element in `dst`.
/// @tparam T2  Type of element in `src`.
/// @tparam N1  Compile-time number of elements in `dst`.
/// @tparam N2  Compile-time number of elements in `src`.
/// @tparam V1  Type of storage for `dst`.
/// @tparam V2  Type of storage for `src`.
/// @param dst  Destination.
/// @param src  Source.
/// @return  TBD: GSL's documentation does not specify.
template<
      typename T1,
      typename T2,
      size_t N1,
      size_t N2,
      template<typename, size_t>
      class V1,
      template<typename, size_t>
      class V2>
int memcpy(v_iface<T1, N1, V1> &dst, v_iface<T2, N2, V2> const &src) {
  static_assert(N1 == N2 || N1 == 0 || N2 == 0);
  return w_memcpy(dst.v(), src.v());
}


/// Swap contents of one and other vector, each with same length.
/// @tparam T1  Type of element in first vector.
/// @tparam T2  Type of element in second vector.
/// @tparam N1  Compile-time number of elements in first vector.
/// @tparam N2  Compile-time number of elements in second vector.
/// @tparam V1  Type of storage for first vector.
/// @tparam V2  Type of storage for second vector.
/// @param v1  Reference to first vector.
/// @param v2  Reference to second vector.
/// @return  TBD: GSL's documentation does not specify.
template<
      typename T1,
      typename T2,
      size_t N1,
      size_t N2,
      template<typename, size_t>
      class V1,
      template<typename, size_t>
      class V2>
int swap(v_iface<T1, N1, V1> &v1, v_iface<T2, N2, V2> &v2) {
  return w_swap(v1.v(), v2.v());
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/vec/v-iterator.hpp

Source
/// \file       include/gslcpp/vec/v-iterator.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition for gsl::v_iterator.

#pragma once

#include <iterator> // random_access_iterator_tag

namespace gsl {


/// Iterator for v_iface.  There is no `operator->` because element is always
/// of type double.  Even if vector actually have non-const elements, const
/// vector is treated as having const elements.
/// @tparam V  Either v_iface or v_iface const.
template<typename V> class v_iterator {
public:
  /// Type of difference of two iterators.
  using difference_type= std::ptrdiff_t;

private:
  V &vi_; ///< Reference to instance of container.
  difference_type off_; ///< Current offset pointed to in container.

  // Make each type of iterator be a friend to the other.
  template<typename OV> friend class v_iterator;

  /// Throw exception if each of two iterators point into different vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  template<typename B> void check_same_vector(v_iterator<B> const &b) const {
    if(&vi_ != &b.vi_) {
      throw std::runtime_error("iterators for different vectors");
    }
  }

  /// Generic declaration for struct that gives type of vector's element.  Even
  /// if vector actually have non-const elements, const vector is treated as
  /// having const elements.
  /// @tparam is_const  True for constant-type element.
  template<bool is_const> struct element;

  /// Specialization for constant type of element of vector.  Even if vector
  /// actually have non-const elements, const vector is treated as having const
  /// elements.
  template<> struct element<true> { using type= typename V::E const; };

  /// Specialization for non-constant type of element for vector.  Even if
  /// vector actually have non-const elements, const vector is treated as
  /// having const elements.
  template<> struct element<false> { using type= typename V::E; };

  /// Type of element for vector.  Even if vector actually have non-const
  /// elements, const vector is treated as having const elements.
  using E= typename element<std::is_const_v<V>>::type;

public:
  using pointer= E *; ///< Type of pointer to element in container.
  using value_type= E; ///< Type of element in container.
  using reference= E &; ///< Type of reference to element in container.

  /// Indicate, to standard library, that iterator is random-access.
  using iterator_category= std::random_access_iterator_tag;

  /// Construct instance of iterator.
  /// @param vi  Reference to container of element pointed to.
  /// @param off  Offset of element pointed to in container.
  v_iterator(V &vi, difference_type off): vi_(vi), off_(off) {}

  /// Dereference iterator.
  /// @return  Reference to element pointed to by iterator.
  reference operator*() const { return vi_[off_]; }

  /// Dereference element at offset from element pointed to by iterator.
  /// @param i  Offset from element pointed to by iterator.
  /// @return  Reference to element at offset `i` from current element.
  reference operator[](difference_type i) const { return vi_[off_ + i]; }

  /// Increment offset of element pointed to.
  /// @return  Reference to this instance after increment of offset.
  v_iterator &operator++() {
    ++off_;
    return *this;
  }

  /// Increment offset of element pointed to.
  /// @return  Copy of this instance made before increment of offset.
  v_iterator operator++(int) {
    v_iterator tmp= *this;
    ++(*this); // Call prefix-increment!
    return tmp;
  }

  /// Decrement offset of element pointed to.
  /// @return  Reference to this instance after decrement of offset.
  v_iterator &operator--() {
    --off_;
    return *this;
  }

  /// Decrement offset of element pointed to.
  /// @return  Copy of this instance made before decrement of offset.
  v_iterator operator--(int) {
    v_iterator tmp= *this;
    --(*this); // Call prefix-decrement!
    return tmp;
  }

  /// For positive `n`, increase, by `n`, offset of element pointed to.  This
  /// is like fast forward in place for an iterator.  Do nothing when `n == 0`.
  /// Actually decrease offset when `n < 0`.
  /// @param n  Number by which to increase offset.
  /// @return  Reference to this instance after increase of offset.
  v_iterator &operator+=(difference_type n) {
    off_+= n;
    return *this;
  }

  /// For positive `n`, decrease, by `n`, offset of element pointed to.  This
  /// is like fast reverse in place for an iterator.  Do nothing when `n == 0`.
  /// Actually increase offset when `n < 0`.
  /// @param n  Number by which to decrease offset.
  /// @return  Reference to this instance after decrease of offset.
  v_iterator &operator-=(difference_type n) {
    off_-= n;
    return *this;
  }

  /// Produce new iterator at offset greater than that of existing iterator.
  /// This is like fast forward for an iterator.
  /// @param i  Iterator.
  /// @param n  Offset.
  /// @return  Iterator whose internal offset is `n` more than that of `i`.
  friend v_iterator operator+(v_iterator i, difference_type n) {
    i+= n;
    return i;
  }

  /// Produce new iterator at offset greater than that of existing iterator.
  /// This is like fast forward for an iterator.
  /// @param n  Offset.
  /// @param i  Iterator.
  /// @return  Iterator whose internal offset is `n` more than that of `i`.
  friend v_iterator operator+(difference_type n, v_iterator i) {
    return i + n;
  }

  /// Produce new iterator at offset less than that of existing iterator.  This
  /// is like fast reverse for an iterator.
  /// @param i  Iterator.
  /// @param n  Offset.
  /// @return  Iterator whose internal offset is `n` less than that of `i`.
  friend v_iterator operator-(v_iterator i, difference_type n) {
    i-= n;
    return i;
  }

  /// Difference in offset between two iterators.  Throw runtime_error if
  /// iterators do not point into same vector.
  /// @tparam I  Type of vector for iterator with offset to subtract.
  /// @param i  Iterator with offset to subtract.
  /// @return  Difference between offset of this iterator and offset of `i`.
  template<typename I>
  difference_type operator-(v_iterator<I> const &i) const {
    check_same_vector(i);
    return off_ - i.off_;
  }

  /// Compare two iterators for equality.  Throw runtime_error if iterators do
  /// not point into same vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  /// @return  True only if this and second iterator point to same element.
  template<typename B> bool operator==(v_iterator<B> const &b) const {
    check_same_vector(b);
    return off_ == b.off_;
  }

  /// Compare two iterators for inequality.  Throw runtime_error if iterators
  /// do not point into same vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  /// @return  True only if this and second do not point to same element.
  template<typename B> bool operator!=(v_iterator<B> const &b) const {
    check_same_vector(b);
    return off_ != b.off_;
  }

  /// Compare two iterators for ordering.  Throw runtime_error if iterators do
  /// not point into same vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  /// @return  True only if this iterator point to element earlier in vector
  ///          than element pointed to by second iterator.
  template<typename B> bool operator<(v_iterator<B> const &b) const {
    check_same_vector(b);
    return off_ < b.off_;
  }

  /// Compare two iterators for ordering.  Throw runtime_error if iterators do
  /// not point into same vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  /// @return  True only if this iterator point to element later in vector
  ///          than element pointed to by second iterator.
  template<typename B> bool operator>(v_iterator<B> const &b) const {
    check_same_vector(b);
    return off_ > b.off_;
  }

  /// Compare two iterators for ordering.  Throw runtime_error if iterators do
  /// not point into same vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  /// @return  True only if this iterator point to element either same as or
  ///          earlier in vector than element pointed to by second iterator.
  template<typename B> bool operator<=(v_iterator<B> const &b) const {
    check_same_vector(b);
    return off_ <= b.off_;
  }

  /// Compare two iterators for ordering.  Throw runtime_error if iterators do
  /// not point into same vector.
  /// @tparam B  Type of vector for second iterator.
  /// @param b  Second iterator.
  /// @return  True only if this iterator point to element either same as or
  ///          later in vector than element pointed to by second iterator.
  template<typename B> bool operator>=(v_iterator<B> const &b) const {
    check_same_vector(b);
    return off_ >= b.off_;
  }
};


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/vec/v-stor.hpp

Source
/// \file       include/gslcpp/vec/v-stor.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition for gsl::v_stor.

#pragma once
#include "../wrap/free.hpp" // w_free
#include "../wrap/vector-alloc.hpp" // w_vector_alloc
#include "../wrap/vector-calloc.hpp" // w_vector_calloc
#include "../wrap/vector-view-array.hpp" // vector_view_array

namespace gsl {


/// Generic %v_stor is interface to storage with two key properties:
/// (1) that size of storage is known statically, at compile-time, and
/// (2) that it is owned by instance of %v_stor.
///
/// Specialization gsl::v_stor<T,0> is for storage-size determined at run-time.
///
/// @tparam T  Type of each element in vector.
/// @tparam S  Compile-time size of vector (0 for size specified at run-time).
template<typename T, size_t S= 0> class v_stor {
  static_assert(S > 0);

  T d_[S]; ///< Storage for data.
  w_vector_view<T> cview_; ///< GSL's view of data.

  v_stor(v_stor const &)= delete; ///< Disable copy-construction.
  v_stor &operator=(v_stor const &)= delete; ///< Disable copy-assignment.

public:
  /// Initialize GSL's view of static storage, but do not initialize elements.
  /// If number `n` of elements intended for vector be not `S`, then throw.
  /// \param n  Number of elements intended for vector.
  v_stor(size_t n= S): cview_(w_vector_view_array(d_, 1, S)) {
    if(n != S) throw "mismatch in size";
  }

  /// Pointer to GSL's interface to vector.
  /// @return  Pointer to GSL's interface to vector.
  auto *v() { return &cview_.vector; }

  /// Pointer to GSL's interface to vector.
  /// @return  Pointer to GSL's interface to immutable vector.
  auto const *v() const { return &cview_.vector; }
};


/// Identifier for each of two possible allocation-methods.
enum alloc_type {
  ALLOC, ///< Just allocate without initialization.
  CALLOC ///< Initialize each element to zero after allocation.
};


/// Specialization, which is interface to storage with two key properties:
/// (1) that size of storage is determined dynamically, at run-time, and
/// (2) that it is owned by instance of interface.
///
/// Generic gsl::v_stor<T,S> is for storage-size `S` determined at
/// compile-time.
///
/// Move-construction is provided, but move-assignment is not.  Once memory is
/// allocated for a vector, that memory and only that memory belongs to the
/// vector until it is destroyed.
///
/// @tparam T  Type of each element in vector.
template<typename T> class v_stor<T> {
  v_stor(v_stor const &)= delete; ///< Disable copy-construction.
  v_stor &operator=(v_stor const &)= delete; ///< Disable copy-assignment.

protected:
  /// Pointer to allocated descriptor for vector.
  w_vector<T> *v_= nullptr;

  /// Deallocate vector and its descriptor.
  void free() {
    if(v_) w_free(v_);
    v_= nullptr;
  }

  /// Allocate vector and its descriptor.
  /// \param n  Number of elements in vector.
  /// \param a  Type of allocation (simple or initialized to zero).
  /// \return  Pointer to vector's descriptor.
  w_vector<T> *allocate(size_t n, alloc_type a) {
    free();
    if(a == ALLOC) return w_vector_alloc<T>(n);
    return w_vector_calloc<T>(n);
  }

public:
  /// Allocate vector and its descriptor.
  /// @param n  Number of elements in vector.
  /// @param a  Method to use for allocation.
  v_stor(size_t n, alloc_type a= ALLOC) { v_= allocate(n, a); }

  /// True if object's data have been validly allocated.
  /// \return  True if object's data have been validly allocated.
  bool valid() const { return v_!= nullptr; }

  /// Reference to GSL's interface to vector.
  /// @return  Reference to GSL's interface to vector.
  auto *v() { return v_; }

  /// Reference to GSL's interface to vector.
  /// @return  Reference to GSL's interface to immutable vector.
  auto const *v() const { return v_; }

  /// Move on construction.
  /// Constructor is not template because moving works only from other %v_stor.
  /// \param src  Vector to move.
  v_stor(v_stor &&src): v_(src.v_) { src.v_= nullptr; }

  /// Deallocate vector and its descriptor.
  virtual ~v_stor() { free(); }
};


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/vec/v-view.hpp

Source
/// \file       include/gslcpp/vec/v-view.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition for gsl::view.

#pragma once
#include "../wrap/container.hpp" // w_vector_view

namespace gsl {


/// Interface to vector-storage not owned by interface.
///
/// %v_view can serve as template-type parameter for (and thus base of)
/// vec::iface.
///
/// @tparam T  Type of each element in vector.
template<typename T, size_t N= 0> class v_view {
  w_vector_view<T> cview_; ///< GSL's view of data outside instance.

public:
  /// Reference to GSL's interface to vector.
  /// @return  Reference to GSL's interface to vector.
  auto *v() { return &cview_.vector; }

  /// Reference to GSL's interface to vector.
  /// @return  Reference to GSL's interface to immutable vector.
  auto const *v() const { return &cview_.vector; }

  /// Constructor called by TBS.
  /// @param v  View to copy.
  v_view(w_vector_view<T> const &v): cview_(v) {}

  /// GSL's native, C-language interface to vector-view.
  /// @return  GSL's native, C-language interface to vector-view.
  auto &cview() const { return cview_; }
};


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/vector-view.hpp

Source
/// \file       include/gslcpp/vector-view.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition for gsl::vector_view.

#pragma once
#include "vec/v-iface.hpp" // v_iface
#include "wrap/vector-view-array.hpp" // w_vector_view_array

/// Namespace for C++-interface to GSL.
namespace gsl {


/// Constructor-type for vector-by-reference whose storage is *not* owned by
/// instance of view.
///
/// Despite its name, %vector_view allows both viewing and modifying data that
/// it refers to.  These data are presented as if they were in a virtual vector
/// represented by the intance.
///
/// %vector_view has its interface to storage given by gsl::v_view, and most of
/// the ordinary vector-interface is given by gsl::v_iface.
///
/// %vector_view inherits these and provides template-constructors for an
/// instance of type gsl::v_iface<T, S, v_view>.
///
///   - One constructor is from a normal, decayed pointer and a length (and
///     optionally a stride).
///
///   - The other is from a non-decayed C-style array (which still retains
///     information about its length).
///
/// Template-value-parameter `S` indicates the number of elements in the vector
/// at compile-time.  If `S` be zero, then the number of elements in the vector
/// is determined at run-time.
///
/// When using %vector_view, one typically does not need to specify
/// template-parameters:
///
/// ~~~{.cpp}
/// #include <gslcpp/vector-view.hpp>
///
/// int main() {
///   double g[]= {1, 2, 3, 4, 5, 6};
///
///   // Deduce vector_view<double, 6> with stride=1:
///   gsl::vector_view v1= g;
///
///   // Deduce vector_view<double, 0> with three elements and stride=2:
///   gsl::vector_view v2(g, 3, 2);
///
///   v2[1]= 10; // Now g[2] is no longer 3 but 10.
///
///   // Deduce vector_view<double const, 0> with three elements and stride=2:
///   double const *h= g;
///   gsl::vector_view v3(h, 3, 2); // Only fetching allowed, not setting.
///
///   return 0;
/// }
/// ~~~
///
/// @tparam T  Type of each element in vector.
/// @tparam S  Compile-time number of elements (0 for number set at run-time).
template<typename T, size_t S= 0>
struct vector_view: public v_iface<T, S, v_view> {
  using P= v_iface<T, S, v_view>; ///< Type of ancestor.
  using P::P;

  /// Initialize view of standard (decayed) C-array.
  ///
  /// Arguments are ordered differently from those given to
  /// gsl_vector_viewiew_array_with_stride().  Putting stride at *end* allows
  /// it to have default value of 1.
  ///
  /// \param b  Pointer to first element of array and of view.
  /// \param n  Number of elements in view.
  /// \param s  Stride of elements relative to array.
  vector_view(T *b, size_t n, size_t s= 1): P(w_vector_view_array(b, s, n)) {}

  /// Initialize view of non-decayed C-array.
  /// \param b  Reference to non-decayed C-array.
  vector_view(T (&b)[S]): P(w_vector_view_array(b, 1, S)) {}
};


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/vector.hpp

Source
/// \dir        include/gslcpp
/// \brief      Top-level directory for gslcpp's header-only library.

/// \file       include/gslcpp/vector.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition for gsl::vector.

#pragma once

#include "vec/v-iface.hpp" // v_iface
#include "vec/v-stor.hpp" // v_stor

namespace gsl {


using std::enable_if_t;
using std::is_const_v;


/// Constructor-type for vector whose storage is owned by instance of vector.
///
/// %vector has its interface to storage given by gsl::v_stor, and most of the
/// ordinary vector-interface is given by gsl::v_iface.
///
/// %vector inherits these and provides template-constructors for an instance
/// of type gsl::v_iface<T, S, v_stor>.
///
/// Each constructor copies data from the source or (in the case of the
/// move-constructor, when both the source is an r-value with `S = 0`, and the
/// destination has `S = 0`) *moves* the data into the instance.
///
/// Template-value-parameter `S` indicates the number of elements in the vector
/// at compile-time.  If `S` be zero, then the number of elements in the vector
/// is determined at run-time.
///
/// Although move-construction is provided, move-assignment is *not* provided.
/// Once a chunk of memory is allocated to a vector, that same chunk, and only
/// ever that chunk, is associated with the vector until it is destroyed.
///
/// When using %vector, one typically does not need to specify
/// template-parameters:
///
/// ~~~{.cpp}
/// #include <gslcpp/vector.hpp>
///
/// int main() {
///   double g[]= {1, 2, 3, 4, 5, 6};
///
///   // Deduce vector<double, 6> with stride=1, and copy the data:
///   gsl::vector v1= g;
///
///   // Deduce vector<double, 0> with three elements and stride=2, and copy
///   // the data:
///   gsl::vector v2(g, 3, 2);
///
///   // Deduce vector<double const, 0> with three elements and stride=2, and
///   // copy the data:
///   double const *h= g;
///   gsl::vector v3(h, 3, 2);
///
///   return 0;
/// }
/// ~~~
///
/// \tparam T  Type of each element in vector.
/// \tparam S  Compile-time number of elements (0 for number set at run-time).
template<typename T, size_t S= 0> struct vector: public v_iface<T, S, v_stor> {
  using P= v_iface<T, S, v_stor>; ///< Type of ancestor.
  using P::P;

  /// Copy data from other vector of same type.
  /// \param src  Reference to other vector.
  vector(vector const &src): P(src.v()->size) { memcpy(*this, src); }

  /// Enable move-constructor in gsl::v_stor to work.
  vector(vector &&)= default;

  /// Enable explicitly defined copy-constructor in gsl::v_iface.
  /// \return  Reference to this instance after assignment.
  vector &operator=(vector const &)= default;

  /// Struct defining whether size of other vector allow copying its data.
  /// \tparam N  Number of elements in other vector.
  template<size_t N> struct sz_ok {
    enum { V= (N == S || N == 0 || S == 0) /**< True if N be OK. */ };
  };

  /// Copy data from vector of different type (different element-constness,
  /// different compile-time number of elements, or different
  /// storage-interface).
  /// \tparam N  Number of elements in other vector.
  /// \tparam V  Type of other vector's interface to storage.
  /// \param src  Reference to other vector.
  template<
        size_t N,
        template<typename, size_t>
        class V,
        typename= enable_if_t<sz_ok<N>::V && !is_const_v<T>>>
  vector(v_iface<T const, N, V> const &src): P(src.v()->size) {
    memcpy(*this, src);
  }

  /// Copy data from vector of different type (different compile-time number of
  /// elements or different storage-interface).
  /// \tparam N  Number of elements in other vector.
  /// \tparam V  Type of other vector's interface to storage.
  /// \param src  Reference to other vector.
  template<
        size_t N,
        template<typename, size_t>
        class V,
        typename= enable_if_t<sz_ok<N>::V>>
  vector(v_iface<T, N, V> const &src): P(src.v()->size) {
    memcpy(*this, src);
  }

  /// Copy from standard (decayed) C-array.
  ///
  /// Arguments are ordered differently from those given to
  /// gsl_vector_viewiew_array_with_stride().  Putting stride at *end* allows
  /// it to have default value of 1.
  ///
  /// \param d  Pointer to first element of array and of vector.
  /// \param n  Number of elements in vector.
  /// \param s  Stride of elements relative to array.
  vector(T const *d, size_t n, size_t s= 1): P(n) {
    auto const cview= w_vector_view_array(d, s, n);
    memcpy(*this, v_iface<T const, 0, v_view>(cview));
  }

  /// Copy from non-decayed C-array.
  /// \param d  Reference to non-decayed C-array.
  vector(T const (&d)[S]): P(S) {
    auto const cview= w_vector_view_array(d, 1, S);
    memcpy(*this, v_iface<T const, S, v_view>(cview));
  }

  /// Copy from initializer-list.
  /// \param i  List of initializers.
  vector(std::initializer_list<T> i): P(i.size()) {
    auto const cview= w_vector_view_array(i.begin(), 1, i.size());
    memcpy(*this, v_iface<T const, 0, v_view>(cview));
  }
};


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/add-constant.hpp

Source
/// @file       include/gslcpp/wrap/add-constant.hpp
/// @copyright  2022 Thomas E. Vaughan, all rights reserved.
/// @brief      Definition of gsl::add_constant().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<double> *u, double const &v) {
  return gsl_vector_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<float> *u, float const &v) {
  return gsl_vector_float_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<long double> *u, long double const &v) {
  return gsl_vector_long_double_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<int> *u, int const &v) {
  return gsl_vector_int_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<unsigned> *u, unsigned const &v) {
  return gsl_vector_uint_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<long> *u, long const &v) {
  return gsl_vector_long_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<unsigned long> *u, unsigned long const &v) {
  return gsl_vector_ulong_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<short> *u, short const &v) {
  return gsl_vector_short_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int
w_add_constant(w_vector<unsigned short> *u, unsigned short const &v) {
  return gsl_vector_ushort_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<char> *u, char const &v) {
  return gsl_vector_char_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(w_vector<unsigned char> *u, unsigned char const &v) {
  return gsl_vector_uchar_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int
w_add_constant(w_vector<complex<double>> *u, complex<double> const &v) {
  return gsl_vector_complex_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int
w_add_constant(w_vector<complex<float>> *u, complex<float> const &v) {
  return gsl_vector_complex_float_add_constant(u, v);
}


/// Add same constant to every element in place.  `add_constant` is overloaded
/// to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
/// @param u  Pointer to vector whose elements are to be modified.
/// @param v  Constant to add into each element.
/// @return  TBD: Not specified in GSL's documentation.
inline int w_add_constant(
      w_vector<complex<long double>> *u, complex<long double> const &v) {
  return gsl_vector_complex_long_double_add_constant(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/add.hpp

Source
/// @file       include/gslcpp/wrap/add.hpp
/// @copyright  2022 Thomas E. Vaughan, all rights reserved.
/// @brief      Definition of gsl::w_add().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<double> *u, w_vector<double const> *v) {
  return gsl_vector_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<float> *u, w_vector<float const> *v) {
  return gsl_vector_float_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<long double> *u, w_vector<long double const> *v) {
  return gsl_vector_long_double_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<int> *u, w_vector<int const> *v) {
  return gsl_vector_int_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<unsigned> *u, w_vector<unsigned const> *v) {
  return gsl_vector_uint_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<long> *u, w_vector<long const> *v) {
  return gsl_vector_long_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_add(w_vector<unsigned long> *u, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<short> *u, w_vector<short const> *v) {
  return gsl_vector_short_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_add(w_vector<unsigned short> *u, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_add(w_vector<char> *u, w_vector<char const> *v) {
  return gsl_vector_char_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_add(w_vector<unsigned char> *u, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_add(w_vector<complex<double>> *u, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_add(w_vector<complex<float>> *u, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_add(u, v);
}


/// Element by element, accumulate `v` into `u`.
/// `add` is overloaded to provide the same name for every type of vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
/// @param u  Pointer to vector to be modified.
/// @param v  Pointer to vector to be added in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_add(w_vector<complex<long double>> *u,
      w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_add(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/axpby.hpp

Source
/// @file       include/gslcpp/wrap/axpby.hpp
/// @copyright  2022 Thomas E. Vaughan, all rights reserved.
/// @brief      Definition of gsl::w_axpby().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      double const &a,
      w_vector<double const> *x,
      double const &b,
      w_vector<double> *y) {
  return gsl_vector_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      float const &a,
      w_vector<float const> *x,
      float const &b,
      w_vector<float> *y) {
  return gsl_vector_float_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      long double const &a,
      w_vector<long double const> *x,
      long double const &b,
      w_vector<long double> *y) {
  return gsl_vector_long_double_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_axpby(int const &a, w_vector<int const> *x, int const &b, w_vector<int> *y) {
  return gsl_vector_int_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      unsigned const &a,
      w_vector<unsigned const> *x,
      unsigned const &b,
      w_vector<unsigned> *y) {
  return gsl_vector_uint_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      long const &a,
      w_vector<long const> *x,
      long const &b,
      w_vector<long> *y) {
  return gsl_vector_long_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      unsigned long const &a,
      w_vector<unsigned long const> *x,
      unsigned long const &b,
      w_vector<unsigned long> *y) {
  return gsl_vector_ulong_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      short const &a,
      w_vector<short const> *x,
      short const &b,
      w_vector<short> *y) {
  return gsl_vector_short_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      unsigned short const &a,
      w_vector<unsigned short const> *x,
      unsigned short const &b,
      w_vector<unsigned short> *y) {
  return gsl_vector_ushort_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      char const &a,
      w_vector<char const> *x,
      char const &b,
      w_vector<char> *y) {
  return gsl_vector_char_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      unsigned char const &a,
      w_vector<unsigned char const> *x,
      unsigned char const &b,
      w_vector<unsigned char> *y) {
  return gsl_vector_uchar_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      complex<double> const &a,
      w_vector<complex<double> const> *x,
      complex<double> const &b,
      w_vector<complex<double>> *y) {
  return gsl_vector_complex_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      complex<float> const &a,
      w_vector<complex<float> const> *x,
      complex<float> const &b,
      w_vector<complex<float>> *y) {
  return gsl_vector_complex_float_axpby(a, x, b, y);
}


/// Perform the logical equivalent of `y = a*x + b*y`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_axpby
///
/// @param a  Coefficient of vector `x`.
/// @param x  Pointer to vector that is multiplied by `a`.
/// @param b  Coefficient of vector `y`.
/// @param y  Pointer to vector that is multiplied by `b` and then updated as
///           `a*x + b*y`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_axpby(
      complex<long double> const &a,
      w_vector<complex<long double> const> *x,
      complex<long double> const &b,
      w_vector<complex<long double>> *y) {
  return gsl_vector_complex_long_double_axpby(a, x, b, y);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/complex.hpp

Source (jump to first uncovered line)
/// \file       include/gslcpp/wrap/complex.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::complex.

#pragma once
#include <complex> // std::complex
#include <gsl/gsl_complex.h> // gsl_complex, etc.

namespace gsl {


/// Complex-number, each of whose components has type A.
/// This is the generic declaration; see each specialization for details.
/// \sa gsl::complex<double>
/// \sa gsl::complex<float>
/// \sa gsl::complex<long double>
/// \tparam A  Type of each component.
template<typename A> struct complex;


/// Specialization of \ref gsl::complex for double.
template<> struct complex<double>: public std::complex<double> {
  using P= std::complex<double>; ///< Type of parent.
  using P::P; // Inherit constructors.

  /// Construct from gsl_complex.
  /// \param z  Reference to instance of gsl_complex.
  complex(gsl_complex const &z): P(GSL_REAL(z), GSL_IMAG(z)) {}

  /// Construct from instance of parent's type.
  /// \param z  Reference to instance of parent's type.
  complex(P const &z): P(z) {}

  /// Convert to gsl_complex.
  /// \return  Reference to this as gsl_complex.
  operator gsl_complex &() { return *(gsl_complex *)this; }

  /// Convert to gsl_complex.
  /// \return  Reference to this as gsl_complex.
  operator gsl_complex const &() const { return *(gsl_complex const *)this; }
};


/// Specialization of \ref gsl::complex for float.
template<> struct complex<float>: public std::complex<float> {
  using P= std::complex<float>; ///< Type of parent.
  using P::P; // Inherit constructors.

  /// Construct from gsl_complex.
  /// \param z  Reference to instance of gsl_complex.
  complex(gsl_complex_float const &z): P(GSL_REAL(z), GSL_IMAG(z)) {}

  /// Construct from instance of parent's type.
  /// \param z  Reference to instance of parent's type.
  complex(P const &z): P(z) {}

  /// Convert to gsl_complex.
  /// \return  Reference to this as gsl_complex.
  operator gsl_complex_float &() { return *(gsl_complex_float *)this; }

  /// Convert to gsl_complex.
  /// \return  Reference to this as gsl_complex.
  operator gsl_complex_float const &() const {
    return *(gsl_complex_float const *)this;
  }
};


/// Specialization of \ref gsl::complex for long double.
template<> struct complex<long double>: public std::complex<long double> {
  using P= std::complex<long double>; ///< Type of parent.
  using P::P; // Inherit constructors.

  /// Construct from gsl_complex.
  /// \param z  Reference to instance of gsl_complex.
  complex(gsl_complex_long_double const &z): P(GSL_REAL(z), GSL_IMAG(z)) {}

  /// Construct from instance of parent's type.
  /// \param z  Reference to instance of parent's type.
  complex(P const &z): P(z) {}

  /// Convert to gsl_complex.
  /// \return  Reference to this as gsl_complex.
  operator gsl_complex_long_double &() {
    return *(gsl_complex_long_double *)this;
  }

  /// Convert to gsl_complex.
  /// \return  Reference to this as gsl_complex.
  operator gsl_complex_long_double const &() const {
    return *(gsl_complex_long_double const *)this;
  }
};


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/div.hpp

Source
/// \file       include/gslcpp/wrap/div.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_div().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<double> *u, w_vector<double const> *v) {
  return gsl_vector_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<float> *u, w_vector<float const> *v) {
  return gsl_vector_float_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<long double> *u, w_vector<long double const> *v) {
  return gsl_vector_long_double_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<int> *u, w_vector<int const> *v) {
  return gsl_vector_int_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<unsigned> *u, w_vector<unsigned const> *v) {
  return gsl_vector_uint_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<long> *u, w_vector<long const> *v) {
  return gsl_vector_long_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_div(w_vector<unsigned long> *u, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<short> *u, w_vector<short const> *v) {
  return gsl_vector_short_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_div(w_vector<unsigned short> *u, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int w_div(w_vector<char> *u, w_vector<char const> *v) {
  return gsl_vector_char_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_div(w_vector<unsigned char> *u, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_div(w_vector<complex<double>> *u, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_div(w_vector<complex<float>> *u, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_div(u, v);
}


/// Perform the logical operation `u = u/v` element by element.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
/// @param u  Pointer to matrix whose elements should be divided into.
/// @param v  Pointer to matrix whose elements divide into.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_div(w_vector<complex<long double>> *u,
      w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_div(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/equal.hpp

Source
/// \file       include/gslcpp/wrap/equal.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_equal().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<double const> *u, w_vector<double const> *v) {
  return gsl_vector_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<float const> *u, w_vector<float const> *v) {
  return gsl_vector_float_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool
w_equal(w_vector<long double const> *u, w_vector<long double const> *v) {
  return gsl_vector_long_double_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<int const> *u, w_vector<int const> *v) {
  return gsl_vector_int_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<unsigned const> *u, w_vector<unsigned const> *v) {
  return gsl_vector_uint_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<long const> *u, w_vector<long const> *v) {
  return gsl_vector_long_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool
w_equal(w_vector<unsigned long const> *u, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<short const> *u, w_vector<short const> *v) {
  return gsl_vector_short_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool
w_equal(w_vector<unsigned short const> *u, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(w_vector<char const> *u, w_vector<char const> *v) {
  return gsl_vector_char_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool
w_equal(w_vector<unsigned char const> *u, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(
      w_vector<complex<double> const> *u, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool
w_equal(w_vector<complex<float> const> *u, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_equal(u, v);
}


/// True if every element in `u` be equal to corrending element in `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  True if vectors be equal.
inline bool w_equal(
      w_vector<complex<long double> const> *u,
      w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_equal(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/fprintf.hpp

Source
/// \file       include/gslcpp/wrap/fprintf.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_fprintf().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<double const> *v, char const *fmt) {
  return gsl_vector_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<float const> *v, char const *fmt) {
  return gsl_vector_float_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<long double const> *v, char const *fmt) {
  return gsl_vector_long_double_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<int const> *v, char const *fmt) {
  return gsl_vector_int_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<unsigned const> *v, char const *fmt) {
  return gsl_vector_uint_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<long const> *v, char const *fmt) {
  return gsl_vector_long_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<unsigned long const> *v, char const *fmt) {
  return gsl_vector_ulong_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<short const> *v, char const *fmt) {
  return gsl_vector_short_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<unsigned short const> *v, char const *fmt) {
  return gsl_vector_ushort_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int w_fprintf(FILE *f, w_vector<char const> *v, char const *fmt) {
  return gsl_vector_char_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<unsigned char const> *v, char const *fmt) {
  return gsl_vector_uchar_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<complex<double> const> *v, char const *fmt) {
  return gsl_vector_complex_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<complex<float> const> *v, char const *fmt) {
  return gsl_vector_complex_float_fprintf(f, v, fmt);
}


/// Write elements of `v` line by line to stream `f` via specifier `fmt`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fprintf
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @param fmt  Pointer to printf-style specifier of format.
/// @return  0 on success or GSL_EFAILED on problem writing to file.
inline int
w_fprintf(FILE *f, w_vector<complex<long double> const> *v, char const *fmt) {
  return gsl_vector_complex_long_double_fprintf(f, v, fmt);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/fread.hpp

Source
/// \file       include/gslcpp/wrap/fread.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_fread().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<double> *v) {
  return gsl_vector_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<float> *v) {
  return gsl_vector_float_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<long double> *v) {
  return gsl_vector_long_double_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<int> *v) {
  return gsl_vector_int_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<unsigned> *v) {
  return gsl_vector_uint_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<long> *v) {
  return gsl_vector_long_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<unsigned long> *v) {
  return gsl_vector_ulong_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<short> *v) {
  return gsl_vector_short_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<unsigned short> *v) {
  return gsl_vector_ushort_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<char> *v) {
  return gsl_vector_char_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<unsigned char> *v) {
  return gsl_vector_uchar_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<complex<double>> *v) {
  return gsl_vector_complex_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<complex<float>> *v) {
  return gsl_vector_complex_float_fread(f, v);
}


/// Read into `v` from stream `f` in binary format.
///
/// Before call to `%w_fread()`, `v` must already have right size because
/// `%w_fread()` uses size of `v` to determine number bytes to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fread
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that should be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fread(FILE *f, w_vector<complex<long double>> *v) {
  return gsl_vector_complex_long_double_fread(f, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/free.hpp

Source
/// \file       include/gslcpp/wrap/free.hpp
/// \copyright  2022 Thomas E. Vaughan
/// \brief      Definition of gsl::w_free().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<double> *v) { gsl_vector_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<float> *v) { gsl_vector_float_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<long double> *v) {
  gsl_vector_long_double_free(v);
}


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<int> *v) { gsl_vector_int_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<unsigned> *v) { gsl_vector_uint_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<long> *v) { gsl_vector_long_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<unsigned long> *v) { gsl_vector_ulong_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<short> *v) { gsl_vector_short_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<unsigned short> *v) { gsl_vector_ushort_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<char> *v) { gsl_vector_char_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<unsigned char> *v) { gsl_vector_uchar_free(v); }


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<complex<double>> *v) {
  gsl_vector_complex_free(v);
}


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<complex<float>> *v) {
  gsl_vector_complex_float_free(v);
}


/// Deallocate memory for GSL's native vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_free
/// @param v  Pointer to vector.
inline void w_free(w_vector<complex<long double>> *v) {
  gsl_vector_complex_long_double_free(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/fscanf.hpp

Source
/// \file       include/gslcpp/wrap/fscanf.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_fscanf().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<double> *v) {
  return gsl_vector_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<float> *v) {
  return gsl_vector_float_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<long double> *v) {
  return gsl_vector_long_double_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<int> *v) {
  return gsl_vector_int_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<unsigned> *v) {
  return gsl_vector_uint_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<long> *v) {
  return gsl_vector_long_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<unsigned long> *v) {
  return gsl_vector_ulong_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<short> *v) {
  return gsl_vector_short_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<unsigned short> *v) {
  return gsl_vector_ushort_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<char> *v) {
  return gsl_vector_char_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<unsigned char> *v) {
  return gsl_vector_uchar_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<complex<double>> *v) {
  return gsl_vector_complex_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<complex<float>> *v) {
  return gsl_vector_complex_float_fscanf(f, v);
}


/// Read formatted data from stream `f` into vector `v`.
///
/// Vector `v` must have correct size before call to `%w_fscanf()` because
/// `%w_fscanf()` uses size of `v` to determine how many numbers to read.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fscanf
///
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector that will be initialized from stream.
/// @return  0 on success or GSL_EFAILED on problem reading from stream.
inline int w_fscanf(FILE *f, w_vector<complex<long double>> *v) {
  return gsl_vector_complex_long_double_fscanf(f, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/fwrite.hpp

Source
/// \file       include/gslcpp/wrap/fwrite.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_fwrite().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<double const> *v) {
  return gsl_vector_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<float const> *v) {
  return gsl_vector_float_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<long double const> *v) {
  return gsl_vector_long_double_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<int const> *v) {
  return gsl_vector_int_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<unsigned const> *v) {
  return gsl_vector_uint_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<long const> *v) {
  return gsl_vector_long_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<short const> *v) {
  return gsl_vector_short_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<char const> *v) {
  return gsl_vector_char_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_fwrite(f, v);
}


/// Write elements of vector `v` to stream `f` in binary format.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_fwrite
/// @param f  Pointer to file-stream.
/// @param v  Pointer to vector.
/// @return  0 on success and `GSL_EFAILED` on problem writing to stream.
inline int w_fwrite(FILE *f, w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_fwrite(f, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/get.hpp

Source
/// \file       include/gslcpp/wrap/get.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_get().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<double const> *v, size_t i) {
  return gsl_vector_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<float const> *v, size_t i) {
  return gsl_vector_float_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<long double const> *v, size_t i) {
  return gsl_vector_long_double_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<int const> *v, size_t i) {
  return gsl_vector_int_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<unsigned const> *v, size_t i) {
  return gsl_vector_uint_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<long const> *v, size_t i) {
  return gsl_vector_long_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<unsigned long const> *v, size_t i) {
  return gsl_vector_ulong_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<short const> *v, size_t i) {
  return gsl_vector_short_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<unsigned short const> *v, size_t i) {
  return gsl_vector_ushort_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<char const> *v, size_t i) {
  return gsl_vector_char_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<unsigned char const> *v, size_t i) {
  return gsl_vector_uchar_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<complex<double> const> *v, size_t i) {
  return gsl_vector_complex_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<complex<float> const> *v, size_t i) {
  return gsl_vector_complex_float_get(v, i);
}


/// Return `i`th element of vector `v` with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_get
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Value of element or 0 on bounds-error.
inline auto w_get(w_vector<complex<long double> const> *v, size_t i) {
  return gsl_vector_complex_long_double_get(v, i);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/imag.hpp

Source (jump to first uncovered line)
/// @file       include/gslcpp/wrap/imag.hpp
/// @copyright  2022 Thomas E. Vaughan, all rights reserved.
/// @brief      Definition of gsl::w_imag().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Imaginary-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_imag
/// @param u  Pointer to vector.
/// @return  View of imaginary part of complex vector.
inline auto w_imag(w_vector<complex<double>> *u) {
  return gsl_vector_complex_imag(u);
}


/// Imaginary-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_imag
/// @param u  Pointer to vector.
/// @return  View of imaginary part of complex vector.
inline auto w_imag(w_vector<complex<float>> *u) {
  return gsl_vector_complex_float_imag(u);
}


/// Imaginary-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_imag
/// @param u  Pointer to vector.
/// @return  View of imaginary part of complex vector.
inline auto w_imag(w_vector<complex<long double>> *u) {
  return gsl_vector_complex_long_double_imag(u);
}


/// Imaginary-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_imag
/// @param u  Pointer to vector.
/// @return  View of imaginary part of complex vector.
inline auto w_imag(w_vector<complex<double>> const *u) {
  return gsl_vector_complex_const_imag(u);
}


/// Imaginary-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_imag
/// @param u  Pointer to vector.
/// @return  View of imaginary part of complex vector.
inline auto w_imag(w_vector<complex<float>> const *u) {
  return gsl_vector_complex_float_const_imag(u);
}


/// Imaginary-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_imag
/// @param u  Pointer to vector.
/// @return  View of imaginary part of complex vector.
inline auto w_imag(w_vector<complex<long double>> const *u) {
  return gsl_vector_complex_long_double_const_imag(u);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/isneg.hpp

Source
/// \file       include/gslcpp/wrap/isneg.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_isneg().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<double const> *v) { return gsl_vector_isneg(v); }


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<float const> *v) {
  return gsl_vector_float_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<long double const> *v) {
  return gsl_vector_long_double_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<int const> *v) { return gsl_vector_int_isneg(v); }


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<unsigned const> *v) {
  return gsl_vector_uint_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<long const> *v) {
  return gsl_vector_long_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<short const> *v) {
  return gsl_vector_short_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<char const> *v) {
  return gsl_vector_char_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<complex<double> const> *v) {
  return gsl_vector_complex_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_isneg(v);
}


/// True only if every element of vector `v` be negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be negative.
inline bool w_isneg(w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_isneg(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/isnonneg.hpp

Source
/// \file       include/gslcpp/wrap/isnonneg.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_isnonneg().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<double const> *v) {
  return gsl_vector_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<float const> *v) {
  return gsl_vector_float_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<long double const> *v) {
  return gsl_vector_long_double_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<int const> *v) {
  return gsl_vector_int_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<unsigned const> *v) {
  return gsl_vector_uint_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<long const> *v) {
  return gsl_vector_long_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<short const> *v) {
  return gsl_vector_short_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<char const> *v) {
  return gsl_vector_char_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<complex<double> const> *v) {
  return gsl_vector_complex_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_isnonneg(v);
}


/// True only if every element of vector `v` be non-negative.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnonneg
/// @param v  Pointer to vector.
/// @return  True only if every element of `v` be non-negative.
inline bool w_isnonneg(w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_isnonneg(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/isnull.hpp

Source
/// \file       include/gslcpp/wrap/isnull.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_isnull().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<double const> *v) {
  return gsl_vector_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<float const> *v) {
  return gsl_vector_float_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<long double const> *v) {
  return gsl_vector_long_double_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<int const> *v) {
  return gsl_vector_int_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<unsigned const> *v) {
  return gsl_vector_uint_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<long const> *v) {
  return gsl_vector_long_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<short const> *v) {
  return gsl_vector_short_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<char const> *v) {
  return gsl_vector_char_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<complex<double> const> *v) {
  return gsl_vector_complex_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_isnull(v);
}


/// True only if every element in vector `v` be zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_isnull
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be zero.
inline bool w_isnull(w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_isnull(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/ispos.hpp

Source
/// \file       include/gslcpp/wrap/ispos.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_ispos().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<double const> *v) { return gsl_vector_ispos(v); }


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<float const> *v) {
  return gsl_vector_float_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<long double const> *v) {
  return gsl_vector_long_double_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<int const> *v) { return gsl_vector_int_ispos(v); }


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<unsigned const> *v) {
  return gsl_vector_uint_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<long const> *v) {
  return gsl_vector_long_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<short const> *v) {
  return gsl_vector_short_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<char const> *v) {
  return gsl_vector_char_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<complex<double> const> *v) {
  return gsl_vector_complex_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_ispos(v);
}


/// True only if every element in vector `v` be positive.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ispos
/// @param v  Pointer to vector.
/// @return  True only if every element in `v` be positive.
inline bool w_ispos(w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_ispos(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/max-index.hpp

Source
/// \file       include/gslcpp/wrap/max-index.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_max_index().

#pragma once
#include "container.hpp" // w_vector // vector

namespace gsl {


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<double const> *v) {
  return gsl_vector_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<float const> *v) {
  return gsl_vector_float_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<long double const> *v) {
  return gsl_vector_long_double_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<int const> *v) {
  return gsl_vector_int_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<unsigned const> *v) {
  return gsl_vector_uint_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<long const> *v) {
  return gsl_vector_long_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<short const> *v) {
  return gsl_vector_short_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<char const> *v) {
  return gsl_vector_char_max_index(v);
}


/// Index of maximum value in vector `v`.
/// When there are several equal maximum elements, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max_index
/// @param v  Pointer to vector.
/// @return  Index of maximum value in `v`.
inline auto w_max_index(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_max_index(v);
}

} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/max.hpp

Source
/// \file       include/gslcpp/wrap/max.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_max().

#pragma once
#include "container.hpp" // w_vector // vector

namespace gsl {


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<double const> *v) { return gsl_vector_max(v); }


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<float const> *v) { return gsl_vector_float_max(v); }


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<long double const> *v) {
  return gsl_vector_long_double_max(v);
}


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<int const> *v) { return gsl_vector_int_max(v); }


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<unsigned const> *v) {
  return gsl_vector_uint_max(v);
}


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<long const> *v) { return gsl_vector_long_max(v); }


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_max(v);
}


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<short const> *v) { return gsl_vector_short_max(v); }


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_max(v);
}


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<char const> *v) { return gsl_vector_char_max(v); }


/// Maximum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_max
/// @param v  Pointer to vector.
/// @return  Maximum value in `v`.
inline auto w_max(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_max(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/memcpy.hpp

Source
/// \file       include/gslcpp/wrap/memcpy.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_memcpy().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<double> *u, w_vector<double const> *v) {
  return gsl_vector_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<float> *u, w_vector<float const> *v) {
  return gsl_vector_float_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<long double> *u, w_vector<long double const> *v) {
  return gsl_vector_long_double_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<int> *u, w_vector<int const> *v) {
  return gsl_vector_int_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<unsigned> *u, w_vector<unsigned const> *v) {
  return gsl_vector_uint_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<long> *u, w_vector<long const> *v) {
  return gsl_vector_long_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_memcpy(w_vector<unsigned long> *u, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<short> *u, w_vector<short const> *v) {
  return gsl_vector_short_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_memcpy(w_vector<unsigned short> *u, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(w_vector<char> *u, w_vector<char const> *v) {
  return gsl_vector_char_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_memcpy(w_vector<unsigned char> *u, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_memcpy(w_vector<complex<double>> *u, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_memcpy(w_vector<complex<float>> *u, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_memcpy(u, v);
}


/// Copy elements of vector `v` into vector `u`.
/// Each vector must have same length.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_memcpy
/// @param u  Pointer to vector that is destination of copying.
/// @param v  Pointer to vector that is source of copying.
/// @return  TBD: GSL's documentation does not specify.
inline int w_memcpy(
      w_vector<complex<long double>> *u,
      w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_memcpy(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/min-index.hpp

Source
/// \file       include/gslcpp/wrap/min-index.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_min_index().

#pragma once
#include "container.hpp" // w_vector // vector

namespace gsl {


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<double const> *v) {
  return gsl_vector_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<float const> *v) {
  return gsl_vector_float_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<long double const> *v) {
  return gsl_vector_long_double_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<int const> *v) {
  return gsl_vector_int_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<unsigned const> *v) {
  return gsl_vector_uint_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<long const> *v) {
  return gsl_vector_long_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<short const> *v) {
  return gsl_vector_short_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<char const> *v) {
  return gsl_vector_char_min_index(v);
}


/// Index of minimum value in vector `v`.
/// When several equal minimum elements are found, lowest index is returned.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min_index
/// @param v  Pointer to vector.
/// @return  Index of minimum value in `v`.
inline auto w_min_index(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_min_index(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/min.hpp

Source
/// \file       include/gslcpp/wrap/min.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_min().

#pragma once
#include "container.hpp" // w_vector // vector

namespace gsl {


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<double const> *v) { return gsl_vector_min(v); }


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<float const> *v) { return gsl_vector_float_min(v); }


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<long double const> *v) {
  return gsl_vector_long_double_min(v);
}


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<int const> *v) { return gsl_vector_int_min(v); }


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<unsigned const> *v) {
  return gsl_vector_uint_min(v);
}


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<long const> *v) { return gsl_vector_long_min(v); }


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_min(v);
}


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<short const> *v) { return gsl_vector_short_min(v); }


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_min(v);
}


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<char const> *v) { return gsl_vector_char_min(v); }


/// Minimum value in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_min
/// @param v  Pointer to vector.
/// @return  Minimum value in `v`.
inline auto w_min(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_min(v);
}

} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/minmax-index.hpp

Source
/// \file       include/gslcpp/wrap/minmax-index.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_minmax_index().

#pragma once
#include "container.hpp" // w_vector // vector

namespace gsl {


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<double const> *v, size_t *min, size_t *max) {
  return gsl_vector_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<float const> *v, size_t *min, size_t *max) {
  return gsl_vector_float_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<long double const> *v, size_t *min, size_t *max) {
  return gsl_vector_long_double_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void w_minmax_index(w_vector<int const> *v, size_t *min, size_t *max) {
  return gsl_vector_int_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<unsigned const> *v, size_t *min, size_t *max) {
  return gsl_vector_uint_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void w_minmax_index(w_vector<long const> *v, size_t *min, size_t *max) {
  return gsl_vector_long_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<unsigned long const> *v, size_t *min, size_t *max) {
  return gsl_vector_ulong_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<short const> *v, size_t *min, size_t *max) {
  return gsl_vector_short_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<unsigned short const> *v, size_t *min, size_t *max) {
  return gsl_vector_ushort_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void w_minmax_index(w_vector<char const> *v, size_t *min, size_t *max) {
  return gsl_vector_char_minmax_index(v, min, max);
}


/// Return indices of minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax_index
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for offset of minimum value.
/// @param max  Pointer to storage ofo offset of maximum value.
inline void
w_minmax_index(w_vector<unsigned char const> *v, size_t *min, size_t *max) {
  return gsl_vector_uchar_minmax_index(v, min, max);
}

} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/minmax.hpp

Source
/// \file       include/gslcpp/wrap/minmax.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_minmax().

#pragma once
#include "container.hpp" // w_vector // vector

namespace gsl {


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(w_vector<double const> *v, double *min, double *max) {
  return gsl_vector_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(w_vector<float const> *v, float *min, float *max) {
  return gsl_vector_float_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void
w_minmax(w_vector<long double const> *v, long double *min, long double *max) {
  return gsl_vector_long_double_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(w_vector<int const> *v, int *min, int *max) {
  return gsl_vector_int_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void
w_minmax(w_vector<unsigned const> *v, unsigned *min, unsigned *max) {
  return gsl_vector_uint_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(w_vector<long const> *v, long *min, long *max) {
  return gsl_vector_long_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(
      w_vector<unsigned long const> *v,
      unsigned long *min,
      unsigned long *max) {
  return gsl_vector_ulong_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(w_vector<short const> *v, short *min, short *max) {
  return gsl_vector_short_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(
      w_vector<unsigned short const> *v,
      unsigned short *min,
      unsigned short *max) {
  return gsl_vector_ushort_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(w_vector<char const> *v, char *min, char *max) {
  return gsl_vector_char_minmax(v, min, max);
}


/// Return minimum and maximum values in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_minmax
/// @param v  Pointer to vector.
/// @param min  Pointer to storage for minimum value.
/// @param max  Pointer to storage for maximum value.
inline void w_minmax(
      w_vector<unsigned char const> *v,
      unsigned char *min,
      unsigned char *max) {
  return gsl_vector_uchar_minmax(v, min, max);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/mul.hpp

Source
/// \file       include/gslcpp/wrap/mul.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_mul().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<double> *u, w_vector<double const> *v) {
  return gsl_vector_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<float> *u, w_vector<float const> *v) {
  return gsl_vector_float_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<long double> *u, w_vector<long double const> *v) {
  return gsl_vector_long_double_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<int> *u, w_vector<int const> *v) {
  return gsl_vector_int_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<unsigned> *u, w_vector<unsigned const> *v) {
  return gsl_vector_uint_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<long> *u, w_vector<long const> *v) {
  return gsl_vector_long_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_mul(w_vector<unsigned long> *u, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<short> *u, w_vector<short const> *v) {
  return gsl_vector_short_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_mul(w_vector<unsigned short> *u, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_mul(w_vector<char> *u, w_vector<char const> *v) {
  return gsl_vector_char_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_mul(w_vector<unsigned char> *u, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_mul(w_vector<complex<double>> *u, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_mul(w_vector<complex<float>> *u, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_mul(u, v);
}


/// For vectors `u` and `v`, produce, element by element, `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_mul
/// @param u  Pointer to vector that `v` will multiply into.
/// @param v  Pointer to vector that will multiply in to `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_mul(w_vector<complex<long double>> *u,
      w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_mul(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/ptr.hpp

Source
/// \file       include/gslcpp/wrap/ptr.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_ptr().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<double> *v, size_t i) {
  return gsl_vector_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<double const> *v, size_t i) {
  return gsl_vector_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<float> *v, size_t i) {
  return gsl_vector_float_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<float const> *v, size_t i) {
  return gsl_vector_float_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<long double> *v, size_t i) {
  return gsl_vector_long_double_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<long double const> *v, size_t i) {
  return gsl_vector_long_double_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<int> *v, size_t i) {
  return gsl_vector_int_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<int const> *v, size_t i) {
  return gsl_vector_int_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<unsigned> *v, size_t i) {
  return gsl_vector_uint_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<unsigned const> *v, size_t i) {
  return gsl_vector_uint_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<long> *v, size_t i) {
  return gsl_vector_long_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<long const> *v, size_t i) {
  return gsl_vector_long_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<unsigned long> *v, size_t i) {
  return gsl_vector_ulong_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<unsigned long const> *v, size_t i) {
  return gsl_vector_ulong_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<short> *v, size_t i) {
  return gsl_vector_short_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<short const> *v, size_t i) {
  return gsl_vector_short_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<unsigned short> *v, size_t i) {
  return gsl_vector_ushort_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline unsigned short const *
w_ptr(w_vector<unsigned short const> *v, size_t i) {
  return gsl_vector_ushort_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<char> *v, size_t i) {
  return gsl_vector_char_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<char const> *v, size_t i) {
  return gsl_vector_char_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<unsigned char> *v, size_t i) {
  return gsl_vector_uchar_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<unsigned char const> *v, size_t i) {
  return gsl_vector_uchar_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<complex<double>> *v, size_t i) {
  return (complex<double> *)gsl_vector_complex_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<complex<double> const> *v, size_t i) {
  return (complex<double> const *)gsl_vector_complex_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<complex<float>> *v, size_t i) {
  return (complex<float> *)gsl_vector_complex_float_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<complex<float> const> *v, size_t i) {
  return (complex<float> const *)gsl_vector_complex_float_const_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto *w_ptr(w_vector<complex<long double>> *v, size_t i) {
  return (complex<long double> *)gsl_vector_complex_long_double_ptr(v, i);
}


/// Pointer to `i`th element of vector `v`, with bounds-checking.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_ptr
/// @param v  Pointer to vector.
/// @param i  Offset of element in vector.
/// @return  Pointer to element at offset `i` in `v`.
inline auto const *w_ptr(w_vector<complex<long double> const> *v, size_t i) {
  return (complex<long double> const *)
        gsl_vector_complex_long_double_const_ptr(v, i);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/real.hpp

Source (jump to first uncovered line)
/// @file       include/gslcpp/wrap/real.hpp
/// @copyright  2022 Thomas E. Vaughan, all rights reserved.
/// @brief      Definition of gsl::w_real().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<double> *v) {
  return gsl_vector_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<double const> *v) {
  return gsl_vector_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<float> *v) {
  return gsl_vector_float_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<float const> *v) {
  return gsl_vector_float_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<long double> *v) {
  return gsl_vector_long_double_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<long double const> *v) {
  return gsl_vector_long_double_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<int> *v) {
  return gsl_vector_int_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<int const> *v) {
  return gsl_vector_int_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned> *v) {
  return gsl_vector_uint_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned const> *v) {
  return gsl_vector_uint_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<long> *v) {
  return gsl_vector_long_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<long const> *v) {
  return gsl_vector_long_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned long> *v) {
  return gsl_vector_ulong_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<short> *v) {
  return gsl_vector_short_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<short const> *v) {
  return gsl_vector_short_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned short> *v) {
  return gsl_vector_ushort_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<char> *v) {
  return gsl_vector_char_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<char const> *v) {
  return gsl_vector_char_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned char> *v) {
  return gsl_vector_uchar_subvector_with_stride(v, 0, 1, v->size);
}


/// Real part (identity-view) of real vector.
/// @param v  Pointer to vector.
/// @return  Identity-view of real vector.
inline auto w_real(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_const_subvector_with_stride(v, 0, 1, v->size);
}


/// Real-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_real
/// @param u  Pointer to vector.
/// @return  View of real-part of complex vector.
inline auto w_real(w_vector<complex<double>> *u) {
  return gsl_vector_complex_real(u);
}


/// Real-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_real
/// @param u  Pointer to vector.
/// @return  View of real-part of complex vector.
inline auto w_real(w_vector<complex<float>> *u) {
  return gsl_vector_complex_float_real(u);
}


/// Real-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_real
/// @param u  Pointer to vector.
/// @return  View of real-part of complex vector.
inline auto w_real(w_vector<complex<long double>> *u) {
  return gsl_vector_complex_long_double_real(u);
}


/// Real-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_real
/// @param u  Pointer to vector.
/// @return  View of real-part of complex vector.
inline auto w_real(w_vector<complex<double>> const *u) {
  return gsl_vector_complex_const_real(u);
}


/// Real-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_real
/// @param u  Pointer to vector.
/// @return  View of real-part of complex vector.
inline auto w_real(w_vector<complex<float>> const *u) {
  return gsl_vector_complex_float_const_real(u);
}


/// Real-part of complex vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_complex_real
/// @param u  Pointer to vector.
/// @return  View of real-part of complex vector.
inline auto w_real(w_vector<complex<long double>> const *u) {
  return gsl_vector_complex_long_double_const_real(u);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/reverse.hpp

Source
/// \file       include/gslcpp/wrap/reverse.hpp
/// \copyright  2022 Thomas E. Vaughan
/// \brief      Definition of gsl::w_reverse().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<double> *v) { return gsl_vector_reverse(v); }


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<float> *v) {
  return gsl_vector_float_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<long double> *v) {
  return gsl_vector_long_double_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<int> *v) { return gsl_vector_int_reverse(v); }


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<unsigned> *v) {
  return gsl_vector_uint_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<long> *v) { return gsl_vector_long_reverse(v); }


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<unsigned long> *v) {
  return gsl_vector_ulong_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<short> *v) {
  return gsl_vector_short_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<unsigned short> *v) {
  return gsl_vector_ushort_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<char> *v) { return gsl_vector_char_reverse(v); }


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<unsigned char> *v) {
  return gsl_vector_uchar_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<complex<double>> *v) {
  return gsl_vector_complex_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<complex<float>> *v) {
  return gsl_vector_complex_float_reverse(v);
}


/// Reverse order of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_reverse
/// @param v  Pointer to vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_reverse(w_vector<complex<long double>> *v) {
  return gsl_vector_complex_long_double_reverse(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/scale.hpp

Source
/// \file       include/gslcpp/wrap/scale.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_scale().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<double> *u, double const &v) {
  return gsl_vector_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<float> *u, float const &v) {
  return gsl_vector_float_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<long double> *u, long double const &v) {
  return gsl_vector_long_double_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<int> *u, int const &v) {
  return gsl_vector_int_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<unsigned> *u, unsigned const &v) {
  return gsl_vector_uint_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<long> *u, long const &v) {
  return gsl_vector_long_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<unsigned long> *u, unsigned long const &v) {
  return gsl_vector_ulong_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<short> *u, short const &v) {
  return gsl_vector_short_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<unsigned short> *u, unsigned short const &v) {
  return gsl_vector_ushort_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<char> *u, char const &v) {
  return gsl_vector_char_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<unsigned char> *u, unsigned char const &v) {
  return gsl_vector_uchar_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<complex<double>> *u, complex<double> const &v) {
  return gsl_vector_complex_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int w_scale(w_vector<complex<float>> *u, complex<float> const &v) {
  return gsl_vector_complex_float_scale(u, v);
}


/// For vector `u` and scalar `v`, produce effect of `u = u * v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_scale
/// @param u  Pointer to vector.
/// @param v  Scalar.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_scale(w_vector<complex<long double>> *u, complex<long double> const &v) {
  return gsl_vector_complex_long_double_scale(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/set-all.hpp

Source
/// \file       include/gslcpp/wrap/set-all.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_set_all().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<double> *v, double const &x) {
  return gsl_vector_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<float> *v, float const &x) {
  return gsl_vector_float_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<long double> *v, long double const &x) {
  return gsl_vector_long_double_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<int> *v, int const &x) {
  return gsl_vector_int_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<unsigned> *v, unsigned const &x) {
  return gsl_vector_uint_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<long> *v, long const &x) {
  return gsl_vector_long_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<unsigned long> *v, unsigned long const &x) {
  return gsl_vector_ulong_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<short> *v, short const &x) {
  return gsl_vector_short_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<unsigned short> *v, unsigned short const &x) {
  return gsl_vector_ushort_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<char> *v, char const &x) {
  return gsl_vector_char_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<unsigned char> *v, unsigned char const &x) {
  return gsl_vector_uchar_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<complex<double>> *v, complex<double> const &x) {
  return gsl_vector_complex_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void w_set_all(w_vector<complex<float>> *v, complex<float> const &x) {
  return gsl_vector_complex_float_set_all(v, x);
}


/// Set every element of vector `v` to same value `x`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_all
/// @param v  Pointer to vector.
/// @param x  Initializer for every element.
inline void
w_set_all(w_vector<complex<long double>> *v, complex<long double> const &x) {
  return gsl_vector_complex_long_double_set_all(v, x);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/set-basis.hpp

Source
/// \file       include/gslcpp/wrap/set-basis.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_set_basis().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<double> *v, size_t i) {
  return gsl_vector_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<float> *v, size_t i) {
  return gsl_vector_float_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<long double> *v, size_t i) {
  return gsl_vector_long_double_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<int> *v, size_t i) {
  return gsl_vector_int_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<unsigned> *v, size_t i) {
  return gsl_vector_uint_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<long> *v, size_t i) {
  return gsl_vector_long_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<unsigned long> *v, size_t i) {
  return gsl_vector_ulong_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<short> *v, size_t i) {
  return gsl_vector_short_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<unsigned short> *v, size_t i) {
  return gsl_vector_ushort_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<char> *v, size_t i) {
  return gsl_vector_char_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<unsigned char> *v, size_t i) {
  return gsl_vector_uchar_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<complex<double>> *v, size_t i) {
  return gsl_vector_complex_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<complex<float>> *v, size_t i) {
  return gsl_vector_complex_float_set_basis(v, i);
}


/// Make basis-vector by setting every element in `v` to zero except for `i`th
/// element, which is set to unity.
///
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_basis
///
/// @param v  Pointer to vector.
/// @param i  Offset of component that should be set to unity.
/// @return  TBD: GSL's documentation does not specify.
inline int w_set_basis(w_vector<complex<long double>> *v, size_t i) {
  return gsl_vector_complex_long_double_set_basis(v, i);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/set-zero.hpp

Source
/// \file       include/gslcpp/wrap/set-zero.hpp
/// \copyright  2022 Thomas E. Vaughan
/// \brief      Definition of gsl::w_set_zero().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<double> *v) { gsl_vector_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<float> *v) { gsl_vector_float_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<long double> *v) {
  gsl_vector_long_double_set_zero(v);
}


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<int> *v) { gsl_vector_int_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<unsigned> *v) { gsl_vector_uint_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<long> *v) { gsl_vector_long_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<unsigned long> *v) {
  gsl_vector_ulong_set_zero(v);
}


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<short> *v) { gsl_vector_short_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<unsigned short> *v) {
  gsl_vector_ushort_set_zero(v);
}


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<char> *v) { gsl_vector_char_set_zero(v); }


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<unsigned char> *v) {
  gsl_vector_uchar_set_zero(v);
}


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<complex<double>> *v) {
  gsl_vector_complex_set_zero(v);
}


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<complex<float>> *v) {
  gsl_vector_complex_float_set_zero(v);
}


/// Set every element of vector `v` to zero.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set_zero
/// @param v  Pointer to vector.
inline void w_set_zero(w_vector<complex<long double>> *v) {
  gsl_vector_complex_long_double_set_zero(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/set.hpp

Source
/// \file       include/gslcpp/wrap/set.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_set().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<double> *v, size_t i, double const &x) {
  return gsl_vector_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<float> *v, size_t i, float const &x) {
  return gsl_vector_float_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<long double> *v, size_t i, long double const &x) {
  return gsl_vector_long_double_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<int> *v, size_t i, int const &x) {
  return gsl_vector_int_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<unsigned> *v, size_t i, unsigned const &x) {
  return gsl_vector_uint_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<long> *v, size_t i, long const &x) {
  return gsl_vector_long_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void
w_set(w_vector<unsigned long> *v, size_t i, unsigned long const &x) {
  return gsl_vector_ulong_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<short> *v, size_t i, short const &x) {
  return gsl_vector_short_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void
w_set(w_vector<unsigned short> *v, size_t i, unsigned short const &x) {
  return gsl_vector_ushort_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void w_set(w_vector<char> *v, size_t i, char const &x) {
  return gsl_vector_char_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void
w_set(w_vector<unsigned char> *v, size_t i, unsigned char const &x) {
  return gsl_vector_uchar_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void
w_set(w_vector<complex<double>> *v, size_t i, complex<double> const &x) {
  return gsl_vector_complex_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void
w_set(w_vector<complex<float>> *v, size_t i, complex<float> const &x) {
  return gsl_vector_complex_float_set(v, i, x);
}


/// Set to `x` the value of `i`th element of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_set
/// @param v  Pointer to vector.
/// @param i  Offset of element whose value should change.
/// @param x  New value for element at offset `i`.
inline void
w_set(w_vector<complex<long double>> *v,
      size_t i,
      complex<long double> const &x) {
  return gsl_vector_complex_long_double_set(v, i, x);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/sub.hpp

Source
/// \file       include/gslcpp/wrap/sub.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_sub().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<double> *u, w_vector<double const> *v) {
  return gsl_vector_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<float> *u, w_vector<float const> *v) {
  return gsl_vector_float_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<long double> *u, w_vector<long double const> *v) {
  return gsl_vector_long_double_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<int> *u, w_vector<int const> *v) {
  return gsl_vector_int_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<unsigned> *u, w_vector<unsigned const> *v) {
  return gsl_vector_uint_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<long> *u, w_vector<long const> *v) {
  return gsl_vector_long_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_sub(w_vector<unsigned long> *u, w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<short> *u, w_vector<short const> *v) {
  return gsl_vector_short_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_sub(w_vector<unsigned short> *u, w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int w_sub(w_vector<char> *u, w_vector<char const> *v) {
  return gsl_vector_char_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_sub(w_vector<unsigned char> *u, w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_sub(w_vector<complex<double>> *u, w_vector<complex<double> const> *v) {
  return gsl_vector_complex_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_sub(w_vector<complex<float>> *u, w_vector<complex<float> const> *v) {
  return gsl_vector_complex_float_sub(u, v);
}


/// For vectors `u` and `v`, obtain effect `u = u - v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sub
/// @param u  Pointer to vector from which `u` will be subtracted.
/// @param v  Pointer to vector to subtract from `u`.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_sub(w_vector<complex<long double>> *u,
      w_vector<complex<long double> const> *v) {
  return gsl_vector_complex_long_double_sub(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/subvector.hpp

Source
/// \file       include/gslcpp/wrap/subvector.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_subvector().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<double> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<double const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<float> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_float_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<float const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_float_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<long double> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_long_double_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<long double const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_long_double_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<int> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_int_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<int const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_int_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<unsigned> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_uint_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_uint_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<long> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_long_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<long const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_long_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned long> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_ulong_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned long const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_ulong_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<short> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_short_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<short const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_short_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned short> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_ushort_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned short const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_ushort_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(w_vector<char> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_char_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<char const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_char_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned char> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_uchar_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<unsigned char const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_uchar_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<complex<double>> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_complex_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<complex<double> const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_complex_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<complex<float>> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_complex_float_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<complex<float> const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_complex_float_const_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto
w_subvector(w_vector<complex<long double>> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_complex_long_double_subvector_with_stride(v, i, s, n);
}


/// View of subvector of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_subvector_with_stride
/// @param v  Pointer to vector.
/// @param i  Offset in `v` of view's first element.
/// @param s  Stride of successive elements in view relative to offsets in `v`.
/// @param n  Number of elements in view.
/// @return  View of subvector.
inline auto w_subvector(
      w_vector<complex<long double> const> *v, size_t i, size_t s, size_t n) {
  return gsl_vector_complex_long_double_const_subvector_with_stride(
        v, i, s, n);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/sum.hpp

Source (jump to first uncovered line)
/// \file       include/gslcpp/wrap/sum.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_sum().

#pragma once
#include "container.hpp" // w_vector
#include "element.hpp" // element_t
#include <Eigen/Core> // Dynamic, Map, Matrix, Stride

namespace gsl {


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<double const> *v) { return gsl_vector_sum(v); }


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<float const> *v) { return gsl_vector_float_sum(v); }


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<long double const> *v) {
  return gsl_vector_long_double_sum(v);
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<int const> *v) { return gsl_vector_int_sum(v); }


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<unsigned const> *v) {
  return gsl_vector_uint_sum(v);
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<long const> *v) { return gsl_vector_long_sum(v); }


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<unsigned long const> *v) {
  return gsl_vector_ulong_sum(v);
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<short const> *v) { return gsl_vector_short_sum(v); }


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<unsigned short const> *v) {
  return gsl_vector_ushort_sum(v);
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<char const> *v) { return gsl_vector_char_sum(v); }


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<unsigned char const> *v) {
  return gsl_vector_uchar_sum(v);
}


/// Sum of elements in complex vector, not covered by GSL's sum.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// This implementation uses Eigen to compute the sum.
/// @tparam C  Complex type of vector's element.
/// @param v  Reference to vector.
/// @return  Sum of elements.
template<typename C> C complex_sum(w_vector<C const> *v) {
  using Eigen::Dynamic;
  using Eigen::Map;
  using Eigen::Matrix;
  using Eigen::Stride;
  using S= Stride<Dynamic, Dynamic>;
  using map= Map<Matrix<C, Dynamic, 1> const, 0, S>;
  S const s(v->size * v->stride, v->stride);
  return map((C const *)v->data, v->size, s).sum();
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<gsl::complex<double> const> *v) {
  return complex_sum<gsl::complex<double>>(v);
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<gsl::complex<float> const> *v) {
  return complex_sum<gsl::complex<float>>(v);
}


/// Sum of elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_sum
/// @param v  Pointer to vector.
/// @return  Sum of elements in `v`.
inline auto w_sum(w_vector<gsl::complex<long double> const> *v) {
  return complex_sum<gsl::complex<long double>>(v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/swap-elements.hpp

Source
/// \file       include/gslcpp/wrap/swap-elements.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_swap_elements().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<double> *v, size_t i, size_t j) {
  return gsl_vector_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<float> *v, size_t i, size_t j) {
  return gsl_vector_float_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<long double> *v, size_t i, size_t j) {
  return gsl_vector_long_double_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<int> *v, size_t i, size_t j) {
  return gsl_vector_int_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<unsigned> *v, size_t i, size_t j) {
  return gsl_vector_uint_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<long> *v, size_t i, size_t j) {
  return gsl_vector_long_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<unsigned long> *v, size_t i, size_t j) {
  return gsl_vector_ulong_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<short> *v, size_t i, size_t j) {
  return gsl_vector_short_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<unsigned short> *v, size_t i, size_t j) {
  return gsl_vector_ushort_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<char> *v, size_t i, size_t j) {
  return gsl_vector_char_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<unsigned char> *v, size_t i, size_t j) {
  return gsl_vector_uchar_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<complex<double>> *v, size_t i, size_t j) {
  return gsl_vector_complex_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap_elements(w_vector<complex<float>> *v, size_t i, size_t j) {
  return gsl_vector_complex_float_swap_elements(v, i, j);
}


/// Exchange `i`th and `j`th elements in vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap_elements
/// @param v  Pointer to vector.
/// @param i  Offset of one element to exchange.
/// @param j  Offset of other element to exchange.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_swap_elements(w_vector<complex<long double>> *v, size_t i, size_t j) {
  return gsl_vector_complex_long_double_swap_elements(v, i, j);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/swap.hpp

Source
/// \file       include/gslcpp/wrap/swap.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_swap().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<double> *u, w_vector<double> *v) {
  return gsl_vector_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<float> *u, w_vector<float> *v) {
  return gsl_vector_float_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<long double> *u, w_vector<long double> *v) {
  return gsl_vector_long_double_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<int> *u, w_vector<int> *v) {
  return gsl_vector_int_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<unsigned> *u, w_vector<unsigned> *v) {
  return gsl_vector_uint_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<long> *u, w_vector<long> *v) {
  return gsl_vector_long_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<unsigned long> *u, w_vector<unsigned long> *v) {
  return gsl_vector_ulong_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<short> *u, w_vector<short> *v) {
  return gsl_vector_short_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<unsigned short> *u, w_vector<unsigned short> *v) {
  return gsl_vector_ushort_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<char> *u, w_vector<char> *v) {
  return gsl_vector_char_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<unsigned char> *u, w_vector<unsigned char> *v) {
  return gsl_vector_uchar_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<complex<double>> *u, w_vector<complex<double>> *v) {
  return gsl_vector_complex_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int w_swap(w_vector<complex<float>> *u, w_vector<complex<float>> *v) {
  return gsl_vector_complex_float_swap(u, v);
}


/// Exchange elements of vector `u` and corresponding ones of vector `v`.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_swap
/// @param u  Pointer to one vector.
/// @param v  Pointer to other vector.
/// @return  TBD: GSL's documentation does not specify.
inline int
w_swap(w_vector<complex<long double>> *u, w_vector<complex<long double>> *v) {
  return gsl_vector_complex_long_double_swap(u, v);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/vector-alloc.hpp

Source
/// \file       include/gslcpp/wrap/vector-alloc.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_vector_alloc<E>(size_t).

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Generic template-declaration for function that allocates vector whose
/// element-type is E.
///
/// @tparam E  Type of each element in vector.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<typename E> w_vector<E> *w_vector_alloc(size_t n);


/// Specialization for double.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<double> *w_vector_alloc<double>(size_t n) {
  return gsl_vector_alloc(n);
}


/// Specialization for float.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<float> *w_vector_alloc<float>(size_t n) {
  return gsl_vector_float_alloc(n);
}


/// Specialization for long double.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<long double> *w_vector_alloc<long double>(size_t n) {
  return gsl_vector_long_double_alloc(n);
}


/// Specialization for int.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<int> *w_vector_alloc<int>(size_t n) {
  return gsl_vector_int_alloc(n);
}


/// Specialization for unsigned.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<unsigned> *w_vector_alloc<unsigned>(size_t n) {
  return gsl_vector_uint_alloc(n);
}


/// Specialization for long.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<long> *w_vector_alloc<long>(size_t n) {
  return gsl_vector_long_alloc(n);
}


/// Specialization for unsigned long.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<unsigned long> *w_vector_alloc<unsigned long>(size_t n) {
  return gsl_vector_ulong_alloc(n);
}


/// Specialization for short.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<short> *w_vector_alloc<short>(size_t n) {
  return gsl_vector_short_alloc(n);
}


/// Specialization for unsigned short.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<unsigned short> *w_vector_alloc<unsigned short>(size_t n) {
  return gsl_vector_ushort_alloc(n);
}


/// Specialization for char.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<char> *w_vector_alloc<char>(size_t n) {
  return gsl_vector_char_alloc(n);
}


/// Specialization for unsigned char.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<unsigned char> *w_vector_alloc<unsigned char>(size_t n) {
  return gsl_vector_uchar_alloc(n);
}


/// Specialization for complex<double>.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<complex<double>> *w_vector_alloc<complex<double>>(size_t n) {
  return gsl_vector_complex_alloc(n);
}


/// Specialization for complex<float>.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<complex<float>> *w_vector_alloc<complex<float>>(size_t n) {
  return gsl_vector_complex_float_alloc(n);
}


/// Specialization for complex<long double>.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<complex<long double>> *
w_vector_alloc<complex<long double>>(size_t n) {
  return gsl_vector_complex_long_double_alloc(n);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/vector-calloc.hpp

Source
/// \file       include/gslcpp/wrap/vector-calloc.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_vector_calloc<E>(size_t).

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Generic template-declaration for function that allocates vector whose
/// element-type is E and initializes each element to zero.
///
/// @tparam E  Type of each element in vector.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for zero-initialized vector.
template<typename E> w_vector<E> *w_vector_calloc(size_t n);


/// Specialization for double.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<double> *w_vector_calloc<double>(size_t n) {
  return gsl_vector_calloc(n);
}


/// Specialization for float.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<float> *w_vector_calloc<float>(size_t n) {
  return gsl_vector_float_calloc(n);
}


/// Specialization for long double.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<long double> *w_vector_calloc<long double>(size_t n) {
  return gsl_vector_long_double_calloc(n);
}


/// Specialization for int.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<int> *w_vector_calloc<int>(size_t n) {
  return gsl_vector_int_calloc(n);
}


/// Specialization for unsigned.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<unsigned> *w_vector_calloc<unsigned>(size_t n) {
  return gsl_vector_uint_calloc(n);
}


/// Specialization for long.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<long> *w_vector_calloc<long>(size_t n) {
  return gsl_vector_long_calloc(n);
}


/// Specialization for unsigned long.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<unsigned long> *w_vector_calloc<unsigned long>(size_t n) {
  return gsl_vector_ulong_calloc(n);
}


/// Specialization for short.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<short> *w_vector_calloc<short>(size_t n) {
  return gsl_vector_short_calloc(n);
}


/// Specialization for unsigned short.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<unsigned short> *w_vector_calloc<unsigned short>(size_t n) {
  return gsl_vector_ushort_calloc(n);
}


/// Specialization for char.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<> inline w_vector<char> *w_vector_calloc<char>(size_t n) {
  return gsl_vector_char_calloc(n);
}


/// Specialization for unsigned char.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<unsigned char> *w_vector_calloc<unsigned char>(size_t n) {
  return gsl_vector_uchar_calloc(n);
}


/// Specialization for complex<double>.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<complex<double>> *w_vector_calloc<complex<double>>(size_t n) {
  return gsl_vector_complex_calloc(n);
}


/// Specialization for complex<float>.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<complex<float>> *w_vector_calloc<complex<float>>(size_t n) {
  return gsl_vector_complex_float_calloc(n);
}


/// Specialization for complex<long double>.
/// @param n  Number of elements to allocate.
/// @return  Pointer to GSL's native C-struct for vector.
template<>
inline w_vector<complex<long double>> *
w_vector_calloc<complex<long double>>(size_t n) {
  return gsl_vector_complex_long_double_calloc(n);
}


} // namespace gsl

// EOF

/home/runner/work/gslcpp/gslcpp/include/gslcpp/wrap/vector-view-array.hpp

Source
/// \file       include/gslcpp/wrap/vector-view-array.hpp
/// \copyright  2022 Thomas E. Vaughan, all rights reserved.
/// \brief      Definition of gsl::w_vector_view_array().

#pragma once
#include "container.hpp" // w_vector

namespace gsl {


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(double *b, size_t s, size_t n) {
  return gsl_vector_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(double const *b, size_t s, size_t n) {
  return gsl_vector_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(float *b, size_t s, size_t n) {
  return gsl_vector_float_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(float const *b, size_t s, size_t n) {
  return gsl_vector_float_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(long double *b, size_t s, size_t n) {
  return gsl_vector_long_double_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(long double const *b, size_t s, size_t n) {
  return gsl_vector_long_double_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(int *b, size_t s, size_t n) {
  return gsl_vector_int_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(int const *b, size_t s, size_t n) {
  return gsl_vector_int_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned *b, size_t s, size_t n) {
  return gsl_vector_uint_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned const *b, size_t s, size_t n) {
  return gsl_vector_uint_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(long *b, size_t s, size_t n) {
  return gsl_vector_long_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(long const *b, size_t s, size_t n) {
  return gsl_vector_long_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned long *b, size_t s, size_t n) {
  return gsl_vector_ulong_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned long const *b, size_t s, size_t n) {
  return gsl_vector_ulong_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(short *b, size_t s, size_t n) {
  return gsl_vector_short_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(short const *b, size_t s, size_t n) {
  return gsl_vector_short_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned short *b, size_t s, size_t n) {
  return gsl_vector_ushort_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned short const *b, size_t s, size_t n) {
  return gsl_vector_ushort_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(char *b, size_t s, size_t n) {
  return gsl_vector_char_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(char const *b, size_t s, size_t n) {
  return gsl_vector_char_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned char *b, size_t s, size_t n) {
  return gsl_vector_uchar_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(unsigned char const *b, size_t s, size_t n) {
  return gsl_vector_uchar_const_view_array_with_stride(b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(complex<double> *b, size_t s, size_t n) {
  return gsl_vector_complex_view_array_with_stride((double *)b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(complex<double> const *b, size_t s, size_t n) {
  return gsl_vector_complex_const_view_array_with_stride(
        (double const *)b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(complex<float> *b, size_t s, size_t n) {
  return gsl_vector_complex_float_view_array_with_stride((float *)b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(complex<float> const *b, size_t s, size_t n) {
  return gsl_vector_complex_float_const_view_array_with_stride(
        (float const *)b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto w_vector_view_array(complex<long double> *b, size_t s, size_t n) {
  return gsl_vector_complex_long_double_view_array_with_stride(
        (long double *)b, s, n);
}


/// Initialize view of C-style array as vector.
/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_view_array_with_stride
/// @param b  Pointer to first element of view.
/// @param s  Stride of successive elements in view relative to array.
/// @param n  Number of elements in view.
/// @return  View of C-style array as vector.
inline auto
w_vector_view_array(complex<long double> const *b, size_t s, size_t n) {
  return gsl_vector_complex_long_double_const_view_array_with_stride(
        (long double const *)b, s, n);
}


} // namespace gsl

// EOF

Line	Count	Source
1		/// @file include/gslcpp/wrap/add-constant.hpp
2		/// @copyright 2022 Thomas E. Vaughan, all rights reserved.
3		/// @brief Definition of gsl::add_constant().
4
5		#pragma once
6		#include "container.hpp" // w_vector
7
8		namespace gsl {
9
10
11		/// Add same constant to every element in place. `add_constant` is overloaded
12		/// to provide the same name for every type of vector.
13		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
14		/// @param u Pointer to vector whose elements are to be modified.
15		/// @param v Constant to add into each element.
16		/// @return TBD: Not specified in GSL's documentation.
17	5	inline int w_add_constant(w_vector<double> *u, double const &v) {
18	5	return gsl_vector_add_constant(u, v);
19	5	}
20
21
22		/// Add same constant to every element in place. `add_constant` is overloaded
23		/// to provide the same name for every type of vector.
24		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
25		/// @param u Pointer to vector whose elements are to be modified.
26		/// @param v Constant to add into each element.
27		/// @return TBD: Not specified in GSL's documentation.
28	5	inline int w_add_constant(w_vector<float> *u, float const &v) {
29	5	return gsl_vector_float_add_constant(u, v);
30	5	}
31
32
33		/// Add same constant to every element in place. `add_constant` is overloaded
34		/// to provide the same name for every type of vector.
35		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
36		/// @param u Pointer to vector whose elements are to be modified.
37		/// @param v Constant to add into each element.
38		/// @return TBD: Not specified in GSL's documentation.
39	5	inline int w_add_constant(w_vector<long double> *u, long double const &v) {
40	5	return gsl_vector_long_double_add_constant(u, v);
41	5	}
42
43
44		/// Add same constant to every element in place. `add_constant` is overloaded
45		/// to provide the same name for every type of vector.
46		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
47		/// @param u Pointer to vector whose elements are to be modified.
48		/// @param v Constant to add into each element.
49		/// @return TBD: Not specified in GSL's documentation.
50	5	inline int w_add_constant(w_vector<int> *u, int const &v) {
51	5	return gsl_vector_int_add_constant(u, v);
52	5	}
53
54
55		/// Add same constant to every element in place. `add_constant` is overloaded
56		/// to provide the same name for every type of vector.
57		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
58		/// @param u Pointer to vector whose elements are to be modified.
59		/// @param v Constant to add into each element.
60		/// @return TBD: Not specified in GSL's documentation.
61	5	inline int w_add_constant(w_vector<unsigned> *u, unsigned const &v) {
62	5	return gsl_vector_uint_add_constant(u, v);
63	5	}
64
65
66		/// Add same constant to every element in place. `add_constant` is overloaded
67		/// to provide the same name for every type of vector.
68		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
69		/// @param u Pointer to vector whose elements are to be modified.
70		/// @param v Constant to add into each element.
71		/// @return TBD: Not specified in GSL's documentation.
72	5	inline int w_add_constant(w_vector<long> *u, long const &v) {
73	5	return gsl_vector_long_add_constant(u, v);
74	5	}
75
76
77		/// Add same constant to every element in place. `add_constant` is overloaded
78		/// to provide the same name for every type of vector.
79		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
80		/// @param u Pointer to vector whose elements are to be modified.
81		/// @param v Constant to add into each element.
82		/// @return TBD: Not specified in GSL's documentation.
83	5	inline int w_add_constant(w_vector<unsigned long> *u, unsigned long const &v) {
84	5	return gsl_vector_ulong_add_constant(u, v);
85	5	}
86
87
88		/// Add same constant to every element in place. `add_constant` is overloaded
89		/// to provide the same name for every type of vector.
90		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
91		/// @param u Pointer to vector whose elements are to be modified.
92		/// @param v Constant to add into each element.
93		/// @return TBD: Not specified in GSL's documentation.
94	5	inline int w_add_constant(w_vector<short> *u, short const &v) {
95	5	return gsl_vector_short_add_constant(u, v);
96	5	}
97
98
99		/// Add same constant to every element in place. `add_constant` is overloaded
100		/// to provide the same name for every type of vector.
101		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
102		/// @param u Pointer to vector whose elements are to be modified.
103		/// @param v Constant to add into each element.
104		/// @return TBD: Not specified in GSL's documentation.
105		inline int
106	5	w_add_constant(w_vector<unsigned short> *u, unsigned short const &v) {
107	5	return gsl_vector_ushort_add_constant(u, v);
108	5	}
109
110
111		/// Add same constant to every element in place. `add_constant` is overloaded
112		/// to provide the same name for every type of vector.
113		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
114		/// @param u Pointer to vector whose elements are to be modified.
115		/// @param v Constant to add into each element.
116		/// @return TBD: Not specified in GSL's documentation.
117	5	inline int w_add_constant(w_vector<char> *u, char const &v) {
118	5	return gsl_vector_char_add_constant(u, v);
119	5	}
120
121
122		/// Add same constant to every element in place. `add_constant` is overloaded
123		/// to provide the same name for every type of vector.
124		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
125		/// @param u Pointer to vector whose elements are to be modified.
126		/// @param v Constant to add into each element.
127		/// @return TBD: Not specified in GSL's documentation.
128	5	inline int w_add_constant(w_vector<unsigned char> *u, unsigned char const &v) {
129	5	return gsl_vector_uchar_add_constant(u, v);
130	5	}
131
132
133		/// Add same constant to every element in place. `add_constant` is overloaded
134		/// to provide the same name for every type of vector.
135		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
136		/// @param u Pointer to vector whose elements are to be modified.
137		/// @param v Constant to add into each element.
138		/// @return TBD: Not specified in GSL's documentation.
139		inline int
140	5	w_add_constant(w_vector<complex<double>> *u, complex<double> const &v) {
141	5	return gsl_vector_complex_add_constant(u, v);
142	5	}
143
144
145		/// Add same constant to every element in place. `add_constant` is overloaded
146		/// to provide the same name for every type of vector.
147		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
148		/// @param u Pointer to vector whose elements are to be modified.
149		/// @param v Constant to add into each element.
150		/// @return TBD: Not specified in GSL's documentation.
151		inline int
152	5	w_add_constant(w_vector<complex<float>> *u, complex<float> const &v) {
153	5	return gsl_vector_complex_float_add_constant(u, v);
154	5	}
155
156
157		/// Add same constant to every element in place. `add_constant` is overloaded
158		/// to provide the same name for every type of vector.
159		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add_constant
160		/// @param u Pointer to vector whose elements are to be modified.
161		/// @param v Constant to add into each element.
162		/// @return TBD: Not specified in GSL's documentation.
163		inline int w_add_constant(
164	5	w_vector<complex<long double>> *u, complex<long double> const &v) {
165	5	return gsl_vector_complex_long_double_add_constant(u, v);
166	5	}
167
168
169		} // namespace gsl
170
171		// EOF

Line	Count	Source
1		/// @file include/gslcpp/wrap/add.hpp
2		/// @copyright 2022 Thomas E. Vaughan, all rights reserved.
3		/// @brief Definition of gsl::w_add().
4
5		#pragma once
6		#include "container.hpp" // w_vector
7
8		namespace gsl {
9
10
11		/// Element by element, accumulate `v` into `u`.
12		/// `add` is overloaded to provide the same name for every type of vector.
13		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
14		/// @param u Pointer to vector to be modified.
15		/// @param v Pointer to vector to be added in to `u`.
16		/// @return TBD: GSL's documentation does not specify.
17	2	inline int w_add(w_vector<double> u, w_vector<double const> v) {
18	2	return gsl_vector_add(u, v);
19	2	}
20
21
22		/// Element by element, accumulate `v` into `u`.
23		/// `add` is overloaded to provide the same name for every type of vector.
24		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
25		/// @param u Pointer to vector to be modified.
26		/// @param v Pointer to vector to be added in to `u`.
27		/// @return TBD: GSL's documentation does not specify.
28	2	inline int w_add(w_vector<float> u, w_vector<float const> v) {
29	2	return gsl_vector_float_add(u, v);
30	2	}
31
32
33		/// Element by element, accumulate `v` into `u`.
34		/// `add` is overloaded to provide the same name for every type of vector.
35		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
36		/// @param u Pointer to vector to be modified.
37		/// @param v Pointer to vector to be added in to `u`.
38		/// @return TBD: GSL's documentation does not specify.
39	2	inline int w_add(w_vector<long double> u, w_vector<long double const> v) {
40	2	return gsl_vector_long_double_add(u, v);
41	2	}
42
43
44		/// Element by element, accumulate `v` into `u`.
45		/// `add` is overloaded to provide the same name for every type of vector.
46		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
47		/// @param u Pointer to vector to be modified.
48		/// @param v Pointer to vector to be added in to `u`.
49		/// @return TBD: GSL's documentation does not specify.
50	2	inline int w_add(w_vector<int> u, w_vector<int const> v) {
51	2	return gsl_vector_int_add(u, v);
52	2	}
53
54
55		/// Element by element, accumulate `v` into `u`.
56		/// `add` is overloaded to provide the same name for every type of vector.
57		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
58		/// @param u Pointer to vector to be modified.
59		/// @param v Pointer to vector to be added in to `u`.
60		/// @return TBD: GSL's documentation does not specify.
61	2	inline int w_add(w_vector<unsigned> u, w_vector<unsigned const> v) {
62	2	return gsl_vector_uint_add(u, v);
63	2	}
64
65
66		/// Element by element, accumulate `v` into `u`.
67		/// `add` is overloaded to provide the same name for every type of vector.
68		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
69		/// @param u Pointer to vector to be modified.
70		/// @param v Pointer to vector to be added in to `u`.
71		/// @return TBD: GSL's documentation does not specify.
72	2	inline int w_add(w_vector<long> u, w_vector<long const> v) {
73	2	return gsl_vector_long_add(u, v);
74	2	}
75
76
77		/// Element by element, accumulate `v` into `u`.
78		/// `add` is overloaded to provide the same name for every type of vector.
79		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
80		/// @param u Pointer to vector to be modified.
81		/// @param v Pointer to vector to be added in to `u`.
82		/// @return TBD: GSL's documentation does not specify.
83		inline int
84	2	w_add(w_vector<unsigned long> u, w_vector<unsigned long const> v) {
85	2	return gsl_vector_ulong_add(u, v);
86	2	}
87
88
89		/// Element by element, accumulate `v` into `u`.
90		/// `add` is overloaded to provide the same name for every type of vector.
91		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
92		/// @param u Pointer to vector to be modified.
93		/// @param v Pointer to vector to be added in to `u`.
94		/// @return TBD: GSL's documentation does not specify.
95	2	inline int w_add(w_vector<short> u, w_vector<short const> v) {
96	2	return gsl_vector_short_add(u, v);
97	2	}
98
99
100		/// Element by element, accumulate `v` into `u`.
101		/// `add` is overloaded to provide the same name for every type of vector.
102		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
103		/// @param u Pointer to vector to be modified.
104		/// @param v Pointer to vector to be added in to `u`.
105		/// @return TBD: GSL's documentation does not specify.
106		inline int
107	2	w_add(w_vector<unsigned short> u, w_vector<unsigned short const> v) {
108	2	return gsl_vector_ushort_add(u, v);
109	2	}
110
111
112		/// Element by element, accumulate `v` into `u`.
113		/// `add` is overloaded to provide the same name for every type of vector.
114		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
115		/// @param u Pointer to vector to be modified.
116		/// @param v Pointer to vector to be added in to `u`.
117		/// @return TBD: GSL's documentation does not specify.
118	2	inline int w_add(w_vector<char> u, w_vector<char const> v) {
119	2	return gsl_vector_char_add(u, v);
120	2	}
121
122
123		/// Element by element, accumulate `v` into `u`.
124		/// `add` is overloaded to provide the same name for every type of vector.
125		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
126		/// @param u Pointer to vector to be modified.
127		/// @param v Pointer to vector to be added in to `u`.
128		/// @return TBD: GSL's documentation does not specify.
129		inline int
130	2	w_add(w_vector<unsigned char> u, w_vector<unsigned char const> v) {
131	2	return gsl_vector_uchar_add(u, v);
132	2	}
133
134
135		/// Element by element, accumulate `v` into `u`.
136		/// `add` is overloaded to provide the same name for every type of vector.
137		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
138		/// @param u Pointer to vector to be modified.
139		/// @param v Pointer to vector to be added in to `u`.
140		/// @return TBD: GSL's documentation does not specify.
141		inline int
142	2	w_add(w_vector<complex<double>> u, w_vector<complex<double> const> v) {
143	2	return gsl_vector_complex_add(u, v);
144	2	}
145
146
147		/// Element by element, accumulate `v` into `u`.
148		/// `add` is overloaded to provide the same name for every type of vector.
149		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
150		/// @param u Pointer to vector to be modified.
151		/// @param v Pointer to vector to be added in to `u`.
152		/// @return TBD: GSL's documentation does not specify.
153		inline int
154	2	w_add(w_vector<complex<float>> u, w_vector<complex<float> const> v) {
155	2	return gsl_vector_complex_float_add(u, v);
156	2	}
157
158
159		/// Element by element, accumulate `v` into `u`.
160		/// `add` is overloaded to provide the same name for every type of vector.
161		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_add
162		/// @param u Pointer to vector to be modified.
163		/// @param v Pointer to vector to be added in to `u`.
164		/// @return TBD: GSL's documentation does not specify.
165		inline int
166		w_add(w_vector<complex<long double>> *u,
167	2	w_vector<complex<long double> const> *v) {
168	2	return gsl_vector_complex_long_double_add(u, v);
169	2	}
170
171
172		} // namespace gsl
173
174		// EOF

Line	Count	Source (jump to first uncovered line)
1		/// \file include/gslcpp/wrap/complex.hpp
2		/// \copyright 2022 Thomas E. Vaughan, all rights reserved.
3		/// \brief Definition of gsl::complex.
4
5		#pragma once
6		#include <complex> // std::complex
7		#include <gsl/gsl_complex.h> // gsl_complex, etc.
8
9		namespace gsl {
10
11
12		/// Complex-number, each of whose components has type A.
13		/// This is the generic declaration; see each specialization for details.
14		/// \sa gsl::complex<double>
15		/// \sa gsl::complex<float>
16		/// \sa gsl::complex<long double>
17		/// \tparam A Type of each component.
18		template<typename A> struct complex;
19
20
21		/// Specialization of \ref gsl::complex for double.
22		template<> struct complex<double>: public std::complex<double> {
23		using P= std::complex<double>; ///< Type of parent.
24		using P::P; // Inherit constructors.
25
26		/// Construct from gsl_complex.
27		/// \param z Reference to instance of gsl_complex.
28	1	complex(gsl_complex const &z): P(GSL_REAL(z), GSL_IMAG(z)) {}
29
30		/// Construct from instance of parent's type.
31		/// \param z Reference to instance of parent's type.
32	3	complex(P const &z): P(z) {}
33
34		/// Convert to gsl_complex.
35		/// \return Reference to this as gsl_complex.
36	0	operator gsl_complex &() { return (gsl_complex )this; }
37
38		/// Convert to gsl_complex.
39		/// \return Reference to this as gsl_complex.
40	19	operator gsl_complex const &() const { return (gsl_complex const )this; }
41		};
42
43
44		/// Specialization of \ref gsl::complex for float.
45		template<> struct complex<float>: public std::complex<float> {
46		using P= std::complex<float>; ///< Type of parent.
47		using P::P; // Inherit constructors.
48
49		/// Construct from gsl_complex.
50		/// \param z Reference to instance of gsl_complex.
51	1	complex(gsl_complex_float const &z): P(GSL_REAL(z), GSL_IMAG(z)) {}
52
53		/// Construct from instance of parent's type.
54		/// \param z Reference to instance of parent's type.
55	3	complex(P const &z): P(z) {}
56
57		/// Convert to gsl_complex.
58		/// \return Reference to this as gsl_complex.
59	0	operator gsl_complex_float &() { return (gsl_complex_float )this; }
60
61		/// Convert to gsl_complex.
62		/// \return Reference to this as gsl_complex.
63	19	operator gsl_complex_float const &() const {
64	19	return (gsl_complex_float const )this;
65	19	}
66		};
67
68
69		/// Specialization of \ref gsl::complex for long double.
70		template<> struct complex<long double>: public std::complex<long double> {
71		using P= std::complex<long double>; ///< Type of parent.
72		using P::P; // Inherit constructors.
73
74		/// Construct from gsl_complex.
75		/// \param z Reference to instance of gsl_complex.
76	1	complex(gsl_complex_long_double const &z): P(GSL_REAL(z), GSL_IMAG(z)) {}
77
78		/// Construct from instance of parent's type.
79		/// \param z Reference to instance of parent's type.
80	3	complex(P const &z): P(z) {}
81
82		/// Convert to gsl_complex.
83		/// \return Reference to this as gsl_complex.
84	0	operator gsl_complex_long_double &() {
85	0	return (gsl_complex_long_double )this;
86	0	}
87
88		/// Convert to gsl_complex.
89		/// \return Reference to this as gsl_complex.
90	19	operator gsl_complex_long_double const &() const {
91	19	return (gsl_complex_long_double const )this;
92	19	}
93		};
94
95
96		} // namespace gsl
97
98		// EOF

Line	Count	Source
1		/// \file include/gslcpp/wrap/div.hpp
2		/// \copyright 2022 Thomas E. Vaughan, all rights reserved.
3		/// \brief Definition of gsl::w_div().
4
5		#pragma once
6		#include "container.hpp" // w_vector
7
8		namespace gsl {
9
10
11		/// Perform the logical operation `u = u/v` element by element.
12		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
13		/// @param u Pointer to matrix whose elements should be divided into.
14		/// @param v Pointer to matrix whose elements divide into.
15		/// @return TBD: GSL's documentation does not specify.
16	2	inline int w_div(w_vector<double> u, w_vector<double const> v) {
17	2	return gsl_vector_div(u, v);
18	2	}
19
20
21		/// Perform the logical operation `u = u/v` element by element.
22		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
23		/// @param u Pointer to matrix whose elements should be divided into.
24		/// @param v Pointer to matrix whose elements divide into.
25		/// @return TBD: GSL's documentation does not specify.
26	2	inline int w_div(w_vector<float> u, w_vector<float const> v) {
27	2	return gsl_vector_float_div(u, v);
28	2	}
29
30
31		/// Perform the logical operation `u = u/v` element by element.
32		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
33		/// @param u Pointer to matrix whose elements should be divided into.
34		/// @param v Pointer to matrix whose elements divide into.
35		/// @return TBD: GSL's documentation does not specify.
36	2	inline int w_div(w_vector<long double> u, w_vector<long double const> v) {
37	2	return gsl_vector_long_double_div(u, v);
38	2	}
39
40
41		/// Perform the logical operation `u = u/v` element by element.
42		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
43		/// @param u Pointer to matrix whose elements should be divided into.
44		/// @param v Pointer to matrix whose elements divide into.
45		/// @return TBD: GSL's documentation does not specify.
46	2	inline int w_div(w_vector<int> u, w_vector<int const> v) {
47	2	return gsl_vector_int_div(u, v);
48	2	}
49
50
51		/// Perform the logical operation `u = u/v` element by element.
52		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
53		/// @param u Pointer to matrix whose elements should be divided into.
54		/// @param v Pointer to matrix whose elements divide into.
55		/// @return TBD: GSL's documentation does not specify.
56	2	inline int w_div(w_vector<unsigned> u, w_vector<unsigned const> v) {
57	2	return gsl_vector_uint_div(u, v);
58	2	}
59
60
61		/// Perform the logical operation `u = u/v` element by element.
62		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
63		/// @param u Pointer to matrix whose elements should be divided into.
64		/// @param v Pointer to matrix whose elements divide into.
65		/// @return TBD: GSL's documentation does not specify.
66	2	inline int w_div(w_vector<long> u, w_vector<long const> v) {
67	2	return gsl_vector_long_div(u, v);
68	2	}
69
70
71		/// Perform the logical operation `u = u/v` element by element.
72		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
73		/// @param u Pointer to matrix whose elements should be divided into.
74		/// @param v Pointer to matrix whose elements divide into.
75		/// @return TBD: GSL's documentation does not specify.
76		inline int
77	2	w_div(w_vector<unsigned long> u, w_vector<unsigned long const> v) {
78	2	return gsl_vector_ulong_div(u, v);
79	2	}
80
81
82		/// Perform the logical operation `u = u/v` element by element.
83		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
84		/// @param u Pointer to matrix whose elements should be divided into.
85		/// @param v Pointer to matrix whose elements divide into.
86		/// @return TBD: GSL's documentation does not specify.
87	2	inline int w_div(w_vector<short> u, w_vector<short const> v) {
88	2	return gsl_vector_short_div(u, v);
89	2	}
90
91
92		/// Perform the logical operation `u = u/v` element by element.
93		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
94		/// @param u Pointer to matrix whose elements should be divided into.
95		/// @param v Pointer to matrix whose elements divide into.
96		/// @return TBD: GSL's documentation does not specify.
97		inline int
98	2	w_div(w_vector<unsigned short> u, w_vector<unsigned short const> v) {
99	2	return gsl_vector_ushort_div(u, v);
100	2	}
101
102
103		/// Perform the logical operation `u = u/v` element by element.
104		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
105		/// @param u Pointer to matrix whose elements should be divided into.
106		/// @param v Pointer to matrix whose elements divide into.
107		/// @return TBD: GSL's documentation does not specify.
108	2	inline int w_div(w_vector<char> u, w_vector<char const> v) {
109	2	return gsl_vector_char_div(u, v);
110	2	}
111
112
113		/// Perform the logical operation `u = u/v` element by element.
114		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
115		/// @param u Pointer to matrix whose elements should be divided into.
116		/// @param v Pointer to matrix whose elements divide into.
117		/// @return TBD: GSL's documentation does not specify.
118		inline int
119	2	w_div(w_vector<unsigned char> u, w_vector<unsigned char const> v) {
120	2	return gsl_vector_uchar_div(u, v);
121	2	}
122
123
124		/// Perform the logical operation `u = u/v` element by element.
125		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
126		/// @param u Pointer to matrix whose elements should be divided into.
127		/// @param v Pointer to matrix whose elements divide into.
128		/// @return TBD: GSL's documentation does not specify.
129		inline int
130	2	w_div(w_vector<complex<double>> u, w_vector<complex<double> const> v) {
131	2	return gsl_vector_complex_div(u, v);
132	2	}
133
134
135		/// Perform the logical operation `u = u/v` element by element.
136		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
137		/// @param u Pointer to matrix whose elements should be divided into.
138		/// @param v Pointer to matrix whose elements divide into.
139		/// @return TBD: GSL's documentation does not specify.
140		inline int
141	2	w_div(w_vector<complex<float>> u, w_vector<complex<float> const> v) {
142	2	return gsl_vector_complex_float_div(u, v);
143	2	}
144
145
146		/// Perform the logical operation `u = u/v` element by element.
147		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_div
148		/// @param u Pointer to matrix whose elements should be divided into.
149		/// @param v Pointer to matrix whose elements divide into.
150		/// @return TBD: GSL's documentation does not specify.
151		inline int
152		w_div(w_vector<complex<long double>> *u,
153	2	w_vector<complex<long double> const> *v) {
154	2	return gsl_vector_complex_long_double_div(u, v);
155	2	}
156
157
158		} // namespace gsl
159
160		// EOF

Line	Count	Source
1		/// \file include/gslcpp/wrap/equal.hpp
2		/// \copyright 2022 Thomas E. Vaughan, all rights reserved.
3		/// \brief Definition of gsl::w_equal().
4
5		#pragma once
6		#include "container.hpp" // w_vector
7
8		namespace gsl {
9
10
11		/// True if every element in `u` be equal to corrending element in `v`.
12		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
13		/// @param u Pointer to one vector.
14		/// @param v Pointer to other vector.
15		/// @return True if vectors be equal.
16	17	inline bool w_equal(w_vector<double const> u, w_vector<double const> v) {
17	17	return gsl_vector_equal(u, v);
18	17	}
19
20
21		/// True if every element in `u` be equal to corrending element in `v`.
22		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
23		/// @param u Pointer to one vector.
24		/// @param v Pointer to other vector.
25		/// @return True if vectors be equal.
26	15	inline bool w_equal(w_vector<float const> u, w_vector<float const> v) {
27	15	return gsl_vector_float_equal(u, v);
28	15	}
29
30
31		/// True if every element in `u` be equal to corrending element in `v`.
32		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
33		/// @param u Pointer to one vector.
34		/// @param v Pointer to other vector.
35		/// @return True if vectors be equal.
36		inline bool
37	15	w_equal(w_vector<long double const> u, w_vector<long double const> v) {
38	15	return gsl_vector_long_double_equal(u, v);
39	15	}
40
41
42		/// True if every element in `u` be equal to corrending element in `v`.
43		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
44		/// @param u Pointer to one vector.
45		/// @param v Pointer to other vector.
46		/// @return True if vectors be equal.
47	15	inline bool w_equal(w_vector<int const> u, w_vector<int const> v) {
48	15	return gsl_vector_int_equal(u, v);
49	15	}
50
51
52		/// True if every element in `u` be equal to corrending element in `v`.
53		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
54		/// @param u Pointer to one vector.
55		/// @param v Pointer to other vector.
56		/// @return True if vectors be equal.
57	15	inline bool w_equal(w_vector<unsigned const> u, w_vector<unsigned const> v) {
58	15	return gsl_vector_uint_equal(u, v);
59	15	}
60
61
62		/// True if every element in `u` be equal to corrending element in `v`.
63		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
64		/// @param u Pointer to one vector.
65		/// @param v Pointer to other vector.
66		/// @return True if vectors be equal.
67	15	inline bool w_equal(w_vector<long const> u, w_vector<long const> v) {
68	15	return gsl_vector_long_equal(u, v);
69	15	}
70
71
72		/// True if every element in `u` be equal to corrending element in `v`.
73		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
74		/// @param u Pointer to one vector.
75		/// @param v Pointer to other vector.
76		/// @return True if vectors be equal.
77		inline bool
78	15	w_equal(w_vector<unsigned long const> u, w_vector<unsigned long const> v) {
79	15	return gsl_vector_ulong_equal(u, v);
80	15	}
81
82
83		/// True if every element in `u` be equal to corrending element in `v`.
84		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
85		/// @param u Pointer to one vector.
86		/// @param v Pointer to other vector.
87		/// @return True if vectors be equal.
88	15	inline bool w_equal(w_vector<short const> u, w_vector<short const> v) {
89	15	return gsl_vector_short_equal(u, v);
90	15	}
91
92
93		/// True if every element in `u` be equal to corrending element in `v`.
94		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
95		/// @param u Pointer to one vector.
96		/// @param v Pointer to other vector.
97		/// @return True if vectors be equal.
98		inline bool
99	15	w_equal(w_vector<unsigned short const> u, w_vector<unsigned short const> v) {
100	15	return gsl_vector_ushort_equal(u, v);
101	15	}
102
103
104		/// True if every element in `u` be equal to corrending element in `v`.
105		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
106		/// @param u Pointer to one vector.
107		/// @param v Pointer to other vector.
108		/// @return True if vectors be equal.
109	15	inline bool w_equal(w_vector<char const> u, w_vector<char const> v) {
110	15	return gsl_vector_char_equal(u, v);
111	15	}
112
113
114		/// True if every element in `u` be equal to corrending element in `v`.
115		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
116		/// @param u Pointer to one vector.
117		/// @param v Pointer to other vector.
118		/// @return True if vectors be equal.
119		inline bool
120	15	w_equal(w_vector<unsigned char const> u, w_vector<unsigned char const> v) {
121	15	return gsl_vector_uchar_equal(u, v);
122	15	}
123
124
125		/// True if every element in `u` be equal to corrending element in `v`.
126		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
127		/// @param u Pointer to one vector.
128		/// @param v Pointer to other vector.
129		/// @return True if vectors be equal.
130		inline bool w_equal(
131	15	w_vector<complex<double> const> u, w_vector<complex<double> const> v) {
132	15	return gsl_vector_complex_equal(u, v);
133	15	}
134
135
136		/// True if every element in `u` be equal to corrending element in `v`.
137		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
138		/// @param u Pointer to one vector.
139		/// @param v Pointer to other vector.
140		/// @return True if vectors be equal.
141		inline bool
142	15	w_equal(w_vector<complex<float> const> u, w_vector<complex<float> const> v) {
143	15	return gsl_vector_complex_float_equal(u, v);
144	15	}
145
146
147		/// True if every element in `u` be equal to corrending element in `v`.
148		/// https://www.gnu.org/software/gsl/doc/html/vectors.html#c.gsl_vector_equal
149		/// @param u Pointer to one vector.
150		/// @param v Pointer to other vector.
151		/// @return True if vectors be equal.
152		inline bool w_equal(
153		w_vector<complex<long double> const> *u,
154	15	w_vector<complex<long double> const> *v) {
155	15	return gsl_vector_complex_long_double_equal(u, v);
156	15	}
157
158
159		} // namespace gsl
160
161		// EOF