6 |
8 |
16 |
17 | );
18 | }
19 |
20 | export default NotFound;
21 |
--------------------------------------------------------------------------------
/site/vite.config.ts:
--------------------------------------------------------------------------------
1 | import { defineConfig } from "vite";
2 | import react from "@vitejs/plugin-react";
3 | import mdx from "@mdx-js/rollup";
4 |
5 | export default defineConfig({
6 | server: {
7 | port: 3000,
8 | host: "0.0.0.0",
9 | },
10 | optimizeDeps: {
11 | include: ["react/jsx-runtime"],
12 | exclude: ["@mdx-js/react"],
13 | },
14 | base: "/", // for custom domain set to / as per https://vitejs.dev/guide/static-deploy.html#github-pages
15 | plugins: [
16 | {
17 | enforce: "pre",
18 | ...mdx(),
19 | },
20 | react({
21 | include: /\.(mdx|js|jsx|ts|tsx)$/,
22 | }),
23 | ],
24 | });
25 |
--------------------------------------------------------------------------------
/examples/basicUsage.js:
--------------------------------------------------------------------------------
1 | import webfft from "../lib/main.js";
2 | //import webfft from "webfft";
3 | //const webfft = require("webfft");
4 |
5 | // Complex-valued input
6 | const fftsize = 1024;
7 | const fft = new webfft(fftsize);
8 | const inputArr = new Float32Array(fftsize * 2);
9 | for (let i = 0; i < fftsize * 2; i++) {
10 | inputArr[i] = i * 1.12312312; // Arbitrary
11 | }
12 | const outputArr = fft.fft(inputArr);
13 | console.log(outputArr);
14 |
15 | // Real-valued input
16 | const inputArrReal = new Float32Array(fftsize);
17 | for (let i = 0; i < fftsize; i++) {
18 | inputArrReal[i] = i * 1.12312312; // Arbitrary
19 | }
20 | const outputArrReal = fft.fftr(inputArrReal);
21 | console.log(outputArrReal);
22 |
23 | fft.dispose();
24 |
--------------------------------------------------------------------------------
/examples/profile.js:
--------------------------------------------------------------------------------
1 | import webfft from "../lib/main.js";
2 | //import webfft from "webfft";
3 | //const webfft = require("webfft");
4 |
5 | const fftsize = 1024;
6 | const fft = new webfft(fftsize);
7 | const profileObj = fft.profile(2); // duration to run profile, in seconds
8 | fft.dispose();
9 | console.log(profileObj);
10 | console.log("Fastest sub-library:", profileObj.fastestSubLibrary);
11 |
12 | // get it from local storage
13 | if (typeof localStorage !== "undefined") {
14 | const profileObjLocal = JSON.parse(localStorage.getItem("webfftProfile"));
15 | console.log(profileObjLocal);
16 | console.log("Fastest sub-library:", profileObjLocal.fastestSubLibrary);
17 | }
18 |
19 | // it will automatically set future .fft() calls to use whichever was fastest
20 |
--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "[typescript]": {
3 | "editor.defaultFormatter": "esbenp.prettier-vscode",
4 | "editor.formatOnSave": true
5 | },
6 | "[typescriptreact]": {
7 | "editor.defaultFormatter": "esbenp.prettier-vscode",
8 | "editor.formatOnSave": true
9 | },
10 | "[javascript]": {
11 | "editor.defaultFormatter": "esbenp.prettier-vscode",
12 | "editor.formatOnSave": true
13 | },
14 | "[javascriptreact]": {
15 | "editor.formatOnSave": true,
16 | "editor.defaultFormatter": "esbenp.prettier-vscode"
17 | },
18 | "[css]": {
19 | "editor.formatOnSave": true,
20 | "editor.defaultFormatter": "esbenp.prettier-vscode"
21 | },
22 | "[markdown]": {
23 | "editor.formatOnSave": false
24 | },
25 | "prettier.printWidth": 120
26 | }
27 |
--------------------------------------------------------------------------------
/site/src/components/SiteHeader.tsx:
--------------------------------------------------------------------------------
1 | import { Link } from "react-router-dom";
2 |
3 | function SiteHeader() {
4 | return (
5 | 12 | 404
15 |
7 |
22 | 8 | 14 | WebFFT 15 | 16 |
17 |
18 | Optimized, Intelligent, and Ultra-Fast.
19 |
That's WebFFT Meta-Library for You.
20 |
18 |
20 |
30 |
31 | );
32 | }
33 |
34 | export default Home;
35 |
--------------------------------------------------------------------------------
/lib/indutny/LICENSE:
--------------------------------------------------------------------------------
1 | This software is licensed under the MIT License.
2 |
3 | Copyright Fedor Indutny, 2017.
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
6 |
7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
8 |
9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--------------------------------------------------------------------------------
/lib/indutnymodified/LICENSE:
--------------------------------------------------------------------------------
1 | This software is licensed under the MIT License.
2 |
3 | Copyright Fedor Indutny, 2017.
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
6 |
7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
8 |
9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2023 IQEngine
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/lib/dntj/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License
2 |
3 | Copyright (c) 2012 Nick Jones
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
--------------------------------------------------------------------------------
/lib/utils/sortPerformance.js:
--------------------------------------------------------------------------------
1 | function sortDescending(data) {
2 | // Extract arrays from data object
3 | let xArray = data[0].x;
4 | let yArray = data[0].y;
5 | let barColors = data[0].marker.color;
6 |
7 | if (!yArray || yArray.length == 0) {
8 | return data;
9 | }
10 |
11 | // Create an array of objects from xArray, yArray, and barColors
12 | let combined = xArray.map((x, i) => ({
13 | x: x,
14 | y: yArray[i],
15 | color: barColors[i],
16 | }));
17 |
18 | // Sort combined array by 'y' property in descending order
19 | combined.sort((a, b) => b.y - a.y);
20 |
21 | // Map sorted array back to original arrays
22 | const sortedXArray = combined.map((item) => item.x);
23 | const sortedYArray = combined.map((item) => item.y);
24 | const sortedBarColors = combined.map((item) => item.color);
25 |
26 | // Create a new data object with sorted arrays
27 | const sortedData = [
28 | {
29 | x: sortedXArray,
30 | y: sortedYArray,
31 | type: "bar",
32 | marker: { color: sortedBarColors },
33 | },
34 | ];
35 |
36 | return sortedData;
37 | }
38 |
39 | export default sortDescending;
40 |
--------------------------------------------------------------------------------
/lib/wasmfft/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2022 Jeppe Johansen - jeppe@j-software.dk
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/site/src/components/Breadcrumbs.tsx:
--------------------------------------------------------------------------------
1 | import { useLocation, useNavigate } from "react-router-dom";
2 |
3 | function Breadcrumbs() {
4 | const location = useLocation();
5 | const navigate = useNavigate();
6 |
7 | const pathnames = location.pathname.split("/").filter((x) => x);
8 |
9 | return (
10 |
11 | {pathnames.length > 0 ? (
12 | <>
13 |
30 | );
31 | }
32 |
33 | export default Breadcrumbs;
34 |
--------------------------------------------------------------------------------
/lib/cross/FFT.js:
--------------------------------------------------------------------------------
1 | import CrossModule from "./Cross.mjs";
2 |
3 | ("use strict");
4 |
5 | var crossModule = CrossModule({});
6 |
7 | var fftCross = crossModule.cwrap("fftCross", "void", [
8 | "number",
9 | "number",
10 | "number",
11 | "number",
12 | "number",
13 | "number",
14 | ]);
15 |
16 | function FFTCross(size) {
17 | this.size = size;
18 | this.n = size * 8;
19 | this.ptr = crossModule._malloc(this.n * 4);
20 | this.ri = new Uint8Array(crossModule.HEAPU8.buffer, this.ptr, this.n);
21 | this.ii = new Uint8Array(
22 | crossModule.HEAPU8.buffer,
23 | this.ptr + this.n,
24 | this.n,
25 | );
26 |
27 | this.transform = function (real, imag, inverse) {
28 | var ptr = this.ptr;
29 | var n = this.n;
30 | this.ri.set(new Uint8Array(real.buffer));
31 | this.ii.set(new Uint8Array(imag.buffer));
32 | fftCross(this.size, inverse, ptr, ptr + n, ptr + n * 2, ptr + n * 3);
33 | var ro = new Float64Array(
34 | crossModule.HEAPU8.buffer,
35 | ptr + n * 2,
36 | this.size,
37 | );
38 | var io = new Float64Array(
39 | crossModule.HEAPU8.buffer,
40 | ptr + n * 3,
41 | this.size,
42 | );
43 | return { real: ro, imag: io };
44 | };
45 |
46 | this.dispose = function () {
47 | crossModule._free(this.ptr);
48 | };
49 | }
50 |
51 | export default FFTCross;
52 |
--------------------------------------------------------------------------------
/lib/vailNOTFINISHED/complex.cjs:
--------------------------------------------------------------------------------
1 | //-------------------------------------------------
2 | // Add two complex numbers
3 | //-------------------------------------------------
4 | var complexAdd = function (a, b) {
5 | return [a[0] + b[0], a[1] + b[1]];
6 | };
7 |
8 | //-------------------------------------------------
9 | // Subtract two complex numbers
10 | //-------------------------------------------------
11 | var complexSubtract = function (a, b) {
12 | return [a[0] - b[0], a[1] - b[1]];
13 | };
14 |
15 | //-------------------------------------------------
16 | // Multiply two complex numbers
17 | //
18 | // (a + bi) * (c + di) = (ac - bd) + (ad + bc)i
19 | //-------------------------------------------------
20 | var complexMultiply = function (a, b) {
21 | return [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]];
22 | };
23 |
24 | //-------------------------------------------------
25 | // Calculate |a + bi|
26 | //
27 | // sqrt(a*a + b*b)
28 | //-------------------------------------------------
29 | var complexMagnitude = function (c) {
30 | return Math.sqrt(c[0] * c[0] + c[1] * c[1]);
31 | };
32 |
33 | //-------------------------------------------------
34 | // Exports
35 | //-------------------------------------------------
36 | module.exports = {
37 | add: complexAdd,
38 | subtract: complexSubtract,
39 | multiply: complexMultiply,
40 | magnitude: complexMagnitude
41 | };
42 |
--------------------------------------------------------------------------------
/lib/wasmfft/wasmfftWrapper.js:
--------------------------------------------------------------------------------
1 | import { getFFT, wasmBinary } from "./fft.js";
2 |
3 | ("use strict");
4 |
5 | function intArrayFromBase64(s) {
6 | try {
7 | var decoded = atob(s);
8 | var bytes = new Uint8Array(decoded.length);
9 | for (var i = 0; i < decoded.length; ++i) {
10 | bytes[i] = decoded.charCodeAt(i)
11 | }
12 | return bytes
13 | } catch (_) {
14 | throw new Error("Converting base64 string to bytes failed.")
15 | }
16 | }
17 |
18 | var module = new WebAssembly.Module(intArrayFromBase64(wasmBinary));
19 |
20 | class WasmFftWrapperWasm {
21 | constructor(size) {
22 | this.size = size;
23 |
24 | this.instance = getFFT(module, size, "complex", "complex");
25 |
26 | this.inptr = this.instance.getInputBuffer();
27 | [this.outr, this.outi] = this.instance.getOutputBuffer();
28 | }
29 |
30 | fft = function (inputArray) {
31 | this.inptr.set(inputArray);
32 |
33 | this.instance.run();
34 |
35 | let outputArray = new Float32Array(this.size * 2);
36 | let [outr, outi] = [this.outr, this.outi];
37 | for (let i=0; i navigate("/")} className="text-cyber-secondary cursor-pointer">
14 | Home
15 |
16 | {pathnames.map((value, index) => {
17 | const to = `/${pathnames.slice(0, index + 1).join("/")}`;
18 | return (
19 |
20 | {">"}{" "}
21 |
25 | );
26 | })}
27 |
28 | ) : null}
29 | navigate(to)} className="inline text-cyber-secondary cursor-pointer">
22 | {value.charAt(0).toUpperCase() + value.slice(1)}
23 |
24 |
27 |
34 |
42 |
49 |
50 | );
51 | };
52 |
53 | export default FFTSizeInput;
54 |
--------------------------------------------------------------------------------
/lib/kissfft/webfftWrapper.js:
--------------------------------------------------------------------------------
1 | import KissFFTModule from "./KissFFT.mjs";
2 |
3 | ("use strict");
4 |
5 | var kissFFTModule = KissFFTModule({});
6 |
7 | var kiss_fft_alloc = kissFFTModule.cwrap("kiss_fft_alloc", "number", [
8 | "number",
9 | "number",
10 | "number",
11 | "number",
12 | ]);
13 |
14 | var kiss_fft = kissFFTModule.cwrap("kiss_fft", "void", [
15 | "number",
16 | "number",
17 | "number",
18 | ]);
19 |
20 | var kiss_fft_free = kissFFTModule.cwrap("kiss_fft_free", "void", ["number"]);
21 |
22 | class KissFftWrapperWasm {
23 | constructor(size) {
24 | this.size = size;
25 | this.fcfg = kiss_fft_alloc(this.size, false);
26 | this.icfg = kiss_fft_alloc(this.size, true);
27 |
28 | this.inptr = kissFFTModule._malloc(this.size * 8);
29 |
30 | this.cin = new Float32Array(
31 | kissFFTModule.HEAPU8.buffer,
32 | this.inptr,
33 | this.size * 2,
34 | );
35 | }
36 |
37 | fft = function (inputArray) {
38 | // TODO: figure out how to move this into the constructor without breaking things (unit tests will catch it)
39 | const outptr = kissFFTModule._malloc(this.size * 8);
40 |
41 | const cout = new Float32Array(
42 | kissFFTModule.HEAPU8.buffer,
43 | outptr,
44 | this.size * 2,
45 | );
46 |
47 | this.cin.set(inputArray);
48 |
49 | kiss_fft(this.fcfg, this.inptr, outptr);
50 |
51 | // we need to free the memory of outptr before we return, so we need this too
52 | let outputArray = new Float32Array(this.size * 2);
53 | outputArray.set(cout);
54 |
55 | kissFFTModule._free(outptr);
56 |
57 | return outputArray;
58 | };
59 |
60 | dispose() {
61 | kiss_fft_free(this.fcfg);
62 | kiss_fft_free(this.icfg);
63 | kissFFTModule._free(this.inptr);
64 | }
65 | }
66 |
67 | export default KissFftWrapperWasm;
68 |
--------------------------------------------------------------------------------
/lib/kissfftmodified/webfftWrapper.js:
--------------------------------------------------------------------------------
1 | import KissFFTModule from "./KissFFT.mjs";
2 |
3 | ("use strict");
4 |
5 | var kissFFTModule = KissFFTModule({});
6 |
7 | var kiss_fft_alloc = kissFFTModule.cwrap("kiss_fft_alloc", "number", [
8 | "number",
9 | "number",
10 | "number",
11 | "number",
12 | ]);
13 |
14 | var kiss_fft = kissFFTModule.cwrap("kiss_fft", "void", [
15 | "number",
16 | "number",
17 | "number",
18 | ]);
19 |
20 | var kiss_fft_free = kissFFTModule.cwrap("kiss_fft_free", "void", ["number"]);
21 |
22 | class KissFftModifiedWrapperWasm {
23 | constructor(size) {
24 | this.size = size;
25 | this.fcfg = kiss_fft_alloc(size, false);
26 | this.icfg = kiss_fft_alloc(size, true);
27 |
28 | this.inptr = kissFFTModule._malloc(size * 8 + size * 8);
29 |
30 | this.cin = new Float32Array(
31 | kissFFTModule.HEAPU8.buffer,
32 | this.inptr,
33 | size * 2,
34 | );
35 | }
36 |
37 | fft = function (inputArray) {
38 | // TODO: figure out how to move this into the constructor without breaking things (unit tests will catch it)
39 | const outptr = kissFFTModule._malloc(this.size * 8);
40 |
41 | const cout = new Float32Array(
42 | kissFFTModule.HEAPU8.buffer,
43 | outptr,
44 | this.size * 2,
45 | );
46 |
47 | this.cin.set(inputArray);
48 |
49 | kiss_fft(this.fcfg, this.inptr, outptr);
50 |
51 | // we need to free the memory of outptr before we return, so we need this too
52 | let outputArray = new Float32Array(this.size * 2);
53 | outputArray.set(cout);
54 |
55 | kissFFTModule._free(outptr);
56 |
57 | return outputArray;
58 | };
59 |
60 | dispose() {
61 | kiss_fft_free(this.fcfg);
62 | kiss_fft_free(this.icfg);
63 | kissFFTModule._free(this.inptr);
64 | }
65 | }
66 |
67 | export default KissFftModifiedWrapperWasm;
68 |
--------------------------------------------------------------------------------
/lib/Makefile:
--------------------------------------------------------------------------------
1 | all: KissFFT KissFFTModified NayukiCFFT Cross
2 |
3 | KissFFT: kissfft/kiss_fft.c kissfft/kiss_fft.h
4 | emcc --no-entry kissfft/kiss_fft.c -o kissfft/KissFFT.mjs \
5 | -s ENVIRONMENT='web' \
6 | -s EXPORT_NAME='KissFFTModule' \
7 | -s MODULARIZE=1 \
8 | -s BINARYEN_ASYNC_COMPILATION=0 \
9 | -s SINGLE_FILE=1 \
10 | -s EXPORTED_FUNCTIONS='["_malloc", "_free", "_kiss_fft_alloc", "_kiss_fft", "_kiss_fft_free"]' \
11 | -s EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
12 | -O3
13 |
14 | KissFFTModified: kissfftmodified/kiss_fft.c kissfftmodified/kiss_fft.h
15 | emcc --no-entry kissfftmodified/kiss_fft.c -o kissfftmodified/KissFFT.mjs \
16 | -s ENVIRONMENT='web' \
17 | -s EXPORT_NAME='KissFFTModule' \
18 | -s MODULARIZE=1 \
19 | -s BINARYEN_ASYNC_COMPILATION=0 \
20 | -s SINGLE_FILE=1 \
21 | -s EXPORTED_FUNCTIONS='["_malloc", "_free", "_kiss_fft_alloc", "_kiss_fft", "_kiss_fft_free"]' \
22 | -s EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
23 | -O3
24 |
25 | NayukiCFFT: nayukic/fft.c nayukic/fft.h
26 | emcc --no-entry nayukic/fft.c -o nayukic/NayukiCFFT.mjs \
27 | -s ENVIRONMENT='web' \
28 | -s MODULARIZE=1 \
29 | -s BINARYEN_ASYNC_COMPILATION=0 \
30 | -s SINGLE_FILE=1 \
31 | -s EXPORT_NAME="'NayukiCModule'" \
32 | -s EXPORTED_FUNCTIONS="['_malloc', '_free', '_transform_radix2_precalc','_precalc','_dispose','_transform_radix2_precalc_f','_precalc_f','_dispose_f']" \
33 | -s EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
34 | -O3
35 |
36 | Cross: cross/Cross.c cross/Cross.h
37 | emcc --no-entry cross/Cross.c -o cross/Cross.mjs -s ENVIRONMENT='web' -s EXPORT_NAME='CrossModule' -s MODULARIZE=1 -s BINARYEN_ASYNC_COMPILATION=0 -s SINGLE_FILE=1 -s EXPORTED_FUNCTIONS='["_malloc", "_free", "_fftCross"]' -s EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' -O3
38 |
39 |
40 | .PHONY: clean
41 | clean:
42 | rm kissfft/KissFFT.mjs
43 | rm kissfftmodified/KissFFT.mjs
44 | rm nayukic/NayukiCFFT.mjs
45 | rm cross/Cross.mjs
46 |
--------------------------------------------------------------------------------
/lib/kissfft/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | asdasdasd
5 |
6 |
62 |
63 |
--------------------------------------------------------------------------------
/lib/kissfftmodified/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | asdasdasd
5 |
6 |
62 |
63 |
--------------------------------------------------------------------------------
/lib/vailNOTFINISHED/fftutil.cjs:
--------------------------------------------------------------------------------
1 | /*===========================================================================*\
2 | * Fast Fourier Transform Frequency/Magnitude passes
3 | *
4 | * (c) Vail Systems. Joshua Jung and Ben Bryan. 2015
5 | *
6 | * This code is not designed to be highly optimized but as an educational
7 | * tool to understand the Fast Fourier Transform.
8 | \*===========================================================================*/
9 |
10 | //-------------------------------------------------
11 | // The following code assumes a complex number is
12 | // an array: [real, imaginary]
13 | //-------------------------------------------------
14 | var complex = require("./complex.cjs");
15 |
16 | //-------------------------------------------------
17 | // By Eulers Formula:
18 | //
19 | // e^(i*x) = cos(x) + i*sin(x)
20 | //
21 | // and in DFT:
22 | //
23 | // x = -2*PI*(k/N)
24 | //-------------------------------------------------
25 | var mapExponent = {},
26 | exponent = function (k, N) {
27 | var x = -2 * Math.PI * (k / N);
28 |
29 | mapExponent[N] = mapExponent[N] || {};
30 | mapExponent[N][k] = mapExponent[N][k] || [Math.cos(x), Math.sin(x)]; // [Real, Imaginary]
31 |
32 | return mapExponent[N][k];
33 | };
34 |
35 | //-------------------------------------------------
36 | // Calculate FFT Magnitude for complex numbers.
37 | //-------------------------------------------------
38 | var fftMag = function (fftBins) {
39 | var ret = fftBins.map(complex.magnitude);
40 | return ret.slice(0, ret.length / 2);
41 | };
42 |
43 | //-------------------------------------------------
44 | // Calculate Frequency Bins
45 | //
46 | // Returns an array of the frequencies (in hertz) of
47 | // each FFT bin provided, assuming the sampleRate is
48 | // samples taken per second.
49 | //-------------------------------------------------
50 | var fftFreq = function (fftBins, sampleRate) {
51 | var stepFreq = sampleRate / fftBins.length;
52 | var ret = fftBins.slice(0, fftBins.length / 2);
53 |
54 | return ret.map(function (__, ix) {
55 | return ix * stepFreq;
56 | });
57 | };
58 |
59 | //-------------------------------------------------
60 | // Exports
61 | //-------------------------------------------------
62 | module.exports = {
63 | fftMag: fftMag,
64 | fftFreq: fftFreq,
65 | exponent: exponent
66 | };
67 |
--------------------------------------------------------------------------------
/site/src/docs/GettingStarted.mdx:
--------------------------------------------------------------------------------
1 | ## Overview
2 |
3 | WebFFT is a metalibrary containing many FFT libraries, both javascript and webassembly based. We'll refer to these as sub-libraries.
4 |
5 | There is a default sub-library that is used, but if you run
6 |
7 | ```javascript
8 | import webfft from "webfft";
9 | const fft = new webfft(1024);
10 | fft.profile(); // optional arg sets number of seconds spent profiling
11 | ```
12 |
13 | it will benchmark them all and use the best one for future calls.
14 |
15 | As part of importing the library we will run a check to see if wasm is even supported, so the profiler and default can know which pool to pull from.
16 |
17 | ### Basic Usage
18 |
19 | ```javascript
20 | const webfft = require('webfft');
21 |
22 | // Instantiate
23 | const fftsize = 1024; // must be power of 2
24 | const fft = new webfft(fftsize);
25 |
26 | // Profile
27 | profileResults = fft.profile(); // results object can be used to make visualizations of the benchmarking results
28 |
29 | // Create Input
30 | const input = new Float32Array(2048); // interleaved complex array (IQIQIQIQ...), so it's twice the size
31 | input.fill(0);
32 |
33 | // Run FFT
34 | const out = fft.fft(input); // out will be a Float32Array of size 2048
35 | // or
36 | const out = fft.fft(input, 'kissWasm');
37 |
38 | fft.dispose(); // release Wasm memory
39 | ```
40 |
41 | ### 2D FFTs
42 |
43 | WebFFT also supports 2D FFTs, using an array of arrays.
44 | The inner arrays should be length 2*size and the outter array length should be a power of 2 but does not need to match the inner.
45 |
46 | ```javascript
47 | import webfft from "webfft";
48 |
49 | const fftsize = 1024;
50 | const outterSize = 128;
51 | const fft = new webfft(fftsize);
52 | let inputArr = [];
53 | for (let j = 0; j < outterSize; j++) {
54 | const subArray = new Float32Array(fftsize * 2);
55 | for (let i = 0; i < fftsize * 2; i++) {
56 | subArray[i] = i * j * 1.12312312; // Arbitrary
57 | }
58 | inputArr.push(subArray); // add inner array
59 | }
60 | const out = fft.fft2d(inputArr);
61 |
62 | fft.dispose(); // cleanup wasm
63 | ```
64 |
65 | ### Other Notes
66 |
67 | Use fftr() for real-valued input, the output will still be complex but only the positive frequencies will be returned.
68 |
69 | You don't have to pass fft/fftr/fft2d typed arrays, they can be regular javascript arrays.
--------------------------------------------------------------------------------
/tests/fft2d.test.js:
--------------------------------------------------------------------------------
1 | import { expect, test } from "vitest";
2 | import webfft from "../lib/main.js";
3 |
4 | test("fft2d validation which also validates 1d fft values", () => {
5 | const fftsize = 1024;
6 | const outterSize = 128;
7 |
8 | // Create input
9 | let inputArr = [];
10 | for (let j = 0; j < outterSize; j++) {
11 | let subArray = new Float32Array(fftsize * 2);
12 | for (let i = 0; i < fftsize * 2; i++) {
13 | subArray[i] = Math.sin(i + j); // Arbitrary, but dont change or known correct sum will be wrong
14 | }
15 | inputArr.push(subArray);
16 | }
17 |
18 | const unusedft = new webfft(16); // doesnt matter
19 | const availableSubLibraries = unusedft.availableSubLibraries();
20 | for (let i = 0; i < availableSubLibraries.length; i++) {
21 | const fft = new webfft(fftsize, availableSubLibraries[i]);
22 | const outputArr = fft.fft2d(inputArr);
23 | fft.dispose();
24 |
25 | expect(outputArr[0][0]).toBeCloseTo(0.1705339835898485, 3);
26 | expect(outputArr[0][1]).toBeCloseTo(-0.17611848087108228, 3);
27 |
28 | expect(outputArr[100][2000]).toBeCloseTo(-0.01635975610207374, 5);
29 | expect(outputArr[100][2001]).toBeCloseTo(0.9907842644470186, 5);
30 |
31 | // sum the mags
32 | let sum = 0;
33 | for (let i = 0; i < outterSize; i++) {
34 | for (let j = 0; j < fftsize; j++) {
35 | sum += Math.sqrt(
36 | outputArr[i][j * 2] * outputArr[i][j * 2] +
37 | outputArr[i][j * 2 + 1] * outputArr[i][j * 2 + 1],
38 | );
39 | }
40 | }
41 | expect(sum).toBeCloseTo(1039851.9120030339, 0); // see below for how this number was found
42 | }
43 | });
44 |
45 | /*
46 | PYTHON USED TO GET CORRECT SUM
47 |
48 | import numpy as np
49 | fftsize = 1024
50 | outterSize = 128
51 | inputArr = np.zeros((outterSize, fftsize), np.complex64)
52 | for j in range(outterSize):
53 | for i in range(fftsize):
54 | real_part = np.sin((2*i) + j)
55 | imag_part = np.sin((2*i + 1) + j)
56 | inputArr[j][i] = real_part + 1j * imag_part
57 |
58 | out = np.fft.fft2(inputArr)
59 |
60 | sum = 0
61 | for i in range(outterSize):
62 | for j in range(fftsize):
63 | sum += np.abs(out[i][j])
64 |
65 | print(sum)
66 | print(out[0][0])
67 | print(out[100][1000])
68 |
69 | >>> print(sum)
70 | 1039851.9120030339
71 | >>> print(out[0][0])
72 | (0.1705339835898485-0.17611848087108228j)
73 | >>> print(out[100][1000])
74 | (-0.01635975610207374+0.9907842644470186j)
75 |
76 | */
77 |
--------------------------------------------------------------------------------
/lib/benchmark.js:
--------------------------------------------------------------------------------
1 | // Adapted from https://github.com/j-funk/js-dsp-test
2 | // Nice comparison in https://thebreakfastpost.com/2015/10/18/ffts-in-javascript/
3 |
4 | import webfft from "./main.js";
5 | import sortDescending from "./utils/sortPerformance.js";
6 | import checkBrowserCapabilities from "./utils/checkCapabilities.js";
7 |
8 | // Check for Wasm and SIMD support
9 | checkBrowserCapabilities().then((capabilities) => {
10 | console.log(`Capabilities: ${JSON.stringify(capabilities)}`);
11 | });
12 |
13 | window.onload = function () {
14 | const duration = 0.1;
15 | const fftsize = 1024;
16 | const fft = new webfft(fftsize);
17 |
18 | const profileObj = fft.profile(duration);
19 | fft.dispose();
20 | console.log(profileObj);
21 |
22 | let results = profileObj.fftsPerSecond;
23 |
24 | let test_names = [];
25 | let barColors = [];
26 | for (let i = 0; i < profileObj.subLibraries.length; i++) {
27 | if (profileObj.subLibraries[i].includes("Javascript")) {
28 | test_names.push(profileObj.subLibraries[i].split("Javascript")[0]);
29 | barColors.push("rgba(255,0,0,0.7)");
30 | } else if (profileObj.subLibraries[i].includes("Wasm")) {
31 | test_names.push(profileObj.subLibraries[i].split("Wasm")[0]);
32 | barColors.push("rgba(0,0,255,0.7)");
33 | } else {
34 | console.error("all sublibraries should end in Javascript or Wasm");
35 | }
36 | }
37 |
38 | // Plotly stuff
39 | const xArray = test_names;
40 | const yArray = results;
41 |
42 | const data = [
43 | {
44 | x: xArray,
45 | y: yArray,
46 | type: "bar",
47 | marker: { color: barColors },
48 | },
49 | ];
50 |
51 | const layout = {
52 | title: "Comparison of FFTs in Javascript and WebAssembly",
53 | yaxis: {
54 | title: {
55 | text: "FFTs per Second",
56 | font: {
57 | family: "sans serif",
58 | size: 18,
59 | },
60 | },
61 | },
62 | annotations: [
63 | {
64 | x: 1,
65 | y: Math.max.apply(Math, yArray) * 1.2,
66 | text: "JavaScript",
67 | showarrow: false,
68 | font: {
69 | family: "sans serif",
70 | size: 18,
71 | color: "rgba(255,0,0,1)",
72 | },
73 | },
74 | {
75 | x: 1,
76 | y: Math.max.apply(Math, yArray) * 1.3,
77 | text: "WebAssembly",
78 | showarrow: false,
79 | font: {
80 | family: "sans serif",
81 | size: 18,
82 | color: "rgba(0,0,255,1)",
83 | },
84 | },
85 | ],
86 | };
87 |
88 | Plotly.newPlot("myPlot", sortDescending(data), layout);
89 | };
90 |
--------------------------------------------------------------------------------
/lib/cross/Cross.c:
--------------------------------------------------------------------------------
1 |
2 | /* Public domain FFT implementation from Don Cross. */
3 |
4 | #include "Cross.h"
5 |
6 | #include
22 | {React.Children.map(children, (child) => {
23 | if (React.isValidElement(child) && child.type === "code") {
24 | return child; // Simply return the code child without wrapping it again
25 | }
26 | })}
27 |
28 | ) : (
29 |
30 | {children}
31 |
32 | );
33 | };
34 |
35 | const components = {
36 | h1: (props: any) => (
37 |
38 | ),
39 | h2: (props: any) => (
40 |
41 | ),
42 | h3: (props: any) => (
43 |
44 | ),
45 | h4: (props: any) => (
46 |
47 | ),
48 | h5: (props: any) => (
49 |
50 | ),
51 | h6: (props: any) => (
52 |
53 | ),
54 | ul: (props: any) => (
55 |
26 |
36 |
63 |
86 |
89 |
90 |
91 | );
92 | }
93 |
94 | export default Docs;
95 |
--------------------------------------------------------------------------------
/site/src/index.css:
--------------------------------------------------------------------------------
1 | @tailwind base;
2 | @tailwind components;
3 | @tailwind utilities;
4 |
5 | :root {
6 | font-family: "Orbitron", system-ui, Avenir, Helvetica, Arial, sans-serif;
7 | line-height: 1.5;
8 | font-weight: 400;
9 |
10 | color-scheme: light dark;
11 | color: rgba(255, 255, 255, 0.87);
12 | background-color: #242424;
13 |
14 | font-synthesis: none;
15 | text-rendering: optimizeLegibility;
16 | -webkit-font-smoothing: antialiased;
17 | -moz-osx-font-smoothing: grayscale;
18 | -webkit-text-size-adjust: 100%;
19 | }
20 |
21 | a {
22 | font-weight: 500;
23 | color: theme("colors.cyber-secondary");
24 | text-decoration: inherit;
25 | }
26 | a:hover {
27 | color: #535bf2;
28 | }
29 |
30 | body {
31 | margin: 0;
32 | font-family: "Orbitron", "system-ui", sans-serif;
33 | background-color: #242424; /* fallback color */
34 | background-image: linear-gradient(
35 | 45deg,
36 | #0b0b0b 60%,
37 | theme("colors.cyber-primary")
38 | ),
39 | radial-gradient(circle at 75% 75%, transparent 30%, #242424 70%);
40 | background-repeat: no-repeat, no-repeat, no-repeat;
41 | background-position:
42 | 0 0,
43 | bottom left,
44 | bottom left;
45 | background-size:
46 | 100% 100%,
47 | 30% 30%,
48 | 100% 100%;
49 | background-blend-mode: normal, screen, normal;
50 | }
51 |
52 | h1 {
53 | font-size: 3.2em;
54 | line-height: 1.1;
55 | }
56 |
57 | button {
58 | border-radius: 8px;
59 | border: 1px solid transparent;
60 | padding: 0.6em 1.2em;
61 | font-size: 1em;
62 | font-weight: 500;
63 | font-family: inherit;
64 | background-color: #1a1a1a;
65 | cursor: pointer;
66 | transition: border-color theme("colors.cyber-secondary");
67 | }
68 | button:hover {
69 | border-color: theme("colors.cyber-secondary");
70 | }
71 | button:focus,
72 | button:focus-visible {
73 | outline: 4px auto -webkit-focus-ring-color;
74 | }
75 |
76 | @media (prefers-color-scheme: light) {
77 | :root {
78 | color: #213547;
79 | background-color: #ffffff;
80 | }
81 | a:hover {
82 | color: #747bff;
83 | }
84 | button {
85 | background-color: #f9f9f9;
86 | }
87 | }
88 |
89 | /* sm: apply styles for screens ≥640px */
90 | @media (min-width: 640px) {
91 | span,
92 | body,
93 | p,
94 | label {
95 | @apply text-base;
96 | }
97 | h1 {
98 | @apply text-4xl;
99 | }
100 | h2 {
101 | @apply text-3xl;
102 | }
103 | h3 {
104 | @apply text-2xl;
105 | }
106 | }
107 |
108 | /* md: apply styles for screens ≥768px */
109 | @media (min-width: 768px) {
110 | span,
111 | body,
112 | p,
113 | label {
114 | @apply text-xl;
115 | }
116 | h1 {
117 | @apply text-5xl;
118 | }
119 | h2 {
120 | @apply text-4xl;
121 | }
122 | h3 {
123 | @apply text-3xl;
124 | }
125 | }
126 |
127 | /* lg: apply styles for screens ≥1024px */
128 | @media (min-width: 1024px) {
129 | span,
130 | body,
131 | p,
132 | label {
133 | @apply text-xl;
134 | }
135 | h1 {
136 | @apply text-6xl;
137 | }
138 | h2 {
139 | @apply text-5xl;
140 | }
141 | h3 {
142 | @apply text-4xl;
143 | }
144 | }
145 |
146 | /* Chrome */
147 | @media screen and (-webkit-min-device-pixel-ratio: 0) {
148 | body {
149 | -webkit-text-size-adjust: 100%;
150 | }
151 | }
152 |
153 | /* Firefox */
154 | @-moz-document url-prefix() {
155 | body {
156 | -moz-text-size-adjust: 100%;
157 | text-size-adjust: 100%;
158 | }
159 | }
160 |
--------------------------------------------------------------------------------
/site/src/components/LinksSection.tsx:
--------------------------------------------------------------------------------
1 | import GitHubMark from "/assets/github-mark/github-mark-white.svg";
2 | import NpmLogo from "/assets/npm-logo-red.svg";
3 | import { Link } from "react-router-dom";
4 |
5 | function LinksSection() {
6 | return (
7 |
87 | Loading...
}>{routes}
88 |
9 |
14 | 
19 | NPM
20 |
21 |
26 | 
31 | GitHub
32 |
33 |
34 |
35 |
41 | Documentation
42 |
43 |
49 | About
50 |
51 |
52 |
53 |
80 |
54 |
79 |
55 | ⚡
56 | 1d, 2d, complex, real
57 |
58 |
59 | ⚡
60 | Auto-optimized FFT algorithms
61 |
62 |
63 | ⚡
64 | Browser-specific optimizations
65 |
66 |
67 | ⚡
68 | SIMD WASM support
69 |
70 |
71 | ⚡
72 | Peak performance assurance
73 |
74 |
75 | ⚡
76 | Easy integration
77 |
78 |
104 | {(loading || benchmarkData) && (
105 |
127 |
137 | )}
138 |
139 | {/* Display table of all of the results here */}
140 | {/* Assuming you will populate the table with data fetched after the benchmarking */}
141 |
142 | 109 | Results 110 |
111 | )} 112 | 113 | {loading && ( 114 |
128 |
136 |
6 |
8 |
24 |
108 |
114 |
116 |
117 | );
118 | }
119 |
120 | export default About;
121 |
--------------------------------------------------------------------------------
/lib/mljs/fftlib.js:
--------------------------------------------------------------------------------
1 | // core operations
2 | let _n = 0; // order
3 | let _bitrev = null; // bit reversal table
4 | let _cstb = null; // sin/cos table
5 |
6 | function init(n) {
7 | if (n !== 0 && (n & (n - 1)) === 0) {
8 | _n = n;
9 | _initArray();
10 | _makeBitReversalTable();
11 | _makeCosSinTable();
12 | } else {
13 | throw new Error("init: radix-2 required");
14 | }
15 | }
16 |
17 | // 1D-FFT
18 | function fft1d(re, im) {
19 | fastFourierTransform(re, im, 1);
20 | }
21 |
22 | // 1D-IFFT
23 | function ifft1d(re, im) {
24 | let n = 1 / _n;
25 | fastFourierTransform(re, im, -1);
26 | for (let i = 0; i < _n; i++) {
27 | re[i] *= n;
28 | im[i] *= n;
29 | }
30 | }
31 |
32 | // 1D-IFFT
33 | function bt1d(re, im) {
34 | fastFourierTransform(re, im, -1);
35 | }
36 |
37 | // 2D-FFT Not very useful if the number of rows have to be equal to cols
38 | function fft2d(re, im) {
39 | let tre = [];
40 | let tim = [];
41 | let i = 0;
42 | // x-axis
43 | for (let y = 0; y < _n; y++) {
44 | i = y * _n;
45 | for (let x1 = 0; x1 < _n; x1++) {
46 | tre[x1] = re[x1 + i];
47 | tim[x1] = im[x1 + i];
48 | }
49 | fft1d(tre, tim);
50 | for (let x2 = 0; x2 < _n; x2++) {
51 | re[x2 + i] = tre[x2];
52 | im[x2 + i] = tim[x2];
53 | }
54 | }
55 | // y-axis
56 | for (let x = 0; x < _n; x++) {
57 | for (let y1 = 0; y1 < _n; y1++) {
58 | i = x + y1 * _n;
59 | tre[y1] = re[i];
60 | tim[y1] = im[i];
61 | }
62 | fft1d(tre, tim);
63 | for (let y2 = 0; y2 < _n; y2++) {
64 | i = x + y2 * _n;
65 | re[i] = tre[y2];
66 | im[i] = tim[y2];
67 | }
68 | }
69 | }
70 |
71 | // 2D-IFFT
72 | function ifft2d(re, im) {
73 | let tre = [];
74 | let tim = [];
75 | let i = 0;
76 | // x-axis
77 | for (let y = 0; y < _n; y++) {
78 | i = y * _n;
79 | for (let x1 = 0; x1 < _n; x1++) {
80 | tre[x1] = re[x1 + i];
81 | tim[x1] = im[x1 + i];
82 | }
83 | ifft1d(tre, tim);
84 | for (let x2 = 0; x2 < _n; x2++) {
85 | re[x2 + i] = tre[x2];
86 | im[x2 + i] = tim[x2];
87 | }
88 | }
89 | // y-axis
90 | for (let x = 0; x < _n; x++) {
91 | for (let y1 = 0; y1 < _n; y1++) {
92 | i = x + y1 * _n;
93 | tre[y1] = re[i];
94 | tim[y1] = im[i];
95 | }
96 | ifft1d(tre, tim);
97 | for (let y2 = 0; y2 < _n; y2++) {
98 | i = x + y2 * _n;
99 | re[i] = tre[y2];
100 | im[i] = tim[y2];
101 | }
102 | }
103 | }
104 |
105 | // core operation of FFT
106 | function fastFourierTransform(re, im, inv) {
107 | let d;
108 | let h;
109 | let ik;
110 | let m;
111 | let tmp;
112 | let wr;
113 | let wi;
114 | let xr;
115 | let xi;
116 | let n4 = _n >> 2;
117 | // bit reversal
118 | for (let l = 0; l < _n; l++) {
119 | m = _bitrev[l];
120 | if (l < m) {
121 | tmp = re[l];
122 | re[l] = re[m];
123 | re[m] = tmp;
124 | tmp = im[l];
125 | im[l] = im[m];
126 | im[m] = tmp;
127 | }
128 | }
129 | // butterfly operation
130 | for (let k = 1; k < _n; k <<= 1) {
131 | h = 0;
132 | d = _n / (k << 1);
133 | for (let j = 0; j < k; j++) {
134 | wr = _cstb[h + n4];
135 | wi = inv * _cstb[h];
136 | for (let i = j; i < _n; i += k << 1) {
137 | ik = i + k;
138 | xr = wr * re[ik] + wi * im[ik];
139 | xi = wr * im[ik] - wi * re[ik];
140 | re[ik] = re[i] - xr;
141 | re[i] += xr;
142 | im[ik] = im[i] - xi;
143 | im[i] += xi;
144 | }
145 | h += d;
146 | }
147 | }
148 | }
149 |
150 | // initialize the array (supports TypedArray)
151 | function _initArray() {
152 | if (typeof Uint32Array !== "undefined") {
153 | _bitrev = new Uint32Array(_n);
154 | } else {
155 | _bitrev = [];
156 | }
157 | if (typeof Float64Array !== "undefined") {
158 | _cstb = new Float64Array(_n * 1.25);
159 | } else {
160 | _cstb = [];
161 | }
162 | }
163 |
164 | //function _paddingZero() {
165 | // // TODO
166 | //}
167 |
168 | function _makeBitReversalTable() {
169 | let i = 0;
170 | let j = 0;
171 | let k = 0;
172 | _bitrev[0] = 0;
173 | while (++i < _n) {
174 | k = _n >> 1;
175 | while (k <= j) {
176 | j -= k;
177 | k >>= 1;
178 | }
179 | j += k;
180 | _bitrev[i] = j;
181 | }
182 | }
183 |
184 | // makes trigonometric function table
185 | function _makeCosSinTable() {
186 | let n2 = _n >> 1;
187 | let n4 = _n >> 2;
188 | let n8 = _n >> 3;
189 | let n2p4 = n2 + n4;
190 | let t = Math.sin(Math.PI / _n);
191 | let dc = 2 * t * t;
192 | let ds = Math.sqrt(dc * (2 - dc));
193 | let c = (_cstb[n4] = 1);
194 | let s = (_cstb[0] = 0);
195 | t = 2 * dc;
196 | for (let i = 1; i < n8; i++) {
197 | c -= dc;
198 | dc += t * c;
199 | s += ds;
200 | ds -= t * s;
201 | _cstb[i] = s;
202 | _cstb[n4 - i] = c;
203 | }
204 | if (n8 !== 0) {
205 | _cstb[n8] = Math.sqrt(0.5);
206 | }
207 | for (let j = 0; j < n4; j++) {
208 | _cstb[n2 - j] = _cstb[j];
209 | }
210 | for (let k = 0; k < n2p4; k++) {
211 | _cstb[k + n2] = -_cstb[k];
212 | }
213 | }
214 |
215 | const FFT = {
216 | init,
217 | fft1d,
218 | ifft1d,
219 | fft2d,
220 | ifft2d,
221 | fft: fft1d,
222 | ifft: ifft1d,
223 | bt: bt1d
224 | };
225 |
226 | export default FFT;
227 |
--------------------------------------------------------------------------------
/lib/utils/checkCapabilities.js:
--------------------------------------------------------------------------------
1 | // The following SIMD checkers were taken from 'wasm-feature-detect' NPM package:
2 | async function relaxedSimd() {
3 | return await WebAssembly.validate(
4 | new Uint8Array([
5 | 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 15,
6 | 1, 13, 0, 65, 1, 253, 15, 65, 2, 253, 15, 253, 128, 2, 11,
7 | ]),
8 | );
9 | }
10 |
11 | async function simd() {
12 | return await WebAssembly.validate(
13 | new Uint8Array([
14 | 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 10,
15 | 1, 8, 0, 65, 0, 253, 15, 253, 98, 11,
16 | ]),
17 | );
18 | }
19 |
20 | // Define the async function to check for Wasm and SIMD support
21 | async function checkBrowserCapabilities() {
22 | let browserName = "Other";
23 | let browserVersion = "Unknown";
24 | let osName = "Other";
25 | let osVersion = "Unknown";
26 | let uad = navigator.userAgentData;
27 | let ua = navigator.userAgent;
28 |
29 | // Check if Edge, Chrome, or Opera (uses User Agent Data API)
30 | try {
31 | if (uad) {
32 | const values = await uad.getHighEntropyValues([
33 | "architecture",
34 | "model",
35 | "platform",
36 | "platformVersion",
37 | "uaFullVersion",
38 | ]);
39 |
40 | const brandInfo = uad.brands.find((brand) =>
41 | ["Microsoft Edge", "Google Chrome", "Opera"].includes(brand.brand),
42 | );
43 | browserName = brandInfo ? brandInfo.brand : "Other";
44 | browserVersion = brandInfo ? `v${brandInfo.version}` : "Unknown";
45 | osName = values.platform ? values.platform : "Other";
46 | osVersion = values.platformVersion
47 | ? `v${values.platformVersion}`
48 | : "Unknown";
49 | }
50 |
51 | // user agent string parsing for mobile and firefox, safari
52 | // other browsers included in case mobile
53 | if (browserName === "Other" || osName === "Other") {
54 | const uaArr = ua.split(" ");
55 | const uaBrowser = uaArr[uaArr.length - 1];
56 | const isFirefox = /Firefox/.test(uaBrowser);
57 | // CriOS is Chrome for iOS and Chrome is Chrome for Android
58 | const isSafari =
59 | /Safari/.test(uaBrowser) &&
60 | !/CriOS/.test(uaBrowser) &&
61 | !/Chrome/.test(uaBrowser);
62 | const isChrome = /CriOS/.test(uaBrowser) || /Chrome/.test(uaBrowser);
63 | const isEdge = /Edg/.test(uaBrowser);
64 | const isOpera = /OPR/.test(uaBrowser);
65 |
66 | const browsers = [
67 | {
68 | name: "Mozilla Firefox",
69 | regex: /Firefox\/(\d+\.\d+)/,
70 | flag: isFirefox,
71 | },
72 | { name: "Safari", regex: /Version\/(\d+\.\d+)/, flag: isSafari },
73 | {
74 | name: "Google Chrome",
75 | regex: /CriOS|Chrome\/(\d+\.\d+)/,
76 | flag: isChrome,
77 | },
78 | { name: "Microsoft Edge", regex: /Edg\/(\d+\.\d+)/, flag: isEdge },
79 | { name: "Opera", regex: /OPR\/(\d+\.\d+)/, flag: isOpera },
80 | ];
81 |
82 | for (const browser of browsers) {
83 | if (browser.flag) {
84 | browserName = browser.name;
85 | const versionMatch = uaBrowser.match(browser.regex);
86 | browserVersion = versionMatch ? versionMatch[1] : "Unknown";
87 | break;
88 | }
89 | }
90 |
91 | const osMatch = ua.match(/\(([^)]+)\)/);
92 | const osDetails = osMatch ? osMatch[1].split("; ") : [];
93 | console.log(osMatch);
94 | console.log(osDetails);
95 |
96 | const windowsVersionMap = {
97 | "10.0": "10",
98 | "6.3": "8.1",
99 | "6.2": "8",
100 | "6.1": "7",
101 | "6.0": "Vista",
102 | "5.2": "XP 64-bit",
103 | "5.1": "XP",
104 | "5.0": "2000",
105 | };
106 |
107 | const osInfo = [
108 | {
109 | name: "Windows",
110 | regex: /Windows NT/,
111 | transform: (s) => windowsVersionMap[s.split(" ")[2]],
112 | index: 0,
113 | },
114 | {
115 | name: "Mac OS X",
116 | regex: /Mac OS X/,
117 | transform: (s) => s.replace("_", ".").split(" ")[3],
118 | index: 0,
119 | },
120 | {
121 | name: "Linux",
122 | regex: /Linux/,
123 | transform: () => "Unknown", // Precise Linux version can be difficult to determine
124 | index: 0,
125 | },
126 | {
127 | name: "Android",
128 | regex: /Android/,
129 | transform: (s) => s.split(" ")[1],
130 | index: 0,
131 | },
132 | {
133 | name: "iOS",
134 | regex: /iPhone/,
135 | transform: (s) => s.split(" ")[1].replace("_", "."),
136 | index: 0,
137 | },
138 | ];
139 |
140 | for (const os of osInfo) {
141 | if (os.regex.test(osDetails[0])) {
142 | osName = os.name;
143 | console.log(`osDetails: ${osDetails}`);
144 | osVersion = os.transform
145 | ? os.transform(osDetails[1])
146 | : os.versionMap[osDetails[1].split(" ")[os.index]];
147 | break;
148 | }
149 | }
150 | }
151 | } catch (error) {
152 | console.error("Could not retrieve user agent data", error);
153 | }
154 | return {
155 | browserName: browserName,
156 | browserVersion: browserVersion,
157 | osName: osName,
158 | osVersion: osVersion,
159 | wasm: typeof WebAssembly === "object",
160 | relaxedSimd: await relaxedSimd(),
161 | simd: await simd(),
162 | };
163 | }
164 |
165 | // Export the function
166 | export default checkBrowserCapabilities;
167 |
--------------------------------------------------------------------------------
/lib/vailNOTFINISHED/twiddle.cjs:
--------------------------------------------------------------------------------
1 | /**
2 | * Bit twiddling hacks for JavaScript.
3 | *
4 | * Author: Mikola Lysenko
5 | *
6 | * Ported from Stanford bit twiddling hack library:
7 | * http://graphics.stanford.edu/~seander/bithacks.html
8 | */
9 |
10 | "use strict";
11 | "use restrict";
12 |
13 | //Number of bits in an integer
14 | var INT_BITS = 32;
15 |
16 | //Constants
17 | exports.INT_BITS = INT_BITS;
18 | exports.INT_MAX = 0x7fffffff;
19 | exports.INT_MIN = -1 << (INT_BITS - 1);
20 |
21 | //Returns -1, 0, +1 depending on sign of x
22 | exports.sign = function (v) {
23 | return (v > 0) - (v < 0);
24 | };
25 |
26 | //Computes absolute value of integer
27 | exports.abs = function (v) {
28 | var mask = v >> (INT_BITS - 1);
29 | return (v ^ mask) - mask;
30 | };
31 |
32 | //Computes minimum of integers x and y
33 | exports.min = function (x, y) {
34 | return y ^ ((x ^ y) & -(x < y));
35 | };
36 |
37 | //Computes maximum of integers x and y
38 | exports.max = function (x, y) {
39 | return x ^ ((x ^ y) & -(x < y));
40 | };
41 |
42 | //Checks if a number is a power of two
43 | exports.isPow2 = function (v) {
44 | return !(v & (v - 1)) && !!v;
45 | };
46 |
47 | //Computes log base 2 of v
48 | exports.log2 = function (v) {
49 | var r, shift;
50 | r = (v > 0xffff) << 4;
51 | v >>>= r;
52 | shift = (v > 0xff) << 3;
53 | v >>>= shift;
54 | r |= shift;
55 | shift = (v > 0xf) << 2;
56 | v >>>= shift;
57 | r |= shift;
58 | shift = (v > 0x3) << 1;
59 | v >>>= shift;
60 | r |= shift;
61 | return r | (v >> 1);
62 | };
63 |
64 | //Computes log base 10 of v
65 | exports.log10 = function (v) {
66 | return v >= 1000000000
67 | ? 9
68 | : v >= 100000000
69 | ? 8
70 | : v >= 10000000
71 | ? 7
72 | : v >= 1000000
73 | ? 6
74 | : v >= 100000
75 | ? 5
76 | : v >= 10000
77 | ? 4
78 | : v >= 1000
79 | ? 3
80 | : v >= 100
81 | ? 2
82 | : v >= 10
83 | ? 1
84 | : 0;
85 | };
86 |
87 | //Counts number of bits
88 | exports.popCount = function (v) {
89 | v = v - ((v >>> 1) & 0x55555555);
90 | v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
91 | return (((v + (v >>> 4)) & 0xf0f0f0f) * 0x1010101) >>> 24;
92 | };
93 |
94 | //Counts number of trailing zeros
95 | function countTrailingZeros(v) {
96 | var c = 32;
97 | v &= -v;
98 | if (v) c--;
99 | if (v & 0x0000ffff) c -= 16;
100 | if (v & 0x00ff00ff) c -= 8;
101 | if (v & 0x0f0f0f0f) c -= 4;
102 | if (v & 0x33333333) c -= 2;
103 | if (v & 0x55555555) c -= 1;
104 | return c;
105 | }
106 | exports.countTrailingZeros = countTrailingZeros;
107 |
108 | //Rounds to next power of 2
109 | exports.nextPow2 = function (v) {
110 | v += v === 0;
111 | --v;
112 | v |= v >>> 1;
113 | v |= v >>> 2;
114 | v |= v >>> 4;
115 | v |= v >>> 8;
116 | v |= v >>> 16;
117 | return v + 1;
118 | };
119 |
120 | //Rounds down to previous power of 2
121 | exports.prevPow2 = function (v) {
122 | v |= v >>> 1;
123 | v |= v >>> 2;
124 | v |= v >>> 4;
125 | v |= v >>> 8;
126 | v |= v >>> 16;
127 | return v - (v >>> 1);
128 | };
129 |
130 | //Computes parity of word
131 | exports.parity = function (v) {
132 | v ^= v >>> 16;
133 | v ^= v >>> 8;
134 | v ^= v >>> 4;
135 | v &= 0xf;
136 | return (0x6996 >>> v) & 1;
137 | };
138 |
139 | var REVERSE_TABLE = new Array(256);
140 |
141 | (function (tab) {
142 | for (var i = 0; i < 256; ++i) {
143 | var v = i,
144 | r = i,
145 | s = 7;
146 | for (v >>>= 1; v; v >>>= 1) {
147 | r <<= 1;
148 | r |= v & 1;
149 | --s;
150 | }
151 | tab[i] = (r << s) & 0xff;
152 | }
153 | })(REVERSE_TABLE);
154 |
155 | //Reverse bits in a 32 bit word
156 | exports.reverse = function (v) {
157 | return (
158 | (REVERSE_TABLE[v & 0xff] << 24) |
159 | (REVERSE_TABLE[(v >>> 8) & 0xff] << 16) |
160 | (REVERSE_TABLE[(v >>> 16) & 0xff] << 8) |
161 | REVERSE_TABLE[(v >>> 24) & 0xff]
162 | );
163 | };
164 |
165 | //Interleave bits of 2 coordinates with 16 bits. Useful for fast quadtree codes
166 | exports.interleave2 = function (x, y) {
167 | x &= 0xffff;
168 | x = (x | (x << 8)) & 0x00ff00ff;
169 | x = (x | (x << 4)) & 0x0f0f0f0f;
170 | x = (x | (x << 2)) & 0x33333333;
171 | x = (x | (x << 1)) & 0x55555555;
172 |
173 | y &= 0xffff;
174 | y = (y | (y << 8)) & 0x00ff00ff;
175 | y = (y | (y << 4)) & 0x0f0f0f0f;
176 | y = (y | (y << 2)) & 0x33333333;
177 | y = (y | (y << 1)) & 0x55555555;
178 |
179 | return x | (y << 1);
180 | };
181 |
182 | //Extracts the nth interleaved component
183 | exports.deinterleave2 = function (v, n) {
184 | v = (v >>> n) & 0x55555555;
185 | v = (v | (v >>> 1)) & 0x33333333;
186 | v = (v | (v >>> 2)) & 0x0f0f0f0f;
187 | v = (v | (v >>> 4)) & 0x00ff00ff;
188 | v = (v | (v >>> 16)) & 0x000ffff;
189 | return (v << 16) >> 16;
190 | };
191 |
192 | //Interleave bits of 3 coordinates, each with 10 bits. Useful for fast octree codes
193 | exports.interleave3 = function (x, y, z) {
194 | x &= 0x3ff;
195 | x = (x | (x << 16)) & 4278190335;
196 | x = (x | (x << 8)) & 251719695;
197 | x = (x | (x << 4)) & 3272356035;
198 | x = (x | (x << 2)) & 1227133513;
199 |
200 | y &= 0x3ff;
201 | y = (y | (y << 16)) & 4278190335;
202 | y = (y | (y << 8)) & 251719695;
203 | y = (y | (y << 4)) & 3272356035;
204 | y = (y | (y << 2)) & 1227133513;
205 | x |= y << 1;
206 |
207 | z &= 0x3ff;
208 | z = (z | (z << 16)) & 4278190335;
209 | z = (z | (z << 8)) & 251719695;
210 | z = (z | (z << 4)) & 3272356035;
211 | z = (z | (z << 2)) & 1227133513;
212 |
213 | return x | (z << 2);
214 | };
215 |
216 | //Extracts nth interleaved component of a 3-tuple
217 | exports.deinterleave3 = function (v, n) {
218 | v = (v >>> n) & 1227133513;
219 | v = (v | (v >>> 2)) & 3272356035;
220 | v = (v | (v >>> 4)) & 251719695;
221 | v = (v | (v >>> 8)) & 4278190335;
222 | v = (v | (v >>> 16)) & 0x3ff;
223 | return (v << 22) >> 22;
224 | };
225 |
226 | //Computes next combination in colexicographic order (this is mistakenly called nextPermutation on the bit twiddling hacks page)
227 | exports.nextCombination = function (v) {
228 | var t = v | (v - 1);
229 | return (t + 1) | (((~t & -~t) - 1) >>> (countTrailingZeros(v) + 1));
230 | };
231 |
--------------------------------------------------------------------------------
/lib/indutnymodified/fft.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | /* Modification Notes
4 | - Removing the inv part increased it by 3% or so
5 | - Simplifying transform hurt because i was repeating the same math
6 | - getting rid of the wrapper imrpoved it by like 1%
7 | */
8 |
9 | function IndutnyModifiedFftWrapperJavascript(size) {
10 | this.size = size;
11 |
12 | this._csize = size << 1;
13 |
14 | var table = new Array(this.size * 2);
15 | for (var i = 0; i < table.length; i += 2) {
16 | const angle = (Math.PI * i) / this.size;
17 | table[i] = Math.cos(angle);
18 | table[i + 1] = -Math.sin(angle);
19 | }
20 | this.table = table;
21 |
22 | // Find size's power of two
23 | var power = 0;
24 | for (var t = 1; this.size > t; t <<= 1) power++;
25 |
26 | // Calculate initial step's width, either 4 or 8 depending on the fftsize
27 | this._width = power % 2 === 0 ? power - 1 : power;
28 |
29 | // Pre-compute bit-reversal patterns
30 | this._bitrev = new Array(1 << this._width);
31 | for (var j = 0; j < this._bitrev.length; j++) {
32 | this._bitrev[j] = 0;
33 | for (var shift = 0; shift < this._width; shift += 2) {
34 | var revShift = this._width - shift - 2;
35 | this._bitrev[j] |= ((j >>> shift) & 3) << revShift;
36 | }
37 | }
38 |
39 | this._data = null;
40 | }
41 |
42 | // FFT
43 | IndutnyModifiedFftWrapperJavascript.prototype.fft = function fft(data) {
44 | this._data = data;
45 | this._out = new Float32Array(2 * this.size);
46 | var size = this._csize;
47 |
48 | // Initial step (permute and transform)
49 | var step = 1 << this._width;
50 | var len = (size / step) << 1;
51 |
52 | var outOff;
53 | var t;
54 | var bitrev = this._bitrev;
55 | // len is either 4 or 8, and both are used for the common fft sizes
56 | if (len === 4) {
57 | for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
58 | const off = bitrev[t];
59 | this._singleTransform2(outOff, off, step);
60 | }
61 | } else {
62 | for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
63 | const off = bitrev[t];
64 | this._singleTransform4(outOff, off, step);
65 | }
66 | }
67 |
68 | // Loop through steps in decreasing order
69 | for (step >>= 2; step >= 2; step >>= 2) {
70 | len = (size / step) << 1;
71 | var quarterLen = len >>> 2;
72 |
73 | // Loop through offsets in the data
74 | for (outOff = 0; outOff < size; outOff += len) {
75 | // Full case
76 | var limit = outOff + quarterLen;
77 | for (var i = outOff, k = 0; i < limit; i += 2, k += step) {
78 | const A = i;
79 | const B = A + quarterLen;
80 | const C = B + quarterLen;
81 | const D = C + quarterLen;
82 |
83 | // Original values
84 | const Ar = this._out[A];
85 | const Ai = this._out[A + 1];
86 | const Br = this._out[B];
87 | const Bi = this._out[B + 1];
88 | const Cr = this._out[C];
89 | const Ci = this._out[C + 1];
90 | const Dr = this._out[D];
91 | const Di = this._out[D + 1];
92 |
93 | // Middle values
94 | const MAr = Ar;
95 | const MAi = Ai;
96 |
97 | const tableBr = this.table[k];
98 | const tableBi = this.table[k + 1];
99 | const MBr = Br * tableBr - Bi * tableBi;
100 | const MBi = Br * tableBi + Bi * tableBr;
101 |
102 | const tableCr = this.table[2 * k];
103 | const tableCi = this.table[2 * k + 1];
104 | const MCr = Cr * tableCr - Ci * tableCi;
105 | const MCi = Cr * tableCi + Ci * tableCr;
106 |
107 | const tableDr = this.table[3 * k];
108 | const tableDi = this.table[3 * k + 1];
109 | const MDr = Dr * tableDr - Di * tableDi;
110 | const MDi = Dr * tableDi + Di * tableDr;
111 |
112 | // Pre-Final values
113 | const T0r = MAr + MCr;
114 | const T0i = MAi + MCi;
115 | const T1r = MAr - MCr;
116 | const T1i = MAi - MCi;
117 | const T2r = MBr + MDr;
118 | const T2i = MBi + MDi;
119 | const T3r = MBr - MDr;
120 | const T3i = MBi - MDi;
121 |
122 | this._out[A] = T0r + T2r;
123 | this._out[A + 1] = T0i + T2i;
124 | this._out[B] = T1r + T3i;
125 | this._out[B + 1] = T1i - T3r;
126 | this._out[C] = T0r - T2r;
127 | this._out[C + 1] = T0i - T2i;
128 | this._out[D] = T1r - T3i;
129 | this._out[D + 1] = T1i + T3r;
130 | }
131 | }
132 | }
133 |
134 | return this._out;
135 | };
136 |
137 | // radix-2 (called for len=4)
138 | IndutnyModifiedFftWrapperJavascript.prototype._singleTransform2 =
139 | function _singleTransform2(outOff, off, step) {
140 | const evenR = this._data[off];
141 | const evenI = this._data[off + 1];
142 | const oddR = this._data[off + step];
143 | const oddI = this._data[off + step + 1];
144 |
145 | this._out[outOff] = evenR + oddR;
146 | this._out[outOff + 1] = evenI + oddI;
147 | this._out[outOff + 2] = evenR - oddR;
148 | this._out[outOff + 3] = evenI - oddI;
149 | };
150 |
151 | // radix-4 (called for len=8)
152 | IndutnyModifiedFftWrapperJavascript.prototype._singleTransform4 =
153 | function _singleTransform4(outOff, off, step) {
154 | const step2 = step * 2;
155 | const step3 = step * 3;
156 |
157 | const Ar = this._data[off];
158 | const Ai = this._data[off + 1];
159 | const Br = this._data[off + step];
160 | const Bi = this._data[off + step + 1];
161 | const Cr = this._data[off + step2];
162 | const Ci = this._data[off + step2 + 1];
163 | const Dr = this._data[off + step3];
164 | const Di = this._data[off + step3 + 1];
165 |
166 | const T0r = Ar + Cr;
167 | const T0i = Ai + Ci;
168 | const T1r = Ar - Cr;
169 | const T1i = Ai - Ci;
170 | const T2r = Br + Dr;
171 | const T2i = Bi + Di;
172 | const T3r = Br - Dr;
173 | const T3i = Bi - Di;
174 |
175 | this._out[outOff] = T0r + T2r;
176 | this._out[outOff + 1] = T0i + T2i;
177 | this._out[outOff + 2] = T1r + T3i;
178 | this._out[outOff + 3] = T1i - T3r;
179 | this._out[outOff + 4] = T0r - T2r;
180 | this._out[outOff + 5] = T0i - T2i;
181 | this._out[outOff + 6] = T1r - T3i;
182 | this._out[outOff + 7] = T1i + T3r;
183 | };
184 |
185 | export default IndutnyModifiedFftWrapperJavascript;
186 |
--------------------------------------------------------------------------------
/lib/dntj/fft.js:
--------------------------------------------------------------------------------
1 | import * as complex_array from "./complex_array.js";
2 |
3 | ("use strict");
4 |
5 | var ComplexArray = complex_array.ComplexArray,
6 | // Math constants and functions we need.
7 | PI = Math.PI,
8 | SQRT1_2 = Math.SQRT1_2,
9 | sqrt = Math.sqrt,
10 | cos = Math.cos,
11 | sin = Math.sin;
12 |
13 | ComplexArray.prototype.FFT = function () {
14 | return internalFFT(this, false);
15 | };
16 |
17 | export function FFT(input) {
18 | return ensureComplexArray(input).FFT();
19 | }
20 |
21 | ComplexArray.prototype.InvFFT = function () {
22 | return internalFFT(this, true);
23 | };
24 |
25 | export function InvFFT(input) {
26 | return ensureComplexArray(input).InvFFT();
27 | }
28 |
29 | // Applies a frequency-space filter to input, and returns the real-space
30 | // filtered input.
31 | // filterer accepts freq, i, n and modifies freq.real and freq.imag.
32 | ComplexArray.prototype.frequencyMap = function (filterer) {
33 | return this.FFT().map(filterer).InvFFT();
34 | };
35 |
36 | export function frequencyMap(input, filterer) {
37 | return ensureComplexArray(input).frequencyMap(filterer);
38 | }
39 |
40 | function ensureComplexArray(input) {
41 | return (complex_array.isComplexArray(input) && input) || new ComplexArray(input);
42 | }
43 |
44 | function internalFFT(input, inverse) {
45 | var n = input.length;
46 |
47 | if (n & (n - 1)) {
48 | return FFT_Recursive(input, inverse);
49 | } else {
50 | return FFT_2_Iterative(input, inverse);
51 | }
52 | }
53 |
54 | function FFT_Recursive(input, inverse) {
55 | var n = input.length,
56 | // Counters.
57 | i,
58 | j,
59 | output,
60 | // Complex multiplier and its delta.
61 | f_r,
62 | f_i,
63 | del_f_r,
64 | del_f_i,
65 | // Lowest divisor and remainder.
66 | p,
67 | m,
68 | normalisation,
69 | recursive_result,
70 | _swap,
71 | _real,
72 | _imag;
73 |
74 | if (n === 1) {
75 | return input;
76 | }
77 |
78 | output = new ComplexArray(n, input.ArrayType);
79 |
80 | // Use the lowest odd factor, so we are able to use FFT_2_Iterative in the
81 | // recursive transforms optimally.
82 | p = LowestOddFactor(n);
83 | m = n / p;
84 | normalisation = 1 / sqrt(p);
85 | recursive_result = new ComplexArray(m, input.ArrayType);
86 |
87 | // Loops go like O(n Σ p_i), where p_i are the prime factors of n.
88 | // for a power of a prime, p, this reduces to O(n p log_p n)
89 | for (j = 0; j < p; j++) {
90 | for (i = 0; i < m; i++) {
91 | recursive_result.real[i] = input.real[i * p + j];
92 | recursive_result.imag[i] = input.imag[i * p + j];
93 | }
94 | // Don't go deeper unless necessary to save allocs.
95 | if (m > 1) {
96 | recursive_result = internalFFT(recursive_result, inverse);
97 | }
98 |
99 | del_f_r = cos((2 * PI * j) / n);
100 | del_f_i = (inverse ? -1 : 1) * sin((2 * PI * j) / n);
101 | f_r = 1;
102 | f_i = 0;
103 |
104 | for (i = 0; i < n; i++) {
105 | _real = recursive_result.real[i % m];
106 | _imag = recursive_result.imag[i % m];
107 |
108 | output.real[i] += f_r * _real - f_i * _imag;
109 | output.imag[i] += f_r * _imag + f_i * _real;
110 |
111 | _swap = f_r * del_f_r - f_i * del_f_i;
112 | f_i = f_r * del_f_i + f_i * del_f_r;
113 | f_r = _swap;
114 | }
115 | }
116 |
117 | // Copy back to input to match FFT_2_Iterative in-placeness
118 | // TODO: faster way of making this in-place?
119 | for (i = 0; i < n; i++) {
120 | input.real[i] = normalisation * output.real[i];
121 | input.imag[i] = normalisation * output.imag[i];
122 | }
123 |
124 | return input;
125 | }
126 |
127 | function FFT_2_Iterative(input, inverse) {
128 | var n = input.length,
129 | // Counters.
130 | i,
131 | j,
132 | output,
133 | output_r,
134 | output_i,
135 | // Complex multiplier and its delta.
136 | f_r,
137 | f_i,
138 | del_f_r,
139 | del_f_i,
140 | temp,
141 | // Temporary loop variables.
142 | l_index,
143 | r_index,
144 | left_r,
145 | left_i,
146 | right_r,
147 | right_i,
148 | // width of each sub-array for which we're iteratively calculating FFT.
149 | width;
150 |
151 | output = BitReverseComplexArray(input);
152 | output_r = output.real;
153 | output_i = output.imag;
154 | // Loops go like O(n log n):
155 | // width ~ log n; i,j ~ n
156 | width = 1;
157 | while (width < n) {
158 | del_f_r = cos(PI / width);
159 | del_f_i = (inverse ? -1 : 1) * sin(PI / width);
160 | for (i = 0; i < n / (2 * width); i++) {
161 | f_r = 1;
162 | f_i = 0;
163 | for (j = 0; j < width; j++) {
164 | l_index = 2 * i * width + j;
165 | r_index = l_index + width;
166 |
167 | left_r = output_r[l_index];
168 | left_i = output_i[l_index];
169 | right_r = f_r * output_r[r_index] - f_i * output_i[r_index];
170 | right_i = f_i * output_r[r_index] + f_r * output_i[r_index];
171 |
172 | output_r[l_index] = SQRT1_2 * (left_r + right_r);
173 | output_i[l_index] = SQRT1_2 * (left_i + right_i);
174 | output_r[r_index] = SQRT1_2 * (left_r - right_r);
175 | output_i[r_index] = SQRT1_2 * (left_i - right_i);
176 | temp = f_r * del_f_r - f_i * del_f_i;
177 | f_i = f_r * del_f_i + f_i * del_f_r;
178 | f_r = temp;
179 | }
180 | }
181 | width <<= 1;
182 | }
183 |
184 | return output;
185 | }
186 |
187 | function BitReverseIndex(index, n) {
188 | var bitreversed_index = 0;
189 |
190 | while (n > 1) {
191 | bitreversed_index <<= 1;
192 | bitreversed_index += index & 1;
193 | index >>= 1;
194 | n >>= 1;
195 | }
196 | return bitreversed_index;
197 | }
198 |
199 | function BitReverseComplexArray(array) {
200 | var n = array.length,
201 | flips = {},
202 | swap,
203 | i;
204 |
205 | for (i = 0; i < n; i++) {
206 | var r_i = BitReverseIndex(i, n);
207 |
208 | if (flips.hasOwnProperty(i) || flips.hasOwnProperty(r_i)) continue;
209 |
210 | swap = array.real[r_i];
211 | array.real[r_i] = array.real[i];
212 | array.real[i] = swap;
213 |
214 | swap = array.imag[r_i];
215 | array.imag[r_i] = array.imag[i];
216 | array.imag[i] = swap;
217 |
218 | flips[i] = flips[r_i] = true;
219 | }
220 |
221 | return array;
222 | }
223 |
224 | function LowestOddFactor(n) {
225 | var factor = 3,
226 | sqrt_n = sqrt(n);
227 |
228 | while (factor <= sqrt_n) {
229 | if (n % factor === 0) return factor;
230 | factor = factor + 2;
231 | }
232 | return n;
233 | }
234 |
--------------------------------------------------------------------------------
/tests/fft.test.js:
--------------------------------------------------------------------------------
1 | import { expect, test } from "vitest";
2 | import webfft from "../lib/main.js";
3 |
4 | test("basic usage", () => {
5 | const fftsize = 1024;
6 | const fft = new webfft(fftsize);
7 | const inputArr = new Float32Array(fftsize * 2);
8 | for (let i = 0; i < fftsize * 2; i++) {
9 | inputArr[i] = i * 1.12312312; // Arbitrary
10 | }
11 | const outputArr = fft.fft(inputArr);
12 | expect(outputArr[0]).not.toBe(0);
13 | expect(outputArr.length).toBe(2 * fftsize);
14 | fft.dispose();
15 | });
16 |
17 | test("available sublibraries", () => {
18 | const fft = new webfft(1024);
19 | const availableSubLibraries = fft.availableSubLibraries();
20 | expect(availableSubLibraries.length).toBeGreaterThan(1);
21 | fft.dispose();
22 | });
23 |
24 | test("outputs for all sublibs approx match using different fftsizes", () => {
25 | const fftsizes = [
26 | 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
27 | 16384, 32768, 65536, 131072,
28 | ];
29 | for (let j = 0; j < fftsizes.length; j++) {
30 | const fftsize = fftsizes[j];
31 | const fft = new webfft(fftsize);
32 |
33 | const availableSubLibraries = fft.availableSubLibraries();
34 |
35 | const inputArr = new Float32Array(fftsize * 2);
36 | for (let i = 0; i < fftsize * 2; i++) {
37 | inputArr[i] = i * 1.12312312; // Arbitrary
38 | }
39 |
40 | fft.setSubLibrary("indutnyJavascript");
41 | let co = fft.fft(inputArr);
42 | let goldenTotal = 0;
43 | for (let k = 0; k < fftsize; ++k) {
44 | goldenTotal += Math.sqrt(
45 | co[k * 2] * co[k * 2] + co[k * 2 + 1] * co[k * 2 + 1],
46 | );
47 | }
48 | goldenTotal = goldenTotal / fftsize / fftsize;
49 |
50 | // Try each sub-library
51 | for (let i = 0; i < availableSubLibraries.length; i++) {
52 | fft.setSubLibrary(availableSubLibraries[i]);
53 | co = fft.fft(inputArr);
54 | let total = 0;
55 | for (let k = 0; k < fftsize; ++k) {
56 | total += Math.sqrt(
57 | co[k * 2] * co[k * 2] + co[k * 2 + 1] * co[k * 2 + 1],
58 | );
59 | }
60 | total = total / fftsize / fftsize;
61 | expect(total).toBeCloseTo(goldenTotal, 5);
62 | }
63 |
64 | fft.dispose();
65 | }
66 | });
67 |
68 | test("fftr", () => {
69 | const fftsize = 1024;
70 | const fft = new webfft(fftsize);
71 |
72 | const availableSubLibraries = fft.availableSubLibraries();
73 |
74 | const inputArr = new Float32Array(fftsize);
75 | for (let i = 0; i < fftsize; i++) {
76 | inputArr[i] = i * 1.12312312; // Arbitrary
77 | }
78 |
79 | fft.setSubLibrary("indutnyJavascript");
80 | let co = fft.fftr(inputArr);
81 | let goldenTotal = 0;
82 | for (let k = 0; k < fftsize / 2; ++k) {
83 | goldenTotal += Math.sqrt(
84 | co[k * 2] * co[k * 2] + co[k * 2 + 1] * co[k * 2 + 1],
85 | );
86 | }
87 | goldenTotal = goldenTotal / fftsize;
88 |
89 | // Try each sub-library
90 | for (let i = 0; i < availableSubLibraries.length; i++) {
91 | fft.setSubLibrary(availableSubLibraries[i]);
92 | co = fft.fftr(inputArr);
93 | let total = 0;
94 | for (let k = 0; k < fftsize / 2; ++k) {
95 | total += Math.sqrt(co[k * 2] * co[k * 2] + co[k * 2 + 1] * co[k * 2 + 1]);
96 | }
97 | total = total / fftsize;
98 | expect(total).toBeCloseTo(goldenTotal, 3);
99 | }
100 |
101 | fft.dispose();
102 | });
103 |
104 | test("int16 inputs", () => {
105 | const fftsize = 1024;
106 | const fft = new webfft(fftsize);
107 |
108 | const availableSubLibraries = fft.availableSubLibraries();
109 |
110 | const inputArr = new Int16Array(fftsize * 2);
111 | for (let i = 0; i < fftsize * 2; i++) {
112 | inputArr[i] = i * 30; // Arbitrary
113 | }
114 |
115 | fft.setSubLibrary("indutnyJavascript");
116 | let co = fft.fft(inputArr);
117 | let goldenTotal = 0;
118 | for (let k = 0; k < fftsize; ++k) {
119 | goldenTotal += Math.sqrt(
120 | co[k * 2] * co[k * 2] + co[k * 2 + 1] * co[k * 2 + 1],
121 | );
122 | }
123 | goldenTotal = goldenTotal / fftsize;
124 |
125 | // Try each sub-library
126 | for (let i = 0; i < availableSubLibraries.length; i++) {
127 | fft.setSubLibrary(availableSubLibraries[i]);
128 | co = fft.fft(inputArr);
129 | let total = 0;
130 | for (let k = 0; k < fftsize; ++k) {
131 | total += Math.sqrt(co[k * 2] * co[k * 2] + co[k * 2 + 1] * co[k * 2 + 1]);
132 | }
133 | total = total / fftsize;
134 | expect(total).toBeCloseTo(goldenTotal, 1);
135 | }
136 |
137 | fft.dispose();
138 | });
139 |
140 | test("1000th element matches for all", () => {
141 | const fftsize = 1024;
142 | const fft = new webfft(fftsize);
143 |
144 | const availableSubLibraries = fft.availableSubLibraries();
145 |
146 | const inputArr = new Float32Array(fftsize * 2);
147 | for (let i = 0; i < fftsize * 2; i++) {
148 | inputArr[i] = i * 1.12312312; // Arbitrary
149 | }
150 |
151 | fft.setSubLibrary("indutnyJavascript");
152 | let co = fft.fft(inputArr);
153 | const goldenPhase = Math.atan(co[1000] / co[1001]);
154 | const goldenMag = Math.sqrt(co[1000] * co[1000] + co[1001] * co[1001]);
155 |
156 | // Try each sub-library
157 | for (let i = 0; i < availableSubLibraries.length; i++) {
158 | console.log("Testing", availableSubLibraries[i]);
159 | fft.setSubLibrary(availableSubLibraries[i]);
160 |
161 | co = fft.fft(inputArr);
162 | const phase = Math.atan(co[1000] / co[1001]);
163 | const mag = Math.sqrt(co[1000] * co[1000] + co[1001] * co[1001]);
164 | expect(phase).toBeCloseTo(goldenPhase, 5); // 2nd arg is the num digits after decimal point that must match
165 | expect(mag).toBeCloseTo(goldenMag, 2); // 2nd arg is the num digits after decimal point that must match
166 | }
167 |
168 | fft.dispose();
169 | });
170 |
171 | test("non power of 2 size", () => {
172 | expect(() => {
173 | const fft = new webfft(1023);
174 | }).toThrowError();
175 |
176 | const fft2 = new webfft(1024);
177 |
178 | // fft
179 | const inputArray = new Float32Array(1023 * 2);
180 | inputArray.fill(0);
181 | expect(() => {
182 | fft2.fft(inputArray);
183 | }).toThrowError();
184 |
185 | // fftr
186 | const inputArray2 = new Float32Array(1023);
187 | expect(() => {
188 | fft2.fftr(inputArray2);
189 | }).toThrowError();
190 |
191 | // fft2d inner
192 | const inputArray3 = [new Float32Array(1023 * 2), new Float32Array(1023 * 2)];
193 | expect(() => {
194 | fft2.fft2d(inputArray3);
195 | }).toThrowError();
196 |
197 | // fft2d outter
198 | const inputArray4 = [
199 | new Float32Array(1024 * 2),
200 | new Float32Array(1024 * 2),
201 | new Float32Array(1024 * 2),
202 | ];
203 | expect(() => {
204 | fft2.fft2d(inputArray4);
205 | }).toThrowError();
206 | });
207 |
208 | test("invalid sublibrary", () => {
209 | expect(() => {
210 | const fft = new webfft(1024, "notasublibrary");
211 | }).toThrowError();
212 | });
213 |
--------------------------------------------------------------------------------
/lib/nayukic/ffttest.c:
--------------------------------------------------------------------------------
1 | /*
2 | * FFT and convolution test (C)
3 | *
4 | * Copyright (c) 2014 Project Nayuki
5 | * http://www.nayuki.io/page/free-small-fft-in-multiple-languages
6 | *
7 | * (MIT License)
8 | * Permission is hereby granted, free of charge, to any person obtaining a copy of
9 | * this software and associated documentation files (the "Software"), to deal in
10 | * the Software without restriction, including without limitation the rights to
11 | * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 | * the Software, and to permit persons to whom the Software is furnished to do so,
13 | * subject to the following conditions:
14 | * - The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | * - The Software is provided "as is", without warranty of any kind, express or
17 | * implied, including but not limited to the warranties of merchantability,
18 | * fitness for a particular purpose and noninfringement. In no event shall the
19 | * authors or copyright holders be liable for any claim, damages or other
20 | * liability, whether in an action of contract, tort or otherwise, arising from,
21 | * out of or in connection with the Software or the use or other dealings in the
22 | * Software.
23 | */
24 |
25 | #include 12 | {" "} 13 | About WebFFT 14 |
15 | 16 |
17 | WebFFT started as part of a Microsoft internal Hackathon in 2023,
18 | motivated by the lack of actively maintained web-based FFT libraries{" "}
19 |
20 | and interest in applying new WebSIMD technology to the problem.
21 |
24 |
25 |
106 |
107 |
26 |
27 | 
32 | Marc
33 |
34 |
35 |
32 | Marc
33 |
34 |
36 |
37 | 
42 | Luis
43 |
44 |
45 |
42 | Luis
43 |
44 |
46 |
47 | 
52 | Chad
53 |
54 |
55 |
52 | Chad
53 |
54 |
56 |
57 | 
62 | Maheen
63 |
64 |
65 |
62 | Maheen
63 |
64 |
66 |
67 | 
72 | Fai
73 |
74 |
75 |
72 | Fai
73 |
74 |
76 |
77 | 
82 | Tensae
83 |
84 |
85 |
82 | Tensae
83 |
84 |
86 |
87 | 
92 | Luke
93 |
94 |
95 |
92 | Luke
93 |
94 |
96 |
97 | 
102 | Gabriel
103 |
104 |
105 |
102 | Gabriel
103 |
104 | 108 |
109 | The project is currently maintained by the{" "} 110 | IQEngine{" "} 111 | organization, as it is heavily used within IQEngine. 112 |
113 |114 |
WebFFT is licensed under the MIT License and welcomes Issues/PRs!
115 |116 | WebFFT In Action! 117 |
118 |
119 | {/* Start/Stop Button */}
120 |
235 |
121 |
133 |
134 | {/* Amplitude Control */}
135 |
136 | Signal Amplitude
137 |
146 |
147 | {/* Frequency Control */}
148 |
149 | Signal Frequency
150 |
159 |
160 | {/* SVG Plot */}
161 |
162 |
173 |
174 | {/* ChartJS Plot */}
175 |
176 | i,
181 | ),
182 | datasets: [
183 | {
184 | label: "Dataset",
185 | data: plotData,
186 | fill: false,
187 | borderColor: waveColor,
188 | borderWidth: 1,
189 | pointRadius: 0,
190 | },
191 | ],
192 | }}
193 | options={{
194 | plugins: {
195 | legend: {
196 | display: false,
197 | },
198 | },
199 | scales: {
200 | x: {
201 | display: true,
202 | grid: {
203 | display: false,
204 | },
205 | title: {
206 | display: true,
207 | text: "Frequency",
208 | color: textColor,
209 | },
210 | ticks: {
211 | display: false,
212 | color: textColor,
213 | },
214 | },
215 | y: {
216 | display: true,
217 | grid: {
218 | display: false,
219 | },
220 | title: {
221 | display: true,
222 | text: "PSD",
223 | color: textColor,
224 | },
225 | ticks: {
226 | display: false,
227 | color: textColor,
228 | },
229 | },
230 | },
231 | }}
232 | />
233 |
234 |
83 |
94 | );
95 | }
96 | return (
97 |
98 | Browser not recognized or detected.
99 |
100 | );
101 | };
102 |
103 | // This will run when you click the run benchmark button
104 | useEffect(() => {
105 | if (loading) {
106 | // allow UI to update before starting long running task
107 | const fftWorker = new Worker(
108 | new URL("../utils/webworker.tsx", import.meta.url),
109 | { type: "module" },
110 | );
111 |
112 | fftWorker.postMessage([fftSize, duration]);
113 |
114 | fftWorker.onmessage = (e: MessageEvent
84 | Browser:
85 | {browserCapabilities.browserName ?? "Unknown"}{" "}
86 | {{browserCapabilities.browserVersion} ?? ""}
87 |
88 |
89 | OS:
90 | {browserCapabilities.osName ?? "Unknown"}{" "}
91 | {{browserCapabilities.osVersion} ?? ""}
92 |
93 |
183 |
184 |
274 |
275 |
277 | );
278 | }
279 |
280 | export default BenchmarkSection;
281 |
--------------------------------------------------------------------------------
188 | Benchmark your browser 189 |
190 | 191 |
192 |
202 |
203 |
210 |
217 |
218 |
219 | {showSettings && (
220 |
221 |
272 | )}
273 |
222 | FFT Size
223 |
225 |
226 |
227 |
245 |
246 |
247 |
248 |
249 | Browser Information:
250 | {renderBrowserInfo()} 251 | 252 | 253 | SIMD Support:
254 | 255 | {simdSupport ? "Supported" : "Not supported"} 256 | 257 | 258 | 259 | Relaxed SIMD:
260 | 261 | {relaxedSimdSupport ? "Enabled" : "Disabled"} 262 | 263 | 264 | 265 | WASM Support:
266 | 267 | {wasmSupport ? "Supported" : "Not supported"} 268 | 269 | 270 |
271 | 250 | {renderBrowserInfo()} 251 | 252 | 253 | SIMD Support:
254 | 255 | {simdSupport ? "Supported" : "Not supported"} 256 | 257 | 258 | 259 | Relaxed SIMD:
260 | 261 | {relaxedSimdSupport ? "Enabled" : "Disabled"} 262 | 263 | 264 | 265 | WASM Support:
266 | 267 | {wasmSupport ? "Supported" : "Not supported"} 268 | 269 | 270 |