add files for working with samples

faust/paradigma9.dsp

@@ -1,193 +0,0 @@
-// Modulation synthesis with sparse convolution filter and distortions.
-// ---------------------------------------------------------------------
-//
-// A "3D" oscillator oscillating on x,y,z axis, with the radius of x,y used as waveform,
-// very similar and related to FM / AM.
-//
-// The y axis oscillation is set by MIDI pitch, x and z are detuned by simple just tuned ratios.
-// Feedback acts on the individual sine oscillations (giving a sawtooth like waveform).
-//
-// Three weighted copies with time varying shifts are summed in a lossy integrator
-// (sparse convolution), followed by a peak resonance filter and shaped by
-// an internal pick-up like distortion and an asymmetric polynomial.
-//
-// The convolution tabs give a (variyng) triangle impulse response if integrated twice,
-// with a -12 dB/octave rolloff and regular notches.
-// Here only one integrator is used.
-//
-// The envelope is hard wired to the oscillation amplitudes and the rise time of the filter.
-//
-// An LFO is wired to pitch.
-//
-// A resonant EQ and the Dattoro Reverb from the Faust libary are added as effect on the sum.
-//
-// Inspired by the history of sound synthesis, namely Trautonium, Mini Moog, Phase Modulation Synthesis,
-// Variophon Wind Instrument Synthesizer, Physical Modeling, and the work of Thomas D. Rossing.
-//
-// References:
-// Kot, Vítězslav. (2006). DIGITAL SOUND EFFECTS ECHO AND REVERB BASED ON NON EXPONENTIALLY DECAYING COMB FILTER.
-// https://en.wikipedia.org/wiki/Variophon
-// Parker, Julian & Zavalishin, Vadim & Le Bivic, Efflam. (2016). Reducing The Aliasing Of Nonlinear Waveshaping Using Continuous-TimeConvolution.
-// Nicholas G. Horton, Thomas R. Moore. (2008). Modelling The Magnetic Pickup Of An Electric Guitar.
-// https://www.musicdsp.org/en/latest/Effects/86-waveshaper-gloubi-boulga.html, see comment from 2005-09-22 01:07:58
-// Frei, Beat. Digital Sound Generation I & II, ICST Zurich University of the Arts
-// Smith, J.O. Physical Audio Signal Processing,http://ccrma.stanford.edu/~jos/pasp/, online book, 2010 edition
-
-declare options "[midi:on][nvoices:8]"; declare name "Paradigma_9"; declare version "1.0"; declare author "gabriel";
-import("stdfaust.lib");
-
-// Frequency Ratios table
-frtonum = waveform{1, 16, 9, 6, 5, 4, 7, 3, 8, 5, 7, 15};
-frtodiv = waveform{1, 15, 8, 5, 4, 3, 5, 2, 5, 3, 4, 8};
-
-// MIDI
-// minimum velocity
-minvelo = 1/32;
-midigrp(x) = hgroup("[1]MIDI", x);
-f = nentry("freq[hidden:1]", 200, 40, 2000, 0.1);
-kmidi = nentry("key[hidden:1]", 69, 0, 127, 1);
-bend = ba.semi2ratio(hslider("bend[hidden:1][midi:pitchwheel][style:knob]", 0, -2, 2, 0.01));
-gain = nentry("gain[hidden:1]", 0.6, 0, 1, 0.01)<:*:_*(1-minvelo):_+minvelo;
-master = hslider("volume[midi:ctrl 7]", 0.6, 0, 1, 0.01);
-gate = button("gate[hidden:0]");
-
-// Oscillator Parameter
-rtogrp(x) = hgroup("[2]Oscillator", x);
-rto1sel = rtogrp(hslider("[1]x[style:knob]", -12, -36, 36, 1));
-rto2sel = rtogrp(hslider("[2]z[style:knob]", 19, -36, 36, 1));
-fbka = rtogrp(hslider("[3]Feedback[style:knob]", 0.15, 0, 1, 0.01)<:*:*(1/ma.PI));
-detune = rtogrp(hslider("[4]Detune[style:knob]", 0.125, 0, 0.5, 0.005)/ma.SR);
-
-// LFO and Envelope Parameter
-lfogrp(x) = hgroup("[3]Envelope & LFO", x);
-enva = (lfogrp(ba.db2linear(hslider("[1]A[style:knob]", 20, 15, 66, 1))/1000));
-envd = (lfogrp(ba.db2linear(hslider("[2]D[style:knob]", 74, 26, 100, 1))/1000)*envpscal);
-envs = (lfogrp(hslider("[3]S[style:knob]", 0, 0, 1, 0.01)));
-envr = (lfogrp(ba.db2linear(hslider("[4]R[style:knob]", 50, 26, 100, 1))/1000)*envpscal);
-lfof = lfogrp(hslider("[5]LFO Hz[style:knob]", 3, 0.1, 12, 0.1));
-lfvibra = lfogrp(hslider("[6]Vibrato[style:knob]", 0.125, 0, 1, 0.01))<:*;
-env = en.adsre(enva, envd*envpscal, envs, envr*envpscal, gate);
-envg = env:_*gain;
-lfosn = qsin(mphasor(lfof/ma.SR));
-
-// Triangular Filter Parameter
-fltgrp(x) = hgroup("[4]Filter", x);
-wid = fltgrp(hslider("[1]Rise[style:knob]", 3, 1, 9, 0.001)):2^_:1/_;
-edge = fltgrp(hslider("[2]Fall[style:knob]", 6, 1, 9, 0.001)):2^_:1/_;
-fiq = fltgrp(hslider("[3]Q[style:knob]", 1, 0.5, 3.87, 0.01))<:*;
-drive = fltgrp(hslider("[4]Drive[style:knob]", -12, -12, 30, 0.1)):_/20.0:10^_;
-
-// Modulation Frequency Ratios
-rto1oct = rto1sel/12:floor;
-rto1semi = rto1sel+36:_%12;
-rto1a = frtonum, rto1semi:rdtable;
-rto1b = frtodiv, rto1semi:rdtable;
-rto1 = (rto1a/rto1b)*(2^rto1oct);
-rto1r = min((1/rto1), 1);
-rto2oct = rto2sel/12:floor;
-rto2semi = rto2sel+36:_%12;
-rto2a = frtonum, rto2semi:rdtable;
-rto2b = frtodiv, rto2semi:rdtable;
-rto2 = rto1*(rto2a/rto2b)*(2^rto2oct);
-rto2r = min((1/rto2), 1);
-
-// Pitch
-lg2f = ma.log2(f/440);
-stretch = 0.0333*lg2f;
-envpscal = (-3*lg2f):ba.db2linear;
-fplus = f*bend+lfosn*lfvibra*f*0.5/12*envg+stretch;
-w = f/ma.SR;
-w2 = rto1*w;
-w3 = rto2*w;
-wplus = fplus/ma.SR;
-fbk1 = fbka*(0.5-w)^4;
-fbk2 = fbka*(0.5-w2)^4*rto1r;
-fbk3 = fbka*(0.5-w3)^4*rto2r;
-
-// Modulation Reduction Per Frequency
-redux1 = ((3.3-((rto1+1)*w))/3.3), 0:max:_^3;
-redux2 = ((3.3-((rto2+1)*w))/3.3), 0:max:_^3;
-modep = envg;
-modep1 = envg*redux1*rto1r*gain;
-modep2 = envg*redux2*rto2r*gain;
-
-// Sine Oscillator
-wrap(n) = n-(floor(n+0.5));
-// Bhaskara I based approximate sine curve
-qsincurve(x) = 1-((x*x)<:*(1.2253517*16), (_<:*:*(-3.60562732*16)):>_);
-qsin(x) = x+(0.5):wrap<:(abs:-(0.25):qsincurve), _:ma.copysign;
-// Feedback Depth Reduction Curve
-fbcurve(x) = x:abs:-(1)<:^(3):_, (x):ma.copysign;
-
-// Oscillator
-mphasor(fw) = (+(fw)~(wrap));
-oscsn(fw, off) = mphasor(fw)+off:qsin:+~*(0.5);
-osc1(fw, off) = ((fw), +(off):(oscsn))~(*(fbk2):fi.pole(0.5):_*fbcurve(fw));
-
-// 3D to 2D radius
-oscy(fw, off) = (osc1(fw, off)*osc1(fw*rto2+2*detune, 0.75+off)*modep2)*modep;
-oscx(fw, off) = (osc1(fw*rto1+detune, 0.25+off)*osc1(fw*rto2+2*detune, 0.25+off)*modep2)*modep1;
-oscxy(fw, off) = (oscy(fw, off)<:*), (oscx(fw, off)<:*):+:sqrt;
-
-// Pick-Up like Distortion
-// distance :
-pickd = 0.25;
-pickup(x, pickd) = x, // normal for in < 1.2e-4
-(x, (x^2:_+pickd:_^(3/2)):/), // ILO:
-(pickd^(3/2)/(sqrt(x*x+1)):ma.neg:_+pickd^(3/2)):// select
-ba.if((_:abs:_<=1.2e-4), _, _):_*(pickd^(4/3));
-
-// Basic Synthvoice, modulated Oscillations
-synthvox(fw, ph2, ph3, g1, g2, g3) = (oscxy(fw, 0):_*g1), (oscxy(fw, ph2):_*g2), (oscxy(fw, ph3):_*g3):>_:fi.zero(1.0)<:_, (pickd):pickup;
-
-// Triangle
-// reduce width with frequency
-widredux = w<:+:_^3:1.0-_;
- // diff to max f in octaves, reduced for higher octaves
-dwo = (0.25/wid):max(_, 1):ma.log2:ma.inv:_*widredux:ma.inv;
-// falling edge
-egderto = edge/wid;
-wid2 = wid*(2^(dwo*(1-envg))):_*(2^(dwo*(1-gain))):min(_, 0.25):max(_, 4/(ma.SR/fplus));
-wid2e = edge:min(_, 0.25):max(_, 4/(ma.SR/fplus));
-fiw = wplus/wid2;
-fiwtail = wplus/wid2e;
-// triangle coefficients
-apg0 = fiw;
-apg1 = -apg0-fiwtail;
-apg2 = fiwtail;
-// integration freq
-igpole = 1.0-5.0/ma.SR;
-resf = (fplus/(wid2+wid2e)):min(_, (0.249*ma.SR));
-
-// Asymmetric Shaper x - 0.15x²-0.15x³
-tubicclip = _:min(_, (1.19419)):max(_, (-1.86086));
-tubicilo(x) = x, // normal for in < 1.2e-4
-(x-0.15*(x^2)-0.15*(x^3)), // ILO:
-((0.5*(x^2)-0.05*(x^3)-0.0375*(x^4)), (x<:_, _':-:_<:(abs:max(_, 1.2e-4)), (ma.signum):ma.copysign):/):// select
-ba.if((_:abs:_<=1.2e-4), _, _):fi.dcblockerat(10.0);
-
-// Sound
-process = synthvox(wplus, wid2, wid2e, apg0, apg1, apg2):fi.dcblockerat(10.0):fi.pole(igpole):fi.svf.peak(resf, fiq):_*drive:tubicclip:tubicilo:_*(1/drive);
-effect = _*master:preeq(lsf, lsgain, b1f, eqq2, eqg2, b2f, eqq3, eqg3, hsf, hsgain)<:_, _:re.dattorro_rev_default;
-
-// ---------------------------------------------------------------------------------------------------------------
-// Resonant EQ for instrument corpus, based on SVF
-eqgrp(x) = hgroup("[5]EQ", x);
-lsgain = eqgrp(hslider("[1]Low Gain[style:knob]", 3, -18, 18, 0.25));
-b1f = eqgrp(hslider("[2]Split F Low[style:knob]", -0.5, -1, 1, 0.05)):(2.0)^_:_*360;
-b1gain = eqgrp(hslider("[3]Band 1 Gain[style:knob]", 4.5, -18, 18, 0.25));
-b2f = eqgrp(hslider("[4]Split F Hi[style:knob]", -0.5, -1, 1, 0.05)):(2.0)^_:_*720;
-b2gain = eqgrp(hslider("[5]Band 2 Gain[style:knob]", 4.5, -18, 18, 0.25));
-hsgain = eqgrp(hslider("[6]Hi Gain[style:knob]", -3, -18, 18, 0.25));
-// Q and gain of middle bands are scaled simultanously, with saturation curveongain,
-// max gain is reduced from the output. Bands are spaced in octaves by default.
-lsf = b1f*0.5;
-hsf = b2f*2;
-gcurve(gain, gainrange) = abs(gain/gainrange)<:*:1-_:_+1:_*0.5;
-qscal(gain, gainrange) = 1.414*(abs(gain/gainrange)):_+1.414;
-eqq2 = qscal(b1gain, 18.0);
-eqg2 = b1gain*gcurve(b1gain, 18.0);
-eqq3 = qscal(b2gain, 18.0);
-eqg3 = b2gain*gcurve(b2gain, 18.0);
-eqredux = max(lsgain, eqg2):max(_, eqg3):max(_, hsgain):ba.db2linear:ma.inv;
-preeq(f1, g1, f2, q2, g2, f3, q3, g3, f4, g4) = _*eqredux:fi.svf.bell(f1,1.414,g1):fi.svf.bell(f2, q2, g2):fi.svf.bell(f3,q3,g3):fi.svf.hs(f4, 1.414, g4);

faust/pultec.dsp

@@ -1,137 +0,0 @@
-import("stdfaust.lib");
-
-pultec(in1) = wd.buildtree(tree)
-with{
-    //resistors and potentiometers
-    p_HB_p(i) = wd.resistor(i, (10.0e4 - p_HB_ui + 1));
-    p_HB_m(i) = wd.resistor(i, (p_HB_ui + 1));
-    p_HBQ(i) = wd.resistor(i, (p_HBQ_ui+1));
-    p_LC(i) = wd.resistor(i, (p_LC_ui +1));
-    p_HC_p(i) = wd.resistor(i, (1.0e3 - p_HC_ui + 1));
-    p_HC_m(i) = wd.resistor(i, (p_HC_ui + 1));
-    p_BL(i) = wd.resistor(i, (p_BL_ui + 1));
-    r_a(i) = wd.resistor(i, 570);
-    r_b(i) = wd.resistor(i, 1.0e3);
-    r_c(i) = wd.resistor(i, 75);
-    r_d(i) = wd.resistor_Vout(i, 10.0e3);
-    //capacitors
-    c_HBF(i) = wd.capacitor(i, cl_HBF_ui(0));
-    c_HCF(i) = wd.capacitor(i, c_HCF_ui);
-    c_LF_a(i) = wd.capacitor(i, c_LF_ui(0));
-    c_LF_b(i) = wd.capacitor(i, c_LF_ui(1));
-    //inductor
-    l_HBF(i) = wd.inductor(i, cl_HBF_ui(1));
-    //voltage input
-    vin(i) = wd.resVoltage(i, 10, in1);
-
-    //connection tree parts
-    tree = u_6port : (a, b, c, d, e, f)
-    with{       
-        a = wd.series : (p_HC_m, (wd.parallel : (p_LC, c_LF_a)));
-        b = wd.series : (p_HC_p, (wd.parallel : (p_HC_m, (wd.series : (c_HCF, r_c))))); 
-        c = r_b; 
-        d = r_d; 
-        e = wd.parallel : (c_LF_b, p_BL); 
-        f = wd.series : ((wd.series : (p_HB_p, (wd.parallel : (vin, r_a)))), (wd.parallel : (p_HB_m, (wd.series : (p_HBQ, (wd.series : (l_HBF, c_HBF))))))); 
-       
-    };
-
-    //approximate a potentiometer position as an audio taper (log) resistance (%)
-    log_pot(slider) = 10^(slider/50) - 1; 
-    //approximate a potentiometer postion as an inverse log resistance (%)
-    invlog_pot(slider) = (slider+1) : log10*50;
-
-    //ui-elements
-    p_HB_ui = log_pot(hslider("h:PULTEC PROGRAM EQUALIZER/v:[2]HIGH FREQUENCY/h:[0]KNOBS/[0]BOOSTHi[style:knob]", 0, 0, 93, 1))/100 * 10.0e4;
-    p_HC_ui = invlog_pot(hslider("h:PULTEC PROGRAM EQUALIZER/v:[2]HIGH FREQUENCY/h:[0]KNOBS/[1]ATTENHi[style:knob]", 0, 0, 30, 1))/100 * 1.0e3;
-
-    p_HBQ_ui = log_pot(hslider("h:PULTEC PROGRAM EQUALIZER/v:[1]BANDWIDTH/ADJUST[style:knob]", 0, 0, 150, 1))/100 * 2.2e3;
-    p_BL_ui = log_pot(hslider("h:PULTEC PROGRAM EQUALIZER/v:[0]LOW FREQUENCY/h:[0]KNOBS/[0]BOOSTLow[style:knob]", 0, 0, 20, 1))/100 * 10.0e4;
-    p_LC_ui = log_pot(hslider("h:PULTEC PROGRAM EQUALIZER/v:[0]LOW FREQUENCY/h:[0]KNOBS/[1]ATTENLow[style:knob]", 0, 0, 130, 1))/100 * 100.0e1;
-    cl_HBF_ui = 
-    case{
-        (0) => (15.0e-9, 15.0e-9, 10.0e-9, 10.0e-9, 6.8e-9, 6.8e-9, 15.0e-9) : ba.selectn(7, switch_HBF); //capacitor switched values
-        (1) => (175.0e-3, 100.0e-3, 90.0e-3, 65.0e-3, 35.0e-3, 23.0e-3, 19.0e-3) : ba.selectn(7, switch_HBF);//inductor switched values
-        //(3kHz, 4kHz, 5kHz, 6kHz, 10kHz, 12kHz, 16kHz)
-        (x) => 5; 
-    }with{
-        switch_HBF = hslider("h:PULTEC PROGRAM EQUALIZER/v:[2]HIGH FREQUENCY/[1]CPSHi[style:menu{'3 kHz':0;'4 kHz':1;'5 kHz':2;'6 kHz':3;'10 kHz':4;'12 kHz':5;'16 kHz':6}]", 0, 0, 6, 1);
-    };
-    c_LF_ui = 
-    case{
-        (0) => (100.0e-9, 47.0e-9, 22.0e-9, 15.0e-9) : ba.selectn(4, switch_LF); //capacitor switched values
-        (1) => (2.2e-6, 1.0e-6, 470.0e-9, 330.0e-9) : ba.selectn(4, switch_LF);//inductor switched values
-        //(20hz, 30hz, 60hz, 100hz)
-        (x) => 5; 
-    }with{
-        switch_LF = hslider("h:PULTEC PROGRAM EQUALIZER/v:[0]LOW FREQUENCY/[1]CPSLow[style:menu{'20 Hz':0;'30 Hz':1;'60 Hz':2;'100 Hz':3}]", 0, 0, 3, 1);
-    };
-    c_HCF_ui = (47.0e-9, 94.0e-9, 197.0e-9) : ba.selectn(3, switch_HCF) //capacitor switched values
-            //(20hz, 30hz, 60hz, 100hz)
-    with{
-        switch_HCF = hslider("h:PULTEC PROGRAM EQUALIZER/v:[3]ATTEN SELECT/HI-CUT F[style:menu{'20':0;'10':1;'5':2}]", 0, 0, 2, 1);
-    };
-
-    u_6port(i) = wd.u_genericNode(i, sixport_scatter)
-    with{
-        sixport_scatter(Ra, Rb, Rc, Rd, Re, Rf) =  matrix(6, 6, scatter)
-        with{
-            scatter  =
-            case{
-                (1, 1) => ((-Ra)*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) 
-                        + Rc*(Re*Rf   + Rd*(Re + Rf)) +   Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (1, 2) => (2*Ra*((Rc + Re)*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (1, 3) => (2*Ra*(Rb*Rd + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (1, 4) => (-1)*((2*Ra*(Rb*(Rc + Re) + Rc*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (1, 5) => (2*Ra*(Rb*Rd - Rc*Rf))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (1, 6) => (-1)*((2*Ra*(Rc*Re + Rb*(Rc + Rd + Re)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (2, 1) => (2*Rb*((Rc + Re)*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (2, 2) => (Ra*(Rd*Re - Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) - Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) 
-                        + Rc*(Re*Rf + Rd*(Re + Rf)) +   Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (2, 3) => (-1)*((2*Rb*(Ra*Re + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (2, 4) => (-2*Ra*Rb*Re + 2*Rb*Rc*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (2, 5) => (2*Rb*(Ra*(Rc + Rd) + Rc*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (2, 6) => (-1)*((2*Rb*(Rc*Rd + Ra*(Rc + Rd + Re)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (3, 1) => (2*Rc*(Rb*Rd + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (3, 2) => (-1)*((2*Rc*(Ra*Re + Re*Rf + Rd*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (3, 3) => 1 - (2*Rc*(Rd*Re + Rd*Rf + Re*Rf + Rb*(Rd + Rf) + Ra*(Rb + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (3, 4) => (-1)*((2*Rc*(Rb*Rf + Ra*(Rb + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (3, 5) => (-1)*((2*Rc*(Ra*(Rb + Rf) + Rb*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (3, 6) => (2*Rc*(Rb*Rd - Ra*Re))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (4, 1) => (-1)*((2*Rd*(Rb*(Rc + Re) + Rc*(Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (4, 2) => (-2*Ra*Rd*Re + 2*Rc*Rd*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (4, 3) => (-1)*((2*Rd*(Rb*Rf + Ra*(Rb + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (4, 4) => 1 - (2*Rd*(Rc*(Re + Rf) + Ra*(Rb + Re + Rf) + Rb*(Rc + Re + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (4, 5) => (-1)*((2*Rd*((Rb + Rc)*Rf + Ra*(Rb + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (4, 6) => (-1)*((2*Rd*((Ra + Rc)*Re + Rb*(Rc + Re)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (5, 1) => (2*Re*(Rb*Rd - Rc*Rf))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (5, 2) => (2*Re*(Ra*(Rc + Rd) + Rc*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (5, 3) => (-1)*((2*Re*(Ra*(Rb + Rf) + Rb*(Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (5, 4) => (-1)*((2*Re*((Rb + Rc)*Rf + Ra*(Rb + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (5, 5) => 1 - (2*Re*((Rb + Rc)*(Rd + Rf) + Ra*(Rb + Rc + Rd + Rf)))/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (5, 6) => (2*((Rb + Rc)*Rd + Ra*(Rc + Rd))*Re)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (6, 1) => (-1)*((2*(Rc*Re + Rb*(Rc + Rd + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (6, 2) => (-1)*((2*(Rc*Rd + Ra*(Rc + Rd + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (6, 3) => (2*(Rb*Rd - Ra*Re)*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (6, 4) => (-1)*((2*((Ra + Rc)*Re + Rb*(Rc + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf))));
-                (6, 5) => (2*((Rb + Rc)*Rd + Ra*(Rc + Rd))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (6, 6) => 1 - (2*(Rc*(Rd + Re) + Ra*(Rc + Rd + Re) + Rb*(Rc + Rd + Re))*Rf)/(Ra*(Rd*Re + Rb*(Rc + Rd + Re) + Rd*Rf + Re*Rf + Rc*(Re + Rf)) + Rc*(Re*Rf + Rd*(Re + Rf)) + Rb*(Re*Rf + Rc*(Rd + Rf) + Rd*(Re + Rf)));
-                (i, j) => 10;
-            };
-            matrix(M,N,f) = si.bus(N) <: ro.interleave(N,M) : par(n,N, par(m,M,*(f(m+1,n+1)))) :> si.bus(M);
-        };
-    };
-};
-
-
-capacitorMobius(i, C, aM, bM, cM, dM) = genericNode_output_I(i, f, upPortRes)
-with{
-    f(a) = a*sF <: _, _'*sB : (_, _, _ :> _)~(_'*sB*sB)
-    with{
-        sB = (-1)*(aM*dM+bM*cM)/(2*aM*cM);
-        sF = (aM*dM-bM*cM)/(2*aM*cM);
-    };
-    upPortRes = cM/C*aM; 
-};
-
-process = pultec*200;

microsound-explorer/main.scd

@@ -0,0 +1,5 @@
+(
+~microsound_explorer = (
+  
+);
+)

projects/make-scd.el

@@ -1,50 +0,0 @@
-(defun create-scd-project ()
-  "Create a new project directory with a samples subdirectory and a main.scd file containing SuperCollider code."
-  (interactive)
-  (let* ((project-path (read-directory-name "Project path: " default-directory))
-         (project-name (read-string "Project name: "))
-         (full-path (expand-file-name project-name project-path))
-         (samples-path (expand-file-name "samples" full-path))
-         (main-file (expand-file-name "main.scd" full-path))
-         (supercollider-code (format
-                              "(
-                              s.options.memSize_(2.pow(20));
-                              s.waitForBoot({
-                                  ~makeBuffers = { |path, event, mono = false|
-                                      var dir = PathName.new(path);
-                                      var contents = dir.entries;
-                                      if (contents.select({ |n| n.isFile }).size > 0)
-                                      {
-                                          var files, bufArray;
-                                          files = contents.select({ |n| n.isFile });
-                                          files = files.select({ |n|
-                                              [\"aif\", \"aiff\", \"wav\"].includesEqual(n.extension)
-                                          });
-                                          if (event[dir.folderName.asSymbol] != nil)
-                                          { \"duplicate subfolder name ignored\".warn; }
-                                          {
-                                              bufArray = files.collect({ |n|
-                                                  if(mono)
-                                                  { Buffer.readChannel(s, n.fullPath, channels:[0]) }
-                                                  { Buffer.read(s, n.fullPath) };
-                                              });
-                                              event[dir.folderName.asSymbol] = bufArray;
-                                          };
-                                      };
-                                      if (contents.select({ |n| n.isFolder }).size > 0)
-                                      {
-                                          var folders = contents.select({ |n| n.isFolder });
-                                          folders.do({ |n| ~makeBuffers.(n.fullPath, event, mono) });
-                                      };
-                                      event;
-                                  };
-                                  ~samples = ~makeBuffers.(\"%s\", ());
-                              });
-                              )"
-                              samples-path)))
-         (make-directory full-path t)
-         (make-directory samples-path t)
-         (with-temp-file main-file
-           (insert supercollider-code))
-         (find-file main-file)
-         (save-buffer)))

readme.org

@@ -3,12 +3,11 @@ This repo contains reusable code I often share
 between my SuperCollider projects
 
 * Structure
-- NodeDictionary
+- *NodeDictionary*
   Set of Dictionary class extentions for generating
   nodes from declarative definitions
-- quarks
+- *quarks*
   Quarks and Extentions I usally use for projects
-- projects
+- *microsound-explorer*
-  code for SuperCollider projects maintaining
+  Tool for searchg and playing parts of soundfile using basic
-- faust
+  granular synth from my DSP library and copy specs
-  set of Faust dsp algorythms