kmat 0.0.3 → 0.1.0

data/ext/kmat/linalg/linalg.c

@@ -20,6 +20,20 @@ km_check_size(int pairc, ...)
 	}
 	va_end(argp);
 }
+void
+km_check_size_s(int pairc, ...)
+{
+	va_list argp;
+	va_start(argp, pairc);
+	for (int i=0; i<pairc; i++ ) {
+		size_t a = va_arg(argp, size_t); size_t b = va_arg(argp, size_t);
+		if ( a != b ) {
+			va_end(argp);
+			rb_raise(km_eDim, "dimension mismatched (%zu != %zu)", a, b);
+		}
+	}
+	va_end(argp);
+}
 
 // the number of SMATs is specified by `argc'
 // check whether the value types of the arguments are VT_DOUBLE or not
@@ -123,8 +137,8 @@ km_recover_trans(VALUE vab)
 {
 	SMAT *sa = km_mat2smat(rb_ary_entry(vab, 0));
 	SMAT *sb = km_mat2smat(rb_ary_entry(vab, 1));
-	sa->trans = !sa->trans; SWAP(int, sa->m, sa->n);
-	sb->trans = !sb->trans; SWAP(int, sb->m, sb->n);
+	sa->trans = !sa->trans; SWAP(size_t, sa->m, sa->n);
+	sb->trans = !sb->trans; SWAP(size_t, sb->m, sb->n);
 	return vab;
 }
 static VALUE
@@ -174,8 +188,8 @@ kmm_mat_inverse(VALUE va)
 void
 km_dmprod(int m, int n, int k, double *a, int lda, double *b, int ldb, double *r, int ldr)
 {
-	static char trans[] = "N";
-	static double alpha=1.0, beta=0.0;
+	char trans[] = "N";
+	const double alpha=1.0, beta=0.0;
 	dgemm_(trans, trans, &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, r, &ldr);
 }
 struct km_mprod_arg {
@@ -187,8 +201,8 @@ km_mprod_body(VALUE data)
 {
 	struct km_mprod_arg *a = (struct km_mprod_arg *)data;
 	
-	int m = a->sr->m, n = a->sr->n, k = a->sa->n;
-	km_check_size(3, a->sb->m,k, a->sa->m,m, a->sb->n,n);
+	int m = s2i(a->sr->m), n = s2i(a->sr->n), k = s2i(a->sa->n);
+	km_check_size(3, s2i(a->sb->m),k, s2i(a->sa->m),m, s2i(a->sb->n),n);
 	
 	KALLOCz(a->r, a->sr);
 	KALLOCn(a->a, a->sa);
@@ -198,35 +212,37 @@ km_mprod_body(VALUE data)
 	if ( vt == VT_DOUBLE ) {
 		char trans[] = "N";
 		double alpha=1.0, beta=0.0;
-		dgemm_(trans, trans, &m, &n, &k, &alpha, a->a.d, &(a->a.ld), a->b.d, &(a->b.ld), &beta, a->r.d, &(a->r.ld));
+		int lda=s2i(a->a.ld), ldb=s2i(a->b.ld), ldr=s2i(a->r.ld);
+		dgemm_(trans, trans, &m, &n, &k, &alpha, a->a.d, &lda, a->b.d, &ldb, &beta, a->r.d, &ldr);
 	} else if ( vt == VT_COMPLEX ) {
 		char trans[] = "N";
 		COMPLEX alpha=cpack(1.0, 0.0), beta=cpack(0.0, 0.0);
-		zgemm_(trans, trans, &m, &n, &k, &alpha, a->a.z, &(a->a.ld), a->b.z, &(a->b.ld), &beta, a->r.z, &(a->r.ld));
+		int lda=s2i(a->a.ld), ldb=s2i(a->b.ld), ldr=s2i(a->r.ld);
+		zgemm_(trans, trans, &m, &n, &k, &alpha, a->a.z, &lda, a->b.z, &ldb, &beta, a->r.z, &ldr);
 	} else if ( vt == VT_INT ) {
 		for ( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) {
-			int *foo=(a->r.i)+(i+j*(a->r.ld));
-			int jldb = j*(a->b.ld);
+			int *foo=(a->r.i)+(i+j*s2i(a->r.ld));
+			const int jldb = j*s2i(a->b.ld);
 			for ( int l=0; l<k; l++ ) {
-				*foo += (a->a.i)[i+l*(a->a.ld)] * (a->b.i)[l+jldb];
+				*foo += (a->a.i)[i+l*s2i(a->a.ld)] * (a->b.i)[l+jldb];
 			}
 		} }
 	} else if ( vt == VT_BOOL ) {
 		for ( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) {
-			bool *foo=(a->r.b)+(i+j*(a->r.ld));
-			int jldb = j*(a->b.ld);
+			bool *foo=(a->r.b)+(i+j*s2i(a->r.ld));
+			const int jldb = j*s2i(a->b.ld);
 			for ( int l=0; l<k; l++ ) {
-				bool bar = ( (a->a.b)[i+l*(a->a.ld)] && (a->b.b)[l+jldb] );
+				const bool bar = ( (a->a.b)[i+l*s2i(a->a.ld)] && (a->b.b)[l+jldb] );
 				*foo = XOR(*foo, bar);
 			}
 		} }
 	} else if ( vt == VT_VALUE ) {
 		for ( int i=0; i<m; i++ ) { for ( int j=0; j<n; j++ ) {
-			VALUE *foo=(a->r.v)+(i+j*(a->r.ld));
+			VALUE *foo=(a->r.v)+(i+j*s2i(a->r.ld));
 			*foo = INT2NUM(0);
-			int jldb = j*(a->b.ld);
+			const int jldb = j*s2i(a->b.ld);
 			for ( int l=0; l<k; l++ ) {
-				VALUE bar = rb_funcall( (a->a.v)[i+l*(a->a.ld)], id_op_mul, 1, (a->b.v)[l+jldb] );
+				const VALUE bar = rb_funcall( (a->a.v)[i+l*s2i(a->a.ld)], id_op_mul, 1, (a->b.v)[l+jldb] );
 				*foo = rb_funcall(*foo, id_op_plus, 1, bar);
 			}
 		} }

data/ext/kmat/linalg/norm.c

@@ -1,6 +1,6 @@
 #include "../kmat.h"
 
-#define SET_LD(ldx, smat) int ldx; \
+#define SET_LD(ldx, smat) size_t ldx; \
 	if ( smat->n == 1 ) { \
 		if ( smat->trans ) { \
 			ldx = smat->ld; \
@@ -14,23 +14,37 @@
 			ldx = smat->ld; \
 		} \
 	}
+#define SET_LDi(ldx, smat) int ldx; \
+	if ( smat->n == 1 ) { \
+		if ( smat->trans ) { \
+			ldx = s2i(smat->ld); \
+		} else { \
+			ldx = 1; \
+		} \
+	} else { \
+		if ( smat->trans ) { \
+			ldx = 1; \
+		} else { \
+			ldx = s2i(smat->ld); \
+		} \
+	}
 #define DEF_IPROD(id, type, mul, add, zero) static type \
 km_##id##mat_iprod(SMAT *sa, SMAT *sb) { \
 	type ret; \
 	SET_LD(lda, sa) \
 	SET_LD(ldb, sb) \
-	int len = LENGTH(sa); \
+	const size_t len = LENGTH(sa); \
 	if ( len == 0 ) { return zero; } \
 	if ( sa->stype == ST_RSUB ) { \
 		if ( sb->stype == ST_RSUB ) { \
 			ret = mul( *(sa->id##pbody[0]), *(sb->id##pbody[0]) ); \
-			for ( int i=1; i<len; i++ ) { \
+			for ( size_t i=1; i<len; i++ ) { \
 				type temp = mul( *(sa->id##pbody[i*lda]), *(sb->id##pbody[i*ldb]) ); \
 				ret = add(ret, temp); \
 			} \
 		} else { \
 			ret = mul( *(sa->id##pbody[0]), (sb->id##body[0]) ); \
-			for ( int i=1; i<len; i++ ) { \
+			for ( size_t i=1; i<len; i++ ) { \
 				type temp = mul( *(sa->id##pbody[i*lda]), (sb->id##body[i*ldb]) ); \
 				ret = add(ret, temp); \
 			} \
@@ -38,13 +52,13 @@ km_##id##mat_iprod(SMAT *sa, SMAT *sb) { \
 	} else { \
 		if ( sb->stype == ST_RSUB ) { \
 			ret = mul( (sa->id##body[0]), *(sb->id##pbody[0]) ); \
-			for ( int i=1; i<len; i++ ) { \
+			for ( size_t i=1; i<len; i++ ) { \
 				type temp = mul( (sa->id##body[i*lda]), *(sb->id##pbody[i*ldb]) ); \
 				ret = add(ret, temp); \
 			} \
 		} else { \
 			ret = mul( (sa->id##body[0]), (sb->id##body[0]) ); \
-			for ( int i=1; i<len; i++ ) { \
+			for ( size_t i=1; i<len; i++ ) { \
 				type temp = mul( (sa->id##body[i*lda]), (sb->id##body[i*ldb]) ); \
 				ret = add(ret, temp); \
 			} \
@@ -68,9 +82,9 @@ km_dmat_iprodb(SMAT *sa, SMAT *sb)
 	if ( sa->stype == ST_RSUB || sb->stype == ST_RSUB ) {
 		return km_dmat_iprod(sa, sb);
 	}
-	SET_LD(lda, sa)
-	SET_LD(ldb, sb)
-	int n = LENGTH(sa);
+	SET_LDi(lda, sa)
+	SET_LDi(ldb, sb)
+	const int n = LENGTHi(sa);
 	return ddot_(&n, sa->dbody, &lda, sb->dbody, &ldb);
 }
 static COMPLEX
@@ -79,9 +93,9 @@ km_zmat_iprodb(SMAT *sa, SMAT *sb)
 	if ( sa->stype == ST_RSUB || sb->stype == ST_RSUB ) {
 		return km_zmat_iprod(sa, sb);
 	}
-	SET_LD(lda, sa)
-	SET_LD(ldb, sb)
-	int n = LENGTH(sa);
+	SET_LDi(lda, sa)
+	SET_LDi(ldb, sb)
+	const int n = LENGTHi(sa);
 	return zdotu_(&n, sa->zbody, &lda, sb->zbody, &ldb);
 }
 VALUE
@@ -91,7 +105,7 @@ kmm_mat__iprod(VALUE self, VALUE vb)
 	if ( !VECTOR_P(sa) || !VECTOR_P(sb) ) {
 		rb_raise(km_eDim, "both self and the argument must be vectors");
 	} else if ( LENGTH(sa) != LENGTH(sb) ) {
-		rb_raise(km_eDim, "dimensions must be the same (%d != %d)", LENGTH(sa), LENGTH(sb));
+		rb_raise(km_eDim, "dimensions must be the same (%zu != %zu)", LENGTH(sa), LENGTH(sb));
 	} else if ( sa->vtype != sb->vtype ) {
 		rb_raise(km_eVT, "value types must be the same");
 	}
@@ -141,16 +155,16 @@ kmm_mat_normf(VALUE self)
 	SMAT *smat = km_mat2smat(self);
 	if ( smat->vtype == VT_DOUBLE ) {
 		if ( smat->stype == ST_FULL ) {
-			int ione=1, n = LENGTH(smat);
+			const int ione=1, n = LENGTHi(smat);
 			return rb_float_new(dnrm2_(&n, smat->dbody, &ione));
 		} else if ( smat->stype == ST_SSUB ) {
-			int ione=1, lps, size; double ret=0.0;
+			const int ione=1; int size; size_t lps; double ret=0.0;
 			if ( smat->trans ) {
-				lps = smat->m; size = smat->n;
+				lps = smat->m; size = s2i(smat->n);
 			} else {
-				lps = smat->n; size = smat->m;
+				lps = smat->n; size = s2i(smat->m);
 			}
-			for ( int i=0; i<lps; i++ ) {
+			for ( size_t i=0; i<lps; i++ ) {
 				ret = hypot(ret, dnrm2_(&size, smat->dbody+i*(smat->ld), &ione));
 			}
 			return rb_float_new(ret);
@@ -161,16 +175,16 @@ kmm_mat_normf(VALUE self)
 		}
 	} else if ( smat->vtype == VT_COMPLEX ) {
 		if ( smat->stype == ST_FULL ) {
-			int ione=1, n = LENGTH(smat);
+			const int ione=1, n = LENGTHi(smat);
 			return rb_float_new(dznrm2_(&n, smat->zbody, &ione));
 		} else if ( smat->stype == ST_SSUB ) {
-			int ione=1, lps, size; double ret=0.0;
+			const int ione=1; int size; size_t lps; double ret=0.0;
 			if ( smat->trans ) {
-				lps = smat->m; size = smat->n;
+				lps = smat->m; size = s2i(smat->n);
 			} else {
-				lps = smat->n; size = smat->m;
+				lps = smat->n; size = s2i(smat->m);
 			}
-			for ( int i=0; i<lps; i++ ) {
+			for ( size_t i=0; i<lps; i++ ) {
 				ret = hypot(ret, dznrm2_(&size, smat->zbody+i*(smat->ld), &ione));
 			}
 			return rb_float_new(ret);
@@ -199,13 +213,13 @@ kmm_mat_normf(VALUE self)
 // L-1, L-infinity norm
 #define NORM1(type, id, m_ent, m, n, m_abs, m_add, m_cmp, x2v) \
 	type ret = m_abs(m_ent(smat, id, 0)); \
-	for ( int i=1; i<m; i++ ) { \
+	for ( size_t i=1; i<m; i++ ) { \
 		type foo = m_abs(m_ent(smat, id, i)); \
 		ret = m_add(ret, foo); \
 	} \
-	for ( int j=1; j<n; j++ ) { \
+	for ( size_t j=1; j<n; j++ ) { \
 		type bar = m_abs(m_ent(smat, id, j*(smat->ld))); \
-		for ( int i=1; i<m; i++ ) { \
+		for ( size_t i=1; i<m; i++ ) { \
 			type foo = m_abs(m_ent(smat, id, i+j*(smat->ld))); \
 			bar = m_add(bar, foo); \
 		} \
@@ -216,10 +230,10 @@ kmm_mat_normf(VALUE self)
 	if ( smat->stype == ST_RSUB ) { \
 		NORM1(double, id, ENTITYr0, m, n, m_abs, NUM_ADD, NUM_CMP, rb_float_new); \
 	} else { \
-		const int ione=1; \
-		double ret = bid##asum_(&(m), smat->id##body, &ione); \
-		for ( int j=1; j<n; j++ ) { \
-			double temp = bid##asum_(&(m), smat->id##body+(j*(smat->ld)), &ione); \
+		const int ione=1, m_i=s2i(m); \
+		double ret = bid##asum_(&m_i, smat->id##body, &ione); \
+		for ( size_t j=1; j<n; j++ ) { \
+			double temp = bid##asum_(&m_i, smat->id##body+(j*(smat->ld)), &ione); \
 			if ( ret < temp ) { ret = temp; } \
 		} \
 		return rb_float_new(ret); \
@@ -227,13 +241,13 @@ kmm_mat_normf(VALUE self)
 } while (0)
 #define NORMi(type, id, m_ent, m, n, m_abs, m_add, m_cmp, x2v) \
 	type ret = m_abs(m_ent(smat, id, 0)); \
-	for ( int j=1; j<n; j++ ) { \
+	for ( size_t j=1; j<n; j++ ) { \
 		type foo = m_abs(m_ent(smat, id, j*(smat->ld))); \
 		ret = m_add(ret, foo); \
 	} \
-	for ( int i=1; i<m; i++ ) { \
+	for ( size_t i=1; i<m; i++ ) { \
 		type bar = m_abs(m_ent(smat, id, i)); \
-		for ( int j=1; j<n; j++ ) { \
+		for ( size_t j=1; j<n; j++ ) { \
 			type foo = m_abs(m_ent(smat, id, i+j*(smat->ld))); \
 			bar = m_add(bar, foo); \
 		} \
@@ -244,9 +258,10 @@ kmm_mat_normf(VALUE self)
 	if ( smat->stype == ST_RSUB ) { \
 		NORMi(double, id, ENTITYr0, m, n, m_abs, NUM_ADD, NUM_CMP, rb_float_new); \
 	} else { \
-		double ret = bid##asum_(&(n), smat->id##body, &(smat->ld)); \
-		for ( int i=1; i<m; i++ ) { \
-			double temp = bid##asum_(&(n), smat->id##body+i, &(smat->ld)); \
+		const int ld=s2i(smat->ld), n_i=s2i(n); \
+		double ret = bid##asum_(&n_i, smat->id##body, &ld); \
+		for ( size_t i=1; i<m; i++ ) { \
+			const double temp = bid##asum_(&n_i, smat->id##body+i, &ld); \
 			if ( ret < temp ) { ret = temp; } \
 		} \
 		return rb_float_new(ret); \
@@ -350,16 +365,16 @@ kmm_mat_norm_e1(VALUE self)
 	SMAT *smat = km_mat2smat(self);
 	if ( smat->vtype == VT_DOUBLE ) {
 		if ( smat->stype == ST_FULL ) {
-			int ione = 1, n = LENGTH(smat);
+			const int ione = 1, n = LENGTHi(smat);
 			return rb_float_new(dasum_(&n, smat->dbody, &ione));
 		} else if ( smat->stype == ST_SSUB ) {
-			int ione = 1, lps, size; double ret = 0.0;
+			const int ione = 1; int size; size_t lps; double ret = 0.0;
 			if ( smat->trans ) {
-				lps = smat->m; size = smat->n;
+				lps = smat->m; size = s2i(smat->n);
 			} else {
-				lps = smat->n; size = smat->m;
+				lps = smat->n; size = s2i(smat->m);
 			}
-			for ( int i=0; i<lps; i++ ) {
+			for ( size_t i=0; i<lps; i++ ) {
 				ret += dasum_(&size, smat->dbody+(i*(smat->ld)), &ione);
 			}
 			return rb_float_new(ret);
@@ -370,16 +385,16 @@ kmm_mat_norm_e1(VALUE self)
 		}
 	} else if ( smat->vtype == VT_COMPLEX ) {
 		if ( smat->stype == ST_FULL ) {
-			int ione = 1, n = LENGTH(smat);
+			const int ione = 1, n = LENGTHi(smat);
 			return rb_float_new(dzasum_(&n, smat->zbody, &ione));
 		} else if ( smat->stype == ST_SSUB ) {
-			int ione = 1, lps, size; double ret = 0.0;
+			const int ione = 1; int size; size_t lps; double ret = 0.0;
 			if ( smat->trans ) {
-				lps = smat->m; size = smat->n;
+				lps = smat->m; size = s2i(smat->n);
 			} else {
-				lps = smat->n; size = smat->m;
+				lps = smat->n; size = s2i(smat->m);
 			}
-			for ( int i=0; i<lps; i++ ) {
+			for ( size_t i=0; i<lps; i++ ) {
 				ret += dzasum_(&size, smat->zbody+(i*(smat->ld)), &ione);
 			}
 			return rb_float_new(ret);
@@ -410,7 +425,7 @@ static void
 km_amax_d(double *ent, void *data)
 {
 	double *ret = (double *)data;
-	double temp = fabs(*ent);
+	const double temp = fabs(*ent);
 	if ( *ret < temp ) {
 		*ret = temp;
 	}
@@ -419,7 +434,7 @@ static void
 km_amax_z(COMPLEX *ent, void *data)
 {
 	double *ret = (double *)data;
-	double temp = cabs(*ent);
+	const double temp = cabs(*ent);
 	if ( *ret < temp ) {
 		*ret = temp;
 	}
@@ -428,7 +443,7 @@ static void
 km_amax_i(int *ent, void *data)
 {
 	int *ret = (int *)data;
-	int temp = ABS(*ent);
+	const int temp = ABS(*ent);
 	if ( *ret < temp ) {
 		*ret = temp;
 	}
@@ -443,7 +458,7 @@ static void
 km_amax_v(VALUE *ent, void *data)
 {
 	VALUE *ret = (VALUE *)data;
-	VALUE temp = rb_funcall(*ent, id_abs, 0);
+	const VALUE temp = rb_funcall(*ent, id_abs, 0);
 	if ( rb_funcall(*ret, id_op_lt, 1, temp) ) {
 		*ret = temp;
 	}
@@ -454,16 +469,16 @@ kmm_mat_norm_einf(VALUE self)
 	SMAT *smat = km_mat2smat(self);
 	if ( smat->vtype == VT_DOUBLE ) {
 		if ( smat->stype == ST_FULL ) {
-			int ione=1, n=LENGTH(smat);
+			const int ione=1, n=LENGTHi(smat);
 			return rb_float_new(fabs(smat->dbody[idamax_(&n, smat->dbody, &ione)-1]));
 		} else if ( smat->stype == ST_SSUB ) {
-			int ione=1, lps, size; double ret = 0.0;
+			const int ione=1; int size; size_t lps; double ret = 0.0;
 			if ( smat->trans ) {
-				lps = smat->m; size = smat->n;
+				lps = smat->m; size = s2i(smat->n);
 			} else {
-				lps = smat->n; size = smat->m;
+				lps = smat->n; size = s2i(smat->m);
 			}
-			for ( int i=0; i<lps; i++ ) {
+			for ( size_t i=0; i<lps; i++ ) {
 				double temp = fabs(smat->dbody[idamax_(&size, smat->dbody+(i*(smat->ld)), &ione)-1]);
 				if ( ret < temp ) { ret = temp; }
 			}
@@ -475,16 +490,16 @@ kmm_mat_norm_einf(VALUE self)
 		}
 	} else if ( smat->vtype == VT_COMPLEX ) {
 		if ( smat->stype == ST_FULL ) {
-			int ione=1, n=LENGTH(smat);
+			const int ione=1, n=LENGTHi(smat);
 			return rb_float_new(cabs(smat->zbody[izamax_(&n, smat->zbody, &ione)-1]));
 		} else if ( smat->stype == ST_SSUB ) {
-			int ione=1, lps, size; double ret = 0.0;
+			const int ione=1; int size; size_t lps; double ret = 0.0;
 			if ( smat->trans ) {
-				lps = smat->m; size = smat->n;
+				lps = smat->m; size = s2i(smat->n);
 			} else {
-				lps = smat->n; size = smat->m;
+				lps = smat->n; size = s2i(smat->m);
 			}
-			for ( int i=0; i<lps; i++ ) {
+			for ( size_t i=0; i<lps; i++ ) {
 				double temp = cabs(smat->zbody[izamax_(&size, smat->zbody+(i*(smat->ld)), &ione)-1]);
 				if ( ret < temp ) { ret = temp; }
 			}
@@ -522,7 +537,7 @@ km_norm2_body(VALUE data)
 {
 	struct km_norm2_arg *a = (struct km_norm2_arg *)data;
 	
-	int m = a->sa->m, n = a->sa->n;
+	int m = s2i(a->sa->m), n = s2i(a->sa->n);
 	
 	double opt; int lwork=-1, info;
 	char jobz[] = "N";
@@ -573,8 +588,8 @@ km__rcond2_body(VALUE data)
 {
 	struct km__rcond2_arg *a = (struct km__rcond2_arg *)data;
 	
-	int n = a->sa->m;
-	km_check_size(1, a->sa->n,n);
+	int n = s2i(a->sa->m);
+	km_check_size(1, s2i(a->sa->n),n);
 	
 	double opt; int lwork=-1, info;
 	char jobz[]="N";
@@ -625,8 +640,8 @@ km__rcondf_body(VALUE data)
 {
 	struct km__rcondf_arg *a = (struct km__rcondf_arg *)data;
 	
-	int n = a->sa->m;
-	km_check_size(1, a->sa->n,n);
+	int n = s2i(a->sa->m);
+	km_check_size(1, s2i(a->sa->n),n);
 	
 	double opt; int lwork=-1, info;
 	dgetri_(&n, NULL, &n, NULL, &opt, &lwork, &info);
@@ -640,7 +655,7 @@ km__rcondf_body(VALUE data)
 	km_check_info(info, km_eUncomp, "the matrix is exactry singular", "dgetrf");
 	dgetri_(&n, a->a, &n, a->ipiv, a->work, &lwork, &info);
 	km_check_info(info, rb_eRuntimeError, "unexpected info value", "dgetri");
-	int len = n*n, ione = 1;
+	const int len = n*n, ione = 1;
 	return rb_float_new(1.0/((a->normf)*dnrm2_(&len, a->a, &ione)));
 }
 static VALUE
@@ -678,8 +693,8 @@ km__rcondoi_body(VALUE data)
 {
 	struct km__rcondoi_arg *a = (struct km__rcondoi_arg *)data;
 	
-	int n = a->sa->m;
-	km_check_size(1, a->sa->n,n);
+	int n = s2i(a->sa->m);
+	km_check_size(1, s2i(a->sa->n),n);
 	
 	KALLOCc(a->a, a->sa);
 	KALLOC(a->iwork, n);
@@ -724,4 +739,3 @@ kmm_mat__rcondoi(VALUE self, VALUE sym)
 	
 	return self;
 }
-

data/ext/kmat/linalg/vla.c

@@ -9,23 +9,23 @@ 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);
+	const size_t n=a->sx->m, nrhs=a->sx->n;
+	km_check_size_s(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);
+	const VALUE zero=INT2NUM(0);
 	
 	// forward elimination
-	for ( int k=0; k<n; k++ ) {
+	for ( size_t 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++ ) {
+			for ( size_t 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++ ) {
+					for ( size_t j=k; j<n; j++ ) {
 						SWAP(VALUE, (a->a)[k+j*n], (a->a)[i+j*n]);
 					}
-					for ( int j=0; j<nrhs; j++ ) {
+					for ( size_t 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;
@@ -34,32 +34,32 @@ km_vmat_solve_body(VALUE data)
 			rb_raise(km_eUncomp, "matrix is singular");
 			nonsingular: ;
 		}
-		VALUE akk = (a->a)[k+k*n];
-		for ( int j=k+1; j<n; j++ ) {
+		const VALUE akk = (a->a)[k+k*n];
+		for ( size_t 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++ ) {
+		for ( size_t 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]);
+		for( size_t i=k+1; i<n; i++ ) {
+			const VALUE aik = (a->a)[i+k*n];
+			for ( size_t j=k+1; j<n; j++ ) {
+				const 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)]);
+			for ( size_t j=0; j<nrhs; j++ ) {
+				const 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)]);
+	for ( size_t k=n-1; k>0; k-- ) {
+		for ( size_t i=0; i<k; i++ ) {
+			const VALUE aik = (a->a)[i+k*n];
+			for ( size_t j=0; j<nrhs; j++ ) {
+				const 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);
 			}
 		}
@@ -94,8 +94,8 @@ 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);
+	const size_t n = sa->m;
+	km_check_size_s(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);