func.c

Calc Software Package for Number Calc

				result.v_type = V_NUM;
				comfree(tmp);
			}
			break;
		default:
			return error_value(E_ACOT2);
	}
	return result;
}

static VALUE
f_asin(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ASIN1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			result.v_num = qasin(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_type = V_COM;
				result.v_com = c_asin(tmp, err);
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_asin(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ASIN2);
	}
	if (result.v_type == V_COM && cisreal(result.v_com)) {
		q = qlink(result.v_com->real);
		comfree(result.v_com);
		result.v_type = V_NUM;
		result.v_num = q;
	}
	return result;
}

static VALUE
f_acos(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ACOS1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			result.v_num = qacos(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_type = V_COM;
				result.v_com = c_acos(tmp, err);
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_acos(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ACOS2);
	}
	if (result.v_type == V_COM && cisreal(result.v_com)) {
		q = qlink(result.v_com->real);
		comfree(result.v_com);
		result.v_type = V_NUM;
		result.v_num = q;
	}
	return result;
}


static VALUE
f_asec(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ASEC1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			if (qiszero(vals[0]->v_num))
				return error_value(E_LOGINF);
			result.v_num = qasec(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_asec(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_asec(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ASEC2);
	}
	if (result.v_type == V_COM) {
		if (result.v_com == NULL)
			return error_value(E_LOGINF);
		if (cisreal(result.v_com)) {
			q = qlink(result.v_com->real);
			comfree(result.v_com);
			result.v_type = V_NUM;
			result.v_num = q;
		}
	}
	return result;
}


static VALUE
f_acsc(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ACSC1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			if (qiszero(vals[0]->v_num))
				return error_value(E_LOGINF);
			result.v_num = qacsc(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_acsc(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_acsc(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ACSC2);
	}
	if (result.v_type == V_COM) {
		if (result.v_com == NULL)
			return error_value(E_LOGINF);
		if (cisreal(result.v_com)) {
			q = qlink(result.v_com->real);
			comfree(result.v_com);
			result.v_type = V_NUM;
			result.v_num = q;
		}
	}
	return result;
}


static VALUE
f_asinh(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ASINH1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			result.v_num = qasinh(vals[0]->v_num, err);
			result.v_type = V_NUM;
			break;
		case V_COM:
			tmp = c_asinh(vals[0]->v_com, err);
			result.v_type = V_COM;
			result.v_com = tmp;
			if (cisreal(tmp)) {
				result.v_num = qlink(tmp->real);
				result.v_type = V_NUM;
				comfree(tmp);
			}
			break;
		default:
			return error_value(E_ASINH2);
	}
	return result;
}


static VALUE
f_acosh(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ACOSH1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			result.v_num = qacosh(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_acosh(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_acosh(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ACOSH2);
	}
	if (result.v_type == V_COM && cisreal(result.v_com)) {
		q = qlink(result.v_com->real);
		comfree(result.v_com);
		result.v_type = V_NUM;
		result.v_num = q;
	}
	return result;
}


static VALUE
f_atanh(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ATANH1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			result.v_num = qatanh(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_atanh(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_atanh(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ATANH2);
	}
	if (result.v_type == V_COM) {
		if (result.v_com == NULL)
			return error_value(E_LOGINF);
		if (cisreal(result.v_com)) {
			q = qlink(result.v_com->real);
			comfree(result.v_com);
			result.v_type = V_NUM;
			result.v_num = q;
		}
	}
	return result;
}


static VALUE
f_acoth(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ACOTH1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			result.v_num = qacoth(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_acoth(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_acoth(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ACOTH2);
	}
	if (result.v_type == V_COM) {
		if (result.v_com == NULL)
			return error_value(E_LOGINF);
		if (cisreal(result.v_com)) {
			q = qlink(result.v_com->real);
			comfree(result.v_com);
			result.v_type = V_NUM;
			result.v_num = q;
		}
	}
	return result;
}


static VALUE
f_asech(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_SECH1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			if (qiszero(vals[0]->v_num))
				return error_value(E_LOGINF);
			result.v_num = qasech(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_asech(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_asech(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ASECH2);
	}
	if (result.v_type == V_COM) {
		if (result.v_com == NULL)
			return error_value(E_LOGINF);
		if (cisreal(result.v_com)) {
			q = qlink(result.v_com->real);
			comfree(result.v_com);
			result.v_type = V_NUM;
			result.v_num = q;
		}
	}
	return result;
}


static VALUE
f_acsch(int count, VALUE **vals)
{
	VALUE result;
	COMPLEX *tmp;
	NUMBER *err;
	NUMBER *q;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	err = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_ACSCH1);
		err = vals[1]->v_num;
	}
	switch (vals[0]->v_type) {
		case V_NUM:
			if (qiszero(vals[0]->v_num))
				return error_value(E_LOGINF);
			result.v_num = qacsch(vals[0]->v_num, err);
			result.v_type = V_NUM;
			if (result.v_num == NULL) {
				tmp = comalloc();
				qfree(tmp->real);
				tmp->real = qlink(vals[0]->v_num);
				result.v_com = c_acsch(tmp, err);
				result.v_type = V_COM;
				comfree(tmp);
			}
			break;
		case V_COM:
			result.v_com = c_acsch(vals[0]->v_com, err);
			result.v_type = V_COM;
			break;
		default:
			return error_value(E_ACSCH2);
	}
	if (result.v_type == V_COM) {
		if (result.v_com == NULL)
			return error_value(E_LOGINF);
		if (cisreal(result.v_com)) {
			q = qlink(result.v_com->real);
			comfree(result.v_com);
			result.v_type = V_NUM;
			result.v_num = q;
		}
	}
	return result;
}


static VALUE
f_gd(int count, VALUE **vals)
{
	VALUE result;
	NUMBER *eps;
	NUMBER *q;
	COMPLEX *tmp;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	eps = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_GD1);
		eps = vals[1]->v_num;
	}
	result.v_type = V_COM;
	switch (vals[0]->v_type) {
		case V_NUM:
			if (qiszero(vals[0]->v_num)) {
				result.v_type = V_NUM;
				result.v_num = qlink(&_qzero_);
				return result;
			}
			tmp = comalloc();
			qfree(tmp->real);
			tmp->real = qlink(vals[0]->v_num);
			result.v_com = c_gd(tmp, eps);
			comfree(tmp);
			break;
		case V_COM:
			result.v_com = c_gd(vals[0]->v_com, eps);
			break;
		default:
			return error_value(E_GD2);
	}
	if (result.v_com == NULL)
		return error_value(E_GD3);
	if (cisreal(result.v_com)) {
		q = qlink(result.v_com->real);
		comfree(result.v_com);
		result.v_num = q;
		result.v_type = V_NUM;
	}
	return result;
}


static VALUE
f_agd(int count, VALUE **vals)
{
	VALUE result;
	NUMBER *eps;
	NUMBER *q;
	COMPLEX *tmp;

	/* initialize VALUE */
	result.v_subtype = V_NOSUBTYPE;

	eps = conf->epsilon;
	if (count == 2) {
		if (vals[1]->v_type != V_NUM || qiszero(vals[1]->v_num))
			return error_value(E_AGD1);
		eps = vals[1]->v_num;
	}
	result.v_type = V_COM;
	switch (vals[0]->v_type) {
		case V_NUM:
			if (qiszero(vals[0]->v_num)) {
				result.v_type = V_NUM;
				result.v_num = qlink(&_qzero_);
				return result;
			}
			tmp = comalloc();
			qfree(tmp->real);
			tmp->real = qlink(vals[0]->v_num);
			result.v_com = c_agd(tmp, eps);
			comfree(tmp);
			break;
		case V_COM:
			result.v_com = c_agd(vals[0]->v_com, eps);
			break;
		default:
			return error_value(E_AGD2);
	}
	if (result.v_com == NULL)
			return error_value(E_AGD3);
	if (cisreal(result.v_com)) {
		q = qlink(result.v_com->real);
		comfree(result.v_com);
		result.v_num = q;
		result.v_type = V_NUM;
	}
	return result;
}


static VALUE
f_comb(VALUE *v1, VALUE *v2)
{
	long n;
	VALUE result;
	VALUE tmp1, tmp2, div;

	if (v2->v_type != V_NUM || qisfrac(v2->v_num))
		return error_value(E_COMB1);
	result.v_subtype = V_NOSUBTYPE;
	result.v_type = V_NUM;
	if (qisneg(v2->v_num)) {
		result.v_num = qlink(&_qzero_);
		return result;
	}
	if (qiszero(v2->v_num)) {
		result.v_num = qlink(&_qone_);
		return result;
	}
	if (qisone(v2->v_num)) {
		copyvalue(v1, &result);
		return result;
	}
	if (v1->v_type == V_NUM) {
		result.v_num = qcomb(v1->v_num, v2->v_num);
		if (result.v_num == NULL)
			return error_value(E_COMB2);
		return result;
	}
	if (zge24b(v2->v_num->num))
		return error_value(E_COMB2);
	n = qtoi(v2->v_num);
	copyvalue(v1, &result);
	decvalue(v1, &tmp1);
	div.v_type = V_NUM;
	div.v_num = qlink(&_qtwo_);
	n--;
	for (;;) {
		mulvalue(&result, &tmp1, &tmp2);
		freevalue(&result);
		divvalue(&tmp2, &div, &result);
		freevalue(&tmp2);
		if (--n == 0 || !testvalue(&result) || result.v_type < 0) {
			freevalue(&tmp1);
			freevalue(&div);
			return result;
		}
		decvalue(&tmp1, &tmp2);
		freevalue(&tmp1);
		tmp1 = tmp2;
		incvalue(&div, &tmp2);
		freevalue(&div);
		div = tmp2;
	}
}


static VALUE
f_bern(VALUE *vp)
{
	VALUE res;

	if (vp->v_type != V_NUM || qisfrac(vp->v_num))
		return error_value(E_BERN);

	res.v_subtype = V_NOSUBTYPE;