sethares-dissonance 0.0.1 → 0.1.0

package/classes/DissonanceCurve.ts

@@ -1,45 +1,57 @@
-import { getSetharesDissonance, transpose, type Spectrum } from "../lib/utils";
-
-type DissonanceCurveOptions = {
-  context: Spectrum;
-  compliment: Spectrum;
-  precision?: number;
+import {
+  getSetharesDissonance,
+  SETHARES_DISSONANCE_PARAMS,
+  transpose,
+  type SpectrumPartial,
+} from "../lib";
+
+export type DissonanceCurveOptions = Partial<
+  typeof SETHARES_DISSONANCE_PARAMS
+> & {
+  context: SpectrumPartial[];
+  complement: SpectrumPartial[];
+  step?: number;
   rangeMin?: number;
   rangeMax?: number;
 };
 
 export class DissonanceCurve {
   private _data: Map<number, number> = new Map();
-  private step: number;
 
   public readonly rangeMin: NonNullable<DissonanceCurveOptions["rangeMin"]>;
   public readonly rangeMax: NonNullable<DissonanceCurveOptions["rangeMax"]>;
-  public readonly precision: NonNullable<DissonanceCurveOptions["precision"]>;
+  public readonly step: NonNullable<DissonanceCurveOptions["step"]>;
   public readonly context: DissonanceCurveOptions["context"];
-  public readonly compliment: DissonanceCurveOptions["compliment"];
+  public readonly complement: DissonanceCurveOptions["complement"];
   public readonly maxDissonance: number = 0;
   public readonly change: number = 0;
 
   constructor(opts: DissonanceCurveOptions) {
-    this.context = opts.context;
-    this.compliment = opts.compliment;
-
-    this.rangeMin = opts.rangeMin ?? 0;
-    this.rangeMax = opts.rangeMax ?? 1200;
-    this.precision = opts.precision ?? 1;
+    const {
+      context,
+      complement,
+      rangeMin,
+      rangeMax,
+      step,
+      ...dissonanceParams
+    } = opts;
+
+    this.context = context;
+    this.complement = complement;
+
+    this.rangeMin = rangeMin ?? 0;
+    this.rangeMax = rangeMax ?? 1200;
+    this.step = step ?? 1;
 
     if (this.rangeMin > this.rangeMax)
       throw Error("rangeMin should be less or equal to rangeMax");
-    if (this.precision <= 0)
-      throw Error("precision should be greater than zero");
-
-    this.step =
-      (this.rangeMax - this.rangeMin) / (this.rangeMax * this.precision);
+    if (this.step <= 0) throw Error("precision should be greater than zero");
 
     for (let cent = this.rangeMin; cent <= this.rangeMax; cent += this.step) {
       const dissonance = getSetharesDissonance(
         this.context,
-        transpose(this.compliment, cent)
+        transpose(this.complement, cent),
+        dissonanceParams
       );
 
       if (dissonance > this.maxDissonance) this.maxDissonance = dissonance;
@@ -52,6 +64,10 @@ export class DissonanceCurve {
     return Array.from(this._data.entries()).sort((a, b) => a[0] - b[0]);
   }
 
+  public get(cent: number) {
+    return this._data.get(cent);
+  }
+
   private getRowString(row: Array<number | string>) {
     if (row.length === 0) return "";
 

package/lib/utils.ts

@@ -1,16 +1,25 @@
-export type Spectrum = {
-  freq: number;
-  loudness: number;
-}[];
+export type SpectrumPartial = {
+  rate: number;
+  amplitude: number;
+  phase?: number;
+};
+
+const NORMALISATION_PRESSURE_UNIT = 2.8284271247461905;
 
-/** The formula to calculate loudness from amplitude proposed by Sethares in the appendix "How to Draw Dissonance Curves" */
-export function getSetharesLoudness(amplitude: number): number {
-  const P_e = amplitude / Math.SQRT2;
-  const P_ref = 20;
+/**
+ * The formula to calculate loudness from amplitude. The converstion to SPL (phons) is done according to Sethares in the appendix "How to Draw Dissonance Curves". The converstion to loudness is done according to https://sengpielaudio.com/calculatorSonephon.htm
+ * @param {number} amplitude - the normalized peak value where 0.001 corresponds to SPL of 40 db or 1 sone and 1 to SPL of 100db and 64 sones. Normalisation is done for the simplicity of providing harmonic spectrum with amplitudes 1, 1/2, 1/3, ...
+ */
+export function getLoudness(amplitude: number): number {
+  const rms = amplitude / Math.SQRT2;
+  const pressure = rms * NORMALISATION_PRESSURE_UNIT;
+  const referencePressure = 2e-5;
 
-  const SPL = 20 * Math.log10(P_e / P_ref);
+  const phons = 20 * Math.log10(pressure / referencePressure);
 
-  return 2 ** (SPL / 10) / 16;
+  if (phons < 8) return 0;
+  if (phons < 40) return Math.pow(phons / 40, 2.86) - 0.005;
+  return Math.pow(2, (phons - 40) / 10);
 }
 
 /** Fitting parameters proposed by Sethares in the appendix "How to Draw Dissonance Curves" */
@@ -22,21 +31,26 @@ export const SETHARES_DISSONANCE_PARAMS = {
   x_star: 0.24,
 };
 
+export type SetharesDissonanceParams = Partial<
+  typeof SETHARES_DISSONANCE_PARAMS
+>;
+
 /** The formula to calculate sensory dissoannce proposed by Sethares in the appendix "How to Draw Dissonance Curves" */
 export function getPlompLeveltDissonance(
-  freq1: number,
-  freq2: number,
-  loudness1: number,
-  loudness2: number,
+  partial1: SpectrumPartial,
+  partial2: SpectrumPartial,
   params = SETHARES_DISSONANCE_PARAMS
 ): number {
-  if (freq1 === freq2) return 0;
+  if (partial1.rate === partial2.rate) return 0;
 
-  const minLoudness = Math.min(loudness1, loudness2);
+  const minLoudness = Math.min(
+    getLoudness(partial1.amplitude),
+    getLoudness(partial2.amplitude)
+  );
   if (minLoudness <= 0) return 0;
 
-  const minFrequency = Math.min(freq1, freq2);
-  const frequencyDifference = Math.abs(freq1 - freq2);
+  const minFrequency = Math.min(partial1.rate, partial2.rate);
+  const frequencyDifference = Math.abs(partial1.rate - partial2.rate);
 
   if (minFrequency <= 0) return 0;
 
@@ -50,8 +64,8 @@ export function getPlompLeveltDissonance(
 }
 
 export function getIntrinsicDissonance(
-  spectrum: Spectrum,
-  params = SETHARES_DISSONANCE_PARAMS
+  spectrum: SpectrumPartial[],
+  params?: SetharesDissonanceParams
 ) {
   let dissonance = 0;
 
@@ -60,13 +74,10 @@ export function getIntrinsicDissonance(
       const partial1 = spectrum[i]!;
       const partial2 = spectrum[j]!;
 
-      dissonance += getPlompLeveltDissonance(
-        partial1.freq,
-        partial2.freq,
-        partial1.loudness,
-        partial2.loudness,
-        params
-      );
+      dissonance += getPlompLeveltDissonance(partial1, partial2, {
+        ...SETHARES_DISSONANCE_PARAMS,
+        ...params,
+      });
     }
   }
 
@@ -74,26 +85,23 @@ export function getIntrinsicDissonance(
 }
 
 export function getSetharesDissonance(
-  spectrum1: Spectrum,
-  spectrum2: Spectrum,
-  params = SETHARES_DISSONANCE_PARAMS
+  spectrum1: SpectrumPartial[],
+  spectrum2: SpectrumPartial[],
+  params?: SetharesDissonanceParams
 ) {
   let dissonance =
     getIntrinsicDissonance(spectrum1, params) +
     getIntrinsicDissonance(spectrum2, params);
 
   for (let i = 0; i < spectrum1.length; i++) {
-    for (let j = i + 1; j < spectrum2.length; j++) {
+    for (let j = 0; j < spectrum2.length; j++) {
       const partial1 = spectrum1[i]!;
       const partial2 = spectrum2[j]!;
 
-      dissonance += getPlompLeveltDissonance(
-        partial1.freq,
-        partial2.freq,
-        partial1.loudness,
-        partial2.loudness,
-        params
-      );
+      dissonance += getPlompLeveltDissonance(partial1, partial2, {
+        ...SETHARES_DISSONANCE_PARAMS,
+        ...params,
+      });
     }
   }
 
@@ -105,16 +113,16 @@ export function ratioToCents(ratio: number): number {
 }
 
 export function centsToRatio(cents: number): number {
-  return 2 ** (cents / 1200);
+  return Math.pow(2, cents / 1200);
 }
 
-export function transpose(spectrum: Spectrum, cents: number) {
-  const result: Spectrum = [];
+export function transpose(partials: SpectrumPartial[], cents: number) {
+  const result: SpectrumPartial[] = [];
 
-  for (const partial of spectrum) {
+  for (const partial of partials) {
     result.push({
-      freq: partial.freq * centsToRatio(cents),
-      loudness: partial.loudness,
+      rate: partial.rate * centsToRatio(cents),
+      amplitude: partial.amplitude,
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sethares-dissonance",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "module": "index.ts",
   "type": "module",
   "devDependencies": {

package/tests/utils.test.ts

@@ -0,0 +1,12 @@
+import { expect, test, describe } from "bun:test";
+
+import * as Utils from "../lib/utils";
+
+describe("lib/utils", () => {
+  test("Should calculate loudness", () => {
+    const amplitudes = [1, 0.001, 0.000025];
+    const expectedOutcome = [64, 1, 0];
+
+    expect(amplitudes.map(Utils.getLoudness)).toEqual(expectedOutcome);
+  });
+});