Signal : FloatArray : RawArray : ArrayedCollection : SequenceableCollection : Collection : Object

Fill a Signal of the given size with a sum of sines at the given amplitudes and phases. The Signal will be normalized.Signal.sineFill(1000, 1.0/[1, 2, 3, 4, 5, 6]).plot;

Arguments:

Fill a Signal of the given size with a sum of Chebyshev polynomials at the given amplitudes. For eventual use in waveshaping by the Shaper ugen; see Shaper helpfile and Buffer:cheby too.

Arguments:

Discussion:

Signal.chebyFill(1000, [1]).plot; // shifted to avoid DC offset when waveshaping a zero signal Signal.chebyFill(1000, [0, 1], zeroOffset: true).plot; // normalized sum of (unshifted) Chebyshev polynomials (the default) Signal.chebyFill(1000, [0, 1, 0, 0, 0, 1], normalize: true, zeroOffset: false).plot; Signal.chebyFill(1000, [0, 0, 1]).plot; Signal.chebyFill(1000, [0.3, -0.8, 1.1]).plot; // This waveshaping example uses two buffers, one with zero offset and // the other not. // // 1. The offset version gives zero output (DC free) when waveshaping an // input signal with amplitude of zero (e.g. DC.ar(0)). // // 2. The non-offset version makes better use of the full (-1 to 1) range // when waveshaping a varying signal with amplitude near 1, but (if even // Chebyshev polynomial degrees are used) will have a DC offset when // waveshaping a signal with amplitude of zero. // // 3. Wrapping the non-offset Shaper in a LeakDC (the third signal in the // example) cancels out any DC offsets (third version), while making full use // of the -1 to 1 range. ( s.waitForBoot({ var amplitudes = [0, 1, 1, -2, 1]; var sigs = [ Signal.chebyFill(256+1, amplitudes, normalize: true, zeroOffset: true), Signal.chebyFill(256+1, amplitudes, normalize: true, zeroOffset: false) ]; b = sigs.collect{ arg sig; Buffer.loadCollection(s, sig.asWavetableNoWrap) }; s.sync; x = { var in = SinOsc.ar(100, 0, SinOsc.kr(0.1, 0, 0.5, 0.5)); Shaper.ar(b, in ) ++ LeakDC.ar(Shaper.ar(b[1], in)) }.scope; }) ) x.free; b.do(_.free); b = nil

Fill a Signal of the given size with a Hanning window.Signal.hanningWindow(1024).plot; Signal.hanningWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Hamming window.

Arguments:

Fill a Signal of the given size with a Welch window.Signal.welchWindow(1024).plot; Signal.welchWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a rectangular window.Signal.rectWindow(1024).plot; Signal.rectWindow(1024, 512).plot;

Arguments:

Fourier Transform: Fill a Signal with the cosine table needed by the FFT methods. See also the instance methods -fft and -ifft.Signal.fftCosTable(512).plot;

This used to be Signal.hammingWindow, but the coefficients were incorrect (making it a different window in the generalized Hamming window family). It is provided to assist in porting code to 3.11 and later.

Fill a Signal of the given size with a Bartlett/triangular window.Signal.bartlettWindow(1024, 0).plot; Signal.bartlettWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Blackman-Harris window.Signal.blackmanHarrisWindow(1024, 0).plot; Signal.blackmanHarrisWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Blackman-Nuttall window.Signal.blackmanNuttallWindow(1024, 0).plot; Signal.blackmanNuttallWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Gaussian window.Signal.gaussianWindow(1024, 0).plot; Signal.gaussianWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Hanning window. Overwrote SCClassLibrary to have the symmetry argument.Signal.hanningWindow(1024, 0).plot; Signal.hanningWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Hamming window. Overwrote SCClassLibrary to have the symmetry argument.Signal.hammingWindow(1024, 0).plot; Signal.hammingWindow(1024, 512).plot;

Arguments:

Synonymous with hanningWindow method with the extra symmetry argument.Signal.hannWindow(1024, 0).plot; Signal.hannWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Kaiser window.Signal.kaiserWindow(1024).plot; Signal.kaiserWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Lanczos window.Signal.lanczosWindow(1024).plot; Signal.lanczosWindow(1024, 512).plot;

Arguments:

Fill a Signal of the given size with a Tukey window (tapered-cosine window).Signal.tukeyWindow(1024).plot; Signal.tukeyWindow(1024, 512).plot;

Arguments:

Fourier Transform: Fill a Signal with the cosine table needed by the Real-FFT methods. See also the instance methods -rfft and -irfft.Signal.rfftCosTable(512/2 + 1).plot;

Fourier Transform: Fill a Signal with the cosine table needed by the Real-FFT-Two methods. See also the instance methods -rfftTwo and -irfftTwo.Signal.rfftTwoCosTable(512/2 + 1).plot;

Fill a Signal of the given size with a sum of cosines at the given amplitudes and phases. The Signal will be normalized.Signal.cosineFill(1000, 1.0/[1, 2, 3, 4, 5, 6]).plot;

Arguments:

Fill a Signal of the given size with a sum of Hann enveloped cosines at the given amplitudes and phases. The Signal will be normalized.Signal.packetFill(1000, 1.0/[1, 2, 3, 4, 5, 6]).plot("wave packet"); // compare with (Signal.cosineFill(500, 1.0/[1, 2, 3, 4, 5, 6]).wrapExtend(1000) * Signal.hannWindow(1000)).plot("enveloped cosines");

Arguments:

Fill a Signal of the given size with zeros. A synonym for *newClear.Signal.zeroFill(1000).plot;

Arguments:

Read a soundfile.( var path, size, startFrame; path = Platform.resourceDir +/+ "sounds/SinedPink.aiff"; // size = 501 size = 2048; startFrame = -250; x = Signal.read(path, size, startFrame); x.plot("sound: %".format(path), minval: -1.0, maxval: 1.0); )

Arguments:

Read a periodic waveform from a soundfile.( var path, soundFile, size, skipTime, freq; path = Platform.resourceDir +/+ "sounds/a11wlk01-44_1.aiff"; skipTime = 1.2589; freq = 132.5; size = 2048; soundFile = SoundFile.new(path); soundFile.openRead; x = Signal.readWave(path, size, (soundFile.sampleRate * skipTime).asInteger, freq: freq); x.plot("waveform: %".format(path), minval: -1.0, maxval: 1.0); soundFile.close; )

Arguments:

Discussion:

freq

Successful synthesis of a periodic waveform from a soundfile depends largely on closely estimating the frequency of the waveform. The folding frequency of the Kaiser synthesis window is mapped to this analysis frequency.

alpha

Time domain smoothing is directly specified by the Kaiser window alpha. Choosing alpha = 0; winScale = 0 specifies a rectangular window, and allows us to view an unsmoothed period of the source waveform. Higher values of alpha mean more time domain smoothing.( var path, soundFile, size, skipTime, freq; var alpha = 0, winScale = 0; path = Platform.resourceDir +/+ "sounds/a11wlk01-44_1.aiff"; skipTime = 1.2589; freq = 132.5; size = 2048; soundFile = SoundFile.new(path); soundFile.openRead; x = Signal.readWave(path, size, (soundFile.sampleRate * skipTime).asInteger, freq: freq, alpha: alpha, winScale: winScale); x.plot("unsmoothed waveform: %".format(path), minval: -1.0, maxval: 1.0); soundFile.close; )

winScale

The window scale argument scales the Kaiser window folding frequency with respect to the period of the waveform, like this:

The default, winScale = 1, is optimimal in the sense that frequency domain artifacts are relected furthest from the harmonics of the periodic waveform of interest, without excessive oversampling.

Read a Hann enveloped wave packet from a soundfile.( var path, soundFile, size, skipTime, freq; path = Platform.resourceDir +/+ "sounds/a11wlk01-44_1.aiff"; skipTime = 1.2589; freq = 132.5; size = 2048; soundFile = SoundFile.new(path); soundFile.openRead; x = Signal.readPacket(path, size, (soundFile.sampleRate * skipTime).asInteger, freq: freq); x.plot("wave packet: %".format(path), minval: -1.0, maxval: 1.0); soundFile.close; )

Arguments:

Discussion:

See *readWave discussion above.

Return a rectangular windowed sinc filter kernel.¹

Arguments:

Return a log shelf filter kernel.² See also: FreqSpectrum: *logShelf.

Arguments:

Return an Array of gaussian windowed filter kernels.( var size = 4096; var sampleRate = 44100; var freqs = [ 2756.25, 5512.5, 11025.0 ]; var alpha; var bank; // smoothing alpha = 1.0; // ideal // alpha = 10.0; // flatter // alpha = 0.1; // smoother // design gaussian filter bank bank = Signal.gaussianBank(size, freqs, alpha, sampleRate); // view! bank.do({ |item, i| item.rfft(Signal.rfftCosTable(size / 2 + 1)).magnitude.ampdb.plot(format("Magnitude response (dB): kernel %.", i), minval: -60.0, maxval: 6.0) }) )

Arguments:

Return gaussian white noise, with a mean of 0 and standard deviation of 1.

See also SimpleNumber: -gauss.Signal.gaussianNoise(2048).plot;

Arguments:

Return periodic power-law noise, aka fractional noise. Magnitude at Nyquist is normalized to 1.( var size = 2048; var rfftsize = (size / 2 + 1).asInteger; var rcosTable = Signal.rfftCosTable(rfftsize); var plnoise = Signal.periodicPLNoise(size); // white // var plnoise = Signal.periodicPLNoise(size, 1); // pink plnoise.plot; plnoise.rfft(rcosTable).magnitude.ampdb.plot(minval: -5.0, maxval: 5.0) )

Arguments:

Return a rectangular windowed sinus power-law chirp.³ ( var size = 2048; var rfftsize = (size / 2 + 1).asInteger; var rcosTable = Signal.rfftCosTable(rfftsize); var sampleRate = 44100; var freq1 = sampleRate * 2.pow(-2); var freq0 = freq1 * 2.pow(-3); // 3 octaves // var chirp = Signal.cosineChirp(size, freq0, freq1, sampleRate: sampleRate); // white var chirp = Signal.cosineChirp(size, freq0, freq1, beta: 1, sampleRate: sampleRate); // pink chirp.plot; chirp.rfft(rcosTable).magnitude.ampdb.plot )

Arguments:

Discussion:

Synthesized in the time domain.

Return a rectangular windowed sinus power-law chirp.

Arguments:

Discussion:

Synthesized in the time domain.

Return a rectangular windowed complex analytic sinus power-law chirp.( var size = 2048; var sampleRate = 44100; var freq1 = sampleRate * 2.pow(-2); var freq0 = freq1 * 2.pow(-3); // 3 octaves // var chirp = Signal.analyticChirp(size, freq0, freq1, sampleRate: sampleRate); // white var chirp = Signal.analyticChirp(size, freq0, freq1, beta: 1, sampleRate: sampleRate); // pink chirp.magnitude.ampdb.plot(minval: -5, maxval: 5); )

Arguments:

Discussion:

Synthesized in the time domain.

Return a complex analytic Signal of the given size with a sum of cosines and a sum of sines at the given amplitudes and phases. The Signal will be normalized.( var complex; complex = Signal.analyticFill(1000, 1.0/[1, 2, 3, 4, 5, 6]); complex.real.plot("real"); complex.imag.plot("imag"); )

Arguments:

Hilbert Transform: Return complex Hilbert Transform coefficients.( var complex; complex = Signal.hilbert(2048); complex.real.plot("real"); complex.imag.plot("imag"); )

Arguments:

Return an Array of Higher Order Ambisonic signal (HOA) near-field effect (NFE), distance radial filters collected by Associated Legendre degree (ℓ).

Arguments:

Discussion:

Offers FIR coefficients, equivalent to the IIR coefficients returned by NFECoeffs: -dist. Implemented as a frequency sampling design, with coefficients returned by HoaOrder: -distWeights. See also: FreqSpectrum: *hoaDist.

Return an Array of Higher Order Ambisonic signal (HOA) near-field effect (NFE), control radial filters collected by Associated Legendre degree (ℓ).

Arguments:

Discussion:

Offers FIR coefficients, equivalent to the IIR coefficients returned by NFECoeffs: -ctrl. Implemented as a frequency sampling design, with coefficients returned by HoaOrder: -ctrlWeights. See also: FreqSpectrum: *hoaCtrl.( ~size = 4096; ~order = 2; ~sampleRate = 44100; ~speedOfSound = AtkHoa.speedOfSound; ~refRadius = AtkHoa.refRadius; ~theta = (pi/4).rand2; ~phi = (pi/4).rand2; ~radius = 1.0.rrand(2.0); // design coefficients ~hoaOrder = ~order.asHoaOrder; ~angularCoeffs = ~hoaOrder.sph(~theta, ~phi); ~radialKernels = Signal.hoaCtrl(~size, ~radius, ~refRadius, ~order, ~sampleRate, ~speedOfSound); // design encoding kernels @ [ ~theta, ~phi, ~radius ] ~encodingKernels = ~angularCoeffs * ~radialKernels[~hoaOrder.l]; // view! ~encodingKernels.do({ arg kernel, index; kernel.plot(format("Encoding kernel [ %, %, % ] index: %.", ~theta.raddeg.round(1e-2), ~phi.raddeg.round(1e-2), ~radius.round(1e-2), index))}) )

Return an Array of Higher Order Ambisonic signal (HOA) near-field effect (NFE), focalisation radial filters collected by Associated Legendre degree (ℓ).

Arguments:

Discussion:

Offers FIR coefficients; implemented as a linear phase frequency sampling design, with coefficients returned by HoaOrder: -foclWeights. See also: FreqSpectrum: *hoaFocl.

Return an Array of Higher Order Ambisonic signal (HOA) filters combining multi-band beamforming and near-field effect (NFE) focalisation, collected by Associated Legendre degree (ℓ).

Arguments:

Discussion:

Offers FIR coefficients; implemented as a linear phase frequency sampling design, with coefficients returned by *logShelf and *hoaFocl. See also: FreqSpectrum: *hoaMultiBandFocl for design examples.

Plot the Signal in a window. The arguments are not required and if not given defaults will be used.Signal.sineFill(512, [1]).plot; Signal.sineFill(512, [1]).plot("Signal 1", Rect(50, 50, 150, 450));

For details, see plot

Loads the signal into a buffer on the server and plays it. Returns the buffer so you can free it again.b = Signal.sineFill(512, [1]).play(true, 0.2); b.free; // free the buffer again.

Arguments:

Fill the Signal with a function evaluated over an interval.

Arguments:

Convert the Signal into a Wavetable.Signal.sineFill(512, [1]).asWavetable.plot;

Fill the Signal with a value.Signal.newClear(512).fill(0.2).plot;

Scale the Signal by a factor in place.a = Signal[1, 2, 3, 4]; a.scale(0.5); a;

Offset the Signal by a value in place.a = Signal[1, 2, 3, 4]; a.offset(0.5); a;

Return the peak absolute value of a Signal.Signal[1, 2, -3, 2.5].peak;

Normalize the Signal in place such that the maximum absolute peak value is 1.Signal[1, 2, -4, 2.5].normalize; Signal[1, 2, -4, 2.5].normalize(0, 1); // normalize only a range

Normalizes a transfer function so that the center value of the table is offset to zero and the absolute peak value is 1. Transfer functions are meant to be used in the Shaper ugen.Signal[1, 2, 3, 2.5, 1].normalizeTransfer;

Invert the Signal in place.a = Signal[1, 2, 3, 4]; a.invert(0.5); a;

Reverse a subrange of the Signal in place.a = Signal[1, 2, 3, 4]; a.reverse(1, 2); a;

Fade a subrange of the Signal in place.a = Signal.fill(10, 1); a.fade(0, 3); // fade in a.fade(6, 9, 1, 0); // fade out

Return the integral of a signal.Signal[1, 2, 3, 4].integral;

Add a signal to myself starting at the index. If the other signal is too long only the first part is overdubbed.a = Signal.fill(10, 100); a.overDub(Signal[1, 2, 3, 4], 3); // run out of range a = Signal.fill(10, 100); a.overDub(Signal[1, 2, 3, 4], 8); a = Signal.fill(10, 100); a.overDub(Signal[1, 2, 3, 4], -4); a = Signal.fill(10, 100); a.overDub(Signal[1, 2, 3, 4], -1); a = Signal.fill(10, 100); a.overDub(Signal[1, 2, 3, 4], -2); a = Signal.fill(4, 100); a.overDub(Signal[1, 2, 3, 4, 5, 6, 7, 8], -2);

Write a signal to myself starting at the index. If the other signal is too long only the first part is overdubbed.a = Signal.fill(10, 100); a.overWrite(Signal[1, 2, 3, 4], 3); // run out of range a = Signal.fill(10, 100); a.overWrite(Signal[1, 2, 3, 4], 8); a = Signal.fill(10, 100); a.overWrite(Signal[1, 2, 3, 4], -4); a = Signal.fill(10, 100); a.overWrite(Signal[1, 2, 3, 4], -1); a = Signal.fill(10, 100); a.overWrite(Signal[1, 2, 3, 4], -2); a = Signal.fill(4, 100); a.overWrite(Signal[1, 2, 3, 4, 5, 6, 7, 8], -2);

Blend two signals by some proportion.Signal[1, 2, 3, 4].blend(Signal[5, 5, 5, 0], 0); Signal[1, 2, 3, 4].blend(Signal[5, 5, 5, 0], 0.2); Signal[1, 2, 3, 4].blend(Signal[5, 5, 5, 0], 0.4); Signal[1, 2, 3, 4].blend(Signal[5, 5, 5, 0], 1); Signal[1, 2, 3, 4].blend(Signal[5, 5, 5, 0], 2);

Perform an FFT on a real and imaginary signal in place. See also the class method *fftCosTable.( var size = 512; var real, imag, cosTable, frqAmpPhs, complex; // Create a signal of sine partials: // partial freqs, amps, and phases frqAmpPhs = [ // 0 Hz (DC), amp: 1, phase pi/2 (cosine) [0, 1, 0.5pi], // other partials, various amp and phase [8], [13, 0.25], [21, 0.25], [55, 0.5, 0.5pi], // nyquist, amp: 1, phase pi/2 (cosine) [size/2, 1, 0.5pi] ]; real = Signal.newClear(size); real.sineFill2(frqAmpPhs); imag = Signal.newClear(size); // zeros cosTable = Signal.fftCosTable(size); // Perform fft complex = fft(real, imag, cosTable); // Plot signals and spectrum [ real, imag, (complex.magnitude) / size ] .plot("fft", Window.screenBounds.insetBy(*200!2)) .axisLabelX_(["Signal (real, samples)", "Signal (imaginary, samples)", "FFT spectrum (bins)"]) .axisLabelY_(["Amplitude", "Amplitude", "Magnitude"]) .plotMode_([\linear, \linear, \steps]); )

Perform an inverse FFT on a real and imaginary signal in place. See also the class method *fftCosTable.( var real, imag, cosTable, complex, ifft; var size = 512; // Create a signal of sine partials, add noise real = Signal.newClear(size); real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); real.overDub(Signal.fill(size, { 0.2.bilinrand })); imag = Signal.newClear(size); // zeros cosTable = Signal.fftCosTable(size); // Perform fft & ifft complex = fft(real, imag, cosTable).postln; ifft = complex.real.ifft(complex.imag, cosTable); // Plot input and output [ real, ifft.real ] .plot("fft -> ifft", Window.screenBounds.insetBy(*200!2)) .axisLabelX_(["Real signal (samples)", "Restored signal (samples)"]) .axisLabelY_("Amplitude"); )

Return a complex Real-FFT spectrum from a complex FFT spectrum. See also the instance method -rfftToFft.( var size = 512, rfftsize, real, imag, cosTable, complexFft, complexRfft; rfftsize = size/2 + 1; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); imag = Signal.newClear(size); cosTable = Signal.fftCosTable(size); complexFft = fft(real, imag, cosTable); complexRfft = complexFft.real.fftToRfft(complexFft.imag); [real, imag, (complexFft.magnitude) / 100, (complexRfft.magnitude ++ Signal.zeroFill(size - rfftsize)) / 100 ].flop.flat .plot("fft & rfft", Rect(0, 0, 512 + 8, 500), numChannels: 4); )

Perform a Real-FFT on a real signal.⁸ See also the class method *rfftCosTable.( var size = 512, rfftsize, real, cosTable, complex; real = Signal.newClear(size);         // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]);         // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); rfftsize = size/2 + 1; cosTable = Signal.rfftCosTable(rfftsize); complex = rfft(real, cosTable); [real, (complex.magnitude ++ Signal.zeroFill(size - rfftsize)) / 100 ].flop.flat     .plot("rfft", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Perform an inverse Real-FFT on a real and imaginary signal. See also the class method *rfftCosTable.( var size = 512, rfftsize, real, cosTable, complex, irfft; real = Signal.newClear(size);         // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]);         // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); rfftsize = size/2 + 1; cosTable = Signal.rfftCosTable(rfftsize); complex = rfft(real, cosTable).postln; irfft = complex.real.irfft(complex.imag, cosTable); [real, irfft].flop.flat     .plot("rfft and back", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Return a complex FFT spectrum from a complex Real-FFT spectrum. See also the instance method -fftToRfft.( var size = 512, rfftsize, real, cosTable, complexRfft, complexFft; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); rfftsize = size/2 + 1; cosTable = Signal.rfftCosTable(rfftsize); complexRfft = rfft(real, cosTable); complexFft = complexRfft.real.rfftToFft(complexRfft.imag); [real, (complexRfft.magnitude ++ Signal.zeroFill(size - rfftsize)) / 100, (complexFft.magnitude) / 100 ].flop.flat .plot("rfft & fft", Rect(0, 0, 512 + 8, 500), numChannels: 3); )

Perform a Real-FFT on two real signals. See also the class method *rfftTwoCosTable.( var size = 512, rfftsize, real1, real2, cosTable, complexDict; // some harmonics real1 = Signal.newClear(size); real1.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // some noise real2 = Signal.newClear(size); real2.overDub(Signal.fill(size, { 0.2.bilinrand })); rfftsize = size/2 + 1; cosTable = Signal.rfftTwoCosTable(rfftsize); complexDict = rfftTwo(real1, real2, cosTable); [real1, (complexDict.rfft1.magnitude ++ Signal.zeroFill(size - rfftsize)) / 100, real2, (complexDict.rfft2.magnitude ++ Signal.zeroFill(size - rfftsize)) / 100 ].flop.flat .plot("rfftTwo", Rect(0, 0, 512 + 8, 500), numChannels: 4); )

Perform an inverse Real-FFT on two real and imaginary signals. See also the class method *rfftTwoCosTable.( var size = 512, rfftsize, real1, real2, cosTable, complexDict, irfftDict; // some harmonics real1 = Signal.newClear(size); real1.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // some noise real2 = Signal.newClear(size); real2.overDub(Signal.fill(size, { 0.2.bilinrand })); rfftsize = size/2 + 1; cosTable = Signal.rfftTwoCosTable(rfftsize); complexDict = rfftTwo(real1, real2, cosTable).postln; irfftDict = complexDict.rfft1.real.irfftTwo(complexDict.rfft1.imag, complexDict.rfft2.real, complexDict.rfft2.imag, cosTable); [real1, real2, irfftDict.irfft1, irfftDict.irfft2].flop.flat     .plot("rfftTwo and back", Rect(0, 0, 512 + 8, 500), numChannels: 4); )

Perform a DFT on a real and imaginary signal.

Arguments:

Perform an inverse DFT on a real and imaginary signal.

Arguments:

Perform a Zoom DFT on a real and imaginary signal.( var size = 512, zoomsize = 512, k0, k1, real, imag, complex; k0 = 0; // start at DC k1 = 60; // just above last harmonic real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); imag = Signal.newClear(size); complex = dftZoom(real, imag, zoomsize, k0, k1); [real, (complex.magnitude) / 100 ].flop.flat .plot("dftZoom", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Arguments:

Perform a Zoom DFT on a real signal.

Arguments:

Return individual terms of a DFT on a real and imaginary signal.⁹

Arguments:

Return individual terms of a DFT on a real signal.

Arguments:

The flip operator.¹⁰ ( var size = 1000; var cosine, sine, cosineF, sineF; cosine = Signal.newClear(size).cosineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125]]); sine = Signal.newClear(size).sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125]]); cosineF = cosine.flip; sineF = sine.flip; [cosine, cosineF, sine, sineF].flop.flat .plot("cosine, cosine.flip, sine, sine.flip", Rect(0, 0, size + 8, 500), numChannels: 4); )

Thresholding replaces every value < threshold with 0.

// these fail for Signal but work for FloatArray: Signal[0, 0.5, 1] pow: 2; Signal[0, 0.5, 1] ** 2; Signal[0, 0.5, 1] mod: 0.15; Signal[0, 0.5, 1] % 0.15; FloatArray[0, 0.5, 1] % 0.15;

Bilateral thresholding.

Arguments:

Discussion:

Add a single cosine to myself with the given harmonic, amplitude and phase.

A sum of cosines with the given amplitudes and phases, returned in place.Signal.newClear(1000).cosineFill(1.0/[1, 2, 3, 4, 5, 6]).plot;

Arguments:

A sum of cosines with the given harmonics, amplitudes and phases, returned in place.( var numharms, harms, amps, phases, list; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); Signal.newClear(1000).cosineFill2(list).plot; )

Arguments:

A sum of Hann enveloped cosines at the given amplitudes and phases, returned in place.Signal.newClear(1000).packetFill(1.0/[1, 2, 3, 4, 5, 6]).plot;

Arguments:

A sum of Hann enveloped cosines with the given harmonics, amplitudes and phases, returned in place.( var numharms, harms, amps, phases, list; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); Signal.newClear(1000).packetFill2(list).plot; )

Arguments:

Given a periodic waveform, returns a Hann enveloped wave packet. The receiver is unchanged.( var numharms, harms, amps, phases, list; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); Signal.newClear(1000).cosineFill2(list).wavePacket.plot; )

Given a superposition density window, returns a constant-overlap-add (COLA) window.¹¹ The receiver is unchanged.( var size, hopsize, overlapsize; var colawindow; var ola; size = 1000; // hopsize = 1000; hopsize = 531; // hopsize = 500; // hopsize = 303; // hopsize = 106; // calc overlapsize overlapsize = size - hopsize; // generate cola window colawindow = Signal.hannWindow(overlapsize + 1).cola(size); "size: ".post; size.postln; "hopsize: ".post; hopsize.postln; "overlapsize: ".post; overlapsize.postln; // overlap add ola = Signal.newClear(size * 6); 16.do({ arg i; ola.overDub(colawindow, i * hopsize) }); [ Signal.newClear(size * 6).deepCopy.overDub(colawindow), ola].flop.flat .plot("constant-overlap-add (COLA)", Rect(0, 0, 512 + 8, 500), numChannels: 2, minval: 0.0, maxval: 1.5); )

Returns a new Signal whose elements are repeated sequences of the receiver, up to size length. The receiver is unchanged.( var numharms, harms, amps, phases, list; var size = 600; var real1, real2; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real1 = Signal.newClear(size).cosineFill2(list); real2 = real1.wrapExtend(size.nextPowerOfTwo); [real1.zeroPad(size.nextPowerOfTwo), real2 ].flop.flat .plot("wrapExtend", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Returns a new Signal resampled in the frequency domain to a new size. The receiver is unchanged.( var numharms, harms, amps, phases, list; var size = 600; var real1, real2; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real1 = Signal.newClear(size).cosineFill2(list); real2 = real1.resize(real1.size.nextPowerOfTwo); [real1.zeroPad(size.nextPowerOfTwo), real2 ].flop.flat .plot("resize", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Remove the DC component the Signal in place.( Signal.newClear(8).cosineFill2([[1, 1]]).plot("Cosine Only"); // prototype Signal.newClear(8).cosineFill2([[0, 1], [1, 1]]).plot("Cosine + DC"); // with DC Signal.newClear(8).cosineFill2([[0, 1], [1, 1]]).discardDC.plot("Cosine + DC, DC removed"); // with DC )

Writes the entire Signal to a file, where every chunk of four bytes is a 32-bit floating point sample.( var numharms, harms, amps, phases, list; var size = 600; var real1, real2; var path = "~/Desktop/testBinarySignal".standardizePath; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real1 = Signal.newClear(size).cosineFill2(list); // write it real1.writeFile(path); // read it real2 = Signal.readNew(File.new(path, "r")); [real1, real2 ].flop.flat .plot("writeFile", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Writes the entire Signal to a soundfile.( var numharms, harms, amps, phases, list; var size = 600; var real1, real2, soundFile; var path = "~/Desktop/testSoundFile.wav".standardizePath; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real1 = Signal.newClear(size).cosineFill2(list); // write it real1.write(path); // read it soundFile = SoundFile.openRead(path); real2 = FloatArray.newClear(soundFile.numFrames); soundFile.readData(real2); real2 = real2.as(Signal); [real1, real2 ].flop.flat .plot("write", Rect(0, 0, 512 + 8, 500), numChannels: 2); )

Arguments:

Convolve myself with a signal.( var size1 = 1000, size2 = 200, size3; var win1, win2, win3; win1 = Signal.hannWindow(size1); win2 = Signal.series(size2, 0.0, (size2.reciprocal)); win3 = win1.convolve(win2); size3 = win3.size; [win1.zeroPad(size3), win2.zeroPad(size3), win3.zeroPad(size3)].flop.flat .plot("win1, win2, win1*win2", Rect(0, 0, size3 + 8, 500), numChannels: 3); )

Arguments:

Periodic convolve myself with a signal.( var size1 = 1000, size2 = 200, size3; var win1, win2, win3; win1 = Signal.hannWindow(size1); win2 = Signal.series(size2, 0.0, (size2.reciprocal)); win3 = win1.periodicConvolve(win2); size3 = win3.size; [win1.zeroPad(size3), win2.zeroPad(size3), win3.zeroPad(size3)].flop.flat .plot("win1, win2, win1*win2", Rect(0, 0, size3 + 8, 500), numChannels: 3); )

Arguments:

Partition convolve myself with a signal.( var size1 = 1000, size2 = 200, size3; var partSize = 100; var win1, win2, win3; win1 = Signal.hannWindow(size1); win2 = Signal.series(size2, 0.0, (size2.reciprocal)); win3 = win1.partConvolve(win2, partSize); size3 = win3.size; [win1.zeroPad(size3), win2.zeroPad(size3), win3.zeroPad(size3)].flop.flat .plot("win1, win2, win1*win2", Rect(0, 0, size3 + 8, 500), numChannels: 3); )

Arguments:

Hilbert Transform: Return a complex analytic signal from a real signal.¹² ( var numharms, harms, amps, phases, list; var real, complex; numharms = 6; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real = Signal.newClear(1000).cosineFill2(list); complex = real.analytic; [real, complex.real, complex.imag].flop.flat .plot("real, complex.real, complex.imag", Rect(0, 0, 1000 + 8, 500), numChannels: 3); )

Return the instantaneous frequency from a real signal.¹³ ( var size = 8192; var sampleRate = 44100; var freq1 = sampleRate * 2.pow(-2); var freq0 = freq1 * 2.pow(-3); // 3 octaves var instFreq; // var chirp = Signal.cosineChirp(size, freq0, freq1, sampleRate: sampleRate); // white var chirp = Signal.cosineChirp(size, freq0, freq1, beta: 1, sampleRate: sampleRate); // pink instFreq = chirp.instaneousFreq(sampleRate: sampleRate); chirp.plot("chirp"); instFreq.plot("instantaneous freq") )

Arguments:

Return a complex signal with the given real and imaginary parts.( var size = 1000, real, imag, complex; real = Signal.newClear(size).sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); imag = Signal.newClear(size).overDub(Signal.fill(size, { 0.2.bilinrand })); complex = real.complex(imag); [complex.real, complex.imag].flop.flat .plot("complex.real, complex.imag", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Rotate the Signal by a value in radians, in place.

Rotate the phase of Signal by a value in radians, in place.( var size = 1000, real, rotated; real = Signal.newClear(size).cosineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); rotated = real.deepCopy.rotatePhase(-pi/2); [real, rotated].flop.flat .plot("rotate phase: original and rotated", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Return a linear phase kernel, preserving the magnitude, in place.( var numharms, harms, amps, phases, list; var real, reset; numharms = 16; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real = Signal.newClear(1000).cosineFill2(list).normalize; real = real * Signal.hannWindow(1000); // window reset = real.deepCopy.linearPhase; [real, reset].flop.flat .plot("reset phase: original and linear", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Arguments:

Return a minimum phase kernel, preserving the magnitude, in place.¹⁴ ( var numharms, harms, amps, phases, list; var real, reset; numharms = 16; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real = Signal.newClear(1000).cosineFill2(list).normalize; real = real * Signal.hannWindow(1000); // window reset = real.deepCopy.minimumPhase(oversample: 8); [real, reset].flop.flat .plot("reset phase: original and minimum", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Arguments:

Return a gaussian noise phase kernel, preserving the magnitude, in place.( var numharms, harms, amps, phases, list; var real, reset; numharms = 16; harms = Array.rand(numharms, 1, 16); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.rand(numharms, 0, 2pi); list = [harms, amps, phases].lace.clump(3); real = Signal.newClear(1000).cosineFill2(list).normalize; real = real * Signal.hannWindow(1000); // window reset = real.deepCopy.gaussianPhase; [real, reset].flop.flat .plot("reset phase: original and gaussian", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Return the even part of a signal.¹⁵ ( var size = 1000, numharms = 16, harms, amps, phases, list; var cosines, sines, sum, even, odd; harms = Array.rand(numharms, 1, numharms); amps = Array.rand(numharms, 0, -12).dbamp; phases = Array.zeroFill(numharms); list = [harms, amps, phases].lace.clump(3); cosines = Signal.newClear(1000).cosineFill2(list.keep((numharms/2).asInteger)).normalize; // half as cosines... sines = Signal.newClear(1000).sineFill2(list.keep((numharms.neg/2).asInteger)).normalize; // ... half as sines sum = cosines + sines; // sum even = sum.even; // even is cosines! odd = sum.odd; // odd is sines! [cosines, sines, sum, even, odd].flop.flat .plot("cosines, sines, sum, even, odd", Rect(0, 0, 1000 + 8, 500), numChannels: 5); )

Return the odd part of a signal.

Return the RMS of a signal.Signal.rectWindow(1000).rms; Signal.sineFill(1000, [1]).rms; Signal.cosineFill(1000, [1]).rms; Signal.hannWindow(1000).rms;

Return the peak of the frequency domain magnitude of a signal.( var size = 512, real, imag, cosTable, complex; var peakMag; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); peakMag = (real.peakMagnitude / 100); // scale to plotted value imag = Signal.newClear(size); cosTable = Signal.fftCosTable(size); complex = fft(real, imag, cosTable); [real, imag, (complex.magnitude) / 100 ].flop.flat .plot("fft: peak magnitude = %".format(peakMag), Rect(0, 0, 512 + 8, 500), numChannels: 3); )

Arguments:

Normalize the Signal in place such that the maximum magnitude in the frequency domain is 1.( var size = 512, real, imag, cosTable, complex; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); // real.put(0, -12.dbamp); // for comparison... impulse response real.normalizeMagnitude; imag = Signal.newClear(size); cosTable = Signal.fftCosTable(size); complex = fft(real, imag, cosTable); [real, imag, (complex.magnitude) ].flop.flat .plot("fft: peak magnitude = 1.0", Rect(0, 0, 512 + 8, 500), numChannels: 3); )

Arguments:

Return the real part of the cepstrum of a real signal.¹⁶ ( var size = 1000, real, realceps; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); // make an "echo" real.overDub(real.rotateWave(-pi/4)); realceps = rceps(real); [real, realceps].flop.flat .plot("rceps", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Return the real part of the inverse of the real part of the cepstrum.( var size = 1000, real, realceps, irealceps; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); realceps = rceps(real); irealceps = irceps(realceps); [real, irealceps].flop.flat .plot("irceps - phase is lost!", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Perform a Chirp z-Transform on a real and imaginary signal.¹⁷ ( var size = 1000, real, imag, complex; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); imag = Signal.newClear(size); complex = czt(real, imag); // just the DFT! [real, (complex.magnitude) / 100 ].flop.flat .plot("dft via czt", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Arguments:

Perform a Chirp z-Transform on a real signal.( var size = 1000, real, complex; real = Signal.newClear(size); // some harmonics real.sineFill2([[8], [13, 0.5], [21, 0.25], [55, 0.125, 0.5pi]]); // add a little noise real.overDub(Signal.fill(size, { 0.2.bilinrand })); complex = rczt(real); // just the DFT! [real, (complex.magnitude) / 100 ].flop.flat .plot("dft via rczt", Rect(0, 0, 1000 + 8, 500), numChannels: 2); )

Arguments: