complex.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2014 NVIDIA Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
 
#pragma once
 
#include <cusp/detail/config.h>
 
#include <thrust/functional.h>
 
#if THRUST_VERSION >= 100800
#include <thrust/complex.h>
#else
#include <cusp/detail/thrust/complex.h>
#endif
 
namespace cusp
{
 
using thrust::complex;
 
/* \cond */
template <typename T>
struct norm_type
{
    typedef T type;
};
 
template <typename T>
struct norm_type< cusp::complex<T> >
{
    typedef T type;
};
/* \endcond */
 
using thrust::conj;
template<typename T>
_CCCL_HOST_DEVICE
inline T
conj(const T& z)
{
    return z;
}
 
using thrust::abs;
template <typename T>
_CCCL_HOST_DEVICE
inline typename cusp::norm_type<T>::type
abs(const T& z)
{
    return z > 0 ? z : -z;
}
 
using thrust::norm;
template <typename T>
_CCCL_HOST_DEVICE
inline typename cusp::norm_type<T>::type
norm(const T& z)
{
    return cusp::abs(z);
}
 
using thrust::sqrt;
 
// define complex type for the purpose of Doxygenating it
// it is actually defined in Thrust
#if 0
template <typename T>
struct complex
{
public:
 
    typedef T value_type;
 
    /* --- Constructors --- */
 
    inline _CCCL_HOST_DEVICE
    complex(const T & re = T(), const T& im = T());
 
    template <typename X>
    inline _CCCL_HOST_DEVICE
    complex(const complex<X> & z);
 
    template <typename X>
    inline _CCCL_HOST
    complex(const std::complex<X> & z);
 
 
 
    /* --- Compound Assignment Operators --- */
 
    _CCCL_HOST_DEVICE
    inline complex<T>& operator+=(const complex<T> z);
 
    _CCCL_HOST_DEVICE
    inline complex<T>& operator-=(const complex<T> z);
 
    _CCCL_HOST_DEVICE
    inline complex<T>& operator*=(const complex<T> z);
 
    _CCCL_HOST_DEVICE
    inline complex<T>& operator/=(const complex<T> z);
 
 
 
    /* --- Getter functions ---
     * The volatile ones are there to help for example
     * with certain reductions optimizations
     */
 
    _CCCL_HOST_DEVICE inline T real() const volatile {
        return m_data[0];
    }
 
    _CCCL_HOST_DEVICE inline T imag() const volatile {
        return m_data[1];
    }
 
    _CCCL_HOST_DEVICE inline T real() const {
        return m_data[0];
    }
 
    _CCCL_HOST_DEVICE inline T imag() const {
        return m_data[1];
    }
 
 
 
    /* --- Setter functions ---
     * The volatile ones are there to help for example
     * with certain reductions optimizations
     */
 
    _CCCL_HOST_DEVICE inline void real(T re)volatile {
        m_data[0] = re;
    }
 
    _CCCL_HOST_DEVICE inline void imag(T im)volatile {
        m_data[1] = im;
    }
 
    _CCCL_HOST_DEVICE inline void real(T re) {
        m_data[0] = re;
    }
 
    _CCCL_HOST_DEVICE inline void imag(T im) {
        m_data[1] = im;
    }
 
 
 
    /* --- Casting functions --- */
 
    inline operator std::complex<T>() const {
        return std::complex<T>(real(),imag());
    }
 
private:
    T m_data[2];
};
 
 
/* --- General Functions --- */
 
template<typename T> _CCCL_HOST_DEVICE inline T abs(const complex<T>& z);
 
template<typename T> _CCCL_HOST_DEVICE inline T arg(const complex<T>& z);
 
template<typename T> _CCCL_HOST_DEVICE inline T norm(const complex<T>& z);
 
template<typename T> _CCCL_HOST_DEVICE inline complex<T> conj(const complex<T>& z);
 
template<typename T> _CCCL_HOST_DEVICE inline complex<T> polar(const T& m, const T& theta = 0);
 
template<typename T> _CCCL_HOST_DEVICE inline complex<T> proj(const T& z);
 
 
 
/* --- Binary Arithmetic operators --- */
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator*(const complex<T>& lhs, const T & rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator*(const T& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator/(const complex<T>& lhs, const T & rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator/(const T& lhs, const complex<T> & rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator+(const complex<T>& lhs, const T & rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator+(const T& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator-(const complex<T>& lhs, const T & rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator-(const T& lhs, const complex<T>& rhs);
 
 
 
/* --- Unary Arithmetic operators --- */
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator+(const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> operator-(const complex<T>& rhs);
 
 
 
/* --- Exponential Functions --- */
 
template <typename T> _CCCL_HOST_DEVICE complex<T> exp(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> log(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE inline complex<T> log10(const complex<T>& z);
 
 
 
/* --- Power Functions --- */
 
template <typename T> _CCCL_HOST_DEVICE complex<T> pow(const complex<T>& x, const complex<T>& y);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> pow(const complex<T>& x, const T& y);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> pow(const T& x, const complex<T>& y);
 
#if !defined _MSC_VER
template <typename T, typename U> _CCCL_HOST_DEVICE complex<typename detail::promoted_numerical_type<T,U>::type > pow(const complex<T>& x, const complex<U>& y);
 
template <typename T, typename U> _CCCL_HOST_DEVICE complex<typename detail::promoted_numerical_type<T,U>::type > pow(const complex<T>& x, const U& y);
 
template <typename T, typename U> _CCCL_HOST_DEVICE complex<typename detail::promoted_numerical_type<T,U>::type > pow(const T& x,const complex<U>& y);
 
#endif // !defined _MSC_VER
 
template <typename T> _CCCL_HOST_DEVICE complex<T> sqrt(const complex<T>&z);
 
 
 
/* --- Trigonometric Functions --- */
 
template <typename T> _CCCL_HOST_DEVICE complex<T> cos(const complex<T>&z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> sin(const complex<T>&z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> tan(const complex<T>&z);
 
 
 
/* --- Hyperbolic Functions --- */
 
template <typename T> _CCCL_HOST_DEVICE complex<T> cosh(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> sinh(const complex<T>&z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> tanh(const complex<T>&z);
 
 
 
/* --- Inverse Trigonometric Functions --- */
 
template <typename T> _CCCL_HOST_DEVICE complex<T> acos(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> asin(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> atan(const complex<T>& z);
 
 
 
/* --- Inverse Hyperbolic Functions --- */
 
template <typename T> _CCCL_HOST_DEVICE complex<T> acosh(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> asinh(const complex<T>& z);
 
template <typename T> _CCCL_HOST_DEVICE complex<T> atanh(const complex<T>& z);
 
 
 
/* --- Stream Operators --- */
 
template<typename ValueType,class charT, class traits>
std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const complex<ValueType>& z);
 
template<typename ValueType, typename charT, class traits>
std::basic_istream<charT, traits>&
operator>>(std::basic_istream<charT, traits>& is, complex<ValueType>& z);
 
 
 
/* --- Equality Operators --- */
 
template <typename T> _CCCL_HOST_DEVICE inline bool operator==(const complex<T>& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline bool operator==(const T & lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline bool operator==(const complex<T> & lhs, const T& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline bool operator!=(const complex<T>& lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline bool operator!=(const T & lhs, const complex<T>& rhs);
 
template <typename T> _CCCL_HOST_DEVICE inline bool operator!=(const complex<T> & lhs, const T& rhs);
 
#include <thrust/detail/complex/complex.inl>
 
#endif
 
} // end namespace cusp