From 52a3f113cab0c7de829b17b4a8ec364c946432c5 Mon Sep 17 00:00:00 2001 From: daniellga <43149605+daniellga@users.noreply.github.com> Date: Tue, 18 Jun 2024 02:00:48 +0000 Subject: [PATCH] Update docs --- _docs/contents/hfftplanner.qmd | 158 +++ _docs/contents/hrealfftplanner.qmd | 169 +++ docs/about.html | 12 + docs/contents/harray.html | 12 + docs/contents/haudioop.html | 12 + docs/contents/haudiosink.html | 12 + docs/contents/hdatatype.html | 12 + docs/contents/hdecodedaudio.html | 12 + docs/contents/hdecoderstream.html | 12 + docs/contents/hfft.html | 12 + docs/contents/hfftplanner.html | 1009 ++++++++++++++++ docs/contents/hfile.html | 12 + docs/contents/hinterpolationtype.html | 12 + docs/contents/hmetadatatype.html | 12 + docs/contents/hpolynomialdegree.html | 12 + docs/contents/hrealfftplanner.html | 1017 +++++++++++++++++ docs/contents/hresampler.html | 12 + docs/contents/hresamplertype.html | 12 + .../hsincinterpolationparameters.html | 12 + docs/contents/hwindow.html | 12 + docs/contents/hwindowtype.html | 12 + docs/index.html | 12 + docs/search.json | 248 +++- 23 files changed, 2759 insertions(+), 58 deletions(-) create mode 100644 _docs/contents/hfftplanner.qmd create mode 100644 _docs/contents/hrealfftplanner.qmd create mode 100644 docs/contents/hfftplanner.html create mode 100644 docs/contents/hrealfftplanner.html diff --git a/_docs/contents/hfftplanner.qmd b/_docs/contents/hfftplanner.qmd new file mode 100644 index 0000000..921f0be --- /dev/null +++ b/_docs/contents/hfftplanner.qmd @@ -0,0 +1,158 @@ +--- +title: HFftPlanner +--- + +## new + +`new(dtype: HDataType) -> HFftPlanner` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L65) \ + +Creates a new `HFftPlanner` instance. \ +If you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data +across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with +FFT instances created by a different planner) \ +In the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with +the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs. \ + +#### Arguments + +* `dtype` \ +A complex `HDataType` to indicate the dtype that the `HFftPlanner` will be working with. \ + +#### Returns + +An `HFftPlanner`. \ +Will return an error if dtype is of a float type. \ + +#### Examples + +```r +library(harmonium) +arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4)) +dtype = HDataType$Float32 +harray = HArray$new_from_values(arr, dtype) +fft_planner = HFftPlanner$new(harray$dtype()) +``` + +_________ + +## fft + +`fft(harray: HArray)` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L115) \ + +Computes the fast fourier transform of a complex `HArray`. \ +The operation is done in-place. \ +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, +by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform +is therefore most efficient for these sizes. \ + +The function does not normalize outputs. Callers must manually normalize the results by scaling each element by +`1/sqrt(n)`. Multiple normalization steps can be merged into one via pairwise multiplication, so when doing +a forward FFT followed by an inverse callers can normalize once by scaling each element by `1/n`. \ + +Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0. \ + +#### Arguments + +* `harray` \ +A complex `HArray`. \ + +#### Returns + +Will return an error if: +* The `HArray`'s dtype is incompatible with the `HFftPlanner`'s dtype. \ +* The `HArray`'s `ndim` is greater than 2. \ + +#### Examples + +```r +library(harmonium) +arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4)) +dtype = HDataType$Float32 +harray = HArray$new_from_values(arr, dtype) +fft_planner = HFftPlanner$new(harray$dtype()) +fft_planner$fft(harray) +``` + +_________ + +## ifft + +`ifft(harray: HArray)` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L158) \ + +Computes the inverse fast fourier transform of a complex `HArray`. \ +The operation is done in-place. \ +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, +by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform +is therefore most efficient for these sizes. \ + +The function does not normalize outputs. Callers must manually normalize the results by scaling each element by +`1/sqrt(n)`. Multiple normalization steps can be merged into one via pairwise multiplication, so when doing +a forward FFT followed by an inverse callers can normalize once by scaling each element by `1/n`. \ + +#### Arguments + +* `harray` \ +A complex `HArray`. \ + +#### Returns + +Will return an error if: +* The `HArray`'s dtype is incompatible with the `HFftPlanner`'s dtype. \ +* The `HArray`'s `ndim` is greater than 2. \ + +#### Examples + +```r +library(harmonium) +arr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2)) +dtype = HDataType$Complex32 +harray = HArray$new_from_values(arr, dtype) +fft_planner = HFftPlanner$new(harray$dtype()) +fft_planner$ifft(harray) +``` + +_________ + +## dtype + +`dtype() -> HDataType` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L185) \ + +Gets the `HFftPlanner`'s dtype. + +#### Returns + +An `HDataType`. + +#### Examples + +```r +arr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2)) +dtype = HDataType$Complex32 +harray = HArray$new_from_values(arr, dtype) +fft_planner = HFftPlanner$new(harray$dtype()) +fft_planner$dtype() +``` + +_________ + +## print + +`print()` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L212) \ + +Print the `HFftPlanner`. \ +Differently from R's normal behaviour, `print` doesn't return the value invisibly. \ + +#### Examples + +```r +arr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2)) +dtype = HDataType$Complex32 +harray = HArray$new_from_values(arr, dtype) +fft_planner = HFftPlanner$new(harray$dtype()) +fft_planner$print() + +# or similarly: +print(fft_planner) +``` + +_________ diff --git a/_docs/contents/hrealfftplanner.qmd b/_docs/contents/hrealfftplanner.qmd new file mode 100644 index 0000000..139eece --- /dev/null +++ b/_docs/contents/hrealfftplanner.qmd @@ -0,0 +1,169 @@ +--- +title: HRealFftPlanner +--- + +## new + +`new(dtype: HDataType) -> HRealFftPlanner` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L253) \ + +Creates a new `HRealFftPlanner` instance. \ +If you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data +across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with +FFT instances created by a different planner) \ +In the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with +the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs. \ + +#### Arguments + +* `dtype` \ +A float `HDataType` to indicate the dtype that the `HFftPlanner` will be working with. \ + +#### Returns + +An `HRealFftPlanner`. \ +Will return an error if dtype is of a complex type. \ + +#### Examples + +```r +library(harmonium) +arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4)) +dtype = HDataType$Float32 +harray = HArray$new_from_values(arr, dtype) +real_fft_planner = HRealFftPlanner$new(harray$dtype()) +``` + +_________ + +## rfft + +`rfft(harray: HArray)` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L305) \ + +Computes the fast fourier transform of a float `HArray`. Transforms a real signal of length `N` to a complex-valued spectrum of length `N/2+1` (with `N/2` rounded down). \ +The operation is not done in-place, although the same external pointer is used to store the new HArray. \ +The FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i]) so the output contains only the positive frequencies +below the Nyquist frequency. \ +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, +by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform +is therefore most efficient for these sizes. \ + +The function does not normalize outputs. Callers must manually normalize the results by scaling each element by +`1/sqrt(n)`. Multiple normalization steps can be merged into one via pairwise multiplication, so when doing +a forward FFT followed by an inverse callers can normalize once by scaling each element by `1/n`. \ + +Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0. \ + +#### Arguments + +* `harray` \ +A float `HArray`. \ + +#### Returns + +Will return an error if: +* The `HArray`'s dtype is incompatible with the `HFftPlanner`'s dtype. \ +* The `HArray`'s `ndim` is greater than 2. \ + +#### Examples + +```r +library(harmonium) +arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4)) +dtype = HDataType$Float32 +harray = HArray$new_from_values(arr, dtype) +real_fft_planner = HRealFftPlanner$new(harray$dtype()) +real_fft_planner$rfft(harray) +``` + +_________ + +## irfft + +`irfft(harray: HArray, length: integer)` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L357) \ + +Computes the inverse fast fourier transform of a complex `HArray`. Transforms a complex spectrum of length `N/2+1` (with `N/2` rounded down) to a real-valued +signal of length `N`. \ +The operation is not done in-place, although the same external pointer is used to store the new HArray. \ +The FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i]) so the output contains only the positive frequencies +below the Nyquist frequency. \ +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, +by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform +is therefore most efficient for these sizes. \ + +The function does not normalize outputs. Callers must manually normalize the results by scaling each element by +`1/sqrt(n)`. Multiple normalization steps can be merged into one via pairwise multiplication, so when doing +a forward FFT followed by an inverse callers can normalize once by scaling each element by `1/n`. \ + +#### Arguments + +* `harray` \ +A complex `HArray`. The `HArray`'s dtype must be the complex equivalent of the `HRealFftPlanner`'s dtype. For example if `HRealFftPlanner` dtype is `Float64`, +the `HArray`'s dtype must be `Complex64`. \ +* `length` \ +An integer. The output length of the signal. Since the spectrum is `N/2+1`, the length can be `N` and `N+1`, if `N` is even, or can be `N` and `N-1` if `N` is odd. \ + +#### Returns + +Will return an error if: +* The `HArray`'s dtype is incompatible with the `HFftPlanner`'s dtype. \ +* The `HArray`'s `ndim` is greater than 2. \ +* The `length` argument is not compatible with the spectrum length. \ + +#### Examples + +```r +library(harmonium) +r = as.double(sample(100, 4, replace = TRUE)) +i = as.double(sample(100, 3, replace = TRUE)) +arr = array(complex(real=r, imaginary=c(0,i)), c(4,1)) +dtype = HDataType$Complex32 +harray = HArray$new_from_values(arr, dtype) +real_fft_planner = HRealFftPlanner$new(HDataType$Float32) +real_fft_planner$irfft(harray, 7L) +``` + +_________ + +## dtype + +`dtype() -> HDataType` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L388) \ + +Gets the `HRealFftPlanner`'s dtype. + +#### Returns + +An `HDataType`. + +#### Examples + +```r +arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4)) +dtype = HDataType$Float32 +harray = HArray$new_from_values(arr, dtype) +real_fft_planner = HRealFftPlanner$new(harray$dtype()) +real_fft_planner$dtype() +``` + +_________ + +## print + +`print()` [source](https://github.com/daniellga/harmonium/tree/master/r-harmonium/src/rust/src/hfft.rs#L415) \ + +Print the `HRealFftPlanner`. \ +Differently from R's normal behaviour, `print` doesn't return the value invisibly. \ + +#### Examples + +```r +arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4)) +dtype = HDataType$Float32 +harray = HArray$new_from_values(arr, dtype) +real_fft_planner = HRealFftPlanner$new(harray$dtype()) +real_fft_planner$print() + +# or similarly: +print(real_fft_planner) +``` + +_________ diff --git a/docs/about.html b/docs/about.html index d93e3d5..94c2e1c 100644 --- a/docs/about.html +++ b/docs/about.html @@ -158,6 +158,12 @@ HFft + +
  • +
    + + HFftPlanner +
  • @@ -182,6 +188,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/harray.html b/docs/contents/harray.html index 95de947..e34cdf2 100644 --- a/docs/contents/harray.html +++ b/docs/contents/harray.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/haudioop.html b/docs/contents/haudioop.html index 71a0b1a..b2fe578 100644 --- a/docs/contents/haudioop.html +++ b/docs/contents/haudioop.html @@ -221,6 +221,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -245,6 +251,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/haudiosink.html b/docs/contents/haudiosink.html index f1f9a20..3ec7696 100644 --- a/docs/contents/haudiosink.html +++ b/docs/contents/haudiosink.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hdatatype.html b/docs/contents/hdatatype.html index 9a3b6ef..7fe153c 100644 --- a/docs/contents/hdatatype.html +++ b/docs/contents/hdatatype.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hdecodedaudio.html b/docs/contents/hdecodedaudio.html index 0ef1ee1..726ddce 100644 --- a/docs/contents/hdecodedaudio.html +++ b/docs/contents/hdecodedaudio.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hdecoderstream.html b/docs/contents/hdecoderstream.html index 8bd27e8..39a4609 100644 --- a/docs/contents/hdecoderstream.html +++ b/docs/contents/hdecoderstream.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hfft.html b/docs/contents/hfft.html index f5727fa..c24dd94 100644 --- a/docs/contents/hfft.html +++ b/docs/contents/hfft.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hfftplanner.html b/docs/contents/hfftplanner.html new file mode 100644 index 0000000..0c28460 --- /dev/null +++ b/docs/contents/hfftplanner.html @@ -0,0 +1,1009 @@ + + + + + + + + + +Harmonium - HFftPlanner + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + +
    + +
    + + +
    + + + +
    + +
    +
    +

    HFftPlanner

    +
    + + + +
    + + + + +
    + + + +
    + + +
    +

    new

    +

    new(dtype: HDataType) -> HFftPlanner source
    +

    +

    Creates a new HFftPlanner instance.
    +If you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)
    +In the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.
    +

    +
    +

    Arguments

    +
      +
    • dtype
      +A complex HDataType to indicate the dtype that the HFftPlanner will be working with.
      +
      • +
    +
    +
    +

    Returns

    +

    An HFftPlanner.
    +Will return an error if dtype is of a float type.
    +

    +
    +
    +

    Examples

    +
    library(harmonium)
+arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))
+dtype = HDataType$Float32
+harray = HArray$new_from_values(arr, dtype)
+fft_planner = HFftPlanner$new(harray$dtype())
    +
    +
    +
    +
    +

    fft

    +

    fft(harray: HArray) source
    +

    +

    Computes the fast fourier transform of a complex HArray.
    +The operation is done in-place.
    +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.
    +

    +

    The function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.
    +

    +

    Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.
    +

    +
    +

    Arguments

    +
      +
    • harray
      +A complex HArray.
      +
      • +
    +
    +
    +

    Returns

    +

    Will return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.
    +* The HArray’s ndim is greater than 2.
    +

    +
    +
    +

    Examples

    +
    library(harmonium)
+arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))
+dtype = HDataType$Float32
+harray = HArray$new_from_values(arr, dtype)
+fft_planner = HFftPlanner$new(harray$dtype())
+fft_planner$fft(harray)
    +
    +
    +
    +
    +

    ifft

    +

    ifft(harray: HArray) source
    +

    +

    Computes the inverse fast fourier transform of a complex HArray.
    +The operation is done in-place.
    +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.
    +

    +

    The function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.
    +

    +
    +

    Arguments

    +
      +
    • harray
      +A complex HArray.
      +
      • +
    +
    +
    +

    Returns

    +

    Will return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.
    +* The HArray’s ndim is greater than 2.
    +

    +
    +
    +

    Examples

    +
    library(harmonium)
+arr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2))
+dtype = HDataType$Complex32
+harray = HArray$new_from_values(arr, dtype)
+fft_planner = HFftPlanner$new(harray$dtype())
+fft_planner$ifft(harray)
    +
    +
    +
    +
    +

    dtype

    +

    dtype() -> HDataType source
    +

    +

    Gets the HFftPlanner’s dtype.

    +
    +

    Returns

    +

    An HDataType.

    +
    +
    +

    Examples

    +
    arr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2))
+dtype = HDataType$Complex32
+harray = HArray$new_from_values(arr, dtype)
+fft_planner = HFftPlanner$new(harray$dtype())
+fft_planner$dtype()
    +
    +
    +
    +
    +

    print

    +

    print() source
    +

    +

    Print the HFftPlanner.
    +Differently from R’s normal behaviour, print doesn’t return the value invisibly.
    +

    +
    +

    Examples

    +
    arr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2))
+dtype = HDataType$Complex32
+harray = HArray$new_from_values(arr, dtype)
+fft_planner = HFftPlanner$new(harray$dtype())
+fft_planner$print()
+
+# or similarly:
+print(fft_planner)
    +
    + + +
    +
    + +
    + +
    + + + + + \ No newline at end of file diff --git a/docs/contents/hfile.html b/docs/contents/hfile.html index f9cf0c2..c28b7a1 100644 --- a/docs/contents/hfile.html +++ b/docs/contents/hfile.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hinterpolationtype.html b/docs/contents/hinterpolationtype.html index 876ee0f..0677be1 100644 --- a/docs/contents/hinterpolationtype.html +++ b/docs/contents/hinterpolationtype.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hmetadatatype.html b/docs/contents/hmetadatatype.html index f7a5c27..c5253d8 100644 --- a/docs/contents/hmetadatatype.html +++ b/docs/contents/hmetadatatype.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hpolynomialdegree.html b/docs/contents/hpolynomialdegree.html index 1257072..2b9dfb5 100644 --- a/docs/contents/hpolynomialdegree.html +++ b/docs/contents/hpolynomialdegree.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hrealfftplanner.html b/docs/contents/hrealfftplanner.html new file mode 100644 index 0000000..abd0b2e --- /dev/null +++ b/docs/contents/hrealfftplanner.html @@ -0,0 +1,1017 @@ + + + + + + + + + +Harmonium - HRealFftPlanner + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + +
    + +
    + + +
    + + + +
    + +
    +
    +

    HRealFftPlanner

    +
    + + + +
    + + + + +
    + + + +
    + + +
    +

    new

    +

    new(dtype: HDataType) -> HRealFftPlanner source
    +

    +

    Creates a new HRealFftPlanner instance.
    +If you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)
    +In the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.
    +

    +
    +

    Arguments

    +
      +
    • dtype
      +A float HDataType to indicate the dtype that the HFftPlanner will be working with.
      +
      • +
    +
    +
    +

    Returns

    +

    An HRealFftPlanner.
    +Will return an error if dtype is of a complex type.
    +

    +
    +
    +

    Examples

    +
    library(harmonium)
+arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))
+dtype = HDataType$Float32
+harray = HArray$new_from_values(arr, dtype)
+real_fft_planner = HRealFftPlanner$new(harray$dtype())
    +
    +
    +
    +
    +

    rfft

    +

    rfft(harray: HArray) source
    +

    +

    Computes the fast fourier transform of a float HArray. Transforms a real signal of length N to a complex-valued spectrum of length N/2+1 (with N/2 rounded down).
    +The operation is not done in-place, although the same external pointer is used to store the new HArray.
    +The FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i]) so the output contains only the positive frequencies below the Nyquist frequency.
    +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.
    +

    +

    The function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.
    +

    +

    Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.
    +

    +
    +

    Arguments

    +
      +
    • harray
      +A float HArray.
      +
      • +
    +
    +
    +

    Returns

    +

    Will return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.
    +* The HArray’s ndim is greater than 2.
    +

    +
    +
    +

    Examples

    +
    library(harmonium)
+arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))
+dtype = HDataType$Float32
+harray = HArray$new_from_values(arr, dtype)
+real_fft_planner = HRealFftPlanner$new(harray$dtype())
+real_fft_planner$rfft(harray)
    +
    +
    +
    +
    +

    irfft

    +

    irfft(harray: HArray, length: integer) source
    +

    +

    Computes the inverse fast fourier transform of a complex HArray. Transforms a complex spectrum of length N/2+1 (with N/2 rounded down) to a real-valued signal of length N.
    +The operation is not done in-place, although the same external pointer is used to store the new HArray.
    +The FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i]) so the output contains only the positive frequencies below the Nyquist frequency.
    +FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.
    +

    +

    The function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.
    +

    +
    +

    Arguments

    +
      +
    • harray
      +A complex HArray. The HArray’s dtype must be the complex equivalent of the HRealFftPlanner’s dtype. For example if HRealFftPlanner dtype is Float64, the HArray’s dtype must be Complex64.
      +
      • +
    • length
      +An integer. The output length of the signal. Since the spectrum is N/2+1, the length can be N and N+1, if N is even, or can be N and N-1 if N is odd.
      +
      • +
    +
    +
    +

    Returns

    +

    Will return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.
    +* The HArray’s ndim is greater than 2.
    +* The length argument is not compatible with the spectrum length.
    +

    +
    +
    +

    Examples

    +
    library(harmonium)
+r = as.double(sample(100, 4, replace = TRUE))
+i = as.double(sample(100, 3, replace = TRUE))
+arr = array(complex(real=r, imaginary=c(0,i)), c(4,1))
+dtype = HDataType$Complex32
+harray = HArray$new_from_values(arr, dtype)
+real_fft_planner = HRealFftPlanner$new(HDataType$Float32)
+real_fft_planner$irfft(harray, 7L)
    +
    +
    +
    +
    +

    dtype

    +

    dtype() -> HDataType source
    +

    +

    Gets the HRealFftPlanner’s dtype.

    +
    +

    Returns

    +

    An HDataType.

    +
    +
    +

    Examples

    +
    arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))
+dtype = HDataType$Float32
+harray = HArray$new_from_values(arr, dtype)
+real_fft_planner = HRealFftPlanner$new(harray$dtype())
+real_fft_planner$dtype()
    +
    +
    +
    +
    +

    print

    +

    print() source
    +

    +

    Print the HRealFftPlanner.
    +Differently from R’s normal behaviour, print doesn’t return the value invisibly.
    +

    +
    +

    Examples

    +
    arr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))
+dtype = HDataType$Float32
+harray = HArray$new_from_values(arr, dtype)
+real_fft_planner = HRealFftPlanner$new(harray$dtype())
+real_fft_planner$print()
+
+# or similarly:
+print(real_fft_planner)
    +
    + + +
    +
    + +
    + +
    + + + + + \ No newline at end of file diff --git a/docs/contents/hresampler.html b/docs/contents/hresampler.html index ca315cb..fdaadf4 100644 --- a/docs/contents/hresampler.html +++ b/docs/contents/hresampler.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hresamplertype.html b/docs/contents/hresamplertype.html index 81d2293..733713e 100644 --- a/docs/contents/hresamplertype.html +++ b/docs/contents/hresamplertype.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hsincinterpolationparameters.html b/docs/contents/hsincinterpolationparameters.html index 450ec70..d38dc85 100644 --- a/docs/contents/hsincinterpolationparameters.html +++ b/docs/contents/hsincinterpolationparameters.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hwindow.html b/docs/contents/hwindow.html index d61d6d9..a6ba728 100644 --- a/docs/contents/hwindow.html +++ b/docs/contents/hwindow.html @@ -221,6 +221,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -245,6 +251,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/contents/hwindowtype.html b/docs/contents/hwindowtype.html index b9b7178..e3ec127 100644 --- a/docs/contents/hwindowtype.html +++ b/docs/contents/hwindowtype.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/index.html b/docs/index.html index e4b68a7..c630be8 100644 --- a/docs/index.html +++ b/docs/index.html @@ -192,6 +192,12 @@ HFft
    +
    • +
  • +
    + + HFftPlanner +
  • @@ -216,6 +222,12 @@ HPolynomialDegree
    +
    • +
  • +
    + + HRealFftPlanner +
  • diff --git a/docs/search.json b/docs/search.json index ea071a2..d014272 100644 --- a/docs/search.json +++ b/docs/search.json @@ -417,6 +417,196 @@ "HDecoderStream" ] }, + { + "objectID": "contents/hfftplanner.html", + "href": "contents/hfftplanner.html", + "title": "HFftPlanner", + "section": "", + "text": "new(dtype: HDataType) -> HFftPlanner source \n\nCreates a new HFftPlanner instance.\nIf you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)\nIn the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.\n\n\n\n\ndtype\nA complex HDataType to indicate the dtype that the HFftPlanner will be working with.\n\n\n\n\n\nAn HFftPlanner.\nWill return an error if dtype is of a float type.\n\n\n\n\nlibrary(harmonium)\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nfft_planner = HFftPlanner$new(harray$dtype())", + "crumbs": [ + "Classes", + "HFftPlanner" + ] + }, + { + "objectID": "contents/hfftplanner.html#new", + "href": "contents/hfftplanner.html#new", + "title": "HFftPlanner", + "section": "", + "text": "new(dtype: HDataType) -> HFftPlanner source \n\nCreates a new HFftPlanner instance.\nIf you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)\nIn the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.\n\n\n\n\ndtype\nA complex HDataType to indicate the dtype that the HFftPlanner will be working with.\n\n\n\n\n\nAn HFftPlanner.\nWill return an error if dtype is of a float type.\n\n\n\n\nlibrary(harmonium)\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nfft_planner = HFftPlanner$new(harray$dtype())", + "crumbs": [ + "Classes", + "HFftPlanner" + ] + }, + { + "objectID": "contents/hfftplanner.html#fft", + "href": "contents/hfftplanner.html#fft", + "title": "HFftPlanner", + "section": "fft", + "text": "fft\nfft(harray: HArray) source \n\nComputes the fast fourier transform of a complex HArray.\nThe operation is done in-place.\nFFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.\n\nThe function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.\n\nElements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.\n\n\nArguments\n\nharray\nA complex HArray.\n\n\n\n\nReturns\nWill return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.\n* The HArray’s ndim is greater than 2.\n\n\n\nExamples\nlibrary(harmonium)\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nfft_planner = HFftPlanner$new(harray$dtype())\nfft_planner$fft(harray)", + "crumbs": [ + "Classes", + "HFftPlanner" + ] + }, + { + "objectID": "contents/hfftplanner.html#ifft", + "href": "contents/hfftplanner.html#ifft", + "title": "HFftPlanner", + "section": "ifft", + "text": "ifft\nifft(harray: HArray) source \n\nComputes the inverse fast fourier transform of a complex HArray.\nThe operation is done in-place.\nFFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.\n\nThe function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.\n\n\nArguments\n\nharray\nA complex HArray.\n\n\n\n\nReturns\nWill return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.\n* The HArray’s ndim is greater than 2.\n\n\n\nExamples\nlibrary(harmonium)\narr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2))\ndtype = HDataType$Complex32\nharray = HArray$new_from_values(arr, dtype)\nfft_planner = HFftPlanner$new(harray$dtype())\nfft_planner$ifft(harray)", + "crumbs": [ + "Classes", + "HFftPlanner" + ] + }, + { + "objectID": "contents/hfftplanner.html#dtype", + "href": "contents/hfftplanner.html#dtype", + "title": "HFftPlanner", + "section": "dtype", + "text": "dtype\ndtype() -> HDataType source \n\nGets the HFftPlanner’s dtype.\n\nReturns\nAn HDataType.\n\n\nExamples\narr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2))\ndtype = HDataType$Complex32\nharray = HArray$new_from_values(arr, dtype)\nfft_planner = HFftPlanner$new(harray$dtype())\nfft_planner$dtype()", + "crumbs": [ + "Classes", + "HFftPlanner" + ] + }, + { + "objectID": "contents/hfftplanner.html#print", + "href": "contents/hfftplanner.html#print", + "title": "HFftPlanner", + "section": "print", + "text": "print\nprint() source \n\nPrint the HFftPlanner.\nDifferently from R’s normal behaviour, print doesn’t return the value invisibly.\n\n\nExamples\narr = array(c(1+1i,2+2i,3+3i,4+4i,5+5i,6+6i), c(3,2))\ndtype = HDataType$Complex32\nharray = HArray$new_from_values(arr, dtype)\nfft_planner = HFftPlanner$new(harray$dtype())\nfft_planner$print()\n\n# or similarly:\nprint(fft_planner)", + "crumbs": [ + "Classes", + "HFftPlanner" + ] + }, + { + "objectID": "contents/hrealfftplanner.html", + "href": "contents/hrealfftplanner.html", + "title": "HRealFftPlanner", + "section": "", + "text": "new(dtype: HDataType) -> HRealFftPlanner source \n\nCreates a new HRealFftPlanner instance.\nIf you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)\nIn the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.\n\n\n\n\ndtype\nA float HDataType to indicate the dtype that the HFftPlanner will be working with.\n\n\n\n\n\nAn HRealFftPlanner.\nWill return an error if dtype is of a complex type.\n\n\n\n\nlibrary(harmonium)\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nreal_fft_planner = HRealFftPlanner$new(harray$dtype())", + "crumbs": [ + "Classes", + "HRealFftPlanner" + ] + }, + { + "objectID": "contents/hrealfftplanner.html#new", + "href": "contents/hrealfftplanner.html#new", + "title": "HRealFftPlanner", + "section": "", + "text": "new(dtype: HDataType) -> HRealFftPlanner source \n\nCreates a new HRealFftPlanner instance.\nIf you plan on creating multiple FFT instances, it is recommended to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)\nIn the constructor, the FftPlanner will detect available CPU features. If AVX, SSE, Neon, or WASM SIMD are available, it will set itself up to plan FFTs with the fastest available instruction set. If no SIMD instruction sets are available, the planner will seamlessly fall back to planning non-SIMD FFTs.\n\n\n\n\ndtype\nA float HDataType to indicate the dtype that the HFftPlanner will be working with.\n\n\n\n\n\nAn HRealFftPlanner.\nWill return an error if dtype is of a complex type.\n\n\n\n\nlibrary(harmonium)\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nreal_fft_planner = HRealFftPlanner$new(harray$dtype())", + "crumbs": [ + "Classes", + "HRealFftPlanner" + ] + }, + { + "objectID": "contents/hrealfftplanner.html#rfft", + "href": "contents/hrealfftplanner.html#rfft", + "title": "HRealFftPlanner", + "section": "rfft", + "text": "rfft\nrfft(harray: HArray) source \n\nComputes the fast fourier transform of a float HArray. Transforms a real signal of length N to a complex-valued spectrum of length N/2+1 (with N/2 rounded down).\nThe operation is not done in-place, although the same external pointer is used to store the new HArray.\nThe FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i]) so the output contains only the positive frequencies below the Nyquist frequency.\nFFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.\n\nThe function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.\n\nElements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.\n\n\nArguments\n\nharray\nA float HArray.\n\n\n\n\nReturns\nWill return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.\n* The HArray’s ndim is greater than 2.\n\n\n\nExamples\nlibrary(harmonium)\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nreal_fft_planner = HRealFftPlanner$new(harray$dtype())\nreal_fft_planner$rfft(harray)", + "crumbs": [ + "Classes", + "HRealFftPlanner" + ] + }, + { + "objectID": "contents/hrealfftplanner.html#irfft", + "href": "contents/hrealfftplanner.html#irfft", + "title": "HRealFftPlanner", + "section": "irfft", + "text": "irfft\nirfft(harray: HArray, length: integer) source \n\nComputes the inverse fast fourier transform of a complex HArray. Transforms a complex spectrum of length N/2+1 (with N/2 rounded down) to a real-valued signal of length N.\nThe operation is not done in-place, although the same external pointer is used to store the new HArray.\nThe FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i]) so the output contains only the positive frequencies below the Nyquist frequency.\nFFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes.\n\nThe function does not normalize outputs. Callers must manually normalize the results by scaling each element by 1/sqrt(n). Multiple normalization steps can be merged into one via pairwise multiplication, so when doing a forward FFT followed by an inverse callers can normalize once by scaling each element by 1/n.\n\n\nArguments\n\nharray\nA complex HArray. The HArray’s dtype must be the complex equivalent of the HRealFftPlanner’s dtype. For example if HRealFftPlanner dtype is Float64, the HArray’s dtype must be Complex64.\n\nlength\nAn integer. The output length of the signal. Since the spectrum is N/2+1, the length can be N and N+1, if N is even, or can be N and N-1 if N is odd.\n\n\n\n\nReturns\nWill return an error if: * The HArray’s dtype is incompatible with the HFftPlanner’s dtype.\n* The HArray’s ndim is greater than 2.\n* The length argument is not compatible with the spectrum length.\n\n\n\nExamples\nlibrary(harmonium)\nr = as.double(sample(100, 4, replace = TRUE))\ni = as.double(sample(100, 3, replace = TRUE))\narr = array(complex(real=r, imaginary=c(0,i)), c(4,1))\ndtype = HDataType$Complex32\nharray = HArray$new_from_values(arr, dtype)\nreal_fft_planner = HRealFftPlanner$new(HDataType$Float32)\nreal_fft_planner$irfft(harray, 7L)", + "crumbs": [ + "Classes", + "HRealFftPlanner" + ] + }, + { + "objectID": "contents/hrealfftplanner.html#dtype", + "href": "contents/hrealfftplanner.html#dtype", + "title": "HRealFftPlanner", + "section": "dtype", + "text": "dtype\ndtype() -> HDataType source \n\nGets the HRealFftPlanner’s dtype.\n\nReturns\nAn HDataType.\n\n\nExamples\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nreal_fft_planner = HRealFftPlanner$new(harray$dtype())\nreal_fft_planner$dtype()", + "crumbs": [ + "Classes", + "HRealFftPlanner" + ] + }, + { + "objectID": "contents/hrealfftplanner.html#print", + "href": "contents/hrealfftplanner.html#print", + "title": "HRealFftPlanner", + "section": "print", + "text": "print\nprint() source \n\nPrint the HRealFftPlanner.\nDifferently from R’s normal behaviour, print doesn’t return the value invisibly.\n\n\nExamples\narr = array(c(1,2,3,4,5,6,7,8,9,10,11,12), c(3,4))\ndtype = HDataType$Float32\nharray = HArray$new_from_values(arr, dtype)\nreal_fft_planner = HRealFftPlanner$new(harray$dtype())\nreal_fft_planner$print()\n\n# or similarly:\nprint(real_fft_planner)", + "crumbs": [ + "Classes", + "HRealFftPlanner" + ] + }, + { + "objectID": "index.html", + "href": "index.html", + "title": "Harmonium", + "section": "", + "text": "Harmonium is an audio interface inspired by Python’s librosa.\n\n\nBasic usage\nLoad the library\nlibrary(harmonium)\nCreate an HArray from an existing array\narr = matrix(c(1,2,3,4,5,6,7,8,9,10,11,12), ncol = 2)\ndtype = HDataType$float64\nharray = HArray$new_from_values(arr, dtype = dtype)\nprint(harray)\nOr decode from an existing audio file\nl = HFile$decode(\"file.wav\", dtype)\nharray = l[[0]]\nsr = l[[1]] # sampling rate\nprint(harray)\nVerify the dimensions\nharray$len()\nHAudioOp$nchannels(harray)\nHAudioOp$nframes(harray)\nVerify the data type\nharray$dtype()\nConvert to an R array\nharray$collect()\nConvert to mono\nHAudioOp$to_mono(harray)\nResample the haudio\nsr_in = 48000L\nsr_out = 22050L\nnbr_channels = HAudioOp$nchannels(harray)\ndtype = HDataType$float64\nres_type = HResamplerType$fft_fixed_in\nresampler = HResampler$new_fft(sr_in, sr_out, nbr_channels, res_type)\nhresampler$process(harray)\nPlay the haudio\nhaudiosink = HAudioSink$new()\nhaudiosink$append_from_harray(harray)\nOr play directly from the file\nhaudiosink$append_from_file(\"file.wav\")\nGet the number of audios to be played\nhaudiosink$len()\nDouble the audio volume and the playback speed\nhaudiosink$set_volume(2)\nhaudiosink$set_speed(2)\nPause the playback and confirms it is paused\nhaudiosink$pause()\nhaudiosink$is_paused()\nIt is also possible to get metadata from an audio file\nmetatadatype = HMetadataType$text\nHFile$metadata(\"file.wav\", metatadatype)\nAnd to get some audio parameters directly from a file\nparams = HFile$params(\"file.wav\")\nsr = params[[1]]\nnframes = params[[2]]\nnchannels = params[[3]]\nduration = params[[4]]" + }, + { + "objectID": "about.html", + "href": "about.html", + "title": "About", + "section": "", + "text": "About this site" + }, + { + "objectID": "contents/hwindowtype.html", + "href": "contents/hwindowtype.html", + "title": "HWindowType", + "section": "", + "text": "A window type representation.\nSupports Blackman, Blackman2, BlackmanHarris, BlackmanHarris2, Hann and Hann2 types.", + "crumbs": [ + "Classes", + "HWindowType" + ] + }, + { + "objectID": "contents/hwindowtype.html#print", + "href": "contents/hwindowtype.html#print", + "title": "HWindowType", + "section": "print", + "text": "print\nprint() source \n\nPrints the HWindowType.\nDifferently from R’s behaviour, print doesn’t return the value invisibly.\n\n\nExamples\nwindowtype = HWindowType$Blackman\nwindowtype$print()\n\n# or similarly:\nprint(windowtype)", + "crumbs": [ + "Classes", + "HWindowType" + ] + }, + { + "objectID": "contents/hwindowtype.html#eq", + "href": "contents/hwindowtype.html#eq", + "title": "HWindowType", + "section": "eq", + "text": "eq\neq(other: HWindowType) -> bool source \n\nEquality with another HWindowType.\n\nArguments\n\nother\nAn HWindowType.\n\n\n\n\nReturns\nA bool.\n\n\nExamples\nwindowtype1 = HWindowType$Blackman\nwindowtype2 = HWindowType$Blackman\nwindowtype1$eq(windowtype2) # TRUE\n\n# or similarly:\nwindowtype1 == windowtype2", + "crumbs": [ + "Classes", + "HWindowType" + ] + }, + { + "objectID": "contents/hwindowtype.html#ne", + "href": "contents/hwindowtype.html#ne", + "title": "HWindowType", + "section": "ne", + "text": "ne\nne(other: HWindowType) -> bool source \n\nDifference with another HWindowType.\n\nArguments\n\nother\nAn HWindowType.\n\n\n\n\nReturns\nA bool.\n\n\nExamples\nwindowtype1 = HWindowType$Blackman\nwindowtype2 = HWindowType$Blackman\nwindowtype1$ne(windowtype2) # FALSE\n\n# or similarly:\nwindowtype1 != windowtype2", + "crumbs": [ + "Classes", + "HWindowType" + ] + }, { "objectID": "contents/haudiosink.html", "href": "contents/haudiosink.html", @@ -648,64 +838,6 @@ "HAudioSink" ] }, - { - "objectID": "index.html", - "href": "index.html", - "title": "Harmonium", - "section": "", - "text": "Harmonium is an audio interface inspired by Python’s librosa.\n\n\nBasic usage\nLoad the library\nlibrary(harmonium)\nCreate an HArray from an existing array\narr = matrix(c(1,2,3,4,5,6,7,8,9,10,11,12), ncol = 2)\ndtype = HDataType$float64\nharray = HArray$new_from_values(arr, dtype = dtype)\nprint(harray)\nOr decode from an existing audio file\nl = HFile$decode(\"file.wav\", dtype)\nharray = l[[0]]\nsr = l[[1]] # sampling rate\nprint(harray)\nVerify the dimensions\nharray$len()\nHAudioOp$nchannels(harray)\nHAudioOp$nframes(harray)\nVerify the data type\nharray$dtype()\nConvert to an R array\nharray$collect()\nConvert to mono\nHAudioOp$to_mono(harray)\nResample the haudio\nsr_in = 48000L\nsr_out = 22050L\nnbr_channels = HAudioOp$nchannels(harray)\ndtype = HDataType$float64\nres_type = HResamplerType$fft_fixed_in\nresampler = HResampler$new_fft(sr_in, sr_out, nbr_channels, res_type)\nhresampler$process(harray)\nPlay the haudio\nhaudiosink = HAudioSink$new()\nhaudiosink$append_from_harray(harray)\nOr play directly from the file\nhaudiosink$append_from_file(\"file.wav\")\nGet the number of audios to be played\nhaudiosink$len()\nDouble the audio volume and the playback speed\nhaudiosink$set_volume(2)\nhaudiosink$set_speed(2)\nPause the playback and confirms it is paused\nhaudiosink$pause()\nhaudiosink$is_paused()\nIt is also possible to get metadata from an audio file\nmetatadatype = HMetadataType$text\nHFile$metadata(\"file.wav\", metatadatype)\nAnd to get some audio parameters directly from a file\nparams = HFile$params(\"file.wav\")\nsr = params[[1]]\nnframes = params[[2]]\nnchannels = params[[3]]\nduration = params[[4]]" - }, - { - "objectID": "about.html", - "href": "about.html", - "title": "About", - "section": "", - "text": "About this site" - }, - { - "objectID": "contents/hwindowtype.html", - "href": "contents/hwindowtype.html", - "title": "HWindowType", - "section": "", - "text": "A window type representation.\nSupports Blackman, Blackman2, BlackmanHarris, BlackmanHarris2, Hann and Hann2 types.", - "crumbs": [ - "Classes", - "HWindowType" - ] - }, - { - "objectID": "contents/hwindowtype.html#print", - "href": "contents/hwindowtype.html#print", - "title": "HWindowType", - "section": "print", - "text": "print\nprint() source \n\nPrints the HWindowType.\nDifferently from R’s behaviour, print doesn’t return the value invisibly.\n\n\nExamples\nwindowtype = HWindowType$Blackman\nwindowtype$print()\n\n# or similarly:\nprint(windowtype)", - "crumbs": [ - "Classes", - "HWindowType" - ] - }, - { - "objectID": "contents/hwindowtype.html#eq", - "href": "contents/hwindowtype.html#eq", - "title": "HWindowType", - "section": "eq", - "text": "eq\neq(other: HWindowType) -> bool source \n\nEquality with another HWindowType.\n\nArguments\n\nother\nAn HWindowType.\n\n\n\n\nReturns\nA bool.\n\n\nExamples\nwindowtype1 = HWindowType$Blackman\nwindowtype2 = HWindowType$Blackman\nwindowtype1$eq(windowtype2) # TRUE\n\n# or similarly:\nwindowtype1 == windowtype2", - "crumbs": [ - "Classes", - "HWindowType" - ] - }, - { - "objectID": "contents/hwindowtype.html#ne", - "href": "contents/hwindowtype.html#ne", - "title": "HWindowType", - "section": "ne", - "text": "ne\nne(other: HWindowType) -> bool source \n\nDifference with another HWindowType.\n\nArguments\n\nother\nAn HWindowType.\n\n\n\n\nReturns\nA bool.\n\n\nExamples\nwindowtype1 = HWindowType$Blackman\nwindowtype2 = HWindowType$Blackman\nwindowtype1$ne(windowtype2) # FALSE\n\n# or similarly:\nwindowtype1 != windowtype2", - "crumbs": [ - "Classes", - "HWindowType" - ] - }, { "objectID": "contents/hmetadatatype.html", "href": "contents/hmetadatatype.html",