kmat 0.0.3 → 0.1.0

data/ext/kmat/arith/binary.c

@@ -37,44 +37,46 @@ kmm_mat_add_destl(VALUE self, VALUE other)
 	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;
+			const double alpha = 1.0; const int len = LENGTHi(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;
+			const double alpha = 1.0; int incy, incx; size_t stepy, stepx;
 			if ( sy->trans ) {
-				incy = sy->ld; stepy = 1;
+				incy = s2i(sy->ld); stepy = 1;
 			} else {
 				incy = 1; stepy = sy->ld;
 			}
 			if ( sx->trans ) {
-				incx = sx->ld; stepx = 1;
+				incx = s2i(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);
+			const int m=s2i(sy->m);
+			for ( size_t i=0; i<(sy->n); i++ ) {
+				daxpy_(&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;
+			const COMPLEX alpha = cpack(1.0, 0.0); int len = LENGTHi(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;
+			const COMPLEX alpha = cpack(1.0, 0.0); int incy, incx; size_t stepy, stepx;
 			if ( sy->trans ) {
-				incy = sy->ld; stepy = 1;
+				incy = s2i(sy->ld); stepy = 1;
 			} else {
 				incy = 1; stepy = sy->ld;
 			}
 			if ( sx->trans ) {
-				incx = sx->ld; stepx = 1;
+				incx = s2i(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);
+			const int m=s2i(sy->m);
+			for ( size_t i=0; i<(sy->n); i++ ) {
+				zaxpy_(&m, &alpha, (sx->zbody)+(i*stepx), &incx, (sy->zbody)+(i*stepy), &incy);
 			}
 		} else {
 			km_smat_each2_z(sy, sx, km_add_z, NULL);
@@ -122,44 +124,46 @@ kmm_mat_sub_destl(VALUE self, VALUE other)
 	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;
+			const double alpha = -1.0; const int len = LENGTHi(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;
+			const double alpha = -1.0; int incy, incx; size_t stepy, stepx;
 			if ( sy->trans ) {
-				incy = sy->ld; stepy = 1;
+				incy = s2i(sy->ld); stepy = 1;
 			} else {
 				incy = 1; stepy = sy->ld;
 			}
 			if ( sx->trans ) {
-				incx = sx->ld; stepx = 1;
+				incx = s2i(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);
+			const int m=s2i(sy->m);
+			for ( size_t i=0; i<(sy->n); i++ ) {
+				daxpy_(&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;
+			const COMPLEX alpha = cpack(-1.0, 0.0); const int len = LENGTHi(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;
+			const COMPLEX alpha = cpack(-1.0, 0.0); int incy, incx; size_t stepy, stepx;
 			if ( sy->trans ) {
-				incy = sy->ld; stepy = 1;
+				incy = s2i(sy->ld); stepy = 1;
 			} else {
 				incy = 1; stepy = sy->ld;
 			}
 			if ( sx->trans ) {
-				incx = sx->ld; stepx = 1;
+				incx = s2i(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);
+			const int m=s2i(sy->m);
+			for ( size_t i=0; i<(sy->n); i++ ) {
+				zaxpy_(&m, &alpha, (sx->zbody)+(i*stepx), &incx, (sy->zbody)+(i*stepy), &incy);
 			}
 		} else {
 			km_smat_each2_z(sy, sx, km_sub_z, NULL);
@@ -283,31 +287,31 @@ kmm_mat_e_div_destl(VALUE self, VALUE other)
 static void
 km_s_add_d(double *ent, void *data)
 {
-	double *val = (double *)data;
+	const double *val = (double *)data;
 	*ent += *val;
 }
 static void
 km_s_add_z(COMPLEX *ent, void *data)
 {
-	COMPLEX *val = (COMPLEX *)data;
+	const COMPLEX *val = (COMPLEX *)data;
 	*ent += *val;
 }
 static void
 km_s_add_i(int *ent, void *data)
 {
-	int *val = (int *)data;
+	const int *val = (int *)data;
 	*ent += *val;
 }
 static void
 km_s_add_b(bool *ent, void *data)
 {
-	bool *val = (bool *)data;
+	const bool *val = (bool *)data;
 	*ent = XOR(*ent, *val);
 }
 static void
 km_s_add_v(VALUE *ent, void *data)
 {
-	VALUE val = (VALUE)data;
+	const VALUE val = (VALUE)data;
 	*ent = rb_funcall(*ent, id_op_plus, 1, val);
 }
 VALUE
@@ -316,52 +320,56 @@ 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);
+		const double val = NUM2DBL(vval);
 		if ( sy->stype == ST_FULL ) {
-			double alpha=1.0;
-			int len=LENGTH(sy), ione=1, izero=0;
+			const double alpha=1.0;
+			const int len=LENGTHi(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;
+			const double alpha=1.0;
+			const 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);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					daxpy_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					daxpy_(&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);
+		const 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;
+			const COMPLEX alpha=cpack(1.0, 0.0);
+			const int len=LENGTHi(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;
+			const COMPLEX alpha=cpack(1.0, 0.0);
+			const 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);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					zaxpy_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					zaxpy_(&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);
+		const 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);
+		const 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);
@@ -374,25 +382,25 @@ kmm_mat_s_add_destl(VALUE self, VALUE vval)
 static void
 km_s_sub_d(double *ent, void *data)
 {
-	double *val = (double *)data;
+	const double *val = (double *)data;
 	*ent -= *val;
 }
 static void
 km_s_sub_z(COMPLEX *ent, void *data)
 {
-	COMPLEX *val = (COMPLEX *)data;
+	const COMPLEX *val = (COMPLEX *)data;
 	*ent -= *val;
 }
 static void
 km_s_sub_i(int *ent, void *data)
 {
-	int *val = (int *)data;
+	const int *val = (int *)data;
 	*ent -= *val;
 }
 static void
 km_s_sub_v(VALUE *ent, void *data)
 {
-	VALUE val = (VALUE)data;
+	const VALUE val = (VALUE)data;
 	*ent = rb_funcall(*ent, id_op_minus, 1, val);
 }
 VALUE
@@ -403,50 +411,54 @@ kmm_mat_s_sub_destl(VALUE self, VALUE vval)
 	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;
+			const double alpha=-1.0;
+			const int len=LENGTHi(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;
+			const double alpha=-1.0;
+			const 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);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					daxpy_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					daxpy_(&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);
+		const 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;
+			const COMPLEX alpha=cpack(-1.0, 0.0);
+			const int len=LENGTHi(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;
+			const COMPLEX alpha=cpack(-1.0, 0.0);
+			const 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);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					zaxpy_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					zaxpy_(&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);
+		const 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);
+		const 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);
@@ -460,25 +472,25 @@ kmm_mat_s_sub_destl(VALUE self, VALUE vval)
 static void
 km_s_mul_d(double *ent, void *data)
 {
-	double *val = (double *)data;
+	const double *val = (double *)data;
 	*ent *= *val;
 }
 static void
 km_s_mul_z(COMPLEX *ent, void *data)
 {
-	COMPLEX *val = (COMPLEX *)data;
+	const COMPLEX *val = (COMPLEX *)data;
 	*ent *= *val;
 }
 static void
 km_s_mul_i(int *ent, void *data)
 {
-	int *val = (int *)data;
+	const int *val = (int *)data;
 	*ent *= *val;
 }
 static void
 km_s_mul_v(VALUE *ent, void *data)
 {
-	VALUE val = (VALUE)data;
+	const VALUE val = (VALUE)data;
 	*ent = rb_funcall(*ent, id_op_mul, 1, val);
 }
 VALUE
@@ -487,45 +499,49 @@ 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);
+		const double val = NUM2DBL(vval);
 		if ( sy->stype == ST_FULL ) {
-			int len=LENGTH(sy), ione=1;
+			const int len=LENGTHi(sy), ione=1;
 			dscal_(&len, &val, sy->dbody, &ione);
 		} else if ( sy->stype == ST_SSUB ) {
-			int ione=1;
+			const int ione=1;
 			if ( sy->trans ) {
-				for ( int i=0; i<(sy->m); i++ ) {
-					dscal_(&(sy->n), &val, (sy->dbody)+(i*(sy->ld)), &ione);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					dscal_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					dscal_(&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);
+		const COMPLEX val = km_v2c(vval);
 		if ( sy->stype == ST_FULL ) {
-			int len=LENGTH(sy), ione=1;
+			const int len=LENGTHi(sy), ione=1;
 			zscal_(&len, &val, sy->zbody, &ione);
 		} else if ( sy->stype == ST_SSUB ) {
-			int ione=1;
+			const int ione=1;
 			if ( sy->trans ) {
-				for ( int i=0; i<(sy->m); i++ ) {
-					zscal_(&(sy->n), &val, (sy->zbody)+(i*(sy->ld)), &ione);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					zscal_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					zscal_(&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);
+		const int val = NUM2INT(vval);
 		km_smat_each_i(sy, km_s_mul_i, (void *)&val);
 	} else if ( sy->vtype == VT_BOOL ) {
 		if ( RTEST(vval) ) {
@@ -544,13 +560,13 @@ kmm_mat_s_mul_destl(VALUE self, VALUE vval)
 static void
 km_s_div_i(int *ent, void *data)
 {
-	int *val = (int *)data;
+	const int *val = (int *)data;
 	*ent /= *val;
 }
 static void
 km_s_div_v(VALUE *ent, void *data)
 {
-	VALUE val = (VALUE)data;
+	const VALUE val = (VALUE)data;
 	*ent = rb_funcall(*ent, id_op_div, 1, val);
 }
 VALUE
@@ -563,17 +579,19 @@ kmm_mat_s_div_destl(VALUE self, VALUE 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;
+			const int len=LENGTHi(sy), ione=1;
 			dscal_(&len, &val, sy->dbody, &ione);
 		} else if ( sy->stype == ST_SSUB ) {
-			int ione=1;
+			const int ione=1;
 			if ( sy->trans ) {
-				for ( int i=0; i<(sy->m); i++ ) {
-					dscal_(&(sy->n), &val, (sy->dbody)+(i*(sy->ld)), &ione);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					dscal_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					dscal_(&m, &val, (sy->dbody)+(i*(sy->ld)), &ione);
 				}
 			}
 		} else {
@@ -584,24 +602,26 @@ kmm_mat_s_div_destl(VALUE self, VALUE 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;
+			const int len=LENGTHi(sy), ione=1;
 			zscal_(&len, &val, sy->zbody, &ione);
 		} else if ( sy->stype == ST_SSUB ) {
-			int ione=1;
+			const int ione=1;
 			if ( sy->trans ) {
-				for ( int i=0; i<(sy->m); i++ ) {
-					zscal_(&(sy->n), &val, (sy->zbody)+(i*(sy->ld)), &ione);
+				const int n=s2i(sy->n);
+				for ( size_t i=0; i<(sy->m); i++ ) {
+					zscal_(&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);
+				const int m=s2i(sy->m);
+				for ( size_t i=0; i<(sy->n); i++ ) {
+					zscal_(&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);
+		const 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 ) {
@@ -617,19 +637,19 @@ kmm_mat_s_div_destl(VALUE self, VALUE vval)
 static void
 km_add_times_d(double *y, double *x, void *data)
 {
-	double *a = (double *)data;
+	const double *a = (double *)data;
 	*y += ( (*x) * (*a) );
 }
 static void
 km_add_times_z(COMPLEX *y, COMPLEX *x, void *data)
 {
-	COMPLEX *a = (COMPLEX *)data;
+	const COMPLEX *a = (COMPLEX *)data;
 	*y += ( (*x) * (*a) );
 }
 static void
 km_add_times_i(int *y, int *x, void *data)
 {
-	int *a = (int *)data;
+	const int *a = (int *)data;
 	*y += ( (*x) * (*a) );
 }
 static void
@@ -649,53 +669,55 @@ kmm_mat_add_times_destl(VALUE self, VALUE other, VALUE valpha)
 	}
 	CHECK_SAME_SIZE(sx, sy);
 	if ( sy->vtype == VT_DOUBLE ) {
-		double alpha = NUM2DBL(valpha);
+		const double alpha = NUM2DBL(valpha);
 		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
-			int len = LENGTH(sy), ione=1;
+			const int len = LENGTHi(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;
+			int incy, incx; size_t stepx, stepy;
 			if ( sy->trans ) {
-				incy = sy->ld; stepy = 1;
+				incy = s2i(sy->ld); stepy = 1;
 			} else {
 				incy = 1; stepy = sy->ld;
 			}
 			if ( sx->trans ) {
-				incx = sx->ld; stepx = 1;
+				incx = s2i(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);
+			const int m=s2i(sy->m);
+			for ( size_t i=0; i<(sy->n); i++ ) {
+				daxpy_(&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);
+		const COMPLEX alpha = km_v2c(valpha);
 		if ( sy->stype == ST_FULL && sx->stype == ST_FULL && sy->trans == sx->trans ) {
-			int len = LENGTH(sy), ione=1;
+			const int len = LENGTHi(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;
+			int incy, incx; size_t stepx, stepy;
 			if ( sy->trans ) {
-				incy = sy->ld; stepy = 1;
+				incy = s2i(sy->ld); stepy = 1;
 			} else {
 				incy = 1; stepy = sy->ld;
 			}
 			if ( sx->trans ) {
-				incx = sx->ld; stepx = 1;
+				incx = s2i(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);
+			const int m=s2i(sy->m);
+			for ( size_t i=0; i<(sy->n); i++ ) {
+				zaxpy_(&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);
+		const 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) ) {
@@ -772,7 +794,7 @@ kmm_mat_maximum_destl(VALUE self, VALUE other)
 static void
 km_s_maximum_d(double *ey, void *data)
 {
-	double *val = (double *)data;
+	const double *val = (double *)data;
 	if ( *ey < *val ) {
 		*ey = *val;
 	}
@@ -780,7 +802,7 @@ km_s_maximum_d(double *ey, void *data)
 static void
 km_s_maximum_i(int *ey, void *data)
 {
-	int *val = (int *)data;
+	const int *val = (int *)data;
 	if ( *ey < *val ) {
 		*ey = *val;
 	}
@@ -788,7 +810,7 @@ km_s_maximum_i(int *ey, void *data)
 static void
 km_s_maximum_b(bool *ey, void *data)
 {
-	bool *val = (bool *)data;
+	const bool *val = (bool *)data;
 	if ( *val ) {
 		*ey = true;
 	}
@@ -796,7 +818,7 @@ km_s_maximum_b(bool *ey, void *data)
 static void
 km_s_maximum_v(VALUE *ey, void *data)
 {
-	VALUE val = (VALUE)data;
+	const VALUE val = (VALUE)data;
 	if ( rb_funcall(*ey, id_op_lt, 1, val) ) {
 		*ey = val;
 	}
@@ -888,7 +910,7 @@ kmm_mat_minimum_destl(VALUE self, VALUE other)
 static void
 km_s_minimum_d(double *ey, void *data)
 {
-	double *val = (double *)data;
+	const double *val = (double *)data;
 	if ( *val < *ey ) {
 		*ey = *val;
 	}
@@ -896,7 +918,7 @@ km_s_minimum_d(double *ey, void *data)
 static void
 km_s_minimum_i(int *ey, void *data)
 {
-	int *val = (int *)data;
+	const int *val = (int *)data;
 	if ( *val < *ey ) {
 		*ey = *val;
 	}
@@ -904,7 +926,7 @@ km_s_minimum_i(int *ey, void *data)
 static void
 km_s_minimum_b(bool *ey, void *data)
 {
-	bool *val = (bool *)data;
+	const bool *val = (bool *)data;
 	if ( !*val ) {
 		*ey = false;
 	}
@@ -912,7 +934,7 @@ km_s_minimum_b(bool *ey, void *data)
 static void
 km_s_minimum_v(VALUE *ey, void *data)
 {
-	VALUE val = (VALUE)data;
+	const VALUE val = (VALUE)data;
 	if ( rb_funcall(val, id_op_lt, 1, *ey) ) {
 		*ey = val;
 	}
@@ -1002,19 +1024,19 @@ kmm_mat_pow_destl(VALUE self, VALUE other)
 static void
 km_s_pow_d(double *b, void *data)
 {
-	double *e = (double *)data;
+	const double *e = (double *)data;
 	*b = pow(*b, *e);
 }
 static void
 km_s_pow_z(COMPLEX *b, void *data)
 {
-	COMPLEX *e = (COMPLEX *)data;
+	const COMPLEX *e = (COMPLEX *)data;
 	*b = cpow(*b, *e);
 }
 static void
 km_s_pow_i(int *b, void *data)
 {
-	int *e = (int *)data;
+	const int *e = (int *)data;
 	if ( *e < 0 ) {
 		rb_raise(rb_const_get(rb_mMath, id_DomainError), "the exponent must be non-negative");
 	}
@@ -1030,13 +1052,13 @@ km_s_pow_i(int *b, void *data)
 static void
 km_s_pow_b(bool *b, void *data)
 {
-	bool *e = (bool *)data;
+	const bool *e = (bool *)data;
 	*b = ( *b || !*e );
 }
 static void
 km_s_pow_v(VALUE *b, void *data)
 {
-	VALUE e = (VALUE)data;
+	const VALUE e = (VALUE)data;
 	*b = rb_funcall(*b, id_op_pow, 1, e);
 }
 VALUE
@@ -1091,13 +1113,13 @@ kmm_mat_hypot_destl(VALUE self, VALUE other)
 static void
 km_s_hypot_d(double *y, void *data)
 {
-	double *x = (double *)data;
+	const double *x = (double *)data;
 	*y = hypot(*y, *x);
 }
 static void
 km_s_hypot_z(COMPLEX *y, void *data)
 {
-	COMPLEX *x = (COMPLEX *)data;
+	const COMPLEX *x = (COMPLEX *)data;
 	*y = csqrt((*y)*(*y)+(*x)*(*x));
 }
 static void