complex.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2015  Virginia Tech
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Justus Calvin
 *  Department of Chemistry, Virginia Tech
 *
 *  complex.h
 *  Dec 11, 2015
 *
 */

#ifndef TILEDARRAY_SRC_TILEDARRAY_TENSOR_COMPLEX_H__INCLUDED
#define TILEDARRAY_SRC_TILEDARRAY_TENSOR_COMPLEX_H__INCLUDED

#include <TiledArray/type_traits.h>

namespace TiledArray {
  namespace detail {



    template <typename R,
        typename std::enable_if<! is_complex<R>::value>::type* = nullptr>
    TILEDARRAY_FORCE_INLINE R conj(const R r) {
      return r;
    }


    template <typename R>
    TILEDARRAY_FORCE_INLINE std::complex<R> conj(const std::complex<R> z) {
      return std::conj(z);
    }


    template <typename L, typename R,
        typename std::enable_if<! is_complex<L>::value>::type* = nullptr>
    TILEDARRAY_FORCE_INLINE auto inner_product(const L l, const R r) {
      return l * r;
    }


    template <typename L, typename R,
        typename std::enable_if<is_complex<L>::value>::type* = nullptr>
    TILEDARRAY_FORCE_INLINE auto inner_product(const L l, const R r) {
      return TiledArray::detail::conj(l) * r;
    }


    template <typename R,
        typename std::enable_if<! is_complex<R>::value>::type* = nullptr>
    TILEDARRAY_FORCE_INLINE R norm(const R r) {
      return r * r;
    }


    template <typename R>
    TILEDARRAY_FORCE_INLINE R norm(const std::complex<R> z) {
      const R real = z.real();
      const R imag = z.imag();
      return real * real + imag * imag;
    }

    template <typename S>
    class ComplexConjugate {
      S factor_;

    public:
      ComplexConjugate(const S factor) : factor_(factor) { }

      TILEDARRAY_FORCE_INLINE S factor() const { return factor_; }

      TILEDARRAY_FORCE_INLINE ComplexConjugate<S> operator-() const {
        return ComplexConjugate<S>(-factor_);
      }

      friend std::ostream& operator<<(std::ostream& os, const ComplexConjugate<S>& cc) {
        os << "conj()] [" << cc.factor_;
        return os;
      }
    };


    struct ComplexNegTag { };

    template <>
    class ComplexConjugate<void> {
    public:

      inline ComplexConjugate<ComplexNegTag> operator-() const;

      friend std::ostream&
      operator<<(std::ostream& os, const ComplexConjugate<void>& cc) {
        os << "conj()";
        return os;
      }
    };

    template <>
    class ComplexConjugate<ComplexNegTag> {
    public:

      inline ComplexConjugate<void> operator-() const;

      friend std::ostream&
      operator<<(std::ostream& os, const ComplexConjugate<ComplexNegTag>& cc) {
        os << "conj()] [-1";
        return os;
      }
    };


    inline ComplexConjugate<void>
    ComplexConjugate<ComplexNegTag>::operator-() const {
      return ComplexConjugate<void>();
    }

    inline ComplexConjugate<ComplexNegTag>
    ComplexConjugate<void>::operator-() const {
      return ComplexConjugate<ComplexNegTag>();
    }

    template <typename S>
    struct is_numeric<ComplexConjugate<S> > : public std::true_type { };


    template <typename S>
    inline ComplexConjugate<S> conj_op(const S factor) {
      return ComplexConjugate<S>(factor);
    }


    inline ComplexConjugate<void> conj_op() {
      return ComplexConjugate<void>();
    }

    template <typename L, typename R>
    TILEDARRAY_FORCE_INLINE auto
    operator*(const L value, const ComplexConjugate<R> op)
    { return TiledArray::detail::conj(value) * op.factor(); }

    template <typename L>
    TILEDARRAY_FORCE_INLINE auto
    operator*(const L value, const ComplexConjugate<void>&)
    { return TiledArray::detail::conj(value); }

    template <typename L>
    TILEDARRAY_FORCE_INLINE auto
    operator*(const L value, const ComplexConjugate<ComplexNegTag>&)
    { return -TiledArray::detail::conj(value); }


    template <typename L, typename R>
    TILEDARRAY_FORCE_INLINE auto
    operator*(const ComplexConjugate<L> op, const R value)
    { return TiledArray::detail::conj(value) * op.factor(); }

    template <typename R>
    TILEDARRAY_FORCE_INLINE auto
    operator*(const ComplexConjugate<void>, const R value)
    { return TiledArray::detail::conj(value); }

    template <typename R>
    TILEDARRAY_FORCE_INLINE auto
    operator*(const ComplexConjugate<ComplexNegTag>, const R value)
    { return -TiledArray::detail::conj(value); }


    template <typename L, typename R,
        typename std::enable_if<! std::is_void<R>::value>::type* = nullptr>
    TILEDARRAY_FORCE_INLINE L&
    operator*=(L& value, const ComplexConjugate<R> op) {
      value = TiledArray::detail::conj(value) * op.factor();
      return value;
    }

    template <typename L>
    TILEDARRAY_FORCE_INLINE L&
    operator*=(L& value, const ComplexConjugate<void>&) {
      value = TiledArray::detail::conj(value);
      return value;
    }

    template <typename L>
    TILEDARRAY_FORCE_INLINE L&
    operator*=(L& value, const ComplexConjugate<ComplexNegTag>&) {
      value = -TiledArray::detail::conj(value);
      return value;
    }

    template<typename T>
    inline auto abs(const ComplexConjugate<T>& a){
      return std::abs(a.factor());
    }

    inline int abs(const ComplexConjugate<void>& a){
      return 1;
    }

  }  // namespace detail
} // namespace TiledArray

#endif // TILEDARRAY_SRC_TILEDARRAY_TENSOR_COMPLEX_H__INCLUDED