complex_base.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_CORE_COMPLEX_BASE_HPP
#define STAN_MATH_PRIM_CORE_COMPLEX_BASE_HPP
 
#include <stan/math/prim/fun/square.hpp>
#include <stan/math/prim/meta.hpp>
#include <complex>
 
namespace stan {
namespace math {
 
template <typename ValueType>
class complex_base {
 public:
  using value_type = ValueType;
 
  using complex_type = std::complex<value_type>;
 
  complex_base() = default;
 
  template <typename U>  // , typename = require_stan_scalar_t<U>>
  complex_base(const U& re) : re_(re) {}  // NOLINT(runtime/explicit)
 
  template <typename U, typename V>
  complex_base(const U& re, const V& im) : re_(re), im_(im) {}
 
  value_type real() const { return re_; }
 
  void real(const value_type& re) { re_ = re; }
 
  value_type imag() const { return im_; }
 
  void imag(const value_type& im) { im_ = im; }
 
  template <typename U, typename = require_stan_scalar_t<U>>
  complex_type& operator=(U&& re) {
    re_ = re;
    im_ = 0;
    return derived();
  }
 
  template <typename U>
  complex_type& operator+=(const U& x) {
    re_ += x;
    return derived();
  }
 
  template <typename U>
  complex_type& operator+=(const std::complex<U>& other) {
    re_ += other.real();
    im_ += other.imag();
    return derived();
  }
 
  template <typename U>
  complex_type& operator-=(const U& x) {
    re_ -= x;
    return derived();
  }
 
  template <typename U>
  complex_type& operator-=(const std::complex<U>& other) {
    re_ -= other.real();
    im_ -= other.imag();
    return derived();
  }
 
  template <typename U>
  complex_type& operator*=(const U& x) {
    re_ *= x;
    im_ *= x;
    return derived();
  }
 
  template <typename U>
  complex_type& operator*=(const std::complex<U>& other) {
    value_type re_temp = re_ * other.real() - im_ * other.imag();
    im_ = re_ * other.imag() + other.real() * im_;
    re_ = re_temp;
    return derived();
  }
 
  template <typename U>
  complex_type& operator/=(const U& x) {
    re_ /= x;
    im_ /= x;
    return derived();
  }
 
  template <typename U>
  complex_type& operator/=(const std::complex<U>& other) {
    using stan::math::square;
    value_type sum_sq_im
        = (other.real() * other.real()) + (other.imag() * other.imag());
    value_type re_temp = (re_ * other.real() + im_ * other.imag()) / sum_sq_im;
    im_ = (im_ * other.real() - re_ * other.imag()) / sum_sq_im;
    re_ = re_temp;
    return derived();
  }
 
 protected:
  value_type re_{0};
 
  value_type im_{0};
 
  complex_type& derived() { return static_cast<complex_type&>(*this); }
};
 
}  // namespace math
}  // namespace stan
 
#endif