kmat 0.0.3

data/ext/kmat/linalg/vla.c

@@ -0,0 +1,102 @@
+#include "../kmat.h"
+
+struct km_vmat_solve_arg {
+	SMAT *sx, *sa, *sb;
+	VALUE *a;
+	LAWORK x;
+};
+static VALUE
+km_vmat_solve_body(VALUE data)
+{
+	struct km_vmat_solve_arg *a = (struct km_vmat_solve_arg *)data;
+	int n=a->sx->m, nrhs=a->sx->n;
+	km_check_size(4, a->sa->m,n, a->sa->n,n, a->sb->m,n, a->sb->n,nrhs);
+	
+	KALLOCc(a->a, a->sa);
+	km_alloc_if_needed(a->sx, &(a->x));
+	km_copy2work(a->x.v, a->x.ld, a->sb);
+	VALUE zero=INT2NUM(0);
+	
+	// forward elimination
+	for ( int k=0; k<n; k++ ) {
+		if ( rb_funcall((a->a)[k+k*n], id_op_eq, 1, zero) ) {
+			for ( int i=k+1; i<n; i++ ) {
+				if ( !rb_funcall((a->a)[i+k*n], id_op_eq, 1, zero) ) {
+					for ( int j=k; j<n; j++ ) {
+						SWAP(VALUE, (a->a)[k+j*n], (a->a)[i+j*n]);
+					}
+					for ( int j=0; j<nrhs; j++ ) {
+						SWAP(VALUE, (a->x.v)[k+j*(a->x.ld)], (a->x.v)[i+j*(a->x.ld)]);
+					}
+					goto nonsingular;
+				}
+			}
+			rb_raise(km_eUncomp, "matrix is singular");
+			nonsingular: ;
+		}
+		VALUE akk = (a->a)[k+k*n];
+		for ( int j=k+1; j<n; j++ ) {
+			(a->a)[k+j*n] = rb_funcall((a->a)[k+j*n], id_quo, 1, akk);
+		}
+		for ( int j=0; j<nrhs; j++ ) {
+			(a->x.v)[k+j*(a->x.ld)] = rb_funcall((a->x.v)[k+j*(a->x.ld)], id_quo, 1, akk);
+		}
+		for( int i=k+1; i<n; i++ ) {
+			VALUE aik = (a->a)[i+k*n];
+			for ( int j=k+1; j<n; j++ ) {
+				VALUE tmp = rb_funcall(aik, id_op_mul, 1, (a->a)[k+j*n]);
+				(a->a)[i+j*n] = rb_funcall((a->a)[i+j*n], id_op_minus, 1, tmp);
+			}
+			for ( int j=0; j<nrhs; j++ ) {
+				VALUE tmp = rb_funcall(aik, id_op_mul, 1, (a->x.v)[k+j*(a->x.ld)]);
+				(a->x.v)[i+j*(a->x.ld)] = rb_funcall((a->x.v)[i+j*(a->x.ld)], id_op_minus, 1, tmp);
+			}
+		}
+	}
+	
+	// back substitution
+	for ( int k=n-1; k>0; k-- ) {
+		for ( int i=0; i<k; i++ ) {
+			VALUE aik = (a->a)[i+k*n];
+			for ( int j=0; j<nrhs; j++ ) {
+				VALUE tmp = rb_funcall(aik, id_op_mul, 1, (a->x.v)[k+j*(a->x.ld)]);
+				(a->x.v)[i+j*(a->x.ld)] = rb_funcall((a->x.v)[i+j*(a->x.ld)], id_op_minus, 1, tmp);
+			}
+		}
+	}
+	
+	return Qnil;
+}
+static VALUE
+km_vmat_solve_ensure(VALUE data)
+{
+	struct km_vmat_solve_arg *a = (struct km_vmat_solve_arg *)data;
+	
+	ruby_xfree(a->a);
+	km_copy_and_free_if_needed(a->sx, &(a->x));
+	
+	return Qnil;
+}
+VALUE
+km_vmat_solve(VALUE self, VALUE va, VALUE vb)
+{
+	struct km_vmat_solve_arg a; memset(&a, 0, sizeof(a));
+	a.sx=km_mat2smat(self); a.sa=km_mat2smat(va); a.sb=km_mat2smat(vb);
+	km_check_value(3, a.sx, a.sa, a.sb);
+	
+	km_ensure(km_vmat_solve_body, (VALUE)(&a), km_vmat_solve_ensure, (VALUE)(&a));
+	
+	return self;
+}
+
+VALUE
+km_vmat_inverse(VALUE self, VALUE va)
+{
+	SMAT *sx = km_mat2smat(self), *sa = km_mat2smat(va);
+	km_check_value(2, sx, sa);
+	int n = sa->m;
+	km_check_size(3, sx->m,n, sx->n,n, sa->n,n);
+	VALUE ident = km_Mat(n, n, VT_VALUE);
+	kmm_mat_eye(ident);
+	return km_vmat_solve(self, va, ident);
+}

data/ext/kmat/linalg/working.c

@@ -0,0 +1,240 @@
+#include "../kmat.h"
+
+void *
+km_alloc_and_copy(SMAT *smat)
+{
+	void *ret = ruby_xcalloc(int2size_t(LENGTH(smat)), km_sizeof_vt(smat->vtype));
+	km_copy2work(ret, smat->m, smat);
+	return ret;
+}
+
+// use `smat'->body if it can be used
+// otherwise, calloc()
+void
+km_alloc_if_needed(SMAT *smat, LAWORK *lawork)
+{
+	if ( smat->stype != ST_RSUB && !(smat->trans) ) {
+		lawork->body = smat->body;
+		lawork->ld = smat->ld;
+		lawork->need_to_free = false;
+	} else {
+		lawork->body = ruby_xcalloc(int2size_t(smat->m*smat->n), km_sizeof_vt(smat->vtype));
+		lawork->ld = smat->m;
+		lawork->need_to_free = true;
+	}
+}
+
+// km_alloc_if_needed() and copy from `smat'->body if calloc() is called
+void
+km_alloc_and_copy_if_needed(SMAT *smat, LAWORK *lawork)
+{
+	km_alloc_if_needed(smat, lawork);
+	if ( lawork->need_to_free ) {
+		km_copy2work(lawork->body, lawork->ld, smat);
+	}
+}
+
+// km_alloc_if_needed() and 0 clear in any case
+void
+km_alloc_if_needed_and_0clear(SMAT *smat, LAWORK *lawork)
+{
+	km_alloc_if_needed(smat, lawork);
+	if ( lawork->need_to_free ) { return; }
+	if ( smat->vtype == VT_DOUBLE ) {
+		for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) {
+			lawork->d[i+j*lawork->ld] = 0.0;
+		} }
+	} else if ( smat->vtype == VT_COMPLEX ) {
+		for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) {
+			lawork->z[i+j*lawork->ld] = cpack(0.0, 0.0);
+		} }
+	} else if ( smat->vtype == VT_INT ) {
+		for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) {
+			lawork->i[i+j*lawork->ld] = 0;
+		} }
+	} else if ( smat->vtype == VT_BOOL ) {
+		for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) {
+			lawork->b[i+j*lawork->ld] = false;
+		} }
+	} else {
+		for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) {
+			lawork->v[i+j*lawork->ld] = Qfalse;
+		} }
+	}
+}
+
+struct km_c2w_arg {
+	union {
+		void *work;
+		double *dwork;
+		COMPLEX *zwork;
+		int *iwork;
+		bool *bwork;
+		VALUE *vwork;
+	};
+	int ld;
+};
+void
+km_c2w_func_d(double *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	arg->dwork[i+j*arg->ld] = *ent;
+}
+void
+km_c2w_func_z(COMPLEX *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	arg->zwork[i+j*arg->ld] = *ent;
+}
+void
+km_c2w_func_i(int *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	arg->iwork[i+j*arg->ld] = *ent;
+}
+void
+km_c2w_func_b(bool *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	arg->bwork[i+j*arg->ld] = *ent;
+}
+void
+km_c2w_func_v(VALUE *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	arg->vwork[i+j*arg->ld] = *ent;
+}
+void
+km_copy2work(void *work, int ldw, SMAT *smat)
+{
+	if ( smat->stype == ST_FULL && !(smat->trans) && ldw==smat->ld ) {
+		memcpy(work, smat->body, km_sizeof_vt(smat->vtype)*LENGTHs(smat));
+	} else {
+		struct km_c2w_arg data = {{work}, ldw};
+		if ( smat->vtype == VT_DOUBLE ) {
+			if ( smat->stype == ST_RSUB ) {
+				km_smat_each_with_index_d(smat, km_c2w_func_d, &data);
+			} else if ( smat->trans ) {
+				const int one=1;
+				for ( int i=0; i<smat->m; i++ ) {
+					dcopy_(&(smat->n), smat->dbody+(i*smat->ld), &one, data.dwork+i, &ldw);
+				}
+			} else {
+				char str_a[] = "A";
+				dlacpy_(str_a, &(smat->m), &(smat->n), smat->dbody, &(smat->ld), work, &ldw);
+			}
+		} else if ( smat->vtype == VT_COMPLEX ) {
+			if ( smat->stype == ST_RSUB ) {
+				km_smat_each_with_index_z(smat, km_c2w_func_z, &data);
+			} else if ( smat->trans ) {
+				const int one=1;
+				for ( int i=0; i<smat->m; i++ ) {
+					zcopy_(&(smat->n), smat->zbody+(i*smat->ld), &one, data.zwork+i, &ldw);
+				}
+			} else {
+				char str_a[] = "A";
+				zlacpy_(str_a, &(smat->m), &(smat->n), smat->zbody, &(smat->ld), work, &ldw);
+			}
+		} else if ( smat->vtype == VT_INT ) {
+			km_smat_each_with_index_i(smat, km_c2w_func_i, &data);
+		} else if ( smat->vtype == VT_BOOL ) {
+			km_smat_each_with_index_b(smat, km_c2w_func_b, &data);
+		} else if ( smat->vtype == VT_VALUE ) {
+			km_smat_each_with_index_v(smat, km_c2w_func_v, &data);
+		} else {
+			rb_raise(km_eInternal, "unknown value type");
+		}
+	}
+}
+void
+km_cfw_func_d(double *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	*ent = arg->dwork[i+j*arg->ld];
+}
+void
+km_cfw_func_z(COMPLEX *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	*ent = arg->zwork[i+j*arg->ld];
+}
+void
+km_cfw_func_i(int *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	*ent = arg->iwork[i+j*arg->ld];
+}
+void
+km_cfw_func_b(bool *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	*ent = arg->bwork[i+j*arg->ld];
+}
+void
+km_cfw_func_v(VALUE *ent, int i, int j, void *data)
+{
+	struct km_c2w_arg *arg = (struct km_c2w_arg *)data;
+	*ent = arg->vwork[i+j*arg->ld];
+}
+void
+km_copy_from_work(SMAT *smat, void *work, int ldw)
+{
+	if ( smat->stype == ST_FULL && !(smat->trans) && ldw == smat->ld ) {
+		memcpy(smat->body, work, km_sizeof_vt(smat->vtype)*LENGTHs(smat));
+	} else {
+		struct km_c2w_arg data = {{work}, ldw};
+		if ( smat->vtype == VT_DOUBLE ) {
+			if ( smat->stype == ST_RSUB ) {
+				km_smat_each_with_index_d(smat, km_cfw_func_d, &data);
+			} else if ( smat->trans ) {
+				const int one=1;
+				for ( int i=0; i<smat->m; i++ ) {
+					dcopy_(&(smat->n), data.dwork+i, &ldw, smat->dbody+(i*smat->ld), &one);
+				}
+			} else {
+				char str_a[] = "A";
+				dlacpy_(str_a, &(smat->m), &(smat->n), work, &ldw, smat->dbody, &(smat->ld));
+			}
+		} else if ( smat->vtype == VT_COMPLEX ) {
+			if ( smat->stype == ST_RSUB ) {
+				km_smat_each_with_index_z(smat, km_cfw_func_z, &data);
+			} else if ( smat->trans ) {
+				const int one=1;
+				for ( int i=0; i<smat->m; i++ ) {
+					zcopy_(&(smat->n), data.zwork+i, &ldw, smat->zbody+(i*smat->ld), &one);
+				}
+			} else {
+				char str_a[] = "A";
+				zlacpy_(str_a, &(smat->m), &(smat->n), work, &ldw, smat->zbody, &(smat->ld));
+			}
+		} else if ( smat->vtype == VT_INT ) {
+			km_smat_each_with_index_i(smat, km_cfw_func_i, &data);
+		} else if ( smat->vtype == VT_BOOL ) {
+			km_smat_each_with_index_b(smat, km_cfw_func_b, &data);
+		} else if ( smat->vtype == VT_VALUE ) {
+			km_smat_each_with_index_v(smat, km_cfw_func_v, &data);
+		} else {
+			rb_raise(km_eInternal, "unknown value type");
+		}
+	}
+}
+
+void
+km_free_if_needed(LAWORK *work)
+{
+	if ( work->need_to_free ) {
+		ruby_xfree(work->body);
+		work->body = NULL;
+		work->need_to_free = false;
+	}
+}
+void
+km_copy_and_free_if_needed(SMAT *smat, LAWORK *work)
+{
+	if ( work->need_to_free ) {
+		km_copy_from_work(smat, work->body, work->ld);
+		ruby_xfree(work->body);
+		work->body = NULL;
+		work->need_to_free = false;
+	}
+}

data/ext/kmat/main.c

@@ -0,0 +1,95 @@
+#include "kmat.h"
+
+// km_global_variables_begin
+
+VALUE km_cMat;
+VALUE km_sMat;
+VALUE km_eDim;
+VALUE km_eVT;
+VALUE km_eUncomp;
+VALUE km_eInternal;
+VALUE km_eShare;
+VALUE km_eNotImp;
+
+VALUE rb_mMarshal;
+VALUE rb_mObjSpace;
+VALUE rb_sMath;
+
+// km_global_variables_end
+
+#include "id_sym.c"
+
+// return VALUE as Integer
+// this is useful for debugging
+static VALUE
+kmm_obj_value(VALUE self)
+{
+	return INT2NUM((int)self);
+}
+
+#include "method_definitions.c"
+#include "elementwise_function.c"
+#include "elementwise_function_definitions.c"
+
+void
+Init_kmat(void)
+{
+	rb_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
+	rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+	rb_sMath = rb_singleton_class(rb_mMath);
+
+	// km_cMat = rb_define_class("Mat", rb_cObject); # Mat is defined in /lib/kmat.rb
+	km_cMat = rb_const_get(rb_cObject, rb_intern("Mat"));
+	km_sMat = rb_singleton_class(km_cMat);
+	rb_undef_alloc_func(km_cMat);
+	rb_define_alloc_func(km_cMat, km_Mat_alloc);
+	
+	km_eDim = rb_define_class_under(km_cMat, "MismatchedDimensionError", rb_eStandardError);
+	km_eVT = rb_define_class_under(km_cMat, "ValueTypeError", rb_eStandardError);
+	km_eUncomp = rb_define_class_under(km_cMat, "UncomputableMatrixError", rb_eStandardError);
+	km_eInternal = rb_define_class_under(km_cMat, "InternalError", rb_eException);
+	km_eShare = rb_define_class_under(km_cMat, "SharingError", rb_eStandardError);
+	km_eNotImp = rb_define_class_under(km_cMat, "NotImplementedYetError", rb_eStandardError);
+
+	km_init_id(); km_init_sym();
+
+	rb_define_alias(km_cMat, "+@", "itself");
+	km_define_methods();
+	km_define_efs();
+	km_Mat_rand_init();
+}
+
+// invoke `func'(`data') disabling GC
+// the state of GC will be restored before return
+// return the return value of `func'(`data') unless an exception is raised
+VALUE
+km_gc_escape(VALUE (*func)(), VALUE data)
+{
+	int status;
+	VALUE old = rb_gc_disable();
+	VALUE ret = rb_protect(func, data, &status);
+	if ( old == Qfalse ) {
+		rb_gc_enable();
+	}
+	if ( status != 0 ) {
+		rb_jump_tag(status);
+	} else {
+		return ret;
+	}
+}
+
+// invoke `b_proc'(`data1') and ensure invoking `e_proc'(`data2')
+// if an exception is raised in `b_proc', the exception is re-raised after invoking `e_proc'
+// otherwise, return the return value of `b_proc'
+VALUE
+km_ensure(VALUE (* b_proc)(ANYARGS), VALUE data1, VALUE (* e_proc)(ANYARGS), VALUE data2)
+{
+	int status;
+	VALUE ret = rb_protect(b_proc, data1, &status);
+	(*e_proc)(data2);
+	if ( status != 0 ) {
+		rb_jump_tag(status);
+	} else {
+		return ret;
+	}
+}

data/ext/kmat/smat/accessor.c

@@ -0,0 +1,719 @@
+#include "../kmat.h"
+
+static int
+mod(int a, int b)
+{
+	int r = a % b;
+	if ( r < 0 ) {
+		return r+b;
+	} else {
+		return r;
+	}
+}
+
+// returns (i, j)-th element
+VALUE
+kmm_mat_get_value(VALUE self, VALUE vi, VALUE vj)
+{
+	SMAT *smat = km_mat2smat(self);
+	int i = NUM2INT(vi);
+	int j = NUM2INT(vj);
+	if ( i < 0 || smat->m <= i || j < 0 || smat->n <= j ) {
+		rb_raise(rb_eIndexError, "index (%d, %d) is out of range (%d, %d)", i, j, smat->m, smat->n);
+	}
+	VT_SWITCH( smat->vtype,
+		return rb_float_new(ENTITY(smat, d, i, j));,
+		return km_c2v(ENTITY(smat, z, i, j));,
+		return INT2NUM(ENTITY(smat, i, i, j));,
+		return TF2V(ENTITY(smat, b, i, j));,
+		return ENTITY(smat, v, i, j);
+	);
+}
+
+// make a serial-submatrix with shape (`vm', `vn')
+// (0, 0)-th element of the return is (`vi', `vj')-th element of `self'
+VALUE
+kmm_mat_get_ssub(VALUE self, VALUE vi, VALUE vj, VALUE vm, VALUE vn)
+{
+	return km_Mat_ssub(NUM2INT(vi), NUM2INT(vj), NUM2INT(vm), NUM2INT(vn), self);
+}
+
+// make a random-submatrix by :ivec indecies `vi', `vj'
+// (i, j)-th element of the return is (`vi'[i], `vj'[j])-th element of `self'
+// if both `vi' and `vj' are serial, serial-submatrix is made
+VALUE
+kmm_mat_get_rsub(VALUE self, VALUE vi, VALUE vj)
+{
+	SMAT *si = km_mat2smat(vi);
+	SMAT *sj = km_mat2smat(vj);
+	if ( si->vtype != VT_INT || sj->vtype != VT_INT ) {
+		rb_raise(km_eVT, "index arguments must be int vectors");
+	}
+	if ( !VECTOR_P(si) || !VECTOR_P(sj) ) {
+		rb_raise(km_eDim, "index arguments must be int vectors");
+	}
+	if ( si->stype != ST_FULL ) {
+		si = km_mat2smat(rb_obj_dup(vi));
+	}
+	if ( sj->stype != ST_FULL ) {
+		sj = km_mat2smat(rb_obj_dup(vj));
+	}
+	int *is = si->ibody, *js = sj->ibody;
+	bool flg = true;
+	int m = LENGTH(si), n = LENGTH(sj);
+	for (int i=0; i<m-1; i++) {
+		if ( is[i+1]-is[i] != 1 ) {
+			flg = false;
+			break;
+		}
+	}
+	if ( flg ) {
+		for (int i=0; i<n-1; i++) {
+			if ( js[i+1]-js[i] != 1 ) {
+				flg = false;
+				break;
+			}
+		}
+	}
+	if ( flg ) {
+		return km_Mat_ssub(is[0], js[0], m, n, self);
+	} else {
+		return km_Mat_rsub1(m, n, is, js, self);
+	}
+}
+
+// make a random-submatrix by :vmat index `vi'
+// (i, j)-th element of the return is (`vi'[i, j][0], `vi'[i, j][1])-th element of `self'
+VALUE
+kmm_mat_get_rsub2(VALUE self, VALUE vi)
+{
+	SMAT *smat = km_mat2smat(self);
+	SMAT *vmat = km_mat2smat(vi);
+	if ( vmat->vtype != VT_VALUE ) {
+		rb_raise(km_eVT, "index argument must be an object matrix");
+	}
+	int m = vmat->m, n = vmat->n, idx;
+	int m2 = smat->m, n2 = smat->n;
+	int *is, *js;
+	is = ALLOCA_N(int, int2size_t(n*m));
+	js = ALLOCA_N(int, int2size_t(n*m));
+	VALUE ij;
+	for ( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) {
+		ij = ENTITY(vmat, v, i, j);
+		if ( (TYPE(ij) != T_ARRAY) || (RARRAY_LEN(ij) != 2) ) {
+			rb_raise(rb_eIndexError, "value of vmat-index must be an Array with 2 elements");
+		}
+		idx = i+j*m;
+		is[idx] = mod( NUM2INT(rb_ary_entry(ij, 0)), m2 );
+		js[idx] = mod( NUM2INT(rb_ary_entry(ij, 1)), n2 );
+	} }
+	return km_Mat_rsub2(m, n, is, js, self);
+}
+
+// make a random-submatrix by :bmat index `vi'
+// if `vi'[i, j] is true, the return contains `self'[i, j]
+// if `vi'[i, j] is false, the return does not contain `self'[i, j]
+// the return is a vector which length is the number of trues in `vi'
+static void
+km_gbb_len(bool *eb, void *data)
+{
+	if ( *eb ) { *((int *)data) += 1; };
+}
+struct km_gbb_arg {
+	int l;
+	union {
+		double **dpbody;
+		COMPLEX **zpbody;
+		int **ipbody;
+		bool **bpbody;
+		VALUE **vpbody;
+	};
+};
+static void
+km_gbb_func_d(double *ea, const bool *eb, void *data_)
+{
+	struct km_gbb_arg *data = (struct km_gbb_arg *)data_;
+	if ( *eb ) {
+		data->dpbody[data->l] = ea;
+		data->l += 1;
+	}
+}
+static void
+km_gbb_func_z(COMPLEX *ea, const bool *eb, void *data_)
+{
+	struct km_gbb_arg *data = (struct km_gbb_arg *)data_;
+	if ( *eb ) {
+		data->zpbody[data->l] = ea;
+		data->l += 1;
+	}
+}
+static void
+km_gbb_func_i(int *ea, const bool *eb, void *data_)
+{
+	struct km_gbb_arg *data = (struct km_gbb_arg *)data_;
+	if ( *eb ) {
+		data->ipbody[data->l] = ea;
+		data->l += 1;
+	}
+}
+static void
+km_gbb_func_b(bool *ea, const bool *eb, void *data_)
+{
+	struct km_gbb_arg *data = (struct km_gbb_arg *)data_;
+	if ( *eb ) {
+		data->bpbody[data->l] = ea;
+		data->l += 1;
+	}
+}
+static void
+km_gbb_func_v(VALUE *ea, const bool *eb, void *data_)
+{
+	struct km_gbb_arg *data = (struct km_gbb_arg *)data_;
+	if ( *eb ) {
+		data->vpbody[data->l] = ea;
+		data->l += 1;
+	}
+}
+VALUE
+kmm_mat_get_by_bmat(VALUE self, VALUE vi)
+{
+	SMAT *smat = km_mat2smat(self);
+	SMAT *bmat = km_mat2smat(vi);
+	struct km_gbb_arg data = {0, {NULL}};
+	km_smat_each_b(bmat, km_gbb_len, (void *)&(data.l));
+	VALUE ret = km_Mat_alloc(km_cMat);
+	SMAT *sr = km_mat2smat(ret);
+	km_smat_alloc_pbody(sr, data.l, 1, smat->vtype);
+	data.l = 0;
+	VT_SWITCH( smat->vtype,
+		data.dpbody = sr->dpbody; km_smat_each2_dcb(smat, bmat, km_gbb_func_d, &data);,
+		data.zpbody = sr->zpbody; km_smat_each2_zcb(smat, bmat, km_gbb_func_z, &data);,
+		data.ipbody = sr->ipbody; km_smat_each2_icb(smat, bmat, km_gbb_func_i, &data);,
+		data.bpbody = sr->bpbody; km_smat_each2_bcb(smat, bmat, km_gbb_func_b, &data);,
+		data.vpbody = sr->vpbody; km_smat_each2_vcb(smat, bmat, km_gbb_func_v, &data);
+	);
+	if ( smat->stype == ST_FULL ) {
+		smat->may_have_sub = true;
+		sr->parent = self;
+	} else {
+		sr->parent = smat->parent;
+	}
+	km_infect_frozen(self, ret);
+	return ret;
+}
+
+// set val to (i, j)-th element
+VALUE
+kmm_mat_set_value(VALUE self, VALUE vi, VALUE vj, VALUE val)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	int i = NUM2INT(vi), j = NUM2INT(vj);
+	if ( i<0 || smat->m<i || j<0 || smat->n<j ) {
+		rb_raise(rb_eIndexError, "index (%d, %d) is out of range (%d, %d)", i, j, smat->m, smat->n);
+	}
+	if ( smat->stype == ST_RSUB ) {
+		VT_SWITCH( smat->vtype,
+			ENTITYr0(smat, d, INDEX(smat, i, j)) = NUM2DBL(val);,
+			ENTITYr0(smat, z, INDEX(smat, i, j)) = km_v2c(val);,
+			ENTITYr0(smat, i, INDEX(smat, i, j)) = NUM2INT(val);,
+			ENTITYr0(smat, b, INDEX(smat, i, j)) = RTEST(val);,
+			ENTITYr0(smat, v, INDEX(smat, i, j)) = val;
+		);
+	} else {
+		VT_SWITCH( smat->vtype,
+			ENTITYd0(smat, d, INDEX(smat, i, j)) = NUM2DBL(val);,
+			ENTITYd0(smat, z, INDEX(smat, i, j)) = km_v2c(val);,
+			ENTITYd0(smat, i, INDEX(smat, i, j)) = NUM2INT(val);,
+			ENTITYd0(smat, b, INDEX(smat, i, j)) = RTEST(val);,
+			ENTITYd0(smat, v, INDEX(smat, i, j)) = val;
+		);
+	}
+	return self;
+}
+
+// copy the values of `other' to `self'
+VALUE
+kmm_mat_copy_from(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *dest = km_mat2smat(self), *src = km_mat2smat(other);
+	CHECK_SAME_SIZE(dest, src);
+	if ( dest->vtype == src->vtype ) {
+		if ( ( dest->stype != ST_FULL && ( dest->parent ==  src->parent || dest->parent == other ) ) || src->parent == self ) {
+			km_smat_copy(dest, km_mat2smat(rb_obj_dup(other)));
+		} else {
+			km_smat_copy(dest, src);
+		}
+	} else {
+		VT_SWITCH( dest->vtype,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_fmat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_cmat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_imat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_bmat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_omat(other)));
+		);
+	}
+	return self;
+}
+VALUE
+kmm_mat_tcopy_from(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *dest = km_mat2smat(self), *src = km_mat2smat(other);
+	if ( dest->m!=src->n || dest->n!=src->m ) {
+		rb_raise(km_eDim, "transposed sizes must be the same, (%d, %d) != (%d, %d)", (dest)->m, (dest)->n, (src)->n, (src)->m);
+	}
+	dest->trans = !dest->trans;
+	SWAP(int, dest->m, dest->n);
+	if ( dest->vtype == src->vtype ) {
+		if ( ( dest->stype != ST_FULL && ( dest->parent ==  src->parent || dest->parent == other ) ) || src->parent == self ) {
+			km_smat_copy(dest, km_mat2smat(rb_obj_dup(other)));
+		} else {
+			km_smat_copy(dest, src);
+		}
+	} else {
+		VT_SWITCH( dest->vtype,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_fmat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_cmat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_imat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_bmat(other)));,
+			km_smat_copy(dest, km_mat2smat(kmm_mat_to_omat(other)));
+		);
+	}
+	dest->trans = !dest->trans;
+	SWAP(int, dest->m, dest->n);
+	return self;
+}
+
+// make a random-submatrix vector which contains diagonal elements of `self'
+VALUE
+kmm_mat__diag(VALUE self)
+{
+	SMAT *smat = km_mat2smat(self);
+	VALUE ret = km_Mat_alloc(km_cMat);
+	SMAT *sr = km_mat2smat(ret);
+	km_smat_alloc_pbody(sr, MIN(smat->m, smat->n), 1, smat->vtype);
+	if ( smat->stype == ST_RSUB ) {
+		for ( int i=0; i<sr->m; i++ ) {
+			sr->pbody[i] = smat->pbody[i+i*(smat->ld)];
+		}
+	} else {
+		VT_SWITCH( smat->vtype,
+			for ( int i=0; i<sr->m; i++ ) {
+				sr->pbody[i] = smat->dbody+(i+i*smat->ld);
+			},
+			for ( int i=0; i<sr->m; i++ ) {
+				sr->pbody[i] = smat->zbody+(i+i*smat->ld);
+			},
+			for ( int i=0; i<sr->m; i++ ) {
+				sr->pbody[i] = smat->ibody+(i+i*smat->ld);
+			},
+			for ( int i=0; i<sr->m; i++ ) {
+				sr->pbody[i] = smat->bbody+(i+i*smat->ld);
+			},
+			for ( int i=0; i<sr->m; i++ ) {
+				sr->pbody[i] = smat->vbody+(i+i*smat->ld);
+			}
+		);
+	}
+	if ( smat->stype == ST_FULL ) {
+		sr->parent = self;
+		smat->may_have_sub = true;
+	} else {
+		sr->parent = smat->parent;
+	}
+	km_infect_frozen(self, ret);
+	return ret;
+}
+
+VALUE
+kmm_mat__diag_ul(VALUE self, VALUE vk)
+{
+	SMAT *smat = km_mat2smat(self);
+	VALUE ret = km_Mat_alloc(km_cMat);
+	SMAT *sr = km_mat2smat(ret);
+	int k = NUM2INT(vk);
+	if ( k == 0 ) { return kmm_mat__diag(self); }
+	int len, i_s, j_s;
+	if ( 0 < k ) {
+		if ( k < (smat->n)-(smat->m) ) {
+			len = smat->m;
+		} else {
+			len = smat->n-k;
+		}
+		if ( smat->trans ) {
+			i_s = k; j_s = 0;
+		} else {
+			i_s = 0; j_s = k;
+		}
+	} else {
+		if ( k < (smat->n)-(smat->m) ) {
+			len = smat->m+k;
+		} else {
+			len = smat->n;
+		}
+		if ( smat->trans ) {
+			i_s = 0; j_s = -k;
+		} else {
+			i_s = -k; j_s = 0;
+		}
+	}
+	if ( len <= 0 ) {
+		rb_raise(rb_eArgError, "given offset %d exceeds range [-%d, %d]", k, smat->m-1, smat->n-1);
+	}
+	km_smat_alloc_pbody(sr, len, 1, smat->vtype);
+	if ( smat->stype == ST_RSUB ) {
+		for ( int i=0; i<len; i++ ) {
+			sr->pbody[i] = smat->pbody[i_s+i+(j_s+i)*smat->ld];
+		}
+	} else {
+		VT_SWITCH( smat->vtype,
+			for ( int i=0; i<len; i++ ) {
+				sr->pbody[i] = smat->dbody+(i_s+i+(j_s+i)*smat->ld);
+			},
+			for ( int i=0; i<len; i++ ) {
+				sr->pbody[i] = smat->zbody+(i_s+i+(j_s+i)*smat->ld);
+			},
+			for ( int i=0; i<len; i++ ) {
+				sr->pbody[i] = smat->ibody+(i_s+i+(j_s+i)*smat->ld);
+			},
+			for ( int i=0; i<len; i++ ) {
+				sr->pbody[i] = smat->bbody+(i_s+i+(j_s+i)*smat->ld);
+			},
+			for ( int i=0; i<len; i++ ) {
+				sr->pbody[i] = smat->vbody+(i_s+i+(j_s+i)*smat->ld);
+			}
+		);
+	}
+	if ( smat->stype == ST_FULL ) {
+		sr->parent = self;
+		smat->may_have_sub = true;
+	} else {
+		sr->parent = smat->parent;
+	}
+	km_infect_frozen(self, ret);
+	return ret;
+}
+
+// Mat#[]
+// get an element or make a submatrix
+typedef enum {
+	IT_SERIAL,
+	IT_IVEC,
+	IT_BMAT,
+	IT_INT,
+	IT_ZERO,
+	IT_VMAT,
+	IT_END
+} ITSYM;
+static void
+km_index_treatment(VALUE *oidx, ITSYM *itsym, VALUE iidx, int size, bool convert)
+{
+	if ( iidx == Qnil ) {
+		*oidx = rb_ary_new3(2, INT2NUM(0), INT2NUM(size));
+		*itsym = IT_SERIAL;
+	} else if ( rb_obj_is_kind_of(iidx, km_cMat) ) {
+		SMAT *si = km_mat2smat(iidx);
+		if ( si->vtype == VT_INT ) {
+			if ( VECTOR_P(si) ) {
+				if ( LENGTH(si) == 0 ) {
+					*oidx = Qnil;
+					*itsym = IT_ZERO;
+				} else {
+					*oidx = iidx;
+					*itsym = IT_IVEC;
+				}
+			} else {
+				rb_raise(rb_eArgError, "int-Mat-index must be a vector");
+			}
+		} else if ( si->vtype == VT_BOOL ) {
+			if ( convert && VECTOR_P(si) ) {
+				if ( LENGTH(si) == size ) {
+					int oi_size = 0;
+					if ( si->stype == ST_RSUB ) {
+						for ( int i=0; i<size; i++ ) {
+							if ( *((si->bpbody)[i]) ) {
+								oi_size++;
+							}
+						}
+						*oidx = km_Mat(oi_size,1, VT_INT);
+						SMAT *oi = km_mat2smat(*oidx);
+						oi_size = 0;
+						for ( int i=0; i<size; i++ ) {
+							if ( *((si->bpbody)[i]) ) {
+								oi->ibody[oi_size] = i;
+								oi_size++;
+							}
+						}
+					} else {
+						for ( int i=0; i<size; i++ ) {
+							if ( (si->bbody)[i] ) {
+								oi_size++;
+							}
+						}
+						*oidx = km_Mat(oi_size,1, VT_INT);
+						SMAT *oi = km_mat2smat(*oidx);
+						oi_size = 0;
+						for ( int i=0; i<size; i++ ) {
+							if ( (si->bbody)[i] ) {
+								oi->ibody[oi_size] = i;
+								oi_size++;
+							}
+						}
+					}
+					*itsym = IT_IVEC;
+				} else {
+					rb_raise(km_eDim, "boolean-Mat-index length must match with object size");
+				}
+			} else {
+				*oidx = iidx;
+				*itsym = IT_BMAT;
+			}
+		} else if ( si->vtype == VT_VALUE ) {
+			*oidx = iidx;
+			*itsym = IT_VMAT;
+		} else {
+			rb_raise(km_eVT, "float or complex matrix cannot be an index");
+		}
+	} else if ( rb_obj_is_kind_of(iidx, rb_cArray) ) {
+		int ii_size = (int)RARRAY_LEN(iidx);
+		if ( ii_size == 0 ) {
+			*oidx = rb_ary_new3(2, INT2NUM(0), INT2NUM(size));
+			*itsym = IT_SERIAL;
+		} else if ( rb_ary_entry(iidx, 0) == Qtrue || rb_ary_entry(iidx, 0) == Qfalse ) {
+			if ( ii_size == size ) {
+				int oi_size = 0;
+				for ( int i=0; i<size; i++ ) {
+					if ( RTEST(rb_ary_entry(iidx, i)) ) {
+						oi_size++;
+					}
+				}
+				*oidx = km_Mat(oi_size, 1, VT_INT);
+				SMAT *oi = km_mat2smat(*oidx);
+				oi_size = 0;
+				for ( int i=0; i<size; i++ ) {
+					if ( RTEST(rb_ary_entry(iidx, i)) ) {
+						oi->ibody[oi_size] = i;
+						oi_size++;
+					}
+				}
+				*itsym = IT_IVEC;
+			} else {
+				rb_raise(km_eDim, "boolean-Array-index length must match with object size");
+			}
+		} else {
+			*oidx = km_Mat(ii_size, 1, VT_INT);
+			SMAT *oi = km_mat2smat(*oidx);
+			for ( int i=0; i<ii_size; i++ ) {
+				(oi->ibody)[i] = mod(NUM2INT(rb_ary_entry(iidx, i)), size);
+			}
+			*itsym = IT_IVEC;
+		}
+	} else if ( rb_obj_is_kind_of(iidx, rb_cInteger) ) {
+		*oidx = INT2NUM(mod(NUM2INT(iidx), size));
+		*itsym = IT_INT;
+	} else if ( rb_obj_is_kind_of(iidx, rb_cRange) ) {
+		int f = mod(NUM2INT(rb_funcall(iidx, id_first, 0)), size);
+		int l = NUM2INT(rb_funcall(iidx, id_last, 0));
+		if ( RTEST(rb_funcall(iidx, id_exclude_end_p, 0)) ) {
+			l--;
+		}
+		l = mod(l, size);
+		*oidx = rb_ary_new3(2, INT2NUM(f), INT2NUM(l-f+1));
+		*itsym = IT_SERIAL;
+	} else {
+		rb_raise(rb_eArgError, "unknown index type");
+	}
+}
+
+VALUE
+kmm_mat_bracket(int argc, VALUE *argv, VALUE self)
+{
+	rb_check_arity(argc, 0, 2);
+	SMAT *smat = km_mat2smat(self);
+	if ( LENGTH(smat) == 0 ) {
+		rb_raise(km_eDim, "Mat#[] is not available for 0-size matricies");
+	}
+	if ( argc == 2 ) {
+		VALUE ri, ci;
+		ITSYM rit, cit;
+		km_index_treatment(&ri, &rit, argv[0], smat->m, true);
+		km_index_treatment(&ci, &cit, argv[1], smat->n, true);
+		if ( rit == IT_INT ) {
+			if ( cit == IT_INT ) {
+				return kmm_mat_get_value(self, ri, ci);
+			} else if ( cit == IT_SERIAL ) {
+				return km_Mat_ssub(NUM2INT(ri), NUM2INT(rb_ary_entry(ci, 0)), 1, NUM2INT(rb_ary_entry(ci, 1)), self);
+			} else if (  cit == IT_IVEC ) {
+				VALUE riv = km_Mat(1, 1, VT_INT);
+				(km_mat2smat(riv)->ibody)[0] = NUM2INT(ri);
+				return kmm_mat_get_rsub(self, riv, ci);
+			}
+		} else if ( rit == IT_SERIAL ) {
+			if ( cit == IT_INT ) {
+				return km_Mat_ssub(NUM2INT(rb_ary_entry(ri, 0)), NUM2INT(ci), NUM2INT(rb_ary_entry(ri, 1)), 1, self);
+			} else if ( cit == IT_SERIAL ) {
+				return kmm_mat_get_ssub(self, rb_ary_entry(ri, 0), rb_ary_entry(ci, 0), rb_ary_entry(ri, 1), rb_ary_entry(ci, 1));
+			} else if ( cit == IT_IVEC ) {
+				int ri1 = NUM2INT(rb_ary_entry(ri, 1));
+				VALUE riv = km_Mat(ri1, 1, VT_INT);
+				int ri0 = NUM2INT(rb_ary_entry(ri, 0));
+				SMAT *sri = km_mat2smat(riv);
+				for ( int i=0; i<ri1; i++ ) {
+					(sri->ibody)[i] = i+ri0;
+				}
+				return kmm_mat_get_rsub(self, riv, ci);
+			}
+		} else if ( rit == IT_IVEC ) {
+			if ( cit == IT_INT ) {
+				VALUE civ = km_Mat(1, 1, VT_INT);
+				(km_mat2smat(civ)->ibody)[0] = NUM2INT(ci);
+				return kmm_mat_get_rsub(self, ri, civ);
+			} else if ( cit == IT_SERIAL ) {
+				int ci1 = NUM2INT(rb_ary_entry(ci, 1));
+				VALUE civ = km_Mat(ci1, 1, VT_INT);
+				int ci0 = NUM2INT(rb_ary_entry(ci, 0));
+				SMAT *sci = km_mat2smat(civ);
+				for ( int i=0; i<ci1; i++ ) {
+					(sci->ibody)[i] = i+ci0;
+				}
+				return kmm_mat_get_rsub(self, ri, civ);
+			} else if ( cit == IT_IVEC ) {
+				return kmm_mat_get_rsub(self, ri, ci);
+			}
+		} else if ( rit == IT_ZERO ) {
+			int cs;
+			if ( cit == IT_INT ) {
+				cs = 1;
+			} else if ( cit == IT_SERIAL ) {
+				cs = NUM2INT(rb_ary_entry(ci, 1));
+			} else if ( cit == IT_IVEC ) {
+				cs = LENGTH(km_mat2smat(ci));
+			} else if ( cit == IT_ZERO ) {
+				cs = 0;
+			} else {
+				rb_raise(rb_eArgError, "illegal index type combination [%d, %d]", rit, cit);
+			}
+			return km_Mat(0, cs, smat->vtype);
+		}
+		rb_raise(rb_eArgError, "illegal index type combination [%d, %d]", rit, cit);
+	} else if ( argc == 1 ) {
+		VALUE i;
+		ITSYM it;
+		km_index_treatment(&i, &it, argv[0], LENGTH(smat), false);
+		if ( it == IT_BMAT ) {
+			SMAT *si  = km_mat2smat(i);
+			if ( SAME_SIZE(smat, si) ) {
+				return kmm_mat_get_by_bmat(self, i);
+			} else {
+				rb_raise(km_eDim, "boolean index size (%d, %d) must be the same as matrix size (%d, %d)", si->m, si->n, smat->m, smat->n);
+			}
+		} else if ( it == IT_INT ) {
+			if ( smat->n == 1 ) {
+				return kmm_mat_get_value(self, i, INT2NUM(0));
+			} else if ( smat->m == 1 ) {
+				return kmm_mat_get_value(self, INT2NUM(0), i);
+			} else {
+				rb_raise(rb_eArgError, "single integer index is available only for vectors, not for (%d, %d) matricies", smat->m, smat->n);
+			}
+		} else if ( it == IT_SERIAL ) {
+			if ( smat->n == 1 ) {
+				return km_Mat_ssub(NUM2INT(rb_ary_entry(i, 0)), 0, NUM2INT(rb_ary_entry(i, 1)), 1, self);
+			} else if ( smat->m == 1 ) {
+				return km_Mat_ssub(0, NUM2INT(rb_ary_entry(i, 0)), 1, NUM2INT(rb_ary_entry(i, 1)), self);
+			} else {
+				rb_raise(rb_eArgError, "single serial index is available only for vectors, not for (%d, %d) matricies", smat->m, smat->n);
+			}
+		} else if ( it == IT_IVEC ) {
+			if ( smat->n == 1 ) {
+				VALUE i2 = km_Mat(1, 1, VT_INT);
+				(km_mat2smat(i2)->ibody)[0] = 0;
+				return kmm_mat_get_rsub(self, i, i2);
+			} else if ( smat->m == 1 ) {
+				VALUE i2 = km_Mat(1, 1, VT_INT);
+				(km_mat2smat(i2)->ibody)[0] = 0;
+				return kmm_mat_get_rsub(self, i2, i);
+			} else {
+				rb_raise(rb_eArgError, "single ivec index is available only for vectors, not for (%d, %d) matricies", smat->m, smat->n);
+			}
+		} else if ( it == IT_ZERO ) {
+			if ( smat->n == 1 ) {
+				return km_Mat(1, 0, smat->vtype);
+			} else if ( smat->m == 1 ) {
+				return km_Mat(0, 1, smat->vtype);
+			} else {
+				rb_raise(rb_eArgError, "single serial index is available only for vectors, not for (%d, %d) matricies", smat->m, smat->n);
+			}
+		} else if ( it == IT_VMAT ) {
+			return kmm_mat_get_rsub2(self, i);
+		} else {
+			rb_raise(km_eInternal, "unknown index type %d", it);
+		}
+	} else {
+		return km_Mat_ssub(0, 0, smat->m, smat->n, self);
+	}
+}
+
+// alias []=
+VALUE
+kmm_mat_bracket_set(int argc, VALUE *argv, VALUE self)
+{
+	rb_check_arity(argc, 1, 3);
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	if ( LENGTH(smat) == 0 ) {
+		rb_raise(km_eDim, "Mat#[]= is not avialable for 0-size matricies");
+	}
+	if ( argc == 3 ) {
+		if ( rb_obj_is_kind_of(argv[0], rb_cInteger) && rb_obj_is_kind_of(argv[1], rb_cInteger) ) {
+			kmm_mat_set_value(self, INT2NUM(mod(NUM2INT(argv[0]), smat->m)), INT2NUM(mod(NUM2INT(argv[1]), smat->n)), argv[2]);
+		} else {
+			bool flg = smat->may_have_sub;
+			VALUE target = kmm_mat_bracket(2, argv, self);
+			if ( rb_obj_is_kind_of(argv[2], km_cMat) ) {
+				kmm_mat_copy_from(target, argv[2]);
+			} else {
+				kmm_mat_fill(target, argv[2]);
+			}
+			kmm_mat__kill(target);
+			smat->may_have_sub = flg;
+		}
+	} else if ( argc == 2 ) {
+		if ( rb_obj_is_kind_of(argv[0], rb_cInteger) ) {
+			if ( smat->n == 1 ) {
+				kmm_mat_set_value(self, INT2NUM(mod(NUM2INT(argv[0]), smat->m)), INT2NUM(0), argv[1]);
+			} else if ( smat->m == 1 ) {
+				kmm_mat_set_value(self, INT2NUM(0), INT2NUM(mod(NUM2INT(argv[0]), smat->n)), argv[1]);
+			} else {
+				rb_raise(rb_eArgError, "setting value with single integer index is available only for vectors, not (%d, %d) matricies", smat->m, smat->n);
+			}
+		} else {
+			bool flg = smat->may_have_sub;
+			VALUE target = kmm_mat_bracket(1, argv, self);
+			if ( rb_obj_is_kind_of(argv[1], km_cMat) ) {
+				if ( rb_obj_is_kind_of(argv[0], km_cMat) && km_mat2smat(argv[0])->vtype == VT_BOOL ) {
+					SMAT *smat2 = km_mat2smat(argv[1]);
+					bool flg2 = smat2->may_have_sub;
+					VALUE vsrc = kmm_mat_bracket(1, argv, argv[1]);
+					kmm_mat_copy_from(target, vsrc);
+					kmm_mat__kill(vsrc);
+					smat2->may_have_sub = flg2;
+				} else {
+					kmm_mat_copy_from(target, argv[1]);
+				}
+			} else {
+				kmm_mat_fill(target, argv[1]);
+			}
+			kmm_mat__kill(target);
+			smat->may_have_sub = flg;
+		}
+	} else {
+		if ( rb_obj_is_kind_of(argv[0], km_cMat) ) {
+			kmm_mat_copy_from(self, argv[0]);
+		} else {
+			kmm_mat_fill(self, argv[0]);
+		}
+	}
+	return argv[argc-1];
+}