roctave 0.0.1

data/lib/roctave/cu8_file_reader.rb

@@ -0,0 +1,45 @@
+## 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
+	class CU8FileReader
+		# Read the content of the file as couples of real and imaginary unsigned chars,
+		# and return an array of complex numbers whose real and imaginary parts are floating
+		# point numbers in the range [-1.0, 1.0]
+		# @param filename [String] the path of the file to read
+		# @return [Array<Float>] array of complex numbers read from the file
+		def self.read (filename)
+			reader = Roctave::CU8FileReader.new(filename)
+			arr = reader.read
+			reader.close
+			return arr
+		end
+
+
+		# Creates a new CU8FileReader with the given file name, yields it,
+		# then close it and return the result of the block.
+		# @param filename [String] the path of the file to read
+		def self.open (filename)
+			reader = Roctave::CU8FileReader.new(filename)
+			res = yield(reader)
+			reader.close
+			return res
+		end
+	end
+end
+

data/lib/roctave/dft.rb

@@ -0,0 +1,280 @@
+## 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 Fourier transform
+
+	##
+	# Compute the discrete Fourier transform of +x+.
+	# If called with two arguments, +n+ is expected to be an integer
+	# specifying the number of elements of +x+ to use.
+	# If +n+ is larger than the length of +x+, then +x+ is resized
+	# and padded with zeros.  Otherwise, if +n+ is smaller than the
+	# length of +x+, then +x+ is truncated.
+	# @param x [Array<Float>, Array<Complex>] The input signal.
+	# @param n [Integer, nil] The length of the DFT, defaults to the lengs of +x+.
+	# @param window [Array<Float>, Symbol] Premultiply the input signal by the window, eigher an array of length +n+, or a window symbol (ex: :blackman).
+	# @param normalize [Boolean] Divide the output by the area under the window.
+	# @return [Array<Complex>] The result of the DFT.
+	def self.dft (x, n = nil, window: nil, normalize: false)
+		xlen = x.length
+		if n then
+			n = [1, n.to_i].max 
+			len = n
+			xlen = [xlen, n].min
+		else
+			len = x.length
+		end
+		return Roctave.fft(x, n, window: window, normalize: normalize) if Math.log2(len).floor == Math.log2(len) 
+
+		case window
+		when Array
+			raise ArgumentError.new "The window must have the same size as the input array" if window.length < xlen
+			x = (0...xlen).collect{|i| x[i] * window[i]}
+		when Symbol
+			window = Roctave.send(window, xlen)
+			x = (0...xlen).collect{|i| x[i] * window[i]}
+		when nil
+		else
+			raise ArgumentError.new "The window must an array or a symbol"
+		end
+
+		if normalize then
+			if window then
+				factor = window.inject(&:+).to_f
+			else
+				factor = xlen.to_f
+			end
+		else
+			factor = 1.0
+		end
+
+		y = (0...len).collect do |k|
+			acc = Complex(0)
+			(0...xlen).each do |i|
+				acc += Complex.polar(1.0, -2.0*Math::PI*k*i / len) * x[i]
+			end
+			acc / factor
+		end
+		y
+	end
+
+
+	##
+	# Compute the inverse discrete Fourier transform of +x+.
+	# If called with two arguments, +n+ is expected to be an integer
+	# specifying the number of elements of +x+ to use.
+	# If +n+ is larger than the length of +x+, then +x+ is resized
+	# and padded with zeros.  Otherwise, if +n+ is smaller than the
+	# length of +x+, then +x+ is truncated.
+	# @param x [Array<Float>, Array<Complex>] The input signal.
+	# @param n [Integer, nil] The length of the DFT, defaults to the lengs of +x+.
+	# @return [Array<Complex>] The result of the DFT.
+	def self.idft (x, n = nil)
+		xlen = x.length
+		if n then
+			n = [1, n.to_i].max 
+			len = n
+			xlen = [xlen, n].min
+		else
+			len = x.length
+		end
+		return Roctave.ifft(x, n) if Math.log2(len).floor == Math.log2(len) 
+
+
+		y = (0...len).collect do |k|
+			acc = Complex(0)
+			(0...xlen).each do |i|
+				acc += Complex.polar(1.0, 2.0*Math::PI*k*i / len) * x[i]
+			end
+			acc / len
+		end
+		y
+	end
+
+
+	##
+	# same as +dft+, but computes ~30x faster.
+	# The length of the FFT is rounded to the neareast power of two.
+	# @see dft
+	def self.fft(x, n = nil, window: nil, normalize: false)
+		if n then
+			len = [1, n.to_i].max
+		else
+			len = x.length
+		end
+		prevpow2 = 2**(Math.log2(len).floor)
+		nextpow2 = 2**(Math.log2(len).ceil)
+		if (nextpow2 - len) <= (len - prevpow2) then
+			len = nextpow2
+		else
+			len = prevpow2
+		end
+		wlen = [x.length, len].min
+
+		case window
+		when Array
+			raise ArgumentError.new "The window must be of size #{wlen}" unless window.length == wlen
+			x = (0...wlen).collect{|i| x[i] * window[i]}
+		when Symbol
+			window = Roctave.send(window, wlen)
+			x = (0...wlen).collect{|i| x[i] * window[i]}
+		when nil
+		else
+			raise ArgumentError.new "The window must be an array or a symbol"
+		end
+
+		if x.length != len then
+			x = (0...len).collect{|i| x[i].nil? ? 0.0 : x[i]}
+		end
+
+		y = iterative_fft(x)
+
+		if normalize then
+			if window then
+				factor = window.inject(&:+).to_f
+			else
+				factor = wlen.to_f
+			end
+			y.collect!{|v| v / factor}
+		end
+
+		y
+	end
+
+
+	##
+	# Used internaly. Use Roctave.fft instead of calling directly this function.
+	# Implements the Cooley-Tukey FFT
+	def self.iterative_fft (arr_in)
+		## Implementation from https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm 2019-06-11
+		n = arr_in.length
+		nbl = Math.log2(n)
+		raise ArgumentError.new "Input array must have a length power of two" if nbl.floor != nbl
+		nbl = nbl.to_i
+
+		## bit-reverse copy
+		arr = (0...n).collect do |i|
+			arr_in[i.to_s(2).rjust(nbl, '0').reverse.to_i(2)]
+		end
+
+		(1..nbl).each do |s|
+			m = 2**s
+			wm = Complex.polar(1.0, -2.0*Math::PI/m)
+			(0...n).step(m).each do |k|
+				w = Complex(1.0)
+				(0 ... m/2).each do |j|
+					t = w*arr[k+j+m/2]
+					u = arr[k+j]
+					arr[k+j] = u + t
+					arr[k+j+m/2] = u - t
+					w = w * wm
+				end
+			end
+		end
+
+		arr
+	end
+
+
+	# @param x [Array]
+	# @return [Array]
+	def self.fftshift (x)
+		xl = x.length
+		xx = (xl / 2.0).ceil
+		y = Array(xl)
+		i = 0
+		(xx...xl).each do |j|
+			y[i] = x[j]
+			i += 1
+		end
+		(0...xx).each do |j|
+			y[i] = x[j]
+			i += 1
+		end
+		y
+	end
+
+
+	##
+	# same as +idft+, but computes ~30x faster.
+	# The length of the iFFT is rounded to the neareast power of two.
+	# @see dft
+	def self.ifft(x, n = nil, normalized_input: false)
+		if n then
+			len = [1, n.to_i].max
+		else
+			len = x.length
+		end
+		prevpow2 = 2**(Math.log2(len).floor)
+		nextpow2 = 2**(Math.log2(len).ceil)
+		if (nextpow2 - len) <= (len - prevpow2) then
+			len = nextpow2
+		else
+			len = prevpow2
+		end
+		wlen = [x.length, len].min
+
+		if x.length != len then
+			x = (0...len).collect{|i| x[i].nil? ? 0.0 : x[i]}
+		end
+
+		y = iterative_ifft(x)
+
+		unless normalized_input then
+			y.collect!{|v| v / len}
+		end
+
+		y
+	end
+
+
+	##
+	# Used internaly. Use Roctave.fft instead of calling directly this function.
+	# Implements the Cooley-Tukey FFT
+	def self.iterative_ifft (arr_in)
+		## Implementation from https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm 2019-06-11
+		n = arr_in.length
+		nbl = Math.log2(n)
+		raise ArgumentError.new "Input array must have a length power of two" if nbl.floor != nbl
+		nbl = nbl.to_i
+
+		## bit-reverse copy
+		arr = (0...n).collect do |i|
+			arr_in[i.to_s(2).rjust(nbl, '0').reverse.to_i(2)]
+		end
+
+		(1..nbl).each do |s|
+			m = 2**s
+			wm = Complex.polar(1.0, 2.0*Math::PI/m)
+			(0...n).step(m).each do |k|
+				w = Complex(1.0)
+				(0 ... m/2).each do |j|
+					t = w*arr[k+j+m/2]
+					u = arr[k+j]
+					arr[k+j] = u + t
+					arr[k+j+m/2] = u - t
+					w = w * wm
+				end
+			end
+		end
+
+		arr
+	end
+end
+

data/lib/roctave/filter.rb

@@ -0,0 +1,64 @@
+## 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
+	module Filter
+		# @param flt [Roctave::FirFilter, Roctave::IirFilter]
+		# @return [Roctave::FirFilter, Roctave::IirFilter]
+		def cascade (flt)
+			my_b = numerator
+			my_a = denominator
+
+			his_b = flt.numerator
+			his_a = flt.denominator
+
+			c = my_b
+			d = his_b
+			len = c.length + d.length - 1
+			d = len.times.collect do |i|
+				([0, i - d.length + 1].max .. [c.length - 1, i].min).inject(0.0){|sum, k| sum + c[k]*d[i-k]}
+			end
+			b = d
+
+			c = my_a
+			d = his_a
+			len = c.length + d.length - 1
+			d = len.times.collect do |i|
+				([0, i - d.length + 1].max .. [c.length - 1, i].min).inject(0.0){|sum, k| sum + c[k]*d[i-k]}
+			end
+			a = d
+
+			b.collect!{|v| v/ a[0]}
+			a.collect!{|v| v/ a[0]}
+
+			fir = true
+			a[1..-1].each do |v|
+					fir = false if v != 0.0
+			end
+
+			if fir then
+				r = Roctave::FirFilter.new(b)
+			else
+				r = Roctave::IirFilter.new(b, a)
+			end
+
+			r
+		end
+	end
+end
+

data/lib/roctave/finite_difference_coefficients.rb

@@ -0,0 +1,73 @@
+## Copyright (C) 2000 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
+	# @!group FIR filters
+	
+	##
+	# Finite difference equations enable you to take derivatives of any order
+	# at any point using any given sufficiently large selection of points.
+	# By inputting the locations of your sampled points,
+	# this function generates a finite difference equation which will 
+	# approximate the derivative at any desired location. 
+	#
+	# Taken from 
+	# https://en.wikipedia.org/wiki/Finite_difference_coefficient
+	# and
+	# http://web.media.mit.edu/~crtaylor/calculator.html
+	#
+	# @param s [Array<Float>, Range] Location of sample points, given as an array ex: [-3, -1, 0, 2], or a range ex: (-2 ... 1) which is equivalent to [-2, -1, 0, 1]
+	# @param d [Integer] Derivative order
+	# @param fs [Float] Sampling frequency
+	# @return [Array<Float>] The coefficients
+	def self.finite_difference_coefficients (s, d = 1, fs = 1.0)
+		case s
+		when Range
+			s = Range.new([s.begin, s.end].min.to_i, [s.begin, s.end].max.to_i).to_a.collect{|e| e.to_f}
+		when Array
+			s = s.collect{|e| e.to_f}.sort.uniq
+		else
+			raise ArgumentError.new "Location of sample points must be an array of integers, or a range"
+		end
+		d = [1, d.to_i].max
+		fs = fs.to_f
+		len = s.length 
+		raise ArgumentError.new "Please enter a derivative order that is less than the number of points in your stencil." if d >= len 
+
+		y = Matrix.build(len, 1) do |row, col|
+			if row == d then
+				## d! / h^d
+				(1..d).inject(&:*) * fs**d
+			else
+				0.0
+			end
+		end
+
+		a = Matrix.build(len) do |row, col|
+			s[col]**row
+		end
+
+		a_inv = a.inverse
+
+		x = a_inv * y
+
+		x.to_a.flatten.reverse
+	end
+end
+