Moved files around

4 files changed, 2955 insertions, 0 deletions

diff --git a/src/numerics/amount.cc b/src/numerics/amount.cc
new file mode 100644
index 00000000..4c771cc7
--- /dev/null
+++ b/src/numerics/amount.cc
@@ -0,0 +1,1395 @@
+/*
+ * Copyright (c) 2003-2007, John Wiegley.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of New Artisans LLC nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file   amount.cc
+ * @author John Wiegley
+ * @date   Thu Apr 26 15:19:46 2007
+ * 
+ * @brief  Types for handling commoditized math.
+ * 
+ * This file defines member functions for amount_t, and also defines a
+ * helper class, bigint_t, which is used as a refcounted wrapper
+ * around libgmp's mpz_t type.
+ */
+
+#include "amount.h"
+#include "binary.h"
+
+namespace ledger {
+
+commodity_pool_t * amount_t::current_pool = NULL;
+
+bool amount_t::keep_base = false;
+
+bool amount_t::keep_price = false;
+bool amount_t::keep_date  = false;
+bool amount_t::keep_tag	  = false;
+
+bool amount_t::stream_fullstrings = false;
+
+#ifndef THREADSAFE
+/**
+ * These global temporaries are pre-initialized for the sake of
+ * efficiency, and reused over and over again.
+ */
+static mpz_t temp;
+static mpz_t divisor;
+#endif
+
+struct amount_t::bigint_t : public supports_flags<>
+{
+#define BIGINT_BULK_ALLOC 0x01
+#define BIGINT_KEEP_PREC  0x02
+
+  mpz_t		 val;
+  precision_t	 prec;
+  uint_least16_t ref;
+  uint_fast32_t	 index;
+
+#define MPZ(bigint) ((bigint)->val)
+
+  bigint_t() : prec(0), ref(1), index(0) {
+    TRACE_CTOR(bigint_t, "");
+    mpz_init(val);
+  }
+  bigint_t(mpz_t _val) : prec(0), ref(1), index(0) {
+    TRACE_CTOR(bigint_t, "mpz_t");
+    mpz_init_set(val, _val);
+  }
+  bigint_t(const bigint_t& other)
+    : supports_flags<>(other.flags() & BIGINT_KEEP_PREC),
+      prec(other.prec), ref(1), index(0) {
+    TRACE_CTOR(bigint_t, "copy");
+    mpz_init_set(val, other.val);
+  }
+  ~bigint_t() {
+    TRACE_DTOR(bigint_t);
+    assert(ref == 0);
+    mpz_clear(val);
+  }
+};
+
+void amount_t::initialize()
+{
+  mpz_init(temp);
+  mpz_init(divisor);
+
+  // jww (2007-05-02): Be very careful here!
+  if (! current_pool)
+    current_pool = new commodity_pool_t;
+
+  // Add time commodity conversions, so that timelog's may be parsed
+  // in terms of seconds, but reported as minutes or hours.
+  if (commodity_t * commodity = current_pool->create("s")) {
+    commodity->add_flags(COMMODITY_STYLE_NOMARKET | COMMODITY_STYLE_BUILTIN);
+
+    parse_conversion("1.0m", "60s");
+    parse_conversion("1.0h", "60m");
+  } else {
+    assert(false);
+  }
+}
+
+void amount_t::shutdown()
+{
+  mpz_clear(temp);
+  mpz_clear(divisor);
+
+  // jww (2007-05-02): Be very careful here!
+  if (current_pool) {
+    checked_delete(current_pool);
+    current_pool = NULL;
+  }
+}
+
+void amount_t::_copy(const amount_t& amt)
+{
+  if (quantity != amt.quantity) {
+    if (quantity)
+      _release();
+
+    // Never maintain a pointer into a bulk allocation pool; such
+    // pointers are not guaranteed to remain.
+    if (amt.quantity->has_flags(BIGINT_BULK_ALLOC)) {
+      quantity = new bigint_t(*amt.quantity);
+    } else {
+      quantity = amt.quantity;
+      DEBUG("amounts.refs",
+	     quantity << " ref++, now " << (quantity->ref + 1));
+      quantity->ref++;
+    }
+  }
+  commodity_ = amt.commodity_;
+}
+
+void amount_t::_dup()
+{
+  if (quantity->ref > 1) {
+    bigint_t * q = new bigint_t(*quantity);
+    _release();
+    quantity = q;
+  }
+}
+
+void amount_t::_resize(precision_t prec)
+{
+  assert(prec < 256);
+
+  if (! quantity || prec == quantity->prec)
+    return;
+
+  _dup();
+
+  assert(prec > quantity->prec);
+  mpz_ui_pow_ui(divisor, 10, prec - quantity->prec);
+  mpz_mul(MPZ(quantity), MPZ(quantity), divisor);
+
+  quantity->prec = prec;
+}
+
+void amount_t::_clear()
+{
+  if (quantity) {
+    _release();
+    quantity   = NULL;
+    commodity_ = NULL;
+  } else {
+    assert(! commodity_);
+  }
+}
+
+void amount_t::_release()
+{
+  DEBUG("amounts.refs", quantity << " ref--, now " << (quantity->ref - 1));
+
+  if (--quantity->ref == 0) {
+    if (quantity->has_flags(BIGINT_BULK_ALLOC))
+      quantity->~bigint_t();
+    else
+      checked_delete(quantity);
+  }
+}
+
+
+namespace {
+  amount_t::precision_t convert_double(mpz_t dest, double val)
+  {
+#ifndef HAVE_GDTOA
+    // This code is far too imprecise to be worthwhile.
+
+    mpf_t temp;
+    mpf_init_set_d(temp, val);
+
+    mp_exp_t exp;
+    char * buf = mpf_get_str(NULL, &exp, 10, 1000, temp);
+
+    int len = std::strlen(buf);
+    if (len > 0 && buf[0] == '-')
+      exp++;
+
+    if (exp <= len) {
+      exp = len - exp;
+    } else {
+      // There were trailing zeros, which we have to put back on in
+      // order to convert this buffer into an integer.
+
+      int zeroes = exp - len;
+
+      char * newbuf = (char *)std::malloc(len + zeroes);
+      std::strcpy(newbuf, buf);
+
+      int i;
+      for (i = 0; i < zeroes; i++)
+	newbuf[len + i] = '0';
+      newbuf[len + i] = '\0';
+
+      free(buf);
+      buf = newbuf;
+
+      exp = (len - exp) + zeroes;
+    }
+
+    mpz_set_str(dest, buf, 10);
+    free(buf);
+
+    return amount_t::precision_t(exp);
+#else
+    int	   decpt, sign;
+    char * buf = dtoa(val, 0, 0, &decpt, &sign, NULL);
+    char * result;
+    int	   len = std::strlen(buf);
+
+    if (decpt <= len) {
+      decpt  = len - decpt;
+      result = NULL;
+    } else {
+      // There were trailing zeros, which we have to put back on in
+      // order to convert this buffer into an integer.
+
+      int zeroes = decpt - len;
+      result = new char[len + zeroes + 1];
+
+      std::strcpy(result, buf);
+      int i;
+      for (i = 0; i < zeroes; i++)
+	result[len + i] = '0';
+      result[len + i] = '\0';
+
+      decpt = (len - decpt) + zeroes;
+    }
+
+    if (sign) {
+      char * newbuf = new char[std::strlen(result ? result : buf) + 2];
+      newbuf[0] = '-';
+      std::strcpy(&newbuf[1], result ? result : buf);
+      mpz_set_str(dest, newbuf, 10);
+      checked_array_delete(newbuf);
+    } else {
+      mpz_set_str(dest, result ? result : buf, 10);
+    }
+
+    if (result)
+      checked_array_delete(result);
+    freedtoa(buf);
+
+    return decpt;
+#endif
+  }
+}
+
+amount_t::amount_t(const double val) : commodity_(NULL)
+{
+  TRACE_CTOR(amount_t, "const double");
+  quantity = new bigint_t;
+  quantity->prec = convert_double(MPZ(quantity), val);
+}
+
+amount_t::amount_t(const unsigned long val) : commodity_(NULL)
+{
+  TRACE_CTOR(amount_t, "const unsigned long");
+  quantity = new bigint_t;
+  mpz_set_ui(MPZ(quantity), val);
+}
+
+amount_t::amount_t(const long val) : commodity_(NULL)
+{
+  TRACE_CTOR(amount_t, "const long");
+  quantity = new bigint_t;
+  mpz_set_si(MPZ(quantity), val);
+}
+
+
+amount_t& amount_t::operator=(const amount_t& amt)
+{
+  if (this != &amt) {
+    if (amt.quantity)
+      _copy(amt);
+    else if (quantity)
+      _clear();
+  }
+  return *this;
+}
+
+
+int amount_t::compare(const amount_t& amt) const
+{
+  if (! quantity || ! amt.quantity) {
+    if (quantity)
+      throw_(amount_error, "Cannot compare an amount to an uninitialized amount");
+    else if (amt.quantity)
+      throw_(amount_error, "Cannot compare an uninitialized amount to an amount");
+    else
+      throw_(amount_error, "Cannot compare two uninitialized amounts");
+  }
+  
+  if (has_commodity() && amt.has_commodity() &&
+      commodity() != amt.commodity())
+    throw_(amount_error,
+	   "Cannot compare amounts with different commodities: " <<
+	   commodity().symbol() << " and " << amt.commodity().symbol());
+
+  if (quantity->prec == amt.quantity->prec) {
+    return mpz_cmp(MPZ(quantity), MPZ(amt.quantity));
+  }
+  else if (quantity->prec < amt.quantity->prec) {
+    amount_t t(*this);
+    t._resize(amt.quantity->prec);
+    return mpz_cmp(MPZ(t.quantity), MPZ(amt.quantity));
+  }
+  else {
+    amount_t t = amt;
+    t._resize(quantity->prec);
+    return mpz_cmp(MPZ(quantity), MPZ(t.quantity));
+  }
+}
+
+
+amount_t& amount_t::operator+=(const amount_t& amt)
+{
+  if (! quantity || ! amt.quantity) {
+    if (quantity)
+      throw_(amount_error, "Cannot add an amount to an uninitialized amount");
+    else if (amt.quantity)
+      throw_(amount_error, "Cannot add an uninitialized amount to an amount");
+    else
+      throw_(amount_error, "Cannot add two uninitialized amounts");
+  }
+  
+  if (commodity() != amt.commodity())
+    throw_(amount_error,
+	   "Adding amounts with different commodities: " <<
+	   (has_commodity() ? commodity().symbol() : "NONE") <<
+	   " != " <<
+	   (amt.has_commodity() ? amt.commodity().symbol() : "NONE"));
+
+  _dup();
+
+  if (quantity->prec == amt.quantity->prec) {
+    mpz_add(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
+  }
+  else if (quantity->prec < amt.quantity->prec) {
+    _resize(amt.quantity->prec);
+    mpz_add(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
+  }
+  else {
+    amount_t t = amt;
+    t._resize(quantity->prec);
+    mpz_add(MPZ(quantity), MPZ(quantity), MPZ(t.quantity));
+  }
+
+  return *this;
+}
+
+amount_t& amount_t::operator-=(const amount_t& amt)
+{
+  if (! quantity || ! amt.quantity) {
+    if (quantity)
+      throw_(amount_error, "Cannot subtract an amount from an uninitialized amount");
+    else if (amt.quantity)
+      throw_(amount_error, "Cannot subtract an uninitialized amount from an amount");
+    else
+      throw_(amount_error, "Cannot subtract two uninitialized amounts");
+  }
+  
+  if (commodity() != amt.commodity())
+    throw_(amount_error,
+	   "Subtracting amounts with different commodities: " <<
+	   (has_commodity() ? commodity().symbol() : "NONE") <<
+	   " != " <<
+	   (amt.has_commodity() ? amt.commodity().symbol() : "NONE"));
+
+  _dup();
+
+  if (quantity->prec == amt.quantity->prec) {
+    mpz_sub(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
+  }
+  else if (quantity->prec < amt.quantity->prec) {
+    _resize(amt.quantity->prec);
+    mpz_sub(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
+  }
+  else {
+    amount_t t = amt;
+    t._resize(quantity->prec);
+    mpz_sub(MPZ(quantity), MPZ(quantity), MPZ(t.quantity));
+  }
+
+  return *this;
+}
+
+namespace {
+  void mpz_round(mpz_t out, mpz_t value, int value_prec, int round_prec)
+  {
+    // Round `value', with an encoding precision of `value_prec', to a
+    // rounded value with precision `round_prec'.  Result is stored in
+    // `out'.
+
+    assert(value_prec > round_prec);
+
+    mpz_t quotient;
+    mpz_t remainder;
+
+    mpz_init(quotient);
+    mpz_init(remainder);
+
+    mpz_ui_pow_ui(divisor, 10, value_prec - round_prec);
+    mpz_tdiv_qr(quotient, remainder, value, divisor);
+    mpz_divexact_ui(divisor, divisor, 10);
+    mpz_mul_ui(divisor, divisor, 5);
+
+    if (mpz_sgn(remainder) < 0) {
+      mpz_neg(divisor, divisor);
+      if (mpz_cmp(remainder, divisor) < 0) {
+	mpz_ui_pow_ui(divisor, 10, value_prec - round_prec);
+	mpz_add(remainder, divisor, remainder);
+	mpz_ui_sub(remainder, 0, remainder);
+	mpz_add(out, value, remainder);
+      } else {
+	mpz_sub(out, value, remainder);
+      }
+    } else {
+      if (mpz_cmp(remainder, divisor) >= 0) {
+	mpz_ui_pow_ui(divisor, 10, value_prec - round_prec);
+	mpz_sub(remainder, divisor, remainder);
+	mpz_add(out, value, remainder);
+      } else {
+	mpz_sub(out, value, remainder);
+      }
+    }
+    mpz_clear(quotient);
+    mpz_clear(remainder);
+
+    // chop off the rounded bits
+    mpz_ui_pow_ui(divisor, 10, value_prec - round_prec);
+    mpz_tdiv_q(out, out, divisor);
+  }
+}
+
+amount_t& amount_t::operator*=(const amount_t& amt)
+{
+  if (! quantity || ! amt.quantity) {
+    if (quantity)
+      throw_(amount_error, "Cannot multiply an amount by an uninitialized amount");
+    else if (amt.quantity)
+      throw_(amount_error, "Cannot multiply an uninitialized amount by an amount");
+    else
+      throw_(amount_error, "Cannot multiply two uninitialized amounts");
+  }
+  
+  if (has_commodity() && amt.has_commodity() &&
+      commodity() != amt.commodity())
+    throw_(amount_error,
+	   "Multiplying amounts with different commodities: " <<
+	   (has_commodity() ? commodity().symbol() : "NONE") <<
+	   " != " <<
+	   (amt.has_commodity() ? amt.commodity().symbol() : "NONE"));
+
+  _dup();
+
+  mpz_mul(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
+  quantity->prec += amt.quantity->prec;
+
+  if (! has_commodity())
+    commodity_ = amt.commodity_;
+
+  if (has_commodity() && ! (quantity->has_flags(BIGINT_KEEP_PREC))) {
+    precision_t comm_prec = commodity().precision();
+    if (quantity->prec > comm_prec + 6U) {
+      mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, comm_prec + 6U);
+      quantity->prec = comm_prec + 6U;
+    }
+  }
+
+  return *this;
+}
+
+amount_t& amount_t::operator/=(const amount_t& amt)
+{
+  if (! quantity || ! amt.quantity) {
+    if (quantity)
+      throw_(amount_error, "Cannot divide an amount by an uninitialized amount");
+    else if (amt.quantity)
+      throw_(amount_error, "Cannot divide an uninitialized amount by an amount");
+    else
+      throw_(amount_error, "Cannot divide two uninitialized amounts");
+  }
+  
+  if (has_commodity() && amt.has_commodity() &&
+      commodity() != amt.commodity())
+    throw_(amount_error,
+	   "Dividing amounts with different commodities: " <<
+	   (has_commodity() ? commodity().symbol() : "NONE") <<
+	   " != " <<
+	   (amt.has_commodity() ? amt.commodity().symbol() : "NONE"));
+
+  if (! amt)
+    throw_(amount_error, "Divide by zero");
+
+  _dup();
+
+  // Increase the value's precision, to capture fractional parts after
+  // the divide.  Round up in the last position.
+
+  mpz_ui_pow_ui(divisor, 10, (2 * amt.quantity->prec) + quantity->prec + 7U);
+  mpz_mul(MPZ(quantity), MPZ(quantity), divisor);
+  mpz_tdiv_q(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
+  quantity->prec += amt.quantity->prec + quantity->prec + 7U;
+
+  mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, quantity->prec - 1);
+  quantity->prec -= 1;
+
+  if (! has_commodity())
+    commodity_ = amt.commodity_;
+
+  // If this amount has a commodity, and we're not dealing with plain
+  // numbers, or internal numbers (which keep full precision at all
+  // times), then round the number to within the commodity's precision
+  // plus six places.
+
+  if (has_commodity() && ! (quantity->has_flags(BIGINT_KEEP_PREC))) {
+    precision_t comm_prec = commodity().precision();
+    if (quantity->prec > comm_prec + 6U) {
+      mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, comm_prec + 6U);
+      quantity->prec = comm_prec + 6U;
+    }
+  }
+
+  return *this;
+}
+
+
+amount_t::precision_t amount_t::precision() const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot determine precision of an uninitialized amount");
+
+  return quantity->prec;
+}
+
+amount_t& amount_t::in_place_negate()
+{
+  if (quantity) {
+    _dup();
+    mpz_neg(MPZ(quantity), MPZ(quantity));
+  } else {
+    throw_(amount_error, "Cannot negate an uninitialized amount");
+  }
+  return *this;
+}
+
+amount_t amount_t::round(const optional<precision_t>& prec) const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot round an uninitialized amount");
+
+  if (! prec) {
+    if (! has_commodity())
+      return *this;
+    return round(commodity().precision());
+  } else {
+    amount_t t(*this);
+
+    if (quantity->prec <= *prec) {
+      if (quantity && quantity->has_flags(BIGINT_KEEP_PREC)) {
+	t._dup();
+	t.quantity->drop_flags(BIGINT_KEEP_PREC);
+      }
+      return t;
+    }
+
+    t._dup();
+
+    mpz_round(MPZ(t.quantity), MPZ(t.quantity), t.quantity->prec, *prec);
+
+    t.quantity->prec = *prec;
+    t.quantity->drop_flags(BIGINT_KEEP_PREC);
+
+    return t;
+  }
+}
+
+amount_t amount_t::unround() const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot unround an uninitialized amount");
+  else if (quantity->has_flags(BIGINT_KEEP_PREC))
+    return *this;
+
+  amount_t t(*this);
+  t._dup();
+  t.quantity->add_flags(BIGINT_KEEP_PREC);
+
+  return t;
+}
+
+amount_t& amount_t::in_place_reduce()
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot reduce an uninitialized amount");
+
+  while (commodity_ && commodity().smaller()) {
+    *this *= commodity().smaller()->number();
+    commodity_ = commodity().smaller()->commodity_;
+  }
+  return *this;
+}
+
+amount_t& amount_t::in_place_unreduce()
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot unreduce an uninitialized amount");
+
+  while (commodity_ && commodity().larger()) {
+    *this /= commodity().larger()->number();
+    commodity_ = commodity().larger()->commodity_;
+    if (abs() < amount_t(1.0))
+      break;
+  }
+  return *this;
+}
+
+optional<amount_t> amount_t::value(const optional<moment_t>& moment) const
+{
+  if (quantity) {
+    optional<amount_t> amt(commodity().value(moment));
+    if (amt)
+      return (*amt * number()).round();
+  } else {
+    throw_(amount_error, "Cannot determine value of an uninitialized amount");
+  }
+  return none;
+}
+
+
+int amount_t::sign() const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot determine sign of an uninitialized amount");
+
+  return mpz_sgn(MPZ(quantity));
+}
+
+bool amount_t::is_zero() const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot determine sign if an uninitialized amount is zero");
+
+  if (has_commodity()) {
+    if (quantity->prec <= commodity().precision())
+      return is_realzero();
+    else
+      return round(commodity().precision()).sign() == 0;
+  }
+  return is_realzero();
+}
+
+
+double amount_t::to_double(bool no_check) const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot convert an uninitialized amount to a double");
+
+  mpz_t remainder;
+  mpz_init(remainder);
+
+  mpz_set(temp, MPZ(quantity));
+  mpz_ui_pow_ui(divisor, 10, quantity->prec);
+  mpz_tdiv_qr(temp, remainder, temp, divisor);
+
+  char * quotient_s  = mpz_get_str(NULL, 10, temp);
+  char * remainder_s = mpz_get_str(NULL, 10, remainder);
+
+  std::ostringstream num;
+  num << quotient_s << '.' << remainder_s;
+
+  std::free(quotient_s);
+  std::free(remainder_s);
+
+  mpz_clear(remainder);
+
+  double value = lexical_cast<double>(num.str());
+
+  if (! no_check && *this != value)
+    throw_(amount_error, "Conversion of amount to_double loses precision");
+
+  return value;
+}
+
+long amount_t::to_long(bool no_check) const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot convert an uninitialized amount to a long");
+
+  mpz_set(temp, MPZ(quantity));
+  mpz_ui_pow_ui(divisor, 10, quantity->prec);
+  mpz_tdiv_q(temp, temp, divisor);
+
+  long value = mpz_get_si(temp);
+
+  if (! no_check && *this != value)
+    throw_(amount_error, "Conversion of amount to_long loses precision");
+
+  return value;
+}
+
+bool amount_t::fits_in_double() const
+{
+  double value = to_double(true);
+  return *this == amount_t(value);
+}
+
+bool amount_t::fits_in_long() const
+{
+  long value = to_long(true);
+  return *this == amount_t(value);
+}
+
+
+void amount_t::annotate_commodity(const annotation_t& details)
+{
+  commodity_t *		  this_base;
+  annotated_commodity_t * this_ann = NULL;
+
+  if (! quantity)
+    throw_(amount_error, "Cannot annotate the commodity of an uninitialized amount");
+  else if (! has_commodity())
+    throw_(amount_error, "Cannot annotate an amount with no commodity");
+
+  if (commodity().annotated) {
+    this_ann  = &commodity().as_annotated();
+    this_base = &this_ann->referent();
+  } else {
+    this_base = &commodity();
+  }
+  assert(this_base);
+
+  DEBUG("amounts.commodities", "Annotating commodity for amount "
+	<< *this << std::endl << details);
+
+  if (commodity_t * ann_comm =
+      this_base->parent().find_or_create(*this_base, details))
+    set_commodity(*ann_comm);
+#ifdef ASSERTS_ON
+  else
+    assert(false);
+#endif
+
+  DEBUG("amounts.commodities", "  Annotated amount is " << *this);
+}
+
+bool amount_t::commodity_annotated() const
+{
+  if (! quantity)
+    throw_(amount_error,
+	   "Cannot determine if an uninitialized amount's commodity is annotated");
+
+  assert(! commodity().annotated || commodity().as_annotated().details);
+  return commodity().annotated;
+}
+
+annotation_t amount_t::annotation_details() const
+{
+  if (! quantity)
+    throw_(amount_error,
+	   "Cannot return commodity annotation details of an uninitialized amount");
+
+  assert(! commodity().annotated || commodity().as_annotated().details);
+
+  if (commodity().annotated) {
+    annotated_commodity_t& ann_comm(commodity().as_annotated());
+    return ann_comm.details;
+  }
+  return annotation_t();
+}
+
+amount_t amount_t::strip_annotations(const bool _keep_price,
+				     const bool _keep_date,
+				     const bool _keep_tag) const
+{
+  if (! quantity)
+    throw_(amount_error,
+	   "Cannot strip commodity annotations from an uninitialized amount");
+
+  if (! commodity().annotated ||
+      (_keep_price && _keep_date && _keep_tag))
+    return *this;
+
+  amount_t t(*this);
+  t.set_commodity(commodity().as_annotated().
+		  strip_annotations(_keep_price, _keep_date, _keep_tag));
+  return t;
+}
+
+
+namespace {
+  void parse_quantity(std::istream& in, string& value)
+  {
+    char buf[256];
+    char c = peek_next_nonws(in);
+    READ_INTO(in, buf, 255, c,
+	      std::isdigit(c) || c == '-' || c == '.' || c == ',');
+
+    int len = std::strlen(buf);
+    while (len > 0 && ! std::isdigit(buf[len - 1])) {
+      buf[--len] = '\0';
+      in.unget();
+    }
+
+    value = buf;
+  }
+}
+
+void amount_t::parse(std::istream& in, flags_t flags)
+{
+  // The possible syntax for an amount is:
+  //
+  //   [-]NUM[ ]SYM [@ AMOUNT]
+  //   SYM[ ][-]NUM [@ AMOUNT]
+
+  string       symbol;
+  string       quant;
+  annotation_t details;
+  bool	       negative	  = false;
+
+  commodity_t::flags_t comm_flags = COMMODITY_STYLE_DEFAULTS;
+
+  char c = peek_next_nonws(in);
+  if (c == '-') {
+    negative = true;
+    in.get(c);
+    c = peek_next_nonws(in);
+  }
+
+  char n;
+  if (std::isdigit(c)) {
+    parse_quantity(in, quant);
+
+    if (! in.eof() && ((n = in.peek()) != '\n')) {
+      if (std::isspace(n))
+	comm_flags |= COMMODITY_STYLE_SEPARATED;
+
+      commodity_t::parse_symbol(in, symbol);
+
+      if (! symbol.empty())
+	comm_flags |= COMMODITY_STYLE_SUFFIXED;
+
+      if (! in.eof() && ((n = in.peek()) != '\n'))
+	details.parse(in);
+    }
+  } else {
+    commodity_t::parse_symbol(in, symbol);
+
+    if (! in.eof() && ((n = in.peek()) != '\n')) {
+      if (std::isspace(in.peek()))
+	comm_flags |= COMMODITY_STYLE_SEPARATED;
+
+      parse_quantity(in, quant);
+
+      if (! quant.empty() && ! in.eof() && ((n = in.peek()) != '\n'))
+	details.parse(in);
+    }
+  }
+
+  if (quant.empty())
+    throw_(amount_error, "No quantity specified for amount");
+
+  // Allocate memory for the amount's quantity value.  We have to
+  // monitor the allocation in an auto_ptr because this function gets
+  // called sometimes from amount_t's constructor; and if there is an
+  // exeception thrown by any of the function calls after this point,
+  // the destructor will never be called and the memory never freed.
+
+  std::auto_ptr<bigint_t> safe_holder;
+
+  if (! quantity) {
+    quantity = new bigint_t;
+    safe_holder.reset(quantity);
+  }
+  else if (quantity->ref > 1) {
+    _release();
+    quantity = new bigint_t;
+    safe_holder.reset(quantity);
+  }
+
+  // Create the commodity if has not already been seen, and update the
+  // precision if something greater was used for the quantity.
+
+  bool newly_created = false;
+
+  if (symbol.empty()) {
+    commodity_ = NULL;
+  } else {
+    commodity_ = current_pool->find(symbol);
+    if (! commodity_) {
+      commodity_ = current_pool->create(symbol);
+      newly_created = true;
+    }
+    assert(commodity_);
+
+    if (details)
+      commodity_ = current_pool->find_or_create(*commodity_, details);
+  }
+
+  // Determine the precision of the amount, based on the usage of
+  // comma or period.
+
+  string::size_type last_comma  = quant.rfind(',');
+  string::size_type last_period = quant.rfind('.');
+
+  if (last_comma != string::npos && last_period != string::npos) {
+    comm_flags |= COMMODITY_STYLE_THOUSANDS;
+    if (last_comma > last_period) {
+      comm_flags |= COMMODITY_STYLE_EUROPEAN;
+      quantity->prec = quant.length() - last_comma - 1;
+    } else {
+      quantity->prec = quant.length() - last_period - 1;
+    }
+  }
+  else if (last_comma != string::npos &&
+	   commodity().has_flags(COMMODITY_STYLE_EUROPEAN)) {
+    quantity->prec = quant.length() - last_comma - 1;
+  }
+  else if (last_period != string::npos &&
+	   ! (commodity().has_flags(COMMODITY_STYLE_EUROPEAN))) {
+    quantity->prec = quant.length() - last_period - 1;
+  }
+  else {
+    quantity->prec = 0;
+  }
+
+  // Set the commodity's flags and precision accordingly
+
+  if (commodity_ && (newly_created || ! (flags & AMOUNT_PARSE_NO_MIGRATE))) {
+    commodity().add_flags(comm_flags);
+
+    if (quantity->prec > commodity().precision())
+      commodity().set_precision(quantity->prec);
+  }
+
+  // Setup the amount's own flags
+
+  if (flags & AMOUNT_PARSE_NO_MIGRATE)
+    quantity->add_flags(BIGINT_KEEP_PREC);
+
+  // Now we have the final number.  Remove commas and periods, if
+  // necessary.
+
+  if (last_comma != string::npos || last_period != string::npos) {
+    int		 len = quant.length();
+    char *	 buf = new char[len + 1];
+    const char * p   = quant.c_str();
+    char *	 t   = buf;
+
+    while (*p) {
+      if (*p == ',' || *p == '.')
+	p++;
+      *t++ = *p++;
+    }
+    *t = '\0';
+
+    mpz_set_str(MPZ(quantity), buf, 10);
+    checked_array_delete(buf);
+  } else {
+    mpz_set_str(MPZ(quantity), quant.c_str(), 10);
+  }
+
+  if (negative)
+    in_place_negate();
+
+  if (! (flags & AMOUNT_PARSE_NO_REDUCE))
+    in_place_reduce();
+
+  safe_holder.release();	// `this->quantity' owns the pointer
+}
+
+void amount_t::parse_conversion(const string& larger_str,
+				const string& smaller_str)
+{
+  amount_t larger, smaller;
+
+  larger.parse(larger_str, AMOUNT_PARSE_NO_REDUCE);
+  smaller.parse(smaller_str, AMOUNT_PARSE_NO_REDUCE);
+
+  larger *= smaller.number();
+
+  if (larger.commodity()) {
+    larger.commodity().set_smaller(smaller);
+    larger.commodity().add_flags(smaller.commodity().flags() |
+				 COMMODITY_STYLE_NOMARKET);
+  }
+  if (smaller.commodity())
+    smaller.commodity().set_larger(larger);
+}
+
+
+void amount_t::print(std::ostream& _out, bool omit_commodity,
+		     bool full_precision) const
+{
+  if (! quantity)
+    throw_(amount_error, "Cannot write out an uninitialized amount");
+
+  amount_t base(*this);
+  if (! amount_t::keep_base)
+    base.in_place_unreduce();
+
+  std::ostringstream out;
+
+  mpz_t quotient;
+  mpz_t rquotient;
+  mpz_t remainder;
+
+  mpz_init(quotient);
+  mpz_init(rquotient);
+  mpz_init(remainder);
+
+  bool negative = false;
+
+  // Ensure the value is rounded to the commodity's precision before
+  // outputting it.  NOTE: `rquotient' is used here as a temp variable!
+
+  commodity_t& comm(base.commodity());
+  precision_t  precision = 0;
+
+  if (quantity) {
+    if (! comm || full_precision || base.quantity->has_flags(BIGINT_KEEP_PREC)) {
+      mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
+      mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
+      precision = base.quantity->prec;
+    }
+    else if (comm.precision() < base.quantity->prec) {
+      mpz_round(rquotient, MPZ(base.quantity), base.quantity->prec,
+		comm.precision());
+      mpz_ui_pow_ui(divisor, 10, comm.precision());
+      mpz_tdiv_qr(quotient, remainder, rquotient, divisor);
+      precision = comm.precision();
+    }
+    else if (comm.precision() > base.quantity->prec) {
+      mpz_ui_pow_ui(divisor, 10, comm.precision() - base.quantity->prec);
+      mpz_mul(rquotient, MPZ(base.quantity), divisor);
+      mpz_ui_pow_ui(divisor, 10, comm.precision());
+      mpz_tdiv_qr(quotient, remainder, rquotient, divisor);
+      precision = comm.precision();
+    }
+    else if (base.quantity->prec) {
+      mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
+      mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
+      precision = base.quantity->prec;
+    }
+    else {
+      mpz_set(quotient, MPZ(base.quantity));
+      mpz_set_ui(remainder, 0);
+      precision = 0;
+    }
+
+    if (mpz_sgn(quotient) < 0 || mpz_sgn(remainder) < 0) {
+      negative = true;
+
+      mpz_abs(quotient, quotient);
+      mpz_abs(remainder, remainder);
+    }
+    mpz_set(rquotient, remainder);
+  }
+
+  if (! omit_commodity && ! comm.has_flags(COMMODITY_STYLE_SUFFIXED)) {
+    comm.print(out);
+    if (comm.has_flags(COMMODITY_STYLE_SEPARATED))
+      out << " ";
+  }
+
+  if (negative)
+    out << "-";
+
+  if (! quantity || mpz_sgn(quotient) == 0) {
+    out << '0';
+  }
+  else if (omit_commodity || ! comm.has_flags(COMMODITY_STYLE_THOUSANDS)) {
+    char * p = mpz_get_str(NULL, 10, quotient);
+    out << p;
+    std::free(p);
+  }
+  else {
+    std::list<string> strs;
+    char buf[4];
+
+    for (int powers = 0; true; powers += 3) {
+      if (powers > 0) {
+	mpz_ui_pow_ui(divisor, 10, powers);
+	mpz_tdiv_q(temp, quotient, divisor);
+	if (mpz_sgn(temp) == 0)
+	  break;
+	mpz_tdiv_r_ui(temp, temp, 1000);
+      } else {
+	mpz_tdiv_r_ui(temp, quotient, 1000);
+      }
+      mpz_get_str(buf, 10, temp);
+      strs.push_back(buf);
+    }
+
+    bool printed = false;
+
+    for (std::list<string>::reverse_iterator i = strs.rbegin();
+	 i != strs.rend();
+	 i++) {
+      if (printed) {
+	out << (comm.has_flags(COMMODITY_STYLE_EUROPEAN) ? '.' : ',');
+	out.width(3);
+	out.fill('0');
+      }
+      out << *i;
+
+      printed = true;
+    }
+  }
+
+  if (quantity && precision) {
+    std::ostringstream final;
+    final.width(precision);
+    final.fill('0');
+    char * p = mpz_get_str(NULL, 10, rquotient);
+    final << p;
+    std::free(p);
+
+    const string& str(final.str());
+    int i, len = str.length();
+    const char * q = str.c_str();
+    for (i = len; i > 0; i--)
+      if (q[i - 1] != '0')
+	break;
+
+    string ender;
+    if (i == len)
+      ender = str;
+    else if (i < comm.precision())
+      ender = string(str, 0, comm.precision());
+    else
+      ender = string(str, 0, i);
+
+    if (! ender.empty()) {
+      if (omit_commodity)
+	out << '.';
+      else
+	out << (comm.has_flags(COMMODITY_STYLE_EUROPEAN) ? ',' : '.');
+      out << ender;
+    }
+  }
+
+  if (! omit_commodity && comm.has_flags(COMMODITY_STYLE_SUFFIXED)) {
+    if (comm.has_flags(COMMODITY_STYLE_SEPARATED))
+      out << " ";
+    comm.print(out);
+  }
+
+  mpz_clear(quotient);
+  mpz_clear(rquotient);
+  mpz_clear(remainder);
+
+  // If there are any annotations associated with this commodity,
+  // output them now.
+
+  if (! omit_commodity && comm.annotated) {
+    annotated_commodity_t& ann(static_cast<annotated_commodity_t&>(comm));
+    assert(&*ann.details.price != this);
+    ann.write_annotations(out);
+  }
+
+  // Things are output to a string first, so that if anyone has
+  // specified a width or fill for _out, it will be applied to the
+  // entire amount string, and not just the first part.
+
+  _out << out.str();
+}
+
+
+namespace {
+  char *	bigints;
+  char *	bigints_next;
+  uint_fast32_t bigints_index;
+  uint_fast32_t bigints_count;
+  char		buf[4096];
+}
+
+void amount_t::read(std::istream& in)
+{
+  using ledger::binary;
+
+  // Read in the commodity for this amount
+  
+  commodity_t::ident_t ident;
+  read_long(in, ident);
+  if (ident == 0xffffffff)
+    commodity_ = NULL;
+  else if (ident == 0)
+    commodity_ = current_pool->null_commodity;
+  else {
+    commodity_ = current_pool->find(ident);
+    assert(commodity_);
+  }
+
+  // Read in the quantity
+
+  char byte;
+  in.read(&byte, sizeof(byte));
+
+  if (byte < 3) {
+    quantity = new bigint_t;
+
+    unsigned short len;
+    in.read((char *)&len, sizeof(len));
+    assert(len < 4096);
+    in.read(buf, len);
+    mpz_import(MPZ(quantity), len / sizeof(short), 1, sizeof(short),
+	       0, 0, buf);
+
+    char negative;
+    in.read(&negative, sizeof(negative));
+    if (negative)
+      mpz_neg(MPZ(quantity), MPZ(quantity));
+
+    in.read((char *)&quantity->prec, sizeof(quantity->prec));
+
+    bigint_t::flags_t tflags;
+    in.read((char *)&tflags, sizeof(tflags));
+    quantity->set_flags(tflags);
+  }
+  else {
+    assert(false);
+  }
+}
+
+void amount_t::read(const char *& data)
+{
+  using ledger::binary;
+  
+  // Read in the commodity for this amount
+  
+  commodity_t::ident_t ident;
+  read_long(data, ident);
+  if (ident == 0xffffffff)
+    commodity_ = NULL;
+  else if (ident == 0)
+    commodity_ = current_pool->null_commodity;
+  else {
+    commodity_ = current_pool->find(ident);
+    assert(commodity_);
+  }
+
+  // Read in the quantity
+
+  char byte = *data++;;
+
+  if (byte < 3) {
+    if (byte == 2) {
+      quantity = new((bigint_t *)bigints_next) bigint_t;
+      bigints_next += sizeof(bigint_t);
+    } else {
+      quantity = new bigint_t;
+    }
+
+    unsigned short len = *((unsigned short *) data);
+    data += sizeof(unsigned short);
+    mpz_import(MPZ(quantity), len / sizeof(short), 1, sizeof(short),
+	       0, 0, data);
+    data += len;
+
+    char negative = *data++;
+    if (negative)
+      mpz_neg(MPZ(quantity), MPZ(quantity));
+
+    quantity->prec = *((precision_t *) data);
+    data += sizeof(precision_t);
+    quantity->set_flags(*((flags_t *) data));
+    data += sizeof(flags_t);
+
+    if (byte == 2)
+      quantity->add_flags(BIGINT_BULK_ALLOC);
+  } else {
+    uint_fast32_t index = *((uint_fast32_t *) data);
+    data += sizeof(uint_fast32_t);
+
+    quantity = (bigint_t *) (bigints + (index - 1) * sizeof(bigint_t));
+    DEBUG("amounts.refs",
+	   quantity << " ref++, now " << (quantity->ref + 1));
+    quantity->ref++;
+  }
+}
+
+void amount_t::write(std::ostream& out, bool optimized) const
+{
+  using ledger::binary;
+  
+  // Write out the commodity for this amount
+  
+  if (! quantity)
+    throw_(amount_error, "Cannot serialize an uninitialized amount");
+
+  if (commodity_)
+    write_long(out, commodity_->ident);
+  else
+    write_long<commodity_t::ident_t>(out, 0xffffffff);
+
+  // Write out the quantity
+
+  char byte;
+
+  if (! optimized || quantity->index == 0) {
+    if (optimized) {
+      quantity->index = ++bigints_index; // if !optimized, this is garbage
+      bigints_count++;
+      byte = 2;
+    } else {
+      byte = 1;
+    }
+    out.write(&byte, sizeof(byte));
+
+    std::size_t size;
+    mpz_export(buf, &size, 1, sizeof(short), 0, 0, MPZ(quantity));
+    unsigned short len = size * sizeof(short);
+    out.write((char *)&len, sizeof(len));
+    if (len) {
+      assert(len < 4096);
+      out.write(buf, len);
+    }
+
+    byte = mpz_sgn(MPZ(quantity)) < 0 ? 1 : 0;
+    out.write(&byte, sizeof(byte));
+
+    out.write((char *)&quantity->prec, sizeof(quantity->prec));
+    bigint_t::flags_t tflags = quantity->flags() & ~BIGINT_BULK_ALLOC;
+    assert(sizeof(tflags) == sizeof(bigint_t::flags_t));
+    out.write((char *)&tflags, sizeof(tflags));
+  } else {
+    assert(quantity->ref > 1);
+
+    // Since this value has already been written, we simply write
+    // out a reference to which one it was.
+    byte = 3;
+    out.write(&byte, sizeof(byte));
+    out.write((char *)&quantity->index, sizeof(quantity->index));
+  }
+}
+
+
+bool amount_t::valid() const
+{
+  if (quantity) {
+    if (quantity->ref == 0) {
+      DEBUG("ledger.validate", "amount_t: quantity->ref == 0");
+      return false;
+    }
+  }
+  else if (commodity_) {
+    DEBUG("ledger.validate", "amount_t: commodity_ != NULL");
+    return false;
+  }
+  return true;
+}
+
+} // namespace ledger
diff --git a/src/numerics/amount.h b/src/numerics/amount.h
new file mode 100644
index 00000000..f4dbc9bd
--- /dev/null
+++ b/src/numerics/amount.h
@@ -0,0 +1,712 @@
+/*
+ * Copyright (c) 2003-2007, John Wiegley.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of New Artisans LLC nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file   amount.h
+ * @author John Wiegley
+ * @date   Wed Apr 18 22:05:53 2007
+ * 
+ * @brief  Basic type for handling commoditized math: amount_t.
+ * 
+ * This file contains the most basic numerical type in Ledger:
+ * amount_t, which relies upon commodity.h (commodity_t) for handling
+ * commoditized amounts.  This class allows Ledger to handle
+ * mathematical expressions involving differing commodities, as well
+ * as math using no commodities at all (such as increasing a dollar
+ * amount by a multiplier).
+ */
+#ifndef _AMOUNT_H
+#define _AMOUNT_H
+
+#include "utils.h"
+
+namespace ledger {
+
+class commodity_t;
+class annotation_t;
+class commodity_pool_t;
+
+DECLARE_EXCEPTION(amount_error);
+
+/**
+ * @class amount_t
+ *
+ * @brief Encapsulates infinite-precision commoditized amounts.
+ *
+ * The amount_t class can be used for commoditized infinite-precision
+ * math, and also for uncommoditized math.  In the commoditized case,
+ * commodities keep track of how they are used, and will always
+ * display back to the user after the same fashion.  For
+ * uncommoditized numbers, no display truncation is ever done.  In
+ * both cases, internal precision is always kept to an excessive
+ * degree.
+ */
+class amount_t
+  : public ordered_field_operators<amount_t,
+	   ordered_field_operators<amount_t, double,
+	   ordered_field_operators<amount_t, unsigned long,
+	   ordered_field_operators<amount_t, long> > > >
+{
+  // jww (2007-05-03): Make this private, and then make
+  // ledger::initialize into a member function of session_t.
+public:
+  /** 
+   * The initialize and shutdown methods ready the amount subsystem
+   * for use.  Normally they are called by `ledger::initialize' and
+   * `ledger::shutdown'.
+   */
+  static void initialize();
+  static void shutdown();
+
+public:
+  typedef uint_least16_t precision_t;
+
+  /**
+   * The current_pool is a static variable indicating which commodity
+   * pool should be used.
+   */
+  static commodity_pool_t * current_pool;
+
+  /**
+   * The `keep_base' member determines whether scalable commodities
+   * are automatically converted to their most reduced form when
+   * printing.  The default is true.
+   *
+   * For example, Ledger supports time values specified in seconds
+   * (10s), hours (5.2h) or minutes.  Internally, such amounts are
+   * always kept as quantities of seconds.  However, when streaming
+   * the amount Ledger will convert it to its "least representation",
+   * which is "5.2h" in the second case.  If `keep_base' is true, this
+   * amount is displayed as "18720s".
+   */
+  static bool keep_base;
+
+  /**
+   * The following three members determine whether lot details are
+   * maintained when working with commoditized values.  The default is
+   * false for all three.
+   *
+   * Let's say a user adds two values of the following form:
+   *   10 AAPL + 10 AAPL {$20}
+   *
+   * This expression adds ten shares of Apple stock with another ten
+   * shares that were purchased for $20 a share.  If `keep_price' is
+   * false, the result of this expression will be an amount equal to
+   * 20 AAPL.  If `keep_price' is true, the expression yields an
+   * exception for adding amounts with different commodities.  In that
+   * case, a balance_t object must be used to store the combined sum.
+   */
+  static bool keep_price;
+  static bool keep_date;
+  static bool keep_tag;
+
+  /**
+   * The `stream_fullstrings' static member is currently only used by
+   * the unit testing code.  It causes amounts written to streams to
+   * use the `to_fullstring' method rather than the `to_string'
+   * method, so that complete precision is always displayed, no matter
+   * what the precision of an individual commodity might be.
+   * @see to_string
+   * @see to_fullstring
+   */
+  static bool stream_fullstrings;
+
+protected:
+  void _copy(const amount_t& amt);
+  void _dup();
+  void _resize(precision_t prec);
+  void _clear();
+  void _release();
+
+  struct bigint_t;
+
+  bigint_t *	quantity;
+  commodity_t *	commodity_;
+
+public:
+  /**
+   * Constructors.  amount_t supports several forms of construction:
+   *
+   * amount_t() creates a value for which `is_null' is true, and which
+   * has no value or commodity.  If used in value situations it will
+   * be zero, and its commodity equals `commodity_t::null_commodity'.
+   *
+   * amount_t(double), amount_t(unsigned long), amount_t(long) all
+   * convert from the respective numerics type to an amount.  No
+   * precision or sign is lost in any of these conversions.  The
+   * resulting commodity is always `commodity_t::null_commodity'.
+   *
+   * amount_t(string), amount_t(const char *) both convert from a
+   * string representation of an amount, which may or may not include
+   * a commodity.  This is the proper way to initialize an amount like
+   * '$100.00'.
+   */
+  amount_t() : quantity(NULL), commodity_(NULL) {
+    TRACE_CTOR(amount_t, "");
+  }
+  amount_t(const double val);
+  amount_t(const unsigned long val);
+  amount_t(const long val);
+
+  explicit amount_t(const string& val) : quantity(NULL) {
+    TRACE_CTOR(amount_t, "const string&");
+    parse(val);
+  }
+  explicit amount_t(const char * val) : quantity(NULL) {
+    TRACE_CTOR(amount_t, "const char *");
+    parse(val);
+  }
+
+  /**
+   * Static creator function.  Calling amount_t::exact(string) will
+   * create an amount whose display precision is never truncated, even
+   * if the amount uses a commodity (which normally causes "round on
+   * streaming" to occur).  This function is mostly used by the
+   * debugging code.  It is the proper way to initialize '$100.005',
+   * where display of the extra precision is required.  If a regular
+   * constructor is used, this amount will stream as '$100.01', even
+   * though its internal value always equals $100.005.
+   */
+  static amount_t exact(const string& value);
+
+  /**
+   * Destructor.  Releases the reference count held for the underlying
+   * bigint_t object pointed to be `quantity'.
+   */
+  ~amount_t() {
+    TRACE_DTOR(amount_t);
+    if (quantity)
+      _release();
+  }
+
+  /**
+   * Assignment and copy operators.  An amount may be assigned or
+   * copied.  If a double, long or unsigned long is assigned to an
+   * amount, a temporary is constructed, and then the temporary is
+   * assigned to `this'.  Both the value and the commodity are copied,
+   * causing the result to compare equal to the reference amount.
+   *
+   * Note: `quantity' must be initialized to NULL first, otherwise the
+   * `_copy' function will attempt to release the uninitialized pointer.
+   */
+  amount_t(const amount_t& amt) : quantity(NULL) {
+    TRACE_CTOR(amount_t, "copy");
+    if (amt.quantity)
+      _copy(amt);
+    else
+      commodity_ = NULL;
+  }
+  amount_t& operator=(const amount_t& amt);
+
+  amount_t& operator=(const string& str) {
+    return *this = amount_t(str);
+  }
+  amount_t& operator=(const char * str) {
+    return *this = amount_t(str);
+  }
+
+  /**
+   * Comparison operators.  The fundamental comparison operation for
+   * amounts is `compare', which returns a value less than, greater
+   * than or equal to zero.  All the other comparison operators are
+   * defined in terms of this method.  The only special detail is that
+   * `operator==' will fail immediately if amounts with different
+   * commodities are being compared.  Otherwise, if the commodities
+   * are equivalent (@see keep_price, et al), then the amount
+   * quantities are compared numerically.
+   *
+   * Comparison between an amount and a double, long or unsigned long
+   * is allowed.  In such cases the non-amount value is constructed as
+   * an amount temporary, which is then compared to `this'.
+   */
+  int compare(const amount_t& amt) const;
+
+  bool operator==(const amount_t& amt) const;
+
+  template <typename T>
+  bool operator==(const T& val) const {
+    return compare(val) == 0;
+  }
+  template <typename T>
+  bool operator<(const T& amt) const {
+    return compare(amt) < 0;
+  }
+  template <typename T>
+  bool operator>(const T& amt) const {
+    return compare(amt) > 0;
+  }
+
+  /**
+   * Binary arithmetic operators.  Amounts support addition,
+   * subtraction, multiplication and division -- but not modulus,
+   * bitwise operations, or shifting.  Arithmetic is also supported
+   * between amounts, double, long and unsigned long, in which case
+   * temporary amount are constructed for the life of the expression.
+   *
+   * Although only in-place operators are defined here, the remainder
+   * are provided by `boost::ordered_field_operators<>'.
+   */
+  amount_t& operator+=(const amount_t& amt);
+  amount_t& operator-=(const amount_t& amt);
+  amount_t& operator*=(const amount_t& amt);
+  amount_t& operator/=(const amount_t& amt);
+
+  /**
+   * Unary arithmetic operators.  There are several unary methods
+   * support on amounts:
+   *
+   * precision() return an amount's current, internal precision.  To
+   * find the precision it will be displayed at -- assuming it was not
+   * created using the static method `amount_t::exact' -- refer to
+   * commodity().precision.
+   *
+   * negate(), also unary minus (- x), returns the negated value of an
+   * amount.
+   *
+   * abs() returns the absolute value of an amount.  It is equivalent
+   * to: `(x < 0) ? - x : x'.
+   *
+   * round(optional<precision_t>) rounds an amount's internal value to
+   * the given precision, or to the commodity's current display
+   * precision if no precision value is given.  This method changes
+   * the internal value of the amount, if it's internal precision was
+   * greater than the rounding precision.
+   *
+   * unround() yields an amount whose display precision is never
+   * truncated, even though its commodity normally displays only
+   * rounded values.
+   *
+   * reduce() reduces a value to its most basic commodity form, for
+   * amounts that utilize "scaling commodities".  For example, an
+   * amount of 1h after reduction will be 3600s.
+   *
+   * unreduce(), if used with a "scaling commodity", yields the most
+   * compact form greater than 1.0.  That is, 3599s will unreduce to
+   * 59.98m, while 3601 unreduces to 1h.
+   *
+   * value(optional<moment_t>) returns the historical value for an
+   * amount -- the default moment returns the most recently known
+   * price -- based on the price history of its commodity.  For
+   * example, if the amount were 10 AAPL, and on Apr 10, 2000 each
+   * share of AAPL was worth $10, then call value() for that moment in
+   * time would yield the amount $100.00.
+   *
+   * Further, for the sake of efficiency and avoiding temporary
+   * objects, the following methods support "in-place" variants that
+   * act on the amount itself and return a reference to the result
+   * (`*this'):
+   *
+   * in_place_negate()
+   * in_place_reduce()
+   * in_place_unreduce()
+   */
+  precision_t precision() const;
+
+  amount_t negate() const {
+    amount_t temp(*this);
+    temp.in_place_negate();
+    return temp;
+  }
+  amount_t& in_place_negate();
+
+  amount_t operator-() const {
+    return negate();
+  }
+
+  amount_t abs() const {
+    if (sign() < 0)
+      return negate();
+    return *this;
+  }
+
+  amount_t round(const optional<precision_t>& prec) const;
+  amount_t unround() const;
+
+  amount_t reduce() const {
+    amount_t temp(*this);
+    temp.in_place_reduce();
+    return temp;
+  }
+  amount_t& in_place_reduce();
+
+  amount_t unreduce() const {
+    amount_t temp(*this);
+    temp.in_place_unreduce();
+    return temp;
+  }
+  amount_t& in_place_unreduce();
+
+  optional<amount_t> value(const optional<moment_t>& moment = none) const;
+
+  /**
+   * Truth tests.  An amount may be truth test in several ways:
+   *
+   * sign() returns an integer less than, greater than, or equal to
+   * zero depending on whether the amount is negative, zero, or
+   * greater than zero.  Note that this function tests the actual
+   * value of the amount -- using its internal precision -- and not
+   * the display value.  To test its display value, use:
+   * `round().sign()'.
+   *
+   * is_nonzero(), or operator bool, returns true if an amount's
+   * display value is not zero.
+   *
+   * is_zero() returns true if an amount's display value is zero.
+   * Thus, $0.0001 is considered zero if the current display precision
+   * for dollars is two decimal places.
+   *
+   * is_realzero() returns true if an amount's actual value is zero.
+   * Thus, $0.0001 is never considered realzero.
+   *
+   * is_null() returns true if an amount has no value and no
+   * commodity.  This only occurs if an uninitialized amount has never
+   * been assigned a value.
+   */
+  int sign() const;
+
+  operator bool() const {
+    return is_nonzero();
+  }
+  bool is_nonzero() const {
+    return ! is_zero();
+  }
+
+  bool is_zero() const;
+  bool is_realzero() const {
+    return sign() == 0;
+  }
+
+  bool is_null() const {
+    if (! quantity) {
+      assert(! commodity_);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Conversion methods.  An amount may be converted to the same types
+   * it can be constructed from -- with the exception of unsigned
+   * long.  Implicit conversions are not allowed in C++ (though they
+   * are in Python), rather the following conversion methods must be
+   * called explicitly:
+   *
+   * to_double([bool]) returns an amount as a double.  If the optional
+   * boolean argument is true (the default), an exception is thrown if
+   * the conversion would lose information.
+   *
+   * to_long([bool]) returns an amount as a long integer.  If the
+   * optional boolean argument is true (the default), an exception is
+   * thrown if the conversion would lose information.
+   *
+   * fits_in_double() returns true if to_double() would not lose
+   * precision.
+   *
+   * fits_in_long() returns true if to_long() would not lose
+   * precision.
+   *
+   * to_string() returns an amount'ss "display value" as a string --
+   * after rounding the value according to the commodity's default
+   * precision.  It is equivalent to: `round().to_fullstring()'.
+   *
+   * to_fullstring() returns an amount's "internal value" as a string,
+   * without any rounding.
+   *
+   * quantity_string() returns an amount's "display value", but
+   * without any commodity.  Note that this is different from
+   * `number().to_string()', because in that case the commodity has
+   * been stripped and the full, internal precision of the amount
+   * would be displayed.
+   */
+  double to_double(bool no_check = false) const;
+  long   to_long(bool no_check = false) const;
+  string to_string() const;
+  string to_fullstring() const;
+  string quantity_string() const;
+
+  bool fits_in_double() const;
+  bool fits_in_long() const;
+
+  /**
+   * Commodity-related methods.  The following methods relate to an
+   * amount's commodity:
+   *
+   * commodity() returns an amount's commodity.  If the amount has no
+   * commodity, the value returned is `current_pool->null_commodity'.
+   *
+   * has_commodity() returns true if the amount has a commodity.
+   *
+   * set_commodity(commodity_t) sets an amount's commodity to the
+   * given value.  Note that this merely sets the current amount to
+   * that commodity, it does not "observe" the amount for possible
+   * changes in the maximum display precision of the commodity, the
+   * way that `parse' does.
+   *
+   * clear_commodity() sets an amount's commodity to null, such that
+   * has_commodity() afterwards returns false.
+   *
+   * number() returns a commodity-less version of an amount.  This is
+   * useful for accessing just the numeric portion of an amount.
+   */
+  commodity_t& commodity() const;
+
+  bool has_commodity() const;
+  void set_commodity(commodity_t& comm) {
+    if (! quantity)
+      *this = 0L;
+    commodity_ = &comm;
+  }
+  void clear_commodity() {
+    commodity_ = NULL;
+  }
+
+  amount_t number() const {
+    if (! has_commodity())
+      return *this;
+
+    amount_t temp(*this);
+    temp.clear_commodity();
+    return temp;
+  }
+
+  /**
+   * Annotated commodity methods.  An amount's commodity may be
+   * annotated with special details, such as the price it was
+   * purchased for, when it was acquired, or an arbitrary note,
+   * identifying perhaps the lot number of an item.
+   *
+   * annotate_commodity(amount_t price, [moment_t date, string tag])
+   * sets the annotations for the current amount's commodity.  Only
+   * the price argument is required, although it can be passed as
+   * `none' if no price is desired.
+   *
+   * commodity_annotated() returns true if an amount's commodity has
+   * any annotation details associated with it.
+   *
+   * annotation_details() returns all of the details of an annotated
+   * commodity's annotations.  The structure returns will evaluate as
+   * boolean false if there are no details.
+   *
+   * strip_annotations([keep_price, keep_date, keep_tag]) returns an
+   * amount whose commodity's annotations have been stripped.  The
+   * three `keep_' arguments determine which annotation detailed are
+   * kept, meaning that the default is to follow whatever
+   * amount_t::keep_price, amount_t::keep_date and amount_t::keep_tag
+   * have been set to (which all default to false).
+   */
+  void         annotate_commodity(const annotation_t& details);
+  bool         commodity_annotated() const;
+  annotation_t annotation_details() const;
+  amount_t     strip_annotations(const bool _keep_price = keep_price,
+				 const bool _keep_date  = keep_date,
+				 const bool _keep_tag   = keep_tag) const;
+
+  /**
+   * Parsing methods.  The method `parse' is used to parse an amount
+   * from an input stream or a string.  A global operator>> is also
+   * defined which simply calls parse on the input stream.  The
+   * `parse' method has two forms:
+   *
+   * parse(istream, flags_t) parses an amount from the given input
+   * stream.
+   *
+   * parse(string, flags_t) parses an amount from the given string.
+   *
+   * parse(string, flags_t) also parses an amount from a string.
+   *
+   * The `flags' argument of both parsing may be one or more of the
+   * following:
+   *
+   * AMOUNT_PARSE_NO_MIGRATE means to not pay attention to the way an
+   * amount is used.  Ordinarily, if an amount were $100.001, for
+   * example, it would cause the default display precision for $ to be
+   * "widened" to three decimal places.  If AMOUNT_PARSE_NO_MIGRATE is
+   * used, the commodity's default display precision is not changed.
+   *
+   * AMOUNT_PARSE_NO_REDUCE means not to call in_place_reduce() on the
+   * resulting amount after it is parsed.
+   *
+   * These parsing methods observe the amounts they parse (unless
+   * AMOUNT_PARSE_NO_MIGRATE is true), and set the display details of
+   * the corresponding commodity accordingly.  This way, amounts do
+   * not require commodities to be pre-defined in any way, but merely
+   * displays them back to the user in the same fashion as it saw them
+   * used.
+   *
+   * There is also a static convenience method called
+   * `parse_conversion' which can be used to define a relationship
+   * between scaling commodity values.  For example, Ledger uses it to
+   * define the relationships among various time values:
+   *
+   *   amount_t::parse_conversion("1.0m", "60s"); // a minute is 60 seconds
+   *   amount_t::parse_conversion("1.0h", "60m"); // an hour is 60 minutes
+   */
+#define AMOUNT_PARSE_NO_MIGRATE 0x01
+#define AMOUNT_PARSE_NO_REDUCE  0x02
+
+  typedef uint_least8_t flags_t;
+
+  void parse(std::istream& in, flags_t flags = 0);
+  void parse(const string& str, flags_t flags = 0) {
+    std::istringstream stream(str);
+    parse(stream, flags);
+    assert(stream.eof());
+  }
+
+  static void parse_conversion(const string& larger_str,
+			       const string& smaller_str);
+
+  /**
+   * Printing methods.  An amount may be output to a stream using the
+   * `print' method.  There is also a global operator<< defined which
+   * simply calls print for an amount on the given stream.  There is
+   * one form of the print method, which takes one required argument
+   * and two arguments with default values:
+   *
+   * print(ostream, bool omit_commodity = false, bool full_precision =
+   * false) prints an amounts to the given output stream, using its
+   * commodity's default display characteristics.  If `omit_commodity'
+   * is true, the commodity will not be displayed, only the amount
+   * (although the commodity's display precision is still used).  If
+   * `full_precision' is true, the full internal precision of the
+   * amount is displayed, regardless of its commodity's display
+   * precision.
+   */
+  void print(std::ostream& out, bool omit_commodity = false,
+	     bool full_precision = false) const;
+
+  /**
+   * Serialization methods.  An amount may be deserialized from an
+   * input stream or a character pointer, and it may be serialized to
+   * an output stream.  The methods used are:
+   *
+   * read(istream) reads an amount from the given input stream.  It
+   * must have been put there using `write(ostream)'.  The required
+   * flow of logic is:
+   *   amount_t::current_pool->write(out)
+   *   amount.write(out)	// write out all amounts
+   *   amount_t::current_pool->read(in)
+   *   amount.read(in)
+   *
+   * read(char *&) reads an amount from data which has been read from
+   * an input stream into a buffer.  It advances the pointer passed in
+   * to the end of the deserialized amount.
+   *
+   * write(ostream, [bool]) writes an amount to an output stream in a
+   * compact binary format.  If the second parameter is true,
+   * quantities with multiple reference counts will be written in an
+   * optimized fashion.  NOTE: This form of usage is valid only for
+   * the binary journal writer, it should not be used otherwise, as it
+   * has strict requirements for reading that only the binary reader
+   * knows about.
+   */
+  void read(std::istream& in);
+  void read(const char *& data);
+  void write(std::ostream& out, bool optimize = false) const;
+
+  /**
+   * Debugging methods.  There are two methods defined to help with
+   * debugging:
+   *
+   * dump(ostream) dumps an amount to an output stream.  There is
+   * little different from print(), it simply surrounds the display
+   * value with a marker, for example "AMOUNT($1.00)".  This code is
+   * used by other dumping code elsewhere in Ledger.
+   *
+   * valid() returns true if an amount is valid.  This ensures that if
+   * an amount has a commodity, it has a valid value pointer, for
+   * example, even if that pointer simply points to a zero value.
+   */
+  void dump(std::ostream& out) const {
+    out << "AMOUNT(";
+    print(out);
+    out << ")";
+  }
+
+  bool valid() const;
+};
+
+inline amount_t amount_t::exact(const string& value) {
+  amount_t temp;
+  temp.parse(value, AMOUNT_PARSE_NO_MIGRATE);
+  return temp;
+}
+
+inline string amount_t::to_string() const {
+  std::ostringstream bufstream;
+  print(bufstream);
+  return bufstream.str();
+}
+
+inline string amount_t::to_fullstring() const {
+  std::ostringstream bufstream;
+  print(bufstream, false, true);
+  return bufstream.str();
+}
+
+inline string amount_t::quantity_string() const {
+  std::ostringstream bufstream;
+  print(bufstream, true);
+  return bufstream.str();
+}
+
+inline std::ostream& operator<<(std::ostream& out, const amount_t& amt) {
+  amt.print(out, false, amount_t::stream_fullstrings);
+  return out;
+}
+inline std::istream& operator>>(std::istream& in, amount_t& amt) {
+  amt.parse(in);
+  return in;
+}
+
+} // namespace ledger
+
+#include "commodity.h"
+
+namespace ledger {
+
+inline bool amount_t::operator==(const amount_t& amt) const {
+  if (commodity() != amt.commodity())
+    return false;
+  return compare(amt) == 0;
+}
+
+inline commodity_t& amount_t::commodity() const {
+  return has_commodity() ? *commodity_ : *current_pool->null_commodity;
+}
+
+inline bool amount_t::has_commodity() const {
+  return commodity_ && commodity_ != commodity_->parent().null_commodity;
+}
+
+} // namespace ledger
+
+#endif // _AMOUNT_H
diff --git a/src/numerics/balance.h b/src/numerics/balance.h
new file mode 100644
index 00000000..1bab4b6b
--- /dev/null
+++ b/src/numerics/balance.h
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) 2003-2007, John Wiegley.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of New Artisans LLC nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file   balance.h
+ * @author John Wiegley
+ * @date   Sun May 20 15:28:44 2007
+ * 
+ * @brief  Basic type for adding multiple commodities together.
+ * 
+ * Unlike the amount_t class, which throws an exception if amounts of
+ * differing commodities are added or subtracted, the balance_t class
+ * is designed to allow this, tracking the amounts of each component
+ * commodity separately.
+ */
+#ifndef _BALANCE_H
+#define _BALANCE_H
+
+#include "amount.h"
+
+namespace ledger {
+
+DECLARE_EXCEPTION(balance_error);
+
+/**
+ * @class balance_t
+ *
+ * @brief A wrapper around amount_t allowing addition of multiple commodities.
+ *
+ * The balance_t class is appopriate for keeping a running balance
+ * where amounts of multiple commodities may be involved.
+ */
+class balance_t
+  : public equality_comparable<balance_t,
+           equality_comparable<balance_t, amount_t,
+           equality_comparable<balance_t, double,
+           equality_comparable<balance_t, unsigned long,
+           equality_comparable<balance_t, long,
+           additive<balance_t,
+           additive<balance_t, amount_t,
+           additive<balance_t, double,
+           additive<balance_t, unsigned long,
+           additive<balance_t, long,
+           multiplicative<balance_t, amount_t,
+           multiplicative<balance_t, double,
+           multiplicative<balance_t, unsigned long,
+           multiplicative<balance_t, long> > > > > > > > > > > > > >
+{
+public:
+  typedef std::map<const commodity_t *, amount_t> amounts_map;
+
+protected:
+  amounts_map amounts;
+
+  // jww (2007-05-20): Remove these two by adding access methods
+  friend class value_t;
+  friend class entry_base_t;
+
+public:
+  /**
+   * Constructors.  balance_t supports similar forms of construction
+   * to amount_t.
+   *
+   * balance_t() creates an empty balance to which amounts or other
+   * balances may be added or subtracted.
+   *
+   * balance_t(amount_t) constructs a balance whose starting value is
+   * equal to the given amount.
+   *
+   * balance_t(double), balance_t(unsigned long) and balance_t(long)
+   * will construct an amount from their arguments and then construct
+   * a balance whose starting value is equal to that amount.  This
+   * initial balance will have no commodity.
+   *
+   * balance_t(string) and balance_t(const char *) both convert from a
+   * string representation of an amount to a balance whose initial
+   * value is that amount.  This is the proper way to initialize a
+   * balance like '$100.00'.
+   */
+  balance_t() {
+    TRACE_CTOR(balance_t, "");
+  }
+  balance_t(const amount_t& amt) {
+    TRACE_CTOR(balance_t, "const amount_t&");
+    if (amt.is_null())
+      throw_(balance_error,
+	     "Cannot initialize a balance from an uninitialized amount");
+    if (! amt.is_realzero())
+      amounts.insert(amounts_map::value_type(&amt.commodity(), amt));
+  }
+  balance_t(const double val) {
+    TRACE_CTOR(balance_t, "const double");
+    amounts.insert
+      (amounts_map::value_type(amount_t::current_pool->null_commodity, val));
+  }
+  balance_t(const unsigned long val) {
+    TRACE_CTOR(balance_t, "const unsigned long");
+    amounts.insert
+      (amounts_map::value_type(amount_t::current_pool->null_commodity, val));
+  }
+  balance_t(const long val) {
+    TRACE_CTOR(balance_t, "const long");
+    amounts.insert
+      (amounts_map::value_type(amount_t::current_pool->null_commodity, val));
+  }
+
+  explicit balance_t(const string& val) {
+    TRACE_CTOR(balance_t, "const string&");
+    amount_t temp(val);
+    amounts.insert(amounts_map::value_type(&temp.commodity(), temp));
+  }
+  explicit balance_t(const char * val) {
+    TRACE_CTOR(balance_t, "const char *");
+    amount_t temp(val);
+    amounts.insert(amounts_map::value_type(&temp.commodity(), temp));
+  }
+
+  /**
+   * Destructor.  Destroys all of the accumulated amounts in the
+   * balance.
+   */
+  virtual ~balance_t() {
+    TRACE_DTOR(balance_t);
+  }
+
+  /**
+   * Assignment and copy operators.  An balance may be assigned or copied.
+   */
+  balance_t(const balance_t& bal) : amounts(bal.amounts) {
+    TRACE_CTOR(balance_t, "copy");
+  }
+
+  balance_t& operator=(const balance_t& bal) {
+    if (this != &bal)
+      amounts = bal.amounts;
+    return *this;
+  }
+  balance_t& operator=(const amount_t& amt) {
+    if (amt.is_null())
+      throw_(balance_error,
+	     "Cannot assign an uninitialized amount to a balance");
+
+    amounts.clear();
+    if (! amt.is_realzero())
+      amounts.insert(amounts_map::value_type(&amt.commodity(), amt));
+
+    return *this;
+  }
+
+  balance_t& operator=(const string& str) {
+    return *this = balance_t(str);
+  }
+  balance_t& operator=(const char * str) {
+    return *this = balance_t(str);
+  }
+
+  /**
+   * Comparison operators.  Balances are fairly restrictive in terms
+   * of how they may be compared.  They may be compared for equality
+   * or inequality, but this is all, since the concept of "less than"
+   * or "greater than" makes no sense when amounts of multiple
+   * commodities are involved.
+   *
+   * Balances may also be compared to amounts, in which case the sum
+   * of the balance must equal the amount exactly.
+   *
+   * If a comparison between balances is desired, the balances must
+   * first be rendered to value equivalent amounts using the `value'
+   * method, to determine a market valuation at some specific moment
+   * in time.
+   */
+  bool operator==(const balance_t& bal) const {
+    amounts_map::const_iterator i, j;
+    for (i = amounts.begin(), j = bal.amounts.begin();
+	 i != amounts.end() && j != bal.amounts.end();
+	 i++, j++) {
+      if (! (i->first == j->first && i->second == j->second))
+	return false;
+    }
+    return i == amounts.end() && j == bal.amounts.end();
+  }
+  bool operator==(const amount_t& amt) const {
+    if (amt.is_null())
+      throw_(balance_error,
+	     "Cannot compare a balance to an uninitialized amount");
+
+    if (amt.is_realzero())
+      return amounts.empty();
+    else
+      return amounts.size() == 1 && amounts.begin()->second == amt;
+  }
+
+  template <typename T>
+  bool operator==(const T& val) const {
+    return *this == balance_t(val);
+  }
+
+  /**
+   * Binary arithmetic operators.  Balances support addition and
+   * subtraction of other balances or amounts, but multiplication and
+   * division are restricted to uncommoditized amounts only.
+   */
+  balance_t& operator+=(const balance_t& bal);
+  balance_t& operator+=(const amount_t& amt);
+  balance_t& operator-=(const balance_t& bal);
+  balance_t& operator-=(const amount_t& amt);
+
+  balance_t& operator*=(const amount_t& amt);
+  balance_t& operator*=(const double val) {
+    return *this *= amount_t(val);
+  }
+  balance_t& operator*=(const unsigned long val) {
+    return *this *= amount_t(val);
+  }
+  balance_t& operator*=(const long val) {
+    return *this *= amount_t(val);
+  }
+
+  balance_t& operator/=(const amount_t& amt);
+  balance_t& operator/=(const double val) {
+    return *this /= amount_t(val);
+  }
+  balance_t& operator/=(const unsigned long val) {
+    return *this /= amount_t(val);
+  }
+  balance_t& operator/=(const long val) {
+    return *this /= amount_t(val);
+  }
+
+  /**
+   * Unary arithmetic operators.  There are only a few unary methods
+   * support on balance:
+   *
+   * negate(), also unary minus (- x), returns a balance all of whose
+   * component amounts have been negated.  In order words, it inverts
+   * the sign of all member amounts.
+   *
+   * abs() returns a balance where no component amount is negative.
+   *
+   * reduce() reduces the values in a balance to their most basic
+   * commodity forms, for amounts that utilize "scaling commodities".
+   * For example, a balance of 1h and 1m after reduction will be
+   * 3660s.
+   *
+   * unreduce(), if used with amounts that use "scaling commodities",
+   * yields the most compact form greater than 1.0 for each component
+   * amount.  That is, a balance of 10m and 1799s will unreduce to
+   * 39.98m.
+   *
+   * value(optional<moment_t>) returns the total historical value for
+   * a balance -- the default moment returns a value based on the most
+   * recently known price -- based on the price history of its
+   * component commodities.  See amount_t::value for an example.
+   *
+   * Further, for the sake of efficiency and avoiding temporary
+   * objects, the following methods support "in-place" variants act on
+   * the balance itself and return a reference to the result
+   * (`*this'):
+   *
+   * in_place_negate()
+   * in_place_reduce()
+   * in_place_unreduce()
+   */
+  balance_t negate() const {
+    balance_t temp(*this);
+    temp.in_place_negate();
+    return temp;
+  }
+  balance_t& in_place_negate() {
+    for (amounts_map::iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      i->second.in_place_negate();
+    return *this;
+  }
+  balance_t operator-() const {
+    return negate();
+  }
+
+  balance_t abs() const {
+    balance_t temp;
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      temp += i->second.abs();
+    return temp;
+  }
+
+  balance_t reduce() const {
+    balance_t temp(*this);
+    temp.in_place_reduce();
+    return temp;
+  }
+  balance_t& in_place_reduce() {
+    balance_t temp;
+    // A temporary must be used here because reduction may cause
+    // multiple component amounts to collapse to the same commodity.
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      temp += i->second.reduce();
+    return *this = temp;
+  }
+
+  balance_t unreduce() const {
+    balance_t temp(*this);
+    temp.in_place_unreduce();
+    return temp;
+  }
+  balance_t& in_place_unreduce() {
+    balance_t temp;
+    // A temporary must be used here because unreduction may cause
+    // multiple component amounts to collapse to the same commodity.
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      temp += i->second.unreduce();
+    return *this = temp;
+  }
+
+  optional<balance_t> value(const optional<moment_t>& moment = none) const;
+
+  /**
+   * Truth tests.  An balance may be truth test in two ways:
+   *
+   * is_nonzero(), or operator bool, returns true if a balance's
+   * display value is not zero.
+   *
+   * is_zero() returns true if an balance's display value is zero.
+   * Thus, a balance containing $0.0001 is considered zero if the
+   * current display precision for dollars is two decimal places.
+   *
+   * is_realzero() returns true if an balance's actual value is zero.
+   * Thus, a balance containing $0.0001 is never considered realzero.
+   *
+   * is_empty() returns true if a balance has no amounts within it.
+   * This can occur after a balance has been default initialized, or
+   * if the exact amount it contains is subsequently subtracted from
+   * it.
+   */
+  operator bool() const {
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      if (i->second.is_nonzero())
+	return true;
+    return false;
+  }
+
+  bool is_zero() const {
+    if (is_empty())
+      return true;
+
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      if (! i->second.is_zero())
+	return false;
+    return true;
+  }
+
+  bool is_realzero() const {
+    if (is_empty())
+      return true;
+
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      if (! i->second.is_realzero())
+	return false;
+    return true;
+  }
+
+  bool is_empty() const {
+    return amounts.size() == 0;
+  }
+
+  /**
+   * Conversion methods.  A balance can be converted to an amount, but
+   * only if contains a single component amount.
+   */
+  amount_t to_amount() const {
+    if (is_empty())
+      throw_(balance_error, "Cannot convert an empty balance to an amount");
+    else if (amounts.size() == 1)
+      return amounts.begin()->second;
+    else
+      throw_(balance_error,
+	     "Cannot convert a balance with multiple commodities to an amount");
+  }
+
+  /**
+   * Commodity-related methods.  Balances support two
+   * commodity-related methods:
+   *
+   * commodity_count() returns the number of different commodities
+   * stored in the balance.
+   *
+   * commodity_amount(optional<commodity_t>) returns an (optional)
+   * amount for the given commodity within the balance; if no
+   * commodity is specified, it returns the (optional) uncommoditized
+   * component of the balance.  If no matching element can be found,
+   * boost::none is returned.
+   */
+  std::size_t commodity_count() const {
+    return amounts.size();
+  }
+
+  optional<amount_t>
+  commodity_amount(const optional<const commodity_t&>& commodity = none) const;
+
+  /**
+   * Annotated commodity methods.  The amounts contained by a balance
+   * may use annotated commodities.  The `strip_annotations' method
+   * will return a balance all of whose component amount have had
+   * their commodity annotations likewise stripped.  See
+   * amount_t::strip_annotations for more details.
+   */
+  balance_t
+  strip_annotations(const bool keep_price = amount_t::keep_price,
+		    const bool keep_date  = amount_t::keep_date,
+		    const bool keep_tag   = amount_t::keep_tag) const;
+
+  /**
+   * Printing methods.  A balance may be output to a stream using the
+   * `print' method.  There is also a global operator<< defined which
+   * simply calls print for a balance on the given stream.  There is
+   * one form of the print method, which takes two required arguments
+   * and one arguments with a default value:
+   *
+   * print(ostream, int first_width, int latter_width) prints a
+   * balance to the given output stream, using each commodity's
+   * default display characteristics.  The first_width parameter
+   * specifies the width that should be used for printing amounts
+   * (since they are likely to vary in width).  The latter_width, if
+   * specified, gives the width to be used for each line after the
+   * first.  This is useful when printing in a column which falls at
+   * the right-hand side of the screen.
+   *
+   * In addition to the width constraints, balances will also print
+   * with commodities in alphabetized order, regardless of the
+   * relative amounts of those commodities.  There is no option to
+   * change this behavior.
+   */
+  void print(std::ostream& out, const int first_width,
+	     const int latter_width = -1) const;
+
+  /**
+   * Debugging methods.  There are two methods defined to help with
+   * debugging:
+   *
+   * dump(ostream) dumps a balance to an output stream.  There is
+   * little different from print(), it simply surrounds the display
+   * value with a marker, for example "BALANCE($1.00, DM 12.00)".
+   * This code is used by other dumping code elsewhere in Ledger.
+   *
+   * valid() returns true if the amounts within the balance are valid.
+   */
+  void dump(std::ostream& out) const {
+    out << "BALANCE(";
+    bool first = true;
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++) {
+      if (first)
+	first = false;
+      else
+	out << ", ";
+      i->second.print(out);
+    }
+    out << ")";
+  }
+
+  bool valid() const {
+    for (amounts_map::const_iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      if (! i->second.valid())
+	return false;
+    return true;
+  }
+};
+
+inline std::ostream& operator<<(std::ostream& out, const balance_t& bal) {
+  bal.print(out, 12);
+  return out;
+}
+
+} // namespace ledger
+
+#endif // _BALANCE_H
diff --git a/src/numerics/balpair.h b/src/numerics/balpair.h
new file mode 100644
index 00000000..13e4857b
--- /dev/null
+++ b/src/numerics/balpair.h
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 2003-2007, John Wiegley.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of New Artisans LLC nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file   balpair.h
+ * @author John Wiegley
+ * @date   Sun May 20 19:11:58 2007
+ * 
+ * @brief  Provides an abstraction around balance_t for tracking costs.
+ * 
+ * When a transaction's amount is added to a balance, only the "value"
+ * of the amount is added -- not the associated cost of the
+ * transaction.  To provide for this, the balance_pair_t type allows
+ * for adding amounts and costs simultaneously to a single balance.
+ * Both are tracked, and any time either the total amount balance or
+ * the total cost balance may be extracted.
+ *
+ * Note: By default, all balance-like operations operate on the amount
+ * balance, and not the cost.  Also, the cost is entirely optional, in
+ * which case a balance_pair_t may be used as if it were a balance_t,
+ * from which is it derived.
+ */
+#ifndef _BALPAIR_H
+#define _BARPAIR_H
+
+#include "balance.h"
+
+namespace ledger {
+
+class balance_pair_t
+  : public equality_comparable<balance_pair_t,
+           equality_comparable<balance_pair_t, balance_t,
+           equality_comparable<balance_pair_t, amount_t,
+           equality_comparable<balance_pair_t, double,
+           equality_comparable<balance_pair_t, unsigned long,
+           equality_comparable<balance_pair_t, long,
+           additive<balance_pair_t,
+           additive<balance_pair_t, balance_t,
+           additive<balance_pair_t, amount_t,
+           additive<balance_pair_t, double,
+           additive<balance_pair_t, unsigned long,
+           additive<balance_pair_t, long,
+           multiplicative<balance_pair_t, amount_t,
+           multiplicative<balance_pair_t, balance_t,
+           multiplicative<balance_pair_t, double,
+           multiplicative<balance_pair_t, unsigned long,
+           multiplicative2<balance_pair_t, long, balance_t
+			   > > > > > > > > > > > > > > > > >
+{
+  /**
+   * The `cost' member of a balance pair tracks the cost associated
+   * with each transaction amount that is added.  This member is
+   * optional, and if not cost-bearing transactions are added, it will
+   * remain uninitialized.
+   */
+  optional<balance_t> cost;
+
+  /**
+   * The `quantity' method provides direct access to the balance_t
+   * base-class part of the balance pair.
+   */
+  balance_t& quantity() {
+    return *this;
+  }
+  const balance_t& quantity() const {
+    return *this;
+  }
+
+  friend class value_t;
+  friend class entry_base_t;
+
+public:
+  /**
+   * Constructors.  balance_pair_t supports identical forms of construction
+   * to balance_t.  See balance_t for more information.
+   */
+  balance_pair_t() {
+    TRACE_CTOR(balance_pair_t, "");
+  }
+  balance_pair_t(const balance_t& bal) : balance_t(bal) {
+    TRACE_CTOR(balance_pair_t, "const balance_t&");
+  }
+  balance_pair_t(const amount_t& amt) : balance_t(amt) {
+    TRACE_CTOR(balance_pair_t, "const amount_t&");
+  }
+  balance_pair_t(const double val) : balance_t(val) {
+    TRACE_CTOR(balance_pair_t, "const double");
+  }
+  balance_pair_t(const unsigned long val) : balance_t(val) {
+    TRACE_CTOR(balance_pair_t, "const unsigned long");
+  }
+  balance_pair_t(const long val) : balance_t(val) {
+    TRACE_CTOR(balance_pair_t, "const long");
+  }
+
+  explicit balance_pair_t(const string& val) : balance_t(val) {
+    TRACE_CTOR(balance_pair_t, "const string&");
+  }
+  explicit balance_pair_t(const char * val) : balance_t(val) {
+    TRACE_CTOR(balance_pair_t, "const char *");
+  }
+
+  /**
+   * Destructor.
+   */
+  virtual ~balance_pair_t() {
+    TRACE_DTOR(balance_pair_t);
+  }
+
+  /**
+   * Assignment and copy operators.  A balance pair may be assigned or
+   * copied, and assigned or copied from a balance.
+   */
+  balance_pair_t(const balance_pair_t& bal_pair)
+    : balance_t(bal_pair), cost(bal_pair.cost) {
+    TRACE_CTOR(balance_pair_t, "copy");
+  }
+
+  balance_pair_t& operator=(const balance_pair_t& bal_pair) {
+    if (this != &bal_pair) {
+      balance_t::operator=(bal_pair.quantity());
+      cost = bal_pair.cost;
+    }
+    return *this;
+  }
+  balance_pair_t& operator=(const balance_t& bal) {
+    balance_t::operator=(bal);
+    return *this;
+  }
+  balance_pair_t& operator=(const amount_t& amt) {
+    balance_t::operator=(amt);
+    return *this;
+  }
+
+  balance_t& operator=(const string& str) {
+    return *this = balance_t(str);
+  }
+  balance_t& operator=(const char * str) {
+    return *this = balance_t(str);
+  }
+
+  /**
+   * Binary arithmetic operators.  Balances support addition and
+   * subtraction of other balance pairs, balances or amounts, but
+   * multiplication and division are restricted to uncommoditized
+   * amounts only.
+   */
+  balance_pair_t& operator+=(const balance_pair_t& bal_pair) {
+    balance_t::operator+=(bal_pair);
+    if (bal_pair.cost) {
+      if (! cost)
+	*cost = quantity();
+      *cost += *bal_pair.cost;
+    }
+    return *this;
+  }
+  balance_pair_t& operator-=(const balance_pair_t& bal_pair) {
+    balance_t::operator+=(bal_pair);
+    if (bal_pair.cost) {
+      if (! cost)
+	*cost = quantity();
+      *cost += *bal_pair.cost;
+    }
+    return *this;
+  }
+
+  balance_pair_t& operator*=(const amount_t& amt) {
+    balance_t::operator*=(amt);
+    if (cost)
+      *cost *= amt;
+    return *this;
+  }
+  balance_pair_t& operator*=(const double val) {
+    return *this *= amount_t(val);
+  }
+  balance_pair_t& operator*=(const unsigned long val) {
+    return *this *= amount_t(val);
+  }
+  balance_pair_t& operator*=(const long val) {
+    return *this *= amount_t(val);
+  }
+  balance_pair_t& operator/=(const amount_t& amt) {
+    balance_t::operator/=(amt);
+    if (cost)
+      *cost /= amt;
+    return *this;
+  }
+
+  // comparison
+  bool operator==(const balance_pair_t& bal_pair) const {
+    return quantity == bal_pair.quantity;
+  }
+  bool operator==(const balance_t& bal) const {
+    return quantity == bal;
+  }
+  bool operator==(const amount_t& amt) const {
+    return quantity == amt;
+  }
+
+  balance_pair_t& operator*=(const amount_t& amt) {
+    quantity *= amt;
+    if (cost)
+      *cost *= amt;
+    return *this;
+  }
+  balance_pair_t& operator/=(const amount_t& amt) {
+    quantity /= amt;
+    if (cost)
+      *cost /= amt;
+    return *this;
+  }
+
+  // unary negation
+  void in_place_negate() {
+    quantity.in_place_negate();
+    if (cost)
+      cost->in_place_negate();
+  }
+  balance_pair_t negate() const {
+    balance_pair_t temp = *this;
+    temp.in_place_negate();
+    return temp;
+  }
+  balance_pair_t operator-() const {
+    return negate();
+  }
+
+  // test for non-zero (use ! for zero)
+  operator bool() const {
+    return quantity;
+  }
+
+  bool is_realzero() const {
+    return ((! cost || cost->is_realzero()) && quantity.is_realzero());
+  }
+
+  balance_pair_t abs() const {
+    balance_pair_t temp = *this;
+    temp.quantity = temp.quantity.abs();
+    if (temp.cost)
+      temp.cost = temp.cost->abs();
+    return temp;
+  }
+
+  optional<amount_t>
+  commodity_amount(const optional<const commodity_t&>& commodity = none) const {
+    return quantity.commodity_amount(commodity);
+  }
+  optional<balance_t> value(const optional<moment_t>& moment = none) const {
+    return quantity.value(moment);
+  }
+
+  balance_t
+  strip_annotations(const bool keep_price = amount_t::keep_price,
+		    const bool keep_date  = amount_t::keep_date,
+		    const bool keep_tag   = amount_t::keep_tag) const {
+    return quantity.strip_annotations(keep_price, keep_date, keep_tag);
+  }
+
+  void print(std::ostream& out, const int first_width,
+	     const int latter_width = -1) const {
+    quantity.print(out, first_width, latter_width);
+  }
+
+  balance_pair_t& add(const amount_t&  amt,
+		      const optional<amount_t>& a_cost = none) {
+    if (a_cost && ! cost)
+      cost = quantity;
+    quantity += amt;
+    if (cost)
+      *cost += a_cost ? *a_cost : amt;
+    return *this;
+  }
+
+  bool valid() {
+    return quantity.valid() && (! cost || cost->valid());
+  }
+
+  void in_place_reduce() {
+    quantity.in_place_reduce();
+    if (cost) cost->in_place_reduce();
+  }
+  balance_pair_t reduce() const {
+    balance_pair_t temp(*this);
+    temp.in_place_reduce();
+    return temp;
+  }
+
+  friend std::ostream& operator<<(std::ostream& out,
+				  const balance_pair_t& bal_pair);
+};
+
+inline std::ostream& operator<<(std::ostream& out,
+				const balance_pair_t& bal_pair) {
+  bal_pair.quantity.print(out, 12);
+  return out;
+}
+
+} // namespace ledger
+
+#endif // _BALPAIR_H