roctave 0.0.1

data/ext/roctave/iir_filter.h

@@ -0,0 +1,29 @@
+/* Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of Roctave
+ * 
+ * Roctave is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * Roctave 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 General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef IIR_FILTER_H
+#define IIR_FILTER_H
+
+#include <ruby.h>
+
+extern VALUE c_IIR;
+
+void Init_iir_filter();
+
+#endif /* IIR_FILTER_H */

data/ext/roctave/roctave.c

@@ -0,0 +1,38 @@
+/* Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of Roctave
+ * 
+ * Roctave is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * Roctave 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 General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+#include <ruby.h>
+#include "roctave.h"
+#include "fir_filter.h"
+#include "iir_filter.h"
+#include "cu8_file_reader.h"
+#include "freq_shifter.h"
+
+VALUE m_Roctave;
+
+void Init_roctave()
+{
+	m_Roctave = rb_const_get_at(rb_cObject, rb_intern("Roctave"));
+
+	Init_fir_filter();
+	Init_iir_filter();
+	Init_cu8_file_reader();
+	Init_freq_shifter();
+}
+

data/ext/roctave/roctave.h

@@ -0,0 +1,27 @@
+/* Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of Roctave
+ * 
+ * Roctave is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * Roctave 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 General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef ROCTAVE_H
+#define ROCTAVE_H
+
+#include <ruby.h>
+
+extern VALUE m_Roctave;
+
+#endif /* ROCTAVE_H */

data/lib/roctave.rb

@@ -0,0 +1,168 @@
+## Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+##
+## This file is part of Roctave
+## 
+## Roctave is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## Roctave 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 General Public License for more details.
+## 
+## You should have received a copy of the GNU General Public License
+## along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+
+
+module Roctave
+	##
+	# Return a row vector with +n+ linearly spaced elements between +base+
+    # and +limit+.
+	# @overload linspace(base, limit, nb_elem)
+	#  @param base [Numeric]
+	#  @param limit [Numeric]
+	#  @param nb_elem [Integer] number of elements
+	#  @return [Array<Numeric>]
+	# @overload linspace(range, nb_elem)
+	#  @param range [Range]
+	#  @param nb_elem [Integer] number of elements
+	#  @return [Array<Numeric>]
+	def self.linspace (base, limit = nil, nb_elem)
+		nb_elem = [1, nb_elem.to_i].max
+		if limit.nil? then
+			limit = base.end
+			exclude = base.exclude_end?
+			base = base.begin
+			limit -= (limit - base) / nb_elem.to_f if exclude
+		end
+		return [base] if nb_elem == 1
+		nm1 = (nb_elem - 1).to_f
+		(0...nb_elem).collect do |i|
+			base + i*(limit - base) / nm1
+		end
+	end
+
+
+	# @param n [Integer] the lenght of the array
+	# @return [Array<Float>]
+	def self.zeros (len)
+		len = [0, len.to_i].max
+		Array.new(len){0.0}
+	end
+
+
+	# @param n [Integer] the lenght of the array
+	# @return [Array<Float>]
+	def self.ones (len)
+		len = [0, len.to_i].max
+		Array.new(len){1.0}
+	end
+
+	##
+	# Unwrap radian phases by adding multiples of 2*pi as appropriate to
+	# remove jumps greater than TOL.
+	# 
+	# TOL defaults to pi.
+	# @param x [Array<Float>] Input
+	# @param tol [Float] Threshold detection level
+	# @return [Array<Float>]
+	def self.unwrap (x, tol = Math::PI)
+		raise ArgumentError.new "First argument must be an array" unless x.kind_of?(Array)
+		tol = tol.to_f.abs
+		rng = 2.0*Math::PI
+		d = (1...x.length).collect{|i| x[i] - x[i-1]}
+		p = d.collect do |e| 
+			v = (e.abs / rng).ceil * rng
+			if e > tol then
+				-v
+			elsif e < -tol then
+				v
+			else
+				0.0
+			end
+		end
+		r = Array.new(x.length){0.0}
+		p.each.with_index do |e, i|
+			r[i+1] = r[i] + e
+		end
+		r.collect.with_index{|e, i| e + x[i]}
+	end
+
+
+	##
+	# Append the scalar value C to the vector X until it is of length L.
+	# If C is not given, a value of 0 is used.
+	# 
+	# If 'length (X) > L', elements from the end of X are removed until a
+	# vector of length L is obtained.<Paste>
+	# @param x [Array<Numeric>] Input array
+	# @param l [Integer] The requested length
+	# @param c [Numeric] Value to pad with (default: 0.0)
+	def self.postpad(x, l, c = 0.0)
+		raise ArgumentError.new "First argument must be an array" unless x.kind_of?(Array)
+		l = [0, l.to_i].max
+		len = x.length
+		if l == len then
+			x = x.collect{|v| v}
+		elsif l < len then
+			x = x[0...l]
+		else
+			x = x + Array.new(l - len){c}
+		end
+		x
+	end
+
+end
+
+
+class Array
+	def abs
+		self.collect(&:abs)
+	end
+
+	def real
+		self.collect(&:real)
+	end
+
+	def imag
+		self.collect(&:imag)
+	end
+
+	def arg
+		#self.collect{|e| e.kind_of?(Complex) ? e.arg : Complex(e).arg}
+		self.collect(&:arg)
+	end
+
+	def conj
+		self.collect(&:conj)
+	end
+end
+
+require 'matrix'
+require_relative 'roctave/version.rb'
+require_relative 'roctave/roctave'
+require_relative 'roctave/window.rb'
+require_relative 'roctave/dft.rb'
+require_relative 'roctave/roots.rb'
+require_relative 'roctave/plot.rb'
+require_relative 'roctave/freqz.rb'
+require_relative 'roctave/interp1.rb'
+require_relative 'roctave/fir2.rb'
+require_relative 'roctave/fir1.rb'
+require_relative 'roctave/firls.rb'
+require_relative 'roctave/firpm.rb'
+require_relative 'roctave/fir_design.rb'
+require_relative 'roctave/finite_difference_coefficients.rb'
+require_relative 'roctave/sftrans.rb'
+require_relative 'roctave/bilinear.rb'
+require_relative 'roctave/poly.rb'
+require_relative 'roctave/butter.rb'
+require_relative 'roctave/cheby.rb'
+require_relative 'roctave/filter.rb'
+require_relative 'roctave/fir.rb'
+require_relative 'roctave/iir.rb'
+require_relative 'roctave/cu8_file_reader.rb'
+require_relative 'roctave/freq_shifter.rb'
+

data/lib/roctave/bilinear.rb

@@ -0,0 +1,92 @@
+## Copyright (C) 1999 Paul Kienzle <pkienzle@users.sf.net> (GNU Octave implementation)
+## Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+##
+## This file is part of Roctave
+## 
+## Roctave is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## Roctave 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 General Public License for more details.
+## 
+## You should have received a copy of the GNU General Public License
+## along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+
+
+module Roctave
+
+	##
+	# Transform a s-plane filter specification into a z-plane
+	# specification. Filter is specified in zero-pole-gain form.
+	# 1/T is the sampling frequency represented in the z plane.
+	#
+	# Note: this differs from the bilinear function in the signal processing
+	# toolbox, which uses 1/T rather than T.
+	#
+	# Theory: Given a piecewise flat filter design, you can transform it
+	# from the s-plane to the z-plane while maintaining the band edges by
+	# means of the bilinear transform.  This maps the left hand side of the
+	# s-plane into the interior of the unit circle.  The mapping is highly
+	# non-linear, so you must design your filter with band edges in the
+	# s-plane positioned at 2/T tan(w*T/2) so that they will be positioned
+	# at w after the bilinear transform is complete.
+	#
+	# Please note that a pole and a zero at the same place exactly cancel.
+	# This is significant since the bilinear transform creates numerous
+	# extra poles and zeros, most of which cancel. Those which do not
+	# cancel have a "fill-in" effect, extending the shorter of the sets to
+	# have the same number of as the longer of the sets of poles and zeros
+	# (or at least split the difference in the case of the band pass
+	# filter). There may be other opportunistic cancellations but I will
+	# not check for them.
+	#
+	# Also note that any pole on the unit circle or beyond will result in
+	# an unstable filter.  Because of cancellation, this will only happen
+	# if the number of poles is smaller than the number of zeros.  The
+	# analytic design methods all yield more poles than zeros, so this will
+	# not be a problem.
+	#
+	# References:
+	# Proakis & Manolakis (1992). Digital Signal Processing. New York:
+	# Macmillan Publishing Company.
+	#
+	# @param sz [Array<Numeric>] Zeros in the S-plane
+	# @param sp [Array<Numeric>] Poles in the S-plane
+	# @param sg [Numeric] Gain in the S-plane
+	# @param t [Numeric] The sampling period in the Z-plane
+	# @return [Array<Array, Numeric>] An array containing zeros, poles and gain in the Z-plane [zz, zp, zg]
+	def self.bilinear (sz, sp, sg, t)
+		p = sp.length
+		z = sz.length
+
+		if z > p or p == 0 then
+			raise ArgumentError.new "bilinear: must have at least as many poles as zeros in s-plane"
+		end
+
+		## ----------------  -------------------------  ------------------------ ##
+		## Bilinear          zero: (2+xT)/(2-xT)        pole: (2+xT)/(2-xT)      ##
+		##      2 z-1        pole: -1                   zero: -1                 ##
+		## S -> - ---        gain: (2-xT)/T             gain: (2-xT)/T           ##
+		##      T z+1                                                            ##
+		## ----------------  -------------------------  ------------------------ ##
+		zg = (sg * sz.inject(1.0){|m, v| m * ((2.0-v*t)/t)} / sp.inject(1.0){|m, v| m * ((2.0-v*t)/t)}).real
+		zp = sp.collect{|v| (2.0+v*t)/(2.0-v*t)}
+		if sz.empty? then
+			zz = Array.new(p){-1.0}
+		else
+			zz = sz.collect{|v| (2.0+v*t)/(2.0-v*t)}
+			if zz.length > p then
+				zz = zz[0...p]
+			elsif zz.length < p then
+				zz = zz + Array.new(p - zz.length){-1.0}
+			end
+		end
+
+		return [zz, zp, zg]
+	end
+end
+

data/lib/roctave/butter.rb

@@ -0,0 +1,87 @@
+## Copyright (C) 1999 Paul Kienzle <pkienzle@users.sf.net> (GNU Octave implementation)
+## Copyright (C) 2003 Doug Stewart <dastew@sympatico.ca> (GNU Octave implementation)
+## Copyright (C) 2011 Alexander Klein <alexander.klein@math.uni-giessen.de> (GNU Octave implementation)
+## Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+##
+## This file is part of Roctave
+## 
+## Roctave is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## Roctave 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 General Public License for more details.
+## 
+## You should have received a copy of the GNU General Public License
+## along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+
+
+module Roctave
+	# @!group IIR filters
+
+	##
+	# Generate a Butterworth filter.
+	# @param n [Integer] Filter order
+	# @param w [Float, Array<Float, Float>, Range] Normalized to [0 1] cutoff frequency. Either a single frequency, or an array of two frequencies for a pass/stop-band or a range.
+	# @param type [Symbol] Either :low, :high, :pass, :stop
+	# @return [Array<Array{Float}>] An array containing the b and a arrays of floats [b, a].
+	def self.butter(n, w, type = :low)
+		n = [1, n.to_i].max
+
+		case w
+		when Numeric
+			w = [[0.0, [1.0, w.to_f].min].max]
+		when Range
+			w = [[0.0, [1.0, w.begin.to_f].min].max, [0.0, [1.0, w.end.to_f].min].max].sort
+		when Array
+			raise ArgumentError.new "Argument 2 must have exactly two elements" unless w.length == 2
+			w = [[0.0, [1.0, w.first.to_f].min].max, [0.0, [1.0, w.last.to_f].min].max].sort
+		else
+			raise ArgumentError.new "Argument 2 must be a numeric, a two numeric array or a range"
+		end
+
+		stop = false
+		case type
+		when :low
+			stop = false
+		when :pass
+			stop = false
+		when :high
+			stop = true
+		when :stop
+			stop = true
+		else
+			raise ArgumentError.new "Argument 3 must be :low, :pass, :high or :stop"
+		end
+
+		## Prewarp to the band edges to s plane
+		t = 2.0 # sampling frequency of 2 Hz
+		w.collect!{|v| 2.0 / t * Math.tan(Math::PI * v / t)}
+
+		## Generate splane poles for the prototype Butterworth filter
+		## source: Kuc
+		c = 1.0 # default cutoff frequency
+		pole_s = (1..n).collect{|i| c * Complex.polar(1.0, Math::PI * (2.0 * i + n - 1) / (2 * n))}
+		if (n & 1) == 1 then
+			pole_s[(n + 1) / 2 - 1] = Complex(-1.0, 0.0) # pure real value at exp(i*pi)
+		end
+		zero_s = []
+		gain_s = (c**n).to_f;
+
+		## S-plane frequency transform
+		zero_s, pole_s, gain_s = Roctave.sftrans(zero_s, pole_s, gain_s, w, stop)
+
+		## Use bilinear transform to convert poles to the Z plane
+		zero_z, pole_z, gain_z = Roctave.bilinear(zero_s, pole_s, gain_s, t)
+
+		## Convert to the correct output form
+		b = Roctave.poly(zero_z).collect{|v| (gain_z * v).real}
+		a = Roctave.poly(pole_z).collect{|v| v.real}
+
+		return [b, a]
+	end
+end
+

data/lib/roctave/cheby.rb

@@ -0,0 +1,180 @@
+## Copyright (C) 1999 Paul Kienzle <pkienzle@users.sf.net> (GNU Octave implementation)
+## Copyright (C) 2003 Doug Stewart <dastew@sympatico.ca> (GNU Octave implementation)
+## Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+##
+## This file is part of Roctave
+## 
+## Roctave is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+## 
+## Roctave 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 General Public License for more details.
+## 
+## You should have received a copy of the GNU General Public License
+## along with Roctave. If not, see <https://www.gnu.org/licenses/>.
+
+
+module Roctave
+	# @!group IIR filters
+
+	##
+	# Generate a Chebyshev type I filter with rp dB of passband ripple.
+	# @param n [Integer] The filter order
+	# @param rp [Float] Peak-to-peak passband ripple. If positive, in dB, if negative, rp_dB = -20*log10(1-rp)
+	# @param wc [Float, Array<Float>, Range] The cutoff frequency normalized to [0 1], or the two band edges as an array or a range
+	# @param type [Symbol] Either :low, :high, :pass or :stop
+	# @return [Array<Array{Float}>] An array containing the numerator and denominator arrays of polynomial coefficients [b, a]
+	def self.cheby1 (n, rp, wc, type = :low)
+		n = [1, n.to_i].max
+
+		case wc
+		when Numeric
+			wc = [[0.0, [1.0, wc.to_f].min].max]
+		when Range
+			wc = [[0.0, [1.0, wc.begin.to_f].min].max, [0.0, [1.0, wc.end.to_f].min].max].sort
+		when Array
+			raise ArgumentError.new "Argument 3 must have exactly two elements" unless wc.length == 2
+			wc = [[0.0, [1.0, wc.first.to_f].min].max, [0.0, [1.0, wc.last.to_f].min].max].sort
+		else
+			raise ArgumentError.new "Argument 3 must be a numeric, a two numeric array or a range"
+		end
+		wc = wc.uniq
+		raise ArgumentError.new "All elemnts of W must be in the range [0, 1]" if wc.find{|v| v < 0.0 or v > 1.0}
+
+		stop = false
+		case type
+		when :low
+			stop = false
+		when :pass
+			stop = false
+		when :high
+			stop = true
+		when :stop
+			stop = true
+		else
+			raise ArgumentError.new "Argument 4 must be :low, :pass, :high or :stop"
+		end
+
+		raise ArgumentError.new "cheby1: passband ripple RP must be a non-zero scalar" unless (rp.is_a?(Float) and rp != 0.0)
+		rp = -20.0*Math.log10(1.0 + rp) if rp < 0.0
+
+		## Prewarp to the band edges to s plane
+		t = 2.0 # sampling frequency of 2 Hz
+		wc.collect!{|v| 2.0 / t * Math.tan(Math::PI * v / t)}
+
+		## Generate splane poles and zeros for the Chebyshev type 1 filter
+		c = 1.0  ## default cutoff frequency
+		epsilon = Math.sqrt(10**(rp / 10.0) - 1.0)
+		v0 = Math.asinh(1.0 / epsilon) / n
+		pole_s = (-(n-1) .. (n-1)).step(2).collect{|i| Complex.polar(1.0, Math::PI*i/(2.0*n))}
+		pole_s.collect!{|v| Complex(-Math.sinh(v0) * v.real, Math.cosh(v0) * v.imag)}
+		zero_s = []
+
+		## compensate for amplitude at s=0
+		gain_s = pole_s.inject(1.0){|m, v| m * (-v)}
+		## if n is even, the ripple starts low, but if n is odd the ripple
+		## starts high. We must adjust the s=0 amplitude to compensate.
+		gain_s = gain_s / 10**(rp / 20.0) if (n & 1) == 0
+
+		## S-plane frequency transform
+		zero_s, pole_s, gain_s = Roctave.sftrans(zero_s, pole_s, gain_s, wc, stop)
+
+		## Use bilinear transform to convert poles to the Z plane
+		zero_z, pole_z, gain_z = Roctave.bilinear(zero_s, pole_s, gain_s, t)
+
+		## Convert to the correct output form
+		b = Roctave.poly(zero_z).collect{|v| (gain_z * v).real}
+		a = Roctave.poly(pole_z).collect{|v| v.real}
+
+		return [b, a]
+	end
+
+
+	##
+	# Generate a Chebyshev type II filter with rs dB of stopband ripple.
+	# @param n [Integer] The filter order
+	# @param rs [Float] Peak-to-peak stopband ripple. If positive, in dB, if negative, rp_dB = -20*log10(1-rs)
+	# @param wc [Float, Array<Float>, Range] The cutoff frequency normalized to [0 1], or the two band edges as an array or a range
+	# @param type [Symbol] Either :low, :high, :pass or :stop
+	# @return [Array<Array{Float}>] An array containing the numerator and denominator arrays of polynomial coefficients [b, a]
+	def self.cheby2 (n, rs, wc, type = :low)
+		n = [1, n.to_i].max
+
+		case wc
+		when Numeric
+			wc = [[0.0, [1.0, wc.to_f].min].max]
+		when Range
+			wc = [[0.0, [1.0, wc.begin.to_f].min].max, [0.0, [1.0, wc.end.to_f].min].max].sort
+		when Array
+			raise ArgumentError.new "Argument 3 must have exactly two elements" unless wc.length == 2
+			wc = [[0.0, [1.0, wc.first.to_f].min].max, [0.0, [1.0, wc.last.to_f].min].max].sort
+		else
+			raise ArgumentError.new "Argument 3 must be a numeric, a two numeric array or a range"
+		end
+		wc = wc.uniq
+		raise ArgumentError.new "All elemnts of W must be in the range [0, 1]" if wc.find{|v| v < 0.0 or v > 1.0}
+
+		stop = false
+		case type
+		when :low
+			stop = false
+		when :pass
+			stop = false
+		when :high
+			stop = true
+		when :stop
+			stop = true
+		else
+			raise ArgumentError.new "Argument 4 must be :low, :pass, :high or :stop"
+		end
+
+		raise ArgumentError.new "cheby2: passband ripple RS must be a non-zero scalar" unless (rs.is_a?(Float) and rs != 0.0)
+		rs = -20.0*Math.log10(-rs) if rs < 0.0
+
+		## Prewarp to the band edges to s plane
+		t = 2.0 # sampling frequency of 2 Hz
+		wc.collect!{|v| 2.0 / t * Math.tan(Math::PI * v / t)}
+
+		## Generate splane poles and zeros for the Chebyshev type 2 filter
+		## From: Stearns, SD; David, RA; (1988). Signal Processing Algorithms.
+		##       New Jersey: Prentice-Hall.
+		c = 1.0  ## default cutoff frequency
+		lmbd = 10.0**(rs/20.0)
+		phi = Math.log(lmbd + Math.sqrt(lmbd**2 - 1)) / n
+		theta = (1..n).collect{|i| Math::PI*(i-0.5)/n}
+		alpha = theta.collect{|v| -Math.sinh(phi)*Math.sin(v)}
+		beta = theta.collect{|v| Math.cosh(phi)*Math.cos(v)}
+		if (n & 1) == 1 then
+			## drop theta==pi/2 since it results in a zero at infinity
+			zero_s = ((0...(n-1)/2).to_a + ((n+3)/2-1 ... n).to_a).collect{|i| Complex(0.0, c/Math.cos(theta[i]))}
+		else
+			zero_s = theta.collect{|v| Complex(0.0, c/Math.cos(v))}
+		end
+		pole_s = (0...n).collect{|i| c/(alpha[i]**2 + beta[i]**2)*Complex(alpha[i], -beta[i])}
+
+		## Compensate for amplitude at s=0
+		## Because of the vagaries of floating point computations, the
+		## prod(pole)/prod(zero) sometimes comes out as negative and
+		## with a small imaginary component even though analytically
+		## the gain will always be positive, hence the abs(real(...))
+		gain_s = (pole_s.inject(&:*) / zero_s.inject(&:*)).real.abs
+
+		## S-plane frequency transform
+		zero_s, pole_s, gain_s = Roctave.sftrans(zero_s, pole_s, gain_s, wc, stop)
+
+		## Use bilinear transform to convert poles to the Z plane
+		zero_z, pole_z, gain_z = Roctave.bilinear(zero_s, pole_s, gain_s, t)
+
+		## Convert to the correct output form
+		b = Roctave.poly(zero_z).collect{|v| (gain_z * v).real}
+		a = Roctave.poly(pole_z).collect{|v| v.real}
+
+		return [b, a]
+	end
+
+end
+