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>
__host__ __device__
inline T
conj(const T& z)
{
    return z;
}

using thrust::abs;
template <typename T>
__host__ __device__
inline typename cusp::norm_type<T>::type
abs(const T& z)
{
    return z > 0 ? z : -z;
}

using thrust::norm;
template <typename T>
__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 __host__ __device__
    complex(const T & re = T(), const T& im = T());

    template <typename X>
    inline __host__ __device__
    complex(const complex<X> & z);

    template <typename X>
    inline __host__
    complex(const std::complex<X> & z);



    /* --- Compound Assignment Operators --- */

    __host__ __device__
    inline complex<T>& operator+=(const complex<T> z);

    __host__ __device__
    inline complex<T>& operator-=(const complex<T> z);

    __host__ __device__
    inline complex<T>& operator*=(const complex<T> z);

    __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
     */

    __host__ __device__ inline T real() const volatile {
        return m_data[0];
    }

    __host__ __device__ inline T imag() const volatile {
        return m_data[1];
    }

    __host__ __device__ inline T real() const {
        return m_data[0];
    }

    __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
     */

    __host__ __device__ inline void real(T re)volatile {
        m_data[0] = re;
    }

    __host__ __device__ inline void imag(T im)volatile {
        m_data[1] = im;
    }

    __host__ __device__ inline void real(T re) {
        m_data[0] = re;
    }

    __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> __host__ __device__ inline T abs(const complex<T>& z);

template<typename T> __host__ __device__ inline T arg(const complex<T>& z);

template<typename T> __host__ __device__ inline T norm(const complex<T>& z);

template<typename T> __host__ __device__ inline complex<T> conj(const complex<T>& z);

template<typename T> __host__ __device__ inline complex<T> polar(const T& m, const T& theta = 0);

template<typename T> __host__ __device__ inline complex<T> proj(const T& z);



/* --- Binary Arithmetic operators --- */

template <typename T> __host__ __device__ inline complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator*(const complex<T>& lhs, const T & rhs);

template <typename T> __host__ __device__ inline complex<T> operator*(const T& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator/(const complex<T>& lhs, const T & rhs);

template <typename T> __host__ __device__ inline complex<T> operator/(const T& lhs, const complex<T> & rhs);

template <typename T> __host__ __device__ inline complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator+(const complex<T>& lhs, const T & rhs);

template <typename T> __host__ __device__ inline complex<T> operator+(const T& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator-(const complex<T>& lhs, const T & rhs);

template <typename T> __host__ __device__ inline complex<T> operator-(const T& lhs, const complex<T>& rhs);



/* --- Unary Arithmetic operators --- */

template <typename T> __host__ __device__ inline complex<T> operator+(const complex<T>& rhs);

template <typename T> __host__ __device__ inline complex<T> operator-(const complex<T>& rhs);



/* --- Exponential Functions --- */

template <typename T> __host__ __device__ complex<T> exp(const complex<T>& z);

template <typename T> __host__ __device__ complex<T> log(const complex<T>& z);

template <typename T> __host__ __device__ inline complex<T> log10(const complex<T>& z);



/* --- Power Functions --- */

template <typename T> __host__ __device__ complex<T> pow(const complex<T>& x, const complex<T>& y);

template <typename T> __host__ __device__ complex<T> pow(const complex<T>& x, const T& y);

template <typename T> __host__ __device__ complex<T> pow(const T& x, const complex<T>& y);

#if !defined _MSC_VER

template <typename T, typename U> __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> __host__ __device__ complex<typename detail::promoted_numerical_type<T,U>::type > pow(const complex<T>& x, const U& y);

template <typename T, typename U> __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> __host__ __device__ complex<T> sqrt(const complex<T>&z);



/* --- Trigonometric Functions --- */

template <typename T> __host__ __device__ complex<T> cos(const complex<T>&z);

template <typename T> __host__ __device__ complex<T> sin(const complex<T>&z);

template <typename T> __host__ __device__ complex<T> tan(const complex<T>&z);



/* --- Hyperbolic Functions --- */

template <typename T> __host__ __device__ complex<T> cosh(const complex<T>& z);

template <typename T> __host__ __device__ complex<T> sinh(const complex<T>&z);

template <typename T> __host__ __device__ complex<T> tanh(const complex<T>&z);



/* --- Inverse Trigonometric Functions --- */

template <typename T> __host__ __device__ complex<T> acos(const complex<T>& z);

template <typename T> __host__ __device__ complex<T> asin(const complex<T>& z);

template <typename T> __host__ __device__ complex<T> atan(const complex<T>& z);



/* --- Inverse Hyperbolic Functions --- */

template <typename T> __host__ __device__ complex<T> acosh(const complex<T>& z);

template <typename T> __host__ __device__ complex<T> asinh(const complex<T>& z);

template <typename T> __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> __host__ __device__ inline bool operator==(const complex<T>& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline bool operator==(const T & lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline bool operator==(const complex<T> & lhs, const T& rhs);

template <typename T> __host__ __device__ inline bool operator!=(const complex<T>& lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline bool operator!=(const T & lhs, const complex<T>& rhs);

template <typename T> __host__ __device__ inline bool operator!=(const complex<T> & lhs, const T& rhs);

#include <thrust/detail/complex/complex.inl>

#endif

} // end namespace cusp