diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..0c7dc5d5 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "SlidingDFT"] + path = SlidingDFT + url = https://github.com/bronsonp/SlidingDFT.git diff --git a/.travis.yml b/.travis.yml index 2783977e..5e5438a0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -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 diff --git a/Desktop_Interface/Labrador.pro b/Desktop_Interface/Labrador.pro index 20d61baf..7d754d6b 100644 --- a/Desktop_Interface/Labrador.pro +++ b/Desktop_Interface/Labrador.pro @@ -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 diff --git a/Desktop_Interface/asyncdft.cpp b/Desktop_Interface/asyncdft.cpp new file mode 100644 index 00000000..290c69c5 --- /dev/null +++ b/Desktop_Interface/asyncdft.cpp @@ -0,0 +1,153 @@ +#include "asyncdft.h" +#include +#include +#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 AsyncDFT::getPowerSpectrum(QVector 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 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 AsyncDFT::getFrequenciyWindow(int samplesPerSeconds) +{ + double delta_freq = ((double) samplesPerSeconds)/ ((double) n_samples); + QVector 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 AsyncDFT::getWindow() +{ + std::unique_ptr readData = std::make_unique(n_samples); + int i = 0; + for (auto& item : window) { + readData[i] = item; + i++; + } + + return readData; +} + + +QVector AsyncDFT::normalizeDFT(double e_maximum, QVector 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; +} diff --git a/Desktop_Interface/asyncdft.h b/Desktop_Interface/asyncdft.h new file mode 100644 index 00000000..2df212e9 --- /dev/null +++ b/Desktop_Interface/asyncdft.h @@ -0,0 +1,57 @@ +#ifndef ASYNCDFT_H +#define ASYNCDFT_H +#include +#include +#include +#include +#include +#include +#include + +class AsyncDFT +{ +public: + AsyncDFT(); + ~AsyncDFT(); + static const int n_samples = 1<<17; + + /* Raise exception if not ready yet*/ + QVector getPowerSpectrum(QVector input); + QVector getFrequenciyWindow(int samplesPerSeconds); + + /*Add a sample to the time domain samples*/ + void addSample(short sample); + + /*Return the window of samples*/ + std::unique_ptr getWindow(); + + /*Normalize the DFT*/ + QVector normalizeDFT(double e_maximum, QVector 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 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 pending_samples; +}; + +#endif // ASYNCDFT_H diff --git a/Desktop_Interface/build_win/fftw/x64/COPYING b/Desktop_Interface/build_win/fftw/x64/COPYING new file mode 100644 index 00000000..623b6258 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/COPYING @@ -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. + + + Copyright (C) + + 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. + + , 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. diff --git a/Desktop_Interface/build_win/fftw/x64/COPYRIGHT b/Desktop_Interface/build_win/fftw/x64/COPYRIGHT new file mode 100644 index 00000000..089500b6 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/COPYRIGHT @@ -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 + * + */ diff --git a/Desktop_Interface/build_win/fftw/x64/NEWS b/Desktop_Interface/build_win/fftw/x64/NEWS new file mode 100644 index 00000000..9a9cac67 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/NEWS @@ -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=, + 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. diff --git a/Desktop_Interface/build_win/fftw/x64/README b/Desktop_Interface/build_win/fftw/x64/README new file mode 100644 index 00000000..1547fe5d --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/README @@ -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. diff --git a/Desktop_Interface/build_win/fftw/x64/README-WINDOWS b/Desktop_Interface/build_win/fftw/x64/README-WINDOWS new file mode 100644 index 00000000..a3237eb1 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/README-WINDOWS @@ -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 diff --git a/Desktop_Interface/build_win/fftw/x64/README-bench b/Desktop_Interface/build_win/fftw/x64/README-bench new file mode 100644 index 00000000..5a5c6e6f --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/README-bench @@ -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 + +where each command is as follows: + +-s +--speed + + Benchmarks the speed of . + + The syntax for problems is [i|o][r|c][f|b], 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. + 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 +--verify + + 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 + + Set verbosity to , or 1 if 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). diff --git a/Desktop_Interface/build_win/fftw/x64/fftw3.f b/Desktop_Interface/build_win/fftw/x64/fftw3.f new file mode 100644 index 00000000..72d1aaf2 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/fftw3.f @@ -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) diff --git a/Desktop_Interface/build_win/fftw/x64/fftw3.f03 b/Desktop_Interface/build_win/fftw/x64/fftw3.f03 new file mode 100644 index 00000000..85ba1b6d --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/fftw3.f03 @@ -0,0 +1,1254 @@ +! Generated automatically. DO NOT EDIT! + + integer, parameter :: C_FFTW_R2R_KIND = C_INT32_T + + integer(C_INT), parameter :: FFTW_R2HC = 0 + integer(C_INT), parameter :: FFTW_HC2R = 1 + integer(C_INT), parameter :: FFTW_DHT = 2 + integer(C_INT), parameter :: FFTW_REDFT00 = 3 + integer(C_INT), parameter :: FFTW_REDFT01 = 4 + integer(C_INT), parameter :: FFTW_REDFT10 = 5 + integer(C_INT), parameter :: FFTW_REDFT11 = 6 + integer(C_INT), parameter :: FFTW_RODFT00 = 7 + integer(C_INT), parameter :: FFTW_RODFT01 = 8 + integer(C_INT), parameter :: FFTW_RODFT10 = 9 + integer(C_INT), parameter :: FFTW_RODFT11 = 10 + integer(C_INT), parameter :: FFTW_FORWARD = -1 + integer(C_INT), parameter :: FFTW_BACKWARD = +1 + integer(C_INT), parameter :: FFTW_MEASURE = 0 + integer(C_INT), parameter :: FFTW_DESTROY_INPUT = 1 + integer(C_INT), parameter :: FFTW_UNALIGNED = 2 + integer(C_INT), parameter :: FFTW_CONSERVE_MEMORY = 4 + integer(C_INT), parameter :: FFTW_EXHAUSTIVE = 8 + integer(C_INT), parameter :: FFTW_PRESERVE_INPUT = 16 + integer(C_INT), parameter :: FFTW_PATIENT = 32 + integer(C_INT), parameter :: FFTW_ESTIMATE = 64 + integer(C_INT), parameter :: FFTW_WISDOM_ONLY = 2097152 + integer(C_INT), parameter :: FFTW_ESTIMATE_PATIENT = 128 + integer(C_INT), parameter :: FFTW_BELIEVE_PCOST = 256 + integer(C_INT), parameter :: FFTW_NO_DFT_R2HC = 512 + integer(C_INT), parameter :: FFTW_NO_NONTHREADED = 1024 + integer(C_INT), parameter :: FFTW_NO_BUFFERING = 2048 + integer(C_INT), parameter :: FFTW_NO_INDIRECT_OP = 4096 + integer(C_INT), parameter :: FFTW_ALLOW_LARGE_GENERIC = 8192 + integer(C_INT), parameter :: FFTW_NO_RANK_SPLITS = 16384 + integer(C_INT), parameter :: FFTW_NO_VRANK_SPLITS = 32768 + integer(C_INT), parameter :: FFTW_NO_VRECURSE = 65536 + integer(C_INT), parameter :: FFTW_NO_SIMD = 131072 + integer(C_INT), parameter :: FFTW_NO_SLOW = 262144 + integer(C_INT), parameter :: FFTW_NO_FIXED_RADIX_LARGE_N = 524288 + integer(C_INT), parameter :: FFTW_ALLOW_PRUNING = 1048576 + + type, bind(C) :: fftw_iodim + integer(C_INT) n, is, os + end type fftw_iodim + type, bind(C) :: fftw_iodim64 + integer(C_INTPTR_T) n, is, os + end type fftw_iodim64 + + interface + type(C_PTR) function fftw_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftw_plan_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft + + type(C_PTR) function fftw_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftw_plan_dft_1d') + import + integer(C_INT), value :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft_1d + + type(C_PTR) function fftw_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftw_plan_dft_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft_2d + + type(C_PTR) function fftw_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftw_plan_dft_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft_3d + + type(C_PTR) function fftw_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) & + bind(C, name='fftw_plan_many_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_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_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 fftw_plan_many_dft + + type(C_PTR) function fftw_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftw_plan_guru_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_guru_dft + + type(C_PTR) function fftw_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftw_plan_guru_split_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru_split_dft + + type(C_PTR) function fftw_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftw_plan_guru64_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_guru64_dft + + type(C_PTR) function fftw_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftw_plan_guru64_split_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru64_split_dft + + subroutine fftw_execute_dft(p,in,out) bind(C, name='fftw_execute_dft') + import + type(C_PTR), value :: p + complex(C_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftw_execute_dft + + subroutine fftw_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftw_execute_split_dft') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: ri + real(C_DOUBLE), dimension(*), intent(inout) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + end subroutine fftw_execute_split_dft + + type(C_PTR) function fftw_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftw_plan_many_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_DOUBLE), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + complex(C_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 fftw_plan_many_dft_r2c + + type(C_PTR) function fftw_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftw_plan_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c + + type(C_PTR) function fftw_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftw_plan_dft_r2c_1d') + import + integer(C_INT), value :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c_1d + + type(C_PTR) function fftw_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftw_plan_dft_r2c_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c_2d + + type(C_PTR) function fftw_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftw_plan_dft_r2c_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c_3d + + type(C_PTR) function fftw_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftw_plan_many_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_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_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 fftw_plan_many_dft_c2r + + type(C_PTR) function fftw_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftw_plan_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r + + type(C_PTR) function fftw_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftw_plan_dft_c2r_1d') + import + integer(C_INT), value :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r_1d + + type(C_PTR) function fftw_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftw_plan_dft_c2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r_2d + + type(C_PTR) function fftw_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftw_plan_dft_c2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r_3d + + type(C_PTR) function fftw_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru_dft_r2c + + type(C_PTR) function fftw_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru_dft_c2r + + type(C_PTR) function fftw_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftw_plan_guru_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru_split_dft_r2c + + type(C_PTR) function fftw_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftw_plan_guru_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru_split_dft_c2r + + type(C_PTR) function fftw_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru64_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru64_dft_r2c + + type(C_PTR) function fftw_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru64_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru64_dft_c2r + + type(C_PTR) function fftw_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftw_plan_guru64_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru64_split_dft_r2c + + type(C_PTR) function fftw_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftw_plan_guru64_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru64_split_dft_c2r + + subroutine fftw_execute_dft_r2c(p,in,out) bind(C, name='fftw_execute_dft_r2c') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftw_execute_dft_r2c + + subroutine fftw_execute_dft_c2r(p,in,out) bind(C, name='fftw_execute_dft_c2r') + import + type(C_PTR), value :: p + complex(C_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + end subroutine fftw_execute_dft_c2r + + subroutine fftw_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftw_execute_split_dft_r2c') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: in + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + end subroutine fftw_execute_split_dft_r2c + + subroutine fftw_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftw_execute_split_dft_c2r') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: ri + real(C_DOUBLE), dimension(*), intent(inout) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: out + end subroutine fftw_execute_split_dft_c2r + + type(C_PTR) function fftw_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) & + bind(C, name='fftw_plan_many_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_DOUBLE), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + real(C_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 fftw_plan_many_r2r + + type(C_PTR) function fftw_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftw_plan_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftw_plan_r2r + + type(C_PTR) function fftw_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftw_plan_r2r_1d') + import + integer(C_INT), value :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), value :: kind + integer(C_INT), value :: flags + end function fftw_plan_r2r_1d + + type(C_PTR) function fftw_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftw_plan_r2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_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 fftw_plan_r2r_2d + + type(C_PTR) function fftw_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftw_plan_r2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_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 fftw_plan_r2r_3d + + type(C_PTR) function fftw_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftw_plan_guru_r2r') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftw_plan_guru_r2r + + type(C_PTR) function fftw_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftw_plan_guru64_r2r') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftw_plan_guru64_r2r + + subroutine fftw_execute_r2r(p,in,out) bind(C, name='fftw_execute_r2r') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + end subroutine fftw_execute_r2r + + subroutine fftw_destroy_plan(p) bind(C, name='fftw_destroy_plan') + import + type(C_PTR), value :: p + end subroutine fftw_destroy_plan + + subroutine fftw_forget_wisdom() bind(C, name='fftw_forget_wisdom') + import + end subroutine fftw_forget_wisdom + + subroutine fftw_cleanup() bind(C, name='fftw_cleanup') + import + end subroutine fftw_cleanup + + subroutine fftw_set_timelimit(t) bind(C, name='fftw_set_timelimit') + import + real(C_DOUBLE), value :: t + end subroutine fftw_set_timelimit + + subroutine fftw_plan_with_nthreads(nthreads) bind(C, name='fftw_plan_with_nthreads') + import + integer(C_INT), value :: nthreads + end subroutine fftw_plan_with_nthreads + + integer(C_INT) function fftw_init_threads() bind(C, name='fftw_init_threads') + import + end function fftw_init_threads + + subroutine fftw_cleanup_threads() bind(C, name='fftw_cleanup_threads') + import + end subroutine fftw_cleanup_threads + + subroutine fftw_make_planner_thread_safe() bind(C, name='fftw_make_planner_thread_safe') + import + end subroutine fftw_make_planner_thread_safe + + integer(C_INT) function fftw_export_wisdom_to_filename(filename) bind(C, name='fftw_export_wisdom_to_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftw_export_wisdom_to_filename + + subroutine fftw_export_wisdom_to_file(output_file) bind(C, name='fftw_export_wisdom_to_file') + import + type(C_PTR), value :: output_file + end subroutine fftw_export_wisdom_to_file + + type(C_PTR) function fftw_export_wisdom_to_string() bind(C, name='fftw_export_wisdom_to_string') + import + end function fftw_export_wisdom_to_string + + subroutine fftw_export_wisdom(write_char,data) bind(C, name='fftw_export_wisdom') + import + type(C_FUNPTR), value :: write_char + type(C_PTR), value :: data + end subroutine fftw_export_wisdom + + integer(C_INT) function fftw_import_system_wisdom() bind(C, name='fftw_import_system_wisdom') + import + end function fftw_import_system_wisdom + + integer(C_INT) function fftw_import_wisdom_from_filename(filename) bind(C, name='fftw_import_wisdom_from_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftw_import_wisdom_from_filename + + integer(C_INT) function fftw_import_wisdom_from_file(input_file) bind(C, name='fftw_import_wisdom_from_file') + import + type(C_PTR), value :: input_file + end function fftw_import_wisdom_from_file + + integer(C_INT) function fftw_import_wisdom_from_string(input_string) bind(C, name='fftw_import_wisdom_from_string') + import + character(C_CHAR), dimension(*), intent(in) :: input_string + end function fftw_import_wisdom_from_string + + integer(C_INT) function fftw_import_wisdom(read_char,data) bind(C, name='fftw_import_wisdom') + import + type(C_FUNPTR), value :: read_char + type(C_PTR), value :: data + end function fftw_import_wisdom + + subroutine fftw_fprint_plan(p,output_file) bind(C, name='fftw_fprint_plan') + import + type(C_PTR), value :: p + type(C_PTR), value :: output_file + end subroutine fftw_fprint_plan + + subroutine fftw_print_plan(p) bind(C, name='fftw_print_plan') + import + type(C_PTR), value :: p + end subroutine fftw_print_plan + + type(C_PTR) function fftw_sprint_plan(p) bind(C, name='fftw_sprint_plan') + import + type(C_PTR), value :: p + end function fftw_sprint_plan + + type(C_PTR) function fftw_malloc(n) bind(C, name='fftw_malloc') + import + integer(C_SIZE_T), value :: n + end function fftw_malloc + + type(C_PTR) function fftw_alloc_real(n) bind(C, name='fftw_alloc_real') + import + integer(C_SIZE_T), value :: n + end function fftw_alloc_real + + type(C_PTR) function fftw_alloc_complex(n) bind(C, name='fftw_alloc_complex') + import + integer(C_SIZE_T), value :: n + end function fftw_alloc_complex + + subroutine fftw_free(p) bind(C, name='fftw_free') + import + type(C_PTR), value :: p + end subroutine fftw_free + + subroutine fftw_flops(p,add,mul,fmas) bind(C, name='fftw_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 fftw_flops + + real(C_DOUBLE) function fftw_estimate_cost(p) bind(C, name='fftw_estimate_cost') + import + type(C_PTR), value :: p + end function fftw_estimate_cost + + real(C_DOUBLE) function fftw_cost(p) bind(C, name='fftw_cost') + import + type(C_PTR), value :: p + end function fftw_cost + + integer(C_INT) function fftw_alignment_of(p) bind(C, name='fftw_alignment_of') + import + real(C_DOUBLE), dimension(*), intent(out) :: p + end function fftw_alignment_of + + end interface + + type, bind(C) :: fftwf_iodim + integer(C_INT) n, is, os + end type fftwf_iodim + type, bind(C) :: fftwf_iodim64 + integer(C_INTPTR_T) n, is, os + end type fftwf_iodim64 + + interface + type(C_PTR) function fftwf_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftwf_plan_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft + + type(C_PTR) function fftwf_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftwf_plan_dft_1d') + import + integer(C_INT), value :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft_1d + + type(C_PTR) function fftwf_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftwf_plan_dft_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft_2d + + type(C_PTR) function fftwf_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftwf_plan_dft_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft_3d + + type(C_PTR) function fftwf_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) & + bind(C, name='fftwf_plan_many_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + complex(C_FLOAT_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 fftwf_plan_many_dft + + type(C_PTR) function fftwf_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftwf_plan_guru_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_guru_dft + + type(C_PTR) function fftwf_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftwf_plan_guru_split_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru_split_dft + + type(C_PTR) function fftwf_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftwf_plan_guru64_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_guru64_dft + + type(C_PTR) function fftwf_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftwf_plan_guru64_split_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru64_split_dft + + subroutine fftwf_execute_dft(p,in,out) bind(C, name='fftwf_execute_dft') + import + type(C_PTR), value :: p + complex(C_FLOAT_COMPLEX), dimension(*), intent(inout) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftwf_execute_dft + + subroutine fftwf_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftwf_execute_split_dft') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: ri + real(C_FLOAT), dimension(*), intent(inout) :: ii + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + end subroutine fftwf_execute_split_dft + + type(C_PTR) function fftwf_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftwf_plan_many_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_FLOAT), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + complex(C_FLOAT_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 fftwf_plan_many_dft_r2c + + type(C_PTR) function fftwf_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftwf_plan_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c + + type(C_PTR) function fftwf_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftwf_plan_dft_r2c_1d') + import + integer(C_INT), value :: n + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c_1d + + type(C_PTR) function fftwf_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftwf_plan_dft_r2c_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c_2d + + type(C_PTR) function fftwf_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwf_plan_dft_r2c_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c_3d + + type(C_PTR) function fftwf_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftwf_plan_many_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + real(C_FLOAT), 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 fftwf_plan_many_dft_c2r + + type(C_PTR) function fftwf_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftwf_plan_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r + + type(C_PTR) function fftwf_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftwf_plan_dft_c2r_1d') + import + integer(C_INT), value :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r_1d + + type(C_PTR) function fftwf_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftwf_plan_dft_c2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r_2d + + type(C_PTR) function fftwf_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwf_plan_dft_c2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r_3d + + type(C_PTR) function fftwf_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru_dft_r2c + + type(C_PTR) function fftwf_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru_dft_c2r + + type(C_PTR) function fftwf_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftwf_plan_guru_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru_split_dft_r2c + + type(C_PTR) function fftwf_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftwf_plan_guru_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru_split_dft_c2r + + type(C_PTR) function fftwf_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru64_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru64_dft_r2c + + type(C_PTR) function fftwf_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru64_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru64_dft_c2r + + type(C_PTR) function fftwf_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftwf_plan_guru64_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru64_split_dft_r2c + + type(C_PTR) function fftwf_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftwf_plan_guru64_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru64_split_dft_c2r + + subroutine fftwf_execute_dft_r2c(p,in,out) bind(C, name='fftwf_execute_dft_r2c') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftwf_execute_dft_r2c + + subroutine fftwf_execute_dft_c2r(p,in,out) bind(C, name='fftwf_execute_dft_c2r') + import + type(C_PTR), value :: p + complex(C_FLOAT_COMPLEX), dimension(*), intent(inout) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + end subroutine fftwf_execute_dft_c2r + + subroutine fftwf_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftwf_execute_split_dft_r2c') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: in + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + end subroutine fftwf_execute_split_dft_r2c + + subroutine fftwf_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftwf_execute_split_dft_c2r') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: ri + real(C_FLOAT), dimension(*), intent(inout) :: ii + real(C_FLOAT), dimension(*), intent(out) :: out + end subroutine fftwf_execute_split_dft_c2r + + type(C_PTR) function fftwf_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) & + bind(C, name='fftwf_plan_many_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_FLOAT), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + real(C_FLOAT), 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 fftwf_plan_many_r2r + + type(C_PTR) function fftwf_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftwf_plan_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftwf_plan_r2r + + type(C_PTR) function fftwf_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftwf_plan_r2r_1d') + import + integer(C_INT), value :: n + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), value :: kind + integer(C_INT), value :: flags + end function fftwf_plan_r2r_1d + + type(C_PTR) function fftwf_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftwf_plan_r2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), 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 fftwf_plan_r2r_2d + + type(C_PTR) function fftwf_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftwf_plan_r2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), 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 fftwf_plan_r2r_3d + + type(C_PTR) function fftwf_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftwf_plan_guru_r2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftwf_plan_guru_r2r + + type(C_PTR) function fftwf_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftwf_plan_guru64_r2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftwf_plan_guru64_r2r + + subroutine fftwf_execute_r2r(p,in,out) bind(C, name='fftwf_execute_r2r') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + end subroutine fftwf_execute_r2r + + subroutine fftwf_destroy_plan(p) bind(C, name='fftwf_destroy_plan') + import + type(C_PTR), value :: p + end subroutine fftwf_destroy_plan + + subroutine fftwf_forget_wisdom() bind(C, name='fftwf_forget_wisdom') + import + end subroutine fftwf_forget_wisdom + + subroutine fftwf_cleanup() bind(C, name='fftwf_cleanup') + import + end subroutine fftwf_cleanup + + subroutine fftwf_set_timelimit(t) bind(C, name='fftwf_set_timelimit') + import + real(C_DOUBLE), value :: t + end subroutine fftwf_set_timelimit + + subroutine fftwf_plan_with_nthreads(nthreads) bind(C, name='fftwf_plan_with_nthreads') + import + integer(C_INT), value :: nthreads + end subroutine fftwf_plan_with_nthreads + + integer(C_INT) function fftwf_init_threads() bind(C, name='fftwf_init_threads') + import + end function fftwf_init_threads + + subroutine fftwf_cleanup_threads() bind(C, name='fftwf_cleanup_threads') + import + end subroutine fftwf_cleanup_threads + + subroutine fftwf_make_planner_thread_safe() bind(C, name='fftwf_make_planner_thread_safe') + import + end subroutine fftwf_make_planner_thread_safe + + integer(C_INT) function fftwf_export_wisdom_to_filename(filename) bind(C, name='fftwf_export_wisdom_to_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftwf_export_wisdom_to_filename + + subroutine fftwf_export_wisdom_to_file(output_file) bind(C, name='fftwf_export_wisdom_to_file') + import + type(C_PTR), value :: output_file + end subroutine fftwf_export_wisdom_to_file + + type(C_PTR) function fftwf_export_wisdom_to_string() bind(C, name='fftwf_export_wisdom_to_string') + import + end function fftwf_export_wisdom_to_string + + subroutine fftwf_export_wisdom(write_char,data) bind(C, name='fftwf_export_wisdom') + import + type(C_FUNPTR), value :: write_char + type(C_PTR), value :: data + end subroutine fftwf_export_wisdom + + integer(C_INT) function fftwf_import_system_wisdom() bind(C, name='fftwf_import_system_wisdom') + import + end function fftwf_import_system_wisdom + + integer(C_INT) function fftwf_import_wisdom_from_filename(filename) bind(C, name='fftwf_import_wisdom_from_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftwf_import_wisdom_from_filename + + integer(C_INT) function fftwf_import_wisdom_from_file(input_file) bind(C, name='fftwf_import_wisdom_from_file') + import + type(C_PTR), value :: input_file + end function fftwf_import_wisdom_from_file + + integer(C_INT) function fftwf_import_wisdom_from_string(input_string) bind(C, name='fftwf_import_wisdom_from_string') + import + character(C_CHAR), dimension(*), intent(in) :: input_string + end function fftwf_import_wisdom_from_string + + integer(C_INT) function fftwf_import_wisdom(read_char,data) bind(C, name='fftwf_import_wisdom') + import + type(C_FUNPTR), value :: read_char + type(C_PTR), value :: data + end function fftwf_import_wisdom + + subroutine fftwf_fprint_plan(p,output_file) bind(C, name='fftwf_fprint_plan') + import + type(C_PTR), value :: p + type(C_PTR), value :: output_file + end subroutine fftwf_fprint_plan + + subroutine fftwf_print_plan(p) bind(C, name='fftwf_print_plan') + import + type(C_PTR), value :: p + end subroutine fftwf_print_plan + + type(C_PTR) function fftwf_sprint_plan(p) bind(C, name='fftwf_sprint_plan') + import + type(C_PTR), value :: p + end function fftwf_sprint_plan + + type(C_PTR) function fftwf_malloc(n) bind(C, name='fftwf_malloc') + import + integer(C_SIZE_T), value :: n + end function fftwf_malloc + + type(C_PTR) function fftwf_alloc_real(n) bind(C, name='fftwf_alloc_real') + import + integer(C_SIZE_T), value :: n + end function fftwf_alloc_real + + type(C_PTR) function fftwf_alloc_complex(n) bind(C, name='fftwf_alloc_complex') + import + integer(C_SIZE_T), value :: n + end function fftwf_alloc_complex + + subroutine fftwf_free(p) bind(C, name='fftwf_free') + import + type(C_PTR), value :: p + end subroutine fftwf_free + + subroutine fftwf_flops(p,add,mul,fmas) bind(C, name='fftwf_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 fftwf_flops + + real(C_DOUBLE) function fftwf_estimate_cost(p) bind(C, name='fftwf_estimate_cost') + import + type(C_PTR), value :: p + end function fftwf_estimate_cost + + real(C_DOUBLE) function fftwf_cost(p) bind(C, name='fftwf_cost') + import + type(C_PTR), value :: p + end function fftwf_cost + + integer(C_INT) function fftwf_alignment_of(p) bind(C, name='fftwf_alignment_of') + import + real(C_FLOAT), dimension(*), intent(out) :: p + end function fftwf_alignment_of + + end interface diff --git a/Desktop_Interface/build_win/fftw/x64/fftw3.h b/Desktop_Interface/build_win/fftw/x64/fftw3.h new file mode 100644 index 00000000..39661d22 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/fftw3.h @@ -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 + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* If 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 /* 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 */ diff --git a/Desktop_Interface/build_win/fftw/x64/fftw3l.f03 b/Desktop_Interface/build_win/fftw/x64/fftw3l.f03 new file mode 100644 index 00000000..59e7ed27 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/fftw3l.f03 @@ -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 diff --git a/Desktop_Interface/build_win/fftw/x64/fftw3q.f03 b/Desktop_Interface/build_win/fftw/x64/fftw3q.f03 new file mode 100644 index 00000000..61dacd6c --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/fftw3q.f03 @@ -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 diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3-3.def b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.def new file mode 100644 index 00000000..4b50ecd4 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.def @@ -0,0 +1,1017 @@ +LIBRARY libfftw3-3.dll +EXPORTS +dfftw_cleanup_ +dfftw_cleanup__ +dfftw_cleanup_threads_ +dfftw_cleanup_threads__ +dfftw_cost_ +dfftw_cost__ +dfftw_destroy_plan_ +dfftw_destroy_plan__ +dfftw_estimate_cost_ +dfftw_estimate_cost__ +dfftw_execute_ +dfftw_execute__ +dfftw_execute_dft_ +dfftw_execute_dft__ +dfftw_execute_dft_c2r_ +dfftw_execute_dft_c2r__ +dfftw_execute_dft_r2c_ +dfftw_execute_dft_r2c__ +dfftw_execute_r2r_ +dfftw_execute_r2r__ +dfftw_execute_split_dft_ +dfftw_execute_split_dft__ +dfftw_execute_split_dft_c2r_ +dfftw_execute_split_dft_c2r__ +dfftw_execute_split_dft_r2c_ +dfftw_execute_split_dft_r2c__ +dfftw_export_wisdom_ +dfftw_export_wisdom__ +dfftw_flops_ +dfftw_flops__ +dfftw_forget_wisdom_ +dfftw_forget_wisdom__ +dfftw_import_system_wisdom_ +dfftw_import_system_wisdom__ +dfftw_import_wisdom_ +dfftw_import_wisdom__ +dfftw_init_threads_ +dfftw_init_threads__ +dfftw_plan_dft_ +dfftw_plan_dft__ +dfftw_plan_dft_1d_ +dfftw_plan_dft_1d__ +dfftw_plan_dft_2d_ +dfftw_plan_dft_2d__ +dfftw_plan_dft_3d_ +dfftw_plan_dft_3d__ +dfftw_plan_dft_c2r_ +dfftw_plan_dft_c2r__ +dfftw_plan_dft_c2r_1d_ +dfftw_plan_dft_c2r_1d__ +dfftw_plan_dft_c2r_2d_ +dfftw_plan_dft_c2r_2d__ +dfftw_plan_dft_c2r_3d_ +dfftw_plan_dft_c2r_3d__ +dfftw_plan_dft_r2c_ +dfftw_plan_dft_r2c__ +dfftw_plan_dft_r2c_1d_ +dfftw_plan_dft_r2c_1d__ +dfftw_plan_dft_r2c_2d_ +dfftw_plan_dft_r2c_2d__ +dfftw_plan_dft_r2c_3d_ +dfftw_plan_dft_r2c_3d__ +dfftw_plan_guru_dft_ +dfftw_plan_guru_dft__ +dfftw_plan_guru_dft_c2r_ +dfftw_plan_guru_dft_c2r__ +dfftw_plan_guru_dft_r2c_ +dfftw_plan_guru_dft_r2c__ +dfftw_plan_guru_r2r_ +dfftw_plan_guru_r2r__ +dfftw_plan_guru_split_dft_ +dfftw_plan_guru_split_dft__ +dfftw_plan_guru_split_dft_c2r_ +dfftw_plan_guru_split_dft_c2r__ +dfftw_plan_guru_split_dft_r2c_ +dfftw_plan_guru_split_dft_r2c__ +dfftw_plan_many_dft_ +dfftw_plan_many_dft__ +dfftw_plan_many_dft_c2r_ +dfftw_plan_many_dft_c2r__ +dfftw_plan_many_dft_r2c_ +dfftw_plan_many_dft_r2c__ +dfftw_plan_many_r2r_ +dfftw_plan_many_r2r__ +dfftw_plan_r2r_ +dfftw_plan_r2r__ +dfftw_plan_r2r_1d_ +dfftw_plan_r2r_1d__ +dfftw_plan_r2r_2d_ +dfftw_plan_r2r_2d__ +dfftw_plan_r2r_3d_ +dfftw_plan_r2r_3d__ +dfftw_plan_with_nthreads_ +dfftw_plan_with_nthreads__ +dfftw_print_plan_ +dfftw_print_plan__ +dfftw_set_timelimit_ +dfftw_set_timelimit__ +fftw_alignment_of +fftw_alloc_complex +fftw_alloc_real +fftw_assertion_failed +fftw_bufdist +fftw_check_alignment_of_sse2_pm +fftw_choose_radix +fftw_cleanup +fftw_cleanup_threads +fftw_codelet_e01_8 +fftw_codelet_e10_8 +fftw_codelet_hb_10 +fftw_codelet_hb_12 +fftw_codelet_hb_15 +fftw_codelet_hb_16 +fftw_codelet_hb_2 +fftw_codelet_hb_20 +fftw_codelet_hb2_16 +fftw_codelet_hb2_20 +fftw_codelet_hb2_25 +fftw_codelet_hb2_32 +fftw_codelet_hb2_4 +fftw_codelet_hb_25 +fftw_codelet_hb2_5 +fftw_codelet_hb2_8 +fftw_codelet_hb_3 +fftw_codelet_hb_32 +fftw_codelet_hb_4 +fftw_codelet_hb_5 +fftw_codelet_hb_6 +fftw_codelet_hb_64 +fftw_codelet_hb_7 +fftw_codelet_hb_8 +fftw_codelet_hb_9 +fftw_codelet_hc2cb_10 +fftw_codelet_hc2cb_12 +fftw_codelet_hc2cb_16 +fftw_codelet_hc2cb_2 +fftw_codelet_hc2cb_20 +fftw_codelet_hc2cb2_16 +fftw_codelet_hc2cb2_20 +fftw_codelet_hc2cb2_32 +fftw_codelet_hc2cb2_4 +fftw_codelet_hc2cb2_8 +fftw_codelet_hc2cb_32 +fftw_codelet_hc2cb_4 +fftw_codelet_hc2cb_6 +fftw_codelet_hc2cb_8 +fftw_codelet_hc2cbdft_10 +fftw_codelet_hc2cbdft_12 +fftw_codelet_hc2cbdft_16 +fftw_codelet_hc2cbdft_2 +fftw_codelet_hc2cbdft_20 +fftw_codelet_hc2cbdft2_16 +fftw_codelet_hc2cbdft2_20 +fftw_codelet_hc2cbdft2_32 +fftw_codelet_hc2cbdft2_4 +fftw_codelet_hc2cbdft2_8 +fftw_codelet_hc2cbdft_32 +fftw_codelet_hc2cbdft_4 +fftw_codelet_hc2cbdft_6 +fftw_codelet_hc2cbdft_8 +fftw_codelet_hc2cbdftv_10_avx +fftw_codelet_hc2cbdftv_10_sse2 +fftw_codelet_hc2cbdftv_12_avx +fftw_codelet_hc2cbdftv_12_sse2 +fftw_codelet_hc2cbdftv_16_avx +fftw_codelet_hc2cbdftv_16_sse2 +fftw_codelet_hc2cbdftv_20_avx +fftw_codelet_hc2cbdftv_20_sse2 +fftw_codelet_hc2cbdftv_2_avx +fftw_codelet_hc2cbdftv_2_sse2 +fftw_codelet_hc2cbdftv_32_avx +fftw_codelet_hc2cbdftv_32_sse2 +fftw_codelet_hc2cbdftv_4_avx +fftw_codelet_hc2cbdftv_4_sse2 +fftw_codelet_hc2cbdftv_6_avx +fftw_codelet_hc2cbdftv_6_sse2 +fftw_codelet_hc2cbdftv_8_avx +fftw_codelet_hc2cbdftv_8_sse2 +fftw_codelet_hc2cf_10 +fftw_codelet_hc2cf_12 +fftw_codelet_hc2cf_16 +fftw_codelet_hc2cf_2 +fftw_codelet_hc2cf_20 +fftw_codelet_hc2cf2_16 +fftw_codelet_hc2cf2_20 +fftw_codelet_hc2cf2_32 +fftw_codelet_hc2cf2_4 +fftw_codelet_hc2cf2_8 +fftw_codelet_hc2cf_32 +fftw_codelet_hc2cf_4 +fftw_codelet_hc2cf_6 +fftw_codelet_hc2cf_8 +fftw_codelet_hc2cfdft_10 +fftw_codelet_hc2cfdft_12 +fftw_codelet_hc2cfdft_16 +fftw_codelet_hc2cfdft_2 +fftw_codelet_hc2cfdft_20 +fftw_codelet_hc2cfdft2_16 +fftw_codelet_hc2cfdft2_20 +fftw_codelet_hc2cfdft2_32 +fftw_codelet_hc2cfdft2_4 +fftw_codelet_hc2cfdft2_8 +fftw_codelet_hc2cfdft_32 +fftw_codelet_hc2cfdft_4 +fftw_codelet_hc2cfdft_6 +fftw_codelet_hc2cfdft_8 +fftw_codelet_hc2cfdftv_10_avx +fftw_codelet_hc2cfdftv_10_sse2 +fftw_codelet_hc2cfdftv_12_avx +fftw_codelet_hc2cfdftv_12_sse2 +fftw_codelet_hc2cfdftv_16_avx +fftw_codelet_hc2cfdftv_16_sse2 +fftw_codelet_hc2cfdftv_20_avx +fftw_codelet_hc2cfdftv_20_sse2 +fftw_codelet_hc2cfdftv_2_avx +fftw_codelet_hc2cfdftv_2_sse2 +fftw_codelet_hc2cfdftv_32_avx +fftw_codelet_hc2cfdftv_32_sse2 +fftw_codelet_hc2cfdftv_4_avx +fftw_codelet_hc2cfdftv_4_sse2 +fftw_codelet_hc2cfdftv_6_avx +fftw_codelet_hc2cfdftv_6_sse2 +fftw_codelet_hc2cfdftv_8_avx +fftw_codelet_hc2cfdftv_8_sse2 +fftw_codelet_hf_10 +fftw_codelet_hf_12 +fftw_codelet_hf_15 +fftw_codelet_hf_16 +fftw_codelet_hf_2 +fftw_codelet_hf_20 +fftw_codelet_hf2_16 +fftw_codelet_hf2_20 +fftw_codelet_hf2_25 +fftw_codelet_hf2_32 +fftw_codelet_hf2_4 +fftw_codelet_hf_25 +fftw_codelet_hf2_5 +fftw_codelet_hf2_8 +fftw_codelet_hf_3 +fftw_codelet_hf_32 +fftw_codelet_hf_4 +fftw_codelet_hf_5 +fftw_codelet_hf_6 +fftw_codelet_hf_64 +fftw_codelet_hf_7 +fftw_codelet_hf_8 +fftw_codelet_hf_9 +fftw_codelet_n1_10 +fftw_codelet_n1_11 +fftw_codelet_n1_12 +fftw_codelet_n1_13 +fftw_codelet_n1_14 +fftw_codelet_n1_15 +fftw_codelet_n1_16 +fftw_codelet_n1_2 +fftw_codelet_n1_20 +fftw_codelet_n1_25 +fftw_codelet_n1_3 +fftw_codelet_n1_32 +fftw_codelet_n1_4 +fftw_codelet_n1_5 +fftw_codelet_n1_6 +fftw_codelet_n1_64 +fftw_codelet_n1_7 +fftw_codelet_n1_8 +fftw_codelet_n1_9 +fftw_codelet_n1bv_10_avx +fftw_codelet_n1bv_10_sse2 +fftw_codelet_n1bv_11_avx +fftw_codelet_n1bv_11_sse2 +fftw_codelet_n1bv_128_avx +fftw_codelet_n1bv_128_sse2 +fftw_codelet_n1bv_12_avx +fftw_codelet_n1bv_12_sse2 +fftw_codelet_n1bv_13_avx +fftw_codelet_n1bv_13_sse2 +fftw_codelet_n1bv_14_avx +fftw_codelet_n1bv_14_sse2 +fftw_codelet_n1bv_15_avx +fftw_codelet_n1bv_15_sse2 +fftw_codelet_n1bv_16_avx +fftw_codelet_n1bv_16_sse2 +fftw_codelet_n1bv_20_avx +fftw_codelet_n1bv_20_sse2 +fftw_codelet_n1bv_25_avx +fftw_codelet_n1bv_25_sse2 +fftw_codelet_n1bv_2_avx +fftw_codelet_n1bv_2_sse2 +fftw_codelet_n1bv_32_avx +fftw_codelet_n1bv_32_sse2 +fftw_codelet_n1bv_3_avx +fftw_codelet_n1bv_3_sse2 +fftw_codelet_n1bv_4_avx +fftw_codelet_n1bv_4_sse2 +fftw_codelet_n1bv_5_avx +fftw_codelet_n1bv_5_sse2 +fftw_codelet_n1bv_64_avx +fftw_codelet_n1bv_64_sse2 +fftw_codelet_n1bv_6_avx +fftw_codelet_n1bv_6_sse2 +fftw_codelet_n1bv_7_avx +fftw_codelet_n1bv_7_sse2 +fftw_codelet_n1bv_8_avx +fftw_codelet_n1bv_8_sse2 +fftw_codelet_n1bv_9_avx +fftw_codelet_n1bv_9_sse2 +fftw_codelet_n1fv_10_avx +fftw_codelet_n1fv_10_sse2 +fftw_codelet_n1fv_11_avx +fftw_codelet_n1fv_11_sse2 +fftw_codelet_n1fv_128_avx +fftw_codelet_n1fv_128_sse2 +fftw_codelet_n1fv_12_avx +fftw_codelet_n1fv_12_sse2 +fftw_codelet_n1fv_13_avx +fftw_codelet_n1fv_13_sse2 +fftw_codelet_n1fv_14_avx +fftw_codelet_n1fv_14_sse2 +fftw_codelet_n1fv_15_avx +fftw_codelet_n1fv_15_sse2 +fftw_codelet_n1fv_16_avx +fftw_codelet_n1fv_16_sse2 +fftw_codelet_n1fv_20_avx +fftw_codelet_n1fv_20_sse2 +fftw_codelet_n1fv_25_avx +fftw_codelet_n1fv_25_sse2 +fftw_codelet_n1fv_2_avx +fftw_codelet_n1fv_2_sse2 +fftw_codelet_n1fv_32_avx +fftw_codelet_n1fv_32_sse2 +fftw_codelet_n1fv_3_avx +fftw_codelet_n1fv_3_sse2 +fftw_codelet_n1fv_4_avx +fftw_codelet_n1fv_4_sse2 +fftw_codelet_n1fv_5_avx +fftw_codelet_n1fv_5_sse2 +fftw_codelet_n1fv_64_avx +fftw_codelet_n1fv_64_sse2 +fftw_codelet_n1fv_6_avx +fftw_codelet_n1fv_6_sse2 +fftw_codelet_n1fv_7_avx +fftw_codelet_n1fv_7_sse2 +fftw_codelet_n1fv_8_avx +fftw_codelet_n1fv_8_sse2 +fftw_codelet_n1fv_9_avx +fftw_codelet_n1fv_9_sse2 +fftw_codelet_n2bv_10_avx +fftw_codelet_n2bv_10_sse2 +fftw_codelet_n2bv_12_avx +fftw_codelet_n2bv_12_sse2 +fftw_codelet_n2bv_14_avx +fftw_codelet_n2bv_14_sse2 +fftw_codelet_n2bv_16_avx +fftw_codelet_n2bv_16_sse2 +fftw_codelet_n2bv_20_avx +fftw_codelet_n2bv_20_sse2 +fftw_codelet_n2bv_2_avx +fftw_codelet_n2bv_2_sse2 +fftw_codelet_n2bv_32_avx +fftw_codelet_n2bv_32_sse2 +fftw_codelet_n2bv_4_avx +fftw_codelet_n2bv_4_sse2 +fftw_codelet_n2bv_64_avx +fftw_codelet_n2bv_64_sse2 +fftw_codelet_n2bv_6_avx +fftw_codelet_n2bv_6_sse2 +fftw_codelet_n2bv_8_avx +fftw_codelet_n2bv_8_sse2 +fftw_codelet_n2fv_10_avx +fftw_codelet_n2fv_10_sse2 +fftw_codelet_n2fv_12_avx +fftw_codelet_n2fv_12_sse2 +fftw_codelet_n2fv_14_avx +fftw_codelet_n2fv_14_sse2 +fftw_codelet_n2fv_16_avx +fftw_codelet_n2fv_16_sse2 +fftw_codelet_n2fv_20_avx +fftw_codelet_n2fv_20_sse2 +fftw_codelet_n2fv_2_avx +fftw_codelet_n2fv_2_sse2 +fftw_codelet_n2fv_32_avx +fftw_codelet_n2fv_32_sse2 +fftw_codelet_n2fv_4_avx +fftw_codelet_n2fv_4_sse2 +fftw_codelet_n2fv_64_avx +fftw_codelet_n2fv_64_sse2 +fftw_codelet_n2fv_6_avx +fftw_codelet_n2fv_6_sse2 +fftw_codelet_n2fv_8_avx +fftw_codelet_n2fv_8_sse2 +fftw_codelet_n2sv_16_avx +fftw_codelet_n2sv_16_sse2 +fftw_codelet_n2sv_32_avx +fftw_codelet_n2sv_32_sse2 +fftw_codelet_n2sv_4_avx +fftw_codelet_n2sv_4_sse2 +fftw_codelet_n2sv_64_avx +fftw_codelet_n2sv_64_sse2 +fftw_codelet_n2sv_8_avx +fftw_codelet_n2sv_8_sse2 +fftw_codelet_q1_2 +fftw_codelet_q1_3 +fftw_codelet_q1_4 +fftw_codelet_q1_5 +fftw_codelet_q1_6 +fftw_codelet_q1_8 +fftw_codelet_q1bv_2_avx +fftw_codelet_q1bv_2_sse2 +fftw_codelet_q1bv_4_avx +fftw_codelet_q1bv_4_sse2 +fftw_codelet_q1bv_5_avx +fftw_codelet_q1bv_5_sse2 +fftw_codelet_q1bv_8_avx +fftw_codelet_q1bv_8_sse2 +fftw_codelet_q1fv_2_avx +fftw_codelet_q1fv_2_sse2 +fftw_codelet_q1fv_4_avx +fftw_codelet_q1fv_4_sse2 +fftw_codelet_q1fv_5_avx +fftw_codelet_q1fv_5_sse2 +fftw_codelet_q1fv_8_avx +fftw_codelet_q1fv_8_sse2 +fftw_codelet_r2cb_10 +fftw_codelet_r2cb_11 +fftw_codelet_r2cb_12 +fftw_codelet_r2cb_128 +fftw_codelet_r2cb_13 +fftw_codelet_r2cb_14 +fftw_codelet_r2cb_15 +fftw_codelet_r2cb_16 +fftw_codelet_r2cb_2 +fftw_codelet_r2cb_20 +fftw_codelet_r2cb_25 +fftw_codelet_r2cb_3 +fftw_codelet_r2cb_32 +fftw_codelet_r2cb_4 +fftw_codelet_r2cb_5 +fftw_codelet_r2cb_6 +fftw_codelet_r2cb_64 +fftw_codelet_r2cb_7 +fftw_codelet_r2cb_8 +fftw_codelet_r2cb_9 +fftw_codelet_r2cbIII_10 +fftw_codelet_r2cbIII_12 +fftw_codelet_r2cbIII_15 +fftw_codelet_r2cbIII_16 +fftw_codelet_r2cbIII_2 +fftw_codelet_r2cbIII_20 +fftw_codelet_r2cbIII_25 +fftw_codelet_r2cbIII_3 +fftw_codelet_r2cbIII_32 +fftw_codelet_r2cbIII_4 +fftw_codelet_r2cbIII_5 +fftw_codelet_r2cbIII_6 +fftw_codelet_r2cbIII_64 +fftw_codelet_r2cbIII_7 +fftw_codelet_r2cbIII_8 +fftw_codelet_r2cbIII_9 +fftw_codelet_r2cf_10 +fftw_codelet_r2cf_11 +fftw_codelet_r2cf_12 +fftw_codelet_r2cf_128 +fftw_codelet_r2cf_13 +fftw_codelet_r2cf_14 +fftw_codelet_r2cf_15 +fftw_codelet_r2cf_16 +fftw_codelet_r2cf_2 +fftw_codelet_r2cf_20 +fftw_codelet_r2cf_25 +fftw_codelet_r2cf_3 +fftw_codelet_r2cf_32 +fftw_codelet_r2cf_4 +fftw_codelet_r2cf_5 +fftw_codelet_r2cf_6 +fftw_codelet_r2cf_64 +fftw_codelet_r2cf_7 +fftw_codelet_r2cf_8 +fftw_codelet_r2cf_9 +fftw_codelet_r2cfII_10 +fftw_codelet_r2cfII_12 +fftw_codelet_r2cfII_15 +fftw_codelet_r2cfII_16 +fftw_codelet_r2cfII_2 +fftw_codelet_r2cfII_20 +fftw_codelet_r2cfII_25 +fftw_codelet_r2cfII_3 +fftw_codelet_r2cfII_32 +fftw_codelet_r2cfII_4 +fftw_codelet_r2cfII_5 +fftw_codelet_r2cfII_6 +fftw_codelet_r2cfII_64 +fftw_codelet_r2cfII_7 +fftw_codelet_r2cfII_8 +fftw_codelet_r2cfII_9 +fftw_codelet_t1_10 +fftw_codelet_t1_12 +fftw_codelet_t1_15 +fftw_codelet_t1_16 +fftw_codelet_t1_2 +fftw_codelet_t1_20 +fftw_codelet_t1_25 +fftw_codelet_t1_3 +fftw_codelet_t1_32 +fftw_codelet_t1_4 +fftw_codelet_t1_5 +fftw_codelet_t1_6 +fftw_codelet_t1_64 +fftw_codelet_t1_7 +fftw_codelet_t1_8 +fftw_codelet_t1_9 +fftw_codelet_t1buv_10_avx +fftw_codelet_t1buv_10_sse2 +fftw_codelet_t1buv_2_avx +fftw_codelet_t1buv_2_sse2 +fftw_codelet_t1buv_3_avx +fftw_codelet_t1buv_3_sse2 +fftw_codelet_t1buv_4_avx +fftw_codelet_t1buv_4_sse2 +fftw_codelet_t1buv_5_avx +fftw_codelet_t1buv_5_sse2 +fftw_codelet_t1buv_6_avx +fftw_codelet_t1buv_6_sse2 +fftw_codelet_t1buv_7_avx +fftw_codelet_t1buv_7_sse2 +fftw_codelet_t1buv_8_avx +fftw_codelet_t1buv_8_sse2 +fftw_codelet_t1buv_9_avx +fftw_codelet_t1buv_9_sse2 +fftw_codelet_t1bv_10_avx +fftw_codelet_t1bv_10_sse2 +fftw_codelet_t1bv_12_avx +fftw_codelet_t1bv_12_sse2 +fftw_codelet_t1bv_15_avx +fftw_codelet_t1bv_15_sse2 +fftw_codelet_t1bv_16_avx +fftw_codelet_t1bv_16_sse2 +fftw_codelet_t1bv_20_avx +fftw_codelet_t1bv_20_sse2 +fftw_codelet_t1bv_25_avx +fftw_codelet_t1bv_25_sse2 +fftw_codelet_t1bv_2_avx +fftw_codelet_t1bv_2_sse2 +fftw_codelet_t1bv_32_avx +fftw_codelet_t1bv_32_sse2 +fftw_codelet_t1bv_3_avx +fftw_codelet_t1bv_3_sse2 +fftw_codelet_t1bv_4_avx +fftw_codelet_t1bv_4_sse2 +fftw_codelet_t1bv_5_avx +fftw_codelet_t1bv_5_sse2 +fftw_codelet_t1bv_64_avx +fftw_codelet_t1bv_64_sse2 +fftw_codelet_t1bv_6_avx +fftw_codelet_t1bv_6_sse2 +fftw_codelet_t1bv_7_avx +fftw_codelet_t1bv_7_sse2 +fftw_codelet_t1bv_8_avx +fftw_codelet_t1bv_8_sse2 +fftw_codelet_t1bv_9_avx +fftw_codelet_t1bv_9_sse2 +fftw_codelet_t1fuv_10_avx +fftw_codelet_t1fuv_10_sse2 +fftw_codelet_t1fuv_2_avx +fftw_codelet_t1fuv_2_sse2 +fftw_codelet_t1fuv_3_avx +fftw_codelet_t1fuv_3_sse2 +fftw_codelet_t1fuv_4_avx +fftw_codelet_t1fuv_4_sse2 +fftw_codelet_t1fuv_5_avx +fftw_codelet_t1fuv_5_sse2 +fftw_codelet_t1fuv_6_avx +fftw_codelet_t1fuv_6_sse2 +fftw_codelet_t1fuv_7_avx +fftw_codelet_t1fuv_7_sse2 +fftw_codelet_t1fuv_8_avx +fftw_codelet_t1fuv_8_sse2 +fftw_codelet_t1fuv_9_avx +fftw_codelet_t1fuv_9_sse2 +fftw_codelet_t1fv_10_avx +fftw_codelet_t1fv_10_sse2 +fftw_codelet_t1fv_12_avx +fftw_codelet_t1fv_12_sse2 +fftw_codelet_t1fv_15_avx +fftw_codelet_t1fv_15_sse2 +fftw_codelet_t1fv_16_avx +fftw_codelet_t1fv_16_sse2 +fftw_codelet_t1fv_20_avx +fftw_codelet_t1fv_20_sse2 +fftw_codelet_t1fv_25_avx +fftw_codelet_t1fv_25_sse2 +fftw_codelet_t1fv_2_avx +fftw_codelet_t1fv_2_sse2 +fftw_codelet_t1fv_32_avx +fftw_codelet_t1fv_32_sse2 +fftw_codelet_t1fv_3_avx +fftw_codelet_t1fv_3_sse2 +fftw_codelet_t1fv_4_avx +fftw_codelet_t1fv_4_sse2 +fftw_codelet_t1fv_5_avx +fftw_codelet_t1fv_5_sse2 +fftw_codelet_t1fv_64_avx +fftw_codelet_t1fv_64_sse2 +fftw_codelet_t1fv_6_avx +fftw_codelet_t1fv_6_sse2 +fftw_codelet_t1fv_7_avx +fftw_codelet_t1fv_7_sse2 +fftw_codelet_t1fv_8_avx +fftw_codelet_t1fv_8_sse2 +fftw_codelet_t1fv_9_avx +fftw_codelet_t1fv_9_sse2 +fftw_codelet_t1sv_16_avx +fftw_codelet_t1sv_16_sse2 +fftw_codelet_t1sv_2_avx +fftw_codelet_t1sv_2_sse2 +fftw_codelet_t1sv_32_avx +fftw_codelet_t1sv_32_sse2 +fftw_codelet_t1sv_4_avx +fftw_codelet_t1sv_4_sse2 +fftw_codelet_t1sv_8_avx +fftw_codelet_t1sv_8_sse2 +fftw_codelet_t2_10 +fftw_codelet_t2_16 +fftw_codelet_t2_20 +fftw_codelet_t2_25 +fftw_codelet_t2_32 +fftw_codelet_t2_4 +fftw_codelet_t2_5 +fftw_codelet_t2_64 +fftw_codelet_t2_8 +fftw_codelet_t2bv_10_avx +fftw_codelet_t2bv_10_sse2 +fftw_codelet_t2bv_16_avx +fftw_codelet_t2bv_16_sse2 +fftw_codelet_t2bv_20_avx +fftw_codelet_t2bv_20_sse2 +fftw_codelet_t2bv_25_avx +fftw_codelet_t2bv_25_sse2 +fftw_codelet_t2bv_2_avx +fftw_codelet_t2bv_2_sse2 +fftw_codelet_t2bv_32_avx +fftw_codelet_t2bv_32_sse2 +fftw_codelet_t2bv_4_avx +fftw_codelet_t2bv_4_sse2 +fftw_codelet_t2bv_5_avx +fftw_codelet_t2bv_5_sse2 +fftw_codelet_t2bv_64_avx +fftw_codelet_t2bv_64_sse2 +fftw_codelet_t2bv_8_avx +fftw_codelet_t2bv_8_sse2 +fftw_codelet_t2fv_10_avx +fftw_codelet_t2fv_10_sse2 +fftw_codelet_t2fv_16_avx +fftw_codelet_t2fv_16_sse2 +fftw_codelet_t2fv_20_avx +fftw_codelet_t2fv_20_sse2 +fftw_codelet_t2fv_25_avx +fftw_codelet_t2fv_25_sse2 +fftw_codelet_t2fv_2_avx +fftw_codelet_t2fv_2_sse2 +fftw_codelet_t2fv_32_avx +fftw_codelet_t2fv_32_sse2 +fftw_codelet_t2fv_4_avx +fftw_codelet_t2fv_4_sse2 +fftw_codelet_t2fv_5_avx +fftw_codelet_t2fv_5_sse2 +fftw_codelet_t2fv_64_avx +fftw_codelet_t2fv_64_sse2 +fftw_codelet_t2fv_8_avx +fftw_codelet_t2fv_8_sse2 +fftw_codelet_t2sv_16_avx +fftw_codelet_t2sv_16_sse2 +fftw_codelet_t2sv_32_avx +fftw_codelet_t2sv_32_sse2 +fftw_codelet_t2sv_4_avx +fftw_codelet_t2sv_4_sse2 +fftw_codelet_t2sv_8_avx +fftw_codelet_t2sv_8_sse2 +fftw_codelet_t3bv_10_avx +fftw_codelet_t3bv_10_sse2 +fftw_codelet_t3bv_16_avx +fftw_codelet_t3bv_16_sse2 +fftw_codelet_t3bv_20_avx +fftw_codelet_t3bv_20_sse2 +fftw_codelet_t3bv_25_avx +fftw_codelet_t3bv_25_sse2 +fftw_codelet_t3bv_32_avx +fftw_codelet_t3bv_32_sse2 +fftw_codelet_t3bv_4_avx +fftw_codelet_t3bv_4_sse2 +fftw_codelet_t3bv_5_avx +fftw_codelet_t3bv_5_sse2 +fftw_codelet_t3bv_8_avx +fftw_codelet_t3bv_8_sse2 +fftw_codelet_t3fv_10_avx +fftw_codelet_t3fv_10_sse2 +fftw_codelet_t3fv_16_avx +fftw_codelet_t3fv_16_sse2 +fftw_codelet_t3fv_20_avx +fftw_codelet_t3fv_20_sse2 +fftw_codelet_t3fv_25_avx +fftw_codelet_t3fv_25_sse2 +fftw_codelet_t3fv_32_avx +fftw_codelet_t3fv_32_sse2 +fftw_codelet_t3fv_4_avx +fftw_codelet_t3fv_4_sse2 +fftw_codelet_t3fv_5_avx +fftw_codelet_t3fv_5_sse2 +fftw_codelet_t3fv_8_avx +fftw_codelet_t3fv_8_sse2 +fftw_compute_tilesz +fftw_configure_planner +fftw_cost +fftw_cpy1d +fftw_cpy2d +fftw_cpy2d_ci +fftw_cpy2d_co +fftw_cpy2d_pair +fftw_cpy2d_pair_ci +fftw_cpy2d_pair_co +fftw_cpy2d_tiled +fftw_cpy2d_tiledbuf +fftw_ct_applicable +fftw_ct_genericbuf_register +fftw_ct_generic_register +fftw_ct_uglyp +fftw_destroy_plan +fftw_dft_bluestein_register +fftw_dft_buffered_register +fftw_dft_conf_standard +fftw_dft_generic_register +fftw_dft_indirect_register +fftw_dft_indirect_transpose_register +fftw_dft_nop_register +fftw_dft_r2hc_register +fftw_dft_rader_register +fftw_dft_rank_geq2_register +fftw_dft_solve +fftw_dft_thr_vrank_geq1_register +fftw_dft_vrank_geq1_register +fftw_dft_zerotens +fftw_dht_r2hc_register +fftw_dht_rader_register +fftw_dimcmp +fftw_elapsed_since +fftw_estimate_cost +fftw_execute +fftw_execute_dft +fftw_execute_dft_c2r +fftw_execute_dft_r2c +fftw_execute_r2r +fftw_execute_split_dft +fftw_execute_split_dft_c2r +fftw_execute_split_dft_r2c +fftw_export_wisdom +fftw_export_wisdom_to_file +fftw_export_wisdom_to_filename +fftw_export_wisdom_to_string +fftw_extract_reim +fftw_factors_into +fftw_factors_into_small_primes +fftw_find_generator +fftw_first_divisor +fftw_flops +fftw_forget_wisdom +fftw_fprint_plan +fftw_free +fftw_get_crude_time +fftw_guru64_kosherp +fftw_guru_kosherp +fftw_hash +fftw_have_simd_avx +fftw_have_simd_sse2 +fftw_hc2hc_applicable +fftw_hc2hc_generic_register +fftw_iabs +fftw_ialignment_of +fftw_iestimate_cost +fftw_ifree +fftw_ifree0 +fftw_imax +fftw_imin +fftw_import_system_wisdom +fftw_import_wisdom +fftw_import_wisdom_from_file +fftw_import_wisdom_from_filename +fftw_import_wisdom_from_string +fftw_init_threads +fftw_is_prime +fftw_isqrt +fftw_ithreads_init +fftw_join_taint +fftw_kdft_dif_register +fftw_kdft_difsq_register +fftw_kdft_dit_register +fftw_kdft_register +fftw_kernel_free +fftw_kernel_malloc +fftw_khc2c_register +fftw_khc2hc_register +fftw_kr2c_register +fftw_kr2r_register +fftw_make_planner_thread_safe +fftw_malloc +fftw_malloc_plain +fftw_many_kosherp +fftw_mapflags +fftw_map_r2r_kind +fftw_md5begin +fftw_md5end +fftw_md5int +fftw_md5INT +fftw_md5putb +fftw_md5putc +fftw_md5puts +fftw_md5unsigned +fftw_measure_execution_time +fftw_mkapiplan +fftw_mkplan +fftw_mkplan_d +fftw_mkplan_dft +fftw_mkplan_dftw +fftw_mkplan_f_d +fftw_mkplan_hc2c +fftw_mkplan_hc2hc +fftw_mkplanner +fftw_mkplan_rdft +fftw_mkplan_rdft2 +fftw_mkprinter +fftw_mkprinter_cnt +fftw_mkprinter_file +fftw_mkprinter_str +fftw_mkproblem +fftw_mkproblem_dft +fftw_mkproblem_dft_d +fftw_mkproblem_rdft +fftw_mkproblem_rdft_0_d +fftw_mkproblem_rdft_1 +fftw_mkproblem_rdft_1_d +fftw_mkproblem_rdft2 +fftw_mkproblem_rdft2_d +fftw_mkproblem_rdft2_d_3pointers +fftw_mkproblem_rdft_d +fftw_mkproblem_unsolvable +fftw_mkscanner +fftw_mksolver +fftw_mksolver_ct +fftw_mksolver_ct_threads +fftw_mksolver_dft_direct +fftw_mksolver_dft_directbuf +fftw_mksolver_hc2c +fftw_mksolver_hc2hc +fftw_mksolver_hc2hc_threads +fftw_mksolver_rdft2_direct +fftw_mksolver_rdft_r2c_direct +fftw_mksolver_rdft_r2c_directbuf +fftw_mksolver_rdft_r2r_direct +fftw_mkstride +fftw_mktensor +fftw_mktensor_0d +fftw_mktensor_1d +fftw_mktensor_2d +fftw_mktensor_3d +fftw_mktensor_4d +fftw_mktensor_5d +fftw_mktensor_iodims +fftw_mktensor_iodims64 +fftw_mktensor_rowmajor +fftw_mktriggen +fftw_modulo +fftw_nbuf +fftw_nbuf_redundant +fftw_next_prime +fftw_null_awake +fftw_ops_add +fftw_ops_add2 +fftw_ops_cpy +fftw_ops_madd +fftw_ops_madd2 +fftw_ops_other +fftw_ops_zero +fftw_pickdim +fftw_plan_awake +fftw_plan_destroy_internal +fftw_plan_dft +fftw_plan_dft_1d +fftw_plan_dft_2d +fftw_plan_dft_3d +fftw_plan_dft_c2r +fftw_plan_dft_c2r_1d +fftw_plan_dft_c2r_2d +fftw_plan_dft_c2r_3d +fftw_plan_dft_r2c +fftw_plan_dft_r2c_1d +fftw_plan_dft_r2c_2d +fftw_plan_dft_r2c_3d +fftw_plan_guru64_dft +fftw_plan_guru64_dft_c2r +fftw_plan_guru64_dft_r2c +fftw_plan_guru64_r2r +fftw_plan_guru64_split_dft +fftw_plan_guru64_split_dft_c2r +fftw_plan_guru64_split_dft_r2c +fftw_plan_guru_dft +fftw_plan_guru_dft_c2r +fftw_plan_guru_dft_r2c +fftw_plan_guru_r2r +fftw_plan_guru_split_dft +fftw_plan_guru_split_dft_c2r +fftw_plan_guru_split_dft_r2c +fftw_plan_many_dft +fftw_plan_many_dft_c2r +fftw_plan_many_dft_r2c +fftw_plan_many_r2r +fftw_planner_destroy +fftw_plan_null_destroy +fftw_plan_r2r +fftw_plan_r2r_1d +fftw_plan_r2r_2d +fftw_plan_r2r_3d +fftw_plan_with_nthreads +fftw_power_mod +fftw_printer_destroy +fftw_print_plan +fftw_problem_destroy +fftw_rader_tl_delete +fftw_rader_tl_find +fftw_rader_tl_insert +fftw_rdft2_buffered_register +fftw_rdft2_complex_n +fftw_rdft2_inplace_strides +fftw_rdft2_nop_register +fftw_rdft2_pad +fftw_rdft2_rank0_register +fftw_rdft2_rank_geq2_register +fftw_rdft2_rdft_register +fftw_rdft2_solve +fftw_rdft2_strides +fftw_rdft2_tensor_max_index +fftw_rdft2_thr_vrank_geq1_register +fftw_rdft2_vrank_geq1_register +fftw_rdft_buffered_register +fftw_rdft_conf_standard +fftw_rdft_dht_register +fftw_rdft_generic_register +fftw_rdft_indirect_register +fftw_rdft_kind_str +fftw_rdft_nop_register +fftw_rdft_rank0_register +fftw_rdft_rank_geq2_register +fftw_rdft_solve +fftw_rdft_thr_vrank_geq1_register +fftw_rdft_vrank3_transpose_register +fftw_rdft_vrank_geq1_register +fftw_rdft_zerotens +fftw_redft00e_r2hc_pad_register +fftw_regsolver_ct_directw +fftw_regsolver_ct_directwsq +fftw_regsolver_hc2c_direct +fftw_regsolver_hc2hc_direct +fftw_reodft00e_splitradix_register +fftw_reodft010e_r2hc_register +fftw_reodft11e_r2hc_odd_register +fftw_reodft11e_radix2_r2hc_register +fftw_reodft_conf_standard +fftw_rodft00e_r2hc_pad_register +fftw_safe_mulmod +fftw_scanner_destroy +fftw_set_planner_hooks +fftw_set_timelimit +fftw_solver_destroy +fftw_solver_register +fftw_solver_use +fftw_solvtab_exec +fftw_spawn_loop +fftw_sprint_plan +fftw_stride_destroy +fftw_taint +fftw_tensor_append +fftw_tensor_compress +fftw_tensor_compress_contiguous +fftw_tensor_copy +fftw_tensor_copy_except +fftw_tensor_copy_inplace +fftw_tensor_copy_sub +fftw_tensor_destroy +fftw_tensor_destroy2 +fftw_tensor_destroy4 +fftw_tensor_equal +fftw_tensor_inplace_locations +fftw_tensor_inplace_strides +fftw_tensor_inplace_strides2 +fftw_tensor_kosherp +fftw_tensor_max_index +fftw_tensor_md5 +fftw_tensor_min_istride +fftw_tensor_min_ostride +fftw_tensor_min_stride +fftw_tensor_print +fftw_tensor_split +fftw_tensor_strides_decrease +fftw_tensor_sz +fftw_tensor_tornk1 +fftw_the_planner +fftw_threads_cleanup +fftw_threads_conf_standard +fftw_threads_register_planner_hooks +fftw_tile2d +fftw_toobig +fftw_transpose +fftw_transpose_tiled +fftw_transpose_tiledbuf +fftw_triggen_destroy +fftw_twiddle_awake +fftw_twiddle_length +fftw_zero1d_pair diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3-3.dll b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.dll new file mode 100644 index 00000000..75080e49 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.dll differ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3-3.exp b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.exp new file mode 100644 index 00000000..ed919e67 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.exp differ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3-3.lib b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.lib new file mode 100644 index 00000000..af6166db Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3-3.lib differ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.def b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.def new file mode 100644 index 00000000..d61a2c36 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.def @@ -0,0 +1,1017 @@ +LIBRARY libfftw3f-3.dll +EXPORTS +fftwf_alignment_of +fftwf_alloc_complex +fftwf_alloc_real +fftwf_assertion_failed +fftwf_bufdist +fftwf_check_alignment_of_sse2_pm +fftwf_choose_radix +fftwf_cleanup +fftwf_cleanup_threads +fftwf_codelet_e01_8 +fftwf_codelet_e10_8 +fftwf_codelet_hb_10 +fftwf_codelet_hb_12 +fftwf_codelet_hb_15 +fftwf_codelet_hb_16 +fftwf_codelet_hb_2 +fftwf_codelet_hb_20 +fftwf_codelet_hb2_16 +fftwf_codelet_hb2_20 +fftwf_codelet_hb2_25 +fftwf_codelet_hb2_32 +fftwf_codelet_hb2_4 +fftwf_codelet_hb_25 +fftwf_codelet_hb2_5 +fftwf_codelet_hb2_8 +fftwf_codelet_hb_3 +fftwf_codelet_hb_32 +fftwf_codelet_hb_4 +fftwf_codelet_hb_5 +fftwf_codelet_hb_6 +fftwf_codelet_hb_64 +fftwf_codelet_hb_7 +fftwf_codelet_hb_8 +fftwf_codelet_hb_9 +fftwf_codelet_hc2cb_10 +fftwf_codelet_hc2cb_12 +fftwf_codelet_hc2cb_16 +fftwf_codelet_hc2cb_2 +fftwf_codelet_hc2cb_20 +fftwf_codelet_hc2cb2_16 +fftwf_codelet_hc2cb2_20 +fftwf_codelet_hc2cb2_32 +fftwf_codelet_hc2cb2_4 +fftwf_codelet_hc2cb2_8 +fftwf_codelet_hc2cb_32 +fftwf_codelet_hc2cb_4 +fftwf_codelet_hc2cb_6 +fftwf_codelet_hc2cb_8 +fftwf_codelet_hc2cbdft_10 +fftwf_codelet_hc2cbdft_12 +fftwf_codelet_hc2cbdft_16 +fftwf_codelet_hc2cbdft_2 +fftwf_codelet_hc2cbdft_20 +fftwf_codelet_hc2cbdft2_16 +fftwf_codelet_hc2cbdft2_20 +fftwf_codelet_hc2cbdft2_32 +fftwf_codelet_hc2cbdft2_4 +fftwf_codelet_hc2cbdft2_8 +fftwf_codelet_hc2cbdft_32 +fftwf_codelet_hc2cbdft_4 +fftwf_codelet_hc2cbdft_6 +fftwf_codelet_hc2cbdft_8 +fftwf_codelet_hc2cbdftv_10_avx +fftwf_codelet_hc2cbdftv_10_sse2 +fftwf_codelet_hc2cbdftv_12_avx +fftwf_codelet_hc2cbdftv_12_sse2 +fftwf_codelet_hc2cbdftv_16_avx +fftwf_codelet_hc2cbdftv_16_sse2 +fftwf_codelet_hc2cbdftv_20_avx +fftwf_codelet_hc2cbdftv_20_sse2 +fftwf_codelet_hc2cbdftv_2_avx +fftwf_codelet_hc2cbdftv_2_sse2 +fftwf_codelet_hc2cbdftv_32_avx +fftwf_codelet_hc2cbdftv_32_sse2 +fftwf_codelet_hc2cbdftv_4_avx +fftwf_codelet_hc2cbdftv_4_sse2 +fftwf_codelet_hc2cbdftv_6_avx +fftwf_codelet_hc2cbdftv_6_sse2 +fftwf_codelet_hc2cbdftv_8_avx +fftwf_codelet_hc2cbdftv_8_sse2 +fftwf_codelet_hc2cf_10 +fftwf_codelet_hc2cf_12 +fftwf_codelet_hc2cf_16 +fftwf_codelet_hc2cf_2 +fftwf_codelet_hc2cf_20 +fftwf_codelet_hc2cf2_16 +fftwf_codelet_hc2cf2_20 +fftwf_codelet_hc2cf2_32 +fftwf_codelet_hc2cf2_4 +fftwf_codelet_hc2cf2_8 +fftwf_codelet_hc2cf_32 +fftwf_codelet_hc2cf_4 +fftwf_codelet_hc2cf_6 +fftwf_codelet_hc2cf_8 +fftwf_codelet_hc2cfdft_10 +fftwf_codelet_hc2cfdft_12 +fftwf_codelet_hc2cfdft_16 +fftwf_codelet_hc2cfdft_2 +fftwf_codelet_hc2cfdft_20 +fftwf_codelet_hc2cfdft2_16 +fftwf_codelet_hc2cfdft2_20 +fftwf_codelet_hc2cfdft2_32 +fftwf_codelet_hc2cfdft2_4 +fftwf_codelet_hc2cfdft2_8 +fftwf_codelet_hc2cfdft_32 +fftwf_codelet_hc2cfdft_4 +fftwf_codelet_hc2cfdft_6 +fftwf_codelet_hc2cfdft_8 +fftwf_codelet_hc2cfdftv_10_avx +fftwf_codelet_hc2cfdftv_10_sse2 +fftwf_codelet_hc2cfdftv_12_avx +fftwf_codelet_hc2cfdftv_12_sse2 +fftwf_codelet_hc2cfdftv_16_avx +fftwf_codelet_hc2cfdftv_16_sse2 +fftwf_codelet_hc2cfdftv_20_avx +fftwf_codelet_hc2cfdftv_20_sse2 +fftwf_codelet_hc2cfdftv_2_avx +fftwf_codelet_hc2cfdftv_2_sse2 +fftwf_codelet_hc2cfdftv_32_avx +fftwf_codelet_hc2cfdftv_32_sse2 +fftwf_codelet_hc2cfdftv_4_avx +fftwf_codelet_hc2cfdftv_4_sse2 +fftwf_codelet_hc2cfdftv_6_avx +fftwf_codelet_hc2cfdftv_6_sse2 +fftwf_codelet_hc2cfdftv_8_avx +fftwf_codelet_hc2cfdftv_8_sse2 +fftwf_codelet_hf_10 +fftwf_codelet_hf_12 +fftwf_codelet_hf_15 +fftwf_codelet_hf_16 +fftwf_codelet_hf_2 +fftwf_codelet_hf_20 +fftwf_codelet_hf2_16 +fftwf_codelet_hf2_20 +fftwf_codelet_hf2_25 +fftwf_codelet_hf2_32 +fftwf_codelet_hf2_4 +fftwf_codelet_hf_25 +fftwf_codelet_hf2_5 +fftwf_codelet_hf2_8 +fftwf_codelet_hf_3 +fftwf_codelet_hf_32 +fftwf_codelet_hf_4 +fftwf_codelet_hf_5 +fftwf_codelet_hf_6 +fftwf_codelet_hf_64 +fftwf_codelet_hf_7 +fftwf_codelet_hf_8 +fftwf_codelet_hf_9 +fftwf_codelet_n1_10 +fftwf_codelet_n1_11 +fftwf_codelet_n1_12 +fftwf_codelet_n1_13 +fftwf_codelet_n1_14 +fftwf_codelet_n1_15 +fftwf_codelet_n1_16 +fftwf_codelet_n1_2 +fftwf_codelet_n1_20 +fftwf_codelet_n1_25 +fftwf_codelet_n1_3 +fftwf_codelet_n1_32 +fftwf_codelet_n1_4 +fftwf_codelet_n1_5 +fftwf_codelet_n1_6 +fftwf_codelet_n1_64 +fftwf_codelet_n1_7 +fftwf_codelet_n1_8 +fftwf_codelet_n1_9 +fftwf_codelet_n1bv_10_avx +fftwf_codelet_n1bv_10_sse2 +fftwf_codelet_n1bv_11_avx +fftwf_codelet_n1bv_11_sse2 +fftwf_codelet_n1bv_128_avx +fftwf_codelet_n1bv_128_sse2 +fftwf_codelet_n1bv_12_avx +fftwf_codelet_n1bv_12_sse2 +fftwf_codelet_n1bv_13_avx +fftwf_codelet_n1bv_13_sse2 +fftwf_codelet_n1bv_14_avx +fftwf_codelet_n1bv_14_sse2 +fftwf_codelet_n1bv_15_avx +fftwf_codelet_n1bv_15_sse2 +fftwf_codelet_n1bv_16_avx +fftwf_codelet_n1bv_16_sse2 +fftwf_codelet_n1bv_20_avx +fftwf_codelet_n1bv_20_sse2 +fftwf_codelet_n1bv_25_avx +fftwf_codelet_n1bv_25_sse2 +fftwf_codelet_n1bv_2_avx +fftwf_codelet_n1bv_2_sse2 +fftwf_codelet_n1bv_32_avx +fftwf_codelet_n1bv_32_sse2 +fftwf_codelet_n1bv_3_avx +fftwf_codelet_n1bv_3_sse2 +fftwf_codelet_n1bv_4_avx +fftwf_codelet_n1bv_4_sse2 +fftwf_codelet_n1bv_5_avx +fftwf_codelet_n1bv_5_sse2 +fftwf_codelet_n1bv_64_avx +fftwf_codelet_n1bv_64_sse2 +fftwf_codelet_n1bv_6_avx +fftwf_codelet_n1bv_6_sse2 +fftwf_codelet_n1bv_7_avx +fftwf_codelet_n1bv_7_sse2 +fftwf_codelet_n1bv_8_avx +fftwf_codelet_n1bv_8_sse2 +fftwf_codelet_n1bv_9_avx +fftwf_codelet_n1bv_9_sse2 +fftwf_codelet_n1fv_10_avx +fftwf_codelet_n1fv_10_sse2 +fftwf_codelet_n1fv_11_avx +fftwf_codelet_n1fv_11_sse2 +fftwf_codelet_n1fv_128_avx +fftwf_codelet_n1fv_128_sse2 +fftwf_codelet_n1fv_12_avx +fftwf_codelet_n1fv_12_sse2 +fftwf_codelet_n1fv_13_avx +fftwf_codelet_n1fv_13_sse2 +fftwf_codelet_n1fv_14_avx +fftwf_codelet_n1fv_14_sse2 +fftwf_codelet_n1fv_15_avx +fftwf_codelet_n1fv_15_sse2 +fftwf_codelet_n1fv_16_avx +fftwf_codelet_n1fv_16_sse2 +fftwf_codelet_n1fv_20_avx +fftwf_codelet_n1fv_20_sse2 +fftwf_codelet_n1fv_25_avx +fftwf_codelet_n1fv_25_sse2 +fftwf_codelet_n1fv_2_avx +fftwf_codelet_n1fv_2_sse2 +fftwf_codelet_n1fv_32_avx +fftwf_codelet_n1fv_32_sse2 +fftwf_codelet_n1fv_3_avx +fftwf_codelet_n1fv_3_sse2 +fftwf_codelet_n1fv_4_avx +fftwf_codelet_n1fv_4_sse2 +fftwf_codelet_n1fv_5_avx +fftwf_codelet_n1fv_5_sse2 +fftwf_codelet_n1fv_64_avx +fftwf_codelet_n1fv_64_sse2 +fftwf_codelet_n1fv_6_avx +fftwf_codelet_n1fv_6_sse2 +fftwf_codelet_n1fv_7_avx +fftwf_codelet_n1fv_7_sse2 +fftwf_codelet_n1fv_8_avx +fftwf_codelet_n1fv_8_sse2 +fftwf_codelet_n1fv_9_avx +fftwf_codelet_n1fv_9_sse2 +fftwf_codelet_n2bv_10_avx +fftwf_codelet_n2bv_10_sse2 +fftwf_codelet_n2bv_12_avx +fftwf_codelet_n2bv_12_sse2 +fftwf_codelet_n2bv_14_avx +fftwf_codelet_n2bv_14_sse2 +fftwf_codelet_n2bv_16_avx +fftwf_codelet_n2bv_16_sse2 +fftwf_codelet_n2bv_20_avx +fftwf_codelet_n2bv_20_sse2 +fftwf_codelet_n2bv_2_avx +fftwf_codelet_n2bv_2_sse2 +fftwf_codelet_n2bv_32_avx +fftwf_codelet_n2bv_32_sse2 +fftwf_codelet_n2bv_4_avx +fftwf_codelet_n2bv_4_sse2 +fftwf_codelet_n2bv_64_avx +fftwf_codelet_n2bv_64_sse2 +fftwf_codelet_n2bv_6_avx +fftwf_codelet_n2bv_6_sse2 +fftwf_codelet_n2bv_8_avx +fftwf_codelet_n2bv_8_sse2 +fftwf_codelet_n2fv_10_avx +fftwf_codelet_n2fv_10_sse2 +fftwf_codelet_n2fv_12_avx +fftwf_codelet_n2fv_12_sse2 +fftwf_codelet_n2fv_14_avx +fftwf_codelet_n2fv_14_sse2 +fftwf_codelet_n2fv_16_avx +fftwf_codelet_n2fv_16_sse2 +fftwf_codelet_n2fv_20_avx +fftwf_codelet_n2fv_20_sse2 +fftwf_codelet_n2fv_2_avx +fftwf_codelet_n2fv_2_sse2 +fftwf_codelet_n2fv_32_avx +fftwf_codelet_n2fv_32_sse2 +fftwf_codelet_n2fv_4_avx +fftwf_codelet_n2fv_4_sse2 +fftwf_codelet_n2fv_64_avx +fftwf_codelet_n2fv_64_sse2 +fftwf_codelet_n2fv_6_avx +fftwf_codelet_n2fv_6_sse2 +fftwf_codelet_n2fv_8_avx +fftwf_codelet_n2fv_8_sse2 +fftwf_codelet_n2sv_16_avx +fftwf_codelet_n2sv_16_sse2 +fftwf_codelet_n2sv_32_avx +fftwf_codelet_n2sv_32_sse2 +fftwf_codelet_n2sv_4_avx +fftwf_codelet_n2sv_4_sse2 +fftwf_codelet_n2sv_64_avx +fftwf_codelet_n2sv_64_sse2 +fftwf_codelet_n2sv_8_avx +fftwf_codelet_n2sv_8_sse2 +fftwf_codelet_q1_2 +fftwf_codelet_q1_3 +fftwf_codelet_q1_4 +fftwf_codelet_q1_5 +fftwf_codelet_q1_6 +fftwf_codelet_q1_8 +fftwf_codelet_q1bv_2_avx +fftwf_codelet_q1bv_2_sse2 +fftwf_codelet_q1bv_4_avx +fftwf_codelet_q1bv_4_sse2 +fftwf_codelet_q1bv_5_avx +fftwf_codelet_q1bv_5_sse2 +fftwf_codelet_q1bv_8_avx +fftwf_codelet_q1bv_8_sse2 +fftwf_codelet_q1fv_2_avx +fftwf_codelet_q1fv_2_sse2 +fftwf_codelet_q1fv_4_avx +fftwf_codelet_q1fv_4_sse2 +fftwf_codelet_q1fv_5_avx +fftwf_codelet_q1fv_5_sse2 +fftwf_codelet_q1fv_8_avx +fftwf_codelet_q1fv_8_sse2 +fftwf_codelet_r2cb_10 +fftwf_codelet_r2cb_11 +fftwf_codelet_r2cb_12 +fftwf_codelet_r2cb_128 +fftwf_codelet_r2cb_13 +fftwf_codelet_r2cb_14 +fftwf_codelet_r2cb_15 +fftwf_codelet_r2cb_16 +fftwf_codelet_r2cb_2 +fftwf_codelet_r2cb_20 +fftwf_codelet_r2cb_25 +fftwf_codelet_r2cb_3 +fftwf_codelet_r2cb_32 +fftwf_codelet_r2cb_4 +fftwf_codelet_r2cb_5 +fftwf_codelet_r2cb_6 +fftwf_codelet_r2cb_64 +fftwf_codelet_r2cb_7 +fftwf_codelet_r2cb_8 +fftwf_codelet_r2cb_9 +fftwf_codelet_r2cbIII_10 +fftwf_codelet_r2cbIII_12 +fftwf_codelet_r2cbIII_15 +fftwf_codelet_r2cbIII_16 +fftwf_codelet_r2cbIII_2 +fftwf_codelet_r2cbIII_20 +fftwf_codelet_r2cbIII_25 +fftwf_codelet_r2cbIII_3 +fftwf_codelet_r2cbIII_32 +fftwf_codelet_r2cbIII_4 +fftwf_codelet_r2cbIII_5 +fftwf_codelet_r2cbIII_6 +fftwf_codelet_r2cbIII_64 +fftwf_codelet_r2cbIII_7 +fftwf_codelet_r2cbIII_8 +fftwf_codelet_r2cbIII_9 +fftwf_codelet_r2cf_10 +fftwf_codelet_r2cf_11 +fftwf_codelet_r2cf_12 +fftwf_codelet_r2cf_128 +fftwf_codelet_r2cf_13 +fftwf_codelet_r2cf_14 +fftwf_codelet_r2cf_15 +fftwf_codelet_r2cf_16 +fftwf_codelet_r2cf_2 +fftwf_codelet_r2cf_20 +fftwf_codelet_r2cf_25 +fftwf_codelet_r2cf_3 +fftwf_codelet_r2cf_32 +fftwf_codelet_r2cf_4 +fftwf_codelet_r2cf_5 +fftwf_codelet_r2cf_6 +fftwf_codelet_r2cf_64 +fftwf_codelet_r2cf_7 +fftwf_codelet_r2cf_8 +fftwf_codelet_r2cf_9 +fftwf_codelet_r2cfII_10 +fftwf_codelet_r2cfII_12 +fftwf_codelet_r2cfII_15 +fftwf_codelet_r2cfII_16 +fftwf_codelet_r2cfII_2 +fftwf_codelet_r2cfII_20 +fftwf_codelet_r2cfII_25 +fftwf_codelet_r2cfII_3 +fftwf_codelet_r2cfII_32 +fftwf_codelet_r2cfII_4 +fftwf_codelet_r2cfII_5 +fftwf_codelet_r2cfII_6 +fftwf_codelet_r2cfII_64 +fftwf_codelet_r2cfII_7 +fftwf_codelet_r2cfII_8 +fftwf_codelet_r2cfII_9 +fftwf_codelet_t1_10 +fftwf_codelet_t1_12 +fftwf_codelet_t1_15 +fftwf_codelet_t1_16 +fftwf_codelet_t1_2 +fftwf_codelet_t1_20 +fftwf_codelet_t1_25 +fftwf_codelet_t1_3 +fftwf_codelet_t1_32 +fftwf_codelet_t1_4 +fftwf_codelet_t1_5 +fftwf_codelet_t1_6 +fftwf_codelet_t1_64 +fftwf_codelet_t1_7 +fftwf_codelet_t1_8 +fftwf_codelet_t1_9 +fftwf_codelet_t1buv_10_avx +fftwf_codelet_t1buv_10_sse2 +fftwf_codelet_t1buv_2_avx +fftwf_codelet_t1buv_2_sse2 +fftwf_codelet_t1buv_3_avx +fftwf_codelet_t1buv_3_sse2 +fftwf_codelet_t1buv_4_avx +fftwf_codelet_t1buv_4_sse2 +fftwf_codelet_t1buv_5_avx +fftwf_codelet_t1buv_5_sse2 +fftwf_codelet_t1buv_6_avx +fftwf_codelet_t1buv_6_sse2 +fftwf_codelet_t1buv_7_avx +fftwf_codelet_t1buv_7_sse2 +fftwf_codelet_t1buv_8_avx +fftwf_codelet_t1buv_8_sse2 +fftwf_codelet_t1buv_9_avx +fftwf_codelet_t1buv_9_sse2 +fftwf_codelet_t1bv_10_avx +fftwf_codelet_t1bv_10_sse2 +fftwf_codelet_t1bv_12_avx +fftwf_codelet_t1bv_12_sse2 +fftwf_codelet_t1bv_15_avx +fftwf_codelet_t1bv_15_sse2 +fftwf_codelet_t1bv_16_avx +fftwf_codelet_t1bv_16_sse2 +fftwf_codelet_t1bv_20_avx +fftwf_codelet_t1bv_20_sse2 +fftwf_codelet_t1bv_25_avx +fftwf_codelet_t1bv_25_sse2 +fftwf_codelet_t1bv_2_avx +fftwf_codelet_t1bv_2_sse2 +fftwf_codelet_t1bv_32_avx +fftwf_codelet_t1bv_32_sse2 +fftwf_codelet_t1bv_3_avx +fftwf_codelet_t1bv_3_sse2 +fftwf_codelet_t1bv_4_avx +fftwf_codelet_t1bv_4_sse2 +fftwf_codelet_t1bv_5_avx +fftwf_codelet_t1bv_5_sse2 +fftwf_codelet_t1bv_64_avx +fftwf_codelet_t1bv_64_sse2 +fftwf_codelet_t1bv_6_avx +fftwf_codelet_t1bv_6_sse2 +fftwf_codelet_t1bv_7_avx +fftwf_codelet_t1bv_7_sse2 +fftwf_codelet_t1bv_8_avx +fftwf_codelet_t1bv_8_sse2 +fftwf_codelet_t1bv_9_avx +fftwf_codelet_t1bv_9_sse2 +fftwf_codelet_t1fuv_10_avx +fftwf_codelet_t1fuv_10_sse2 +fftwf_codelet_t1fuv_2_avx +fftwf_codelet_t1fuv_2_sse2 +fftwf_codelet_t1fuv_3_avx +fftwf_codelet_t1fuv_3_sse2 +fftwf_codelet_t1fuv_4_avx +fftwf_codelet_t1fuv_4_sse2 +fftwf_codelet_t1fuv_5_avx +fftwf_codelet_t1fuv_5_sse2 +fftwf_codelet_t1fuv_6_avx +fftwf_codelet_t1fuv_6_sse2 +fftwf_codelet_t1fuv_7_avx +fftwf_codelet_t1fuv_7_sse2 +fftwf_codelet_t1fuv_8_avx +fftwf_codelet_t1fuv_8_sse2 +fftwf_codelet_t1fuv_9_avx +fftwf_codelet_t1fuv_9_sse2 +fftwf_codelet_t1fv_10_avx +fftwf_codelet_t1fv_10_sse2 +fftwf_codelet_t1fv_12_avx +fftwf_codelet_t1fv_12_sse2 +fftwf_codelet_t1fv_15_avx +fftwf_codelet_t1fv_15_sse2 +fftwf_codelet_t1fv_16_avx +fftwf_codelet_t1fv_16_sse2 +fftwf_codelet_t1fv_20_avx +fftwf_codelet_t1fv_20_sse2 +fftwf_codelet_t1fv_25_avx +fftwf_codelet_t1fv_25_sse2 +fftwf_codelet_t1fv_2_avx +fftwf_codelet_t1fv_2_sse2 +fftwf_codelet_t1fv_32_avx +fftwf_codelet_t1fv_32_sse2 +fftwf_codelet_t1fv_3_avx +fftwf_codelet_t1fv_3_sse2 +fftwf_codelet_t1fv_4_avx +fftwf_codelet_t1fv_4_sse2 +fftwf_codelet_t1fv_5_avx +fftwf_codelet_t1fv_5_sse2 +fftwf_codelet_t1fv_64_avx +fftwf_codelet_t1fv_64_sse2 +fftwf_codelet_t1fv_6_avx +fftwf_codelet_t1fv_6_sse2 +fftwf_codelet_t1fv_7_avx +fftwf_codelet_t1fv_7_sse2 +fftwf_codelet_t1fv_8_avx +fftwf_codelet_t1fv_8_sse2 +fftwf_codelet_t1fv_9_avx +fftwf_codelet_t1fv_9_sse2 +fftwf_codelet_t1sv_16_avx +fftwf_codelet_t1sv_16_sse2 +fftwf_codelet_t1sv_2_avx +fftwf_codelet_t1sv_2_sse2 +fftwf_codelet_t1sv_32_avx +fftwf_codelet_t1sv_32_sse2 +fftwf_codelet_t1sv_4_avx +fftwf_codelet_t1sv_4_sse2 +fftwf_codelet_t1sv_8_avx +fftwf_codelet_t1sv_8_sse2 +fftwf_codelet_t2_10 +fftwf_codelet_t2_16 +fftwf_codelet_t2_20 +fftwf_codelet_t2_25 +fftwf_codelet_t2_32 +fftwf_codelet_t2_4 +fftwf_codelet_t2_5 +fftwf_codelet_t2_64 +fftwf_codelet_t2_8 +fftwf_codelet_t2bv_10_avx +fftwf_codelet_t2bv_10_sse2 +fftwf_codelet_t2bv_16_avx +fftwf_codelet_t2bv_16_sse2 +fftwf_codelet_t2bv_20_avx +fftwf_codelet_t2bv_20_sse2 +fftwf_codelet_t2bv_25_avx +fftwf_codelet_t2bv_25_sse2 +fftwf_codelet_t2bv_2_avx +fftwf_codelet_t2bv_2_sse2 +fftwf_codelet_t2bv_32_avx +fftwf_codelet_t2bv_32_sse2 +fftwf_codelet_t2bv_4_avx +fftwf_codelet_t2bv_4_sse2 +fftwf_codelet_t2bv_5_avx +fftwf_codelet_t2bv_5_sse2 +fftwf_codelet_t2bv_64_avx +fftwf_codelet_t2bv_64_sse2 +fftwf_codelet_t2bv_8_avx +fftwf_codelet_t2bv_8_sse2 +fftwf_codelet_t2fv_10_avx +fftwf_codelet_t2fv_10_sse2 +fftwf_codelet_t2fv_16_avx +fftwf_codelet_t2fv_16_sse2 +fftwf_codelet_t2fv_20_avx +fftwf_codelet_t2fv_20_sse2 +fftwf_codelet_t2fv_25_avx +fftwf_codelet_t2fv_25_sse2 +fftwf_codelet_t2fv_2_avx +fftwf_codelet_t2fv_2_sse2 +fftwf_codelet_t2fv_32_avx +fftwf_codelet_t2fv_32_sse2 +fftwf_codelet_t2fv_4_avx +fftwf_codelet_t2fv_4_sse2 +fftwf_codelet_t2fv_5_avx +fftwf_codelet_t2fv_5_sse2 +fftwf_codelet_t2fv_64_avx +fftwf_codelet_t2fv_64_sse2 +fftwf_codelet_t2fv_8_avx +fftwf_codelet_t2fv_8_sse2 +fftwf_codelet_t2sv_16_avx +fftwf_codelet_t2sv_16_sse2 +fftwf_codelet_t2sv_32_avx +fftwf_codelet_t2sv_32_sse2 +fftwf_codelet_t2sv_4_avx +fftwf_codelet_t2sv_4_sse2 +fftwf_codelet_t2sv_8_avx +fftwf_codelet_t2sv_8_sse2 +fftwf_codelet_t3bv_10_avx +fftwf_codelet_t3bv_10_sse2 +fftwf_codelet_t3bv_16_avx +fftwf_codelet_t3bv_16_sse2 +fftwf_codelet_t3bv_20_avx +fftwf_codelet_t3bv_20_sse2 +fftwf_codelet_t3bv_25_avx +fftwf_codelet_t3bv_25_sse2 +fftwf_codelet_t3bv_32_avx +fftwf_codelet_t3bv_32_sse2 +fftwf_codelet_t3bv_4_avx +fftwf_codelet_t3bv_4_sse2 +fftwf_codelet_t3bv_5_avx +fftwf_codelet_t3bv_5_sse2 +fftwf_codelet_t3bv_8_avx +fftwf_codelet_t3bv_8_sse2 +fftwf_codelet_t3fv_10_avx +fftwf_codelet_t3fv_10_sse2 +fftwf_codelet_t3fv_16_avx +fftwf_codelet_t3fv_16_sse2 +fftwf_codelet_t3fv_20_avx +fftwf_codelet_t3fv_20_sse2 +fftwf_codelet_t3fv_25_avx +fftwf_codelet_t3fv_25_sse2 +fftwf_codelet_t3fv_32_avx +fftwf_codelet_t3fv_32_sse2 +fftwf_codelet_t3fv_4_avx +fftwf_codelet_t3fv_4_sse2 +fftwf_codelet_t3fv_5_avx +fftwf_codelet_t3fv_5_sse2 +fftwf_codelet_t3fv_8_avx +fftwf_codelet_t3fv_8_sse2 +fftwf_compute_tilesz +fftwf_configure_planner +fftwf_cost +fftwf_cpy1d +fftwf_cpy2d +fftwf_cpy2d_ci +fftwf_cpy2d_co +fftwf_cpy2d_pair +fftwf_cpy2d_pair_ci +fftwf_cpy2d_pair_co +fftwf_cpy2d_tiled +fftwf_cpy2d_tiledbuf +fftwf_ct_applicable +fftwf_ct_genericbuf_register +fftwf_ct_generic_register +fftwf_ct_uglyp +fftwf_destroy_plan +fftwf_dft_bluestein_register +fftwf_dft_buffered_register +fftwf_dft_conf_standard +fftwf_dft_generic_register +fftwf_dft_indirect_register +fftwf_dft_indirect_transpose_register +fftwf_dft_nop_register +fftwf_dft_r2hc_register +fftwf_dft_rader_register +fftwf_dft_rank_geq2_register +fftwf_dft_solve +fftwf_dft_thr_vrank_geq1_register +fftwf_dft_vrank_geq1_register +fftwf_dft_zerotens +fftwf_dht_r2hc_register +fftwf_dht_rader_register +fftwf_dimcmp +fftwf_elapsed_since +fftwf_estimate_cost +fftwf_execute +fftwf_execute_dft +fftwf_execute_dft_c2r +fftwf_execute_dft_r2c +fftwf_execute_r2r +fftwf_execute_split_dft +fftwf_execute_split_dft_c2r +fftwf_execute_split_dft_r2c +fftwf_export_wisdom +fftwf_export_wisdom_to_file +fftwf_export_wisdom_to_filename +fftwf_export_wisdom_to_string +fftwf_extract_reim +fftwf_factors_into +fftwf_factors_into_small_primes +fftwf_find_generator +fftwf_first_divisor +fftwf_flops +fftwf_forget_wisdom +fftwf_fprint_plan +fftwf_free +fftwf_get_crude_time +fftwf_guru64_kosherp +fftwf_guru_kosherp +fftwf_hash +fftwf_have_simd_avx +fftwf_have_simd_sse2 +fftwf_hc2hc_applicable +fftwf_hc2hc_generic_register +fftwf_iabs +fftwf_ialignment_of +fftwf_iestimate_cost +fftwf_ifree +fftwf_ifree0 +fftwf_imax +fftwf_imin +fftwf_import_system_wisdom +fftwf_import_wisdom +fftwf_import_wisdom_from_file +fftwf_import_wisdom_from_filename +fftwf_import_wisdom_from_string +fftwf_init_threads +fftwf_is_prime +fftwf_isqrt +fftwf_ithreads_init +fftwf_join_taint +fftwf_kdft_dif_register +fftwf_kdft_difsq_register +fftwf_kdft_dit_register +fftwf_kdft_register +fftwf_kernel_free +fftwf_kernel_malloc +fftwf_khc2c_register +fftwf_khc2hc_register +fftwf_kr2c_register +fftwf_kr2r_register +fftwf_make_planner_thread_safe +fftwf_malloc +fftwf_malloc_plain +fftwf_many_kosherp +fftwf_mapflags +fftwf_map_r2r_kind +fftwf_md5begin +fftwf_md5end +fftwf_md5int +fftwf_md5INT +fftwf_md5putb +fftwf_md5putc +fftwf_md5puts +fftwf_md5unsigned +fftwf_measure_execution_time +fftwf_mkapiplan +fftwf_mkplan +fftwf_mkplan_d +fftwf_mkplan_dft +fftwf_mkplan_dftw +fftwf_mkplan_f_d +fftwf_mkplan_hc2c +fftwf_mkplan_hc2hc +fftwf_mkplanner +fftwf_mkplan_rdft +fftwf_mkplan_rdft2 +fftwf_mkprinter +fftwf_mkprinter_cnt +fftwf_mkprinter_file +fftwf_mkprinter_str +fftwf_mkproblem +fftwf_mkproblem_dft +fftwf_mkproblem_dft_d +fftwf_mkproblem_rdft +fftwf_mkproblem_rdft_0_d +fftwf_mkproblem_rdft_1 +fftwf_mkproblem_rdft_1_d +fftwf_mkproblem_rdft2 +fftwf_mkproblem_rdft2_d +fftwf_mkproblem_rdft2_d_3pointers +fftwf_mkproblem_rdft_d +fftwf_mkproblem_unsolvable +fftwf_mkscanner +fftwf_mksolver +fftwf_mksolver_ct +fftwf_mksolver_ct_threads +fftwf_mksolver_dft_direct +fftwf_mksolver_dft_directbuf +fftwf_mksolver_hc2c +fftwf_mksolver_hc2hc +fftwf_mksolver_hc2hc_threads +fftwf_mksolver_rdft2_direct +fftwf_mksolver_rdft_r2c_direct +fftwf_mksolver_rdft_r2c_directbuf +fftwf_mksolver_rdft_r2r_direct +fftwf_mkstride +fftwf_mktensor +fftwf_mktensor_0d +fftwf_mktensor_1d +fftwf_mktensor_2d +fftwf_mktensor_3d +fftwf_mktensor_4d +fftwf_mktensor_5d +fftwf_mktensor_iodims +fftwf_mktensor_iodims64 +fftwf_mktensor_rowmajor +fftwf_mktriggen +fftwf_modulo +fftwf_nbuf +fftwf_nbuf_redundant +fftwf_next_prime +fftwf_null_awake +fftwf_ops_add +fftwf_ops_add2 +fftwf_ops_cpy +fftwf_ops_madd +fftwf_ops_madd2 +fftwf_ops_other +fftwf_ops_zero +fftwf_pickdim +fftwf_plan_awake +fftwf_plan_destroy_internal +fftwf_plan_dft +fftwf_plan_dft_1d +fftwf_plan_dft_2d +fftwf_plan_dft_3d +fftwf_plan_dft_c2r +fftwf_plan_dft_c2r_1d +fftwf_plan_dft_c2r_2d +fftwf_plan_dft_c2r_3d +fftwf_plan_dft_r2c +fftwf_plan_dft_r2c_1d +fftwf_plan_dft_r2c_2d +fftwf_plan_dft_r2c_3d +fftwf_plan_guru64_dft +fftwf_plan_guru64_dft_c2r +fftwf_plan_guru64_dft_r2c +fftwf_plan_guru64_r2r +fftwf_plan_guru64_split_dft +fftwf_plan_guru64_split_dft_c2r +fftwf_plan_guru64_split_dft_r2c +fftwf_plan_guru_dft +fftwf_plan_guru_dft_c2r +fftwf_plan_guru_dft_r2c +fftwf_plan_guru_r2r +fftwf_plan_guru_split_dft +fftwf_plan_guru_split_dft_c2r +fftwf_plan_guru_split_dft_r2c +fftwf_plan_many_dft +fftwf_plan_many_dft_c2r +fftwf_plan_many_dft_r2c +fftwf_plan_many_r2r +fftwf_planner_destroy +fftwf_plan_null_destroy +fftwf_plan_r2r +fftwf_plan_r2r_1d +fftwf_plan_r2r_2d +fftwf_plan_r2r_3d +fftwf_plan_with_nthreads +fftwf_power_mod +fftwf_printer_destroy +fftwf_print_plan +fftwf_problem_destroy +fftwf_rader_tl_delete +fftwf_rader_tl_find +fftwf_rader_tl_insert +fftwf_rdft2_buffered_register +fftwf_rdft2_complex_n +fftwf_rdft2_inplace_strides +fftwf_rdft2_nop_register +fftwf_rdft2_pad +fftwf_rdft2_rank0_register +fftwf_rdft2_rank_geq2_register +fftwf_rdft2_rdft_register +fftwf_rdft2_solve +fftwf_rdft2_strides +fftwf_rdft2_tensor_max_index +fftwf_rdft2_thr_vrank_geq1_register +fftwf_rdft2_vrank_geq1_register +fftwf_rdft_buffered_register +fftwf_rdft_conf_standard +fftwf_rdft_dht_register +fftwf_rdft_generic_register +fftwf_rdft_indirect_register +fftwf_rdft_kind_str +fftwf_rdft_nop_register +fftwf_rdft_rank0_register +fftwf_rdft_rank_geq2_register +fftwf_rdft_solve +fftwf_rdft_thr_vrank_geq1_register +fftwf_rdft_vrank3_transpose_register +fftwf_rdft_vrank_geq1_register +fftwf_rdft_zerotens +fftwf_redft00e_r2hc_pad_register +fftwf_regsolver_ct_directw +fftwf_regsolver_ct_directwsq +fftwf_regsolver_hc2c_direct +fftwf_regsolver_hc2hc_direct +fftwf_reodft00e_splitradix_register +fftwf_reodft010e_r2hc_register +fftwf_reodft11e_r2hc_odd_register +fftwf_reodft11e_radix2_r2hc_register +fftwf_reodft_conf_standard +fftwf_rodft00e_r2hc_pad_register +fftwf_safe_mulmod +fftwf_scanner_destroy +fftwf_set_planner_hooks +fftwf_set_timelimit +fftwf_solver_destroy +fftwf_solver_register +fftwf_solver_use +fftwf_solvtab_exec +fftwf_spawn_loop +fftwf_sprint_plan +fftwf_stride_destroy +fftwf_taint +fftwf_tensor_append +fftwf_tensor_compress +fftwf_tensor_compress_contiguous +fftwf_tensor_copy +fftwf_tensor_copy_except +fftwf_tensor_copy_inplace +fftwf_tensor_copy_sub +fftwf_tensor_destroy +fftwf_tensor_destroy2 +fftwf_tensor_destroy4 +fftwf_tensor_equal +fftwf_tensor_inplace_locations +fftwf_tensor_inplace_strides +fftwf_tensor_inplace_strides2 +fftwf_tensor_kosherp +fftwf_tensor_max_index +fftwf_tensor_md5 +fftwf_tensor_min_istride +fftwf_tensor_min_ostride +fftwf_tensor_min_stride +fftwf_tensor_print +fftwf_tensor_split +fftwf_tensor_strides_decrease +fftwf_tensor_sz +fftwf_tensor_tornk1 +fftwf_the_planner +fftwf_threads_cleanup +fftwf_threads_conf_standard +fftwf_threads_register_planner_hooks +fftwf_tile2d +fftwf_toobig +fftwf_transpose +fftwf_transpose_tiled +fftwf_transpose_tiledbuf +fftwf_triggen_destroy +fftwf_twiddle_awake +fftwf_twiddle_length +fftwf_zero1d_pair +sfftw_cleanup_ +sfftw_cleanup__ +sfftw_cleanup_threads_ +sfftw_cleanup_threads__ +sfftw_cost_ +sfftw_cost__ +sfftw_destroy_plan_ +sfftw_destroy_plan__ +sfftw_estimate_cost_ +sfftw_estimate_cost__ +sfftw_execute_ +sfftw_execute__ +sfftw_execute_dft_ +sfftw_execute_dft__ +sfftw_execute_dft_c2r_ +sfftw_execute_dft_c2r__ +sfftw_execute_dft_r2c_ +sfftw_execute_dft_r2c__ +sfftw_execute_r2r_ +sfftw_execute_r2r__ +sfftw_execute_split_dft_ +sfftw_execute_split_dft__ +sfftw_execute_split_dft_c2r_ +sfftw_execute_split_dft_c2r__ +sfftw_execute_split_dft_r2c_ +sfftw_execute_split_dft_r2c__ +sfftw_export_wisdom_ +sfftw_export_wisdom__ +sfftw_flops_ +sfftw_flops__ +sfftw_forget_wisdom_ +sfftw_forget_wisdom__ +sfftw_import_system_wisdom_ +sfftw_import_system_wisdom__ +sfftw_import_wisdom_ +sfftw_import_wisdom__ +sfftw_init_threads_ +sfftw_init_threads__ +sfftw_plan_dft_ +sfftw_plan_dft__ +sfftw_plan_dft_1d_ +sfftw_plan_dft_1d__ +sfftw_plan_dft_2d_ +sfftw_plan_dft_2d__ +sfftw_plan_dft_3d_ +sfftw_plan_dft_3d__ +sfftw_plan_dft_c2r_ +sfftw_plan_dft_c2r__ +sfftw_plan_dft_c2r_1d_ +sfftw_plan_dft_c2r_1d__ +sfftw_plan_dft_c2r_2d_ +sfftw_plan_dft_c2r_2d__ +sfftw_plan_dft_c2r_3d_ +sfftw_plan_dft_c2r_3d__ +sfftw_plan_dft_r2c_ +sfftw_plan_dft_r2c__ +sfftw_plan_dft_r2c_1d_ +sfftw_plan_dft_r2c_1d__ +sfftw_plan_dft_r2c_2d_ +sfftw_plan_dft_r2c_2d__ +sfftw_plan_dft_r2c_3d_ +sfftw_plan_dft_r2c_3d__ +sfftw_plan_guru_dft_ +sfftw_plan_guru_dft__ +sfftw_plan_guru_dft_c2r_ +sfftw_plan_guru_dft_c2r__ +sfftw_plan_guru_dft_r2c_ +sfftw_plan_guru_dft_r2c__ +sfftw_plan_guru_r2r_ +sfftw_plan_guru_r2r__ +sfftw_plan_guru_split_dft_ +sfftw_plan_guru_split_dft__ +sfftw_plan_guru_split_dft_c2r_ +sfftw_plan_guru_split_dft_c2r__ +sfftw_plan_guru_split_dft_r2c_ +sfftw_plan_guru_split_dft_r2c__ +sfftw_plan_many_dft_ +sfftw_plan_many_dft__ +sfftw_plan_many_dft_c2r_ +sfftw_plan_many_dft_c2r__ +sfftw_plan_many_dft_r2c_ +sfftw_plan_many_dft_r2c__ +sfftw_plan_many_r2r_ +sfftw_plan_many_r2r__ +sfftw_plan_r2r_ +sfftw_plan_r2r__ +sfftw_plan_r2r_1d_ +sfftw_plan_r2r_1d__ +sfftw_plan_r2r_2d_ +sfftw_plan_r2r_2d__ +sfftw_plan_r2r_3d_ +sfftw_plan_r2r_3d__ +sfftw_plan_with_nthreads_ +sfftw_plan_with_nthreads__ +sfftw_print_plan_ +sfftw_print_plan__ +sfftw_set_timelimit_ +sfftw_set_timelimit__ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.dll b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.dll new file mode 100644 index 00000000..32a3fcf1 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.dll differ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.exp b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.exp new file mode 100644 index 00000000..b8f1b113 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.exp differ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.lib b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.lib new file mode 100644 index 00000000..17c9fc5a Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3f-3.lib differ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3l-3.def b/Desktop_Interface/build_win/fftw/x64/libfftw3l-3.def new file mode 100644 index 00000000..62a5e423 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x64/libfftw3l-3.def @@ -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__ diff --git a/Desktop_Interface/build_win/fftw/x64/libfftw3l-3.dll b/Desktop_Interface/build_win/fftw/x64/libfftw3l-3.dll new file mode 100644 index 00000000..3e46d34d Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x64/libfftw3l-3.dll differ diff --git a/Desktop_Interface/build_win/fftw/x86/COPYING b/Desktop_Interface/build_win/fftw/x86/COPYING new file mode 100644 index 00000000..623b6258 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/COPYING @@ -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. + + + Copyright (C) + + 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. + + , 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. diff --git a/Desktop_Interface/build_win/fftw/x86/COPYRIGHT b/Desktop_Interface/build_win/fftw/x86/COPYRIGHT new file mode 100644 index 00000000..089500b6 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/COPYRIGHT @@ -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 + * + */ diff --git a/Desktop_Interface/build_win/fftw/x86/NEWS b/Desktop_Interface/build_win/fftw/x86/NEWS new file mode 100644 index 00000000..9a9cac67 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/NEWS @@ -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=, + 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. diff --git a/Desktop_Interface/build_win/fftw/x86/README b/Desktop_Interface/build_win/fftw/x86/README new file mode 100644 index 00000000..1547fe5d --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/README @@ -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. diff --git a/Desktop_Interface/build_win/fftw/x86/README-WINDOWS b/Desktop_Interface/build_win/fftw/x86/README-WINDOWS new file mode 100644 index 00000000..37c9c7c1 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/README-WINDOWS @@ -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 diff --git a/Desktop_Interface/build_win/fftw/x86/README-bench b/Desktop_Interface/build_win/fftw/x86/README-bench new file mode 100644 index 00000000..5a5c6e6f --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/README-bench @@ -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 + +where each command is as follows: + +-s +--speed + + Benchmarks the speed of . + + The syntax for problems is [i|o][r|c][f|b], 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. + 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 +--verify + + 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 + + Set verbosity to , or 1 if 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). diff --git a/Desktop_Interface/build_win/fftw/x86/fftw3.f b/Desktop_Interface/build_win/fftw/x86/fftw3.f new file mode 100644 index 00000000..72d1aaf2 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/fftw3.f @@ -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) diff --git a/Desktop_Interface/build_win/fftw/x86/fftw3.f03 b/Desktop_Interface/build_win/fftw/x86/fftw3.f03 new file mode 100644 index 00000000..85ba1b6d --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/fftw3.f03 @@ -0,0 +1,1254 @@ +! Generated automatically. DO NOT EDIT! + + integer, parameter :: C_FFTW_R2R_KIND = C_INT32_T + + integer(C_INT), parameter :: FFTW_R2HC = 0 + integer(C_INT), parameter :: FFTW_HC2R = 1 + integer(C_INT), parameter :: FFTW_DHT = 2 + integer(C_INT), parameter :: FFTW_REDFT00 = 3 + integer(C_INT), parameter :: FFTW_REDFT01 = 4 + integer(C_INT), parameter :: FFTW_REDFT10 = 5 + integer(C_INT), parameter :: FFTW_REDFT11 = 6 + integer(C_INT), parameter :: FFTW_RODFT00 = 7 + integer(C_INT), parameter :: FFTW_RODFT01 = 8 + integer(C_INT), parameter :: FFTW_RODFT10 = 9 + integer(C_INT), parameter :: FFTW_RODFT11 = 10 + integer(C_INT), parameter :: FFTW_FORWARD = -1 + integer(C_INT), parameter :: FFTW_BACKWARD = +1 + integer(C_INT), parameter :: FFTW_MEASURE = 0 + integer(C_INT), parameter :: FFTW_DESTROY_INPUT = 1 + integer(C_INT), parameter :: FFTW_UNALIGNED = 2 + integer(C_INT), parameter :: FFTW_CONSERVE_MEMORY = 4 + integer(C_INT), parameter :: FFTW_EXHAUSTIVE = 8 + integer(C_INT), parameter :: FFTW_PRESERVE_INPUT = 16 + integer(C_INT), parameter :: FFTW_PATIENT = 32 + integer(C_INT), parameter :: FFTW_ESTIMATE = 64 + integer(C_INT), parameter :: FFTW_WISDOM_ONLY = 2097152 + integer(C_INT), parameter :: FFTW_ESTIMATE_PATIENT = 128 + integer(C_INT), parameter :: FFTW_BELIEVE_PCOST = 256 + integer(C_INT), parameter :: FFTW_NO_DFT_R2HC = 512 + integer(C_INT), parameter :: FFTW_NO_NONTHREADED = 1024 + integer(C_INT), parameter :: FFTW_NO_BUFFERING = 2048 + integer(C_INT), parameter :: FFTW_NO_INDIRECT_OP = 4096 + integer(C_INT), parameter :: FFTW_ALLOW_LARGE_GENERIC = 8192 + integer(C_INT), parameter :: FFTW_NO_RANK_SPLITS = 16384 + integer(C_INT), parameter :: FFTW_NO_VRANK_SPLITS = 32768 + integer(C_INT), parameter :: FFTW_NO_VRECURSE = 65536 + integer(C_INT), parameter :: FFTW_NO_SIMD = 131072 + integer(C_INT), parameter :: FFTW_NO_SLOW = 262144 + integer(C_INT), parameter :: FFTW_NO_FIXED_RADIX_LARGE_N = 524288 + integer(C_INT), parameter :: FFTW_ALLOW_PRUNING = 1048576 + + type, bind(C) :: fftw_iodim + integer(C_INT) n, is, os + end type fftw_iodim + type, bind(C) :: fftw_iodim64 + integer(C_INTPTR_T) n, is, os + end type fftw_iodim64 + + interface + type(C_PTR) function fftw_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftw_plan_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft + + type(C_PTR) function fftw_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftw_plan_dft_1d') + import + integer(C_INT), value :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft_1d + + type(C_PTR) function fftw_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftw_plan_dft_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft_2d + + type(C_PTR) function fftw_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftw_plan_dft_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_dft_3d + + type(C_PTR) function fftw_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) & + bind(C, name='fftw_plan_many_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_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_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 fftw_plan_many_dft + + type(C_PTR) function fftw_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftw_plan_guru_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_guru_dft + + type(C_PTR) function fftw_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftw_plan_guru_split_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru_split_dft + + type(C_PTR) function fftw_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftw_plan_guru64_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftw_plan_guru64_dft + + type(C_PTR) function fftw_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftw_plan_guru64_split_dft') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru64_split_dft + + subroutine fftw_execute_dft(p,in,out) bind(C, name='fftw_execute_dft') + import + type(C_PTR), value :: p + complex(C_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftw_execute_dft + + subroutine fftw_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftw_execute_split_dft') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: ri + real(C_DOUBLE), dimension(*), intent(inout) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + end subroutine fftw_execute_split_dft + + type(C_PTR) function fftw_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftw_plan_many_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_DOUBLE), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + complex(C_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 fftw_plan_many_dft_r2c + + type(C_PTR) function fftw_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftw_plan_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c + + type(C_PTR) function fftw_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftw_plan_dft_r2c_1d') + import + integer(C_INT), value :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c_1d + + type(C_PTR) function fftw_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftw_plan_dft_r2c_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c_2d + + type(C_PTR) function fftw_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftw_plan_dft_r2c_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_r2c_3d + + type(C_PTR) function fftw_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftw_plan_many_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_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_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 fftw_plan_many_dft_c2r + + type(C_PTR) function fftw_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftw_plan_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r + + type(C_PTR) function fftw_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftw_plan_dft_c2r_1d') + import + integer(C_INT), value :: n + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r_1d + + type(C_PTR) function fftw_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftw_plan_dft_c2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r_2d + + type(C_PTR) function fftw_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftw_plan_dft_c2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_dft_c2r_3d + + type(C_PTR) function fftw_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru_dft_r2c + + type(C_PTR) function fftw_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru_dft_c2r + + type(C_PTR) function fftw_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftw_plan_guru_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru_split_dft_r2c + + type(C_PTR) function fftw_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftw_plan_guru_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru_split_dft_c2r + + type(C_PTR) function fftw_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru64_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru64_dft_r2c + + type(C_PTR) function fftw_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftw_plan_guru64_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru64_dft_c2r + + type(C_PTR) function fftw_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftw_plan_guru64_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftw_plan_guru64_split_dft_r2c + + type(C_PTR) function fftw_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftw_plan_guru64_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: ri + real(C_DOUBLE), dimension(*), intent(out) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftw_plan_guru64_split_dft_c2r + + subroutine fftw_execute_dft_r2c(p,in,out) bind(C, name='fftw_execute_dft_r2c') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: in + complex(C_DOUBLE_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftw_execute_dft_r2c + + subroutine fftw_execute_dft_c2r(p,in,out) bind(C, name='fftw_execute_dft_c2r') + import + type(C_PTR), value :: p + complex(C_DOUBLE_COMPLEX), dimension(*), intent(inout) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + end subroutine fftw_execute_dft_c2r + + subroutine fftw_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftw_execute_split_dft_r2c') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: in + real(C_DOUBLE), dimension(*), intent(out) :: ro + real(C_DOUBLE), dimension(*), intent(out) :: io + end subroutine fftw_execute_split_dft_r2c + + subroutine fftw_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftw_execute_split_dft_c2r') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: ri + real(C_DOUBLE), dimension(*), intent(inout) :: ii + real(C_DOUBLE), dimension(*), intent(out) :: out + end subroutine fftw_execute_split_dft_c2r + + type(C_PTR) function fftw_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) & + bind(C, name='fftw_plan_many_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_DOUBLE), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + real(C_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 fftw_plan_many_r2r + + type(C_PTR) function fftw_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftw_plan_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftw_plan_r2r + + type(C_PTR) function fftw_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftw_plan_r2r_1d') + import + integer(C_INT), value :: n + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), value :: kind + integer(C_INT), value :: flags + end function fftw_plan_r2r_1d + + type(C_PTR) function fftw_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftw_plan_r2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_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 fftw_plan_r2r_2d + + type(C_PTR) function fftw_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftw_plan_r2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_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 fftw_plan_r2r_3d + + type(C_PTR) function fftw_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftw_plan_guru_r2r') + import + integer(C_INT), value :: rank + type(fftw_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftw_plan_guru_r2r + + type(C_PTR) function fftw_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftw_plan_guru64_r2r') + import + integer(C_INT), value :: rank + type(fftw_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftw_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_DOUBLE), dimension(*), intent(out) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftw_plan_guru64_r2r + + subroutine fftw_execute_r2r(p,in,out) bind(C, name='fftw_execute_r2r') + import + type(C_PTR), value :: p + real(C_DOUBLE), dimension(*), intent(inout) :: in + real(C_DOUBLE), dimension(*), intent(out) :: out + end subroutine fftw_execute_r2r + + subroutine fftw_destroy_plan(p) bind(C, name='fftw_destroy_plan') + import + type(C_PTR), value :: p + end subroutine fftw_destroy_plan + + subroutine fftw_forget_wisdom() bind(C, name='fftw_forget_wisdom') + import + end subroutine fftw_forget_wisdom + + subroutine fftw_cleanup() bind(C, name='fftw_cleanup') + import + end subroutine fftw_cleanup + + subroutine fftw_set_timelimit(t) bind(C, name='fftw_set_timelimit') + import + real(C_DOUBLE), value :: t + end subroutine fftw_set_timelimit + + subroutine fftw_plan_with_nthreads(nthreads) bind(C, name='fftw_plan_with_nthreads') + import + integer(C_INT), value :: nthreads + end subroutine fftw_plan_with_nthreads + + integer(C_INT) function fftw_init_threads() bind(C, name='fftw_init_threads') + import + end function fftw_init_threads + + subroutine fftw_cleanup_threads() bind(C, name='fftw_cleanup_threads') + import + end subroutine fftw_cleanup_threads + + subroutine fftw_make_planner_thread_safe() bind(C, name='fftw_make_planner_thread_safe') + import + end subroutine fftw_make_planner_thread_safe + + integer(C_INT) function fftw_export_wisdom_to_filename(filename) bind(C, name='fftw_export_wisdom_to_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftw_export_wisdom_to_filename + + subroutine fftw_export_wisdom_to_file(output_file) bind(C, name='fftw_export_wisdom_to_file') + import + type(C_PTR), value :: output_file + end subroutine fftw_export_wisdom_to_file + + type(C_PTR) function fftw_export_wisdom_to_string() bind(C, name='fftw_export_wisdom_to_string') + import + end function fftw_export_wisdom_to_string + + subroutine fftw_export_wisdom(write_char,data) bind(C, name='fftw_export_wisdom') + import + type(C_FUNPTR), value :: write_char + type(C_PTR), value :: data + end subroutine fftw_export_wisdom + + integer(C_INT) function fftw_import_system_wisdom() bind(C, name='fftw_import_system_wisdom') + import + end function fftw_import_system_wisdom + + integer(C_INT) function fftw_import_wisdom_from_filename(filename) bind(C, name='fftw_import_wisdom_from_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftw_import_wisdom_from_filename + + integer(C_INT) function fftw_import_wisdom_from_file(input_file) bind(C, name='fftw_import_wisdom_from_file') + import + type(C_PTR), value :: input_file + end function fftw_import_wisdom_from_file + + integer(C_INT) function fftw_import_wisdom_from_string(input_string) bind(C, name='fftw_import_wisdom_from_string') + import + character(C_CHAR), dimension(*), intent(in) :: input_string + end function fftw_import_wisdom_from_string + + integer(C_INT) function fftw_import_wisdom(read_char,data) bind(C, name='fftw_import_wisdom') + import + type(C_FUNPTR), value :: read_char + type(C_PTR), value :: data + end function fftw_import_wisdom + + subroutine fftw_fprint_plan(p,output_file) bind(C, name='fftw_fprint_plan') + import + type(C_PTR), value :: p + type(C_PTR), value :: output_file + end subroutine fftw_fprint_plan + + subroutine fftw_print_plan(p) bind(C, name='fftw_print_plan') + import + type(C_PTR), value :: p + end subroutine fftw_print_plan + + type(C_PTR) function fftw_sprint_plan(p) bind(C, name='fftw_sprint_plan') + import + type(C_PTR), value :: p + end function fftw_sprint_plan + + type(C_PTR) function fftw_malloc(n) bind(C, name='fftw_malloc') + import + integer(C_SIZE_T), value :: n + end function fftw_malloc + + type(C_PTR) function fftw_alloc_real(n) bind(C, name='fftw_alloc_real') + import + integer(C_SIZE_T), value :: n + end function fftw_alloc_real + + type(C_PTR) function fftw_alloc_complex(n) bind(C, name='fftw_alloc_complex') + import + integer(C_SIZE_T), value :: n + end function fftw_alloc_complex + + subroutine fftw_free(p) bind(C, name='fftw_free') + import + type(C_PTR), value :: p + end subroutine fftw_free + + subroutine fftw_flops(p,add,mul,fmas) bind(C, name='fftw_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 fftw_flops + + real(C_DOUBLE) function fftw_estimate_cost(p) bind(C, name='fftw_estimate_cost') + import + type(C_PTR), value :: p + end function fftw_estimate_cost + + real(C_DOUBLE) function fftw_cost(p) bind(C, name='fftw_cost') + import + type(C_PTR), value :: p + end function fftw_cost + + integer(C_INT) function fftw_alignment_of(p) bind(C, name='fftw_alignment_of') + import + real(C_DOUBLE), dimension(*), intent(out) :: p + end function fftw_alignment_of + + end interface + + type, bind(C) :: fftwf_iodim + integer(C_INT) n, is, os + end type fftwf_iodim + type, bind(C) :: fftwf_iodim64 + integer(C_INTPTR_T) n, is, os + end type fftwf_iodim64 + + interface + type(C_PTR) function fftwf_plan_dft(rank,n,in,out,sign,flags) bind(C, name='fftwf_plan_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft + + type(C_PTR) function fftwf_plan_dft_1d(n,in,out,sign,flags) bind(C, name='fftwf_plan_dft_1d') + import + integer(C_INT), value :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft_1d + + type(C_PTR) function fftwf_plan_dft_2d(n0,n1,in,out,sign,flags) bind(C, name='fftwf_plan_dft_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft_2d + + type(C_PTR) function fftwf_plan_dft_3d(n0,n1,n2,in,out,sign,flags) bind(C, name='fftwf_plan_dft_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_dft_3d + + type(C_PTR) function fftwf_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags) & + bind(C, name='fftwf_plan_many_dft') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + complex(C_FLOAT_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 fftwf_plan_many_dft + + type(C_PTR) function fftwf_plan_guru_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftwf_plan_guru_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_guru_dft + + type(C_PTR) function fftwf_plan_guru_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftwf_plan_guru_split_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru_split_dft + + type(C_PTR) function fftwf_plan_guru64_dft(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & + bind(C, name='fftwf_plan_guru64_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: sign + integer(C_INT), value :: flags + end function fftwf_plan_guru64_dft + + type(C_PTR) function fftwf_plan_guru64_split_dft(rank,dims,howmany_rank,howmany_dims,ri,ii,ro,io,flags) & + bind(C, name='fftwf_plan_guru64_split_dft') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru64_split_dft + + subroutine fftwf_execute_dft(p,in,out) bind(C, name='fftwf_execute_dft') + import + type(C_PTR), value :: p + complex(C_FLOAT_COMPLEX), dimension(*), intent(inout) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftwf_execute_dft + + subroutine fftwf_execute_split_dft(p,ri,ii,ro,io) bind(C, name='fftwf_execute_split_dft') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: ri + real(C_FLOAT), dimension(*), intent(inout) :: ii + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + end subroutine fftwf_execute_split_dft + + type(C_PTR) function fftwf_plan_many_dft_r2c(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftwf_plan_many_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_FLOAT), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + complex(C_FLOAT_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 fftwf_plan_many_dft_r2c + + type(C_PTR) function fftwf_plan_dft_r2c(rank,n,in,out,flags) bind(C, name='fftwf_plan_dft_r2c') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c + + type(C_PTR) function fftwf_plan_dft_r2c_1d(n,in,out,flags) bind(C, name='fftwf_plan_dft_r2c_1d') + import + integer(C_INT), value :: n + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c_1d + + type(C_PTR) function fftwf_plan_dft_r2c_2d(n0,n1,in,out,flags) bind(C, name='fftwf_plan_dft_r2c_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c_2d + + type(C_PTR) function fftwf_plan_dft_r2c_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwf_plan_dft_r2c_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_r2c_3d + + type(C_PTR) function fftwf_plan_many_dft_c2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,flags) & + bind(C, name='fftwf_plan_many_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + real(C_FLOAT), 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 fftwf_plan_many_dft_c2r + + type(C_PTR) function fftwf_plan_dft_c2r(rank,n,in,out,flags) bind(C, name='fftwf_plan_dft_c2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r + + type(C_PTR) function fftwf_plan_dft_c2r_1d(n,in,out,flags) bind(C, name='fftwf_plan_dft_c2r_1d') + import + integer(C_INT), value :: n + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r_1d + + type(C_PTR) function fftwf_plan_dft_c2r_2d(n0,n1,in,out,flags) bind(C, name='fftwf_plan_dft_c2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r_2d + + type(C_PTR) function fftwf_plan_dft_c2r_3d(n0,n1,n2,in,out,flags) bind(C, name='fftwf_plan_dft_c2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_dft_c2r_3d + + type(C_PTR) function fftwf_plan_guru_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru_dft_r2c + + type(C_PTR) function fftwf_plan_guru_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru_dft_c2r + + type(C_PTR) function fftwf_plan_guru_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftwf_plan_guru_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru_split_dft_r2c + + type(C_PTR) function fftwf_plan_guru_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftwf_plan_guru_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru_split_dft_c2r + + type(C_PTR) function fftwf_plan_guru64_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru64_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru64_dft_r2c + + type(C_PTR) function fftwf_plan_guru64_dft_c2r(rank,dims,howmany_rank,howmany_dims,in,out,flags) & + bind(C, name='fftwf_plan_guru64_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru64_dft_c2r + + type(C_PTR) function fftwf_plan_guru64_split_dft_r2c(rank,dims,howmany_rank,howmany_dims,in,ro,io,flags) & + bind(C, name='fftwf_plan_guru64_split_dft_r2c') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + integer(C_INT), value :: flags + end function fftwf_plan_guru64_split_dft_r2c + + type(C_PTR) function fftwf_plan_guru64_split_dft_c2r(rank,dims,howmany_rank,howmany_dims,ri,ii,out,flags) & + bind(C, name='fftwf_plan_guru64_split_dft_c2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: ri + real(C_FLOAT), dimension(*), intent(out) :: ii + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_INT), value :: flags + end function fftwf_plan_guru64_split_dft_c2r + + subroutine fftwf_execute_dft_r2c(p,in,out) bind(C, name='fftwf_execute_dft_r2c') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: in + complex(C_FLOAT_COMPLEX), dimension(*), intent(out) :: out + end subroutine fftwf_execute_dft_r2c + + subroutine fftwf_execute_dft_c2r(p,in,out) bind(C, name='fftwf_execute_dft_c2r') + import + type(C_PTR), value :: p + complex(C_FLOAT_COMPLEX), dimension(*), intent(inout) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + end subroutine fftwf_execute_dft_c2r + + subroutine fftwf_execute_split_dft_r2c(p,in,ro,io) bind(C, name='fftwf_execute_split_dft_r2c') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: in + real(C_FLOAT), dimension(*), intent(out) :: ro + real(C_FLOAT), dimension(*), intent(out) :: io + end subroutine fftwf_execute_split_dft_r2c + + subroutine fftwf_execute_split_dft_c2r(p,ri,ii,out) bind(C, name='fftwf_execute_split_dft_c2r') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: ri + real(C_FLOAT), dimension(*), intent(inout) :: ii + real(C_FLOAT), dimension(*), intent(out) :: out + end subroutine fftwf_execute_split_dft_c2r + + type(C_PTR) function fftwf_plan_many_r2r(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,kind,flags) & + bind(C, name='fftwf_plan_many_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + integer(C_INT), value :: howmany + real(C_FLOAT), dimension(*), intent(out) :: in + integer(C_INT), dimension(*), intent(in) :: inembed + integer(C_INT), value :: istride + integer(C_INT), value :: idist + real(C_FLOAT), 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 fftwf_plan_many_r2r + + type(C_PTR) function fftwf_plan_r2r(rank,n,in,out,kind,flags) bind(C, name='fftwf_plan_r2r') + import + integer(C_INT), value :: rank + integer(C_INT), dimension(*), intent(in) :: n + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftwf_plan_r2r + + type(C_PTR) function fftwf_plan_r2r_1d(n,in,out,kind,flags) bind(C, name='fftwf_plan_r2r_1d') + import + integer(C_INT), value :: n + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), value :: kind + integer(C_INT), value :: flags + end function fftwf_plan_r2r_1d + + type(C_PTR) function fftwf_plan_r2r_2d(n0,n1,in,out,kind0,kind1,flags) bind(C, name='fftwf_plan_r2r_2d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), 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 fftwf_plan_r2r_2d + + type(C_PTR) function fftwf_plan_r2r_3d(n0,n1,n2,in,out,kind0,kind1,kind2,flags) bind(C, name='fftwf_plan_r2r_3d') + import + integer(C_INT), value :: n0 + integer(C_INT), value :: n1 + integer(C_INT), value :: n2 + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), 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 fftwf_plan_r2r_3d + + type(C_PTR) function fftwf_plan_guru_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftwf_plan_guru_r2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftwf_plan_guru_r2r + + type(C_PTR) function fftwf_plan_guru64_r2r(rank,dims,howmany_rank,howmany_dims,in,out,kind,flags) & + bind(C, name='fftwf_plan_guru64_r2r') + import + integer(C_INT), value :: rank + type(fftwf_iodim64), dimension(*), intent(in) :: dims + integer(C_INT), value :: howmany_rank + type(fftwf_iodim64), dimension(*), intent(in) :: howmany_dims + real(C_FLOAT), dimension(*), intent(out) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + integer(C_FFTW_R2R_KIND), dimension(*), intent(in) :: kind + integer(C_INT), value :: flags + end function fftwf_plan_guru64_r2r + + subroutine fftwf_execute_r2r(p,in,out) bind(C, name='fftwf_execute_r2r') + import + type(C_PTR), value :: p + real(C_FLOAT), dimension(*), intent(inout) :: in + real(C_FLOAT), dimension(*), intent(out) :: out + end subroutine fftwf_execute_r2r + + subroutine fftwf_destroy_plan(p) bind(C, name='fftwf_destroy_plan') + import + type(C_PTR), value :: p + end subroutine fftwf_destroy_plan + + subroutine fftwf_forget_wisdom() bind(C, name='fftwf_forget_wisdom') + import + end subroutine fftwf_forget_wisdom + + subroutine fftwf_cleanup() bind(C, name='fftwf_cleanup') + import + end subroutine fftwf_cleanup + + subroutine fftwf_set_timelimit(t) bind(C, name='fftwf_set_timelimit') + import + real(C_DOUBLE), value :: t + end subroutine fftwf_set_timelimit + + subroutine fftwf_plan_with_nthreads(nthreads) bind(C, name='fftwf_plan_with_nthreads') + import + integer(C_INT), value :: nthreads + end subroutine fftwf_plan_with_nthreads + + integer(C_INT) function fftwf_init_threads() bind(C, name='fftwf_init_threads') + import + end function fftwf_init_threads + + subroutine fftwf_cleanup_threads() bind(C, name='fftwf_cleanup_threads') + import + end subroutine fftwf_cleanup_threads + + subroutine fftwf_make_planner_thread_safe() bind(C, name='fftwf_make_planner_thread_safe') + import + end subroutine fftwf_make_planner_thread_safe + + integer(C_INT) function fftwf_export_wisdom_to_filename(filename) bind(C, name='fftwf_export_wisdom_to_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftwf_export_wisdom_to_filename + + subroutine fftwf_export_wisdom_to_file(output_file) bind(C, name='fftwf_export_wisdom_to_file') + import + type(C_PTR), value :: output_file + end subroutine fftwf_export_wisdom_to_file + + type(C_PTR) function fftwf_export_wisdom_to_string() bind(C, name='fftwf_export_wisdom_to_string') + import + end function fftwf_export_wisdom_to_string + + subroutine fftwf_export_wisdom(write_char,data) bind(C, name='fftwf_export_wisdom') + import + type(C_FUNPTR), value :: write_char + type(C_PTR), value :: data + end subroutine fftwf_export_wisdom + + integer(C_INT) function fftwf_import_system_wisdom() bind(C, name='fftwf_import_system_wisdom') + import + end function fftwf_import_system_wisdom + + integer(C_INT) function fftwf_import_wisdom_from_filename(filename) bind(C, name='fftwf_import_wisdom_from_filename') + import + character(C_CHAR), dimension(*), intent(in) :: filename + end function fftwf_import_wisdom_from_filename + + integer(C_INT) function fftwf_import_wisdom_from_file(input_file) bind(C, name='fftwf_import_wisdom_from_file') + import + type(C_PTR), value :: input_file + end function fftwf_import_wisdom_from_file + + integer(C_INT) function fftwf_import_wisdom_from_string(input_string) bind(C, name='fftwf_import_wisdom_from_string') + import + character(C_CHAR), dimension(*), intent(in) :: input_string + end function fftwf_import_wisdom_from_string + + integer(C_INT) function fftwf_import_wisdom(read_char,data) bind(C, name='fftwf_import_wisdom') + import + type(C_FUNPTR), value :: read_char + type(C_PTR), value :: data + end function fftwf_import_wisdom + + subroutine fftwf_fprint_plan(p,output_file) bind(C, name='fftwf_fprint_plan') + import + type(C_PTR), value :: p + type(C_PTR), value :: output_file + end subroutine fftwf_fprint_plan + + subroutine fftwf_print_plan(p) bind(C, name='fftwf_print_plan') + import + type(C_PTR), value :: p + end subroutine fftwf_print_plan + + type(C_PTR) function fftwf_sprint_plan(p) bind(C, name='fftwf_sprint_plan') + import + type(C_PTR), value :: p + end function fftwf_sprint_plan + + type(C_PTR) function fftwf_malloc(n) bind(C, name='fftwf_malloc') + import + integer(C_SIZE_T), value :: n + end function fftwf_malloc + + type(C_PTR) function fftwf_alloc_real(n) bind(C, name='fftwf_alloc_real') + import + integer(C_SIZE_T), value :: n + end function fftwf_alloc_real + + type(C_PTR) function fftwf_alloc_complex(n) bind(C, name='fftwf_alloc_complex') + import + integer(C_SIZE_T), value :: n + end function fftwf_alloc_complex + + subroutine fftwf_free(p) bind(C, name='fftwf_free') + import + type(C_PTR), value :: p + end subroutine fftwf_free + + subroutine fftwf_flops(p,add,mul,fmas) bind(C, name='fftwf_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 fftwf_flops + + real(C_DOUBLE) function fftwf_estimate_cost(p) bind(C, name='fftwf_estimate_cost') + import + type(C_PTR), value :: p + end function fftwf_estimate_cost + + real(C_DOUBLE) function fftwf_cost(p) bind(C, name='fftwf_cost') + import + type(C_PTR), value :: p + end function fftwf_cost + + integer(C_INT) function fftwf_alignment_of(p) bind(C, name='fftwf_alignment_of') + import + real(C_FLOAT), dimension(*), intent(out) :: p + end function fftwf_alignment_of + + end interface diff --git a/Desktop_Interface/build_win/fftw/x86/fftw3.h b/Desktop_Interface/build_win/fftw/x86/fftw3.h new file mode 100644 index 00000000..39661d22 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/fftw3.h @@ -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 + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* If 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 /* 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 */ diff --git a/Desktop_Interface/build_win/fftw/x86/fftw3l.f03 b/Desktop_Interface/build_win/fftw/x86/fftw3l.f03 new file mode 100644 index 00000000..59e7ed27 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/fftw3l.f03 @@ -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 diff --git a/Desktop_Interface/build_win/fftw/x86/fftw3q.f03 b/Desktop_Interface/build_win/fftw/x86/fftw3q.f03 new file mode 100644 index 00000000..61dacd6c --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/fftw3q.f03 @@ -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 diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3-3.def b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.def new file mode 100644 index 00000000..4b50ecd4 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.def @@ -0,0 +1,1017 @@ +LIBRARY libfftw3-3.dll +EXPORTS +dfftw_cleanup_ +dfftw_cleanup__ +dfftw_cleanup_threads_ +dfftw_cleanup_threads__ +dfftw_cost_ +dfftw_cost__ +dfftw_destroy_plan_ +dfftw_destroy_plan__ +dfftw_estimate_cost_ +dfftw_estimate_cost__ +dfftw_execute_ +dfftw_execute__ +dfftw_execute_dft_ +dfftw_execute_dft__ +dfftw_execute_dft_c2r_ +dfftw_execute_dft_c2r__ +dfftw_execute_dft_r2c_ +dfftw_execute_dft_r2c__ +dfftw_execute_r2r_ +dfftw_execute_r2r__ +dfftw_execute_split_dft_ +dfftw_execute_split_dft__ +dfftw_execute_split_dft_c2r_ +dfftw_execute_split_dft_c2r__ +dfftw_execute_split_dft_r2c_ +dfftw_execute_split_dft_r2c__ +dfftw_export_wisdom_ +dfftw_export_wisdom__ +dfftw_flops_ +dfftw_flops__ +dfftw_forget_wisdom_ +dfftw_forget_wisdom__ +dfftw_import_system_wisdom_ +dfftw_import_system_wisdom__ +dfftw_import_wisdom_ +dfftw_import_wisdom__ +dfftw_init_threads_ +dfftw_init_threads__ +dfftw_plan_dft_ +dfftw_plan_dft__ +dfftw_plan_dft_1d_ +dfftw_plan_dft_1d__ +dfftw_plan_dft_2d_ +dfftw_plan_dft_2d__ +dfftw_plan_dft_3d_ +dfftw_plan_dft_3d__ +dfftw_plan_dft_c2r_ +dfftw_plan_dft_c2r__ +dfftw_plan_dft_c2r_1d_ +dfftw_plan_dft_c2r_1d__ +dfftw_plan_dft_c2r_2d_ +dfftw_plan_dft_c2r_2d__ +dfftw_plan_dft_c2r_3d_ +dfftw_plan_dft_c2r_3d__ +dfftw_plan_dft_r2c_ +dfftw_plan_dft_r2c__ +dfftw_plan_dft_r2c_1d_ +dfftw_plan_dft_r2c_1d__ +dfftw_plan_dft_r2c_2d_ +dfftw_plan_dft_r2c_2d__ +dfftw_plan_dft_r2c_3d_ +dfftw_plan_dft_r2c_3d__ +dfftw_plan_guru_dft_ +dfftw_plan_guru_dft__ +dfftw_plan_guru_dft_c2r_ +dfftw_plan_guru_dft_c2r__ +dfftw_plan_guru_dft_r2c_ +dfftw_plan_guru_dft_r2c__ +dfftw_plan_guru_r2r_ +dfftw_plan_guru_r2r__ +dfftw_plan_guru_split_dft_ +dfftw_plan_guru_split_dft__ +dfftw_plan_guru_split_dft_c2r_ +dfftw_plan_guru_split_dft_c2r__ +dfftw_plan_guru_split_dft_r2c_ +dfftw_plan_guru_split_dft_r2c__ +dfftw_plan_many_dft_ +dfftw_plan_many_dft__ +dfftw_plan_many_dft_c2r_ +dfftw_plan_many_dft_c2r__ +dfftw_plan_many_dft_r2c_ +dfftw_plan_many_dft_r2c__ +dfftw_plan_many_r2r_ +dfftw_plan_many_r2r__ +dfftw_plan_r2r_ +dfftw_plan_r2r__ +dfftw_plan_r2r_1d_ +dfftw_plan_r2r_1d__ +dfftw_plan_r2r_2d_ +dfftw_plan_r2r_2d__ +dfftw_plan_r2r_3d_ +dfftw_plan_r2r_3d__ +dfftw_plan_with_nthreads_ +dfftw_plan_with_nthreads__ +dfftw_print_plan_ +dfftw_print_plan__ +dfftw_set_timelimit_ +dfftw_set_timelimit__ +fftw_alignment_of +fftw_alloc_complex +fftw_alloc_real +fftw_assertion_failed +fftw_bufdist +fftw_check_alignment_of_sse2_pm +fftw_choose_radix +fftw_cleanup +fftw_cleanup_threads +fftw_codelet_e01_8 +fftw_codelet_e10_8 +fftw_codelet_hb_10 +fftw_codelet_hb_12 +fftw_codelet_hb_15 +fftw_codelet_hb_16 +fftw_codelet_hb_2 +fftw_codelet_hb_20 +fftw_codelet_hb2_16 +fftw_codelet_hb2_20 +fftw_codelet_hb2_25 +fftw_codelet_hb2_32 +fftw_codelet_hb2_4 +fftw_codelet_hb_25 +fftw_codelet_hb2_5 +fftw_codelet_hb2_8 +fftw_codelet_hb_3 +fftw_codelet_hb_32 +fftw_codelet_hb_4 +fftw_codelet_hb_5 +fftw_codelet_hb_6 +fftw_codelet_hb_64 +fftw_codelet_hb_7 +fftw_codelet_hb_8 +fftw_codelet_hb_9 +fftw_codelet_hc2cb_10 +fftw_codelet_hc2cb_12 +fftw_codelet_hc2cb_16 +fftw_codelet_hc2cb_2 +fftw_codelet_hc2cb_20 +fftw_codelet_hc2cb2_16 +fftw_codelet_hc2cb2_20 +fftw_codelet_hc2cb2_32 +fftw_codelet_hc2cb2_4 +fftw_codelet_hc2cb2_8 +fftw_codelet_hc2cb_32 +fftw_codelet_hc2cb_4 +fftw_codelet_hc2cb_6 +fftw_codelet_hc2cb_8 +fftw_codelet_hc2cbdft_10 +fftw_codelet_hc2cbdft_12 +fftw_codelet_hc2cbdft_16 +fftw_codelet_hc2cbdft_2 +fftw_codelet_hc2cbdft_20 +fftw_codelet_hc2cbdft2_16 +fftw_codelet_hc2cbdft2_20 +fftw_codelet_hc2cbdft2_32 +fftw_codelet_hc2cbdft2_4 +fftw_codelet_hc2cbdft2_8 +fftw_codelet_hc2cbdft_32 +fftw_codelet_hc2cbdft_4 +fftw_codelet_hc2cbdft_6 +fftw_codelet_hc2cbdft_8 +fftw_codelet_hc2cbdftv_10_avx +fftw_codelet_hc2cbdftv_10_sse2 +fftw_codelet_hc2cbdftv_12_avx +fftw_codelet_hc2cbdftv_12_sse2 +fftw_codelet_hc2cbdftv_16_avx +fftw_codelet_hc2cbdftv_16_sse2 +fftw_codelet_hc2cbdftv_20_avx +fftw_codelet_hc2cbdftv_20_sse2 +fftw_codelet_hc2cbdftv_2_avx +fftw_codelet_hc2cbdftv_2_sse2 +fftw_codelet_hc2cbdftv_32_avx +fftw_codelet_hc2cbdftv_32_sse2 +fftw_codelet_hc2cbdftv_4_avx +fftw_codelet_hc2cbdftv_4_sse2 +fftw_codelet_hc2cbdftv_6_avx +fftw_codelet_hc2cbdftv_6_sse2 +fftw_codelet_hc2cbdftv_8_avx +fftw_codelet_hc2cbdftv_8_sse2 +fftw_codelet_hc2cf_10 +fftw_codelet_hc2cf_12 +fftw_codelet_hc2cf_16 +fftw_codelet_hc2cf_2 +fftw_codelet_hc2cf_20 +fftw_codelet_hc2cf2_16 +fftw_codelet_hc2cf2_20 +fftw_codelet_hc2cf2_32 +fftw_codelet_hc2cf2_4 +fftw_codelet_hc2cf2_8 +fftw_codelet_hc2cf_32 +fftw_codelet_hc2cf_4 +fftw_codelet_hc2cf_6 +fftw_codelet_hc2cf_8 +fftw_codelet_hc2cfdft_10 +fftw_codelet_hc2cfdft_12 +fftw_codelet_hc2cfdft_16 +fftw_codelet_hc2cfdft_2 +fftw_codelet_hc2cfdft_20 +fftw_codelet_hc2cfdft2_16 +fftw_codelet_hc2cfdft2_20 +fftw_codelet_hc2cfdft2_32 +fftw_codelet_hc2cfdft2_4 +fftw_codelet_hc2cfdft2_8 +fftw_codelet_hc2cfdft_32 +fftw_codelet_hc2cfdft_4 +fftw_codelet_hc2cfdft_6 +fftw_codelet_hc2cfdft_8 +fftw_codelet_hc2cfdftv_10_avx +fftw_codelet_hc2cfdftv_10_sse2 +fftw_codelet_hc2cfdftv_12_avx +fftw_codelet_hc2cfdftv_12_sse2 +fftw_codelet_hc2cfdftv_16_avx +fftw_codelet_hc2cfdftv_16_sse2 +fftw_codelet_hc2cfdftv_20_avx +fftw_codelet_hc2cfdftv_20_sse2 +fftw_codelet_hc2cfdftv_2_avx +fftw_codelet_hc2cfdftv_2_sse2 +fftw_codelet_hc2cfdftv_32_avx +fftw_codelet_hc2cfdftv_32_sse2 +fftw_codelet_hc2cfdftv_4_avx +fftw_codelet_hc2cfdftv_4_sse2 +fftw_codelet_hc2cfdftv_6_avx +fftw_codelet_hc2cfdftv_6_sse2 +fftw_codelet_hc2cfdftv_8_avx +fftw_codelet_hc2cfdftv_8_sse2 +fftw_codelet_hf_10 +fftw_codelet_hf_12 +fftw_codelet_hf_15 +fftw_codelet_hf_16 +fftw_codelet_hf_2 +fftw_codelet_hf_20 +fftw_codelet_hf2_16 +fftw_codelet_hf2_20 +fftw_codelet_hf2_25 +fftw_codelet_hf2_32 +fftw_codelet_hf2_4 +fftw_codelet_hf_25 +fftw_codelet_hf2_5 +fftw_codelet_hf2_8 +fftw_codelet_hf_3 +fftw_codelet_hf_32 +fftw_codelet_hf_4 +fftw_codelet_hf_5 +fftw_codelet_hf_6 +fftw_codelet_hf_64 +fftw_codelet_hf_7 +fftw_codelet_hf_8 +fftw_codelet_hf_9 +fftw_codelet_n1_10 +fftw_codelet_n1_11 +fftw_codelet_n1_12 +fftw_codelet_n1_13 +fftw_codelet_n1_14 +fftw_codelet_n1_15 +fftw_codelet_n1_16 +fftw_codelet_n1_2 +fftw_codelet_n1_20 +fftw_codelet_n1_25 +fftw_codelet_n1_3 +fftw_codelet_n1_32 +fftw_codelet_n1_4 +fftw_codelet_n1_5 +fftw_codelet_n1_6 +fftw_codelet_n1_64 +fftw_codelet_n1_7 +fftw_codelet_n1_8 +fftw_codelet_n1_9 +fftw_codelet_n1bv_10_avx +fftw_codelet_n1bv_10_sse2 +fftw_codelet_n1bv_11_avx +fftw_codelet_n1bv_11_sse2 +fftw_codelet_n1bv_128_avx +fftw_codelet_n1bv_128_sse2 +fftw_codelet_n1bv_12_avx +fftw_codelet_n1bv_12_sse2 +fftw_codelet_n1bv_13_avx +fftw_codelet_n1bv_13_sse2 +fftw_codelet_n1bv_14_avx +fftw_codelet_n1bv_14_sse2 +fftw_codelet_n1bv_15_avx +fftw_codelet_n1bv_15_sse2 +fftw_codelet_n1bv_16_avx +fftw_codelet_n1bv_16_sse2 +fftw_codelet_n1bv_20_avx +fftw_codelet_n1bv_20_sse2 +fftw_codelet_n1bv_25_avx +fftw_codelet_n1bv_25_sse2 +fftw_codelet_n1bv_2_avx +fftw_codelet_n1bv_2_sse2 +fftw_codelet_n1bv_32_avx +fftw_codelet_n1bv_32_sse2 +fftw_codelet_n1bv_3_avx +fftw_codelet_n1bv_3_sse2 +fftw_codelet_n1bv_4_avx +fftw_codelet_n1bv_4_sse2 +fftw_codelet_n1bv_5_avx +fftw_codelet_n1bv_5_sse2 +fftw_codelet_n1bv_64_avx +fftw_codelet_n1bv_64_sse2 +fftw_codelet_n1bv_6_avx +fftw_codelet_n1bv_6_sse2 +fftw_codelet_n1bv_7_avx +fftw_codelet_n1bv_7_sse2 +fftw_codelet_n1bv_8_avx +fftw_codelet_n1bv_8_sse2 +fftw_codelet_n1bv_9_avx +fftw_codelet_n1bv_9_sse2 +fftw_codelet_n1fv_10_avx +fftw_codelet_n1fv_10_sse2 +fftw_codelet_n1fv_11_avx +fftw_codelet_n1fv_11_sse2 +fftw_codelet_n1fv_128_avx +fftw_codelet_n1fv_128_sse2 +fftw_codelet_n1fv_12_avx +fftw_codelet_n1fv_12_sse2 +fftw_codelet_n1fv_13_avx +fftw_codelet_n1fv_13_sse2 +fftw_codelet_n1fv_14_avx +fftw_codelet_n1fv_14_sse2 +fftw_codelet_n1fv_15_avx +fftw_codelet_n1fv_15_sse2 +fftw_codelet_n1fv_16_avx +fftw_codelet_n1fv_16_sse2 +fftw_codelet_n1fv_20_avx +fftw_codelet_n1fv_20_sse2 +fftw_codelet_n1fv_25_avx +fftw_codelet_n1fv_25_sse2 +fftw_codelet_n1fv_2_avx +fftw_codelet_n1fv_2_sse2 +fftw_codelet_n1fv_32_avx +fftw_codelet_n1fv_32_sse2 +fftw_codelet_n1fv_3_avx +fftw_codelet_n1fv_3_sse2 +fftw_codelet_n1fv_4_avx +fftw_codelet_n1fv_4_sse2 +fftw_codelet_n1fv_5_avx +fftw_codelet_n1fv_5_sse2 +fftw_codelet_n1fv_64_avx +fftw_codelet_n1fv_64_sse2 +fftw_codelet_n1fv_6_avx +fftw_codelet_n1fv_6_sse2 +fftw_codelet_n1fv_7_avx +fftw_codelet_n1fv_7_sse2 +fftw_codelet_n1fv_8_avx +fftw_codelet_n1fv_8_sse2 +fftw_codelet_n1fv_9_avx +fftw_codelet_n1fv_9_sse2 +fftw_codelet_n2bv_10_avx +fftw_codelet_n2bv_10_sse2 +fftw_codelet_n2bv_12_avx +fftw_codelet_n2bv_12_sse2 +fftw_codelet_n2bv_14_avx +fftw_codelet_n2bv_14_sse2 +fftw_codelet_n2bv_16_avx +fftw_codelet_n2bv_16_sse2 +fftw_codelet_n2bv_20_avx +fftw_codelet_n2bv_20_sse2 +fftw_codelet_n2bv_2_avx +fftw_codelet_n2bv_2_sse2 +fftw_codelet_n2bv_32_avx +fftw_codelet_n2bv_32_sse2 +fftw_codelet_n2bv_4_avx +fftw_codelet_n2bv_4_sse2 +fftw_codelet_n2bv_64_avx +fftw_codelet_n2bv_64_sse2 +fftw_codelet_n2bv_6_avx +fftw_codelet_n2bv_6_sse2 +fftw_codelet_n2bv_8_avx +fftw_codelet_n2bv_8_sse2 +fftw_codelet_n2fv_10_avx +fftw_codelet_n2fv_10_sse2 +fftw_codelet_n2fv_12_avx +fftw_codelet_n2fv_12_sse2 +fftw_codelet_n2fv_14_avx +fftw_codelet_n2fv_14_sse2 +fftw_codelet_n2fv_16_avx +fftw_codelet_n2fv_16_sse2 +fftw_codelet_n2fv_20_avx +fftw_codelet_n2fv_20_sse2 +fftw_codelet_n2fv_2_avx +fftw_codelet_n2fv_2_sse2 +fftw_codelet_n2fv_32_avx +fftw_codelet_n2fv_32_sse2 +fftw_codelet_n2fv_4_avx +fftw_codelet_n2fv_4_sse2 +fftw_codelet_n2fv_64_avx +fftw_codelet_n2fv_64_sse2 +fftw_codelet_n2fv_6_avx +fftw_codelet_n2fv_6_sse2 +fftw_codelet_n2fv_8_avx +fftw_codelet_n2fv_8_sse2 +fftw_codelet_n2sv_16_avx +fftw_codelet_n2sv_16_sse2 +fftw_codelet_n2sv_32_avx +fftw_codelet_n2sv_32_sse2 +fftw_codelet_n2sv_4_avx +fftw_codelet_n2sv_4_sse2 +fftw_codelet_n2sv_64_avx +fftw_codelet_n2sv_64_sse2 +fftw_codelet_n2sv_8_avx +fftw_codelet_n2sv_8_sse2 +fftw_codelet_q1_2 +fftw_codelet_q1_3 +fftw_codelet_q1_4 +fftw_codelet_q1_5 +fftw_codelet_q1_6 +fftw_codelet_q1_8 +fftw_codelet_q1bv_2_avx +fftw_codelet_q1bv_2_sse2 +fftw_codelet_q1bv_4_avx +fftw_codelet_q1bv_4_sse2 +fftw_codelet_q1bv_5_avx +fftw_codelet_q1bv_5_sse2 +fftw_codelet_q1bv_8_avx +fftw_codelet_q1bv_8_sse2 +fftw_codelet_q1fv_2_avx +fftw_codelet_q1fv_2_sse2 +fftw_codelet_q1fv_4_avx +fftw_codelet_q1fv_4_sse2 +fftw_codelet_q1fv_5_avx +fftw_codelet_q1fv_5_sse2 +fftw_codelet_q1fv_8_avx +fftw_codelet_q1fv_8_sse2 +fftw_codelet_r2cb_10 +fftw_codelet_r2cb_11 +fftw_codelet_r2cb_12 +fftw_codelet_r2cb_128 +fftw_codelet_r2cb_13 +fftw_codelet_r2cb_14 +fftw_codelet_r2cb_15 +fftw_codelet_r2cb_16 +fftw_codelet_r2cb_2 +fftw_codelet_r2cb_20 +fftw_codelet_r2cb_25 +fftw_codelet_r2cb_3 +fftw_codelet_r2cb_32 +fftw_codelet_r2cb_4 +fftw_codelet_r2cb_5 +fftw_codelet_r2cb_6 +fftw_codelet_r2cb_64 +fftw_codelet_r2cb_7 +fftw_codelet_r2cb_8 +fftw_codelet_r2cb_9 +fftw_codelet_r2cbIII_10 +fftw_codelet_r2cbIII_12 +fftw_codelet_r2cbIII_15 +fftw_codelet_r2cbIII_16 +fftw_codelet_r2cbIII_2 +fftw_codelet_r2cbIII_20 +fftw_codelet_r2cbIII_25 +fftw_codelet_r2cbIII_3 +fftw_codelet_r2cbIII_32 +fftw_codelet_r2cbIII_4 +fftw_codelet_r2cbIII_5 +fftw_codelet_r2cbIII_6 +fftw_codelet_r2cbIII_64 +fftw_codelet_r2cbIII_7 +fftw_codelet_r2cbIII_8 +fftw_codelet_r2cbIII_9 +fftw_codelet_r2cf_10 +fftw_codelet_r2cf_11 +fftw_codelet_r2cf_12 +fftw_codelet_r2cf_128 +fftw_codelet_r2cf_13 +fftw_codelet_r2cf_14 +fftw_codelet_r2cf_15 +fftw_codelet_r2cf_16 +fftw_codelet_r2cf_2 +fftw_codelet_r2cf_20 +fftw_codelet_r2cf_25 +fftw_codelet_r2cf_3 +fftw_codelet_r2cf_32 +fftw_codelet_r2cf_4 +fftw_codelet_r2cf_5 +fftw_codelet_r2cf_6 +fftw_codelet_r2cf_64 +fftw_codelet_r2cf_7 +fftw_codelet_r2cf_8 +fftw_codelet_r2cf_9 +fftw_codelet_r2cfII_10 +fftw_codelet_r2cfII_12 +fftw_codelet_r2cfII_15 +fftw_codelet_r2cfII_16 +fftw_codelet_r2cfII_2 +fftw_codelet_r2cfII_20 +fftw_codelet_r2cfII_25 +fftw_codelet_r2cfII_3 +fftw_codelet_r2cfII_32 +fftw_codelet_r2cfII_4 +fftw_codelet_r2cfII_5 +fftw_codelet_r2cfII_6 +fftw_codelet_r2cfII_64 +fftw_codelet_r2cfII_7 +fftw_codelet_r2cfII_8 +fftw_codelet_r2cfII_9 +fftw_codelet_t1_10 +fftw_codelet_t1_12 +fftw_codelet_t1_15 +fftw_codelet_t1_16 +fftw_codelet_t1_2 +fftw_codelet_t1_20 +fftw_codelet_t1_25 +fftw_codelet_t1_3 +fftw_codelet_t1_32 +fftw_codelet_t1_4 +fftw_codelet_t1_5 +fftw_codelet_t1_6 +fftw_codelet_t1_64 +fftw_codelet_t1_7 +fftw_codelet_t1_8 +fftw_codelet_t1_9 +fftw_codelet_t1buv_10_avx +fftw_codelet_t1buv_10_sse2 +fftw_codelet_t1buv_2_avx +fftw_codelet_t1buv_2_sse2 +fftw_codelet_t1buv_3_avx +fftw_codelet_t1buv_3_sse2 +fftw_codelet_t1buv_4_avx +fftw_codelet_t1buv_4_sse2 +fftw_codelet_t1buv_5_avx +fftw_codelet_t1buv_5_sse2 +fftw_codelet_t1buv_6_avx +fftw_codelet_t1buv_6_sse2 +fftw_codelet_t1buv_7_avx +fftw_codelet_t1buv_7_sse2 +fftw_codelet_t1buv_8_avx +fftw_codelet_t1buv_8_sse2 +fftw_codelet_t1buv_9_avx +fftw_codelet_t1buv_9_sse2 +fftw_codelet_t1bv_10_avx +fftw_codelet_t1bv_10_sse2 +fftw_codelet_t1bv_12_avx +fftw_codelet_t1bv_12_sse2 +fftw_codelet_t1bv_15_avx +fftw_codelet_t1bv_15_sse2 +fftw_codelet_t1bv_16_avx +fftw_codelet_t1bv_16_sse2 +fftw_codelet_t1bv_20_avx +fftw_codelet_t1bv_20_sse2 +fftw_codelet_t1bv_25_avx +fftw_codelet_t1bv_25_sse2 +fftw_codelet_t1bv_2_avx +fftw_codelet_t1bv_2_sse2 +fftw_codelet_t1bv_32_avx +fftw_codelet_t1bv_32_sse2 +fftw_codelet_t1bv_3_avx +fftw_codelet_t1bv_3_sse2 +fftw_codelet_t1bv_4_avx +fftw_codelet_t1bv_4_sse2 +fftw_codelet_t1bv_5_avx +fftw_codelet_t1bv_5_sse2 +fftw_codelet_t1bv_64_avx +fftw_codelet_t1bv_64_sse2 +fftw_codelet_t1bv_6_avx +fftw_codelet_t1bv_6_sse2 +fftw_codelet_t1bv_7_avx +fftw_codelet_t1bv_7_sse2 +fftw_codelet_t1bv_8_avx +fftw_codelet_t1bv_8_sse2 +fftw_codelet_t1bv_9_avx +fftw_codelet_t1bv_9_sse2 +fftw_codelet_t1fuv_10_avx +fftw_codelet_t1fuv_10_sse2 +fftw_codelet_t1fuv_2_avx +fftw_codelet_t1fuv_2_sse2 +fftw_codelet_t1fuv_3_avx +fftw_codelet_t1fuv_3_sse2 +fftw_codelet_t1fuv_4_avx +fftw_codelet_t1fuv_4_sse2 +fftw_codelet_t1fuv_5_avx +fftw_codelet_t1fuv_5_sse2 +fftw_codelet_t1fuv_6_avx +fftw_codelet_t1fuv_6_sse2 +fftw_codelet_t1fuv_7_avx +fftw_codelet_t1fuv_7_sse2 +fftw_codelet_t1fuv_8_avx +fftw_codelet_t1fuv_8_sse2 +fftw_codelet_t1fuv_9_avx +fftw_codelet_t1fuv_9_sse2 +fftw_codelet_t1fv_10_avx +fftw_codelet_t1fv_10_sse2 +fftw_codelet_t1fv_12_avx +fftw_codelet_t1fv_12_sse2 +fftw_codelet_t1fv_15_avx +fftw_codelet_t1fv_15_sse2 +fftw_codelet_t1fv_16_avx +fftw_codelet_t1fv_16_sse2 +fftw_codelet_t1fv_20_avx +fftw_codelet_t1fv_20_sse2 +fftw_codelet_t1fv_25_avx +fftw_codelet_t1fv_25_sse2 +fftw_codelet_t1fv_2_avx +fftw_codelet_t1fv_2_sse2 +fftw_codelet_t1fv_32_avx +fftw_codelet_t1fv_32_sse2 +fftw_codelet_t1fv_3_avx +fftw_codelet_t1fv_3_sse2 +fftw_codelet_t1fv_4_avx +fftw_codelet_t1fv_4_sse2 +fftw_codelet_t1fv_5_avx +fftw_codelet_t1fv_5_sse2 +fftw_codelet_t1fv_64_avx +fftw_codelet_t1fv_64_sse2 +fftw_codelet_t1fv_6_avx +fftw_codelet_t1fv_6_sse2 +fftw_codelet_t1fv_7_avx +fftw_codelet_t1fv_7_sse2 +fftw_codelet_t1fv_8_avx +fftw_codelet_t1fv_8_sse2 +fftw_codelet_t1fv_9_avx +fftw_codelet_t1fv_9_sse2 +fftw_codelet_t1sv_16_avx +fftw_codelet_t1sv_16_sse2 +fftw_codelet_t1sv_2_avx +fftw_codelet_t1sv_2_sse2 +fftw_codelet_t1sv_32_avx +fftw_codelet_t1sv_32_sse2 +fftw_codelet_t1sv_4_avx +fftw_codelet_t1sv_4_sse2 +fftw_codelet_t1sv_8_avx +fftw_codelet_t1sv_8_sse2 +fftw_codelet_t2_10 +fftw_codelet_t2_16 +fftw_codelet_t2_20 +fftw_codelet_t2_25 +fftw_codelet_t2_32 +fftw_codelet_t2_4 +fftw_codelet_t2_5 +fftw_codelet_t2_64 +fftw_codelet_t2_8 +fftw_codelet_t2bv_10_avx +fftw_codelet_t2bv_10_sse2 +fftw_codelet_t2bv_16_avx +fftw_codelet_t2bv_16_sse2 +fftw_codelet_t2bv_20_avx +fftw_codelet_t2bv_20_sse2 +fftw_codelet_t2bv_25_avx +fftw_codelet_t2bv_25_sse2 +fftw_codelet_t2bv_2_avx +fftw_codelet_t2bv_2_sse2 +fftw_codelet_t2bv_32_avx +fftw_codelet_t2bv_32_sse2 +fftw_codelet_t2bv_4_avx +fftw_codelet_t2bv_4_sse2 +fftw_codelet_t2bv_5_avx +fftw_codelet_t2bv_5_sse2 +fftw_codelet_t2bv_64_avx +fftw_codelet_t2bv_64_sse2 +fftw_codelet_t2bv_8_avx +fftw_codelet_t2bv_8_sse2 +fftw_codelet_t2fv_10_avx +fftw_codelet_t2fv_10_sse2 +fftw_codelet_t2fv_16_avx +fftw_codelet_t2fv_16_sse2 +fftw_codelet_t2fv_20_avx +fftw_codelet_t2fv_20_sse2 +fftw_codelet_t2fv_25_avx +fftw_codelet_t2fv_25_sse2 +fftw_codelet_t2fv_2_avx +fftw_codelet_t2fv_2_sse2 +fftw_codelet_t2fv_32_avx +fftw_codelet_t2fv_32_sse2 +fftw_codelet_t2fv_4_avx +fftw_codelet_t2fv_4_sse2 +fftw_codelet_t2fv_5_avx +fftw_codelet_t2fv_5_sse2 +fftw_codelet_t2fv_64_avx +fftw_codelet_t2fv_64_sse2 +fftw_codelet_t2fv_8_avx +fftw_codelet_t2fv_8_sse2 +fftw_codelet_t2sv_16_avx +fftw_codelet_t2sv_16_sse2 +fftw_codelet_t2sv_32_avx +fftw_codelet_t2sv_32_sse2 +fftw_codelet_t2sv_4_avx +fftw_codelet_t2sv_4_sse2 +fftw_codelet_t2sv_8_avx +fftw_codelet_t2sv_8_sse2 +fftw_codelet_t3bv_10_avx +fftw_codelet_t3bv_10_sse2 +fftw_codelet_t3bv_16_avx +fftw_codelet_t3bv_16_sse2 +fftw_codelet_t3bv_20_avx +fftw_codelet_t3bv_20_sse2 +fftw_codelet_t3bv_25_avx +fftw_codelet_t3bv_25_sse2 +fftw_codelet_t3bv_32_avx +fftw_codelet_t3bv_32_sse2 +fftw_codelet_t3bv_4_avx +fftw_codelet_t3bv_4_sse2 +fftw_codelet_t3bv_5_avx +fftw_codelet_t3bv_5_sse2 +fftw_codelet_t3bv_8_avx +fftw_codelet_t3bv_8_sse2 +fftw_codelet_t3fv_10_avx +fftw_codelet_t3fv_10_sse2 +fftw_codelet_t3fv_16_avx +fftw_codelet_t3fv_16_sse2 +fftw_codelet_t3fv_20_avx +fftw_codelet_t3fv_20_sse2 +fftw_codelet_t3fv_25_avx +fftw_codelet_t3fv_25_sse2 +fftw_codelet_t3fv_32_avx +fftw_codelet_t3fv_32_sse2 +fftw_codelet_t3fv_4_avx +fftw_codelet_t3fv_4_sse2 +fftw_codelet_t3fv_5_avx +fftw_codelet_t3fv_5_sse2 +fftw_codelet_t3fv_8_avx +fftw_codelet_t3fv_8_sse2 +fftw_compute_tilesz +fftw_configure_planner +fftw_cost +fftw_cpy1d +fftw_cpy2d +fftw_cpy2d_ci +fftw_cpy2d_co +fftw_cpy2d_pair +fftw_cpy2d_pair_ci +fftw_cpy2d_pair_co +fftw_cpy2d_tiled +fftw_cpy2d_tiledbuf +fftw_ct_applicable +fftw_ct_genericbuf_register +fftw_ct_generic_register +fftw_ct_uglyp +fftw_destroy_plan +fftw_dft_bluestein_register +fftw_dft_buffered_register +fftw_dft_conf_standard +fftw_dft_generic_register +fftw_dft_indirect_register +fftw_dft_indirect_transpose_register +fftw_dft_nop_register +fftw_dft_r2hc_register +fftw_dft_rader_register +fftw_dft_rank_geq2_register +fftw_dft_solve +fftw_dft_thr_vrank_geq1_register +fftw_dft_vrank_geq1_register +fftw_dft_zerotens +fftw_dht_r2hc_register +fftw_dht_rader_register +fftw_dimcmp +fftw_elapsed_since +fftw_estimate_cost +fftw_execute +fftw_execute_dft +fftw_execute_dft_c2r +fftw_execute_dft_r2c +fftw_execute_r2r +fftw_execute_split_dft +fftw_execute_split_dft_c2r +fftw_execute_split_dft_r2c +fftw_export_wisdom +fftw_export_wisdom_to_file +fftw_export_wisdom_to_filename +fftw_export_wisdom_to_string +fftw_extract_reim +fftw_factors_into +fftw_factors_into_small_primes +fftw_find_generator +fftw_first_divisor +fftw_flops +fftw_forget_wisdom +fftw_fprint_plan +fftw_free +fftw_get_crude_time +fftw_guru64_kosherp +fftw_guru_kosherp +fftw_hash +fftw_have_simd_avx +fftw_have_simd_sse2 +fftw_hc2hc_applicable +fftw_hc2hc_generic_register +fftw_iabs +fftw_ialignment_of +fftw_iestimate_cost +fftw_ifree +fftw_ifree0 +fftw_imax +fftw_imin +fftw_import_system_wisdom +fftw_import_wisdom +fftw_import_wisdom_from_file +fftw_import_wisdom_from_filename +fftw_import_wisdom_from_string +fftw_init_threads +fftw_is_prime +fftw_isqrt +fftw_ithreads_init +fftw_join_taint +fftw_kdft_dif_register +fftw_kdft_difsq_register +fftw_kdft_dit_register +fftw_kdft_register +fftw_kernel_free +fftw_kernel_malloc +fftw_khc2c_register +fftw_khc2hc_register +fftw_kr2c_register +fftw_kr2r_register +fftw_make_planner_thread_safe +fftw_malloc +fftw_malloc_plain +fftw_many_kosherp +fftw_mapflags +fftw_map_r2r_kind +fftw_md5begin +fftw_md5end +fftw_md5int +fftw_md5INT +fftw_md5putb +fftw_md5putc +fftw_md5puts +fftw_md5unsigned +fftw_measure_execution_time +fftw_mkapiplan +fftw_mkplan +fftw_mkplan_d +fftw_mkplan_dft +fftw_mkplan_dftw +fftw_mkplan_f_d +fftw_mkplan_hc2c +fftw_mkplan_hc2hc +fftw_mkplanner +fftw_mkplan_rdft +fftw_mkplan_rdft2 +fftw_mkprinter +fftw_mkprinter_cnt +fftw_mkprinter_file +fftw_mkprinter_str +fftw_mkproblem +fftw_mkproblem_dft +fftw_mkproblem_dft_d +fftw_mkproblem_rdft +fftw_mkproblem_rdft_0_d +fftw_mkproblem_rdft_1 +fftw_mkproblem_rdft_1_d +fftw_mkproblem_rdft2 +fftw_mkproblem_rdft2_d +fftw_mkproblem_rdft2_d_3pointers +fftw_mkproblem_rdft_d +fftw_mkproblem_unsolvable +fftw_mkscanner +fftw_mksolver +fftw_mksolver_ct +fftw_mksolver_ct_threads +fftw_mksolver_dft_direct +fftw_mksolver_dft_directbuf +fftw_mksolver_hc2c +fftw_mksolver_hc2hc +fftw_mksolver_hc2hc_threads +fftw_mksolver_rdft2_direct +fftw_mksolver_rdft_r2c_direct +fftw_mksolver_rdft_r2c_directbuf +fftw_mksolver_rdft_r2r_direct +fftw_mkstride +fftw_mktensor +fftw_mktensor_0d +fftw_mktensor_1d +fftw_mktensor_2d +fftw_mktensor_3d +fftw_mktensor_4d +fftw_mktensor_5d +fftw_mktensor_iodims +fftw_mktensor_iodims64 +fftw_mktensor_rowmajor +fftw_mktriggen +fftw_modulo +fftw_nbuf +fftw_nbuf_redundant +fftw_next_prime +fftw_null_awake +fftw_ops_add +fftw_ops_add2 +fftw_ops_cpy +fftw_ops_madd +fftw_ops_madd2 +fftw_ops_other +fftw_ops_zero +fftw_pickdim +fftw_plan_awake +fftw_plan_destroy_internal +fftw_plan_dft +fftw_plan_dft_1d +fftw_plan_dft_2d +fftw_plan_dft_3d +fftw_plan_dft_c2r +fftw_plan_dft_c2r_1d +fftw_plan_dft_c2r_2d +fftw_plan_dft_c2r_3d +fftw_plan_dft_r2c +fftw_plan_dft_r2c_1d +fftw_plan_dft_r2c_2d +fftw_plan_dft_r2c_3d +fftw_plan_guru64_dft +fftw_plan_guru64_dft_c2r +fftw_plan_guru64_dft_r2c +fftw_plan_guru64_r2r +fftw_plan_guru64_split_dft +fftw_plan_guru64_split_dft_c2r +fftw_plan_guru64_split_dft_r2c +fftw_plan_guru_dft +fftw_plan_guru_dft_c2r +fftw_plan_guru_dft_r2c +fftw_plan_guru_r2r +fftw_plan_guru_split_dft +fftw_plan_guru_split_dft_c2r +fftw_plan_guru_split_dft_r2c +fftw_plan_many_dft +fftw_plan_many_dft_c2r +fftw_plan_many_dft_r2c +fftw_plan_many_r2r +fftw_planner_destroy +fftw_plan_null_destroy +fftw_plan_r2r +fftw_plan_r2r_1d +fftw_plan_r2r_2d +fftw_plan_r2r_3d +fftw_plan_with_nthreads +fftw_power_mod +fftw_printer_destroy +fftw_print_plan +fftw_problem_destroy +fftw_rader_tl_delete +fftw_rader_tl_find +fftw_rader_tl_insert +fftw_rdft2_buffered_register +fftw_rdft2_complex_n +fftw_rdft2_inplace_strides +fftw_rdft2_nop_register +fftw_rdft2_pad +fftw_rdft2_rank0_register +fftw_rdft2_rank_geq2_register +fftw_rdft2_rdft_register +fftw_rdft2_solve +fftw_rdft2_strides +fftw_rdft2_tensor_max_index +fftw_rdft2_thr_vrank_geq1_register +fftw_rdft2_vrank_geq1_register +fftw_rdft_buffered_register +fftw_rdft_conf_standard +fftw_rdft_dht_register +fftw_rdft_generic_register +fftw_rdft_indirect_register +fftw_rdft_kind_str +fftw_rdft_nop_register +fftw_rdft_rank0_register +fftw_rdft_rank_geq2_register +fftw_rdft_solve +fftw_rdft_thr_vrank_geq1_register +fftw_rdft_vrank3_transpose_register +fftw_rdft_vrank_geq1_register +fftw_rdft_zerotens +fftw_redft00e_r2hc_pad_register +fftw_regsolver_ct_directw +fftw_regsolver_ct_directwsq +fftw_regsolver_hc2c_direct +fftw_regsolver_hc2hc_direct +fftw_reodft00e_splitradix_register +fftw_reodft010e_r2hc_register +fftw_reodft11e_r2hc_odd_register +fftw_reodft11e_radix2_r2hc_register +fftw_reodft_conf_standard +fftw_rodft00e_r2hc_pad_register +fftw_safe_mulmod +fftw_scanner_destroy +fftw_set_planner_hooks +fftw_set_timelimit +fftw_solver_destroy +fftw_solver_register +fftw_solver_use +fftw_solvtab_exec +fftw_spawn_loop +fftw_sprint_plan +fftw_stride_destroy +fftw_taint +fftw_tensor_append +fftw_tensor_compress +fftw_tensor_compress_contiguous +fftw_tensor_copy +fftw_tensor_copy_except +fftw_tensor_copy_inplace +fftw_tensor_copy_sub +fftw_tensor_destroy +fftw_tensor_destroy2 +fftw_tensor_destroy4 +fftw_tensor_equal +fftw_tensor_inplace_locations +fftw_tensor_inplace_strides +fftw_tensor_inplace_strides2 +fftw_tensor_kosherp +fftw_tensor_max_index +fftw_tensor_md5 +fftw_tensor_min_istride +fftw_tensor_min_ostride +fftw_tensor_min_stride +fftw_tensor_print +fftw_tensor_split +fftw_tensor_strides_decrease +fftw_tensor_sz +fftw_tensor_tornk1 +fftw_the_planner +fftw_threads_cleanup +fftw_threads_conf_standard +fftw_threads_register_planner_hooks +fftw_tile2d +fftw_toobig +fftw_transpose +fftw_transpose_tiled +fftw_transpose_tiledbuf +fftw_triggen_destroy +fftw_twiddle_awake +fftw_twiddle_length +fftw_zero1d_pair diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3-3.dll b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.dll new file mode 100644 index 00000000..f5a97b49 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.dll differ diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3-3.exp b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.exp new file mode 100644 index 00000000..2c8b16f0 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.exp differ diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3-3.lib b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.lib new file mode 100644 index 00000000..b081b4fb Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x86/libfftw3-3.lib differ diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3f-3.def b/Desktop_Interface/build_win/fftw/x86/libfftw3f-3.def new file mode 100644 index 00000000..d61a2c36 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/libfftw3f-3.def @@ -0,0 +1,1017 @@ +LIBRARY libfftw3f-3.dll +EXPORTS +fftwf_alignment_of +fftwf_alloc_complex +fftwf_alloc_real +fftwf_assertion_failed +fftwf_bufdist +fftwf_check_alignment_of_sse2_pm +fftwf_choose_radix +fftwf_cleanup +fftwf_cleanup_threads +fftwf_codelet_e01_8 +fftwf_codelet_e10_8 +fftwf_codelet_hb_10 +fftwf_codelet_hb_12 +fftwf_codelet_hb_15 +fftwf_codelet_hb_16 +fftwf_codelet_hb_2 +fftwf_codelet_hb_20 +fftwf_codelet_hb2_16 +fftwf_codelet_hb2_20 +fftwf_codelet_hb2_25 +fftwf_codelet_hb2_32 +fftwf_codelet_hb2_4 +fftwf_codelet_hb_25 +fftwf_codelet_hb2_5 +fftwf_codelet_hb2_8 +fftwf_codelet_hb_3 +fftwf_codelet_hb_32 +fftwf_codelet_hb_4 +fftwf_codelet_hb_5 +fftwf_codelet_hb_6 +fftwf_codelet_hb_64 +fftwf_codelet_hb_7 +fftwf_codelet_hb_8 +fftwf_codelet_hb_9 +fftwf_codelet_hc2cb_10 +fftwf_codelet_hc2cb_12 +fftwf_codelet_hc2cb_16 +fftwf_codelet_hc2cb_2 +fftwf_codelet_hc2cb_20 +fftwf_codelet_hc2cb2_16 +fftwf_codelet_hc2cb2_20 +fftwf_codelet_hc2cb2_32 +fftwf_codelet_hc2cb2_4 +fftwf_codelet_hc2cb2_8 +fftwf_codelet_hc2cb_32 +fftwf_codelet_hc2cb_4 +fftwf_codelet_hc2cb_6 +fftwf_codelet_hc2cb_8 +fftwf_codelet_hc2cbdft_10 +fftwf_codelet_hc2cbdft_12 +fftwf_codelet_hc2cbdft_16 +fftwf_codelet_hc2cbdft_2 +fftwf_codelet_hc2cbdft_20 +fftwf_codelet_hc2cbdft2_16 +fftwf_codelet_hc2cbdft2_20 +fftwf_codelet_hc2cbdft2_32 +fftwf_codelet_hc2cbdft2_4 +fftwf_codelet_hc2cbdft2_8 +fftwf_codelet_hc2cbdft_32 +fftwf_codelet_hc2cbdft_4 +fftwf_codelet_hc2cbdft_6 +fftwf_codelet_hc2cbdft_8 +fftwf_codelet_hc2cbdftv_10_avx +fftwf_codelet_hc2cbdftv_10_sse2 +fftwf_codelet_hc2cbdftv_12_avx +fftwf_codelet_hc2cbdftv_12_sse2 +fftwf_codelet_hc2cbdftv_16_avx +fftwf_codelet_hc2cbdftv_16_sse2 +fftwf_codelet_hc2cbdftv_20_avx +fftwf_codelet_hc2cbdftv_20_sse2 +fftwf_codelet_hc2cbdftv_2_avx +fftwf_codelet_hc2cbdftv_2_sse2 +fftwf_codelet_hc2cbdftv_32_avx +fftwf_codelet_hc2cbdftv_32_sse2 +fftwf_codelet_hc2cbdftv_4_avx +fftwf_codelet_hc2cbdftv_4_sse2 +fftwf_codelet_hc2cbdftv_6_avx +fftwf_codelet_hc2cbdftv_6_sse2 +fftwf_codelet_hc2cbdftv_8_avx +fftwf_codelet_hc2cbdftv_8_sse2 +fftwf_codelet_hc2cf_10 +fftwf_codelet_hc2cf_12 +fftwf_codelet_hc2cf_16 +fftwf_codelet_hc2cf_2 +fftwf_codelet_hc2cf_20 +fftwf_codelet_hc2cf2_16 +fftwf_codelet_hc2cf2_20 +fftwf_codelet_hc2cf2_32 +fftwf_codelet_hc2cf2_4 +fftwf_codelet_hc2cf2_8 +fftwf_codelet_hc2cf_32 +fftwf_codelet_hc2cf_4 +fftwf_codelet_hc2cf_6 +fftwf_codelet_hc2cf_8 +fftwf_codelet_hc2cfdft_10 +fftwf_codelet_hc2cfdft_12 +fftwf_codelet_hc2cfdft_16 +fftwf_codelet_hc2cfdft_2 +fftwf_codelet_hc2cfdft_20 +fftwf_codelet_hc2cfdft2_16 +fftwf_codelet_hc2cfdft2_20 +fftwf_codelet_hc2cfdft2_32 +fftwf_codelet_hc2cfdft2_4 +fftwf_codelet_hc2cfdft2_8 +fftwf_codelet_hc2cfdft_32 +fftwf_codelet_hc2cfdft_4 +fftwf_codelet_hc2cfdft_6 +fftwf_codelet_hc2cfdft_8 +fftwf_codelet_hc2cfdftv_10_avx +fftwf_codelet_hc2cfdftv_10_sse2 +fftwf_codelet_hc2cfdftv_12_avx +fftwf_codelet_hc2cfdftv_12_sse2 +fftwf_codelet_hc2cfdftv_16_avx +fftwf_codelet_hc2cfdftv_16_sse2 +fftwf_codelet_hc2cfdftv_20_avx +fftwf_codelet_hc2cfdftv_20_sse2 +fftwf_codelet_hc2cfdftv_2_avx +fftwf_codelet_hc2cfdftv_2_sse2 +fftwf_codelet_hc2cfdftv_32_avx +fftwf_codelet_hc2cfdftv_32_sse2 +fftwf_codelet_hc2cfdftv_4_avx +fftwf_codelet_hc2cfdftv_4_sse2 +fftwf_codelet_hc2cfdftv_6_avx +fftwf_codelet_hc2cfdftv_6_sse2 +fftwf_codelet_hc2cfdftv_8_avx +fftwf_codelet_hc2cfdftv_8_sse2 +fftwf_codelet_hf_10 +fftwf_codelet_hf_12 +fftwf_codelet_hf_15 +fftwf_codelet_hf_16 +fftwf_codelet_hf_2 +fftwf_codelet_hf_20 +fftwf_codelet_hf2_16 +fftwf_codelet_hf2_20 +fftwf_codelet_hf2_25 +fftwf_codelet_hf2_32 +fftwf_codelet_hf2_4 +fftwf_codelet_hf_25 +fftwf_codelet_hf2_5 +fftwf_codelet_hf2_8 +fftwf_codelet_hf_3 +fftwf_codelet_hf_32 +fftwf_codelet_hf_4 +fftwf_codelet_hf_5 +fftwf_codelet_hf_6 +fftwf_codelet_hf_64 +fftwf_codelet_hf_7 +fftwf_codelet_hf_8 +fftwf_codelet_hf_9 +fftwf_codelet_n1_10 +fftwf_codelet_n1_11 +fftwf_codelet_n1_12 +fftwf_codelet_n1_13 +fftwf_codelet_n1_14 +fftwf_codelet_n1_15 +fftwf_codelet_n1_16 +fftwf_codelet_n1_2 +fftwf_codelet_n1_20 +fftwf_codelet_n1_25 +fftwf_codelet_n1_3 +fftwf_codelet_n1_32 +fftwf_codelet_n1_4 +fftwf_codelet_n1_5 +fftwf_codelet_n1_6 +fftwf_codelet_n1_64 +fftwf_codelet_n1_7 +fftwf_codelet_n1_8 +fftwf_codelet_n1_9 +fftwf_codelet_n1bv_10_avx +fftwf_codelet_n1bv_10_sse2 +fftwf_codelet_n1bv_11_avx +fftwf_codelet_n1bv_11_sse2 +fftwf_codelet_n1bv_128_avx +fftwf_codelet_n1bv_128_sse2 +fftwf_codelet_n1bv_12_avx +fftwf_codelet_n1bv_12_sse2 +fftwf_codelet_n1bv_13_avx +fftwf_codelet_n1bv_13_sse2 +fftwf_codelet_n1bv_14_avx +fftwf_codelet_n1bv_14_sse2 +fftwf_codelet_n1bv_15_avx +fftwf_codelet_n1bv_15_sse2 +fftwf_codelet_n1bv_16_avx +fftwf_codelet_n1bv_16_sse2 +fftwf_codelet_n1bv_20_avx +fftwf_codelet_n1bv_20_sse2 +fftwf_codelet_n1bv_25_avx +fftwf_codelet_n1bv_25_sse2 +fftwf_codelet_n1bv_2_avx +fftwf_codelet_n1bv_2_sse2 +fftwf_codelet_n1bv_32_avx +fftwf_codelet_n1bv_32_sse2 +fftwf_codelet_n1bv_3_avx +fftwf_codelet_n1bv_3_sse2 +fftwf_codelet_n1bv_4_avx +fftwf_codelet_n1bv_4_sse2 +fftwf_codelet_n1bv_5_avx +fftwf_codelet_n1bv_5_sse2 +fftwf_codelet_n1bv_64_avx +fftwf_codelet_n1bv_64_sse2 +fftwf_codelet_n1bv_6_avx +fftwf_codelet_n1bv_6_sse2 +fftwf_codelet_n1bv_7_avx +fftwf_codelet_n1bv_7_sse2 +fftwf_codelet_n1bv_8_avx +fftwf_codelet_n1bv_8_sse2 +fftwf_codelet_n1bv_9_avx +fftwf_codelet_n1bv_9_sse2 +fftwf_codelet_n1fv_10_avx +fftwf_codelet_n1fv_10_sse2 +fftwf_codelet_n1fv_11_avx +fftwf_codelet_n1fv_11_sse2 +fftwf_codelet_n1fv_128_avx +fftwf_codelet_n1fv_128_sse2 +fftwf_codelet_n1fv_12_avx +fftwf_codelet_n1fv_12_sse2 +fftwf_codelet_n1fv_13_avx +fftwf_codelet_n1fv_13_sse2 +fftwf_codelet_n1fv_14_avx +fftwf_codelet_n1fv_14_sse2 +fftwf_codelet_n1fv_15_avx +fftwf_codelet_n1fv_15_sse2 +fftwf_codelet_n1fv_16_avx +fftwf_codelet_n1fv_16_sse2 +fftwf_codelet_n1fv_20_avx +fftwf_codelet_n1fv_20_sse2 +fftwf_codelet_n1fv_25_avx +fftwf_codelet_n1fv_25_sse2 +fftwf_codelet_n1fv_2_avx +fftwf_codelet_n1fv_2_sse2 +fftwf_codelet_n1fv_32_avx +fftwf_codelet_n1fv_32_sse2 +fftwf_codelet_n1fv_3_avx +fftwf_codelet_n1fv_3_sse2 +fftwf_codelet_n1fv_4_avx +fftwf_codelet_n1fv_4_sse2 +fftwf_codelet_n1fv_5_avx +fftwf_codelet_n1fv_5_sse2 +fftwf_codelet_n1fv_64_avx +fftwf_codelet_n1fv_64_sse2 +fftwf_codelet_n1fv_6_avx +fftwf_codelet_n1fv_6_sse2 +fftwf_codelet_n1fv_7_avx +fftwf_codelet_n1fv_7_sse2 +fftwf_codelet_n1fv_8_avx +fftwf_codelet_n1fv_8_sse2 +fftwf_codelet_n1fv_9_avx +fftwf_codelet_n1fv_9_sse2 +fftwf_codelet_n2bv_10_avx +fftwf_codelet_n2bv_10_sse2 +fftwf_codelet_n2bv_12_avx +fftwf_codelet_n2bv_12_sse2 +fftwf_codelet_n2bv_14_avx +fftwf_codelet_n2bv_14_sse2 +fftwf_codelet_n2bv_16_avx +fftwf_codelet_n2bv_16_sse2 +fftwf_codelet_n2bv_20_avx +fftwf_codelet_n2bv_20_sse2 +fftwf_codelet_n2bv_2_avx +fftwf_codelet_n2bv_2_sse2 +fftwf_codelet_n2bv_32_avx +fftwf_codelet_n2bv_32_sse2 +fftwf_codelet_n2bv_4_avx +fftwf_codelet_n2bv_4_sse2 +fftwf_codelet_n2bv_64_avx +fftwf_codelet_n2bv_64_sse2 +fftwf_codelet_n2bv_6_avx +fftwf_codelet_n2bv_6_sse2 +fftwf_codelet_n2bv_8_avx +fftwf_codelet_n2bv_8_sse2 +fftwf_codelet_n2fv_10_avx +fftwf_codelet_n2fv_10_sse2 +fftwf_codelet_n2fv_12_avx +fftwf_codelet_n2fv_12_sse2 +fftwf_codelet_n2fv_14_avx +fftwf_codelet_n2fv_14_sse2 +fftwf_codelet_n2fv_16_avx +fftwf_codelet_n2fv_16_sse2 +fftwf_codelet_n2fv_20_avx +fftwf_codelet_n2fv_20_sse2 +fftwf_codelet_n2fv_2_avx +fftwf_codelet_n2fv_2_sse2 +fftwf_codelet_n2fv_32_avx +fftwf_codelet_n2fv_32_sse2 +fftwf_codelet_n2fv_4_avx +fftwf_codelet_n2fv_4_sse2 +fftwf_codelet_n2fv_64_avx +fftwf_codelet_n2fv_64_sse2 +fftwf_codelet_n2fv_6_avx +fftwf_codelet_n2fv_6_sse2 +fftwf_codelet_n2fv_8_avx +fftwf_codelet_n2fv_8_sse2 +fftwf_codelet_n2sv_16_avx +fftwf_codelet_n2sv_16_sse2 +fftwf_codelet_n2sv_32_avx +fftwf_codelet_n2sv_32_sse2 +fftwf_codelet_n2sv_4_avx +fftwf_codelet_n2sv_4_sse2 +fftwf_codelet_n2sv_64_avx +fftwf_codelet_n2sv_64_sse2 +fftwf_codelet_n2sv_8_avx +fftwf_codelet_n2sv_8_sse2 +fftwf_codelet_q1_2 +fftwf_codelet_q1_3 +fftwf_codelet_q1_4 +fftwf_codelet_q1_5 +fftwf_codelet_q1_6 +fftwf_codelet_q1_8 +fftwf_codelet_q1bv_2_avx +fftwf_codelet_q1bv_2_sse2 +fftwf_codelet_q1bv_4_avx +fftwf_codelet_q1bv_4_sse2 +fftwf_codelet_q1bv_5_avx +fftwf_codelet_q1bv_5_sse2 +fftwf_codelet_q1bv_8_avx +fftwf_codelet_q1bv_8_sse2 +fftwf_codelet_q1fv_2_avx +fftwf_codelet_q1fv_2_sse2 +fftwf_codelet_q1fv_4_avx +fftwf_codelet_q1fv_4_sse2 +fftwf_codelet_q1fv_5_avx +fftwf_codelet_q1fv_5_sse2 +fftwf_codelet_q1fv_8_avx +fftwf_codelet_q1fv_8_sse2 +fftwf_codelet_r2cb_10 +fftwf_codelet_r2cb_11 +fftwf_codelet_r2cb_12 +fftwf_codelet_r2cb_128 +fftwf_codelet_r2cb_13 +fftwf_codelet_r2cb_14 +fftwf_codelet_r2cb_15 +fftwf_codelet_r2cb_16 +fftwf_codelet_r2cb_2 +fftwf_codelet_r2cb_20 +fftwf_codelet_r2cb_25 +fftwf_codelet_r2cb_3 +fftwf_codelet_r2cb_32 +fftwf_codelet_r2cb_4 +fftwf_codelet_r2cb_5 +fftwf_codelet_r2cb_6 +fftwf_codelet_r2cb_64 +fftwf_codelet_r2cb_7 +fftwf_codelet_r2cb_8 +fftwf_codelet_r2cb_9 +fftwf_codelet_r2cbIII_10 +fftwf_codelet_r2cbIII_12 +fftwf_codelet_r2cbIII_15 +fftwf_codelet_r2cbIII_16 +fftwf_codelet_r2cbIII_2 +fftwf_codelet_r2cbIII_20 +fftwf_codelet_r2cbIII_25 +fftwf_codelet_r2cbIII_3 +fftwf_codelet_r2cbIII_32 +fftwf_codelet_r2cbIII_4 +fftwf_codelet_r2cbIII_5 +fftwf_codelet_r2cbIII_6 +fftwf_codelet_r2cbIII_64 +fftwf_codelet_r2cbIII_7 +fftwf_codelet_r2cbIII_8 +fftwf_codelet_r2cbIII_9 +fftwf_codelet_r2cf_10 +fftwf_codelet_r2cf_11 +fftwf_codelet_r2cf_12 +fftwf_codelet_r2cf_128 +fftwf_codelet_r2cf_13 +fftwf_codelet_r2cf_14 +fftwf_codelet_r2cf_15 +fftwf_codelet_r2cf_16 +fftwf_codelet_r2cf_2 +fftwf_codelet_r2cf_20 +fftwf_codelet_r2cf_25 +fftwf_codelet_r2cf_3 +fftwf_codelet_r2cf_32 +fftwf_codelet_r2cf_4 +fftwf_codelet_r2cf_5 +fftwf_codelet_r2cf_6 +fftwf_codelet_r2cf_64 +fftwf_codelet_r2cf_7 +fftwf_codelet_r2cf_8 +fftwf_codelet_r2cf_9 +fftwf_codelet_r2cfII_10 +fftwf_codelet_r2cfII_12 +fftwf_codelet_r2cfII_15 +fftwf_codelet_r2cfII_16 +fftwf_codelet_r2cfII_2 +fftwf_codelet_r2cfII_20 +fftwf_codelet_r2cfII_25 +fftwf_codelet_r2cfII_3 +fftwf_codelet_r2cfII_32 +fftwf_codelet_r2cfII_4 +fftwf_codelet_r2cfII_5 +fftwf_codelet_r2cfII_6 +fftwf_codelet_r2cfII_64 +fftwf_codelet_r2cfII_7 +fftwf_codelet_r2cfII_8 +fftwf_codelet_r2cfII_9 +fftwf_codelet_t1_10 +fftwf_codelet_t1_12 +fftwf_codelet_t1_15 +fftwf_codelet_t1_16 +fftwf_codelet_t1_2 +fftwf_codelet_t1_20 +fftwf_codelet_t1_25 +fftwf_codelet_t1_3 +fftwf_codelet_t1_32 +fftwf_codelet_t1_4 +fftwf_codelet_t1_5 +fftwf_codelet_t1_6 +fftwf_codelet_t1_64 +fftwf_codelet_t1_7 +fftwf_codelet_t1_8 +fftwf_codelet_t1_9 +fftwf_codelet_t1buv_10_avx +fftwf_codelet_t1buv_10_sse2 +fftwf_codelet_t1buv_2_avx +fftwf_codelet_t1buv_2_sse2 +fftwf_codelet_t1buv_3_avx +fftwf_codelet_t1buv_3_sse2 +fftwf_codelet_t1buv_4_avx +fftwf_codelet_t1buv_4_sse2 +fftwf_codelet_t1buv_5_avx +fftwf_codelet_t1buv_5_sse2 +fftwf_codelet_t1buv_6_avx +fftwf_codelet_t1buv_6_sse2 +fftwf_codelet_t1buv_7_avx +fftwf_codelet_t1buv_7_sse2 +fftwf_codelet_t1buv_8_avx +fftwf_codelet_t1buv_8_sse2 +fftwf_codelet_t1buv_9_avx +fftwf_codelet_t1buv_9_sse2 +fftwf_codelet_t1bv_10_avx +fftwf_codelet_t1bv_10_sse2 +fftwf_codelet_t1bv_12_avx +fftwf_codelet_t1bv_12_sse2 +fftwf_codelet_t1bv_15_avx +fftwf_codelet_t1bv_15_sse2 +fftwf_codelet_t1bv_16_avx +fftwf_codelet_t1bv_16_sse2 +fftwf_codelet_t1bv_20_avx +fftwf_codelet_t1bv_20_sse2 +fftwf_codelet_t1bv_25_avx +fftwf_codelet_t1bv_25_sse2 +fftwf_codelet_t1bv_2_avx +fftwf_codelet_t1bv_2_sse2 +fftwf_codelet_t1bv_32_avx +fftwf_codelet_t1bv_32_sse2 +fftwf_codelet_t1bv_3_avx +fftwf_codelet_t1bv_3_sse2 +fftwf_codelet_t1bv_4_avx +fftwf_codelet_t1bv_4_sse2 +fftwf_codelet_t1bv_5_avx +fftwf_codelet_t1bv_5_sse2 +fftwf_codelet_t1bv_64_avx +fftwf_codelet_t1bv_64_sse2 +fftwf_codelet_t1bv_6_avx +fftwf_codelet_t1bv_6_sse2 +fftwf_codelet_t1bv_7_avx +fftwf_codelet_t1bv_7_sse2 +fftwf_codelet_t1bv_8_avx +fftwf_codelet_t1bv_8_sse2 +fftwf_codelet_t1bv_9_avx +fftwf_codelet_t1bv_9_sse2 +fftwf_codelet_t1fuv_10_avx +fftwf_codelet_t1fuv_10_sse2 +fftwf_codelet_t1fuv_2_avx +fftwf_codelet_t1fuv_2_sse2 +fftwf_codelet_t1fuv_3_avx +fftwf_codelet_t1fuv_3_sse2 +fftwf_codelet_t1fuv_4_avx +fftwf_codelet_t1fuv_4_sse2 +fftwf_codelet_t1fuv_5_avx +fftwf_codelet_t1fuv_5_sse2 +fftwf_codelet_t1fuv_6_avx +fftwf_codelet_t1fuv_6_sse2 +fftwf_codelet_t1fuv_7_avx +fftwf_codelet_t1fuv_7_sse2 +fftwf_codelet_t1fuv_8_avx +fftwf_codelet_t1fuv_8_sse2 +fftwf_codelet_t1fuv_9_avx +fftwf_codelet_t1fuv_9_sse2 +fftwf_codelet_t1fv_10_avx +fftwf_codelet_t1fv_10_sse2 +fftwf_codelet_t1fv_12_avx +fftwf_codelet_t1fv_12_sse2 +fftwf_codelet_t1fv_15_avx +fftwf_codelet_t1fv_15_sse2 +fftwf_codelet_t1fv_16_avx +fftwf_codelet_t1fv_16_sse2 +fftwf_codelet_t1fv_20_avx +fftwf_codelet_t1fv_20_sse2 +fftwf_codelet_t1fv_25_avx +fftwf_codelet_t1fv_25_sse2 +fftwf_codelet_t1fv_2_avx +fftwf_codelet_t1fv_2_sse2 +fftwf_codelet_t1fv_32_avx +fftwf_codelet_t1fv_32_sse2 +fftwf_codelet_t1fv_3_avx +fftwf_codelet_t1fv_3_sse2 +fftwf_codelet_t1fv_4_avx +fftwf_codelet_t1fv_4_sse2 +fftwf_codelet_t1fv_5_avx +fftwf_codelet_t1fv_5_sse2 +fftwf_codelet_t1fv_64_avx +fftwf_codelet_t1fv_64_sse2 +fftwf_codelet_t1fv_6_avx +fftwf_codelet_t1fv_6_sse2 +fftwf_codelet_t1fv_7_avx +fftwf_codelet_t1fv_7_sse2 +fftwf_codelet_t1fv_8_avx +fftwf_codelet_t1fv_8_sse2 +fftwf_codelet_t1fv_9_avx +fftwf_codelet_t1fv_9_sse2 +fftwf_codelet_t1sv_16_avx +fftwf_codelet_t1sv_16_sse2 +fftwf_codelet_t1sv_2_avx +fftwf_codelet_t1sv_2_sse2 +fftwf_codelet_t1sv_32_avx +fftwf_codelet_t1sv_32_sse2 +fftwf_codelet_t1sv_4_avx +fftwf_codelet_t1sv_4_sse2 +fftwf_codelet_t1sv_8_avx +fftwf_codelet_t1sv_8_sse2 +fftwf_codelet_t2_10 +fftwf_codelet_t2_16 +fftwf_codelet_t2_20 +fftwf_codelet_t2_25 +fftwf_codelet_t2_32 +fftwf_codelet_t2_4 +fftwf_codelet_t2_5 +fftwf_codelet_t2_64 +fftwf_codelet_t2_8 +fftwf_codelet_t2bv_10_avx +fftwf_codelet_t2bv_10_sse2 +fftwf_codelet_t2bv_16_avx +fftwf_codelet_t2bv_16_sse2 +fftwf_codelet_t2bv_20_avx +fftwf_codelet_t2bv_20_sse2 +fftwf_codelet_t2bv_25_avx +fftwf_codelet_t2bv_25_sse2 +fftwf_codelet_t2bv_2_avx +fftwf_codelet_t2bv_2_sse2 +fftwf_codelet_t2bv_32_avx +fftwf_codelet_t2bv_32_sse2 +fftwf_codelet_t2bv_4_avx +fftwf_codelet_t2bv_4_sse2 +fftwf_codelet_t2bv_5_avx +fftwf_codelet_t2bv_5_sse2 +fftwf_codelet_t2bv_64_avx +fftwf_codelet_t2bv_64_sse2 +fftwf_codelet_t2bv_8_avx +fftwf_codelet_t2bv_8_sse2 +fftwf_codelet_t2fv_10_avx +fftwf_codelet_t2fv_10_sse2 +fftwf_codelet_t2fv_16_avx +fftwf_codelet_t2fv_16_sse2 +fftwf_codelet_t2fv_20_avx +fftwf_codelet_t2fv_20_sse2 +fftwf_codelet_t2fv_25_avx +fftwf_codelet_t2fv_25_sse2 +fftwf_codelet_t2fv_2_avx +fftwf_codelet_t2fv_2_sse2 +fftwf_codelet_t2fv_32_avx +fftwf_codelet_t2fv_32_sse2 +fftwf_codelet_t2fv_4_avx +fftwf_codelet_t2fv_4_sse2 +fftwf_codelet_t2fv_5_avx +fftwf_codelet_t2fv_5_sse2 +fftwf_codelet_t2fv_64_avx +fftwf_codelet_t2fv_64_sse2 +fftwf_codelet_t2fv_8_avx +fftwf_codelet_t2fv_8_sse2 +fftwf_codelet_t2sv_16_avx +fftwf_codelet_t2sv_16_sse2 +fftwf_codelet_t2sv_32_avx +fftwf_codelet_t2sv_32_sse2 +fftwf_codelet_t2sv_4_avx +fftwf_codelet_t2sv_4_sse2 +fftwf_codelet_t2sv_8_avx +fftwf_codelet_t2sv_8_sse2 +fftwf_codelet_t3bv_10_avx +fftwf_codelet_t3bv_10_sse2 +fftwf_codelet_t3bv_16_avx +fftwf_codelet_t3bv_16_sse2 +fftwf_codelet_t3bv_20_avx +fftwf_codelet_t3bv_20_sse2 +fftwf_codelet_t3bv_25_avx +fftwf_codelet_t3bv_25_sse2 +fftwf_codelet_t3bv_32_avx +fftwf_codelet_t3bv_32_sse2 +fftwf_codelet_t3bv_4_avx +fftwf_codelet_t3bv_4_sse2 +fftwf_codelet_t3bv_5_avx +fftwf_codelet_t3bv_5_sse2 +fftwf_codelet_t3bv_8_avx +fftwf_codelet_t3bv_8_sse2 +fftwf_codelet_t3fv_10_avx +fftwf_codelet_t3fv_10_sse2 +fftwf_codelet_t3fv_16_avx +fftwf_codelet_t3fv_16_sse2 +fftwf_codelet_t3fv_20_avx +fftwf_codelet_t3fv_20_sse2 +fftwf_codelet_t3fv_25_avx +fftwf_codelet_t3fv_25_sse2 +fftwf_codelet_t3fv_32_avx +fftwf_codelet_t3fv_32_sse2 +fftwf_codelet_t3fv_4_avx +fftwf_codelet_t3fv_4_sse2 +fftwf_codelet_t3fv_5_avx +fftwf_codelet_t3fv_5_sse2 +fftwf_codelet_t3fv_8_avx +fftwf_codelet_t3fv_8_sse2 +fftwf_compute_tilesz +fftwf_configure_planner +fftwf_cost +fftwf_cpy1d +fftwf_cpy2d +fftwf_cpy2d_ci +fftwf_cpy2d_co +fftwf_cpy2d_pair +fftwf_cpy2d_pair_ci +fftwf_cpy2d_pair_co +fftwf_cpy2d_tiled +fftwf_cpy2d_tiledbuf +fftwf_ct_applicable +fftwf_ct_genericbuf_register +fftwf_ct_generic_register +fftwf_ct_uglyp +fftwf_destroy_plan +fftwf_dft_bluestein_register +fftwf_dft_buffered_register +fftwf_dft_conf_standard +fftwf_dft_generic_register +fftwf_dft_indirect_register +fftwf_dft_indirect_transpose_register +fftwf_dft_nop_register +fftwf_dft_r2hc_register +fftwf_dft_rader_register +fftwf_dft_rank_geq2_register +fftwf_dft_solve +fftwf_dft_thr_vrank_geq1_register +fftwf_dft_vrank_geq1_register +fftwf_dft_zerotens +fftwf_dht_r2hc_register +fftwf_dht_rader_register +fftwf_dimcmp +fftwf_elapsed_since +fftwf_estimate_cost +fftwf_execute +fftwf_execute_dft +fftwf_execute_dft_c2r +fftwf_execute_dft_r2c +fftwf_execute_r2r +fftwf_execute_split_dft +fftwf_execute_split_dft_c2r +fftwf_execute_split_dft_r2c +fftwf_export_wisdom +fftwf_export_wisdom_to_file +fftwf_export_wisdom_to_filename +fftwf_export_wisdom_to_string +fftwf_extract_reim +fftwf_factors_into +fftwf_factors_into_small_primes +fftwf_find_generator +fftwf_first_divisor +fftwf_flops +fftwf_forget_wisdom +fftwf_fprint_plan +fftwf_free +fftwf_get_crude_time +fftwf_guru64_kosherp +fftwf_guru_kosherp +fftwf_hash +fftwf_have_simd_avx +fftwf_have_simd_sse2 +fftwf_hc2hc_applicable +fftwf_hc2hc_generic_register +fftwf_iabs +fftwf_ialignment_of +fftwf_iestimate_cost +fftwf_ifree +fftwf_ifree0 +fftwf_imax +fftwf_imin +fftwf_import_system_wisdom +fftwf_import_wisdom +fftwf_import_wisdom_from_file +fftwf_import_wisdom_from_filename +fftwf_import_wisdom_from_string +fftwf_init_threads +fftwf_is_prime +fftwf_isqrt +fftwf_ithreads_init +fftwf_join_taint +fftwf_kdft_dif_register +fftwf_kdft_difsq_register +fftwf_kdft_dit_register +fftwf_kdft_register +fftwf_kernel_free +fftwf_kernel_malloc +fftwf_khc2c_register +fftwf_khc2hc_register +fftwf_kr2c_register +fftwf_kr2r_register +fftwf_make_planner_thread_safe +fftwf_malloc +fftwf_malloc_plain +fftwf_many_kosherp +fftwf_mapflags +fftwf_map_r2r_kind +fftwf_md5begin +fftwf_md5end +fftwf_md5int +fftwf_md5INT +fftwf_md5putb +fftwf_md5putc +fftwf_md5puts +fftwf_md5unsigned +fftwf_measure_execution_time +fftwf_mkapiplan +fftwf_mkplan +fftwf_mkplan_d +fftwf_mkplan_dft +fftwf_mkplan_dftw +fftwf_mkplan_f_d +fftwf_mkplan_hc2c +fftwf_mkplan_hc2hc +fftwf_mkplanner +fftwf_mkplan_rdft +fftwf_mkplan_rdft2 +fftwf_mkprinter +fftwf_mkprinter_cnt +fftwf_mkprinter_file +fftwf_mkprinter_str +fftwf_mkproblem +fftwf_mkproblem_dft +fftwf_mkproblem_dft_d +fftwf_mkproblem_rdft +fftwf_mkproblem_rdft_0_d +fftwf_mkproblem_rdft_1 +fftwf_mkproblem_rdft_1_d +fftwf_mkproblem_rdft2 +fftwf_mkproblem_rdft2_d +fftwf_mkproblem_rdft2_d_3pointers +fftwf_mkproblem_rdft_d +fftwf_mkproblem_unsolvable +fftwf_mkscanner +fftwf_mksolver +fftwf_mksolver_ct +fftwf_mksolver_ct_threads +fftwf_mksolver_dft_direct +fftwf_mksolver_dft_directbuf +fftwf_mksolver_hc2c +fftwf_mksolver_hc2hc +fftwf_mksolver_hc2hc_threads +fftwf_mksolver_rdft2_direct +fftwf_mksolver_rdft_r2c_direct +fftwf_mksolver_rdft_r2c_directbuf +fftwf_mksolver_rdft_r2r_direct +fftwf_mkstride +fftwf_mktensor +fftwf_mktensor_0d +fftwf_mktensor_1d +fftwf_mktensor_2d +fftwf_mktensor_3d +fftwf_mktensor_4d +fftwf_mktensor_5d +fftwf_mktensor_iodims +fftwf_mktensor_iodims64 +fftwf_mktensor_rowmajor +fftwf_mktriggen +fftwf_modulo +fftwf_nbuf +fftwf_nbuf_redundant +fftwf_next_prime +fftwf_null_awake +fftwf_ops_add +fftwf_ops_add2 +fftwf_ops_cpy +fftwf_ops_madd +fftwf_ops_madd2 +fftwf_ops_other +fftwf_ops_zero +fftwf_pickdim +fftwf_plan_awake +fftwf_plan_destroy_internal +fftwf_plan_dft +fftwf_plan_dft_1d +fftwf_plan_dft_2d +fftwf_plan_dft_3d +fftwf_plan_dft_c2r +fftwf_plan_dft_c2r_1d +fftwf_plan_dft_c2r_2d +fftwf_plan_dft_c2r_3d +fftwf_plan_dft_r2c +fftwf_plan_dft_r2c_1d +fftwf_plan_dft_r2c_2d +fftwf_plan_dft_r2c_3d +fftwf_plan_guru64_dft +fftwf_plan_guru64_dft_c2r +fftwf_plan_guru64_dft_r2c +fftwf_plan_guru64_r2r +fftwf_plan_guru64_split_dft +fftwf_plan_guru64_split_dft_c2r +fftwf_plan_guru64_split_dft_r2c +fftwf_plan_guru_dft +fftwf_plan_guru_dft_c2r +fftwf_plan_guru_dft_r2c +fftwf_plan_guru_r2r +fftwf_plan_guru_split_dft +fftwf_plan_guru_split_dft_c2r +fftwf_plan_guru_split_dft_r2c +fftwf_plan_many_dft +fftwf_plan_many_dft_c2r +fftwf_plan_many_dft_r2c +fftwf_plan_many_r2r +fftwf_planner_destroy +fftwf_plan_null_destroy +fftwf_plan_r2r +fftwf_plan_r2r_1d +fftwf_plan_r2r_2d +fftwf_plan_r2r_3d +fftwf_plan_with_nthreads +fftwf_power_mod +fftwf_printer_destroy +fftwf_print_plan +fftwf_problem_destroy +fftwf_rader_tl_delete +fftwf_rader_tl_find +fftwf_rader_tl_insert +fftwf_rdft2_buffered_register +fftwf_rdft2_complex_n +fftwf_rdft2_inplace_strides +fftwf_rdft2_nop_register +fftwf_rdft2_pad +fftwf_rdft2_rank0_register +fftwf_rdft2_rank_geq2_register +fftwf_rdft2_rdft_register +fftwf_rdft2_solve +fftwf_rdft2_strides +fftwf_rdft2_tensor_max_index +fftwf_rdft2_thr_vrank_geq1_register +fftwf_rdft2_vrank_geq1_register +fftwf_rdft_buffered_register +fftwf_rdft_conf_standard +fftwf_rdft_dht_register +fftwf_rdft_generic_register +fftwf_rdft_indirect_register +fftwf_rdft_kind_str +fftwf_rdft_nop_register +fftwf_rdft_rank0_register +fftwf_rdft_rank_geq2_register +fftwf_rdft_solve +fftwf_rdft_thr_vrank_geq1_register +fftwf_rdft_vrank3_transpose_register +fftwf_rdft_vrank_geq1_register +fftwf_rdft_zerotens +fftwf_redft00e_r2hc_pad_register +fftwf_regsolver_ct_directw +fftwf_regsolver_ct_directwsq +fftwf_regsolver_hc2c_direct +fftwf_regsolver_hc2hc_direct +fftwf_reodft00e_splitradix_register +fftwf_reodft010e_r2hc_register +fftwf_reodft11e_r2hc_odd_register +fftwf_reodft11e_radix2_r2hc_register +fftwf_reodft_conf_standard +fftwf_rodft00e_r2hc_pad_register +fftwf_safe_mulmod +fftwf_scanner_destroy +fftwf_set_planner_hooks +fftwf_set_timelimit +fftwf_solver_destroy +fftwf_solver_register +fftwf_solver_use +fftwf_solvtab_exec +fftwf_spawn_loop +fftwf_sprint_plan +fftwf_stride_destroy +fftwf_taint +fftwf_tensor_append +fftwf_tensor_compress +fftwf_tensor_compress_contiguous +fftwf_tensor_copy +fftwf_tensor_copy_except +fftwf_tensor_copy_inplace +fftwf_tensor_copy_sub +fftwf_tensor_destroy +fftwf_tensor_destroy2 +fftwf_tensor_destroy4 +fftwf_tensor_equal +fftwf_tensor_inplace_locations +fftwf_tensor_inplace_strides +fftwf_tensor_inplace_strides2 +fftwf_tensor_kosherp +fftwf_tensor_max_index +fftwf_tensor_md5 +fftwf_tensor_min_istride +fftwf_tensor_min_ostride +fftwf_tensor_min_stride +fftwf_tensor_print +fftwf_tensor_split +fftwf_tensor_strides_decrease +fftwf_tensor_sz +fftwf_tensor_tornk1 +fftwf_the_planner +fftwf_threads_cleanup +fftwf_threads_conf_standard +fftwf_threads_register_planner_hooks +fftwf_tile2d +fftwf_toobig +fftwf_transpose +fftwf_transpose_tiled +fftwf_transpose_tiledbuf +fftwf_triggen_destroy +fftwf_twiddle_awake +fftwf_twiddle_length +fftwf_zero1d_pair +sfftw_cleanup_ +sfftw_cleanup__ +sfftw_cleanup_threads_ +sfftw_cleanup_threads__ +sfftw_cost_ +sfftw_cost__ +sfftw_destroy_plan_ +sfftw_destroy_plan__ +sfftw_estimate_cost_ +sfftw_estimate_cost__ +sfftw_execute_ +sfftw_execute__ +sfftw_execute_dft_ +sfftw_execute_dft__ +sfftw_execute_dft_c2r_ +sfftw_execute_dft_c2r__ +sfftw_execute_dft_r2c_ +sfftw_execute_dft_r2c__ +sfftw_execute_r2r_ +sfftw_execute_r2r__ +sfftw_execute_split_dft_ +sfftw_execute_split_dft__ +sfftw_execute_split_dft_c2r_ +sfftw_execute_split_dft_c2r__ +sfftw_execute_split_dft_r2c_ +sfftw_execute_split_dft_r2c__ +sfftw_export_wisdom_ +sfftw_export_wisdom__ +sfftw_flops_ +sfftw_flops__ +sfftw_forget_wisdom_ +sfftw_forget_wisdom__ +sfftw_import_system_wisdom_ +sfftw_import_system_wisdom__ +sfftw_import_wisdom_ +sfftw_import_wisdom__ +sfftw_init_threads_ +sfftw_init_threads__ +sfftw_plan_dft_ +sfftw_plan_dft__ +sfftw_plan_dft_1d_ +sfftw_plan_dft_1d__ +sfftw_plan_dft_2d_ +sfftw_plan_dft_2d__ +sfftw_plan_dft_3d_ +sfftw_plan_dft_3d__ +sfftw_plan_dft_c2r_ +sfftw_plan_dft_c2r__ +sfftw_plan_dft_c2r_1d_ +sfftw_plan_dft_c2r_1d__ +sfftw_plan_dft_c2r_2d_ +sfftw_plan_dft_c2r_2d__ +sfftw_plan_dft_c2r_3d_ +sfftw_plan_dft_c2r_3d__ +sfftw_plan_dft_r2c_ +sfftw_plan_dft_r2c__ +sfftw_plan_dft_r2c_1d_ +sfftw_plan_dft_r2c_1d__ +sfftw_plan_dft_r2c_2d_ +sfftw_plan_dft_r2c_2d__ +sfftw_plan_dft_r2c_3d_ +sfftw_plan_dft_r2c_3d__ +sfftw_plan_guru_dft_ +sfftw_plan_guru_dft__ +sfftw_plan_guru_dft_c2r_ +sfftw_plan_guru_dft_c2r__ +sfftw_plan_guru_dft_r2c_ +sfftw_plan_guru_dft_r2c__ +sfftw_plan_guru_r2r_ +sfftw_plan_guru_r2r__ +sfftw_plan_guru_split_dft_ +sfftw_plan_guru_split_dft__ +sfftw_plan_guru_split_dft_c2r_ +sfftw_plan_guru_split_dft_c2r__ +sfftw_plan_guru_split_dft_r2c_ +sfftw_plan_guru_split_dft_r2c__ +sfftw_plan_many_dft_ +sfftw_plan_many_dft__ +sfftw_plan_many_dft_c2r_ +sfftw_plan_many_dft_c2r__ +sfftw_plan_many_dft_r2c_ +sfftw_plan_many_dft_r2c__ +sfftw_plan_many_r2r_ +sfftw_plan_many_r2r__ +sfftw_plan_r2r_ +sfftw_plan_r2r__ +sfftw_plan_r2r_1d_ +sfftw_plan_r2r_1d__ +sfftw_plan_r2r_2d_ +sfftw_plan_r2r_2d__ +sfftw_plan_r2r_3d_ +sfftw_plan_r2r_3d__ +sfftw_plan_with_nthreads_ +sfftw_plan_with_nthreads__ +sfftw_print_plan_ +sfftw_print_plan__ +sfftw_set_timelimit_ +sfftw_set_timelimit__ diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3f-3.dll b/Desktop_Interface/build_win/fftw/x86/libfftw3f-3.dll new file mode 100644 index 00000000..b0a053a8 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x86/libfftw3f-3.dll differ diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3l-3.def b/Desktop_Interface/build_win/fftw/x86/libfftw3l-3.def new file mode 100644 index 00000000..62a5e423 --- /dev/null +++ b/Desktop_Interface/build_win/fftw/x86/libfftw3l-3.def @@ -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__ diff --git a/Desktop_Interface/build_win/fftw/x86/libfftw3l-3.dll b/Desktop_Interface/build_win/fftw/x86/libfftw3l-3.dll new file mode 100644 index 00000000..abc81ea8 Binary files /dev/null and b/Desktop_Interface/build_win/fftw/x86/libfftw3l-3.dll differ diff --git a/Desktop_Interface/compile_commands.json b/Desktop_Interface/compile_commands.json new file mode 100644 index 00000000..fb5f18ae --- /dev/null +++ b/Desktop_Interface/compile_commands.json @@ -0,0 +1,4044 @@ +[ +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\buffercontrol.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/buffercontrol.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\cursorenabler.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/cursorenabler.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\deviceconnecteddisplay.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/deviceconnecteddisplay.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\espocombobox.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/espocombobox.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\esposlider.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/esposlider.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\espospinbox.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/espospinbox.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\noclosemenu.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/noclosemenu.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\qcp1\\qcustomplot.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1/qcustomplot.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\siprint.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/siprint.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\timedtickbox.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/timedtickbox.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\voltagespinbox.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/voltagespinbox.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\swipeystack.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/swipeystack.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\main.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/main.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\mainwindow.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/mainwindow.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\functiongencontrol.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/functiongencontrol.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isodriver.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isodriver.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isobuffer.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isobuffer.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\desktop_settings.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/desktop_settings.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\scoperangeenterdialog.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/scoperangeenterdialog.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\genericusbdriver.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/genericusbdriver.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isobufferbuffer.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isobufferbuffer.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\uartstyledecoder.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/uartstyledecoder.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\daqform.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/daqform.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\daqloadprompt.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/daqloadprompt.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isobuffer_file.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isobuffer_file.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\i2cdecoder.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/i2cdecoder.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\asyncdft.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/asyncdft.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\winusbdriver.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/winusbdriver.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\unixusbdriver.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/unixusbdriver.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "/TP", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\androidusbdriver.cpp" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/androidusbdriver.cpp" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\buffercontrol.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/buffercontrol.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\cursorenabler.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/cursorenabler.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\deviceconnecteddisplay.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/deviceconnecteddisplay.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\espocombobox.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/espocombobox.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\esposlider.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/esposlider.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\espospinbox.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/espospinbox.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\noclosemenu.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/noclosemenu.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\qcp1\\qcustomplot.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1/qcustomplot.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\siprint.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/siprint.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\timedtickbox.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/timedtickbox.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\voltagespinbox.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/voltagespinbox.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_elements\\swipeystack.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/swipeystack.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\mainwindow.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/mainwindow.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\functiongencontrol.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/functiongencontrol.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\xmega.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/xmega.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isodriver.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isodriver.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isobuffer.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isobuffer.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\desktop_settings.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/desktop_settings.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\scoperangeenterdialog.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/scoperangeenterdialog.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\genericusbdriver.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/genericusbdriver.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isobufferbuffer.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isobufferbuffer.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\q_debugstream.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/q_debugstream.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\unified_debug_structure.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/unified_debug_structure.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\uartstyledecoder.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/uartstyledecoder.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\daqform.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/daqform.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\daqloadprompt.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/daqloadprompt.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\isobuffer_file.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/isobuffer_file.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\i2cdecoder.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/i2cdecoder.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\asyncdft.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/asyncdft.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\winusbdriver.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/winusbdriver.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\unixusbdriver.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/unixusbdriver.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\androidusbdriver.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/androidusbdriver.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_daqform.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_daqform.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_mainwindow.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_mainwindow.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_scoperangeenterdialog.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_scoperangeenterdialog.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_daqloadprompt.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_daqloadprompt.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_scoperangeenterdialog.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_scoperangeenterdialog.h" +}, +{ + "arguments": [ + "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe", + "-c", + "-nologo", + "-Zc:wchar_t", + "-FS", + "-Zc:rvalueCast", + "-Zc:inline", + "-Zc:strictStrings", + "-Zc:throwingNew", + "-Zc:referenceBinding", + "-Zc:__cplusplus", + "-O2", + "-MD", + "-std:c++14", + "-W3", + "-w34100", + "-w34189", + "-w44996", + "-w44456", + "-w44457", + "-w44458", + "-wd4577", + "-wd4467", + "-EHsc", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements/qcp1", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/ui_elements", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/fftw/x64", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/build_win/libusbk/includes", + "-IC:/Qt/5.15.2/msvc2019_64/include", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtPrintSupport", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtWidgets", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtGui", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtANGLE", + "-IC:/Qt/5.15.2/msvc2019_64/include/QtCore", + "-IC:/Users/Esposch/git/labrador/Desktop_Interface/moc", + "-IC:/Qt/5.15.2/msvc2019_64/mkspecs/win32-msvc", + "-DUNICODE", + "-D_UNICODE", + "-DWIN32", + "-D_ENABLE_EXTENDED_ALIGNED_STORAGE", + "-DWIN64", + "-DQCP_VER", + "-DWINDOWS_64_BIT", + "-DPLATFORM_WINDOWS", + "-DNDEBUG", + "-DQT_NO_DEBUG", + "-DQT_PRINTSUPPORT_LIB", + "-DQT_WIDGETS_LIB", + "-DQT_GUI_LIB", + "-DQT_CORE_LIB", + "C:\\Users\\Esposch\\git\\labrador\\Desktop_Interface\\ui_mainwindow.h" + ], + "directory": "C:/Users/Esposch/git/labrador/Desktop_Interface", + "file": "C:/Users/Esposch/git/labrador/Desktop_Interface/ui_mainwindow.h" +} +] \ No newline at end of file diff --git a/Desktop_Interface/isobuffer.cpp b/Desktop_Interface/isobuffer.cpp index 27a39139..1f488731 100644 --- a/Desktop_Interface/isobuffer.cpp +++ b/Desktop_Interface/isobuffer.cpp @@ -2,6 +2,7 @@ #include #include +#include #include "isodriver.h" #include "uartstyledecoder.h" @@ -55,6 +56,7 @@ void isoBuffer::insertIntoBuffer(short item) { m_back = 0; } + async_dft.addSample(item); checkTriggered(); } diff --git a/Desktop_Interface/isobuffer.h b/Desktop_Interface/isobuffer.h index d36df195..59b01050 100644 --- a/Desktop_Interface/isobuffer.h +++ b/Desktop_Interface/isobuffer.h @@ -16,6 +16,7 @@ #include "xmega.h" #include "desktop_settings.h" #include "genericusbdriver.h" +#include "asyncdft.h" class isoDriver; class uartStyleDecoder; @@ -58,14 +59,13 @@ public: // Advanced buffer operations private: - template - void writeBuffer(T* data, int len, int TOP, Function transform); + template + void writeBuffer(T* data, int len, int TOP, Function transform); public: void writeBuffer_char(char* data, int len); void writeBuffer_short(short* data, int len); std::unique_ptr 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; diff --git a/Desktop_Interface/isodriver.cpp b/Desktop_Interface/isodriver.cpp index f343182b..b20bdae5 100644 --- a/Desktop_Interface/isodriver.cpp +++ b/Desktop_Interface/isodriver.cpp @@ -4,7 +4,10 @@ #include "platformspecific.h" #include #include "daqloadprompt.h" +#include +#include +static constexpr int kSpectrumCounterMax = 4; isoDriver::isoDriver(QWidget *parent) : QLabel(parent) { @@ -172,7 +175,7 @@ void isoDriver::analogConvert(short *shortPtr, QVector *doublePtr, int T double frontendGain = (channel == 1 ? frontendGain_CH1 : frontendGain_CH2); double *data = doublePtr->data(); - for (int i=0;isize();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 *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 *doublePtr, int T currentVmax = -20; currentVmin = 20; - for (int i=0;isize();i++){ data[i] -= currentVmean; accumulated += data[i]; @@ -201,8 +204,8 @@ void isoDriver::analogConvert(short *shortPtr, QVector *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 dt_samples1 = internalBuffer375_CH1->async_dft.getWindow(); + std::unique_ptr dt_samples2 = internalBuffer375_CH2->async_dft.getWindow(); - 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); - QVector x(GRAPH_SAMPLES), CH1(GRAPH_SAMPLES), CH2(GRAPH_SAMPLES); + QVector 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,11 +774,42 @@ void isoDriver::frameActionGeneric(char CH1_mode, char CH2_mode) curve->setData(CH1, CH2); axes->xAxis->setRange(xmin, xmax); axes->yAxis->setRange(ymin, ymax); - }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); + } else{ + if (spectrum) { /*If frequency spectrum mode*/ + try { + /*Creating DFT amplitudes*/ + QVector amplitude1 = internalBuffer375_CH1->async_dft.getPowerSpectrum(converted_dt_samples1); + /*Getting array of frequencies for display purposes*/ + QVector 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 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){ @@ -1566,3 +1648,14 @@ void isoDriver::setHexDisplay_CH2(bool enabled) { hexDisplay_CH2 = enabled; } + +void isoDriver::setMinSpectrum(int minSpectrum) +{ + m_spectrumMinX = static_cast(minSpectrum); +} + +void isoDriver::setMaxSpectrum(int maxSpectrum) +{ + m_spectrumMaxX = static_cast(maxSpectrum); +} + diff --git a/Desktop_Interface/isodriver.h b/Desktop_Interface/isodriver.h index 8518f371..f3970a52 100644 --- a/Desktop_Interface/isodriver.h +++ b/Desktop_Interface/isodriver.h @@ -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 *doublePtr, int TOP, bool AC, int channel); void digitalConvert(short *shortPtr, QVector *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 diff --git a/Desktop_Interface/macrun b/Desktop_Interface/macrun new file mode 100755 index 00000000..9d8845ee --- /dev/null +++ b/Desktop_Interface/macrun @@ -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 diff --git a/Desktop_Interface/mainwindow.cpp b/Desktop_Interface/mainwindow.cpp index b0c95b3a..bdef3707 100644 --- a/Desktop_Interface/mainwindow.cpp +++ b/Desktop_Interface/mainwindow.cpp @@ -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::of(&QSpinBox::valueChanged), ui->controller_iso, &isoDriver::setMinSpectrum); + connect(spectrumMaxXSpinbox, QOverload::of(&QSpinBox::valueChanged), ui->controller_iso, &isoDriver::setMaxSpectrum); + + connect(spectrumMinXSpinbox, QOverload::of(&QSpinBox::valueChanged), spectrumMaxXSpinbox, &QSpinBox::setMinimum); + connect(spectrumMaxXSpinbox, QOverload::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; } diff --git a/Desktop_Interface/mainwindow.h b/Desktop_Interface/mainwindow.h index 6f351984..09c8f995 100644 --- a/Desktop_Interface/mainwindow.h +++ b/Desktop_Interface/mainwindow.h @@ -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; diff --git a/Desktop_Interface/make_appimage b/Desktop_Interface/make_appimage index a2911d62..2be78e17 100755 --- a/Desktop_Interface/make_appimage +++ b/Desktop_Interface/make_appimage @@ -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/ diff --git a/Desktop_Interface/ui_files_desktop/mainwindow.ui b/Desktop_Interface/ui_files_desktop/mainwindow.ui index 03228083..4b972403 100644 --- a/Desktop_Interface/ui_files_desktop/mainwindow.ui +++ b/Desktop_Interface/ui_files_desktop/mainwindow.ui @@ -1507,7 +1507,7 @@ 0 0 1493 - 21 + 23 @@ -1535,77 +1535,6 @@ - - - Oscilloscope - - - - &Gain - - - - - - - - - - - - - - &CH1 Stats - - - - - - - - - C&H2 Stats - - - - - - - - - &Frame rate - - - - - - - - - - - &Range - - - - - - - - - - - - - - - - - - - - - &Multimeter @@ -1615,8 +1544,8 @@ 0 0 - 160 - 120 + 172 + 130 @@ -1802,6 +1731,77 @@ Accessibility + + + Oscilloscope + + + + &Gain + + + + + + + + + + + + + + &CH1 Stats + + + + + + + + + C&H2 Stats + + + + + + + + + &Frame rate + + + + + + + + + + + &Range + + + + + + + + + + + + + + + + + + + + + @@ -2645,6 +2645,20 @@ Dark Mode + + + Hide Widget + + + + + true + + + false + + + Frequency Spectrum diff --git a/SlidingDFT b/SlidingDFT new file mode 160000 index 00000000..13e01212 --- /dev/null +++ b/SlidingDFT @@ -0,0 +1 @@ +Subproject commit 13e0121253c73f2e85e418a3ae960463c0fbf31f diff --git a/test.txt b/test.txt new file mode 100644 index 00000000..e69de29b