roctave 0.0.1

data/lib/roctave/fir_design.rb

@@ -0,0 +1,311 @@
+## 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
+
+	##
+	# @param n [Integer] The filter order
+	# @param f [Float] Cutoff frequency in the range [0 1] maping to w = [0 pi]
+	# @param window [Array<Float>, Symbol] The window to use, either an array of length N+1, or a symbol. Defaults to :hamming
+	# @return [Array<Float>] The filter coefficients B
+	def self.fir_low_pass (n, f, window: :hamming)
+		f = [0.0, [1.0, f.to_f].min].max
+		n = [1, n.to_i].max
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		f *= Math::PI
+		b = (0...len).collect do |i|
+			j = i - n/2.0
+			if j == 0.0 then
+				f / Math::PI
+			else
+				Math.sin(f*j) / (Math::PI*j)
+			end
+		end
+
+		b.collect!.with_index{|e, i| e*window[i]} if window
+
+		b
+	end
+
+
+	##
+	# @param n [Integer] The filter order, must be even
+	# @param f [Float] Cutoff frequency in the range [0 1] maping to w = [0 pi]
+	# @param window [Array<Float>, Symbol] The window to use, either an array of length N+1, or a symbol. Defaults to :hamming
+	# @return [Array<Float>] The filter coefficients B
+	def self.fir_high_pass (n, f, window: :hamming)
+		f = [0.0, [1.0, f.to_f].min].max
+		n = [1, n.to_i].max
+		if (n & 1) != 0 then
+			n += 1
+			STDERR.puts "WARNING: #{self.class}::#{__method__}() Order must be even, incrementing to #{n}"
+		end
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		f *= Math::PI
+		b = (0...len).collect do |i|
+			j = i - n/2.0
+			if j == 0.0 then
+				1.0 - f / Math::PI
+			else
+				-Math.sin(f*j) / (Math::PI*j)
+			end
+		end
+
+		b.collect!.with_index{|e, i| e*window[i]} if window
+
+		b
+	end
+
+
+	##
+	# @param n [Integer] The filter order, must be even
+	# @param f [Float, Array<Float, Float>, Range] Either a two elements array or a range defining the band edges, or the center frequency (in that case +width+ must be specified). Frequencies must be the range [0 1] maping to w = [0 pi]
+	# @param width [Float] Width around the ceter frequency +f+, maping to w = [0 pi]
+	# @param window [Array<Float>, Symbol] The window to use, either an array of length N+1, or a symbol. Defaults to :hamming
+	# @return [Array<Float>] The filter coefficients B
+	def self.fir_band_stop (n, f, width = nil, window: :hamming)
+		if f.kind_of?(Array) then
+			raise ArgumentError.new "Second element must be a two element array containing band edges or the center frequency" unless f.length == 2
+			f1 = f.first
+			f2 = f.last
+			raise ArgumentError.new "Width around the center frequeny is not used when band edges are specified with an array" unless width.nil?
+		elsif f.kind_of?(Range) then
+			f1 = f.begin
+			f2 = f.end
+			raise ArgumentError.new "Width around the center frequeny is not used when band edges are specified with an range" unless width.nil?
+		elsif f.kind_of?(Numeric) then
+			raise ArgumentError.new "You must specify the Width around the center frequeny when the center frequency is specified as a scalar" unless width.kind_of?(Float)
+			f = [0.0, [1.0, f.to_f].min].max
+			width = [0.0, [2.0, width.to_f].min].max / 2.0
+			f1 = f - width
+			f2 = f + width
+		else
+			raise ArgumentError.new "Second argument must be a scalar, an array or a range"
+		end
+
+		f1 = [0.0, [1.0, f1.to_f].min].max
+		f2 = [0.0, [1.0, f2.to_f].min].max
+		f1,f2 = f2,f1 if f1 > f2
+		n = [1, n.to_i].max
+		if (n & 1) != 0 then
+			n += 1
+			STDERR.puts "WARNING: #{self.class}::#{__method__}() Order must be even, incrementing to #{n}"
+		end
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		bl = Roctave.fir_low_pass(n, f1, window: window)
+		bh = Roctave.fir_high_pass(n, f2, window: window)
+
+		(0...len).collect{|i| bl[i] + bh[i]}
+	end
+
+
+	##
+	# @param n [Integer] The filter order, must be even
+	# @param f [Float, Array<Float, Float>, Range] Either a two elements array or a range defining the band edges, or the center frequency (in that case +width+ must be specified). Frequencies must be the range [0 1] maping to w = [0 pi]
+	# @param width [Float] Width around the ceter frequency +f+, maping to w = [0 pi]
+	# @param window [Array<Float>, Symbol] The window to use, either an array of length N+1, or a symbol. Defaults to :hamming
+	# @return [Array<Float>] The filter coefficients B
+	def self.fir_band_pass (n, f, width = nil, window: :hamming)
+		if f.kind_of?(Array) then
+			raise ArgumentError.new "Second element must be a two element array containing band edges or the center frequency" unless f.length == 2
+			f1 = f.first
+			f2 = f.last
+			raise ArgumentError.new "Width around the center frequeny is not used when band edges are specified with an array" unless width.nil?
+		elsif f.kind_of?(Range) then
+			f1 = f.begin
+			f2 = f.end
+			raise ArgumentError.new "Width around the center frequeny is not used when band edges are specified with an range" unless width.nil?
+		elsif f.kind_of?(Numeric) then
+			raise ArgumentError.new "You must specify the Width around the center frequeny when the center frequency is specified as a scalar" unless width.kind_of?(Float)
+			f = [0.0, [1.0, f.to_f].min].max
+			width = [0.0, [2.0, width.to_f].min].max / 2.0
+			f1 = f - width
+			f2 = f + width
+		else
+			raise ArgumentError.new "Second argument must be a scalar, an array or a range"
+		end
+
+		f1 = [0.0, [1.0, f1.to_f].min].max
+		f2 = [0.0, [1.0, f2.to_f].min].max
+		f1,f2 = f2,f1 if f1 > f2
+		n = [1, n.to_i].max
+		parity = ((n & 1) == 0) ? :even : :odd
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		if parity == :even then
+			b = Roctave.fir_band_stop(n, [f1, f2], window: window)
+			b.collect!.with_index do |e, i|
+				r = -e
+				r += 1 if i == n / 2.0
+				r
+			end
+		else
+			bl = Roctave.fir_low_pass(n, f1, window: window)
+			bh = Roctave.fir_low_pass(n, f2, window: window)
+
+			b = (0...len).collect{|i| bh[i] - bl[i]}
+		end
+
+		b
+	end
+
+
+	def self.fir_differentiator (n, window: :blackman)
+		n = [2, n.to_i].max
+		if (n & 1) != 0 then
+			n += 1
+			STDERR.puts "WARNING: #{self.name}::#{__method__}() Forcing type III FIR filter, order must be even, incrementing to #{n}."
+		end
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		b = (-n/2 .. n/2).collect do |i|
+			if i == 0 then
+				0.0
+			else
+				(-1)**i / i.to_f
+			end
+		end
+
+		b.collect!.with_index{|e, i| e*window[i]} if window
+
+		b
+	end
+
+
+	def self.fir_hilbert (n, window: :hamming)
+		n = [2, n.to_i].max
+		if (n & 1) != 0 then
+			n += 1
+			STDERR.puts "WARNING: #{self.name}::#{__method__}() Forcing type III FIR filter, order must be even, incrementing to #{n}."
+		end
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		b = (-n/2 .. n/2).collect do |i|
+			if i == 0 then
+				0.0
+			else
+				(1 - (-1)**i) / (Math::PI * i)
+			end
+		end
+
+		b.collect!.with_index{|e, i| e*window[i]} if window
+
+		b
+	end
+
+
+	##
+	# Not very usefull, not better than fir_differentiator()
+	# @param fc [Float] Normalized cutoff frequency in the range [0 0.5]
+	def self.fir_differentiator_low_pass (n, fc = 0.5, window: :hamming)
+		fc = [0.0, [0.5, fc.to_f].min].max
+		n = [2, n.to_i].max
+		if (n & 1) != 0 then
+			n += 1
+			STDERR.puts "WARNING: #{self.name}::#{__method__}() Forcing type III FIR filter, order must be even, incrementing to #{n}."
+		end
+		len = n + 1
+
+		case window
+		when Array
+			raise ArgumentError.new "Window array must be of length #{len}" unless window.length == len
+		when Symbol
+			window = self.send(window, len)
+		when nil
+		else
+			raise ArgumentError.new "Window must either be an array of length N+1 or the symbol of a window"
+		end
+
+		b = (-n/2 .. n/2).collect do |i|
+			if i == 0 then
+				0.0
+			else
+				-2.0/(Math::PI*i*i)*Math.sin(Math::PI*i*fc)*(1.0 - Math.cos(Math::PI*i*fc))
+			end
+		end
+
+		b.collect!.with_index{|e, i| e*window[i]} if window
+
+		b
+	end
+end
+

data/lib/roctave/firls.rb

@@ -0,0 +1,380 @@
+## 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/>.
+
+
+# class Matrix
+# 	def puts
+# 		strings = Array.new(self.row_size){Array.new(self.column_size)}
+# 		(0 ... self.row_size).each do |i|
+# 			(0 ... self.column_size).each do |j|
+# 				strings[i][j] = self[i, j].round(4).to_s
+# 			end
+# 		end
+# 		maxstrlen = strings.flatten.collect{|s| s.length + 2}.max
+# 		Kernel.puts
+# 		(0 ... self.row_size).each do |i|
+# 			if i == 0 and i == self.row_size - 1 then
+# 				print ' ['
+# 			elsif i == 0 then
+# 				print ' ⎡'
+# 			elsif i == self.row_size - 1 then
+# 				print ' ⎣'
+# 			else
+# 				print ' ⎢'
+# 			end
+# 
+# 			(0 ... self.column_size).each do |j|
+# 				print strings[i][j].center(maxstrlen)
+# 			end
+# 
+# 			if i == 0 and i == self.row_size - 1 then
+# 				Kernel.puts ']'
+# 			elsif i == 0 then
+# 				Kernel.puts '⎤'
+# 			elsif i == self.row_size - 1 then
+# 				Kernel.puts '⎦'
+# 			else
+# 				Kernel.puts '⎥'
+# 			end
+# 		end
+# 		Kernel.puts
+# 	end
+# end
+
+
+module Roctave
+	# @!group FIR filters
+
+	##
+	# Weighted least-squares method for FIR filter approximation by optimization.
+	# Minimizes the square of the energy of the error function.
+	# @param n [Integer] The filter order
+	# @param f [Array<Float, Array<Float>, Range>] Frequency band edges, onced flattened, must be of even length
+	# @param a [Array<Float, Array<Float>, Range>] Magnitude at frequency bands. Each element must be a scalar (for the whole band), or a range or a two element array (for the two band edges of the band). Length +a+ == length +f+ / 2
+	# @param w [Array<Float, Array<Float>, Range] Weight at frequency bands. Each element must be a scalar (for the whole band), or a range or a two element array (for the two band edges of the band). Length +w+ == length +f+ / 2
+	# @param type [:odd_symmetry, :even_symmetry] Specify the symmetry of the filter. nil and :even_symmetry are the same and default, for type 1 and 2 filters, :odd_symmetry is for type 3 and 4 filters.
+	# @param grid [Integer] The length of the grid over which the frequency response is evaluated. Defaults to 16, for an interpolation on 16*+n+.
+	# @return [Array<Float>] The filter coefficients B
+	def self.firls (n, f, a, *args)
+		raise ArgumentError.new "Expecting no more than 6 arguments" if args.length > 3
+
+		n = [1, n.to_i].max
+
+		case f
+		when Array
+		when Range
+			f = [f]
+		else
+			raise ArgumentError.new "F must be an array or a range"
+		end
+		f.collect! do |e|
+			case e
+			when Range
+				[e.begin.to_f, e.end.to_f]
+			when Array
+				raise ArgumentError.new "Elements of F which are arrays must have exaclty two floats" unless (e.length == 2 and e.first.kind_of?(Float) and e.last.kind_of?(Float))
+				[e.first.to_f, e.last.to_f]
+			else
+				e.to_f
+			end
+		end
+		f = f.flatten
+		raise ArgumentError.new "At least one frequency band must be specified!" if f.empty?
+		raise ArgumentError.new "Once flattened, F must have an even number of frequency bands!" unless (f.length & 1) == 0
+		raise ArgumentError.new "F must have at least one band!" unless f.length >= 2
+		f.each do |e|
+			raise ArgumentError.new "Frequency band edges must be in the range [0, 1]" unless (e >= 0.0 and e <= 1.0)
+		end
+		(1...f.length).each do |i|
+			raise ArgumentError.new "Frequecy band edges must be strictly increasing" if f[i-1] >= f[i]
+		end
+
+		case a
+		when Array
+		when Range
+			[a]
+		when Numeric
+			[a]
+		else
+			raise ArgumentError.new "A must be an array or a range"
+		end
+		raise ArgumentError.new "Length of A must be half the length of F" unless a.length == f.length/2
+		a.collect! do |e|
+			case e
+			when Range
+				[e.begin.to_f.abs, e.end.to_f.abs]
+			when Array
+				raise ArgumentError.new "Elements of A which are arrays must have at least two floats" if e.length < 2
+				e.collect{|v| v.to_f}
+			else
+				[e.to_f.abs, e.to_f.abs]
+			end
+		end
+
+		w = nil
+		type = :even_symmetry
+		grid = 16
+
+		args.each.with_index do |arg, i|
+			case arg
+			when :even_symmetry
+				type = :even_symmetry
+			when :odd_symmetry
+				type = :odd_symmetry
+			when Numeric
+				grid = [1, arg.to_i].max
+				STDERR.puts "WARNING: recommended grid sampling factor are integers in the range [8, 16]." unless Range.new(8, 16).include?(grid)
+			when Array
+				raise ArgumentError.new "Length of W must be half the length of F" unless arg.length == f.length/2
+				w = arg.collect do |e|
+					case e
+					when Range
+						[e.begin.to_f.abs, e.end.to_f.abs]
+					when Array
+						raise ArgumentError.new "Elements of W which are arrays must have at least two floats" if e.length < 2
+						e.collect{|v| v.to_f}
+					else
+						[e.to_f.abs, e.to_f.abs]
+					end
+				end
+			else
+				raise ArgumentError.new "Argument #{i+4} must either be :odd_symmetry, :even_symmetry, an array of weight or the grid sampling (Integer)"
+			end
+		end
+
+		w = (f.length / 2).times.collect{[1.0, 1.0]} if w.nil?
+
+		bands = (0 ... a.length).collect do |i|
+			{
+				frequencies: Range.new(f[2*i], f[2*i+1]),
+				amplitudes:  a[i],
+				weights: w[i]
+			}
+		end
+
+		## Create the sampling grid by interpolation ##
+		nb_sample_points = grid*n
+		constrained_frequency_amount = bands.inject(0.0){|m, h| m + h[:frequencies].end - h[:frequencies].begin}
+		# debug_amp_plot_args = []
+		# debug_weight_plot_args = []
+		bands.each do |band|
+			# debug_amp_plot_args << Roctave.linspace(band[:frequencies].begin, band[:frequencies].end, band[:amplitudes].length)
+			# debug_amp_plot_args << band[:amplitudes].collect{|e| e}
+			# debug_amp_plot_args << '-+b'
+			# debug_weight_plot_args << Roctave.linspace(band[:frequencies].begin, band[:frequencies].end, band[:weights].length)
+			# debug_weight_plot_args << band[:weights].collect{|e| e}
+			# debug_weight_plot_args << '-+b'
+
+			fi = Roctave.linspace(band[:frequencies].begin, band[:frequencies].end, [2, ((band[:frequencies].end - band[:frequencies].begin) * nb_sample_points / constrained_frequency_amount).ceil].max)
+			ai = Roctave.interp1(Roctave.linspace(band[:frequencies].begin, band[:frequencies].end, band[:amplitudes].length), band[:amplitudes], fi)
+			wi = Roctave.interp1(Roctave.linspace(band[:frequencies].begin, band[:frequencies].end, band[:weights].length), band[:weights], fi)
+
+			# debug_amp_plot_args << fi.collect{|e| e}
+			# debug_amp_plot_args << ai.collect{|e| e}
+			# debug_amp_plot_args << '-xr'
+			# debug_weight_plot_args << fi.collect{|e| e}
+			# debug_weight_plot_args << wi.collect{|e| e}
+			# debug_weight_plot_args << '-xr'
+
+			band[:frequencies] = fi.collect{|v| v*Math::PI}
+			band[:amplitudes]  = ai
+			band[:weights]     = wi
+		end
+		nb_sample_points = bands.inject(0.0){|m, h| m + h[:frequencies].length}
+
+
+		## Filter type ##
+		if type == :even_symmetry then
+			if (n & 1) == 0 then
+				filter_type = 1
+				beta = 0.0
+				q = -> w { 1.0 }
+				l = n / 2
+				coefs_from_p = -> p {
+					(-l .. l).collect{|m| m.abs}.collect do |m|
+						if m == 0 then
+							p[m, 0]
+						else
+							p[m, 0] / 2.0
+						end
+					end
+				}
+			else
+				filter_type = 2
+				beta = 0.0
+				q = -> w { Math.cos(w/2.0) }
+				l = (n - 1) / 2
+				coefs_from_p = -> p {
+					id = (1..l+1).to_a
+					(id.reverse + id).collect{ |m|
+						if m == 1 then
+							p[0, 0] + 0.5*p[1, 0]
+						elsif m == l+1 then
+							0.5*p[l, 0]
+						else
+							0.5*(p[m-1, 0] + p[m, 0])
+						end
+					}.collect{|v| v/2.0}
+				}
+			end
+		else
+			if (n & 1) == 0 then
+				filter_type = 3
+				beta = Math::PI/2
+				q = -> w { Math.sin(w) }
+				l = n / 2 - 1
+				coefs_from_p = -> p {
+					id = (1..l+1).to_a
+					(id.reverse + [0] + id).collect{ |m|
+						if m == 0 then
+							0.0
+						elsif m == 1 then
+							p[0, 0] - 0.5*p[2, 0]
+						elsif m >= l then
+							0.5*p[m-1, 0]
+						else
+							0.5*(p[m-1,0] - p[m+1, 0])
+						end
+					}.collect.with_index{ |v, i|
+						if i < l + 1 then
+							v/2.0
+						else
+							-v/2.0
+						end
+					}
+				}
+			else
+				filter_type = 4
+				beta = Math::PI/2
+				q = -> w { Math.sin(w/2.0) }
+				l = (n - 1) / 2
+				coefs_from_p = -> p {
+					id = (1..l+1).to_a
+					(id.reverse + id).collect{ |m|
+						if m == 1 then
+							p[0, 0] - 0.5*p[1, 0]
+						elsif m == l+1 then
+							0.5*p[l, 0]
+						else
+							0.5*(p[m-1, 0] - p[m, 0])
+						end
+					}.collect.with_index{ |v, i|
+						if i < l + 1 then
+							v/2.0
+						else
+							-v/2.0
+						end
+					}
+				}
+			end
+		end
+		# puts "Filter Type #{case filter_type; when 1 then 'I'; when 2 then 'II'; when 3 then 'III'; else 'IV' end}"
+
+
+		## Create the matrices ##
+		frequencies = bands.inject([]){|m, h| m + h[:frequencies]}
+		amplitudes  = bands.inject([]){|m, h| m + h[:amplitudes]}
+		weights     = bands.inject([]){|m, h| m + h[:weights]}
+
+		mat_Wq2 = Matrix.build(nb_sample_points) do |i, j|
+			if i == j then
+				((weights[i] * q.call(frequencies[i]))**2).to_f
+				#Rational((weights[i] * q.call(frequencies[i]))**2)
+			else
+				0
+				#Rational(0)
+			end
+		end
+
+		mat_dq = Matrix.build(nb_sample_points, 1) do |i|
+			qw = q.call(frequencies[i])
+			qw = 0.000000001 if qw == 0.0
+			amplitudes[i] / qw
+			#Rational(amplitudes[i] / qw)
+		end
+
+		mat_U = Matrix.build(nb_sample_points, l + 1) do |i, j|
+			Math.cos(j * frequencies[i])
+			#Rational(Math.cos(j * frequencies[i]))
+		end
+
+		if false then
+		mat_UT_times_mat_Wq2 = mat_U.transpose * mat_Wq2
+		p = ((mat_UT_times_mat_Wq2 * mat_U).inverse * (mat_UT_times_mat_Wq2 * mat_dq)).collect{|e| e.to_f}
+		else
+			ts_whole = Time.now
+			puts "go"
+			#ts_inv = Time.now
+			#mat_ut = mat_U.transpose
+			#puts "time transp: #{(Time.now - ts_inv).round(3)}"
+			#mat_ut.puts
+			#mat_Wq2.puts
+			ts_inv = Time.now
+			#mat_UT_times_mat_Wq2 = mat_ut * mat_Wq2
+			mat_UT_times_mat_Wq2 = Matrix.build(l+1, nb_sample_points) do |i, j|
+				mat_U[j, i] * mat_Wq2[j, j]
+			end
+			puts "time mult1: #{(Time.now - ts_inv).round(3)}"
+			#mat_UT_times_mat_Wq2.puts
+			ts_inv = Time.now
+			mat_truc = mat_UT_times_mat_Wq2 * mat_U
+			puts "time mult1.5: #{(Time.now - ts_inv).round(3)}"
+			ts_inv = Time.now
+			mat_inv = mat_truc.inverse
+			puts "time inv: #{(Time.now - ts_inv).round(3)}"
+			ts_inv = Time.now
+			mat_truc = mat_UT_times_mat_Wq2 * mat_dq
+			puts "time mult2: #{(Time.now - ts_inv).round(3)}"
+			ts_inv = Time.now
+			p = mat_inv * mat_truc
+			puts "time mult3: #{(Time.now - ts_inv).round(3)}"
+			p = p.collect{|e| e.to_f}
+			puts "time tot: #{(Time.now - ts_whole).round(3)}"
+		end
+
+		#p.puts
+
+		b = coefs_from_p.call(p)
+
+		###
+		# Matrix.column_vector(b).puts
+		#
+		# if filter_type == 1 or filter_type == 3 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
+		#
+		# 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)
+		# debug_amp_plot_args << w2
+		# debug_amp_plot_args << h2
+		# debug_amp_plot_args << '-g;Response;'
+		# 
+		# #Roctave.plot(*debug_weight_plot_args, title: 'Target weights', xlim: (0 .. 1), grid: true)
+		# Roctave.plot(*debug_amp_plot_args, title: 'Target filter magnitude response', xlim: (0 .. 1), grid: true)
+		# Roctave.plot(w2, h2.collect{|v| 10*Math.log10(v)}, xlabel: 'Normalized frequency', ylabel: 'Magnitude response (dB)', grid: true, title: 'Magnitude')
+		# Roctave.plot(w2, p2, grid: true, title: 'Phase')
+		###
+
+		b
+	end
+end
+