cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/libraries/platform.lib

@@ -0,0 +1,59 @@
+//#################################### platform.lib ########################################
+// A library to handle platform specific code in Faust. Its official prefix is `pl`.
+//
+// #### References
+// * <https://github.com/grame-cncm/faustlibraries/blob/master/platform.lib>
+//########################################################################################
+// It can be reimplemented to globally change the SR and the tablesize definitions
+
+
+/************************************************************************
+************************************************************************
+FAUST library file
+Copyright (C) 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.
+************************************************************************
+************************************************************************/
+
+declare name "Generic Platform Library";
+declare version "1.3.0";
+
+//---------------------------------`(pl.)SR`-----------------------------------
+// Current sampling rate (between 1 and 192000Hz). Constant during
+// program execution.
+//-----------------------------------------------------------------------------
+SR = min(192000.0, max(1.0, fconstant(int fSamplingFreq, <math.h>)));
+
+//---------------------------------`(pl.)BS`---------------------------------------
+// Current block-size (between 1 and 16384 frames). Can change during the execution.
+//-----------------------------------------------------------------------------
+BS = min(16384.0, max(1.0, fvariable(int count, <math.h>)));
+
+//---------------------------------`(pl.)tablesize`----------------------------
+// Oscillator table size
+//-----------------------------------------------------------------------------
+tablesize = 1 << 16;

cyfaust/resources/libraries/quantizers.lib

@@ -0,0 +1,310 @@
+//##################################### quantizers.lib ########################################
+// Faust Frequency Quantization Library. Its official prefix is `qu`.
+//
+// #### References
+// * <https://github.com/grame-cncm/faustlibraries/blob/master/quantizers.lib>
+//########################################################################################
+
+ba = library("basics.lib");
+it = library("interpolators.lib");
+
+declare name "Faust Frequency Quantization Library";
+declare version "1.1.0";
+
+//=============================Functions Reference========================================
+//========================================================================================
+
+/************************************************************************
+************************************************************************
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>
+************************************************************************
+************************************************************************/
+
+MinFreq = 10;
+MaxFreq = 20000;
+TableSize = 1024;
+
+qLog(x) = ba.tabulate(1,log(_),TableSize,MinFreq,MaxFreq,x).cub;
+qSmooth(x) = ba.tabulate(1,0.5*atan(_*20-10)/1.4711+0.5,TableSize,0,1,x).cub;
+
+
+//-------`(qu.)quantize`----------
+// Configurable frequency quantization tool. Output only the frequencies that are part of the specified scale.
+// Works for positive audio frequencies.
+//
+// #### Usage
+//
+// ```
+// _ : quantize(rf,nl) : _
+// ```
+// Where :
+//
+// * `rf` : frequency of the root note of the scale
+// * `nl` : list of the ratio of the frequencies of each note in relation to the root frequency
+//------------------------
+quantize(rf,nl) = _<: octave,_ <: _,!,noteRatio(nN) : rf*_*_
+with{
+    octave = (qLog(_)-log(rf))/log(2)<:
+        (_<0)*(1/(1<<(-1*(_-1)):int))+
+        (_>=0)*(1<<(_:int));
+    nN = ba.count(nl);
+    noteRatio(1,oct) = 1;
+    noteRatio(n,oct) = _ <: (ba.take(n,nl)<=((_/oct)/rf))*ba.take(n,nl)+
+                            (ba.take(n,nl)>((_/oct)/rf))*(noteRatio(n-1,oct));
+};
+
+
+//-------`(qu.)quantizeSmoothed`----------
+// Configurable frequency quantization tool. Output frequencies that are closer to the frequencies of the specified scale notes.
+// Works for positive audio frequencies.
+//
+//
+// #### Usage
+//
+// ```
+// _ : quantizeSmoothed(rf,nl) : _
+// nl = (1,1.2,1.4,1.7);
+// ```
+// Where :
+//
+// * `rf` : frequency of the root note of the scale
+// * `nl` : list of the ratio of the frequencies of each note in relation to the root frequency
+//------------------------
+quantizeSmoothed(rf,nl) = _<: octave,_ <: _,!,noteRatio(nN) : rf*_*_
+with{
+    octave = (qLog(_)-log(rf))/log(2)<:
+        (_<0)*(1/(1<<(-1*(_-1)):int))+
+        (_>0)*(1<<(_:int))+
+		(_==0)*2;
+    nN = ba.count(nl);
+    noteRatio(1,oct) = findValue(1,oct);
+    noteRatio(n,oct) = _ <: (ba.take(n,nl)<=((_/oct)/rf))*findValue(n,oct)+
+                            (ba.take(n,nl)>((_/oct)/rf))*(noteRatio(n-1,oct));
+
+    findValue(n,oct) = _<: (n<nN)*
+            (((_/oct)/rf)-ba.take(n,nl))/((ba.take(min(n+1,nN)-(n==nN),nl)-ba.take(n,nl)))
+                    +(n==nN)*
+            (((_/oct)/rf)-ba.take(n,nl))/(2-ba.take(n,nl)):       
+            qSmooth :  //smoothing curve
+            _*((n<nN)*(ba.take(min(n+1,nN)-(n==nN),nl)-ba.take(n,nl))+
+                (n==nN)*(2-ba.take(n,nl))
+            )+ba.take(n,nl);
+};
+
+
+//---------------------`(qu.)ionian`--------------------------
+// List of the frequency ratios of the notes of the ionian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,ionian) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+ionian = (1,pow(2,2/12),pow(2,4/12),pow(2,5/12),pow(2,7/12),pow(2,9/12),pow(2,11/12));
+
+
+//---------------------`(qu.)dorian`--------------------------
+// List of the frequency ratios of the notes of the dorian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,dorian) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+dorian = (1,pow(2,2/12),pow(2,3/12),pow(2,5/12),pow(2,7/12),pow(2,9/12),pow(2,10/12));
+
+
+//---------------------`(qu.)phrygian`--------------------------
+// List of the frequency ratios of the notes of the phrygian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,phrygian) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+phrygian = (1,pow(2,1/12),pow(2,3/12),pow(2,5/12),pow(2,7/12),pow(2,8/12),pow(2,10/12));
+
+
+//---------------------`(qu.)lydian`--------------------------
+// List of the frequency ratios of the notes of the lydian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,lydian) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+lydian = (1,pow(2,2/12),pow(2,4/12),pow(2,6/12),pow(2,7/12),pow(2,9/12),pow(2,11/12));
+
+
+//---------------------`(qu.)mixo`--------------------------
+// List of the frequency ratios of the notes of the mixolydian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,mixo) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+mixo = (1,pow(2,2/12),pow(2,4/12),pow(2,5/12),pow(2,7/12),pow(2,9/12),pow(2,10/12));
+
+
+//---------------------`(qu.)eolian`--------------------------
+// List of the frequency ratios of the notes of the eolian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,eolian) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+eolian = (1,pow(2,2/12),pow(2,3/12),pow(2,5/12),pow(2,7/12),pow(2,8/12),pow(2,10/12));
+
+
+//---------------------`(qu.)locrian`--------------------------
+// List of the frequency ratios of the notes of the locrian mode.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,locrian) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+locrian = (1,pow(2,1/12),pow(2,3/12),pow(2,5/12),pow(2,6/12),pow(2,8/12),pow(2,10/12));
+
+
+//---------------------`(qu.)pentanat`--------------------------
+// List of the frequency ratios of the notes of the pythagorean tuning for the minor pentatonic scale.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,pentanat) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+pentanat = (1,32/27,4/3,3/2,16/9);
+
+
+//---------------------`(qu.)kumoi`--------------------------
+// List of the frequency ratios of the notes of the kumoijoshi, the japanese pentatonic scale.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,kumoi) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+kumoi = (1,16/15,4/3,3/2,8/5);
+
+
+//---------------------`(qu.)natural`--------------------------
+// List of the frequency ratios of the notes of the natural major scale.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,natural) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+natural = (1,9/8,5/4,4/3,3/2,5/3,15/8);
+
+
+//---------------------`(qu.)dodeca`--------------------------
+// List of the frequency ratios of the notes of the dodecaphonic scale.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,dodeca) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+dodeca = (1,pow(2,1/12),pow(2,2/12),pow(2,3/12),pow(2,4/12),pow(2,5/12),pow(2,6/12),pow(2,7/12),pow(2,8/12),pow(2,9/12),pow(2,10/12),pow(2,11/12));
+
+
+//---------------------`(qu.)dimin`--------------------------
+// List of the frequency ratios of the notes of the diminished scale.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,dimin) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+dimin = (1,pow(2,1/12),pow(2,3/12),pow(2,4/12),pow(2,6/12),pow(2,7/12),pow(2,9/12),pow(2,10/12));
+
+
+//---------------------`(qu.)penta`--------------------------
+// List of the frequency ratios of the notes of the minor pentatonic scale.
+//
+// #### Usage
+// ```
+// _ : quantize(rf,penta) : _
+// ```
+//
+// Where:
+//
+// * `rf`: frequency of the root note of the scale
+//-------------------------------------------------------------
+penta = (1,pow(2,3/12),pow(2,5/12),pow(2,7/12),pow(2,10/12));

cyfaust/resources/libraries/reducemaps.lib

@@ -0,0 +1,235 @@
+//############################# reducemaps.lib ###############################
+// A library providing reduce/map operations in Faust. Its official prefix is
+// `rm`. The basic idea behind _reduce_ operations is to combine several values
+// into a single one by repeatedly applying a binary operation. A typical
+// example is finding the maximum of a set of values by repeatedly applying the
+// binary operation `max`.
+//
+// In this reducemaps library, you'll find two types of _reduce_, depending on
+// whether you want to reduce n consecutive samples of the same signal or a set
+// of n parallel signals.
+//
+// #### References
+// * <https://github.com/grame-cncm/faustlibraries/blob/master/reducemaps.lib>
+//#############################################################################
+
+/************************************************************************
+************************************************************************
+FAUST library file
+Copyright (C) 2023 Yann Orlarey
+Copyright (C) 2010-2023 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");
+
+declare name "Reduce Library";
+declare author "Yann Orlarey";
+declare copyright "Grame and Yann Orlarey";
+declare version "1.2.0";
+declare license "LGPL with exception"; 
+
+
+
+//----------------------------`(rm.)parReduce`--------------------------------
+// `parReduce(op,N)` combines a set of `N` parallel signals into a single one
+// using a binary operation `op`.
+//
+// With `parReduce`, this reduction process simultaneously occurs on each half
+// of the incoming signals. In other words, `parReduce(max,256)` is equivalent
+// to `parReduce(max,128),parReduce(max,128) : max`.
+//
+// To be used with `parReduce`, binary operation `op` must be associative.
+// Additionally, the concept of a binary operation extends to operations
+// that have `2*n` inputs and `n` outputs. For example, complex signals can be
+// simulated using two signals for the real and imaginary parts. In
+// such case, a binary operation would have 4 inputs and 2 outputs.
+//
+// Please note also that `parReduce` is faster than `topReduce` or `botReduce`
+// for large number of signals. It is therefore the recommended operation
+// whenever `op` is associative.
+//
+// #### Usage
+//
+// ```
+// _,...,_ : parReduce(op, N) : _
+// ```
+//
+// Where:
+//
+// * `op`: is a binary operation 
+// * `N`: is the number of incomming signals (`N>0`). We use a capital letter
+// here to indicate that the number of incomming signals must be constant and
+// known at compile time.
+//-----------------------------------------------------------------------------
+
+parReduce(op,1) = par(i,outputs(op),_);
+parReduce(op,2) = op;
+parReduce(op,N) = parReduce(op,int(N/2)), parReduce(op,N-int(N/2)) : op;
+
+
+
+
+//----------------------------`(rm.)topReduce`--------------------------------
+// `topReduce(op,N)` involves combining a set of `N` parallel signals into a
+// single one using a binary operation `op`. With `topReduce`, the reduction
+// process starts from the top two incoming signals, down to the bottom. In
+// other words, `topReduce(max,256)` is equivalent to `topReduce(max,255),_ : max`.
+//
+// Contrary to `parReduce`, the binary operation `op` doesn't have to be
+// associative here. Like with `parReduce` the concept of a binary operation can be
+// extended to operations that have 2*n inputs and n outputs. For example,
+// complex signals can be simulated using two signals representing the real and
+// imaginary parts. In such cases, a binary operation would have 4 inputs and 2
+// outputs.
+//
+// #### Usage
+//
+// ```
+//  _,...,_ : topReduce(op, N) : _
+// ```
+//
+// Where:
+//
+// * `op`: is a binary operation
+// * `N`: is the number of incomming signals (`N>0`). We use a capital letter
+// here to indicate that the number of incomming signals must be constant and
+// known at compile time.
+//-----------------------------------------------------------------------------
+
+topReduce(op,1) = par(i,outputs(op),_);
+topReduce(op,2) = op;
+topReduce(op,N) = topReduce(op,N-1), par(i,outputs(op),_) : op;
+
+
+
+//----------------------------`(rm.)botReduce`--------------------------------
+// `botReduce(op,N)` combines a set of `N` parallel signals into a single one
+// using a binary operation `op`. With `botReduce`, the reduction process starts
+// from the bottom two incoming signals, up to the top. In other words,
+// `botReduce(max,256)` is equivalent to `_,botReduce(max,255): max`.
+//
+// Contrary to `parReduce`, the binary operation `op` doesn't have to be
+// associative here. Like with `parReduce` the concept of a binary operation can be
+// extended to operations that have 2*n inputs and n outputs. For example,
+// complex signals can be simulated using two signals representing the real and
+// imaginary parts. In such cases, a binary operation would have 4 inputs and 2
+// outputs.
+//
+// #### Usage
+//
+// ```
+//  _,...,_ : botReduce(op, N) : _
+// ```
+//
+// Where:
+//
+// * op: is a binary operation
+// * N: is the number of incomming signals (`N>0`). We use a capital letter
+// here to indicate that the number of incomming signals must be constant and
+// known at compile time.
+//-----------------------------------------------------------------------------
+
+botReduce(op,1) = par(i,outputs(op),_);
+botReduce(op,2) = op;
+botReduce(op,n) = par(i,outputs(op),_), botReduce(op,n-1) : op;
+
+
+//--------------------------------`(rm.)reduce`--------------------------------
+// Reduce a block of `n` consecutive samples of the incomming signal using a
+// binary operation `op`. For example: `reduce(max,128)` will compute the
+// maximun value of each block of 128 samples. Please note that the resulting
+// value, while computed continuously, will be constant for the duration of a
+// block. A new value is only produced at the end of a block. Note also that
+// blocks should be of at least one sample (n>0).
+//
+// #### Usage
+//
+// ```
+// _ : reduce(op, n) : _
+// ```
+//
+// Where:
+//
+// * `op`: is a binary operation
+// * `n`: is the number of consecutive samples in a block. 
+//-----------------------------------------------------------------------------
+
+reduce(op, n, x) = compute ~ (_,_,_) : (!,!,_)
+    with {
+        compute(acc, count, val) =
+            ba.if(count<n, op(acc,x), x), // new acc
+            ba.if(count<n, count+1, 1),   // new count
+            ba.if(count<n, val, acc);     // new val
+    };
+
+
+//--------------------`(rm.)reducemap`---------------------------
+// Like `reduce` but a `foo` function is applied to the result. From
+// a mathematical point of view:
+// `reducemap(op,foo,n)` is equivalent to `reduce(op,n):foo`
+// but more efficient.
+//
+// #### Usage
+//
+// ```
+// _ : reducemap(op, foo, n) : _
+// ```
+//
+// Where:
+//
+// * `op`: is a binary operation
+// * `foo`: is a function applied to the result of the reduction
+// * `n`: is the number of consecutive samples in a block. 
+//-----------------------------------------------------------------------------
+
+reducemap(op, foo, n, x) = compute ~ (_,_,_) : (!,!,_)
+    with {
+        compute(acc, count, val) =
+            ba.if(count<n, op(acc,x), x),   // new acc
+            ba.if(count<n, count+1, 1),     // new count
+            ba.if(count<n, val, foo(acc));  // new val
+    };
+
+// Some examples using `reduce`and `reducemap`
+//
+// the sum of the amplitudes of the input signal
+sumn(n) = reduce(+,n);
+
+// the maximum amplitude of the input signal
+maxn(n) = reduce(max,n);
+
+// the minimum amplitude of the input signal
+minn(n) = reduce(min,n);
+
+// the average amplitude of the input signal
+mean(n) = reducemap(+, /(n), n);
+
+// RMS
+RMS(n) = float : ^(2) : reducemap(+, (/(n):sqrt), n);
+