hypnosound 1.9.0 → 1.11.0

package/.eslintrc

@@ -1,12 +1,12 @@
-{
-    "parserOptions": {
-        "ecmaVersion": 2024,
-        "sourceType": "module"
-    },
-    "plugins": [
-        "prettier"
-    ],
-    "rules": {
-        "prettier/prettier": "warn"
-    }
-}
+{
+    "parserOptions": {
+        "ecmaVersion": 2024,
+        "sourceType": "module"
+    },
+    "plugins": [
+        "prettier"
+    ],
+    "rules": {
+        "prettier/prettier": "warn"
+    }
+}

package/.github/workflows/publish.yml

@@ -0,0 +1,44 @@
+name: Publish to npm
+
+on:
+  push:
+    branches: [main]
+    paths: [package.json]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Check if version changed
+        id: version-check
+        run: |
+          LOCAL_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view hypnosound version 2>/dev/null || echo "0.0.0")
+          echo "local=$LOCAL_VERSION" >> "$GITHUB_OUTPUT"
+          echo "npm=$NPM_VERSION" >> "$GITHUB_OUTPUT"
+          if [ "$LOCAL_VERSION" != "$NPM_VERSION" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Publish
+        if: steps.version-check.outputs.changed == 'true'
+        run: npm publish --provenance --access public
+
+      - name: Skip
+        if: steps.version-check.outputs.changed == 'false'
+        run: echo "Version ${{ steps.version-check.outputs.local }} already published, skipping"

package/.nvmrc

@@ -1 +1 @@
-v21.6.1
+v21.6.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 hypnodroid
-
-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:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-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.
+MIT License
+
+Copyright (c) 2024 hypnodroid
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

package/docs/IMPROVEMENTS.md

@@ -0,0 +1,43 @@
+# Proposed Improvements
+
+## 1. Consistent Output Normalization (0-1)
+
+Different features currently use wildly different scales: `energy` divides by 1000 (can exceed 1.0), `spectralCrest` is multiplied by 100, `spectralFlux` and `spectralRoughness` divide by 100,000. This makes features hard to compare or feed into downstream systems (ML, visualizations). Standardize all features to the 0-1 range.
+
+## 2. Configurable Sample Rate
+
+44100 Hz is hardcoded across `bass.js`, `mids.js`, `treble.js`, and `pitchClass.js`. Browsers commonly use 48000 Hz, and pro audio uses 96000 Hz. Accept `sampleRate` as an optional parameter in all frequency-dependent features.
+
+## 3. Float32Array Input Support
+
+The library assumes `Uint8Array` input from `getByteFrequencyData()`. But `getFloatFrequencyData()` returns `Float32Array` with dB values offering higher precision, and offline analysis pipelines also produce float data. Detect input type and handle both automatically.
+
+## 4. Configurable Frequency Bands
+
+`bass` (0-400 Hz), `mids` (400-4000 Hz), and `treble` (4000-20000 Hz) have hardcoded ranges. Add a generic `bandEnergy(fft, lowHz, highHz, sampleRate?)` function, and make bass/mids/treble thin wrappers over it.
+
+## 5. RMS and dBFS
+
+The library has `energy` (sum of squares) but no perceptual loudness measures. RMS (root-mean-square amplitude) and dBFS (decibels relative to full scale) are fundamental for audio metering and level detection. Both are cheap to compute and widely useful.
+
+**Status: Implemented**
+
+## 6. Onset / Transient Detection
+
+`spectralFlux` is already computed but the library doesn't surface onset detection - the most common real-time analysis use case (beat detection, rhythm sync). Combine spectral flux with adaptive thresholding using the existing stats infrastructure.
+
+## 7. Chromagram / Pitch Class Distribution
+
+`pitchClass` returns only the dominant pitch class. For harmonic analysis, chord detection, or key detection, users need the full distribution across all 12 pitch classes. Add `chromagram(fft)` returning energy per pitch class.
+
+## 8. Configurable Stats History Window
+
+`makeCalculateStats()` defaults to 500 samples. At 60 fps that's ~8 seconds; at 10 fps it's ~50 seconds. Expose `historySize` as a constructor option on `AudioProcessor`.
+
+## 9. Spectral Flatness (Tonality Coefficient)
+
+Distinguishes tonal (music) from noisy (percussion, speech) content. Geometric mean / arithmetic mean of the power spectrum. Returns 0 (pure tone) to 1 (white noise).
+
+## 10. Zero-Crossing Rate (Time Domain)
+
+All current features are frequency-domain. ZCR is a simple time-domain feature for distinguishing voiced/unvoiced speech and percussive vs tonal content. Accepts raw PCM samples.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "hypnosound",
     "type": "module",
-    "version": "1.9.0",
+    "version": "1.11.0",
     "description": "A small library for analyzing audio",
     "main": "index.js",
     "scripts": {

package/src/audio/bass.js

@@ -1,34 +1,34 @@
-export default function bass(fft) {
-    const sampleRate = 44100
-    const totalSamples = fft.length
-    return calculateBassPower(fft, sampleRate, totalSamples)
-}
-
-function calculateBassPower(fft, sampleRate, totalSamples) {
-    const lowerBound = 0
-    const upperBound = 400
-    let bassEnergy = 0
-    let maxEnergy = 0
-
-    // Calculate frequency resolution
-    const frequencyResolution = sampleRate / totalSamples
-
-    for (let i = 0; i < fft.length; i++) {
-        let frequency = i * frequencyResolution
-        // Normalize each FFT value from 0 to 1 (assuming Uint8Array values 0-255)
-        let magnitude = fft[i] / 255
-        let power = magnitude * magnitude
-
-        // Accumulate max energy for normalization
-        maxEnergy += power
-
-        // Isolate and accumulate bass frequencies
-        if (frequency >= lowerBound && frequency <= upperBound) {
-            bassEnergy += power
-        }
-    }
-
-    // Normalize bass energy from 0 to 1
-    let normalizedBassPower = maxEnergy > 0 ? bassEnergy / maxEnergy : 0
-    return isNaN(normalizedBassPower) ? 0 : normalizedBassPower
-}
+export default function bass(fft) {
+    const sampleRate = 44100
+    const totalSamples = fft.length
+    return calculateBassPower(fft, sampleRate, totalSamples)
+}
+
+function calculateBassPower(fft, sampleRate, totalSamples) {
+    const lowerBound = 0
+    const upperBound = 400
+    let bassEnergy = 0
+    let maxEnergy = 0
+
+    // Calculate frequency resolution
+    const frequencyResolution = sampleRate / totalSamples
+
+    for (let i = 0; i < fft.length; i++) {
+        let frequency = i * frequencyResolution
+        // Normalize each FFT value from 0 to 1 (assuming Uint8Array values 0-255)
+        let magnitude = fft[i] / 255
+        let power = magnitude * magnitude
+
+        // Accumulate max energy for normalization
+        maxEnergy += power
+
+        // Isolate and accumulate bass frequencies
+        if (frequency >= lowerBound && frequency <= upperBound) {
+            bassEnergy += power
+        }
+    }
+
+    // Normalize bass energy from 0 to 1
+    let normalizedBassPower = maxEnergy > 0 ? bassEnergy / maxEnergy : 0
+    return isNaN(normalizedBassPower) ? 0 : normalizedBassPower
+}

package/src/audio/dbfs.js

@@ -0,0 +1,14 @@
+export default function dbfs(fft) {
+    let sumOfSquares = 0
+    for (let i = 0; i < fft.length; i++) {
+        const normalized = fft[i] / 255
+        sumOfSquares += normalized * normalized
+    }
+    const rmsValue = Math.sqrt(sumOfSquares / fft.length)
+    if (rmsValue === 0) return 0
+    // 20 * log10(rms) gives dBFS, range is -Infinity to 0
+    // Normalize to 0-1: silence = 0, full scale = 1
+    // Clamp at -100 dB as practical floor
+    const db = 20 * Math.log10(rmsValue)
+    return Math.max(0, (db + 100) / 100)
+}

package/src/audio/energy.js

@@ -1,19 +1,19 @@
-export default function energy(fft) {
-    return calculateFFTEnergy(fft) / 1000
-}
-
-function calculateFFTEnergy(currentSignal) {
-    let energy = 0
-    const maxPossibleValue = 1 // This should be 1 if your data is normalized between 0 and 1
-    const maxPossibleEnergy = currentSignal.length // Total samples if each sample was at maximum value
-
-    for (let i = 0; i < currentSignal.length; i++) {
-        let normalizedValue = currentSignal[i] / maxPossibleValue // Normalize each FFT value
-        energy += normalizedValue * normalizedValue // Sum the squares of the normalized values
-    }
-
-    // Normalize the computed energy by the number of samples since each sample's max energy would be 1 if maxPossibleValue is 1
-    energy = energy / currentSignal.length
-
-    return energy
-}
+export default function energy(fft) {
+    return calculateFFTEnergy(fft) / 1000
+}
+
+function calculateFFTEnergy(currentSignal) {
+    let energy = 0
+    const maxPossibleValue = 1 // This should be 1 if your data is normalized between 0 and 1
+    const maxPossibleEnergy = currentSignal.length // Total samples if each sample was at maximum value
+
+    for (let i = 0; i < currentSignal.length; i++) {
+        let normalizedValue = currentSignal[i] / maxPossibleValue // Normalize each FFT value
+        energy += normalizedValue * normalizedValue // Sum the squares of the normalized values
+    }
+
+    // Normalize the computed energy by the number of samples since each sample's max energy would be 1 if maxPossibleValue is 1
+    energy = energy / currentSignal.length
+
+    return energy
+}

package/src/audio/index.js

@@ -1,30 +1,34 @@
-export { default as bass } from "./bass.js"
-export { default as energy } from "./energy.js"
-export { default as mids } from "./mids.js"
-export { default as pitchClass } from "./pitchClass.js"
-export { default as spectralCentroid } from "./spectralCentroid.js"
-export { default as spectralCrest } from "./spectralCrest.js"
-export { default as spectralEntropy } from "./spectralEntropy.js"
-export { default as spectralFlux } from "./spectralFlux.js"
-export { default as spectralKurtosis } from "./spectralKurtosis.js"
-export { default as spectralRolloff } from "./spectralRolloff.js"
-export { default as spectralRoughness } from "./spectralRoughness.js"
-export { default as spectralSkew } from "./spectralSkew.js"
-export { default as spectralSpread } from "./spectralSpread.js"
-export { default as treble } from "./treble.js"
-export const AudioFeatures = [
-  "bass",
-  "energy",
-  "mids",
-  "pitchClass",
-  "spectralCentroid",
-  "spectralCrest",
-  "spectralEntropy",
-  "spectralFlux",
-  "spectralKurtosis",
-  "spectralRolloff",
-  "spectralRoughness",
-  "spectralSkew",
-  "spectralSpread",
-  "treble"
+export { default as spectralSpread } from "./spectralSpread.js"
+export { default as treble } from "./treble.js"
+export { default as spectralSkew } from "./spectralSkew.js"
+export { default as dbfs } from "./dbfs.js"
+export { default as pitchClass } from "./pitchClass.js"
+export { default as spectralRoughness } from "./spectralRoughness.js"
+export { default as spectralKurtosis } from "./spectralKurtosis.js"
+export { default as spectralCrest } from "./spectralCrest.js"
+export { default as rms } from "./rms.js"
+export { default as spectralCentroid } from "./spectralCentroid.js"
+export { default as spectralEntropy } from "./spectralEntropy.js"
+export { default as mids } from "./mids.js"
+export { default as spectralFlux } from "./spectralFlux.js"
+export { default as energy } from "./energy.js"
+export { default as bass } from "./bass.js"
+export { default as spectralRolloff } from "./spectralRolloff.js"
+export const AudioFeatures = [
+  "spectralSpread",
+  "treble",
+  "spectralSkew",
+  "dbfs",
+  "pitchClass",
+  "spectralRoughness",
+  "spectralKurtosis",
+  "spectralCrest",
+  "rms",
+  "spectralCentroid",
+  "spectralEntropy",
+  "mids",
+  "spectralFlux",
+  "energy",
+  "bass",
+  "spectralRolloff"
 ]

package/src/audio/mids.js

@@ -1,33 +1,33 @@
-export default function mids(fft) {
-    const sampleRate = 44100
-    const totalSamples = fft.length
-    return calculateMidPower(fft, sampleRate, totalSamples)
-}
-
-function calculateMidPower(fft, sampleRate, totalSamples) {
-    const lowerBound = 400 // 400 Hz
-    const upperBound = 4000 // 4000 Hz
-    let midEnergy = 0
-    let maxEnergy = 0
-
-    // Calculate frequency resolution
-    const frequencyResolution = sampleRate / totalSamples
-
-    for (let i = 0; i < fft.length; i++) {
-        let frequency = i * frequencyResolution
-        let magnitude = Math.abs(fft[i]) / totalSamples
-        let power = magnitude * magnitude
-
-        // Accumulate max energy for normalization
-        maxEnergy += power
-
-        // Isolate and accumulate mid frequencies
-        if (frequency >= lowerBound && frequency <= upperBound) {
-            midEnergy += power
-        }
-    }
-
-    // Normalize mid energy from 0 to 1
-    let normalizedMidPower = midEnergy / maxEnergy
-    return isNaN(normalizedMidPower) ? 0 : normalizedMidPower // Scale by 10 if needed, similar to your original function
-}
+export default function mids(fft) {
+    const sampleRate = 44100
+    const totalSamples = fft.length
+    return calculateMidPower(fft, sampleRate, totalSamples)
+}
+
+function calculateMidPower(fft, sampleRate, totalSamples) {
+    const lowerBound = 400 // 400 Hz
+    const upperBound = 4000 // 4000 Hz
+    let midEnergy = 0
+    let maxEnergy = 0
+
+    // Calculate frequency resolution
+    const frequencyResolution = sampleRate / totalSamples
+
+    for (let i = 0; i < fft.length; i++) {
+        let frequency = i * frequencyResolution
+        let magnitude = Math.abs(fft[i]) / totalSamples
+        let power = magnitude * magnitude
+
+        // Accumulate max energy for normalization
+        maxEnergy += power
+
+        // Isolate and accumulate mid frequencies
+        if (frequency >= lowerBound && frequency <= upperBound) {
+            midEnergy += power
+        }
+    }
+
+    // Normalize mid energy from 0 to 1
+    let normalizedMidPower = midEnergy / maxEnergy
+    return isNaN(normalizedMidPower) ? 0 : normalizedMidPower // Scale by 10 if needed, similar to your original function
+}

package/src/audio/pitchClass.js

@@ -1,26 +1,26 @@
-export default function pitchClass(fft, sampleRate = 44100) {
-    // Constants for the FFT processing
-    const fftSize = fft.length
-    const freqResolution = sampleRate / fftSize
-
-    // Finding the dominant frequency in the FFT data
-    let maxIndex = 0
-    let maxValue = 0
-    for (let i = 1; i < fft.length; i++) {
-        // start from 1 to skip DC offset
-        if (fft[i] > maxValue) {
-            maxValue = fft[i]
-            maxIndex = i
-        }
-    }
-    const dominantFreq = maxIndex * freqResolution
-
-    // Convert to MIDI note then to pitchClass
-    const midiNote = 69 + 12 * Math.log2(dominantFreq / 440)
-    const pitchClass = Math.round(midiNote) % 12 // round to reduce minor fluctuation effects
-
-    // Normalize to a 0-1 range
-    const normalizedpitchClass = pitchClass / 12
-
-    return isNaN(normalizedpitchClass) ? 0 : normalizedpitchClass
-}
+export default function pitchClass(fft, sampleRate = 44100) {
+    // Constants for the FFT processing
+    const fftSize = fft.length
+    const freqResolution = sampleRate / fftSize
+
+    // Finding the dominant frequency in the FFT data
+    let maxIndex = 0
+    let maxValue = 0
+    for (let i = 1; i < fft.length; i++) {
+        // start from 1 to skip DC offset
+        if (fft[i] > maxValue) {
+            maxValue = fft[i]
+            maxIndex = i
+        }
+    }
+    const dominantFreq = maxIndex * freqResolution
+
+    // Convert to MIDI note then to pitchClass
+    const midiNote = 69 + 12 * Math.log2(dominantFreq / 440)
+    const pitchClass = Math.round(midiNote) % 12 // round to reduce minor fluctuation effects
+
+    // Normalize to a 0-1 range
+    const normalizedpitchClass = pitchClass / 12
+
+    return isNaN(normalizedpitchClass) ? 0 : normalizedpitchClass
+}

package/src/audio/rms.js

@@ -0,0 +1,8 @@
+export default function rms(fft) {
+    let sumOfSquares = 0
+    for (let i = 0; i < fft.length; i++) {
+        const normalized = fft[i] / 255
+        sumOfSquares += normalized * normalized
+    }
+    return Math.sqrt(sumOfSquares / fft.length)
+}

package/src/audio/spectralCentroid.js

@@ -1,25 +1,25 @@
-export default function spectralCentroid(fft) {
-    const computed = calculateSpectralCentroid(fft) // Process FFT data
-    return computed * 1.5
-}
-function calculateSpectralCentroid(ampSpectrum) {
-    if (!ampSpectrum.length) return null // Early exit if the spectrum is empty
-
-    let numerator = 0
-    let denominator = 0
-
-    // Calculate the weighted sum (numerator) and the sum of the amplitudes (denominator)
-    ampSpectrum.forEach((amplitude, index) => {
-        numerator += index * amplitude
-        denominator += amplitude
-    })
-
-    // Avoid dividing by zero
-    if (denominator === 0) return null
-
-    const centroidIndex = numerator / denominator
-    // Normalize the centroid index to be between 0 and 1
-    const normalizedCentroid = centroidIndex / (ampSpectrum.length - 1)
-
-    return normalizedCentroid
-}
+export default function spectralCentroid(fft) {
+    const computed = calculateSpectralCentroid(fft) // Process FFT data
+    return computed * 1.5
+}
+function calculateSpectralCentroid(ampSpectrum) {
+    if (!ampSpectrum.length) return null // Early exit if the spectrum is empty
+
+    let numerator = 0
+    let denominator = 0
+
+    // Calculate the weighted sum (numerator) and the sum of the amplitudes (denominator)
+    ampSpectrum.forEach((amplitude, index) => {
+        numerator += index * amplitude
+        denominator += amplitude
+    })
+
+    // Avoid dividing by zero
+    if (denominator === 0) return null
+
+    const centroidIndex = numerator / denominator
+    // Normalize the centroid index to be between 0 and 1
+    const normalizedCentroid = centroidIndex / (ampSpectrum.length - 1)
+
+    return normalizedCentroid
+}

package/src/audio/spectralCrest.js

@@ -1,17 +1,17 @@
-export default function spectralCrest(fft) {
-    const computed = calculateSpectralCrest(fft) // Process FFT data
-    return computed * 100
-}
-
-function calculateSpectralCrest(fftData) {
-    // Find the maximum amplitude in the spectrum
-    const maxAmplitude = Math.max(...fftData)
-
-    // Calculate the sum of all amplitudes
-    const sumAmplitudes = fftData.reduce((sum, amplitude) => sum + amplitude, 0)
-
-    // Calculate the Spectral Crest
-    const spectralCrest = sumAmplitudes !== 0 ? maxAmplitude / sumAmplitudes : 0
-
-    return spectralCrest
-}
+export default function spectralCrest(fft) {
+    const computed = calculateSpectralCrest(fft) // Process FFT data
+    return computed * 100
+}
+
+function calculateSpectralCrest(fftData) {
+    // Find the maximum amplitude in the spectrum
+    const maxAmplitude = Math.max(...fftData)
+
+    // Calculate the sum of all amplitudes
+    const sumAmplitudes = fftData.reduce((sum, amplitude) => sum + amplitude, 0)
+
+    // Calculate the Spectral Crest
+    const spectralCrest = sumAmplitudes !== 0 ? maxAmplitude / sumAmplitudes : 0
+
+    return spectralCrest
+}

package/src/audio/spectralEntropy.js

@@ -1,28 +1,28 @@
-export default function spectralEntropy(fft) {
-    return calculateSpectralEntropy(fft) // Process FFT data
-}
-
-function toPowerSpectrum(fftData) {
-    return fftData.map((amplitude) => Math.pow(amplitude, 2))
-}
-
-function calculateSpectralEntropy(fftData) {
-    const powerSpectrum = toPowerSpectrum(fftData)
-    // Normalize the power spectrum to create a probability distribution
-    const totalPower = powerSpectrum.reduce((sum, val) => sum + val, 0)
-    if (totalPower === 0) return 0
-    const probabilityDistribution = new Float32Array(powerSpectrum.length)
-    for (let i = 0; i < powerSpectrum.length; i++) {
-        probabilityDistribution[i] = powerSpectrum[i] / totalPower
-    }
-
-    const entropy = probabilityDistribution.reduce((sum, prob) => {
-        if (prob > 0) {
-            const logProb = Math.log(prob)
-            return sum - prob * logProb
-        } else {
-            return sum
-        }
-    }, 0)
-    return entropy / Math.log(probabilityDistribution.length)
-}
+export default function spectralEntropy(fft) {
+    return calculateSpectralEntropy(fft) // Process FFT data
+}
+
+function toPowerSpectrum(fftData) {
+    return fftData.map((amplitude) => Math.pow(amplitude, 2))
+}
+
+function calculateSpectralEntropy(fftData) {
+    const powerSpectrum = toPowerSpectrum(fftData)
+    // Normalize the power spectrum to create a probability distribution
+    const totalPower = powerSpectrum.reduce((sum, val) => sum + val, 0)
+    if (totalPower === 0) return 0
+    const probabilityDistribution = new Float32Array(powerSpectrum.length)
+    for (let i = 0; i < powerSpectrum.length; i++) {
+        probabilityDistribution[i] = powerSpectrum[i] / totalPower
+    }
+
+    const entropy = probabilityDistribution.reduce((sum, prob) => {
+        if (prob > 0) {
+            const logProb = Math.log(prob)
+            return sum - prob * logProb
+        } else {
+            return sum
+        }
+    }, 0)
+    return entropy / Math.log(probabilityDistribution.length)
+}