kmat 0.0.3

data/ext/kmat/arith/unary.c

@@ -0,0 +1,165 @@
+#include "../kmat.h"
+
+static void
+km_abs_func_d(double *ent, void *data)
+{
+	*ent = fabs(*ent);
+}
+static void
+km_abs_func_z(COMPLEX *ent, void *data)
+{
+	*ent = cpack(cabs(*ent), 0.0);
+}
+static void
+km_abs_func_i(int *ent, void *data)
+{
+	*ent = ABS(*ent);
+}
+static void
+km_abs_func_v(VALUE *ent, void *data)
+{
+	*ent = rb_funcall(*ent, id_abs, 0);
+}
+VALUE
+kmm_mat_abs_destl(VALUE self)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	VT_SWITCH( smat->vtype,
+		km_smat_each_d(smat, km_abs_func_d, NULL);,
+		km_smat_each_z(smat, km_abs_func_z, NULL);,
+		km_smat_each_i(smat, km_abs_func_i, NULL);,
+		/* nothing to do */,
+		km_smat_each_v(smat, km_abs_func_v, NULL);
+	);
+	return self;
+}
+static void
+km_cabs_func(double *dest, const COMPLEX *src,  void *data)
+{
+	*dest = cabs(*src);
+}
+VALUE
+kmm_mat_abs(VALUE self)
+{
+	SMAT *smat = km_mat2smat(self);
+	if ( smat->vtype == VT_COMPLEX ) {
+		VALUE ret = km_Mat(smat->m, smat->n, VT_DOUBLE);
+		km_smat_each2_dcz(km_mat2smat(ret), smat, km_cabs_func, NULL);
+		return ret;
+	} else {
+		return kmm_mat_abs_destl(rb_obj_dup(self));
+	}
+}
+
+static void
+km_uminus_func_d(double *ent, void *data)
+{
+	*ent = -(*ent);
+}
+static void
+km_uminus_func_z(COMPLEX *ent, void *data)
+{
+	*ent = -(*ent);
+}
+static void
+km_uminus_func_i(int *ent, void *data)
+{
+	*ent = -(*ent);
+}
+static void
+km_uminus_func_v(VALUE *ent, void *data)
+{
+	*ent = rb_funcall(*ent, id_op_uminus, 0);
+}
+VALUE
+kmm_mat_uminus_destl(VALUE self)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	VT_SWITCH( smat->vtype,
+		km_smat_each_d(smat, km_uminus_func_d, NULL);,
+		km_smat_each_z(smat, km_uminus_func_z, NULL);,
+		km_smat_each_i(smat, km_uminus_func_i, NULL);,
+		/* nothing to do */,
+		km_smat_each_v(smat, km_uminus_func_v, NULL);
+	);
+	return self;
+}
+// alias -@
+VALUE
+kmm_mat_uminus(VALUE self)
+{
+	return kmm_mat_uminus_destl(rb_obj_dup(self));
+}
+
+static void
+km_conj_func_z(COMPLEX *ent, void *data)
+{
+	*ent = conj(*ent);
+}
+static void
+km_conj_func_v(VALUE *ent, void *data)
+{
+	*ent = rb_funcall(*ent, id_conj, 0);
+}
+// alias conjugate
+VALUE
+kmm_mat_conj_dest(VALUE self)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	if ( smat->vtype == VT_COMPLEX ) {
+		km_smat_each_z(smat, km_conj_func_z, NULL);
+	} else if ( smat->vtype == VT_VALUE ) {
+		km_smat_each_v(smat, km_conj_func_v, NULL);
+	}
+	return self;
+}
+
+// trace
+// alias tr
+VALUE
+kmm_mat_trace(VALUE self)
+{
+	SMAT *smat = km_mat2smat(self);
+	int len = MIN(smat->m, smat->n);
+	if ( smat->vtype == VT_DOUBLE ) {
+		double ret = 0.0;
+		for ( int i=0; i<len; i++ ) {
+			ret += ENTITY(smat, d, i, i);
+		}
+		return rb_float_new(ret);
+	} else if ( smat->vtype == VT_COMPLEX ) {
+		COMPLEX ret = cpack(0.0, 0.0);
+		for ( int i=0; i<len; i++ ) {
+			ret += ENTITY(smat, z, i, i);
+		}
+		return km_c2v(ret);
+	} else if ( smat->vtype == VT_INT ) {
+		int ret = 0;
+		for ( int i=0; i<len; i++ ) {
+			ret += ENTITY(smat, i, i, i);
+		}
+		return INT2NUM(ret);
+	} else if ( smat->vtype == VT_BOOL ) {
+		bool ret = false;
+		for ( int i=0; i<len; i++ ) {
+			bool ent = ENTITY(smat, b, i, i);
+			ret = XOR(ret, ent);
+		}
+		return TF2V(ret);
+	} else if ( smat->vtype == VT_VALUE ) {
+		if ( len == 0 ) {
+			return INT2NUM(0);
+		} else {
+			VALUE ret = ENTITY(smat, v, 0, 0);
+			for ( int i=1; i<len; i++ ) {
+				ret = rb_funcall(ret, id_op_plus, 1, ENTITY(smat, v, i, i));
+			}
+			return ret;
+		}
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+}

data/ext/kmat/auto_collect.rb

@@ -0,0 +1,118 @@
+
+class MethodDefinition
+	def initialize(name_arg, comment)
+		comment = %r|//\s+(.*)|.match(comment)[1]
+		@als = /\Aalias (.+)/.match(comment)&.[](1)&.split(/[,\s]\s*/)
+		@meth = /\Akmm_/.match(name_arg)
+		return unless @meth
+		m = %r|\A(kmm_([^\(_]+)_([^\(]+))\((.+)\)\Z|.match(name_arg)
+		raise "unknown name_arg pattern `#{name_arg}' found" unless m
+		@funcname, @type, @name, arg =  m[1], type_trans(m[2]), m[3], m[4]
+		if m = %r|(.+)_p\Z|.match(@name)
+			@name = m[1]+'?'
+		elsif m = %r|(.+)_dest\Z|.match(@name)
+			@name = m[1]
+			@dup_esc = true
+		elsif m = %r|(.+)_destl\Z|.match(@name)
+			@name = m[1]+'!'
+		end
+		if m = %r|(.+)_m2\Z|.match(@name)
+			@name = m[1]
+			@argc = -2
+		elsif m = %r|\Aint argc|.match(arg)
+			@argc = -1
+		else
+			@argc = arg.split(/,/).size-1
+		end
+	end
+	attr_reader :meth
+	
+	def type_trans(t)
+		case t
+		when 'obj'
+			'rb_cObject'
+		when 'mat'
+			'km_cMat'
+		when 'Mat'
+			'km_sMat'
+		when 'ary'
+			'rb_cArray'
+		when 'MATH'
+			['rb_mMath', 'rb_sMath']
+		when 'float'
+			'rb_cFloat'
+		else
+			raise "unknown type `#{t}' found"
+		end
+	end
+	
+	def to_s(join="\n\t")
+		ret = []
+		if @type.kind_of?(Array)
+			ret << %Q|rb_define_module_function(#{@type[0]}, "#{@name}", #{@funcname}, #{@argc});|
+		elsif %r|\A\_|.match(@name)
+			ret << %Q|rb_define_private_method(#{@type}, "#{@name}", #{@funcname}, #{@argc});|
+		elsif @dup_esc
+			ret << %Q|rb_define_method(#{@type}, "#{@name}!", #{@funcname}, #{@argc});|
+			ret << %Q|rb_funcall(km_cMat, id__define_dup_escaped_method, 1, rb_str_new_cstr("#{@name}"));|
+		else
+			ret << %Q|rb_define_method(#{@type}, "#{@name}", #{@funcname}, #{@argc});|
+		end
+		@als&.each do |a|
+			if @type.kind_of?(Array)
+				ret << %Q|rb_define_alias(#{@type[0]}, "#{a}", "#{@name}");|
+				ret << %Q|rb_define_alias(#{@type[1]}, "#{a}", "#{@name}");|
+			else
+				ret << %Q|rb_define_alias(#{@type}, "#{a}", "#{@name}");|
+				ret << %Q|rb_define_alias(#{@type}, "#{a}!", "#{@name}!");| if @dup_esc
+			end
+		end
+		ret.join(join)
+	end
+end
+
+defs, decs = [], []
+
+# for all .c files
+Dir.glob("#{__dir__}/**/*.c").each do |file|
+	# for lines that comment line (can be omitted), return type and modifier line, function name and argument line
+	File.read(file).gsub(%r|(//[^\n]+\n)?[^#/{}\n\s][^\n;]+\n[^#/{}\n\s][^\n;]+\n{\n|) do |m|
+		ary = m.split(/\n/)
+		# functions which name start with kmm_ are methods
+		if ary.size == 4
+			foo = MethodDefinition.new(ary[2], ary[0])
+		else
+			foo = MethodDefinition.new(ary[1], '// ')
+		end
+		defs << foo.to_s if foo.meth
+		# ignore static functions and static variables
+		unless /\Astatic/.match(ary[-3])
+			decs << "#{ary[-3]} #{ary[-2]};"
+		end
+		''
+	end
+end
+
+
+File.open('./auto_collected.h', 'w') do |f|
+	decs.each do |dec|
+		f.puts dec
+	end
+end
+
+File.open('./method_definitions.c', 'w') do |f|
+	f.puts "static void\nkm_define_methods(void)\n{"
+	defs.each do |def_|
+		f.puts "\t#{def_}"
+	end
+	f.puts '}'
+end
+
+File.open('./global_variables.h', 'w') do |f|
+	flg = false
+	File.foreach("#{__dir__}/main.c") do |line|
+		flg = true if line == "// km_global_variables_begin\n"
+		f.puts "extern #{line}" if flg && !%r|\A// km_global_variables|.match(line) && !%r|\A\s*\n\Z|.match(line)
+		break if line == "// km_global_variables_end\n"
+	end
+end

data/ext/kmat/elementwise_function.rb

@@ -0,0 +1,149 @@
+both = %w(sin cos tan asin acos atan sinh cosh tanh asinh acosh atanh exp log sqrt)
+fonly = %w(exp2 expm1 log10 log1p log2 logb cbrt erf erfc lgamma tgamma ceil floor round trunc sign)
+dz = %w(real imag arg)
+
+File.open('elementwise_function.c', 'w') do |f|
+	f.puts 'static double sign(double x){ return ( x==0.0 ? 0.0 : ( x>0.0 ? 1.0 : ( x<0.0 ? -1.0 : x ))); }'
+	
+	both.each do |func|
+		f.puts <<"EOS"
+static void
+km_#{func}_d(double *ent, void *null)
+{
+	*ent = #{func}(*ent);
+}
+static void
+km_#{func}_z(COMPLEX *ent, void *null)
+{
+	*ent = c#{func}(*ent);
+}
+static void
+km_#{func}_v(VALUE *ent, void *null)
+{
+	*ent = rb_funcall(rb_mMath, id_#{func}, 1, *ent);
+}
+VALUE
+kmm_mat_#{func}_dest(VALUE self)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	if ( smat->vtype == VT_DOUBLE ) {
+		km_smat_each_d(smat, km_#{func}_d, NULL);
+	} else if ( smat->vtype == VT_COMPLEX ) {
+		km_smat_each_z(smat, km_#{func}_z, NULL);
+	} else if ( smat->vtype == VT_VALUE ) {
+		km_smat_each_v(smat, km_#{func}_v, NULL);
+	} else {
+		rb_raise(km_eVT, "the method is available only for float or complex matricies");
+	}
+	return self;
+}
+EOS
+	end
+	
+	fonly.each do |func|
+		f.puts <<"EOS"
+static void
+km_#{func}_d(double *ent, void *null)
+{
+	*ent = #{func}(*ent);
+}
+static void
+km_#{func}_v(VALUE *ent, void *null)
+{
+	*ent = rb_funcall(rb_mMath, id_#{func}, 1, *ent);
+}
+VALUE
+kmm_mat_#{func}_dest(VALUE self)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	if ( smat->vtype == VT_DOUBLE ) {
+		km_smat_each_d(smat, km_#{func}_d, NULL);
+	} else if ( smat->vtype == VT_VALUE ) {
+		km_smat_each_v(smat, km_#{func}_v, NULL);
+	} else {
+		rb_raise(km_eVT, "the method is available only for float matricies");
+	}
+	return self;
+}
+EOS
+	end
+	f.puts <<'EOS'
+static VALUE
+km_zmat_e_funcapp(VALUE self, void (*func)(COMPLEX *,  void *))
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	if ( smat->vtype != VT_COMPLEX ) {
+		rb_raise(km_eVT, "the method is available only for complex matrcies");
+	}
+	km_smat_each_z(smat, func, NULL);
+	return self;
+}
+static VALUE
+km_zdmat_e_funcapp(VALUE self, VALUE op, void (*func)(double *, const COMPLEX *,  void *))
+{
+	km_check_frozen(op);
+	SMAT *dest = km_mat2smat(op), *src = km_mat2smat(self);
+	if ( dest->vtype != VT_DOUBLE || src->vtype != VT_COMPLEX ) {
+		rb_raise(km_eVT, "self(operand) and argument(output) must be complex and float matrix, respectively");
+	}
+	CHECK_SAME_SIZE(dest, src);
+	km_smat_each2_dcz(dest, src, func, NULL);
+	return op;
+}
+EOS
+	dz.each do |func|
+		f.puts <<"EOS"
+static void
+km_#{func}_z(COMPLEX *ent, void *null)
+{
+	*ent = cpack(c#{func}(*ent), 0.0);
+}
+static void
+km_#{func}_dcz(double *dest, const COMPLEX *src, void *null)
+{
+	*dest = c#{func}(*src);
+}
+VALUE
+kmm_mat_#{func}_destl(int argc, VALUE *argv, VALUE self)
+{
+	rb_check_arity(argc, 0, 1);
+	if ( argc == 0 ) {
+		return km_zmat_e_funcapp(self, km_#{func}_z);
+	} else {
+		return km_zdmat_e_funcapp(self, argv[0], km_#{func}_dcz);
+	}
+}
+VALUE
+kmm_mat_#{func}(VALUE self)
+{
+	SMAT *smat = km_mat2smat(self);
+	return km_zdmat_e_funcapp(self, km_Mat(smat->m, smat->n, VT_DOUBLE), km_#{func}_dcz);
+}
+EOS
+	end
+end
+
+File.open('elementwise_function.h', 'w') do |f|
+	(both+fonly).each do |func|
+		f.puts "VALUE kmm_mat_#{func}_dest(VALUE self);"
+	end
+	dz.each do |func|
+		f.puts "VALUE kmm_mat_#{func}_destl(int argc, VALUE *argv, VALUE self);"
+		f.puts "VALUE kmm_mat_#{func}(VALUE self);"
+	end
+end
+File.open('elementwise_function_definitions.c', 'w') do |f|
+	f.puts "static void\nkm_define_efs(void)\n{"
+	(both+fonly).each do |func|
+		f.puts %Q|\trb_define_method(km_cMat, "#{func}!", kmm_mat_#{func}_dest, 0);|
+		f.puts %Q|\trb_funcall(km_cMat, id__define_dup_escaped_method, 1, rb_str_new_cstr("#{func}"));|
+	end
+	dz.each do |func|
+		f.puts %Q|\trb_define_method(km_cMat, "#{func}!", kmm_mat_#{func}_destl, -1);|
+		f.puts %Q|\trb_define_method(km_cMat, "#{func}", kmm_mat_#{func}, 0);|
+	end
+	f.puts "}"
+end

data/ext/kmat/extconf.rb

@@ -0,0 +1,75 @@
+require "mkmf"
+require 'fileutils'
+
+if find_library("mkl_rt", nil, "/opt/intel/mkl/lib/intel64")
+	puts "It is set to use Intel MKL for BLAS/LAPACK functions."
+	mkl = true
+elsif have_library("blas") && have_library("lapack")
+	puts "It is set to use BLAS/LAPACK."
+	mkl = false
+else
+	puts "Intel MKL or BLAS/LAPACK is neaded to build this library."
+	exit
+end
+
+$CFLAGS = "$(cflags) -std=c11"
+$CFLAGS += " -m64" if mkl
+
+#$warnflags = "-Wall -Wextra -Wdeprecated-declarations -Wimplicit-function-declaration -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wmissing-noreturn -Wno-unused-parameter -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable -Wno-maybe-uninitialized -Winit-self -Wshadow"
+$warnflags = "-Wall -Wextra -Wdeprecated-declarations -Wimplicit-function-declaration -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wmissing-noreturn -Wno-unused-parameter -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable -Winit-self -Wshadow -Wlogical-op -Wconversion"
+
+$DLDFLAGS += " -Wl,-Bsymbolic -fPIC"
+$DLDFLAGS += " -Wl,--no-as-needed" if mkl
+
+
+# set .c files in subdirectories as source
+$objs = Dir.glob("#{__dir__}/**/*.c").map do |file|
+	file[-1] = 'o'
+	obj = %r|#{__dir__}/(.+)|.match(file)[1]
+	if m = %r|(.+)/[^/]+|.match(obj)
+		FileUtils.mkdir_p(m[1]) unless FileTest.exist?(m[1])
+	end
+	obj
+end
+
+srcs = $objs.map do |file|
+	file = file.dup
+	file[-1] = 'c'
+	"$(srcdir)/#{file}"
+end
+
+create_makefile("kmat/kmat")
+
+# change variables after Makefile created
+File.open('./__Makefile__temp__', 'w') do |f|
+	File.foreach('Makefile') do |line|
+		if ARGV.include?('debug')
+			line.sub!(/^optflags.+/, 'optflags = -O0')
+		else
+			line.sub!(/^debugflags.+/, 'debugflags =')
+		end
+		f.puts line
+	end
+end
+File.unlink('./Makefile')
+FileUtils.move('./__Makefile__temp__', './Makefile')
+
+# add dependencies
+File.open('./Makefile', 'a') do |f|
+	f.puts "true_srcs = #{srcs.join(' ')}"
+
+	# invoke auto_collect.rb
+	f.puts "auto_collected.h: auto_collect.rb $(true_srcs)"
+	f.puts "\truby $(srcdir)/auto_collect.rb"
+	
+	# invoke id_sym.rb
+	f.puts "id_sym.c id_sym.h: id_sym.rb id.txt sym.txt"
+	f.puts "\truby $(srcdir)/id_sym.rb"
+	
+	# invoke elementwise_functions.rb
+	f.puts "elementwise_function.h: elementwise_function.rb"
+	f.puts "\truby $(srcdir)/elementwise_function.rb"
+
+	f.puts '$(OBJS): auto_collected.h id_sym.h elementwise_function.h'
+	f.puts 'main.o: id_sym.c'
+end