_valarray.h

来自「stl的源码」· C头文件 代码 · 共 1,685 行 · 第 1/4 页

  return __tmp;
}

template <class _Tp>
inline _Valarray_bool _STLP_CALL operator>=(const _Tp& __c, const valarray<_Tp>& __x) {
  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = __c >= __x[__i];
  return __tmp;
}

template <class _Tp>
inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, const _Tp& __c) {
  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = __x[__i] && __c;
  return __tmp;
}

template <class _Tp>
inline _Valarray_bool _STLP_CALL operator&&(const _Tp& __c, const valarray<_Tp>& __x) {
  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = __c && __x[__i];
  return __tmp;
}

template <class _Tp>
inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, const _Tp& __c) {
  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = __x[__i] || __c;
  return __tmp;
}

template <class _Tp>
inline _Valarray_bool _STLP_CALL operator||(const _Tp& __c, const valarray<_Tp>& __x) {
  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = __c || __x[__i];
  return __tmp;
}

// valarray "transcendentals" (the list includes abs and sqrt, which,
// of course, are not transcendental).

template <class _Tp>
inline valarray<_Tp> abs(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::abs(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> acos(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::acos(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> asin(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::asin(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> atan(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::atan(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> atan2(const valarray<_Tp>& __x,
                           const valarray<_Tp>& __y) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::atan2(__x[__i], __y[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::atan2(__x[__i], __c);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::atan2(__c, __x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> cos(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::cos(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> cosh(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::cosh(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> exp(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::exp(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> log(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::log(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> log10(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::log10(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> pow(const valarray<_Tp>& __x,
                         const valarray<_Tp>& __y) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::pow(__x[__i], __y[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::pow(__x[__i], __c);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::pow(__c, __x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> sin(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::sin(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> sinh(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::sinh(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> sqrt(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::sqrt(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> tan(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::tan(__x[__i]);
  return __tmp;
}

template <class _Tp>
inline valarray<_Tp> tanh(const valarray<_Tp>& __x) {
  typedef typename valarray<_Tp>::_NoInit _NoInit;
  valarray<_Tp> __tmp(__x.size(), _NoInit());
  for (size_t __i = 0; __i < __x.size(); ++__i)
    __tmp[__i] = ::tanh(__x[__i]);
  return __tmp;
}

//----------------------------------------------------------------------
// slice and slice_array

class slice {
public:
  slice() : _M_start(0), _M_length(0), _M_stride(0) {}
  slice(size_t __start, size_t __length, size_t __stride)
    : _M_start(__start), _M_length(__length), _M_stride(__stride)
    {}
  __TRIVIAL_DESTRUCTOR(slice)

  size_t start()  const { return _M_start; }
  size_t size()   const { return _M_length; }
  size_t stride() const { return _M_stride; }

private:
  size_t _M_start;
  size_t _M_length;
  size_t _M_stride;
};

template <class _Tp>
class slice_array {
  friend class valarray<_Tp>;
public:
  typedef _Tp value_type;

  void operator=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] = __x[__i];
  }

  void operator*=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] *= __x[__i];
  }

  void operator/=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] /= __x[__i];
  }

  void operator%=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] %= __x[__i];
  }

  void operator+=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] += __x[__i];
  }

  void operator-=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] -= __x[__i];
  }

  void operator^=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] ^= __x[__i];
  }

  void operator&=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] &= __x[__i];
  }

  void operator|=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] |= __x[__i];
  }

  void operator<<=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] <<= __x[__i];
  }

  void operator>>=(const valarray<value_type>& __x) const {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] >>= __x[__i];
  }

  void operator=(const value_type& __c) /*const could be const but standard says NO (26.3.5.4-1)*/ {
    size_t __index = _M_slice.start();
    for (size_t __i = 0;
         __i < _M_slice.size();
         ++__i, __index += _M_slice.stride())
      _M_array[__index] = __c;
  }

  // C++ Standard defect 253, copy constructor must be public.
  slice_array(const slice_array &__x)
    : _M_slice(__x._M_slice), _M_array(__x._M_array)
    {}

  ~slice_array() {}

private:
  slice_array(const slice& __slice, valarray<_Tp> &__array)
    : _M_slice(__slice), _M_array(__array)
    {}

  slice          _M_slice;
  valarray<_Tp>& _M_array;

private:
  // Disable default constructor and assignment
  slice_array();
  slice_array& operator=(const slice_array&);
};

// valarray member functions dealing with slice and slice_array

template <class _Tp>
inline valarray<_Tp>::valarray(const slice_array<_Tp>& __x)
  : _Valarray_base<_Tp>(__x._M_slice.size()) {
  typedef typename __type_traits<_Tp>::has_trivial_default_constructor
          _Is_Trivial;
  _M_initialize(_Is_Trivial());
  *this = __x;
}


template <class _Tp>
inline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice)
{ return slice_array<_Tp>(__slice, *this); }

//----------------------------------------------------------------------
// gslice and gslice_array

template <class _Size>
struct _Gslice_Iter_tmpl;

class gslice {
  friend struct _Gslice_Iter_tmpl<size_t>;
public:
  gslice() : _M_start(0), _M_lengths(), _M_strides() {}
  gslice(size_t __start,
         const _Valarray_size_t& __lengths, const _Valarray_size_t& __strides)
    : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides)
    {}
  __TRIVIAL_DESTRUCTOR(gslice)

  size_t start()            const { return _M_start; }
  _Valarray_size_t size()   const { return _M_lengths; }
  _Valarray_size_t stride() const { return _M_strides; }

  // Extension: check for an empty gslice.
  bool _M_empty() const { return _M_lengths.size() == 0; }

  // Extension: number of indices this gslice represents.  (For a degenerate
  // gslice, they're not necessarily all distinct.)
  size_t _M_size() const {
    return !this->_M_empty()
      ? accumulate(_M_lengths._M_first + 1,
                   _M_lengths._M_first + _M_lengths._M_size,
                   _M_lengths[0],
                   multiplies<size_t>())
      : 0;
  }