DR error measures

This is a technical or mathematical page. While the subject may be of some relevance to music, the page treats the subject in technical language.

This article will describe several least-squares error measures for delta-rational chords. They have the advantage of not fixing a particular interval in the chord when constructing the chord of best fit. However, like any other numerical measure of concordance or error, you should take them with a grain of salt.

Conventions and introduction

The idea motivating least-squares error measures on a chord as an approximation to a given delta signature is the following (for simplicity, let’s talk about the fully DR case first):

We want the error of a chord 1:r₁:r₂:...:r_n (in increasing order), with n > 1, in the linear domain as an approximation to a fully delta-rational chord with signature +δ₁ +δ₂ ... +δ_n, i.e. a chord

$x:x+{\delta }_1:\cdots :x+\sum _{l=1}^n{\delta }_l$

with root real-valued harmonic x. Let $D_0=0,D_i=\sum _{k=1}^i{\delta }_k$ be the delta signature +δ₁ +δ₂ ... +δ_n written cumulatively.

We want to measure the error without having to fix any dyad (as one might naively fix a dyad and measure errors in the other deltas). To do this we solve a least-squares error problem: use a root-sum-square error function and optimize x to minimize that function.

Domain and error model

We have two choices:

• to measure either the linear (frequency ratio) error or the logarithmic (cents) one (called the domain);
• the collection of intervals to sum over (which we call the error model):
  • Rooted: Only intervals from the root real-valued harmonic x are chosen.
  • Pairwise: All intervals in the chord are compared.
  • All-steps: Only intervals between adjacent notes are compared.

The method to solve the problem will also differ depending on the numbers of variables involved (only one variable x for fully delta-rational).

We arrive at the following general formula: Let $[n]=\{0,1,2,\mathrm{...},n\},$ let $I\subseteq (\genfrac{}{}{0ex}{}{[n]}{2})$ be the error model, and let $f_D$ represent the domain function (identity or $\log$). Then the error function to be minimized by optimizing $x$ and any free deltas is:

$\sum _{i<j,\{i,j\}\in I}\left(f_D\right(\frac{x+D_j}{x+D_i})-f_D(\frac{r_j}{r_i}){)}^2.$

Error function for various modes and error models

Domain	Error model	Error function
Linear	Rooted	$\sqrt{\sum _{i=1}^n(\frac{x+D_i}{x}-r_i{)}^2}=\sqrt{\sum _{i=1}^n(1+\frac{D_i}{x}-r_i{)}^2}$
	Pairwise	$\sqrt{\sum _{0\le i<j\le n}(\frac{x+D_j}{x+D_i}-\frac{r_j}{r_i}{)}^2}$
	All-steps	$\sqrt{\sum _{0\le i<n}(\frac{x+D_{i+1}}{x+D_i}-\frac{r_{i+1}}{r_i}{)}^2}$
Logarithmic (nepers)	Rooted	$\sqrt{\sum _{i=1}^n(\log \frac{x+D_i}{r_{i}x}{)}^2}$
	Pairwise	$\sqrt{\sum _{0\le i<j\le n}(\log \frac{x+D_j}{x+D_i}-\log \frac{r_j}{r_i}{)}^2}$
	All-steps	$\sqrt{\sum _{0\le i<n}(\log \frac{x+D_{i+1}}{x+D_i}-\log \frac{r_{i+1}}{r_i}{)}^2}$

To convert nepers to cents, multiply by $\frac{1200}{\log 2}.$

Solution methods

Analytic (FDR case)

Rooted linear

Setting the derivative to 0 gives us the closed-form solution

$x=\frac{\sum _{i=1}^n{D}_i}{-n+\sum _{i=1}^n{r}_i},$

which can be plugged back into

$\sqrt{\sum _{1=1}^n(1+\frac{D_i}{x}-r_i{)}^2}$

to obtain the least-squares linear error.

Partially DR (one related delta set, one free variable)

Suppose we wish to approximate a target delta signature of the form $+{\delta }_1+?+{\delta }_3$ with the chord $1:r_1:r_2:r_3$ (where the +? is free to vary). By a derivation similar to the above, the least-squares problem is

$\underset{x,y}{\text{minimize}}\sqrt{(\frac{x+{\delta }_1}{x}-r_1{)}^2+(\frac{x+{\delta }_1+y}{x}-r_2{)}^2+(\frac{x+{\delta }_1+y+{\delta }_3}{x}-r_3{)}^2},$

where y represents the free delta +?.

We can set the partial derivatives with respect to x and y of the inner expression equal to zero (since the derivative of sqrt() is never 0) and use SymPy to solve the system:

<syntaxhighlight lang="py"> import sympy x = sympy.Symbol("x", real=True) y = sympy.Symbol("y", real=True) d1 = sympy.Symbol("\\delta_{1}", real=True) d2 = sympy.Symbol("\\delta_{2}", real=True) d3 = sympy.Symbol("\\delta_{3}", real=True) r1 = sympy.Symbol("r_1", real=True) r2 = sympy.Symbol("r_2", real=True) r3 = sympy.Symbol("r_3", real=True) err_squared = ((x + d1) / x - r1) ** 2 + ((x + d1 + y) / x - r2) ** 2 + ((x + d1 + y + d3) / x - r3) ** 2 err_squared.expand() err_squared_x = sympy.diff(err_squared, x) err_squared_y = sympy.diff(err_squared, y) sympy.nonlinsolve([err_squared_x, err_squared_y], [x, y]) </syntaxhighlight>

The unique solution with x > 0 is

$x=\frac{2{\delta }_1+{\delta }_3+2y}{r_2+r_3-2},$

$y=\frac{-2{\delta }_1^2{r}_1+{\delta }_1^2{r}_2+{\delta }_1^2{r}_3-{\delta }_1{\delta }_3{r}_1+{\delta }_1{\delta }_3{r}_2-{\delta }_1{\delta }_3{r}_3+{\delta }_1{\delta }_3+{\delta }_3^2{r}_2-{\delta }_3^2}{2{\delta }_1{r}_1-2{\delta }_1-{\delta }_3{r}_2+{\delta }_3{r}_3}.$

Partially DR (one related delta set, arbitrary free deltas)

We similarly include a free variable y_i to be optimized for every additional +?, after coalescing strings of consecutive +?'s into segments and after trimming leading and trailing free delta segments.

The L-BFGS-B (limited-memory Broyden-Fletcher-Goldfarb-Shanno with box constraints) algorithm is a bounded quasi-Newton method particularly well-suited for this problem:

• Naturally handles the constraint x > 0 via logarithmic barrier penalties, converting the constrained problem to unconstrained
• The sum-of-squared-errors objective function is smooth and differentiable, ideal for gradient-based optimization

The gradient-based approach allows L-BFGS-B to converge in typically 15-20 iterations versus 200-400 for derivative-free methods, making it the preferred choice for PDR optimization.

Performance comparison

Method	Iterations	Notes
L-BFGS-B	14-20	Fastest convergence, lowest errors
Nelder-Mead	200-400	Derivative-free, slower but robust
Powell	150-250	Conjugate directions, moderate speed

Implementation details:

• Variables: [x, y₁, y₂, ..., y_k] where k = number of interior free segments
• Bounds: x ∈ (10^-6, ∞), y_i ∈ (-∞, ∞)
• Normalization: Scales deltas to keep x ≈ 5 for numerical stability
• Multiple starting points: Tries 4-5 random initializations and returns best result
• Barrier weight: 10^-10 (very small to minimize interference with true objective)

External links

• Inthar's DR chord explorer (includes least-squares error calculation in both domains and multiple error models)