roctave 0.0.1

data/samples/butter.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+#b, a = Roctave.butter(12, [0.3, 0.7], :stop)
+b, a = Roctave.butter(12, 0.75, :low)
+pp b #.collect{|v| v.round(5)}
+pp a #.collect{|v| v.round(5)}
+
+Roctave.freqz(b, a, :magnitude, :phase, :group_delay)
+Roctave.zplane(b, a)
+

data/samples/cheby.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+b, a = Roctave.cheby2(5, -0.1, (0.4 .. 0.6), :stop)
+pp b
+pp a
+
+Roctave.freqz(b, a, :magnitude)
+Roctave.zplane(b, a)
+exit
+b, a = Roctave.cheby1(12, -0.01, (0.4 .. 0.6), :stop)
+pp b
+pp a
+
+Roctave.freqz(b, a, :magnitude)
+Roctave.zplane(b, a)
+
+plot_args = []
+(1..10).each do |i|
+	b, a = Roctave.cheby1(i, -0.2, 0.5)
+	h, w = Roctave.freqz(b, a)
+	plot_args << w.collect{|v| v/Math::PI}
+	plot_args << h.abs
+	plot_args << ";n = #{i};"
+end
+
+Roctave.plot(*plot_args, grid: true)

data/samples/dft.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+fs = 600
+fn = fs/2.0
+t = Roctave.linspace(0, 1, fs)
+s = t.collect{|t| 1*Math.cos(2*Math::PI*100*t + 0*Math::PI/3) + 0.8*Math.cos(2*Math::PI*150*t + 1*Math::PI/3) + 0.6*Math.cos(2*Math::PI*200*t + 2*Math::PI/3)}
+#Roctave.plot(t, s, grid: true)
+
+st = Time.now
+dft = Roctave.fftshift(Roctave.dft(s, 2048, window: :nuttall, normalize: true).abs)
+et = Time.now
+puts "Took #{(et - st).round(3)} s to compute #{dft.length}-points DFT"
+dft.collect!{|e| 20.0*Math.log10(e)}
+f = Roctave.linspace(-fn, fn, dft.length)
+#Roctave.plot(f, dft, grid: true, title: 'DFT', xlabel: 'frequency', ylabel: 'Amplitude')
+Roctave.plot(f, dft, grid: true, title: 'DFT', xlabel: 'frequency', ylabel: 'dB', ylim: [-150, 0])

data/samples/differentiator.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+# H(e^(jw)) = j.w, for -pi <= w <= pi
+# h(n) = 0 when n == 0, else (-1)^n / n
+
+n = 14
+
+
+b = Roctave.fir_differentiator(n, window: :blackman)
+Roctave.freqz(b, :magnitude, :phase, :group_delay)
+exit
+
+Roctave.stem((-n/2..n/2).to_a, b, :filled, grid: true, title: "FIR type III order #{n}")
+
+r1 = Roctave.dft(b, 2048)
+h1 = r1[0...1024].abs
+p1 = r1[0...1024].arg
+p1 = Roctave.unwrap(p1)
+w1 = Roctave.linspace(0, 1, 1024)
+Roctave.plot([0, Math::PI], '--;Ideal;', w1, h1, ";FIR type III order #{n};", grid: true, title: 'Magnitude')
+Roctave.plot(w1, p1, grid: true, title: 'Phase')
+
+###
+
+fc = 1.0/2
+b = Roctave.fir_differentiator_low_pass(n, fc, window: :hamming)
+
+Roctave.stem((-n/2..n/2).to_a, b, :filled, grid: true, title: "FIR type III order #{n} \\\"lowpass\\\"")
+
+r2 = Roctave.dft(b, 2048)
+h2 = r2[0...1024].abs
+p2 = r2[0...1024].arg
+p2 = Roctave.unwrap(p2)
+w2 = Roctave.linspace(0, 1, 1024)
+Roctave.plot([0, fc, 2*fc, 1], [0, Math::PI * fc, 0, 0], '--;Ideal;', w2, h2, ";FIR type III order #{n} \"lowpass\";", grid: true, title: 'Magnitude')
+Roctave.plot(w2, p2, grid: true, title: 'Phase')
+
+
+Roctave.plot(
+	[0, Math::PI], '--;Ideal 1;', 
+	[0, fc, 2*fc, 1], [0, Math::PI * fc, 0, 0], '--;Ideal 2;', 
+	w1, h1, ";1 FIR type III order #{n};",
+	w2, h2, ";2 FIR type III order #{n} \"lowpass\";", 
+	grid: true, title: 'Magnitude'
+)
+

data/samples/differentiator_frequency_scaling.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+
+
+if true then # Type III
+	n = 32
+	f = [0, 0.75, 1]
+	m = [Complex(0.0, 0.0), Complex(0.0, 0.75*Math::PI), Complex(0.0, 0.0)]
+else # Type IV
+	n = 31
+	f = [0, 1]
+	m = [Complex(0.0, 0.0), Complex(0.0, Math::PI)]
+end
+b = Roctave.fir2(n, f, m, :odd_symetry, window: :blackman)
+
+Roctave.stem(b, :filled, grid: true)
+
+r = Roctave.dft(b, 2048)
+r = Roctave.fftshift(r)
+h = r.abs
+p = r.arg
+w = Roctave.linspace(-1, 1, 2048)
+Roctave.plot([-1, 0, 1], [Math::PI, 0, Math::PI], '--;Ideal;', w, h, ';Actual;', grid: true, title: 'Magnitude')
+Roctave.plot(w, p, grid: true, title: 'Phase')
+
+=begin
+n = [2, order.to_i].max
+n += n & 1
+grid = 1024
+mgridl = Roctave.linspace(0, Math::PI, grid + 1).collect{|i| Complex(0.0, i)}
+mgridr = mgridl[1...-1].reverse.conj
+mgrid = mgridl + mgridr
+b = Roctave.idft(mgrid)
+mid = (n+1) / 2.0
+b = (b[-(mid.floor) .. -1] + b[0 ... mid.ceil]).collect{|e| e.real}
+window = Roctave.blackman(n+1)
+b = b.collect.with_index{|e, i| e*window[i]}
+
+indexes = (-n/2..n/2).to_a
+Roctave.stem(indexes, b, :filled, grid: true, title: "FIR type III order #{n}")
+
+r = Roctave.dft(b, 2048)
+h = r[0...1024].abs
+p = r[0...1024].arg
+w = Roctave.linspace(0, 1, 1024)
+Roctave.plot([0, Math::PI], '--;Ideal;', w, h, ";FIR type III order #{n};", grid: true, title: 'Magnitude')
+Roctave.plot(w, p, grid: true, title: 'Phase')
+=end
+
+

data/samples/fft.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+fs = 8192
+fn = fs/2.0
+t = Roctave.linspace(0, 1, fs)
+s = t.collect{|t| 1*Math.cos(2*Math::PI*100*t + 0*Math::PI/3) + 0.8*Math.cos(2*Math::PI*150*t + 1*Math::PI/3) + 0.6*Math.cos(2*Math::PI*200*t + 2*Math::PI/3)}
+
+n = 4096
+
+st = Time.now
+fft = Roctave.fftshift(Roctave.fft(s, n, window: :nuttall, normalize: true).abs)
+et = Time.now
+puts "Took #{(et - st).round(3)} s to compute #{fft.length}-points FFT"
+ffttime = et - st
+
+
+st = Time.now
+dft = Roctave.fftshift(Roctave.dft(s, n, window: :nuttall, normalize: true).abs)
+et = Time.now
+puts "Took #{(et - st).round(3)} s to compute #{dft.length}-points DFT"
+dfttime = et - st
+puts "FFT acceleration factor: #{(dfttime / ffttime).round(3)}"
+
+fft.collect!{|e| 20.0*Math.log10(e)}
+dft.collect!{|e| 20.0*Math.log10(e)}
+
+dftf = Roctave.linspace(-fn, fn, dft.length)
+fftf = Roctave.linspace(-fn, fn, fft.length)
+
+#Roctave.plot(f, dft, grid: true, title: 'DFT', xlabel: 'frequency', ylabel: 'Amplitude')
+Roctave.plot(fftf, fft, ";FFT;", dftf, dft, "--;DFT;", grid: true, title: 'DFT', xlabel: 'frequency', ylabel: 'dB', ylim: [-150, 0])
+
+st = Time.now
+si = Roctave.idft(Roctave.dft(s));
+et = Time.now
+puts "Took #{(et - st).round(3)} s to compute forward and inverse #{si.length}-points DFT"
+Roctave.plot(t, s, ';original;', Roctave.linspace(0, 1, si.length), si, '--;reconstructed;')
+

data/samples/finite_difference_coefficient.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+
+n = 8
+
+###
+
+b1 = Roctave.fir_differentiator(n, window: :blackman)
+
+Roctave.stem((-n/2..n/2).to_a, b1, :filled, grid: true, title: "Differentiator")
+
+r1 = Roctave.dft(b1, 2048)
+h1 = r1[0...1024].abs
+p1 = r1[0...1024].arg
+p1 = Roctave.unwrap(p1)
+w1 = Roctave.linspace(0, 1, 1024)
+Roctave.plot([0, Math::PI], '--;Ideal;', w1, h1, ";Filter;", grid: true, title: 'Differentiator magnitude')
+Roctave.plot(w1, p1, grid: true, title: 'Differentiator phase')
+
+###
+
+b2 = Roctave.finite_difference_coefficients((-n/2 .. n/2), 1)
+
+Roctave.stem((-n/2..n/2).to_a, b2, :filled, grid: true, title: "Finite difference")
+
+r2 = Roctave.dft(b2, 2048)
+h2 = r2[0...1024].abs
+p2 = r2[0...1024].arg
+p2 = Roctave.unwrap(p2)
+w2 = Roctave.linspace(0, 1, 1024)
+Roctave.plot([0, Math::PI], '--;Ideal;', w2, h2, ";Filter;", grid: true, title: 'Finite difference magnitude')
+Roctave.plot(w2, p2, grid: true, title: 'Finite difference phase')
+
+###
+
+n = 16
+d = 3
+b2 = Roctave.finite_difference_coefficients((-n/2 .. n/2), d)
+pp b2.reverse
+
+Roctave.stem((-n/2..n/2).to_a, b2, :filled, grid: true, title: "Finite difference length #{n+1} derivative order #{d}")
+
+r2 = Roctave.dft(b2, 2048)
+h2 = r2[0...1024].abs
+p2 = r2[0...1024].arg
+p2 = Roctave.unwrap(p2)
+w2 = Roctave.linspace(0, 1, 1024)
+Roctave.plot(w2, w2.collect{|e| (Math::PI*e)**d}, '--;Ideal;', w2, h2, ";Filter;", grid: true, title: 'Finite difference magnitude length #{n+1} derivative order #{d}')
+Roctave.plot(w2, p2, grid: true, title: 'Finite difference phase length #{n+1} derivative order #{d}')
+
+

data/samples/fir1.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+n = 128
+fc = 0.5
+
+b1 = Roctave.fir1(n, [0.4, 0.6, 0.8], :high)
+
+h1 = Roctave.dft(b1, 2048).abs[0...1024]
+w = Roctave.linspace(0.0, 1.0, 1024)
+Roctave.plot(w, h1, [0.5], [fc], '*', grid: true, ylim: [0, 1.4])
+

data/samples/fir2.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+f = [0.0, 0.3, 0.3, 0.6, 0.6, 1.0]
+m = [0, 0, 1, 0.5, 0, 0]
+b = Roctave.fir2(60, f, m)
+
+h = Roctave.dft(b, 2048).abs[0...1024]
+p = Roctave.dft(b, 2048).arg[0...1024]
+w = Roctave.linspace(0.0, 1.0, 1024)
+Roctave.plot(f, m, ';Ideal;', w, h, '-;fir2;', title: 'Magnitude')
+#Roctave.plot(w, p, title: 'Phase')
+

data/samples/fir2_windows.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+f = [
+ 	0.00000, 0.01000, 0.02000, 0.03000, 0.04000, 0.05000, 0.06000, 0.07000, 0.08000, 0.09000, 0.10000, 0.11000, 0.12000,
+ 	0.13000, 0.14000, 0.15000, 0.16000, 0.17000, 0.18000, 0.20000, 0.38000, 0.40000, 0.55000, 0.56200, 0.58500, 0.60000,
+ 	0.78000, 0.79000, 0.80000, 0.81000, 0.82000, 0.83000, 0.84000, 0.85000, 0.86000, 0.87000, 0.88000, 0.89000, 0.90000,
+ 	0.91000, 0.92000, 0.93000, 0.94000, 0.95000, 0.96000, 0.97000, 0.98000, 0.99000, 1.00000
+]                                                                                                                       
+m = [                                                                                                                   
+	0.50000, 0.61350, 0.70225, 0.74692, 0.73776, 0.67678, 0.57725, 0.46089, 0.35305, 0.27725, 0.25000, 0.27725, 0.35305,
+	0.46089, 0.57725, 0.67678, 0.73776, 0.74692, 0.70225, 0.50000, 2.30000, 1.00000, 1.00000, 0.20000, 0.20000, 1.00000,
+	1.00000, 0.99380, 0.92000, 0.84980, 0.78320, 0.72020, 0.66080, 0.60500, 0.55280, 0.50420, 0.45920, 0.41780, 0.38000,
+	0.34580, 0.31520, 0.28820, 0.26480, 0.24500, 0.22880, 0.21620, 0.20720, 0.20180, 0.20000
+]
+
+n = 128
+hamming          = Roctave.dft(Roctave.fir2(n, f, m, window: :hamming),          2048).abs[0...1024]
+hann             = Roctave.dft(Roctave.fir2(n, f, m, window: :hann),             2048).abs[0...1024]
+blackman         = Roctave.dft(Roctave.fir2(n, f, m, window: :blackman),         2048).abs[0...1024]
+nuttall          = Roctave.dft(Roctave.fir2(n, f, m, window: :nuttall),          2048).abs[0...1024]
+blackman_nuttall = Roctave.dft(Roctave.fir2(n, f, m, window: :blackman_nuttall), 2048).abs[0...1024]
+blackman_harris  = Roctave.dft(Roctave.fir2(n, f, m, window: :blackman_harris),  2048).abs[0...1024]
+gaussian         = Roctave.dft(Roctave.fir2(n, f, m, window: :gaussian),         2048).abs[0...1024]
+
+w = Roctave.linspace(0.0, 1.0, 1024)
+Roctave.plot(f, m, ';Ideal;', w, hamming, ';hamming;', w, hann, ';hann;', w, blackman, ';blackman;', w, nuttall, ';nuttall;', w, blackman_nuttall, ';blackman nuttall;', w, blackman_harris, ';blackman harris;', w, gaussian, ';gaussian;', title: 'Magnitude')
+

data/samples/fir2bank.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+n = 64
+f1 = [0.0, 0.2, 0.2, 1.0]
+m1 = [1.0, 1.0, 0.0, 0.0]
+f2 = [0.0, 0.2, 0.2, 0.4, 0.4, 1.0]
+m2 = [0.0, 0.0, 1.0, 1.0, 0.0, 0.0]
+f3 = [0.0, 0.4, 0.4, 0.6, 0.6, 1.0]
+m3 = [0.0, 0.0, 1.0, 1.0, 0.0, 0.0]
+f4 = [0.0, 0.6, 0.6, 0.8, 0.8, 1.0]
+m4 = [0.0, 0.0, 1.0, 1.0, 0.0, 0.0]
+f5 = [0.0, 0.8, 0.8, 1.0]
+m5 = [0.0, 0.0, 1.0, 1.0]
+b1 = Roctave.fir2(n, f1, m1)
+b2 = Roctave.fir2(n, f2, m2)
+b3 = Roctave.fir2(n, f3, m3)
+b4 = Roctave.fir2(n, f4, m4)
+b5 = Roctave.fir2(n, f5, m5)
+
+w  = Roctave.linspace(0.0, 1.0, 1024)
+h1 = Roctave.dft(b1, 2048).abs[0...1024]
+h2 = Roctave.dft(b2, 2048).abs[0...1024]
+h3 = Roctave.dft(b3, 2048).abs[0...1024]
+h4 = Roctave.dft(b4, 2048).abs[0...1024]
+h5 = Roctave.dft(b5, 2048).abs[0...1024]
+h = (0...1024).collect{|i| h1[i] + h2[i] + h3[i] + h4[i] + h5[i]}
+Roctave.plot(w, h1, w, h2, w, h3, w, h4, w, h5, w, h, grid: true)
+

data/samples/fir_low_pass.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+n = 64
+fc = 0.25
+width = 0.1
+
+b = Roctave.fir_low_pass(n, fc - width/2)
+Roctave.stem(b, grid: true)
+w = Roctave.linspace(0.0, 1.0, 1024)
+h = Roctave.dft(b, 2048).abs[0...1024]
+Roctave.plot(w, h, title: 'Low-pass', xlim: [-0.1, 1.1], ylim: [-0.1, 1.1], grid: true)
+
+b = Roctave.fir_high_pass(n, fc + width/2)
+Roctave.stem(b)
+w = Roctave.linspace(0.0, 1.0, 1024)
+h = Roctave.dft(b, 2048).abs[0...1024]
+Roctave.plot(w, h, title: 'High-pass', xlim: [-0.1, 1.1], ylim: [-0.1, 1.1], grid: true)
+
+b = Roctave.fir_band_stop(n, fc, width, window: :hamming)
+Roctave.stem(b, :filled, grid: true)
+w = Roctave.linspace(0.0, 1.0, 1024)
+h = Roctave.dft(b, 2048).abs[0...1024]
+Roctave.plot(w, h, [fc - width / 2.0, fc + width / 2.0], [0.5, 0.5], title: 'Band-stop', xlim: [-0.1, 1.1], ylim: [-0.1, 1.1], grid: true)
+
+b = Roctave.fir_band_pass(n & ~1, fc, width, window: :hamming)
+Roctave.stem(b, :filled, grid: true, title: "Band-pass even #{b.length - 1}")
+w = Roctave.linspace(0.0, 1.0, 1024)
+h = Roctave.dft(b, 2048).abs[0...1024]
+Roctave.plot(w, h, [fc - width / 2.0, fc + width / 2.0], [0.5, 0.5], title: "Band-pass even #{b.length - 1}", xlim: [-0.1, 1.1], ylim: [-0.1, 1.1], grid: true)
+
+b = Roctave.fir_band_pass((n & ~1) | 1, fc, width, window: :hamming)
+Roctave.stem(b, :filled, grid: true, title: "Band-pass odd #{b.length - 1}")
+w = Roctave.linspace(0.0, 1.0, 1024)
+h = Roctave.dft(b, 2048).abs[0...1024]
+Roctave.plot(w, h, [fc - width / 2.0, fc + width / 2.0], [0.5, 0.5], title: "Band-pass odd #{b.length - 1}", xlim: [-0.1, 1.1], ylim: [-0.1, 1.1], grid: true)
+
+b = Roctave.fir2(n, [0, fc-width/2, fc-width/2, fc+width/2, fc+width/2, 1], [0, 0, 1, 1, 0, 0])
+Roctave.stem(b, :filled, grid: true, title: "Band-pass fir2 #{b.length - 1}")
+w = Roctave.linspace(0.0, 1.0, 1024)
+h = Roctave.dft(b, 2048).abs[0...1024]
+Roctave.plot(w, h, [fc - width / 2.0, fc + width / 2.0], [0.5, 0.5], title: "Band-pass fir2 #{b.length - 1}", xlim: [-0.1, 1.1], ylim: [-0.1, 1.1], grid: true)
+

data/samples/firls.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/roctave.rb'
+
+## Low pass type I
+n = 128 
+delta = 0.05
+f = [(0 .. 0.4-2*delta), (0.4+0*delta .. 1)]
+a = [1, 0]
+w = [1, 1]
+b = Roctave.firls(n, f, a, w, :even_symmetry)
+
+Roctave.freqz(b, :magnitude)
+Roctave.stem(b)
+
+exit
+
+# ## Low pass type II
+# n = 11 
+# f = [(0 .. 0.3), (0.7 .. 1)]
+# a = [1, 0]
+# w = [2, 1]
+# b = Roctave.firls(n, f, a, w, :even_symmetry)
+
+# ## Differentiator type III
+# n = 10 
+# f = [0.05, 0.75]
+# a = [f]
+# w = [Roctave.linspace(f.first, f.last, 16).collect{|v| 1/v}]
+# b = Roctave.firls(n, f, a, w, 16, :odd_symmetry)
+
+# ## Hilbert transformer type IV
+# n = 11 
+# f = [1.0/8, 7.0/8]
+# a = [1]
+# w = [1]
+# b = Roctave.firls(n, f, a, w, :odd_symmetry)
+
+
+
+# r = Roctave.dft(b, 2048)
+# h = r[0..1024].abs
+# p = r[0..1024].arg
+# p = Roctave.unwrap(p)
+# w = Roctave.linspace(0, 1, 1025)
+# 
+# if (n & 1) == 0 then
+# 	Roctave.stem((-n/2..n/2).to_a, b, :filled, grid: true)
+# else
+# 	Roctave.stem((n+1).times.collect{|i| i - (n+1)/2.0 + 0.5}, b, :filled, grid: true)
+# end
+# Roctave.plot(w, p, grid: true, title: 'Phase')
+# Roctave.plot(w, h.collect{|v| 10*Math.log10(v)}, xlabel: 'Normalized frequency', ylabel: 'Magnitude response (dB)', grid: true, title: 'Magnitude')
+# Roctave.plot([0, 0.3], [1, 1], '-b', [0.7, 1], [0, 0], '-b', w, h, title: 'Magnitude response', xlim: (0 .. 1), grid: true)
+
+
+
+
+
+exit
+n = 4
+f = [(0 .. 0.4), (0.6 .. 1)]
+a = [1, 0]
+b = Roctave.firls(n, f, a, 1)
+exit
+
+n = 32
+grid = 8
+f = [[0.2, 0.3], [0.4, 0.6], [0.7, 0.8]]
+a = [
+	0.5,
+	Roctave.linspace(0, Math::PI, 64).collect{|t| 1 - Math.sin(t)},
+	(0.5 .. 0)
+]
+
+b = Roctave.firls(n, f, a, grid)
+