[Boost-commit] svn:boost r77651 - in sandbox/big_number/libs/multiprecision/doc: . html

Subject: [Boost-commit] svn:boost r77651 - in sandbox/big_number/libs/multiprecision/doc: . html
From: john_at_[hidden]
Date: 2012-03-30 14:33:27

Author: johnmaddock
Date: 2012-03-30 14:33:27 EDT (Fri, 30 Mar 2012)
New Revision: 77651
URL: http://svn.boost.org/trac/boost/changeset/77651

Log:
Documentation update, temporarily remove the HTML docs.
Added:
   sandbox/big_number/libs/multiprecision/doc/index.idx   (contents, props changed)
Removed:
   sandbox/big_number/libs/multiprecision/doc/html/
Text files modified: 
   sandbox/big_number/libs/multiprecision/doc/Jamfile.v2         |    10 +                                       
   sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk |   360 ++++++++++++++++++++++++++++++++++++--- 
   2 files changed, 342 insertions(+), 28 deletions(-)

Modified: sandbox/big_number/libs/multiprecision/doc/Jamfile.v2
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/Jamfile.v2	(original)
+++ sandbox/big_number/libs/multiprecision/doc/Jamfile.v2	2012-03-30 14:33:27 EDT (Fri, 30 Mar 2012)
@@ -4,8 +4,10 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 using quickbook ;
+using auto-index ;
 
 path-constant images_location : html ;
+path-constant here : . ;
 
 xml big_number : multiprecision.qbk ;
 boostbook standalone
@@ -62,6 +64,14 @@
         <format>pdf:<xsl:param>img.src.path=$(images_location)/
         <format>pdf:<xsl:param>draft.mode="no"
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/math/doc/sf_and_dist/html
+        # Index generation:
+        <auto-index>on
+        <auto-index-script>$(here)/index.idx
+        <auto-index-prefix>$(here)/../../.. 
+        <auto-index-verbose>on
+        <format>html:<auto-index-internal>on
+        <quickbook-define>enable_index 
+        <format>pdf:<xsl:param>index.on.type=1
     ;
 
 install pdf-install : standalone : <location>. <install-type>PDF ;

Added: sandbox/big_number/libs/multiprecision/doc/index.idx
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/doc/index.idx	2012-03-30 14:33:27 EDT (Fri, 30 Mar 2012)
@@ -0,0 +1,11 @@
+
+!scan-path boost/multiprecision .*\.hpp true
+
+
+
+
+
+
+
+
+

Modified: sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk	(original)
+++ sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk	2012-03-30 14:33:27 EDT (Fri, 30 Mar 2012)
@@ -204,7 +204,7 @@
 one would hope.
 
 Finally, note that `mp_number` takes a second template argument, which, when set to `false` disables all
-the expression template machinary.  The result is much faster to compile, but slower at runtime.
+the expression template machinery.  The result is much faster to compile, but slower at runtime.
 
 We'll conclude this section by providing some more performance comparisons between these three libraries,
 again, all are using [mpfr] to carry out the underlying arithmetic, and all are operating at the same precision
@@ -238,12 +238,14 @@
 [table
 [[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
 [[`cpp_int`][boost/multiprecision/cpp_int.hpp][2][None]
-            [Very versatile, Boost licenced, all C++ integer type which support both [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] and fixed precision integer types.][Slower than [gmp], though typically not as slow as [tommath]]]
-[[`gmp_int`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licenced [gmp] library.]]
+            [Very versatile, Boost licensed, all C++ integer type which support both [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] and fixed precision integer types.][Slower than [gmp], though typically not as slow as [tommath]]]
+[[`gmp_int`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
 [[`tom_int`][boost/multiprecision/tommath.hpp][2][[tommath]][Public domain back-end with no licence restrictions.][Slower than [gmp].]]
 ]
 
-[h4 cpp_int]
+[section:cpp_int cpp_int]
+
+`#include <boost/multiprecision/cpp_int.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -290,7 +292,7 @@
 [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] types
           (where the Allocator parameter is non-void), then this parameter must be `true`.  For fixed precision
           types then this type may be either `true` (type is signed), or `false` (type is unsigned).]]
-[[Allocator][The allocator to use for dymamic memory allocation, or type `void` if this is to be a fixed precision type.]]
+[[Allocator][The allocator to use for dynamic memory allocation, or type `void` if this is to be a fixed precision type.]]
 ]
 
 Things you should know when using this type:
@@ -317,7 +319,11 @@
 
 [cpp_int_eg]
 
-[h4 gmp_int]
+[endsect]
+
+[section:gmp_int gmp_int]
+
+`#include <boost/multiprecision/gmp.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -347,13 +353,17 @@
 `std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown.
 * Division by zero is handled by the [gmp] library - it will trigger a division by zero signal.
 * Although this type is a wrapper around [gmp] it will work equally well with [mpir].  Indeed use of [mpir]
-is recomended on Win32.
+is recommended on Win32.
 
 [h5 Example:]
 
 [mpz_eg]
 
-[h4 tom_int]
+[endsect]
+
+[section:tom_int tom_int]
+
+`#include <boost/multiprecision/tommath.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -384,18 +394,22 @@
 
 [endsect]
 
-[section:reals Floating Point Numbers]
+[endsect]
+
+[section:floats Floating Point Numbers]
 
 The following back-ends provide floating point arithmetic:
 
 [table
 [[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
-[[`mpf_float<N>`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licenced [gmp] library.]]
-[[`mpfr_float<N>`][boost/multiprecision/mpfr.hpp][2][[gmp] and [mpfr]][Very fast and efficient back-end, with its own standard library implementation.][Dependency on GNU licenced [gmp] and [mpfr] libraries.]]
+[[`mpf_float<N>`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
+[[`mpfr_float<N>`][boost/multiprecision/mpfr.hpp][2][[gmp] and [mpfr]][Very fast and efficient back-end, with its own standard library implementation.][Dependency on GNU licensed [gmp] and [mpfr] libraries.]]
 [[`cpp_dec_float<N>`][boost/multiprecision/cpp_dec_float.hpp][10][None][Header only, all C++ implementation. Boost licence.][Approximately 2x slower than the [mpfr] or [gmp] libraries.]]
 ]
 
-[h4 gmp_float]
+[section:gmp_float gmp_float]
+
+`#include <boost/multiprecision/gmp.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -449,7 +463,11 @@
 
 [mpf_eg]
 
-[h4 mpfr_float]
+[endsect]
+
+[section:mpfr_float mpfr_float]
+
+`#include <boost/multiprecision/mpfr_float.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -491,13 +509,17 @@
 * All operations use round to nearest.
 * No changes are made to [gmp] or [mpfr] global settings, so this type can coexist with existing
 [mpfr] or [gmp] code.
-* The code can equally use [mpir] in place of [gmp] - indeed that is the prefered option on Win32.
+* The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
 
 [h5 [mpfr] example:]
 
 [mpfr_eg]
 
-[h4 cpp_dec_float]
+[endsect]
+
+[section:cpp_dec_float cpp_dec_float]
+
+`#include <boost/multiprecision/cpp_dec_float.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -534,20 +556,24 @@
 
 [endsect]
 
+[endsect]
+
 [section:rational Rational Number Types]
 
 The following back-ends provide rational number arithmetic:
 
 [table
 [[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
-[[`gmp_rational`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licenced [gmp] library.]]
-[[`cpp_rational`][boost/multiprecision/cpp_int.hpp][2][None][An all C++ Boost-licenced implementation.][Slower than [gmp].]]
+[[`gmp_rational`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
+[[`cpp_rational`][boost/multiprecision/cpp_int.hpp][2][None][An all C++ Boost-licensed implementation.][Slower than [gmp].]]
 [[`tommath_rational`][boost/multiprecision/tommath.hpp][2][[tommath]][All C/C++ implementation that's Boost Software Licence compatible.][Slower than [gmp].]]
 [[`rational_adapter`][boost/multiprecision/rational_adapter.hpp][N/A][none][All C++ adapter that allows any inetger back-end type to be used as a rational type.][Requires an underlying integer back-end type.]]
 [[`boost::rational`][boost/rational.hpp][N/A][None][A C++ rational number type that can used with any `mp_number` integer type.][The expression templates used by `mp_number` end up being "hidden" inside `boost::rational`: performance may well suffer as a result.]]
 ]
 
-[h4 gmp_rational]
+[section:gmp_rational gmp_rational]
+
+`#include <boost/multiprecision/gmp.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -583,13 +609,17 @@
 * Division by zero results in a hardware exception inside the [gmp] library.
 * No changes are made to the [gmp] library's global settings, so this type can coexist with existing
 [gmp] code.
-* The code can equally be used with [mpir] as the underlying library - indeed that is the prefered option on Win32.
+* The code can equally be used with [mpir] as the underlying library - indeed that is the preferred option on Win32.
 
 [h5 Example:]
 
 [mpq_eg]
 
-[h4 cpp_rational]
+[endsect]
+
+[section:cpp_rational cpp_rational]
+
+`#include <boost/multiprecision/cpp_int.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -623,7 +653,11 @@
 
 [cpp_rational_eg]
 
-[h4 tommath_rational]
+[endsect]
+
+[section:tommath_rational tommath_rational]
+
+`#include <boost/multiprecision/tommath.hpp>`
 
    namespace boost{ namespace multiprecision{
 
@@ -658,13 +692,17 @@
 
 [mp_rat_eg]
 
-[h4 Use With Boost.Rational]
+[endsect]
+
+[section:br Use With Boost.Rational]
 
 All of the integer types in this library can be used as template arguments to `boost::rational<IntType>`.
 
 Note that using the library in this way largely negates the effect of the expression templates in `mp_number`.
 
-[h4 rational_adapter]
+[endsect]
+
+[section:rational_adapter rational_adapter]
 
    namespace boost{ namespace multiprecision{
 
@@ -686,6 +724,72 @@
    MyInt i = numerator(r);
    assert(i == 2);
 
+[endsect]
+
+[endsect]
+
+[section:conversions Constructing and Interconverting Between Number Types]
+
+All of the number types that are based on `mp_number` have certain conversion rules in common.
+In particular:
+
+* Any number type can be constructed (or assigned) from any builtin arithmetic type:
+
+   cpp_dec_float_50 df(0.5); // OK construction from double
+   cpp_int          i(450);  // OK constructs from signed int
+
+* Any number type can be constructed (or assigned) from a `const char*` or a `std::string`:
+
+   // pi to 50 places from a string:
+   cpp_dec_float_50 df = "3.14159265358979323846264338327950288419716939937510";
+   // Integer type will automatically detect "0x" and "0" prefixes and parse the string accordingly:
+   cpp_int          i  = "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000";
+   // Invalid input always results in a std::runtime_error being thrown:
+   i = std::string("3.14");
+
+* Any number type will interoperate with the builtin type in arithmetic expressions:
+
+   // pi to 50 places from a string:
+   cpp_dec_float_50 df = "3.14159265358979323846264338327950288419716939937510";
+   // Multiply by 2 - using an integer literal here is usually more efficient
+   // than constructing a temporary:
+   df *= 2;
+
+   // There is a need to be careful with integer types though:
+   cpp_int i = 2;
+   // Ooops, this really just multiplies by 3:
+   i *= 3.14;
+
+* Any number type can be streamed to and from the C++ iostreams:
+   
+
+   cpp_dec_float_50 df = "3.14159265358979323846264338327950288419716939937510";
+   // Now print at full precision:
+   std::cout << std::setprecision(std::numeric_limits<cpp_dec_float_50>::max_digits10)
+      << df << std::endl
+   cpp_int i = 1;
+   i <<= 256;
+   // Now print in hex format with prefix:
+   std::cout << std::hex << std::showbase << i << std::endl;
+
+* Some intercomnversions between number types are completely generic, and are always available:
+
+   cpp_int cppi(2);
+   // We can always convert between numbers of the same category - 
+   // int to int, rational to rational, or float to float, so this is OK:
+   mpz_int z = cppi;
+   // We can always promote from int to rational, int to float, or rational to float:
+   cpp_rational     cppr = cppi;  // OK, int to rational
+   cpp_dec_float_50 df =   cppi;  // OK, int to float
+   df                  =   cppr;  // OK, rational to float
+   // However narrowing conversions always fail:
+   cppi                =   df;    // Compiler error, conversion not allowed
+
+* Other interconversions may be allowed as special cases, whenever the backend allows it:
+
+   mpf_t     m;           // Native GMP type.
+   mpf_init_set_ui(m, 0); // set to a value;
+   mpf_float i(m);        // copies the value of the native type.
 
 [endsect]
 
@@ -933,7 +1037,7 @@
 
 [variablelist
 [[Backend][The actual arithmetic back-end that does all the work.]]
-[[ExpressionTemplates][A boolean value: when true, then expression templates are enabled, otherwise they are disabled.]]
+[[ExpressionTemplates][A Boolean value: when true, then expression templates are enabled, otherwise they are disabled.]]
 ]
 
    mp_number();
@@ -1248,6 +1352,172 @@
 
 [endsect]
 
+[section:cpp_int_ref cpp_int]
+
+   namespace boost{ namespace multiprecision{
+
+   template <unsigned MinBits = 0, bool Signed = true, class Allocator = std::allocator<limb_type> >
+   struct cpp_int_backend;
+
+   typedef mp_number<cpp_int_backend<> >           cpp_int;    // arbitrary precision integer
+   typedef rational_adapter<cpp_int_backend<> >    cpp_rational_backend;
+   typedef mp_number<cpp_rational_backend>         cpp_rational; // arbitrary precision rational number
+
+   // Fixed precision unsigned types:
+   typedef mp_number<cpp_int_backend<128, false, void>, false>   mp_uint128_t;
+   typedef mp_number<cpp_int_backend<256, false, void>, false>   mp_uint256_t;
+   typedef mp_number<cpp_int_backend<512, false, void>, false>   mp_uint512_t;
+   typedef mp_number<cpp_int_backend<1024, false, void>, false>  mp_uint1024_t;
+
+   // Fixed precision signed types:
+   typedef mp_number<cpp_int_backend<128, true, void>, false>    mp_int128_t;
+   typedef mp_number<cpp_int_backend<256, true, void>, false>    mp_int256_t;
+   typedef mp_number<cpp_int_backend<512, true, void>, false>    mp_int512_t;
+   typedef mp_number<cpp_int_backend<1024, true, void>, false>   mp_int1024_t;
+
+   }} // namespaces
+
+Class template `cpp_int_backend` fulfills all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.  
+It's members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
+to change.
+
+The template arguments are:
+
+[variablelist
+[[Argument][Meaning]]
+[[MinBits]
+   [The number of Bits to reserve inside the class's internal cache.  When constructing a value,
+    the object will use this internal cache if possible before resorting to dynamic memory allocation.
+    When this value is zero, then the size of the internal cache is `2*sizeof(void*)*CHAR_BIT`.
+    When the Allocator argument is `void`, then this parameter determines the precision of the type.]]
+[[Signed][When `true` the type is signed, otherwise unsigned.  Note that unsigned types are currently only 
+      supported when the Allocator parameter is `void`.]]
+[[Allocator][The allocator used for dynamic memory allocation.  This parameter can be `void`, in which case
+      no dymanic memory will ever be allocated.]]
+]
+
+More information on this type can be found in the [link boost_multiprecision.tut.ints.cpp_int tutorial].
+
+[endsect]
+
+[section:gmp_int_ref gmp_int]
+
+   namespace boost{ namespace multiprecision{
+
+   class gmp_int;
+
+   typedef mp_number<gmp_int >         mpz_int;
+
+   }} // namespaces
+
+Class template `gmp_int` fulfills all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.  
+It's members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
+to change.
+
+More information on this type can be found in the [link boost_multiprecision.tut.ints.gmp_int tutorial].
+
+[endsect]
+
+[section:tom_int_ref tom_int]
+
+   namespace boost{ namespace multiprecision{
+
+   class tommath_int;
+
+   typedef mp_number<tommath_int >         tom_int;
+
+   }} // namespaces
+
+Class template `tommath_int` fulfills all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.  
+It's members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
+to change.
+
+More information on this type can be found in the [link boost_multiprecision.tut.ints.tom_int tutorial].
+
+[endsect]
+
+[section:mpf_ref gmp_float]
+
+   namespace boost{ namespace multiprecision{
+
+   template <unsigned Digits10>
+   class gmp_float;
+
+   typedef mp_number<gmp_float<50> >    mpf_float_50;
+   typedef mp_number<gmp_float<100> >   mpf_float_100;
+   typedef mp_number<gmp_float<500> >   mpf_float_500;
+   typedef mp_number<gmp_float<1000> >  mpf_float_1000;
+   typedef mp_number<gmp_float<0> >     mpf_float;
+
+   }} // namespaces
+
+Class template `gmp_float` fulfills all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.  
+It's members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
+to change.
+
+The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
+should support.  When this parameter is zero, then the precision can be set at runtime via `mp_number::default_precision`
+and `mp_number::precision`.  Note that this type does not in any way change the GMP library's global state (for example
+it does not change the default precision of the mpf_t data type), therefore you can safely mix this type with existing
+code that uses GMP, and also mix `gmp_float`s of differing precision.
+
+More information on this type can be found in the [link boost_multiprecision.tut.floats.gmp_float tutorial].
+
+[endsect]
+
+[section:mpfr_ref mpfr_float_backend]
+
+   namespace boost{ namespace multiprecision{
+
+   template <unsigned Digits10>
+   class mpfr_float_backend;
+
+   typedef mp_number<mpfr_float_backend<50> >    mpfr_float_50;
+   typedef mp_number<mpfr_float_backend<100> >   mpfr_float_100;
+   typedef mp_number<mpfr_float_backend<500> >   mpfr_float_500;
+   typedef mp_number<mpfr_float_backend<1000> >  mpfr_float_1000;
+   typedef mp_number<mpfr_float_backend<0> >     mpfr_float;
+
+   }} // namespaces
+
+Class template `mpfr_float_backend` fulfills all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.  
+It's members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
+to change.
+
+The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
+should support.  When this parameter is zero, then the precision can be set at runtime via `mp_number::default_precision`
+and `mp_number::precision`.  Note that this type does not in any way change the GMP or MPFR library's global state (for example
+it does not change the default precision of the mpfr_t data type), therefore you can safely mix this type with existing
+code that uses GMP or MPFR, and also mix `mpfr_float_backend`s of differing precision.
+
+More information on this type can be found in the [link boost_multiprecision.tut.floats.mpfr_float tutorial].
+
+[endsect]
+
+[section:cpp_dec_ref cpp_dec_float]
+
+   namespace boost{ namespace multiprecision{
+
+   template <unsigned Digits10>
+   class cpp_dec_float;
+
+   typedef mp_number<cpp_dec_float<50> > cpp_dec_float_50;
+   typedef mp_number<cpp_dec_float<100> > cpp_dec_float_100;
+
+   }} // namespaces
+
+Class template `cpp_dec_float` fulfills all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.  
+It's members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
+to change.
+
+The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
+should support.  Note that this type does not ever perform any dynamic memory allocation, as a result the `Digits10`
+template argument should not be set too high or the classes size will grow unreasonably large.
+
+More information on this type can be found in the [link boost_multiprecision.tut.floats.cpp_dec_float tutorial].
+
+[endsect]
+
 [section:backendconc Backend Requirements]
 
 [template super[x]'''<superscript>'''[x]'''</superscript>''']
@@ -1414,7 +1684,7 @@
 
 [note
 The non-member functions are all named with an "eval_" prefix to avoid conflicts with template classes of the same name - 
-in point of fact this naming convension shouldn't be necessary, but rather works around some compiler bugs.]
+in point of fact this naming convention shouldn't be necessary, but rather works around some compiler bugs.]
 
 [endsect]
 
@@ -1490,7 +1760,7 @@
 
 Note that these tests are carefully designed to test performance of the underlying algorithms
 and not memory allocation or variable copying.  As usual, performance results should be taken
-with a healthy dose of scepticism, and real-world peformance may vary widely depending upon the
+with a healthy dose of scepticism, and real-world performance may vary widely depending upon the
 specifics of the program.  In each table relative times are given first, with the best performer
 given a score of 1.  Total actual times are given in brackets, measured in seconds for 500000
 operations.
@@ -1560,7 +1830,7 @@
 
 Note that these tests are carefully designed to test performance of the underlying algorithms
 and not memory allocation or variable copying.  As usual, performance results should be taken
-with a healthy dose of scepticism, and real-world peformance may vary widely depending upon the
+with a healthy dose of scepticism, and real-world performance may vary widely depending upon the
 specifics of the program.  In each table relative times are given first, with the best performer
 given a score of 1.  Total actual times are given in brackets, measured in seconds for 500000
 operations.
@@ -1717,7 +1987,7 @@
 
 Note that these tests are carefully designed to test performance of the underlying algorithms
 and not memory allocation or variable copying.  As usual, performance results should be taken
-with a healthy dose of scepticism, and real-world peformance may vary widely depending upon the
+with a healthy dose of scepticism, and real-world performance may vary widely depending upon the
 specifics of the program.  In each table relative times are given first, with the best performer
 given a score of 1.  Total actual times are given in brackets, measured in seconds for 500000
 operations.
@@ -1779,6 +2049,16 @@
 
 [section:hist History]
 
+*2011-2012, John Maddock adds an expression template enabled front end to Christopher's code,
+and adds support for other backends.
+* 2011, Christopher Kormanyos publishes the decimal floating point code under the Boost
+Software Licence.  The code is published as: [@http://doi.acm.org/10.1145/1916461.1916469 
+"Algorithm 910: A Portable C++ Multiple-Precision 
+System for Special-Function Calculations"], in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 
+2011.
+* 2002-2011, Christopher Kormanyos develops the all C++ decimal arithmetic floating point
+code.
+
 [endsect]
 
 [section:todo TODO]
@@ -1794,4 +2074,28 @@
 
 [endsect]
 
+[section:ack Acknowledgements]
+
+This library would not have happened without:
+
+* Christopher Kormanyos' C++ decimal number code.
+* Paul Bristow for patiently testing, and commenting on the library.
+* All the folks at GMP, MPFR and libtommath, for providing the "guts" that makes this library work.
+* [@http://www-cs-faculty.stanford.edu/~uno/taocp.html "The Art Of Computer Programming"], 
+Donald E. Knuth, Volume 2: Seminumerical Algorithms, Third Edition 
+(Reading, Massachusetts: Addison-Wesley, 1997), xiv+762pp. ISBN 0-201-89684-2
+
 [endsect]
+
+[endsect]
+
+[section:indexes Indexes]
+
+[include ../../../../../trunk/tools/auto_index/include/auto_index_helpers.qbk]
+[named_index function_name Function Index]
+[named_index class_name Class Index]
+[named_index typedef_name Typedef Index]
+[index]
+
+[endsect]
+