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 1D Fourier matrix using the FFT algorithm. More...

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

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

Public Types

using value_type = std::complex<double>
using index_type = int64
using transposed_type = Fft
Public Types inherited from gko::EnablePolymorphicAssignment< Fft >
using result_type
Public Types inherited from gko::ConvertibleTo< Fft >
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< 1 > get_fft_size () const
bool is_inverse () const
Public Member Functions inherited from gko::EnableLinOp< Fft >
const Fft * apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< Fft, LinOp >
std::unique_ptr< Fft > create_default (std::shared_ptr< const Executor > exec) const
std::unique_ptr< Fft > clone (std::shared_ptr< const Executor > exec) const
Fft * copy_from (const PolymorphicObject *other)
Fft * move_from (ptr_param< PolymorphicObject > other)
Fft * 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< Fft >
void convert_to (result_type *result) const override
void move_to (result_type *result) override

Static Public Member Functions

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

Friends

class EnablePolymorphicObject< Fft, LinOp >

Detailed Description

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

It implements forward and inverse DFT.

For a power-of-two size n with corresponding root of unity $\omega = e^{-2\pi i / n}$ for forward DFT and $\omega = e^{2 \pi i / n}$ for inverse DFT it computes

\[    x_k = \sum_{j=0}^{n-1} \omega^{jk} b_j
\]

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::Fft::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/2]

std::unique_ptr< Fft > gko::matrix::Fft::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/2]

std::unique_ptr< Fft > gko::matrix::Fft::create ( std::shared_ptr< const Executor > exec,
size_type size = 0,
bool inverse = false )
static

Creates an Fourier matrix with the given dimensions.

Parameters
sizesize of the matrix
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::Fft::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: