roctave 0.0.1

data/lib/roctave/poly.rb

@@ -0,0 +1,46 @@
+## Copyright (C) 1994-2015 John W. Eaton (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
+
+	##
+	# Returns the coefficients of the polynomial whose roots are the elements of the input array.
+	# @param x [Array<Numeric>] An array containing the roots of a polynomial
+	# @return [Array<Numeric>] An array containing coefficients of a polynomial whose roots are +x+.
+	def self.poly (x)
+		m = x.length
+
+		if m == 0 then
+			return [1.0]
+		else
+			v = x
+		end
+
+		y = Array.new(m+1){0.0}
+		y[0] = 1.0
+		(1..m).each do |j|
+			tmp = (1..j).collect{|i| y[i] - v[j-1]*y[i-1]}
+			y[1..j] = tmp
+		end
+
+		y
+	end
+
+end
+

data/lib/roctave/roots.rb

@@ -0,0 +1,73 @@
+## Copyright (C) 1994-2015 John W. Eaton (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
+
+	##
+	# Compute the roots of the polynomial C.
+	#
+	# For a vector C with N components, return the roots of the
+	# polynomial
+	# c(1) * x^(N-1) + ... + c(N-1) * x + c(N)
+	#
+	# @param v [Array<Numeric>] Coefficients of the polynomial. First element is the highest order
+	# @return [Array<Numeric>] Array containing the roots.
+	def self.roots (v)
+		n = v.length
+
+		## If v = [ 0 ... 0 v(k+1) ... v(k+l) 0 ... 0 ],
+		## we can remove the leading k zeros,
+		## and n - k - l roots of the polynomial are zero.
+
+		return [] if v.empty?
+
+		f = []
+		v.each_with_index do |e, i| 
+			f << i unless e.abs == 0.0
+		end
+		m = f.length
+		return [] if f.empty?
+				
+		v = v[f.first .. f.last]
+		l = v.length
+
+		if l > 1 then
+			a = Matrix.build(l-1, l-1) do |row, col|
+				if row == col + 1 then
+					1.0
+				elsif row == 0 then
+					-v[1+col].to_f / v[0]
+				else
+					0.0
+				end
+			end
+			d = a.eigen.d
+			r = (0...l-1).collect{|i| d[i, i]}
+			if (f[-1] + 1) < n then
+				r = r + Roctave.zeros(n - f[-1] - 1)
+			end
+		else
+			r = Roctave.zeros(n - f[-1] - 1)
+		end
+
+		r
+	end
+
+end
+

data/lib/roctave/sftrans.rb

@@ -0,0 +1,157 @@
+## Copyright (C) 1999-2001 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 band edges of a generic lowpass filter (cutoff at W=1)
+	# represented in splane zero-pole-gain form.  W is the edge of the
+	# target filter (or edges if band pass or band stop). Stop is true for
+	# high pass and band stop filters or false for low pass and band pass
+	# filters. Filter edges are specified in radians, from 0 to pi (the
+	# nyquist frequency).
+	#
+	# References:
+	#
+	# Proakis & Manolakis (1992). Digital Signal Processing. New York:
+	# Macmillan Publishing Company.
+	#
+	# @param sz [Array<Numeric>] Zeros in S plane
+	# @param sp [Array<Numeric>] Poless in S plane
+	# @param sg [Numeric] Gain in S plane
+	# @param w  [Array<Float>] Cuttoff frequency. It is an array of either one or two Floats
+	# @param stop  [Boolean] True for high pass and band stop, false for low pass and band pass
+	# @return [Array<Array{Numeric}>] An array of transformed zeros, poles and gain in the S plane [sz, sp, sg]
+	def self.sftrans(sz, sp, sg, w, stop)
+		case w
+		when Numeric
+			w = [w.to_f]
+		when Range
+			w = [w.begin.to_f, w.end.to_f].sort
+		when Array
+			case w.length
+			when 1
+				w = [w.first.to_f]
+			when 2
+				w = [w.first.to_f, w.last.to_f].sort
+			else
+				raise ArgumentError.new "Must specify at most 2 frequency band edges"
+			end
+		else
+			raise ArgumentError.new "w must be a Float, a Range or an array"
+		end
+		raise ArgumentError.new "band edges must not be equal" if w.length > 1 and w.first == w.last
+		stop = not(not(stop))
+
+		c = 1.0
+		p = sp.length
+		z = sz.length
+		if z > p or p == 0 then
+			raise ArgumentError.new "sftrans: must have at least as many poles as zeros in s-plane"
+		end
+
+		if w.length == 2 then
+			fl = w.first
+			fh = w.last
+			if stop then
+				## ----------------  -------------------------  ------------------------ ##
+				## Band Stop         zero: b ± sqrt(b^2-FhFl)   pole: b ± sqrt(b^2-FhFl) ##
+				##        S(Fh-Fl)   pole: ±sqrt(-FhFl)         zero: ±sqrt(-FhFl)       ##
+				## S -> C --------   gain: -x                   gain: -1/x               ##
+				##        S^2+FhFl   b=C/x (Fh-Fl)/2            b=C/x (Fh-Fl)/2          ##
+				## ----------------  -------------------------  ------------------------ ##
+				if sz.empty? then
+					sg = sg * (1.0 / sp.inject(1.0){|m, v| m * (-v)}).real
+				elsif sp.empty? then
+					sg = sg * (sz.inject(1.0){|m, v| m * (-v)}).real
+				else
+					sg = sg * (sz.inject(1.0){|m, v| m * (-v)} / sp.inject(1.0){|m, v| m * (-v)}).real
+				end
+				b = sp.collect{|v| (c*(fh-fl)/2.0)/v}
+				sp = b.collect{|v| v + Math.sqrt(v**2 - fh*fl)} + b.collect{|v| v - Math.sqrt(v**2 - fh*fl)}
+				ext = [Math.sqrt(Complex(-fh*fl)), -Math.sqrt(Complex(-fh*fl))]
+				if sz.empty? then
+					sz = (1 .. 2*p).collect{|i| ext[i % 2]}
+				else
+					b = sz.collect{|v| (c*(fh-fl)/2.0)/v}
+					sz = b.collect{|v| v + Math.sqrt(v**2-fh*fl)} + b.collect{|v| v - Math.sqrt(v**2-fh*fl)}
+					if p > z then
+						sz = sz + (1 .. 2*(p-z)).collect{|i| ext[i%2]}
+					end
+				end
+			else
+				## ----------------  -------------------------  ------------------------ ##
+				## Band Pass         zero: b ± sqrt(b^2-FhFl)   pole: b ± sqrt(b^2-FhFl) ##
+				##        S^2+FhFl   pole: 0                    zero: 0                  ##
+				## S -> C --------   gain: C/(Fh-Fl)            gain: (Fh-Fl)/C          ##
+				##        S(Fh-Fl)   b=x/C (Fh-Fl)/2            b=x/C (Fh-Fl)/2          ##
+				## ----------------  -------------------------  ------------------------ ##
+				sg = sg * (c/(fh-fl))**(z-p)
+				b = sp.collect{|v| v*((fh-fl)/(2.0*c))}
+				sp = b.collect{|v| v + Math.sqrt(v**2-fh*fl)} + b.collect{|v| v - Math.sqrt(v**2-fh*fl)}
+				if sz.empty? then
+					sz = Array.new(p){0.0}
+				else
+					b = sz.collect{|v| v*((fh-fl)/(2.0*c))}
+					sz = b.collect{|v| v + Math.sqrt(v**2-fh*fl)} + b.collect{|v| v - Math.sqrt(v**2-fh*fl)}
+					if p > z then
+						sz = sz + Array.new(p-z){0.0}
+					end
+				end
+			end
+		else
+			fc = w.first
+			if stop then
+				## ----------------  -------------------------  ------------------------ ## 
+				## High Pass         zero: Fc C/x               pole: Fc C/x             ##
+				## S -> C Fc/S       pole: 0                    zero: 0                  ##
+				##                   gain: -x                   gain: -1/x               ##
+				## ----------------  -------------------------  ------------------------ ##
+				if sz.empty? then
+					sg = sg * (1.0 / sp.inject(1.0){|m, v| m * (-v)}).real
+				elsif sp.empty? then
+					sg = sg * sz.inject(1.0){|m, v| m * (-v)}.real
+				else
+					sg = sg * (sz.inject(1.0){|m, v| m * (-v)} / sp.inject(1.0){|m, v| m * (-v)}).real
+				end
+				sp = sp.collect{|v| c*fc/v}
+				if sz.empty? then
+					sz = Array.new(p){0.0}
+				else
+					sz = sz.collect{|v| c*fc/v}
+					if p > z then
+						sz = sz + Array.new(p-z){0.0}
+					end
+				end
+			else
+				## ----------------  -------------------------  ------------------------ ##
+				## Low Pass          zero: Fc x/C               pole: Fc x/C             ##
+				## S -> C S/Fc       gain: C/Fc                 gain: Fc/C               ##
+				## ----------------  -------------------------  ------------------------ ##
+				sg = sg * (c/fc)**(z-p)
+				sp = sp.collect{|v| fc * v / c}
+				sz = sz.collect{|v| fc * v / c}
+			end
+		end
+
+		return [sz, sp, sg]
+	end
+
+end
+

data/lib/roctave/version.rb

@@ -0,0 +1,3 @@
+module Roctave
+	VERSION = '0.0.1'
+end

data/lib/roctave/window.rb

@@ -0,0 +1,116 @@
+## 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 Windows
+
+	##
+	# Hann window
+	# @param n [Integer] Length of the window
+	# @return [Array<Float>]
+	def self.hann (n)
+		n = [1, n.to_i].max
+		t = n - 1
+		(0...n).collect{|i| 0.5 - 0.5*Math.cos(2.0*Math::PI*i/t)}
+	end
+
+
+	##
+	# Hamming window
+	# @param n [Integer] Length of the window
+	# @return [Array<Float>]
+	def self.hamming (n)
+		n = [1, n.to_i].max
+		t = n - 1
+		(0...n).collect{|i| 0.54 - 0.46*Math.cos(2.0*Math::PI*i/t)}
+	end
+
+
+	##
+	# Blackman window
+	# @param n [Integer] Length of the window
+	# @param alpha [Float]
+	# @return [Array<Float>]
+	def self.blackman (n, alpha = 0.16)
+		n = [1, n.to_i].max
+		t = n - 1
+		#(0...n).collect{|i| 0.42 - 0.5*Math.cos(2.0*Math::PI*i/t) + 0.08*Math.cos(4.0*Math::PI*i/t)}
+		a0 = (1.0 - alpha) / 2.0
+		a1 = 0.5
+		a2 = alpha / 2.0
+		(0...n).collect{|i| a0 - a1*Math.cos(2.0*Math::PI*i/t) + a2*Math.cos(4.0*Math::PI*i/t)}
+	end
+
+
+	##
+	# Nuttall window
+	# @param n [Integer] Length of the window
+	# @return [Array<Float>]
+	def self.nuttall (n)
+		n = [1, n.to_i].max
+		t = n - 1
+		a0 = 0.355768
+		a1 = 0.487396
+		a2 = 0.144232
+		a3 = 0.012604
+		(0...n).collect{|i| a0 - a1*Math.cos(2.0*Math::PI*i/t) + a2*Math.cos(4.0*Math::PI*i/t) - a3*Math.cos(6.0*Math::PI*i/t)}
+	end
+
+
+	##
+	# Blackman-Nuttall window
+	# @param n [Integer] Length of the window
+	# @return [Array<Float>]
+	def self.blackman_nuttall (n)
+		n = [1, n.to_i].max
+		t = n - 1
+		a0 = 0.3635819
+		a1 = 0.4891775
+		a2 = 0.1365995
+		a3 = 0.0106411
+		(0...n).collect{|i| a0 - a1*Math.cos(2.0*Math::PI*i/t) + a2*Math.cos(4.0*Math::PI*i/t) - a3*Math.cos(6.0*Math::PI*i/t)}
+	end
+
+
+	##
+	# Blackman-Harris window
+	# @param n [Integer] Length of the window
+	# @return [Array<Float>]
+	def self.blackman_harris (n)
+		n = [1, n.to_i].max
+		t = n - 1
+		a0 = 0.35875
+		a1 = 0.48829
+		a2 = 0.14128
+		a3 = 0.01168
+		(0...n).collect{|i| a0 - a1*Math.cos(2.0*Math::PI*i/t) + a2*Math.cos(4.0*Math::PI*i/t) - a3*Math.cos(6.0*Math::PI*i/t)}
+	end
+
+
+	##
+	# Gaussian window
+	# @param n [Integer] Length of the window
+	# @param sigma [Float] The standard deviation of the Gaussian function is sigma*N/2 sampling periods.
+	# @return [Array<Float>]
+	def self.gaussian (n, sigma = 0.4)
+		n = [1, n.to_i].max
+		t = n - 1
+		(0...n).collect{|i| Math.exp(-0.5*((i - t/2.0)/(sigma*t/2.0))**2)}
+	end
+end
+

data/roctave.gemspec

@@ -0,0 +1,79 @@
+require File.expand_path('../lib/roctave/version', __FILE__)
+
+Gem::Specification.new do |s|
+	s.name = "roctave"
+	s.version = Roctave::VERSION
+	s.date = Time.now.strftime '%Y-%m-%d'
+	s.summary = "Some Matlab / Gnu Octave functions implemented in Ruby."
+	s.description = "Roctave is an attempt to provide some Matlab / Gnu Octave functions in a Ruby gem to generate and analyze digital filters."
+	s.license = 'GPL-3.0+'
+	s.authors = ["Théotime Bollengier"]
+	s.email = 'theotime.bollengier@gmail.com'
+	s.homepage = 'https://gitlab.com/theotime_bollengier/roctave'
+	s.add_runtime_dependency 'gnuplot', '~> 2.6', '>= 2.6.2'
+	s.files = [
+		'LICENSE',
+		'README.md',
+		'roctave.gemspec',
+		'ext/roctave/extconf.rb',
+		'ext/roctave/roctave.c',
+		'ext/roctave/roctave.h',
+		'ext/roctave/fir_filter.c',
+		'ext/roctave/fir_filter.h',
+		'ext/roctave/iir_filter.c',
+		'ext/roctave/iir_filter.h',
+		'ext/roctave/cu8_file_reader.c',
+		'ext/roctave/cu8_file_reader.h',
+		'ext/roctave/freq_shifter.c',
+		'ext/roctave/freq_shifter.h',
+		'lib/roctave.rb',
+		'lib/roctave/version.rb',
+		'lib/roctave/bilinear.rb',
+		'lib/roctave/butter.rb',
+		'lib/roctave/cheby.rb',
+		'lib/roctave/dft.rb',
+		'lib/roctave/finite_difference_coefficients.rb',
+		'lib/roctave/fir1.rb',
+		'lib/roctave/fir2.rb',
+		'lib/roctave/fir_design.rb',
+		'lib/roctave/firls.rb',
+		'lib/roctave/firpm.rb',
+		'lib/roctave/filter.rb',
+		'lib/roctave/fir.rb',
+		'lib/roctave/iir.rb',
+		'lib/roctave/cu8_file_reader.rb',
+		'lib/roctave/freq_shifter.rb',
+		'lib/roctave/freqz.rb',
+		'lib/roctave/interp1.rb',
+		'lib/roctave/plot.rb',
+		'lib/roctave/poly.rb',
+		'lib/roctave/roots.rb',
+		'lib/roctave/sftrans.rb',
+		'lib/roctave/window.rb',
+		'samples/butter.rb',
+		'samples/cheby.rb',
+		'samples/dft.rb',
+		'samples/differentiator_frequency_scaling.rb',
+		'samples/differentiator.rb',
+		'samples/fft.rb',
+		'samples/finite_difference_coefficient.rb',
+		'samples/fir1.rb',
+		'samples/fir2bank.rb',
+		'samples/fir2.rb',
+		'samples/fir2_windows.rb',
+		'samples/fir_low_pass.rb',
+		'samples/firls.rb',
+		'samples/firpm.rb',
+		'samples/hilbert_transformer_frequency_scaling.rb',
+		'samples/hilbert_transformer.rb',
+		'samples/plot.rb',
+		'samples/stem.rb',
+		'samples/type1.rb',
+		'samples/type3.rb',
+		'samples/windows.rb'
+	]
+	s.extensions = [
+		'ext/roctave/extconf.rb'
+	]
+end
+