User:Arseniiv/Fitting - Revision history

Arseniiv: /* Code */ a link to a gist

2023-12-23T19:47:00Z

Code: a link to a gist

← Older revision		Revision as of 19:47, 23 December 2023
Line 28:		Line 28:

	==== Code ====		==== Code ====

			''NB. This code may later be lagging behind [https://gist.github.com/arseniiv/ab128927adc3955867c1cc1bfe6b4cd7 the version at Gist]. The version there is a self-contained module with an example like one in this article.''

	Should work in Python 3.12 and several previous versions. Install fresh <code>more_itertools</code> and <code>sympy</code>.		Should work in Python 3.12 and several previous versions. Install fresh <code>more_itertools</code> and <code>sympy</code>.

Arseniiv: /* Code */ fix code

2023-12-23T19:41:05Z

Code: fix code

← Older revision		Revision as of 19:41, 23 December 2023
Line 40:		Line 40:
	import sympy as sp		import sympy as sp

	def ~~cents~~(ratio: float \| str) -> float:		def _cents(ratio: float \| str) -> float:
	if isinstance(ratio, str):		if isinstance(ratio, str):
	ratio = float(Fraction(ratio))		ratio = float(Fraction(ratio))
Line 48:		Line 48:
	"""Make a scale of pitches in cents from intervals delimited by spaces."""		"""Make a scale of pitches in cents from intervals delimited by spaces."""

	return tuple(map(~~cents~~, intervals.split()))		return tuple(map(_cents, intervals.split()))

	def match_pattern(scale: Sequence[float], pattern: str) -> dict[str, float] \| None:		def match_pattern(scale: Sequence[float], pattern: str) -> dict[str, float] \| None:
Line 88:		Line 88:
	note_errors = [vars_[SHIFT]]		note_errors = [vars_[SHIFT]]
	sym_pitches = [sp.sympify(0)]		sym_pitches = [sp.sympify(0)]
	for letter, pitch in zip(pattern, ~~initial_scale~~):		for letter, pitch in zip(pattern, scale):
	last_pitch = sym_pitches[-1] + vars_[letter]		last_pitch = sym_pitches[-1] + vars_[letter]
	sym_pitches.append(last_pitch)		sym_pitches.append(last_pitch)
Line 96:		Line 96:
	note_errors.pop()		note_errors.pop()
	sym_pitches.pop(0)		sym_pitches.pop(0)
	assert len(note_errors) == len(~~initial_scale~~)		assert len(note_errors) == len(scale)

	error_sqr_sum = sum(error ** 2 for error in note_errors)		error_sqr_sum = sum(error ** 2 for error in note_errors)

Arseniiv: /* To a periodic scale with specific step pattern */ I meant more_itertools

2023-12-23T19:32:47Z

To a periodic scale with specific step pattern: I meant more_itertools

← Older revision		Revision as of 19:32, 23 December 2023
Line 25:		Line 25:
	If we have a pattern of steps in mind, say sLMLsLMsML, we can try fitting a scale to a scale of this form by writing an error term for each note in the period of the new scale. These terms will be integer linear combinations of our chosen step sizes <math>s, M, L</math>, an overal scale shift <math>d</math> (see [[#To edX]]) and numbers (cent values of intervals).		If we have a pattern of steps in mind, say sLMLsLMsML, we can try fitting a scale to a scale of this form by writing an error term for each note in the period of the new scale. These terms will be integer linear combinations of our chosen step sizes <math>s, M, L</math>, an overal scale shift <math>d</math> (see [[#To edX]]) and numbers (cent values of intervals).

	Having all those errors in symbolic form, it’s particularly easy to minimize RMS error constrained by all steps of the scale constituting exactly the period of the old scale, using Lagrange multiplier method. We end up with a linear system comprising of equations in step sizes, <math>d</math> and a single Lagrange multiplier related to the periodicity constraint, which is then solved to get the optimal step sizes. All these computations can be done using <code>sympy</code> Python package. In the code below I also use <code>~~itertools~~</code> to make my life a tad easier.		Having all those errors in symbolic form, it’s particularly easy to minimize RMS error constrained by all steps of the scale constituting exactly the period of the old scale, using Lagrange multiplier method. We end up with a linear system comprising of equations in step sizes, <math>d</math> and a single Lagrange multiplier related to the periodicity constraint, which is then solved to get the optimal step sizes. All these computations can be done using <code>sympy</code> Python package. In the code below I also use <code>more_itertools</code> to make my life a tad easier.

	==== Code ====		==== Code ====

	Should work in Python 3.12 and several previous versions. Install fresh <code>~~itertools~~</code> and <code>sympy</code>.		Should work in Python 3.12 and several previous versions. Install fresh <code>more_itertools</code> and <code>sympy</code>.

	<pre>		<pre>
Line 170:		Line 170:
	print('\n'.join(map(str, fit.pitches)))		print('\n'.join(map(str, fit.pitches)))
	</pre>		</pre>


	== Notes ==		== Notes ==

	<references />		<references />

Arseniiv: fitting to an arbitrary pattern of steps

2023-12-23T19:25:02Z

fitting to an arbitrary pattern of steps

Show changes

Arseniiv: oh, mod wasn’t working at all, why would I write this?..

2023-12-09T12:15:25Z

oh, mod wasn’t working at all, why would I write this?..

← Older revision		Revision as of 12:15, 9 December 2023
Line 15:		Line 15:
	A step of N-edX is <math>S := X/N</math>, so now we round <math>I_k</math> to integer multiples <math>S</math> to get their equalized variants:		A step of N-edX is <math>S := X/N</math>, so now we round <math>I_k</math> to integer multiples <math>S</math> to get their equalized variants:

	:: <math>E_k := \mathsf{round}(s I_k) / s</math><ref>if there’s no <math>\mathsf{round}(x)</math> function in your environment, it can be defined as ~~<math>(x + \frac12) \bmod 1 - \frac12</math> using floating-point remainder or~~ <math>\lfloor x + \frac12 \rfloor - \frac12</math> using floor <math>\lfloor\ldots\rfloor</math>; these agree up to cases when <math>x</math> is exactly a half-odd-integer</ref>.		:: <math>E_k := \mathsf{round}(s I_k) / s</math><ref>if there’s no <math>\mathsf{round}(x)</math> function in your environment, it can be defined as <math>\lfloor x + \frac12 \rfloor - \frac12</math> using floor <math>\lfloor\ldots\rfloor</math>; these agree up to cases when <math>x</math> is exactly a half-odd-integer</ref>.

	Then we can get errors of this approximation as <math>\Delta_k := I_k - E_k</math>. Note that always <math>-\frac S2 \le \Delta_k \le +\frac S2</math> but the largest negative error and the largest positive error might not be “balanced” and sum to zero, nor any other measure of well-fitting might be minimized: all because we fixed ourselves to necessarily fit one of the notes exactly (<math>I_0</math> being exactly zero). We can fix that by subtracting the average <math>d</math> of all <math>\Delta_k</math> that we are interested in (arithmetic mean, RMS or something else), or, in the simplest case of minimizing the largest absolute error attained, subtract <math>d := \frac12(\min_k \Delta_k + \max_k \Delta_k)</math>.		Then we can get errors of this approximation as <math>\Delta_k := I_k - E_k</math>. Note that always <math>-\frac S2 \le \Delta_k \le +\frac S2</math> but the largest negative error and the largest positive error might not be “balanced” and sum to zero, nor any other measure of well-fitting might be minimized: all because we fixed ourselves to necessarily fit one of the notes exactly (<math>I_0</math> being exactly zero). We can fix that by subtracting the average <math>d</math> of all <math>\Delta_k</math> that we are interested in (arithmetic mean, RMS or something else), or, in the simplest case of minimizing the largest absolute error attained, subtract <math>d := \frac12(\min_k \Delta_k + \max_k \Delta_k)</math>.

Arseniiv: fix a typo

2023-12-09T12:14:10Z

fix a typo

← Older revision		Revision as of 12:14, 9 December 2023
Line 15:		Line 15:
	A step of N-edX is <math>S := X/N</math>, so now we round <math>I_k</math> to integer multiples <math>S</math> to get their equalized variants:		A step of N-edX is <math>S := X/N</math>, so now we round <math>I_k</math> to integer multiples <math>S</math> to get their equalized variants:

	:: <math>E_k := \mathsf{round}(s I_k) / s</math><ref>if there’s no <math>\mathsf{round}(x)</math> function in your environment, it can be defined as <math>(x + \frac12) \bmod 1 + \frac12</math> using floating-point remainder or <math>\lfloor x + \frac12 \rfloor - \frac12</math> using floor <math>\lfloor\ldots\rfloor</math>; these agree up to cases when <math>x</math> is exactly a half-odd-integer</ref>.		:: <math>E_k := \mathsf{round}(s I_k) / s</math><ref>if there’s no <math>\mathsf{round}(x)</math> function in your environment, it can be defined as <math>(x + \frac12) \bmod 1 - \frac12</math> using floating-point remainder or <math>\lfloor x + \frac12 \rfloor - \frac12</math> using floor <math>\lfloor\ldots\rfloor</math>; these agree up to cases when <math>x</math> is exactly a half-odd-integer</ref>.

	Then we can get errors of this approximation as <math>\Delta_k := I_k - E_k</math>. Note that always <math>-\frac S2 \le \Delta_k \le +\frac S2</math> but the largest negative error and the largest positive error might not be “balanced” and sum to zero, nor any other measure of well-fitting might be minimized: all because we fixed ourselves to necessarily fit one of the notes exactly (<math>I_0</math> being exactly zero). We can fix that by subtracting the average <math>d</math> of all <math>\Delta_k</math> that we are interested in (arithmetic mean, RMS or something else), or, in the simplest case of minimizing the largest absolute error attained, subtract <math>d := \frac12(\min_k \Delta_k + \max_k \Delta_k)</math>.		Then we can get errors of this approximation as <math>\Delta_k := I_k - E_k</math>. Note that always <math>-\frac S2 \le \Delta_k \le +\frac S2</math> but the largest negative error and the largest positive error might not be “balanced” and sum to zero, nor any other measure of well-fitting might be minimized: all because we fixed ourselves to necessarily fit one of the notes exactly (<math>I_0</math> being exactly zero). We can fix that by subtracting the average <math>d</math> of all <math>\Delta_k</math> that we are interested in (arithmetic mean, RMS or something else), or, in the simplest case of minimizing the largest absolute error attained, subtract <math>d := \frac12(\min_k \Delta_k + \max_k \Delta_k)</math>.

Arseniiv: references in a better place

2023-12-09T12:12:54Z

references in a better place

← Older revision		Revision as of 12:12, 9 December 2023
Line 20:		Line 20:

	Then, <math>E_k</math> is still our true fit of <math>I_k</math> in case of our average being the last case, arithmetic mean, RMS and several other kinds of averagings because we’ll still have <math>-\frac S2 \le \Delta_k - d \le +\frac S2</math>.		Then, <math>E_k</math> is still our true fit of <math>I_k</math> in case of our average being the last case, arithmetic mean, RMS and several other kinds of averagings because we’ll still have <math>-\frac S2 \le \Delta_k - d \le +\frac S2</math>.

			== Notes ==

			<references />

Arseniiv: fitting a periodic scale to an equal division

2023-12-09T12:11:43Z

fitting a periodic scale to an equal division

New page

How to fit a scale to a scale of particular structure (say, [[equal-step tuning]], [[MOS scale]] etc.).

This is eternal work in progress.

== Any periodic scale ==

The methods here may be applicable to aperiodic scales specifiable with finite data (like “aperiodic MOS scales”<ref>for example, infinite Fibonacci words …ABABBABBABABBAB… grown from an L-system {A → B, B → BA}</ref>) but I’m not considering them yet.

=== To edX ===

We’ll consider that periods of an initial scale and an N-ed it’s matched to are the same, but they needn’t be. Let <math>X</math>, the period of both, be specified in cents or other logarithmic units, as all other intervals.

Let’s say k-steps from a given note upwards are <math>0 = I_0 < I_1 < \ldots < I_m = X</math>.

A step of N-edX is <math>S := X/N</math>, so now we round <math>I_k</math> to integer multiples <math>S</math> to get their equalized variants:

:: <math>E_k := \mathsf{round}(s I_k) / s</math><ref>if there’s no <math>\mathsf{round}(x)</math> function in your environment, it can be defined as <math>(x + \frac12) \bmod 1 + \frac12</math> using floating-point remainder or <math>\lfloor x + \frac12 \rfloor - \frac12</math> using floor <math>\lfloor\ldots\rfloor</math>; these agree up to cases when <math>x</math> is exactly a half-odd-integer</ref>.

Then we can get errors of this approximation as <math>\Delta_k := I_k - E_k</math>. Note that always <math>-\frac S2 \le \Delta_k \le +\frac S2</math> but the largest negative error and the largest positive error might not be “balanced” and sum to zero, nor any other measure of well-fitting might be minimized: all because we fixed ourselves to necessarily fit one of the notes exactly (<math>I_0</math> being exactly zero). We can fix that by subtracting the average <math>d</math> of all <math>\Delta_k</math> that we are interested in (arithmetic mean, RMS or something else), or, in the simplest case of minimizing the largest absolute error attained, subtract <math>d := \frac12(\min_k \Delta_k + \max_k \Delta_k)</math>.

Then, <math>E_k</math> is still our true fit of <math>I_k</math> in case of our average being the last case, arithmetic mean, RMS and several other kinds of averagings because we’ll still have <math>-\frac S2 \le \Delta_k - d \le +\frac S2</math>.