Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Native/FFT/IILFFT.cs @ 10903

Last change on this file since 10903 was 9102, checked in by gkronber, 12 years ago

#1967: ILNumerics source for experimentation
File size: 9.0 KB
Line 
1///
2///    This file is part of ILNumerics Community Edition.
3///
4///    ILNumerics Community Edition - high performance computing for applications.
5///    Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
6///
7///    ILNumerics Community Edition is free software: you can redistribute it and/or modify
8///    it under the terms of the GNU General Public License version 3 as published by
9///    the Free Software Foundation.
10///
11///    ILNumerics Community Edition is distributed in the hope that it will be useful,
12///    but WITHOUT ANY WARRANTY; without even the implied warranty of
13///    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14///    GNU General Public License for more details.
15///
16///    You should have received a copy of the GNU General Public License
17///    along with ILNumerics Community Edition. See the file License.txt in the root
18///    of your distribution package. If not, see <http://www.gnu.org/licenses/>.
19///
20///    In addition this software uses the following components and/or licenses:
21///
22///    =================================================================================
23///    The Open Toolkit Library License
24///   
25///    Copyright (c) 2006 - 2009 the Open Toolkit library.
26///   
27///    Permission is hereby granted, free of charge, to any person obtaining a copy
28///    of this software and associated documentation files (the "Software"), to deal
29///    in the Software without restriction, including without limitation the rights to
30///    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
31///    the Software, and to permit persons to whom the Software is furnished to do
32///    so, subject to the following conditions:
33///
34///    The above copyright notice and this permission notice shall be included in all
35///    copies or substantial portions of the Software.
36///
37///    =================================================================================
38///   
39
40using System;
41using ILNumerics;
42
43namespace ILNumerics.Native {
44
45    /// <summary>
46    /// Interface for all FFT methods supported
47    /// </summary>
48    public interface IILFFT {
49        /// <summary>
50        /// performs backward n-dimensional fft
51        /// </summary>
52        /// <param name="A">input array</param>
53        /// <param name="nDims">number of dimensions of fft</param>
54        /// <returns>result, same size as A</returns>
55        ILRetArray<complex> FFTBackward(ILInArray<complex> A, int nDims);
56        /// <summary>
57        /// performs backward n-dimensional fft
58        /// </summary>
59        /// <param name="A">input array</param>
60        /// <param name="nDims">number of dimensions of fft</param>
61        /// <returns>result, same size as A</returns>
62        ILRetArray<fcomplex> FFTBackward(ILInArray<fcomplex> A, int nDims);
63        /// <summary>
64        /// performs backward 1-dimensional fft
65        /// </summary>
66        /// <param name="A">input array</param>
67        /// <param name="dim">dimension to perform fft along</param>
68        /// <returns>result, same size as A</returns>
69        ILRetArray<fcomplex> FFTBackward1D(ILInArray<fcomplex> A, int dim);
70        /// <summary>
71        /// performs backward 1-dimensional fft
72        /// </summary>
73        /// <param name="A">input array</param>
74        /// <param name="dim">dimension to perform fft along</param>
75        /// <returns>result, same size as A</returns>
76        ILRetArray<complex> FFTBackward1D(ILInArray<complex> A, int dim);
77        /// <summary>
78        /// performs backward n-dimensional fft on hermitian sequence
79        /// </summary>
80        /// <param name="A">input array</param>
81        /// <param name="nDims">number of dimensions of fft</param>
82        /// <returns>result, same size as A</returns>
83        /// <remarks>This function brings increased performance if the implementation supports it.
84        /// If not, the method will be implemented by repeated calls of (inplace) 1D fft.</remarks>
85        ILRetArray<float> FFTBackwSym(ILInArray<fcomplex> A, int nDims);
86        /// <summary>
87        /// performs backward n-dimensional fft on hermitian sequence
88        /// </summary>
89        /// <param name="A">input array</param>
90        /// <param name="nDims">number of dimensions of fft</param>
91        /// <returns>result, same size as A</returns>
92        /// <remarks>This function brings increased performance if the implementation supports it.
93        /// If not, the method will be implemented by repeated calls of (inplace) 1D fft.</remarks>
94        ILRetArray<double> FFTBackwSym(ILInArray<complex> A, int nDims);
95        /// <summary>
96        /// performs backward 1-dimensional fft on hermitian sequence
97        /// </summary>
98        /// <param name="A">input array</param>
99        /// <param name="dim">dimension to perform fft along</param>
100        /// <returns>result, same size as A</returns>
101        /// <remarks>This function brings increased performance if the implementation supports it.
102        /// If not, the method will be implemented by repeated calls of (inplace) 1D fft.</remarks>
103        ILRetArray<float> FFTBackwSym1D(ILInArray<fcomplex> A, int dim);
104        /// <summary>
105        /// performs backward 1-dimensional fft on hermitian sequence
106        /// </summary>
107        /// <param name="A">input array</param>
108        /// <param name="dim">dimension to perform fft along</param>
109        /// <returns>result, same size as A</returns>
110        /// <remarks>This function brings increased performance if the implementation supports it.
111        /// If not, the method will be implemented by repeated calls of (inplace) 1D fft.</remarks>
112        ILRetArray<double> FFTBackwSym1D(ILInArray<complex> A, int dim);
113        /// <summary>
114        /// performs n-dimensional fft
115        /// </summary>
116        /// <param name="A">input array</param>
117        /// <param name="nDims">number of dimension of fft</param>
118        /// <returns>result, same size as A</returns>
119        ILRetArray<fcomplex> FFTForward(ILInArray<fcomplex> A, int nDims);
120        /// <summary>
121        /// performs n-dimensional fft
122        /// </summary>
123        /// <param name="A">input array</param>
124        /// <param name="nDims">number of dimension of fft</param>
125        /// <returns>result, same size as A</returns>
126        ILRetArray<complex> FFTForward(ILInArray<double> A, int nDims);
127        /// <summary>
128        /// performs n-dimensional fft
129        /// </summary>
130        /// <param name="A">input array</param>
131        /// <param name="nDims">number of dimension of fft</param>
132        /// <returns>result, same size as A</returns>
133        ILRetArray<complex> FFTForward(ILInArray<complex> A, int nDims);
134        /// <summary>
135        /// performs n-dimensional fft
136        /// </summary>
137        /// <param name="A">input array</param>
138        /// <param name="nDims">number of dimension of fft</param>
139        /// <returns>result, same size as A</returns>
140        ILRetArray<fcomplex> FFTForward(ILInArray<float> A, int nDims);
141        /// <summary>
142        /// performs 1-dimensional fft
143        /// </summary>
144        /// <param name="A">input array</param>
145        /// <param name="dim">dimension to perform fft along</param>
146        /// <returns>result, same size as A</returns>
147        ILRetArray<complex> FFTForward1D(ILInArray<complex> A, int dim);
148        /// <summary>
149        /// performs 1-dimensional fft
150        /// </summary>
151        /// <param name="A">input array</param>
152        /// <param name="dim">dimension to perform fft along</param>
153        /// <returns>result, same size as A</returns>
154        ILRetArray<complex> FFTForward1D(ILInArray<double> A, int dim);
155        /// <summary>
156        /// performs 1-dimensional fft
157        /// </summary>
158        /// <param name="A">input array</param>
159        /// <param name="dim">dimension to perform fft along</param>
160        /// <returns>result, same size as A</returns>
161        ILRetArray<fcomplex> FFTForward1D(ILInArray<fcomplex> A, int dim);
162        /// <summary>
163        /// performs 1-dimensional fft
164        /// </summary>
165        /// <param name="A">input array</param>
166        /// <param name="dim">dimension to perform fft along</param>
167        /// <returns>result, same size as A</returns>
168        ILRetArray<fcomplex> FFTForward1D(ILInArray<float> A, int dim);
169        /// <summary>
170        /// true, if the implementation caches plans between subsequent calls
171        /// </summary>
172        bool CachePlans { get; }
173        /// <summary>
174        /// Clear all currently cached plans
175        /// </summary>
176        void FreePlans();
177        /// <summary>
178        /// true, if the implementation efficiently transforms from/to hermitian sequences (hermitian symmetry).
179        /// </summary>
180        /// <remarks>If this property returns 'true', the implementation brings increased performance.
181        /// If not, the symmetry methods will bring no performance advantage over the 1D transforms. </remarks>
182        bool SpeedyHermitian { get; }
183
184    }
185}
Note: See TracBrowser for help on using the repository browser.