void m_apm_divide(M_APM rr, int places, M_APM aa, M_APM bb)
{
M_APM tmp0, tmp1;
int sn, nexp, dplaces;
sn = aa->m_apm_sign * bb->m_apm_sign;
if (sn == 0) /* one number is zero, result is zero */
{
if (bb->m_apm_sign == 0)
{
M_apm_log_error_msg(M_APM_RETURN,
"Warning! ... \'m_apm_divide\', Divide by 0");
}
M_set_to_zero(rr);
return;
}
/*
* Use the original 'Knuth' method for smaller divides. On the
* author's system, this was the *approx* break even point before
* the reciprocal method used below became faster.
*/
if (places < 250)
{
M_apm_sdivide(rr, places, aa, bb);
return;
}
/* mimic the decimal place behavior of the original divide */
nexp = aa->m_apm_exponent - bb->m_apm_exponent;
if (nexp > 0)
dplaces = nexp + places;
else
dplaces = places;
tmp0 = M_get_stack_var();
tmp1 = M_get_stack_var();
m_apm_reciprocal(tmp0, (dplaces + 8), bb);
m_apm_multiply(tmp1, tmp0, aa);
m_apm_round(rr, dplaces, tmp1);
M_restore_stack(2);
}
/*
* cosh(x) == 0.5 * [ exp(x) + exp(-x) ]
*/
void m_apm_cosh(M_APM rr, int places, M_APM aa)
{
M_APM tmp1, tmp2, tmp3;
int local_precision;
tmp1 = M_get_stack_var();
tmp2 = M_get_stack_var();
tmp3 = M_get_stack_var();
local_precision = places + 4;
m_apm_exp(tmp1, local_precision, aa);
m_apm_reciprocal(tmp2, local_precision, tmp1);
m_apm_add(tmp3, tmp1, tmp2);
m_apm_multiply(tmp1, tmp3, MM_0_5);
m_apm_round(rr, places, tmp1);
M_restore_stack(3);
}
/*
* tanh(x) == [ exp(x) - exp(-x) ] / [ exp(x) + exp(-x) ]
*/
void m_apm_tanh(M_APM rr, int places, M_APM aa)
{
M_APM tmp1, tmp2, tmp3, tmp4;
int local_precision;
tmp1 = M_get_stack_var();
tmp2 = M_get_stack_var();
tmp3 = M_get_stack_var();
tmp4 = M_get_stack_var();
local_precision = places + 4;
m_apm_exp(tmp1, local_precision, aa);
m_apm_reciprocal(tmp2, local_precision, tmp1);
m_apm_subtract(tmp3, tmp1, tmp2);
m_apm_add(tmp4, tmp1, tmp2);
m_apm_divide(tmp1, local_precision, tmp3, tmp4);
m_apm_round(rr, places, tmp1);
M_restore_stack(4);
}
/*
* check if our local copy of log(2) & log(10) is precise
* enough for our purpose. if not, calculate them so it's
* as precise as desired, accurate to at least 'places'.
*/
void M_check_log_places(int places)
{
M_APM tmp6, tmp7, tmp8, tmp9;
int dplaces;
dplaces = places + 4;
if (dplaces > MM_lc_log_digits)
{
MM_lc_log_digits = dplaces + 4;
tmp6 = M_get_stack_var();
tmp7 = M_get_stack_var();
tmp8 = M_get_stack_var();
tmp9 = M_get_stack_var();
dplaces += 6 + (int)log10((double)places);
m_apm_copy(tmp7, MM_One);
tmp7->m_apm_exponent = -places;
M_log_AGM_R_func(tmp8, dplaces, MM_One, tmp7);
m_apm_multiply(tmp6, tmp7, MM_0_5);
M_log_AGM_R_func(tmp9, dplaces, MM_One, tmp6);
m_apm_subtract(MM_lc_log2, tmp9, tmp8); /* log(2) */
tmp7->m_apm_exponent -= 1; /* divide by 10 */
M_log_AGM_R_func(tmp9, dplaces, MM_One, tmp7);
m_apm_subtract(MM_lc_log10, tmp9, tmp8); /* log(10) */
m_apm_reciprocal(MM_lc_log10R, dplaces, MM_lc_log10); /* 1 / log(10) */
M_restore_stack(4);
}
}
void M_log_AGM_R_func(M_APM rr, int places, M_APM aa, M_APM bb)
{
M_APM tmp1, tmp2, tmp3, tmp4, tmpC2, sum, pow_2, tmpA0, tmpB0;
int tolerance, dplaces;
tmpA0 = M_get_stack_var();
tmpB0 = M_get_stack_var();
tmpC2 = M_get_stack_var();
tmp1 = M_get_stack_var();
tmp2 = M_get_stack_var();
tmp3 = M_get_stack_var();
tmp4 = M_get_stack_var();
sum = M_get_stack_var();
pow_2 = M_get_stack_var();
tolerance = places + 8;
dplaces = places + 16;
m_apm_copy(tmpA0, aa);
m_apm_copy(tmpB0, bb);
m_apm_copy(pow_2, MM_0_5);
m_apm_multiply(tmp1, aa, aa); /* 0.5 * [ a ^ 2 - b ^ 2 ] */
m_apm_multiply(tmp2, bb, bb);
m_apm_subtract(tmp3, tmp1, tmp2);
m_apm_multiply(sum, MM_0_5, tmp3);
while (TRUE)
{
m_apm_subtract(tmp1, tmpA0, tmpB0); /* C n+1 = 0.5 * [ An - Bn ] */
m_apm_multiply(tmp4, MM_0_5, tmp1); /* C n+1 */
m_apm_multiply(tmpC2, tmp4, tmp4); /* C n+1 ^ 2 */
/* do the AGM */
m_apm_add(tmp1, tmpA0, tmpB0);
m_apm_multiply(tmp3, MM_0_5, tmp1);
m_apm_multiply(tmp2, tmpA0, tmpB0);
m_apm_sqrt(tmpB0, dplaces, tmp2);
m_apm_round(tmpA0, dplaces, tmp3);
/* end AGM */
m_apm_multiply(tmp2, MM_Two, pow_2);
m_apm_copy(pow_2, tmp2);
m_apm_multiply(tmp1, tmpC2, pow_2);
m_apm_add(tmp3, sum, tmp1);
if ((tmp1->m_apm_sign == 0) ||
((-2 * tmp1->m_apm_exponent) > tolerance))
break;
m_apm_round(sum, dplaces, tmp3);
}
m_apm_subtract(tmp4, MM_One, tmp3);
m_apm_reciprocal(rr, places, tmp4);
M_restore_stack(9);
}
void m_apm_integer_pow(M_APM rr, int places, M_APM aa, int mexp)
{
M_APM tmp0, tmpy, tmpz;
int nexp, ii, signflag, local_precision;
if (mexp == 0)
{
m_apm_copy(rr, MM_One);
return;
}
else
{
if (mexp > 0)
{
signflag = 0;
nexp = mexp;
}
else
{
signflag = 1;
nexp = -mexp;
}
}
if (aa->m_apm_sign == 0)
{
M_set_to_zero(rr);
return;
}
tmp0 = M_get_stack_var();
tmpy = M_get_stack_var();
tmpz = M_get_stack_var();
local_precision = places + 8;
m_apm_copy(tmpy, MM_One);
m_apm_copy(tmpz, aa);
while (TRUE)
{
ii = nexp & 1;
nexp = nexp >> 1;
if (ii != 0) /* exponent -was- odd */
{
m_apm_multiply(tmp0, tmpy, tmpz);
m_apm_round(tmpy, local_precision, tmp0);
if (nexp == 0)
break;
}
m_apm_multiply(tmp0, tmpz, tmpz);
m_apm_round(tmpz, local_precision, tmp0);
}
if (signflag)
{
m_apm_reciprocal(rr, places, tmpy);
}
else
{
m_apm_round(rr, places, tmpy);
}
M_restore_stack(3);
}
void m_apm_reciprocal_mt(M_APM rr, int places, M_APM aa)
{
m_apm_enter();
m_apm_reciprocal(rr,places,aa);
m_apm_leave();
}
