Raise version numbers, regenerate.

basics.lib

@@ -58,7 +58,7 @@ it = library("interpolators.lib");
 si = library("signals.lib");
 
 declare name "Faust Basic Element Library";
-declare version "1.19.1";
+declare version "1.20.0";
 
 //=============================Conversion Tools===========================================
 //========================================================================================

docs/index.html

@@ -384,5 +384,5 @@ <h4 class="modal-title" id="keyboardModalLabel">Keyboard Shortcuts</h4>
 
 <!--
 MkDocs version : 1.5.3
-Build Date UTC : 2024-11-09 17:02:15.250632+00:00
+Build Date UTC : 2024-11-12 18:35:48.466269+00:00
 -->

docs/libs/basics/index.html

@@ -457,6 +457,10 @@
               <ul class="nav flex-column">
               </ul>
             </li>
+            <li class="nav-item" data-level="3"><a href="#batandh" class="nav-link">(ba.)tAndH</a>
+              <ul class="nav flex-column">
+              </ul>
+            </li>
             <li class="nav-item" data-level="3"><a href="#badownsample" class="nav-link">(ba.)downSample</a>
               <ul class="nav flex-column">
               </ul>
@@ -1540,11 +1544,21 @@ <h4 id="usage_52">Usage</h4>
 <li><code>trig</code>: hold trigger (0 for hold, 1 for bypass)</li>
 </ul>
 <hr />
+<h3 id="batandh"><code>(ba.)tAndH</code></h3>
+<p>Test And Hold: "records" the input when pred(input) is true, outputs a frozen value otherwise.</p>
+<h4 id="usage_53">Usage</h4>
+<pre><code>_ : tAndH(pred) : _
+</code></pre>
+<p>Where:</p>
+<ul>
+<li><code>pred</code>: predicate to test the input</li>
+</ul>
+<hr />
 <h3 id="badownsample"><code>(ba.)downSample</code></h3>
 <p>Down sample a signal. WARNING: this function doesn't change the
 rate of a signal, it just holds samples...
 <code>downSample</code> is a standard Faust function.</p>
-<h4 id="usage_53">Usage</h4>
+<h4 id="usage_54">Usage</h4>
 <pre><code>_ : downSample(freq) : _
 </code></pre>
 <p>Where:</p>
@@ -1557,7 +1571,7 @@ <h3 id="badownsamplecv"><code>(ba.)downSampleCV</code></h3>
 been replaced by an <code>amount</code> parameter that is in the range zero
 to one. WARNING: this function doesn't change the rate of a
 signal, it just holds samples...</p>
-<h4 id="usage_54">Usage</h4>
+<h4 id="usage_55">Usage</h4>
 <pre><code>_ : downSampleCV(amount) : _
 </code></pre>
 <p>Where:</p>
@@ -1567,7 +1581,7 @@ <h4 id="usage_54">Usage</h4>
 <hr />
 <h3 id="bapeakhold"><code>(ba.)peakhold</code></h3>
 <p>Outputs current max value above zero.</p>
-<h4 id="usage_55">Usage</h4>
+<h4 id="usage_56">Usage</h4>
 <pre><code>_ : peakhold(mode) : _
 </code></pre>
 <p>Where:</p>
@@ -1584,7 +1598,7 @@ <h3 id="bapeakholder"><code>(ba.)peakholder</code></h3>
 and sent to the output; otherwise, a timer starts and the current peak
 is held for N samples; once the timer is out and no new peaks have been
 detected, the absolute value of the current input becomes the new peak.</p>
-<h4 id="usage_56">Usage</h4>
+<h4 id="usage_57">Usage</h4>
 <pre><code>_ : peakholder(holdTime) : _
 </code></pre>
 <p>Where:</p>
@@ -1594,7 +1608,7 @@ <h4 id="usage_56">Usage</h4>
 <hr />
 <h3 id="bakr2ar"><code>(ba.)kr2ar</code></h3>
 <p>Force a control rate signal to be used as an audio rate signal.</p>
-<h4 id="usage_57">Usage</h4>
+<h4 id="usage_58">Usage</h4>
 <pre><code>hslider(&quot;freq&quot;, 200, 200, 2000, 0.1) : kr2ar;
 </code></pre>
 <hr />
@@ -1603,13 +1617,13 @@ <h3 id="baimpulsify"><code>(ba.)impulsify</code></h3>
 (0.3,0.2,0.1 becomes 0.3,0.0,0.0). This function is typically used with a
 <code>button</code> to turn its output into an impulse. <code>impulsify</code> is a standard Faust
 function.</p>
-<h4 id="usage_58">Usage</h4>
+<h4 id="usage_59">Usage</h4>
 <pre><code>button(&quot;gate&quot;) : impulsify;
 </code></pre>
 <hr />
 <h3 id="baautomat"><code>(ba.)automat</code></h3>
 <p>Record and replay in a loop the successives values of the input signal.</p>
-<h4 id="usage_59">Usage</h4>
+<h4 id="usage_60">Usage</h4>
 <pre><code>hslider(...) : automat(t, size, init) : _
 </code></pre>
 <p>Where:</p>
@@ -1673,7 +1687,7 @@ <h3 id="babpf"><code>(ba.)bpf</code></h3>
 <hr />
 <h3 id="balistinterp"><code>(ba.)listInterp</code></h3>
 <p>Linearly interpolates between the elements of a list.</p>
-<h4 id="usage_60">Usage</h4>
+<h4 id="usage_61">Usage</h4>
 <pre><code>index = 1.69; // range is 0-4
 process = listInterp((800,400,350,450,325),index);
 </code></pre>
@@ -1687,7 +1701,7 @@ <h3 id="babypass1"><code>(ba.)bypass1</code></h3>
 <p>Takes a mono input signal, route it to <code>e</code> and bypass it if <code>bpc = 1</code>.
 When bypassed, <code>e</code> is feed with zeros so that its state is cleanup up.
 <code>bypass1</code> is a standard Faust function.</p>
-<h4 id="usage_61">Usage</h4>
+<h4 id="usage_62">Usage</h4>
 <pre><code>_ : bypass1(bpc,e) : _
 </code></pre>
 <p>Where:</p>
@@ -1700,7 +1714,7 @@ <h3 id="babypass2"><code>(ba.)bypass2</code></h3>
 <p>Takes a stereo input signal, route it to <code>e</code> and bypass it if <code>bpc = 1</code>.
 When bypassed, <code>e</code> is feed with zeros so that its state is cleanup up.
 <code>bypass2</code> is a standard Faust function.</p>
-<h4 id="usage_62">Usage</h4>
+<h4 id="usage_63">Usage</h4>
 <pre><code>_,_ : bypass2(bpc,e) : _,_
 </code></pre>
 <p>Where:</p>
@@ -1714,7 +1728,7 @@ <h3 id="babypass1to2"><code>(ba.)bypass1to2</code></h3>
 Effect <code>e</code> is bypassed if <code>bpc = 1</code>.When bypassed, <code>e</code> is feed with zeros
 so that its state is cleanup up.
 <code>bypass1to2</code> is a standard Faust function.</p>
-<h4 id="usage_63">Usage</h4>
+<h4 id="usage_64">Usage</h4>
 <pre><code>_ : bypass1to2(bpc,e) : _,_
 </code></pre>
 <p>Where:</p>
@@ -1729,7 +1743,7 @@ <h3 id="babypass_fade"><code>(ba.)bypass_fade</code></h3>
 so that 'e' state is cleanup up.
 Once bypassed the effect is replaced by <code>par(i,N,_)</code>.
 Bypassed circuits can be chained.</p>
-<h4 id="usage_64">Usage</h4>
+<h4 id="usage_65">Usage</h4>
 <pre><code>_ : bypass_fade(n,b,e) : _
 or
 _,_ : bypass_fade(n,b,e) : _,_
@@ -1747,7 +1761,7 @@ <h4 id="example-test-program_8">Example test program</h4>
 <h3 id="batoggle"><code>(ba.)toggle</code></h3>
 <p>Triggered by the change of 0 to 1, it toggles the output value
 between 0 and 1.</p>
-<h4 id="usage_65">Usage</h4>
+<h4 id="usage_66">Usage</h4>
 <pre><code>_ : toggle : _
 </code></pre>
 <h4 id="example-test-program_9">Example test program</h4>
@@ -1757,7 +1771,7 @@ <h4 id="example-test-program_9">Example test program</h4>
 <hr />
 <h3 id="baon_and_off"><code>(ba.)on_and_off</code></h3>
 <p>The first channel set the output to 1, the second channel to 0.</p>
-<h4 id="usage_66">Usage</h4>
+<h4 id="usage_67">Usage</h4>
 <pre><code>_,_ : on_and_off : _
 </code></pre>
 <h4 id="example-test-program_10">Example test program</h4>
@@ -1766,7 +1780,7 @@ <h4 id="example-test-program_10">Example test program</h4>
 <hr />
 <h3 id="babitcrusher"><code>(ba.)bitcrusher</code></h3>
 <p>Produce distortion by reduction of the signal resolution.</p>
-<h4 id="usage_67">Usage</h4>
+<h4 id="usage_68">Usage</h4>
 <pre><code>_ : bitcrusher(nbits) : _
 </code></pre>
 <p>Where:</p>
@@ -1908,7 +1922,7 @@ <h3 id="baslidingreduce"><code>(ba.)slidingReduce</code></h3>
 <code>slidingReduce(max,128,128,0-(ma.MAX))</code> will compute the maximum of the last
 128 samples. The output is updated each sample, unlike reduce, where the
 output is constant for the duration of a block.</p>
-<h4 id="usage_68">Usage</h4>
+<h4 id="usage_69">Usage</h4>
 <pre><code>_ : slidingReduce(op,n,maxN,disabledVal) : _
 </code></pre>
 <p>Where:</p>
@@ -1927,7 +1941,7 @@ <h3 id="baslidingsum"><code>(ba.)slidingSum</code></h3>
 <p>The sliding sum of the last n input samples.</p>
 <p>It will eventually run into numerical trouble when there is a persistent dc component.
 If that matters in your application, use the more CPU-intensive <code>ba.slidingSump</code>.</p>
-<h4 id="usage_69">Usage</h4>
+<h4 id="usage_70">Usage</h4>
 <pre><code>_ : slidingSum(n) : _
 </code></pre>
 <p>Where:</p>
@@ -1938,7 +1952,7 @@ <h4 id="usage_69">Usage</h4>
 <h3 id="baslidingsump"><code>(ba.)slidingSump</code></h3>
 <p>The sliding sum of the last n input samples.</p>
 <p>It uses a lot more CPU than <code>ba.slidingSum</code>, but is numerically stable "forever" in return.</p>
-<h4 id="usage_70">Usage</h4>
+<h4 id="usage_71">Usage</h4>
 <pre><code>_ : slidingSump(n,maxN) : _
 </code></pre>
 <p>Where:</p>
@@ -1949,7 +1963,7 @@ <h4 id="usage_70">Usage</h4>
 <hr />
 <h3 id="baslidingmax"><code>(ba.)slidingMax</code></h3>
 <p>The sliding maximum of the last n input samples.</p>
-<h4 id="usage_71">Usage</h4>
+<h4 id="usage_72">Usage</h4>
 <pre><code>_ : slidingMax(n,maxN) : _
 </code></pre>
 <p>Where:</p>
@@ -1960,7 +1974,7 @@ <h4 id="usage_71">Usage</h4>
 <hr />
 <h3 id="baslidingmin"><code>(ba.)slidingMin</code></h3>
 <p>The sliding minimum of the last n input samples.</p>
-<h4 id="usage_72">Usage</h4>
+<h4 id="usage_73">Usage</h4>
 <pre><code>_ : slidingMin(n,maxN) : _
 </code></pre>
 <p>Where:</p>
@@ -1973,7 +1987,7 @@ <h3 id="baslidingmean"><code>(ba.)slidingMean</code></h3>
 <p>The sliding mean of the last n input samples.</p>
 <p>It will eventually run into numerical trouble when there is a persistent dc component.
 If that matters in your application, use the more CPU-intensive <code>ba.slidingMeanp</code>.</p>
-<h4 id="usage_73">Usage</h4>
+<h4 id="usage_74">Usage</h4>
 <pre><code>_ : slidingMean(n) : _
 </code></pre>
 <p>Where:</p>
@@ -1984,7 +1998,7 @@ <h4 id="usage_73">Usage</h4>
 <h3 id="baslidingmeanp"><code>(ba.)slidingMeanp</code></h3>
 <p>The sliding mean of the last n input samples.</p>
 <p>It uses a lot more CPU than <code>ba.slidingMean</code>, but is numerically stable "forever" in return.</p>
-<h4 id="usage_74">Usage</h4>
+<h4 id="usage_75">Usage</h4>
 <pre><code>_ : slidingMeanp(n,maxN) : _
 </code></pre>
 <p>Where:</p>
@@ -1997,7 +2011,7 @@ <h3 id="baslidingrms"><code>(ba.)slidingRMS</code></h3>
 <p>The root mean square of the last n input samples.</p>
 <p>It will eventually run into numerical trouble when there is a persistent dc component.
 If that matters in your application, use the more CPU-intensive <code>ba.slidingRMSp</code>.</p>
-<h4 id="usage_75">Usage</h4>
+<h4 id="usage_76">Usage</h4>
 <pre><code>_ : slidingRMS(n) : _
 </code></pre>
 <p>Where:</p>
@@ -2008,7 +2022,7 @@ <h4 id="usage_75">Usage</h4>
 <h3 id="baslidingrmsp"><code>(ba.)slidingRMSp</code></h3>
 <p>The root mean square of the last n input samples.</p>
 <p>It uses a lot more CPU than <code>ba.slidingRMS</code>, but is numerically stable "forever" in return.</p>
-<h4 id="usage_76">Usage</h4>
+<h4 id="usage_77">Usage</h4>
 <pre><code>_ : slidingRMSp(n,maxN) : _
 </code></pre>
 <p>Where:</p>
@@ -2028,7 +2042,7 @@ <h2 id="parallel-operators">Parallel Operators</h2>
 <hr />
 <h3 id="baparallelop"><code>(ba.)parallelOp</code></h3>
 <p>Apply a commutative binary operation <code>op</code> to N parallel inputs.</p>
-<h4 id="usage_77">usage</h4>
+<h4 id="usage_78">usage</h4>
 <pre><code>si.bus(N) : parallelOp(op,N) : _
 </code></pre>
 <p>where:</p>
@@ -2039,7 +2053,7 @@ <h4 id="usage_77">usage</h4>
 <hr />
 <h3 id="baparallelmax"><code>(ba.)parallelMax</code></h3>
 <p>The maximum of N parallel inputs.</p>
-<h4 id="usage_78">Usage</h4>
+<h4 id="usage_79">Usage</h4>
 <pre><code>si.bus(N) : parallelMax(N) : _
 </code></pre>
 <p>Where:</p>
@@ -2049,7 +2063,7 @@ <h4 id="usage_78">Usage</h4>
 <hr />
 <h3 id="baparallelmin"><code>(ba.)parallelMin</code></h3>
 <p>The minimum of N parallel inputs.</p>
-<h4 id="usage_79">Usage</h4>
+<h4 id="usage_80">Usage</h4>
 <pre><code>si.bus(N) : parallelMin(N) : _
 </code></pre>
 <p>Where:</p>
@@ -2059,7 +2073,7 @@ <h4 id="usage_79">Usage</h4>
 <hr />
 <h3 id="baparallelmean"><code>(ba.)parallelMean</code></h3>
 <p>The mean of N parallel inputs.</p>
-<h4 id="usage_80">Usage</h4>
+<h4 id="usage_81">Usage</h4>
 <pre><code>si.bus(N) : parallelMean(N) : _
 </code></pre>
 <p>Where:</p>
@@ -2069,7 +2083,7 @@ <h4 id="usage_80">Usage</h4>
 <hr />
 <h3 id="baparallelrms"><code>(ba.)parallelRMS</code></h3>
 <p>The RMS of N parallel inputs.</p>
-<h4 id="usage_81">Usage</h4>
+<h4 id="usage_82">Usage</h4>
 <pre><code>si.bus(N) : parallelRMS(N) : _
 </code></pre>
 <p>Where:</p>

docs/libs/index.html

@@ -480,6 +480,7 @@ <h2 id="basics">basics</h2>
 <a href="basics/#baselectoutn">(ba.)selectoutn</a> &nbsp; &nbsp;
 <a href="basics/#balatch">(ba.)latch</a> &nbsp; &nbsp;
 <a href="basics/#basandh">(ba.)sAndH</a> &nbsp; &nbsp;
+<a href="basics/#batandh">(ba.)tAndH</a> &nbsp; &nbsp;
 <a href="basics/#badownsample">(ba.)downSample</a> &nbsp; &nbsp;
 <a href="basics/#badownsamplecv">(ba.)downSampleCV</a> &nbsp; &nbsp;
 <a href="basics/#bapeakhold">(ba.)peakhold</a> &nbsp; &nbsp;

maths.lib

@@ -55,7 +55,7 @@ pl = library("platform.lib");
 ma = library("maths.lib"); // for compatible copy/paste out of this file
 
 declare name "Faust Math Library";
-declare version "2.8.0";
+declare version "2.8.1";
 declare author "GRAME";
 declare copyright "GRAME";
 declare license "LGPL with exception";

version.lib

@@ -16,7 +16,7 @@
 //
 //------------------------------------------------------------
 version =   2,  // MAJOR version when we make incompatible API changes,
-            41, // MINOR version when we add functionality in a backwards compatible manner,
+            42, // MINOR version when we add functionality in a backwards compatible manner,
             0;  // PATCH version when we make backwards compatible bug fixes.