kmat 0.0.3

data/ext/kmat/arith/logical.c

@@ -0,0 +1,332 @@
+#include "../kmat.h"
+
+// the number of SMATs is specified by `argc'
+// check whether the value types of the arguments are VT_BOOL or not
+// raise Mat::ValueTypeError if at least one of the arguments is not a boolean matrix
+void
+km_check_bool(int argc, ...)
+{
+	va_list argp;
+	va_start(argp, argc);
+	for ( int i=0; i<argc; i++ ) {
+		SMAT *smat = va_arg(argp, SMAT *);
+		if ( smat->vtype != VT_BOOL ) {
+			va_end(argp);
+			rb_raise(km_eVT, "boolean matrix is expected");
+		}
+	}
+	va_end(argp);
+}
+
+
+// element-wise logical operations
+static void
+km_not_func(bool *ent, void *null)
+{
+	*ent = !(*ent);
+}
+VALUE
+kmm_mat_not_dest(VALUE self)
+{
+	km_check_frozen(self);
+	SMAT *smat = km_mat2smat(self);
+	km_check_bool(1, smat);
+	km_smat_each_b(smat, km_not_func, NULL);
+	return self;
+}
+
+static void
+km_and_func(bool *dest, bool *other, void *null)
+{
+	*dest = ( *dest && *other );
+}
+VALUE
+kmm_mat_and_dest(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *ss = km_mat2smat(self), *so = km_mat2smat(other);
+	km_check_bool(2, ss, so);
+	CHECK_SAME_SIZE(ss, so);
+	km_smat_each2_b(ss, so, km_and_func, NULL);
+	return self;
+}
+
+static void
+km_or_func(bool *dest, bool *other, void *null)
+{
+	*dest = ( *dest || *other );
+}
+VALUE
+kmm_mat_or_dest(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *ss = km_mat2smat(self), *so = km_mat2smat(other);
+	km_check_bool(2, ss, so);
+	CHECK_SAME_SIZE(ss, so);
+	km_smat_each2_b(ss, so, km_or_func, NULL);
+	return self;
+}
+
+static void
+km_xor_func(bool *dest, bool *other, void *null)
+{
+	*dest = XOR( *dest, *other );
+}
+VALUE
+kmm_mat_xor_dest(VALUE self, VALUE other)
+{
+	km_check_frozen(self);
+	SMAT *ss = km_mat2smat(self), *so = km_mat2smat(other);
+	km_check_bool(2, ss, so);
+	CHECK_SAME_SIZE(ss, so);
+	km_smat_each2_b(ss, so, km_xor_func, NULL);
+	return self;
+}
+
+// compare operations
+static void
+km_eq_d(bool *r, const double *a, const double *b, void *null)
+{
+	*r = (*a == *b);
+}
+static void
+km_eq_z(bool *r, const COMPLEX *a, const COMPLEX *b, void *null)
+{
+	*r = (*a == *b);
+}
+static void
+km_eq_i(bool *r, const int *a, const int *b, void *null)
+{
+	*r = (*a == *b);
+}
+static void
+km_eq_b(bool *r, const bool *a, const bool *b, void *null)
+{
+	*r = (*a == *b);
+}
+static void
+km_eq_v(bool *r, const VALUE *a, const VALUE *b, void *null)
+{
+	*r = rb_funcall(*a, id_op_eq, 1, *b);
+}
+VALUE
+kmm_mat_eq_destl(VALUE self, VALUE va, VALUE vb)
+{
+	km_check_frozen(self);
+	SMAT *sr=km_mat2smat(self), *sa=km_mat2smat(va), *sb=km_mat2smat(vb);
+	km_check_bool(1, sr);
+	CHECK_SAME_SIZE(sr, sa);
+	CHECK_SAME_SIZE(sr, sb);
+	if ( sa->vtype != sb->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	VT_SWITCH( sa->vtype,
+		km_smat_each3_bcdcd(sr, sa, sb, km_eq_d, NULL);,
+		km_smat_each3_bczcz(sr, sa, sb, km_eq_z, NULL);,
+		km_smat_each3_bcici(sr, sa, sb, km_eq_i, NULL);,
+		km_smat_each3_bcbcb(sr, sa, sb, km_eq_b, NULL);,
+		km_smat_each3_bcvcv(sr, sa, sb, km_eq_v, NULL);
+	);
+	return self;
+}
+static void
+km_ne_d(bool *r, const double *a, const double *b, void *null)
+{
+	*r = (*a != *b);
+}
+static void
+km_ne_z(bool *r, const COMPLEX *a, const COMPLEX *b, void *null)
+{
+	*r = (*a != *b);
+}
+static void
+km_ne_i(bool *r, const int *a, const int *b, void *null)
+{
+	*r = (*a != *b);
+}
+static void
+km_ne_b(bool *r, const bool *a, const bool *b, void *null)
+{
+	*r = (*a != *b);
+}
+static void
+km_ne_v(bool *r, const VALUE *a, const VALUE *b, void *null)
+{
+	*r = rb_funcall(*a, id_op_ne, 1, *b);
+}
+VALUE
+kmm_mat_ne_destl(VALUE self, VALUE va, VALUE vb)
+{
+	km_check_frozen(self);
+	SMAT *sr=km_mat2smat(self), *sa=km_mat2smat(va), *sb=km_mat2smat(vb);
+	km_check_bool(1, sr);
+	CHECK_SAME_SIZE(sr, sa);
+	CHECK_SAME_SIZE(sr, sb);
+	if ( sa->vtype != sb->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	VT_SWITCH( sa->vtype,
+		km_smat_each3_bcdcd(sr, sa, sb, km_ne_d, NULL);,
+		km_smat_each3_bczcz(sr, sa, sb, km_ne_z, NULL);,
+		km_smat_each3_bcici(sr, sa, sb, km_ne_i, NULL);,
+		km_smat_each3_bcbcb(sr, sa, sb, km_ne_b, NULL);,
+		km_smat_each3_bcvcv(sr, sa, sb, km_ne_v, NULL);
+	);
+	return self;
+}
+static void
+km_lt_d(bool *r, const double *a, const double *b, void *null)
+{
+	*r = (*a < *b);
+}
+static void
+km_lt_i(bool *r, const int *a, const int *b, void *null)
+{
+	*r = (*a < *b);
+}
+static void
+km_lt_v(bool *r, const VALUE *a, const VALUE *b, void *null)
+{
+	*r = rb_funcall(*a, id_op_lt, 1, *b);
+}
+VALUE
+kmm_mat_lt_destl(VALUE self, VALUE va, VALUE vb)
+{
+	km_check_frozen(self);
+	SMAT *sr=km_mat2smat(self), *sa=km_mat2smat(va), *sb=km_mat2smat(vb);
+	km_check_bool(1, sr);
+	CHECK_SAME_SIZE(sr, sa);
+	CHECK_SAME_SIZE(sr, sb);
+	if ( sa->vtype != sb->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	if ( sa->vtype == VT_DOUBLE ) {
+		km_smat_each3_bcdcd(sr, sa, sb, km_lt_d, NULL);
+	} else if ( sa->vtype == VT_INT ) {
+		km_smat_each3_bcici(sr, sa, sb, km_lt_i, NULL);
+	} else {
+		if ( sa->vtype != VT_VALUE ) {
+			sa = km_mat2smat(kmm_mat_to_omat(va));
+			sb = km_mat2smat(kmm_mat_to_omat(vb));
+		}
+		km_smat_each3_bcvcv(sr, sa, sb, km_lt_v, NULL);
+	}
+	return self;
+}
+static void
+km_le_d(bool *r, const double *a, const double *b, void *null)
+{
+	*r = (*a <= *b);
+}
+static void
+km_le_i(bool *r, const int *a, const int *b, void *null)
+{
+	*r = (*a <= *b);
+}
+static void
+km_le_v(bool *r, const VALUE *a, const VALUE *b, void *null)
+{
+	*r = rb_funcall(*a, id_op_le, 1, *b);
+}
+VALUE
+kmm_mat_le_destl(VALUE self, VALUE va, VALUE vb)
+{
+	km_check_frozen(self);
+	SMAT *sr=km_mat2smat(self), *sa=km_mat2smat(va), *sb=km_mat2smat(vb);
+	km_check_bool(1, sr);
+	CHECK_SAME_SIZE(sr, sa);
+	CHECK_SAME_SIZE(sr, sb);
+	if ( sa->vtype != sb->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	if ( sa->vtype == VT_DOUBLE ) {
+		km_smat_each3_bcdcd(sr, sa, sb, km_le_d, NULL);
+	} else if ( sa->vtype == VT_INT ) {
+		km_smat_each3_bcici(sr, sa, sb, km_le_i, NULL);
+	} else {
+		if ( sa->vtype != VT_VALUE ) {
+			sa = km_mat2smat(kmm_mat_to_omat(va));
+			sb = km_mat2smat(kmm_mat_to_omat(vb));
+		}
+		km_smat_each3_bcvcv(sr, sa, sb, km_le_v, NULL);
+	}
+	return self;
+}
+static void
+km_gt_d(bool *r, const double *a, const double *b, void *null)
+{
+	*r = (*a > *b);
+}
+static void
+km_gt_i(bool *r, const int *a, const int *b, void *null)
+{
+	*r = (*a > *b);
+}
+static void
+km_gt_v(bool *r, const VALUE *a, const VALUE *b, void *null)
+{
+	*r = rb_funcall(*a, id_op_gt, 1, *b);
+}
+VALUE
+kmm_mat_gt_destl(VALUE self, VALUE va, VALUE vb)
+{
+	km_check_frozen(self);
+	SMAT *sr=km_mat2smat(self), *sa=km_mat2smat(va), *sb=km_mat2smat(vb);
+	km_check_bool(1, sr);
+	CHECK_SAME_SIZE(sr, sa);
+	CHECK_SAME_SIZE(sr, sb);
+	if ( sa->vtype != sb->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	if ( sa->vtype == VT_DOUBLE ) {
+		km_smat_each3_bcdcd(sr, sa, sb, km_gt_d, NULL);
+	} else if ( sa->vtype == VT_INT ) {
+		km_smat_each3_bcici(sr, sa, sb, km_gt_i, NULL);
+	} else {
+		if ( sa->vtype != VT_VALUE ) {
+			sa = km_mat2smat(kmm_mat_to_omat(va));
+			sb = km_mat2smat(kmm_mat_to_omat(vb));
+		}
+		km_smat_each3_bcvcv(sr, sa, sb, km_gt_v, NULL);
+	}
+	return self;
+}
+static void
+km_ge_d(bool *r, const double *a, const double *b, void *null)
+{
+	*r = (*a >= *b);
+}
+static void
+km_ge_i(bool *r, const int *a, const int *b, void *null)
+{
+	*r = (*a >= *b);
+}
+static void
+km_ge_v(bool *r, const VALUE *a, const VALUE *b, void *null)
+{
+	*r = rb_funcall(*a, id_op_ge, 1, *b);
+}
+VALUE
+kmm_mat_ge_destl(VALUE self, VALUE va, VALUE vb)
+{
+	km_check_frozen(self);
+	SMAT *sr=km_mat2smat(self), *sa=km_mat2smat(va), *sb=km_mat2smat(vb);
+	km_check_bool(1, sr);
+	CHECK_SAME_SIZE(sr, sa);
+	CHECK_SAME_SIZE(sr, sb);
+	if ( sa->vtype != sb->vtype ) {
+		rb_raise(km_eVT, "value types must be same");
+	}
+	if ( sa->vtype == VT_DOUBLE ) {
+		km_smat_each3_bcdcd(sr, sa, sb, km_ge_d, NULL);
+	} else if ( sa->vtype == VT_INT ) {
+		km_smat_each3_bcici(sr, sa, sb, km_ge_i, NULL);
+	} else {
+		if ( sa->vtype != VT_VALUE ) {
+			sa = km_mat2smat(kmm_mat_to_omat(va));
+			sb = km_mat2smat(kmm_mat_to_omat(vb));
+		}
+		km_smat_each3_bcvcv(sr, sa, sb, km_ge_v, NULL);
+	}
+	return self;
+}

data/ext/kmat/arith/math.c

@@ -0,0 +1,34 @@
+#include "../kmat.h"
+
+VALUE
+kmm_MATH_exp2(VALUE self, VALUE x)
+{
+	return rb_float_new(exp2(NUM2DBL(x)));
+}
+
+VALUE
+kmm_MATH_expm1(VALUE self, VALUE x)
+{
+	return rb_float_new(expm1(NUM2DBL(x)));
+}
+
+VALUE
+kmm_MATH_log1p(VALUE self, VALUE x)
+{
+	return rb_float_new(log1p(NUM2DBL(x)));
+}
+
+VALUE
+kmm_float_sign(VALUE self)
+{
+	double x = NUM2DBL(self);
+	if ( x == 0.0 ) {
+		return INT2NUM(0);
+	} else if ( x > 0.0 ) {
+		return INT2NUM(1);
+	} else if ( x < 0.0 ) {
+		return INT2NUM(-1);
+	} else {
+		return self;
+	}
+}

data/ext/kmat/arith/statistics.c

@@ -0,0 +1,173 @@
+#include "../kmat.h"
+
+// product of all elements
+void
+km_prod_d(double *ent, void *data)
+{
+	double *ret = (double *)data;
+	*ret *= *ent;
+}
+void
+km_prod_z(COMPLEX *ent, void *data)
+{
+	COMPLEX *ret = (COMPLEX *)data;
+	*ret *= *ent;
+}
+void
+km_prod_i(int *ent, void *data)
+{
+	int *ret = (int *)data;
+	*ret *= *ent;
+}
+void
+km_prod_v(VALUE *ent, void *data)
+{
+	VALUE *ret = (VALUE *)data;
+	*ret = rb_funcall(*ret, id_op_mul, 1, *ent);
+}
+VALUE
+kmm_mat_prod(VALUE self)
+{
+	SMAT *smat = km_mat2smat(self);
+	VT_SWITCH( smat->vtype,
+		double ret=1.0; km_smat_each_d(smat, km_prod_d, (void *)(&ret)); return rb_float_new(ret);,
+		COMPLEX ret=cpack(1.0, 0.0); km_smat_each_z(smat, km_prod_z, (void *)(&ret)); return km_c2v(ret);,
+		int ret=1; km_smat_each_i(smat, km_prod_i, (void *)(&ret)); return INT2NUM(ret);,
+		return rb_funcall(self, id_all_p, 0);,
+		VALUE ret=INT2NUM(1); km_smat_each_v(smat, km_prod_v, (void *)(&ret)); return ret;
+	);
+}
+
+// summation
+// the shape of the output-argument determines the axis of summations
+void
+km_sum_all_d(double *ent, void *data)
+{
+	double *ret = (double *)data;
+	*ret += *ent;
+}
+void
+km_sum_all_z(COMPLEX *ent, void *data)
+{
+	COMPLEX *ret = (COMPLEX *)data;
+	*ret += *ent;
+}
+void
+km_sum_all_i(int *ent, void *data)
+{
+	int *ret = (int *)data;
+	*ret += *ent;
+}
+void
+km_sum_all_b(bool *ent, void *data)
+{
+	bool *ret = (bool *)data;
+	*ret = XOR(*ret, *ent);
+}
+void
+km_sum_all_v(VALUE *ent, void *data)
+{
+	VALUE *ret = (VALUE *)data;
+	*ret = rb_funcall(*ret, id_op_plus, 1, *ent);
+}
+void
+km_sum_col_d(double *ent, int i, int j, void *data)
+{
+	double *r = (double *)data;
+	r[j] += *ent;
+}
+void
+km_sum_col_z(COMPLEX *ent, int i, int j, void *data)
+{
+	COMPLEX *r = (COMPLEX *)data;
+	r[j] += *ent;
+}
+void
+km_sum_col_i(int *ent, int i, int j, void *data)
+{
+	int *r = (int *)data;
+	r[j] += *ent;
+}
+void
+km_sum_col_b(bool *ent, int i, int j, void *data)
+{
+	bool *r = (bool *)data;
+	r[j] = XOR(r[j], *ent);
+}
+void
+km_sum_col_v(VALUE *ent, int i, int j, void *data)
+{
+	VALUE *r = (VALUE *)data;
+	r[j] = rb_funcall(r[j], id_op_plus, 1, *ent);
+}
+void
+km_sum_row_d(double *ent, int i, int j, void *data)
+{
+	double *r = (double *)data;
+	r[i] += *ent;
+}
+void
+km_sum_row_z(COMPLEX *ent, int i, int j, void *data)
+{
+	COMPLEX *r = (COMPLEX *)data;
+	r[i] += *ent;
+}
+void
+km_sum_row_i(int *ent, int i, int j, void *data)
+{
+	int *r = (int *)data;
+	r[i] += *ent;
+}
+void
+km_sum_row_b(bool *ent, int i, int j, void *data)
+{
+	bool *r = (bool *)data;
+	r[i] = XOR(r[i], *ent);
+}
+void
+km_sum_row_v(VALUE *ent, int i, int j, void *data)
+{
+	VALUE *r = (VALUE *)data;
+	r[i] = rb_funcall(r[i], id_op_plus, 1, *ent);
+}
+VALUE
+kmm_mat__sum(VALUE self, VALUE dest)
+{
+	km_check_frozen(dest);
+	SMAT *sr = km_mat2smat(dest), *sa = km_mat2smat(self);
+	if ( sr->vtype != sa->vtype ) { rb_raise(km_eVT, "value types must be same"); }
+	if ( sr->stype != ST_FULL ) { rb_raise(km_eShare, "the argument must be a full matrix"); }
+	sr->trans = false; sr->ld = sr->m;
+	if ( sr->m == 1 && sr->n == 1 ) {
+		VT_SWITCH( sr->vtype,
+			sr->dbody[0]=0.0; km_smat_each_d(sa, km_sum_all_d, sr->body); return rb_float_new(sr->dbody[0]);,
+			sr->zbody[0]=cpack(0.0, 0.0); km_smat_each_z(sa, km_sum_all_z, sr->body); return km_c2v(sr->zbody[0]);,
+			sr->ibody[0]=0; km_smat_each_i(sa, km_sum_all_i, sr->body); return INT2NUM(sr->ibody[0]);,
+			sr->bbody[0]=false; km_smat_each_b(sa, km_sum_all_b, sr->body); return TF2V(sr->bbody[0]);,
+			sr->vbody[0]=INT2NUM(0); km_smat_each_v(sa, km_sum_all_v, sr->body); return sr->vbody[0];
+		);
+	} else if ( sr->m == 1 && sr->n == sa->n ) {
+		kmm_mat_zero(dest);
+		VT_SWITCH( sr->vtype,
+			km_smat_each_with_index_d(sa, km_sum_col_d, sr->body);,
+			km_smat_each_with_index_z(sa, km_sum_col_z, sr->body);,
+			km_smat_each_with_index_i(sa, km_sum_col_i, sr->body);,
+			km_smat_each_with_index_b(sa, km_sum_col_b, sr->body);,
+			km_smat_each_with_index_v(sa, km_sum_col_v, sr->body);
+		);
+	} else if ( sr->m == sa->m && sr->n == 1 ) {
+		kmm_mat_zero(dest);
+		VT_SWITCH( sr->vtype,
+			km_smat_each_with_index_d(sa, km_sum_row_d, sr->body);,
+			km_smat_each_with_index_z(sa, km_sum_row_z, sr->body);,
+			km_smat_each_with_index_i(sa, km_sum_row_i, sr->body);,
+			km_smat_each_with_index_b(sa, km_sum_row_b, sr->body);,
+			km_smat_each_with_index_v(sa, km_sum_row_v, sr->body);
+		);
+	} else if ( SAME_SIZE(sr, sa) ) {
+		km_smat_copy(sr, sa);
+	} else {
+		rb_raise(km_eDim, "sum from size (%d, %d) to size (%d, %d) is not defined", sa->m, sa->n, sr->m, sr->n);
+	}
+	return dest;
+}