Skip to content
This repository has been archived by the owner on Apr 15, 2024. It is now read-only.

Kokkos::Complex

Jump to bottom
crtrott edited this page Aug 14, 2019 · 2 revisions

Kokkos::complex

Header File: Kokkos_Core.hpp

Usage:

Kokkos::complex<double> a,b;
a.imag() = 5.0; a.real() = 1.0
b = a;
a += b;

.

Synopsis

template<class Scalar>
class complex {
    
  public:
    typedef Scalar value_type;

  private: 
    value_type re,im;      

  public:

    KOKKOS_INLINE_FUNCTION complex();
    KOKKOS_INLINE_FUNCTION complex(const complex& src);
    KOKKOS_INLINE_FUNCTION complex(const volatile complex& src);

    template<class T>
    KOKKOS_INLINE_FUNCTION complex(const T& re);
    
    template <class T1, class T2>
    KOKKOS_INLINE_FUNCTION complex(const T1& re, const T2& im)
    
    template<class T>
    complex(const std::complex<T>& src);

    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const volatile complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const complex<T>& src) volatile;
    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const volatile complex<T>& src) volatile;

    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const T& re);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const T& re) volatile;

    template<class T>
    KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const std::complex<T>& src);
    template<class T>

    operator std::complex<Scalar>() const;

    KOKKOS_INLINE_FUNCTION RealType& imag();
    KOKKOS_INLINE_FUNCTION RealType& real();
    KOKKOS_INLINE_FUNCTION const RealType imag() const;
    KOKKOS_INLINE_FUNCTION const RealType real() const;
    KOKKOS_INLINE_FUNCTION volatile RealType& imag() volatile;
    KOKKOS_INLINE_FUNCTION volatile RealType& real() volatile;
    KOKKOS_INLINE_FUNCTION const RealType imag() const volatile;
    KOKKOS_INLINE_FUNCTION const RealType real() const volatile;
    KOKKOS_INLINE_FUNCTION void imag(RealType v);
    KOKKOS_INLINE_FUNCTION void real(RealType v);

    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator += (const complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator += (const volatile complex<T>& src) volatile;
    template<class T>
    complex& operator += (const std::complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator += (const T& real);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator += (const volatile T& real) real;

    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator -= (const complex<T>& src);
    template<class T>
    complex& operator -= (const std::complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator -= (const T& real);

    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator *= (const complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator *= (const volatile complex<T>& src) volatile;
    template<class T>
    complex& operator *= (const std::complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator *= (const T& real);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator *= (const volatile T& real) real;

    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator /= (const complex<T>& src);
    template<class T>
    complex& operator /= (const std::complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator /= (const T& real);

    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator == (const complex<T>& src);
    template<class T>
    complex& operator == (const std::complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator == (const T& real);

    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator != (const complex<T>& src);
    template<class T>
    complex& operator != (const std::complex<T>& src);
    template<class T>
    KOKKOS_INLINE_FUNCTION complex& operator != (const T& real);
};

Public Class Members

Typedefs

  • value_type: The scalar type of the real and the imaginary component.

Constructors

  •    KOKKOS_INLINE_FUNCTION complex();

    Default constructor. Initializes the re and im with value_type().

  •    KOKKOS_INLINE_FUNCTION complex(const complex& src);

    Copy constructor. Sets re = src.real() and im = src.imag().

  •    KOKKOS_INLINE_FUNCTION complex(const volatile complex& src);

    Copy constructor. Sets re = src.real() and im = src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex(const T& real);

    Constructor from a real number. Sets re = real and im = value_type().

  •    template <class T1, class T2>
   KOKKOS_INLINE_FUNCTION complex(const T1& real, const T2& imag)

    Constructor from real numbers. Sets re = real and im = imag.

  •    template<class T>
   complex(const std::complex<T>& src);

    Copy constructor. Sets re = src.real() and im = src.imag().

Assignment and conversion

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const complex<T>& src);

    Sets re = src.real() and im = src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const volatile complex<T>& src);

    Sets re = src.real() and im = src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const complex<T>& src) volatile;

    Sets re = src.real() and im = src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const volatile complex<T>& src) volatile;

    Sets re = src.real() and im = src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const T& re);

    Sets re = src.real() and im = value_type().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const T& re) volatile;

    Sets re = src.real() and im = value_type().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex<Scalar>& operator= (const std::complex<T>& src);

    Sets re = src.real() and im = src.imag().

  •    operator std::complex<value_type>() const;

    Returns std::complex<value_type>(re,im).

Functions

  •    KOKKOS_INLINE_FUNCTION RealType& imag();

    Return im.

  •    KOKKOS_INLINE_FUNCTION RealType& real();

    Return re.

  •    KOKKOS_INLINE_FUNCTION const RealType imag() const;

    Return im.

  •    KOKKOS_INLINE_FUNCTION const RealType real() const;

    Return re.

  •    KOKKOS_INLINE_FUNCTION volatile RealType& imag() volatile;

    Return im.

  •    KOKKOS_INLINE_FUNCTION volatile RealType& real() volatile;

    Return re.

  •    KOKKOS_INLINE_FUNCTION const RealType imag() const volatile;

    Return im.

  •    KOKKOS_INLINE_FUNCTION const RealType real() const volatile;

    Return re.

  •    KOKKOS_INLINE_FUNCTION void imag(RealType v);

    Sets im = v.

  •    KOKKOS_INLINE_FUNCTION void real(RealType v);

    Sets re = v.

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator += (const complex<T>& src);

    Executes re += src.real(); im += src.imag(); return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator += (const volatile complex<T>& src) volatile;

    Executes re += src.real(); im += src.imag(); return *this;

  •    template<class T>
   complex& operator += (const std::complex<T>& src);

    Executes re += src.real(); im += src.imag(); return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator += (const T& real);

    Executes re += real; return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator += (const volatile T& real) real;

    Executes re += real; return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator -= (const complex<T>& src);

    Executes re -= src.real(); im -= src.imag(); return *this;

  •    template<class T>
   complex& operator -= (const std::complex<T>& src);

    Executes re -= src.real(); im -= src.imag(); return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator -= (const T& real);

    Executes re -= real; return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator *= (const complex<T>& src);

    Multiplies the current complex number with the complex number src.

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator *= (const volatile complex<T>& src) volatile;

    Multiplies the current complex number with the complex number src.

  •    template<class T>
   complex& operator *= (const std::complex<T>& src);

    Multiplies the current complex number with the complex number src.

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator *= (const T& real);

    Executes re *= real; im *= real; return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator *= (const volatile T& real) real;

    Executes re *= real; im *= real; return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator /= (const complex<T>& src);

    Divides the current complex number with the complex number src.

  •    template<class T>
   complex& operator /= (const std::complex<T>& src);

    Divides the current complex number with the complex number src.

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator /= (const T& real);

    Executes re /= real; im /= real; return *this;

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator == (const complex<T>& src);

    Returns re == src.real() && im == src.imag().

  •    template<class T>
   complex& operator == (const std::complex<T>& src);

    Returns re == src.real() && im == src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator == (const T& real);

    Returns re == src.real() && im == value_type().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator != (const complex<T>& src);

    Returns re != src.real() || im != src.imag().

  •    template<class T>
   complex& operator != (const std::complex<T>& src);

    Returns re != src.real() || im != src.imag().

  •    template<class T>
   KOKKOS_INLINE_FUNCTION complex& operator != (const T& real);

    Returns re != src.real() || im != value_type().

Home:

Programming Guide

Content: Core

  1. Introduction
  2. Machine Model
  3. Programming Model
  4. Compiling
  5. Initialization
  6. View
  7. Parallel Dispatch
  8. Hierarchical Parallelism
  9. Custom Reductions
  10. Atomic Operations
  11. Subviews
  12. Interoperability
  13. Kokkos and Virtual Functions

Content: Containers

  1. Dual View
  2. Dynamic Rank View
  3. Dynamic Length View
  4. Offset View
  5. Unordered Map

Content: Algorithms

  1. Sorting
  2. Random Numbers
  3. Iterators
  4. Std Algorithms
    1. NonModSequenceOps
    2. ModSeqOps
    3. PartioningOps

API Reference

Content: Alphabetical

Content: Core

  1. Initialization and Finalization
  2. View
  3. Data Parallelism
  4. Execution Policies
  5. Spaces
  6. Task Parallelism
  7. Utilities
  8. STL Compatibility
  9. Numerics
  10. Detection Idiom

Content: Containers

Content: Algorithms

  1. Sort
  2. Random Number

Use Cases

  1. MPI Halo Exchange
  2. ScatterView Average To Nodes
  3. Tightly nested loops
  4. Using Virtual Functions
  5. Classes and Functors
  6. Overlapping Host and Device work
  7. Tasking
  8. Fortran Interop
  9. SoA and AoSoA with Cabana

A Guide to Kokkos Testing and Issue Tracking

  1. Requirement Tracking
  2. Testing Processes
  3. Testing Workflow Components
  4. Kokkos Testing
  5. Testing Process Details
Clone this wiki locally