DP44/enriched-qwen3-coder-next/DataPRO/FftSharp/Windows.md

source_files, generated_at, model, schema_version, sha256

source_files	generated_at	model	schema_version	sha256
DataPRO/FftSharp/Windows/Bartlett.cs DataPRO/FftSharp/Windows/Cosine.cs DataPRO/FftSharp/Windows/Welch.cs DataPRO/FftSharp/Windows/Rectangular.cs DataPRO/FftSharp/Windows/Hanning.cs DataPRO/FftSharp/Windows/Hamming.cs DataPRO/FftSharp/Windows/FlatTop.cs DataPRO/FftSharp/Windows/Blackman.cs DataPRO/FftSharp/Windows/BlackmanHarris.cs DataPRO/FftSharp/Windows/Tukey.cs DataPRO/FftSharp/Windows/Kaiser.cs	2026-04-16T04:24:07.110679+00:00	Qwen/Qwen3-Coder-Next-FP8	1	330f92c33efc913c

Windows

Documentation: FftSharp.Windows Module

1. Purpose

This module provides a suite of window functions used in spectral analysis (e.g., before applying the FFT) to mitigate spectral leakage. Each window class implements a specific mathematical formulation to taper the signal at its edges, reducing discontinuities introduced by the finite-length FFT. The classes inherit from an abstract Window base class and implement the IWindow interface, offering a consistent API for generating window coefficients of a given size. These windows are intended for use in signal processing pipelines where accurate frequency-domain representation is required.

2. Public Interface

All window classes are concrete, non-abstract subclasses of Window and implement IWindow. Each defines a public constructor (with optional parameters for tunable windows) and overrides Name, Description, and the protected windowValue(int index, int size) method. The base Window class (not shown in source) is assumed to expose a public method (e.g., Generate(int size)) that populates an array by calling windowValue for each index.

• Bartlett

  • Name: "Bartlett–Hann"
  • Description: Triangular (2nd-order B-spline), convolution of two half-sized rectangular windows.
  • windowValue(index, size): 1 - |(index - size/2) / (size/2)|

• Cosine

  • Name: "Cosine"
  • Description: Simple sine-shaped window (sin(π·i/(N−1))), reaches zero at edges; discouraged for practical use.
  • windowValue(index, size): Math.Sin(index * Math.PI / (size - 1))

• Welch

  • Name: "Welch"
  • Description: Parabolic window, better frequency response than Bartlett below π, but with a distinct bump above π; used for antialiasing/resampling.
  • windowValue(index, size): 1 - ((index - (size-1)/2) / ((size-1)/2))²

• Rectangular

  • Name: "Rectangular"
  • Description: Boxcar/Dirichlet window (all ones); preserves transients but causes high spectral leakage.
  • windowValue(index, size): 1

• Hanning

  • Name: "Hanning"
  • Description: Sinusoidal window touching zero at edges; low leakage, good for general use.
  • windowValue(index, size): 0.5 - 0.5 * cos(2π·i / size)

• Hamming

  • Name: "Hamming"
  • Description: Sinusoidal window not zero at edges; designed to cancel the largest sidelobe.
  • windowValue(index, size): 0.54 - 0.46 * cos(2π·i / size)

• FlatTop

  • Name: "FlatTop"
  • Description: Partially negative-valued window; minimal scalloping loss, ideal for amplitude measurement. Inherits from Blackman with fixed coefficients.
  • Constructor: FlatTop() calls base(0.2810639, 0.5208972, 0.1980399)
  • Uses Blackman.windowValue with those coefficients:
    A - B·cos(2π·i/size) + C·cos(4π·i/size)

• Blackman

  • Name: "Blackman"
  • Description: Three-term cosine window; exact coefficients null 3rd/4th sidelobes.
  • Constructors:
    • Blackman() — uses default coefficients (A=0.42659071, B=0.49656062, C=0.07684867)
    • Blackman(double a, double b, double c) — custom coefficients
  • windowValue(index, size): A - B·cos(2π·i/size) + C·cos(4π·i/size)

• BlackmanHarris

  • Name: "Blackman-Harris"
  • Description: Four-term cosine window; wide main lobe but strong sidelobe suppression.
  • Constructors:
    • BlackmanHarris() — uses default coefficients (A=0.35875, B=0.48829, C=0.14128, D=0.01168)
    • BlackmanHarris(double a, double b, double c, double d) — custom coefficients
  • windowValue(index, size): A - B·cos(2π·i/size) + C·cos(4π·i/size) - D·cos(6π·i/size)

• Tukey

  • Name: "Tukey"
  • Description: Flat center with cosine taper at edges; controlled by Alpha (0–1). Ideal for transient analysis.
  • Constructors:
    • Tukey() — Alpha = 0.5
    • Tukey(double alpha = 0.5)
  • windowValue(index, size):
    • If index < edgeSizePoints or index > size - edgeSizePoints: (1 - cos(index * 2π / (Alpha * size))) / 2
    • Else: 1
    • Where edgeSizePoints = (int)(size * Alpha / 2)

• Kaiser

  • Name: "Kaiser-Bessel"
  • Description: Tunable via Beta; balances main lobe width, sidelobe height, and distance.
  • Constructors:
    • Kaiser() — Beta = 15
    • Kaiser(double beta)
  • windowValue(index, size): I0(Beta * sqrt(1 - ((index - (size-1)/2) / ((size-1)/2))²)) / I0(Beta)
  • I0(double x): Modified Bessel function of the first kind (order 0), implemented via piecewise series.

3. Invariants

• All windows are symmetric about index = (size - 1) / 2. This is evident from the use of (index - center) in all formulas.
• Window values are computed for indices 0 ≤ index < size.
• For all windows except Rectangular, windowValue(0, size) == windowValue(size - 1, size).
• For Hanning, Hamming, Blackman, BlackmanHarris, and FlatTop, the window is periodic with period size in the cosine argument (i.e., cos(2π·i/size)).
• Tukey uses integer truncation for edgeSizePoints, which may cause asymmetry for odd size and non-integer size * Alpha / 2.
• Kaiser window is defined only for size > 1; division by zero occurs if size == 1 (since alpha = (size-1)/2 = 0).

4. Dependencies

• Internal: All classes depend on the abstract base class Window and interface IWindow (not shown), which define the contract for window generation (e.g., a public method like double[] Generate(int size)).
• External:
  • System namespace (for Math, Abs, Cos, Sin, Exp, Sqrt, Pow).
  • FlatTop inherits from Blackman, reusing its windowValue implementation with fixed coefficients.
• Inferred usage: These classes are likely consumed by an FFT processing pipeline (e.g., FftSharp.Fft or similar) that applies windowing before forward FFT and/or after inverse FFT.

5. Gotchas

• Cosine window naming: Despite the class name, windowValue computes sin(π·i/(N−1)), not a cosine. This is likely intentional (sine is a shifted cosine), but the name may mislead.
• Bartlett vs. standard Bartlett: The description says "Bartlett–Hann", but the formula matches the standard Bartlett (triangular) window, not the Bartlett–Hann (which combines triangular and cosine terms). This may be a documentation or naming error.
• Tukey edge handling: For non-integer size * Alpha / 2, edgeSizePoints truncates, causing asymmetric tapering when size is odd and Alpha is not tuned to avoid this.
• Kaiser division by zero: If size == 1, alpha = 0, leading to division by zero in ((index - alpha) / alpha)². This case is not guarded.
• FlatTop inheritance: FlatTop inherits from Blackman and hardcodes coefficients, but Blackman’s constructor is not protected, so FlatTop must call base(...) explicitly. This tight coupling makes FlatTop inflexible (e.g., no custom coefficients).
• Missing IWindow implementation: The source does not show the IWindow interface or Window base class, so the exact public API (e.g., method names, return types) is inferred.
• No validation of size: All windowValue methods assume size > 1. For size == 1, Welch and Kaiser involve division by zero; Tukey’s edgeSizePoints becomes 0, but the logic may still hold.

None identified beyond the above.