Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r84459 - in branches/release: boost/detail boost/math boost/math/special_functions libs/math libs/math/doc libs/math/doc/background libs/math/doc/complex libs/math/doc/complex/html libs/math/doc/concepts libs/math/doc/constants libs/math/doc/distributions libs/math/doc/equations libs/math/doc/fp_utilities libs/math/doc/gcd libs/math/doc/gcd/html libs/math/doc/graphs libs/math/doc/html libs/math/doc/internals libs/math/doc/octonion libs/math/doc/octonion/html libs/math/doc/overview libs/math/doc/performance libs/math/doc/policies libs/math/doc/quaternion libs/math/doc/quaternion/html libs/math/doc/sf libs/math/doc/sf_and_dist libs/math/doc/tr1 libs/math/example libs/math/test
From: john_at_[hidden]
Date: 2013-05-24 07:17:54

Author: johnmaddock
Date: 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
New Revision: 84459
URL: http://svn.boost.org/trac/boost/changeset/84459

Log:
Merge big documentation update from Trunk.
Added:
   branches/release/libs/math/doc/background/
      - copied from r84458, /trunk/libs/math/doc/background/
   branches/release/libs/math/doc/concepts/
      - copied from r84458, /trunk/libs/math/doc/concepts/
   branches/release/libs/math/doc/constants/
      - copied from r84458, /trunk/libs/math/doc/constants/
   branches/release/libs/math/doc/distributions/
      - copied from r84458, /trunk/libs/math/doc/distributions/
   branches/release/libs/math/doc/equations/
      - copied from r84458, /trunk/libs/math/doc/equations/
   branches/release/libs/math/doc/fp_utilities/
      - copied from r84458, /trunk/libs/math/doc/fp_utilities/
   branches/release/libs/math/doc/graphs/
      - copied from r84458, /trunk/libs/math/doc/graphs/
   branches/release/libs/math/doc/html/
      - copied from r84458, /trunk/libs/math/doc/html/
   branches/release/libs/math/doc/html4_symbols.qbk
      - copied unchanged from r84458, /trunk/libs/math/doc/html4_symbols.qbk
   branches/release/libs/math/doc/index.idx
      - copied unchanged from r84458, /trunk/libs/math/doc/index.idx
   branches/release/libs/math/doc/internals/
      - copied from r84458, /trunk/libs/math/doc/internals/
   branches/release/libs/math/doc/overview/
      - copied from r84458, /trunk/libs/math/doc/overview/
   branches/release/libs/math/doc/performance/
      - copied from r84458, /trunk/libs/math/doc/performance/
   branches/release/libs/math/doc/plot_owens_3d_xyp.png
      - copied unchanged from r84458, /trunk/libs/math/doc/plot_owens_3d_xyp.png
   branches/release/libs/math/doc/plot_owens_t.png
      - copied unchanged from r84458, /trunk/libs/math/doc/plot_owens_t.png
   branches/release/libs/math/doc/policies/
      - copied from r84458, /trunk/libs/math/doc/policies/
   branches/release/libs/math/doc/sf/
      - copied from r84458, /trunk/libs/math/doc/sf/
   branches/release/libs/math/doc/tr1/
      - copied from r84458, /trunk/libs/math/doc/tr1/
   branches/release/libs/math/doc/win32_nmake.mak
      - copied unchanged from r84458, /trunk/libs/math/doc/win32_nmake.mak
Removed:
   branches/release/libs/math/doc/common_factor.html
   branches/release/libs/math/doc/complex/Jamfile.v2
   branches/release/libs/math/doc/complex/html/
   branches/release/libs/math/doc/gcd/Jamfile.v2
   branches/release/libs/math/doc/gcd/html/
   branches/release/libs/math/doc/octonion/Jamfile.v2
   branches/release/libs/math/doc/octonion/html/
   branches/release/libs/math/doc/quaternion/Jamfile.v2
   branches/release/libs/math/doc/quaternion/html/
   branches/release/libs/math/doc/sf_and_dist/
Properties modified:
   branches/release/boost/detail/fenv.hpp (props changed)
   branches/release/boost/math/ (props changed)
   branches/release/libs/math/ (props changed)
   branches/release/libs/math/doc/overview/faq.qbk (props changed)
   branches/release/libs/math/example/ (props changed)
   branches/release/libs/math/test/s_.ipp (props changed)
Text files modified:
   branches/release/boost/math/special_functions/fpclassify.hpp | 9
   branches/release/libs/math/doc/Jamfile.v2 | 64 ++
   branches/release/libs/math/doc/complex/complex-tr1.qbk | 79 +-
   branches/release/libs/math/doc/gcd/math-gcd.qbk | 50 -
   branches/release/libs/math/doc/index.html | 8
   branches/release/libs/math/doc/math.qbk | 796 +++++++++++++++++++++++--------
   branches/release/libs/math/doc/octonion/math-octonion.qbk | 982 +++++++++++++++++++--------------------
   branches/release/libs/math/doc/quaternion/math-quaternion.qbk | 937 ++++++++++++++++++-------------------
   branches/release/libs/math/example/binomial_quiz_example.cpp | 9
   branches/release/libs/math/example/fft_sines_table.cpp | 18
   branches/release/libs/math/example/find_location_example.cpp | 27
   branches/release/libs/math/example/find_mean_and_sd_normal.cpp | 15
   branches/release/libs/math/example/find_root_example.cpp | 35
   branches/release/libs/math/example/find_scale_example.cpp | 26
   branches/release/libs/math/example/geometric_examples.cpp | 50 +-
   branches/release/libs/math/example/nc_chi_sq_example.cpp | 4
   branches/release/libs/math/example/negative_binomial_example1.cpp | 134 ++--
   branches/release/libs/math/example/nonfinite_facet_simple.cpp | 14
   branches/release/libs/math/example/normal_misc_examples.cpp | 105 ++--
   19 files changed, 1867 insertions(+), 1495 deletions(-)

Modified: branches/release/boost/math/special_functions/fpclassify.hpp
==============================================================================
--- branches/release/boost/math/special_functions/fpclassify.hpp (original)
+++ branches/release/boost/math/special_functions/fpclassify.hpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -94,6 +94,11 @@
//
namespace math_detail{

+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4800)
+#endif
+
template <class T>
inline bool is_nan_helper(T t, const boost::true_type&)
{
@@ -107,6 +112,10 @@
#endif
}

+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
template <class T>
inline bool is_nan_helper(T, const boost::false_type&)
{

Modified: branches/release/libs/math/doc/Jamfile.v2
==============================================================================
--- branches/release/libs/math/doc/Jamfile.v2 (original)
+++ branches/release/libs/math/doc/Jamfile.v2 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -4,6 +4,11 @@
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

using quickbook ;
+using auto-index ;
+import modules ;
+
+path-constant images_location : html ;
+path-constant here : . ;

xml math : math.qbk ;
boostbook standalone
@@ -12,6 +17,7 @@
 :
 # Path for links to Boost:
 <xsl:param>boost.root=../../../..
+ <xsl:param>html.stylesheet=boostbook.css

 # Some general style settings:
 <xsl:param>table.footnote.number.format=1
@@ -21,12 +27,64 @@
 # Use graphics not text for navigation:
 <xsl:param>navig.graphics=1
 # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=1
+ <xsl:param>chunk.section.depth=10
 # Don't put the first section on the same page as the TOC:
- <xsl:param>chunk.first.sections=0
+ <xsl:param>chunk.first.sections=1
 # How far down sections get TOC's
- <xsl:param>toc.section.depth=1
+ <xsl:param>toc.section.depth=10
+ # Max depth in each TOC:
+ <xsl:param>toc.max.depth=4
+ # How far down we go with TOC's
+ <xsl:param>generate.section.toc.level=10
+ # Index on type:
+ <xsl:param>index.on.type=1
+ <xsl:param>boost.noexpand.chapter.toc=1
+
+ #<xsl:param>root.filename="sf_dist_and_tools"
+ #<xsl:param>graphicsize.extension=1
+ #<xsl:param>use.extensions=1
+
+ # PDF Options:
+ # TOC Generation: this is needed for FOP-0.9 and later:
+ <xsl:param>fop1.extensions=0
+ <format>pdf:<xsl:param>xep.extensions=1
+ # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+ <format>pdf:<xsl:param>fop.extensions=0
+ <format>pdf:<xsl:param>fop1.extensions=0
+ # No indent on body text:
+ <format>pdf:<xsl:param>body.start.indent=0pt
+ # Margin size:
+ <format>pdf:<xsl:param>page.margin.inner=0.5in
+ # Margin size:
+ <format>pdf:<xsl:param>page.margin.outer=0.5in
+ # Paper type = A4
+ <format>pdf:<xsl:param>paper.type=A4
+ # Yes, we want graphics for admonishments:
+ <xsl:param>admon.graphics=1
+ # Set this one for PDF generation *only*:
+ # default pnd graphics are awful in PDF form,
+ # better use SVG's instead:
+ <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+ <format>pdf:<xsl:param>use.role.for.mediaobject=1
+ <format>pdf:<xsl:param>preferred.mediaobject.role=print
+ <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/html
+ <auto-index>on <format>pdf:<auto-index-internal>off
+ <format>html:<auto-index-internal>on
+ <auto-index-script>$(here)/index.idx
+ <auto-index-prefix>$(here)/../../..
+ #<auto-index-verbose>on
+ <quickbook-define>enable_index
+ <format>pdf:<xsl:param>index.on.type=1
 ;

+install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF <name>math.pdf ;
+explicit pdfinstall ;
+
+
+
+
+

Deleted: branches/release/libs/math/doc/common_factor.html
==============================================================================
--- branches/release/libs/math/doc/common_factor.html 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
+++ (empty file)
@@ -1,18 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
- <head>
- <meta http-equiv="refresh" content="0; URL=gcd/html/index.html">
- </head>
- <body>
- Automatic redirection failed, please go to
- gcd/html/index.html
- Copyright Daryle Walker 2006
- Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../../LICENSE_1_0.txt">
- LICENSE_1_0.txt</A> or copy at www.boost.org/LICENSE_1_0.txt).
- </body>
-</html>
-
-
-
-
-

Deleted: branches/release/libs/math/doc/complex/Jamfile.v2
==============================================================================
--- branches/release/libs/math/doc/complex/Jamfile.v2 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
+++ (empty file)
@@ -1,77 +0,0 @@
-
-# Copyright John Maddock 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-using quickbook ;
-
-path-constant images_location : html ;
-
-xml complex-tr1 : complex-tr1.qbk ;
-boostbook standalone
- :
- complex-tr1
- :
- # Path for links to Boost:
- <xsl:param>boost.root=../../../../..
-
- # Some general style settings:
- <xsl:param>table.footnote.number.format=1
- <xsl:param>footnote.number.format=1
-
- # HTML options first:
- # Use graphics not text for navigation:
- <xsl:param>navig.graphics=1
- # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=10
- # Don't put the first section on the same page as the TOC:
- <xsl:param>chunk.first.sections=1
- # How far down sections get TOC's
- <xsl:param>toc.section.depth=10
- # Max depth in each TOC:
- <xsl:param>toc.max.depth=4
- # How far down we go with TOC's
- <xsl:param>generate.section.toc.level=10
- #<xsl:param>root.filename="sf_dist_and_tools"
-
- # PDF Options:
- # TOC Generation: this is needed for FOP-0.9 and later:
- # <xsl:param>fop1.extensions=1
- <format>pdf:<xsl:param>xep.extensions=1
- # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
- <format>pdf:<xsl:param>fop.extensions=0
- <format>pdf:<xsl:param>fop1.extensions=0
- # No indent on body text:
- <format>pdf:<xsl:param>body.start.indent=0pt
- # Margin size:
- <format>pdf:<xsl:param>page.margin.inner=0.5in
- # Margin size:
- <format>pdf:<xsl:param>page.margin.outer=0.5in
- # Paper type = A4
- <format>pdf:<xsl:param>paper.type=A4
- # Yes, we want graphics for admonishments:
- <xsl:param>admon.graphics=1
- # Set this one for PDF generation *only*:
- # default pnd graphics are awful in PDF form,
- # better use SVG's instead:
- <format>pdf:<xsl:param>admon.graphics.extension=".svg"
- <format>pdf:<xsl:param>use.role.for.mediaobject=1
- <format>pdf:<xsl:param>preferred.mediaobject.role=print
- <format>pdf:<xsl:param>img.src.path=$(images_location)/
- <format>pdf:<xsl:param>draft.mode="no"
- ;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Modified: branches/release/libs/math/doc/complex/complex-tr1.qbk
==============================================================================
--- branches/release/libs/math/doc/complex/complex-tr1.qbk (original)
+++ branches/release/libs/math/doc/complex/complex-tr1.qbk 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,51 +1,32 @@
-[article Complex Number TR1 Algorithms
- [quickbook 1.4]
- [copyright 2005 John Maddock]
- [purpose Complex number arithmetic]
- [license
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt http://www.boost.org/LICENSE_1_0.txt])
- ]
- [authors [Maddock, John]]
- [category math]
- [last-revision $Date: 2006-12-29 11:08:32 +0000 (Fri, 29 Dec 2006) $]
-]
-
-
[def __effects [*Effects: ]]
[def __formula [*Formula: ]]
[def __exm1 '''<code>e<superscript>x</superscript> - 1</code>''']
[def __ex '''<code>e<superscript>x</superscript></code>''']
[def __te '''2ε''']
-[template tr1[] [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Technical Report on C++ Library Extensions]]
-
-This manual is also available in
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-printer friendly PDF format].

-[section:inverse_complex Complex Number Inverse Trigonometric Functions]
+[mathpart inverse_complex..Complex Number Functions]

The following complex number algorithms are the inverses of trigonometric functions currently
present in the C++ standard. Equivalents to these functions are part of the C99 standard, and
are part of the [tr1].

-[section:implementation Implementation and Accuracy]
+[section:complex_implementation Implementation and Accuracy]

Although there are deceptively simple formulae available for all of these functions, a naive
implementation that used these formulae would fail catastrophically for some input
values. The Boost versions of these functions have been implemented using the methodology
described in "Implementing the Complex Arcsine and Arccosine Functions Using Exception Handling"
-by T. E. Hull Thomas F. Fairgrieve and Ping Tak Peter Tang, ACM Transactions on Mathematical Software,
+by T. E. Hull Thomas F. Fairgrieve and Ping Tak Peter Tang, ACM Transactions on Mathematical Software,
Vol. 23, No. 3, September 1997. This means that the functions are well defined over the entire
complex number range, and produce accurate values even at the extremes of that range, where as a naive
-formula would cause overflow or underflow to occur during the calculation, even though the result is
-actually a representable value. The maximum theoretical relative error for all of these functions
-is less than 9.5E for every machine-representable point in the complex plane. Please refer to
+formula would cause overflow or underflow to occur during the calculation, even though the result is
+actually a representable value. The maximum theoretical relative error for all of these functions
+is less than 9.5[epsilon] for every machine-representable point in the complex plane. Please refer to
comments in the header files themselves and to the above mentioned paper for more information
on the implementation methodology.

[endsect]
+
[section:asin asin]

[h4 Header:]
@@ -54,12 +35,12 @@

[h4 Synopsis:]

- template<class T>
+ template<class T>
 std::complex<T> asin(const std::complex<T>& z);
-
+
__effects returns the inverse sine of the complex number z.

-__formula [$../../images/asin.png]
+__formula [$../images/asin.png]

[endsect]

@@ -71,12 +52,12 @@

[h4 Synopsis:]

- template<class T>
+ template<class T>
 std::complex<T> acos(const std::complex<T>& z);
-
+
__effects returns the inverse cosine of the complex number z.

-__formula [$../../images/acos.png]
+__formula [$../images/acos.png]

[endsect]

@@ -88,12 +69,12 @@

[h4 Synopsis:]

- template<class T>
+ template<class T>
 std::complex<T> atan(const std::complex<T>& z);
-
+
__effects returns the inverse tangent of the complex number z.

-__formula [$../../images/atan.png]
+__formula [$../images/atan.png]

[endsect]

@@ -105,12 +86,12 @@

[h4 Synopsis:]

- template<class T>
+ template<class T>
 std::complex<T> asinh(const std::complex<T>& z);
-
+
__effects returns the inverse hyperbolic sine of the complex number z.

-__formula [$../../images/asinh.png]
+__formula [$../images/asinh.png]

[endsect]

@@ -122,12 +103,12 @@

[h4 Synopsis:]

- template<class T>
+ template<class T>
 std::complex<T> acosh(const std::complex<T>& z);
-
+
__effects returns the inverse hyperbolic cosine of the complex number z.

-__formula [$../../images/acosh.png]
+__formula [$../images/acosh.png]

[endsect]

@@ -139,16 +120,16 @@

[h4 Synopsis:]

- template<class T>
+ template<class T>
 std::complex<T> atanh(const std::complex<T>& z);
-
+
__effects returns the inverse hyperbolic tangent of the complex number z.

-__formula [$../../images/atanh.png]
+__formula [$../images/atanh.png]

[endsect]

-[section History]
+[section:complex_history History]

* 2005/12/17: Added support for platforms with no meaningful numeric_limits<>::infinity().
* 2005/12/01: Initial version, added as part of the TR1 library.
@@ -156,7 +137,13 @@

[endsect]

-[endsect]
+[endmathpart]

+[/
+ Copyright 2008, 2009 John Maddock and Paul A. Bristow.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]

Deleted: branches/release/libs/math/doc/gcd/Jamfile.v2
==============================================================================
--- branches/release/libs/math/doc/gcd/Jamfile.v2 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
+++ (empty file)
@@ -1,66 +0,0 @@
-
-# Copyright John Maddock 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-using quickbook ;
-
-path-constant images_location : html ;
-
-xml math-gcd : math-gcd.qbk ;
-boostbook standalone
- :
- math-gcd
- :
- # Path for links to Boost:
- <xsl:param>boost.root=../../../../..
-
- # Some general style settings:
- <xsl:param>table.footnote.number.format=1
- <xsl:param>footnote.number.format=1
-
- # HTML options first:
- # Use graphics not text for navigation:
- <xsl:param>navig.graphics=1
- # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=10
- # Don't put the first section on the same page as the TOC:
- <xsl:param>chunk.first.sections=1
- # How far down sections get TOC's
- <xsl:param>toc.section.depth=10
- # Max depth in each TOC:
- <xsl:param>toc.max.depth=4
- # How far down we go with TOC's
- <xsl:param>generate.section.toc.level=10
- #<xsl:param>root.filename="sf_dist_and_tools"
-
- # PDF Options:
- # TOC Generation: this is needed for FOP-0.9 and later:
- # <xsl:param>fop1.extensions=1
- <format>pdf:<xsl:param>xep.extensions=1
- # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
- <format>pdf:<xsl:param>fop.extensions=0
- <format>pdf:<xsl:param>fop1.extensions=0
- # No indent on body text:
- <format>pdf:<xsl:param>body.start.indent=0pt
- # Margin size:
- <format>pdf:<xsl:param>page.margin.inner=0.5in
- # Margin size:
- <format>pdf:<xsl:param>page.margin.outer=0.5in
- # Paper type = A4
- <format>pdf:<xsl:param>paper.type=A4
- # Yes, we want graphics for admonishments:
- <xsl:param>admon.graphics=1
- # Set this one for PDF generation *only*:
- # default pnd graphics are awful in PDF form,
- # better use SVG's instead:
- <format>pdf:<xsl:param>admon.graphics.extension=".svg"
- <format>pdf:<xsl:param>use.role.for.mediaobject=1
- <format>pdf:<xsl:param>preferred.mediaobject.role=print
- <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/gcd/html
- ;
-
-
-

Modified: branches/release/libs/math/doc/gcd/math-gcd.qbk
==============================================================================
--- branches/release/libs/math/doc/gcd/math-gcd.qbk (original)
+++ branches/release/libs/math/doc/gcd/math-gcd.qbk 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,22 +1,5 @@
-[article GCD and LCM
- [quickbook 1.3]
- [copyright 2001-2002 Daryle Walker]
- [license
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt http://www.boost.org/LICENSE_1_0.txt])
- ]
- [authors [Walker, Daryle]]
- [category math]
- [last-revision $Date: 2006-12-29 11:08:32 +0000 (Fri, 29 Dec 2006) $]
-]
-
-This manual is also available in
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-printer friendly PDF format].

-
-[section:gcd_lcm Greatest Common Divisor and Least Common Multiple]
+[mathpart gcd_lcm Integer Utilities (Greatest Common Divisor and Least Common Multiple)]

[section Introduction]

@@ -59,7 +42,7 @@

[section GCD Function Object]

-[*Header: ] [@../../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]

 template < typename IntegerType >
 class boost::math::gcd_evaluator
@@ -91,7 +74,7 @@

[section LCM Function Object]

-[*Header: ] [@../../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]

 template < typename IntegerType >
 class boost::math::lcm_evaluator
@@ -124,7 +107,7 @@

[section:run_time Run-time GCD & LCM Determination]

-[*Header: ] [@../../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]

 template < typename IntegerType >
 IntegerType boost::math::gcd( IntegerType const &a, IntegerType const &b );
@@ -145,7 +128,7 @@

[section:compile_time Compile time GCD and LCM determination]

-[*Header: ] [@../../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
+[*Header: ] [@../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]

 typedef ``['unspecified]`` static_gcd_type;

@@ -203,11 +186,11 @@

[endsect]

-[section:header Header <boost/math/common_factor.hpp>]
+[section:gcd_header Header <boost/math/common_factor.hpp>]

This header simply includes the headers
-[@../../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
-and [@../../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>].
+[@../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
+and [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>].

Note this is a legacy header: it used to contain the actual implementation,
but the compile-time and run-time facilities
@@ -217,7 +200,7 @@

[section:demo Demonstration Program]

-The program [@../../../../../libs/math/test/common_factor_test.cpp common_factor_test.cpp] is a demonstration of the results from
+The program [@../../../../libs/math/test/common_factor_test.cpp common_factor_test.cpp] is a demonstration of the results from
instantiating various examples of the run-time GCD and LCM function
templates and the compile-time GCD and LCM class templates.
(The run-time GCD and LCM class templates are tested indirectly through
@@ -234,15 +217,16 @@

[endsect]

-[section History]
+[section:gcd_history History]

+* 13 May 2013 Moved into main Boost.Math Quickbook documentation.
* 17 Dec 2005: Converted documentation to Quickbook Format.
* 2 Jul 2002: Compile-time and run-time items separated to new headers.
* 7 Nov 2001: Initial version

[endsect]

-[section Credits]
+[section:gcd_credits Credits]

The author of the Boost compilation of GCD and LCM computations is
Daryle Walker. The code was prompted by existing code hiding in the
@@ -251,5 +235,13 @@

[endsect]

-[endsect]
+[endmathpart]
+
+[/
+Copyright 2005, 2013 Daryle Walker.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt).
+]
+

Modified: branches/release/libs/math/doc/index.html
==============================================================================
--- branches/release/libs/math/doc/index.html (original)
+++ branches/release/libs/math/doc/index.html 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,4 +1,8 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+ 
+ 
+ 
+ 
<html>
 <head>
 <meta http-equiv="refresh" content="0; URL=html/index.html">
@@ -6,7 +10,7 @@
 <body>
 Automatic redirection failed, please go to
 <a href="html/index.html">html/index.html</a>
- Copyright Daryle Walker, Hubert Holin and John Maddock 2006
+ Copyright Daryle Walker, Hubert Holin and John Maddock 2013
 Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../../LICENSE_1_0.txt">
 LICENSE_1_0.txt</A> or copy at www.boost.org/LICENSE_1_0.txt).
 </body>
@@ -15,3 +19,5 @@

+
+

Modified: branches/release/libs/math/doc/math.qbk
==============================================================================
--- branches/release/libs/math/doc/math.qbk (original)
+++ branches/release/libs/math/doc/math.qbk 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,230 +1,592 @@
-[article Boost.Math
- [quickbook 1.5]
- [copyright 2006, 2007, 2008, 2009, 2010 John Maddock, Paul A. Bristow, Hubert Holin, Daryle Walker, Xiaogang Zhang, Bruno Lalande, Johan Råde, Gautam Sewani and Thijs van den Berg]
+[book Math Toolkit
+ [quickbook 1.6]
+ [copyright 2006, 2007, 2008, 2009, 2010, 2012, 2013 Paul A. Bristow, Christopher Kormanyos, Hubert Holin, Bruno Lalande, John Maddock, Johan RÃ¥de, Gautam Sewani, Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang]
+ [/purpose ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22]
 [license
 Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt http://www.boost.org/LICENSE_1_0.txt])
+ [@http://www.boost.org/LICENSE_1_0.txt])
 ]
- [authors [Maddock, John], [Bristow, Paul A.], [Holin, Hubert], [Walker, Daryle], [Zhang, Xiaogang], [Lalande, Bruno], [Råde, Johan], [Sewani, Gautam], [van den Berg, Thijs]]
- [last-revision $Date$]
+ [authors [Bristow, Paul A.], [Holin, Hubert], [Kormanyos, Christopher], [Lalande, Bruno], [Maddock, John], [RÃ¥de, Johan], [Sobotta, Benjamin], [Sewani, Gautam], [van den Berg, Thijs], [Walker, Daryle], [Zhang, Xiaogang] ]
+ [/last-revision $Date$]
]

-[def __R ['[*R]]]
-[def __C ['[*C]]]
-[def __H ['[*H]]]
-[def __O ['[*O]]]
-[def __R3 ['[*'''R<superscript>3</superscript>''']]]
-[def __R4 ['[*'''R<superscript>4</superscript>''']]]
-[def __quadrulple ('''α,β,γ,δ''')]
-[def __quat_formula ['[^q = '''α + βi + γj + δk''']]]
-[def __quat_complex_formula ['[^q = ('''α + βi) + (γ + δi)j''' ]]]
-[def __not_equal ['[^xy '''≠''' yx]]]
-[def __octulple ('''α,β,γ,δ,ε,ζ,η,θ''')]
-[def __oct_formula ['[^o = '''α + βi + γj + δk + εe' + ζi' + ηj' + θk' ''']]]
-[def __oct_complex_formula ['[^o = ('''α + βi) + (γ + δi)j + (ε + ζi)e' + (η - θi)j' ''']]]
-[def __oct_quat_formula ['[^o = ('''α + βi + γj + δk) + (ε + ζi + ηj - θj)e' ''']]]
-[def __oct_not_equal ['[^x(yz) '''≠''' (xy)z]]]
-[template tr1[] [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Technical Report on C++ Library Extensions]]
-
-The following libraries are present in Boost.Math:
+[template mathpart[id title]
+[block '''<chapter id="'''[id]'''"><title>'''[title]'''</title>''']]
+[template endmathpart[]
+[block '''</chapter>''']]
+
+[/ \u00E5 = Latin small letter A with ring above doesn't seem to work in authors with Quickbook 1.5]
+
+[template equation[name] '''<inlinemediaobject>
+<imageobject role="html">
+<imagedata fileref="../equations/'''[name]'''.png"></imagedata>
+</imageobject>
+<imageobject role="print">
+<imagedata fileref="../equations/'''[name]'''.svg"></imagedata>
+</imageobject>
+</inlinemediaobject>''']
+
+[template graph[name] '''<inlinemediaobject>
+<imageobject role="html">
+<imagedata align="center" fileref="../graphs/'''[name]'''.png"></imagedata>
+</imageobject>
+<imageobject role="print">
+<imagedata align="center" fileref="../graphs/'''[name]'''.svg"></imagedata>
+</imageobject>
+</inlinemediaobject>''']
+
+[import ../../../tools/auto_index/include/auto_index_helpers.qbk]
+[/ Must be first included file!]
+
+[import html4_symbols.qbk]
+
+[import overview/common_overviews.qbk] [/ overviews that appear in more than one place!]
+[import overview/tr1.qbk] [/tr1 docs also appear in more than one place!]
+[import overview/roadmap.qbk] [/ for history]
+
+[def __effects [*Effects: ]]
+[def __formula [*Formula: ]]
+[def __exm1 '''<code>e<superscript>x</superscript> - 1</code>'''] [/e^x -1]
+[def __ex '''<code>e<superscript>x</superscript></code>'''] [/e^x]
+[def __te '''2ɛ'''] [/small Latin letter open e]
+
+[def __ceilR '''⌉''']
+[def __ceilL '''ऄ''']
+[def __floorR '''⌋''']
+[def __floorL '''⌊''']
+[def __infin '''∞''']
+[def __integral '''∫''']
+[def __aacute '''á''']
+[def __eacute '''é''']
+[def __quarter '''¼''']
+[def __nearequal '''≊''']
+[def __spaces '''  '''] [/ two spaces - useful for an indent.]
+
+[def __caution This is now an official Boost library, but remains a library under
+ development, the code is fully functional and robust, but
+ interfaces, library structure, and function and distribution names
+ may still be changed without notice.]

-[table
-[[Library][Description]]
+[template tr1[] [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Technical Report on C++ Library Extensions]]
+[template C99[] [@http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf C99 Standard ISO/IEC 9899:1999]]
+[template jm_rationals[] [link math_toolkit.sf_implementation.rational_approximations_used devised by JM]]

- [[Complex Number Inverse Trigonometric Functions
-
- [@../complex/html/index.html HTML Docs]
-
- [@http://sourceforge.net/projects/boost/files/boost-docs/
- PDF Docs]]
- [
-These complex number algorithms are the inverses of trigonometric functions currently
-present in the C++ standard. Equivalents to these functions are part of the C99 standard, and
-are part of the [tr1].
- ]]
-
- [[Greatest Common Divisor and Least Common Multiple
-
- [@../gcd/html/index.html HTML Docs]
-
- [@http://sourceforge.net/projects/boost/files/boost-docs/
- PDF Docs]]
- [
-The class and function templates in <boost/math/common_factor.hpp>
-provide run-time and compile-time evaluation of the greatest common divisor
-(GCD) or least common multiple (LCM) of two integers.
-These facilities are useful for many numeric-oriented generic
-programming problems.
- ]]
-
-[[Octonions
-
-[@../octonion/html/index.html HTML Docs]
-
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-PDF Docs]]
- [
-Octonions, like [@../quaternion/html/index.html quaternions], are a relative of complex numbers.
-
-Octonions see some use in theoretical physics.
-
-In practical terms, an octonion is simply an octuple of real numbers __octulple,
-which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
-are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
-are distinct objects which play essentially the same kind of role as ['[^i]] (or ['[^j]] or ['[^k]]).
-
-Addition and a multiplication is defined on the set of octonions,
-which generalize their quaternionic counterparts. The main novelty this time
-is that [*the multiplication is not only not commutative, is now not even
-associative] (i.e. there are quaternions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
-A way of remembering things is by using the following multiplication table:
-
-[$../../octonion/graphics/octonion_blurb17.jpeg]
-
-Octonions (and their kin) are described in far more details in this other
-[@../../quaternion/TQE.pdf document]
-(with [@../../quaternion/TQE_EA.pdf errata and addenda]).
-
-Some traditional constructs, such as the exponential, carry over without too
-much change into the realms of octonions, but other, such as taking a square root,
-do not (the fact that the exponential has a closed form is a result of the
-author, but the fact that the exponential exists at all for octonions is known
-since quite a long time ago).
- ]]
-
-[[Special Functions
-
-[@../sf_and_dist/html/index.html HTML Docs]
-
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-PDF Docs]]
-
- [ Provides a number of high quality special functions, initially
- these were concentrated on functions used in statistical applications
- along with those in the Technical Report on C++ Library Extensions.
-
- The function families currently implemented are the gamma, beta & erf
- functions along with the incomplete gamma and beta functions
- (four variants of each) and all the possible inverses of these,
- plus digamma, various factorial functions, Bessel functions,
- elliptic integrals, sinus cardinals (along with their
- hyperbolic variants), inverse hyperbolic functions,
- Legrendre/Laguerre/Hermite polynomials and various special power
- and logarithmic functions.
-
- All the implementations are fully generic and support the use of
- arbitrary "real-number" types, although they are optimised for
- use with types with known-about significand (or mantissa)
- sizes: typically float, double or long double. ]]
-
-[[Statistical Distributions
-
-[@../sf_and_dist/html/index.html HTML Docs]
-
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-PDF Docs]]
-
- [Provides a reasonably comprehensive set of statistical distributions,
- upon which higher level statistical tests can be built.
-
- The initial focus is on the central univariate distributions.
- Both continuous (like normal & Fisher) and discrete (like binomial
- & Poisson) distributions are provided.
-
- A comprehensive tutorial is provided, along with a series of worked
- examples illustrating how the library is used to conduct statistical tests. ]]
-
-[[Quaternions
-
-[@../quaternion/html/index.html HTML Docs]
-
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-PDF Docs]]
-
- [
-Quaternions are a relative of complex numbers.
-
-Quaternions are in fact part of a small hierarchy of structures built
-upon the real numbers, which comprise only the set of real numbers
-(traditionally named __R), the set of complex numbers (traditionally named __C),
-the set of quaternions (traditionally named __H) and the set of octonions
-(traditionally named __O), which possess interesting mathematical properties
-(chief among which is the fact that they are ['division algebras],
-['i.e.] where the following property is true: if ['[^y]] is an element of that
-algebra and is [*not equal to zero], then ['[^yx = yx']], where ['[^x]] and ['[^x']]
-denote elements of that algebra, implies that ['[^x = x']]).
-Each member of the hierarchy is a super-set of the former.
-
-One of the most important aspects of quaternions is that they provide an
-efficient way to parameterize rotations in __R3 (the usual three-dimensional space)
-and __R4.
-
-In practical terms, a quaternion is simply a quadruple of real numbers __quadrulple,
-which we can write in the form __quat_formula, where ['[^i]] is the same object as for complex numbers,
-and ['[^j]] and ['[^k]] are distinct objects which play essentially the same kind of role as ['[^i]].
-
-An addition and a multiplication is defined on the set of quaternions,
-which generalize their real and complex counterparts. The main novelty
-here is that [*the multiplication is not commutative] (i.e. there are
-quaternions ['[^x]] and ['[^y]] such that __not_equal). A good mnemotechnical way of remembering
-things is by using the formula ['[^i*i = j*j = k*k = -1]].
-
-Quaternions (and their kin) are described in far more details in this
-other [@../../quaternion/TQE.pdf document]
-(with [@../../quaternion/TQE_EA.pdf errata and addenda]).
-
-Some traditional constructs, such as the exponential, carry over without
-too much change into the realms of quaternions, but other, such as taking
-a square root, do not.
- ]]
-
+[def __domain_error [link math_toolkit.error_handling.domain_error domain_error]]
+[def __pole_error [link math_toolkit.error_handling.pole_error pole_error]]
+[def __overflow_error [link math_toolkit.error_handling.overflow_error overflow_error]]
+[def __underflow_error [link math_toolkit.error_handling.underflow_error underflow_error]]
+[def __denorm_error [link math_toolkit.error_handling.denorm_error denorm_error]]
+[def __evaluation_error [link math_toolkit.error_handling.evaluation_error evaluation_error]]
+[def __rounding_error [link math_toolkit.error_handling.rounding_error rounding_error]]
+[def __indeterminate_result_error [link math_toolkit.error_handling.indeterminate_result_error indeterminate_result_error]]
+[def __checked_narrowing_cast [link math_toolkit.error_handling.checked_narrowing_cast checked_narrowing_cast]]
+
+[def __arg_pomotion_rules [link math_toolkit.result_type ['result type calculation rules]]]
+[def __sf_result [link math_toolkit.result_type ['calculated-result-type]]]
+
+[/ The following macros expand to links to the various special functions
+and use the function's name as the link text.]
+
+[/Misc]
+[def __lanczos [link math_toolkit.lanczos Lanczos approximation]]
+[def __zero_error [link math_toolkit.relative_error.zero_error effectively zero error]]
+[def __relative_error [link math_toolkit.relative_error relative zero error]]
+[def __root_finding_with_derivatives [link math_toolkit.internals1.roots root-finding with derivatives]]
+[def __root_finding_without_derivatives [link math_toolkit.internals1.roots2 root-finding without derivatives]]
+
+[/gammas]
+[def __lgamma [link math_toolkit.sf_gamma.lgamma lgamma]]
+[def __digamma [link math_toolkit.sf_gamma.digamma digamma]]
+[def __tgamma_ratio [link math_toolkit.sf_gamma.gamma_ratios tgamma_ratio]]
+[def __tgamma_delta_ratio [link math_toolkit.sf_gamma.gamma_ratios tgamma_delta_ratio]]
+[def __tgamma [link math_toolkit.sf_gamma.tgamma tgamma]]
+[def __tgamma1pm1 [link math_toolkit.sf_gamma.tgamma tgamma1pm1]]
+[def __tgamma_lower [link math_toolkit.sf_gamma.igamma tgamma_lower]]
+[def __gamma_p [link math_toolkit.sf_gamma.igamma gamma_p]]
+[def __gamma_q [link math_toolkit.sf_gamma.igamma gamma_q]]
+[def __gamma_q_inv [link math_toolkit.sf_gamma.igamma_inv gamma_q_inv]]
+[def __gamma_p_inv [link math_toolkit.sf_gamma.igamma_inv gamma_p_inv]]
+[def __gamma_q_inva [link math_toolkit.sf_gamma.igamma_inv gamma_q_inva]]
+[def __gamma_p_inva [link math_toolkit.sf_gamma.igamma_inv gamma_p_inva]]
+[def __gamma_p_derivative [link math_toolkit.sf_gamma.gamma_derivatives gamma_p_derivative]]
+
+[/factorials]
+[def __factorial [link math_toolkit.factorials.sf_factorial factorial]]
+[def __unchecked_factorial [link math_toolkit.factorials.sf_factorial unchecked_factorial]]
+[def __max_factorial [link math_toolkit.factorials.sf_factorial max_factorial]]
+[def __double_factorial [link math_toolkit.factorials.sf_double_factorial double_factorial]]
+[def __rising_factorial [link math_toolkit.factorials.sf_rising_factorial rising_factorial]]
+[def __falling_factorial [link math_toolkit.factorials.sf_falling_factorial falling_factorial]]
+
+[/error functions]
+[def __erf [link math_toolkit.sf_erf.error_function erf]]
+[def __erfc [link math_toolkit.sf_erf.error_function erfc]]
+[def __erf_inv [link math_toolkit.sf_erf.error_inv erf_inv]]
+[def __erfc_inv [link math_toolkit.sf_erf.error_inv erfc_inv]]
+
+[/beta functions]
+[def __beta [link math_toolkit.sf_beta.beta_function beta]]
+[def __beta3 [link math_toolkit.sf_beta.ibeta_function beta]]
+[def __betac [link math_toolkit.sf_beta.ibeta_function betac]]
+[def __ibeta [link math_toolkit.sf_beta.ibeta_function ibeta]]
+[def __ibetac [link math_toolkit.sf_beta.ibeta_function ibetac]]
+[def __ibeta_inv [link math_toolkit.sf_beta.ibeta_inv_function ibeta_inv]]
+[def __ibetac_inv [link math_toolkit.sf_beta.ibeta_inv_function ibetac_inv]]
+[def __ibeta_inva [link math_toolkit.sf_beta.ibeta_inv_function ibeta_inva]]
+[def __ibetac_inva [link math_toolkit.sf_beta.ibeta_inv_function ibetac_inva]]
+[def __ibeta_invb [link math_toolkit.sf_beta.ibeta_inv_function ibeta_invb]]
+[def __ibetac_invb [link math_toolkit.sf_beta.ibeta_inv_function ibetac_invb]]
+[def __ibeta_derivative [link math_toolkit.sf_beta.beta_derivative ibeta_derivative]]
+
+[/elliptic integrals]
+[def __ellint_rj [link math_toolkit.ellint.ellint_carlson ellint_rj]]
+[def __ellint_rf [link math_toolkit.ellint.ellint_carlson ellint_rf]]
+[def __ellint_rc [link math_toolkit.ellint.ellint_carlson ellint_rc]]
+[def __ellint_rd [link math_toolkit.ellint.ellint_carlson ellint_rd]]
+[def __ellint_1 [link math_toolkit.ellint.ellint_1 ellint_1]]
+[def __ellint_2 [link math_toolkit.ellint.ellint_2 ellint_2]]
+[def __ellint_3 [link math_toolkit.ellint.ellint_3 ellint_3]]
+
+[/Bessel functions]
+[def __cyl_bessel_j [link math_toolkit.bessel.bessel_first cyl_bessel_j]]
+[def __cyl_neumann [link math_toolkit.bessel.bessel_first cyl_neumann]]
+[def __cyl_bessel_i [link math_toolkit.bessel.mbessel cyl_bessel_i]]
+[def __cyl_bessel_k [link math_toolkit.bessel.mbessel cyl_bessel_k]]
+[def __sph_bessel [link math_toolkit.bessel.sph_bessel sph_bessel]]
+[def __sph_neumann [link math_toolkit.bessel.sph_bessel sph_neumann]]
+
+[/Hankel Functions]
+[def __cyl_hankel_1 [link math_toolkit.hankel.cyl_hankel cyl_hankel_1]]
+[def __cyl_hankel_2 [link math_toolkit.hankel.cyl_hankel cyl_hankel_2]]
+[def __sph_hankel_1 [link math_toolkit.hankel.sph_hankel sph_hankel_1]]
+[def __sph_hankel_2 [link math_toolkit.hankel.sph_hankel sph_hankel_2]]
+
+[/Airy Functions]
+[def __airy_ai [link math_toolkit.airy.ai airy_ai]]
+[def __airy_bi [link math_toolkit.airy.bi airy_bi]]
+[def __airy_bi_prime [link math_toolkit.airy.bip airy_bi_prime]]
+[def __airy_ai_prime [link math_toolkit.airy.aip airy_ai_prime]]
+
+[/Jacobi Elliptic Functions]
+[def __jacobi_elliptic [link math_toolkit.jacobi.jacobi_elliptic jacobi_elliptic]]
+[def __jacobi_cd [link math_toolkit.jacobi.jacobi_cd jacobi_cd]]
+[def __jacobi_cn [link math_toolkit.jacobi.jacobi_cn jacobi_cn]]
+[def __jacobi_cs [link math_toolkit.jacobi.jacobi_cs jacobi_cs]]
+[def __jacobi_dc [link math_toolkit.jacobi.jacobi_dc jacobi_dc]]
+[def __jacobi_dn [link math_toolkit.jacobi.jacobi_dn jacobi_dn]]
+[def __jacobi_ds [link math_toolkit.jacobi.jacobi_ds jacobi_ds]]
+[def __jacobi_nd [link math_toolkit.jacobi.jacobi_nd jacobi_nd]]
+[def __jacobi_nc [link math_toolkit.jacobi.jacobi_nc jacobi_nc]]
+[def __jacobi_ns [link math_toolkit.jacobi.jacobi_ns jacobi_ns]]
+[def __jacobi_sd [link math_toolkit.jacobi.jacobi_sd jacobi_sd]]
+[def __jacobi_sn [link math_toolkit.jacobi.jacobi_sn jacobi_sn]]
+[def __jacobi_sc [link math_toolkit.jacobi.jacobi_sc jacobi_sc]]
+
+[/sinus cardinals]
+[def __sinc_pi [link math_toolkit.sinc.sinc_pi sinc_pi]]
+[def __sinhc_pi [link math_toolkit.sinc.sinhc_pi sinhc_pi]]
+
+[/Inverse hyperbolics]
+[def __acosh [link math_toolkit.inv_hyper.acosh acosh]]
+[def __asinh [link math_toolkit.inv_hyper.asinh asinh]]
+[def __atanh [link math_toolkit.inv_hyper.atanh atanh]]
+
+[/classify]
+[def __fpclassify [link math_toolkit.fpclass fpclassify]]
+[def __isfinite [link math_toolkit.fpclass isfinite]]
+[def __isnan [link math_toolkit.fpclass isnan]]
+[def __isinf [link math_toolkit.fpclass isinf]]
+[def __isnormal [link math_toolkit.fpclass isnormal]]
+[def __fp_facets [link math_toolkit.fp_facets nonfinite fp_facets]]
+
+[/powers etc]
+[def __expm1 [link math_toolkit.powers.expm1 expm1]]
+[def __log1p [link math_toolkit.powers.log1p log1p]]
+[def __cbrt [link math_toolkit.powers.cbrt cbrt]]
+[def __sqrt1pm1 [link math_toolkit.powers.sqrt1pm1 sqrt1pm1]]
+[def __powm1 [link math_toolkit.powers.powm1 powm1]]
+[def __hypot [link math_toolkit.powers.hypot hypot]]
+[def __pow [link math_toolkit.powers.ct_pow pow]]
+
+[/zeta]
+[def __zeta [link math_toolkit.zetas.zeta zeta]]
+
+[/expint]
+[def __expint_i [link math_toolkit.expint.expint_i zeta]]
+[def __expint_n [link math_toolkit.expint.expint_n zeta]]
+
+[/rounding]
+[def __round [link math_toolkit.rounding.round round]]
+[def __lround [link math_toolkit.rounding.round round]]
+[def __llround [link math_toolkit.rounding.round round]]
+[def __trunc [link math_toolkit.rounding.trunc trunc]]
+[def __modf [link math_toolkit.rounding.modf modf]]
+
+[/polynomials]
+[def __laguerre [link math_toolkit.sf_poly.laguerre laguerre]]
+[def __legendre [link math_toolkit.sf_poly.legendre legendre_p]]
+[def __hermite [link math_toolkit.sf_poly.hermite hermite]]
+
+[/Misc]
+[def __expint [link math_toolkit.expint.expint_i expint]]
+[def __spherical_harmonic [link math_toolkit.sf_poly.sph_harm spherical_harmonic]]
+[def __owens_t [link math_toolkit.owens_t Owens T]]
+
+
+[/tools]
+[def __tuple [link math_toolkit.internals1.tuples boost::math::tuple]]
+
+[/ distribution non-members]
+[def __cdf [link math_toolkit.dist_ref.nmp.cdf Cumulative Distribution Function]]
+[def __pdf [link math_toolkit.dist_ref.nmp.pdf Probability Density Function]]
+[def __ccdf [link math_toolkit.dist_ref.nmp.ccdf Complement of the Cumulative Distribution Function]]
+[def __quantile [link math_toolkit.dist_ref.nmp.quantile Quantile]]
+[def __quantile_c [link math_toolkit.dist_ref.nmp.quantile_c Quantile from the complement of the probability]]
+[def __mean [link math_toolkit.dist_ref.nmp.mean mean]]
+[def __median [link math_toolkit.dist_ref.nmp.median median]]
+[def __mode [link math_toolkit.dist_ref.nmp.mode mode]]
+[def __skewness [link math_toolkit.dist_ref.nmp.skewness skewness]]
+[def __kurtosis [link math_toolkit.dist_ref.nmp.kurtosis kurtosis]]
+[def __kurtosis_excess [link math_toolkit.dist_ref.nmp.kurtosis_excess kurtosis_excess]]
+[def __variance [link math_toolkit.dist_ref.nmp.variance variance]]
+[def __sd [link math_toolkit.dist_ref.nmp.sd standard deviation]]
+[def __hazard [link math_toolkit.dist_ref.nmp.hazard Hazard Function]]
+[def __chf [link math_toolkit.dist_ref.nmp.chf Cumulative Hazard Function]]
+[def __range [link math_toolkit.dist_ref.nmp.range range]]
+[def __support [link math_toolkit.dist_ref.nmp.support support]]
+[def __algorithms [link math_toolkit.dist_ref.dist_algorithms algorithms]]
+
+
+[/ distribution def names end in distrib to avoid clashes]
+[def __beta_distrib [link math_toolkit.dist_ref.dists.beta_dist Beta Distribution]]
+[def __binomial_distrib [link math_toolkit.dist_ref.dists.binomial_dist Binomial Distribution]]
+[def __cauchy_distrib [link math_toolkit.dist_ref.dists.cauchy_dist Cauchy Distribution]]
+[def __chi_squared_distrib [link math_toolkit.dist_ref.dists.chi_squared_dist Chi Squared Distribution]]
+[def __extreme_distrib [link math_toolkit.dist_ref.dists.extreme_dist Extreme Distributions]]
+[def __exp_distrib [link math_toolkit.dist_ref.dists.exp_dist Exponential Distribution]]
+[def __F_distrib [link math_toolkit.dist_ref.dists.f_dist Fisher F Distribution]]
+[def __gamma_distrib [link math_toolkit.dist_ref.dists.gamma_dist Gamma Distribution]]
+[def __geometric_distrib [link math_toolkit.dist_ref.dists.geometric_dist Geometric Distribution]]
+[def __hypergeometric_distrib [link math_toolkit.dist_ref.dists.hypergeometric_dist hypergeometric Distribution]]
+[def __inverse_gamma_distrib [link math_toolkit.dist_ref.dists.inverse_gamma_dist Inverse Gamma Distribution]]
+[def __inverse_gaussian_distrib [link math_toolkit.dist_ref.dists.inverse_gaussian_dist Inverse Gaussian Distribution]]
+[def __inverse_chi_squared_distrib [link math_toolkit.dist_ref.dists.inverse_chi_squared_dist Inverse chi squared Distribution]]
+[def __laplace_distrib [link math_toolkit.dist_ref.dists.laplace_dist Laplace Distribution]]
+[def __logistic_distrib [link math_toolkit.dist_ref.dists.logistic_dist Logistic Distribution]]
+[def __lognormal_distrib [link math_toolkit.dist_ref.dists.lognormal_dist Log-normal Distribution]]
+[def __negative_binomial_distrib [link math_toolkit.dist_ref.dists.negative_binomial_dist Negative Binomial Distribution]]
+[def __non_central_chi_squared_distrib [link math_toolkit.dist_ref.dists.nc_chi_squared_dist Noncentral Chi Squared Distribution]]
+[def __non_central_beta_distrib [link math_toolkit.dist_ref.dists.nc_beta_dist Noncentral Beta Distribution]]
+[def __non_central_F_distrib [link math_toolkit.dist_ref.dists.nc_f_dist Noncentral F Distribution]]
+[def __non_central_T_distrib [link math_toolkit.dist_ref.dists.nc_t_dist Noncentral T Distribution]]
+[def __non_central_t_distrib [link math_toolkit.dist_ref.dists.nc_t_dist noncentral T distribution]]
+[def __normal_distrib [link math_toolkit.dist_ref.dists.normal_dist Normal Distribution]]
+[def __poisson_distrib [link math_toolkit.dist_ref.dists.poisson_dist Poisson Distribution]]
+[def __pareto_distrib [link math_toolkit.dist_ref.dists.pareto_dist Pareto Distribution]]
+[def __students_t_distrib [link math_toolkit.dist_ref.dists.students_t_dist Students t Distribution]]
+[def __skew_normal_distrib [link math_toolkit.dist_ref.dists.skew_normal_dist Skew Normal Distribution]]
+[def __weibull_distrib [link math_toolkit.dist_ref.dists.weibull_dist Weibull Distribution]]
+
+[/links to policy]
+[def __Policy [link policy Policy]] [/ Used in distribution template specifications]
+[def __policy_section [link policy Policies]] [/ Used in text to refer to.]
+[def __policy_class [link math_toolkit.pol_ref.pol_ref_ref policies::policy<>]]
+[def __math_undefined [link math_toolkit.pol_ref.assert_undefined mathematically undefined function]]
+[def __policy_ref [link math_toolkit.pol_ref policy reference]]
+[def __policy_tutorial [link math_toolkit.pol_tutorial policy tutorial]]
+[def __policy_defaults [link math_toolkit.pol_tutorial.policy_tut_defaults policy defaults]]
+[def __error_policy [link math_toolkit.pol_ref.error_handling_policies error handling policies]]
+[def __changing_policy_defaults [link math_toolkit.pol_ref.policy_defaults changing policies defaults]]
+[def __math_discrete [link math_toolkit.pol_ref.discrete_quant_ref discrete functions]]
+[def __understand_dis_quant [link math_toolkit.pol_tutorial.understand_dis_quant understanding discrete quantiles]]
+[def __user_error_handling [link math_toolkit.pol_tutorial.user_def_err_pol user error handling]]
+[def __promotion_policy [link math_toolkit.pol_ref.internal_promotion internal promotion policy]]
+[def __precision_policy [link math_toolkit.pol_ref.precision_pol precision policy]]
+[def __policy_macros [link math_toolkit.pol_ref.policy_defaults Using Macros to Change the Policy Defaults]]
+
+[def __random_variate [@http://en.wikipedia.org/wiki/Random_variate random variate]]
+[def __random_variable [@http://en.wikipedia.org/wiki/Random_variable random variable]]
+[def __probability_distribution [@http://en.wikipedia.org/wiki/Probability_distribution probability_distribution]]
+
+[def __usual_accessors __cdf, __pdf, __quantile, __hazard,
+ __chf, __mean, __median, __mode, __variance, __sd, __skewness,
+ __kurtosis, __kurtosis_excess, __range and __support]
+
+[def __gsl [@http://www.gnu.org/software/gsl/ GSL-1.9]]
+[def __glibc [@http://www.gnu.org/software/libc/ GNU C Lib]]
+[def __hpc [@http://docs.hp.com/en/B9106-90010/index.html HP-UX C Library]]
+[def __cephes [@http://www.netlib.org/cephes/ Cephes]]
+[def __NTL [@http://www.shoup.net/ntl/ NTL A Library for doing Number Theory]]
+[def __NTL_RR [@http://shoup.net/ntl/doc/RR.txt NTL::RR]]
+[def __NTL_quad_float [@http://shoup.net/ntl/doc/quad_float.txt NTL::quad_float]]
+[def __MPFR [@http://www.mpfr.org/ GNU MPFR library]]
+[def __GMP [@http://gmplib.org/ GNU Multiple Precision Arithmetic Library]]
+[def __multiprecision [@http://www.boost.org/doc/libs/1_53_0_beta1/libs/multiprecision/doc/html/index.html Boost.Multiprecision]]
+[def __cpp_dec_float [@http://www.boost.org/doc/libs/1_53_0_beta1/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html cpp_dec_float]]
+[def __R [@http://www.r-project.org/ The R Project for Statistical Computing]]
+[def __godfrey [link godfrey Godfrey]]
+[def __pugh [link pugh Pugh]]
+[def __NaN [@http://en.wikipedia.org/wiki/NaN NaN]]
+[def __errno [@http://en.wikipedia.org/wiki/Errno `::errno`]]
+[def __Mathworld [@http://mathworld.wolfram.com Wolfram MathWorld]]
+[def __Mathematica [@http://www.wolfram.com/products/mathematica/index.html Wolfram Mathematica]]
+[def __WolframAlpha [@http://www.wolframalpha.com/ Wolfram Alpha]]
+[def __TOMS748 [@http://portal.acm.org/citation.cfm?id=210111 TOMS Algorithm 748: enclosing zeros of continuous functions]]
+[def __TOMS910 [@http://portal.acm.org/citation.cfm?id=1916469 TOMS Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations]]
+[def __why_complements [link why_complements why complements?]]
+[def __complements [link math_toolkit.stat_tut.overview.complements complements]]
+[def __performance [link perf performance]]
+[def __building [link math_toolkit.building building libraries]]
+[def __e_float [@http://calgo.acm.org/910.zip e_float (TOMS Algorithm 910)]]
+[def __Abramowitz_Stegun M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions, NBS (1964)]
+[def _DMLF [@http://dlmf.nist.gov/ NIST Digital Library of Mathematical Functions]]
+
+[/ Some composite templates]
+[template super[x]'''<superscript>'''[x]'''</superscript>''']
+[template sub[x]'''<subscript>'''[x]'''</subscript>''']
+[template floor[x]'''⌊'''[x]'''⌋''']
+[template floorlr[x][lfloor][x][rfloor]]
+[template ceil[x] '''⌈'''[x]'''⌉''']
+
+[template header_file[file] [@../../../../[file] [file]]]
+
+[template optional_policy[]
+The final __Policy argument is optional and can be used to
+control the behaviour of the function: how it handles errors,
+what level of precision to use etc. Refer to the
+[link policy policy documentation for more details].]
+
+[template discrete_quantile_warning[NAME]
+[caution
+The [NAME] distribution is a discrete distribution: internally,
+functions like the `cdf` and `pdf` are treated "as if" they are continuous
+functions, but in reality the results returned from these functions
+only have meaning if an integer value is provided for the random variate
+argument.
+
+The quantile function will by default return an integer result that has been
+/rounded outwards/. That is to say lower quantiles (where the probability is
+less than 0.5) are rounded downward, and upper quantiles (where the probability
+is greater than 0.5) are rounded upwards. This behaviour
+ensures that if an X% quantile is requested, then /at least/ the requested
+coverage will be present in the central region, and /no more than/
+the requested coverage will be present in the tails.
+
+This behaviour can be changed so that the quantile functions are rounded
+differently, or even return a real-valued result using
+[link math_toolkit.pol_overview Policies]. It is strongly
+recommended that you read the tutorial
+[link math_toolkit.pol_tutorial.understand_dis_quant
+Understanding Quantiles of Discrete Distributions] before
+using the quantile function on the [NAME] distribution. The
+[link math_toolkit.pol_ref.discrete_quant_ref reference docs]
+describe how to change the rounding policy
+for these distributions.
+] [/ caution]
+] [/ template discrete_quantile_warning]
+
+[block '''<bookinfo><releaseinfo>'''
+This manual is also available in
+[@http://sourceforge.net/projects/boost/files/boost-docs/
+printer friendly PDF format],
+and as a CD ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22.
+'''</releaseinfo></bookinfo>''']
+
+[mathpart overview Overview]
+[include overview/overview.qbk]
+[include overview/structure.qbk] [/getting about, directory and file structure.]
+[include overview/result_type_calc.qbk]
+[include overview/error_handling.qbk]
+
+[section:compilers_overview Compilers]
+[compilers_overview]
+[endsect]
+[include overview/config_macros.qbk]
+[section:intro_pol_overview Policies]
+[policy_overview]
+[endsect]
+
+[include overview/thread_safety.qbk]
+
+[section:perf_over1 Performance]
+[performance_overview]
+[endsect]
+[include overview/building.qbk]
+[section:history1 History and What's New]
+[history]
+[endsect]
+[section:overview_tr1 C99 and C++ TR1 C-style Functions]
+[tr1_overview]
+[endsect]
+[include overview/faq.qbk]
+[include overview/contact_info.qbk]
+
+[endmathpart] [/section:main_overview Overview]
+
+[mathpart dist Statistical Distributions and Functions]
+[include distributions/dist_tutorial.qbk]
+[include distributions/dist_reference.qbk] [/includes all individual distribution.qbk files]
+[endmathpart] [/section:dist Statistical Distributions and Functions]
+
+[mathpart special Special Functions]
+
+[section:sf_gamma Gamma Functions]
+[include sf/tgamma.qbk]
+[include sf/lgamma.qbk]
+[include sf/digamma.qbk]
+[include sf/gamma_ratios.qbk]
+[include sf/igamma.qbk]
+[include sf/igamma_inv.qbk]
+[include sf/gamma_derivatives.qbk]
+[endsect] [/section:sf_gamma Gamma Functions]
+
+[include sf/factorials.qbk]
+
+[section:sf_beta Beta Functions]
+[include sf/beta.qbk]
+[include sf/ibeta.qbk]
+[include sf/ibeta_inv.qbk]
+[include sf/beta_derivative.qbk]
+[endsect] [/section:sf_beta Beta Functions]
+
+[section:sf_erf Error Functions]
+[include sf/erf.qbk]
+[include sf/erf_inv.qbk]
+[endsect] [/section:sf_erf Error Functions]
+
+[section:sf_poly Polynomials]
+[include sf/legendre.qbk]
+[include sf/laguerre.qbk]
+[include sf/hermite.qbk]
+[include sf/spherical_harmonic.qbk]
+[endsect] [/section:sf_poly Polynomials]
+
+[section:bessel Bessel Functions]
+[include sf/bessel_introduction.qbk]
+[include sf/bessel_jy.qbk]
+[include sf/bessel_ik.qbk]
+[include sf/bessel_spherical.qbk]
+[endsect] [/section:bessel Bessel Functions]
+
+[/Hankel functions]
+[include sf/hankel.qbk]
+
+[/Airy Functions]
+[include sf/airy.qbk]
+
+[section:ellint Elliptic Integrals]
+[include sf/ellint_introduction.qbk]
+[include sf/ellint_carlson.qbk]
+[include sf/ellint_legendre.qbk]
+[endsect] [/section:ellint Elliptic Integrals]
+
+[include sf/jacobi_elliptic.qbk]
+
+[section:zetas Zeta Functions]
+[include sf/zeta.qbk]
+[endsect]
+
+[include sf/expint.qbk]
+
+[include sf/powers.qbk]
+[include sf/sinc.qbk]
+[include sf/inv_hyper.qbk]
+
+[include sf/owens_t.qbk]
+
+[endmathpart] [/section:special Special Functions]
+
+[mathpart utils Floating Point Utilities]
+[include fp_utilities/rounding_func.qbk]
+[include fp_utilities/fpclassify.qbk]
+[include fp_utilities/sign.qbk]
+[include fp_utilities/fp_facets.qbk]
+[include fp_utilities/float_next.qbk]
+[endmathpart]
+
+[mathpart extern_c TR1 and C99 external "C" Functions]
+[section:main_tr1 C99 and TR1 C Functions Overview]
+[tr1_overview]
+[endsect]
+[include tr1/c99_ref.qbk]
+[include tr1/tr1_ref.qbk]
+[endmathpart]
+
+[include constants/constants.qbk]
+
+[include complex/complex-tr1.qbk]
+[include quaternion/math-quaternion.qbk]
+[include octonion/math-octonion.qbk]
+[include gcd/math-gcd.qbk]
+
+[mathpart toolkit Internals (Series, Rationals and Continued Fractions, Root Finding, Function Minimization, Testing and Development Tools)]
+
+[include internals/internals_overview.qbk]
+
+[section:internals1 Utilities & internals]
+[include internals/series.qbk]
+[include internals/fraction.qbk]
+[include internals/rational.qbk]
+[include internals/roots.qbk]
+[include internals/roots_without_derivatives.qbk]
+[include internals/minima.qbk]
+[include internals/tuple.qbk]
+[endsect] [/section:internals1 Utilities & internals]
+
+[section:internals2 Testing and Development]
+[include internals/polynomial.qbk]
+[include internals/minimax.qbk]
+[include internals/relative_error.qbk] [/ uncertainty of floating-point calculations.]
+[include internals/test_data.qbk]
+[endsect] [/section:internals2 Testing and Development]
+
+[endmathpart] [/section:toolkit Toolkit]
+
+[mathpart using_udt Use with User-Defined Floating-Point Types - Boost.Multiprecision and others]
+[include concepts/concepts.qbk]
+[endmathpart] [/section:using_udt Use with User Defined Floating-Point Types]
+
+[include policies/policy.qbk]
+
+[include performance/performance.qbk]
+
+[mathpart backgrounders Backgrounders]
+[include background/implementation.qbk]
+[include background/error.qbk] [/relative error NOT handling]
+[include background/lanczos.qbk]
+[include background/remez.qbk]
+[include background/references.qbk]
+[endmathpart] [/section:backgrounders Backgrounders]
+
+[mathpart status Library Status]
+[section:history2 History and What's New]
+[history]
+[endsect]
+[include overview/issues.qbk]
+[include overview/credits.qbk]
+[/include test_HTML4_symbols.qbk]
+[/include test_Latin1_symbols.qbk]
+
+[endmathpart] [/section:status Status and Roadmap]
+
+[mathpart indexes Indexes]
+
+[named_index function_name Function Index]
+[named_index class_name Class Index]
+[named_index typedef_name Typedef Index]
+[named_index macro_name Macro Index]
+[index]
+
+[endmathpart]
+
+[/ math.qbk
+ Copyright 2008, 2010, 2012, 2013 John Maddock and Paul A. Bristow.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
]

-The following Boost libraries are also mathematically oriented:

-[table
-[[Library][Description]]

- [[[@../../../integer/index.html Integer]]
- [Headers to ease dealing with integral types.]]
-
- [[[@../../../numeric/interval/doc/interval.htm Interval]]
- [As implied by its name, this library is intended to help manipulating
- mathematical intervals. It consists of a single header
- <boost/numeric/interval.hpp> and principally a type which can be
- used as interval<T>. ]]
-
- [[[@../../../multi_array/doc/index.html Multi Array]]
- [Boost.MultiArray provides a generic N-dimensional array concept
- definition and common implementations of that interface.]]
-
- [[[@../../../numeric/conversion/index.html Numeric.Conversion]]
- [The Boost Numeric Conversion library is a collection of tools to
- describe and perform conversions between values of different numeric types.]]
-
- [[[@../../../utility/operators.htm Operators]]
- [The header <boost/operators.hpp> supplies several sets of class
- templates (in namespace boost). These templates define operators at
- namespace scope in terms of a minimal number of fundamental
- operators provided by the class.]]
-
- [[[@../../../random/index.html Random]]
- [Random numbers are useful in a variety of applications. The Boost
- Random Number Library (Boost.Random for short) provides a vast variety
- of generators and distributions to produce random numbers having useful
- properties, such as uniform distribution.]]
-
- [[[@../../../rational/index.html Rational]]
- [The header rational.hpp provides an implementation of rational numbers.
- The implementation is template-based, in a similar manner to the
- standard complex number class.]]
-
- [[[@../../../numeric/ublas/doc/index.htm uBLAS]]
- [uBLAS is a C++ template class library that provides BLAS level 1, 2, 3
- functionality for dense, packed and sparse matrices. The design and
- implementation unify mathematical notation via operator overloading and
- efficient code generation via expression templates.]]
-
-]

Deleted: branches/release/libs/math/doc/octonion/Jamfile.v2
==============================================================================
--- branches/release/libs/math/doc/octonion/Jamfile.v2 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
+++ (empty file)
@@ -1,66 +0,0 @@
-
-# Copyright John Maddock 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-using quickbook ;
-
-path-constant images_location : html ;
-
-xml octonion : math-octonion.qbk ;
-boostbook standalone
- :
- octonion
- :
- # Path for links to Boost:
- <xsl:param>boost.root=../../../../..
-
- # Some general style settings:
- <xsl:param>table.footnote.number.format=1
- <xsl:param>footnote.number.format=1
-
- # HTML options first:
- # Use graphics not text for navigation:
- <xsl:param>navig.graphics=1
- # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=10
- # Don't put the first section on the same page as the TOC:
- <xsl:param>chunk.first.sections=1
- # How far down sections get TOC's
- <xsl:param>toc.section.depth=10
- # Max depth in each TOC:
- <xsl:param>toc.max.depth=4
- # How far down we go with TOC's
- <xsl:param>generate.section.toc.level=10
- #<xsl:param>root.filename="sf_dist_and_tools"
-
- # PDF Options:
- # TOC Generation: this is needed for FOP-0.9 and later:
- # <xsl:param>fop1.extensions=1
- <format>pdf:<xsl:param>xep.extensions=1
- # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
- <format>pdf:<xsl:param>fop.extensions=0
- <format>pdf:<xsl:param>fop1.extensions=0
- # No indent on body text:
- <format>pdf:<xsl:param>body.start.indent=0pt
- # Margin size:
- <format>pdf:<xsl:param>page.margin.inner=0.5in
- # Margin size:
- <format>pdf:<xsl:param>page.margin.outer=0.5in
- # Paper type = A4
- <format>pdf:<xsl:param>paper.type=A4
- # Yes, we want graphics for admonishments:
- <xsl:param>admon.graphics=1
- # Set this one for PDF generation *only*:
- # default pnd graphics are awful in PDF form,
- # better use SVG's instead:
- <format>pdf:<xsl:param>admon.graphics.extension=".svg"
- <format>pdf:<xsl:param>use.role.for.mediaobject=1
- <format>pdf:<xsl:param>preferred.mediaobject.role=print
- <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/octonion/html
- ;
-
-
-

Modified: branches/release/libs/math/doc/octonion/math-octonion.qbk
==============================================================================
--- branches/release/libs/math/doc/octonion/math-octonion.qbk (original)
+++ branches/release/libs/math/doc/octonion/math-octonion.qbk 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,16 +1,3 @@
-[article Boost.Octonions
- [quickbook 1.3]
- [copyright 2001-2003 Hubert Holin]
- [purpose Octonions]
- [license
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt http://www.boost.org/LICENSE_1_0.txt])
- ]
- [authors [Holin, Hubert]]
- [category math]
- [last-revision $Date: 2006-12-29 11:08:32 +0000 (Fri, 29 Dec 2006) $]
-]

[def __R ['[*R]]]
[def __C ['[*C]]]
@@ -24,300 +11,286 @@
[def __oct_quat_formula ['[^o = ('''α + βi + γj + δk) + (ε + ζi + ηj - θj)e' ''']]]
[def __oct_not_equal ['[^x(yz) '''≠''' (xy)z]]]

-[def __asinh [link boost_quaternions.math_special_functions.asinh asinh]]
-[def __acosh [link boost_quaternions.math_special_functions.acosh acosh]]
-[def __atanh [link boost_quaternions.math_special_functions.atanh atanh]]
-[def __sinc_pi [link boost_quaternions.math_special_functions.sinc_pi sinc_pi]]
-[def __sinhc_pi [link boost_quaternions.math_special_functions.sinhc_pi sinhc_pi]]
-
-[def __log1p [link boost_quaternions.math_special_functions.log1p log1p]]
-[def __expm1 [link boost_quaternions.math_special_functions.expm1 expm1]]
-[def __hypot [link boost_quaternions.math_special_functions.hypot hypot]]
-
-This manual is also available in
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-printer friendly PDF format].
+[mathpart octonions Octonions]

-[section Octonions]
+[section:oct_overview Overview]

-[section Overview]
-
-Octonions, like [@../../quaternion/html/index.html quaternions], are a relative of complex numbers.
+Octonions, like [link quaternions quaternions], are a relative of complex numbers.

Octonions see some use in theoretical physics.

-In practical terms, an octonion is simply an octuple of real numbers __octulple,
-which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
-are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
+In practical terms, an octonion is simply an octuple of real numbers __octulple,
+which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
+are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
are distinct objects which play essentially the same kind of role as ['[^i]] (or ['[^j]] or ['[^k]]).

-Addition and a multiplication is defined on the set of octonions,
-which generalize their quaternionic counterparts. The main novelty this time
-is that [*the multiplication is not only not commutative, is now not even
-associative] (i.e. there are octonions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
+Addition and a multiplication is defined on the set of octonions,
+which generalize their quaternionic counterparts. The main novelty this time
+is that [*the multiplication is not only not commutative, is now not even
+associative] (i.e. there are octonions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
A way of remembering things is by using the following multiplication table:

-[$../../../octonion/graphics/octonion_blurb17.jpeg]
+[$../../octonion/graphics/octonion_blurb17.jpeg]

-Octonions (and their kin) are described in far more details in this other
-[@../../../quaternion/TQE.pdf document]
-(with [@../../../quaternion/TQE_EA.pdf errata and addenda]).
-
-Some traditional constructs, such as the exponential, carry over without too
-much change into the realms of octonions, but other, such as taking a square root,
-do not (the fact that the exponential has a closed form is a result of the
-author, but the fact that the exponential exists at all for octonions is known
+Octonions (and their kin) are described in far more details in this other
+[@../../quaternion/TQE.pdf document]
+(with [@../../quaternion/TQE_EA.pdf errata and addenda]).
+
+Some traditional constructs, such as the exponential, carry over without too
+much change into the realms of octonions, but other, such as taking a square root,
+do not (the fact that the exponential has a closed form is a result of the
+author, but the fact that the exponential exists at all for octonions is known
since quite a long time ago).

[endsect]

-[section Header File]
+[section:oct_header Header File]

-The interface and implementation are both supplied by the header file
-[@../../../../../boost/math/octonion.hpp octonion.hpp].
+The interface and implementation are both supplied by the header file
+[@../../../../boost/math/octonion.hpp octonion.hpp].

[endsect]

-[section Synopsis]
+[section:oct_synopsis Synopsis]

 namespace boost{ namespace math{

- template<typename T> class ``[link boost_octonions.octonions.template_class_octonion octonion]``;
- template<> class ``[link boost_octonions.octonions.octonion_specializations octonion<float>]``;
- template<> class ``[link boost_octonions.octonion_double octonion<double>]``;
- template<> class ``[link boost_octonions.octonion_long_double octonion<long double>]``;
+ template<typename T> class ``[link math_toolkit.octonion octonion]``;
+ template<> class ``[link math_toolkit.oct_specialization octonion<float>]``;
+ template<> class ``[link math_octonion_double octonion<double>]``;
+ template<> class ``[link math_octonion_long_double octonion<long double>]``;

 // operators

- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.non_mem.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
-
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_octonions.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
+
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);

 template<typename T, typename charT, class traits>
- ::std::basic_istream<charT,traits> & ``[link boost_octonions.octonions.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, octonion<T> & o);
+ ::std::basic_istream<charT,traits> & ``[link math_toolkit.oct_non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, octonion<T> & o);

 template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits> & ``[link boost_octonions.octonions.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
+ ::std::basic_ostream<charT,traits> & ``[link math_toolkit.oct_non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);

 // values

- template<typename T> T ``[link boost_octonions.octonions.octonion_value_operations.real_and_unreal real]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonion_value_operations.real_and_unreal unreal]``(octonion<T> const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.real_and_unreal real]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.real_and_unreal unreal]``(octonion<T> const & o);

- template<typename T> T ``[link boost_octonions.octonions.octonion_value_operations.sup sup]``(octonion<T> const & o);
- template<typename T> T ``[link boost_octonions.octonions.octonion_value_operations.l1 l1]``(octonion<T>const & o);
- template<typename T> T ``[link boost_octonions.octonions.octonion_value_operations.abs abs]``(octonion<T> const & o);
- template<typename T> T ``[link boost_octonions.octonions.octonion_value_operations.norm norm]``(octonion<T>const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonion_value_operations.conj conj]``(octonion<T> const & o);
-
- template<typename T> octonion<T> ``[link boost_octonions.octonions.oct_create spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2, T const & phi3, T const & phi4, T const & phi5, T const & phi6);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.oct_create multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.oct_create cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.sup sup]``(octonion<T> const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.l1 l1]``(octonion<T>const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.abs abs]``(octonion<T> const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.norm norm]``(octonion<T>const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.conj conj]``(octonion<T> const & o);
+
+ template<typename T> octonion<T> ``[link math_toolkit.oct_create spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2, T const & phi3, T const & phi4, T const & phi5, T const & phi6);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_create multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_create cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);

 // transcendentals

- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.exp exp]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.cos cos]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.sin sin]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.tan tan]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.cosh cosh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.sinh sinh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.tanh tanh]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.exp exp]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cos cos]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sin sin]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tan tan]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cosh cosh]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sinh sinh]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tanh tanh]``(octonion<T> const & o);

- template<typename T> octonion<T> ``[link boost_octonions.octonions.octonions_transcendentals.pow pow]``(octonion<T> const & o, int n);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.pow pow]``(octonion<T> const & o, int n);

 } } // namespaces
-
+
[endsect]

-[section Template Class octonion]
+[section:octonion Template Class octonion]

 namespace boost{ namespace math {
-
+
 template<typename T>
 class octonion
 {
 public:
 typedef T value_type;

- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
- template<typename X>
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<X> const & a_recopier);
-
- T ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<T> ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- T ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<T> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<T> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<T> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<T> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<T> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<T> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<T> const & a_affecter);
- template<typename X>
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (T const & a_affecter);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
-
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (T const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (T const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (T const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (T const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
+ template<typename X>
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<X> const & a_recopier);
+
+ T ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
+ octonion<T> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
+
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
+ T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
+
+ ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
+ ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
+ ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<T> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<T> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
+
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<T> const & a_affecter);
+ template<typename X>
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (T const & a_affecter);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
+
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
+ template<typename X>
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
+ template<typename X>
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
+ template<typename X>
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
+ template<typename X>
+ octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 };

 } } // namespaces
-
+
[endsect]

-[section Octonion Specializations]
+[section:oct_specialization Octonion Specializations]

 namespace boost{ namespace math{
-
+
 template<>
 class octonion<float>
 {
 public:
 typedef float value_type;

- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<double> const & a_recopier);
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<long double> const & a_recopier);
-
- float ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<float> ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- float ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<float> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<float> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<float> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<float> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<float> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<float> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<float> const & a_affecter);
- template<typename X>
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (float const & a_affecter);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
-
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (float const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (float const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (float const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (float const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
+
+ float ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
+ octonion<float> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
+
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
+ float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
+
+ ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
+ ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
+ ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<float> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<float> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
+
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<float> const & a_affecter);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (float const & a_affecter);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
+
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 };

-[#boost_octonions.octonion_double]
+[#math_octonion_double]

 template<>
 class octonion<double>
@@ -325,65 +298,65 @@
 public:
 typedef double value_type;

- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<long double> const & a_recopier);
-
- double ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<double> ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<double> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<double> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<double> const & a_affecter);
- template<typename X>
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (double const & a_affecter);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
-
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (double const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (double const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (double const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (double const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
+
+ double ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
+ octonion<double> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
+
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
+ double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
+
+ ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
+ ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
+ ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
+
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<double> const & a_affecter);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (double const & a_affecter);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
+
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 };

-[#boost_octonions.octonion_long_double]
+[#math_octonion_long_double]

 template<>
 class octonion<long double>
@@ -391,69 +364,69 @@
 public:
 typedef long double value_type;

- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``( ::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & z1 = ::boost::math::quaternion<long double>());
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link boost_octonions.octonions.octonion_member_functions.constructors octonion]``(octonion<double> const & a_recopier);
-
- long double ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<long double> ``[link boost_octonions.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- long double ``[link boost_octonions.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<long double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<long double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<long double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<long double> ``[link boost_octonions.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<long double> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<long double> ``[link boost_octonions.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
- template<typename X>
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (long double const & a_affecter);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
-
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_octonions.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``( ::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & z1 = ::boost::math::quaternion<long double>());
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
+ explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
+
+ long double ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
+ octonion<long double> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
+
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
+ long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
+
+ ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
+ ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
+ ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<long double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<long double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
+
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (long double const & a_affecter);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
+
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 };

 } } // namespaces
-
+
[endsect]

-[section Octonion Member Typedefs]
+[section:oct_typedefs Octonion Member Typedefs]

[*value_type]

@@ -464,7 +437,7 @@
Float specialization version:

 typedef float value_type;
-
+
Double specialization version:

 typedef double value_type;
@@ -477,7 +450,7 @@

[endsect]

-[section Octonion Member Functions]
+[section:oct_mem_fun Octonion Member Functions]

[h3 Constructors]

@@ -486,7 +459,7 @@
 explicit octonion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
 explicit octonion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
 explicit octonion(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
- template<typename X>
+ template<typename X>
 explicit octonion(octonion<X> const & a_recopier);

Float specialization version:
@@ -494,7 +467,7 @@
 explicit octonion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
 explicit octonion(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
 explicit octonion(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
- explicit octonion(octonion<double> const & a_recopier);
+ explicit octonion(octonion<double> const & a_recopier);
 explicit octonion(octonion<long double> const & a_recopier);

Double specialization version:
@@ -513,19 +486,19 @@
 explicit octonion(octonion<float> const & a_recopier);
 explicit octonion(octonion<double> const & a_recopier);

-A default constructor is provided for each form, which initializes each component
-to the default values for their type (i.e. zero for floating numbers).
-This constructor can also accept one to eight base type arguments.
-A constructor is also provided to build octonions from one to four complex numbers
+A default constructor is provided for each form, which initializes each component
+to the default values for their type (i.e. zero for floating numbers).
+This constructor can also accept one to eight base type arguments.
+A constructor is also provided to build octonions from one to four complex numbers
sharing the same base type, and another taking one or two quaternions
-sharing the same base type. The unspecialized template also sports a
-templarized copy constructor, while the specialized forms have copy
-constructors from the other two specializations, which are explicit
-when a risk of precision loss exists. For the unspecialized form,
+sharing the same base type. The unspecialized template also sports a
+templarized copy constructor, while the specialized forms have copy
+constructors from the other two specializations, which are explicit
+when a risk of precision loss exists. For the unspecialized form,
the base type's constructors must not throw.

-Destructors and untemplated copy constructors (from the same type)
-are provided by the compiler. Converting copy constructors make use
+Destructors and untemplated copy constructors (from the same type)
+are provided by the compiler. Converting copy constructors make use
of a templated helper function in a "detail" subnamespace.

[h3 Other member functions]
@@ -535,10 +508,10 @@
 T real() const;
 octonion<T> unreal() const;

-Like complex number, octonions do have a meaningful notion of "real part",
-but unlike them there is no meaningful notion of "imaginary part".
-Instead there is an "unreal part" which itself is a octonion,
-and usually nothing simpler (as opposed to the complex number case).
+Like complex number, octonions do have a meaningful notion of "real part",
+but unlike them there is no meaningful notion of "imaginary part".
+Instead there is an "unreal part" which itself is a octonion,
+and usually nothing simpler (as opposed to the complex number case).
These are returned by the first two functions.

[h4 Individual Real Components]
@@ -552,7 +525,7 @@
 T R_component_7() const;
 T R_component_8() const;

-A octonion having eight real components, these are returned by
+A octonion having eight real components, these are returned by
these eight functions. Hence real and R_component_1 return the same value.

[h4 Individual Complex Components]
@@ -562,12 +535,12 @@
 ::std::complex<T> C_component_3() const;
 ::std::complex<T> C_component_4() const;

-A octonion likewise has four complex components. Actually, octonions
-are indeed a (left) vector field over the complexes, but beware, as
-for any octonion __oct_formula we also have __oct_complex_formula
-(note the [*minus] sign in the last factor).
-What the C_component_n functions return, however, are the complexes
-which could be used to build the octonion using the constructor, and
+A octonion likewise has four complex components. Actually, octonions
+are indeed a (left) vector field over the complexes, but beware, as
+for any octonion __oct_formula we also have __oct_complex_formula
+(note the [*minus] sign in the last factor).
+What the C_component_n functions return, however, are the complexes
+which could be used to build the octonion using the constructor, and
[*not] the components of the octonion on the basis ['[^(1, j, e', j')]].

[h4 Individual Quaternion Components]
@@ -575,24 +548,24 @@
 ::boost::math::quaternion<T> H_component_1() const;
 ::boost::math::quaternion<T> H_component_2() const;

-Likewise, for any octonion __oct_formula we also have __oct_quat_formula, though there
-is no meaningful vector-space-like structure based on the quaternions.
-What the H_component_n functions return are the quaternions which
+Likewise, for any octonion __oct_formula we also have __oct_quat_formula, though there
+is no meaningful vector-space-like structure based on the quaternions.
+What the H_component_n functions return are the quaternions which
could be used to build the octonion using the constructor.

[h3 Octonion Member Operators]
[h4 Assignment Operators]

 octonion<T> & operator = (octonion<T> const & a_affecter);
- template<typename X>
+ template<typename X>
 octonion<T> & operator = (octonion<X> const & a_affecter);
 octonion<T> & operator = (T const & a_affecter);
 octonion<T> & operator = (::std::complex<T> const & a_affecter);
 octonion<T> & operator = (::boost::math::quaternion<T> const & a_affecter);

-These perform the expected assignment, with type modification if
-necessary (for instance, assigning from a base type will set the
-real part to that value, and all other components to zero).
+These perform the expected assignment, with type modification if
+necessary (for instance, assigning from a base type will set the
+real part to that value, and all other components to zero).
For the unspecialized form, the base type's assignment operators must not throw.

[h4 Other Member Operators]
@@ -600,58 +573,58 @@
 octonion<T> & operator += (T const & rhs)
 octonion<T> & operator += (::std::complex<T> const & rhs);
 octonion<T> & operator += (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
 octonion<T> & operator += (octonion<X> const & rhs);

-These perform the mathematical operation `(*this)+rhs` and store the result in
-`*this`. The unspecialized form has exception guards, which the specialized
-forms do not, so as to insure exception safety. For the unspecialized form,
+These perform the mathematical operation `(*this)+rhs` and store the result in
+`*this`. The unspecialized form has exception guards, which the specialized
+forms do not, so as to insure exception safety. For the unspecialized form,
the base type's assignment operators must not throw.

 octonion<T> & operator -= (T const & rhs)
 octonion<T> & operator -= (::std::complex<T> const & rhs);
 octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
 octonion<T> & operator -= (octonion<X> const & rhs);

-These perform the mathematical operation `(*this)-rhs` and store the result
-in `*this`. The unspecialized form has exception guards, which the
-specialized forms do not, so as to insure exception safety.
+These perform the mathematical operation `(*this)-rhs` and store the result
+in `*this`. The unspecialized form has exception guards, which the
+specialized forms do not, so as to insure exception safety.
For the unspecialized form, the base type's assignment operators must not throw.

 octonion<T> & operator *= (T const & rhs)
 octonion<T> & operator *= (::std::complex<T> const & rhs);
 octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
 octonion<T> & operator *= (octonion<X> const & rhs);

-These perform the mathematical operation `(*this)*rhs` in this order
-(order is important as multiplication is not commutative for octonions)
-and store the result in `*this`. The unspecialized form has exception guards,
-which the specialized forms do not, so as to insure exception safety.
-For the unspecialized form, the base type's assignment operators must
-not throw. Also, for clarity's sake, you should always group the
-factors in a multiplication by groups of two, as the multiplication is
-not even associative on the octonions (though there are of course cases
+These perform the mathematical operation `(*this)*rhs` in this order
+(order is important as multiplication is not commutative for octonions)
+and store the result in `*this`. The unspecialized form has exception guards,
+which the specialized forms do not, so as to insure exception safety.
+For the unspecialized form, the base type's assignment operators must
+not throw. Also, for clarity's sake, you should always group the
+factors in a multiplication by groups of two, as the multiplication is
+not even associative on the octonions (though there are of course cases
where this does not matter, it usually does).

 octonion<T> & operator /= (T const & rhs)
 octonion<T> & operator /= (::std::complex<T> const & rhs);
 octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
 octonion<T> & operator /= (octonion<X> const & rhs);

-These perform the mathematical operation `(*this)*inverse_of(rhs)`
-in this order (order is important as multiplication is not commutative
-for octonions) and store the result in `*this`. The unspecialized form
-has exception guards, which the specialized forms do not, so as to
-insure exception safety. For the unspecialized form, the base
-type's assignment operators must not throw. As for the multiplication,
+These perform the mathematical operation `(*this)*inverse_of(rhs)`
+in this order (order is important as multiplication is not commutative
+for octonions) and store the result in `*this`. The unspecialized form
+has exception guards, which the specialized forms do not, so as to
+insure exception safety. For the unspecialized form, the base
+type's assignment operators must not throw. As for the multiplication,
remember to group any two factors using parenthesis.

[endsect]

-[section:non_mem Octonion Non-Member Operators]
+[section:oct_non_mem Octonion Non-Member Operators]

[h4 Unary Plus and Minus Operators]

@@ -709,7 +682,7 @@
 template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 template<typename T> octonion<T> operator / (octonion<T> const & lhs, octonion<T> const & rhs);

-These operators return `octonion<T>(lhs) /= rhs`. It is of course still an
+These operators return `octonion<T>(lhs) /= rhs`. It is of course still an
error to divide by zero...

[h4 Binary Equality Operators]
@@ -722,8 +695,8 @@
 template<typename T> bool operator == (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 template<typename T> bool operator == (octonion<T> const & lhs, octonion<T> const & rhs);

-These return true if and only if the four components of `octonion<T>(lhs)`
-are equal to their counterparts in `octonion<T>(rhs)`. As with any
+These return true if and only if the four components of `octonion<T>(lhs)`
+are equal to their counterparts in `octonion<T>(rhs)`. As with any
floating-type entity, this is essentially meaningless.

[h4 Binary Inequality Operators]
@@ -736,7 +709,7 @@
 template<typename T> bool operator != (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 template<typename T> bool operator != (octonion<T> const & lhs, octonion<T> const & rhs);

-These return true if and only if `octonion<T>(lhs) == octonion<T>(rhs)`
+These return true if and only if `octonion<T>(lhs) == octonion<T>(rhs)`
is false. As with any floating-type entity, this is essentially meaningless.

[h4 Stream Extractor]
@@ -744,11 +717,11 @@
 template<typename T, typename charT, class traits>
 ::std::basic_istream<charT,traits> & operator >> (::std::basic_istream<charT,traits> & is, octonion<T> & o);

-Extracts an octonion `o`. We accept any format which seems reasonable.
-However, since this leads to a great many ambiguities, decisions were made
+Extracts an octonion `o`. We accept any format which seems reasonable.
+However, since this leads to a great many ambiguities, decisions were made
to lift these. In case of doubt, stick to lists of reals.

-The input values must be convertible to T. If bad input is encountered,
+The input values must be convertible to T. If bad input is encountered,
calls `is.setstate(ios::failbit)` (which may throw `ios::failure` (27.4.5.3)).

Returns `is`.
@@ -781,10 +754,10 @@

 return os << s.str();
 }
-
+
[endsect]

-[section Octonion Value Operations]
+[section:oct_value_ops Octonion Value Operations]

[h4 Real and Unreal]

@@ -803,14 +776,14 @@

 template<typename T> T sup(octonion<T> const & o);

-This return the sup norm (the greatest among
+This return the sup norm (the greatest among
`abs(o.R_component_1())...abs(o.R_component_8()))` of the octonion.

[h4 l1]

 template<typename T> T l1(octonion<T> const & o);

-This return the l1 norm (`abs(o.R_component_1())+...+abs(o.R_component_8())`)
+This return the l1 norm (`abs(o.R_component_1())+...+abs(o.R_component_8())`)
of the octonion.

[h4 abs]
@@ -823,10 +796,10 @@

 template<typename T> T norm(octonion<T>const & o);

-This return the (Cayley) norm of the octonion. The term "norm" might
-be confusing, as most people associate it with the Euclidian norm
-(and quadratic functionals). For this version of (the mathematical
-objects known as) octonions, the Euclidian norm (also known as
+This return the (Cayley) norm of the octonion. The term "norm" might
+be confusing, as most people associate it with the Euclidian norm
+(and quadratic functionals). For this version of (the mathematical
+objects known as) octonions, the Euclidian norm (also known as
magnitude) is the square root of the Cayley norm.

[endsect]
@@ -837,149 +810,150 @@
 template<typename T> octonion<T> multipolar(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
 template<typename T> octonion<T> cylindrical(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);

-These build octonions in a way similar to the way polar builds
-complex numbers, as there is no strict equivalent to
+These build octonions in a way similar to the way polar builds
+complex numbers, as there is no strict equivalent to
polar coordinates for octonions.

-`spherical` is a simple transposition of `polar`, it takes as inputs a
-(positive) magnitude and a point on the hypersphere, given
-by three angles. The first of these, ['theta] has a natural range of
--pi to +pi, and the other two have natural ranges of
--pi/2 to +pi/2 (as is the case with the usual spherical
-coordinates in __R3). Due to the many symmetries and periodicities,
-nothing untoward happens if the magnitude is negative or the angles are
-outside their natural ranges. The expected degeneracies (a magnitude of
+`spherical` is a simple transposition of `polar`, it takes as inputs a
+(positive) magnitude and a point on the hypersphere, given
+by three angles. The first of these, ['theta] has a natural range of
+-pi to +pi, and the other two have natural ranges of
+-pi/2 to +pi/2 (as is the case with the usual spherical
+coordinates in __R3). Due to the many symmetries and periodicities,
+nothing untoward happens if the magnitude is negative or the angles are
+outside their natural ranges. The expected degeneracies (a magnitude of
zero ignores the angles settings...) do happen however.

-`cylindrical` is likewise a simple transposition of the usual
-cylindrical coordinates in __R3, which in turn is another derivative of
-planar polar coordinates. The first two inputs are the polar
-coordinates of the first __C component of the octonion. The third and
-fourth inputs are placed into the third and fourth __R components of the
+`cylindrical` is likewise a simple transposition of the usual
+cylindrical coordinates in __R3, which in turn is another derivative of
+planar polar coordinates. The first two inputs are the polar
+coordinates of the first __C component of the octonion. The third and
+fourth inputs are placed into the third and fourth __R components of the
octonion, respectively.

-`multipolar` is yet another simple generalization of polar coordinates.
+`multipolar` is yet another simple generalization of polar coordinates.
This time, both __C components of the octonion are given in polar coordinates.

-In this version of our implementation of octonions, there is no
-analogue of the complex value operation arg as the situation is
+In this version of our implementation of octonions, there is no
+analogue of the complex value operation arg as the situation is
somewhat more complicated.

[endsect]

-[section Octonions Transcendentals]
+[section:oct_trans Octonions Transcendentals]

-There is no `log` or `sqrt` provided for octonions in this implementation,
-and `pow` is likewise restricted to integral powers of the exponent.
-There are several reasons to this: on the one hand, the equivalent of
-analytic continuation for octonions ("branch cuts") remains to be
-investigated thoroughly (by me, at any rate...), and we wish to avoid
-the nonsense introduced in the standard by exponentiations of
-complexes by complexes (which is well defined, but not in the standard...).
-Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is
+There is no `log` or `sqrt` provided for octonions in this implementation,
+and `pow` is likewise restricted to integral powers of the exponent.
+There are several reasons to this: on the one hand, the equivalent of
+analytic continuation for octonions ("branch cuts") remains to be
+investigated thoroughly (by me, at any rate...), and we wish to avoid
+the nonsense introduced in the standard by exponentiations of
+complexes by complexes (which is well defined, but not in the standard...).
+Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is
just plain brain-dead...

-We do, however provide several transcendentals, chief among which is
-the exponential. That it allows for a "closed formula" is a result
-of the author (the existence and definition of the exponential, on the
-octonions among others, on the other hand, is a few centuries old).
-Basically, any converging power series with real coefficients which
-allows for a closed formula in __C can be transposed to __O. More
-transcendentals of this type could be added in a further revision upon
-request. It should be noted that it is these functions which force the
-dependency upon the
-[@../../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp]
-and the
-[@../../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp]
+We do, however provide several transcendentals, chief among which is
+the exponential. That it allows for a "closed formula" is a result
+of the author (the existence and definition of the exponential, on the
+octonions among others, on the other hand, is a few centuries old).
+Basically, any converging power series with real coefficients which
+allows for a closed formula in __C can be transposed to __O. More
+transcendentals of this type could be added in a further revision upon
+request. It should be noted that it is these functions which force the
+dependency upon the
+[@../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp]
+and the
+[@../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp]
headers.

[h4 exp]

- template<typename T>
+ template<typename T>
 octonion<T> exp(octonion<T> const & o);

Computes the exponential of the octonion.

[h4 cos]

- template<typename T>
+ template<typename T>
 octonion<T> cos(octonion<T> const & o);

Computes the cosine of the octonion

[h4 sin]

- template<typename T>
+ template<typename T>
 octonion<T> sin(octonion<T> const & o);

Computes the sine of the octonion.

[h4 tan]

- template<typename T>
+ template<typename T>
 octonion<T> tan(octonion<T> const & o);

Computes the tangent of the octonion.

[h4 cosh]

- template<typename T>
+ template<typename T>
 octonion<T> cosh(octonion<T> const & o);

Computes the hyperbolic cosine of the octonion.

[h4 sinh]

- template<typename T>
+ template<typename T>
 octonion<T> sinh(octonion<T> const & o);

Computes the hyperbolic sine of the octonion.

[h4 tanh]

- template<typename T>
+ template<typename T>
 octonion<T> tanh(octonion<T> const & o);

Computes the hyperbolic tangent of the octonion.

[h4 pow]

- template<typename T>
+ template<typename T>
 octonion<T> pow(octonion<T> const & o, int n);

Computes the n-th power of the octonion q.

[endsect]

-[section Test Program]
+[section:oct_tests Test Program]

-The [@../../../octonion/octonion_test.cpp octonion_test.cpp]
-test program tests octonions specialisations for float, double and long double
-([@../../../octonion/output.txt sample output]).
-
-If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
-output ([@../../../octonion/output_more.txt verbose output]); this will
-only be helpfull if you enable message output at the same time, of course
-(by uncommenting the relevant line in the test or by adding --log_level=messages
-to your command line,...). In that case, and if you are running interactively,
-you may in addition define the symbol BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to
-interactively test the input operator with input of your choice from the
+The [@../../octonion/octonion_test.cpp octonion_test.cpp]
+test program tests octonions specialisations for float, double and long double
+([@../../octonion/output.txt sample output]).
+
+If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
+output ([@../../octonion/output_more.txt verbose output]); this will
+only be helpfull if you enable message output at the same time, of course
+(by uncommenting the relevant line in the test or by adding --log_level=messages
+to your command line,...). In that case, and if you are running interactively,
+you may in addition define the symbol BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to
+interactively test the input operator with input of your choice from the
standard input (instead of hard-coding it in the test).

[endsect]

-[section Acknowledgements]
+[section:acknowledgements Acknowledgements]

-The mathematical text has been typeset with
-[@http://www.nisus-soft.com/ Nisus Writer].
-Jens Maurer has helped with portability and standard adherence, and was the
-Review Manager for this library. More acknowledgements in the
+The mathematical text has been typeset with
+[@http://www.nisus-soft.com/ Nisus Writer].
+Jens Maurer has helped with portability and standard adherence, and was the
+Review Manager for this library. More acknowledgements in the
History section. Thank you to all who contributed to the discussion about this library.

[endsect]

-[section History]
+[section:oct_history History]

+* 1.5.9 - 13/5/2013: Incorporated into Boost.Math.
* 1.5.8 - 17/12/2005: Converted documentation to Quickbook Format.
* 1.5.7 - 25/02/2003: transitionned to the unit test framework; <boost/config.hpp> now included by the library header (rather than the test files), via <boost/math/quaternion.hpp>.
* 1.5.6 - 15/10/2002: Gcc2.95.x and stlport on linux compatibility by Alkis Evlogimenos (alkis_at_[hidden]).
@@ -994,16 +968,24 @@
* 1.3.0 - 12/07/2000: pow now uses Maarten Hilferink's (mhilferink_at_[hidden]) algorithm.
* 1.2.0 - 25/05/2000: fixed the division operators and output; changed many signatures.
* 1.1.0 - 23/05/2000: changed sinc into sinc_pi; added sin, cos, sinh, cosh.
-* 1.0.0 - 10/08/1999: first public version.
+* 1.0.0 - 10/08/1999: first public version.

[endsect]

-[section To Do]
+[section:oct_todo To Do]

* Improve testing.
* Rewrite input operatore using Spirit (creates a dependency).
-* Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
+* Put in place an Expression Template mechanism (perhaps borrowing from uBlas).

[endsect]

-[endsect]
+[endmathpart]
+
+
+[/
+Copyright 1999, 2005, 2013 Hubert Holin.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt).
+]

Deleted: branches/release/libs/math/doc/quaternion/Jamfile.v2
==============================================================================
--- branches/release/libs/math/doc/quaternion/Jamfile.v2 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
+++ (empty file)
@@ -1,66 +0,0 @@
-
-# Copyright John Maddock 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-using quickbook ;
-
-path-constant images_location : html ;
-
-xml quaternion : math-quaternion.qbk ;
-boostbook standalone
- :
- quaternion
- :
- # Path for links to Boost:
- <xsl:param>boost.root=../../../../..
-
- # Some general style settings:
- <xsl:param>table.footnote.number.format=1
- <xsl:param>footnote.number.format=1
-
- # HTML options first:
- # Use graphics not text for navigation:
- <xsl:param>navig.graphics=1
- # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=10
- # Don't put the first section on the same page as the TOC:
- <xsl:param>chunk.first.sections=1
- # How far down sections get TOC's
- <xsl:param>toc.section.depth=10
- # Max depth in each TOC:
- <xsl:param>toc.max.depth=4
- # How far down we go with TOC's
- <xsl:param>generate.section.toc.level=10
- #<xsl:param>root.filename="sf_dist_and_tools"
-
- # PDF Options:
- # TOC Generation: this is needed for FOP-0.9 and later:
- # <xsl:param>fop1.extensions=1
- <format>pdf:<xsl:param>xep.extensions=1
- # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
- <format>pdf:<xsl:param>fop.extensions=0
- <format>pdf:<xsl:param>fop1.extensions=0
- # No indent on body text:
- <format>pdf:<xsl:param>body.start.indent=0pt
- # Margin size:
- <format>pdf:<xsl:param>page.margin.inner=0.5in
- # Margin size:
- <format>pdf:<xsl:param>page.margin.outer=0.5in
- # Paper type = A4
- <format>pdf:<xsl:param>paper.type=A4
- # Yes, we want graphics for admonishments:
- <xsl:param>admon.graphics=1
- # Set this one for PDF generation *only*:
- # default pnd graphics are awful in PDF form,
- # better use SVG's instead:
- <format>pdf:<xsl:param>admon.graphics.extension=".svg"
- <format>pdf:<xsl:param>use.role.for.mediaobject=1
- <format>pdf:<xsl:param>preferred.mediaobject.role=print
- <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/quaternion/html
- ;
-
-
-

Modified: branches/release/libs/math/doc/quaternion/math-quaternion.qbk
==============================================================================
--- branches/release/libs/math/doc/quaternion/math-quaternion.qbk (original)
+++ branches/release/libs/math/doc/quaternion/math-quaternion.qbk 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,17 +1,3 @@
-[article Boost.Quaternions
- [quickbook 1.3]
- [copyright 2001-2003 Hubert Holin]
- [purpose Quaternions]
- [license
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt http://www.boost.org/LICENSE_1_0.txt])
- ]
- [authors [Holin, Hubert]]
- [category math]
- [last-revision $Date: 2006-12-29 11:08:32 +0000 (Fri, 29 Dec 2006) $]
-]
-
[def __R ['[*R]]]
[def __C ['[*C]]]
[def __H ['[*H]]]
@@ -23,210 +9,195 @@
[def __quat_complex_formula ['[^q = ('''α + βi) + (γ + δi)j''' ]]]
[def __not_equal ['[^xy '''≠''' yx]]]

-[def __asinh [link boost_quaternions.math_special_functions.asinh asinh]]
-[def __acosh [link boost_quaternions.math_special_functions.acosh acosh]]
-[def __atanh [link boost_quaternions.math_special_functions.atanh atanh]]
-[def __sinc_pi [link boost_quaternions.math_special_functions.sinc_pi sinc_pi]]
-[def __sinhc_pi [link boost_quaternions.math_special_functions.sinhc_pi sinhc_pi]]
-
-[def __log1p [link boost_quaternions.math_special_functions.log1p log1p]]
-[def __expm1 [link boost_quaternions.math_special_functions.expm1 expm1]]
-[def __hypot [link boost_quaternions.math_special_functions.hypot hypot]]
-
-This manual is also available in
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-printer friendly PDF format].
+[mathpart quaternions Quaternions]

-
-[section Quaternions]
-
-[section Overview]
+[section:quat_overview Overview]

Quaternions are a relative of complex numbers.

-Quaternions are in fact part of a small hierarchy of structures built
-upon the real numbers, which comprise only the set of real numbers
-(traditionally named __R), the set of complex numbers (traditionally named __C),
-the set of quaternions (traditionally named __H) and the set of octonions
-(traditionally named __O), which possess interesting mathematical properties
-(chief among which is the fact that they are ['division algebras],
-['i.e.] where the following property is true: if ['[^y]] is an element of that
-algebra and is [*not equal to zero], then ['[^yx = yx']], where ['[^x]] and ['[^x']]
-denote elements of that algebra, implies that ['[^x = x']]).
+Quaternions are in fact part of a small hierarchy of structures built
+upon the real numbers, which comprise only the set of real numbers
+(traditionally named __R), the set of complex numbers (traditionally named __C),
+the set of quaternions (traditionally named __H) and the set of octonions
+(traditionally named __O), which possess interesting mathematical properties
+(chief among which is the fact that they are ['division algebras],
+['i.e.] where the following property is true: if ['[^y]] is an element of that
+algebra and is [*not equal to zero], then ['[^yx = yx']], where ['[^x]] and ['[^x']]
+denote elements of that algebra, implies that ['[^x = x']]).
Each member of the hierarchy is a super-set of the former.

-One of the most important aspects of quaternions is that they provide an
-efficient way to parameterize rotations in __R3 (the usual three-dimensional space)
+One of the most important aspects of quaternions is that they provide an
+efficient way to parameterize rotations in __R3 (the usual three-dimensional space)
and __R4.

-In practical terms, a quaternion is simply a quadruple of real numbers __quadrulple,
-which we can write in the form __quat_formula, where ['[^i]] is the same object as for complex numbers,
+In practical terms, a quaternion is simply a quadruple of real numbers __quadrulple,
+which we can write in the form __quat_formula, where ['[^i]] is the same object as for complex numbers,
and ['[^j]] and ['[^k]] are distinct objects which play essentially the same kind of role as ['[^i]].

-An addition and a multiplication is defined on the set of quaternions,
-which generalize their real and complex counterparts. The main novelty
-here is that [*the multiplication is not commutative] (i.e. there are
-quaternions ['[^x]] and ['[^y]] such that __not_equal). A good mnemotechnical way of remembering
+An addition and a multiplication is defined on the set of quaternions,
+which generalize their real and complex counterparts. The main novelty
+here is that [*the multiplication is not commutative] (i.e. there are
+quaternions ['[^x]] and ['[^y]] such that __not_equal). A good mnemotechnical way of remembering
things is by using the formula ['[^i*i = j*j = k*k = -1]].

-Quaternions (and their kin) are described in far more details in this
-other [@../../../quaternion/TQE.pdf document]
-(with [@../../../quaternion/TQE_EA.pdf errata and addenda]).
+Quaternions (and their kin) are described in far more details in this
+other [@../../quaternion/TQE.pdf document]
+(with [@../../quaternion/TQE_EA.pdf errata and addenda]).

-Some traditional constructs, such as the exponential, carry over without
-too much change into the realms of quaternions, but other, such as taking
+Some traditional constructs, such as the exponential, carry over without
+too much change into the realms of quaternions, but other, such as taking
a square root, do not.

[endsect]

-[section Header File]
+[section:quat_header Header File]

-The interface and implementation are both supplied by the header file
-[@../../../../../boost/math/quaternion.hpp quaternion.hpp].
+The interface and implementation are both supplied by the header file
+[@../../../../boost/math/quaternion.hpp quaternion.hpp].

[endsect]

-[section Synopsis]
+[section:quat_synopsis Synopsis]

 namespace boost{ namespace math{
-
- template<typename T> class ``[link boost_quaternions.quaternions.quat quaternion]``;
- template<> class ``[link boost_quaternions.quaternions.spec quaternion<float>]``;
- template<> class ``[link boost_quaternions.quaternion_double quaternion<double>]``;
- template<> class ``[link boost_quaternions.quaternion_long_double quaternion<long double>]``;
+
+ template<typename T> class ``[link math_toolkit.quat quaternion]``;
+ template<> class ``[link math_toolkit.spec quaternion<float>]``;
+ template<> class ``[link math_quaternion_double quaternion<double>]``;
+ template<> class ``[link math_quaternion_long_double quaternion<long double>]``;

 // operators
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.unary_plus operator +]`` (quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.unary_minus operator -]`` (quaternion<T> const & q);
-
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_subtraction_operators operator -]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_multiplication_operators operator *]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_division_operators operator /]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.unary_plus operator +]`` (quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.quat_non_mem.unary_minus operator -]`` (quaternion<T> const & q);
+
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.equality_operators operator ==]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.inequality_operators operator !=]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.quat_non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);

 template<typename T, typename charT, class traits>
- ::std::basic_istream<charT,traits>& ``[link boost_quaternions.quaternions.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, quaternion<T> & q);
+ ::std::basic_istream<charT,traits>& ``[link math_toolkit.quat_non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, quaternion<T> & q);

 template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits>& operator ``[link boost_quaternions.quaternions.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);
+ ::std::basic_ostream<charT,traits>& operator ``[link math_toolkit.quat_non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);

 // values
- template<typename T> T ``[link boost_quaternions.quaternions.value_op.real_and_unreal real]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.value_op.real_and_unreal unreal]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.real_and_unreal real]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.value_op.real_and_unreal unreal]``(quaternion<T> const & q);

- template<typename T> T ``[link boost_quaternions.quaternions.value_op.sup sup]``(quaternion<T> const & q);
- template<typename T> T ``[link boost_quaternions.quaternions.value_op.l1 l1]``(quaternion<T> const & q);
- template<typename T> T ``[link boost_quaternions.quaternions.value_op.abs abs]``(quaternion<T> const & q);
- template<typename T> T ``[link boost_quaternions.quaternions.value_op.norm norm]``(quaternion<T>const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.value_op.conj conj]``(quaternion<T> const & q);
-
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_spherical spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2);
+ template<typename T> T ``[link math_toolkit.value_op.sup sup]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.l1 l1]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.abs abs]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.norm norm]``(quaternion<T>const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.value_op.conj conj]``(quaternion<T> const & q);
+
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2);

 // transcendentals
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.exp exp]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.cos cos]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.sin sin]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.tan tan]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.cosh cosh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.sinh sinh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.tanh tanh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.pow pow]``(quaternion<T> const & q, int n);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.exp exp]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.cos cos]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.sin sin]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.tan tan]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.cosh cosh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.sinh sinh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.tanh tanh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.pow pow]``(quaternion<T> const & q, int n);

 } // namespace math
 } // namespace boost
-
+
[endsect]

[section:quat Template Class quaternion]

 namespace boost{ namespace math{
-
+
 template<typename T>
 class quaternion
 {
 public:

- typedef T ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
+ typedef T ``[link math_toolkit.mem_typedef value_type]``;

- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
- template<typename X>
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<X> const & a_recopier);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
+ template<typename X>
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<X> const & a_recopier);

- T ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<T> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<T> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<T> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
+ T ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<T> ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts unreal]``() const;
+ T ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_1]``() const;
+ T ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_2]``() const;
+ T ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_3]``() const;
+ T ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<T> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<T> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_2]``() const;

- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<T> const & a_affecter);
- template<typename X>
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(T const & a_affecter);
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<T> const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<T> const & a_affecter);
+ template<typename X>
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(T const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(::std::complex<T> const & a_affecter);

- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(T const & rhs);
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(::std::complex<T> const & rhs);
 template<typename X>
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);

- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(T const & rhs);
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(::std::complex<T> const & rhs);
 template<typename X>
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);

- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(T const & rhs);
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(::std::complex<T> const & rhs);
 template<typename X>
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);

- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(T const & rhs);
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(::std::complex<T> const & rhs);
 template<typename X>
- quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
 };

 } // namespace math
 } // namespace boost
-
+
[endsect]

[section:spec Quaternion Specializations]
@@ -237,150 +208,150 @@
 class quaternion<float>
 {
 public:
- typedef float ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
-
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
-
- float ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<float> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<float> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<float> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
-
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<float> const & a_affecter);
- template<typename X>
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(float const & a_affecter);
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);
-
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(float const & rhs);
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<float> const & rhs);
- template<typename X>
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(float const & rhs);
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<float> const & rhs);
- template<typename X>
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(float const & rhs);
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<float> const & rhs);
+ typedef float ``[link math_toolkit.mem_typedef value_type]``;
+
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
+
+ float ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<float> ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts unreal]``() const;
+ float ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_1]``() const;
+ float ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_2]``() const;
+ float ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_3]``() const;
+ float ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<float> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<float> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_2]``() const;
+
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<float> const & a_affecter);
+ template<typename X>
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(float const & a_affecter);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);
+
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(::std::complex<float> const & rhs);
+ template<typename X>
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(::std::complex<float> const & rhs);
+ template<typename X>
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(::std::complex<float> const & rhs);
 template<typename X>
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);

- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(float const & rhs);
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<float> const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(::std::complex<float> const & rhs);
 template<typename X>
- quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<float>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
 };
-
-[#boost_quaternions.quaternion_double]
+
+[#math_quaternion_double]

 template<>
 class quaternion<double>
 {
 public:
- typedef double ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
-
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
-
- double ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<double> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
-
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<double> const & a_affecter);
- template<typename X>
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(double const & a_affecter);
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);
-
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(double const & rhs);
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<double> const & rhs);
- template<typename X>
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(double const & rhs);
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<double> const & rhs);
- template<typename X>
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(double const & rhs);
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<double> const & rhs);
+ typedef double ``[link math_toolkit.mem_typedef value_type]``;
+
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
+
+ double ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<double> ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts unreal]``() const;
+ double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_1]``() const;
+ double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_2]``() const;
+ double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_3]``() const;
+ double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<double> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<double> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_2]``() const;
+
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<double> const & a_affecter);
+ template<typename X>
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(double const & a_affecter);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);
+
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(::std::complex<double> const & rhs);
+ template<typename X>
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(::std::complex<double> const & rhs);
+ template<typename X>
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(::std::complex<double> const & rhs);
 template<typename X>
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);

- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(double const & rhs);
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<double> const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(::std::complex<double> const & rhs);
 template<typename X>
- quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<double>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
 };

-[#boost_quaternions.quaternion_long_double]
+[#math_quaternion_long_double]

 template<>
 class quaternion<long double>
 {
 public:
- typedef long double ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
-
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
- explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
-
- long double ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<long double> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<long double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<long double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
-
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<long double> const & a_affecter);
- template<typename X>
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(long double const & a_affecter);
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);
-
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<long double> const & rhs);
- template<typename X>
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs);
- template<typename X>
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs);
+ typedef long double ``[link math_toolkit.mem_typedef value_type]``;
+
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
+ explicit ``[link math_toolkit.quat_mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
+
+ long double ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<long double> ``[link math_toolkit.quat_mem_fun.real_and_unreal_parts unreal]``() const;
+ long double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_1]``() const;
+ long double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_2]``() const;
+ long double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_3]``() const;
+ long double ``[link math_toolkit.quat_mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<long double> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<long double> ``[link math_toolkit.quat_mem_fun.individual_complex_components C_component_2]``() const;
+
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<long double> const & a_affecter);
+ template<typename X>
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(long double const & a_affecter);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);
+
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(::std::complex<long double> const & rhs);
+ template<typename X>
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs);
 template<typename X>
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);

- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<long double> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs);
 template<typename X>
- quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(::std::complex<long double> const & rhs);
+ template<typename X>
+ quaternion<long double>& ``[link math_toolkit.quat_mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
 };

 } // namespace math
 } // namespace boost
-
+
[endsect]

[section:mem_typedef Quaternion Member Typedefs]
@@ -407,7 +378,7 @@

[endsect]

-[section:mem_fun Quaternion Member Functions]
+[section:quat_mem_fun Quaternion Member Functions]
[h3 Constructors]

Template version:
@@ -421,7 +392,7 @@

 explicit quaternion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
 explicit quaternion(::std::complex<float> const & z0,::std::complex<float> const & z1 = ::std::complex<float>());
- explicit quaternion(quaternion<double> const & a_recopier);
+ explicit quaternion(quaternion<double> const & a_recopier);
 explicit quaternion(quaternion<long double> const & a_recopier);

Double specialization version:
@@ -434,23 +405,23 @@
Long double specialization version:

 explicit quaternion(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
- explicit quaternion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
+ explicit quaternion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
 explicit quaternion(quaternion<float> const & a_recopier);
 explicit quaternion(quaternion<double> const & a_recopier);

-A default constructor is provided for each form, which initializes
-each component to the default values for their type
-(i.e. zero for floating numbers). This constructor can also accept
-one to four base type arguments. A constructor is also provided to
-build quaternions from one or two complex numbers sharing the same
-base type. The unspecialized template also sports a templarized copy
-constructor, while the specialized forms have copy constructors
-from the other two specializations, which are explicit when a risk of
-precision loss exists. For the unspecialized form, the base type's
+A default constructor is provided for each form, which initializes
+each component to the default values for their type
+(i.e. zero for floating numbers). This constructor can also accept
+one to four base type arguments. A constructor is also provided to
+build quaternions from one or two complex numbers sharing the same
+base type. The unspecialized template also sports a templarized copy
+constructor, while the specialized forms have copy constructors
+from the other two specializations, which are explicit when a risk of
+precision loss exists. For the unspecialized form, the base type's
constructors must not throw.

-Destructors and untemplated copy constructors (from the same type) are
-provided by the compiler. Converting copy constructors make use of a
+Destructors and untemplated copy constructors (from the same type) are
+provided by the compiler. Converting copy constructors make use of a
templated helper function in a "detail" subnamespace.

[h3 Other member functions]
@@ -459,10 +430,10 @@
 T real() const;
 quaternion<T> unreal() const;

-Like complex number, quaternions do have a meaningful notion of "real part",
-but unlike them there is no meaningful notion of "imaginary part".
-Instead there is an "unreal part" which itself is a quaternion,
-and usually nothing simpler (as opposed to the complex number case).
+Like complex number, quaternions do have a meaningful notion of "real part",
+but unlike them there is no meaningful notion of "imaginary part".
+Instead there is an "unreal part" which itself is a quaternion,
+and usually nothing simpler (as opposed to the complex number case).
These are returned by the first two functions.

[h4 Individual Real Components]
@@ -472,89 +443,89 @@
 T R_component_3() const;
 T R_component_4() const;

-A quaternion having four real components, these are returned by these four
+A quaternion having four real components, these are returned by these four
functions. Hence real and R_component_1 return the same value.

[h4 Individual Complex Components]

- ::std::complex<T> C_component_1() const;
- ::std::complex<T> C_component_2() const;
+ ::std::complex<T> C_component_1() const;
+ ::std::complex<T> C_component_2() const;

-A quaternion likewise has two complex components, and as we have seen above,
-for any quaternion __quat_formula we also have __quat_complex_formula. These functions return them.
+A quaternion likewise has two complex components, and as we have seen above,
+for any quaternion __quat_formula we also have __quat_complex_formula. These functions return them.
The real part of `q.C_component_1()` is the same as `q.real()`.

[h3 Quaternion Member Operators]
[h4 Assignment Operators]

 quaternion<T>& operator = (quaternion<T> const & a_affecter);
- template<typename X>
+ template<typename X>
 quaternion<T>& operator = (quaternion<X> const& a_affecter);
 quaternion<T>& operator = (T const& a_affecter);
 quaternion<T>& operator = (::std::complex<T> const& a_affecter);

-These perform the expected assignment, with type modification if necessary
-(for instance, assigning from a base type will set the real part to that
-value, and all other components to zero). For the unspecialized form,
+These perform the expected assignment, with type modification if necessary
+(for instance, assigning from a base type will set the real part to that
+value, and all other components to zero). For the unspecialized form,
the base type's assignment operators must not throw.

[h4 Addition Operators]

 quaternion<T>& operator += (T const & rhs)
 quaternion<T>& operator += (::std::complex<T> const & rhs);
- template<typename X>
+ template<typename X>
 quaternion<T>& operator += (quaternion<X> const & rhs);

-These perform the mathematical operation `(*this)+rhs` and store the result in
-`*this`. The unspecialized form has exception guards, which the specialized
-forms do not, so as to insure exception safety. For the unspecialized form,
+These perform the mathematical operation `(*this)+rhs` and store the result in
+`*this`. The unspecialized form has exception guards, which the specialized
+forms do not, so as to insure exception safety. For the unspecialized form,
the base type's assignment operators must not throw.

[h4 Subtraction Operators]

 quaternion<T>& operator -= (T const & rhs)
 quaternion<T>& operator -= (::std::complex<T> const & rhs);
- template<typename X>
+ template<typename X>
 quaternion<T>& operator -= (quaternion<X> const & rhs);

-These perform the mathematical operation `(*this)-rhs` and store the result
-in `*this`. The unspecialized form has exception guards, which the
-specialized forms do not, so as to insure exception safety.
-For the unspecialized form, the base type's assignment operators
+These perform the mathematical operation `(*this)-rhs` and store the result
+in `*this`. The unspecialized form has exception guards, which the
+specialized forms do not, so as to insure exception safety.
+For the unspecialized form, the base type's assignment operators
must not throw.

[h4 Multiplication Operators]

 quaternion<T>& operator *= (T const & rhs)
 quaternion<T>& operator *= (::std::complex<T> const & rhs);
- template<typename X>
+ template<typename X>
 quaternion<T>& operator *= (quaternion<X> const & rhs);

-These perform the mathematical operation `(*this)*rhs` [*in this order]
-(order is important as multiplication is not commutative for quaternions)
-and store the result in `*this`. The unspecialized form has exception guards,
-which the specialized forms do not, so as to insure exception safety.
+These perform the mathematical operation `(*this)*rhs` [*in this order]
+(order is important as multiplication is not commutative for quaternions)
+and store the result in `*this`. The unspecialized form has exception guards,
+which the specialized forms do not, so as to insure exception safety.
For the unspecialized form, the base type's assignment operators must not throw.

[h4 Division Operators]

 quaternion<T>& operator /= (T const & rhs)
 quaternion<T>& operator /= (::std::complex<T> const & rhs);
- template<typename X>
+ template<typename X>
 quaternion<T>& operator /= (quaternion<X> const & rhs);

-These perform the mathematical operation `(*this)*inverse_of(rhs)` [*in this
-order] (order is important as multiplication is not commutative for quaternions)
-and store the result in `*this`. The unspecialized form has exception guards,
-which the specialized forms do not, so as to insure exception safety.
+These perform the mathematical operation `(*this)*inverse_of(rhs)` [*in this
+order] (order is important as multiplication is not commutative for quaternions)
+and store the result in `*this`. The unspecialized form has exception guards,
+which the specialized forms do not, so as to insure exception safety.
For the unspecialized form, the base type's assignment operators must not throw.

[endsect]
-[section:non_mem Quaternion Non-Member Operators]
+[section:quat_non_mem Quaternion Non-Member Operators]

[h4 Unary Plus]

- template<typename T>
+ template<typename T>
 quaternion<T> operator + (quaternion<T> const & q);

This unary operator simply returns q.
@@ -568,66 +539,66 @@

[h4 Binary Addition Operators]

- template<typename T> quaternion<T> operator + (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> operator + (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator + (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> operator + (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return `quaternion<T>(lhs) += rhs`.

[h4 Binary Subtraction Operators]

- template<typename T> quaternion<T> operator - (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> operator - (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator - (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> operator - (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return `quaternion<T>(lhs) -= rhs`.

[h4 Binary Multiplication Operators]

- template<typename T> quaternion<T> operator * (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> operator * (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator * (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> operator * (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return `quaternion<T>(lhs) *= rhs`.

[h4 Binary Division Operators]

- template<typename T> quaternion<T> operator / (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> operator / (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator / (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> operator / (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, quaternion<T> const & rhs);

-These operators return `quaternion<T>(lhs) /= rhs`. It is of course still an
+These operators return `quaternion<T>(lhs) /= rhs`. It is of course still an
error to divide by zero...

[h4 Equality Operators]

- template<typename T> bool operator == (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool operator == (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool operator == (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool operator == (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool operator == (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> bool operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool operator == (quaternion<T> const & lhs, quaternion<T> const & rhs);

These return true if and only if the four components of `quaternion<T>(lhs)`
-are equal to their counterparts in `quaternion<T>(rhs)`. As with any
+are equal to their counterparts in `quaternion<T>(rhs)`. As with any
floating-type entity, this is essentially meaningless.

[h4 Inequality Operators]

- template<typename T> bool operator != (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool operator != (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool operator != (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool operator != (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool operator != (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> bool operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool operator != (quaternion<T> const & lhs, quaternion<T> const & rhs);

-These return true if and only if `quaternion<T>(lhs) == quaternion<T>(rhs)` is
+These return true if and only if `quaternion<T>(lhs) == quaternion<T>(rhs)` is
false. As with any floating-type entity, this is essentially meaningless.

[h4 Stream Extractor]
@@ -635,21 +606,21 @@
 template<typename T, typename charT, class traits>
 ::std::basic_istream<charT,traits>& operator >> (::std::basic_istream<charT,traits> & is, quaternion<T> & q);

-Extracts a quaternion q of one of the following forms
+Extracts a quaternion q of one of the following forms
(with a, b, c and d of type `T`):

[^a (a), (a,b), (a,b,c), (a,b,c,d) (a,(c)), (a,(c,d)), ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b),(c,d))]

-The input values must be convertible to `T`. If bad input is encountered,
+The input values must be convertible to `T`. If bad input is encountered,
calls `is.setstate(ios::failbit)` (which may throw ios::failure (27.4.5.3)).

[*Returns:] `is`.

-The rationale for the list of accepted formats is that either we have a
-list of up to four reals, or else we have a couple of complex numbers,
-and in that case if it formated as a proper complex number, then it should
-be accepted. Thus potential ambiguities are lifted (for instance (a,b) is
-(a,b,0,0) and not (a,0,b,0), i.e. it is parsed as a list of two real numbers
+The rationale for the list of accepted formats is that either we have a
+list of up to four reals, or else we have a couple of complex numbers,
+and in that case if it formated as a proper complex number, then it should
+be accepted. Thus potential ambiguities are lifted (for instance (a,b) is
+(a,b,0,0) and not (a,0,b,0), i.e. it is parsed as a list of two real numbers
and not two complex numbers which happen to have imaginary parts equal to zero).

[h4 Stream Inserter]
@@ -660,11 +631,11 @@
Inserts the quaternion q onto the stream `os` as if it were implemented as follows:

 template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits>& operator << (
+ ::std::basic_ostream<charT,traits>& operator << (
 ::std::basic_ostream<charT,traits> & os,
 quaternion<T> const & q)
 {
- ::std::basic_ostringstream<charT,traits> s;
+ ::std::basic_ostringstream<charT,traits> s;

 s.flags(os.flags());
 s.imbue(os.getloc());
@@ -677,209 +648,209 @@

 return os << s.str();
 }
-
+
[endsect]

[section:value_op Quaternion Value Operations]

[h4 real and unreal]

- template<typename T> T real(quaternion<T> const & q);
- template<typename T> quaternion<T> unreal(quaternion<T> const & q);
+ template<typename T> T real(quaternion<T> const & q);
+ template<typename T> quaternion<T> unreal(quaternion<T> const & q);

These return `q.real()` and `q.unreal()` respectively.

[h4 conj]

- template<typename T> quaternion<T> conj(quaternion<T> const & q);
+ template<typename T> quaternion<T> conj(quaternion<T> const & q);

This returns the conjugate of the quaternion.

[h4 sup]

-template<typename T> T sup(quaternion<T> const & q);
+template<typename T> T sup(quaternion<T> const & q);

-This return the sup norm (the greatest among
+This return the sup norm (the greatest among
`abs(q.R_component_1())...abs(q.R_component_4()))` of the quaternion.

[h4 l1]

- template<typename T> T l1(quaternion<T> const & q);
+ template<typename T> T l1(quaternion<T> const & q);

This return the l1 norm `(abs(q.R_component_1())+...+abs(q.R_component_4()))`
of the quaternion.

[h4 abs]

- template<typename T> T abs(quaternion<T> const & q);
+ template<typename T> T abs(quaternion<T> const & q);

This return the magnitude (Euclidian norm) of the quaternion.

[h4 norm]

- template<typename T> T norm(quaternion<T>const & q);
+ template<typename T> T norm(quaternion<T>const & q);

-This return the (Cayley) norm of the quaternion.
-The term "norm" might be confusing, as most people associate it with the
-Euclidian norm (and quadratic functionals). For this version of
-(the mathematical objects known as) quaternions, the Euclidian norm
+This return the (Cayley) norm of the quaternion.
+The term "norm" might be confusing, as most people associate it with the
+Euclidian norm (and quadratic functionals). For this version of
+(the mathematical objects known as) quaternions, the Euclidian norm
(also known as magnitude) is the square root of the Cayley norm.

[endsect]

[section:create Quaternion Creation Functions]

- template<typename T> quaternion<T> spherical(T const & rho, T const & theta, T const & phi1, T const & phi2);
- template<typename T> quaternion<T> semipolar(T const & rho, T const & alpha, T const & theta1, T const & theta2);
- template<typename T> quaternion<T> multipolar(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
- template<typename T> quaternion<T> cylindrospherical(T const & t, T const & radius, T const & longitude, T const & latitude);
- template<typename T> quaternion<T> cylindrical(T const & r, T const & angle, T const & h1, T const & h2);
+ template<typename T> quaternion<T> spherical(T const & rho, T const & theta, T const & phi1, T const & phi2);
+ template<typename T> quaternion<T> semipolar(T const & rho, T const & alpha, T const & theta1, T const & theta2);
+ template<typename T> quaternion<T> multipolar(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
+ template<typename T> quaternion<T> cylindrospherical(T const & t, T const & radius, T const & longitude, T const & latitude);
+ template<typename T> quaternion<T> cylindrical(T const & r, T const & angle, T const & h1, T const & h2);

-These build quaternions in a way similar to the way polar builds complex
+These build quaternions in a way similar to the way polar builds complex
numbers, as there is no strict equivalent to polar coordinates for quaternions.

-[#boost_quaternions.quaternions.creation_spherical] `spherical` is a simple transposition of `polar`, it takes as inputs
-a (positive) magnitude and a point on the hypersphere, given by three angles.
-The first of these, `theta` has a natural range of `-pi` to `+pi`, and the other
-two have natural ranges of `-pi/2` to `+pi/2` (as is the case with the usual
-spherical coordinates in __R3). Due to the many symmetries and periodicities,
-nothing untoward happens if the magnitude is negative or the angles are
-outside their natural ranges. The expected degeneracies (a magnitude of
+[#math_quaternions.creation_spherical] `spherical` is a simple transposition of `polar`, it takes as inputs
+a (positive) magnitude and a point on the hypersphere, given by three angles.
+The first of these, `theta` has a natural range of `-pi` to `+pi`, and the other
+two have natural ranges of `-pi/2` to `+pi/2` (as is the case with the usual
+spherical coordinates in __R3). Due to the many symmetries and periodicities,
+nothing untoward happens if the magnitude is negative or the angles are
+outside their natural ranges. The expected degeneracies (a magnitude of
zero ignores the angles settings...) do happen however.

-[#boost_quaternions.quaternions.creation_cylindrical] `cylindrical` is likewise a simple transposition of the usual
-cylindrical coordinates in __R3, which in turn is another derivative of
-planar polar coordinates. The first two inputs are the polar coordinates of
-the first __C component of the quaternion. The third and fourth inputs
-are placed into the third and fourth __R components of the quaternion,
+[#math_quaternions.creation_cylindrical] `cylindrical` is likewise a simple transposition of the usual
+cylindrical coordinates in __R3, which in turn is another derivative of
+planar polar coordinates. The first two inputs are the polar coordinates of
+the first __C component of the quaternion. The third and fourth inputs
+are placed into the third and fourth __R components of the quaternion,
respectively.

-[#boost_quaternions.quaternions.creation_multipolar] `multipolar` is yet another simple generalization of polar coordinates.
+[#math_quaternions.creation_multipolar] `multipolar` is yet another simple generalization of polar coordinates.
This time, both __C components of the quaternion are given in polar coordinates.

-[#boost_quaternions.quaternions.creation_cylindrospherical] `cylindrospherical` is specific to quaternions. It is often interesting to
-consider __H as the cartesian product of __R by __R3 (the quaternionic
-multiplication as then a special form, as given here). This function
-therefore builds a quaternion from this representation, with the __R3
+[#math_quaternions.creation_cylindrospherical] `cylindrospherical` is specific to quaternions. It is often interesting to
+consider __H as the cartesian product of __R by __R3 (the quaternionic
+multiplication as then a special form, as given here). This function
+therefore builds a quaternion from this representation, with the __R3
component given in usual __R3 spherical coordinates.

-[#boost_quaternions.quaternions.creation_semipolar] `semipolar` is another generator which is specific to quaternions.
-It takes as a first input the magnitude of the quaternion, as a
-second input an angle in the range `0` to `+pi/2` such that magnitudes
-of the first two __C components of the quaternion are the product of the
-first input and the sine and cosine of this angle, respectively, and finally
-as third and fourth inputs angles in the range `-pi/2` to `+pi/2` which
-represent the arguments of the first and second __C components of
-the quaternion, respectively. As usual, nothing untoward happens if
-what should be magnitudes are negative numbers or angles are out of their
+[#math_quaternions.creation_semipolar] `semipolar` is another generator which is specific to quaternions.
+It takes as a first input the magnitude of the quaternion, as a
+second input an angle in the range `0` to `+pi/2` such that magnitudes
+of the first two __C components of the quaternion are the product of the
+first input and the sine and cosine of this angle, respectively, and finally
+as third and fourth inputs angles in the range `-pi/2` to `+pi/2` which
+represent the arguments of the first and second __C components of
+the quaternion, respectively. As usual, nothing untoward happens if
+what should be magnitudes are negative numbers or angles are out of their
natural ranges, as symmetries and periodicities kick in.

-In this version of our implementation of quaternions, there is no
-analogue of the complex value operation `arg` as the situation is
-somewhat more complicated. Unit quaternions are linked both to
-rotations in __R3 and in __R4, and the correspondences are not too complicated,
-but there is currently a lack of standard (de facto or de jure) matrix
-library with which the conversions could work. This should be remedied in
-a further revision. In the mean time, an example of how this could be
-done is presented here for
-[@../../../quaternion/HSO3.hpp __R3], and here for
-[@../../../quaternion/HSO4.hpp __R4]
-([@../../../quaternion/HSO3SO4.cpp example test file]).
+In this version of our implementation of quaternions, there is no
+analogue of the complex value operation `arg` as the situation is
+somewhat more complicated. Unit quaternions are linked both to
+rotations in __R3 and in __R4, and the correspondences are not too complicated,
+but there is currently a lack of standard (de facto or de jure) matrix
+library with which the conversions could work. This should be remedied in
+a further revision. In the mean time, an example of how this could be
+done is presented here for
+[@../../quaternion/HSO3.hpp __R3], and here for
+[@../../quaternion/HSO4.hpp __R4]
+([@../../quaternion/HSO3SO4.cpp example test file]).

[endsect]

[section:trans Quaternion Transcendentals]

-There is no `log` or `sqrt` provided for quaternions in this implementation,
-and `pow` is likewise restricted to integral powers of the exponent.
-There are several reasons to this: on the one hand, the equivalent of
-analytic continuation for quaternions ("branch cuts") remains to be
-investigated thoroughly (by me, at any rate...), and we wish to avoid the
-nonsense introduced in the standard by exponentiations of complexes by
-complexes (which is well defined, but not in the standard...).
-Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is just
+There is no `log` or `sqrt` provided for quaternions in this implementation,
+and `pow` is likewise restricted to integral powers of the exponent.
+There are several reasons to this: on the one hand, the equivalent of
+analytic continuation for quaternions ("branch cuts") remains to be
+investigated thoroughly (by me, at any rate...), and we wish to avoid the
+nonsense introduced in the standard by exponentiations of complexes by
+complexes (which is well defined, but not in the standard...).
+Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is just
plain brain-dead...

-We do, however provide several transcendentals, chief among which is the
-exponential. This author claims the complete proof of the "closed formula"
-as his own, as well as its independant invention (there are claims to prior
-invention of the formula, such as one by Professor Shoemake, and it is
-possible that the formula had been known a couple of centuries back, but in
-absence of bibliographical reference, the matter is pending, awaiting further
-investigation; on the other hand, the definition and existence of the
-exponential on the quaternions, is of course a fact known for a very long time).
-Basically, any converging power series with real coefficients which allows for a
-closed formula in __C can be transposed to __H. More transcendentals of this
-type could be added in a further revision upon request. It should be
-noted that it is these functions which force the dependency upon the
-[@../../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp] and the
-[@../../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp] headers.
+We do, however provide several transcendentals, chief among which is the
+exponential. This author claims the complete proof of the "closed formula"
+as his own, as well as its independant invention (there are claims to prior
+invention of the formula, such as one by Professor Shoemake, and it is
+possible that the formula had been known a couple of centuries back, but in
+absence of bibliographical reference, the matter is pending, awaiting further
+investigation; on the other hand, the definition and existence of the
+exponential on the quaternions, is of course a fact known for a very long time).
+Basically, any converging power series with real coefficients which allows for a
+closed formula in __C can be transposed to __H. More transcendentals of this
+type could be added in a further revision upon request. It should be
+noted that it is these functions which force the dependency upon the
+[@../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp] and the
+[@../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp] headers.

[h4 exp]

- template<typename T> quaternion<T> exp(quaternion<T> const & q);
+ template<typename T> quaternion<T> exp(quaternion<T> const & q);

Computes the exponential of the quaternion.

[h4 cos]

- template<typename T> quaternion<T> cos(quaternion<T> const & q);
+ template<typename T> quaternion<T> cos(quaternion<T> const & q);

Computes the cosine of the quaternion

[h4 sin]

- template<typename T> quaternion<T> sin(quaternion<T> const & q);
+ template<typename T> quaternion<T> sin(quaternion<T> const & q);

Computes the sine of the quaternion.

[h4 tan]

- template<typename T> quaternion<T> tan(quaternion<T> const & q);
+ template<typename T> quaternion<T> tan(quaternion<T> const & q);

Computes the tangent of the quaternion.

[h4 cosh]

- template<typename T> quaternion<T> cosh(quaternion<T> const & q);
+ template<typename T> quaternion<T> cosh(quaternion<T> const & q);

Computes the hyperbolic cosine of the quaternion.

[h4 sinh]

- template<typename T> quaternion<T> sinh(quaternion<T> const & q);
+ template<typename T> quaternion<T> sinh(quaternion<T> const & q);

Computes the hyperbolic sine of the quaternion.

[h4 tanh]

- template<typename T> quaternion<T> tanh(quaternion<T> const & q);
+ template<typename T> quaternion<T> tanh(quaternion<T> const & q);

Computes the hyperbolic tangent of the quaternion.

[h4 pow]

- template<typename T> quaternion<T> pow(quaternion<T> const & q, int n);
+ template<typename T> quaternion<T> pow(quaternion<T> const & q, int n);

Computes the n-th power of the quaternion q.

[endsect]

-[section Test Program]
+[section:quat_tests Test Program]

-The [@../../../quaternion/quaternion_test.cpp quaternion_test.cpp]
-test program tests quaternions specializations for float, double and long double
-([@../../../quaternion/output.txt sample output], with message output
+The [@../../quaternion/quaternion_test.cpp quaternion_test.cpp]
+test program tests quaternions specializations for float, double and long double
+([@../../quaternion/output.txt sample output], with message output
enabled).

-If you define the symbol boost_quaternions_TEST_VERBOSE, you will get
-additional output ([@../../../quaternion/output_more.txt verbose output]);
-this will only be helpfull if you enable message output at the same time,
-of course (by uncommenting the relevant line in the test or by adding
-[^--log_level=messages] to your command line,...). In that case, and if you
-are running interactively, you may in addition define the symbol
-BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to interactively test the input
-operator with input of your choice from the standard input
+If you define the symbol TEST_VERBOSE, you will get
+additional output ([@../../quaternion/output_more.txt verbose output]);
+this will only be helpfull if you enable message output at the same time,
+of course (by uncommenting the relevant line in the test or by adding
+[^--log_level=messages] to your command line,...). In that case, and if you
+are running interactively, you may in addition define the symbol
+BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to interactively test the input
+operator with input of your choice from the standard input
(instead of hard-coding it in the test).

[endsect]
@@ -888,23 +859,24 @@

Please refer to the following PDF's:

-*[@../../../quaternion/TQE.pdf The Quaternionic Exponential (and beyond)]
-*[@../../../quaternion/TQE_EA.pdf The Quaternionic Exponential (and beyond) ERRATA & ADDENDA]
+*[@../../quaternion/TQE.pdf The Quaternionic Exponential (and beyond)]
+*[@../../quaternion/TQE_EA.pdf The Quaternionic Exponential (and beyond) ERRATA & ADDENDA]

[endsect]

-[section Acknowledgements]
+[section:acknowledgement Acknowledgements]

-The mathematical text has been typeset with
-[@http://www.nisus-soft.com/ Nisus Writer]. Jens Maurer has helped with
-portability and standard adherence, and was the Review Manager
-for this library. More acknowledgements in the History section.
+The mathematical text has been typeset with
+[@http://www.nisus-soft.com/ Nisus Writer]. Jens Maurer has helped with
+portability and standard adherence, and was the Review Manager
+for this library. More acknowledgements in the History section.
Thank you to all who contributed to the discution about this library.

[endsect]

-[section History]
+[section:quat_history History]

+* 1.5.9 - 13/5/2013: Incorporated into Boost.Math.
* 1.5.8 - 17/12/2005: Converted documentation to Quickbook Format.
* 1.5.7 - 24/02/2003: transitionned to the unit test framework; <boost/config.hpp> now included by the library header (rather than the test files).
* 1.5.6 - 15/10/2002: Gcc2.95.x and stlport on linux compatibility by Alkis Evlogimenos (alkis_at_[hidden]).
@@ -919,17 +891,28 @@
* 1.3.0 - 12/07/2000: pow now uses Maarten Hilferink's (mhilferink_at_[hidden]) algorithm.
* 1.2.0 - 25/05/2000: fixed the division operators and output; changed many signatures.
* 1.1.0 - 23/05/2000: changed sinc into sinc_pi; added sin, cos, sinh, cosh.
-* 1.0.0 - 10/08/1999: first public version.
+* 1.0.0 - 10/08/1999: first public version.

[endsect]
-[section To Do]
+[section:quat_todo To Do]

* Improve testing.
* Rewrite input operatore using Spirit (creates a dependency).
* Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
-* Use uBlas for the link with rotations (and move from the
-[@../../../quaternion/HSO3SO4.cpp example]
-implementation to an efficient one).
-
-[endsect]
+* Use uBlas for the link with rotations (and move from the
+[@../../quaternion/HSO3SO4.cpp example]
+implementation to an efficient one).
+
[endsect]
+[endmathpart]
+
+[/
+Copyright 1999, 2005, 2013 Hubert Holin.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt).
+]
+
+
+
+

Modified: branches/release/libs/math/example/binomial_quiz_example.cpp
==============================================================================
--- branches/release/libs/math/example/binomial_quiz_example.cpp (original)
+++ branches/release/libs/math/example/binomial_quiz_example.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -148,7 +148,7 @@
[pre
Probability of getting > 10 right (to pass) is 0.000285239
]
-But this should be resisted in favor of using the complement function. [link why_complements Why complements?]
+But this should be resisted in favor of using the __complements function (see __why_complements).
*/
cout << "Probability of getting > 10 right (to pass) is " << cdf(complement(quiz, 10)) << endl;
/*`
@@ -344,14 +344,11 @@

//[discrete_quantile_real
/*`
-Quantiles values are controlled by the
-[link math_toolkit.policy.pol_ref.discrete_quant_ref discrete quantile policy]
-chosen.
+Quantiles values are controlled by the __understand_dis_quant quantile policy chosen.
The default is `integer_round_outwards`,
so the lower quantile is rounded down, and the upper quantile is rounded up.

-But we might believe that the real values tell us a little more - see
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant Understanding Discrete Quantile Policy].
+But we might believe that the real values tell us a little more - see __math_discrete.

We could control the policy for *all* distributions by

Modified: branches/release/libs/math/example/fft_sines_table.cpp
==============================================================================
--- branches/release/libs/math/example/fft_sines_table.cpp (original)
+++ branches/release/libs/math/example/fft_sines_table.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -22,9 +22,9 @@
/*`[h5 Using Boost.Multiprecision to generate a high-precision array of sin coefficents for use with FFT.]

The Boost.Multiprecision library can be used for computations requiring precision
-exceeding that of standard built-in types such as float, double
-and long double. For extended-precision calculations, Boost.Multiprecision
-supplies a template data type called cpp_dec_float. The number of decimal
+exceeding that of standard built-in types such as `float`, `double`
+and `long double`. For extended-precision calculations, Boost.Multiprecision
+supplies a template data type called `cpp_dec_float`. The number of decimal
digits of precision is fixed at compile-time via template parameter.

To use these floating-point types and constants, we need some includes:
@@ -44,8 +44,8 @@
#include <fstream>

/*`Define a text string which is a C++ comment with the program licence, copyright etc.
-You could of course, tailor this to your needs, including copyright claim.
-There are versions of `array` provided by Boost/array in boost::array or
+You could of course, tailor this to your needs, including your copyright claim.
+There are versions of `array` provided by Boost.Array in `boost::array` or
the C++11 std::array, but since not all platforms provide C++11 support,
this program provides the Boost version as fallback.
*/
@@ -69,8 +69,8 @@

using boost::multiprecision::cpp_dec_float_50;
using boost::math::constants::pi;
-// VS 2010 (wrongly) requires these at file scope, not local scope in main.
-// This program also requires -std=c++11 option to compile using Clang and GCC.
+// VS 2010 (wrongly) requires these at file scope, not local scope in `main`.
+// This program also requires `-std=c++11` option to compile using Clang and GCC.

int main()
{
@@ -174,7 +174,7 @@
 fout << " " << sin_values[i];
 if (i == sin_values.size()-1)
 { // next is last value.
- fout << "\n}};\n"; // 2nd } needed for some GCC compiler versions.
+ fout << "\n}};\n"; // 2nd } needed for some earlier GCC compiler versions.
 break;
 }
 else
@@ -188,7 +188,7 @@
 std::cout << "Close file " << sines_name << " for output OK." << std::endl;

 }
-//`The output file generated can be seen at [@..\sines.hpp]
+//`The output file generated can be seen at [@../../example/sines.hpp]
//] [/fft_sines_table_example_1]

 return EXIT_SUCCESS;

Modified: branches/release/libs/math/example/find_location_example.cpp
==============================================================================
--- branches/release/libs/math/example/find_location_example.cpp (original)
+++ branches/release/libs/math/example/find_location_example.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -54,7 +54,7 @@
with mean (location) zero and standard deviation (scale) unity.
This is also the default for this implementation.
*/
- normal N01; // Default 'standard' normal distribution with zero mean and
+ normal N01; // Default 'standard' normal distribution with zero mean and
 double sd = 1.; // normal default standard deviation is 1.
/*`Suppose we want to find a different normal distribution whose mean is shifted
so that only fraction p (here 0.001 or 0.1%) are below a certain chosen limit
@@ -65,7 +65,7 @@

 cout << "Normal distribution with mean = " << N01.location()
 << ", standard deviation " << N01.scale()
- << ", has " << "fraction <= " << z
+ << ", has " << "fraction <= " << z
 << ", p = " << cdf(N01, z) << endl;
 cout << "Normal distribution with mean = " << N01.location()
 << ", standard deviation " << N01.scale()
@@ -95,11 +95,11 @@
/*`
And re-calculating the fraction below our chosen limit.
*/
-cout << "Normal distribution with mean = " << l
- << " has " << "fraction <= " << z
+cout << "Normal distribution with mean = " << l
+ << " has " << "fraction <= " << z
 << ", p = " << cdf(np001pc, z) << endl;
- cout << "Normal distribution with mean = " << l
- << " has " << "fraction > " << z
+ cout << "Normal distribution with mean = " << l
+ << " has " << "fraction > " << z
 << ", p = " << cdf(complement(np001pc, z)) << endl;
/*`
[pre
@@ -109,7 +109,7 @@

[h4 Controlling Error Handling from find_location]
We can also control the policy for handling various errors.
-For example, we can define a new (possibly unwise)
+For example, we can define a new (possibly unwise)
policy to ignore domain errors ('bad' arguments).

Unless we are using the boost::math namespace, we will need:
@@ -132,25 +132,24 @@
 // A new policy, ignoring domain errors, without using a typedef.
 l = find_location<normal>(z, p, sd, policy<domain_error<ignore_error> >());
/*`
-If we want to use a probability that is the
-[link complements complement of our probability],
+If we want to use a probability that is the __complements of our probability,
we should not even think of writing `find_location<normal>(z, 1 - p, sd)`,
-but, [link why_complements to avoid loss of accuracy], use the complement version.
+but use the complement version, see __why_complements.
*/
 z = 2.;
 double q = 0.95; // = 1 - p; // complement.
 l = find_location<normal>(complement(z, q, sd));

 normal np95pc(l, sd); // Same standard_deviation (scale) but with mean(location) shifted
- cout << "Normal distribution with mean = " << l << " has "
+ cout << "Normal distribution with mean = " << l << " has "
 << "fraction <= " << z << " = " << cdf(np95pc, z) << endl;
- cout << "Normal distribution with mean = " << l << " has "
+ cout << "Normal distribution with mean = " << l << " has "
 << "fraction > " << z << " = " << cdf(complement(np95pc, z)) << endl;
 //] [/find_location2]
 }
 catch(const std::exception& e)
- { // Always useful to include try & catch blocks because default policies
- // are to throw exceptions on arguments that cause errors like underflow, overflow.
+ { // Always useful to include try & catch blocks because default policies
+ // are to throw exceptions on arguments that cause errors like underflow, overflow.
 // Lacking try & catch blocks, the program will abort without a message below,
 // which may give some helpful clues as to the cause of the exception.
 std::cout <<

Modified: branches/release/libs/math/example/find_mean_and_sd_normal.cpp
==============================================================================
--- branches/release/libs/math/example/find_mean_and_sd_normal.cpp (original)
+++ branches/release/libs/math/example/find_mean_and_sd_normal.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -116,8 +116,8 @@
// Setting the packer to 3.06449 will mean that fraction of packs >= 2.9 is 0.95

/*`
-This calculation is generalized as the free function called
-[link math_toolkit.dist.dist_ref.dist_algorithms find_location].
+This calculation is generalized as the free function called `find_location`,
+see __algorithms.

To use this we will need to
*/
@@ -205,9 +205,9 @@
For other applications, where it is more difficult or expensive to make many observations,
the confidence intervals are depressingly wide.

-See [link math_toolkit.dist.stat_tut.weg.cs_eg.chi_sq_intervals Confidence Intervals on the standard deviation]
+See [link math_toolkit.stat_tut.weg.cs_eg.chi_sq_intervals Confidence Intervals on the standard deviation]
for a worked example
-[@../../../example/chi_square_std_dev_test.cpp chi_square_std_dev_test.cpp]
+[@../../example/chi_square_std_dev_test.cpp chi_square_std_dev_test.cpp]
of estimating these intervals.

@@ -261,8 +261,7 @@
/*`
Now we are getting really close, but to do the job properly,
we might need to use root finding method, for example the tools provided,
-and used elsewhere, in the Math Toolkit, see
-[link math_toolkit.toolkit.internals1.roots2 Root Finding Without Derivatives].
+and used elsewhere, in the Math Toolkit, see __root_finding_without_derivatives

But in this (normal) distribution case, we can and should be even smarter
and make a direct calculation.
@@ -278,7 +277,7 @@

Rearranging, we can directly calculate the required standard deviation:
*/
-normal N01; // standard normal distribution with meamn zero and unit standard deviation.
+normal N01; // standard normal distribution with mean zero and unit standard deviation.
p = 0.05;
double qp = quantile(N01, p);
double sd95 = (minimum_weight - mean) / qp;
@@ -328,7 +327,7 @@
// find_scale<normal>(minimum_weight, under_fraction, packs.mean()); 0.0607957

/*`But notice that using '1 - over_fraction' - will lead to a
-[link why_complements loss of accuracy, especially if over_fraction was close to unity.]
+loss of accuracy, especially if over_fraction was close to unity. (See __why_complements).
In this (very common) case, we should instead use the __complements,
giving the most accurate result.
*/

Modified: branches/release/libs/math/example/find_root_example.cpp
==============================================================================
--- branches/release/libs/math/example/find_root_example.cpp (original)
+++ branches/release/libs/math/example/find_root_example.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -33,7 +33,7 @@
 using std::exception;

//] //[/root_find1]
-
+
int main()
{
 cout << "Example: Normal distribution, root finding.";
@@ -42,9 +42,9 @@

//[root_find2

-/*`A machine is set to pack 3 kg of ground beef per pack.
+/*`A machine is set to pack 3 kg of ground beef per pack.
Over a long period of time it is found that the average packed was 3 kg
-with a standard deviation of 0.1 kg.
+with a standard deviation of 0.1 kg.
Assuming the packing is normally distributed,
we can find the fraction (or %) of packages that weigh more than 3.1 kg.
*/
@@ -58,7 +58,7 @@
<< cdf(complement(packs, max_weight)) << endl; // P(X > 3.1)

double under_weight = 2.9;
-cout <<"fraction of packs <= " << under_weight << " with a mean of " << mean
+cout <<"fraction of packs <= " << under_weight << " with a mean of " << mean
 << " is " << cdf(complement(packs, under_weight)) << endl;
// fraction of packs <= 2.9 with a mean of 3 is 0.841345
// This is 0.84 - more than the target 0.95
@@ -67,7 +67,7 @@
double over_mean = 3.0664;
normal xpacks(over_mean, standard_deviation);
cout << "fraction of packs >= " << under_weight
-<< " with a mean of " << xpacks.mean()
+<< " with a mean of " << xpacks.mean()
 << " is " << cdf(complement(xpacks, under_weight)) << endl;
// fraction of packs >= 2.9 with a mean of 3.06449 is 0.950005
double under_fraction = 0.05; // so 95% are above the minimum weight mean - sd = 2.9
@@ -77,7 +77,7 @@

normal nominal_packs(nominal_mean, standard_deviation);
cout << "Setting the packer to " << nominal_mean << " will mean that "
- << "fraction of packs >= " << under_weight
+ << "fraction of packs >= " << under_weight
 << " is " << cdf(complement(nominal_packs, under_weight)) << endl;

/*`
@@ -93,7 +93,7 @@
*/
double p = 0.05; // wanted p th quantile.
cout << "Quantile of " << p << " = " << quantile(packs, p)
- << ", mean = " << packs.mean() << ", sd = " << packs.standard_deviation() << endl; //
+ << ", mean = " << packs.mean() << ", sd = " << packs.standard_deviation() << endl; //
/*`
Quantile of 0.05 = 2.83551, mean = 3, sd = 0.1

@@ -103,14 +103,14 @@

Let's start by guessing that it (now 0.1) needs to be halved, to a standard deviation of 0.05
*/
-normal pack05(mean, 0.05);
-cout << "Quantile of " << p << " = " << quantile(pack05, p)
+normal pack05(mean, 0.05);
+cout << "Quantile of " <= " << under_weight << " with a mean of " << mean
+cout <<"Fraction of packs >= " << under_weight << " with a mean of " << mean
 << " and standard deviation of " << pack05.standard_deviation()
 << " is " << cdf(complement(pack05, under_weight)) << endl;
-//
+//
/*`
Fraction of packs >= 2.9 with a mean of 3 and standard deviation of 0.05 is 0.9772

@@ -119,11 +119,11 @@
more guessing to get closer, say by increasing to 0.06
*/

-normal pack06(mean, 0.06);
-cout << "Quantile of " << p << " = " << quantile(pack06, p)
+normal pack06(mean, 0.06);
+cout << "Quantile of " <= " << under_weight << " with a mean of " << mean
+cout <<"Fraction of packs >= " << under_weight << " with a mean of " << mean
 << " and standard deviation of " << pack06.standard_deviation()
 << " is " << cdf(complement(pack06, under_weight)) << endl;
/*`
@@ -131,8 +131,7 @@

Now we are getting really close, but to do the job properly,
we could use root finding method, for example the tools provided, and used elsewhere,
-in the Math Toolkit, see
-[link math_toolkit.toolkit.internals1.roots2 Root Finding Without Derivatives].
+in the Math Toolkit, see __root_finding_without_derivatives.

But in this normal distribution case, we could be even smarter and make a direct calculation.
*/
@@ -140,8 +139,8 @@

 }
 catch(const std::exception& e)
- { // Always useful to include try & catch blocks because default policies
- // are to throw exceptions on arguments that cause errors like underflow, overflow.
+ { // Always useful to include try & catch blocks because default policies
+ // are to throw exceptions on arguments that cause errors like underflow, overflow.
 // Lacking try & catch blocks, the program will abort without a message below,
 // which may give some helpful clues as to the cause of the exception.
 std::cout <<

Modified: branches/release/libs/math/example/find_scale_example.cpp
==============================================================================
--- branches/release/libs/math/example/find_scale_example.cpp (original)
+++ branches/release/libs/math/example/find_scale_example.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -21,7 +21,7 @@
#include <boost/math/distributions/normal.hpp> // for normal_distribution
 using boost::math::normal; // typedef provides default type is double.
#include <boost/math/distributions/find_scale.hpp>
- using boost::math::find_scale;
+ using boost::math::find_scale;
 using boost::math::complement; // Needed if you want to use the complement version.
 using boost::math::policies::policy; // Needed to specify the error handling policy.

@@ -55,7 +55,7 @@

 cout << "Normal distribution with mean = " << N01.location() // aka N01.mean()
 << ", standard deviation " << N01.scale() // aka N01.standard_deviation()
- << ", has " << "fraction <= " << z
+ << ", has " << "fraction <= " << z
 << ", p = " << cdf(N01, z) << endl;
 cout << "Normal distribution with mean = " << N01.location()
 << ", standard deviation " << N01.scale()
@@ -83,15 +83,15 @@
by constructing a new distribution
with the new standard deviation (but same zero mean):
*/
- normal np001pc(N01.location(), s);
+ normal np001pc(N01.location(), s);
/*`
And re-calculating the fraction below (and above) our chosen limit.
*/
- cout << "Normal distribution with mean = " << l
- << " has " << "fraction <= " << z
+ cout << "Normal distribution with mean = " << l
+ << " has " << "fraction <= " << z
 << ", p = " << cdf(np001pc, z) << endl;
- cout << "Normal distribution with mean = " << l
- << " has " << "fraction > " << z
+ cout << "Normal distribution with mean = " << l
+ << " has " << "fraction > " << z
 << ", p = " << cdf(complement(np001pc, z)) << endl;
/*`
[pre
@@ -101,7 +101,7 @@

[h4 Controlling how Errors from find_scale are handled]
We can also control the policy for handling various errors.
-For example, we can define a new (possibly unwise)
+For example, we can define a new (possibly unwise)
policy to ignore domain errors ('bad' arguments).

Unless we are using the boost::math namespace, we will need:
@@ -127,16 +127,16 @@
/*`
If we want to express a probability, say 0.999, that is a complement, `1 - p`
we should not even think of writing `find_scale<normal>(z, 1 - p, l)`,
-but [link why_complements instead], use the __complements version.
+but use the __complements version (see __why_complements).
*/
 z = -2.;
 double q = 0.999; // = 1 - p; // complement of 0.001.
 sd = find_scale<normal>(complement(z, q, l));

 normal np95pc(l, sd); // Same standard_deviation (scale) but with mean(scale) shifted
- cout << "Normal distribution with mean = " << l << " has "
+ cout << "Normal distribution with mean = " << l << " has "
 << "fraction <= " << z << " = " << cdf(np95pc, z) << endl;
- cout << "Normal distribution with mean = " << l << " has "
+ cout << "Normal distribution with mean = " << l << " has "
 << "fraction > " << z << " = " << cdf(complement(np95pc, z)) << endl;

/*`
@@ -154,8 +154,8 @@
//] [/find_scale2]
 }
 catch(const std::exception& e)
- { // Always useful to include try & catch blocks because default policies
- // are to throw exceptions on arguments that cause errors like underflow, overflow.
+ { // Always useful to include try & catch blocks because default policies
+ // are to throw exceptions on arguments that cause errors like underflow, overflow.
 // Lacking try & catch blocks, the program will abort without a message below,
 // which may give some helpful clues as to the cause of the exception.
 std::cout <<

Modified: branches/release/libs/math/example/geometric_examples.cpp
==============================================================================
--- branches/release/libs/math/example/geometric_examples.cpp (original)
+++ branches/release/libs/math/example/geometric_examples.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -8,7 +8,7 @@
// or copy at http://www.boost.org/LICENSE_1_0.txt)

// This file is written to be included from a Quickbook .qbk document.
-// It can still be compiled by the C++ compiler, and run.
+// It can still be compiled by the C++ compiler, and run.
// Any output can also be added here as comment or included or pasted in elsewhere.
// Caution: this file contains Quickbook markup as well as code
// and comments: don't change any of the special comment markups!
@@ -17,7 +17,7 @@

//[geometric_eg1_1
/*`
-For this example, we will opt to #define two macros to control
+For this example, we will opt to #define two macros to control
the error and discrete handling policies.
For this simple example, we want to avoid throwing
an exception (the default policy) and just return infinity.
@@ -34,7 +34,7 @@
*/
#include <boost/math/distributions/geometric.hpp>
 // for geometric_distribution
- using ::boost::math::geometric_distribution; //
+ using ::boost::math::geometric_distribution; //
 using ::boost::math::geometric; // typedef provides default type is double.
 using ::boost::math::pdf; // Probability mass function.
 using ::boost::math::cdf; // Cumulative density function.
@@ -52,7 +52,7 @@
 using std::cout; using std::endl;
 using std::noshowpoint; using std::fixed; using std::right; using std::left;
#include <iomanip>
- using std::setprecision; using std::setw;
+ using std::setprecision; using std::setw;

#include <limits>
 using std::numeric_limits;
@@ -81,7 +81,7 @@
is one with only two possible outcomes, success of failure,
and /p/ is the probability of success).

-Suppose an 'fair' 6-face dice is thrown repeatedly:
+Suppose an 'fair' 6-face dice is thrown repeatedly:
*/
 double success_fraction = 1./6; // success_fraction (p) = 0.1666
 // (so failure_fraction is 1 - success_fraction = 5./6 = 1- 0.1666 = 0.8333)
@@ -119,7 +119,7 @@

/*`If we allow many more (12) throws, the probability of getting our /three/ gets very high:*/
 cout << "cdf(g6, 12) = " << cdf(g6, 12) << endl; // 0.9065 or 90% probability.
-/*`If we want to be much more confident, say 99%,
+/*`If we want to be much more confident, say 99%,
we can estimate the number of throws to be this sure
using the inverse or quantile.
*/
@@ -127,8 +127,8 @@
/*`Note that the value returned is not an integer:
if you want an integer result you should use either floor, round or ceil functions,
or use the policies mechanism.
-See [link math_toolkit.policy.pol_tutorial.understand_dis_quant
-Understanding Quantiles of Discrete Distributions]
+
+See __understand_dis_quant.

The geometric distribution is related to the negative binomial
__spaces `negative_binomial_distribution(RealType r, RealType p);` with parameter /r/ = 1.
@@ -159,13 +159,13 @@

#ifdef BOOST_NO_CXX11_NUMERIC_LIMITS
 int max_digits10 = 2 + (boost::math::policies::digits<double, boost::math::policies::policy<> >() * 30103UL) / 100000UL;
- cout << "BOOST_NO_CXX11_NUMERIC_LIMITS is defined" << endl;
-#else
+ cout << "BOOST_NO_CXX11_NUMERIC_LIMITS is defined" << endl;
+#else
 int max_digits10 = std::numeric_limits<double>::max_digits10;
#endif
 cout << "Show all potentially significant decimal digits std::numeric_limits<double>::max_digits10 = "
- << max_digits10 << endl;
- cout.precision(max_digits10); //
+ << max_digits10 << endl;
+ cout.precision(max_digits10); //

 cout << cdf(g05, 0.0001) << endl; // returns 0.5000346561579232, not exact 0.5.
/*`To get the R discrete behaviour, you simply need to round with,
@@ -186,7 +186,7 @@
so the 'success_fraction' of finding a fault is 0.02.
It wants to interview a purchaser of faulty products to assess their 'user experience'.

-To estimate how many customers they will probably need to contact
+To estimate how many customers they will probably need to contact
in order to find one who has suffered from the fault,
we first construct a geometric distribution with probability 0.02,
and then chose a confidence, say 80%, 95%, or 99% to finding a customer with a fault.
@@ -202,20 +202,20 @@
 double c = 0.95; // 95% confidence.
 cout << " quantile(g, " << c << ") = " << quantile(g, c) << endl;

- cout << "To be " << c * 100
+ cout << "To be " << c * 100
 << "% confident of finding we customer with a fault, need to survey "
 << ceil(quantile(g, c)) << " customers." << endl; // 148
 c = 0.99; // Very confident.
- cout << "To be " << c * 100
+ cout << "To be " << c * 100
 << "% confident of finding we customer with a fault, need to survey "
 << ceil(quantile(g, c)) << " customers." << endl; // 227
 c = 0.80; // Only reasonably confident.
- cout << "To be " << c * 100
+ cout << "To be " << c * 100
 << "% confident of finding we customer with a fault, need to survey "
 << ceil(quantile(g, c)) << " customers." << endl; // 79

/*`[h6 Basket Ball Shooters]
-According to Wikipedia, average pro basket ball players get
+According to Wikipedia, average pro basket ball players get
[@http://en.wikipedia.org/wiki/Free_throw free throws]
in the baskets 70 to 80 % of the time,
but some get as high as 95%, and others as low as 50%.
@@ -224,7 +224,7 @@
To start we will consider the average shooter, say 75%.
So we construct a geometric distribution
with success_fraction parameter 75/100 = 0.75.
-*/
+*/
 cout.precision(2);
 geometric gav(0.75); // Shooter averages 7.5 out of 10 in the basket.
/*`What is probability of getting 1st try in the basket, that is with no failures? */
@@ -255,8 +255,8 @@
it is not the whole truth,
for it hides the big uncertainty when estimating from a single event.
"One swallow doesn't make a summer."
-To show the magnitude of the uncertainty, the geometric
-(or the negative binomial) distribution can be used.
+To show the magnitude of the uncertainty, the geometric
+(or the negative binomial) distribution can be used.

If we chose the popular 95% confidence in the limits, corresponding to an alpha of 0.05,
because we are calculating a two-sided interval, we must divide alpha by two.
@@ -265,7 +265,7 @@
 double k = 100; // So frequency of occurence is 1/100.
 cout << "Probability is failure is " << 1/k << endl;
 double t = geometric::find_lower_bound_on_p(k, alpha/2);
- cout << "geometric::find_lower_bound_on_p(" << int(k) << ", " << alpha/2 << ") = "
+ cout << "geometric::find_lower_bound_on_p(" << int(k) << ", " << alpha/2 << ") = "
 << t << endl; // 0.00025
 t = geometric::find_upper_bound_on_p(k, alpha/2);
 cout << "geometric::find_upper_bound_on_p(" << int(k) << ", " << alpha/2 << ") = "
@@ -302,8 +302,8 @@
 // an overflow exception should never be thrown.
 std::cout << "\nMessage from thrown exception was:\n " << e.what() << std::endl;
/*`
-For example, without a ignore domain error policy,
-if we asked for ``pdf(g, -1)`` for example,
+For example, without a ignore domain error policy,
+if we asked for ``pdf(g, -1)`` for example,
we would get an unhelpful abort, but with a catch:
[pre
Message from thrown exception was:
@@ -321,7 +321,7 @@
Output is:

 Geometric distribution example
-
+
 success fraction of a six-sided dice is 0.1667
 0.1667
 0.1667
@@ -350,7 +350,7 @@
 geometric::find_upper_bound_on_p(100, 0.05) = 0.03
 geometric::find_lower_bound_on_p(100, 0.005) = 5e-005
 geometric::find_upper_bound_on_p(100, 0.005) = 0.052
-
+
*/

Modified: branches/release/libs/math/example/nc_chi_sq_example.cpp
==============================================================================
--- branches/release/libs/math/example/nc_chi_sq_example.cpp (original)
+++ branches/release/libs/math/example/nc_chi_sq_example.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -1,5 +1,5 @@
// Copyright John Maddock 2008
-// Copyright Paul A. Bristow 2010
+// Copyright Paul A. Bristow 2010, 2013
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
@@ -108,7 +108,7 @@
[[20][0.0961][0.158][0.232][0.315][0.402][0.489][0.572][0.648][0.716][0.775]]
]

-See [@../../../example/nc_chi_sq_example.cpp nc_chi_sq_example.cpp] for the full C++ source code.
+See [@../../example/nc_chi_sq_example.cpp nc_chi_sq_example.cpp] for the full C++ source code.

*/

Modified: branches/release/libs/math/example/negative_binomial_example1.cpp
==============================================================================
--- branches/release/libs/math/example/negative_binomial_example1.cpp (original)
+++ branches/release/libs/math/example/negative_binomial_example1.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -63,7 +63,7 @@
 using std::cout; using std::endl;
 using std::noshowpoint; using std::fixed; using std::right; using std::left;
#include <iomanip>
- using std::setprecision; using std::setw;
+ using std::setprecision; using std::setw;

#include <limits>
 using std::numeric_limits;
@@ -71,13 +71,13 @@

int main()
{
- cout <<"Selling candy bars - using the negative binomial distribution."
+ cout <<"Selling candy bars - using the negative binomial distribution."
 << "\nby Dr. Diane Evans,"
 "\nProfessor of Mathematics at Rose-Hulman Institute of Technology,"
 << "\nsee http://en.wikipedia.org/wiki/Negative_binomial_distribution\n"
 << endl;
 cout << endl;
- cout.precision(5);
+ cout.precision(5);
 // None of the values calculated have a useful accuracy as great this, but
 // INF shows wrongly with < 5 !
 // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=240227
@@ -122,7 +122,7 @@

 int all_houses = 30; // The number of houses on the estate.

- cout << "With a success rate of " << nb.success_fraction()
+ cout << "With a success rate of " << nb.success_fraction()
 << ", he might expect, on average,\n"
 "to need to visit about " << success_fraction * all_houses
 << " houses in order to sell all " << nb.successes() << " bars. " << endl;
@@ -131,14 +131,13 @@
Pat has a sales per house success rate of 0.4.
Therefore he would, on average, sell 40 bars after trying 100 houses.
With a success rate of 0.4, he might expect, on average,
-to need to visit about 12 houses in order to sell all 5 bars.
+to need to visit about 12 houses in order to sell all 5 bars.
]

The random variable of interest is the number of houses
that must be visited to sell five candy bars,
so we substitute k = n - 5 into a negative_binomial(5, 0.4)
-and obtain the [link math.dist.pdf probability mass (density) function (pdf or pmf)]
-of the distribution of houses visited.
+and obtain the __pdf of the distribution of houses visited.
Obviously, the best possible case is that Pat makes sales on all the first five houses.

We calculate this using the pdf function:
@@ -182,7 +181,7 @@
]

Or, usually better, by using the negative binomial *cumulative* distribution function.
-*/
+*/
 cout << "\nProbability of selling his quota of " << sales_quota
 << " bars\non or before the " << 8 << "th house is "
 << cdf(nb, 8 - sales_quota) << endl;
@@ -222,14 +221,14 @@
]
Finally consider the risk of Pat not selling his quota of 5 bars
even after visiting all the houses.
-Calculate the probability that he /will/ sell on
+Calculate the probability that he /will/ sell on
or before the last house:
Calculate the probability that he would sell all his quota on the very last house.
*/
 cout << "Probability that Pat finishes on the " << all_houses
 << " house is " << pdf(nb, all_houses - sales_quota) << endl;
/*`
-Probability of selling his quota of 5 bars on the 30th house is
+Probability of selling his quota of 5 bars on the 30th house is
[pre
Probability that Pat finishes on the 30 house is 0.00069145
]
@@ -237,7 +236,7 @@

What is the probability that Pat exhausts all 30 houses in the neighborhood,
and *still* doesn't sell the required 5 candy bars?
-*/
+*/
 cout << "\nProbability of selling his quota of " << sales_quota
 << " bars\non or before the " << all_houses << "th house is "
 << cdf(nb, all_houses - sales_quota) << endl;
@@ -252,10 +251,9 @@
But using this expression may cause serious inaccuracy,
so it would be much better to use the complement of the cdf:
So the risk of failing even at, or after, the 31th (non-existent) houses is 1 - this probability,
- ``1 - cdf(nb, all_houses - sales_quota)``
-But using this expression may cause serious inaccuracy.
-So it would be much better to use the complement of the cdf.
-[link why_complements Why complements?]
+ ``1 - cdf(nb, all_houses - sales_quota)``
+But using this expression may cause serious inaccuracy.
+So it would be much better to use the __complement of the cdf (see __why_complements).
*/
 cout << "\nProbability of failing to sell his quota of " << sales_quota
 << " bars\neven after visiting all " << all_houses << " houses is "
@@ -268,7 +266,7 @@
We can also use the quantile (percentile), the inverse of the cdf, to
predict which house Pat will finish on. So for the 8th house:
*/
- double p = cdf(nb, (8 - sales_quota));
+ double p = cdf(nb, (8 - sales_quota));
 cout << "Probability of meeting sales quota on or before 8th house is "<< p << endl;
/*`
[pre
@@ -317,7 +315,7 @@
If the opposite is true, we don't want to assume any confidence, then this is tantamount
to assuming that all the first sales_quota trials will be successful sales.
*/
- cout << "If confidence of meeting quota is zero\n(we assume all houses are successful sales)"
+ cout << "If confidence of meeting quota is zero\n(we assume all houses are successful sales)"
 ", then finishing house is " << sales_quota << endl;
/*`
[pre
@@ -381,31 +379,31 @@
/*`
[pre
House for 5 th (last) sale. Probability (%)
-5 0.01024
-6 0.04096
+5 0.01024
+6 0.04096
7 0.096256
-8 0.17367
-9 0.26657
-10 0.3669
-11 0.46723
-12 0.56182
-13 0.64696
-14 0.72074
-15 0.78272
-16 0.83343
-17 0.874
-18 0.90583
-19 0.93039
-20 0.94905
-21 0.96304
-22 0.97342
-23 0.98103
-24 0.98655
-25 0.99053
-26 0.99337
-27 0.99539
-28 0.99681
-29 0.9978
+8 0.17367
+9 0.26657
+10 0.3669
+11 0.46723
+12 0.56182
+13 0.64696
+14 0.72074
+15 0.78272
+16 0.83343
+17 0.874
+18 0.90583
+19 0.93039
+20 0.94905
+21 0.96304
+22 0.97342
+23 0.98103
+24 0.98655
+25 0.99053
+26 0.99337
+27 0.99539
+28 0.99681
+29 0.9978
30 0.99849
]

@@ -441,12 +439,12 @@
Pat has a sales per house success rate of 0.4.
Therefore he would, on average, sell 40 bars after trying 100 houses.
With a success rate of 0.4, he might expect, on average,
-to need to visit about 12 houses in order to sell all 5 bars.
+to need to visit about 12 houses in order to sell all 5 bars.
Probability that Pat finishes on the 5th house is 0.01024
Probability that Pat finishes on the 6th house is 0.03072
Probability that Pat finishes on the 7th house is 0.055296
Probability that Pat finishes on the 8th house is 0.077414
-Probability that Pat finishes on or before the 8th house is sum
+Probability that Pat finishes on or before the 8th house is sum
pdf(sales_quota) + pdf(6) + pdf(7) + pdf(8) = 0.17367
Probability of selling his quota of 5 bars
on or before the 8th house is 0.17367
@@ -485,32 +483,32 @@
If confidence of meeting quota is 0.999, then finishing house is 31.1
If confidence of meeting quota is 1, then finishing house is 1.#J
House for 5th (last) sale. Probability (%)
-5 0.01024
-6 0.04096
+5 0.01024
+6 0.04096
7 0.096256
-8 0.17367
-9 0.26657
-10 0.3669
-11 0.46723
-12 0.56182
-13 0.64696
-14 0.72074
-15 0.78272
-16 0.83343
-17 0.874
-18 0.90583
-19 0.93039
-20 0.94905
-21 0.96304
-22 0.97342
-23 0.98103
-24 0.98655
-25 0.99053
-26 0.99337
-27 0.99539
-28 0.99681
-29 0.9978
-30 0.99849
+8 0.17367
+9 0.26657
+10 0.3669
+11 0.46723
+12 0.56182
+13 0.64696
+14 0.72074
+15 0.78272
+16 0.83343
+17 0.874
+18 0.90583
+19 0.93039
+20 0.94905
+21 0.96304
+22 0.97342
+23 0.98103
+24 0.98655
+25 0.99053
+26 0.99337
+27 0.99539
+28 0.99681
+29 0.9978
+30 0.99849

*/

Modified: branches/release/libs/math/example/nonfinite_facet_simple.cpp
==============================================================================
--- branches/release/libs/math/example/nonfinite_facet_simple.cpp (original)
+++ branches/release/libs/math/example/nonfinite_facet_simple.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -24,7 +24,7 @@
and imbue input and output streams with the non_finite_num put and get facets.
This allow output and input of infinity and NaN in a Standard portable way,
This permits 'loop-back' of output back into input (and portably across different system too).
-This is particularly useful when used with Boost.Seralization so that non-finite NaNs and infinity
+This is particularly useful when used with Boost.Serialization so that non-finite NaNs and infinity
values in text and xml archives can be handled correctly and portably.

*/
@@ -89,14 +89,15 @@

 // Output the nonfinite values using the current (default C) locale.
 // The default representations differ from system to system,
- // for example, using Microsoft compilers, 1.#INF, -1.#INF, and 1.#QNAN.
+ // for example, using Microsoft compilers, 1.#INF, -1.#INF, and 1.#QNAN,
+ // Linux "inf", "-inf", "nan"
 cout << "Using C locale" << endl;
 cout << "+std::numeric_limits<double>::infinity() = " << plus_infinity << endl;
 cout << "-std::numeric_limits<double>::infinity() = " << minus_infinity << endl;
 cout << "+std::numeric_limits<double>::quiet_NaN () = " << NaN << endl;

 // Display negated NaN.
- cout << "negated NaN " << negated_NaN << endl; // "-1.IND"
+ cout << "negated NaN " << negated_NaN << endl; // "-1.IND" or "-nan".

 // Create a new output locale, and add the nonfinite_num_put facet
 std::locale C99_out_locale (default_locale, new boost::math::nonfinite_num_put<char>);
@@ -106,14 +107,15 @@
 // Or for the same effect more concisely:
 cout.imbue (locale(locale(), new boost::math::nonfinite_num_put<char>));

- // Output using the new locale
+ // Output using the new locale:
 cout << "Using C99_out_locale " << endl;
 cout << "+std::numeric_limits<double>::infinity() = " << plus_infinity << endl;
 cout << "-std::numeric_limits<double>::infinity() = " << minus_infinity << endl;
 cout << "+std::numeric_limits<double>::quiet_NaN () = " << NaN << endl;
+ // Expect "inf", "-inf", "nan".

 // Display negated NaN.
- cout << "negated NaN " << negated_NaN << endl; // -nan
+ cout << "negated NaN " << negated_NaN << endl; // Expect "-nan".

 // Create a string with the expected C99 representation of plus infinity.
 std::string inf = "inf";
@@ -126,7 +128,7 @@
 // and read "inf" from the stringstream:
 iss >> infinity;

- // This will not work on all platforms!
+ // This will not work on all platforms! (Intel-Linux-13.0.1 fails EXIT STATUS: 139)
 if (! iss)
 { // Reading infinity went wrong!
 std::cerr << "C locale input format error!" << std::endl;

Modified: branches/release/libs/math/example/normal_misc_examples.cpp
==============================================================================
--- branches/release/libs/math/example/normal_misc_examples.cpp (original)
+++ branches/release/libs/math/example/normal_misc_examples.cpp 2013-05-24 07:17:51 EDT (Fri, 24 May 2013)
@@ -36,8 +36,8 @@
 {
 { // Traditional tables and values.
/*`Let's start by printing some traditional tables.
-*/
- double step = 1.; // in z
+*/
+ double step = 1.; // in z
 double range = 4; // min and max z = -range to +range.
 int precision = 17; // traditional tables are only computed to much lower precision.
 // but std::numeric_limits<double>::max_digits10; on new Standard Libraries gives
@@ -57,28 +57,28 @@
 cout.precision(5);
 for (double z = -range; z < range + step; z += step)
 {
- cout << left << setprecision(3) << setw(6) << z << " "
+ cout << left << setprecision(3) << setw(6) << z << " "
 << setprecision(precision) << setw(12) << pdf(s, z) << endl;
 }
 cout.precision(6); // default
 /*`And the area under the normal curve from -[infin] up to z,
 the cumulative distribution function (cdf).
*/
- // For a standard normal distribution
+ // For a standard normal distribution
 cout << "Standard normal mean = "<< s.mean()
 << ", standard deviation = " << s.standard_deviation() << endl;
 cout << "Integral (area under the curve) from - infinity up to z " << endl;
 cout << " z " " cdf " << endl;
 for (double z = -range; z < range + step; z += step)
 {
- cout << left << setprecision(3) << setw(6) << z << " "
+ cout << left << setprecision(3) << setw(6) << z << " "
 << setprecision(precision) << setw(12) << cdf(s, z) << endl;
 }
 cout.precision(6); // default

/*`And all this you can do with a nanoscopic amount of work compared to
the team of *human computers* toiling with Milton Abramovitz and Irene Stegen
-at the US National Bureau of Standards (now [@http://www.nist.gov NIST]).
+at the US National Bureau of Standards (now [@http://www.nist.gov NIST]).
Starting in 1938, their "Handbook of Mathematical Functions with Formulas, Graphs and Mathematical Tables",
was eventually published in 1964, and has been reprinted numerous times since.
(A major replacement is planned at [@http://dlmf.nist.gov Digital Library of Mathematical Functions]).
@@ -86,7 +86,7 @@
Pretty-printing a traditional 2-dimensional table is left as an exercise for the student,
but why bother now that the Math Toolkit lets you write
*/
- double z = 2.;
+ double z = 2.;
 cout << "Area for z = " << z << " is " << cdf(s, z) << endl; // to get the area for z.
/*`
Correspondingly, we can obtain the traditional 'critical' values for significance levels.
@@ -111,7 +111,7 @@
*/
 double alpha1 = cdf(s, -1) * 2; // 0.3173105078629142
 cout << setprecision(17) << "Significance level for z == 1 is " << alpha1 << endl;
-/*`
+/*`
 and place in our array of favorite alpha values.
*/
 double alpha[] = {0.3173105078629142, // z for 1 standard deviation.
@@ -127,7 +127,7 @@
 for (int i = 0; i < sizeof(alpha)/sizeof(alpha[0]); ++i)
 {
 cout << setw(15) << alpha[i] << setw(15) << alpha[i] /2 << setw(10) << quantile(complement(s, alpha[i]/2)) << endl;
- // Use quantile(complement(s, alpha[i]/2)) to avoid potential loss of accuracy from quantile(s, 1 - alpha[i]/2)
+ // Use quantile(complement(s, alpha[i]/2)) to avoid potential loss of accuracy from quantile(s, 1 - alpha[i]/2)
 }
 cout << endl;

@@ -181,7 +181,7 @@
[@http://en.wikipedia.org/wiki/Confidence_interval confidence intervals]
by using cout.precision(15);

-[pre
+[pre
Fraction 1 standard deviation within either side of mean is 0.682689492137086
Fraction 2 standard deviations within either side of mean is 0.954499736103642
Fraction 3 standard deviations within either side of mean is 0.997300203936740
@@ -209,7 +209,7 @@
*/
 double mean_life = 1100.;
 double life_standard_deviation = 100.;
- normal bulbs(mean_life, life_standard_deviation);
+ normal bulbs(mean_life, life_standard_deviation);
 double expected_life = 1000.;

/*`The we can use the Cumulative distribution function to predict fractions
@@ -224,7 +224,7 @@
 cout << "Fraction of bulbs that will last between "
 << min_life << " and " << max_life << " is "
 << cdf(bulbs, max_life) // P(X <= 1200)
- - cdf(bulbs, min_life) << endl; // P(X <= 900)
+ - cdf(bulbs, min_life) << endl; // P(X <= 900)
/*`
[note Real-life failures are often very ab-normal,
with a significant number that 'dead-on-arrival' or suffer failure very early in their life:
@@ -232,15 +232,15 @@
*/
//] [/normal_bulbs_example1 Quickbook end]
 }
- {
+ {
 // K. Krishnamoorthy, Handbook of Statistical Distributions with Applications,
- // ISBN 1 58488 635 8, page 125, Example 10.3.6
+ // ISBN 1 58488 635 8, page 125, Example 10.3.6

//[normal_bulbs_example3
/*`Weekly demand for 5 lb sacks of onions at a store is normally distributed with mean 140 sacks and standard deviation 10.
*/
 double mean = 140.; // sacks per week.
- double standard_deviation = 10;
+ double standard_deviation = 10;
 normal sacks(mean, standard_deviation);

 double stock = 160.; // per week.
@@ -260,13 +260,13 @@
//] [/normal_bulbs_example3 Quickbook end]
 }
 { // K. Krishnamoorthy, Handbook of Statistical Distributions with Applications,
- // ISBN 1 58488 635 8, page 125, Example 10.3.7
+ // ISBN 1 58488 635 8, page 125, Example 10.3.7

//[normal_bulbs_example4

-/*`A machine is set to pack 3 kg of ground beef per pack.
+/*`A machine is set to pack 3 kg of ground beef per pack.
Over a long period of time it is found that the average packed was 3 kg
-with a standard deviation of 0.1 kg.
+with a standard deviation of 0.1 kg.
Assuming the packing is normally distributed,
we can find the fraction (or %) of packages that weigh more than 3.1 kg.
*/
@@ -280,7 +280,7 @@
<< cdf(complement(packs, max_weight)) << endl; // P(X > 3.1)

double under_weight = 2.9;
-cout <<"fraction of packs <= " << under_weight << " with a mean of " << mean
+cout <<"fraction of packs <= " << under_weight << " with a mean of " << mean
 << " is " << cdf(complement(packs, under_weight)) << endl;
// fraction of packs <= 2.9 with a mean of 3 is 0.841345
// This is 0.84 - more than the target 0.95
@@ -289,7 +289,7 @@
double over_mean = 3.0664;
normal xpacks(over_mean, standard_deviation);
cout << "fraction of packs >= " << under_weight
-<< " with a mean of " << xpacks.mean()
+<< " with a mean of " << xpacks.mean()
 << " is " << cdf(complement(xpacks, under_weight)) << endl;
// fraction of packs >= 2.9 with a mean of 3.06449 is 0.950005
double under_fraction = 0.05; // so 95% are above the minimum weight mean - sd = 2.9
@@ -299,7 +299,7 @@

normal nominal_packs(nominal_mean, standard_deviation);
cout << "Setting the packer to " << nominal_mean << " will mean that "
- << "fraction of packs >= " << under_weight
+ << "fraction of packs >= " << under_weight
 << " is " << cdf(complement(nominal_packs, under_weight)) << endl;

/*`
@@ -315,7 +315,7 @@
*/
double p = 0.05; // wanted p th quantile.
cout << "Quantile of " << p << " = " << quantile(packs, p)
- << ", mean = " << packs.mean() << ", sd = " << packs.standard_deviation() << endl; //
+ << ", mean = " << packs.mean() << ", sd = " << packs.standard_deviation() << endl; //
/*`
Quantile of 0.05 = 2.83551, mean = 3, sd = 0.1

@@ -325,14 +325,14 @@

Let's start by guessing that it (now 0.1) needs to be halved, to a standard deviation of 0.05
*/
-normal pack05(mean, 0.05);
-cout << "Quantile of " << p << " = " << quantile(pack05, p)
+normal pack05(mean, 0.05);
+cout << "Quantile of " <= " << under_weight << " with a mean of " << mean
+cout <<"Fraction of packs >= " << under_weight << " with a mean of " << mean
 << " and standard deviation of " << pack05.standard_deviation()
 << " is " << cdf(complement(pack05, under_weight)) << endl;
-//
+//
/*`
Fraction of packs >= 2.9 with a mean of 3 and standard deviation of 0.05 is 0.9772

@@ -341,11 +341,11 @@
more guessing to get closer, say by increasing to 0.06
*/

-normal pack06(mean, 0.06);
-cout << "Quantile of " << p << " = " << quantile(pack06, p)
+normal pack06(mean, 0.06);
+cout << "Quantile of " <= " << under_weight << " with a mean of " << mean
+cout <<"Fraction of packs >= " << under_weight << " with a mean of " << mean
 << " and standard deviation of " << pack06.standard_deviation()
 << " is " << cdf(complement(pack06, under_weight)) << endl;
/*`
@@ -353,13 +353,12 @@

Now we are getting really close, but to do the job properly,
we could use root finding method, for example the tools provided, and used elsewhere,
-in the Math Toolkit, see
-[link math_toolkit.toolkit.internals1.roots2 Root Finding Without Derivatives].
+in the Math Toolkit, see __root_finding_without_derivatives.

But in this normal distribution case, we could be even smarter and make a direct calculation.
*/

-normal s; // For standard normal distribution,
+normal s; // For standard normal distribution,
double sd = 0.1;
double x = 2.9; // Our required limit.
// then probability p = N((x - mean) / sd)
@@ -373,11 +372,11 @@
// Rearranging, we can directly calculate the required standard deviation:
double sd95 = abs((x - mean)) / qp;

-cout << "If we want the "<< p << " th quantile to be located at "
+cout << "If we want the "<< p << " th quantile to be located at "
 << x << ", would need a standard deviation of " << sd95 << endl;

normal pack95(mean, sd95); // Distribution of the 'ideal better' packer.
-cout <<"Fraction of packs >= " << under_weight << " with a mean of " << mean
+cout <<"Fraction of packs >= " << under_weight << " with a mean of " << mean
 << " and standard deviation of " << pack95.standard_deviation()
 << " is " << cdf(complement(pack95, under_weight)) << endl;

@@ -398,16 +397,16 @@
 // ISBN 1 58488 635 8, page 125, example 10.3.8
//[normal_bulbs_example5
/*`A bolt is usable if between 3.9 and 4.1 long.
-From a large batch of bolts, a sample of 50 show a
+From a large batch of bolts, a sample of 50 show a
mean length of 3.95 with standard deviation 0.1.
Assuming a normal distribution, what proportion is usable?
-The true sample mean is unknown,
+The true sample mean is unknown,
but we can use the sample mean and standard deviation to find approximate solutions.
*/

 normal bolts(3.95, 0.1);
 double top = 4.1;
- double bottom = 3.9;
+ double bottom = 3.9;

cout << "Fraction long enough [ P(X <= " << top << ") ] is " << cdf(bolts, top) << endl;
cout << "Fraction too short [ P(X <= " << bottom << ") ] is " << cdf(bolts, bottom) << endl;
@@ -419,13 +418,13 @@
 << cdf(complement(bolts, top)) << endl;

cout << "95% of bolts are shorter than " << quantile(bolts, 0.95) << endl;
-
+
//] [/normal_bulbs_example5 Quickbook end]
 }
 }
 catch(const std::exception& e)
- { // Always useful to include try & catch blocks because default policies
- // are to throw exceptions on arguments that cause errors like underflow, overflow.
+ { // Always useful to include try & catch blocks because default policies
+ // are to throw exceptions on arguments that cause errors like underflow, overflow.
 // Lacking try & catch blocks, the program will abort without a message below,
 // which may give some helpful clues as to the cause of the exception.
 std::cout <<
@@ -442,7 +441,7 @@
Autorun "i:\boost-06-05-03-1300\libs\math\test\Math_test\debug\normal_misc_examples.exe"
Example: Normal distribution, Miscellaneous Applications.Standard normal distribution, mean = 0, standard deviation = 1
Probability distribution function values
- z pdf
+ z pdf
-4 0.00013383022576488537
-3 0.0044318484119380075
-2 0.053990966513188063
@@ -453,13 +452,13 @@
3 0.0044318484119380075
4 0.00013383022576488537
Standard normal mean = 0, standard deviation = 1
-Integral (area under the curve) from - infinity up to z
- z cdf
+Integral (area under the curve) from - infinity up to z
+ z cdf
-4 3.1671241833119979e-005
-3 0.0013498980316300959
-2 0.022750131948179219
-1 0.1586552539314571
-0 0.5
+0 0.5
1 0.84134474606854293
2 0.97724986805182079
3 0.9986501019683699
@@ -469,15 +468,15 @@
95% of area has a z between 1.95996 and -1.95996
Significance level for z == 1 is 0.3173105078629142
level of significance (alpha)
-2-sided 1 -sided z(alpha)
-0.3173 0.1587 1
-0.2 0.1 1.282
-0.1 0.05 1.645
-0.05 0.025 1.96
-0.01 0.005 2.576
-0.001 0.0005 3.291
-0.0001 5e-005 3.891
-1e-005 5e-006 4.417
+2-sided 1 -sided z(alpha)
+0.3173 0.1587 1
+0.2 0.1 1.282
+0.1 0.05 1.645
+0.05 0.025 1.96
+0.01 0.005 2.576
+0.001 0.0005 3.291
+0.0001 5e-005 3.891
+1e-005 5e-006 4.417
cdf(s, s.standard_deviation()) = 0.841
cdf(complement(s, s.standard_deviation())) = 0.159
Fraction 1 standard deviation within either side of mean is 0.683

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk