FourierTransform.h

Go to the documentation of this file.

// -*- c++ -*-
/*
 * Copyright (c) 2010-2012, Jim Bosch
 * All rights reserved.
 *
 * ndarray is distributed under a simple BSD-like license;
 * see the LICENSE file that should be present in the root
 * of the source distribution, or alternately available at:
 * https://github.com/ndarray/ndarray
 */
#ifndef NDARRAY_FFT_FourierTransform_h_INCLUDED
#define NDARRAY_FFT_FourierTransform_h_INCLUDED
 
#include <boost/noncopyable.hpp>
 
#include "ndarray.h"
#include "ndarray/fft/FourierTraits.h"
 
namespace ndarray {
 
template <typename T, int N>
class FourierTransform : private boost::noncopyable {
    BOOST_STATIC_ASSERT((!boost::is_const<T>::value));
public:
    
    typedef boost::shared_ptr<FourierTransform> Ptr;
 
    typedef typename detail::FourierTraits<T>::ElementX ElementX; 
    typedef typename detail::FourierTraits<T>::ElementK ElementK; 
 
    typedef Vector<Size,N> Index; 
    typedef Array<ElementX,N,N> ArrayX; 
    typedef Array<ElementK,N,N> ArrayK; 
    typedef Vector<Size,N+1> MultiplexIndex; 
    typedef Array<ElementX,N+1,N+1> MultiplexArrayX; 
    typedef Array<ElementK,N+1,N+1> MultiplexArrayK; 
 
    static Ptr planForward(
        Index const & shape,  
        ArrayX & x,           
        ArrayK & k            
    );
 
    static Ptr planInverse(
        Index const & shape,  
        ArrayK & k,           
        ArrayX & x            
    );
 
    static Ptr planMultiplexForward(
        MultiplexIndex const & shape, 
        MultiplexArrayX & x,          
        MultiplexArrayK & k           
    );
 
    static Ptr planMultiplexInverse(
        MultiplexIndex const & shape, 
        MultiplexArrayK & k,          
        MultiplexArrayX & x           
    );
 
    template <int M>
    static Array<ElementX,M,M> initializeX(Vector<Size,M> const & shape);
 
    template <int M>
    static Array<ElementK,M,M> initializeK(Vector<Size,M> const & shape);
 
    template <int M>
    static void initialize(Vector<Size,M> const & shape, Array<ElementX,M,M> & x, Array<ElementK,M,M> & k);
 
    void execute();
 
    ~FourierTransform();
 
private:
    typedef boost::shared_ptr<ElementX> OwnerX;
    typedef boost::shared_ptr<ElementK> OwnerK;
 
    FourierTransform(void * plan, Manager::Ptr const & x, Manager::Ptr const & k)
        : _plan(plan), _x(x), _k(k) {}
 
    void * _plan; // 'void' so we don't have to include fftw3.h in the header file
    Manager::Ptr _x;
    Manager::Ptr _k;
};
 
} // namespace ndarray
 
#endif // !NDARRAY_FFT_FourierTransform_h_INCLUDED