Ginkgo Generated from branch based on main. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches

This LinOp implements a 2D Fourier matrix using the FFT algorithm. More...

#include <ginkgo/core/matrix/fft.hpp>

Inheritance diagram for gko::matrix::Fft2:
[legend]
Collaboration diagram for gko::matrix::Fft2:
[legend]

Public Types

using value_type = std::complex<double>
using index_type = int64
using transposed_type = Fft2
Public Types inherited from gko::EnablePolymorphicAssignment< Fft2 >
using result_type
Public Types inherited from gko::ConvertibleTo< Fft2 >
using result_type

Public Member Functions

std::unique_ptr< LinOptranspose () const override
 Returns a LinOp representing the transpose of the Transposable object.
std::unique_ptr< LinOpconj_transpose () const override
 Returns a LinOp representing the conjugate transpose of the Transposable object.
void write (matrix_data< std::complex< float >, int32 > &data) const override
void write (matrix_data< std::complex< float >, int64 > &data) const override
void write (matrix_data< std::complex< double >, int32 > &data) const override
void write (matrix_data< std::complex< double >, int64 > &data) const override
dim< 2 > get_fft_size () const
bool is_inverse () const
Public Member Functions inherited from gko::EnableLinOp< Fft2 >
const Fft2 * apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< Fft2, LinOp >
std::unique_ptr< Fft2 > create_default (std::shared_ptr< const Executor > exec) const
std::unique_ptr< Fft2 > clone (std::shared_ptr< const Executor > exec) const
Fft2 * copy_from (const PolymorphicObject *other)
Fft2 * move_from (ptr_param< PolymorphicObject > other)
Fft2 * clear ()
Public Member Functions inherited from gko::LinOp
LinOpapply (ptr_param< const LinOp > b, ptr_param< LinOp > x)
 Applies a linear operator to a vector (or a sequence of vectors).
const LinOpapply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
LinOpapply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x)
 Performs the operation x = alpha * op(b) + beta * x.
const LinOpapply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const
const dim< 2 > & get_size () const noexcept
 Returns the size of the operator.
virtual bool apply_uses_initial_guess () const
 Returns true if the linear operator uses the data given in x as an initial guess.
LinOpoperator= (const LinOp &)=default
 Copy-assigns a LinOp.
LinOpoperator= (LinOp &&other)
 Move-assigns a LinOp.
 LinOp (const LinOp &)=default
 Copy-constructs a LinOp.
 LinOp (LinOp &&other)
 Move-constructs a LinOp.
Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< LinOp >
std::unique_ptr< LinOpcreate_default (std::shared_ptr< const Executor > exec) const
std::unique_ptr< LinOpclone (std::shared_ptr< const Executor > exec) const
LinOpcopy_from (const PolymorphicObject *other)
LinOpmove_from (ptr_param< PolymorphicObject > other)
LinOpclear ()
Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObjectoperator= (const PolymorphicObject &)
std::unique_ptr< PolymorphicObjectcreate_default (std::shared_ptr< const Executor > exec) const
 Creates a new "default" object of the same dynamic type as this object.
std::unique_ptr< PolymorphicObjectcreate_default () const
 Creates a new "default" object of the same dynamic type as this object.
std::unique_ptr< PolymorphicObjectclone (std::shared_ptr< const Executor > exec) const
 Creates a clone of the object.
std::unique_ptr< PolymorphicObjectclone () const
 Creates a clone of the object.
PolymorphicObjectcopy_from (const PolymorphicObject *other)
 Copies another object into this object.
template<typename Derived, typename Deleter>
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, PolymorphicObject > * copy_from (std::unique_ptr< Derived, Deleter > &&other)
 Moves another object into this object.
template<typename Derived, typename Deleter>
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, PolymorphicObject > * copy_from (const std::unique_ptr< Derived, Deleter > &other)
 Copies another object into this object.
PolymorphicObjectcopy_from (const std::shared_ptr< const PolymorphicObject > &other)
 Copies another object into this object.
PolymorphicObjectmove_from (ptr_param< PolymorphicObject > other)
 Moves another object into this object.
PolymorphicObjectclear ()
 Transforms the object into its default state.
std::shared_ptr< const Executorget_executor () const noexcept
 Returns the Executor of the object.
Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void add_logger (std::shared_ptr< const Logger > logger) override
 Adds a new logger to the list of subscribed loggers.
void remove_logger (const Logger *logger) override
 Removes a logger from the list of subscribed loggers.
const std::vector< std::shared_ptr< const Logger > > & get_loggers () const override
 Returns the vector containing all loggers registered at this object.
void clear_loggers () override
 Remove all loggers registered at this object.
Public Member Functions inherited from gko::log::Loggable
void remove_logger (ptr_param< const Logger > logger)
Public Member Functions inherited from gko::EnablePolymorphicAssignment< Fft2 >
void convert_to (result_type *result) const override
void move_to (result_type *result) override

Static Public Member Functions

static std::unique_ptr< Fft2create (std::shared_ptr< const Executor > exec)
 Creates an empty Fourier matrix.
static std::unique_ptr< Fft2create (std::shared_ptr< const Executor > exec, size_type size)
 Creates an Fourier matrix with the given dimensions.
static std::unique_ptr< Fft2create (std::shared_ptr< const Executor > exec, size_type size1, size_type size2, bool inverse=false)
 Creates an Fourier matrix with the given dimensions.

Friends

class EnablePolymorphicObject< Fft2, LinOp >

Detailed Description

This LinOp implements a 2D Fourier matrix using the FFT algorithm.

For indexing purposes, the first dimension is the major axis.

It implements complex-to-complex forward and inverse FFT.

For a power-of-two sizes $n_1, n_2$ with corresponding root of unity $\omega = e^{-2\pi i / (n_1 n_2)}$ for forward DFT and $\omega = e^{2 \pi i / (n_1 n_2)}$ for inverse DFT it computes

\[    x_{k_1 n_2 + k_2} = \sum_{i_1=0}^{n_1-1} \sum_{i_2=0}^{n_2-1}
                          \omega^{i_1 k_1 + i_2 k_2} b_{i_1 n_2 + i_2}
\]

without normalization factors.

The Reference and OpenMP implementations support only power-of-two input sizes, as they use the Radix-2 algorithm by J. W. Cooley and J. W. Tukey, "An Algorithm for the Machine Calculation of Complex Fourier Series," Mathematics of Computation, vol. 19, no. 90, pp. 297–301, 1965, doi: 10.2307/2003354. The CUDA and HIP implementations use cuSPARSE/hipSPARSE with full support for non-power-of-two input sizes and special optimizations for products of small prime powers.

Member Function Documentation

◆ conj_transpose()

std::unique_ptr< LinOp > gko::matrix::Fft2::conj_transpose ( ) const
overridevirtual

Returns a LinOp representing the conjugate transpose of the Transposable object.

Returns
a pointer to the new conjugate transposed object

Implements gko::Transposable.

◆ create() [1/3]

std::unique_ptr< Fft2 > gko::matrix::Fft2::create ( std::shared_ptr< const Executor > exec)
static

Creates an empty Fourier matrix.

Parameters
execExecutor associated to the matrix
Returns
A smart pointer to the newly created matrix.

◆ create() [2/3]

std::unique_ptr< Fft2 > gko::matrix::Fft2::create ( std::shared_ptr< const Executor > exec,
size_type size )
static

Creates an Fourier matrix with the given dimensions.

Parameters
sizesize of both FFT dimensions
Returns
A smart pointer to the newly created matrix.

◆ create() [3/3]

std::unique_ptr< Fft2 > gko::matrix::Fft2::create ( std::shared_ptr< const Executor > exec,
size_type size1,
size_type size2,
bool inverse = false )
static

Creates an Fourier matrix with the given dimensions.

Parameters
size1size of the first FFT dimension
size2size of the second FFT dimension
inversetrue to compute an inverse DFT instead of a normal DFT
Returns
A smart pointer to the newly created matrix.

References gko::matrix::inverse.

◆ transpose()

std::unique_ptr< LinOp > gko::matrix::Fft2::transpose ( ) const
overridevirtual

Returns a LinOp representing the transpose of the Transposable object.

Returns
a pointer to the new transposed object

Implements gko::Transposable.


The documentation for this class was generated from the following file: