sethares-dissonance 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NewTonality
+
+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/README.md

@@ -0,0 +1,15 @@
+# sethares-dissonance
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.15. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/classes/DissonanceCurve.ts

@@ -0,0 +1,83 @@
+import { getSetharesDissonance, transpose, type Spectrum } from "../lib/utils";
+
+type DissonanceCurveOptions = {
+  context: Spectrum;
+  compliment: Spectrum;
+  precision?: 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 context: DissonanceCurveOptions["context"];
+  public readonly compliment: DissonanceCurveOptions["compliment"];
+  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;
+
+    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);
+
+    for (let cent = this.rangeMin; cent <= this.rangeMax; cent += this.step) {
+      const dissonance = getSetharesDissonance(
+        this.context,
+        transpose(this.compliment, cent)
+      );
+
+      if (dissonance > this.maxDissonance) this.maxDissonance = dissonance;
+
+      this._data.set(cent, dissonance);
+    }
+  }
+
+  public get points() {
+    return Array.from(this._data.entries()).sort((a, b) => a[0] - b[0]);
+  }
+
+  private getRowString(row: Array<number | string>) {
+    if (row.length === 0) return "";
+
+    let result = `${row[0]}`;
+
+    for (let i = 1; i < row.length; i += 1) {
+      result += `\t${row[i]}`;
+    }
+
+    return result;
+  }
+
+  public toFileString() {
+    if (this._data.size === 0) return "";
+
+    const headerRow = this.getRowString([
+      "Interval (cents)",
+      "Sensory dissonance",
+    ]);
+
+    let result = headerRow + "\n";
+
+    for (const point of this.points) {
+      result += this.getRowString(point);
+    }
+
+    return result;
+  }
+}

package/classes/index.ts

@@ -0,0 +1 @@
+export * from "./DissonanceCurve"

package/index.ts

@@ -0,0 +1,2 @@
+export * from "./classes"
+export * from "./lib"

package/lib/index.ts

@@ -0,0 +1 @@
+export * from "./utils"

package/lib/utils.ts

@@ -0,0 +1,122 @@
+export type Spectrum = {
+  freq: number;
+  loudness: number;
+}[];
+
+/** 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;
+
+  const SPL = 20 * Math.log10(P_e / P_ref);
+
+  return 2 ** (SPL / 10) / 16;
+}
+
+/** Fitting parameters proposed by Sethares in the appendix "How to Draw Dissonance Curves" */
+export const SETHARES_DISSONANCE_PARAMS = {
+  s1: 0.021,
+  s2: 19,
+  b1: 3.5,
+  b2: 5.75,
+  x_star: 0.24,
+};
+
+/** 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,
+  params = SETHARES_DISSONANCE_PARAMS
+): number {
+  if (freq1 === freq2) return 0;
+
+  const minLoudness = Math.min(loudness1, loudness2);
+  if (minLoudness <= 0) return 0;
+
+  const minFrequency = Math.min(freq1, freq2);
+  const frequencyDifference = Math.abs(freq1 - freq2);
+
+  if (minFrequency <= 0) return 0;
+
+  const s = params.x_star / (params.s1 * minFrequency + params.s2);
+
+  return (
+    minLoudness *
+    (Math.exp(-1 * params.b1 * s * frequencyDifference) -
+      Math.exp(-1 * params.b2 * s * frequencyDifference))
+  );
+}
+
+export function getIntrinsicDissonance(
+  spectrum: Spectrum,
+  params = SETHARES_DISSONANCE_PARAMS
+) {
+  let dissonance = 0;
+
+  for (let i = 0; i < spectrum.length; i++) {
+    for (let j = i + 1; j < spectrum.length; j++) {
+      const partial1 = spectrum[i]!;
+      const partial2 = spectrum[j]!;
+
+      dissonance += getPlompLeveltDissonance(
+        partial1.freq,
+        partial2.freq,
+        partial1.loudness,
+        partial2.loudness,
+        params
+      );
+    }
+  }
+
+  return dissonance;
+}
+
+export function getSetharesDissonance(
+  spectrum1: Spectrum,
+  spectrum2: Spectrum,
+  params = SETHARES_DISSONANCE_PARAMS
+) {
+  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++) {
+      const partial1 = spectrum1[i]!;
+      const partial2 = spectrum2[j]!;
+
+      dissonance += getPlompLeveltDissonance(
+        partial1.freq,
+        partial2.freq,
+        partial1.loudness,
+        partial2.loudness,
+        params
+      );
+    }
+  }
+
+  return dissonance;
+}
+
+export function ratioToCents(ratio: number): number {
+  return ratio > 0 ? 1200 * Math.log2(ratio) : 0;
+}
+
+export function centsToRatio(cents: number): number {
+  return 2 ** (cents / 1200);
+}
+
+export function transpose(spectrum: Spectrum, cents: number) {
+  const result: Spectrum = [];
+
+  for (const partial of spectrum) {
+    result.push({
+      freq: partial.freq * centsToRatio(cents),
+      loudness: partial.loudness,
+    });
+  }
+
+  return result;
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "sethares-dissonance",
+  "version": "0.0.1",
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}