mirrors
/
Labrador
mirror of https://github.com/EspoTek/Labrador.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Vincenzo's FFT patch

This commit is contained in:
Vincenzo Petrolo 2021-05-08 01:06:44 +02:00 committed by Chris Esposito
parent ec7f08ab8a
commit aa193ec479
57 changed files with 18025 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored Normal file
View File

@ -0,0 +1,3 @@
[submodule "SlidingDFT"]
path = SlidingDFT
url = https://github.com/bronsonp/SlidingDFT.git

2
.travis.yml
View File

@ -42,6 +42,8 @@ install:
if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
brew install qt5
brew link qt5 --force
brew instal libomp
brew install fftw
#brew install libusb
#brew install wget
# Linux

19
Desktop_Interface/Labrador.pro
View File

@ -43,7 +43,8 @@ SOURCES += main.cpp\
daqform.cpp \
daqloadprompt.cpp \
isobuffer_file.cpp \
i2cdecoder.cpp
i2cdecoder.cpp \
asyncdft.cpp
HEADERS += mainwindow.h \
functiongencontrol.h \
@ -60,7 +61,8 @@ HEADERS += mainwindow.h \
daqform.h \
daqloadprompt.h \
isobuffer_file.h \
i2cdecoder.h
i2cdecoder.h \
asyncdft.h
android:{
FORMS += ui_files_mobile/mainwindow.ui \
@ -103,10 +105,15 @@ win32{
CONFIG(release, debug|release): LIBS += -L$$PWD/build_win/libusbk/bin/lib/x86/ -llibusbK
else:CONFIG(debug, debug|release): LIBS += -L$$PWD/build_win/libusbk/bin/lib/x86/ -llibusbK
DEFINES += "WINDOWS_32_BIT"
INCLUDEPATH += $$PWD/build_win/fftw/x86
LIBS += -L$$PWD/build_win/fftw/x86 -llibfftw3-3
} else {
message("Building for Windows (x64)")
CONFIG(release, debug|release): LIBS += -L$$PWD/build_win/libusbk/bin/lib/amd64/ -llibusbK
else:CONFIG(debug, debug|release): LIBS += -L$$PWD/build_win/libusbk/bin/lib/amd64/ -llibusbK
INCLUDEPATH += $$PWD/build_win/fftw/x64
LIBS += -L$$PWD/build_win/fftw/x64 -llibfftw3-3
DEFINES += "WINDOWS_64_BIT"
}
INCLUDEPATH += $$PWD/build_win/libusbk/includes
@ -120,6 +127,7 @@ win32{
unix:!android:!macx{
INCLUDEPATH += $$PWD/build_linux
LIBS += -lfftw3
contains(QT_ARCH, arm) {
message("Building for Raspberry Pi")
#libusb include
@ -350,3 +358,10 @@ DISTFILES += \
build_android/package_source/gradle/wrapper/gradle-wrapper.properties \
build_android/package_source/gradlew.bat \
build_android/package_source/res/xml/device_filter.xml
# Vincenzo added these to get multithreading on Unix fftw
unix: LIBS += -lomp
unix: LIBS += -lfftw3f_omp
unix: LIBS += -lfftw3_threads
macx: INCLUDEPATH += /usr/local/include
macx: LIBS+= -L/usr/local/lib

153
Desktop_Interface/asyncdft.cpp Normal file
View File

@ -0,0 +1,153 @@
#include "asyncdft.h"
#include <iostream>
#include <math.h>
#include "isobuffer.h"
#define DBG 0
AsyncDFT::AsyncDFT()
{
/*Creating the main thread, which will manage everything*/
stopping = false;
/*Data is not valid until we get n_samples into the window*/
data_valid = false;
/*Samples counter*/
samples_count=0;
/*Initializing time domain window to 0s*/
/*FFTW3 inits*/
fftw_init_threads();
fftw_plan_with_nthreads(omp_get_max_threads() * 2);
#if DBG
std::cout << "Starting with " << omp_get_max_threads() << "threads" << std::endl;
#endif
out_buffer = fftw_alloc_complex(n_samples);
plan = fftw_plan_dft_r2c_1d(n_samples,in_buffer, out_buffer,0);
}
AsyncDFT::~AsyncDFT()
{
#if DBG
stopping = true;
mtx_samples.unlock(); //Unlock thread manager if blocked and waiting for more samples
while (!manager.joinable());
manager.join();
std::cout << "Joined manager thread [DESTRUCTOR]" << std::endl;
#endif
}
void AsyncDFT::threadManager()
{
while(stopping == false) {
/*Calculating DFT if there are new samples, otherwise DFT would be the same*/
if (samples_count >= n_samples) {
mtx_samples.lock();
if (!window.empty()) {
window.pop_front();
}
short tmp = pending_samples.front();
pending_samples.pop();
window.push_back(tmp);
/*Data is now valid*/
data_valid = true;
mtx_samples.unlock();
}
}
}
void AsyncDFT::addSample(short sample)
{
/*Adding to the waiting jobs the sample*/
if (samples_count >= n_samples) {
/*Shifting window by 1 by removing first element and adding an element to the end*/
window.pop_front();
window.push_back(sample);
samples_count = n_samples;
data_valid = true;
} else {
/*Fill the window*/
window.push_back(sample);
}
/*Updating the number of samples*/
samples_count++;
}
QVector<double> AsyncDFT::getPowerSpectrum(QVector<double> input)
{
/*Before doing anything, check if sliding DFT is computable*/
if (data_valid == false) {
throw std::exception();
}
for(int i = 0; i < n_samples; i++) {
in_buffer[i] = input[i];
}
/*Zero-padding for better resolution of DFT*/
QVector<double> amplitude(n_samples/2+1,0);
maximum = -1;
/*Executing FFTW plan*/
fftw_execute(plan);
amplitude[0] = sqrt(out_buffer[0][0]*out_buffer[0][0] + out_buffer[0][1]*out_buffer[0][1]); /* DC component */
maximum = (amplitude[0] > maximum ) ? amplitude[0] : maximum;
for (int k = 1; k < (n_samples+1)/2; ++k) { /* (k < N/2 rounded up) */
amplitude[k] = sqrt(out_buffer[k][0]*out_buffer[k][0] + out_buffer[k][1]*out_buffer[k][1]);
maximum = (amplitude[k] > maximum ) ? amplitude[k] : maximum;
}
if (n_samples % 2 == 0) { /* N is even */
amplitude[n_samples/2] = sqrt(out_buffer[n_samples/2][0]*out_buffer[n_samples/2][0]); /* Nyquist freq. */
maximum = (amplitude[n_samples/2] > maximum ) ? amplitude[n_samples/2] : maximum;
}
return amplitude;
}
QVector<double> AsyncDFT::getFrequenciyWindow(int samplesPerSeconds)
{
double delta_freq = ((double) samplesPerSeconds)/ ((double) n_samples);
QVector<double> f(n_samples/2 + 1);
for (int i = 0; i < n_samples/2 + 1; i++) {
f[i] = i*delta_freq;
}
return f;
}
std::unique_ptr<short[]> AsyncDFT::getWindow()
{
std::unique_ptr<short[]> readData = std::make_unique<short[]>(n_samples);
int i = 0;
for (auto& item : window) {
readData[i] = item;
i++;
}
return readData;
}
QVector<double> AsyncDFT::normalizeDFT(double e_maximum, QVector<double> dft)
{
double u_maximum;
/*Normalize with the greater maximum*/
if (this->maximum > e_maximum) {
u_maximum = this->maximum;
} else {
u_maximum = e_maximum;
}
for(int i=0; i < dft.size(); i++) {
dft[i] /= u_maximum;
dft[i] *= 100;
}
return dft;
}

57
Desktop_Interface/asyncdft.h Normal file
View File

@ -0,0 +1,57 @@
#ifndef ASYNCDFT_H
#define ASYNCDFT_H
#include <thread>
#include <QVector>
#include <mutex>
#include <queue>
#include <omp.h>
#include <list>
#include <fftw3.h>
class AsyncDFT
{
public:
AsyncDFT();
~AsyncDFT();
static const int n_samples = 1<<17;
/* Raise exception if not ready yet*/
QVector<double> getPowerSpectrum(QVector<double> input);
QVector<double> getFrequenciyWindow(int samplesPerSeconds);
/*Add a sample to the time domain samples*/
void addSample(short sample);
/*Return the window of samples*/
std::unique_ptr<short[]> getWindow();
/*Normalize the DFT*/
QVector<double> normalizeDFT(double e_maximum, QVector<double> dft);
private:
/*Thread manager method*/
void threadManager(); //threaded
/*Shifts left the window by 1*/
void shift();
public:
/*Maximum power value obtained from power spectrum*/
double maximum = -1;
private:
/*Time domain window*/
std::list<double> window;
double in_buffer[n_samples];
/*Indicates if dft is available*/
bool data_valid;
/*Number of time domain samples accumulated*/
int samples_count;
/*FFTW3*/
fftw_plan plan;
fftw_complex *out_buffer;
std::mutex mtx_samples;
bool stopping = false;
std::thread manager;
std::queue<short> pending_samples;
};
#endif // ASYNCDFT_H

340
Desktop_Interface/build_win/fftw/x64/COPYING Normal file
View File

@ -0,0 +1,340 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

19
Desktop_Interface/build_win/fftw/x64/COPYRIGHT Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright (c) 2003, 2007-14 Matteo Frigo
* Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/

592
Desktop_Interface/build_win/fftw/x64/NEWS Normal file
View File

@ -0,0 +1,592 @@
FFTW 3.3.5:
* New SIMD support:
- Power8 VSX instructions in single and double precision.
To use, add --enable-vsx to configure.
- Support for AVX2 (256-bit FMA instructions).
To use, add --enable-avx2 to configure.
- Experimental support for AVX512 and KCVI. (--enable-avx512, --enable-kcvi)
This code is expected to work but the FFTW maintainers do not have
hardware to test it.
- Support for AVX128/FMA (for some AMD machines) (--enable-avx128-fma)
- Double precision Neon SIMD for aarch64.
This code is expected to work but the FFTW maintainers do not have
hardware to test it.
- generic SIMD support using gcc vector intrinsics
* Add fftw_make_planner_thread_safe() API
* fix #18 (disable float128 for CUDACC)
* fix #19: missing Fortran interface for fftwq_alloc_real
* fix #21 (don't use float128 on Portland compilers, which pretend to be gcc)
* fix: Avoid segfaults due to double free in MPI transpose
* Special note for distribution maintainers: Although FFTW supports a
zillion SIMD instruction sets, enabling them all at the same time is
a bad idea, because it increases the planning time for minimal gain.
We recommend that general-purpose x86 distributions only enable SSE2
and perhaps AVX. Users who care about the last ounce of performance
should recompile FFTW themselves.
FFTW 3.3.4
* New functions fftw_alignment_of (to check whether two arrays are
equally aligned for the purposes of applying a plan) and fftw_sprint_plan
(to output a description of plan to a string).
* Bugfix in fftw-wisdom-to-conf; thanks to Florian Oppermann for the
bug report.
* Fixed manual to work with texinfo-5.
* Increased timing interval on x86_64 to reduce timing errors.
* Default to Win32 threads, not pthreads, if both are present.
* Various build-script fixes.
FFTW 3.3.3
* Fix deadlock bug in MPI transforms (thanks to Michael Pippig for the
bug report and patch, and to Graham Dennis for the bug report).
* Use 128-bit ARM NEON instructions instead of 64-bits. This change
appears to speed up even ARM processors with a 64-bit NEON pipe.
* Speed improvements for single-precision AVX.
* Speed up planner on machines without "official" cycle counters, such as ARM.
FFTW 3.3.2
* Removed an archaic stack-alignment hack that was failing with
gcc-4.7/i386.
* Added stack-alignment hack necessary for gcc on Windows/i386. We
will regret this in ten years (see previous change).
* Fix incompatibility with Intel icc which pretends to be gcc
but does not support quad precision.
* make libfftw{threads,mpi} depend upon libfftw when using libtool;
this is consistent with most other libraries and simplifies the life
of various distributors of GNU/Linux.
FFTW 3.3.1
* Changes since 3.3.1-beta1:
- Reduced planning time in estimate mode for sizes with large
prime factors.
- Added AVX autodetection under Visual Studio. Thanks Carsten
Steger for submitting the necessary code.
- Modern Fortran interface now uses a separate fftw3l.f03 interface
file for the long double interface, which is not supported by
some Fortran compilers. Provided new fftw3q.f03 interface file
to access the quadruple-precision FFTW routines with recent
versions of gcc/gfortran.
* Added support for the NEON extensions to the ARM ISA. (Note to beta
users: an ARM cycle counter is not yet implemented; please contact
fftw@fftw.org if you know how to do it right.)
* MPI code now compiles even if mpicc is a C++ compiler; thanks to
Kyle Spyksma for the bug report.
FFTW 3.3
* Changes since 3.3-beta1:
- Compiling OpenMP support (--enable-openmp) now installs a
fftw3_omp library, instead of fftw3_threads, so that OpenMP
and POSIX threads (--enable-threads) libraries can be built
and installed at the same time.
- Various minor compilation fixes, corrections of manual typos, and
improvements to the benchmark test program.
* Add support for the AVX extensions to x86 and x86-64. The AVX code
works with 16-byte alignment (as opposed to 32-byte alignment),
so there is no ABI change compared to FFTW 3.2.2.
* Added Fortran 2003 interface, which should be usable on most modern
Fortran compilers (e.g. gfortran) and provides type-checked access
to the the C FFTW interface. (The legacy Fortran-77 interface is
still included also.)
* Added MPI distributed-memory transforms. Compared to 3.3alpha,
the major changes in the MPI transforms are:
- Fixed some deadlock and crashing bugs.
- Added Fortran 2003 interface.
- Added new-array execute functions for MPI plans.
- Eliminated use of large MPI tags, since Cray MPI requires tags < 2^24;
thanks to Jonathan Bentz for the bug report.
- Expanded documentation.
- 'make check' now runs MPI tests
- Some ABI changes - not binary-compatible with 3.3alpha MPI.
* Add support for quad-precision __float128 in gcc 4.6 or later (on x86.
x86-64, and Itanium). The new routines use the fftwq_ prefix.
* Removed support for MIPS paired-single instructions due to lack of
available hardware for testing. Users who want this functionality
should continue using FFTW 3.2.x. (Note that FFTW 3.3 still works
on MIPS; this only concerns special instructions available on some
MIPS chips.)
* Removed support for the Cell Broadband Engine. Cell users should
use FFTW 3.2.x.
* New convenience functions fftw_alloc_real and fftw_alloc_complex
to use fftw_malloc for real and complex arrays without typecasts
or sizeof.
* New convenience functions fftw_export_wisdom_to_filename and
fftw_import_wisdom_from_filename that export/import wisdom
to a file, which don't require you to open/close the file yourself.
* New function fftw_cost to return FFTW's internal cost metric for
a given plan; thanks to Rhys Ulerich and Nathanael Schaeffer for the
suggestion.
* The --enable-sse2 configure flag now works in both double and single
precision (and is equivalent to --enable-sse in the latter case).
* Remove --enable-portable-binary flag: we new produce portable binaries
by default.
* Remove the automatic detection of native architecture flag for gcc
which was introduced in fftw-3.1, since new gcc supports -mtune=native.
Remove the --with-gcc-arch flag; if you want to specify a particlar
arch to configure, use ./configure CC="gcc -mtune=...".
* --with-our-malloc16 configure flag is now renamed --with-our-malloc.
* Fixed build problem failure when srand48 declaration is missing;
thanks to Ralf Wildenhues for the bug report.
* Fixed bug in fftw_set_timelimit: ensure that a negative timelimit
is equivalent to no timelimit in all cases. Thanks to William Andrew
Burnson for the bug report.
* Fixed stack-overflow problem on OpenBSD caused by using alloca with
too large a buffer.
FFTW 3.2.2
* Improve performance of some copy operations of complex arrays on
x86 machines.
* Add configure flag to disable alloca(), which is broken in mingw64.
* Planning in FFTW_ESTIMATE mode for r2r transforms became slower
between fftw-3.1.3 and 3.2. This regression has now been fixed.
FFTW 3.2.1
* Performance improvements for some multidimensional r2c/c2r transforms;
thanks to Eugene Miloslavsky for his benchmark reports.
* Compile with icc on MacOS X, use better icc compiler flags.
* Compilation fixes for systems where snprintf is defined as a macro;
thanks to Marcus Mae for the bug report.
* Fortran documentation now recommends not using dfftw_execute,
because of reports of problems with various Fortran compilers;
it is better to use dfftw_execute_dft etcetera.
* Some documentation clarifications, e.g. of fact that --enable-openmp
and --enable-threads are mutually exclusive (thanks to Long To),
and document slightly odd behavior of plan_guru_r2r in Fortran
(thanks to Alexander Pozdneev).
* FAQ was accidentally omitted from 3.2 tarball.
* Remove some extraneous (harmless) files accidentally included in
a subdirectory of the 3.2 tarball.
FFTW 3.2
* Worked around apparent glibc bug that leads to rare hangs when freeing
semaphores.
* Fixed segfault due to unaligned access in certain obscure problems
that use SSE and multiple threads.
* MPI transforms not included, as they are still in alpha; the alpha
versions of the MPI transforms have been moved to FFTW 3.3alpha1.
FFTW 3.2alpha3
* Performance improvements for sizes with factors of 5 and 10.
* Documented FFTW_WISDOM_ONLY flag, at the suggestion of Mario
Emmenlauer and Phil Dumont.
* Port Cell code to SDK2.1 (libspe2), as opposed to the old libspe1 code.
* Performance improvements in Cell code for N < 32k, thanks to Jan Wagner
for the suggestions.
* Cycle counter for Sun x86_64 compiler, and compilation fix in cycle
counter for AIX/xlc (thanks to Jeff Haferman for the bug report).
* Fixed incorrect type prefix in MPI code that prevented wisdom routines
from working in single precision (thanks to Eric A. Borisch for the report).
* Added 'make check' for MPI code (which still fails in a couple corner
cases, but should be much better than in alpha2).
* Many other small fixes.
FFTW 3.2alpha2
* Support for the Cell processor, donated by IBM Research; see README.Cell
and the Cell section of the manual.
* New 64-bit API: for every "plan_guru" function there is a new "plan_guru64"
function with the same semantics, but which takes fftw_iodim64 instead of
fftw_iodim. fftw_iodim64 is the same as fftw_iodim, except that it takes
ptrdiff_t integer types as parameters, which is a 64-bit type on
64-bit machines. This is only useful for specifying very large transforms
on 64-bit machines. (Internally, FFTW uses ptrdiff_t everywhere
regardless of what API you choose.)
* Experimental MPI support. Complex one- and multi-dimensional FFTs,
multi-dimensional r2r, multi-dimensional r2c/c2r transforms, and
distributed transpose operations, with 1d block distributions.
(This is an alpha preview: routines have not been exhaustively
tested, documentation is incomplete, and some functionality is
missing, e.g. Fortran support.) See mpi/README and also the MPI
section of the manual.
* Significantly faster r2c/c2r transforms, especially on machines with SIMD.
* Rewritten multi-threaded support for better performance by
re-using a fixed pool of threads rather than continually
respawning and joining (which nowadays is much slower).
* Support for MIPS paired-single SIMD instructions, donated by
Codesourcery.
* FFTW_WISDOM_ONLY planner flag, to create plan only if wisdom is
available and return NULL otherwise.
* Removed k7 support, which only worked in 32-bit mode and is
becoming obsolete. Use --enable-sse instead.
* Added --with-g77-wrappers configure option to force inclusion
of g77 wrappers, in addition to whatever is needed for the
detected Fortran compilers. This is mainly intended for GNU/Linux
distros switching to gfortran that wish to include both
gfortran and g77 support in FFTW.
* In manual, renamed "guru execute" functions to "new-array execute"
functions, to reduce confusion with the guru planner interface.
(The programming interface is unchanged.)
* Add missing __declspec attribute to threads API functions when compiling
for Windows; thanks to Robert O. Morris for the bug report.
* Fixed missing return value from dfftw_init_threads in Fortran;
thanks to Markus Wetzstein for the bug report.
FFTW 3.1.3
* Bug fix: FFTW computes incorrect results when the user plans both
REDFT11 and RODFT11 transforms of certain sizes. The bug is caused
by incorrect sharing of twiddle-factor tables between the two
transforms, and only occurs when both are used. Thanks to Paul
A. Valiant for the bug report.
FFTW 3.1.2
* Correct bug in configure script: --enable-portable-binary option was ignored!
Thanks to Andrew Salamon for the bug report.
* Threads compilation fix on AIX: prefer xlc_r to cc_r, and don't use
either if we are using gcc. Thanks to Guy Moebs for the bug report.
* Updated FAQ to note that Apple gcc 4.0.1 on MacOS/Intel is broken,
and suggest a workaround. configure script now detects Core/Duo arch.
* Use -maltivec when checking for altivec.h. Fixes Gentoo bug #129304,
thanks to Markus Dittrich.
FFTW 3.1.1
* Performance improvements for Intel EMT64.
* Performance improvements for large-size transforms with SIMD.
* Cycle counter support for Intel icc and Visual C++ on x86-64.
* In fftw-wisdom tool, replaced obsolete --impatient with --measure.
* Fixed compilation failure with AIX/xlc; thanks to Joseph Thomas.
* Windows DLL support for Fortran API (added missing __declspec(dllexport)).
* SSE/SSE2 code works properly (i.e. disables itself) on older 386 and 486
CPUs lacking a CPUID instruction; thanks to Eric Korpela.
FFTW 3.1
* Faster FFTW_ESTIMATE planner.
* New (faster) algorithm for REDFT00/RODFT00 (type-I DCT/DST) of odd size.
* "4-step" algorithm for faster FFTs of very large sizes (> 2^18).
* Faster in-place real-data DFTs (for R2HC and HC2R r2r formats).
* Faster in-place non-square transpositions (FFTW uses these internally
for in-place FFTs, and you can also perform them explicitly using
the guru interface).
* Faster prime-size DFTs: implemented Bluestein's algorithm, as well
as a zero-padded Rader variant to limit recursive use of Rader's algorithm.
* SIMD support for split complex arrays.
* Much faster Altivec/VMX performance.
* New fftw_set_timelimit function to specify a (rough) upper bound to the
planning time (does not affect ESTIMATE mode).
* Removed --enable-3dnow support; use --enable-k7 instead.
* FMA (fused multiply-add) version is now included in "standard" FFTW,
and is enabled with --enable-fma (the default on PowerPC and Itanium).
* Automatic detection of native architecture flag for gcc. New
configure options: --enable-portable-binary and --with-gcc-arch=<arch>,
for people distributing compiled binaries of FFTW (see manual).
* Automatic detection of Altivec under Linux with gcc 3.4 (so that
same binary should work on both Altivec and non-Altivec PowerPCs).
* Compiler-specific tweaks/flags/workarounds for gcc 3.4, xlc, HP/UX,
Solaris/Intel.
* Various documentation clarifications.
* 64-bit clean. (Fixes a bug affecting the split guru planner on
64-bit machines, reported by David Necas.)
* Fixed Debian bug #259612: inadvertent use of SSE instructions on
non-SSE machines (causing a crash) for --enable-sse binaries.
* Fixed bug that caused HC2R transforms to destroy the input in
certain cases, even if the user specified FFTW_PRESERVE_INPUT.
* Fixed bug where wisdom would be lost under rare circumstances,
causing excessive planning time.
* FAQ notes bug in gcc-3.4.[1-3] that causes FFTW to crash with SSE/SSE2.
* Fixed accidentally exported symbol that prohibited simultaneous
linking to double/single multithreaded FFTW (thanks to Alessio Massaro).
* Support Win32 threads under MinGW (thanks to Alessio Massaro).
* Fixed problem with building DLL under Cygwin; thanks to Stephane Fillod.
* Fix build failure if no Fortran compiler is found (thanks to Charles
Radley for the bug report).
* Fixed compilation failure with icc 8.0 and SSE/SSE2. Automatic
detection of icc architecture flag (e.g. -xW).
* Fixed compilation with OpenMP on AIX (thanks to Greg Bauer).
* Fixed compilation failure on x86-64 with gcc (thanks to Orion Poplawski).
* Incorporated patch from FreeBSD ports (FreeBSD does not have memalign,
but its malloc is 16-byte aligned).
* Cycle-counter compilation fixes for Itanium, Alpha, x86-64, Sparc,
MacOS (thanks to Matt Boman, John Bowman, and James A. Treacy for
reports/fixes). Added x86-64 cycle counter for PGI compilers,
courtesy Cristiano Calonaci.
* Fix compilation problem in test program due to C99 conflict.
* Portability fix for import_system_wisdom with djgpp (thanks to Juan
Manuel Guerrero).
* Fixed compilation failure on MacOS 10.3 due to getopt conflict.
* Work around Visual C++ (version 6/7) bug in SSE compilation;
thanks to Eddie Yee for his detailed report.
Changes from FFTW 3.1 beta 2:
* Several minor compilation fixes.
* Eliminate FFTW_TIMELIMIT flag and replace fftw_timelimit global with
fftw_set_timelimit function. Make wisdom work with time-limited plans.
Changes from FFTW 3.1 beta 1:
* Fixes for creating DLLs under Windows; thanks to John Pavel for his feedback.
* Fixed more 64-bit problems, thanks to John Pavel for the bug report.
* Further speed improvements for Altivec/VMX.
* Further speed improvements for non-square transpositions.
* Many minor tweaks.
FFTW 3.0.1
* Some speed improvements in SIMD code.
* --without-cycle-counter option is removed. If no cycle counter is found,
then the estimator is always used. A --with-slow-timer option is provided
to force the use of lower-resolution timers.
* Several fixes for compilation under Visual C++, with help from Stefane Ruel.
* Added x86 cycle counter for Visual C++, with help from Morten Nissov.
* Added S390 cycle counter, courtesy of James Treacy.
* Added missing static keyword that prevented simultaneous linkage
of different-precision versions; thanks to Rasmus Larsen for the bug report.
* Corrected accidental omission of f77_wisdom.f file; thanks to Alan Watson.
* Support -xopenmp flag for SunOS; thanks to John Lou for the bug report.
* Compilation with HP/UX cc requires -Wp,-H128000 flag to increase
preprocessor limits; thanks to Peter Vouras for the bug report.
* Removed non-portable use of 'tempfile' in fftw-wisdom-to-conf script;
thanks to Nicolas Decoster for the patch.
* Added 'make smallcheck' target in tests/ directory, at the request of
James Treacy.
FFTW 3.0
Major goals of this release:
* Speed: often 20% or more faster than FFTW 2.x, even without SIMD (see below).
* Complete rewrite, to make it easier to add new algorithms and transforms.
* New API, to support more general semantics.
Other enhancements:
* SIMD acceleration on supporting CPUs (SSE, SSE2, 3DNow!, and AltiVec).
(With special thanks to Franz Franchetti for many experimental prototypes
and to Stefan Kral for the vectorizing generator from fftwgel.)
* True in-place 1d transforms of large sizes (as well as compressed
twiddle tables for additional memory/cache savings).
* More arbitrary placement of real & imaginary data, e.g. including
interleaved (as in FFTW 2.x) as well as separate real/imag arrays.
* Efficient prime-size transforms of real data.
* Multidimensional transforms can operate on a subset of a larger matrix,
and/or transform selected dimensions of a multidimensional array.
* By popular demand, simultaneous linking to double precision (fftw),
single precision (fftwf), and long-double precision (fftwl) versions
of FFTW is now supported.
* Cycle counters (on all modern CPUs) are exploited to speed planning.
* Efficient transforms of real even/odd arrays, a.k.a. discrete
cosine/sine transforms (types I-IV). (Currently work via pre/post
processing of real transforms, ala FFTPACK, so are not optimal.)
* DHTs (Discrete Hartley Transforms), again via post-processing
of real transforms (and thus suboptimal, for now).
* Support for linking to just those parts of FFTW that you need,
greatly reducing the size of statically linked programs when
only a limited set of transform sizes/types are required.
* Canonical global wisdom file (/etc/fftw/wisdom) on Unix, along
with a command-line tool (fftw-wisdom) to generate/update it.
* Fortran API can be used with both g77 and non-g77 compilers
simultaneously.
* Multi-threaded version has optional OpenMP support.
* Authors' good looks have greatly improved with age.
Changes from 3.0beta3:
* Separate FMA distribution to better exploit fused multiply-add instructions
on PowerPC (and possibly other) architectures.
* Performance improvements via some inlining tweaks.
* fftw_flops now returns double arguments, not int, to avoid overflows
for large sizes.
* Workarounds for automake bugs.
Changes from 3.0beta2:
* The standard REDFT00/RODFT00 (DCT-I/DST-I) algorithm (used in
FFTPACK, NR, etcetera) turns out to have poor numerical accuracy, so
we replaced it with a slower routine that is more accurate.
* The guru planner and execute functions now have two variants, one that
takes complex arguments and one that takes separate real/imag pointers.
* Execute and planner routines now automatically align the stack on x86,
in case the calling program is misaligned.
* README file for test program.
* Fixed bugs in the combination of SIMD with multi-threaded transforms.
* Eliminated internal fftw_threads_init function, which some people were
calling accidentally instead of the fftw_init_threads API function.
* Check for -openmp flag (Intel C compiler) when --enable-openmp is used.
* Support AMD x86-64 SIMD and cycle counter.
* Support SSE2 intrinsics in forthcoming gcc 3.3.
Changes from 3.0beta1:
* Faster in-place 1d transforms of non-power-of-two sizes.
* SIMD improvements for in-place, multi-dimensional, and/or non-FFTW_PATIENT
transforms.
* Added support for hard-coded DCT/DST/DHT codelets of small sizes; the
default distribution only includes hard-coded size-8 DCT-II/III, however.
* Many minor improvements to the manual. Added section on using the
codelet generator to customize and enhance FFTW.
* The default 'make check' should now only take a few minutes; for more
strenuous tests (which may take a day or so), do 'cd tests; make bigcheck'.
* fftw_print_plan is split into fftw_fprint_plan and fftw_print_plan, where
the latter uses stdout.
* Fixed ability to compile with a C++ compiler.
* Fixed support for C99 complex type under glibc.
* Fixed problems with alloca under MinGW, AIX.
* Workaround for gcc/SPARC bug.
* Fixed multi-threaded initialization failure on IRIX due to lack of
user-accessible PTHREAD_SCOPE_SYSTEM there.

54
Desktop_Interface/build_win/fftw/x64/README Normal file
View File

@ -0,0 +1,54 @@
FFTW is a free collection of fast C routines for computing the
Discrete Fourier Transform in one or more dimensions. It includes
complex, real, symmetric, and parallel transforms, and can handle
arbitrary array sizes efficiently. FFTW is typically faster than
other publically-available FFT implementations, and is even
competitive with vendor-tuned libraries. (See our web page
http://fftw.org/ for extensive benchmarks.) To achieve this
performance, FFTW uses novel code-generation and runtime
self-optimization techniques (along with many other tricks).
The doc/ directory contains the manual in texinfo, PDF, info, and HTML
formats. Frequently asked questions and answers can be found in the
doc/FAQ/ directory in ASCII and HTML.
For a quick introduction to calling FFTW, see the "Tutorial" section
of the manual.
INSTALLATION
------------
INSTALLATION FROM AN OFFICIAL RELEASE:
Please read chapter 10 "Installation and Customization" of the manual.
In short:
./configure
make
make install
INSTALLATION FROM THE GIT REPOSITORY:
First, install these programs:
ocaml, ocamlbuild, autoconf, automake, indent, and libtool,
Then, execute
sh bootstrap.sh
make
The bootstrap.sh script runs configure directly, but if you need to
re-run configure, you must pass the --enable-maintainer-mode flag:
./configure --enable-maintainer-mode [OTHER CONFIGURE FLAGS]
CONTACTS
--------
FFTW was written by Matteo Frigo and Steven G. Johnson. You can
contact them at fftw@fftw.org. The latest version of FFTW,
benchmarks, links, and other information can be found at the FFTW home
page (http://www.fftw.org). You can also sign up to the fftw-announce
Google group to receive (infrequent) updates and information about new
releases.

29
Desktop_Interface/build_win/fftw/x64/README-WINDOWS Normal file
View File

@ -0,0 +1,29 @@
This .zip archive contains DLL libraries and the associated header (.h)
and module-definition (.def) files of FFTW compiled for Win64. It
also contains the corresponding bench.exe test/benchmark programs
and wisdom utilities.
There are three libraries: single precision (float), double precision,
and extended precision (long double). To use the third library,
your compiler must have sizeof(long double) == 12.
In order to link to these .dll files from Visual C++, you need to
create .lib "import libraries" for them, and can do so with the "lib"
command that comes with VC++. In particular, run:
lib /def:libfftw3f-3.def
lib /def:libfftw3-3.def
lib /def:libfftw3l-3.def
On Visual Studio 2008 in 64-bit mode, and possibly in
other cases, you may need to specify the machine explicitly:
lib /machine:x64 /def:libfftw3f-3.def
lib /machine:x64 /def:libfftw3-3.def
lib /machine:x64 /def:libfftw3l-3.def
The single- and double-precision libraries use SSE and SSE2, respectively,
but should also work on older processors (the library checks at runtime
to see whether SSE/SSE2 is supported and disables the relevant code if not).
They were compiled by the GNU C compiler for MinGW, specifically:
x86_64-w64-mingw32-gcc (GCC) 4.9.1

73
Desktop_Interface/build_win/fftw/x64/README-bench Normal file
View File

@ -0,0 +1,73 @@
This directory contains a benchmarking and testing program
for fftw3.
The `bench' program has a zillion options, because we use it for
benchmarking other FFT libraries as well. This file only documents
the basic usage of bench.
Usage: bench <commands>
where each command is as follows:
-s <problem>
--speed <problem>
Benchmarks the speed of <problem>.
The syntax for problems is [i|o][r|c][f|b]<size>, where
i/o means in-place or out-of-place. Out of place is the default.
r/c means real or complex transform. Complex is the default.
f/b means forward or backward transform. Forward is the default.
<size> is an arbitrary multidimensional sequence of integers
separated by the character 'x'.
(The syntax for problems is actually richer, but we do not document
it here. See the man page for fftw-wisdom for more information.)
Example:
ib256 : in-place backward complex transform of size 256
32x64 : out-of-place forward complex 2D transform of 32 rows
and 64 columns.
-y <problem>
--verify <problem>
Verify that FFTW is computing the correct answer.
The program does not output anything unless an error occurs or
verbosity is at least one.
-v<n>
Set verbosity to <n>, or 1 if <n> is omitted. -v2 will output
the created plans with fftw_print_plan.
-oestimate
-opatient
-oexhaustive
Plan with FFTW_ESTIMATE, FFTW_PATIENT, or FFTW_EXHAUSTIVE, respectively.
The default is FFTW_MEASURE.
If you benchmark FFTW, please use -opatient.
-onthreads=N
Use N threads, if FFTW was compiled with --enable-threads. N
must be a positive integer; the default is N=1.
-onosimd
Disable SIMD instructions (e.g. SSE or SSE2).
-ounaligned
Plan with the FFTW_UNALIGNED flag.
-owisdom
On startup, read wisdom from a file wis.dat in the current directory
(if it exists). On completion, write accumulated wisdom to wis.dat
(overwriting any existing file of that name).

72
Desktop_Interface/build_win/fftw/x64/fftw3.f Normal file
View File

@ -0,0 +1,72 @@
INTEGER FFTW_R2HC
PARAMETER (FFTW_R2HC=0)
INTEGER FFTW_HC2R
PARAMETER (FFTW_HC2R=1)
INTEGER FFTW_DHT
PARAMETER (FFTW_DHT=2)
INTEGER FFTW_REDFT00
PARAMETER (FFTW_REDFT00=3)
INTEGER FFTW_REDFT01
PARAMETER (FFTW_REDFT01=4)
INTEGER FFTW_REDFT10
PARAMETER (FFTW_REDFT10=5)
INTEGER FFTW_REDFT11
PARAMETER (FFTW_REDFT11=6)
INTEGER FFTW_RODFT00
PARAMETER (FFTW_RODFT00=7)
INTEGER FFTW_RODFT01
PARAMETER (FFTW_RODFT01=8)
INTEGER FFTW_RODFT10
PARAMETER (FFTW_RODFT10=9)
INTEGER FFTW_RODFT11
PARAMETER (FFTW_RODFT11=10)
INTEGER FFTW_FORWARD
PARAMETER (FFTW_FORWARD=-1)
INTEGER FFTW_BACKWARD
PARAMETER (FFTW_BACKWARD=+1)
INTEGER FFTW_MEASURE
PARAMETER (FFTW_MEASURE=0)
INTEGER FFTW_DESTROY_INPUT
PARAMETER (FFTW_DESTROY_INPUT=1)
INTEGER FFTW_UNALIGNED
PARAMETER (FFTW_UNALIGNED=2)
INTEGER FFTW_CONSERVE_MEMORY
PARAMETER (FFTW_CONSERVE_MEMORY=4)
INTEGER FFTW_EXHAUSTIVE
PARAMETER (FFTW_EXHAUSTIVE=8)
INTEGER FFTW_PRESERVE_INPUT
PARAMETER (FFTW_PRESERVE_INPUT=16)
INTEGER FFTW_PATIENT
PARAMETER (FFTW_PATIENT=32)
INTEGER FFTW_ESTIMATE
PARAMETER (FFTW_ESTIMATE=64)
INTEGER FFTW_WISDOM_ONLY
PARAMETER (FFTW_WISDOM_ONLY=2097152)
INTEGER FFTW_ESTIMATE_PATIENT
PARAMETER (FFTW_ESTIMATE_PATIENT=128)
INTEGER FFTW_BELIEVE_PCOST
PARAMETER (FFTW_BELIEVE_PCOST=256)
INTEGER FFTW_NO_DFT_R2HC
PARAMETER (FFTW_NO_DFT_R2HC=512)
INTEGER FFTW_NO_NONTHREADED
PARAMETER (FFTW_NO_NONTHREADED=1024)
INTEGER FFTW_NO_BUFFERING
PARAMETER (FFTW_NO_BUFFERING=2048)
INTEGER FFTW_NO_INDIRECT_OP
PARAMETER (FFTW_NO_INDIRECT_OP=4096)
INTEGER FFTW_ALLOW_LARGE_GENERIC
PARAMETER (FFTW_ALLOW_LARGE_GENERIC=8192)
INTEGER FFTW_NO_RANK_SPLITS
PARAMETER (FFTW_NO_RANK_SPLITS=16384)
INTEGER FFTW_NO_VRANK_SPLITS
PARAMETER (FFTW_NO_VRANK_SPLITS=32768)
INTEGER FFTW_NO_VRECURSE
PARAMETER (FFTW_NO_VRECURSE=65536)
INTEGER FFTW_NO_SIMD
PARAMETER (FFTW_NO_SIMD=131072)
INTEGER FFTW_NO_SLOW
PARAMETER (FFTW_NO_SLOW=262144)
INTEGER FFTW_NO_FIXED_RADIX_LARGE_N
PARAMETER (FFTW_NO_FIXED_RADIX_LARGE_N=524288)
INTEGER FFTW_ALLOW_PRUNING
PARAMETER (FFTW_ALLOW_PRUNING=1048576)

1254
Desktop_Interface/build_win/fftw/x64/fftw3.f03 Normal file
View File

File diff suppressed because it is too large Load Diff

415
Desktop_Interface/build_win/fftw/x64/fftw3.h Normal file
View File

@ -0,0 +1,415 @@
/*
* Copyright (c) 2003, 2007-14 Matteo Frigo
* Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
*
* The following statement of license applies *only* to this header file,
* and *not* to the other files distributed with FFTW or derived therefrom:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/***************************** NOTE TO USERS *********************************
*
* THIS IS A HEADER FILE, NOT A MANUAL
*
* If you want to know how to use FFTW, please read the manual,
* online at http://www.fftw.org/doc/ and also included with FFTW.
* For a quick start, see the manual's tutorial section.
*
* (Reading header files to learn how to use a library is a habit
* stemming from code lacking a proper manual. Arguably, it's a
* *bad* habit in most cases, because header files can contain
* interfaces that are not part of the public, stable API.)
*
****************************************************************************/
#ifndef FFTW3_H
#define FFTW3_H
#include <stdio.h>
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* If <complex.h> is included, use the C99 complex type. Otherwise
define a type bit-compatible with C99 complex */
#if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
# define FFTW_DEFINE_COMPLEX(R, C) typedef R _Complex C
#else
# define FFTW_DEFINE_COMPLEX(R, C) typedef R C[2]
#endif
#define FFTW_CONCAT(prefix, name) prefix ## name
#define FFTW_MANGLE_DOUBLE(name) FFTW_CONCAT(fftw_, name)
#define FFTW_MANGLE_FLOAT(name) FFTW_CONCAT(fftwf_, name)
#define FFTW_MANGLE_LONG_DOUBLE(name) FFTW_CONCAT(fftwl_, name)
#define FFTW_MANGLE_QUAD(name) FFTW_CONCAT(fftwq_, name)
/* IMPORTANT: for Windows compilers, you should add a line
*/
#define FFTW_DLL
/*
here and in kernel/ifftw.h if you are compiling/using FFTW as a
DLL, in order to do the proper importing/exporting, or
alternatively compile with -DFFTW_DLL or the equivalent
command-line flag. This is not necessary under MinGW/Cygwin, where
libtool does the imports/exports automatically. */
#if defined(FFTW_DLL) && (defined(_WIN32) || defined(__WIN32__))
/* annoying Windows syntax for shared-library declarations */
# if defined(COMPILING_FFTW) /* defined in api.h when compiling FFTW */
# define FFTW_EXTERN extern __declspec(dllexport)
# else /* user is calling FFTW; import symbol */
# define FFTW_EXTERN extern __declspec(dllimport)
# endif
#else
# define FFTW_EXTERN extern
#endif
enum fftw_r2r_kind_do_not_use_me {
FFTW_R2HC=0, FFTW_HC2R=1, FFTW_DHT=2,
FFTW_REDFT00=3, FFTW_REDFT01=4, FFTW_REDFT10=5, FFTW_REDFT11=6,
FFTW_RODFT00=7, FFTW_RODFT01=8, FFTW_RODFT10=9, FFTW_RODFT11=10
};
struct fftw_iodim_do_not_use_me {
int n; /* dimension size */
int is; /* input stride */
int os; /* output stride */
};
#include <stddef.h> /* for ptrdiff_t */
struct fftw_iodim64_do_not_use_me {
ptrdiff_t n; /* dimension size */
ptrdiff_t is; /* input stride */
ptrdiff_t os; /* output stride */
};
typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *);
typedef int (*fftw_read_char_func_do_not_use_me)(void *);
/*
huge second-order macro that defines prototypes for all API
functions. We expand this macro for each supported precision
X: name-mangling macro
R: real data type
C: complex data type
*/
#define FFTW_DEFINE_API(X, R, C) \
\
FFTW_DEFINE_COMPLEX(R, C); \
\
typedef struct X(plan_s) *X(plan); \
\
typedef struct fftw_iodim_do_not_use_me X(iodim); \
typedef struct fftw_iodim64_do_not_use_me X(iodim64); \
\
typedef enum fftw_r2r_kind_do_not_use_me X(r2r_kind); \
\
typedef fftw_write_char_func_do_not_use_me X(write_char_func); \
typedef fftw_read_char_func_do_not_use_me X(read_char_func); \
\
FFTW_EXTERN void X(execute)(const X(plan) p); \
\
FFTW_EXTERN X(plan) X(plan_dft)(int rank, const int *n, \
C *in, C *out, int sign, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_1d)(int n, C *in, C *out, int sign, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_2d)(int n0, int n1, \
C *in, C *out, int sign, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_3d)(int n0, int n1, int n2, \
C *in, C *out, int sign, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_many_dft)(int rank, const int *n, \
int howmany, \
C *in, const int *inembed, \
int istride, int idist, \
C *out, const int *onembed, \
int ostride, int odist, \
int sign, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_dft)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
C *in, C *out, \
int sign, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru_split_dft)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *ri, R *ii, R *ro, R *io, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_dft)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
C *in, C *out, \
int sign, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru64_split_dft)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *ri, R *ii, R *ro, R *io, \
unsigned flags); \
\
FFTW_EXTERN void X(execute_dft)(const X(plan) p, C *in, C *out); \
FFTW_EXTERN void X(execute_split_dft)(const X(plan) p, R *ri, R *ii, \
R *ro, R *io); \
\
FFTW_EXTERN X(plan) X(plan_many_dft_r2c)(int rank, const int *n, \
int howmany, \
R *in, const int *inembed, \
int istride, int idist, \
C *out, const int *onembed, \
int ostride, int odist, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_r2c)(int rank, const int *n, \
R *in, C *out, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_r2c_1d)(int n,R *in,C *out,unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_r2c_2d)(int n0, int n1, \
R *in, C *out, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_r2c_3d)(int n0, int n1, \
int n2, \
R *in, C *out, unsigned flags); \
\
\
FFTW_EXTERN X(plan) X(plan_many_dft_c2r)(int rank, const int *n, \
int howmany, \
C *in, const int *inembed, \
int istride, int idist, \
R *out, const int *onembed, \
int ostride, int odist, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_c2r)(int rank, const int *n, \
C *in, R *out, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_c2r_1d)(int n,C *in,R *out,unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_c2r_2d)(int n0, int n1, \
C *in, R *out, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_c2r_3d)(int n0, int n1, \
int n2, \
C *in, R *out, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_dft_r2c)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *in, C *out, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru_dft_c2r)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
C *in, R *out, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_split_dft_r2c)( \
int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *in, R *ro, R *io, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru_split_dft_c2r)( \
int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *ri, R *ii, R *out, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_dft_r2c)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *in, C *out, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru64_dft_c2r)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
C *in, R *out, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_split_dft_r2c)( \
int rank, const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *in, R *ro, R *io, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru64_split_dft_c2r)( \
int rank, const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *ri, R *ii, R *out, \
unsigned flags); \
\
FFTW_EXTERN void X(execute_dft_r2c)(const X(plan) p, R *in, C *out); \
FFTW_EXTERN void X(execute_dft_c2r)(const X(plan) p, C *in, R *out); \
\
FFTW_EXTERN void X(execute_split_dft_r2c)(const X(plan) p, \
R *in, R *ro, R *io); \
FFTW_EXTERN void X(execute_split_dft_c2r)(const X(plan) p, \
R *ri, R *ii, R *out); \
\
FFTW_EXTERN X(plan) X(plan_many_r2r)(int rank, const int *n, \
int howmany, \
R *in, const int *inembed, \
int istride, int idist, \
R *out, const int *onembed, \
int ostride, int odist, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_r2r)(int rank, const int *n, R *in, R *out, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_r2r_1d)(int n, R *in, R *out, \
X(r2r_kind) kind, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_r2r_2d)(int n0, int n1, R *in, R *out, \
X(r2r_kind) kind0, X(r2r_kind) kind1, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_r2r_3d)(int n0, int n1, int n2, \
R *in, R *out, X(r2r_kind) kind0, \
X(r2r_kind) kind1, X(r2r_kind) kind2, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_r2r)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *in, R *out, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_r2r)(int rank, const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *in, R *out, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN void X(execute_r2r)(const X(plan) p, R *in, R *out); \
\
FFTW_EXTERN void X(destroy_plan)(X(plan) p); \
FFTW_EXTERN void X(forget_wisdom)(void); \
FFTW_EXTERN void X(cleanup)(void); \
\
FFTW_EXTERN void X(set_timelimit)(double t); \
\
FFTW_EXTERN void X(plan_with_nthreads)(int nthreads); \
FFTW_EXTERN int X(init_threads)(void); \
FFTW_EXTERN void X(cleanup_threads)(void); \
FFTW_EXTERN void X(make_planner_thread_safe)(void); \
\
FFTW_EXTERN int X(export_wisdom_to_filename)(const char *filename); \
FFTW_EXTERN void X(export_wisdom_to_file)(FILE *output_file); \
FFTW_EXTERN char *X(export_wisdom_to_string)(void); \
FFTW_EXTERN void X(export_wisdom)(X(write_char_func) write_char, \
void *data); \
FFTW_EXTERN int X(import_system_wisdom)(void); \
FFTW_EXTERN int X(import_wisdom_from_filename)(const char *filename); \
FFTW_EXTERN int X(import_wisdom_from_file)(FILE *input_file); \
FFTW_EXTERN int X(import_wisdom_from_string)(const char *input_string); \
FFTW_EXTERN int X(import_wisdom)(X(read_char_func) read_char, void *data); \
\
FFTW_EXTERN void X(fprint_plan)(const X(plan) p, FILE *output_file); \
FFTW_EXTERN void X(print_plan)(const X(plan) p); \
FFTW_EXTERN char *X(sprint_plan)(const X(plan) p); \
\
FFTW_EXTERN void *X(malloc)(size_t n); \
FFTW_EXTERN R *X(alloc_real)(size_t n); \
FFTW_EXTERN C *X(alloc_complex)(size_t n); \
FFTW_EXTERN void X(free)(void *p); \
\
FFTW_EXTERN void X(flops)(const X(plan) p, \
double *add, double *mul, double *fmas); \
FFTW_EXTERN double X(estimate_cost)(const X(plan) p); \
FFTW_EXTERN double X(cost)(const X(plan) p); \
\
FFTW_EXTERN int X(alignment_of)(R *p); \
FFTW_EXTERN const char X(version)[]; \
FFTW_EXTERN const char X(cc)[]; \
FFTW_EXTERN const char X(codelet_optim)[];
/* end of FFTW_DEFINE_API macro */
FFTW_DEFINE_API(FFTW_MANGLE_DOUBLE, double, fftw_complex)
FFTW_DEFINE_API(FFTW_MANGLE_FLOAT, float, fftwf_complex)
FFTW_DEFINE_API(FFTW_MANGLE_LONG_DOUBLE, long double, fftwl_complex)
/* __float128 (quad precision) is a gcc extension on i386, x86_64, and ia64
for gcc >= 4.6 (compiled in FFTW with --enable-quad-precision) */
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) \
&& !(defined(__ICC) || defined(__INTEL_COMPILER) || defined(__CUDACC__) || defined(__PGI)) \
&& (defined(__i386__) || defined(__x86_64__) || defined(__ia64__))
# if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
/* note: __float128 is a typedef, which is not supported with the _Complex
keyword in gcc, so instead we use this ugly __attribute__ version.
However, we can't simply pass the __attribute__ version to
FFTW_DEFINE_API because the __attribute__ confuses gcc in pointer
types. Hence redefining FFTW_DEFINE_COMPLEX. Ugh. */
# undef FFTW_DEFINE_COMPLEX
# define FFTW_DEFINE_COMPLEX(R, C) typedef _Complex float __attribute__((mode(TC))) C
# endif
FFTW_DEFINE_API(FFTW_MANGLE_QUAD, __float128, fftwq_complex)
#endif
#define FFTW_FORWARD (-1)
#define FFTW_BACKWARD (+1)
#define FFTW_NO_TIMELIMIT (-1.0)
/* documented flags */
#define FFTW_MEASURE (0U)
#define FFTW_DESTROY_INPUT (1U << 0)
#define FFTW_UNALIGNED (1U << 1)
#define FFTW_CONSERVE_MEMORY (1U << 2)
#define FFTW_EXHAUSTIVE (1U << 3) /* NO_EXHAUSTIVE is default */
#define FFTW_PRESERVE_INPUT (1U << 4) /* cancels FFTW_DESTROY_INPUT */
#define FFTW_PATIENT (1U << 5) /* IMPATIENT is default */
#define FFTW_ESTIMATE (1U << 6)
#define FFTW_WISDOM_ONLY (1U << 21)
/* undocumented beyond-guru flags */
#define FFTW_ESTIMATE_PATIENT (1U << 7)
#define FFTW_BELIEVE_PCOST (1U << 8)
#define FFTW_NO_DFT_R2HC (1U << 9)
#define FFTW_NO_NONTHREADED (1U << 10)
#define FFTW_NO_BUFFERING (1U << 11)
#define FFTW_NO_INDIRECT_OP (1U << 12)
#define FFTW_ALLOW_LARGE_GENERIC (1U << 13) /* NO_LARGE_GENERIC is default */
#define FFTW_NO_RANK_SPLITS (1U << 14)
#define FFTW_NO_VRANK_SPLITS (1U << 15)
#define FFTW_NO_VRECURSE (1U << 16)
#define FFTW_NO_SIMD (1U << 17)
#define FFTW_NO_SLOW (1U << 18)
#define FFTW_NO_FIXED_RADIX_LARGE_N (1U << 19)
#define FFTW_ALLOW_PRUNING (1U << 20)
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* FFTW3_H */

609
Desktop_Interface/build_win/fftw/x64/fftw3l.f03 Normal file
View File

@ -0,0 +1,609 @@
! Generated automatically. DO NOT EDIT!
type, bind(C) :: fftwl_iodim
integer(C_INT) n, is, os
end type fftwl_iodim
type, bind(C) :: fftwl_iodim64
integer(C_INTPTR_T) n, is, os
end type fftwl_iodim64
interface
type(C_PTR) function fftwl_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftwl_plan_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft
type(C_PTR) function fftwl_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftwl_plan_dft_1d')
import
integer(C_INT), value :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft_1d
type(C_PTR) function fftwl_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftwl_plan_dft_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft_2d
type(C_PTR) function fftwl_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftwl_plan_dft_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft_3d
type(C_PTR) function fftwl_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) &
bind(C, name='fftwl_plan_many_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_many_dft
type(C_PTR) function fftwl_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwl_plan_guru_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_guru_dft
type(C_PTR) function fftwl_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwl_plan_guru_split_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru_split_dft
type(C_PTR) function fftwl_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwl_plan_guru64_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_guru64_dft
type(C_PTR) function fftwl_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwl_plan_guru64_split_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru64_split_dft
subroutine fftwl_execute_dft(p,in,out) bind(C, name='fftwl_execute_dft')
import
type(C_PTR), value :: p
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
end subroutine fftwl_execute_dft
subroutine fftwl_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftwl_execute_split_dft')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
end subroutine fftwl_execute_split_dft
type(C_PTR) function fftwl_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwl_plan_many_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwl_plan_many_dft_r2c
type(C_PTR) function fftwl_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftwl_plan_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c
type(C_PTR) function fftwl_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftwl_plan_dft_r2c_1d')
import
integer(C_INT), value :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c_1d
type(C_PTR) function fftwl_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftwl_plan_dft_r2c_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c_2d
type(C_PTR) function fftwl_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwl_plan_dft_r2c_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c_3d
type(C_PTR) function fftwl_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwl_plan_many_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwl_plan_many_dft_c2r
type(C_PTR) function fftwl_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftwl_plan_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r
type(C_PTR) function fftwl_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftwl_plan_dft_c2r_1d')
import
integer(C_INT), value :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r_1d
type(C_PTR) function fftwl_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftwl_plan_dft_c2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r_2d
type(C_PTR) function fftwl_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwl_plan_dft_c2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r_3d
type(C_PTR) function fftwl_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru_dft_r2c
type(C_PTR) function fftwl_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru_dft_c2r
type(C_PTR) function fftwl_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwl_plan_guru_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru_split_dft_r2c
type(C_PTR) function fftwl_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwl_plan_guru_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru_split_dft_c2r
type(C_PTR) function fftwl_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru64_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru64_dft_r2c
type(C_PTR) function fftwl_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru64_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru64_dft_c2r
type(C_PTR) function fftwl_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwl_plan_guru64_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru64_split_dft_r2c
type(C_PTR) function fftwl_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwl_plan_guru64_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru64_split_dft_c2r
subroutine fftwl_execute_dft_r2c(p,in,out) bind(C, name='fftwl_execute_dft_r2c')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
end subroutine fftwl_execute_dft_r2c
subroutine fftwl_execute_dft_c2r(p,in,out) bind(C, name='fftwl_execute_dft_c2r')
import
type(C_PTR), value :: p
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
end subroutine fftwl_execute_dft_c2r
subroutine fftwl_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftwl_execute_split_dft_r2c')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
end subroutine fftwl_execute_split_dft_r2c
subroutine fftwl_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftwl_execute_split_dft_c2r')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
end subroutine fftwl_execute_split_dft_c2r
type(C_PTR) function fftwl_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) &
bind(C, name='fftwl_plan_many_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_many_r2r
type(C_PTR) function fftwl_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftwl_plan_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_r2r
type(C_PTR) function fftwl_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftwl_plan_r2r_1d')
import
integer(C_INT), value :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind
integer(C_INT), value :: flags
end function fftwl_plan_r2r_1d
type(C_PTR) function fftwl_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftwl_plan_r2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_INT), value :: flags
end function fftwl_plan_r2r_2d
type(C_PTR) function fftwl_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftwl_plan_r2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_FFTW_R2R_KIND), value :: kind2
integer(C_INT), value :: flags
end function fftwl_plan_r2r_3d
type(C_PTR) function fftwl_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwl_plan_guru_r2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_guru_r2r
type(C_PTR) function fftwl_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwl_plan_guru64_r2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_guru64_r2r
subroutine fftwl_execute_r2r(p,in,out) bind(C, name='fftwl_execute_r2r')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
end subroutine fftwl_execute_r2r
subroutine fftwl_destroy_plan(p) bind(C, name='fftwl_destroy_plan')
import
type(C_PTR), value :: p
end subroutine fftwl_destroy_plan
subroutine fftwl_forget_wisdom() bind(C, name='fftwl_forget_wisdom')
import
end subroutine fftwl_forget_wisdom
subroutine fftwl_cleanup() bind(C, name='fftwl_cleanup')
import
end subroutine fftwl_cleanup
subroutine fftwl_set_timelimit(t) bind(C, name='fftwl_set_timelimit')
import
real(C_DOUBLE), value :: t
end subroutine fftwl_set_timelimit
subroutine fftwl_plan_with_nthreads(nthreads) bind(C, name='fftwl_plan_with_nthreads')
import
integer(C_INT), value :: nthreads
end subroutine fftwl_plan_with_nthreads
integer(C_INT) function fftwl_init_threads() bind(C, name='fftwl_init_threads')
import
end function fftwl_init_threads
subroutine fftwl_cleanup_threads() bind(C, name='fftwl_cleanup_threads')
import
end subroutine fftwl_cleanup_threads
subroutine fftwl_make_planner_thread_safe() bind(C, name='fftwl_make_planner_thread_safe')
import
end subroutine fftwl_make_planner_thread_safe
integer(C_INT) function fftwl_export_wisdom_to_filename(filename) bind(C, name='fftwl_export_wisdom_to_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwl_export_wisdom_to_filename
subroutine fftwl_export_wisdom_to_file(output_file) bind(C, name='fftwl_export_wisdom_to_file')
import
type(C_PTR), value :: output_file
end subroutine fftwl_export_wisdom_to_file
type(C_PTR) function fftwl_export_wisdom_to_string() bind(C, name='fftwl_export_wisdom_to_string')
import
end function fftwl_export_wisdom_to_string
subroutine fftwl_export_wisdom(write_char,data) bind(C, name='fftwl_export_wisdom')
import
type(C_FUNPTR), value :: write_char
type(C_PTR), value :: data
end subroutine fftwl_export_wisdom
integer(C_INT) function fftwl_import_system_wisdom() bind(C, name='fftwl_import_system_wisdom')
import
end function fftwl_import_system_wisdom
integer(C_INT) function fftwl_import_wisdom_from_filename(filename) bind(C, name='fftwl_import_wisdom_from_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwl_import_wisdom_from_filename
integer(C_INT) function fftwl_import_wisdom_from_file(input_file) bind(C, name='fftwl_import_wisdom_from_file')
import
type(C_PTR), value :: input_file
end function fftwl_import_wisdom_from_file
integer(C_INT) function fftwl_import_wisdom_from_string(input_string) bind(C, name='fftwl_import_wisdom_from_string')
import
character(C_CHAR), dimension(*), intent(in) :: input_string
end function fftwl_import_wisdom_from_string
integer(C_INT) function fftwl_import_wisdom(read_char,data) bind(C, name='fftwl_import_wisdom')
import
type(C_FUNPTR), value :: read_char
type(C_PTR), value :: data
end function fftwl_import_wisdom
subroutine fftwl_fprint_plan(p,output_file) bind(C, name='fftwl_fprint_plan')
import
type(C_PTR), value :: p
type(C_PTR), value :: output_file
end subroutine fftwl_fprint_plan
subroutine fftwl_print_plan(p) bind(C, name='fftwl_print_plan')
import
type(C_PTR), value :: p
end subroutine fftwl_print_plan
type(C_PTR) function fftwl_sprint_plan(p) bind(C, name='fftwl_sprint_plan')
import
type(C_PTR), value :: p
end function fftwl_sprint_plan
type(C_PTR) function fftwl_malloc(n) bind(C, name='fftwl_malloc')
import
integer(C_SIZE_T), value :: n
end function fftwl_malloc
type(C_PTR) function fftwl_alloc_real(n) bind(C, name='fftwl_alloc_real')
import
integer(C_SIZE_T), value :: n
end function fftwl_alloc_real
type(C_PTR) function fftwl_alloc_complex(n) bind(C, name='fftwl_alloc_complex')
import
integer(C_SIZE_T), value :: n
end function fftwl_alloc_complex
subroutine fftwl_free(p) bind(C, name='fftwl_free')
import
type(C_PTR), value :: p
end subroutine fftwl_free
subroutine fftwl_flops(p,add,mul,fmas) bind(C, name='fftwl_flops')
import
type(C_PTR), value :: p
real(C_DOUBLE), intent(out) :: add
real(C_DOUBLE), intent(out) :: mul
real(C_DOUBLE), intent(out) :: fmas
end subroutine fftwl_flops
real(C_DOUBLE) function fftwl_estimate_cost(p) bind(C, name='fftwl_estimate_cost')
import
type(C_PTR), value :: p
end function fftwl_estimate_cost
real(C_DOUBLE) function fftwl_cost(p) bind(C, name='fftwl_cost')
import
type(C_PTR), value :: p
end function fftwl_cost
integer(C_INT) function fftwl_alignment_of(p) bind(C, name='fftwl_alignment_of')
import
real(C_LONG_DOUBLE), dimension(*), intent(out) :: p
end function fftwl_alignment_of
end interface

609
Desktop_Interface/build_win/fftw/x64/fftw3q.f03 Normal file
View File

@ -0,0 +1,609 @@
! Generated automatically. DO NOT EDIT!
type, bind(C) :: fftwq_iodim
integer(C_INT) n, is, os
end type fftwq_iodim
type, bind(C) :: fftwq_iodim64
integer(C_INTPTR_T) n, is, os
end type fftwq_iodim64
interface
type(C_PTR) function fftwq_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftwq_plan_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft
type(C_PTR) function fftwq_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftwq_plan_dft_1d')
import
integer(C_INT), value :: n
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft_1d
type(C_PTR) function fftwq_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftwq_plan_dft_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft_2d
type(C_PTR) function fftwq_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftwq_plan_dft_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft_3d
type(C_PTR) function fftwq_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) &
bind(C, name='fftwq_plan_many_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_many_dft
type(C_PTR) function fftwq_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwq_plan_guru_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_guru_dft
type(C_PTR) function fftwq_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwq_plan_guru_split_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru_split_dft
type(C_PTR) function fftwq_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwq_plan_guru64_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_guru64_dft
type(C_PTR) function fftwq_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwq_plan_guru64_split_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru64_split_dft
subroutine fftwq_execute_dft(p,in,out) bind(C, name='fftwq_execute_dft')
import
type(C_PTR), value :: p
complex(16), dimension(*), intent(inout) :: in
complex(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_dft
subroutine fftwq_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftwq_execute_split_dft')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: ri
real(16), dimension(*), intent(inout) :: ii
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
end subroutine fftwq_execute_split_dft
type(C_PTR) function fftwq_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwq_plan_many_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwq_plan_many_dft_r2c
type(C_PTR) function fftwq_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftwq_plan_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c
type(C_PTR) function fftwq_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftwq_plan_dft_r2c_1d')
import
integer(C_INT), value :: n
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c_1d
type(C_PTR) function fftwq_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftwq_plan_dft_r2c_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c_2d
type(C_PTR) function fftwq_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwq_plan_dft_r2c_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c_3d
type(C_PTR) function fftwq_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwq_plan_many_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwq_plan_many_dft_c2r
type(C_PTR) function fftwq_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftwq_plan_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r
type(C_PTR) function fftwq_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftwq_plan_dft_c2r_1d')
import
integer(C_INT), value :: n
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r_1d
type(C_PTR) function fftwq_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftwq_plan_dft_c2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r_2d
type(C_PTR) function fftwq_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwq_plan_dft_c2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r_3d
type(C_PTR) function fftwq_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru_dft_r2c
type(C_PTR) function fftwq_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru_dft_c2r
type(C_PTR) function fftwq_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwq_plan_guru_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru_split_dft_r2c
type(C_PTR) function fftwq_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwq_plan_guru_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru_split_dft_c2r
type(C_PTR) function fftwq_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru64_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru64_dft_r2c
type(C_PTR) function fftwq_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru64_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru64_dft_c2r
type(C_PTR) function fftwq_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwq_plan_guru64_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru64_split_dft_r2c
type(C_PTR) function fftwq_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwq_plan_guru64_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru64_split_dft_c2r
subroutine fftwq_execute_dft_r2c(p,in,out) bind(C, name='fftwq_execute_dft_r2c')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: in
complex(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_dft_r2c
subroutine fftwq_execute_dft_c2r(p,in,out) bind(C, name='fftwq_execute_dft_c2r')
import
type(C_PTR), value :: p
complex(16), dimension(*), intent(inout) :: in
real(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_dft_c2r
subroutine fftwq_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftwq_execute_split_dft_r2c')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: in
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
end subroutine fftwq_execute_split_dft_r2c
subroutine fftwq_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftwq_execute_split_dft_c2r')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: ri
real(16), dimension(*), intent(inout) :: ii
real(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_split_dft_c2r
type(C_PTR) function fftwq_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) &
bind(C, name='fftwq_plan_many_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_many_r2r
type(C_PTR) function fftwq_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftwq_plan_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_r2r
type(C_PTR) function fftwq_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftwq_plan_r2r_1d')
import
integer(C_INT), value :: n
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind
integer(C_INT), value :: flags
end function fftwq_plan_r2r_1d
type(C_PTR) function fftwq_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftwq_plan_r2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_INT), value :: flags
end function fftwq_plan_r2r_2d
type(C_PTR) function fftwq_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftwq_plan_r2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_FFTW_R2R_KIND), value :: kind2
integer(C_INT), value :: flags
end function fftwq_plan_r2r_3d
type(C_PTR) function fftwq_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwq_plan_guru_r2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_guru_r2r
type(C_PTR) function fftwq_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwq_plan_guru64_r2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_guru64_r2r
subroutine fftwq_execute_r2r(p,in,out) bind(C, name='fftwq_execute_r2r')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: in
real(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_r2r
subroutine fftwq_destroy_plan(p) bind(C, name='fftwq_destroy_plan')
import
type(C_PTR), value :: p
end subroutine fftwq_destroy_plan
subroutine fftwq_forget_wisdom() bind(C, name='fftwq_forget_wisdom')
import
end subroutine fftwq_forget_wisdom
subroutine fftwq_cleanup() bind(C, name='fftwq_cleanup')
import
end subroutine fftwq_cleanup
subroutine fftwq_set_timelimit(t) bind(C, name='fftwq_set_timelimit')
import
real(C_DOUBLE), value :: t
end subroutine fftwq_set_timelimit
subroutine fftwq_plan_with_nthreads(nthreads) bind(C, name='fftwq_plan_with_nthreads')
import
integer(C_INT), value :: nthreads
end subroutine fftwq_plan_with_nthreads
integer(C_INT) function fftwq_init_threads() bind(C, name='fftwq_init_threads')
import
end function fftwq_init_threads
subroutine fftwq_cleanup_threads() bind(C, name='fftwq_cleanup_threads')
import
end subroutine fftwq_cleanup_threads
subroutine fftwq_make_planner_thread_safe() bind(C, name='fftwq_make_planner_thread_safe')
import
end subroutine fftwq_make_planner_thread_safe
integer(C_INT) function fftwq_export_wisdom_to_filename(filename) bind(C, name='fftwq_export_wisdom_to_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwq_export_wisdom_to_filename
subroutine fftwq_export_wisdom_to_file(output_file) bind(C, name='fftwq_export_wisdom_to_file')
import
type(C_PTR), value :: output_file
end subroutine fftwq_export_wisdom_to_file
type(C_PTR) function fftwq_export_wisdom_to_string() bind(C, name='fftwq_export_wisdom_to_string')
import
end function fftwq_export_wisdom_to_string
subroutine fftwq_export_wisdom(write_char,data) bind(C, name='fftwq_export_wisdom')
import
type(C_FUNPTR), value :: write_char
type(C_PTR), value :: data
end subroutine fftwq_export_wisdom
integer(C_INT) function fftwq_import_system_wisdom() bind(C, name='fftwq_import_system_wisdom')
import
end function fftwq_import_system_wisdom
integer(C_INT) function fftwq_import_wisdom_from_filename(filename) bind(C, name='fftwq_import_wisdom_from_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwq_import_wisdom_from_filename
integer(C_INT) function fftwq_import_wisdom_from_file(input_file) bind(C, name='fftwq_import_wisdom_from_file')
import
type(C_PTR), value :: input_file
end function fftwq_import_wisdom_from_file
integer(C_INT) function fftwq_import_wisdom_from_string(input_string) bind(C, name='fftwq_import_wisdom_from_string')
import
character(C_CHAR), dimension(*), intent(in) :: input_string
end function fftwq_import_wisdom_from_string
integer(C_INT) function fftwq_import_wisdom(read_char,data) bind(C, name='fftwq_import_wisdom')
import
type(C_FUNPTR), value :: read_char
type(C_PTR), value :: data
end function fftwq_import_wisdom
subroutine fftwq_fprint_plan(p,output_file) bind(C, name='fftwq_fprint_plan')
import
type(C_PTR), value :: p
type(C_PTR), value :: output_file
end subroutine fftwq_fprint_plan
subroutine fftwq_print_plan(p) bind(C, name='fftwq_print_plan')
import
type(C_PTR), value :: p
end subroutine fftwq_print_plan
type(C_PTR) function fftwq_sprint_plan(p) bind(C, name='fftwq_sprint_plan')
import
type(C_PTR), value :: p
end function fftwq_sprint_plan
type(C_PTR) function fftwq_malloc(n) bind(C, name='fftwq_malloc')
import
integer(C_SIZE_T), value :: n
end function fftwq_malloc
type(C_PTR) function fftwq_alloc_real(n) bind(C, name='fftwq_alloc_real')
import
integer(C_SIZE_T), value :: n
end function fftwq_alloc_real
type(C_PTR) function fftwq_alloc_complex(n) bind(C, name='fftwq_alloc_complex')
import
integer(C_SIZE_T), value :: n
end function fftwq_alloc_complex
subroutine fftwq_free(p) bind(C, name='fftwq_free')
import
type(C_PTR), value :: p
end subroutine fftwq_free
subroutine fftwq_flops(p,add,mul,fmas) bind(C, name='fftwq_flops')
import
type(C_PTR), value :: p
real(C_DOUBLE), intent(out) :: add
real(C_DOUBLE), intent(out) :: mul
real(C_DOUBLE), intent(out) :: fmas
end subroutine fftwq_flops
real(C_DOUBLE) function fftwq_estimate_cost(p) bind(C, name='fftwq_estimate_cost')
import
type(C_PTR), value :: p
end function fftwq_estimate_cost
real(C_DOUBLE) function fftwq_cost(p) bind(C, name='fftwq_cost')
import
type(C_PTR), value :: p
end function fftwq_cost
integer(C_INT) function fftwq_alignment_of(p) bind(C, name='fftwq_alignment_of')
import
real(16), dimension(*), intent(out) :: p
end function fftwq_alignment_of
end interface

1017
Desktop_Interface/build_win/fftw/x64/libfftw3-3.def Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3-3.dll Normal file
View File

Binary file not shown.

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3-3.exp Normal file
View File

Binary file not shown.

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3-3.lib Normal file
View File

Binary file not shown.

1017
Desktop_Interface/build_win/fftw/x64/libfftw3f-3.def Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3f-3.dll Normal file
View File

Binary file not shown.

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3f-3.exp Normal file
View File

Binary file not shown.

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3f-3.lib Normal file
View File

Binary file not shown.

634
Desktop_Interface/build_win/fftw/x64/libfftw3l-3.def Normal file
View File

@ -0,0 +1,634 @@
LIBRARY libfftw3l-3.dll
EXPORTS
fftwl_alignment_of
fftwl_alloc_complex
fftwl_alloc_real
fftwl_assertion_failed
fftwl_bufdist
fftwl_choose_radix
fftwl_cleanup
fftwl_cleanup_threads
fftwl_codelet_e01_8
fftwl_codelet_e10_8
fftwl_codelet_hb_10
fftwl_codelet_hb_12
fftwl_codelet_hb_15
fftwl_codelet_hb_16
fftwl_codelet_hb_2
fftwl_codelet_hb_20
fftwl_codelet_hb2_16
fftwl_codelet_hb2_20
fftwl_codelet_hb2_25
fftwl_codelet_hb2_32
fftwl_codelet_hb2_4
fftwl_codelet_hb_25
fftwl_codelet_hb2_5
fftwl_codelet_hb2_8
fftwl_codelet_hb_3
fftwl_codelet_hb_32
fftwl_codelet_hb_4
fftwl_codelet_hb_5
fftwl_codelet_hb_6
fftwl_codelet_hb_64
fftwl_codelet_hb_7
fftwl_codelet_hb_8
fftwl_codelet_hb_9
fftwl_codelet_hc2cb_10
fftwl_codelet_hc2cb_12
fftwl_codelet_hc2cb_16
fftwl_codelet_hc2cb_2
fftwl_codelet_hc2cb_20
fftwl_codelet_hc2cb2_16
fftwl_codelet_hc2cb2_20
fftwl_codelet_hc2cb2_32
fftwl_codelet_hc2cb2_4
fftwl_codelet_hc2cb2_8
fftwl_codelet_hc2cb_32
fftwl_codelet_hc2cb_4
fftwl_codelet_hc2cb_6
fftwl_codelet_hc2cb_8
fftwl_codelet_hc2cbdft_10
fftwl_codelet_hc2cbdft_12
fftwl_codelet_hc2cbdft_16
fftwl_codelet_hc2cbdft_2
fftwl_codelet_hc2cbdft_20
fftwl_codelet_hc2cbdft2_16
fftwl_codelet_hc2cbdft2_20
fftwl_codelet_hc2cbdft2_32
fftwl_codelet_hc2cbdft2_4
fftwl_codelet_hc2cbdft2_8
fftwl_codelet_hc2cbdft_32
fftwl_codelet_hc2cbdft_4
fftwl_codelet_hc2cbdft_6
fftwl_codelet_hc2cbdft_8
fftwl_codelet_hc2cf_10
fftwl_codelet_hc2cf_12
fftwl_codelet_hc2cf_16
fftwl_codelet_hc2cf_2
fftwl_codelet_hc2cf_20
fftwl_codelet_hc2cf2_16
fftwl_codelet_hc2cf2_20
fftwl_codelet_hc2cf2_32
fftwl_codelet_hc2cf2_4
fftwl_codelet_hc2cf2_8
fftwl_codelet_hc2cf_32
fftwl_codelet_hc2cf_4
fftwl_codelet_hc2cf_6
fftwl_codelet_hc2cf_8
fftwl_codelet_hc2cfdft_10
fftwl_codelet_hc2cfdft_12
fftwl_codelet_hc2cfdft_16
fftwl_codelet_hc2cfdft_2
fftwl_codelet_hc2cfdft_20
fftwl_codelet_hc2cfdft2_16
fftwl_codelet_hc2cfdft2_20
fftwl_codelet_hc2cfdft2_32
fftwl_codelet_hc2cfdft2_4
fftwl_codelet_hc2cfdft2_8
fftwl_codelet_hc2cfdft_32
fftwl_codelet_hc2cfdft_4
fftwl_codelet_hc2cfdft_6
fftwl_codelet_hc2cfdft_8
fftwl_codelet_hf_10
fftwl_codelet_hf_12
fftwl_codelet_hf_15
fftwl_codelet_hf_16
fftwl_codelet_hf_2
fftwl_codelet_hf_20
fftwl_codelet_hf2_16
fftwl_codelet_hf2_20
fftwl_codelet_hf2_25
fftwl_codelet_hf2_32
fftwl_codelet_hf2_4
fftwl_codelet_hf_25
fftwl_codelet_hf2_5
fftwl_codelet_hf2_8
fftwl_codelet_hf_3
fftwl_codelet_hf_32
fftwl_codelet_hf_4
fftwl_codelet_hf_5
fftwl_codelet_hf_6
fftwl_codelet_hf_64
fftwl_codelet_hf_7
fftwl_codelet_hf_8
fftwl_codelet_hf_9
fftwl_codelet_n1_10
fftwl_codelet_n1_11
fftwl_codelet_n1_12
fftwl_codelet_n1_13
fftwl_codelet_n1_14
fftwl_codelet_n1_15
fftwl_codelet_n1_16
fftwl_codelet_n1_2
fftwl_codelet_n1_20
fftwl_codelet_n1_25
fftwl_codelet_n1_3
fftwl_codelet_n1_32
fftwl_codelet_n1_4
fftwl_codelet_n1_5
fftwl_codelet_n1_6
fftwl_codelet_n1_64
fftwl_codelet_n1_7
fftwl_codelet_n1_8
fftwl_codelet_n1_9
fftwl_codelet_q1_2
fftwl_codelet_q1_3
fftwl_codelet_q1_4
fftwl_codelet_q1_5
fftwl_codelet_q1_6
fftwl_codelet_q1_8
fftwl_codelet_r2cb_10
fftwl_codelet_r2cb_11
fftwl_codelet_r2cb_12
fftwl_codelet_r2cb_128
fftwl_codelet_r2cb_13
fftwl_codelet_r2cb_14
fftwl_codelet_r2cb_15
fftwl_codelet_r2cb_16
fftwl_codelet_r2cb_2
fftwl_codelet_r2cb_20
fftwl_codelet_r2cb_25
fftwl_codelet_r2cb_3
fftwl_codelet_r2cb_32
fftwl_codelet_r2cb_4
fftwl_codelet_r2cb_5
fftwl_codelet_r2cb_6
fftwl_codelet_r2cb_64
fftwl_codelet_r2cb_7
fftwl_codelet_r2cb_8
fftwl_codelet_r2cb_9
fftwl_codelet_r2cbIII_10
fftwl_codelet_r2cbIII_12
fftwl_codelet_r2cbIII_15
fftwl_codelet_r2cbIII_16
fftwl_codelet_r2cbIII_2
fftwl_codelet_r2cbIII_20
fftwl_codelet_r2cbIII_25
fftwl_codelet_r2cbIII_3
fftwl_codelet_r2cbIII_32
fftwl_codelet_r2cbIII_4
fftwl_codelet_r2cbIII_5
fftwl_codelet_r2cbIII_6
fftwl_codelet_r2cbIII_64
fftwl_codelet_r2cbIII_7
fftwl_codelet_r2cbIII_8
fftwl_codelet_r2cbIII_9
fftwl_codelet_r2cf_10
fftwl_codelet_r2cf_11
fftwl_codelet_r2cf_12
fftwl_codelet_r2cf_128
fftwl_codelet_r2cf_13
fftwl_codelet_r2cf_14
fftwl_codelet_r2cf_15
fftwl_codelet_r2cf_16
fftwl_codelet_r2cf_2
fftwl_codelet_r2cf_20
fftwl_codelet_r2cf_25
fftwl_codelet_r2cf_3
fftwl_codelet_r2cf_32
fftwl_codelet_r2cf_4
fftwl_codelet_r2cf_5
fftwl_codelet_r2cf_6
fftwl_codelet_r2cf_64
fftwl_codelet_r2cf_7
fftwl_codelet_r2cf_8
fftwl_codelet_r2cf_9
fftwl_codelet_r2cfII_10
fftwl_codelet_r2cfII_12
fftwl_codelet_r2cfII_15
fftwl_codelet_r2cfII_16
fftwl_codelet_r2cfII_2
fftwl_codelet_r2cfII_20
fftwl_codelet_r2cfII_25
fftwl_codelet_r2cfII_3
fftwl_codelet_r2cfII_32
fftwl_codelet_r2cfII_4
fftwl_codelet_r2cfII_5
fftwl_codelet_r2cfII_6
fftwl_codelet_r2cfII_64
fftwl_codelet_r2cfII_7
fftwl_codelet_r2cfII_8
fftwl_codelet_r2cfII_9
fftwl_codelet_t1_10
fftwl_codelet_t1_12
fftwl_codelet_t1_15
fftwl_codelet_t1_16
fftwl_codelet_t1_2
fftwl_codelet_t1_20
fftwl_codelet_t1_25
fftwl_codelet_t1_3
fftwl_codelet_t1_32
fftwl_codelet_t1_4
fftwl_codelet_t1_5
fftwl_codelet_t1_6
fftwl_codelet_t1_64
fftwl_codelet_t1_7
fftwl_codelet_t1_8
fftwl_codelet_t1_9
fftwl_codelet_t2_10
fftwl_codelet_t2_16
fftwl_codelet_t2_20
fftwl_codelet_t2_25
fftwl_codelet_t2_32
fftwl_codelet_t2_4
fftwl_codelet_t2_5
fftwl_codelet_t2_64
fftwl_codelet_t2_8
fftwl_compute_tilesz
fftwl_configure_planner
fftwl_cost
fftwl_cpy1d
fftwl_cpy2d
fftwl_cpy2d_ci
fftwl_cpy2d_co
fftwl_cpy2d_pair
fftwl_cpy2d_pair_ci
fftwl_cpy2d_pair_co
fftwl_cpy2d_tiled
fftwl_cpy2d_tiledbuf
fftwl_ct_applicable
fftwl_ct_genericbuf_register
fftwl_ct_generic_register
fftwl_ct_uglyp
fftwl_destroy_plan
fftwl_dft_bluestein_register
fftwl_dft_buffered_register
fftwl_dft_conf_standard
fftwl_dft_generic_register
fftwl_dft_indirect_register
fftwl_dft_indirect_transpose_register
fftwl_dft_nop_register
fftwl_dft_r2hc_register
fftwl_dft_rader_register
fftwl_dft_rank_geq2_register
fftwl_dft_solve
fftwl_dft_thr_vrank_geq1_register
fftwl_dft_vrank_geq1_register
fftwl_dft_zerotens
fftwl_dht_r2hc_register
fftwl_dht_rader_register
fftwl_dimcmp
fftwl_elapsed_since
fftwl_estimate_cost
fftwl_execute
fftwl_execute_dft
fftwl_execute_dft_c2r
fftwl_execute_dft_r2c
fftwl_execute_r2r
fftwl_execute_split_dft
fftwl_execute_split_dft_c2r
fftwl_execute_split_dft_r2c
fftwl_export_wisdom
fftwl_export_wisdom_to_file
fftwl_export_wisdom_to_filename
fftwl_export_wisdom_to_string
fftwl_extract_reim
fftwl_factors_into
fftwl_factors_into_small_primes
fftwl_find_generator
fftwl_first_divisor
fftwl_flops
fftwl_forget_wisdom
fftwl_fprint_plan
fftwl_free
fftwl_get_crude_time
fftwl_guru64_kosherp
fftwl_guru_kosherp
fftwl_hash
fftwl_hc2hc_applicable
fftwl_hc2hc_generic_register
fftwl_iabs
fftwl_ialignment_of
fftwl_iestimate_cost
fftwl_ifree
fftwl_ifree0
fftwl_imax
fftwl_imin
fftwl_import_system_wisdom
fftwl_import_wisdom
fftwl_import_wisdom_from_file
fftwl_import_wisdom_from_filename
fftwl_import_wisdom_from_string
fftwl_init_threads
fftwl_is_prime
fftwl_isqrt
fftwl_ithreads_init
fftwl_kdft_dif_register
fftwl_kdft_difsq_register
fftwl_kdft_dit_register
fftwl_kdft_register
fftwl_kernel_free
fftwl_kernel_malloc
fftwl_khc2c_register
fftwl_khc2hc_register
fftwl_kr2c_register
fftwl_kr2r_register
fftwl_make_planner_thread_safe
fftwl_malloc
fftwl_malloc_plain
fftwl_many_kosherp
fftwl_mapflags
fftwl_map_r2r_kind
fftwl_md5begin
fftwl_md5end
fftwl_md5int
fftwl_md5INT
fftwl_md5putb
fftwl_md5putc
fftwl_md5puts
fftwl_md5unsigned
fftwl_measure_execution_time
fftwl_mkapiplan
fftwl_mkplan
fftwl_mkplan_d
fftwl_mkplan_dft
fftwl_mkplan_dftw
fftwl_mkplan_f_d
fftwl_mkplan_hc2c
fftwl_mkplan_hc2hc
fftwl_mkplanner
fftwl_mkplan_rdft
fftwl_mkplan_rdft2
fftwl_mkprinter
fftwl_mkprinter_cnt
fftwl_mkprinter_file
fftwl_mkprinter_str
fftwl_mkproblem
fftwl_mkproblem_dft
fftwl_mkproblem_dft_d
fftwl_mkproblem_rdft
fftwl_mkproblem_rdft_0_d
fftwl_mkproblem_rdft_1
fftwl_mkproblem_rdft_1_d
fftwl_mkproblem_rdft2
fftwl_mkproblem_rdft2_d
fftwl_mkproblem_rdft2_d_3pointers
fftwl_mkproblem_rdft_d
fftwl_mkproblem_unsolvable
fftwl_mkscanner
fftwl_mksolver
fftwl_mksolver_ct
fftwl_mksolver_ct_threads
fftwl_mksolver_dft_direct
fftwl_mksolver_dft_directbuf
fftwl_mksolver_hc2c
fftwl_mksolver_hc2hc
fftwl_mksolver_hc2hc_threads
fftwl_mksolver_rdft2_direct
fftwl_mksolver_rdft_r2c_direct
fftwl_mksolver_rdft_r2c_directbuf
fftwl_mksolver_rdft_r2r_direct
fftwl_mktensor
fftwl_mktensor_0d
fftwl_mktensor_1d
fftwl_mktensor_2d
fftwl_mktensor_3d
fftwl_mktensor_4d
fftwl_mktensor_5d
fftwl_mktensor_iodims
fftwl_mktensor_iodims64
fftwl_mktensor_rowmajor
fftwl_mktriggen
fftwl_modulo
fftwl_nbuf
fftwl_nbuf_redundant
fftwl_next_prime
fftwl_null_awake
fftwl_ops_add
fftwl_ops_add2
fftwl_ops_cpy
fftwl_ops_madd
fftwl_ops_madd2
fftwl_ops_other
fftwl_ops_zero
fftwl_pickdim
fftwl_plan_awake
fftwl_plan_destroy_internal
fftwl_plan_dft
fftwl_plan_dft_1d
fftwl_plan_dft_2d
fftwl_plan_dft_3d
fftwl_plan_dft_c2r
fftwl_plan_dft_c2r_1d
fftwl_plan_dft_c2r_2d
fftwl_plan_dft_c2r_3d
fftwl_plan_dft_r2c
fftwl_plan_dft_r2c_1d
fftwl_plan_dft_r2c_2d
fftwl_plan_dft_r2c_3d
fftwl_plan_guru64_dft
fftwl_plan_guru64_dft_c2r
fftwl_plan_guru64_dft_r2c
fftwl_plan_guru64_r2r
fftwl_plan_guru64_split_dft
fftwl_plan_guru64_split_dft_c2r
fftwl_plan_guru64_split_dft_r2c
fftwl_plan_guru_dft
fftwl_plan_guru_dft_c2r
fftwl_plan_guru_dft_r2c
fftwl_plan_guru_r2r
fftwl_plan_guru_split_dft
fftwl_plan_guru_split_dft_c2r
fftwl_plan_guru_split_dft_r2c
fftwl_plan_many_dft
fftwl_plan_many_dft_c2r
fftwl_plan_many_dft_r2c
fftwl_plan_many_r2r
fftwl_planner_destroy
fftwl_plan_null_destroy
fftwl_plan_r2r
fftwl_plan_r2r_1d
fftwl_plan_r2r_2d
fftwl_plan_r2r_3d
fftwl_plan_with_nthreads
fftwl_power_mod
fftwl_printer_destroy
fftwl_print_plan
fftwl_problem_destroy
fftwl_rader_tl_delete
fftwl_rader_tl_find
fftwl_rader_tl_insert
fftwl_rdft2_buffered_register
fftwl_rdft2_complex_n
fftwl_rdft2_inplace_strides
fftwl_rdft2_nop_register
fftwl_rdft2_pad
fftwl_rdft2_rank0_register
fftwl_rdft2_rank_geq2_register
fftwl_rdft2_rdft_register
fftwl_rdft2_solve
fftwl_rdft2_strides
fftwl_rdft2_tensor_max_index
fftwl_rdft2_thr_vrank_geq1_register
fftwl_rdft2_vrank_geq1_register
fftwl_rdft_buffered_register
fftwl_rdft_conf_standard
fftwl_rdft_dht_register
fftwl_rdft_generic_register
fftwl_rdft_indirect_register
fftwl_rdft_kind_str
fftwl_rdft_nop_register
fftwl_rdft_rank0_register
fftwl_rdft_rank_geq2_register
fftwl_rdft_solve
fftwl_rdft_thr_vrank_geq1_register
fftwl_rdft_vrank3_transpose_register
fftwl_rdft_vrank_geq1_register
fftwl_rdft_zerotens
fftwl_redft00e_r2hc_pad_register
fftwl_regsolver_ct_directw
fftwl_regsolver_ct_directwsq
fftwl_regsolver_hc2c_direct
fftwl_regsolver_hc2hc_direct
fftwl_reodft00e_splitradix_register
fftwl_reodft010e_r2hc_register
fftwl_reodft11e_r2hc_odd_register
fftwl_reodft11e_radix2_r2hc_register
fftwl_reodft_conf_standard
fftwl_rodft00e_r2hc_pad_register
fftwl_safe_mulmod
fftwl_scanner_destroy
fftwl_set_planner_hooks
fftwl_set_timelimit
fftwl_solver_destroy
fftwl_solver_register
fftwl_solver_use
fftwl_solvtab_exec
fftwl_spawn_loop
fftwl_sprint_plan
fftwl_tensor_append
fftwl_tensor_compress
fftwl_tensor_compress_contiguous
fftwl_tensor_copy
fftwl_tensor_copy_except
fftwl_tensor_copy_inplace
fftwl_tensor_copy_sub
fftwl_tensor_destroy
fftwl_tensor_destroy2
fftwl_tensor_destroy4
fftwl_tensor_equal
fftwl_tensor_inplace_locations
fftwl_tensor_inplace_strides
fftwl_tensor_inplace_strides2
fftwl_tensor_kosherp
fftwl_tensor_max_index
fftwl_tensor_md5
fftwl_tensor_min_istride
fftwl_tensor_min_ostride
fftwl_tensor_min_stride
fftwl_tensor_print
fftwl_tensor_split
fftwl_tensor_strides_decrease
fftwl_tensor_sz
fftwl_tensor_tornk1
fftwl_the_planner
fftwl_threads_cleanup
fftwl_threads_conf_standard
fftwl_threads_register_planner_hooks
fftwl_tile2d
fftwl_toobig
fftwl_transpose
fftwl_transpose_tiled
fftwl_transpose_tiledbuf
fftwl_triggen_destroy
fftwl_twiddle_awake
fftwl_twiddle_length
fftwl_zero1d_pair
lfftw_cleanup_
lfftw_cleanup__
lfftw_cleanup_threads_
lfftw_cleanup_threads__
lfftw_cost_
lfftw_cost__
lfftw_destroy_plan_
lfftw_destroy_plan__
lfftw_estimate_cost_
lfftw_estimate_cost__
lfftw_execute_
lfftw_execute__
lfftw_execute_dft_
lfftw_execute_dft__
lfftw_execute_dft_c2r_
lfftw_execute_dft_c2r__
lfftw_execute_dft_r2c_
lfftw_execute_dft_r2c__
lfftw_execute_r2r_
lfftw_execute_r2r__
lfftw_execute_split_dft_
lfftw_execute_split_dft__
lfftw_execute_split_dft_c2r_
lfftw_execute_split_dft_c2r__
lfftw_execute_split_dft_r2c_
lfftw_execute_split_dft_r2c__
lfftw_export_wisdom_
lfftw_export_wisdom__
lfftw_flops_
lfftw_flops__
lfftw_forget_wisdom_
lfftw_forget_wisdom__
lfftw_import_system_wisdom_
lfftw_import_system_wisdom__
lfftw_import_wisdom_
lfftw_import_wisdom__
lfftw_init_threads_
lfftw_init_threads__
lfftw_plan_dft_
lfftw_plan_dft__
lfftw_plan_dft_1d_
lfftw_plan_dft_1d__
lfftw_plan_dft_2d_
lfftw_plan_dft_2d__
lfftw_plan_dft_3d_
lfftw_plan_dft_3d__
lfftw_plan_dft_c2r_
lfftw_plan_dft_c2r__
lfftw_plan_dft_c2r_1d_
lfftw_plan_dft_c2r_1d__
lfftw_plan_dft_c2r_2d_
lfftw_plan_dft_c2r_2d__
lfftw_plan_dft_c2r_3d_
lfftw_plan_dft_c2r_3d__
lfftw_plan_dft_r2c_
lfftw_plan_dft_r2c__
lfftw_plan_dft_r2c_1d_
lfftw_plan_dft_r2c_1d__
lfftw_plan_dft_r2c_2d_
lfftw_plan_dft_r2c_2d__
lfftw_plan_dft_r2c_3d_
lfftw_plan_dft_r2c_3d__
lfftw_plan_guru_dft_
lfftw_plan_guru_dft__
lfftw_plan_guru_dft_c2r_
lfftw_plan_guru_dft_c2r__
lfftw_plan_guru_dft_r2c_
lfftw_plan_guru_dft_r2c__
lfftw_plan_guru_r2r_
lfftw_plan_guru_r2r__
lfftw_plan_guru_split_dft_
lfftw_plan_guru_split_dft__
lfftw_plan_guru_split_dft_c2r_
lfftw_plan_guru_split_dft_c2r__
lfftw_plan_guru_split_dft_r2c_
lfftw_plan_guru_split_dft_r2c__
lfftw_plan_many_dft_
lfftw_plan_many_dft__
lfftw_plan_many_dft_c2r_
lfftw_plan_many_dft_c2r__
lfftw_plan_many_dft_r2c_
lfftw_plan_many_dft_r2c__
lfftw_plan_many_r2r_
lfftw_plan_many_r2r__
lfftw_plan_r2r_
lfftw_plan_r2r__
lfftw_plan_r2r_1d_
lfftw_plan_r2r_1d__
lfftw_plan_r2r_2d_
lfftw_plan_r2r_2d__
lfftw_plan_r2r_3d_
lfftw_plan_r2r_3d__
lfftw_plan_with_nthreads_
lfftw_plan_with_nthreads__
lfftw_print_plan_
lfftw_print_plan__
lfftw_set_timelimit_
lfftw_set_timelimit__

BIN
Desktop_Interface/build_win/fftw/x64/libfftw3l-3.dll Normal file
View File

Binary file not shown.

340
Desktop_Interface/build_win/fftw/x86/COPYING Normal file
View File

@ -0,0 +1,340 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

19
Desktop_Interface/build_win/fftw/x86/COPYRIGHT Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright (c) 2003, 2007-14 Matteo Frigo
* Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/

592
Desktop_Interface/build_win/fftw/x86/NEWS Normal file
View File

@ -0,0 +1,592 @@
FFTW 3.3.5:
* New SIMD support:
- Power8 VSX instructions in single and double precision.
To use, add --enable-vsx to configure.
- Support for AVX2 (256-bit FMA instructions).
To use, add --enable-avx2 to configure.
- Experimental support for AVX512 and KCVI. (--enable-avx512, --enable-kcvi)
This code is expected to work but the FFTW maintainers do not have
hardware to test it.
- Support for AVX128/FMA (for some AMD machines) (--enable-avx128-fma)
- Double precision Neon SIMD for aarch64.
This code is expected to work but the FFTW maintainers do not have
hardware to test it.
- generic SIMD support using gcc vector intrinsics
* Add fftw_make_planner_thread_safe() API
* fix #18 (disable float128 for CUDACC)
* fix #19: missing Fortran interface for fftwq_alloc_real
* fix #21 (don't use float128 on Portland compilers, which pretend to be gcc)
* fix: Avoid segfaults due to double free in MPI transpose
* Special note for distribution maintainers: Although FFTW supports a
zillion SIMD instruction sets, enabling them all at the same time is
a bad idea, because it increases the planning time for minimal gain.
We recommend that general-purpose x86 distributions only enable SSE2
and perhaps AVX. Users who care about the last ounce of performance
should recompile FFTW themselves.
FFTW 3.3.4
* New functions fftw_alignment_of (to check whether two arrays are
equally aligned for the purposes of applying a plan) and fftw_sprint_plan
(to output a description of plan to a string).
* Bugfix in fftw-wisdom-to-conf; thanks to Florian Oppermann for the
bug report.
* Fixed manual to work with texinfo-5.
* Increased timing interval on x86_64 to reduce timing errors.
* Default to Win32 threads, not pthreads, if both are present.
* Various build-script fixes.
FFTW 3.3.3
* Fix deadlock bug in MPI transforms (thanks to Michael Pippig for the
bug report and patch, and to Graham Dennis for the bug report).
* Use 128-bit ARM NEON instructions instead of 64-bits. This change
appears to speed up even ARM processors with a 64-bit NEON pipe.
* Speed improvements for single-precision AVX.
* Speed up planner on machines without "official" cycle counters, such as ARM.
FFTW 3.3.2
* Removed an archaic stack-alignment hack that was failing with
gcc-4.7/i386.
* Added stack-alignment hack necessary for gcc on Windows/i386. We
will regret this in ten years (see previous change).
* Fix incompatibility with Intel icc which pretends to be gcc
but does not support quad precision.
* make libfftw{threads,mpi} depend upon libfftw when using libtool;
this is consistent with most other libraries and simplifies the life
of various distributors of GNU/Linux.
FFTW 3.3.1
* Changes since 3.3.1-beta1:
- Reduced planning time in estimate mode for sizes with large
prime factors.
- Added AVX autodetection under Visual Studio. Thanks Carsten
Steger for submitting the necessary code.
- Modern Fortran interface now uses a separate fftw3l.f03 interface
file for the long double interface, which is not supported by
some Fortran compilers. Provided new fftw3q.f03 interface file
to access the quadruple-precision FFTW routines with recent
versions of gcc/gfortran.
* Added support for the NEON extensions to the ARM ISA. (Note to beta
users: an ARM cycle counter is not yet implemented; please contact
fftw@fftw.org if you know how to do it right.)
* MPI code now compiles even if mpicc is a C++ compiler; thanks to
Kyle Spyksma for the bug report.
FFTW 3.3
* Changes since 3.3-beta1:
- Compiling OpenMP support (--enable-openmp) now installs a
fftw3_omp library, instead of fftw3_threads, so that OpenMP
and POSIX threads (--enable-threads) libraries can be built
and installed at the same time.
- Various minor compilation fixes, corrections of manual typos, and
improvements to the benchmark test program.
* Add support for the AVX extensions to x86 and x86-64. The AVX code
works with 16-byte alignment (as opposed to 32-byte alignment),
so there is no ABI change compared to FFTW 3.2.2.
* Added Fortran 2003 interface, which should be usable on most modern
Fortran compilers (e.g. gfortran) and provides type-checked access
to the the C FFTW interface. (The legacy Fortran-77 interface is
still included also.)
* Added MPI distributed-memory transforms. Compared to 3.3alpha,
the major changes in the MPI transforms are:
- Fixed some deadlock and crashing bugs.
- Added Fortran 2003 interface.
- Added new-array execute functions for MPI plans.
- Eliminated use of large MPI tags, since Cray MPI requires tags < 2^24;
thanks to Jonathan Bentz for the bug report.
- Expanded documentation.
- 'make check' now runs MPI tests
- Some ABI changes - not binary-compatible with 3.3alpha MPI.
* Add support for quad-precision __float128 in gcc 4.6 or later (on x86.
x86-64, and Itanium). The new routines use the fftwq_ prefix.
* Removed support for MIPS paired-single instructions due to lack of
available hardware for testing. Users who want this functionality
should continue using FFTW 3.2.x. (Note that FFTW 3.3 still works
on MIPS; this only concerns special instructions available on some
MIPS chips.)
* Removed support for the Cell Broadband Engine. Cell users should
use FFTW 3.2.x.
* New convenience functions fftw_alloc_real and fftw_alloc_complex
to use fftw_malloc for real and complex arrays without typecasts
or sizeof.
* New convenience functions fftw_export_wisdom_to_filename and
fftw_import_wisdom_from_filename that export/import wisdom
to a file, which don't require you to open/close the file yourself.
* New function fftw_cost to return FFTW's internal cost metric for
a given plan; thanks to Rhys Ulerich and Nathanael Schaeffer for the
suggestion.
* The --enable-sse2 configure flag now works in both double and single
precision (and is equivalent to --enable-sse in the latter case).
* Remove --enable-portable-binary flag: we new produce portable binaries
by default.
* Remove the automatic detection of native architecture flag for gcc
which was introduced in fftw-3.1, since new gcc supports -mtune=native.
Remove the --with-gcc-arch flag; if you want to specify a particlar
arch to configure, use ./configure CC="gcc -mtune=...".
* --with-our-malloc16 configure flag is now renamed --with-our-malloc.
* Fixed build problem failure when srand48 declaration is missing;
thanks to Ralf Wildenhues for the bug report.
* Fixed bug in fftw_set_timelimit: ensure that a negative timelimit
is equivalent to no timelimit in all cases. Thanks to William Andrew
Burnson for the bug report.
* Fixed stack-overflow problem on OpenBSD caused by using alloca with
too large a buffer.
FFTW 3.2.2
* Improve performance of some copy operations of complex arrays on
x86 machines.
* Add configure flag to disable alloca(), which is broken in mingw64.
* Planning in FFTW_ESTIMATE mode for r2r transforms became slower
between fftw-3.1.3 and 3.2. This regression has now been fixed.
FFTW 3.2.1
* Performance improvements for some multidimensional r2c/c2r transforms;
thanks to Eugene Miloslavsky for his benchmark reports.
* Compile with icc on MacOS X, use better icc compiler flags.
* Compilation fixes for systems where snprintf is defined as a macro;
thanks to Marcus Mae for the bug report.
* Fortran documentation now recommends not using dfftw_execute,
because of reports of problems with various Fortran compilers;
it is better to use dfftw_execute_dft etcetera.
* Some documentation clarifications, e.g. of fact that --enable-openmp
and --enable-threads are mutually exclusive (thanks to Long To),
and document slightly odd behavior of plan_guru_r2r in Fortran
(thanks to Alexander Pozdneev).
* FAQ was accidentally omitted from 3.2 tarball.
* Remove some extraneous (harmless) files accidentally included in
a subdirectory of the 3.2 tarball.
FFTW 3.2
* Worked around apparent glibc bug that leads to rare hangs when freeing
semaphores.
* Fixed segfault due to unaligned access in certain obscure problems
that use SSE and multiple threads.
* MPI transforms not included, as they are still in alpha; the alpha
versions of the MPI transforms have been moved to FFTW 3.3alpha1.
FFTW 3.2alpha3
* Performance improvements for sizes with factors of 5 and 10.
* Documented FFTW_WISDOM_ONLY flag, at the suggestion of Mario
Emmenlauer and Phil Dumont.
* Port Cell code to SDK2.1 (libspe2), as opposed to the old libspe1 code.
* Performance improvements in Cell code for N < 32k, thanks to Jan Wagner
for the suggestions.
* Cycle counter for Sun x86_64 compiler, and compilation fix in cycle
counter for AIX/xlc (thanks to Jeff Haferman for the bug report).
* Fixed incorrect type prefix in MPI code that prevented wisdom routines
from working in single precision (thanks to Eric A. Borisch for the report).
* Added 'make check' for MPI code (which still fails in a couple corner
cases, but should be much better than in alpha2).
* Many other small fixes.
FFTW 3.2alpha2
* Support for the Cell processor, donated by IBM Research; see README.Cell
and the Cell section of the manual.
* New 64-bit API: for every "plan_guru" function there is a new "plan_guru64"
function with the same semantics, but which takes fftw_iodim64 instead of
fftw_iodim. fftw_iodim64 is the same as fftw_iodim, except that it takes
ptrdiff_t integer types as parameters, which is a 64-bit type on
64-bit machines. This is only useful for specifying very large transforms
on 64-bit machines. (Internally, FFTW uses ptrdiff_t everywhere
regardless of what API you choose.)
* Experimental MPI support. Complex one- and multi-dimensional FFTs,
multi-dimensional r2r, multi-dimensional r2c/c2r transforms, and
distributed transpose operations, with 1d block distributions.
(This is an alpha preview: routines have not been exhaustively
tested, documentation is incomplete, and some functionality is
missing, e.g. Fortran support.) See mpi/README and also the MPI
section of the manual.
* Significantly faster r2c/c2r transforms, especially on machines with SIMD.
* Rewritten multi-threaded support for better performance by
re-using a fixed pool of threads rather than continually
respawning and joining (which nowadays is much slower).
* Support for MIPS paired-single SIMD instructions, donated by
Codesourcery.
* FFTW_WISDOM_ONLY planner flag, to create plan only if wisdom is
available and return NULL otherwise.
* Removed k7 support, which only worked in 32-bit mode and is
becoming obsolete. Use --enable-sse instead.
* Added --with-g77-wrappers configure option to force inclusion
of g77 wrappers, in addition to whatever is needed for the
detected Fortran compilers. This is mainly intended for GNU/Linux
distros switching to gfortran that wish to include both
gfortran and g77 support in FFTW.
* In manual, renamed "guru execute" functions to "new-array execute"
functions, to reduce confusion with the guru planner interface.
(The programming interface is unchanged.)
* Add missing __declspec attribute to threads API functions when compiling
for Windows; thanks to Robert O. Morris for the bug report.
* Fixed missing return value from dfftw_init_threads in Fortran;
thanks to Markus Wetzstein for the bug report.
FFTW 3.1.3
* Bug fix: FFTW computes incorrect results when the user plans both
REDFT11 and RODFT11 transforms of certain sizes. The bug is caused
by incorrect sharing of twiddle-factor tables between the two
transforms, and only occurs when both are used. Thanks to Paul
A. Valiant for the bug report.
FFTW 3.1.2
* Correct bug in configure script: --enable-portable-binary option was ignored!
Thanks to Andrew Salamon for the bug report.
* Threads compilation fix on AIX: prefer xlc_r to cc_r, and don't use
either if we are using gcc. Thanks to Guy Moebs for the bug report.
* Updated FAQ to note that Apple gcc 4.0.1 on MacOS/Intel is broken,
and suggest a workaround. configure script now detects Core/Duo arch.
* Use -maltivec when checking for altivec.h. Fixes Gentoo bug #129304,
thanks to Markus Dittrich.
FFTW 3.1.1
* Performance improvements for Intel EMT64.
* Performance improvements for large-size transforms with SIMD.
* Cycle counter support for Intel icc and Visual C++ on x86-64.
* In fftw-wisdom tool, replaced obsolete --impatient with --measure.
* Fixed compilation failure with AIX/xlc; thanks to Joseph Thomas.
* Windows DLL support for Fortran API (added missing __declspec(dllexport)).
* SSE/SSE2 code works properly (i.e. disables itself) on older 386 and 486
CPUs lacking a CPUID instruction; thanks to Eric Korpela.
FFTW 3.1
* Faster FFTW_ESTIMATE planner.
* New (faster) algorithm for REDFT00/RODFT00 (type-I DCT/DST) of odd size.
* "4-step" algorithm for faster FFTs of very large sizes (> 2^18).
* Faster in-place real-data DFTs (for R2HC and HC2R r2r formats).
* Faster in-place non-square transpositions (FFTW uses these internally
for in-place FFTs, and you can also perform them explicitly using
the guru interface).
* Faster prime-size DFTs: implemented Bluestein's algorithm, as well
as a zero-padded Rader variant to limit recursive use of Rader's algorithm.
* SIMD support for split complex arrays.
* Much faster Altivec/VMX performance.
* New fftw_set_timelimit function to specify a (rough) upper bound to the
planning time (does not affect ESTIMATE mode).
* Removed --enable-3dnow support; use --enable-k7 instead.
* FMA (fused multiply-add) version is now included in "standard" FFTW,
and is enabled with --enable-fma (the default on PowerPC and Itanium).
* Automatic detection of native architecture flag for gcc. New
configure options: --enable-portable-binary and --with-gcc-arch=<arch>,
for people distributing compiled binaries of FFTW (see manual).
* Automatic detection of Altivec under Linux with gcc 3.4 (so that
same binary should work on both Altivec and non-Altivec PowerPCs).
* Compiler-specific tweaks/flags/workarounds for gcc 3.4, xlc, HP/UX,
Solaris/Intel.
* Various documentation clarifications.
* 64-bit clean. (Fixes a bug affecting the split guru planner on
64-bit machines, reported by David Necas.)
* Fixed Debian bug #259612: inadvertent use of SSE instructions on
non-SSE machines (causing a crash) for --enable-sse binaries.
* Fixed bug that caused HC2R transforms to destroy the input in
certain cases, even if the user specified FFTW_PRESERVE_INPUT.
* Fixed bug where wisdom would be lost under rare circumstances,
causing excessive planning time.
* FAQ notes bug in gcc-3.4.[1-3] that causes FFTW to crash with SSE/SSE2.
* Fixed accidentally exported symbol that prohibited simultaneous
linking to double/single multithreaded FFTW (thanks to Alessio Massaro).
* Support Win32 threads under MinGW (thanks to Alessio Massaro).
* Fixed problem with building DLL under Cygwin; thanks to Stephane Fillod.
* Fix build failure if no Fortran compiler is found (thanks to Charles
Radley for the bug report).
* Fixed compilation failure with icc 8.0 and SSE/SSE2. Automatic
detection of icc architecture flag (e.g. -xW).
* Fixed compilation with OpenMP on AIX (thanks to Greg Bauer).
* Fixed compilation failure on x86-64 with gcc (thanks to Orion Poplawski).
* Incorporated patch from FreeBSD ports (FreeBSD does not have memalign,
but its malloc is 16-byte aligned).
* Cycle-counter compilation fixes for Itanium, Alpha, x86-64, Sparc,
MacOS (thanks to Matt Boman, John Bowman, and James A. Treacy for
reports/fixes). Added x86-64 cycle counter for PGI compilers,
courtesy Cristiano Calonaci.
* Fix compilation problem in test program due to C99 conflict.
* Portability fix for import_system_wisdom with djgpp (thanks to Juan
Manuel Guerrero).
* Fixed compilation failure on MacOS 10.3 due to getopt conflict.
* Work around Visual C++ (version 6/7) bug in SSE compilation;
thanks to Eddie Yee for his detailed report.
Changes from FFTW 3.1 beta 2:
* Several minor compilation fixes.
* Eliminate FFTW_TIMELIMIT flag and replace fftw_timelimit global with
fftw_set_timelimit function. Make wisdom work with time-limited plans.
Changes from FFTW 3.1 beta 1:
* Fixes for creating DLLs under Windows; thanks to John Pavel for his feedback.
* Fixed more 64-bit problems, thanks to John Pavel for the bug report.
* Further speed improvements for Altivec/VMX.
* Further speed improvements for non-square transpositions.
* Many minor tweaks.
FFTW 3.0.1
* Some speed improvements in SIMD code.
* --without-cycle-counter option is removed. If no cycle counter is found,
then the estimator is always used. A --with-slow-timer option is provided
to force the use of lower-resolution timers.
* Several fixes for compilation under Visual C++, with help from Stefane Ruel.
* Added x86 cycle counter for Visual C++, with help from Morten Nissov.
* Added S390 cycle counter, courtesy of James Treacy.
* Added missing static keyword that prevented simultaneous linkage
of different-precision versions; thanks to Rasmus Larsen for the bug report.
* Corrected accidental omission of f77_wisdom.f file; thanks to Alan Watson.
* Support -xopenmp flag for SunOS; thanks to John Lou for the bug report.
* Compilation with HP/UX cc requires -Wp,-H128000 flag to increase
preprocessor limits; thanks to Peter Vouras for the bug report.
* Removed non-portable use of 'tempfile' in fftw-wisdom-to-conf script;
thanks to Nicolas Decoster for the patch.
* Added 'make smallcheck' target in tests/ directory, at the request of
James Treacy.
FFTW 3.0
Major goals of this release:
* Speed: often 20% or more faster than FFTW 2.x, even without SIMD (see below).
* Complete rewrite, to make it easier to add new algorithms and transforms.
* New API, to support more general semantics.
Other enhancements:
* SIMD acceleration on supporting CPUs (SSE, SSE2, 3DNow!, and AltiVec).
(With special thanks to Franz Franchetti for many experimental prototypes
and to Stefan Kral for the vectorizing generator from fftwgel.)
* True in-place 1d transforms of large sizes (as well as compressed
twiddle tables for additional memory/cache savings).
* More arbitrary placement of real & imaginary data, e.g. including
interleaved (as in FFTW 2.x) as well as separate real/imag arrays.
* Efficient prime-size transforms of real data.
* Multidimensional transforms can operate on a subset of a larger matrix,
and/or transform selected dimensions of a multidimensional array.
* By popular demand, simultaneous linking to double precision (fftw),
single precision (fftwf), and long-double precision (fftwl) versions
of FFTW is now supported.
* Cycle counters (on all modern CPUs) are exploited to speed planning.
* Efficient transforms of real even/odd arrays, a.k.a. discrete
cosine/sine transforms (types I-IV). (Currently work via pre/post
processing of real transforms, ala FFTPACK, so are not optimal.)
* DHTs (Discrete Hartley Transforms), again via post-processing
of real transforms (and thus suboptimal, for now).
* Support for linking to just those parts of FFTW that you need,
greatly reducing the size of statically linked programs when
only a limited set of transform sizes/types are required.
* Canonical global wisdom file (/etc/fftw/wisdom) on Unix, along
with a command-line tool (fftw-wisdom) to generate/update it.
* Fortran API can be used with both g77 and non-g77 compilers
simultaneously.
* Multi-threaded version has optional OpenMP support.
* Authors' good looks have greatly improved with age.
Changes from 3.0beta3:
* Separate FMA distribution to better exploit fused multiply-add instructions
on PowerPC (and possibly other) architectures.
* Performance improvements via some inlining tweaks.
* fftw_flops now returns double arguments, not int, to avoid overflows
for large sizes.
* Workarounds for automake bugs.
Changes from 3.0beta2:
* The standard REDFT00/RODFT00 (DCT-I/DST-I) algorithm (used in
FFTPACK, NR, etcetera) turns out to have poor numerical accuracy, so
we replaced it with a slower routine that is more accurate.
* The guru planner and execute functions now have two variants, one that
takes complex arguments and one that takes separate real/imag pointers.
* Execute and planner routines now automatically align the stack on x86,
in case the calling program is misaligned.
* README file for test program.
* Fixed bugs in the combination of SIMD with multi-threaded transforms.
* Eliminated internal fftw_threads_init function, which some people were
calling accidentally instead of the fftw_init_threads API function.
* Check for -openmp flag (Intel C compiler) when --enable-openmp is used.
* Support AMD x86-64 SIMD and cycle counter.
* Support SSE2 intrinsics in forthcoming gcc 3.3.
Changes from 3.0beta1:
* Faster in-place 1d transforms of non-power-of-two sizes.
* SIMD improvements for in-place, multi-dimensional, and/or non-FFTW_PATIENT
transforms.
* Added support for hard-coded DCT/DST/DHT codelets of small sizes; the
default distribution only includes hard-coded size-8 DCT-II/III, however.
* Many minor improvements to the manual. Added section on using the
codelet generator to customize and enhance FFTW.
* The default 'make check' should now only take a few minutes; for more
strenuous tests (which may take a day or so), do 'cd tests; make bigcheck'.
* fftw_print_plan is split into fftw_fprint_plan and fftw_print_plan, where
the latter uses stdout.
* Fixed ability to compile with a C++ compiler.
* Fixed support for C99 complex type under glibc.
* Fixed problems with alloca under MinGW, AIX.
* Workaround for gcc/SPARC bug.
* Fixed multi-threaded initialization failure on IRIX due to lack of
user-accessible PTHREAD_SCOPE_SYSTEM there.

54
Desktop_Interface/build_win/fftw/x86/README Normal file
View File

@ -0,0 +1,54 @@
FFTW is a free collection of fast C routines for computing the
Discrete Fourier Transform in one or more dimensions. It includes
complex, real, symmetric, and parallel transforms, and can handle
arbitrary array sizes efficiently. FFTW is typically faster than
other publically-available FFT implementations, and is even
competitive with vendor-tuned libraries. (See our web page
http://fftw.org/ for extensive benchmarks.) To achieve this
performance, FFTW uses novel code-generation and runtime
self-optimization techniques (along with many other tricks).
The doc/ directory contains the manual in texinfo, PDF, info, and HTML
formats. Frequently asked questions and answers can be found in the
doc/FAQ/ directory in ASCII and HTML.
For a quick introduction to calling FFTW, see the "Tutorial" section
of the manual.
INSTALLATION
------------
INSTALLATION FROM AN OFFICIAL RELEASE:
Please read chapter 10 "Installation and Customization" of the manual.
In short:
./configure
make
make install
INSTALLATION FROM THE GIT REPOSITORY:
First, install these programs:
ocaml, ocamlbuild, autoconf, automake, indent, and libtool,
Then, execute
sh bootstrap.sh
make
The bootstrap.sh script runs configure directly, but if you need to
re-run configure, you must pass the --enable-maintainer-mode flag:
./configure --enable-maintainer-mode [OTHER CONFIGURE FLAGS]
CONTACTS
--------
FFTW was written by Matteo Frigo and Steven G. Johnson. You can
contact them at fftw@fftw.org. The latest version of FFTW,
benchmarks, links, and other information can be found at the FFTW home
page (http://www.fftw.org). You can also sign up to the fftw-announce
Google group to receive (infrequent) updates and information about new
releases.

22
Desktop_Interface/build_win/fftw/x86/README-WINDOWS Normal file
View File

@ -0,0 +1,22 @@
This .zip archive contains DLL libraries and the associated header (.h)
and module-definition (.def) files of FFTW compiled for Win32. It
also contains the corresponding bench.exe test/benchmark programs
and wisdom utilities.
There are three libraries: single precision (float), double precision,
and extended precision (long double). To use the third library,
your compiler must have sizeof(long double) == 12.
In order to link to these .dll files from Visual C++, you need to
create .lib "import libraries" for them, and can do so with the "lib"
command that comes with VC++. In particular, run:
lib /def:libfftw3f-3.def
lib /def:libfftw3-3.def
lib /def:libfftw3l-3.def
The single- and double-precision libraries use SSE and SSE2, respectively,
but should also work on older processors (the library checks at runtime
to see whether SSE/SSE2 is supported and disables the relevant code if not).
They were compiled by the GNU C compiler for MinGW, specifically:
i686-w64-mingw32-gcc (GCC) 4.9.1

73
Desktop_Interface/build_win/fftw/x86/README-bench Normal file
View File

@ -0,0 +1,73 @@
This directory contains a benchmarking and testing program
for fftw3.
The `bench' program has a zillion options, because we use it for
benchmarking other FFT libraries as well. This file only documents
the basic usage of bench.
Usage: bench <commands>
where each command is as follows:
-s <problem>
--speed <problem>
Benchmarks the speed of <problem>.
The syntax for problems is [i|o][r|c][f|b]<size>, where
i/o means in-place or out-of-place. Out of place is the default.
r/c means real or complex transform. Complex is the default.
f/b means forward or backward transform. Forward is the default.
<size> is an arbitrary multidimensional sequence of integers
separated by the character 'x'.
(The syntax for problems is actually richer, but we do not document
it here. See the man page for fftw-wisdom for more information.)
Example:
ib256 : in-place backward complex transform of size 256
32x64 : out-of-place forward complex 2D transform of 32 rows
and 64 columns.
-y <problem>
--verify <problem>
Verify that FFTW is computing the correct answer.
The program does not output anything unless an error occurs or
verbosity is at least one.
-v<n>
Set verbosity to <n>, or 1 if <n> is omitted. -v2 will output
the created plans with fftw_print_plan.
-oestimate
-opatient
-oexhaustive
Plan with FFTW_ESTIMATE, FFTW_PATIENT, or FFTW_EXHAUSTIVE, respectively.
The default is FFTW_MEASURE.
If you benchmark FFTW, please use -opatient.
-onthreads=N
Use N threads, if FFTW was compiled with --enable-threads. N
must be a positive integer; the default is N=1.
-onosimd
Disable SIMD instructions (e.g. SSE or SSE2).
-ounaligned
Plan with the FFTW_UNALIGNED flag.
-owisdom
On startup, read wisdom from a file wis.dat in the current directory
(if it exists). On completion, write accumulated wisdom to wis.dat
(overwriting any existing file of that name).

72
Desktop_Interface/build_win/fftw/x86/fftw3.f Normal file
View File

@ -0,0 +1,72 @@
INTEGER FFTW_R2HC
PARAMETER (FFTW_R2HC=0)
INTEGER FFTW_HC2R
PARAMETER (FFTW_HC2R=1)
INTEGER FFTW_DHT
PARAMETER (FFTW_DHT=2)
INTEGER FFTW_REDFT00
PARAMETER (FFTW_REDFT00=3)
INTEGER FFTW_REDFT01
PARAMETER (FFTW_REDFT01=4)
INTEGER FFTW_REDFT10
PARAMETER (FFTW_REDFT10=5)
INTEGER FFTW_REDFT11
PARAMETER (FFTW_REDFT11=6)
INTEGER FFTW_RODFT00
PARAMETER (FFTW_RODFT00=7)
INTEGER FFTW_RODFT01
PARAMETER (FFTW_RODFT01=8)
INTEGER FFTW_RODFT10
PARAMETER (FFTW_RODFT10=9)
INTEGER FFTW_RODFT11
PARAMETER (FFTW_RODFT11=10)
INTEGER FFTW_FORWARD
PARAMETER (FFTW_FORWARD=-1)
INTEGER FFTW_BACKWARD
PARAMETER (FFTW_BACKWARD=+1)
INTEGER FFTW_MEASURE
PARAMETER (FFTW_MEASURE=0)
INTEGER FFTW_DESTROY_INPUT
PARAMETER (FFTW_DESTROY_INPUT=1)
INTEGER FFTW_UNALIGNED
PARAMETER (FFTW_UNALIGNED=2)
INTEGER FFTW_CONSERVE_MEMORY
PARAMETER (FFTW_CONSERVE_MEMORY=4)
INTEGER FFTW_EXHAUSTIVE
PARAMETER (FFTW_EXHAUSTIVE=8)
INTEGER FFTW_PRESERVE_INPUT
PARAMETER (FFTW_PRESERVE_INPUT=16)
INTEGER FFTW_PATIENT
PARAMETER (FFTW_PATIENT=32)
INTEGER FFTW_ESTIMATE
PARAMETER (FFTW_ESTIMATE=64)
INTEGER FFTW_WISDOM_ONLY
PARAMETER (FFTW_WISDOM_ONLY=2097152)
INTEGER FFTW_ESTIMATE_PATIENT
PARAMETER (FFTW_ESTIMATE_PATIENT=128)
INTEGER FFTW_BELIEVE_PCOST
PARAMETER (FFTW_BELIEVE_PCOST=256)
INTEGER FFTW_NO_DFT_R2HC
PARAMETER (FFTW_NO_DFT_R2HC=512)
INTEGER FFTW_NO_NONTHREADED
PARAMETER (FFTW_NO_NONTHREADED=1024)
INTEGER FFTW_NO_BUFFERING
PARAMETER (FFTW_NO_BUFFERING=2048)
INTEGER FFTW_NO_INDIRECT_OP
PARAMETER (FFTW_NO_INDIRECT_OP=4096)
INTEGER FFTW_ALLOW_LARGE_GENERIC
PARAMETER (FFTW_ALLOW_LARGE_GENERIC=8192)
INTEGER FFTW_NO_RANK_SPLITS
PARAMETER (FFTW_NO_RANK_SPLITS=16384)
INTEGER FFTW_NO_VRANK_SPLITS
PARAMETER (FFTW_NO_VRANK_SPLITS=32768)
INTEGER FFTW_NO_VRECURSE
PARAMETER (FFTW_NO_VRECURSE=65536)
INTEGER FFTW_NO_SIMD
PARAMETER (FFTW_NO_SIMD=131072)
INTEGER FFTW_NO_SLOW
PARAMETER (FFTW_NO_SLOW=262144)
INTEGER FFTW_NO_FIXED_RADIX_LARGE_N
PARAMETER (FFTW_NO_FIXED_RADIX_LARGE_N=524288)
INTEGER FFTW_ALLOW_PRUNING
PARAMETER (FFTW_ALLOW_PRUNING=1048576)

1254
Desktop_Interface/build_win/fftw/x86/fftw3.f03 Normal file
View File

File diff suppressed because it is too large Load Diff

415
Desktop_Interface/build_win/fftw/x86/fftw3.h Normal file
View File

@ -0,0 +1,415 @@
/*
* Copyright (c) 2003, 2007-14 Matteo Frigo
* Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
*
* The following statement of license applies *only* to this header file,
* and *not* to the other files distributed with FFTW or derived therefrom:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/***************************** NOTE TO USERS *********************************
*
* THIS IS A HEADER FILE, NOT A MANUAL
*
* If you want to know how to use FFTW, please read the manual,
* online at http://www.fftw.org/doc/ and also included with FFTW.
* For a quick start, see the manual's tutorial section.
*
* (Reading header files to learn how to use a library is a habit
* stemming from code lacking a proper manual. Arguably, it's a
* *bad* habit in most cases, because header files can contain
* interfaces that are not part of the public, stable API.)
*
****************************************************************************/
#ifndef FFTW3_H
#define FFTW3_H
#include <stdio.h>
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* If <complex.h> is included, use the C99 complex type. Otherwise
define a type bit-compatible with C99 complex */
#if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
# define FFTW_DEFINE_COMPLEX(R, C) typedef R _Complex C
#else
# define FFTW_DEFINE_COMPLEX(R, C) typedef R C[2]
#endif
#define FFTW_CONCAT(prefix, name) prefix ## name
#define FFTW_MANGLE_DOUBLE(name) FFTW_CONCAT(fftw_, name)
#define FFTW_MANGLE_FLOAT(name) FFTW_CONCAT(fftwf_, name)
#define FFTW_MANGLE_LONG_DOUBLE(name) FFTW_CONCAT(fftwl_, name)
#define FFTW_MANGLE_QUAD(name) FFTW_CONCAT(fftwq_, name)
/* IMPORTANT: for Windows compilers, you should add a line
*/
#define FFTW_DLL
/*
here and in kernel/ifftw.h if you are compiling/using FFTW as a
DLL, in order to do the proper importing/exporting, or
alternatively compile with -DFFTW_DLL or the equivalent
command-line flag. This is not necessary under MinGW/Cygwin, where
libtool does the imports/exports automatically. */
#if defined(FFTW_DLL) && (defined(_WIN32) || defined(__WIN32__))
/* annoying Windows syntax for shared-library declarations */
# if defined(COMPILING_FFTW) /* defined in api.h when compiling FFTW */
# define FFTW_EXTERN extern __declspec(dllexport)
# else /* user is calling FFTW; import symbol */
# define FFTW_EXTERN extern __declspec(dllimport)
# endif
#else
# define FFTW_EXTERN extern
#endif
enum fftw_r2r_kind_do_not_use_me {
FFTW_R2HC=0, FFTW_HC2R=1, FFTW_DHT=2,
FFTW_REDFT00=3, FFTW_REDFT01=4, FFTW_REDFT10=5, FFTW_REDFT11=6,
FFTW_RODFT00=7, FFTW_RODFT01=8, FFTW_RODFT10=9, FFTW_RODFT11=10
};
struct fftw_iodim_do_not_use_me {
int n; /* dimension size */
int is; /* input stride */
int os; /* output stride */
};
#include <stddef.h> /* for ptrdiff_t */
struct fftw_iodim64_do_not_use_me {
ptrdiff_t n; /* dimension size */
ptrdiff_t is; /* input stride */
ptrdiff_t os; /* output stride */
};
typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *);
typedef int (*fftw_read_char_func_do_not_use_me)(void *);
/*
huge second-order macro that defines prototypes for all API
functions. We expand this macro for each supported precision
X: name-mangling macro
R: real data type
C: complex data type
*/
#define FFTW_DEFINE_API(X, R, C) \
\
FFTW_DEFINE_COMPLEX(R, C); \
\
typedef struct X(plan_s) *X(plan); \
\
typedef struct fftw_iodim_do_not_use_me X(iodim); \
typedef struct fftw_iodim64_do_not_use_me X(iodim64); \
\
typedef enum fftw_r2r_kind_do_not_use_me X(r2r_kind); \
\
typedef fftw_write_char_func_do_not_use_me X(write_char_func); \
typedef fftw_read_char_func_do_not_use_me X(read_char_func); \
\
FFTW_EXTERN void X(execute)(const X(plan) p); \
\
FFTW_EXTERN X(plan) X(plan_dft)(int rank, const int *n, \
C *in, C *out, int sign, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_1d)(int n, C *in, C *out, int sign, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_2d)(int n0, int n1, \
C *in, C *out, int sign, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_3d)(int n0, int n1, int n2, \
C *in, C *out, int sign, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_many_dft)(int rank, const int *n, \
int howmany, \
C *in, const int *inembed, \
int istride, int idist, \
C *out, const int *onembed, \
int ostride, int odist, \
int sign, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_dft)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
C *in, C *out, \
int sign, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru_split_dft)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *ri, R *ii, R *ro, R *io, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_dft)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
C *in, C *out, \
int sign, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru64_split_dft)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *ri, R *ii, R *ro, R *io, \
unsigned flags); \
\
FFTW_EXTERN void X(execute_dft)(const X(plan) p, C *in, C *out); \
FFTW_EXTERN void X(execute_split_dft)(const X(plan) p, R *ri, R *ii, \
R *ro, R *io); \
\
FFTW_EXTERN X(plan) X(plan_many_dft_r2c)(int rank, const int *n, \
int howmany, \
R *in, const int *inembed, \
int istride, int idist, \
C *out, const int *onembed, \
int ostride, int odist, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_r2c)(int rank, const int *n, \
R *in, C *out, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_r2c_1d)(int n,R *in,C *out,unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_r2c_2d)(int n0, int n1, \
R *in, C *out, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_r2c_3d)(int n0, int n1, \
int n2, \
R *in, C *out, unsigned flags); \
\
\
FFTW_EXTERN X(plan) X(plan_many_dft_c2r)(int rank, const int *n, \
int howmany, \
C *in, const int *inembed, \
int istride, int idist, \
R *out, const int *onembed, \
int ostride, int odist, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_c2r)(int rank, const int *n, \
C *in, R *out, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_dft_c2r_1d)(int n,C *in,R *out,unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_c2r_2d)(int n0, int n1, \
C *in, R *out, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_dft_c2r_3d)(int n0, int n1, \
int n2, \
C *in, R *out, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_dft_r2c)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *in, C *out, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru_dft_c2r)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
C *in, R *out, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_split_dft_r2c)( \
int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *in, R *ro, R *io, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru_split_dft_c2r)( \
int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *ri, R *ii, R *out, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_dft_r2c)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *in, C *out, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru64_dft_c2r)(int rank, \
const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
C *in, R *out, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_split_dft_r2c)( \
int rank, const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *in, R *ro, R *io, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_guru64_split_dft_c2r)( \
int rank, const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *ri, R *ii, R *out, \
unsigned flags); \
\
FFTW_EXTERN void X(execute_dft_r2c)(const X(plan) p, R *in, C *out); \
FFTW_EXTERN void X(execute_dft_c2r)(const X(plan) p, C *in, R *out); \
\
FFTW_EXTERN void X(execute_split_dft_r2c)(const X(plan) p, \
R *in, R *ro, R *io); \
FFTW_EXTERN void X(execute_split_dft_c2r)(const X(plan) p, \
R *ri, R *ii, R *out); \
\
FFTW_EXTERN X(plan) X(plan_many_r2r)(int rank, const int *n, \
int howmany, \
R *in, const int *inembed, \
int istride, int idist, \
R *out, const int *onembed, \
int ostride, int odist, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_r2r)(int rank, const int *n, R *in, R *out, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_r2r_1d)(int n, R *in, R *out, \
X(r2r_kind) kind, unsigned flags); \
FFTW_EXTERN X(plan) X(plan_r2r_2d)(int n0, int n1, R *in, R *out, \
X(r2r_kind) kind0, X(r2r_kind) kind1, \
unsigned flags); \
FFTW_EXTERN X(plan) X(plan_r2r_3d)(int n0, int n1, int n2, \
R *in, R *out, X(r2r_kind) kind0, \
X(r2r_kind) kind1, X(r2r_kind) kind2, \
unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru_r2r)(int rank, const X(iodim) *dims, \
int howmany_rank, \
const X(iodim) *howmany_dims, \
R *in, R *out, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN X(plan) X(plan_guru64_r2r)(int rank, const X(iodim64) *dims, \
int howmany_rank, \
const X(iodim64) *howmany_dims, \
R *in, R *out, \
const X(r2r_kind) *kind, unsigned flags); \
\
FFTW_EXTERN void X(execute_r2r)(const X(plan) p, R *in, R *out); \
\
FFTW_EXTERN void X(destroy_plan)(X(plan) p); \
FFTW_EXTERN void X(forget_wisdom)(void); \
FFTW_EXTERN void X(cleanup)(void); \
\
FFTW_EXTERN void X(set_timelimit)(double t); \
\
FFTW_EXTERN void X(plan_with_nthreads)(int nthreads); \
FFTW_EXTERN int X(init_threads)(void); \
FFTW_EXTERN void X(cleanup_threads)(void); \
FFTW_EXTERN void X(make_planner_thread_safe)(void); \
\
FFTW_EXTERN int X(export_wisdom_to_filename)(const char *filename); \
FFTW_EXTERN void X(export_wisdom_to_file)(FILE *output_file); \
FFTW_EXTERN char *X(export_wisdom_to_string)(void); \
FFTW_EXTERN void X(export_wisdom)(X(write_char_func) write_char, \
void *data); \
FFTW_EXTERN int X(import_system_wisdom)(void); \
FFTW_EXTERN int X(import_wisdom_from_filename)(const char *filename); \
FFTW_EXTERN int X(import_wisdom_from_file)(FILE *input_file); \
FFTW_EXTERN int X(import_wisdom_from_string)(const char *input_string); \
FFTW_EXTERN int X(import_wisdom)(X(read_char_func) read_char, void *data); \
\
FFTW_EXTERN void X(fprint_plan)(const X(plan) p, FILE *output_file); \
FFTW_EXTERN void X(print_plan)(const X(plan) p); \
FFTW_EXTERN char *X(sprint_plan)(const X(plan) p); \
\
FFTW_EXTERN void *X(malloc)(size_t n); \
FFTW_EXTERN R *X(alloc_real)(size_t n); \
FFTW_EXTERN C *X(alloc_complex)(size_t n); \
FFTW_EXTERN void X(free)(void *p); \
\
FFTW_EXTERN void X(flops)(const X(plan) p, \
double *add, double *mul, double *fmas); \
FFTW_EXTERN double X(estimate_cost)(const X(plan) p); \
FFTW_EXTERN double X(cost)(const X(plan) p); \
\
FFTW_EXTERN int X(alignment_of)(R *p); \
FFTW_EXTERN const char X(version)[]; \
FFTW_EXTERN const char X(cc)[]; \
FFTW_EXTERN const char X(codelet_optim)[];
/* end of FFTW_DEFINE_API macro */
FFTW_DEFINE_API(FFTW_MANGLE_DOUBLE, double, fftw_complex)
FFTW_DEFINE_API(FFTW_MANGLE_FLOAT, float, fftwf_complex)
FFTW_DEFINE_API(FFTW_MANGLE_LONG_DOUBLE, long double, fftwl_complex)
/* __float128 (quad precision) is a gcc extension on i386, x86_64, and ia64
for gcc >= 4.6 (compiled in FFTW with --enable-quad-precision) */
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) \
&& !(defined(__ICC) || defined(__INTEL_COMPILER) || defined(__CUDACC__) || defined(__PGI)) \
&& (defined(__i386__) || defined(__x86_64__) || defined(__ia64__))
# if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
/* note: __float128 is a typedef, which is not supported with the _Complex
keyword in gcc, so instead we use this ugly __attribute__ version.
However, we can't simply pass the __attribute__ version to
FFTW_DEFINE_API because the __attribute__ confuses gcc in pointer
types. Hence redefining FFTW_DEFINE_COMPLEX. Ugh. */
# undef FFTW_DEFINE_COMPLEX
# define FFTW_DEFINE_COMPLEX(R, C) typedef _Complex float __attribute__((mode(TC))) C
# endif
FFTW_DEFINE_API(FFTW_MANGLE_QUAD, __float128, fftwq_complex)
#endif
#define FFTW_FORWARD (-1)
#define FFTW_BACKWARD (+1)
#define FFTW_NO_TIMELIMIT (-1.0)
/* documented flags */
#define FFTW_MEASURE (0U)
#define FFTW_DESTROY_INPUT (1U << 0)
#define FFTW_UNALIGNED (1U << 1)
#define FFTW_CONSERVE_MEMORY (1U << 2)
#define FFTW_EXHAUSTIVE (1U << 3) /* NO_EXHAUSTIVE is default */
#define FFTW_PRESERVE_INPUT (1U << 4) /* cancels FFTW_DESTROY_INPUT */
#define FFTW_PATIENT (1U << 5) /* IMPATIENT is default */
#define FFTW_ESTIMATE (1U << 6)
#define FFTW_WISDOM_ONLY (1U << 21)
/* undocumented beyond-guru flags */
#define FFTW_ESTIMATE_PATIENT (1U << 7)
#define FFTW_BELIEVE_PCOST (1U << 8)
#define FFTW_NO_DFT_R2HC (1U << 9)
#define FFTW_NO_NONTHREADED (1U << 10)
#define FFTW_NO_BUFFERING (1U << 11)
#define FFTW_NO_INDIRECT_OP (1U << 12)
#define FFTW_ALLOW_LARGE_GENERIC (1U << 13) /* NO_LARGE_GENERIC is default */
#define FFTW_NO_RANK_SPLITS (1U << 14)
#define FFTW_NO_VRANK_SPLITS (1U << 15)
#define FFTW_NO_VRECURSE (1U << 16)
#define FFTW_NO_SIMD (1U << 17)
#define FFTW_NO_SLOW (1U << 18)
#define FFTW_NO_FIXED_RADIX_LARGE_N (1U << 19)
#define FFTW_ALLOW_PRUNING (1U << 20)
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* FFTW3_H */

609
Desktop_Interface/build_win/fftw/x86/fftw3l.f03 Normal file
View File

@ -0,0 +1,609 @@
! Generated automatically. DO NOT EDIT!
type, bind(C) :: fftwl_iodim
integer(C_INT) n, is, os
end type fftwl_iodim
type, bind(C) :: fftwl_iodim64
integer(C_INTPTR_T) n, is, os
end type fftwl_iodim64
interface
type(C_PTR) function fftwl_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftwl_plan_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft
type(C_PTR) function fftwl_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftwl_plan_dft_1d')
import
integer(C_INT), value :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft_1d
type(C_PTR) function fftwl_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftwl_plan_dft_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft_2d
type(C_PTR) function fftwl_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftwl_plan_dft_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_dft_3d
type(C_PTR) function fftwl_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) &
bind(C, name='fftwl_plan_many_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_many_dft
type(C_PTR) function fftwl_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwl_plan_guru_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_guru_dft
type(C_PTR) function fftwl_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwl_plan_guru_split_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru_split_dft
type(C_PTR) function fftwl_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwl_plan_guru64_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwl_plan_guru64_dft
type(C_PTR) function fftwl_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwl_plan_guru64_split_dft')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru64_split_dft
subroutine fftwl_execute_dft(p,in,out) bind(C, name='fftwl_execute_dft')
import
type(C_PTR), value :: p
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
end subroutine fftwl_execute_dft
subroutine fftwl_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftwl_execute_split_dft')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
end subroutine fftwl_execute_split_dft
type(C_PTR) function fftwl_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwl_plan_many_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwl_plan_many_dft_r2c
type(C_PTR) function fftwl_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftwl_plan_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c
type(C_PTR) function fftwl_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftwl_plan_dft_r2c_1d')
import
integer(C_INT), value :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c_1d
type(C_PTR) function fftwl_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftwl_plan_dft_r2c_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c_2d
type(C_PTR) function fftwl_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwl_plan_dft_r2c_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_r2c_3d
type(C_PTR) function fftwl_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwl_plan_many_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwl_plan_many_dft_c2r
type(C_PTR) function fftwl_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftwl_plan_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r
type(C_PTR) function fftwl_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftwl_plan_dft_c2r_1d')
import
integer(C_INT), value :: n
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r_1d
type(C_PTR) function fftwl_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftwl_plan_dft_c2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r_2d
type(C_PTR) function fftwl_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwl_plan_dft_c2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_dft_c2r_3d
type(C_PTR) function fftwl_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru_dft_r2c
type(C_PTR) function fftwl_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru_dft_c2r
type(C_PTR) function fftwl_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwl_plan_guru_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru_split_dft_r2c
type(C_PTR) function fftwl_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwl_plan_guru_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru_split_dft_c2r
type(C_PTR) function fftwl_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru64_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru64_dft_r2c
type(C_PTR) function fftwl_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwl_plan_guru64_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru64_dft_c2r
type(C_PTR) function fftwl_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwl_plan_guru64_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwl_plan_guru64_split_dft_r2c
type(C_PTR) function fftwl_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwl_plan_guru64_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwl_plan_guru64_split_dft_c2r
subroutine fftwl_execute_dft_r2c(p,in,out) bind(C, name='fftwl_execute_dft_r2c')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: in
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(out) :: out
end subroutine fftwl_execute_dft_r2c
subroutine fftwl_execute_dft_c2r(p,in,out) bind(C, name='fftwl_execute_dft_c2r')
import
type(C_PTR), value :: p
complex(C_LONG_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
end subroutine fftwl_execute_dft_c2r
subroutine fftwl_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftwl_execute_split_dft_r2c')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: ro
real(C_LONG_DOUBLE), dimension(*), intent(out) :: io
end subroutine fftwl_execute_split_dft_r2c
subroutine fftwl_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftwl_execute_split_dft_c2r')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ri
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: ii
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
end subroutine fftwl_execute_split_dft_c2r
type(C_PTR) function fftwl_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) &
bind(C, name='fftwl_plan_many_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_many_r2r
type(C_PTR) function fftwl_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftwl_plan_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_r2r
type(C_PTR) function fftwl_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftwl_plan_r2r_1d')
import
integer(C_INT), value :: n
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind
integer(C_INT), value :: flags
end function fftwl_plan_r2r_1d
type(C_PTR) function fftwl_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftwl_plan_r2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_INT), value :: flags
end function fftwl_plan_r2r_2d
type(C_PTR) function fftwl_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftwl_plan_r2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_FFTW_R2R_KIND), value :: kind2
integer(C_INT), value :: flags
end function fftwl_plan_r2r_3d
type(C_PTR) function fftwl_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwl_plan_guru_r2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_guru_r2r
type(C_PTR) function fftwl_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwl_plan_guru64_r2r')
import
integer(C_INT), value :: rank
type(fftwl_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwl_iodim64), dimension(*), intent(in) :: howmany_dims
real(C_LONG_DOUBLE), dimension(*), intent(out) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwl_plan_guru64_r2r
subroutine fftwl_execute_r2r(p,in,out) bind(C, name='fftwl_execute_r2r')
import
type(C_PTR), value :: p
real(C_LONG_DOUBLE), dimension(*), intent(inout) :: in
real(C_LONG_DOUBLE), dimension(*), intent(out) :: out
end subroutine fftwl_execute_r2r
subroutine fftwl_destroy_plan(p) bind(C, name='fftwl_destroy_plan')
import
type(C_PTR), value :: p
end subroutine fftwl_destroy_plan
subroutine fftwl_forget_wisdom() bind(C, name='fftwl_forget_wisdom')
import
end subroutine fftwl_forget_wisdom
subroutine fftwl_cleanup() bind(C, name='fftwl_cleanup')
import
end subroutine fftwl_cleanup
subroutine fftwl_set_timelimit(t) bind(C, name='fftwl_set_timelimit')
import
real(C_DOUBLE), value :: t
end subroutine fftwl_set_timelimit
subroutine fftwl_plan_with_nthreads(nthreads) bind(C, name='fftwl_plan_with_nthreads')
import
integer(C_INT), value :: nthreads
end subroutine fftwl_plan_with_nthreads
integer(C_INT) function fftwl_init_threads() bind(C, name='fftwl_init_threads')
import
end function fftwl_init_threads
subroutine fftwl_cleanup_threads() bind(C, name='fftwl_cleanup_threads')
import
end subroutine fftwl_cleanup_threads
subroutine fftwl_make_planner_thread_safe() bind(C, name='fftwl_make_planner_thread_safe')
import
end subroutine fftwl_make_planner_thread_safe
integer(C_INT) function fftwl_export_wisdom_to_filename(filename) bind(C, name='fftwl_export_wisdom_to_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwl_export_wisdom_to_filename
subroutine fftwl_export_wisdom_to_file(output_file) bind(C, name='fftwl_export_wisdom_to_file')
import
type(C_PTR), value :: output_file
end subroutine fftwl_export_wisdom_to_file
type(C_PTR) function fftwl_export_wisdom_to_string() bind(C, name='fftwl_export_wisdom_to_string')
import
end function fftwl_export_wisdom_to_string
subroutine fftwl_export_wisdom(write_char,data) bind(C, name='fftwl_export_wisdom')
import
type(C_FUNPTR), value :: write_char
type(C_PTR), value :: data
end subroutine fftwl_export_wisdom
integer(C_INT) function fftwl_import_system_wisdom() bind(C, name='fftwl_import_system_wisdom')
import
end function fftwl_import_system_wisdom
integer(C_INT) function fftwl_import_wisdom_from_filename(filename) bind(C, name='fftwl_import_wisdom_from_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwl_import_wisdom_from_filename
integer(C_INT) function fftwl_import_wisdom_from_file(input_file) bind(C, name='fftwl_import_wisdom_from_file')
import
type(C_PTR), value :: input_file
end function fftwl_import_wisdom_from_file
integer(C_INT) function fftwl_import_wisdom_from_string(input_string) bind(C, name='fftwl_import_wisdom_from_string')
import
character(C_CHAR), dimension(*), intent(in) :: input_string
end function fftwl_import_wisdom_from_string
integer(C_INT) function fftwl_import_wisdom(read_char,data) bind(C, name='fftwl_import_wisdom')
import
type(C_FUNPTR), value :: read_char
type(C_PTR), value :: data
end function fftwl_import_wisdom
subroutine fftwl_fprint_plan(p,output_file) bind(C, name='fftwl_fprint_plan')
import
type(C_PTR), value :: p
type(C_PTR), value :: output_file
end subroutine fftwl_fprint_plan
subroutine fftwl_print_plan(p) bind(C, name='fftwl_print_plan')
import
type(C_PTR), value :: p
end subroutine fftwl_print_plan
type(C_PTR) function fftwl_sprint_plan(p) bind(C, name='fftwl_sprint_plan')
import
type(C_PTR), value :: p
end function fftwl_sprint_plan
type(C_PTR) function fftwl_malloc(n) bind(C, name='fftwl_malloc')
import
integer(C_SIZE_T), value :: n
end function fftwl_malloc
type(C_PTR) function fftwl_alloc_real(n) bind(C, name='fftwl_alloc_real')
import
integer(C_SIZE_T), value :: n
end function fftwl_alloc_real
type(C_PTR) function fftwl_alloc_complex(n) bind(C, name='fftwl_alloc_complex')
import
integer(C_SIZE_T), value :: n
end function fftwl_alloc_complex
subroutine fftwl_free(p) bind(C, name='fftwl_free')
import
type(C_PTR), value :: p
end subroutine fftwl_free
subroutine fftwl_flops(p,add,mul,fmas) bind(C, name='fftwl_flops')
import
type(C_PTR), value :: p
real(C_DOUBLE), intent(out) :: add
real(C_DOUBLE), intent(out) :: mul
real(C_DOUBLE), intent(out) :: fmas
end subroutine fftwl_flops
real(C_DOUBLE) function fftwl_estimate_cost(p) bind(C, name='fftwl_estimate_cost')
import
type(C_PTR), value :: p
end function fftwl_estimate_cost
real(C_DOUBLE) function fftwl_cost(p) bind(C, name='fftwl_cost')
import
type(C_PTR), value :: p
end function fftwl_cost
integer(C_INT) function fftwl_alignment_of(p) bind(C, name='fftwl_alignment_of')
import
real(C_LONG_DOUBLE), dimension(*), intent(out) :: p
end function fftwl_alignment_of
end interface

609
Desktop_Interface/build_win/fftw/x86/fftw3q.f03 Normal file
View File

@ -0,0 +1,609 @@
! Generated automatically. DO NOT EDIT!
type, bind(C) :: fftwq_iodim
integer(C_INT) n, is, os
end type fftwq_iodim
type, bind(C) :: fftwq_iodim64
integer(C_INTPTR_T) n, is, os
end type fftwq_iodim64
interface
type(C_PTR) function fftwq_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftwq_plan_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft
type(C_PTR) function fftwq_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftwq_plan_dft_1d')
import
integer(C_INT), value :: n
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft_1d
type(C_PTR) function fftwq_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftwq_plan_dft_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft_2d
type(C_PTR) function fftwq_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftwq_plan_dft_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_dft_3d
type(C_PTR) function fftwq_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) &
bind(C, name='fftwq_plan_many_dft')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_many_dft
type(C_PTR) function fftwq_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwq_plan_guru_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_guru_dft
type(C_PTR) function fftwq_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwq_plan_guru_split_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru_split_dft
type(C_PTR) function fftwq_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) &
bind(C, name='fftwq_plan_guru64_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: sign
integer(C_INT), value :: flags
end function fftwq_plan_guru64_dft
type(C_PTR) function fftwq_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) &
bind(C, name='fftwq_plan_guru64_split_dft')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru64_split_dft
subroutine fftwq_execute_dft(p,in,out) bind(C, name='fftwq_execute_dft')
import
type(C_PTR), value :: p
complex(16), dimension(*), intent(inout) :: in
complex(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_dft
subroutine fftwq_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftwq_execute_split_dft')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: ri
real(16), dimension(*), intent(inout) :: ii
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
end subroutine fftwq_execute_split_dft
type(C_PTR) function fftwq_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwq_plan_many_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
complex(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwq_plan_many_dft_r2c
type(C_PTR) function fftwq_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftwq_plan_dft_r2c')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c
type(C_PTR) function fftwq_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftwq_plan_dft_r2c_1d')
import
integer(C_INT), value :: n
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c_1d
type(C_PTR) function fftwq_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftwq_plan_dft_r2c_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c_2d
type(C_PTR) function fftwq_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwq_plan_dft_r2c_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_r2c_3d
type(C_PTR) function fftwq_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) &
bind(C, name='fftwq_plan_many_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
complex(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_INT), value :: flags
end function fftwq_plan_many_dft_c2r
type(C_PTR) function fftwq_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftwq_plan_dft_c2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r
type(C_PTR) function fftwq_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftwq_plan_dft_c2r_1d')
import
integer(C_INT), value :: n
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r_1d
type(C_PTR) function fftwq_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftwq_plan_dft_c2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r_2d
type(C_PTR) function fftwq_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwq_plan_dft_c2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_dft_c2r_3d
type(C_PTR) function fftwq_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru_dft_r2c
type(C_PTR) function fftwq_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru_dft_c2r
type(C_PTR) function fftwq_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwq_plan_guru_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru_split_dft_r2c
type(C_PTR) function fftwq_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwq_plan_guru_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru_split_dft_c2r
type(C_PTR) function fftwq_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru64_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
complex(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru64_dft_r2c
type(C_PTR) function fftwq_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) &
bind(C, name='fftwq_plan_guru64_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
complex(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru64_dft_c2r
type(C_PTR) function fftwq_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) &
bind(C, name='fftwq_plan_guru64_split_dft_r2c')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
integer(C_INT), value :: flags
end function fftwq_plan_guru64_split_dft_r2c
type(C_PTR) function fftwq_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) &
bind(C, name='fftwq_plan_guru64_split_dft_c2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: ri
real(16), dimension(*), intent(out) :: ii
real(16), dimension(*), intent(out) :: out
integer(C_INT), value :: flags
end function fftwq_plan_guru64_split_dft_c2r
subroutine fftwq_execute_dft_r2c(p,in,out) bind(C, name='fftwq_execute_dft_r2c')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: in
complex(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_dft_r2c
subroutine fftwq_execute_dft_c2r(p,in,out) bind(C, name='fftwq_execute_dft_c2r')
import
type(C_PTR), value :: p
complex(16), dimension(*), intent(inout) :: in
real(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_dft_c2r
subroutine fftwq_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftwq_execute_split_dft_r2c')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: in
real(16), dimension(*), intent(out) :: ro
real(16), dimension(*), intent(out) :: io
end subroutine fftwq_execute_split_dft_r2c
subroutine fftwq_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftwq_execute_split_dft_c2r')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: ri
real(16), dimension(*), intent(inout) :: ii
real(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_split_dft_c2r
type(C_PTR) function fftwq_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) &
bind(C, name='fftwq_plan_many_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
integer(C_INT), value :: howmany
real(16), dimension(*), intent(out) :: in
integer(C_INT), dimension(*), intent(in) :: inembed
integer(C_INT), value :: istride
integer(C_INT), value :: idist
real(16), dimension(*), intent(out) :: out
integer(C_INT), dimension(*), intent(in) :: onembed
integer(C_INT), value :: ostride
integer(C_INT), value :: odist
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_many_r2r
type(C_PTR) function fftwq_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftwq_plan_r2r')
import
integer(C_INT), value :: rank
integer(C_INT), dimension(*), intent(in) :: n
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_r2r
type(C_PTR) function fftwq_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftwq_plan_r2r_1d')
import
integer(C_INT), value :: n
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind
integer(C_INT), value :: flags
end function fftwq_plan_r2r_1d
type(C_PTR) function fftwq_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftwq_plan_r2r_2d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_INT), value :: flags
end function fftwq_plan_r2r_2d
type(C_PTR) function fftwq_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftwq_plan_r2r_3d')
import
integer(C_INT), value :: n0
integer(C_INT), value :: n1
integer(C_INT), value :: n2
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), value :: kind0
integer(C_FFTW_R2R_KIND), value :: kind1
integer(C_FFTW_R2R_KIND), value :: kind2
integer(C_INT), value :: flags
end function fftwq_plan_r2r_3d
type(C_PTR) function fftwq_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwq_plan_guru_r2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_guru_r2r
type(C_PTR) function fftwq_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) &
bind(C, name='fftwq_plan_guru64_r2r')
import
integer(C_INT), value :: rank
type(fftwq_iodim64), dimension(*), intent(in) :: dims
integer(C_INT), value :: howmany_rank
type(fftwq_iodim64), dimension(*), intent(in) :: howmany_dims
real(16), dimension(*), intent(out) :: in
real(16), dimension(*), intent(out) :: out
integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind
integer(C_INT), value :: flags
end function fftwq_plan_guru64_r2r
subroutine fftwq_execute_r2r(p,in,out) bind(C, name='fftwq_execute_r2r')
import
type(C_PTR), value :: p
real(16), dimension(*), intent(inout) :: in
real(16), dimension(*), intent(out) :: out
end subroutine fftwq_execute_r2r
subroutine fftwq_destroy_plan(p) bind(C, name='fftwq_destroy_plan')
import
type(C_PTR), value :: p
end subroutine fftwq_destroy_plan
subroutine fftwq_forget_wisdom() bind(C, name='fftwq_forget_wisdom')
import
end subroutine fftwq_forget_wisdom
subroutine fftwq_cleanup() bind(C, name='fftwq_cleanup')
import
end subroutine fftwq_cleanup
subroutine fftwq_set_timelimit(t) bind(C, name='fftwq_set_timelimit')
import
real(C_DOUBLE), value :: t
end subroutine fftwq_set_timelimit
subroutine fftwq_plan_with_nthreads(nthreads) bind(C, name='fftwq_plan_with_nthreads')
import
integer(C_INT), value :: nthreads
end subroutine fftwq_plan_with_nthreads
integer(C_INT) function fftwq_init_threads() bind(C, name='fftwq_init_threads')
import
end function fftwq_init_threads
subroutine fftwq_cleanup_threads() bind(C, name='fftwq_cleanup_threads')
import
end subroutine fftwq_cleanup_threads
subroutine fftwq_make_planner_thread_safe() bind(C, name='fftwq_make_planner_thread_safe')
import
end subroutine fftwq_make_planner_thread_safe
integer(C_INT) function fftwq_export_wisdom_to_filename(filename) bind(C, name='fftwq_export_wisdom_to_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwq_export_wisdom_to_filename
subroutine fftwq_export_wisdom_to_file(output_file) bind(C, name='fftwq_export_wisdom_to_file')
import
type(C_PTR), value :: output_file
end subroutine fftwq_export_wisdom_to_file
type(C_PTR) function fftwq_export_wisdom_to_string() bind(C, name='fftwq_export_wisdom_to_string')
import
end function fftwq_export_wisdom_to_string
subroutine fftwq_export_wisdom(write_char,data) bind(C, name='fftwq_export_wisdom')
import
type(C_FUNPTR), value :: write_char
type(C_PTR), value :: data
end subroutine fftwq_export_wisdom
integer(C_INT) function fftwq_import_system_wisdom() bind(C, name='fftwq_import_system_wisdom')
import
end function fftwq_import_system_wisdom
integer(C_INT) function fftwq_import_wisdom_from_filename(filename) bind(C, name='fftwq_import_wisdom_from_filename')
import
character(C_CHAR), dimension(*), intent(in) :: filename
end function fftwq_import_wisdom_from_filename
integer(C_INT) function fftwq_import_wisdom_from_file(input_file) bind(C, name='fftwq_import_wisdom_from_file')
import
type(C_PTR), value :: input_file
end function fftwq_import_wisdom_from_file
integer(C_INT) function fftwq_import_wisdom_from_string(input_string) bind(C, name='fftwq_import_wisdom_from_string')
import
character(C_CHAR), dimension(*), intent(in) :: input_string
end function fftwq_import_wisdom_from_string
integer(C_INT) function fftwq_import_wisdom(read_char,data) bind(C, name='fftwq_import_wisdom')
import
type(C_FUNPTR), value :: read_char
type(C_PTR), value :: data
end function fftwq_import_wisdom
subroutine fftwq_fprint_plan(p,output_file) bind(C, name='fftwq_fprint_plan')
import
type(C_PTR), value :: p
type(C_PTR), value :: output_file
end subroutine fftwq_fprint_plan
subroutine fftwq_print_plan(p) bind(C, name='fftwq_print_plan')
import
type(C_PTR), value :: p
end subroutine fftwq_print_plan
type(C_PTR) function fftwq_sprint_plan(p) bind(C, name='fftwq_sprint_plan')
import
type(C_PTR), value :: p
end function fftwq_sprint_plan
type(C_PTR) function fftwq_malloc(n) bind(C, name='fftwq_malloc')
import
integer(C_SIZE_T), value :: n
end function fftwq_malloc
type(C_PTR) function fftwq_alloc_real(n) bind(C, name='fftwq_alloc_real')
import
integer(C_SIZE_T), value :: n
end function fftwq_alloc_real
type(C_PTR) function fftwq_alloc_complex(n) bind(C, name='fftwq_alloc_complex')
import
integer(C_SIZE_T), value :: n
end function fftwq_alloc_complex
subroutine fftwq_free(p) bind(C, name='fftwq_free')
import
type(C_PTR), value :: p
end subroutine fftwq_free
subroutine fftwq_flops(p,add,mul,fmas) bind(C, name='fftwq_flops')
import
type(C_PTR), value :: p
real(C_DOUBLE), intent(out) :: add
real(C_DOUBLE), intent(out) :: mul
real(C_DOUBLE), intent(out) :: fmas
end subroutine fftwq_flops
real(C_DOUBLE) function fftwq_estimate_cost(p) bind(C, name='fftwq_estimate_cost')
import
type(C_PTR), value :: p
end function fftwq_estimate_cost
real(C_DOUBLE) function fftwq_cost(p) bind(C, name='fftwq_cost')
import
type(C_PTR), value :: p
end function fftwq_cost
integer(C_INT) function fftwq_alignment_of(p) bind(C, name='fftwq_alignment_of')
import
real(16), dimension(*), intent(out) :: p
end function fftwq_alignment_of
end interface

1017
Desktop_Interface/build_win/fftw/x86/libfftw3-3.def Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
Desktop_Interface/build_win/fftw/x86/libfftw3-3.dll Normal file
View File

Binary file not shown.

BIN
Desktop_Interface/build_win/fftw/x86/libfftw3-3.exp Normal file
View File

Binary file not shown.

BIN
Desktop_Interface/build_win/fftw/x86/libfftw3-3.lib Normal file
View File

Binary file not shown.

1017
Desktop_Interface/build_win/fftw/x86/libfftw3f-3.def Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
Desktop_Interface/build_win/fftw/x86/libfftw3f-3.dll Normal file
View File

Binary file not shown.

634
Desktop_Interface/build_win/fftw/x86/libfftw3l-3.def Normal file
View File

@ -0,0 +1,634 @@
LIBRARY libfftw3l-3.dll
EXPORTS
fftwl_alignment_of
fftwl_alloc_complex
fftwl_alloc_real
fftwl_assertion_failed
fftwl_bufdist
fftwl_choose_radix
fftwl_cleanup
fftwl_cleanup_threads
fftwl_codelet_e01_8
fftwl_codelet_e10_8
fftwl_codelet_hb_10
fftwl_codelet_hb_12
fftwl_codelet_hb_15
fftwl_codelet_hb_16
fftwl_codelet_hb_2
fftwl_codelet_hb_20
fftwl_codelet_hb2_16
fftwl_codelet_hb2_20
fftwl_codelet_hb2_25
fftwl_codelet_hb2_32
fftwl_codelet_hb2_4
fftwl_codelet_hb_25
fftwl_codelet_hb2_5
fftwl_codelet_hb2_8
fftwl_codelet_hb_3
fftwl_codelet_hb_32
fftwl_codelet_hb_4
fftwl_codelet_hb_5
fftwl_codelet_hb_6
fftwl_codelet_hb_64
fftwl_codelet_hb_7
fftwl_codelet_hb_8
fftwl_codelet_hb_9
fftwl_codelet_hc2cb_10
fftwl_codelet_hc2cb_12
fftwl_codelet_hc2cb_16
fftwl_codelet_hc2cb_2
fftwl_codelet_hc2cb_20
fftwl_codelet_hc2cb2_16
fftwl_codelet_hc2cb2_20
fftwl_codelet_hc2cb2_32
fftwl_codelet_hc2cb2_4
fftwl_codelet_hc2cb2_8
fftwl_codelet_hc2cb_32
fftwl_codelet_hc2cb_4
fftwl_codelet_hc2cb_6
fftwl_codelet_hc2cb_8
fftwl_codelet_hc2cbdft_10
fftwl_codelet_hc2cbdft_12
fftwl_codelet_hc2cbdft_16
fftwl_codelet_hc2cbdft_2
fftwl_codelet_hc2cbdft_20
fftwl_codelet_hc2cbdft2_16
fftwl_codelet_hc2cbdft2_20
fftwl_codelet_hc2cbdft2_32
fftwl_codelet_hc2cbdft2_4
fftwl_codelet_hc2cbdft2_8
fftwl_codelet_hc2cbdft_32
fftwl_codelet_hc2cbdft_4
fftwl_codelet_hc2cbdft_6
fftwl_codelet_hc2cbdft_8
fftwl_codelet_hc2cf_10
fftwl_codelet_hc2cf_12
fftwl_codelet_hc2cf_16
fftwl_codelet_hc2cf_2
fftwl_codelet_hc2cf_20
fftwl_codelet_hc2cf2_16
fftwl_codelet_hc2cf2_20
fftwl_codelet_hc2cf2_32
fftwl_codelet_hc2cf2_4
fftwl_codelet_hc2cf2_8
fftwl_codelet_hc2cf_32
fftwl_codelet_hc2cf_4
fftwl_codelet_hc2cf_6
fftwl_codelet_hc2cf_8
fftwl_codelet_hc2cfdft_10
fftwl_codelet_hc2cfdft_12
fftwl_codelet_hc2cfdft_16
fftwl_codelet_hc2cfdft_2
fftwl_codelet_hc2cfdft_20
fftwl_codelet_hc2cfdft2_16
fftwl_codelet_hc2cfdft2_20
fftwl_codelet_hc2cfdft2_32
fftwl_codelet_hc2cfdft2_4
fftwl_codelet_hc2cfdft2_8
fftwl_codelet_hc2cfdft_32
fftwl_codelet_hc2cfdft_4
fftwl_codelet_hc2cfdft_6
fftwl_codelet_hc2cfdft_8
fftwl_codelet_hf_10
fftwl_codelet_hf_12
fftwl_codelet_hf_15
fftwl_codelet_hf_16
fftwl_codelet_hf_2
fftwl_codelet_hf_20
fftwl_codelet_hf2_16
fftwl_codelet_hf2_20
fftwl_codelet_hf2_25
fftwl_codelet_hf2_32
fftwl_codelet_hf2_4
fftwl_codelet_hf_25
fftwl_codelet_hf2_5
fftwl_codelet_hf2_8
fftwl_codelet_hf_3
fftwl_codelet_hf_32
fftwl_codelet_hf_4
fftwl_codelet_hf_5
fftwl_codelet_hf_6
fftwl_codelet_hf_64
fftwl_codelet_hf_7
fftwl_codelet_hf_8
fftwl_codelet_hf_9
fftwl_codelet_n1_10
fftwl_codelet_n1_11
fftwl_codelet_n1_12
fftwl_codelet_n1_13
fftwl_codelet_n1_14
fftwl_codelet_n1_15
fftwl_codelet_n1_16
fftwl_codelet_n1_2
fftwl_codelet_n1_20
fftwl_codelet_n1_25
fftwl_codelet_n1_3
fftwl_codelet_n1_32
fftwl_codelet_n1_4
fftwl_codelet_n1_5
fftwl_codelet_n1_6
fftwl_codelet_n1_64
fftwl_codelet_n1_7
fftwl_codelet_n1_8
fftwl_codelet_n1_9
fftwl_codelet_q1_2
fftwl_codelet_q1_3
fftwl_codelet_q1_4
fftwl_codelet_q1_5
fftwl_codelet_q1_6
fftwl_codelet_q1_8
fftwl_codelet_r2cb_10
fftwl_codelet_r2cb_11
fftwl_codelet_r2cb_12
fftwl_codelet_r2cb_128
fftwl_codelet_r2cb_13
fftwl_codelet_r2cb_14
fftwl_codelet_r2cb_15
fftwl_codelet_r2cb_16
fftwl_codelet_r2cb_2
fftwl_codelet_r2cb_20
fftwl_codelet_r2cb_25
fftwl_codelet_r2cb_3
fftwl_codelet_r2cb_32
fftwl_codelet_r2cb_4
fftwl_codelet_r2cb_5
fftwl_codelet_r2cb_6
fftwl_codelet_r2cb_64
fftwl_codelet_r2cb_7
fftwl_codelet_r2cb_8
fftwl_codelet_r2cb_9
fftwl_codelet_r2cbIII_10
fftwl_codelet_r2cbIII_12
fftwl_codelet_r2cbIII_15
fftwl_codelet_r2cbIII_16
fftwl_codelet_r2cbIII_2
fftwl_codelet_r2cbIII_20
fftwl_codelet_r2cbIII_25
fftwl_codelet_r2cbIII_3
fftwl_codelet_r2cbIII_32
fftwl_codelet_r2cbIII_4
fftwl_codelet_r2cbIII_5
fftwl_codelet_r2cbIII_6
fftwl_codelet_r2cbIII_64
fftwl_codelet_r2cbIII_7
fftwl_codelet_r2cbIII_8
fftwl_codelet_r2cbIII_9
fftwl_codelet_r2cf_10
fftwl_codelet_r2cf_11
fftwl_codelet_r2cf_12
fftwl_codelet_r2cf_128
fftwl_codelet_r2cf_13
fftwl_codelet_r2cf_14
fftwl_codelet_r2cf_15
fftwl_codelet_r2cf_16
fftwl_codelet_r2cf_2
fftwl_codelet_r2cf_20
fftwl_codelet_r2cf_25
fftwl_codelet_r2cf_3
fftwl_codelet_r2cf_32
fftwl_codelet_r2cf_4
fftwl_codelet_r2cf_5
fftwl_codelet_r2cf_6
fftwl_codelet_r2cf_64
fftwl_codelet_r2cf_7
fftwl_codelet_r2cf_8
fftwl_codelet_r2cf_9
fftwl_codelet_r2cfII_10
fftwl_codelet_r2cfII_12
fftwl_codelet_r2cfII_15
fftwl_codelet_r2cfII_16
fftwl_codelet_r2cfII_2
fftwl_codelet_r2cfII_20
fftwl_codelet_r2cfII_25
fftwl_codelet_r2cfII_3
fftwl_codelet_r2cfII_32
fftwl_codelet_r2cfII_4
fftwl_codelet_r2cfII_5
fftwl_codelet_r2cfII_6
fftwl_codelet_r2cfII_64
fftwl_codelet_r2cfII_7
fftwl_codelet_r2cfII_8
fftwl_codelet_r2cfII_9
fftwl_codelet_t1_10
fftwl_codelet_t1_12
fftwl_codelet_t1_15
fftwl_codelet_t1_16
fftwl_codelet_t1_2
fftwl_codelet_t1_20
fftwl_codelet_t1_25
fftwl_codelet_t1_3
fftwl_codelet_t1_32
fftwl_codelet_t1_4
fftwl_codelet_t1_5
fftwl_codelet_t1_6
fftwl_codelet_t1_64
fftwl_codelet_t1_7
fftwl_codelet_t1_8
fftwl_codelet_t1_9
fftwl_codelet_t2_10
fftwl_codelet_t2_16
fftwl_codelet_t2_20
fftwl_codelet_t2_25
fftwl_codelet_t2_32
fftwl_codelet_t2_4
fftwl_codelet_t2_5
fftwl_codelet_t2_64
fftwl_codelet_t2_8
fftwl_compute_tilesz
fftwl_configure_planner
fftwl_cost
fftwl_cpy1d
fftwl_cpy2d
fftwl_cpy2d_ci
fftwl_cpy2d_co
fftwl_cpy2d_pair
fftwl_cpy2d_pair_ci
fftwl_cpy2d_pair_co
fftwl_cpy2d_tiled
fftwl_cpy2d_tiledbuf
fftwl_ct_applicable
fftwl_ct_genericbuf_register
fftwl_ct_generic_register
fftwl_ct_uglyp
fftwl_destroy_plan
fftwl_dft_bluestein_register
fftwl_dft_buffered_register
fftwl_dft_conf_standard
fftwl_dft_generic_register
fftwl_dft_indirect_register
fftwl_dft_indirect_transpose_register
fftwl_dft_nop_register
fftwl_dft_r2hc_register
fftwl_dft_rader_register
fftwl_dft_rank_geq2_register
fftwl_dft_solve
fftwl_dft_thr_vrank_geq1_register
fftwl_dft_vrank_geq1_register
fftwl_dft_zerotens
fftwl_dht_r2hc_register
fftwl_dht_rader_register
fftwl_dimcmp
fftwl_elapsed_since
fftwl_estimate_cost
fftwl_execute
fftwl_execute_dft
fftwl_execute_dft_c2r
fftwl_execute_dft_r2c
fftwl_execute_r2r
fftwl_execute_split_dft
fftwl_execute_split_dft_c2r
fftwl_execute_split_dft_r2c
fftwl_export_wisdom
fftwl_export_wisdom_to_file
fftwl_export_wisdom_to_filename
fftwl_export_wisdom_to_string
fftwl_extract_reim
fftwl_factors_into
fftwl_factors_into_small_primes
fftwl_find_generator
fftwl_first_divisor
fftwl_flops
fftwl_forget_wisdom
fftwl_fprint_plan
fftwl_free
fftwl_get_crude_time
fftwl_guru64_kosherp
fftwl_guru_kosherp
fftwl_hash
fftwl_hc2hc_applicable
fftwl_hc2hc_generic_register
fftwl_iabs
fftwl_ialignment_of
fftwl_iestimate_cost
fftwl_ifree
fftwl_ifree0
fftwl_imax
fftwl_imin
fftwl_import_system_wisdom
fftwl_import_wisdom
fftwl_import_wisdom_from_file
fftwl_import_wisdom_from_filename
fftwl_import_wisdom_from_string
fftwl_init_threads
fftwl_is_prime
fftwl_isqrt
fftwl_ithreads_init
fftwl_kdft_dif_register
fftwl_kdft_difsq_register
fftwl_kdft_dit_register
fftwl_kdft_register
fftwl_kernel_free
fftwl_kernel_malloc
fftwl_khc2c_register
fftwl_khc2hc_register
fftwl_kr2c_register
fftwl_kr2r_register
fftwl_make_planner_thread_safe
fftwl_malloc
fftwl_malloc_plain
fftwl_many_kosherp
fftwl_mapflags
fftwl_map_r2r_kind
fftwl_md5begin
fftwl_md5end
fftwl_md5int
fftwl_md5INT
fftwl_md5putb
fftwl_md5putc
fftwl_md5puts
fftwl_md5unsigned
fftwl_measure_execution_time
fftwl_mkapiplan
fftwl_mkplan
fftwl_mkplan_d
fftwl_mkplan_dft
fftwl_mkplan_dftw
fftwl_mkplan_f_d
fftwl_mkplan_hc2c
fftwl_mkplan_hc2hc
fftwl_mkplanner
fftwl_mkplan_rdft
fftwl_mkplan_rdft2
fftwl_mkprinter
fftwl_mkprinter_cnt
fftwl_mkprinter_file
fftwl_mkprinter_str
fftwl_mkproblem
fftwl_mkproblem_dft
fftwl_mkproblem_dft_d
fftwl_mkproblem_rdft
fftwl_mkproblem_rdft_0_d
fftwl_mkproblem_rdft_1
fftwl_mkproblem_rdft_1_d
fftwl_mkproblem_rdft2
fftwl_mkproblem_rdft2_d
fftwl_mkproblem_rdft2_d_3pointers
fftwl_mkproblem_rdft_d
fftwl_mkproblem_unsolvable
fftwl_mkscanner
fftwl_mksolver
fftwl_mksolver_ct
fftwl_mksolver_ct_threads
fftwl_mksolver_dft_direct
fftwl_mksolver_dft_directbuf
fftwl_mksolver_hc2c
fftwl_mksolver_hc2hc
fftwl_mksolver_hc2hc_threads
fftwl_mksolver_rdft2_direct
fftwl_mksolver_rdft_r2c_direct
fftwl_mksolver_rdft_r2c_directbuf
fftwl_mksolver_rdft_r2r_direct
fftwl_mktensor
fftwl_mktensor_0d
fftwl_mktensor_1d
fftwl_mktensor_2d
fftwl_mktensor_3d
fftwl_mktensor_4d
fftwl_mktensor_5d
fftwl_mktensor_iodims
fftwl_mktensor_iodims64
fftwl_mktensor_rowmajor
fftwl_mktriggen
fftwl_modulo
fftwl_nbuf
fftwl_nbuf_redundant
fftwl_next_prime
fftwl_null_awake
fftwl_ops_add
fftwl_ops_add2
fftwl_ops_cpy
fftwl_ops_madd
fftwl_ops_madd2
fftwl_ops_other
fftwl_ops_zero
fftwl_pickdim
fftwl_plan_awake
fftwl_plan_destroy_internal
fftwl_plan_dft
fftwl_plan_dft_1d
fftwl_plan_dft_2d
fftwl_plan_dft_3d
fftwl_plan_dft_c2r
fftwl_plan_dft_c2r_1d
fftwl_plan_dft_c2r_2d
fftwl_plan_dft_c2r_3d
fftwl_plan_dft_r2c
fftwl_plan_dft_r2c_1d
fftwl_plan_dft_r2c_2d
fftwl_plan_dft_r2c_3d
fftwl_plan_guru64_dft
fftwl_plan_guru64_dft_c2r
fftwl_plan_guru64_dft_r2c
fftwl_plan_guru64_r2r
fftwl_plan_guru64_split_dft
fftwl_plan_guru64_split_dft_c2r
fftwl_plan_guru64_split_dft_r2c
fftwl_plan_guru_dft
fftwl_plan_guru_dft_c2r
fftwl_plan_guru_dft_r2c
fftwl_plan_guru_r2r
fftwl_plan_guru_split_dft
fftwl_plan_guru_split_dft_c2r
fftwl_plan_guru_split_dft_r2c
fftwl_plan_many_dft
fftwl_plan_many_dft_c2r
fftwl_plan_many_dft_r2c
fftwl_plan_many_r2r
fftwl_planner_destroy
fftwl_plan_null_destroy
fftwl_plan_r2r
fftwl_plan_r2r_1d
fftwl_plan_r2r_2d
fftwl_plan_r2r_3d
fftwl_plan_with_nthreads
fftwl_power_mod
fftwl_printer_destroy
fftwl_print_plan
fftwl_problem_destroy
fftwl_rader_tl_delete
fftwl_rader_tl_find
fftwl_rader_tl_insert
fftwl_rdft2_buffered_register
fftwl_rdft2_complex_n
fftwl_rdft2_inplace_strides
fftwl_rdft2_nop_register
fftwl_rdft2_pad
fftwl_rdft2_rank0_register
fftwl_rdft2_rank_geq2_register
fftwl_rdft2_rdft_register
fftwl_rdft2_solve
fftwl_rdft2_strides
fftwl_rdft2_tensor_max_index
fftwl_rdft2_thr_vrank_geq1_register
fftwl_rdft2_vrank_geq1_register
fftwl_rdft_buffered_register
fftwl_rdft_conf_standard
fftwl_rdft_dht_register
fftwl_rdft_generic_register
fftwl_rdft_indirect_register
fftwl_rdft_kind_str
fftwl_rdft_nop_register
fftwl_rdft_rank0_register
fftwl_rdft_rank_geq2_register
fftwl_rdft_solve
fftwl_rdft_thr_vrank_geq1_register
fftwl_rdft_vrank3_transpose_register
fftwl_rdft_vrank_geq1_register
fftwl_rdft_zerotens
fftwl_redft00e_r2hc_pad_register
fftwl_regsolver_ct_directw
fftwl_regsolver_ct_directwsq
fftwl_regsolver_hc2c_direct
fftwl_regsolver_hc2hc_direct
fftwl_reodft00e_splitradix_register
fftwl_reodft010e_r2hc_register
fftwl_reodft11e_r2hc_odd_register
fftwl_reodft11e_radix2_r2hc_register
fftwl_reodft_conf_standard
fftwl_rodft00e_r2hc_pad_register
fftwl_safe_mulmod
fftwl_scanner_destroy
fftwl_set_planner_hooks
fftwl_set_timelimit
fftwl_solver_destroy
fftwl_solver_register
fftwl_solver_use
fftwl_solvtab_exec
fftwl_spawn_loop
fftwl_sprint_plan
fftwl_tensor_append
fftwl_tensor_compress
fftwl_tensor_compress_contiguous
fftwl_tensor_copy
fftwl_tensor_copy_except
fftwl_tensor_copy_inplace
fftwl_tensor_copy_sub
fftwl_tensor_destroy
fftwl_tensor_destroy2
fftwl_tensor_destroy4
fftwl_tensor_equal
fftwl_tensor_inplace_locations
fftwl_tensor_inplace_strides
fftwl_tensor_inplace_strides2
fftwl_tensor_kosherp
fftwl_tensor_max_index
fftwl_tensor_md5
fftwl_tensor_min_istride
fftwl_tensor_min_ostride
fftwl_tensor_min_stride
fftwl_tensor_print
fftwl_tensor_split
fftwl_tensor_strides_decrease
fftwl_tensor_sz
fftwl_tensor_tornk1
fftwl_the_planner
fftwl_threads_cleanup
fftwl_threads_conf_standard
fftwl_threads_register_planner_hooks
fftwl_tile2d
fftwl_toobig
fftwl_transpose
fftwl_transpose_tiled
fftwl_transpose_tiledbuf
fftwl_triggen_destroy
fftwl_twiddle_awake
fftwl_twiddle_length
fftwl_zero1d_pair
lfftw_cleanup_
lfftw_cleanup__
lfftw_cleanup_threads_
lfftw_cleanup_threads__
lfftw_cost_
lfftw_cost__
lfftw_destroy_plan_
lfftw_destroy_plan__
lfftw_estimate_cost_
lfftw_estimate_cost__
lfftw_execute_
lfftw_execute__
lfftw_execute_dft_
lfftw_execute_dft__
lfftw_execute_dft_c2r_
lfftw_execute_dft_c2r__
lfftw_execute_dft_r2c_
lfftw_execute_dft_r2c__
lfftw_execute_r2r_
lfftw_execute_r2r__
lfftw_execute_split_dft_
lfftw_execute_split_dft__
lfftw_execute_split_dft_c2r_
lfftw_execute_split_dft_c2r__
lfftw_execute_split_dft_r2c_
lfftw_execute_split_dft_r2c__
lfftw_export_wisdom_
lfftw_export_wisdom__
lfftw_flops_
lfftw_flops__
lfftw_forget_wisdom_
lfftw_forget_wisdom__
lfftw_import_system_wisdom_
lfftw_import_system_wisdom__
lfftw_import_wisdom_
lfftw_import_wisdom__
lfftw_init_threads_
lfftw_init_threads__
lfftw_plan_dft_
lfftw_plan_dft__
lfftw_plan_dft_1d_
lfftw_plan_dft_1d__
lfftw_plan_dft_2d_
lfftw_plan_dft_2d__
lfftw_plan_dft_3d_
lfftw_plan_dft_3d__
lfftw_plan_dft_c2r_
lfftw_plan_dft_c2r__
lfftw_plan_dft_c2r_1d_
lfftw_plan_dft_c2r_1d__
lfftw_plan_dft_c2r_2d_
lfftw_plan_dft_c2r_2d__
lfftw_plan_dft_c2r_3d_
lfftw_plan_dft_c2r_3d__
lfftw_plan_dft_r2c_
lfftw_plan_dft_r2c__
lfftw_plan_dft_r2c_1d_
lfftw_plan_dft_r2c_1d__
lfftw_plan_dft_r2c_2d_
lfftw_plan_dft_r2c_2d__
lfftw_plan_dft_r2c_3d_
lfftw_plan_dft_r2c_3d__
lfftw_plan_guru_dft_
lfftw_plan_guru_dft__
lfftw_plan_guru_dft_c2r_
lfftw_plan_guru_dft_c2r__
lfftw_plan_guru_dft_r2c_
lfftw_plan_guru_dft_r2c__
lfftw_plan_guru_r2r_
lfftw_plan_guru_r2r__
lfftw_plan_guru_split_dft_
lfftw_plan_guru_split_dft__
lfftw_plan_guru_split_dft_c2r_
lfftw_plan_guru_split_dft_c2r__
lfftw_plan_guru_split_dft_r2c_
lfftw_plan_guru_split_dft_r2c__
lfftw_plan_many_dft_
lfftw_plan_many_dft__
lfftw_plan_many_dft_c2r_
lfftw_plan_many_dft_c2r__
lfftw_plan_many_dft_r2c_
lfftw_plan_many_dft_r2c__
lfftw_plan_many_r2r_
lfftw_plan_many_r2r__
lfftw_plan_r2r_
lfftw_plan_r2r__
lfftw_plan_r2r_1d_
lfftw_plan_r2r_1d__
lfftw_plan_r2r_2d_
lfftw_plan_r2r_2d__
lfftw_plan_r2r_3d_
lfftw_plan_r2r_3d__
lfftw_plan_with_nthreads_
lfftw_plan_with_nthreads__
lfftw_print_plan_
lfftw_print_plan__
lfftw_set_timelimit_
lfftw_set_timelimit__

BIN
Desktop_Interface/build_win/fftw/x86/libfftw3l-3.dll Normal file
View File

Binary file not shown.

4044
Desktop_Interface/compile_commands.json Normal file
View File

File diff suppressed because it is too large Load Diff

2
Desktop_Interface/isobuffer.cpp
View File

@ -2,6 +2,7 @@
#include <algorithm>
#include <cassert>
#include <iostream>
#include "isodriver.h"
#include "uartstyledecoder.h"
@ -55,6 +56,7 @@ void isoBuffer::insertIntoBuffer(short item)
{
m_back = 0;
}
async_dft.addSample(item);
checkTriggered();
}

4
Desktop_Interface/isobuffer.h
View File

@ -16,6 +16,7 @@
#include "xmega.h"
#include "desktop_settings.h"
#include "genericusbdriver.h"
#include "asyncdft.h"
class isoDriver;
class uartStyleDecoder;
@ -65,7 +66,6 @@ public:
void writeBuffer_short(short* data, int len);
std::unique_ptr<short[]> readBuffer(double sampleWindow, int numSamples, bool singleBit, double delayOffset);
// file I/O
private:
void outputSampleToFile(double averageSample);
@ -118,6 +118,8 @@ public:
// UARTS decoding
uartStyleDecoder* m_decoder = NULL;
bool m_isDecoding = true;
//DFT
AsyncDFT async_dft;
private:
// File I/O
bool m_fileIOEnabled = false;

113
Desktop_Interface/isodriver.cpp
View File

@ -4,7 +4,10 @@
#include "platformspecific.h"
#include <math.h>
#include "daqloadprompt.h"
#include <iostream>
#include <omp.h>
static constexpr int kSpectrumCounterMax = 4;
isoDriver::isoDriver(QWidget *parent) : QLabel(parent)
{
@ -172,7 +175,7 @@ void isoDriver::analogConvert(short *shortPtr, QVector<double> *doublePtr, int T
double frontendGain = (channel == 1 ? frontendGain_CH1 : frontendGain_CH2);
double *data = doublePtr->data();
for (int i=0;i<GRAPH_SAMPLES;i++){
for (int i=0;i<doublePtr->size();i++){
data[i] = (shortPtr[i] * (vcc/2)) / (frontendGain*scope_gain*TOP);
if (driver->deviceMode != 7) data[i] += ref;
#ifdef INVERT_MM
@ -184,8 +187,8 @@ void isoDriver::analogConvert(short *shortPtr, QVector<double> *doublePtr, int T
if (data[i] > currentVmax) currentVmax = data[i];
if (data[i] < currentVmin) currentVmin = data[i];
}
currentVmean = accumulated / GRAPH_SAMPLES;
currentVRMS = sqrt(accumulated_square / GRAPH_SAMPLES);
currentVmean = accumulated / doublePtr->size();
currentVRMS = sqrt(accumulated_square / doublePtr->size());
if(AC){
//Previous measurments are wrong, edit and redo.
accumulated = 0;
@ -193,7 +196,7 @@ void isoDriver::analogConvert(short *shortPtr, QVector<double> *doublePtr, int T
currentVmax = -20;
currentVmin = 20;
for (int i=0;i<GRAPH_SAMPLES;i++){
for (int i=0;i<doublePtr->size();i++){
data[i] -= currentVmean;
accumulated += data[i];
@ -201,8 +204,8 @@ void isoDriver::analogConvert(short *shortPtr, QVector<double> *doublePtr, int T
if (data[i] > currentVmax) currentVmax = data[i];
if (data[i] < currentVmin) currentVmin = data[i];
}
currentVmean = accumulated / GRAPH_SAMPLES;
currentVRMS = sqrt(accumulated_square / GRAPH_SAMPLES);
currentVmean = accumulated / doublePtr->size();
currentVRMS = sqrt(accumulated_square / doublePtr->size());
}
//cool_waveform = cool_waveform - AC_offset;
}
@ -614,6 +617,18 @@ void isoDriver::setTriggerMode(int newMode)
//0 for off, 1 for ana, 2 for dig, -1 for ana750, -2 for file
void isoDriver::frameActionGeneric(char CH1_mode, char CH2_mode)
{
// The Spectrum is computationally expensive to calculate, so we don't want to do it on every frame
static int spectrumCounter = 0;
if(spectrum)
{
spectrumCounter = (spectrumCounter + 1) % kSpectrumCounterMax;
if (spectrumCounter != 0)
return;
}
//qDebug() << "made it to frameActionGeneric";
if(!paused_CH1 && CH1_mode == - 1){
for (unsigned int i=0;i<(length/ADC_SPF);i++){
@ -662,34 +677,70 @@ void isoDriver::frameActionGeneric(char CH1_mode, char CH2_mode)
if(singleShotEnabled && (triggerDelay != 0))
singleShotTriggered(1);
if (!spectrum) {
readData375_CH1 = internalBuffer375_CH1->readBuffer(display.window,GRAPH_SAMPLES,CH1_mode==2, display.delay + triggerDelay);
if(CH2_mode) readData375_CH2 = internalBuffer375_CH2->readBuffer(display.window,GRAPH_SAMPLES,CH2_mode==2, display.delay + triggerDelay);
if(CH1_mode == -1) readData750 = internalBuffer750->readBuffer(display.window,GRAPH_SAMPLES,false, display.delay + triggerDelay);
if(CH1_mode == -2) readDataFile = internalBufferFile->readBuffer(display.window,GRAPH_SAMPLES,false, display.delay);
} else {
/*Don't allow moving frequency spectrum right or left
* by overwriting display window and delay before reading
* the buffer each time.
* @TODO improve this limitation.
*/
double const_displ_window = ((double)internalBuffer375_CH1->async_dft.n_samples)/(internalBuffer375_CH1->m_samplesPerSecond);
double const_displ_delay = 0;
display.delay = const_displ_delay;
display.window = const_displ_window;
readData375_CH1 = internalBuffer375_CH1->readBuffer(display.window,GRAPH_SAMPLES,CH1_mode==2, display.delay + triggerDelay);
if(CH2_mode) readData375_CH2 = internalBuffer375_CH2->readBuffer(display.window,GRAPH_SAMPLES,CH2_mode==2, display.delay + triggerDelay);
if(CH1_mode == -1) readData750 = internalBuffer750->readBuffer(display.window,GRAPH_SAMPLES,false, display.delay + triggerDelay);
}
/*Convert data also for spectrum CH1 and CH2*/
std::unique_ptr<short[]> dt_samples1 = internalBuffer375_CH1->async_dft.getWindow();
std::unique_ptr<short[]> dt_samples2 = internalBuffer375_CH2->async_dft.getWindow();
QVector<double> x(GRAPH_SAMPLES), CH1(GRAPH_SAMPLES), CH2(GRAPH_SAMPLES);
QVector<double> x(GRAPH_SAMPLES), CH1(GRAPH_SAMPLES), CH2(GRAPH_SAMPLES),
converted_dt_samples1(internalBuffer375_CH1->async_dft.n_samples),
converted_dt_samples2(internalBuffer375_CH2->async_dft.n_samples);
if (CH1_mode == 1){
analogConvert(readData375_CH1.get(), &CH1, 128, AC_CH1, 1);
for (int i=0; i < GRAPH_SAMPLES; i++)
analogConvert(dt_samples1.get(), &converted_dt_samples1, 128, AC_CH1, 1);
for (int i=0; i < CH1.size(); i++)
{
CH1[i] /= m_attenuation_CH1;
CH1[i] += m_offset_CH1;
}
for (int i=0; i < converted_dt_samples1.size(); i++)
{
converted_dt_samples1[i] /= m_attenuation_CH1;
converted_dt_samples1[i] += m_offset_CH1;
}
xmin = (currentVmin < xmin) ? currentVmin : xmin;
xmax = (currentVmax > xmax) ? currentVmax : xmax;
broadcastStats(0);
}
/*After conversion of dt samples, sending them again to asyncDFT*/
if (CH1_mode == 2) digitalConvert(readData375_CH1.get(), &CH1);
if (CH2_mode == 1){
analogConvert(readData375_CH2.get(), &CH2, 128, AC_CH2, 2);
analogConvert(dt_samples2.get(), &converted_dt_samples2, 128, AC_CH2, 2);
for (int i=0; i < GRAPH_SAMPLES; i++)
{
CH2[i] /= m_attenuation_CH2;
CH2[i] += m_offset_CH2;
}
for (int i=0; i < converted_dt_samples2.size(); i++)
{
converted_dt_samples2[i] /= m_attenuation_CH1;
converted_dt_samples2[i] += m_offset_CH1;
}
ymin = (currentVmin < ymin) ? currentVmin : ymin;
ymax = (currentVmax > ymax) ? currentVmax : ymax;
broadcastStats(1);
@ -723,12 +774,43 @@ void isoDriver::frameActionGeneric(char CH1_mode, char CH2_mode)
curve->setData(CH1, CH2);
axes->xAxis->setRange(xmin, xmax);
axes->yAxis->setRange(ymin, ymax);
}else{
} else{
if (spectrum) { /*If frequency spectrum mode*/
try {
/*Creating DFT amplitudes*/
QVector<double> amplitude1 = internalBuffer375_CH1->async_dft.getPowerSpectrum(converted_dt_samples1);
/*Getting array of frequencies for display purposes*/
QVector<double> f = internalBuffer375_CH1->async_dft.getFrequenciyWindow(internalBuffer375_CH1->m_samplesPerSecond);
/*Max amplitude for display purposes*/
double max1 = internalBuffer375_CH1->async_dft.maximum;
double max2 = -1;
if(CH2_mode) {
QVector<double> amplitude2 = internalBuffer375_CH2->async_dft.getPowerSpectrum(converted_dt_samples2);
max2 = internalBuffer375_CH2->async_dft.maximum;
/*Normalization with respect to amplitude1*/
amplitude2 = internalBuffer375_CH2->async_dft.normalizeDFT(max1, amplitude2);
axes->graph(1)->setData(f,amplitude2);
}
/*Decision for normalization & display purposes*/
amplitude1 = internalBuffer375_CH1->async_dft.normalizeDFT(max2, amplitude1);
axes->graph(0)->setData(f, amplitude1);
axes->xAxis->setRange(m_spectrumMinX, m_spectrumMaxX);
/*Setting maximum/minimum y-axis 0%-100%*/
axes->yAxis->setRange(100,0);
} catch (std::exception) {
std::cout << "Cannot yet get correct value for DFT" << std::endl;
}
} else {
axes->graph(0)->setData(x,CH1);
if(CH2_mode) axes->graph(1)->setData(x,CH2);
axes->xAxis->setRange(-display.window - display.delay, -display.delay);
axes->yAxis->setRange(display.topRange, display.botRange);
}
}
if(snapshotEnabled_CH1){
snapshotFile_CH1->open(QIODevice::WriteOnly);
@ -1566,3 +1648,14 @@ void isoDriver::setHexDisplay_CH2(bool enabled)
{
hexDisplay_CH2 = enabled;
}
void isoDriver::setMinSpectrum(int minSpectrum)
{
m_spectrumMinX = static_cast<double>(minSpectrum);
}
void isoDriver::setMaxSpectrum(int maxSpectrum)
{
m_spectrumMaxX = static_cast<double>(maxSpectrum);
}

8
Desktop_Interface/isodriver.h
View File

@ -89,6 +89,7 @@ public:
//DAQ
bool fileModeEnabled = false;
double daq_maxWindowSize;
bool spectrum = false;
private:
//Those bloody bools that just Enable/Disable a single property
bool paused_CH1 = false;
@ -124,6 +125,8 @@ private:
bool firstFrame = true;
bool hexDisplay_CH1 = false;
bool hexDisplay_CH2 = false;
//Generic Functions
void analogConvert(short *shortPtr, QVector<double> *doublePtr, int TOP, bool AC, int channel);
void digitalConvert(short *shortPtr, QVector<double> *doublePtr);
@ -185,6 +188,9 @@ private:
uint8_t deviceMode_prev;
//DAQ
double daqLoad_startTime, daqLoad_endTime;
//Spectrum
double m_spectrumMinX = 0;
double m_spectrumMaxX = 187500;
signals:
void setGain(double newGain);
@ -282,6 +288,8 @@ public slots:
void attenuationChanged_CH2(int attenuationIndex);
void setHexDisplay_CH1(bool enabled);
void setHexDisplay_CH2(bool enabled);
void setMinSpectrum(int minSpectrum);
void setMaxSpectrum(int maxSpectrum);
};
#endif // ISODRIVER_H

5
Desktop_Interface/macrun Executable file
View File

@ -0,0 +1,5 @@
qmake
make -j$(sysctl -n hw.physicalcpu)
cp -R ./bin/waveforms ./bin/Labrador.app/Contents/MacOS
cp -R ./bin/firmware ./bin/Labrador.app/Contents/MacOS
./bin/Labrador.app/Contents/MacOS/Labrador

41
Desktop_Interface/mainwindow.cpp
View File

@ -247,6 +247,38 @@ MainWindow::MainWindow(QWidget *parent) :
connect(ui->attenuationComboBox_CH2, SIGNAL(currentIndexChanged(int)), ui->controller_iso, SLOT(attenuationChanged_CH2(int)));
#endif
connect(ui->controller_iso, &isoDriver::enableCursorGroup, this, &MainWindow::cursorGroupEnabled);
spectrumMinXSpinbox = new QSpinBox();
spectrumMaxXSpinbox = new QSpinBox();
spectrumLayoutWidget = new QWidget();
QHBoxLayout* spectrumLayout = new QHBoxLayout();
QLabel* spectrumMinFreqLabel = new QLabel("Min Frequency (Hz)");
QLabel* spectrumMaxFreqLabel = new QLabel("Max Frequency (Hz)");
QSpacerItem* spacer = new QSpacerItem(20, 40, QSizePolicy::Expanding, QSizePolicy::Minimum);
spectrumLayoutWidget->setLayout(spectrumLayout);
spectrumMinXSpinbox->setMinimum(0);
spectrumMinXSpinbox->setMaximum(187500);
spectrumMaxXSpinbox->setMinimum(0);
spectrumMaxXSpinbox->setMaximum(187500);
spectrumMaxXSpinbox->setValue(187500);
spectrumLayout->addItem(spacer);
spectrumLayout->addWidget(spectrumMinFreqLabel);
spectrumLayout->addWidget(spectrumMinXSpinbox);
spectrumLayout->addItem(spacer);
spectrumLayout->addWidget(spectrumMaxFreqLabel);
spectrumLayout->addWidget(spectrumMaxXSpinbox);
spectrumLayout->addItem(spacer);
connect(spectrumMinXSpinbox, QOverload<int>::of(&QSpinBox::valueChanged), ui->controller_iso, &isoDriver::setMinSpectrum);
connect(spectrumMaxXSpinbox, QOverload<int>::of(&QSpinBox::valueChanged), ui->controller_iso, &isoDriver::setMaxSpectrum);
connect(spectrumMinXSpinbox, QOverload<int>::of(&QSpinBox::valueChanged), spectrumMaxXSpinbox, &QSpinBox::setMinimum);
connect(spectrumMaxXSpinbox, QOverload<int>::of(&QSpinBox::valueChanged), spectrumMinXSpinbox, &QSpinBox::setMaximum);
ui->verticalLayout->addWidget(spectrumLayoutWidget);
spectrumLayoutWidget->setVisible(false);
}
MainWindow::~MainWindow()
@ -2586,4 +2618,13 @@ void MainWindow::on_actionDark_Mode_triggered(bool checked)
void MainWindow::on_actionShow_Debug_Console_triggered(bool checked)
{
enableLabradorDebugging(checked);
void MainWindow::on_actionFrequency_Spectrum_triggered(bool checked)
{
ui->controller_iso->spectrum = checked;
spectrumLayoutWidget->setVisible(checked);
if (checked == true)
MAX_WINDOW_SIZE = 1<<17;
else
MAX_WINDOW_SIZE = 10;
}

5
Desktop_Interface/mainwindow.h
View File

@ -228,6 +228,7 @@ private slots:
void on_actionDark_Mode_triggered(bool checked);
void on_actionShow_Debug_Console_triggered(bool checked);
void on_actionFrequency_Spectrum_triggered(bool checked);
private:
//Generic Vars
@ -298,6 +299,10 @@ private:
QShortcut *shortcut_Debug;
QShortcut *shortcut_Esc;
QWidget* spectrumLayoutWidget = nullptr;
QSpinBox* spectrumMinXSpinbox = nullptr;
QSpinBox* spectrumMaxXSpinbox = nullptr;
//Duct Tape
bool dt_AlreadyAskedAboutCalibration = false;
int dt_userWantsToCalibrate;

24
Desktop_Interface/make_appimage
View File

@ -1,5 +1,27 @@
#!/bin/bash
FFTW=fftw-3.3.9
if [ ! -d $FFTW ]
then
wget "http://fftw.org/$FFTW.tar.gz"
tar xvf "$FFTW.tar.gz"
rm "$FFTW.tar.gz"
fi
cd $FFTW
./configure \
F77=gfortran \
--with-gcc \
--prefix=/usr \
--infodir=/usr/share/info \
--enable-type-prefix \
--enable-shared \
--enable-threads \
--enable-openmp \
--enable-mpi
make -j8
sudo make install
cd ..
set -e
qmake APPIMAGE=1 CONFIG+=release PREFIX=/usr DEFINES+=GIT_HASH_SHORT=$(git rev-parse --short HEAD)
@ -11,7 +33,7 @@ unset QTDIR; unset QT_PLUGIN_PATH ; unset LD_LIBRARY_PATH
export VERSION=$(git rev-parse --short HEAD)
./linuxdeployqt-*.AppImage appdir/usr/share/applications/*.desktop -bundle-non-qt-libs -verbose=2 -unsupported-allow-new-glibc
mkdir -p appdir/usr/optional/ ; wget -c https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/exec-x86_64.so -O ./appdir/usr/optional/exec.so
mkdir -p appdir/usr/optional/libstdc++/ ; cp /usr/lib/x86_64-linux-gnu/libstdc++.so.6 ./appdir/usr/optional/libstdc++/
mkdir -p appdir/usr/optional/libstdc++/ ; cp /usr/lib/libstdc++.so.6 ./appdir/usr/optional/libstdc++/
./linuxdeployqt-*.AppImage --appimage-extract
rm ./appdir/AppRun ; cp ./resources/AppRun appdir/ ; chmod a+x ./appdir/AppRun
PATH=./squashfs-root/usr/bin:$PATH ./squashfs-root/usr/bin/appimagetool -g ./appdir/

162
Desktop_Interface/ui_files_desktop/mainwindow.ui
View File

@ -1507,7 +1507,7 @@
<x>0</x>
<y>0</y>
<width>1493</width>
<height>21</height>
<height>23</height>
</rect>
</property>
<widget class="QMenu" name="menuFile">
@ -1535,77 +1535,6 @@
<addaction name="actionExportImage"/>
<addaction name="actionQuit"/>
</widget>
<widget class="QMenu" name="menuOscilloscope_2">
<property name="title">
<string>Oscilloscope</string>
</property>
<widget class="QMenu" name="menuGain_2">
<property name="title">
<string>&amp;Gain</string>
</property>
<addaction name="actionGainAuto"/>
<addaction name="actionGain0_5"/>
<addaction name="actionGain1"/>
<addaction name="actionGain2"/>
<addaction name="actionGain4"/>
<addaction name="actionGain8"/>
<addaction name="actionGain16"/>
<addaction name="actionGain32"/>
<addaction name="actionGain64"/>
</widget>
<widget class="noCloseMenu" name="menuCH1_Stats">
<property name="title">
<string>&amp;CH1 Stats</string>
</property>
<addaction name="actionMax"/>
<addaction name="actionMin"/>
<addaction name="actionMean"/>
<addaction name="actionRMS"/>
</widget>
<widget class="noCloseMenu" name="menuCH2_Stats">
<property name="title">
<string>C&amp;H2 Stats</string>
</property>
<addaction name="actionMax_2"/>
<addaction name="actionMin_2"/>
<addaction name="actionMean_2"/>
<addaction name="actionRMS_2"/>
</widget>
<widget class="QMenu" name="menuFrame_rate">
<property name="title">
<string>&amp;Frame rate</string>
</property>
<addaction name="action60FPS"/>
<addaction name="action30FPS"/>
<addaction name="action20FPS"/>
<addaction name="action15FPS"/>
<addaction name="action10FPS"/>
<addaction name="action5FPS"/>
</widget>
<widget class="QMenu" name="menuRange">
<property name="title">
<string>&amp;Range</string>
</property>
<addaction name="actionSnap_to_Cursors"/>
<addaction name="actionEnter_Manually"/>
</widget>
<addaction name="menuRange"/>
<addaction name="separator"/>
<addaction name="menuFrame_rate"/>
<addaction name="separator"/>
<addaction name="menuGain_2"/>
<addaction name="separator"/>
<addaction name="menuCH1_Stats"/>
<addaction name="menuCH2_Stats"/>
<addaction name="actionCursor_Stats"/>
<addaction name="separator"/>
<addaction name="actionCalibrate"/>
<addaction name="actionForce_Square"/>
<addaction name="actionAutomatically_Enable_Cursors"/>
<addaction name="actionShow_Range_Dialog_on_Main_Page"/>
<addaction name="separator"/>
<addaction name="actionHide_Widget_Oscilloscope"/>
</widget>
<widget class="QMenu" name="menuMultimeter_2">
<property name="title">
<string>&amp;Multimeter</string>
@ -1615,8 +1544,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>160</width>
<height>120</height>
<width>172</width>
<height>130</height>
</rect>
</property>
<property name="title">
@ -1802,6 +1731,77 @@
<string>Accessibility</string>
</property>
<addaction name="actionDark_Mode"/>
<widget class="QMenu" name="menuOscilloscope_2">
<property name="title">
<string>Oscilloscope</string>
</property>
<widget class="QMenu" name="menuGain_2">
<property name="title">
<string>&amp;Gain</string>
</property>
<addaction name="actionGainAuto"/>
<addaction name="actionGain0_5"/>
<addaction name="actionGain1"/>
<addaction name="actionGain2"/>
<addaction name="actionGain4"/>
<addaction name="actionGain8"/>
<addaction name="actionGain16"/>
<addaction name="actionGain32"/>
<addaction name="actionGain64"/>
</widget>
<widget class="noCloseMenu" name="menuCH1_Stats">
<property name="title">
<string>&amp;CH1 Stats</string>
</property>
<addaction name="actionMax"/>
<addaction name="actionMin"/>
<addaction name="actionMean"/>
<addaction name="actionRMS"/>
</widget>
<widget class="noCloseMenu" name="menuCH2_Stats">
<property name="title">
<string>C&amp;H2 Stats</string>
</property>
<addaction name="actionMax_2"/>
<addaction name="actionMin_2"/>
<addaction name="actionMean_2"/>
<addaction name="actionRMS_2"/>
</widget>
<widget class="QMenu" name="menuFrame_rate">
<property name="title">
<string>&amp;Frame rate</string>
</property>
<addaction name="action60FPS"/>
<addaction name="action30FPS"/>
<addaction name="action20FPS"/>
<addaction name="action15FPS"/>
<addaction name="action10FPS"/>
<addaction name="action5FPS"/>
</widget>
<widget class="QMenu" name="menuRange">
<property name="title">
<string>&amp;Range</string>
</property>
<addaction name="actionSnap_to_Cursors"/>
<addaction name="actionEnter_Manually"/>
</widget>
<addaction name="menuRange"/>
<addaction name="separator"/>
<addaction name="menuFrame_rate"/>
<addaction name="separator"/>
<addaction name="menuGain_2"/>
<addaction name="separator"/>
<addaction name="menuCH1_Stats"/>
<addaction name="menuCH2_Stats"/>
<addaction name="actionCursor_Stats"/>
<addaction name="separator"/>
<addaction name="actionCalibrate"/>
<addaction name="actionForce_Square"/>
<addaction name="actionAutomatically_Enable_Cursors"/>
<addaction name="actionShow_Range_Dialog_on_Main_Page"/>
<addaction name="separator"/>
<addaction name="actionHide_Widget_Oscilloscope"/>
<addaction name="actionFrequency_Spectrum"/>
</widget>
<addaction name="menuFile"/>
<addaction name="menuOscilloscope_2"/>
@ -2645,6 +2645,20 @@
</property>
<property name="text">
<string>Dark Mode</string>
<action name="actionWidget">
<property name="text">
<string>Hide Widget</string>
</property>
</action>
<action name="actionFrequency_Spectrum">
<property name="checkable">
<bool>true</bool>
</property>
<property name="checked">
<bool>false</bool>
</property>
<property name="text">
<string>Frequency Spectrum</string>
</property>
</action>
</widget>

1
SlidingDFT Submodule

@ -0,0 +1 @@
Subproject commit 13e0121253c73f2e85e418a3ae960463c0fbf31f

0
test.txt Normal file
View File