kmat 0.0.3

data/lib/kmat/linalg.rb

@@ -0,0 +1,279 @@
+class Mat
+	def least_squares!(a, b, tor: nil, weight: nil, transpose: false)
+		if tor
+			raise ArgumentError, "tor and weight must not specify at once" if weight
+			raise ArgumentError, "for conjugate LS, auto-transpose is not available" if transpose
+			_ls_conj(a, b, tor)
+		elsif weight
+			raise ArgumentError, "for weighted LS, auto-transpose is not available" if transpose
+			wls!(a, b, weight)
+		else
+			if transpose
+				tls!(a, b)
+			else
+				_ls(a, b)
+			end
+		end
+	end
+	def least_squares(b, tor: nil, weight: nil, transpose: false)
+		if tor
+			raise ArgumentError, "tor and weight must not specify at once" if weight
+			raise ArgumentError, "for conjugate LS, auto-transpose is not available" if transpose
+			ls_conj(b, tor)
+		elsif weight
+			raise ArgumentError, "for weighted LS, auto-transpose is not available" if transpose
+			wls(b, weight)
+		else
+			if transpose
+				tls(b)
+			else
+				n = self.col_size
+				Mat.new(n, n, :float).__send__(:_ls, b)
+			end
+		end
+	end
+	alias :ls :least_squares
+	alias :ls! :least_squares!
+
+	def ls_conj!(a, b, tor: Float::EPSILON)
+		_ls_conj(a, b, tor)
+	end
+	def ls_conj(b, tor: Float::EPSILON)
+		Mat.new(self.col_size, 1, :float).ls_conj!(self, b, tor: tor)
+	end
+	
+	# weighted least squares
+	# weight `w' is a vector consists of standard deviations of errors
+	# a; (m, n)-matrix
+	# b: m-vector
+	# x: n-vector
+	def wls!(a, b, w)
+		nw = w.length
+		diag = Mat.new(nw, nw, :f)
+		diag.diag.temp do |dd|
+			begin
+				dd.copy_from(w)
+			rescue MismatchedDimensionError
+				dd.tcopy_from(w)
+			end
+			dd.sqrt!
+		end
+		glm!(a, diag, b)
+	end
+	def wls(b, w)
+		Mat.new(self.col_size, 1, :f).wls!(self, b, w)
+	end
+	
+	def rand_orth(random: $MatRandom)
+		_rand_orth(random)
+	end
+	def self.rand_orth(n, random: $MatRandom)
+		Mat.new(n, n, :float).rand_orth(random: random)
+	end
+	
+	def under(other)
+		if square?
+			begin
+				solve(other)
+			rescue UncomputableMatrixError
+				ls(other)
+			end
+		else
+			ls(other)
+		end
+	end
+	def under!(a, b)
+		if a.square?
+			begin
+				solve!(a, b)
+			rescue UncomputableMatrixError
+				ls!(a, b)
+			end
+		else
+			ls!(a, b)
+		end
+	end
+	def over(other)
+		if other.square?
+			begin
+				other.tsolve(self).t!
+			rescue UncomputableMatrixError
+				other.tls(self).t!
+			end
+		else
+			other.tls(self).t!
+		end
+	end
+	def over!(a, b)
+		if b.square?
+			begin
+				tsolve!(b, a).t!
+			rescue UncomputableMatrixError
+				tls!(b, a).t!
+			end
+		else
+			tls!(b, a).t!
+		end
+	end
+	def pinv
+		n = self.size.min
+		i = Mat.I(n)
+		if square?
+			begin
+				solve(i)
+			rescue UncomputableMatrixError
+				ls(i)
+			end
+		else
+			ls(i)
+		end
+	end
+	def eigen_values
+		if symmetry?
+			symmetrize().sym_eigen_values()
+		else
+			ge_eigen_values()
+		end
+	end
+	def evd
+		if symmetry?
+			symmetrize().sym_evd()
+		else
+			ge_evd()
+		end
+	end
+	
+	# inner product
+	# let x and y are column vectors and M is a square matrix
+	# the following is available
+	# (1) x.iprod => x'*x
+	# (2) x.iprod(y) => x'*y
+	# (3) M.iprod(x) => x'*M*x
+	# (4) M.iprod(x, y) => x'*M*y
+	# if `inverse' is true, M is replaced by its Moore–Penrose inverse
+	# in case (1) or (2), `inverse' is ignored
+	# if x or y is row vector, take transpose automatically
+	def iprod(*args, inverse: false)
+		case  args.size
+		when 0
+			if vector? # case 1
+				_iprod(self)
+			else
+				raise MismatchedDimensionError, "self must be a vector"
+			end
+		when 1
+			o = args[0]
+			if o.vector?
+				if vector? # case 2
+					_iprod(o)
+				else # case 3
+					if !square?
+						raise MismatchecDimensionError, "M must be square for M.iprod(x)"
+					elsif inverse
+						temp = Mat.new(row_size, 1, vtype)
+						if o.col_size == 1
+							begin
+								temp.solve!(self, o)
+							rescue UncomputableMatrixError
+								temp.ls!(self, o)
+							end
+						else
+							begin
+								temp.tsolve!(self, o)
+							rescue UncomputableMatrixError
+								temp.tls!(self, o)
+							end
+						end
+					else
+						temp = Mat.new(row_size, 1, vtype)
+						if o.col_size == 1
+							temp.mprod!(self, o)
+						else
+							temp.mprod!(o, self)
+						end
+					end
+					temp.__send__(:_iprod, o)
+				end
+			else
+				raise MismatchedDimensionError, "as iprod with single argument, x.iprod(y) and M.iprod(x) are available, not x.iprod(M) or others"
+			end
+		when 2 # case 4
+			x, y = *args
+			if !square? || !x.vector? || !y.vector? || x.length != row_size || y.length != row_size
+				raise MismatchecDimensionError, "as iprod with 2 arguments, only M.iprod(x, y) is available, not others"
+			end
+			temp = Mat(row_size, 1, vtype)
+			if y.col_size == 1
+				temp.mprod!(y)
+			else
+				if y.frozen?
+					y = y.dup
+					y.transpose
+					temp.mprod!(y)
+				else
+					begin
+						y.transpose
+						temp.mprod!(y)
+					ensure
+						y.transpose
+					end
+				end
+			end
+			x.__send__(:_iprod, temp)
+		else
+			raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..2)"
+		end
+	end
+	alias :inner_product :iprod
+	
+	# distance (Frobenius norm of the difference)
+	def distance(other)
+		self.dup.sub!(other).normf
+	end
+	def squared_distance(other)
+		self.dup.sub!(other).iprod
+	end
+	
+	# matrix norm
+	# `type' Symbol or Integer specifies norm definition
+	# if `elementwise' is true, return induced norm
+	# if `elementwise' is false, return elementwise norm
+	# if `type' is :fro, return Frobenius norm
+	def norm(type=:two, elementwise: false)
+		if elementwise
+			case type
+			when :one, :o, 1
+				norm_e1()
+			when :infinity, :i, :inf, :infty, Float::INFINITY
+				norm_einf()
+			when :two, :t, 2, :frobenius, :f, :fro
+				normf()
+			end
+		else
+			case type
+			when :one, :o, 1
+				norm1()
+			when :infinity, :i, :inf, :infty, Float::INFINITY
+				normi()
+			when :two, :t, 2
+				norm2()
+			when :frobenius, :f, :fro
+				normf()
+			end
+		end
+	end
+	
+	def rcond(type=:two)
+		case type
+		when :one, :o, 1
+			_rcondoi(:one)
+		when :infinity, :i, :inf, :infty, Float::INFINITY
+			_rcondoi(:infinity)
+		when :two, :t, 2
+			_rcond2()
+		when :frobenius, :f, :fro
+			_rcondf()
+		end
+	end
+end
+

data/lib/kmat/logical.rb

@@ -0,0 +1,150 @@
+class Mat
+	def all?(*args)
+		if block_given?
+			each do |ent|
+				return false unless yield(ent, *args)
+			end
+		elsif args.size == 0
+			if self.vtype == :bool
+				each do |ent|
+					return false unless ent
+				end
+			else
+				return enum_for(__method__)
+			end
+		else
+			each do |ent|
+				args.each do |arg|
+					return false unless arg === ent
+				end
+			end
+		end
+		return true
+	end
+	def any?(*args)
+		if block_given?
+			each do |ent|
+				return true if yield(ent, *args)
+			end
+		elsif args.size == 0
+			if self.vtype == :bool
+				each do |ent|
+					return true if ent
+				end
+			else
+				return enum_for(__method__)
+			end
+		else
+			each do |ent|
+				args.each do |arg|
+					return true if arg === ent
+				end
+			end
+		end
+		return false
+	end
+	
+	def ==(other)
+		return true if self.equal?(other)
+		return false unless other.kind_of?(Mat)
+		if self.vtype == other.vtype && self.size == other.size
+			each_with_index do |e, i, j|
+				return false unless e == other[i, j]
+			end
+			true
+		else
+			false
+		end
+	end
+	def <(other)
+		return false if self.equal?(other)
+		unless other.kind_of?(Mat)
+			raise ArgumentError, "Mat < #{other.class} is not defined"
+		end
+		if self.vtype != other.vtype
+			raise ValueTypeError, "value types must be the same"
+		elsif self.size != other.size
+			raise MismatchedDimensionError, "the sizes must be the same, (#{self.size.join(', ')}) != (#{other.size.join(', ')})"
+		end
+		each_with_index do |e, i, j|
+			return false unless e < other[i, j]
+		end
+		true
+	end
+	def <=(other)
+		return false if self.equal?(other)
+		unless other.kind_of?(Mat)
+			raise ArgumentError, "Mat <= #{other.class} is not defined"
+		end
+		if self.vtype != other.vtype
+			raise ValueTypeError, "value types must be the same"
+		elsif self.size != other.size
+			raise MismatchedDimensionError, "the sizes must be the same, (#{self.size.join(', ')}) != (#{other.size.join(', ')})"
+		end
+		each_with_index do |e, i, j|
+			return false unless e <= other[i, j]
+		end
+		true
+	end
+	def >(other)
+		return false if self.equal?(other)
+		unless other.kind_of?(Mat)
+			raise ArgumentError, "Mat > #{other.class} is not defined"
+		end
+		if self.vtype != other.vtype
+			raise ValueTypeError, "value types must be the same"
+		elsif self.size != other.size
+			raise MismatchedDimensionError, "the sizes must be the same, (#{self.size.join(', ')}) != (#{other.size.join(', ')})"
+		end
+		each_with_index do |e, i, j|
+			return false unless e > other[i, j]
+		end
+		true
+	end
+	def >=(other)
+		return false if self.equal?(other)
+		unless other.kind_of?(Mat)
+			raise ArgumentError, "Mat > #{other.class} is not defined"
+		end
+		if self.vtype != other.vtype
+			raise ValueTypeError, "value types must be the same"
+		elsif self.size != other.size
+			raise MismatchedDimensionError, "the sizes must be the same, (#{self.size.join(', ')}) != (#{other.size.join(', ')})"
+		end
+		each_with_index do |e, i, j|
+			return false unless e >= other[i, j]
+		end
+		true
+	end
+	
+	def eq(other)
+		unless other.kind_of?(Mat) && other.size == self.size
+			other = broadcast(other)
+		end
+		Mat.new(row_size(), col_size(), :bool).eq!(self, other)
+	end
+	def lt(other)
+		unless other.kind_of?(Mat) && other.size == self.size
+			other = broadcast(other)
+		end
+		Mat.new(row_size(), col_size(), :bool).lt!(self, other)
+	end
+	def le(other)
+		unless other.kind_of?(Mat) && other.size == self.size
+			other = broadcast(other)
+		end
+		Mat.new(row_size(), col_size(), :bool).le!(self, other)
+	end
+	def gt(other)
+		unless other.kind_of?(Mat) && other.size == self.size
+			other = broadcast(other)
+		end
+		Mat.new(row_size(), col_size(), :bool).gt!(self, other)
+	end
+	def ge(other)
+		unless other.kind_of?(Mat) && other.size == self.size
+			other = broadcast(other)
+		end
+		Mat.new(row_size(), col_size(), :bool).ge!(self, other)
+	end
+end

data/lib/kmat/misc.rb

@@ -0,0 +1,122 @@
+class << Mat
+	def hilb(n, type=:float)
+		self.new(n, n, type) do |i, j|
+			1.quo(i+j+1)
+		end
+	end
+	def load(file)
+		case file
+		when String
+			ret = nil
+			File.open(file) do |f|
+				ret = Marshal.load(f)
+			end
+			ret
+		when IO
+			Marshal.load(file)
+		else
+			raise ArgumentError, 'the argument must be a filepath or an IO object'
+		end
+	end
+end
+
+class Mat
+	def save(file)
+		case file
+		when String
+			File.open(file, 'w') do |f|
+				Marshal.dump(self, f)
+			end
+		when IO
+			Marshal.dump(self, file)
+		else
+			raise ArgumentError, 'the argument must be a filepath or an IO object'
+		end
+		nil
+	end
+	
+	def geo_normalize!(arg=:all)
+		self.log!
+		foo = self.mean(arg)
+		if foo.kind_of?(Mat)
+			self.sub!(self.broadcast(foo))
+		else
+			self.s_sub!(foo)
+		end
+		self.exp!
+	end
+	def geo_normalize(arg=:all)
+		self.dup.geo_normalize!(arg)
+	end
+	def normalize!
+		if self.vector?
+			self.s_div!(self.normf)
+		elsif self.square?
+			ev = self.eigen_values
+			if ev[0] < 0
+				self.diag.s_add!(ev[0]*(-2))
+				ev.s_add!(ev[0]*(-2))
+			end
+			self.s_div!(Math.exp(ev.log!.mean))
+		else
+			raise MismatchedDimensionError, "normalize is available only for vectors or square matricies"
+		end
+	end
+	def normalize
+		self.dup.normalize!
+	end
+end
+
+class Array
+	def argsort
+		ret = Array.new(self.size, &:itself)
+		if block_given?
+			ret.sort! do |a, b|
+				yield(self[a], self[b])
+			end
+		else
+			ret.sort_by! do |elm|
+				self[elm]
+			end
+		end
+	end
+	def argsort!(ary)
+		if block_given?
+			sort! do |a, b|
+				yield(ary[a], ary[b])
+			end
+		else
+			sort_by! do |elm|
+				self[elm]
+			end
+		end
+	end
+	def argsort_by
+		if block_given?
+			Array.new(self.size, &:itself).sort_by! do |elm|
+				yield(self[elm])
+			end
+		else
+			self.to_enum(:argsort_by)
+		end
+	end
+end
+module Enumerable
+	def argsort(&block)
+		self.to_a.argsort(&block)
+	end
+	def argsort_by(&block)
+		self.to_a.argsort_by(&block)
+	end
+end
+class Numeric
+	def limit(min, max)
+		if ( self < min ) then
+			min
+		elsif ( max < self ) then
+			max
+		else
+			self
+		end
+	end
+end