kmat 0.0.3

data/ext/kmat/sym.txt

@@ -0,0 +1,34 @@
+a
+all
+b
+bool
+boolean
+c
+col
+column
+complex
+d
+double
+each
+each_with_index2
+f
+float
+full
+i
+infinity
+int
+integer
+mmap
+mmap_with_index2
+n
+none
+o
+object
+one
+r
+random
+row
+serial
+v
+value
+z

data/kmat.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "kmat/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "kmat"
+  spec.version       = Mat::VERSION
+  spec.authors       = ["KAZOON"]
+  spec.email         = ["cycloawaodorin+gem@gmail.com"]
+  spec.license = "GPL-3.0"
+
+  spec.summary       = %q{Kmat is a Ruby gem for matrix operations. Kmat uses BLAS/LAPACK as back-end.}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/cycloawaodorin/"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    #spec.metadata["allowed_push_host"] = "http://localhost"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/cycloawaodorin/kmat"
+    spec.metadata["changelog_uri"] = "https://github.com/cycloawaodorin/kmat/blob/master/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/kmat/extconf.rb"]
+
+  spec.add_development_dependency "bundler", ">= 2.0"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "pry", ">= 0.12.2"
+  
+  spec.required_ruby_version = '>= 2.6.0'
+end

data/lib/kmat.rb

@@ -0,0 +1,20 @@
+require "kmat/version"
+
+class Mat
+	include Enumerable
+end
+
+class << Mat
+	private def _define_dup_escaped_method(method)
+		Mat.class_eval("def #{method}(*args, &block); self.dup.#{method}!(*args, &block); end")
+	end
+end
+
+require "kmat/kmat"
+require "kmat/arith"
+require "kmat/accessor"
+require "kmat/linalg"
+require "kmat/logical"
+require "kmat/misc"
+require "kmat/random"
+require "kmat/statistics"

data/lib/kmat/accessor.rb

@@ -0,0 +1,164 @@
+class Mat	
+	def ===(other)
+		if other.kind_of?(Mat)
+			self == other
+		else
+			false
+		end
+	end
+	
+	def [](*idx)
+		if block_given?
+			tmp = self.bracket(*idx)
+			ret = yield(tmp)
+			tmp.__send__(:_kill)
+			ret
+		else
+			self.bracket(*idx)
+		end
+	end
+	
+	def temp
+		ret = yield(self)
+		_kill
+		ret
+	end
+	
+	# for example, A.repmat(2, 3) returns [A, A, A: A, A, A]
+	def repmat(row_repeat, col_repeat)
+		ri = Mat.new(row_size()*row_repeat, 1, :int) do |i, j|
+			i % row_size()
+		end
+		ci = Mat.new(col_size()*col_repeat, 1, :int) do |i, j|
+			i % col_size()
+		end
+		self[ri, ci] do |m|
+			m.dup
+		end
+	end
+	
+	# extend `other' to fit the shape of self
+	# this is similar to Python's numpy broadcasting
+	def broadcast(other, vt=nil)
+		if other.kind_of?(Mat)
+			if other.row_size == 1
+				if other.col_size == 1
+					other.repmat(row_size(), col_size())
+				elsif other.col_size == self.col_size
+					other.repmat(self.row_size, 1)
+				else
+					raise MismatchedDimensionError, "can't broadcast from (#{other.size.join(', ')}) to (#{self.size.join(', ')})"
+				end
+			elsif other.row_size == self.row_size
+				if other.col_size == 1
+					other.repmat(1, col_size())
+				elsif other.col_size == self.col_size
+					other
+				else
+					raise MismatchedDimensionError, "can't broadcast from (#{self.size.join(', ')}) to (#{other.size.join(', ')})"
+				end
+			else
+				raise MismatchedDimensionError, "can't broadcast from (#{self.size.join(', ')}) to (#{other.size.join(', ')})"
+			end
+		else
+			vt = vtype() if vt.nil?
+			Mat.new(row_size(), col_size(), vt).fill(other)
+		end
+	end
+	
+	# replace self by repeated `src'
+	# self will be left-top of infinitly repeated `src'
+	def replace_rep(src)
+		ri = Mat.new(row_size(), 1, :int) do |i, j|
+			i % src.row_size
+		end
+		ci = Mat.new(col_size(), 1, :int) do |i, j|
+			i % src.col_size
+		end
+		src[ri, ci] do |m|
+			self.copy_from(m)
+		end
+	end
+	
+	# flip row, column or both axis
+	# `dim' Symbol specifies fliping axis (:row, :col, :both, :none are available)
+	def flip(dim=:both)
+		dim = dim.to_sym if dim.respond_to?(:to_sym)
+		m, n = *shape()
+		case dim
+		when :both, :b
+			ri = Mat.new(m, 1, :int) do |i, j|
+				m-i-1
+			end
+			ci = Mat.new(n, 1, :int) do |i, j|
+				n-i-1
+			end
+			self[ri, ci]
+		when :row, :r
+			ri = Mat.new(m, 1, :int) do |i, j|
+				m-i-1
+			end
+			self[ri, nil]
+		when :col, :c
+			ci = Mat.new(n, 1, :int) do |i, j|
+				n-i-1
+			end
+			self[nil, ci]
+		when :none, :n
+			self[]
+		else
+			raise ArgumentError, "unknown axis symbol #{dim.inspect}"
+		end
+	end
+	
+	def diag(k=0)
+		_diag_ul(k)
+	end
+end
+
+class << Mat
+	# for example, Mat.blocks([a, b], [c, d]) returns a single matrix of [a, b; c, d]
+	def blocks(*blocks)
+		vstack(*blocks.map do |row|
+			hstack(*row)
+		end)
+	end
+	
+	def vstack(*mats)
+		m, n = *mats[0].shape
+		1.upto(mats.size-1) do |i|
+			mat = mats[i]
+			raise MismatchedDimensionError, 'column-sizes must be the same' if mat.col_size != n
+			m += mat.row_size
+		end
+		ret = Mat.new(m, n, mats[0].vtype)
+		k = 0;
+		n = Mat.irange(n)
+		mats.each do |mat|
+			ret[Mat.new(mat.row_size, 1, :int) do |i, j|
+				i+k
+			end, n] = mat
+			k += mat.row_size
+		end
+		ret
+	end
+	
+	def hstack(*mats)
+		m, n = *mats[0].shape
+		1.upto(mats.size-1) do |i|
+			mat = mats[i]
+			raise MismatchedDimensionError, 'row-sizes must be the same' if mat.row_size != m
+			n += mat.col_size
+		end
+		ret = Mat.new(m, n, mats[0].vtype)
+		k = 0
+		m = Mat.irange(m)
+		mats.each do |mat|
+			ret[m, Mat.new(mat.col_size, 1, :int) do |i, j|
+				i+k
+			end] = mat
+			k += mat.col_size
+		end
+		ret
+	end
+end

data/lib/kmat/arith.rb

@@ -0,0 +1,189 @@
+class Mat
+	# to define Numeric * Mat as Mat#scalar(Numeric) remaining Mat * Mat is undefined,
+	# this returns non‐standard value
+	def coerce(other)
+		if caller.first[/`([^']*)'/, 1] == '*'
+			[self, other]
+		else
+			raise TypeError, "Mat can't be coerced into #{other.class}"
+		end
+	end
+	def add(other)
+		if other.kind_of?(Mat)
+			self.dup.add!(broadcast(other))
+		else
+			self.dup.s_add!(other)
+		end
+	end
+	alias :+ :add
+	def sub(other)
+		if other.kind_of?(Mat)
+			self.dup.sub!(broadcast(other))
+		else
+			self.dup.s_sub!(other)
+		end
+	end
+	alias :- :sub
+	def e_mul(other)
+		if other.kind_of?(Mat)
+			self.dup.e_mul!(broadcast(other))
+		else
+			self.dup.s_mul!(other)
+		end
+	end
+	def e_div(other)
+		if other.kind_of?(Mat)
+			self.dup.e_div!(broadcast(other))
+		else
+			self.dup.s_div!(other)
+		end
+	end
+	module MatrixProductOperator
+		refine Mat do
+			def *(other)
+				if other.kind_of?(Mat)
+					mprod(other)
+				else
+					self.dup.s_mul!(other)
+				end
+			end
+			def /(other)
+				if other.kind_of?(Mat)
+					over(other)
+				else
+					self.dup.s_div!(other)
+				end
+			end
+		end
+	end
+	def *(other)
+		if other.kind_of?(Mat)
+			raise ArgumentError, "Mat#* is available only for scalar multiplication. To use Mat#*(Mat) for matrix product, call `using Mat::MatrixProductOperator'"
+		else
+			self.dup.s_mul!(other)
+		end
+	end
+	def scalar(alpha)
+		self.dup.s_mul!(alpha)
+	end
+	alias :"scalar!" :"s_mul!"
+	def /(other)
+		if other.kind_of?(Mat)
+			raise ArgumentError, "Mat#/ is available only for scalar multiplication with reciprocal. To use Mat#/(Mat) as an alias of Mat#over, call `using Mat::MatrixProductOperator`"
+		else
+			self.dup.s_div!(other)
+		end
+	end
+	
+	def add_times(other, alpha)
+		if other.kind_of?(Mat)
+			self.dup.add_times!(broadcast(other), alpha)
+		else
+			self.dup.s_mul!(other*alpha)
+		end
+	end
+	
+	def maximum(other)
+		if other.kind_of?(Mat)
+			self.dup.maximum!(broadcast(other))
+		else
+			self.dup.s_maximum!(other)
+		end
+	end
+	def minimum(other)
+		if other.kind_of?(Mat)
+			self.dup.minimum!(broadcast(other))
+		else
+			self.dup.s_minimum!(other)
+		end
+	end
+	
+	def pow(other)
+		if other.kind_of?(Mat)
+			self.dup.pow!(broadcast(other))
+		else
+			self.dup.s_pow!(other)
+		end
+	end
+	def rpow(other)
+		other.dup.pow!(other.broadcast(self))
+	end
+	def **(other)
+		case other
+		when Integer
+			ret, temp = self.dup, self.dup
+			ret.eye
+			if 0 <= other
+				a = self.dup
+			else
+				a = self.inv
+				other = -other
+			end
+			loop do
+				if other % 2 == 1
+					temp.mprod!(ret, a)
+					temp, ret = ret, temp
+				end
+				other = other.div(2)
+				break if other == 0
+				temp.mprod!(a, a)
+				temp, a = a, temp
+			end
+			ret
+		when Float
+			if self.symmetry?
+				v, d = self.symmetrize.sym_evd
+				d.diag.s_pow!(other)
+				foo = v.mprod(d)
+				d.mprod!(foo, v.t!)
+			else
+				raise UncomputableMatrixError, "cannot compute float power of non-symmetric matrcies"
+			end
+		when Rational
+			self ** other.to_f
+		else
+			raise ArgumentError, "Mat powered by #{other.class} is not supported"
+		end
+	end
+	
+	def hypot(other)
+		if other.kind_of?(Mat)
+			self.dup.hypot!(broadcast(other))
+		else
+			self.dup.s_hypot!(other)
+		end
+	end
+end
+
+class << Mat
+	def max(*args)
+		case args.size
+		when 0
+			nil
+		when 1
+			args[0]
+		else
+			ret = args[0].dup
+			1.upto(args.size-1) { |i|
+				ret.maximum!(args[i])
+			}
+			ret
+		end
+	end
+	alias :maximum :max
+	def min(*args)
+		case args.size
+		when 0
+			nil
+		when 1
+			args[0]
+		else
+			ret = args[0].dup
+			1.upto(args.size-1) { |i|
+				ret.minimum!(args[i])
+			}
+			ret
+		end
+	end
+	alias :minimum :min
+end