kmat 0.0.3

data/README.md

@@ -0,0 +1,224 @@
+# kmat
+
+Kmat is a Ruby gem for matrix operations. Kmat uses BLAS/LAPACK as back-end.
+
+## Requirements
+
+BLAS/LAPACK libraries are needed to build kmat. MKL can also be used.
+You need to modify extconf.rb to use the other BLAS/LAPACK compatible libraries (pull requests are welcome).
+
+## Installation
+
+Kmat is available on RubyGems.org:
+
+    $ gem install kmat
+
+or in your Gemfile:
+
+```ruby
+gem 'kmat'
+```
+
+## Usage
+
+While the gem name is kmat, the top module of this gem is the class `Mat`. Most of the functions of kmat are defined under `Mat` (some monkey patches (e.g. `Random#randn`) are applied to built-in modules/classes).
+
+`Mat` is a class of matricies. It has matrix operations as methods. Unlike numpy in Python, `Mat` cannot be a tensor with order other than 2. `Mat` with shape `(n, 1)` or `(1, n)` behaves as a vector (not be distinguished from each other) in some methods (e.g. `Mat#iprod`).
+
+Matlab style expected return value comments appear in the following sample codes, but they are only in documents (kmat has no way to generate these strings from Mat instances nor way to generate Mat instances from these strings).
+
+### Construction of matricies
+
+```ruby
+require 'kmat'
+
+Mat[[1, 2], [3, 4]]       #=> [1, 2; 3, 4]
+Mat.ones(2, 2)            #=> [1, 1; 1, 1]
+Mat.eye(2, 2)             #=> [1, 0; 0, 1]
+Mat.randn(2, 2)           #=> [-0.11, 0.25; 0.83, -0.03] (vary every call)
+Mat.range(3)              #=> [0; 1; 2]
+Mat.new(2, 3){|i, j| i+j} #=> [0, 1, 2; 1, 2, 3]
+```
+
+### Arithmetic operations
+```ruby
+require 'kmat'
+
+a = Mat.ones; b = Mat[[2, 0], [0, 1]]
+a+b        #=> [3, 1; 1, 2]
+a-b        #=> [-1, 1; 1, 0]
+a.mprod(b) #=> [2, 1; 2, 1] (matrix product)
+a.e_mul(b) #=> [2, 0; 0, 1] (element-wise product)
+b.under(a) #=> [0.5, 0.5; 1, 1] (like b\a in Matlab)
+a.over(b)  #=> [0.5, 1; 0.5, 1] (like a/b in Matlab)
+a*b        #=> ArgumentError (to avoid confusion of Mat#mprod vs Mat#e_mul)
+using Mat::MatrixProductOperator
+[a*b, a/b] #=> [ [2, 1; 2, 1], [0.5, 1; 0.5, 1] ] (refinements are available)
+a.sin      # Most of mathematical functions defined in math.h are available as element-wise operations
+```
+
+### Destructive operation
+```ruby
+require 'kmat'
+
+a = Mat.ones; b = Mat[[2, 0], [0, 1]]
+a+b; a     #=> [1, 1; 1, 1]
+a.add!(b)
+a          #=> [3, 1; 1, 2]
+c = Mat.new(2, 2)
+c.mprod!(a, b)
+c          #=> [6, 1; 2, 2]
+a.sub!(b); a.e_mul!(b); b.e_div!(a); c.under!(a, b)
+```
+
+### Numpy-like broadcasting
+```ruby
+require 'kmat'
+
+a = Mat.eye(2, 2); b = Mat.range(2)
+a+b                    #=> [1, 1; 2, 2]
+a.add!(a.broadcast(b)) # For destructive operation, you need to fit shape using Mat#broadcast
+a.s_add!(1.5)          # Or use Mat#s_xxx! for element-wise opertion with broadcasted scalar value
+0.5 * a                # Numeric#* can be used as scalar multiplication (others like Numeric+Mat are not available)
+```
+
+### Element or submatrix accessing
+```ruby
+rquire 'kmat'
+
+a = Mat[[1, 2], [3, 4]]
+a[1, 0]                  #=> 3.0
+a[0, -1]                 #=> 2.0 (negative indexing is available)
+a[nil, 1]                #=> [2; 4] (nil works like `:' in numpy)
+a[[1, 0], 0..1]          #=> [3, 4; 1, 2]
+a[a.gt(2)]               #=> [3; 4] (boolean indexing returns a vector)
+vidx = Mat.new(1, 2, :object){ |i, j| [j, i] }
+a[vidx]                  #=> [1, 3] (=[a[0, 0], a[1, 0]])
+b = a[0, nil]            # a submatrix is like a `view' of numby
+a[0, 0] = 5
+b                        #=> [5, 2]
+b[0, 1] = -1             # but it's writable and may change the `supermatrix'
+a                        #=> [5, -1; 3, 4]
+b.freeze                 # use Object#freeze to avoid it
+a[0, 0] = -3             # but, freezing submatrix do not freeze the `supermatrix'
+b                        #=> [-3, -1]
+a.deep_freeze            # use `supermatrix'.deep_freeze to freeze all the related matricies
+b[0, 0] = 7              #=> FrozenError
+c = a[0, nil]            # submatrix made from frozen matrix is pre-frozen
+c[0, 0] = 9              #=> FrozenError
+a = Mat[[1, 2], [3, 4]]
+a[nil, 0] = Mat.range(2) # multi-entry substitution is also available
+a                        #=> [0, 2; 1, 4]
+a.map(&:-@)              #=> [0, -2; -1, -4]
+a.map_with_index!{|e, i, j| e+j}
+a.diag                   #=> [0; 4] (returns diagonal elements as a vector)
+a[]                      #=> [0, 2; 1, 4] (with no argument is equivalent to a[nil, nil])
+Mat.range(3)[2]          #=> 2.0 (with single integer or single integer array is available for vectors)
+```
+
+### Value types
+Mat in kmat has 5 value types.
+#### Float
+The default value type is `:float`. Values are `double` in C language and it is compatible with `Float` in Ruby. Most of linear argebraic operations are available only on float matricies.
+
+#### Complex
+`:complex` is available to deal with complex floats. Some operations are defined but the number of available operations is limitted.
+
+#### Int
+`:int` can be used as row or column index array. Values are `int` in C language, so it is not useful for matrix operations with large integer elements. We recomend to use `:object` with `Integer` for such usage.
+
+#### Bool
+`:bool` can be used as boolean indexing. Logical operations are available. In some operations, elements in boolean matricies behaves as a finite filed with order 2 (`+` is exclusive disjunction and `*` is logical conjunction).
+
+#### Object
+`:object` matricies can contain arbitrary Ruby objects. Operation behaviors are dependent on methods defined for the objects. For example, `Mat#solve` works if `K#==`, `K#quo`, `K#*` and `K#-` are defined appropriately, where `K` is a class of the elements.
+`:object` matricies with 2-length `Array`s are used as indecies for other `Mat`s.
+
+```ruby
+rquire 'kmat'
+
+Mat.new(2, 2, :float){|i, j| i+j}
+Mat.new(2, 2, :complex){|i, j| Complex.rect(i, j)}
+Mat.new(2, 2, :int){|i, j| i-j}
+Mat.new(2, 2, :bool){|i, j| i==j}
+Mat.new(2, 2, :object){|i, j| Rational(i, j) }
+Mat.new(1, 1).vtype   #=> :float (Mat#vtype returns its value type as a Symbol above)
+```
+
+### Sort, stacking and logical operations
+```ruby
+require 'kmat'
+
+a = Mat[[3, 2, 1], [5, -3, 7]]
+a.sort(:row)  #=> [1, 2, 3; -3, 5, 7]
+a.rsort(:col) #=> [5, 2, 7; 3, -3, 1]
+a.flip(:both) #=> [7, -3, 5; 1, 2, 3]
+a.t           #=> [3, 5; 2, -3; 1, 7] (transpose)
+b = Mat.range(2)
+Mat.blocks([[a, b], [b, a]]) #=> [3, 2, 1, 0; 5, -3, 7, 1; 0, 3, 2, 1; 1, 5, -3, 7]
+Mat.vstack(a, a); Mat.hstack(a, b)
+a.gt(b)       #=> [true, true, true; true, false, true] (numpy-like broadcasting)
+a.eq(b); a.ne(b); a.ge(b); a.lt(b); a.le(b)
+a.max         #=> 7
+a.maximum(b)  #=> [3, 2, 1; 5, 1, 7]
+Mat.maximum(a, b.repmat(1, 3), Mat.randn(2, 3))
+              #=> Mat.maximum can recieve arbitrary number of arguments but do not broadcast automatically
+```
+
+### Linear algebraic operations
+Most of them are useing BLAS/LAPACK as a back-end.
+```ruby
+require 'kmat'
+
+a, b = Mat.randn(3, 3), Mat.rand(3, 1)
+a.ls(b)          # ls means least_squares, the return x mimimize a.mprod(x)-b
+a.evd            # eigendecomposition
+a.svd            # singular value decomposition
+a.lup            # LUP decomposition
+a.det            # determinant
+a.qr             # QR decomposition
+Mat.rand_orth(3) # Random orthogonal matrix
+a.tr             # trace
+```
+
+### Copying elements
+```ruby
+require 'kmat'
+
+a, b = Mat.randn(2, 2), Mat.randn(2, 2)
+a.dup           # dup/clone are like Array#dup/clone
+a.copy_from(b)  # it is equivalent to a[] = b, value type is dependent on the reciever
+a.replace(b[])  # Mat#replace copies submatrix relation and value type (Mat#copy_from do not)
+a.fill(1.5)     #=> [1.5, 1.5; 1.5, 1.5] (destructive)
+Marshal.load(Marshal.dump(a))
+                # Marshal.dump/load are available
+```
+
+### Random
+```ruby
+require 'kmat'
+
+Mat.randn(2, 2, random: Random.new) # In kmat, methods using random value, the generator can be specified by keyword `random'
+$MatRandom = Random.new             # Or substitute into $MatRandom (default value of $MatRandom is Random::DEFAULT)
+Random.new.randn                    # Random#randn returns a random value following N(0, 1)
+randn()                             # Kernel#randn is equivalent to Random::DEFAULT.randn
+```
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cycloawaodorin/kmat.
+
+## License
+Kmat 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 version3 of the License, or (at your option) any later version.
+
+Kmat 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 the gem; see the file LICENSE.md. If not, see the website of [GPL](https://www.gnu.org/licenses/).
+
+## `/ext/lapack_headers/*.h`
+The header files under `/ext/lapack_headers/` directory are modified or copied version of an Azalea Clive's product or Intel Corp's products. The original versions are distributed at the following.
+
+`blas.h` is distributed at [BLASの簡単な使い方](http://azalea.s35.xrea.com/blas/sample1.html).
+
+`lapacke.h`, `lapacke_config.h`, `lapacke_mangling.h` and `lapacke_utils.h` are distributed at the website of [LAPACKE](http://www.netlib.org/lapack/#_standard_c_language_apis_for_lapack) under modified BSD license.

data/Rakefile

@@ -0,0 +1,26 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+task :build => :compile
+
+def istrue(key)
+	val = ENV[key]
+	if val.nil?
+		false
+	elsif val.kind_of?(String)
+		if val == '0' || val =~ /false/i || val =~ /nil/i
+			false
+		else
+			true
+		end
+	else
+		raise "unknown environment value type #{val.class} for ENV['#{key}']"
+	end
+end
+
+Rake::ExtensionTask.new("kmat") do |ext|
+  ext.lib_dir = "lib/kmat"
+  ext.config_options = %w|debug| if istrue('KMAT_DEBUG')
+end
+
+task :default => [:clobber, :compile, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kmat"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/kmat/arith/binary.c

@@ -0,0 +1,1121 @@
+#include "../kmat.h"
+
+// element-wise arithmetic operations
+static void
+km_add_d(double *y, double *x, void *null)
+{
+	*y += *x;
+}
+static void
+km_add_z(COMPLEX *y, COMPLEX *x, void *null)
+{
+	*y += *x;
+}
+static void
+km_add_i(int *y, int *x, void *null)
+{
+	*y += *x;
+}
+static void
+km_add_b(bool *y, bool *x, void *null)
+{
+	*y = XOR(*y, *x);
+}
+static void
+km_add_v(VALUE *y, VALUE *x, void *null)
+{
+	*y = rb_funcall(*y, id_op_plus, 1, *x);
+}
+VALUE
+kmm_mat_add_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy=km_mat2smat(self), *sx=km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sy, sx);
+	if ( sy->vtype == VT_DOUBLE ) {
+		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
+			double alpha = 1.0; int len = LENGTH(sy), ione=1;
+			daxpy_(&len, &alpha, sx->dbody, &ione, sy->dbody, &ione);
+		} else if ( sy->stype != ST_RSUB && sx->stype != ST_RSUB ) {
+			double alpha = 1.0; int incy, stepy, incx, stepx;
+			if ( sy->trans ) {
+				incy = sy->ld; stepy = 1;
+			} else {
+				incy = 1; stepy = sy->ld;
+			}
+			if ( sx->trans ) {
+				incx = sx->ld; stepx = 1;
+			} else {
+				incx = 1; stepx = sx->ld;
+			}
+			for ( int i=0; i<(sy->n); i++ ) {
+				daxpy_(&(sy->m), &alpha, (sx->dbody)+(i*stepx), &incx, (sy->dbody)+(i*stepy), &incy);
+			}
+		} else {
+			km_smat_each2_d(sy, sx, km_add_d, NULL);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
+			COMPLEX alpha = cpack(1.0, 0.0); int len = LENGTH(sy), ione=1;
+			zaxpy_(&len, &alpha, sx->zbody, &ione, sy->zbody, &ione);
+		} else if ( sy->stype != ST_RSUB && sx->stype != ST_RSUB ) {
+			COMPLEX alpha = cpack(1.0, 0.0); int incy, stepy, incx, stepx;
+			if ( sy->trans ) {
+				incy = sy->ld; stepy = 1;
+			} else {
+				incy = 1; stepy = sy->ld;
+			}
+			if ( sx->trans ) {
+				incx = sx->ld; stepx = 1;
+			} else {
+				incx = 1; stepx = sx->ld;
+			}
+			for ( int i=0; i<(sy->n); i++ ) {
+				zaxpy_(&(sy->m), &alpha, (sx->zbody)+(i*stepx), &incx, (sy->zbody)+(i*stepy), &incy);
+			}
+		} else {
+			km_smat_each2_z(sy, sx, km_add_z, NULL);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		km_smat_each2_i(sy, sx, km_add_i, NULL);
+	} else if ( sy->vtype == VT_BOOL ) {
+		km_smat_each2_b(sy, sx, km_add_b, NULL);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_add_v, NULL);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_sub_d(double *y, double *x, void *null)
+{
+	*y -= *x;
+}
+static void
+km_sub_z(COMPLEX *y, COMPLEX *x, void *null)
+{
+	*y -= *x;
+}
+static void
+km_sub_i(int *y, int *x, void *null)
+{
+	*y -= *x;
+}
+static void
+km_sub_v(VALUE *y, VALUE *x, void *null)
+{
+	*y = rb_funcall(*y, id_op_minus, 1, *x);
+}
+VALUE
+kmm_mat_sub_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy=km_mat2smat(self), *sx=km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sy, sx);
+	if ( sy->vtype == VT_DOUBLE ) {
+		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
+			double alpha = -1.0; int len = LENGTH(sy), ione=1;
+			daxpy_(&len, &alpha, sx->dbody, &ione, sy->dbody, &ione);
+		} else if ( sy->stype != ST_RSUB && sx->stype != ST_RSUB ) {
+			double alpha = -1.0; int incy, stepy, incx, stepx;
+			if ( sy->trans ) {
+				incy = sy->ld; stepy = 1;
+			} else {
+				incy = 1; stepy = sy->ld;
+			}
+			if ( sx->trans ) {
+				incx = sx->ld; stepx = 1;
+			} else {
+				incx = 1; stepx = sx->ld;
+			}
+			for ( int i=0; i<(sy->n); i++ ) {
+				daxpy_(&(sy->m), &alpha, (sx->dbody)+(i*stepx), &incx, (sy->dbody)+(i*stepy), &incy);
+			}
+		} else {
+			km_smat_each2_d(sy, sx, km_sub_d, NULL);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
+			COMPLEX alpha = cpack(-1.0, 0.0); int len = LENGTH(sy), ione=1;
+			zaxpy_(&len, &alpha, sx->zbody, &ione, sy->zbody, &ione);
+		} else if ( sy->stype != ST_RSUB && sx->stype != ST_RSUB ) {
+			COMPLEX alpha = cpack(-1.0, 0.0); int incy, stepy, incx, stepx;
+			if ( sy->trans ) {
+				incy = sy->ld; stepy = 1;
+			} else {
+				incy = 1; stepy = sy->ld;
+			}
+			if ( sx->trans ) {
+				incx = sx->ld; stepx = 1;
+			} else {
+				incx = 1; stepx = sx->ld;
+			}
+			for ( int i=0; i<(sy->n); i++ ) {
+				zaxpy_(&(sy->m), &alpha, (sx->zbody)+(i*stepx), &incx, (sy->zbody)+(i*stepy), &incy);
+			}
+		} else {
+			km_smat_each2_z(sy, sx, km_sub_z, NULL);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		km_smat_each2_i(sy, sx, km_sub_i, NULL);
+	} else if ( sy->vtype == VT_BOOL ) {
+		km_smat_each2_b(sy, sx, km_add_b, NULL); // subtract is the same as add for boolean
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_sub_v, NULL);
+	} else {
+		rb_raise(km_eInternal, "unkown value type");
+	}
+	return self;
+}
+
+static void
+km_mul_d(double *y, double *x, void *null)
+{
+	*y *= *x;
+}
+static void
+km_mul_z(COMPLEX *y, COMPLEX *x, void *null)
+{
+	*y *= *x;
+}
+static void
+km_mul_i(int *y, int *x, void *null)
+{
+	*y *= *x;
+}
+static void
+km_mul_b(bool *y, bool *x, void *null)
+{
+	*y = ( *y && *x );
+}
+static void
+km_mul_v(VALUE *y, VALUE *x, void *null)
+{
+	*y = rb_funcall(*y, id_op_mul, 1, *x);
+}
+VALUE
+kmm_mat_e_mul_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy=km_mat2smat(self), *sx=km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sy, sx);
+	if ( sy->vtype == VT_DOUBLE ) {
+		km_smat_each2_d(sy, sx, km_mul_d, NULL);
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		km_smat_each2_z(sy, sx, km_mul_z, NULL);
+	} else if ( sy->vtype == VT_INT ) {
+		km_smat_each2_i(sy, sx, km_mul_i, NULL);
+	} else if ( sy->vtype == VT_BOOL ) {
+		km_smat_each2_b(sy, sx, km_mul_b, NULL);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_mul_v, NULL);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_div_d(double *y, double *x, void *null)
+{
+	if ( *x == 0.0 ) {
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	}
+	*y /= *x;
+}
+static void
+km_div_z(COMPLEX *y, COMPLEX *x, void *null)
+{
+	if ( *x == cpack(0.0, 0.0) ) {
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	}
+	*y /= *x;
+}
+static void
+km_div_i(int *y, int *x, void *null)
+{
+	if ( *x == 0 ) {
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	}
+	*y /= *x;
+}
+static void
+km_div_v(VALUE *y, VALUE *x, void *null)
+{
+	*y = rb_funcall(*y, id_op_div, 1, *x);
+}
+VALUE
+kmm_mat_e_div_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy=km_mat2smat(self), *sx=km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sy, sx);
+	if ( sy->vtype == VT_DOUBLE ) {
+		km_smat_each2_d(sy, sx, km_div_d, NULL);
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		km_smat_each2_z(sy, sx, km_div_z, NULL);
+	} else if ( sy->vtype == VT_INT ) {
+		km_smat_each2_i(sy, sx, km_div_i, NULL);
+	} else if ( sy->vtype == VT_BOOL ) {
+		rb_raise(km_eVT, "division for boolean is meaningless");
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_div_v, NULL);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_s_add_d(double *ent, void *data)
+{
+	double *val = (double *)data;
+	*ent += *val;
+}
+static void
+km_s_add_z(COMPLEX *ent, void *data)
+{
+	COMPLEX *val = (COMPLEX *)data;
+	*ent += *val;
+}
+static void
+km_s_add_i(int *ent, void *data)
+{
+	int *val = (int *)data;
+	*ent += *val;
+}
+static void
+km_s_add_b(bool *ent, void *data)
+{
+	bool *val = (bool *)data;
+	*ent = XOR(*ent, *val);
+}
+static void
+km_s_add_v(VALUE *ent, void *data)
+{
+	VALUE val = (VALUE)data;
+	*ent = rb_funcall(*ent, id_op_plus, 1, val);
+}
+VALUE
+kmm_mat_s_add_destl(VALUE self, VALUE vval)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double val = NUM2DBL(vval);
+		if ( sy->stype == ST_FULL ) {
+			double alpha=1.0;
+			int len=LENGTH(sy), ione=1, izero=0;
+			daxpy_(&len, &alpha, &val, &izero, sy->dbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			double alpha=1.0;
+			int ione=1, izero=0;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					daxpy_(&(sy->n), &alpha, &val, &izero, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					daxpy_(&(sy->m), &alpha, &val, &izero, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_d(sy, km_s_add_d, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		COMPLEX val = km_v2c(vval);
+		if ( sy->stype == ST_FULL ) {
+			COMPLEX alpha=cpack(1.0, 0.0);
+			int len=LENGTH(sy), ione=1, izero=0;
+			zaxpy_(&len, &alpha, &val, &izero, sy->zbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			COMPLEX alpha=cpack(1.0, 0.0);
+			int ione=1, izero=0;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					zaxpy_(&(sy->n), &alpha, &val, &izero, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					zaxpy_(&(sy->m), &alpha, &val, &izero, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_z(sy, km_s_add_z, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		int val = NUM2INT(vval);
+		km_smat_each_i(sy, km_s_add_i, (void *)&val);
+	} else if ( sy->vtype == VT_BOOL ) {
+		bool val = RTEST(vval);
+		km_smat_each_b(sy, km_s_add_b, (void *)&val);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each_v(sy, km_s_add_v, (void *)vval);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_s_sub_d(double *ent, void *data)
+{
+	double *val = (double *)data;
+	*ent -= *val;
+}
+static void
+km_s_sub_z(COMPLEX *ent, void *data)
+{
+	COMPLEX *val = (COMPLEX *)data;
+	*ent -= *val;
+}
+static void
+km_s_sub_i(int *ent, void *data)
+{
+	int *val = (int *)data;
+	*ent -= *val;
+}
+static void
+km_s_sub_v(VALUE *ent, void *data)
+{
+	VALUE val = (VALUE)data;
+	*ent = rb_funcall(*ent, id_op_minus, 1, val);
+}
+VALUE
+kmm_mat_s_sub_destl(VALUE self, VALUE vval)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double val = NUM2DBL(vval);
+		if ( sy->stype == ST_FULL ) {
+			double alpha=-1.0;
+			int len=LENGTH(sy), ione=1, izero=0;
+			daxpy_(&len, &alpha, &val, &izero, sy->dbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			double alpha=-1.0;
+			int ione=1, izero=0;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					daxpy_(&(sy->n), &alpha, &val, &izero, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					daxpy_(&(sy->m), &alpha, &val, &izero, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_d(sy, km_s_sub_d, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		COMPLEX val = km_v2c(vval);
+		if ( sy->stype == ST_FULL ) {
+			COMPLEX alpha=cpack(-1.0, 0.0);
+			int len=LENGTH(sy), ione=1, izero=0;
+			zaxpy_(&len, &alpha, &val, &izero, sy->zbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			COMPLEX alpha=cpack(-1.0, 0.0);
+			int ione=1, izero=0;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					zaxpy_(&(sy->n), &alpha, &val, &izero, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					zaxpy_(&(sy->m), &alpha, &val, &izero, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_z(sy, km_s_sub_z, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		int val = NUM2INT(vval);
+		km_smat_each_i(sy, km_s_sub_i, (void *)&val);
+	} else if ( sy->vtype == VT_BOOL ) {
+		bool val = RTEST(vval);
+		km_smat_each_b(sy, km_s_add_b, (void *)&val); // subtract is the same as add for boolean
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each_v(sy, km_s_sub_v, (void *)vval);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+
+static void
+km_s_mul_d(double *ent, void *data)
+{
+	double *val = (double *)data;
+	*ent *= *val;
+}
+static void
+km_s_mul_z(COMPLEX *ent, void *data)
+{
+	COMPLEX *val = (COMPLEX *)data;
+	*ent *= *val;
+}
+static void
+km_s_mul_i(int *ent, void *data)
+{
+	int *val = (int *)data;
+	*ent *= *val;
+}
+static void
+km_s_mul_v(VALUE *ent, void *data)
+{
+	VALUE val = (VALUE)data;
+	*ent = rb_funcall(*ent, id_op_mul, 1, val);
+}
+VALUE
+kmm_mat_s_mul_destl(VALUE self, VALUE vval)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double val = NUM2DBL(vval);
+		if ( sy->stype == ST_FULL ) {
+			int len=LENGTH(sy), ione=1;
+			dscal_(&len, &val, sy->dbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			int ione=1;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					dscal_(&(sy->n), &val, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					dscal_(&(sy->m), &val, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_d(sy, km_s_mul_d, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		COMPLEX val = km_v2c(vval);
+		if ( sy->stype == ST_FULL ) {
+			int len=LENGTH(sy), ione=1;
+			zscal_(&len, &val, sy->zbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			int ione=1;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					zscal_(&(sy->n), &val, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					zscal_(&(sy->m), &val, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_z(sy, km_s_mul_z, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		int val = NUM2INT(vval);
+		km_smat_each_i(sy, km_s_mul_i, (void *)&val);
+	} else if ( sy->vtype == VT_BOOL ) {
+		if ( RTEST(vval) ) {
+			// nothing to do
+		} else {
+			kmm_mat_fill(self, Qfalse);
+		}
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each_v(sy, km_s_mul_v, (void *)vval);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_s_div_i(int *ent, void *data)
+{
+	int *val = (int *)data;
+	*ent /= *val;
+}
+static void
+km_s_div_v(VALUE *ent, void *data)
+{
+	VALUE val = (VALUE)data;
+	*ent = rb_funcall(*ent, id_op_div, 1, val);
+}
+VALUE
+kmm_mat_s_div_destl(VALUE self, VALUE vval)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double val = NUM2DBL(vval);
+		if ( val == 0.0 ) { rb_raise(rb_eZeroDivError, "divided by 0"); }
+		val = 1.0/val;
+		if ( sy->stype == ST_FULL ) {
+			int len=LENGTH(sy), ione=1;
+			dscal_(&len, &val, sy->dbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			int ione=1;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					dscal_(&(sy->n), &val, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					dscal_(&(sy->m), &val, (sy->dbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_d(sy, km_s_mul_d, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		COMPLEX val = km_v2c(vval);
+		if ( val == cpack(0.0, 0.0) ) { rb_raise(rb_eZeroDivError, "divided by 0"); }
+		val = cpack(1.0, 0.0)/val;
+		if ( sy->stype == ST_FULL ) {
+			int len=LENGTH(sy), ione=1;
+			zscal_(&len, &val, sy->zbody, &ione);
+		} else if ( sy->stype == ST_SSUB ) {
+			int ione=1;
+			if ( sy->trans ) {
+				for ( int i=0; i<(sy->m); i++ ) {
+					zscal_(&(sy->n), &val, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			} else {
+				for ( int i=0; i<(sy->n); i++ ) {
+					zscal_(&(sy->m), &val, (sy->zbody)+(i*(sy->ld)), &ione);
+				}
+			}
+		} else {
+			km_smat_each_z(sy, km_s_mul_z, (void *)&val);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		int val = NUM2INT(vval);
+		if ( val == 0 ) { rb_raise(rb_eZeroDivError, "divided by 0"); }
+		km_smat_each_i(sy, km_s_div_i, (void *)&val);
+	} else if ( sy->vtype == VT_BOOL ) {
+		rb_raise(km_eVT, "division for boolean is meaningless");
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each_v(sy, km_s_div_v, (void *)vval);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_add_times_d(double *y, double *x, void *data)
+{
+	double *a = (double *)data;
+	*y += ( (*x) * (*a) );
+}
+static void
+km_add_times_z(COMPLEX *y, COMPLEX *x, void *data)
+{
+	COMPLEX *a = (COMPLEX *)data;
+	*y += ( (*x) * (*a) );
+}
+static void
+km_add_times_i(int *y, int *x, void *data)
+{
+	int *a = (int *)data;
+	*y += ( (*x) * (*a) );
+}
+static void
+km_add_times_v(VALUE *y, VALUE *x, void *data)
+{
+	VALUE a = (VALUE)data;
+	a = rb_funcall(*x, id_op_mul, 1, a);
+	*y = rb_funcall(*y, id_op_plus, 1, a);
+}
+VALUE
+kmm_mat_add_times_destl(VALUE self, VALUE other, VALUE valpha)
+{
+	km_check_frozen(self);
+	SMAT *sy=km_mat2smat(self), *sx=km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sx, sy);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double alpha = NUM2DBL(valpha);
+		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
+			int len = LENGTH(sy), ione=1;
+			daxpy_(&len, &alpha, sx->dbody, &ione, sy->dbody, &ione);
+		} else if ( sy->stype != ST_RSUB &&  sx->stype != ST_RSUB ) {
+			int incy, stepy, incx, stepx;
+			if ( sy->trans ) {
+				incy = sy->ld; stepy = 1;
+			} else {
+				incy = 1; stepy = sy->ld;
+			}
+			if ( sx->trans ) {
+				incx = sx->ld; stepx = 1;
+			} else {
+				incx = 1; stepx = sx->ld;
+			}
+			for ( int i=0; i<(sy->n); i++ ) {
+				daxpy_(&(sy->m), &alpha, (sx->dbody)+(i*stepx), &incx, (sy->dbody)+(i*stepy), &incy);
+			}
+		} else {
+			km_smat_each2_d(sy, sx, km_add_times_d, (void *)&alpha);
+		}
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		COMPLEX alpha = km_v2c(valpha);
+		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
+			int len = LENGTH(sy), ione=1;
+			zaxpy_(&len, &alpha, sx->zbody, &ione, sy->zbody, &ione);
+		} else if ( sy->stype != ST_RSUB &&  sx->stype != ST_RSUB ) {
+			int incy, stepy, incx, stepx;
+			if ( sy->trans ) {
+				incy = sy->ld; stepy = 1;
+			} else {
+				incy = 1; stepy = sy->ld;
+			}
+			if ( sx->trans ) {
+				incx = sx->ld; stepx = 1;
+			} else {
+				incx = 1; stepx = sx->ld;
+			}
+			for ( int i=0; i<(sy->n); i++ ) {
+				zaxpy_(&(sy->m), &alpha, (sx->zbody)+(i*stepx), &incx, (sy->zbody)+(i*stepy), &incy);
+			}
+		} else {
+			km_smat_each2_z(sy, sx, km_add_times_z, (void *)&alpha);
+		}
+	} else if ( sy->vtype == VT_INT ) {
+		int alpha = NUM2INT(valpha);
+		km_smat_each2_i(sy, sx, km_add_times_i, (void *)&alpha);
+	} else if ( sy->vtype == VT_BOOL ) {
+		if ( RTEST(valpha) ) {
+			kmm_mat_add_destl(self, other);
+		} else {
+			// nothing to do
+		}
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_add_times_v, (void *)valpha);
+	} else {
+		rb_raise(km_eVT, "unknown value type");
+	}
+	return self;
+}
+
+// element-wise max/min operations of two matricies
+static void
+km_maximum_d(double *ey, double *ex, void *null)
+{
+	if ( *ey < *ex ) {
+		*ey = *ex;
+	}
+}
+static void
+km_maximum_i(int *ey, int *ex, void *null)
+{
+	if ( *ey < *ex ) {
+		*ey = *ex;
+	}
+}
+static void
+km_maximum_b(bool *ey, bool *ex, void *null)
+{
+	if ( *ex ) {
+		*ey = true;
+	}
+}
+static void
+km_maximum_v(VALUE *ey, VALUE *ex, void *null)
+{
+	if ( rb_funcall(*ey, id_op_lt, 1, *ex) ) {
+		*ey = *ex;
+	}
+}
+VALUE
+kmm_mat_maximum_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self), *sx = km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sx, sy);
+	if ( sy->vtype == VT_DOUBLE ) {
+		km_smat_each2_d(sy, sx, km_maximum_d, NULL);
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		VALUE oself = kmm_mat_to_omat(self);
+		sy = km_mat2smat(oself);
+		sx = km_mat2smat(kmm_mat_to_omat(other));
+		km_smat_each2_v(sy, sx, km_maximum_v, NULL);
+		kmm_mat_copy_from(self, oself);
+	} else if ( sy->vtype == VT_INT ) {
+		km_smat_each2_i(sy, sx, km_maximum_i, NULL);
+	} else if ( sy->vtype == VT_BOOL ) {
+		km_smat_each2_b(sy, sx, km_maximum_b, NULL);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_maximum_v, NULL);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_s_maximum_d(double *ey, void *data)
+{
+	double *val = (double *)data;
+	if ( *ey < *val ) {
+		*ey = *val;
+	}
+}
+static void
+km_s_maximum_i(int *ey, void *data)
+{
+	int *val = (int *)data;
+	if ( *ey < *val ) {
+		*ey = *val;
+	}
+}
+static void
+km_s_maximum_b(bool *ey, void *data)
+{
+	bool *val = (bool *)data;
+	if ( *val ) {
+		*ey = true;
+	}
+}
+static void
+km_s_maximum_v(VALUE *ey, void *data)
+{
+	VALUE val = (VALUE)data;
+	if ( rb_funcall(*ey, id_op_lt, 1, val) ) {
+		*ey = val;
+	}
+}
+VALUE
+kmm_mat_s_maximum_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double data = NUM2DBL(other);
+		km_smat_each_d(sy, km_s_maximum_d, (void *)&data);
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		VALUE oself = kmm_mat_to_omat(self);
+		sy = km_mat2smat(oself);
+		km_smat_each_v(sy, km_s_maximum_v, (void *)other);
+		kmm_mat_copy_from(self, oself);
+	} else if ( sy->vtype == VT_INT ) {
+		int data = NUM2INT(other);
+		km_smat_each_i(sy, km_s_maximum_i, (void *)&data);
+	} else if ( sy->vtype == VT_BOOL ) {
+		bool data = RTEST(other);
+		km_smat_each_b(sy, km_s_maximum_b, (void *)&data);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each_v(sy, km_s_maximum_v, (void *)other);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_minimum_d(double *ey, double *ex, void *null)
+{
+	if ( *ex < *ey ) {
+		*ey = *ex;
+	}
+}
+static void
+km_minimum_i(int *ey, int *ex, void *null)
+{
+	if ( *ex < *ey ) {
+		*ey = *ex;
+	}
+}
+static void
+km_minimum_b(bool *ey, bool *ex, void *null)
+{
+	if ( !*ex ) {
+		*ey = false;
+	}
+}
+static void
+km_minimum_v(VALUE *ey, VALUE *ex, void *null)
+{
+	if ( rb_funcall(*ex, id_op_lt, 1, *ey) ) {
+		*ey = *ex;
+	}
+}
+VALUE
+kmm_mat_minimum_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self), *sx = km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sx, sy);
+	if ( sy->vtype == VT_DOUBLE ) {
+		km_smat_each2_d(sy, sx, km_minimum_d, NULL);
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		VALUE oself = kmm_mat_to_omat(self);
+		sy = km_mat2smat(oself);
+		sx = km_mat2smat(kmm_mat_to_omat(other));
+		km_smat_each2_v(sy, sx, km_minimum_v, NULL);
+		kmm_mat_copy_from(self, oself);
+	} else if ( sy->vtype == VT_INT ) {
+		km_smat_each2_i(sy, sx, km_minimum_i, NULL);
+	} else if ( sy->vtype == VT_BOOL ) {
+		km_smat_each2_b(sy, sx, km_minimum_b, NULL);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each2_v(sy, sx, km_minimum_v, NULL);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+static void
+km_s_minimum_d(double *ey, void *data)
+{
+	double *val = (double *)data;
+	if ( *val < *ey ) {
+		*ey = *val;
+	}
+}
+static void
+km_s_minimum_i(int *ey, void *data)
+{
+	int *val = (int *)data;
+	if ( *val < *ey ) {
+		*ey = *val;
+	}
+}
+static void
+km_s_minimum_b(bool *ey, void *data)
+{
+	bool *val = (bool *)data;
+	if ( !*val ) {
+		*ey = false;
+	}
+}
+static void
+km_s_minimum_v(VALUE *ey, void *data)
+{
+	VALUE val = (VALUE)data;
+	if ( rb_funcall(val, id_op_lt, 1, *ey) ) {
+		*ey = val;
+	}
+}
+VALUE
+kmm_mat_s_minimum_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	if ( sy->vtype == VT_DOUBLE ) {
+		double data = NUM2DBL(other);
+		km_smat_each_d(sy, km_s_minimum_d, (void *)&data);
+	} else if ( sy->vtype == VT_COMPLEX ) {
+		VALUE oself = kmm_mat_to_omat(self);
+		sy = km_mat2smat(oself);
+		km_smat_each_v(sy, km_s_minimum_v, (void *)other);
+		kmm_mat_copy_from(self, oself);
+	} else if ( sy->vtype == VT_INT ) {
+		int data = NUM2INT(other);
+		km_smat_each_i(sy, km_s_minimum_i, (void *)&data);
+	} else if ( sy->vtype == VT_BOOL ) {
+		bool data = RTEST(other);
+		km_smat_each_b(sy, km_s_minimum_b, (void *)&data);
+	} else if ( sy->vtype == VT_VALUE ) {
+		km_smat_each_v(sy, km_s_minimum_v, (void *)other);
+	} else {
+		rb_raise(km_eInternal, "unknown value type");
+	}
+	return self;
+}
+
+// pow, hypot
+static void
+km_pow_d(double *b, double *e, void *null)
+{
+	*b = pow(*b, *e);
+}
+static void
+km_pow_z(COMPLEX *b, COMPLEX *e, void *null)
+{
+	*b = cpow(*b, *e);
+}
+static void
+km_pow_i(int *b, int *e, void *null)
+{
+	if ( *e < 0 ) {
+		rb_raise(rb_const_get(rb_mMath, id_DomainError), "the exponent must be non-negative");
+	}
+	int a = *b;
+	*b = 1;
+	for (int i=*e; i>0; i>>=1) {
+		if ( i & 1 ) {
+			*b *= a;
+		}
+		a *= a;
+	}
+}
+static void
+km_pow_b(bool *b, bool *e, void *null)
+{
+	*b = ( *b || !*e );
+}
+static void
+km_pow_v(VALUE *b, VALUE *e, void *null)
+{
+	*b = rb_funcall(*b, id_op_pow, 1, *e);
+}
+VALUE
+kmm_mat_pow_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sb = km_mat2smat(self), *se = km_mat2smat(other);
+	if ( sb->vtype != se->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sb, se);
+	VT_SWITCH( sb->vtype,
+		km_smat_each2_d(sb, se, km_pow_d, NULL);,
+		km_smat_each2_z(sb, se, km_pow_z, NULL);,
+		km_smat_each2_i(sb, se, km_pow_i, NULL);,
+		km_smat_each2_b(sb, se, km_pow_b, NULL);,
+		km_smat_each2_v(sb, se, km_pow_v, NULL);
+	);
+	return self;
+}
+
+static void
+km_s_pow_d(double *b, void *data)
+{
+	double *e = (double *)data;
+	*b = pow(*b, *e);
+}
+static void
+km_s_pow_z(COMPLEX *b, void *data)
+{
+	COMPLEX *e = (COMPLEX *)data;
+	*b = cpow(*b, *e);
+}
+static void
+km_s_pow_i(int *b, void *data)
+{
+	int *e = (int *)data;
+	if ( *e < 0 ) {
+		rb_raise(rb_const_get(rb_mMath, id_DomainError), "the exponent must be non-negative");
+	}
+	int a = *b;
+	*b = 1;
+	for (int i=*e; i>0; i>>=1) {
+		if ( i & 1 ) {
+			*b *= a;
+		}
+		a *= a;
+	}
+}
+static void
+km_s_pow_b(bool *b, void *data)
+{
+	bool *e = (bool *)data;
+	*b = ( *b || !*e );
+}
+static void
+km_s_pow_v(VALUE *b, void *data)
+{
+	VALUE e = (VALUE)data;
+	*b = rb_funcall(*b, id_op_pow, 1, e);
+}
+VALUE
+kmm_mat_s_pow_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sb = km_mat2smat(self);
+	VT_SWITCH( sb->vtype,
+		double data=NUM2DBL(other); km_smat_each_d(sb, km_s_pow_d, (void *)&data);,
+		COMPLEX data=km_v2c(other); km_smat_each_z(sb, km_s_pow_z, (void *)&data);,
+		int data=NUM2INT(other); km_smat_each_i(sb, km_s_pow_i, (void *)&data);,
+		bool data=RTEST(other); km_smat_each_b(sb, km_s_pow_b, (void *)&data);,
+		km_smat_each_v(sb, km_s_pow_v, (void *)other);
+	);
+	return self;
+}
+
+static void
+km_hypot_d(double *y, double *x, void *null)
+{
+	*y = hypot(*y, *x);
+}
+static void
+km_hypot_z(COMPLEX *y, COMPLEX *x, void *null)
+{
+	*y = csqrt((*y)*(*y)+(*x)*(*x));
+}
+static void
+km_hypot_v(VALUE *y, VALUE *x, void *null)
+{
+	*y = rb_funcall(rb_mMath, id_hypot, 2, *y, *x);
+}
+VALUE
+kmm_mat_hypot_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self), *sx = km_mat2smat(other);
+	if ( sy->vtype != sx->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	CHECK_SAME_SIZE(sy, sx);
+	VT_SWITCH( sy->vtype,
+		km_smat_each2_d(sy, sx, km_hypot_d, NULL);,
+		km_smat_each2_z(sy, sx, km_hypot_z, NULL);,
+		rb_raise(km_eVT, "Mat#hypot is not available for int matricies");,
+		km_smat_each2_b(sy, sx, km_add_b, NULL);,
+		km_smat_each2_v(sy, sx, km_hypot_v, NULL);
+	);
+	return self;
+}
+
+static void
+km_s_hypot_d(double *y, void *data)
+{
+	double *x = (double *)data;
+	*y = hypot(*y, *x);
+}
+static void
+km_s_hypot_z(COMPLEX *y, void *data)
+{
+	COMPLEX *x = (COMPLEX *)data;
+	*y = csqrt((*y)*(*y)+(*x)*(*x));
+}
+static void
+km_s_hypot_v(VALUE *y, void *data)
+{
+	*y = rb_funcall(rb_mMath, id_hypot, 2, *y, (VALUE)data);
+}
+VALUE
+kmm_mat_s_hypot_destl(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *sy = km_mat2smat(self);
+	VT_SWITCH( sy->vtype,
+		double data=NUM2DBL(other); km_smat_each_d(sy, km_s_hypot_d, (void *)&data);,
+		COMPLEX data=km_v2c(other); km_smat_each_z(sy, km_s_hypot_z, (void *)&data);,
+		rb_raise(km_eVT, "Mat#hypot is not available for int matricies");,
+		bool data=RTEST(other); km_smat_each_b(sy, km_s_add_b, (void *)&data);,
+		km_smat_each_v(sy, km_s_hypot_v, (void *)other);
+	);
+	return self;
+}