kmat 0.0.3 → 0.1.0

data/ext/kmat/smat/fund.c

@@ -2,7 +2,7 @@
 
 // make a (m, n)-matrix with value type vt
 VALUE
-km_Mat(int m, int n, VTYPE vt)
+km_Mat(size_t m, size_t n, VTYPE vt)
 {
 	VALUE ret = km_Mat_alloc(km_cMat);
 	SMAT *smat = km_mat2smat(ret);
@@ -16,9 +16,9 @@ km_Mat(int m, int n, VTYPE vt)
 // otherwise, the return is filled by 0
 // if a block given, the (i, j)-th element is a return of yield(i, j)
 #define DEFINE_INIT_LOOP_FUNC(id, type, func) static void \
-km_initialize_loop_func_##id(type *elm, int i, int j, void *null) \
+km_initialize_loop_func_##id(type *elm, size_t i, size_t j, void *null) \
 {\
-	*elm = func( rb_yield( rb_ary_new3(2, INT2NUM(i), INT2NUM(j)) ) ); \
+	*elm = func( rb_yield( rb_ary_new3(2, ZU2NUM(i), ZU2NUM(j)) ) ); \
 }
 DEFINE_INIT_LOOP_FUNC(d, double, NUM2DBL)
 DEFINE_INIT_LOOP_FUNC(z, COMPLEX, km_v2c)
@@ -34,7 +34,7 @@ static VALUE
 km_initialize_loop(VALUE varg)
 {
 	struct km_initialize_loop_arg *arg = (struct km_initialize_loop_arg *)varg;
-	km_smat_alloc_body(arg->smat, NUM2INT(arg->argv[0]), NUM2INT(arg->argv[1]), arg->vt);
+	km_smat_alloc_body(arg->smat, NUM2ZU(arg->argv[0]), NUM2ZU(arg->argv[1]), arg->vt);
 	if ( rb_block_given_p() ) {
 		VT_SWITCH( arg->vt,
 			km_smat_each_with_index_d(arg->smat, km_initialize_loop_func_d, NULL);,
@@ -45,8 +45,8 @@ km_initialize_loop(VALUE varg)
 		);
 	} else {
 		if ( arg->vt == VT_VALUE ) {
-			for ( int i=0; i<arg->smat->m; i++ ) {
-				for ( int j=0; j<arg->smat->n; j++ ) {
+			for ( size_t i=0; i<arg->smat->m; i++ ) {
+				for ( size_t j=0; j<arg->smat->n; j++ ) {
 					arg->smat->vbody[i+j*arg->smat->ld] = Qnil;
 				}
 			}
@@ -104,15 +104,15 @@ kmm_mat_reshape(VALUE self, VALUE vm, VALUE vn)
 	if ( smat->stype == ST_SSUB ) {
 		rb_raise(km_eShare, "can't reshape submatrix. try detach before reshaping");
 	}
-	int m = NUM2INT(vm), n = NUM2INT(vn);
-	km_check_positive(m, n);
+	const size_t m = NUM2ZU(vm), n = NUM2ZU(vn);
+	km_check_size2(m, n);
 	if ( m*n == LENGTH(smat) ) {
 		smat->trans = false;
 		smat->m = m; smat->n = n;
 		smat->ld = m;
 		return self;
 	} else {
-		rb_raise(km_eDim, "the length of the matrix must no be changed, (%d, %d) -> (%d, %d) is unavailable",
+		rb_raise(km_eDim, "the length of the matrix must no be changed, (%zu, %zu) -> (%zu, %zu) is unavailable",
 			smat->m, smat->n, m, n);
 	}
 }
@@ -129,7 +129,7 @@ kmm_mat_resize(VALUE self, VALUE vm, VALUE vn)
 	} else if ( kmm_mat_have_submatrix_p(self) ) {
 		rb_raise(km_eShare, "can't resize supermatrix. try detach before reshaping");
 	}
-	int m = NUM2INT(vm), n = NUM2INT(vn);
+	const size_t m = NUM2ZU(vm), n = NUM2ZU(vn);
 	if ( m*n == LENGTH(smat) ) {
 		return kmm_mat_reshape(self, vm, vn);
 	} else {
@@ -146,7 +146,7 @@ kmm_mat_transpose_dest(VALUE self)
 	km_check_frozen(self);
 	SMAT *smat = km_mat2smat(self);
 	smat->trans = !(smat->trans);
-	SWAP(int, smat->m, smat->n);
+	SWAP(size_t, smat->m, smat->n);
 	return self;
 }
 
@@ -200,7 +200,7 @@ kmm_mat_zero(VALUE self)
 	type one; \
 }; \
 static void \
-km_eye_func_##id(type *elm, int i, int j, void *data_) \
+km_eye_func_##id(type *elm, size_t i, size_t j, void *data_) \
 {\
 	struct km_eye_##id *data = (struct km_eye_##id *)data_; \
 	if ( i == j ) { \
@@ -293,11 +293,11 @@ kmm_mat__randn0(VALUE self, VALUE random)
 		km_fill_normal(LENGTH(smat), smat->dbody, random);
 	} else if ( smat->stype == ST_SSUB ) {
 		if ( smat->trans ) {
-			for ( int i=0; i<smat->m; i++ ) {
+			for ( size_t i=0; i<smat->m; i++ ) {
 				km_fill_normal(smat->n, smat->dbody+i*smat->ld, random);
 			}
 		} else {
-			for ( int i=0; i<smat->n; i++ ) {
+			for ( size_t i=0; i<smat->n; i++ ) {
 				km_fill_normal(smat->m, smat->dbody+i*smat->ld, random);
 			}
 		}
@@ -341,9 +341,9 @@ kmm_mat_each(VALUE self)
 
 // invoke yield(element, i, j) for all the elements
 #define DEFINE_EACH_WI2_FUNC(id, type, func) static void \
-km_each_with_index2_func_##id(type *elm, int i, int j, void *null) \
+km_each_with_index2_func_##id(type *elm, size_t i, size_t j, void *null) \
 { \
-	rb_yield(rb_ary_new3(3, func(*elm), INT2NUM(i), INT2NUM(j))); \
+	rb_yield(rb_ary_new3(3, func(*elm), ZU2NUM(i), ZU2NUM(j))); \
 }
 DEFINE_EACH_WI2_FUNC(d, double, rb_float_new)
 DEFINE_EACH_WI2_FUNC(z, COMPLEX, km_c2v)
@@ -401,9 +401,9 @@ kmm_mat_mmap_dest(VALUE self)
 
 // invoke yield(element, i, j) and replace the element by the return for all the elements
 #define DEFINE_MMAP_WI2_FUNC(id, type, func, func2) static void \
-km_mmap_with_index2_func_##id(type *elm, int i, int j, void *null) \
+km_mmap_with_index2_func_##id(type *elm, size_t i, size_t j, void *null) \
 { \
-	*elm = func2(rb_yield(rb_ary_new3(3, func(*elm), INT2NUM(i), INT2NUM(j)))); \
+	*elm = func2(rb_yield(rb_ary_new3(3, func(*elm), ZU2NUM(i), ZU2NUM(j)))); \
 }
 DEFINE_MMAP_WI2_FUNC(d, double, rb_float_new, NUM2DBL)
 DEFINE_MMAP_WI2_FUNC(z, COMPLEX, km_c2v, km_v2c)
@@ -430,9 +430,9 @@ kmm_mat_mmap_with_index2_dest(VALUE self)
 }
 
 // make a row-major Array of Arrays (Mat#to_a is Enumerable#to_a and it is not the same as this)
-#define TA_LOOP(id, func) for ( int i=0; i<smat->m; i++ ) { \
-	VALUE row = rb_ary_new2(smat->n); \
-	for ( int j=0; j<smat->n; j++ ) { \
+#define TA_LOOP(id, func) for ( size_t i=0; i<smat->m; i++ ) { \
+	VALUE row = rb_ary_new2(s2l(smat->n)); \
+	for ( size_t j=0; j<smat->n; j++ ) { \
 		rb_ary_push(row, func(smat->id##body[INDEX(smat, i, j)])); \
 	} \
 	rb_ary_push(ret, row); \
@@ -441,7 +441,7 @@ VALUE
 kmm_mat_to_ary(VALUE self)
 {
 	SMAT *smat = km_mat2smat(self);
-	VALUE ret = rb_ary_new2(smat->m);
+	VALUE ret = rb_ary_new2(s2l(smat->m));
 	VT_SWITCH( smat->vtype,
 		TA_LOOP(d, rb_float_new),
 		TA_LOOP(z, km_c2v),
@@ -453,9 +453,9 @@ kmm_mat_to_ary(VALUE self)
 }
 
 // make a String
-#define TS_LOOP(tid, func) for ( int i=0; i<smat->m; i++ ) { \
-	VALUE row = rb_ary_new2(smat->n); \
-	for ( int j=0; j<smat->n; j++ ) { \
+#define TS_LOOP(tid, func) for ( size_t i=0; i<smat->m; i++ ) { \
+	VALUE row = rb_ary_new2(s2l(smat->n)); \
+	for ( size_t j=0; j<smat->n; j++ ) { \
 		rb_ary_push(row, rb_funcall(func(ENTITY(smat, tid, i, j)), id, 0)); \
 	} \
 	rb_str_cat2(ret, " ["); \
@@ -481,9 +481,9 @@ km_smat_to_s(const SMAT *smat, ID id, VALUE vtsym, VALUE stsym)
 	rb_str_cat2(ret, ")");
 	return ret;
 }
-#define TSP_LOOP(tid, func) for ( int i=0; i<smat->m; i++ ) { \
-	VALUE row = rb_ary_new2(smat->n); \
-	for ( int j=0; j<smat->n; j++ ) { \
+#define TSP_LOOP(tid, func) for ( size_t i=0; i<smat->m; i++ ) { \
+	VALUE row = rb_ary_new2(s2l(smat->n)); \
+	for ( size_t j=0; j<smat->n; j++ ) { \
 		rb_ary_push(row, rb_funcall(format, id_op_percent, 1, func(ENTITY(smat, tid, i, j)))); \
 	} \
 	rb_str_cat2(ret, " ["); \
@@ -536,15 +536,15 @@ kmm_mat_symmetrize_dest(VALUE self)
 		rb_raise(km_eDim, "non-square matrix cannot be symmetrized");
 	}
 	if ( smat->vtype == VT_DOUBLE ) {
-		for ( int i=0; i<smat->m-1; i++ ) {
-			for ( int j=i+1; j<smat->m; j++ ) {
+		for ( size_t i=0; i<smat->m-1; i++ ) {
+			for ( size_t j=i+1; j<smat->m; j++ ) {
 				smat->dbody[i+j*smat->ld] = ( smat->dbody[i+j*smat->ld] + smat->dbody[j+i*smat->ld] ) * 0.5;
 				smat->dbody[j+i*smat->ld] = smat->dbody[i+j*smat->ld];
 			}
 		}
 	} else if ( smat->vtype == VT_COMPLEX ) {
-		for ( int i=0; i<smat->m-1; i++ ) {
-			for ( int j=i+1; j<smat->m; j++ ) {
+		for ( size_t i=0; i<smat->m-1; i++ ) {
+			for ( size_t j=i+1; j<smat->m; j++ ) {
 				smat->zbody[i+j*smat->ld] = ( smat->zbody[i+j*smat->ld] + smat->zbody[j+i*smat->ld] ) * 0.5;
 				smat->zbody[j+i*smat->ld] = smat->zbody[i+j*smat->ld];
 			}
@@ -587,8 +587,8 @@ km_near_v(VALUE a, VALUE b)
 		return RTEST(rb_funcall(a, id_op_eq, 1, b));
 	}
 }
-#define SYM_BODY(id, func) for ( int i=0; i<(smat->n)-1; i++ ) { \
-	for ( int j=i+1; j<(smat->n); j++ ) { \
+#define SYM_BODY(id, func) for ( size_t i=0; i<(smat->n)-1; i++ ) { \
+	for ( size_t j=i+1; j<(smat->n); j++ ) { \
 		if ( !func(smat->id##body[i+j*(smat->ld)], smat->id##body[j+i*(smat->ld)]) ) { \
 			return Qfalse; \
 		} \
@@ -622,7 +622,7 @@ kmm_mat_symmetry_p(int argc, VALUE *argv, VALUE self)
 
 // judge whether `self' is near to `other'
 // consider a is near to b iff |a-b| < tol
-// the default value of tol is (maximub absolute value of each element) * max(m, n) * eps
+// the default value of tol is (maximum absolute value of each element) * max(m, n) * eps
 static bool
 km_near_abs_d(double a, double b, double tol)
 {
@@ -687,7 +687,7 @@ kmm_mat_near_p(int argc, VALUE *argv, VALUE self)
 	struct km_near_arg data = {true, 0.0};
 	if ( argc == 1 ) {
 		double ns = NUM2DBL(kmm_mat_norm_einf(self)), no = NUM2DBL(kmm_mat_norm_einf(argv[0]));
-		data.tol = MAX(ns, no) * MAX(ss->m, ss->n) * DBL_EPSILON;
+		data.tol = MAX(ns, no) * (double)MAX(ss->m, ss->n) * DBL_EPSILON;
 	} else {
 		data.tol = NUM2DBL(argv[1]);
 	}
@@ -698,5 +698,5 @@ kmm_mat_near_p(int argc, VALUE *argv, VALUE self)
 		km_smat_each2_b(ss, so, km_near_func_b, (void *)&data);,
 		km_smat_each2_v(ss, so, km_near_func_v, (void *)&data);
 	);
-	return data.ret;
+	return TF2V(data.ret);
 }

data/ext/kmat/smat/share.c

@@ -18,6 +18,7 @@ km_mat_deep_freeze0(VALUE self)
 	if ( smat->vtype == VT_VALUE ) {
 		km_smat_each_v(smat, km_mat_deep_freeze_func, NULL);
 	}
+	rb_obj_freeze(self);
 }
 VALUE
 kmm_mat_deep_freeze(VALUE self)
@@ -85,7 +86,7 @@ bool
 km_smat_have_submatrix_p(SMAT *smat)
 {
 	if ( smat->may_have_sub ) {
-		VALUE v = km_smat_find_value(smat);
+		const VALUE v = km_smat_find_value(smat);
 		if ( v == Qnil ) {
 			rb_raise(km_eInternal, "km_smat_have_submatrix_p has been called with out-of-ruby-controlled Mat struct");
 		} else {
@@ -177,7 +178,7 @@ VALUE
 kmm_mat_detach(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 0, 1);
-	bool check_other = ( ( argc == 1 ) && RTEST(argv[0]) );
+	const bool check_other = ( ( argc == 1 ) && RTEST(argv[0]) );
 	SMAT *smat = km_mat2smat(self);
 	if ( smat->stype == ST_FULL ) {
 		VALUE list = kmm_mat_submatricies(self);
@@ -191,7 +192,7 @@ kmm_mat_detach(int argc, VALUE *argv, VALUE self)
 		smat->may_have_sub = false;
 		return self;
 	} else {
-		VALUE old_parent = smat->parent;
+		const VALUE old_parent = smat->parent;
 		kmm_mat_replace(self, rb_obj_dup(self));
 		if ( check_other ) {
 			kmm_mat_submatricies(old_parent);
@@ -204,7 +205,7 @@ kmm_mat_detach(int argc, VALUE *argv, VALUE self)
 // if `self' is a submatrix of a supermatrix, detach from the supermatrix
 // in any case, `self' is replaced by (0, 0)-matrix, and return `self'
 static VALUE
-km_kill_func(VALUE elm, VALUE nil, VALUE self)
+km_kill_func(RB_BLOCK_CALL_FUNC_ARGLIST(elm, nil))
 {
 	SMAT *ssub = km_mat2smat(elm);
 	if ( ssub->stype != ST_SSUB ) {
@@ -223,7 +224,7 @@ kmm_mat__kill(VALUE self)
 	SMAT *smat = km_mat2smat(self);
 	if ( smat->stype == ST_FULL ) {
 		VALUE list = kmm_mat_submatricies(self);
-		rb_iterate(rb_ary_each, list, km_kill_func, Qnil);
+		rb_block_call(list, id_each, 0, (VALUE *)0, km_kill_func, Qnil);
 	}
 	if ( smat->stype != ST_SSUB ) {
 		ruby_xfree(smat->body);
@@ -277,9 +278,9 @@ kmm_mat_replace(VALUE self, VALUE val)
 			if ( dest->stype != ST_SSUB ) {
 				ruby_xfree(dest->body);
 			}
-			dest->body = ruby_xcalloc(LENGTHs(src), sizeof(void*));
+			dest->body = ruby_xcalloc(LENGTH(src), sizeof(void*));
 		}
-		memcpy(dest->body, src->body, sizeof(void*)*LENGTHs(src));
+		memcpy(dest->body, src->body, sizeof(void*)*LENGTH(src));
 		dest->ld = src->ld; dest->m = src->m; dest->n = src->n;
 		dest->vtype = src->vtype; dest->stype = ST_RSUB;
 		dest->trans = src->trans;
@@ -291,11 +292,11 @@ kmm_mat_replace(VALUE self, VALUE val)
 }
 
 VALUE
-km_Mat_ssub(int i, int j, int m, int n, VALUE super)
+km_Mat_ssub(size_t i, size_t j, size_t m, size_t n, VALUE super)
 {
 	SMAT *ssup = km_mat2smat(super);
 	if ( ssup->m < i+m || ssup->n < j+n ) {
-		rb_raise(rb_eIndexError, "given index+size (%d+%d, %d+%d) is out of range (%d, %d)", i, m, j, n, ssup->m, ssup->n);
+		rb_raise(rb_eIndexError, "given index+size (%zu+%zu, %zu+%zu) is out of range (%zu, %zu)", i, m, j, n, ssup->m, ssup->n);
 	}
 	SMAT *sret;
 	if ( ssup->stype == ST_FULL ) {
@@ -318,9 +319,9 @@ km_Mat_ssub(int i, int j, int m, int n, VALUE super)
 		);
 		sret->parent = ssup->parent;
 	} else if ( ssup->stype == ST_RSUB ) {
-		int is[m]; int js[n];
-		for ( int k=0; k<m; k++ ) { is[k] = i+k; }
-		for ( int k=0; k<n; k++ ) { js[k] = j+k; }
+		int is[m], js[n];
+		for ( size_t k=0; k<m; k++ ) { is[k] = s2i(i+k); }
+		for ( size_t k=0; k<n; k++ ) { js[k] = s2i(j+k); }
 		return km_Mat_rsub1(m, n, is, js, super);
 	} else {
 		rb_raise(km_eInternal, "unknown storage type");
@@ -332,24 +333,24 @@ km_Mat_ssub(int i, int j, int m, int n, VALUE super)
 }
 
 static void
-km_rsub_check_range(SMAT *ssup, int ii, int jj)
+km_rsub_check_range(SMAT *ssup, size_t ii, size_t jj)
 {
-	if ( ii < 0 || ssup->m <= ii || jj < 0 || ssup->n <= jj ) {
-		rb_raise(rb_eIndexError, "given index (%d, %d) is out of range (%d, %d)", ii, jj, ssup->m, ssup->n);
+	if ( ssup->m <= ii || ssup->n <= jj ) {
+		rb_raise(rb_eIndexError, "given index (%zu, %zu) is out of range (%zu, %zu)", ii, jj, ssup->m, ssup->n);
 	}
 }
-#define RSUB1_LOOPr(id) for ( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) { \
-	km_rsub_check_range(ssup, is[i], js[j]); \
-	sret->id##pbody[i+j*m] = ssup->id##pbody[INDEX(ssup, is[i], js[j])]; \
+#define RSUB1_LOOPr(id) for ( size_t i=0; i<m; i++ ) { for ( size_t j=0; j<n; j++ ) { \
+	km_rsub_check_range(ssup, i2s(is[i]), i2s(js[j])); \
+	sret->id##pbody[i+j*m] = ssup->id##pbody[INDEX(ssup, i2s(is[i]), i2s(js[j]))]; \
 } }
-#define RSUB1_LOOP(id) for ( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) { \
-	km_rsub_check_range(ssup, is[i], js[j]); \
-	sret->id##pbody[i+j*m] = ssup->id##body + INDEX(ssup, is[i], js[j]); \
+#define RSUB1_LOOP(id) for ( size_t i=0; i<m; i++ ) { for ( size_t j=0; j<n; j++ ) { \
+	km_rsub_check_range(ssup, i2s(is[i]), i2s(js[j])); \
+	sret->id##pbody[i+j*m] = ssup->id##body + INDEX(ssup, i2s(is[i]), i2s(js[j])); \
 } }
 VALUE
-km_Mat_rsub1(int m, int n, int *is, int *js, VALUE super)
+km_Mat_rsub1(size_t m, size_t n, const int *is, const int *js, VALUE super)
 {
-	km_check_positive(m, n);
+	km_check_size2(m, n);
 	VALUE ret = km_Mat_alloc(km_cMat);
 	SMAT *ssup = km_mat2smat(super);
 	SMAT *sret = km_mat2smat(ret);
@@ -382,18 +383,18 @@ km_Mat_rsub1(int m, int n, int *is, int *js, VALUE super)
 	return ret;
 }
 
-#define RSUB2_LOOPr(id) for( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) { \
+#define RSUB2_LOOPr(id) for( size_t i=0; i<m; i++ ) { for ( size_t j=0; j<n; j++ ) { \
 	km_rsub_check_range(ssup, is[i+j*m], js[i+j*m]); \
 	sret->id##pbody[i+j*m] = ssup->id##pbody[INDEX(ssup, is[i+j*m], js[i+j*m])]; \
 } }
-#define RSUB2_LOOP(id) for( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) { \
+#define RSUB2_LOOP(id) for( size_t i=0; i<m; i++ ) { for ( size_t j=0; j<n; j++ ) { \
 	km_rsub_check_range(ssup, is[i+j*m], js[i+j*m]); \
 	sret->id##pbody[i+j*m] = ssup->id##body+INDEX(ssup, is[i+j*m], js[i+j*m]); \
 } }
 VALUE
-km_Mat_rsub2(int m, int n, int *is, int *js, VALUE super)
+km_Mat_rsub2(size_t m, size_t n, const size_t *is, const size_t *js, VALUE super)
 {
-	km_check_positive(m, n);
+	km_check_size2(m, n);
 	VALUE ret = km_Mat_alloc(km_cMat);
 	SMAT *ssup = km_mat2smat(super);
 	SMAT *sret = km_mat2smat(ret);

data/ext/kmat/smat/smat.c

@@ -35,9 +35,9 @@ km_smat_size(const void *_data)
 		size_t ret = sizeof(SMAT);
 		if ( data->body != NULL ) {
 			if ( data->stype == ST_FULL ) {
-				ret += km_sizeof_vt(data->vtype)*int2size_t(data->m*data->n);
+				ret += km_sizeof_vt(data->vtype)*(data->m*data->n);
 			} else if ( data->stype == ST_RSUB ) {
-				ret += sizeof(void *)*int2size_t(data->m*data->n);
+				ret += sizeof(void *)*(data->m*data->n);
 			}
 		}
 		return ret;
@@ -46,6 +46,22 @@ km_smat_size(const void *_data)
 	}
 }
 
+static void
+km_rb_gc_location_wrap(VALUE *obj, void *null)
+{
+	(*obj) = rb_gc_location(*obj);
+}
+static void
+km_smat_compact(void *_data)
+{
+	SMAT *data = (SMAT *)_data;
+	data->parent = rb_gc_location(data->parent);
+	if ( data->vtype == VT_VALUE && data->body != NULL ) {
+		km_smat_each_v(data, km_rb_gc_location_wrap, NULL);
+	}
+}
+
+
 // functions for allocation
 const rb_data_type_t km_mat_data_type = {
 	"kmat-Mat",
@@ -53,7 +69,8 @@ const rb_data_type_t km_mat_data_type = {
 		km_smat_mark,
 		km_smat_free,
 		km_smat_size,
-		{ (void *)0, (void *)0 }
+		km_smat_compact,
+		{ (void *)0 }
 	},
 	(rb_data_type_t *)0,
 	(void *)0,
@@ -68,9 +85,9 @@ km_Mat_alloc(VALUE klass)
 // calloc a side of SMAT
 // return->body is the argument `body'
 SMAT *
-km_smat_alloc_with(int m, int n, VTYPE vt, void *body)
+km_smat_alloc_with(size_t m, size_t n, VTYPE vt, void *body)
 {
-	km_check_positive(m, n);
+	km_check_size2(m, n);
 	SMAT *data = ZALLOC(SMAT);
 	data->body = body; data->ld = data->m = m; data->n = n;
 	data->vtype = vt; data->stype = ST_FULL; data->trans = false;
@@ -79,19 +96,19 @@ km_smat_alloc_with(int m, int n, VTYPE vt, void *body)
 }
 
 SMAT *
-km_smat_alloc(int m, int n, VTYPE vt)
+km_smat_alloc(size_t m, size_t n, VTYPE vt)
 {
-	km_check_positive(m, n);
-	void *body = ruby_xcalloc(int2size_t(n*m), km_sizeof_vt(vt));
+	km_check_size2(m, n);
+	void *body = ruby_xcalloc(n*m, km_sizeof_vt(vt));
 	return km_smat_alloc_with(m, n, vt, body);
 }
 
 // calloc a SMAT of (m, n)-matrix
 // return->body will be calloc-ed
 void
-km_smat_alloc_body(SMAT *data, int m, int n, VTYPE vt)
+km_smat_alloc_body(SMAT *data, size_t m, size_t n, VTYPE vt)
 {
-	km_check_positive(m, n);
+	km_check_size2(m, n);
 	if ( data->stype != ST_FULL ) {
 		rb_raise(km_eShare, "can't re-alloc submatrix body");
 	} else if ( km_smat_have_submatrix_p(data) ) {
@@ -99,12 +116,12 @@ km_smat_alloc_body(SMAT *data, int m, int n, VTYPE vt)
 	}
 	data->ld = data->m = m; data->n = n; data->vtype = vt; data->stype = ST_FULL;
 	ruby_xfree(data->body);
-	data->body = ruby_xcalloc(int2size_t(n*m), km_sizeof_vt(vt));
+	data->body = ruby_xcalloc(n*m, km_sizeof_vt(vt));
 }
 void
-km_smat_alloc_pbody(SMAT *data, int m, int n, VTYPE vt)
+km_smat_alloc_pbody(SMAT *data, size_t m, size_t n, VTYPE vt)
 {
-	km_check_positive(m, n);
+	km_check_size2(m, n);
 	if ( data->stype != ST_FULL ) {
 		rb_raise(km_eShare, "can't re-alloc submatrix body");
 	} else if ( km_smat_have_submatrix_p(data) ) {
@@ -112,7 +129,7 @@ km_smat_alloc_pbody(SMAT *data, int m, int n, VTYPE vt)
 	}
 	data->ld = data->m = m; data->n = n; data->vtype = vt; data->stype = ST_RSUB;
 	ruby_xfree(data->body);
-	data->body = ruby_xcalloc(int2size_t(n*m), sizeof(void*));
+	data->body = ruby_xcalloc(n*m, sizeof(void*));
 }
 
 
@@ -152,7 +169,7 @@ km_smat_copy(SMAT *dest, const SMAT *src)
 				rb_raise(km_eShare, "can't copy to value-type mismatched or dimension mismatched submatrix");
 			}
 			ruby_xfree(dest->body);
-			dest->body = ruby_xcalloc(LENGTHs(src), km_sizeof_vt(src->vtype));
+			dest->body = ruby_xcalloc(LENGTH(src), km_sizeof_vt(src->vtype));
 			dest->ld = src->m; dest->vtype = src->vtype;
 		} else if ( dest->m != src->m ) { // need not to resize but reshape is needed
 			if ( dest->stype != ST_FULL ) { // the destination must not be a submatrix
@@ -163,7 +180,7 @@ km_smat_copy(SMAT *dest, const SMAT *src)
 		dest->m = src->m; dest->n = src->n;
 		if ( dest->stype==ST_FULL && src->stype==ST_FULL ) {
 			dest->ld = src->ld; dest->trans = src->trans;
-			memcpy(dest->body, src->body, km_sizeof_vt(src->vtype)*LENGTHs(src));
+			memcpy(dest->body, src->body, km_sizeof_vt(src->vtype)*LENGTH(src));
 		} else {
 			VT_SWITCH( dest->vtype,
 				km_smat_each2_dcd(dest, src, km_smat_copy_d, NULL);,
@@ -189,15 +206,15 @@ kmm_mat_marshal_dump(VALUE self)
 	if ( smat->stype != ST_FULL ) {
 		smat = km_mat2smat(rb_obj_dup(self));
 	}
-	VALUE headder = rb_str_new((char *)&(smat->vtype), sizeof(VTYPE));
+	VALUE headder = rb_str_new((char *)&(smat->vtype), s2l(sizeof(VTYPE)));
 	VALUE body;
 	if ( smat->vtype == VT_VALUE ) {
 		body = kmm_mat_to_ary(self);
 	} else {
-		rb_str_cat(headder, (char *)&(smat->m), sizeof(int));
-		rb_str_cat(headder, (char *)&(smat->n), sizeof(int));
+		rb_str_cat(headder, (char *)&(smat->m), sizeof(size_t));
+		rb_str_cat(headder, (char *)&(smat->n), sizeof(size_t));
 		rb_str_cat(headder, (char *)&(smat->trans), sizeof(bool));
-		body = rb_str_new((char *)(smat->body), (long)km_sizeof_vt(smat->vtype)*LENGTH(smat));
+		body = rb_str_new((char *)(smat->body), s2l(km_sizeof_vt(smat->vtype)*LENGTH(smat)));
 	}
 	return rb_ary_new3(2, headder, body);
 }
@@ -212,13 +229,13 @@ kmm_mat_marshal_load(VALUE self, VALUE dump)
 		km_smat_copy(smat, km_mat2smat(kmm_ary_to_omat(body)));
 	} else {
 		hptr += sizeof(VTYPE);
-		int m, n; bool t;
-		memcpy(&m, hptr, sizeof(int)); hptr += sizeof(int);
-		memcpy(&n, hptr, sizeof(int)); hptr += sizeof(int);
+		size_t m, n; bool t;
+		memcpy(&m, hptr, sizeof(size_t)); hptr += sizeof(size_t);
+		memcpy(&n, hptr, sizeof(size_t)); hptr += sizeof(size_t);
 		memcpy(&t, hptr, sizeof(bool)); hptr += sizeof(bool);
 		km_smat_alloc_body(smat, m, n, smat->vtype);
 		smat->trans = t;
-		size_t sb = km_sizeof_vt(smat->vtype)*LENGTHs(smat);
+		size_t sb = km_sizeof_vt(smat->vtype)*LENGTH(smat);
 		if ( RSTRING_LEN(body) != (long)sb ) {
 			rb_raise(rb_eArgError, "wrong object given");
 		}
@@ -233,21 +250,21 @@ km_smat_each_##id(SMAT *smat, void (*func)(type *, void *), void *data) \
 { \
 	if ( smat->stype == ST_RSUB ) { \
 		if ( smat->trans ) { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(smat->id##pbody[j+i*(smat->ld)], data); \
 			} } \
 		} else { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(smat->id##pbody[i+j*(smat->ld)], data); \
 			} } \
 		} \
 	} else { \
 		if ( smat->trans ) { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(&(smat->id##body[j+i*(smat->ld)]), data); \
 			} } \
 		} else { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(&(smat->id##body[i+j*(smat->ld)]), data); \
 			} } \
 		} \
@@ -261,25 +278,25 @@ DEFINE_KM_SMAT_EACH_ID(v, VALUE)
 
 // call `func'(&element, `data', i, j) for each elements of `smat'
 #define DEFINE_KM_SMAT_EACH_WI_ID(id, type) void \
-km_smat_each_with_index_##id(SMAT *smat, void (*func)(type *, int, int, void *), void *data) \
+km_smat_each_with_index_##id(SMAT *smat, void (*func)(type *, size_t, size_t, void *), void *data) \
 { \
 	if ( smat->stype == ST_RSUB ) { \
 		if ( smat->trans ) { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(smat->id##pbody[j+i*(smat->ld)], i, j, data); \
 			} } \
 		} else { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(smat->id##pbody[i+j*(smat->ld)], i, j, data); \
 			} } \
 		} \
 	} else { \
 		if ( smat->trans ) { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(&(smat->id##body[j+i*(smat->ld)]), i, j, data); \
 			} } \
 		} else { \
-			for ( int i=0; i<smat->m; i++ ) { for ( int j=0; j<smat->n; j++ ) { \
+			for ( size_t i=0; i<smat->m; i++ ) { for ( size_t j=0; j<smat->n; j++ ) { \
 				func(&(smat->id##body[i+j*(smat->ld)]), i, j, data); \
 			} } \
 		} \
@@ -296,21 +313,21 @@ DEFINE_KM_SMAT_EACH_WI_ID(v, VALUE)
 // SEGV will occur if `sb' is smaller than `sa'
 #define KM_SMAT_EACH2_BLOOP(elma, id) if ( sb->stype == ST_RSUB ) { \
 	if ( sb->trans ) { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, sb->id##pbody[j+i*(sb->ld)], data); \
 		} } \
 	} else { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, sb->id##pbody[i+j*(sb->ld)], data); \
 		} } \
 	} \
 } else { \
 	if ( sb->trans ) { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, &(sb->id##body[j+i*(sb->ld)]), data); \
 		} } \
 	} else { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, &(sb->id##body[i+j*(sb->ld)]), data); \
 		} } \
 	} \
@@ -370,21 +387,21 @@ DEFINE_KM_SMAT_EACH2_ID_CONST_ID(d, double, z, COMPLEX)
 // SEGV will occur if `sb' or `sc' is smaller than `sa'
 #define KM_SMAT_EACH3_CLOOP(elma, elmb, id) if ( sc->stype == ST_RSUB ) { \
 	if ( sc->trans ) { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, elmb, sc->id##pbody[j+i*(sc->ld)], data); \
 		} } \
 	} else { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, elmb, sc->id##pbody[i+j*(sc->ld)], data); \
 		} } \
 	} \
 } else { \
 	if ( sc->trans ) { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, elmb, &(sc->id##body[j+i*(sc->ld)]), data); \
 		} } \
 	} else { \
-		for ( int i=0; i<sa->m; i++ ) { for ( int j=0; j<sa->n; j++ ) { \
+		for ( size_t i=0; i<sa->m; i++ ) { for ( size_t j=0; j<sa->n; j++ ) { \
 			func(elma, elmb, &(sc->id##body[i+j*(sc->ld)]), data); \
 		} } \
 	} \
@@ -527,4 +544,3 @@ km_smat_each3_bcvcv(SMAT *sa, const SMAT *sb, const SMAT *sc, void (*func)(bool
 		}
 	}
 }
-