cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/libraries/interpolators.lib

@@ -0,0 +1,675 @@
+//#################################### interpolators.lib ########################################
+// A library to handle interpolation. Its official prefix is `it`.
+//
+// This library provides several basic interpolation functions, as well as interpolators 
+// taking a `gen` circuit of N outputs producing values to be interpolated, triggered
+// by a `idv` read index signal. Two points and four points interpolations are implemented.
+//
+// The `idv` parameter is to be used as a read index. In `-single` (= singleprecision) mode, 
+// a technique based on 2 signals with the pure integer index and a fractional part in the [0,1] 
+// range is used to avoid accumulating errors. In `-double` (= doubleprecision) or `-quad` (= quadprecision) modes, 
+// a standard implementation with a single fractional index signal is used. Three functions `int_part`, `frac_part` and `mak_idv` are available to manipulate the read index signal.
+//
+// Here is a use-case with `waveform`. Here the signal given to `interpolator_XXX` uses the `idv` model.
+// 
+// ```
+// waveform_interpolator(wf, step, interp) = interp(gen, idv)
+// with {
+//    gen(idx) = wf, (idx:max(0):min(size-1)) : rdtable with { size = wf:(_,!); };   /* waveform size */
+//    index = (+(step)~_)-step;  /* starting from 0 */
+//    idv = it.make_idv(index);  /* build the signal for interpolation in a generic way */
+// };
+// 
+// waveform_linear(wf, step) = waveform_interpolator(wf, step, it.interpolator_linear);
+// waveform_cosine(wf, step) = waveform_interpolator(wf, step, it.interpolator_cosine);
+// waveform_cubic(wf, step) = waveform_interpolator(wf, step, it.interpolator_cubic);
+// 
+// waveform_interp(wf, step, selector) = waveform_interpolator(wf, step, interp_select(selector))
+// with {
+//    /* adapts the argument order */
+//    interp_select(sel, gen, idv) = it.interpolator_select(gen, idv, sel);
+// };
+// 
+// waveform and index 
+// waveform_interpolator1(wf, idv, interp) = interp(gen, idv)
+// with {
+//    gen(idx) = wf, (idx:max(0):min(size-1)) : rdtable with { size = wf:(_,!); };   /* waveform size */
+// };
+// 
+// waveform_linear1(wf, idv) = waveform_interpolator1(wf, idv, it.interpolator_linear);
+// waveform_cosine1(wf, idv) = waveform_interpolator1(wf, idv, it.interpolator_cosine);
+// waveform_cubic1(wf, idv) = waveform_interpolator1(wf, idv, it.interpolator_cubic);
+// 
+// waveform_interp1(wf, idv, selector) = waveform_interpolator1(wf, idv, interp_select(selector))
+// with {
+//    /* adapts the argument order */
+//    interp_select(sel, gen, idv) = it.interpolator_select(gen, idv, sel);
+// };
+// ```
+// 
+// Some tests here:
+// 
+// ```
+// wf = waveform {0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 50.0, 40.0, 30.0, 20.0, 10.0, 0.0};
+// 
+// process = waveform_linear(wf, step), waveform_cosine(wf, step), waveform_cubic(wf, step) with { step = 0.25; };
+// 
+// process = waveform_interp(wf, 0.25, nentry("algo", 0, 0, 3, 1));
+// 
+// process = waveform_interp1(wf, idv, nentry("algo", 0, 0, 3, 1))
+// with {
+//    step = 0.1;
+//    idv_aux = (+(step)~_)-step;  /* starting from 0 */
+//    idv = it.make_idv(idv_aux);  /* build the signal for interpolation in a generic way */
+// };
+// 
+// /* Test linear interpolation between 2 samples with a `(idx,dv)` signal built using a waveform */
+// linear_test = (idx,dv), it.interpolator_linear(gen, (idx,dv))
+// with {
+//    /* signal to interpolate (only 2 points here) */
+//    gen(id) = waveform {3.0, -1.0}, (id:max(0)) : rdtable;
+//    dv = waveform {0.0, 0.25, 0.50, 0.75, 1.0}, index : rdtable;
+//    idx = 0; 
+//    /* test index signal */
+//    index = (+(1)~_)-1;   /* starting from 0 */
+// };
+// 
+// /* Test cosine interpolation between 2 samples with a `(idx,dv)` signal built using a waveform */
+// cosine_test = (idx,dv), it.interpolator_cosine(gen, (idx,dv))
+// with {
+//    /* signal to interpolate (only 2 points here) */
+//    gen(id) = waveform {3.0, -1.0}, (id:max(0)) : rdtable;
+//    dv = waveform {0.0, 0.25, 0.50, 0.75, 1.0}, index : rdtable;
+//    idx = 0;
+//    /* test index signal */
+//    index = (+(1)~_)-1;   /* starting from 0 */
+// };
+// 
+// /* Test cubic interpolation between 4 samples with a `(idx,dv)` signal built using a waveform */
+// cubic_test = (idx,dv), it.interpolator_cubic(gen, (idx,dv))
+// with {
+//    /* signal to interpolate (only 4 points here) */
+//    gen(id) = waveform {-1.0, 2.0, 1.0, 4.0}, (id:max(0)) : rdtable;
+//    dv = waveform {0.0, 0.25, 0.50, 0.75, 1.0}, index : rdtable;
+//    idx = 0;
+//    /* test index signal */
+//    index = (+(1)~_)-1;   /* starting from 0 */
+// };
+// ```
+//
+// #### References
+// * <https://github.com/grame-cncm/faustlibraries/blob/master/interpolators.lib>
+//########################################################################################
+
+/************************************************************************
+************************************************************************
+FAUST library file
+Copyright (C) 2019-2020 GRAME, Centre National de Creation Musicale
+----------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation; either version 2.1 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with the GNU C Library; if not, write to the Free
+Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+EXCEPTION TO THE LGPL LICENSE : As a special exception, you may create a
+larger FAUST program which directly or indirectly imports this library
+file and still distribute the compiled code generated by the FAUST
+compiler, or a modified version of this compiled code, under your own
+copyright and license. This EXCEPTION TO THE LGPL LICENSE explicitly
+grants you the right to freely choose the license for the resulting
+compiled code. In particular the resulting compiled code has no obligation
+to be LGPL or GPL. For example you are free to choose a commercial or
+closed source license or any other license if you decide so.
+************************************************************************
+************************************************************************/
+
+ba = library("basics.lib");
+ro = library("routes.lib");
+ma = library("maths.lib");
+si = library("signals.lib");
+
+declare name "Faust Interpolator Library";
+declare version "1.3.0";
+
+reset(trig) = (trig-trig') <= 0;
+ 
+// The following 3 functions allow to adapt a 'single signal' fractional idv in this [idx, dv] model.
+
+singleprecision int_part(idv) = idv : _,!;
+singleprecision frac_part(idv) = idv : !,_;
+singleprecision make_idv(id) = int(id), ma.frac(id);
+
+// Infinite raising index
+singleprecision raise(trig, step, length) = id, dv
+letrec {
+    'id = (id + int(step) + int(dv + ma.frac(step))) * reset(trig);
+    'dv = ma.frac(dv + ma.frac(step)) * reset(trig);
+};
+
+// Modulo based raising index
+singleprecision raise_modulo(trig, step, length) = id, dv
+letrec {
+    'id = fmod(id + int(step) + int(dv + ma.frac(step)), length) * reset(trig);
+    'dv = ma.frac(dv + ma.frac(step)) * reset(trig);
+};
+
+// Decreasing index starting at 'length'
+singleprecision decrease(trig, step, length) = raise(trig, -step, length) : (+(length), _);
+
+// Modulo decreasing index starting at 'length'
+singleprecision decrease_modulo(trig, step, length) = raise_modulo(trig, -step, length) : (+(length), _);
+
+// The following 3 functions allow to adapt a 'single signal' fractional idv in this [idx, dv] model.
+
+doubleprecision quadprecision int_part(idv) = int(idv);
+doubleprecision quadprecision frac_part(idv) = ma.frac(idv);
+doubleprecision quadprecision make_idv(id) = id;
+
+// Infinite raising index
+doubleprecision quadprecision raise(trig, step, length) = idv
+letrec {
+    'idv = (idv + step) * reset(trig);
+};
+
+// Modulo based raising index
+doubleprecision quadprecision raise_modulo(trig, step, length) = idv
+letrec {
+    'idv = fmod(idv + step, length) * reset(trig);
+};
+
+// Decreasing index starting at 'length'
+doubleprecision quadprecision decrease(trig, step, length) = raise(trig, -step, length) + length;
+
+// Modulo decreasing index starting at 'length'
+doubleprecision quadprecision decrease_modulo(trig, step, length) = raise_modulo(trig, -step, length) + length;
+ 
+//=========================Two points interpolation functions=============================
+//========================================================================================
+
+//-------`(it.)interpolate_linear`----------
+// Linear interpolation between 2 values.
+//
+// #### Usage
+//
+// ```
+// interpolate_linear(dv,v0,v1) : _
+// ```
+//
+// Where:
+//
+// * `dv`: in the fractional value in [0..1] range
+// * `v0`: is the first value
+// * `v1`: is the second value
+//
+//
+// #### Reference:
+//
+// <https://github.com/jamoma/JamomaCore/blob/master/Foundation/library/includes/TTInterpolate.h>
+//
+//--------------------------------------------
+declare interpolate_linear author "Stéphane Letz";
+declare interpolate_linear licence "MIT";
+
+interpolate_linear(dv,v0,v1) = v0 + dv*(v1-v0);  // (faster than v0*(1-dv)+v1*dv which is currently not optimized...)
+
+
+//-------`(it.)interpolate_cosine`----------
+// Cosine interpolation between 2 values.
+//
+// #### Usage
+//
+// ```
+// interpolate_cosine(dv,v0,v1) : _
+// ```
+//
+// Where:
+//
+// * `dv`: in the fractional value in [0..1] range
+// * `v0`: is the first value
+// * `v1`: is the second value
+//
+//
+// #### Reference:
+//
+// <https://github.com/jamoma/JamomaCore/blob/master/Foundation/library/includes/TTInterpolate.h>
+//
+//--------------------------------------------
+declare interpolate_cosine author "Stéphane Letz";
+declare interpolate_cosine licence "MIT";
+
+interpolate_cosine(dv,v0,v1) = v0 + a2*(v1-v0) with { a2 = 0.5 * (1.0 - cos(dv*ma.PI)); };
+
+
+//=========================Four points interpolation functions============================
+//========================================================================================
+
+//-------`(it.)interpolate_cubic`----------
+// Cubic interpolation between 4 values.
+//
+// #### Usage
+//
+// ```
+// interpolate_cubic(dv,v0,v1,v2,v3) : _
+// ```
+//
+// Where:
+//
+// * `dv`: in the fractional value in [0..1] range
+// * `v0`: is the first value
+// * `v1`: is the second value
+// * `v2`: is the third value
+// * `v3`: is the fourth value
+//
+//
+// #### Reference:
+//
+// <https://www.paulinternet.nl/?page=bicubic>
+//
+//--------------------------------------------
+declare interpolate_cubic author "Stéphane Letz";
+declare interpolate_cubic licence "MIT";
+
+interpolate_cubic(dv,v0,v1,v2,v3) 
+	= v1 + 0.5*dv*(v2 - v0 + dv*(2.0*v0 - 5.0*v1 + 4.0*v2 - v3 + dv*(3.0*(v1 - v2) + v3 - v0)));
+
+
+//=========================Two points interpolators=======================================
+//========================================================================================
+
+//-------`(it.)interpolator_two_points`----------
+// Generic interpolator on two points (current and next index), assuming an increasing index.
+//
+// #### Usage
+//
+// ```
+// interpolator_two_points(gen, idv, interpolate_two_points) : si.bus(outputs(gen))
+// ```
+//
+// Where:
+//
+// * `gen`: a circuit with an 'idv' reader input that produces N outputs
+// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair
+// * `interpolate_two_points`: a two points interpolation function
+//
+//--------------------------------------------
+declare interpolator_two_points author "Stéphane Letz";
+declare interpolator_two_points licence "MIT";
+
+interpolator_two_points(gen, idv, interpolate_two_points) = (gen(id0), gen(id1))
+                                                            : ro.interleave(outputs(gen), 2)
+                                                            : par(i, outputs(gen), interpolate_two_points(dv))
+with {
+    id0 = int_part(idv); // index integer part
+    id1 = id0 + 1;       // next index
+    dv = frac_part(idv); // index fractional part in [0..1]
+};
+
+
+//-------`(it.)interpolator_linear`----------
+// Linear interpolator for a 'gen' circuit triggered by an 'idv' input to generate values.
+//
+// #### Usage
+//
+// ```
+// interpolator_linear(gen, idv) : si.bus(outputs(gen))
+// ```
+//
+// Where:
+//
+// * `gen`: a circuit with an 'idv' reader input that produces N outputs
+// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair
+//
+//--------------------------------------------
+declare interpolator_linear author "Stéphane Letz";
+declare interpolator_linear licence "MIT";
+
+interpolator_linear(gen, idv) = interpolator_two_points(gen, idv, interpolate_linear);
+
+
+//-------`(it.)interpolator_cosine`----------
+// Cosine interpolator for a 'gen' circuit triggered by an 'idv' input to generate values.
+//
+// #### Usage
+//
+// ```
+// interpolator_cosine(gen, idv) : si.bus(outputs(gen))
+// ```
+//
+// Where:
+//
+// * `gen`: a circuit with an 'idv' reader input that produces N outputs
+// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair
+//
+//--------------------------------------------
+declare interpolator_cosine author "Stéphane Letz";
+declare interpolator_cosine licence "MIT";
+
+interpolator_cosine(gen, idv) = interpolator_two_points(gen, idv, interpolate_cosine);
+
+
+// To be used in 'interpolator_select'
+interpolator_null(gen, idv) = interpolator_two_points(gen, idv, \(dv,v0,v1).(v0));
+
+
+//=========================Four points interpolators======================================
+//========================================================================================
+
+//-------`(it.)interpolator_four_points`----------
+// Generic interpolator on interpolator_four_points points (previous, current and two next indexes), assuming an increasing index.
+//
+// #### Usage
+//
+// ```
+// interpolator_four_points(gen, idv, interpolate_four_points) : si.bus(outputs(gen))
+// ```
+//
+// Where:
+//
+// * `gen`: a circuit with an 'idv' reader input that produces N outputs
+// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair
+// * `interpolate_four_points`: a four points interpolation function
+//
+//--------------------------------------------
+declare interpolator_four_points author "Stéphane Letz";
+declare interpolator_four_points licence "MIT";
+
+interpolator_four_points(gen, idv, interpolate_four_points) = (gen(id0), gen(id1), gen(id2), gen(id3))
+                                                            : ro.interleave(outputs(gen), 4)
+                                                            : par(i, outputs(gen), interpolate_four_points(dv))
+with {
+    id0 = id1 - 1;       // previous index
+    id1 = int_part(idv); // index integer part
+    id2 = id1 + 1;       // next index
+    id3 = id2 + 1;       // next index
+    dv = frac_part(idv); // index fractional part in [0..1]
+};
+
+
+//-------`(it.)interpolator_cubic`----------
+// Cubic interpolator for a 'gen' circuit triggered by an 'idv' input to generate values
+//
+// #### Usage
+//
+// ```
+// interpolator_cubic(gen, idv) : si.bus(outputs(gen))
+// ```
+//
+// Where:
+//
+// * `gen`: a circuit with an 'idv' reader input that produces N outputs
+// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair
+//
+//--------------------------------------------
+declare interpolator_cubic author "Stéphane Letz";
+declare interpolator_cubic licence "MIT";
+
+interpolator_cubic(gen, idv) = interpolator_four_points(gen, idv, interpolate_cubic);
+
+// Enum of interpolation algorithms
+MAX_INTER = 4;
+
+linear = 0;
+cosine = 1;
+cubic  = 2;
+nointerp = MAX_INTER-1;
+
+
+//-------`(it.)interpolator_select`----------
+// Generic configurable interpolator (with selector between in [0..3]). The value 3 is used for no interpolation.
+//
+// #### Usage
+//
+// ```
+// interpolator_select(gen, idv, sel) : _,_... (equal to N = outputs(gen))
+// ```
+//
+// Where:
+//
+// * `gen`: a circuit with an 'idv' reader input that produces N outputs
+// * `idv`: a fractional read index expressed as a float value, or a (int,frac) pair
+// * `sel`: an interpolation algorithm selector in [0..3] (0 = linear, 1 = cosine, 2 = cubic, 3 = nointerp)
+//
+//--------------------------------------------
+declare interpolator_select author "Stéphane Letz";
+declare interpolator_select licence "MIT";
+
+interpolator_select(gen, idv, sel) = ba.selectmulti(ma.SR/10, interpolators, sel)
+with {
+	interpolators = (interpolator_linear(gen, idv),
+                    interpolator_cosine(gen, idv),
+                    interpolator_cubic(gen, idv),
+                    interpolator_null(gen, idv));
+};
+
+//=========================Lagrange based interpolators====================================
+//========================================================================================
+
+//-------`(it.)lagrangeCoeffs(N, xCoordsList)` ---------------------------------------------
+//
+// This is a function to generate N + 1 coefficients for an Nth-order Lagrange
+// basis polynomial with arbitrary spacing of the points.
+//
+// #### Usage
+//
+// ```
+// lagrangeCoeffs(N, xCoordsList, x) : si.bus(N + 1)
+// ```
+//
+// Where:
+//
+// * `N`: order of the interpolation filter, known at compile-time
+// * `xCoordsList`: a list of N + 1 elements determining the x-axis coordinates of N + 1 values, known at compile-time
+// * `x`: a fractional position on the x-axis to obtain the interpolated y-value
+//
+// #### Reference
+//
+// <https://ccrma.stanford.edu/~jos/pasp/Lagrange_Interpolation.html>
+// <https://en.wikipedia.org/wiki/Lagrange_polynomial>
+//------------------------------------------------------------
+
+declare lagrangeCoeffs author "Dario Sanfilippo";
+declare lagrangeCoeffs copyright "Copyright (C) 2021 Dario Sanfilippo
+    <sanfilippo.dario@gmail.com>";
+declare lagrangeCoeffs license "MIT license";
+lagrangeCoeffs(N, xCoords, x) = par(n, N + 1, prod(k, N + 1, f(n, k)))
+    with {
+        xVals(i) = ba.take(i + 1, xCoords);
+        f(n, k) = ((x - xVals(k)) * (n != k) + (n == k)) / 
+                  ((xVals(n) - xVals(k)) + (n == k));
+    };
+// The following definition for uniformely-spaced points interpolation is kept for back-compatibility
+lagrange_h(N, x) = lagrangeCoeffs(N, xCoord, x)
+    with {
+        xCoord = par(i, N + 1, i);
+    };
+
+//-------`(it.)lagrangeInterpolation(N, xCoordsList)` --------------------------------------
+//
+// Nth-order Lagrange interpolator to interpolate between a set of arbitrarily spaced N + 1 points.
+//
+// #### Usage
+//
+// ```
+// x , yCoords : lagrangeInterpolation(N, xCoordsList) : _
+// ```
+//
+// Where:
+//
+// * `N`: order of the interpolator, known at compile-time
+// * `xCoordsList`: a list of N + 1 elements determining the x-axis spacing of the points, known at compile-time
+// * `x`: an x-axis position to interpolate between the y-values
+// * `yCoords`: N + 1 elements determining the values of the interpolation points
+//
+// Example: find the centre position of a four-point set using an order-3
+// Lagrange function fitting the equally-spaced points [2, 5, -1, 3]:
+//
+// ```
+// N = 3;
+// xCoordsList = (0, 1, 2, 3);
+// x = N / 2.0;
+// yCoords = 2, 5, -1, 3;
+// process = x, yCoords : lagrangeInterpolation(N, xCoordsList);
+// ```
+//
+// which outputs ~1.938.
+//
+// Example: output the dashed curve showed on the Wikipedia page (top figure, https://en.wikipedia.org/wiki/Lagrange_polynomial):
+//
+// ```
+// N = 3;
+// xCoordsList = (-9, -4, -1, 7);
+// x = os.phasor(16, 1) - 9;
+// yCoords = 5, 2, -2, 9;
+// process = x, yCoords : lagrangeInterpolation(N, xCoordsList);
+// ```
+//
+// #### Reference
+// 
+// <https://ccrma.stanford.edu/~jos/pasp/Lagrange_Interpolation.html>
+// Sanfilippo and Parker 2021, "Combining zeroth and first‐order analysis with Lagrange polynomials to reduce artefacts in live concatenative granular processing." Proceedings of the DAFx conference 2021, Vienna, Austria.
+// <https://dafx2020.mdw.ac.at/proceedings/papers/DAFx20in21_paper_38.pdf>
+//------------------------------------------------------------
+
+declare lagrangeInterpolation author "Dario Sanfilippo";
+declare lagrangeInterpolation copyright "Copyright (C) 2021 Dario Sanfilippo
+    <sanfilippo.dario@gmail.com>";
+declare lagrangeInterpolation license "MIT license";
+lagrangeInterpolation(N, xCoords, x) = si.dot(N + 1, lagrangeCoeffs(N, xCoords, x));
+// The following definition for uniformely-spaced points interpolation is kept for back-compatibility
+lagrangeN(N, x) = si.dot(N + 1, lagrange_h(N, x));
+
+//-------`(it.)frdtable(N, S)` --------------------------------------------
+//
+// Look-up circular table with Nth-order Lagrange interpolation for fractional
+// indexes. The index is wrapped-around and the table is cycles for an index
+// span of size S, which is the table size in samples.
+//
+// #### Usage
+//
+// ```
+// frdtable(N, S, init, idx) : _
+// ```
+//
+// Where:
+//
+// * `N`: Lagrange interpolation order, known at compile-time
+// * `S`: table size in samples, known at compile-time
+// * `init`: signal for table initialisation
+// * `idx`: fractional index wrapped-around 0 and S
+//
+// #### Example test program
+// Test the effectiveness of the 5th-order interpolation scheme by 
+// creating a table look-up oscillator using only 16 points of a sinewave; 
+// compare the result with a non-interpolated version:
+//
+// ```
+// N = 5;
+// S = 16;
+// index = os.phasor(S, 1000);
+// process = rdtable(S, os.sinwaveform(S), int(index)) ,
+//           it.frdtable(N, S, os.sinwaveform(S), index);
+// ```
+//------------------------------------------------------------
+
+declare frdtable author "Dario Sanfilippo";
+declare frdtable copyright "Copyright (C) 2021 Dario Sanfilippo
+    <sanfilippo.dario@gmail.com>";
+declare frdtable license "LGPL v3.0 license";
+frdtable(N, S, init, idx) =
+    lagrangeN(N, f_idx, par(i, N + 1, table(i_idx - int(N / 2) + i)))
+    with {
+        table(j) = rdtable(S, init, int(ma.modulo(j, S)));
+        f_idx = ma.frac(idx) + int(N / 2);
+        i_idx = int(idx);
+    };
+
+
+//-------`(it.)frwtable(N, S)` --------------------------------------------
+//
+// Look-up updatable circular table with Nth-order Lagrange interpolation for
+// fractional indexes. The index is wrapped-around and the table is circular
+// indexes ranging from 0 to S, which is the table size in samples.
+//
+// #### Usage
+//
+// ```
+// frwtable(N, S, init, w_idx, x, r_idx) : _
+// ```
+//
+// Where:
+//
+// * `N`: Lagrange interpolation order, known at compile-time
+// * `S`: table size in samples, known at compile-time
+// * `init`: constant for table initialisation, known at compile-time
+// * `w_idx`: it should be an INT between 0 and S - 1
+// * `x`: input signal written on the w_idx positions
+// * `r_idx`: fractional index wrapped-around 0 and S
+//
+// #### Example test program
+// Test the effectiveness of the 5th-order interpolation scheme by
+// creating a table look-up oscillator using only 16 points of a sinewave;
+// compare the result with a non-interpolated version:
+//
+// ```
+// N = 5;
+// S = 16;
+// rIdx = os.phasor(S, 300);
+// wIdx = ba.period(S);
+// process = rwtable(S, os.sinwaveform(S), wIdx, os.sinwaveform(S), int(rIdx)) ,
+//           frwtable(N, S, os.sinwaveform(S), wIdx, os.sinwaveform(S), rIdx);
+// ```
+//------------------------------------------------------------
+
+declare frwtable author "Dario Sanfilippo";
+declare frwtable copyright "Copyright (C) 2021 Dario Sanfilippo
+    <sanfilippo.dario@gmail.com>";
+declare frwtable license "LGPL v3.0 license";
+frwtable(N, S, init, w_idx, x, r_idx) =
+    lagrangeN(N, f_idx, par(i, N + 1, table(i_idx - int(N / 2) + i)))
+    with {
+        table(j) = rwtable(S, init, w_idx, x, int(ma.modulo(j, S)));
+        f_idx = ma.frac(r_idx) + int(N / 2);
+        i_idx = int(r_idx);
+    };
+
+
+//=========================Misc functions=================================================
+//========================================================================================
+
+//---------------`(it.)remap` ---------------------------------------------
+// Linearly map from an input domain to an output range.
+//
+// #### Usage
+//
+// ```
+// _ : remap(from1, from2, to1, to2) : _
+// ```
+//
+// Where:
+//
+// * `from1`: the domain's lower bound.
+// * `from2`: the domain's upper bound.
+// * `to1`: the range's lower bound.
+// * `to2`: the range's upper bound.
+//
+// Note that having `from1` == `from2` in the mapping will cause a division by zero that has to be taken in account.
+//
+// Example: An oscillator remapped from [-1., 1.] to [100., 1000.]
+// ```
+// os.osc(440) : it.remap(-1., 1., 100., 1000.)
+// ```
+//------------------------------------------------------------
+declare remap author "David Braun";
+
+remap(from1, from2, to1, to2, x) = to1 + (x-from1)*(to2-to1)/(from2-from1);
+