Boost-Commit :

Date view	Thread view	Subject view	Author view

From: john_at_[hidden]
Date: 2007-10-11 07:47:13

Next message: john_at_[hidden]: "[Boost-commit] svn:boost r39925 - trunk/libs/math"
Previous message: joaquin_at_[hidden]: "[Boost-commit] svn:boost r39923 - in trunk: boost/multi_index/detail libs/multi_index/example"

Author: johnmaddock
Date: 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
New Revision: 39924
URL: http://svn.boost.org/trac/boost/changeset/39924

Log:
Added Boost.Math overview.
Added:
   trunk/libs/math/doc/html/
   trunk/libs/math/doc/html/index.html (contents, props changed)
Removed:
   trunk/libs/math/doc/math-background.qbk
   trunk/libs/math/doc/math-gcd.qbk
   trunk/libs/math/doc/math-octonion.qbk
   trunk/libs/math/doc/math-quaternion.qbk
   trunk/libs/math/doc/math-sf.qbk
   trunk/libs/math/doc/math-tr1.qbk
Text files modified:
   trunk/libs/math/doc/Jamfile.v2 | 46 +++----
   trunk/libs/math/doc/common_factor.html | 5
   trunk/libs/math/doc/index.html | 5
   trunk/libs/math/doc/math.qbk | 226 +++++++++++++++++++++++++++++++--------
   4 files changed, 202 insertions(+), 80 deletions(-)

Modified: trunk/libs/math/doc/Jamfile.v2
==============================================================================
--- trunk/libs/math/doc/Jamfile.v2 (original)
+++ trunk/libs/math/doc/Jamfile.v2 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
@@ -5,37 +5,31 @@

using quickbook ;

-path-constant boost-images : ../../../doc/src/images ;
-path-constant images_location : ../../../doc/html ;
-
xml math : math.qbk ;
boostbook standalone
 :
 math
 :
- <xsl:param>nav.layout=none
- <xsl:param>navig.graphics=0
- # PDF Options:
- # TOC Generation: this is needed for FOP-0.9 and later:
- #<xsl:param>fop1.extensions=1
- # Or enable this if you're using XEP:
- <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!
- <xsl:param>fop.extensions=0
- # No indent on body text:
- <xsl:param>body.start.indent=0pt
- # Margin size:
- <xsl:param>page.margin.inner=0.5in
- # Margin size:
- <xsl:param>page.margin.outer=0.5in
- # 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>admon.graphics.path=$(boost-images)/
- <format>pdf:<xsl:param>img.src.path=$(images_location)/
+ # Path for links to Boost:
+ <xsl:param>boost.root=../../../..
+ # Path for libraries index:
+ <xsl:param>boost.libraries=../../../../libs/libraries.htm
+ # Use the main Boost stylesheet:
+ <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
+
+ # 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=1
+ # Don't put the first section on the same page as the TOC:
+ <xsl:param>chunk.first.sections=0
+ # How far down sections get TOC's
+ <xsl:param>toc.section.depth=1
 ;

Modified: trunk/libs/math/doc/common_factor.html
==============================================================================
--- trunk/libs/math/doc/common_factor.html (original)
+++ trunk/libs/math/doc/common_factor.html 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
@@ -1,11 +1,11 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
- <meta http-equiv="refresh" content="0; URL=../../../doc/html/boost_math/gcd_lcm.html">
+ <meta http-equiv="refresh" content="0; URL=gcd/html/index.html">
 </head>
 <body>
 Automatic redirection failed, please go to
- ../../../doc/html/boost_math/gcd_lcm.html
+ 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).
@@ -15,3 +15,4 @@

+

Added: trunk/libs/math/doc/html/index.html
==============================================================================
--- (empty file)
+++ trunk/libs/math/doc/html/index.html 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
@@ -0,0 +1,371 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.Math</title>
+<link rel="stylesheet" href="../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<link rel="start" href="index.html" title="Boost.Math">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+<div class="article" lang="en">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="boost_math"></a>Boost.Math</h2></div>
+<div><div class="legalnotice">
+<a name="id437518"></a>
+ 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)
+ 
+</div></div>
+</div>
+<hr>
+</div>
+
+ The following mathematical libraries are present in Boost:
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Library
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <a href="../complex/html/index.html" target="_top">Complex Number Inverse Trigonometric
+ Functions</a>
+ 
+ </td>
+<td>
+ 
+ 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 will be part of the forthcoming Technical
+ Report on C++ Standard Library Extensions.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <a href="../gcd/html/index.html" target="_top">Greatest Common Divisor and Least
+ Common Multiple</a>
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Integer
+ 
+ </td>
+<td>
+ 
+ Headers to ease dealing with integral types.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Interval
+ 
+ </td>
+<td>
+ 
+ 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>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Multi Array
+ 
+ </td>
+<td>
+ 
+ Boost.MultiArray provides a generic N-dimensional array concept definition
+ and common implementations of that interface.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Numeric.Conversion
+ 
+ </td>
+<td>
+ 
+ The Boost Numeric Conversion library is a collection of tools to describe
+ and perform conversions between values of different numeric types.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Octonions
+ 
+ </td>
+<td>
+ 
+ Octonions, like 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
+ (α,β,γ,δ,ε,ζ,η,θ), which we can write in the form <code class="literal">o = α + βi + γj + δk + εe' + ζi' + ηj' + θk'</code>,
+ where <code class="literal">i</code>, <code class="literal">j</code>
+ and <code class="literal">k</code> are the same objects as
+ for quaternions, and <code class="literal">e'</code>, <code class="literal">i'</code>,
+ <code class="literal">j'</code> and <code class="literal">k'</code>
+ are distinct objects which play essentially the same kind of role as
+ <code class="literal">i</code> (or <code class="literal">j</code>
+ or <code class="literal">k</code>).
+ 
+ 
+ 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 <code class="literal">x</code>,
+ <code class="literal">y</code> and <code class="literal">z</code>
+ such that <code class="literal">x(yz) ≠ (xy)z</code>). A way
+ of remembering things is by using the following multiplication table:
+ 
+ 
+ <img src="../../octonion/graphics/octonion_blurb17.jpeg" alt="octonion_blurb17">
+ 
+ 
+ Octonions (and their kin) are described in far more details in this other
+ document (with <a href="../../quaternion/TQE_EA.pdf" target="_top">errata
+ and addenda</a>).
+ 
+ 
+ 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).
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Operators
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Special Functions
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Statistical Distributions
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Quaternions
+ 
+ </td>
+<td>
+ 
+ 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 <code class="literal">y</code>
+ is an element of that algebra and is not equal
+ to zero, then <code class="literal">yx = yx'</code>,
+ where <code class="literal">x</code> and <code class="literal">x'</code>
+ denote elements of that algebra, implies that <code class="literal">x =
+ x'</code>). 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
+ (α,β,γ,δ), which we can write in the form <code class="literal">q = α + βi + γj + δk</code>,
+ where <code class="literal">i</code> is the same object as
+ for complex numbers, and <code class="literal">j</code> and
+ <code class="literal">k</code> are distinct objects which
+ play essentially the same kind of role as <code class="literal">i</code>.
+ 
+ 
+ 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 <code class="literal">x</code>
+ and <code class="literal">y</code> such that <code class="literal">xy
+ ≠ yx</code>). A good mnemotechnical way of remembering things
+ is by using the formula <code class="literal">i*i = j*j = k*k = -1</code>.
+ 
+ 
+ Quaternions (and their kin) are described in far more details in this
+ other document (with
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Random
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Rational
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ uBLAS
+ 
+ </td>
+<td>
+ 
+ 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.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left">Last revised: December 29, 2006 at 11:08:32 +0000</td>
+<td align="right"></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+</body>
+</html>

Modified: trunk/libs/math/doc/index.html
==============================================================================
--- trunk/libs/math/doc/index.html (original)
+++ trunk/libs/math/doc/index.html 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
@@ -1,11 +1,11 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
- <meta http-equiv="refresh" content="0; URL=../../../doc/html/boost_math.html">
+ <meta http-equiv="refresh" content="0; URL=html/index.html">
 </head>
 <body>
 Automatic redirection failed, please go to
- ../../../doc/html/boost_math.html
+ html/index.html
 Copyright Daryle Walker, Hubert Holin and John Maddock 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).
@@ -14,3 +14,4 @@

+

Deleted: trunk/libs/math/doc/math-background.qbk
==============================================================================
--- trunk/libs/math/doc/math-background.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
+++ (empty file)
@@ -1,89 +0,0 @@
-
-[def __form1 [^\]-1;1\[]]
-[def __form2 [^\[0;+'''∞'''\[]]
-[def __form3 [^\[+1;+'''∞'''\[]]
-[def __form4 [^\]-'''∞''';0\]]]
-[def __form5 [^x '''≥''' 0]]
-
-
-[section Background Information and White Papers]
-
-[section The Inverse Hyperbolic Functions]
-
-The exponential funtion is defined, for all object for which this makes sense,
-as the power series
-[$../../libs/math/special_functions/graphics/special_functions_blurb1.jpeg],
-with ['[^n! = 1x2x3x4x5...xn]] (and ['[^0! = 1]] by definition) being the factorial of ['[^n]].
-In particular, the exponential function is well defined for real numbers,
-complex number, quaternions, octonions, and matrices of complex numbers,
-among others.
-
-[: ['[*Graph of exp on R]] ]
-
-[: [$../../libs/math/special_functions/graphics/exp_on_R.png] ]
-
-[: ['[*Real and Imaginary parts of exp on C]]]
-[: [$../../libs/math/special_functions/graphics/Im_exp_on_C.png]]
-
-The hyperbolic functions are defined as power series which
-can be computed (for reals, complex, quaternions and octonions) as:
-
-Hyperbolic cosine: [$../../libs/math/special_functions/graphics/special_functions_blurb5.jpeg]
-
-Hyperbolic sine: [$../../libs/math/special_functions/graphics/special_functions_blurb6.jpeg]
-
-Hyperbolic tangent: [$../../libs/math/special_functions/graphics/special_functions_blurb7.jpeg]
-
-[: ['[*Trigonometric functions on R (cos: purple; sin: red; tan: blue)]]]
-[: [$../../libs/math/special_functions/graphics/trigonometric.png]]
-
-[: ['[*Hyperbolic functions on r (cosh: purple; sinh: red; tanh: blue)]]]
-[: [$../../libs/math/special_functions/graphics/hyperbolic.png]]
-
-The hyperbolic sine is one to one on the set of real numbers,
-with range the full set of reals, while the hyperbolic tangent is
-also one to one on the set of real numbers but with range __form1, and
-therefore both have inverses. The hyperbolic cosine is one to one from __form2
-onto __form3 (and from __form4 onto __form3); the inverse function we use
-here is defined on __form3 with range __form2.
-
-The inverse of the hyperbolic tangent is called the Argument hyperbolic tangent,
-and can be computed as [$../../libs/math/special_functions/graphics/special_functions_blurb15.jpeg].
-
-The inverse of the hyperbolic sine is called the Argument hyperbolic sine,
-and can be computed (for __form5) as [$../../libs/math/special_functions/graphics/special_functions_blurb17.jpeg].
-
-The inverse of the hyperbolic cosine is called the Argument hyperbolic cosine,
-and can be computed as [$../../libs/math/special_functions/graphics/special_functions_blurb18.jpeg].
-
-[endsect]
-
-[section Sinus Cardinal and Hyperbolic Sinus Cardinal Functions]
-
-The Sinus Cardinal family of functions (indexed by the family of indices [^a > 0])
-is defined by
-[$../../libs/math/special_functions/graphics/special_functions_blurb20.jpeg];
-it sees heavy use in signal processing tasks.
-
-By analogy, the Hyperbolic Sinus Cardinal family of functions
-(also indexed by the family of indices [^a > 0]) is defined by
-[$../../libs/math/special_functions/graphics/special_functions_blurb22.jpeg].
-
-These two families of functions are composed of entire functions.
-
-[: ['[*Sinus Cardinal of index pi (purple) and Hyperbolic Sinus Cardinal of index pi (red) on R]]]
-[: [$../../libs/math/special_functions/graphics/sinc_pi_and_sinhc_pi_on_R.png]]
-
-[endsect]
-
-[section The Quaternionic Exponential]
-
-Please refer to the following PDF's:
-
-*[@../../libs/math/quaternion/TQE.pdf The Quaternionic Exponential (and beyond)]
-*[@../../libs/math/quaternion/TQE_EA.pdf The Quaternionic Exponential (and beyond) ERRATA & ADDENDA]
-
-[endsect]
-
-[endsect]
-

Deleted: trunk/libs/math/doc/math-gcd.qbk
==============================================================================
--- trunk/libs/math/doc/math-gcd.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
+++ (empty file)
@@ -1,230 +0,0 @@
-
-[section:gcd_lcm Greatest Common Divisor and Least Common Multiple]
-
-[section Introduction]
-
-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.
-
-[endsect]
-
-[section Synopsis]
-
- namespace boost
- {
- namespace math
- {
-
- template < typename IntegerType >
- class gcd_evaluator;
- template < typename IntegerType >
- class lcm_evaluator;
-
- template < typename IntegerType >
- IntegerType gcd( IntegerType const &a, IntegerType const &b );
- template < typename IntegerType >
- IntegerType lcm( IntegerType const &a, IntegerType const &b );
-
- template < unsigned long Value1, unsigned long Value2 >
- struct static_gcd;
- template < unsigned long Value1, unsigned long Value2 >
- struct static_lcm;
-
- }
- }
-
-[endsect]
-
-[section GCD Function Object]
-
-[*Header: ] [@../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
-
- template < typename IntegerType >
- class boost::math::gcd_evaluator
- {
- public:
- // Types
- typedef IntegerType result_type;
- typedef IntegerType first_argument_type;
- typedef IntegerType second_argument_type;
-
- // Function object interface
- result_type operator ()( first_argument_type const &a,
- second_argument_type const &b ) const;
- };
-
-The boost::math::gcd_evaluator class template defines a function object
-class to return the greatest common divisor of two integers.
-The template is parameterized by a single type, called IntegerType here.
-This type should be a numeric type that represents integers.
-The result of the function object is always nonnegative, even if either of
-the operator arguments is negative.
-
-This function object class template is used in the corresponding version of
-the GCD function template. If a numeric type wants to customize evaluations
-of its greatest common divisors, then the type should specialize on the
-gcd_evaluator class template.
-
-[endsect]
-
-[section LCM Function Object]
-
-[*Header: ] [@../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
-
- template < typename IntegerType >
- class boost::math::lcm_evaluator
- {
- public:
- // Types
- typedef IntegerType result_type;
- typedef IntegerType first_argument_type;
- typedef IntegerType second_argument_type;
-
- // Function object interface
- result_type operator ()( first_argument_type const &a,
- second_argument_type const &b ) const;
- };
-
-The boost::math::lcm_evaluator class template defines a function object
-class to return the least common multiple of two integers. The template
-is parameterized by a single type, called IntegerType here. This type
-should be a numeric type that represents integers. The result of the
-function object is always nonnegative, even if either of the operator
-arguments is negative. If the least common multiple is beyond the range
-of the integer type, the results are undefined.
-
-This function object class template is used in the corresponding version
-of the LCM function template. If a numeric type wants to customize
-evaluations of its least common multiples, then the type should
-specialize on the lcm_evaluator class template.
-
-[endsect]
-
-[section Run-time GCD & LCM Determination]
-
-[*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 );
-
- template < typename IntegerType >
- IntegerType boost::math::lcm( IntegerType const &a, IntegerType const &b );
-
-The boost::math::gcd function template returns the greatest common
-(nonnegative) divisor of the two integers passed to it.
-The boost::math::lcm function template returns the least common
-(nonnegative) multiple of the two integers passed to it.
-The function templates are parameterized on the function arguments'
-IntegerType, which is also the return type. Internally, these function
-templates use an object of the corresponding version of the
-gcd_evaluator and lcm_evaluator class templates, respectively.
-
-[endsect]
-
-[section Compile time GCD and LCM determination]
-
-[*Header: ] [@../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
-
- template < unsigned long Value1, unsigned long Value2 >
- struct boost::math::static_gcd
- {
- static unsigned long const value = implementation_defined;
- };
-
- template < unsigned long Value1, unsigned long Value2 >
- struct boost::math::static_lcm
- {
- static unsigned long const value = implementation_defined;
- };
-
-The boost::math::static_gcd and boost::math::static_lcm class templates
-take two value-based template parameters of the unsigned long type
-and have a single static constant data member, value, of that same type.
-The value of that member is the greatest common factor or least
-common multiple, respectively, of the template arguments.
-A compile-time error will occur if the least common multiple
-is beyond the range of an unsigned long.
-
-[h3 Example]
-
- #include <boost/math/common_factor.hpp>
- #include <algorithm>
- #include <iterator>
-
-
- int main()
- {
- using std::cout;
- using std::endl;
-
- cout << "The GCD and LCM of 6 and 15 are "
- << boost::math::gcd(6, 15) << " and "
- << boost::math::lcm(6, 15) << ", respectively."
- << endl;
-
- cout << "The GCD and LCM of 8 and 9 are "
- << boost::math::static_gcd<8, 9>::value
- << " and "
- << boost::math::static_lcm<8, 9>::value
- << ", respectively." << endl;
-
- int a[] = { 4, 5, 6 }, b[] = { 7, 8, 9 }, c[3];
- std::transform( a, a + 3, b, c, boost::math::gcd_evaluator<int>() );
- std::copy( c, c + 3, std::ostream_iterator<int>(cout, " ") );
- }
-
-[endsect]
-
-[section 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>].
-
-Note this is a legacy header: it used to contain the actual implementation,
-but the compile-time and run-time facilities
-were moved to separate headers (since they were independent of each other).
-
-[endsect]
-
-[section Demonstration Program]
-
-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
-the run-time function templates.)
-
-[endsect]
-
-[section Rationale]
-
-The greatest common divisor and least common multiple functions are
-greatly used in some numeric contexts, including some of the other
-Boost libraries. Centralizing these functions to one header improves
-code factoring and eases maintainence.
-
-[endsect]
-
-[section History]
-
-* 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]
-
-The author of the Boost compilation of GCD and LCM computations is
-Daryle Walker. The code was prompted by existing code hiding in the
-implementations of Paul Moore's rational library and Steve Cleary's
-pool library. The code had updates by Helmut Zeisel.
-
-[endsect]
-
-[endsect]
-

Deleted: trunk/libs/math/doc/math-octonion.qbk
==============================================================================
--- trunk/libs/math/doc/math-octonion.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
+++ (empty file)
@@ -1,983 +0,0 @@
-
-[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 __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]]]
-
-
-[section Octonions]
-
-[section Overview]
-
-Octonions, like [link boost_math.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']]
-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:
-
-[$../../libs/math/octonion/graphics/octonion_blurb17.jpeg]
-
-Octonions (and their kin) are described in far more details in this other
-[@../../libs/math/quaternion/TQE.pdf document]
-(with [@../../libs/math/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]
-
-The interface and implementation are both supplied by the header file
-[@../../boost/math/octonion.hpp octonion.hpp].
-
-[endsect]
-
-[section Synopsis]
-
- namespace boost{ namespace math{
-
- template<typename T> class ``[link boost_math.octonions.template_class_octonion octonion]``;
- template<> class ``[link boost_math.octonions.octonion_specializations octonion<float>]``;
- template<> class ``[link boost_math.octonion_double octonion<double>]``;
- template<> class ``[link boost_math.octonion_long_double octonion<long double>]``;
-
- // operators
-
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_non_member_operators.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
-
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_math.octonions.octonion_non_member_operators.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_math.octonions.octonion_non_member_operators.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_math.octonions.octonion_non_member_operators.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
-
- // values
-
- template<typename T> T ``[link boost_math.octonions.octonion_value_operations.real_and_unreal real]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_value_operations.real_and_unreal unreal]``(octonion<T> const & o);
-
- template<typename T> T ``[link boost_math.octonions.octonion_value_operations.sup sup]``(octonion<T> const & o);
- template<typename T> T ``[link boost_math.octonions.octonion_value_operations.l1 l1]``(octonion<T>const & o);
- template<typename T> T ``[link boost_math.octonions.octonion_value_operations.abs abs]``(octonion<T> const & o);
- template<typename T> T ``[link boost_math.octonions.octonion_value_operations.norm norm]``(octonion<T>const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonion_value_operations.conj conj]``(octonion<T> const & o);
-
- template<typename T> octonion<T> ``[link boost_math.octonions.quaternion_creation_functions 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_math.octonions.quaternion_creation_functions 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_math.octonions.quaternion_creation_functions 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_math.octonions.octonions_transcendentals.exp exp]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.cos cos]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.sin sin]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.tan tan]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.cosh cosh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.sinh sinh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.tanh tanh]``(octonion<T> const & o);
-
- template<typename T> octonion<T> ``[link boost_math.octonions.octonions_transcendentals.pow pow]``(octonion<T> const & o, int n);
-
- } } // namespaces
-
-[endsect]
-
-[section Template Class octonion]
-
- namespace boost{ namespace math {
-
- template<typename T>
- class octonion
- {
- public:
- typedef T value_type;
-
- explicit ``[link boost_math.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_math.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_math.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_math.octonions.octonion_member_functions.constructors octonion]``(octonion<X> const & a_recopier);
-
- T ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<T> ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- T ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<T> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<T> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<T> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<T> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<T> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<T> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<T> const & a_affecter);
- template<typename X>
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (T const & a_affecter);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
-
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (T const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (T const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (T const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (T const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
-
- } } // namespaces
-
-[endsect]
-
-[section Octonion Specializations]
-
- namespace boost{ namespace math{
-
- template<>
- class octonion<float>
- {
- public:
- typedef float value_type;
-
- explicit ``[link boost_math.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_math.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_math.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_math.octonions.octonion_member_functions.constructors octonion]``(octonion<double> const & a_recopier);
- explicit ``[link boost_math.octonions.octonion_member_functions.constructors octonion]``(octonion<long double> const & a_recopier);
-
- float ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<float> ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- float ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<float> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<float> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<float> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<float> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<float> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<float> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<float> const & a_affecter);
- template<typename X>
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (float const & a_affecter);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
-
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (float const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (float const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (float const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (float const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
-
-[#boost_math.octonion_double]
-
- template<>
- class octonion<double>
- {
- public:
- typedef double value_type;
-
- explicit ``[link boost_math.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_math.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_math.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_math.octonions.octonion_member_functions.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link boost_math.octonions.octonion_member_functions.constructors octonion]``(octonion<long double> const & a_recopier);
-
- double ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<double> ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<double> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<double> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<double> const & a_affecter);
- template<typename X>
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (double const & a_affecter);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
-
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (double const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (double const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (double const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (double const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
-
-[#boost_math.octonion_long_double]
-
- template<>
- class octonion<long double>
- {
- public:
- typedef long double value_type;
-
- explicit ``[link boost_math.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_math.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_math.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_math.octonions.octonion_member_functions.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link boost_math.octonions.octonion_member_functions.constructors octonion]``(octonion<double> const & a_recopier);
-
- long double ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts real]``() const;
- octonion<long double> ``[link boost_math.octonions.octonion_member_functions.real_and_unreal_parts unreal]``() const;
-
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_1]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_2]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_3]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_4]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_5]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_6]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_7]``() const;
- long double ``[link boost_math.octonions.octonion_member_functions.individual_real_components R_component_8]``() const;
-
- ::std::complex<long double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_1]``() const;
- ::std::complex<long double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_2]``() const;
- ::std::complex<long double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_3]``() const;
- ::std::complex<long double> ``[link boost_math.octonions.octonion_member_functions.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<long double> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<long double> ``[link boost_math.octonions.octonion_member_functions.individual_quaternion_components H_component_2]``() const;
-
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
- template<typename X>
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (long double const & a_affecter);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
-
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (long double const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link boost_math.octonions.octonion_member_functions.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
-
- } } // namespaces
-
-[endsect]
-
-[section Octonion Member Typedefs]
-
-[*value_type]
-
-Template version:
-
- typedef T value_type;
-
-Float specialization version:
-
- typedef float value_type;
-
-Double specialization version:
-
- typedef double value_type;
-
-Long double specialization version:
-
- typedef long double value_type;
-
-These provide easy acces to the type the template is built upon.
-
-[endsect]
-
-[section Octonion Member Functions]
-
-[h3 Constructors]
-
-Template version:
-
- 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>
- explicit octonion(octonion<X> const & a_recopier);
-
-Float specialization version:
-
- 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<long double> const & a_recopier);
-
-Double specialization version:
-
- explicit 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 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 octonion(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
- explicit octonion(octonion<float> const & a_recopier);
- explicit octonion(octonion<long double> const & a_recopier);
-
-Long double specialization version:
-
- explicit 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 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 octonion(::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & q1 = ::boost::math::quaternion<long double>());
- 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
-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,
-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 templated helper function in a "detail" subnamespace.
-
-[h3 Other member functions]
-
-[h4 Real and Unreal Parts]
-
- 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).
-These are returned by the first two functions.
-
-[h4 Individual Real Components]
-
- T R_component_1() const;
- T R_component_2() const;
- T R_component_3() const;
- T R_component_4() const;
- T R_component_5() const;
- T R_component_6() const;
- T R_component_7() const;
- T R_component_8() const;
-
-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]
-
- ::std::complex<T> C_component_1() const;
- ::std::complex<T> C_component_2() const;
- ::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
-[*not] the components of the octonion on the basis ['[^(1, j, e', j')]].
-
-[h4 Individual Quaternion Components]
-
- ::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
-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>
- 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).
-For the unspecialized form, the base type's assignment operators must not throw.
-
-[h4 Other Member Operators]
-
- 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>
- 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,
-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>
- 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, 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>
- 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
-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>
- 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,
-remember to group any two factors using parenthesis.
-
-[endsect]
-
-[section Octonion Non-Member Operators]
-
-[h4 Unary Plus and Minus Operators]
-
- template<typename T> octonion<T> operator + (octonion<T> const & o);
-
-This unary operator simply returns o.
-
- template<typename T> octonion<T> operator - (octonion<T> const & o);
-
-This unary operator returns the opposite of o.
-
-[h4 Binary Addition Operators]
-
- template<typename T> octonion<T> operator + (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator + (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator + (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator + (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator + (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- 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`.
-
-[h4 Binary Subtraction Operators]
-
- template<typename T> octonion<T> operator - (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator - (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator - (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator - (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator - (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- 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`.
-
-[h4 Binary Multiplication Operators]
-
- template<typename T> octonion<T> operator * (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator * (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator * (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator * (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator * (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- 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`.
-
-[h4 Binary Division Operators]
-
- template<typename T> octonion<T> operator / (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator / (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator / (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator / (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- 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
-error to divide by zero...
-
-[h4 Binary Equality Operators]
-
- template<typename T> bool operator == (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator == (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool operator == (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator == (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool operator == (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- 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
-floating-type entity, this is essentially meaningless.
-
-[h4 Binary Inequality Operators]
-
- template<typename T> bool operator != (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator != (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool operator != (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator != (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool operator != (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- 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)`
-is false. As with any floating-type entity, this is essentially meaningless.
-
-[h4 Stream Extractor]
-
- 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
-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,
-calls `is.setstate(ios::failbit)` (which may throw `ios::failure` (27.4.5.3)).
-
-Returns `is`.
-
-[h4 Stream Inserter]
-
- template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits> & operator << (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
-
-Inserts the octonion `o` 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> & os,
- octonion<T> const & o)
- {
- ::std::basic_ostringstream<charT,traits> s;
-
- s.flags(os.flags());
- s.imbue(os.getloc());
- s.precision(os.precision());
-
- s << '(' << o.R_component_1() << ','
- << o.R_component_2() << ','
- << o.R_component_3() << ','
- << o.R_component_4() << ','
- << o.R_component_5() << ','
- << o.R_component_6() << ','
- << o.R_component_7() << ','
- << o.R_component_8() << ')';
-
- return os << s.str();
- }
-
-[endsect]
-
-[section Octonion Value Operations]
-
-[h4 Real and Unreal]
-
- template<typename T> T real(octonion<T> const & o);
- template<typename T> octonion<T> unreal(octonion<T> const & o);
-
-These return `o.real()` and `o.unreal()` respectively.
-
-[h4 conj]
-
- template<typename T> octonion<T> conj(octonion<T> const & o);
-
-This returns the conjugate of the octonion.
-
-[h4 sup]
-
- template<typename T> T sup(octonion<T> const & o);
-
-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())`)
-of the octonion.
-
-[h4 abs]
-
- template<typename T> T abs(octonion<T> const & o);
-
-This return the magnitude (Euclidian norm) of the octonion.
-
-[h4 norm]
-
- 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
-magnitude) is the square root of the Cayley norm.
-
-[endsect]
-
-[section Quaternion Creation Functions]
-
- template<typename T> octonion<T> 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> 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
-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
-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
-octonion, respectively.
-
-`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
-somewhat more complicated.
-
-[endsect]
-
-[section 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
-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]
-headers.
-
-[h4 exp]
-
- template<typename T>
- octonion<T> exp(octonion<T> const & o);
-
-Computes the exponential of the octonion.
-
-[h4 cos]
-
- template<typename T>
- octonion<T> cos(octonion<T> const & o);
-
-Computes the cosine of the octonion
-
-[h4 sin]
-
- template<typename T>
- octonion<T> sin(octonion<T> const & o);
-
-Computes the sine of the octonion.
-
-[h4 tan]
-
- template<typename T>
- octonion<T> tan(octonion<T> const & o);
-
-Computes the tangent of the octonion.
-
-[h4 cosh]
-
- template<typename T>
- octonion<T> cosh(octonion<T> const & o);
-
-Computes the hyperbolic cosine of the octonion.
-
-[h4 sinh]
-
- template<typename T>
- octonion<T> sinh(octonion<T> const & o);
-
-Computes the hyperbolic sine of the octonion.
-
-[h4 tanh]
-
- template<typename T>
- octonion<T> tanh(octonion<T> const & o);
-
-Computes the hyperbolic tangent of the octonion.
-
-[h4 pow]
-
- 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]
-
-The [@../../libs/math/octonion/octonion_test.cpp octonion_test.cpp]
-test program tests octonions specialisations for float, double and long double
-([@../../libs/math/octonion/output.txt sample output]).
-
-If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
-output ([@../../libs/math/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]
-
-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]
-
-* 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]).
-* 1.5.5 - 27/09/2002: Microsoft VCPP 7 compatibility, by Michael Stevens (michael_at_[hidden]); requires the /Za compiler option.
-* 1.5.4 - 19/09/2002: fixed problem with multiple inclusion (in different translation units); attempt at an improved compatibility with Microsoft compilers, by Michael Stevens (michael_at_[hidden]) and Fredrik Blomqvist; other compatibility fixes.
-* 1.5.3 - 01/02/2002: bugfix and Gcc 2.95.3 compatibility by Douglas Gregor (gregod_at_[hidden]).
-* 1.5.2 - 07/07/2001: introduced namespace math.
-* 1.5.1 - 07/06/2001: (end of Boost review) now includes <boost/math/special_functions/sinc.hpp> and <boost/math/special_functions/sinhc.hpp> instead of <boost/special_functions.hpp>; corrected bug in sin (Daryle Walker); removed check for self-assignment (Gary Powel); made converting functions explicit (Gary Powel); added overflow guards for division operators and abs (Peter Schmitteckert); added sup and l1; used Vesa Karvonen's CPP metaprograming technique to simplify code.
-* 1.5.0 - 23/03/2001: boostification, inlining of all operators except input, output and pow, fixed exception safety of some members (template version).
-* 1.4.0 - 09/01/2001: added tan and tanh.
-* 1.3.1 - 08/01/2001: cosmetic fixes.
-* 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.
-
-[endsect]
-
-[section To Do]
-
-* Improve testing.
-* Rewrite input operatore using Spirit (creates a dependency).
-* Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
-
-[endsect]
-
-[endsect]

Deleted: trunk/libs/math/doc/math-quaternion.qbk
==============================================================================
--- trunk/libs/math/doc/math-quaternion.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
+++ (empty file)
@@ -1,899 +0,0 @@
-
-[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]]]
-
-
-[section Quaternions]
-
-[section 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']]).
-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 [@../../libs/math/quaternion/TQE.pdf document]
-(with [@../../libs/math/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.
-
-[endsect]
-
-[section Header File]
-
-The interface and implementation are both supplied by the header file
-[@../../boost/math/quaternion.hpp quaternion.hpp].
-
-[endsect]
-
-[section Synopsis]
-
- namespace boost{ namespace math{
-
- template<typename T> class ``[link boost_math.quaternions.template_class_quaternion quaternion]``;
- template<> class ``[link boost_math.quaternions.quaternion_specializations quaternion<float>]``;
- template<> class ``[link boost_math.quaternion_double quaternion<double>]``;
- template<> class ``[link boost_math.quaternion_long_double quaternion<long double>]``;
-
- // operators
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_addition_operators operator +]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_addition_operators operator +]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_addition_operators operator +]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_subtraction_operators operator -]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_multiplication_operators operator *]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_division_operators operator /]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.unary_plus operator +]`` (quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_non_member_operators.unary_minus operator -]`` (quaternion<T> const & q);
-
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.equality_operators operator ==]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.equality_operators operator ==]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.equality_operators operator ==]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.inequality_operators operator !=]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link boost_math.quaternions.quaternion_non_member_operators.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_math.quaternions.quaternion_non_member_operators.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_math.quaternions.quaternion_non_member_operators.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);
-
- // values
- template<typename T> T ``[link boost_math.quaternions.quaternion_value_operations.real_and_unreal real]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_value_operations.real_and_unreal unreal]``(quaternion<T> const & q);
-
- template<typename T> T ``[link boost_math.quaternions.quaternion_value_operations.sup sup]``(quaternion<T> const & q);
- template<typename T> T ``[link boost_math.quaternions.quaternion_value_operations.l1 l1]``(quaternion<T> const & q);
- template<typename T> T ``[link boost_math.quaternions.quaternion_value_operations.abs abs]``(quaternion<T> const & q);
- template<typename T> T ``[link boost_math.quaternions.quaternion_value_operations.norm norm]``(quaternion<T>const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_value_operations.conj conj]``(quaternion<T> const & q);
-
- template<typename T> quaternion<T> ``[link boost_math.quaternions.creation_spherical spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
- template<typename T> quaternion<T> ``[link boost_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_math.quaternions.quaternion_transcendentals.exp exp]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.cos cos]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.sin sin]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.tan tan]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.cosh cosh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.sinh sinh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.tanh tanh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link boost_math.quaternions.quaternion_transcendentals.pow pow]``(quaternion<T> const & q, int n);
-
- } // namespace math
- } // namespace boost
-
-[endsect]
-
-[section Template Class quaternion]
-
- namespace boost{ namespace math{
-
- template<typename T>
- class quaternion
- {
- public:
-
- typedef T ``[link boost_math.quaternions.quaternion_member_typedefs value_type]``;
-
- explicit ``[link boost_math.quaternions.quaternion_member_functions.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_math.quaternions.quaternion_member_functions.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
- template<typename X>
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<X> const & a_recopier);
-
- T ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts real]``() const;
- quaternion<T> ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts unreal]``() const;
- T ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_1]``() const;
- T ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_2]``() const;
- T ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_3]``() const;
- T ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_4]``() const;
- ::std::complex<T> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_1]``() const;
- ::std::complex<T> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_2]``() const;
-
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<T> const & a_affecter);
- template<typename X>
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(T const & a_affecter);
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(::std::complex<T> const & a_affecter);
-
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(T const & rhs);
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(::std::complex<T> const & rhs);
- template<typename X>
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(T const & rhs);
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(::std::complex<T> const & rhs);
- template<typename X>
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(T const & rhs);
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(::std::complex<T> const & rhs);
- template<typename X>
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
-
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(T const & rhs);
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(::std::complex<T> const & rhs);
- template<typename X>
- quaternion<T>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(quaternion<X> const & rhs);
- };
-
- } // namespace math
- } // namespace boost
-
-[endsect]
-
-[section Quaternion Specializations]
-
- namespace boost{ namespace math{
-
- template<>
- class quaternion<float>
- {
- public:
- typedef float ``[link boost_math.quaternions.quaternion_member_typedefs value_type]``;
-
- explicit ``[link boost_math.quaternions.quaternion_member_functions.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_math.quaternions.quaternion_member_functions.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<double> const & a_recopier);
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<long double> const & a_recopier);
-
- float ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts real]``() const;
- quaternion<float> ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts unreal]``() const;
- float ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_1]``() const;
- float ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_2]``() const;
- float ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_3]``() const;
- float ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_4]``() const;
- ::std::complex<float> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_1]``() const;
- ::std::complex<float> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_2]``() const;
-
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<float> const & a_affecter);
- template<typename X>
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(float const & a_affecter);
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);
-
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(float const & rhs);
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(::std::complex<float> const & rhs);
- template<typename X>
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(float const & rhs);
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(::std::complex<float> const & rhs);
- template<typename X>
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(float const & rhs);
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(::std::complex<float> const & rhs);
- template<typename X>
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
-
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(float const & rhs);
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(::std::complex<float> const & rhs);
- template<typename X>
- quaternion<float>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(quaternion<X> const & rhs);
- };
-
-[#boost_math.quaternion_double]
-
- template<>
- class quaternion<double>
- {
- public:
- typedef double ``[link boost_math.quaternions.quaternion_member_typedefs value_type]``;
-
- explicit ``[link boost_math.quaternions.quaternion_member_functions.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_math.quaternions.quaternion_member_functions.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<float> const & a_recopier);
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<long double> const & a_recopier);
-
- double ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts real]``() const;
- quaternion<double> ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts unreal]``() const;
- double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_1]``() const;
- double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_2]``() const;
- double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_3]``() const;
- double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_4]``() const;
- ::std::complex<double> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_1]``() const;
- ::std::complex<double> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_2]``() const;
-
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<double> const & a_affecter);
- template<typename X>
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(double const & a_affecter);
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);
-
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(double const & rhs);
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(::std::complex<double> const & rhs);
- template<typename X>
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(double const & rhs);
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(::std::complex<double> const & rhs);
- template<typename X>
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(double const & rhs);
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(::std::complex<double> const & rhs);
- template<typename X>
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
-
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(double const & rhs);
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(::std::complex<double> const & rhs);
- template<typename X>
- quaternion<double>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(quaternion<X> const & rhs);
- };
-
-[#boost_math.quaternion_long_double]
-
- template<>
- class quaternion<long double>
- {
- public:
- typedef long double ``[link boost_math.quaternions.quaternion_member_typedefs value_type]``;
-
- explicit ``[link boost_math.quaternions.quaternion_member_functions.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_math.quaternions.quaternion_member_functions.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<float> const & a_recopier);
- explicit ``[link boost_math.quaternions.quaternion_member_functions.constructors quaternion]``(quaternion<double> const & a_recopier);
-
- long double ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts real]``() const;
- quaternion<long double> ``[link boost_math.quaternions.quaternion_member_functions.real_and_unreal_parts unreal]``() const;
- long double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_1]``() const;
- long double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_2]``() const;
- long double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_3]``() const;
- long double ``[link boost_math.quaternions.quaternion_member_functions.individual_real_components R_component_4]``() const;
- ::std::complex<long double> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_1]``() const;
- ::std::complex<long double> ``[link boost_math.quaternions.quaternion_member_functions.individual_complex__components C_component_2]``() const;
-
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<long double> const & a_affecter);
- template<typename X>
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(long double const & a_affecter);
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);
-
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(::std::complex<long double> const & rhs);
- template<typename X>
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.addition_operators operator += ]``(quaternion<X> const & rhs);
-
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs);
- template<typename X>
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
-
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs);
- template<typename X>
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
-
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(long double const & rhs);
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(::std::complex<long double> const & rhs);
- template<typename X>
- quaternion<long double>& ``[link boost_math.quaternions.quaternion_member_functions.division_operators operator /= ]``(quaternion<X> const & rhs);
- };
-
- } // namespace math
- } // namespace boost
-
-[endsect]
-
-[section Quaternion Member Typedefs]
-
-[*value_type]
-
-Template version:
-
- typedef T value_type;
-
-Float specialization version:
-
- typedef float value_type;
-
-Double specialization version:
-
- typedef double value_type;
-
-Long double specialization version:
-
- typedef long double value_type;
-
-These provide easy acces to the type the template is built upon.
-
-[endsect]
-
-[section Quaternion Member Functions]
-[h3 Constructors]
-
-Template version:
-
- explicit quaternion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
- explicit quaternion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
- template<typename X>
- explicit quaternion(quaternion<X> const & a_recopier);
-
-Float specialization version:
-
- 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<long double> const & a_recopier);
-
-Double specialization version:
-
- explicit 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 quaternion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
- explicit quaternion(quaternion<float> const & a_recopier);
- explicit quaternion(quaternion<long double> const & a_recopier);
-
-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(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
-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
-templated helper function in a "detail" subnamespace.
-
-[h3 Other member functions]
-[h4 Real and Unreal Parts]
-
- 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).
-These are returned by the first two functions.
-
-[h4 Individual Real Components]
-
- T R_component_1() const;
- T R_component_2() const;
- T R_component_3() const;
- T R_component_4() const;
-
-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;
-
-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>
- 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,
-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>
- 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 must not throw.
-
-[h4 Subtraction Operators]
-
- quaternion<T>& operator -= (T const & rhs)
- quaternion<T>& operator -= (::std::complex<T> const & rhs);
- 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
-must not throw.
-
-[h4 Multiplication Operators]
-
- quaternion<T>& operator *= (T const & rhs)
- quaternion<T>& operator *= (::std::complex<T> const & rhs);
- 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.
-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>
- 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.
-For the unspecialized form, the base type's assignment operators must not throw.
-
-[endsect]
-[section Quaternion Non-Member Operators]
-
-[h4 Unary Plus]
-
- template<typename T>
- quaternion<T> operator + (quaternion<T> const & q);
-
-This unary operator simply returns q.
-
-[h4 Unary Minus]
-
- template<typename T>
- quaternion<T> operator - (quaternion<T> const & q);
-
-This unary operator returns the opposite of q.
-
-[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);
-
-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);
-
-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);
-
-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);
-
-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);
-
-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
-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);
-
-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]
-
- 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
-(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,
-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
-and not two complex numbers which happen to have imaginary parts equal to zero).
-
-[h4 Stream Inserter]
-
- template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits>& operator << (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);
-
-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> & os,
- quaternion<T> const & q)
- {
- ::std::basic_ostringstream<charT,traits> s;
-
- s.flags(os.flags());
- s.imbue(os.getloc());
- s.precision(os.precision());
-
- s << '(' << q.R_component_1() << ','
- << q.R_component_2() << ','
- << q.R_component_3() << ','
- << q.R_component_4() << ')';
-
- return os << s.str();
- }
-
-[endsect]
-
-[section 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);
-
-These return `q.real()` and `q.unreal()` respectively.
-
-[h4 conj]
-
- 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);
-
-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);
-
-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);
-
-This return the magnitude (Euclidian norm) of the quaternion.
-
-[h4 norm]
-
- 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
-(also known as magnitude) is the square root of the Cayley norm.
-
-[endsect]
-
-[section 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);
-
-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_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_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_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_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_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
-[@../../libs/math/quaternion/HSO3.hpp __R3], and here for
-[@../../libs/math/quaternion/HSO4.hpp __R4]
-([@../../libs/math/quaternion/HSO3SO4.cpp example test file]).
-
-[endsect]
-
-[section 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
-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.
-
-[h4 exp]
-
- 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);
-
-Computes the cosine of the quaternion
-
-[h4 sin]
-
- 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);
-
-Computes the tangent of the quaternion.
-
-[h4 cosh]
-
- 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);
-
-Computes the hyperbolic sine of the quaternion.
-
-[h4 tanh]
-
- 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);
-
-Computes the n-th power of the quaternion q.
-
-[endsect]
-
-[section Test Program]
-
-The [@../../libs/math/quaternion/quaternion_test.cpp quaternion_test.cpp]
-test program tests quaternions specializations for float, double and long double
-([@../../libs/math/quaternion/output.txt sample output], with message output
-enabled).
-
-If you define the symbol BOOST_QUATERNION_TEST_VERBOSE, you will get
-additional output ([@../../libs/math/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]
-
-[section 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.
-Thank you to all who contributed to the discution about this library.
-
-[endsect]
-
-[section History]
-
-* 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]).
-* 1.5.5 - 27/09/2002: Microsoft VCPP 7 compatibility, by Michael Stevens (michael_at_[hidden]); requires the /Za compiler option.
-* 1.5.4 - 19/09/2002: fixed problem with multiple inclusion (in different translation units); attempt at an improved compatibility with Microsoft compilers, by Michael Stevens (michael_at_[hidden]) and Fredrik Blomqvist; other compatibility fixes.
-* 1.5.3 - 01/02/2002: bugfix and Gcc 2.95.3 compatibility by Douglas Gregor (gregod_at_[hidden]).
-* 1.5.2 - 07/07/2001: introduced namespace math.
-* 1.5.1 - 07/06/2001: (end of Boost review) now includes <boost/math/special_functions/sinc.hpp> and <boost/math/special_functions/sinhc.hpp> instead of <boost/special_functions.hpp>; corrected bug in sin (Daryle Walker); removed check for self-assignment (Gary Powel); made converting functions explicit (Gary Powel); added overflow guards for division operators and abs (Peter Schmitteckert); added sup and l1; used Vesa Karvonen's CPP metaprograming technique to simplify code.
-* 1.5.0 - 26/03/2001: boostification, inlining of all operators except input, output and pow, fixed exception safety of some members (template version) and output operator, added spherical, semipolar, multipolar, cylindrospherical and cylindrical.
-* 1.4.0 - 09/01/2001: added tan and tanh.
-* 1.3.1 - 08/01/2001: cosmetic fixes.
-* 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.
-
-[endsect]
-[section 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
-[@../../libs/math/quaternion/HSO3SO4.cpp example]
-implementation to an efficient one).
-
-[endsect]
-[endsect]

Deleted: trunk/libs/math/doc/math-sf.qbk
==============================================================================
--- trunk/libs/math/doc/math-sf.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
+++ (empty file)
@@ -1,314 +0,0 @@
-
-[def __asinh [link boost_math.math_special_functions.asinh asinh]]
-[def __acosh [link boost_math.math_special_functions.acosh acosh]]
-[def __atanh [link boost_math.math_special_functions.atanh atanh]]
-[def __sinc_pi [link boost_math.math_special_functions.sinc_pi sinc_pi]]
-[def __sinhc_pi [link boost_math.math_special_functions.sinhc_pi sinhc_pi]]
-
-[def __log1p [link boost_math.math_special_functions.log1p log1p]]
-[def __expm1 [link boost_math.math_special_functions.expm1 expm1]]
-[def __hypot [link boost_math.math_special_functions.hypot hypot]]
-
-[def __form1 [^\[0;+'''∞'''\[]]
-[def __form2 [^\]-'''∞''';+1\[]]
-[def __form3 [^\]-'''∞''';-1\[]]
-[def __form4 [^\]+1;+'''∞'''\[]]
-[def __form5 `[^\[-1;-1+'''ε'''\[]]
-[def __form6 '''ε''']
-[def __form7 [^\]+1-'''ε''';+1\]]]
-
-[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ε''']
-
-
-[section Math Special Functions]
-
-[section Overview]
-
-The Special Functions library currently provides eight templated special functions,
-in namespace boost. Two of these (__sinc_pi and __sinhc_pi) are needed by our
-implementation of quaternions and octonions.
-
-The functions __acosh, __asinh and __atanh are entirely classical,
-the function __sinc_pi sees heavy use in signal processing tasks,
-and the function __sinhc_pi is an ad'hoc function whose naming is modelled on
-__sinc_pi and hyperbolic functions.
-
-The functions __log1p, __expm1 and __hypot are all part of the C99 standard
-but not yet C++. Two of these (__log1p and __hypot) were needed for the
-[link boost_math.inverse_complex complex number inverse trigonometric functions].
-
-The functions implemented here can throw standard exceptions, but no
-exception specification has been made.
-
-[endsect]
-
-[section Header Files]
-
-The interface and implementation for each function (or forms of a function)
-are both supplied by one header file:
-
-* [@../../boost/math/special_functions/acosh.hpp acosh.hpp]
-* [@../../boost/math/special_functions/asinh.hpp asinh.hpp]
-* [@../../boost/math/special_functions/atanh.hpp atanh.hpp]
-* [@../../boost/math/special_functions/expm1.hpp expm1.hpp]
-* [@../../boost/math/special_functions/hypot.hpp hypot.hpp]
-* [@../../boost/math/special_functions/log1p.hpp log1p.hpp]
-* [@../../boost/math/special_functions/sinc.hpp sinc.hpp]
-* [@../../boost/math/special_functions/sinhc.hpp sinhc.hpp]
-
-[endsect]
-
-[section Synopsis]
-
- namespace boost{ namespace math{
-
- template<typename T>
- T __acosh(const T x);
-
- template<typename T>
- T __asinh(const T x);
-
- template<typename T>
- T __atanh(const T x);
-
- template<typename T>
- T __expm1(const T x);
-
- template<typename T>
- T __hypot(const T x);
-
- template<typename T>
- T __log1p(const T x);
-
- template<typename T>
- T __sinc_pi(const T x);
-
- template<typename T, template<typename> class U>
- U<T> __sinc_pi(const U<T> x);
-
- template<typename T>
- T __sinhc_pi(const T x);
-
- template<typename T, template<typename> class U>
- U<T> __sinhc_pi(const U<T> x);
-
- }
- }
-
-[endsect]
-
-[section acosh]
-
- template<typename T>
- T acosh(const T x);
-
-Computes the reciprocal of (the restriction to the range of __form1)
-[link boost_math.background_information_and_white_papers.the_inverse_hyperbolic_functions
-the hyperbolic cosine function], at x. Values returned are positive. Generalised
-Taylor series are used near 1 and Laurent series are used near the
-infinity to ensure accuracy.
-
-If x is in the range __form2 a quiet NaN is returned (if the system allows,
-otherwise a `domain_error` exception is generated).
-
-[endsect]
-
-[section asinh]
-
- template<typename T>
- T asinh(const T x);
-
-Computes the reciprocal of
-[link boost_math.background_information_and_white_papers.the_inverse_hyperbolic_functions
-the hyperbolic sine function].
-Taylor series are used at the origin and Laurent series are used near the
-infinity to ensure accuracy.
-
-[endsect]
-
-[section atanh]
-
- template<typename T>
- T atanh(const T x);
-
-Computes the reciprocal of
-[link boost_math.background_information_and_white_papers.the_inverse_hyperbolic_functions
-the hyperbolic tangent function], at x.
-Taylor series are used at the origin to ensure accuracy.
-
-If x is in the range
-__form3
-or in the range
-__form4
-a quiet NaN is returned
-(if the system allows, otherwise a `domain_error` exception is generated).
-
-If x is in the range
-__form5,
-minus infinity is returned
-(if the system allows, otherwise an `out_of_range` exception
-is generated), with
-__form6
-denoting numeric_limits<T>::epsilon().
-
-If x is in the range
-__form7,
-plus infinity is returned (if the system allows,
-otherwise an `out_of_range` exception is generated), with
-__form6
-denoting
-numeric_limits<T>::epsilon().
-
-[endsect]
-
-[section:expm1 expm1]
-
- template <class T>
- T expm1(T t);
-
-__effects returns __exm1.
-
-For small x, then __ex is very close to 1, as a result calculating __exm1 results
-in catastrophic cancellation errors when x is small. `expm1` calculates __exm1 using
-a series expansion when x is small (giving an accuracy of less than __te).
-
-Finally when BOOST_HAS_EXPM1 is defined then the `float/double/long double`
-specializations of this template simply forward to the platform's
-native implementation of this function.
-
-[endsect]
-
-[section:hypot hypot]
-
- template <class T>
- T hypot(T x, T y);
-
-__effects computes [$../../libs/math/doc/images/hypot.png] in such a way as to avoid undue underflow and overflow.
-
-When calculating [$../../libs/math/doc/images/hypot.png] it's quite easy for the intermediate terms to either
-overflow or underflow, even though the result is in fact perfectly representable.
-One possible alternative form is [$../../libs/math/doc/images/hypot2.png], but that can overflow or underflow
-if x and y are of very differing magnitudes. The `hypot` function takes care of
-all the special cases for you, so you don't have to.
-
-[endsect]
-
-[section:log1p log1p]
-
- template <class T>
- T log1p(T x);
-
-__effects returns the natural logarithm of `x+1`.
-
-There are many situations where it is desirable to compute `log(x+1)`.
-However, for small `x` then `x+1` suffers from catastrophic cancellation errors
-so that `x+1 == 1` and `log(x+1) == 0`, when in fact for very small x, the
-best approximation to `log(x+1)` would be `x`. `log1p` calculates the best
-approximation to `log(1+x)` using a Taylor series expansion for accuracy
-(less than __te).
-Note that there are faster methods available, for example using the equivalence:
-
- log(1+x) == (log(1+x) * x) / ((1-x) - 1)
-
-However, experience has shown that these methods tend to fail quite spectacularly
-once the compiler's optimizations are turned on. In contrast, the series expansion
-method seems to be reasonably immune optimizer-induced errors.
-
-Finally when BOOST_HAS_LOG1P is defined then the `float/double/long double`
-specializations of this template simply forward to the platform's
-native implementation of this function.
-
-[endsect]
-
-[section sinc_pi]
-
- template<typename T>
- T sinc_pi(const T x);
-
- template<typename T, template<typename> class U>
- U<T> sinc_pi(const U<T> x);
-
-Computes
-[link boost_math.background_information_and_white_papers.sinus_cardinal_and_hyperbolic_sinus_cardinal_functions
-the Sinus Cardinal] of x. The second form is for complexes,
-quaternions, octonions... Taylor series are used at the origin
-to ensure accuracy.
-
-[endsect]
-
-[section sinhc_pi]
-
- template<typename T>
- T sinhc_pi(const T x);
-
- template<typename T, template<typename> class U>
- U<T> sinhc_pi(const U<T> x);
-
-Computes
-[link boost_math.background_information_and_white_papers.sinus_cardinal_and_hyperbolic_sinus_cardinal_functions
-the Hyperbolic Sinus Cardinal] of x. The second form is for
-complexes, quaternions, octonions... Taylor series are used at the origin
-to ensure accuracy.
-
-[endsect]
-
-[section Test Programs]
-
-The [@../../libs/math/special_functions/special_functions_test.cpp
-special_functions_test.cpp]
-and [@../../libs/math/test/log1p_expm1_test.cpp log1p_expm1_test.cpp] test programs test the functions for
-float, double and long double arguments ([@../../libs/math/special_functions/output.txt sample output], with message
-output enabled).
-
-If you define the symbol BOOST_SPECIAL_FUNCTIONS_TEST_VERBOSE, you will
-get additional output
-([@../../libs/math/special_functions/output_more.txt verbose output]),
-which may prove useful for
-tuning on your platform (the library use "reasonable" tolerances,
-which may prove to be too strict for your platform); 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,...).
-
-[endsect]
-
-[section Acknowledgements]
-
-The mathematical text has been typeset with [@http://www.nisus-soft.com/
-Nisus Writer], and the
-illustrations have been made with [@http://www.pacifict.com/
-Graphing Calculator]. Jens Maurer
-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]
-
-* 1.5.0 - 17/12/2005: John Maddock added __log1p, __expm1 and __hypot. Converted documentation to Quickbook Format.
-* 1.4.2 - 03/02/2003: transitionned to the unit test framework; <boost/config.hpp> now included by the library headers (rather than the test files).
-* 1.4.1 - 18/09/2002: improved compatibility with Microsoft compilers.
-* 1.4.0 - 14/09/2001: added (after rewrite) __acosh and __asinh, which were submited by Eric Ford; applied changes for Gcc 2.9.x suggested by John Maddock; improved accuracy; sanity check for test file, related to accuracy.
-* 1.3.2 - 07/07/2001: introduced namespace math.
-* 1.3.1 - 07/06/2001:(end of Boost review) split special_functions.hpp into atanh.hpp, sinc.hpp and sinhc.hpp; improved efficiency of __atanh with compile-time technique (Daryle Walker); improved accuracy of all functions near zero (Peter Schmitteckert).
-* 1.3.0 - 26/03/2001: support for complexes & all, for cardinal functions.
-* 1.2.0 - 31/01/2001: minor modifications for Koenig lookup.
-* 1.1.0 - 23/01/2001: boostification.
-* 1.0.0 - 10/08/1999: first public version.
-
-[endsect]
-
-[section To Do]
-
-* Add more functions.
-* Improve test of each function.
-
-[endsect]
-[endsect]
-
-

Deleted: trunk/libs/math/doc/math-tr1.qbk
==============================================================================
--- trunk/libs/math/doc/math-tr1.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
+++ (empty file)
@@ -1,142 +0,0 @@
-
-[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ε''']
-
-[section:inverse_complex Complex Number Inverse Trigonometric 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
-will be part of the forthcoming Technical Report on C++ Standard Library Extensions.
-
-[section 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,
-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
-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:]
-
- #include <boost/math/complex/asin.hpp>
-
-[h4 Synopsis:]
-
- template<class T>
- std::complex<T> asin(const std::complex<T>& z);
-
-__effects returns the inverse sine of the complex number z.
-
-__formula [$../../libs/math/doc/images/asin.png]
-
-[endsect]
-
-[section:acos acos]
-
-[h4 Header:]
-
- #include <boost/math/complex/acos.hpp>
-
-[h4 Synopsis:]
-
- template<class T>
- std::complex<T> acos(const std::complex<T>& z);
-
-__effects returns the inverse cosine of the complex number z.
-
-__formula [$../../libs/math/doc/images/acos.png]
-
-[endsect]
-
-[section:atan atan]
-
-[h4 Header:]
-
- #include <boost/math/complex/atan.hpp>
-
-[h4 Synopsis:]
-
- template<class T>
- std::complex<T> atan(const std::complex<T>& z);
-
-__effects returns the inverse tangent of the complex number z.
-
-__formula [$../../libs/math/doc/images/atan.png]
-
-[endsect]
-
-[section:asinh asinh]
-
-[h4 Header:]
-
- #include <boost/math/complex/asinh.hpp>
-
-[h4 Synopsis:]
-
- template<class T>
- std::complex<T> asinh(const std::complex<T>& z);
-
-__effects returns the inverse hyperbolic sine of the complex number z.
-
-__formula [$../../libs/math/doc/images/asinh.png]
-
-[endsect]
-
-[section:acosh acosh]
-
-[h4 Header:]
-
- #include <boost/math/complex/acosh.hpp>
-
-[h4 Synopsis:]
-
- template<class T>
- std::complex<T> acosh(const std::complex<T>& z);
-
-__effects returns the inverse hyperbolic cosine of the complex number z.
-
-__formula [$../../libs/math/doc/images/acosh.png]
-
-[endsect]
-
-[section:atanh atanh]
-
-[h4 Header:]
-
- #include <boost/math/complex/atanh.hpp>
-
-[h4 Synopsis:]
-
- template<class T>
- std::complex<T> atanh(const std::complex<T>& z);
-
-__effects returns the inverse hyperbolic tangent of the complex number z.
-
-__formula [$../../libs/math/doc/images/atanh.png]
-
-[endsect]
-
-[section 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.
-
-
-[endsect]
-
-[endsect]
-
-

Modified: trunk/libs/math/doc/math.qbk
==============================================================================
--- trunk/libs/math/doc/math.qbk (original)
+++ trunk/libs/math/doc/math.qbk 2007-10-11 07:47:11 EDT (Thu, 11 Oct 2007)
@@ -1,63 +1,189 @@
-[library Boost.Math
+[article Boost.Math
 [quickbook 1.3]
- [copyright 2001-2002 Daryle Walker, 2001-2003 Hubert Holin, 2005 John Maddock]
- [purpose Various mathematical functions and data types]
 [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], [Maddock, John], [Walker, Daryle]]
 [category math]
 [last-revision $Date$]
]

-[def __asinh [link boost_math.math_special_functions.asinh asinh]]
-[def __acosh [link boost_math.math_special_functions.acosh acosh]]
-[def __atanh [link boost_math.math_special_functions.atanh atanh]]
-[def __sinc_pi [link boost_math.math_special_functions.sinc_pi sinc_pi]]
-[def __sinhc_pi [link boost_math.math_special_functions.sinhc_pi sinhc_pi]]
-
-[def __log1p [link boost_math.math_special_functions.log1p log1p]]
-[def __expm1 [link boost_math.math_special_functions.expm1 expm1]]
-[def __hypot [link boost_math.math_special_functions.hypot hypot]]
-
-
-[section Overview]
-
-The [link boost_math.gcd_lcm Greatest Common Divisor and Least Common Multiple library]
-provides run-time and compile-time evaluation of the greatest common divisor (GCD)
-or least common multiple (LCM) of two integers.
-
-The [link boost_math.math_special_functions Special Functions library] currently provides eight templated special functions,
-in namespace boost. Two of these (__sinc_pi and __sinhc_pi) are needed by our
-implementation of quaternions and octonions. The functions __acosh,
-__asinh and __atanh are entirely classical,
-the function __sinc_pi sees heavy use in signal processing tasks,
-and the function __sinhc_pi is an ad'hoc function whose naming is modelled on
-__sinc_pi and hyperbolic functions. The functions __log1p, __expm1 and __hypot are all part of the C99 standard
-but not yet C++. Two of these (__log1p and __hypot) were needed for the
-[link boost_math.inverse_complex complex number inverse trigonometric functions].
-
-The [link boost_math.inverse_complex Complex Number Inverse Trigonometric Functions]
-are the inverses of trigonometric functions currently present in the C++ standard.
-Equivalents to these functions are part of the C99 standard, and they
+[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]]]
+
+
+The following mathematical libraries are present in Boost:
+
+[table
+[[Library][Description]]
+
+ [[[@../complex/html/index.html Complex Number Inverse Trigonometric Functions]]
+ [
+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
will be part of the forthcoming Technical Report on C++ Standard Library Extensions.
+ ]]
+
+ [[[@../gcd/html/index.html Greatest Common Divisor and Least Common Multiple]]
+ [
+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.
+ ]]
+
+ [[[@../../../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/doc/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.]]
+
+[[[@../octonion/html/index.html Octonions]]
+ [
+Octonions, like [@../../quaternions/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).
+ ]]
+
+ [[[@../../../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.]]
+
+[[[@../sf_and_dist/html/index.html Special Functions]]
+ [ 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. ]]
+
+[[[@../sf_and_dist/html/index.html Statistical Distributions]]
+ [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. ]]
+
+[[[@../quaternion/html/index.html Quaternions]]
+ [
+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.
+ ]]
+
+ [[[@../../../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.]]

-[link boost_math.quaternions Quaternions] are a relative of
-complex numbers often used to parameterise rotations in three
-dimentional space.
-
-[link boost_math.octonions Octonions], like [link boost_math.quaternions quaternions],
-are a relative of complex numbers. [link boost_math.octonions Octonions]
-see some use in theoretical physics.
-
-[endsect]
-
-[include math-gcd.qbk]
-[include math-sf.qbk]
-[include math-tr1.qbk]
-[include math-quaternion.qbk]
-[include math-octonion.qbk]
-[include math-background.qbk]
+]

Next message: john_at_[hidden]: "[Boost-commit] svn:boost r39925 - trunk/libs/math"
Previous message: joaquin_at_[hidden]: "[Boost-commit] svn:boost r39923 - in trunk: boost/multi_index/detail libs/multi_index/example"

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