/*
 * Arbitrary precision decimal arithmetic.
 *
 * Copyright (C) 1984 Free Software Foundation, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you can either send email to this
 * program's author (see below) or write to: The Free Software Foundation,
 * Inc.; 675 Mass Ave. Cambridge, MA 02139, USA.
 */

/* Some known problems:

	Another problem with decimal_div is found when you try to
	divide a number with > scale fraction digits by 1.  The
	expected result is simply truncation, but all sorts of things
	happen instead.  An example is that the result of .99999998/1
	with scale set to 6 is .000001

	There are some problems in the behavior of the decimal package
	related to printing and parsing.  The
	printer is weird about very large output radices, tending to want
	to output single ASCII characters for any and all digits (even
	in radices > 127).  The UNIX bc approach is to print digit groups
	separated by spaces.  There is a rather overwrought workaround in
	the function decputc() in bcmisc.c, but it would be better if
	decimal.c got a fix for this.  */

/* For stand-alone testing, compile with -DTEST.
   This DTESTable feature defines a `main' function
   which is a simple loop that accepts input of the form
   number space op space number newline
   where op is +, -, *, /, %, p or r,
   and performs the operation and prints the operands and result.
   `p' means print the first number in the radix spec'd by the second.
   `r' means read the first one in the radix specified by the second
   (and print the result in decimal).
   Divide in this test keeps three fraction digits. */

#include "decimal.h"

#define MAX(a, b) (((a) > (b) ? (a) : (b)))

/* Some constant decimal numbers */

struct decimal decimal_zero = {0, 0, 0, 0, 0};

struct decimal decimal_one = {0, 0, 1, 0, 1};

/*** Assumes RADIX is even ***/
struct decimal decimal_half = {0, 1, 0, 0, RADIX / 2};

decimal static decimal_add1 (), decimal_sub1 ();
static void add_scaled ();
static int subtract_scaled ();

/* Create and return a decimal number that has `before' digits before
   the decimal point and `after' digits after.  The digits themselves are
   initialized to zero.  */

decimal
make_decimal (before, after)
     int before, after;
{
  decimal result;
  if (before >= 1<<16)
    {
      decimal_error ("%d too many decimal digits", before);
      return 0;
    }
  if (after >= 1<<15)
    {
      decimal_error ("%d too many decimal digits", after);
      return 0;
    }
  result = (decimal) malloc (sizeof (struct decimal) + before + after - 1);
  result->sign = 0;
  result->before = before;
  result->after = after;
  result->refcnt = 0;
  bzero (result->contents, before + after);
  return result;
}

/* Create a copy of the decimal number `b' and return it.  */

decimal
decimal_copy (b)
     decimal b;
{
  decimal result = make_decimal (b->before, b->after);
  bcopy (b->contents, result->contents, LENGTH(b));
  result->sign = b->sign;
  return result;
}

/* Copy a decimal number `b' but extend or truncate to exactly
   `digits' fraction digits. */

static decimal
decimal_copy_1 (b, digits)
     decimal b;
     int digits;
{
  if (digits > b->after)
    {
      decimal result = make_decimal (b->before, digits);
      bcopy (b->contents, result->contents + (digits - (int) b->after), LENGTH(b));
      return result;
    }
  else
    return decimal_trunc_digits (b, digits);
}

/* flush specified number `digits' of trailing fraction digits,
   and flush any trailing fraction zero digits exposed after they are gone.
   The number `b' is actually modified; no new storage is allocated.
   That is why this is not global.  */

static void
flush_trailing_digits (b, digits)
     decimal b;
     int digits;
{
  int flush = digits;
  int maxdig = b->after;

  while (flush < maxdig && !b->contents [flush])
    flush++;

  if (flush)
    {
      int i;

      b->after -= flush;
      for (i = 0; i < LENGTH (b); i++)
	b->contents[i] = b->contents[flush + i];
    }

}

/* Return nonzero integer if the value of decimal number `b' is zero.  */

int
decimal_zerop (b)
     decimal b;
{
  return !LENGTH(b);
}

/* Compare two decimal numbers arithmetically.
   The value is < 0 if b1 < b2, > 0 if b1 > b2, 0 if b1 = b2.
   This is the same way that `strcmp' reports the result of comparing
   strings.  */

int
decimal_compare (b1, b2)
     decimal b1, b2;
{
  int l1, l2;
  char *p1, *p2, *s1, *s2;
  int i;

  /* If signs differ, deduce result from the signs */

  if (b2->sign && !b1->sign) return 1;
  if (b1->sign && !b2->sign) return -1;

  /* If same sign but number of nonfraction digits differs,
     the one with more of them is farther from zero.  */

  if (b1->before != b2->before)
    if (b1->sign)
      return (int) (b2->before - b1->before);
    else
      return (int) (b1->before - b2->before);

  /* Else compare the numbers digit by digit from high end */
  l1 = LENGTH(b1);
  l2 = LENGTH(b2);
  s1 = b1->contents;		/* Start of number -- don't back up digit pointer past here */
  s2 = b2->contents;
  p1 = b1->contents + l1;	/* Scanning pointer, for fetching digits.  */
  p2 = b2->contents + l2;
  for (i = MAX(l1, l2); i >= 0; i--)
    {
      int r = ((p1 != s1) ? *--p1 : 0) - ((p2 != s2) ? *--p2 : 0);
      if (r)
	return b1->sign ? -r : r;
    }
  return 0;
}

/* Return the number of digits stored in decimal number `b' */

int
decimal_length (b)
     decimal b;
{
  return LENGTH(b);
}

/* Return the number of fraction digits stored in decimal number `b'.  */

int
decimal_after (b)
     decimal b;
{
  return b->after;
}

/* Round decimal number `b' to have only `digits' fraction digits.
   Result is rounded to nearest unit in the last remaining digit.
   Return the result, another decimal number.  */

decimal
decimal_round_digits (b, digits)
     decimal b;
     int digits;
{
  decimal result;
  int old;

  if (b->after <= digits) return decimal_copy (b);

  if (digits < 0)
    {
      decimal_error ("request to keep negative number of digits %d", digits);
      return decimal_copy (b);
    }

  result = make_decimal (b->before + 1, b->after);
  result->sign = b->sign;
  bcopy (b->contents, result->contents, LENGTH(b));

  old = result->after;

  /* Add .5 * last place to keep, so that we round rather than truncate */
  /* Note this ignores sign of result, so if result is negative
     it is subtracting */

  add_scaled (result, DECIMAL_HALF, 1, old - digits - 1);

  /* Flush desired digits, and any trailing zeros exposed by them.  */

  flush_trailing_digits (result, old - digits);

  /* Flush leading digits -- always is one, unless was a carry into it */

  while (result->before > 0
	 && result->contents[LENGTH(result) - 1] == 0)
    result->before--;

  return result;
}

/* Truncate decimal number `b' to have only `digits' fraction digits.
   Any fraction digits in `b' beyond that are dropped and ignored.
   Truncation is toward zero.
   Return the result, another decimal number.  */

decimal
decimal_trunc_digits (b, digits)
     decimal b;
     int digits;
{
  decimal result = decimal_copy (b);
  int old = result->after;

  if (old <= digits) return result;

  if (digits < 0)
    {
      decimal_error ("request to keep negative number of digits %d", digits);
      return result;
    }

  flush_trailing_digits (result, old - digits);

  return result;
}

/* Return the fractional part of decimal number `b':
   that is, `b' - decimal_trunc_digits (`b') */

decimal
decimal_fraction (b)
     decimal b;
{
  decimal result = make_decimal (0, b->after);
  bcopy (b->contents, result->contents, b->after);
  return result;
}

/* return an integer whose value is that of decimal `b', sans its fraction.  */

int
decimal_to_int (b)
     decimal b;
{
  int result = 0;
  int i;
  int end = b->after;

  for (i = LENGTH(b) - 1; i >= end; i--)
    {
      result *= RADIX;
      result += b->contents[i];
    }
  return result;
}

/* return a decimal whose value is the integer i.  */

decimal
decimal_from_int (i)
     int i;
{
  int log, tem;
  decimal result;

  for (log = 0, tem = (i > 0 ? i : - i); tem; log++, tem /= RADIX);

  result = make_decimal (log, 0);

  for (log = 0, tem = (i > 0 ? i : - i); tem; log++, tem /= RADIX)
    result->contents[log] = tem % RADIX;

  if (i < 0) result->sign = 1;
  return result;
}

/* Return (as an integer) the result of dividing decimal number `b' by
   integer `divisor'.
   This is used in printing decimal numbers in other radices. */

int
decimal_int_rem (b, divisor)
     decimal b;
     int divisor;
{
  int len = LENGTH(b);
  int end = b->after;
  int accum = 0;
  int i;

  for (i = len - 1; i >= end; i--)
    {
      accum %= divisor;
      accum *= RADIX;
      accum += b->contents[i];
    }
  return accum % divisor;
}

/* Convert digit `digit' to a character and output it by calling
   `charout' with it as arg. */

static void
print_digit (digit, charout)
     int digit;
     void (*charout) ();
{
  if (digit < 10)
    charout ('0' + digit);
  else
    charout ('A' + digit - 10);
}

/* print decimal number `b' in radix `radix', assuming it is an integer.
   `r' is `radix' expressed as a decimal number. */

static
decimal_print_1 (b, r, radix, charout)
     decimal b, r;
     int radix;
     void (*charout) ();
{
  int digit = decimal_int_rem (b, radix);
  decimal rest = decimal_div (b, r, 0);

  if (!decimal_zerop (rest))
    decimal_print_1 (rest, r, radix, charout);

  print_digit (digit, charout);

  free (rest);
}

/* User entry: print decimal number `b' in radix `radix' (an integer),
   outputting characters by calling `charout'.  */

void
decimal_print (b, charout, radix)
     decimal b;
     void (*charout) ();
     int radix;
{
  if (b->sign) charout ('-');

  if (radix == RADIX)
    {
      /* decimal output => just print the digits, inserting a point in
	 the proper place.  */
      int i;
      int before = b->before;
      int len = before + b->after;
      for (i = 0; i < len; i++)
	{
	  if (i == before) charout ('.');
	  /* Broken if RADIX /= 10
	     charout ('0' + b->contents [len - 1 - i]); */
	  print_digit (b->contents [len - 1 - i], charout);
	}
      if (!len)
	charout ('0');
    }
  else
    {
      /* nonstandard radix: must use multiply and divide to determine the
	 digits of the number in that radix.  */

      int i;
      extern double log10 ();
      /* Compute the number of fraction digits we want to have in the
         new radix.  They should contain the same amount of
         information as the decimal digits we have.  */
      int nfrac = (b->after / log10 ((double) radix) + .99);
      decimal r = decimal_from_int (radix);
      decimal intpart = decimal_trunc_digits (b, 0);

      /* print integer part */
      decimal_print_1 (intpart, r, radix, charout);
      free (intpart);

      /* print fraction part */
      if (nfrac)
	{
          decimal tem1, tem2;
	  tem1 = decimal_fraction (b);
	  charout ('.');
	  /* repeatedly multiply by `radix', print integer part as one digit,
	     and flush the integer part.  */
	  for (i = 0; i < nfrac; i++)
	    {
	      tem2 = decimal_mul (tem1, r);
	      free (tem1);
	      print_digit (decimal_to_int (tem2), charout);
	      tem1 = decimal_fraction (tem2);
	      free (tem2);
	    }
	  free (tem1);
	}
      free (r);
    }
}

static int
decode_digit (digitchar)
     char digitchar;
{
  if ('0' <= digitchar && digitchar <= '9')
    return digitchar - '0';
  if ('a' <= digitchar && digitchar <= 'z')
    return digitchar - 'a' + 10;
  if ('A' <= digitchar && digitchar <= 'Z')
    return digitchar - 'A' + 10;
  return -1;
}

/* Parse string `s' into a number using radix `radix'
   and return result as a decimal number.  */

decimal
decimal_parse (s, radix)
     char *s;
     int radix;
{
  int i, len, before = -1;
  char *p;
  char c;
  decimal result;
  int negative = 0;
  int excess_digit = 0;

  if (*s == '-')
    {
      s++;
      negative = 1;
    }

  /* First scan for valid characters.
     Count total num digits, and count num before the decimal point.  */

  p = s;
  i = 0;
  while (c = *p++)
    {
      if (c == '.')
        {
	  if (before >= 0)
	    decimal_error ("two decimal points in %s", s);
          before = i;
	}
      else if (c == '0' && !i && before < 0)
	s++;   /* Discard leading zeros */
      else if (decode_digit (c) >= 0)
	{
	  i++;
	  if (decode_digit (c) > RADIX)
	    excess_digit = 1;
	}
      else
	decimal_error ("invalid number %s", s);
    }

  len = i;
  if (before < 0) before = i;

  p = s;

  /* Now parse those digits */

  if (radix != RADIX || excess_digit)
    {
      decimal r = decimal_from_int (radix);
      extern double log10 ();
      int digits = (len - before) * log10 ((double) radix) + .99;
      result = decimal_copy (DECIMAL_ZERO);

      /* Parse all the digits into an integer, ignoring decimal point,
	 by multiplying by `radix'.  */

      while (i > 0 && (c = *p++))
	{
	  if (c != '.')
	    {
	      decimal newdig = decimal_from_int (decode_digit (c));
	      decimal prod = decimal_mul (result, r);
	      decimal newresult = decimal_add (newdig, prod);

	      free (newdig);  free (prod);  free (result);
	      result = newresult;
	      i--;
	    }
	}

      /* Now put decimal point in right place
	 by dividing by `radix' once for each digit
	 that really should have followed the decimal point.  */

      for (i = before; i < len; i++)
	{
	  decimal newresult = decimal_div (result, r, digits);
	  free (result);
	  result = newresult;
	}
      free (r);
    }
  else
    {
      /* radix is standard - just copy the digits into a decimal number.  */

      int tem;
      result = make_decimal (before, len - before);

      while (i > 0 && (c = *p++))
	{
	  if ((c != '.') &&
	      ((tem = decode_digit (c)) >= 0))
	    result->contents [--i] = tem;
	}
    }

  if (negative) result->sign = 1;
  flush_trailing_digits (result, 0);
  return result;
}

/* Add b1 and b2, considering their signs */

decimal
decimal_add (b1, b2)
     decimal b1, b2;
{
  decimal v;

  if (b1->sign != b2->sign)
    v = decimal_sub1 (b1, b2);
  else
    v = decimal_add1 (b1, b2);
  if (b1->sign && !decimal_zerop (v))
    v->sign = !v->sign;
  return v;
}

/* Add b1 and minus b2, considering their signs */

decimal
decimal_sub (b1, b2)
     decimal b1, b2;
{
  decimal v;

  if (b1->sign != b2->sign)
    v = decimal_add1 (b1, b2);
  else
    v = decimal_sub1 (b1, b2);
  if (b1->sign && !decimal_zerop (v))
    v->sign = !v->sign;
  return v;
}

/* Return the negation of b2.  */

decimal
decimal_neg (b2)
     decimal b2;
{
  decimal v = decimal_copy (b2);

  if (!decimal_zerop (v))
    v->sign = !v->sign;
  return v;
}

/* add magnitudes of b1 and b2, ignoring their signs. */

static decimal
decimal_add1 (b1, b2)
     decimal b1, b2;
{
  int before = MAX (b1->before, b2->before);
  int after = MAX (b1->after, b2->after);

  int len = before+after+1;
  decimal result = make_decimal (before+1, after);

  int i;
  char *s1 = b1->contents;
  char *s2 = b2->contents;
  char *p1 = s1 + b1->after - after;
  char *p2 = s2 + b2->after - after;
  char *e1 = s1 + b1->before + b1->after;
  char *e2 = s2 + b2->before + b2->after;
  char *pr = result->contents;
  int accum = 0;

  for (i = 0; i < len; i++, p1++, p2++)
    {
      accum /= RADIX;
      if (p1 >= s1 && p1 < e1) accum += *p1;
      if (p2 >= s2 && p2 < e2) accum += *p2;
      *pr++ = accum % RADIX;
    }
  if (!accum)
    (result->before)--;

  flush_trailing_digits (result, 0);

  return result;
}

/* subtract magnitude of b2 from that or b1, returning signed decimal
   number. */

static decimal
decimal_sub1 (b1, b2)
     decimal b1, b2;
{
  int before = MAX (b1->before, b2->before);
  int after = MAX (b1->after, b2->after);

  int len = before+after;
  decimal result = make_decimal (before, after);

  int i;
  char *s1 = b1->contents;
  char *s2 = b2->contents;
  char *p1 = s1 + b1->after - after;
  char *p2 = s2 + b2->after - after;
  char *e1 = s1 + b1->before + b1->after;
  char *e2 = s2 + b2->before + b2->after;
  char *pr = result->contents;
  int accum = 0;

  for (i = 0; i < len; i++, p1++, p2++)
    {
      if (p1 >= s1 && p1 < e1) accum += *p1;
      if (p2 >= s2 && p2 < e2) accum -= *p2;
      if (accum < 0 && accum % RADIX)
        *pr = RADIX - (- accum) % RADIX;
      else
	*pr = accum % RADIX;
      accum -= *pr++;
      accum /= RADIX;
    }

  /* If result is negative, subtract it from RADIX**length
     so that we get the right digits for sign-magnitude
     rather than RADIX-complement */

  if (accum)
    {
      result->sign = 1;
      pr = result->contents;
      accum = 0;
      for (i = 0; i < len; i++)
	{
	  accum -= *pr;
	  if (accum)
	    *pr = accum + RADIX;
	  else
	    *pr = 0;
	  accum -= *pr++;
	  accum /= RADIX;
	}
    }

  /* flush leading nonfraction zero digits */

  while (result->before && *--pr == 0)
    (result->before)--;

  flush_trailing_digits (result, 0);

  return result;
}

/* multiply b1 and b2 keeping `digits' fraction digits */

decimal
decimal_mul_rounded (b1, b2, digits)
     decimal b1, b2;
     int digits;
{
  decimal tem = decimal_mul (b1, b2);
  decimal result = decimal_round_digits (tem, digits);
  free (tem);
  return result;
}

/* multiply b1 and b2 keeping the right number of fraction digits
   for the `dc' program with precision = `digits'.  */

decimal
decimal_mul_dc (b1, b2, digits)
     decimal b1, b2;
     int digits;
{
  decimal tem = decimal_mul (b1, b2);
  decimal result
    = decimal_round_digits (tem, MAX (digits, MAX (b1->after, b2->after)));
  free (tem);
  return result;
}

/* multiply b1 and b2 as decimal error-free values;
   keep LENGTH(b1) plus LENGTH(b2) significant figures. */

decimal
decimal_mul (b1, b2)
     decimal b1, b2;
{
  decimal result = make_decimal (b1->before + b2->before, b1->after + b2->after);
  int i;
  int length2 = LENGTH(b2);
  char *pr;

  for (i = 0; i < length2; i++)
    add_scaled (result, b1, b2->contents[i], i);

  /* flush leading nonfraction zero digits */

  pr = result->contents + LENGTH(result);
  while (result->before && *--pr == 0)
    (result->before)--;

  flush_trailing_digits (result, 0);   /* flush trailing zeros */

  /* Set sign properly */

  if (b1->sign != b2->sign && LENGTH(result))
    result->sign = 1;

  return result;
}

/* Modify decimal number `into' by adding `from',
   multiplied by `factor' (which should be nonnegative and less than RADIX)
   and shifted left `scale' digits at the least significant end. */

static void
add_scaled (into, from, factor, scale)
     decimal into, from;
     int factor, scale;
{
  char *pf = from->contents;
  char *pi = into->contents + scale;
  int lengthf = LENGTH(from);
  int lengthi = LENGTH(into) - scale;

  int accum = 0;
  int i;

  for (i = 0; i < lengthi; i++)
    {
      accum /= RADIX;
      if (i < lengthf)
        accum += *pf++ * factor;
      accum += *pi;
      *pi++ = accum % RADIX;
    }
}

/* Divide decimal number `b1' by `b2', keeping at most `digits'
   fraction digits.
   Returns the result as a decimal number.

   When division is not exact, the quotient is truncated toward zero.  */

decimal
decimal_div (b1, b2, digits)
     decimal b1, b2;
     int digits;
{
  decimal result = make_decimal (MAX(1, (int) (1 + b1->before - b2->before)), digits);

  /* b1copy holds what is left of the dividend,
     that is not accounted for by the quotient digits already known */

  decimal b1copy = decimal_copy_1 (b1, b2->after + digits);
  int length1 = LENGTH(b1copy);
  int length2 = LENGTH(b2);
  int lengthr = LENGTH(result);
  int i;

  /* leading_divisor_digits contains the first two divisor digits, as
     an integer */

  int leading_divisor_digits = b2->contents[length2-1]*RADIX;
  if (length2 > 1)
    leading_divisor_digits += b2->contents[length2-2];

  if (decimal_zerop (b2))
    {
      decimal_error ("divisor is zero", 0);
      return decimal_copy (DECIMAL_ZERO);
    }

/*   if (lengthr <= (length1 - length2))
    abort(); */		 /* My reasoning says this cannot happen, I hope */

  for (i = length1 - length2; i >= 0; i--)
    {
      /* Guess the next quotient digit (in order of decreasing significance)
	 using integer division */

      int guess;
      int trial_dividend = b1copy->contents[length2+i-1]*RADIX;
      if (i != length1 - length2)
	trial_dividend += b1copy->contents[length2+i]*RADIX*RADIX;
      if (length2 + i > 1)
	trial_dividend += b1copy->contents[length2+i-2];

      guess = trial_dividend / leading_divisor_digits;

      /* Remove the quotient times this digit from the dividend left */
      /* We may find that the quotient digit is too large,
	 when we consider the entire divisor.
	 Then we decrement the quotient digit and add the divisor back in */

      if (guess && 0 > subtract_scaled (b1copy, b2, guess, i))
	{
	  guess--;
	  add_scaled (b1copy, b2, 1, i);
	}

      if (guess >= RADIX)
	{
	  result->contents[i + 1] += guess / RADIX;
	  guess %= RADIX;
	}
      result->contents[i] = guess;
    }

  free (b1copy);

  result->sign = (b1->sign != b2->sign);

  /* flush leading nonfraction zero digits */

  {
    char *pr = result->contents + lengthr;
    while (result->before && *--pr == 0)
      (result->before)--;
  }

  flush_trailing_digits (result, 0);	/* Flush trailing zero fraction digits */

  return result;
}

/* The remainder for the above division.
   Same as `b1' - (`b1' / `b2') * 'b2'.
   Note that the value depends on the number of fraction digits
   that were kept in computing `b1' / `b2';
   the argument `digits' specifies this.

   The remainder has the same sign as the dividend.
   The divisor's sign is ignored.  */

decimal
decimal_rem (b1, b2, digits)
     decimal b1, b2;
     int digits;
{
  decimal b1copy = decimal_copy_1 (b1, b2->after + digits);
  int length1 = LENGTH(b1copy);
  int length2 = LENGTH(b2);
  int i;

  int leading_divisor_digits = b2->contents[length2-1]*RADIX;

  if (length2 > 1)
    leading_divisor_digits += b2->contents[length2-2];

  if (decimal_zerop (b2))
    {
      decimal_error ("divisor is zero", 0);
      return decimal_copy (DECIMAL_ZERO);
    }

  /* Do like division, above, but throw away the quotient.
     Keep only the final `rest of dividend', which becomes the remainder.  */

  for (i = length1 - length2; i >= 0; i--)
    {
      int guess;
      int trial_dividend = b1copy->contents[length2+i-1]*RADIX;
      if (i != length1 - length2)
	trial_dividend += b1copy->contents[length2+i]*RADIX*RADIX;
      if (length2 + i > 1)
	trial_dividend += b1copy->contents[length2+i-2];

      guess = trial_dividend / leading_divisor_digits;

      if (guess && 0 > subtract_scaled (b1copy, b2, guess, i))
	{
	  guess--;
	  add_scaled (b1copy, b2, 1, i);
	}
      /* No need to check whether guess exceeds RADIX
	 since we are not saving guess.  */
    }

  /* flush leading nonfraction zero digits */

  {
    char *pr = b1copy->contents + length1;
    while (b1copy->before && *--pr == 0)
      (b1copy->before)--;
  }

  flush_trailing_digits (b1copy, 0);
  return b1copy;
}

/* returns negative number if we chose factor too large */

static int
subtract_scaled (into, from, factor, scale)
     decimal into, from;
     int factor, scale;
{
  char *pf = from->contents;
  char *pi = into->contents + scale;
  int lengthf = LENGTH(from);
  int lengthi = LENGTH(into) - scale;
  int accum = 0;
  int i;

  for (i = 0; i < lengthi && i <= lengthf; i++)
    {
      if (i < lengthf)
        accum -= *pf++ * factor;
      accum += *pi;
      if (accum < 0 && accum % RADIX)
        *pi = RADIX - (- accum) % RADIX;
      else
	*pi = accum % RADIX;
      accum -= *pi++;
      accum /= RADIX;
    }
  return accum;
}

/* Return the square root of decimal number D, using Newton's method.
   Number of fraction digits returned is max of FRAC_DIGITS
   and D's number of fraction digits.  */

decimal
decimal_sqrt (d, frac_digits)
     decimal d;
     int frac_digits;
{
  decimal guess;
  int notdone = 1;

  if (decimal_zerop (d)) return d;
  if (d->sign)
    {
      decimal_error ("square root argument negative", 0);
      return decimal_copy (DECIMAL_ZERO);
    }

  frac_digits = MAX (frac_digits, d->after);

  /* Compute an initial guess by taking the square root
     of a nearby power of RADIX.  */

  if (d->before)
    {
      guess = make_decimal ((d->before + 1) / 2, 0);
      guess->contents[guess->before - 1] = 1;
    }
  else
    {
      /* Arg is less than 1; compute nearest power of RADIX */
      char *p = d->contents + LENGTH(d);
      char *sp = p;

      while (!*--p);	/* Find most significant nonzero digit */
      if (sp - p == 1)
	{
	  /* Arg is bigger than 1/RADIX; use 1 as a guess */
	  guess = decimal_copy (DECIMAL_ONE);
	}
      else
	{
	  guess = make_decimal (0, (sp - p) / 2);
	  guess->contents[0] = 1;
	}
    }

  /* Iterate doing guess = (guess + d/guess) / 2  */

  while (notdone)
    {
      decimal tem1 = decimal_div (d, guess, frac_digits + 1);
      decimal tem2 = decimal_add (guess, tem1);
      decimal tem3 = decimal_mul_rounded (tem2, DECIMAL_HALF, frac_digits);
      notdone = decimal_compare (guess, tem3);
      free (tem1);
      free (tem2);
      free (guess);
      guess = tem3;
      if (decimal_zerop (guess)) return guess;  /* Avoid divide-by-zero */
    }

  return guess;
}

/* Raise decimal number `base' to power of integer part of decimal
   number `expt'.
   This function depends on using radix 10.
   It is too hard to write it to work for any value of RADIX,
   so instead it is simply not available if RADIX is not ten.  */

#if !(RADIX - 10)

decimal
decimal_expt (base, expt, frac_digits)
     decimal base, expt;
     int frac_digits;
{
  decimal accum = decimal_copy (DECIMAL_ONE);
  decimal basis1 = base;
  int digits = expt->before;
  int dig = 0;				/* Expt digit being processed */

  if (expt->sign)
  /* If negative power, take reciprocal first thing
     so that fraction digit truncation won't destroy
     what will ultimately be nonfraction digits.  */
    basis1 = decimal_div (DECIMAL_ONE, base, frac_digits);
  while (dig < digits)
    {
      decimal basis2, basis4, basis8, basis10;
      int thisdigit = expt->contents[expt->after + dig];

      /* Compute factors to multiply in for each bit of this digit */

      basis2 = decimal_mul_rounded (basis1, basis1, frac_digits);
      basis4 = decimal_mul_rounded (basis2, basis2, frac_digits);
      basis8 = decimal_mul_rounded (basis4, basis4, frac_digits);

      /* Now accumulate the factors this digit value selects */

      if (thisdigit & 1)
	{
	  decimal accum1 = decimal_mul_rounded (accum, basis1, frac_digits);
	  free (accum);
	  accum = accum1;
	}

      if (thisdigit & 2)
	{
	  decimal accum1 = decimal_mul_rounded (accum, basis2, frac_digits);
	  free (accum);
	  accum = accum1;
	}

      if (thisdigit & 4)
	{
	  decimal accum1 = decimal_mul_rounded (accum, basis4, frac_digits);
	  free (accum);
	  accum = accum1;
	}

      if (thisdigit & 8)
	{
	  decimal accum1 = decimal_mul_rounded (accum, basis8, frac_digits);
	  free (accum);
	  accum = accum1;
	}

      /* If there are further digits, compute the basis1 for the next digit */

      if (++dig < digits)
	basis10 = decimal_mul_rounded (basis2, basis8, frac_digits);

      /* Free intermediate results */

      if (basis1 != base) free (basis1);
      free (basis2);
      free (basis4);
      free (basis8);
      basis1 = basis10;
    }
  return accum;
}
#endif

#ifdef TEST

fputchar (c)
     char c;
{
  putchar (c);
}

/* Top level that can be used to test the arithmetic functions */

main ()
{
  char s1[40], s2[40];
  decimal b1, b2, b3;
  char c;

  while (1)
    {
      scanf ("%s %c %s", s1, &c, s2);
      b1 = decimal_parse (s1, RADIX);
      b2 = decimal_parse (s2, RADIX);
      switch (c)
	{
	default:
	  c = '+';
	case '+':
	  b3 = decimal_add (b1, b2);
	  break;
	case '*':
	  b3 = decimal_mul (b1, b2);
	  break;
        case '/':
	  b3 = decimal_div (b1, b2, 3);
	  break;
	case '%':
	  b3 = decimal_rem (b1, b2, 3);
	  break;
        case 'p':
	  decimal_print (b1, fputchar, RADIX);
	  printf (" printed in base %d is ", decimal_to_int (b2));
	  decimal_print (b1, fputchar, decimal_to_int (b2));
	  printf ("\n");
	  continue;
	case 'r':
	  printf ("%s read in base %d is ", s1, decimal_to_int (b2));
	  decimal_print (decimal_parse (s1, decimal_to_int (b2)), fputchar, RADIX);
	  printf ("\n");
	  continue;
	}
      decimal_print (b1, fputchar, RADIX);
      printf (" %c ", c);
      decimal_print (b2, fputchar, RADIX);
      printf (" = ");
      decimal_print (b3, fputchar, RADIX);
      printf ("\n");
    }
}

decimal_error (s1, s2)
     char *s1, *s2;
{
  printf ("\n");
  printf (s1, s2);
  printf ("\n");
}

static void
pbi (b)
      int b;
{
  decimal_print ((decimal) b, fputchar, RADIX);
}

static void
pb (b)
      decimal b;
{
  decimal_print (b, fputchar, RADIX);
}

#endif
