|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r84201 - in sandbox/math/libs/math: doc doc/background doc/complex doc/concepts doc/constants doc/distributions doc/gcd doc/html doc/internals doc/octonion doc/overview doc/performance doc/policies doc/quaternion doc/sf example
From: john_at_[hidden]
Date: 2013-05-09 05:04:29
Author: johnmaddock
Date: 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
New Revision: 84201
URL: http://svn.boost.org/trac/boost/changeset/84201
Log:
Change to quickbook 1.6.
Change to use chapters at the top level.
Big search and replace on link names.
Removed:
sandbox/math/libs/math/doc/html/
sandbox/math/libs/math/doc/sf/math.qbk
Text files modified:
sandbox/math/libs/math/doc/Jamfile.v2 | 2
sandbox/math/libs/math/doc/background/error.qbk | 2
sandbox/math/libs/math/doc/background/implementation.qbk | 14
sandbox/math/libs/math/doc/background/lanczos.qbk | 4
sandbox/math/libs/math/doc/background/references.qbk | 2
sandbox/math/libs/math/doc/complex/complex-tr1.qbk | 4
sandbox/math/libs/math/doc/concepts/concepts.qbk | 18
sandbox/math/libs/math/doc/constants/constants.qbk | 16
sandbox/math/libs/math/doc/distributions/background.qbk | 6
sandbox/math/libs/math/doc/distributions/bernoulli.qbk | 2
sandbox/math/libs/math/doc/distributions/beta.qbk | 6
sandbox/math/libs/math/doc/distributions/binomial.qbk | 14
sandbox/math/libs/math/doc/distributions/cauchy.qbk | 4
sandbox/math/libs/math/doc/distributions/chi_squared.qbk | 6
sandbox/math/libs/math/doc/distributions/chi_squared_examples.qbk | 2
sandbox/math/libs/math/doc/distributions/dist_algorithms.qbk | 2
sandbox/math/libs/math/doc/distributions/dist_reference.qbk | 2
sandbox/math/libs/math/doc/distributions/dist_tutorial.qbk | 23
sandbox/math/libs/math/doc/distributions/error_handling_example.qbk | 2
sandbox/math/libs/math/doc/distributions/exponential.qbk | 2
sandbox/math/libs/math/doc/distributions/extreme_value.qbk | 2
sandbox/math/libs/math/doc/distributions/fisher.qbk | 8
sandbox/math/libs/math/doc/distributions/gamma.qbk | 2
sandbox/math/libs/math/doc/distributions/geometric.qbk | 8
sandbox/math/libs/math/doc/distributions/geometric_example.qbk | 2
sandbox/math/libs/math/doc/distributions/hypergeometric.qbk | 8
sandbox/math/libs/math/doc/distributions/inverse_chi_squared.qbk | 2
sandbox/math/libs/math/doc/distributions/inverse_gamma.qbk | 2
sandbox/math/libs/math/doc/distributions/inverse_gaussian.qbk | 2
sandbox/math/libs/math/doc/distributions/laplace.qbk | 2
sandbox/math/libs/math/doc/distributions/logistic.qbk | 2
sandbox/math/libs/math/doc/distributions/lognormal.qbk | 4
sandbox/math/libs/math/doc/distributions/nc_beta.qbk | 4
sandbox/math/libs/math/doc/distributions/nc_chi_squared.qbk | 4
sandbox/math/libs/math/doc/distributions/nc_f.qbk | 2
sandbox/math/libs/math/doc/distributions/nc_t.qbk | 4
sandbox/math/libs/math/doc/distributions/negative_binomial.qbk | 8
sandbox/math/libs/math/doc/distributions/non_members.qbk | 114 ++++----
sandbox/math/libs/math/doc/distributions/normal.qbk | 4
sandbox/math/libs/math/doc/distributions/pareto.qbk | 2
sandbox/math/libs/math/doc/distributions/poisson.qbk | 2
sandbox/math/libs/math/doc/distributions/rayleigh.qbk | 2
sandbox/math/libs/math/doc/distributions/skew_normal.qbk | 4
sandbox/math/libs/math/doc/distributions/students_t.qbk | 8
sandbox/math/libs/math/doc/distributions/students_t_examples.qbk | 6
sandbox/math/libs/math/doc/distributions/triangular.qbk | 4
sandbox/math/libs/math/doc/distributions/uniform.qbk | 2
sandbox/math/libs/math/doc/distributions/weibull.qbk | 2
sandbox/math/libs/math/doc/gcd/math-gcd.qbk | 5
sandbox/math/libs/math/doc/html4_symbols.qbk | 2
sandbox/math/libs/math/doc/internals/minimax.qbk | 4
sandbox/math/libs/math/doc/internals/rational.qbk | 4
sandbox/math/libs/math/doc/internals/roots.qbk | 13
sandbox/math/libs/math/doc/internals/test_data.qbk | 1
sandbox/math/libs/math/doc/math.qbk | 433 +++++++++++++++--------------
sandbox/math/libs/math/doc/octonion/math-octonion.qbk | 570 ++++++++++++++++++++--------------------
sandbox/math/libs/math/doc/overview/building.qbk | 2
sandbox/math/libs/math/doc/overview/common_overviews.qbk | 30 +-
sandbox/math/libs/math/doc/overview/config_macros.qbk | 8
sandbox/math/libs/math/doc/overview/error_handling.qbk | 48 +-
sandbox/math/libs/math/doc/overview/overview.qbk | 38 +-
sandbox/math/libs/math/doc/overview/result_type_calc.qbk | 2
sandbox/math/libs/math/doc/overview/roadmap.qbk | 2
sandbox/math/libs/math/doc/overview/tr1.qbk | 6
sandbox/math/libs/math/doc/performance/performance.qbk | 26 -
sandbox/math/libs/math/doc/policies/policy.qbk | 10
sandbox/math/libs/math/doc/policies/policy_tutorial.qbk | 6
sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk | 380 +++++++++++++-------------
sandbox/math/libs/math/doc/sf/ellint_introduction.qbk | 8
sandbox/math/libs/math/doc/sf/erf.qbk | 2
sandbox/math/libs/math/doc/sf/erf_inv.qbk | 2
sandbox/math/libs/math/doc/sf/inv_hyper.qbk | 6
sandbox/math/libs/math/doc/sf/pow.qbk | 2
sandbox/math/libs/math/doc/sf/sinc.qbk | 4
sandbox/math/libs/math/example/binomial_quiz_example.cpp | 4
sandbox/math/libs/math/example/fft_sines_table.cpp | 2
sandbox/math/libs/math/example/find_location_example.cpp | 2
sandbox/math/libs/math/example/find_mean_and_sd_normal.cpp | 6
sandbox/math/libs/math/example/find_root_example.cpp | 2
sandbox/math/libs/math/example/geometric_examples.cpp | 2
sandbox/math/libs/math/example/negative_binomial_example1.cpp | 2
sandbox/math/libs/math/example/normal_misc_examples.cpp | 2
82 files changed, 990 insertions(+), 995 deletions(-)
Modified: sandbox/math/libs/math/doc/Jamfile.v2
==============================================================================
--- sandbox/math/libs/math/doc/Jamfile.v2 (original)
+++ sandbox/math/libs/math/doc/Jamfile.v2 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -32,7 +32,7 @@
# How far down sections get TOC's
<xsl:param>toc.section.depth=10
# Max depth in each TOC:
- <xsl:param>toc.max.depth=1
+ <xsl:param>toc.max.depth=4
# How far down we go with TOC's
<xsl:param>generate.section.toc.level=10
# Index on type:
Modified: sandbox/math/libs/math/doc/background/error.qbk
==============================================================================
--- sandbox/math/libs/math/doc/background/error.qbk (original)
+++ sandbox/math/libs/math/doc/background/error.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -41,7 +41,7 @@
maximum relative errors differ by a factor of 2, can actually be accurate
to the same number of binary digits. You have been warned!
-[#zero_error][h4 The Impossibility of Zero Error]
+[h4:zero_error The Impossibility of Zero Error]
For many of the functions in this library, it is assumed that the error is
"effectively zero" if the computation can be done with a number of guard
Modified: sandbox/math/libs/math/doc/background/implementation.qbk
==============================================================================
--- sandbox/math/libs/math/doc/background/implementation.qbk (original)
+++ sandbox/math/libs/math/doc/background/implementation.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -125,14 +125,14 @@
['ISO/IEC 9899:1999 Programming languages - C]
and with the
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Draft Technical Report on C++ Library Extensions, 2005-06-24, section 5.2.1, paragraph 5].
-[link math_toolkit.main_overview.error_handling See also domain_error].
+[link math_toolkit.error_handling See also domain_error].
See __policy_ref for details of the error handling policies that should allow
a user to comply with any of these recommendations, as well as other behaviour.
-See [link math_toolkit.main_overview.error_handling error handling]
+See [link math_toolkit.error_handling error handling]
for a detailed explanation of the mechanism, and
-[link math_toolkit.dist.stat_tut.weg.error_eg error_handling example]
+[link math_toolkit.stat_tut.weg.error_eg error_handling example]
and
[@../../../example/error_handling_example.cpp error_handling_example.cpp]
@@ -146,7 +146,7 @@
Functions that are not mathematically defined,
like the Cauchy mean, fail to compile by default.
-A [link math_toolkit.policy.pol_ref.assert_undefined policy]
+A [link math_toolkit.pol_ref.assert_undefined policy]
allows control of this.
If the policy is to permit undefined functions, then calling them
@@ -267,7 +267,7 @@
Some of the special functions in this library are implemented via
rational approximations. These are either taken from the literature,
or devised by John Maddock using
-[link math_toolkit.toolkit.internals2.minimax our Remez code].
+[link math_toolkit.internals2.minimax our Remez code].
Rational rather than Polynomial approximations are used to ensure
accuracy: polynomial approximations are often wonderful up to
@@ -541,8 +541,8 @@
[pre \[warning\]could not find any font family matching "Times New Roman"; replaced by Helvetica]
-(html is the default so it is generated at math_toolkit\libs\math\doc\sf_and_dist\html\index.html
-using command line >bjam -a > math_docs.log).
+(html is the default so it is generated at libs\math\doc\html\index.html
+using command line >bjam -a > math_toolkit.docs.log).
<!-- Sample configuration for Windows TrueType fonts. -->
is provided in the xep.xml downloaded, but the Windows TrueType fonts are commented out.
Modified: sandbox/math/libs/math/doc/background/lanczos.qbk
==============================================================================
--- sandbox/math/libs/math/doc/background/lanczos.qbk (original)
+++ sandbox/math/libs/math/doc/background/lanczos.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -50,8 +50,8 @@
approximations can make the difference between obtaining a valid result, or
simply garbage. Refer to the implementation notes for the __beta function for
an example of this method in practice. The incomplete
-[link math_toolkit.special.sf_gamma.igamma gamma_p gamma] and
-[link math_toolkit.special.sf_beta.ibeta_function beta] functions
+[link math_toolkit.sf_gamma.igamma gamma_p gamma] and
+[link math_toolkit.sf_beta.ibeta_function beta] functions
use similar analytic combinations of power terms, to combine gamma and beta
functions divided by large powers into single (simpler) expressions.
Modified: sandbox/math/libs/math/doc/background/references.qbk
==============================================================================
--- sandbox/math/libs/math/doc/background/references.qbk (original)
+++ sandbox/math/libs/math/doc/background/references.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -103,7 +103,7 @@
Robert Demming & Daniel J. Duffy, Introduction to the C++ Boost Libraries - Volume I - Foundations
and Volume II ISBN 978-94-91028-01-4, Advanced Libraries and Applications, ISBN 978-94-91028-02-1
(to be published in 2011).
-discusses application of Boost.Math, especially in finance.]
+discusses application of Boost.Math, especially in finance.
[endsect] [/section:references References]
[/
Modified: sandbox/math/libs/math/doc/complex/complex-tr1.qbk
==============================================================================
--- sandbox/math/libs/math/doc/complex/complex-tr1.qbk (original)
+++ sandbox/math/libs/math/doc/complex/complex-tr1.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -4,7 +4,7 @@
[def __ex '''<code>e<superscript>x</superscript></code>''']
[def __te '''2ε''']
-[section:inverse_complex Complex Number Functions]
+[mathpart inverse_complex..Complex Number Functions]
The following complex number algorithms are the inverses of trigonometric functions currently
present in the C++ standard. Equivalents to these functions are part of the C99 standard, and
@@ -137,7 +137,7 @@
[endsect]
-[endsect]
+[endmathpart]
Modified: sandbox/math/libs/math/doc/concepts/concepts.qbk
==============================================================================
--- sandbox/math/libs/math/doc/concepts/concepts.qbk (original)
+++ sandbox/math/libs/math/doc/concepts/concepts.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -269,7 +269,7 @@
the built-in floating-point types will meet these requirements.
User-defined types that meet the requirements can also be used.
-For example, with [link math_toolkit.using_udt.high_precision.use_ntl a thin wrapper class]
+For example, with [link math_toolkit.high_precision.use_ntl a thin wrapper class]
one of the types provided with [@http://shoup.net/ntl/ NTL (RR)] can be used.
But now that __multiprecision library is available,
this has become the reference real number type.
@@ -459,8 +459,8 @@
Please note that this documentation should not be used as a substitute
for the
-[link math_toolkit.dist.dist_ref reference documentation], and
-[link math_toolkit.dist.stat_tut tutorial] of the statistical
+[link math_toolkit.dist_ref reference documentation], and
+[link math_toolkit.stat_tut tutorial] of the statistical
distributions.
In the following table, /d/ is an object of type `DistributionType`,
@@ -558,7 +558,7 @@
}}} // namespaces
`real_concept` is an archetype for
-[link math_toolkit.using_udt.concepts user defined real types],
+[link math_toolkit.concepts user defined real types],
it declares its standard library functions in its own
namespace: these will only be found if they are called unqualified
allowing argument dependent lookup to locate them. In addition
@@ -566,11 +566,11 @@
this allows code that would not otherwise be exercised by the built-in
floating point types to be tested. There is no std::numeric_limits<>
support for this type, since numeric_limits is not a conceptual requirement
-for [link math_toolkit.using_udt.concepts RealType]s.
+for [link math_toolkit.concepts RealType]s.
NTL RR is an example of a type meeting the requirements that this type
models, but note that use of a thin wrapper class is required: refer to
-[linkmath_toolkit.using_udt.high_precision.use_ntl "Using With NTL - a High-Precision Floating-Point Library"].
+[link math_toolkit.high_precision.use_ntl "Using With NTL - a High-Precision Floating-Point Library"].
There is no specific test case for type `real_concept`, instead, since this
type is usable at runtime, each individual test case as well as testing
@@ -595,7 +595,7 @@
}}} // namespaces
The class template `distribution_archetype` is a model of the
-[link math_toolkit.using_udt.dist_concept Distribution concept].
+[link math_toolkit.dist_concept Distribution concept].
The class template `DistributionConcept` is a
[@../../../../../libs/concept_check/index.html concept checking class]
@@ -607,11 +607,11 @@
[@../../../test/compile_test/distribution_concept_check.cpp distribution_concept_check.cpp]
is responsible for using `DistributionConcept` to verify that all the
distributions in this library conform to the
-[link math_toolkit.using_udt.dist_concept Distribution concept].
+[link math_toolkit.dist_concept Distribution concept].
The class template `DistributionConcept` verifies the existence
(but not proper function) of the non-member accessors
-required by the [link math_toolkit.using_udt.dist_concept Distribution concept].
+required by the [link math_toolkit.dist_concept Distribution concept].
These are checked by calls like
v = pdf(dist, x); // (Result v is ignored).
Modified: sandbox/math/libs/math/doc/constants/constants.qbk
==============================================================================
--- sandbox/math/libs/math/doc/constants/constants.qbk (original)
+++ sandbox/math/libs/math/doc/constants/constants.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,4 +1,6 @@
-[section:constants Mathematical Constants]
+
+
+[mathpart constants..Mathematical Constants]
[section:intro Introduction]
@@ -8,7 +10,7 @@
* Readable. For the very many jobs just using built-in like `double`, you can just write expressions like
``double area = pi * r * r;``
-(If that's all you want, jump direct to [link math_toolkit.constants.tutorial.non_templ use in non-template code]!)
+(If that's all you want, jump direct to [link math_toolkit.tutorial.non_templ use in non-template code]!)
* Effortless - avoiding a search of reference sources.
* Usable with both builtin floating point types, and user-defined, possibly extended precision, types such as
NTL, MPFR/GMP, mp_float: in the latter case the constants are computed to the necessary precision and then cached.
@@ -19,7 +21,7 @@
* Less risk of inaccurate result from functions pow, trig and log at [@http://en.wikipedia.org/wiki/Corner_case corner cases].
* Less risk of [@http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html cancellation error].
* Portable - as possible between different systems using different floating-point precisions:
-see [link math_toolkit.constants.tutorial.templ use in template code].
+see [link math_toolkit.tutorial.templ use in template code].
* Tested - by comparison with other published sources, or separately computed at long double precision.
* Faster - can avoid (re-)calculation at runtime.
* If the value returned is a builtin type then it's returned by value as a `constexpr` (C++11 feature, if available).
@@ -64,7 +66,7 @@
Likewise, constants that are suitable for use at `long double` precision
are available in the namespace `boost::math::long_double_constants`.
-You can see the full list of available constants at [link math_toolkit.constants.constants].
+You can see the full list of available constants at [link math_toolkit.constants].
Some examples of using constants are at [@../../../example/constants_eg1.cpp constants_eg1].
@@ -579,7 +581,7 @@
[h4 What is the Internal Format of the constants, and why?]
-See [link math_toolkit.constants.tutorial tutorial] above for normal use,
+See [link math_toolkit.tutorial tutorial] above for normal use,
but this FAQ explains the internal details used for the constants.
Constants are stored as 100 decimal digit values.
@@ -605,7 +607,7 @@
In this case the significand is 109 decimal digits, ensuring 100 decimal digits are exact, and exponent is zero.
-See [link math_toolkit.constants.new_const defining new constants] to calculate new constants.
+See [link math_toolkit.new_const defining new constants] to calculate new constants.
A macro definition like this can be pasted into user code where convenient,
or into `boost/math/constants.hpp` if it is to be added to the Boost.Math library.
@@ -729,7 +731,7 @@
[endsect] [/section:FAQ FAQ]
-[endsect] [/section:constants Mathematical Constants]
+[endmathpart] [/section:constants Mathematical Constants]
[/
Copyright 2012 John Maddock and Paul A. Bristow.
Modified: sandbox/math/libs/math/doc/distributions/background.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/background.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/background.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -62,12 +62,12 @@
This behaviour can be changed so that the quantile functions are rounded
differently, or even return a real-valued result using
-[link math_toolkit.policy.pol_overview Policies]. It is strongly
+[link math_toolkit.pol_overview Policies]. It is strongly
recommended that you read the tutorial
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant
+[link math_toolkit.pol_tutorial.understand_dis_quant
Understanding Quantiles of Discrete Distributions] before
using the quantile function on a discrete distribution. The
-[link math_toolkit.policy.pol_ref.discrete_quant_ref reference docs]
+[link math_toolkit.pol_ref.discrete_quant_ref reference docs]
describe how to change the rounding policy
for these distributions.
]
Modified: sandbox/math/libs/math/doc/distributions/bernoulli.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/bernoulli.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/bernoulli.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -61,7 +61,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is 0 and 1,
Modified: sandbox/math/libs/math/doc/distributions/beta.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/beta.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/beta.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -180,7 +180,7 @@
[h4 Non-member Accessor Functions]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The formulae for calculating these are shown in the table below, and at
@@ -217,8 +217,8 @@
[h4 Accuracy]
This distribution is implemented using the
-[link math_toolkit.special.sf_beta.beta_function beta functions] __beta and
-[link math_toolkit.special.sf_beta.ibeta_function incomplete beta functions] __ibeta and __ibetac;
+[link math_toolkit.sf_beta.beta_function beta functions] __beta and
+[link math_toolkit.sf_beta.ibeta_function incomplete beta functions] __ibeta and __ibetac;
please refer to these functions for information on accuracy.
[h4 Implementation]
Modified: sandbox/math/libs/math/doc/distributions/binomial.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/binomial.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/binomial.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -133,7 +133,7 @@
p``[sub min]`` = binomial_distribution<RealType>::find_lower_bound_on_p(
n, k, 0.05);
-[link math_toolkit.dist.stat_tut.weg.binom_eg.binom_conf See worked example.]
+[link math_toolkit.stat_tut.weg.binom_eg.binom_conf See worked example.]
There are currently two possible values available for the /method/
optional parameter: /clopper_pearson_exact_interval/
@@ -213,7 +213,7 @@
p``[sub max]`` = binomial_distribution<RealType>::find_upper_bound_on_p(
n, k, 0.05);
-[link math_toolkit.dist.stat_tut.weg.binom_eg.binom_conf See worked example.]
+[link math_toolkit.stat_tut.weg.binom_eg.binom_conf See worked example.]
[note
In order to obtain a two sided bound on the success fraction, you
@@ -227,7 +227,7 @@
So for example a two sided 95% confidence interval would be obtained
by passing [alpha] = 0.025 to each of the functions.
-[link math_toolkit.dist.stat_tut.weg.binom_eg.binom_conf See worked example.]
+[link math_toolkit.stat_tut.weg.binom_eg.binom_conf See worked example.]
]
@@ -280,11 +280,11 @@
of not observing any events that occur with one in a million frequency.
This is typically used in failure analysis.
-[link math_toolkit.dist.stat_tut.weg.binom_eg.binom_size_eg See Worked Example.]
+[link math_toolkit.stat_tut.weg.binom_eg.binom_size_eg See Worked Example.]
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain for the random variable /k/ is `0 <= k <= N`, otherwise a
@@ -328,7 +328,7 @@
[h4 Examples]
-Various [link math_toolkit.dist.stat_tut.weg.binom_eg worked examples]
+Various [link math_toolkit.stat_tut.weg.binom_eg worked examples]
are available illustrating the use of the binomial distribution.
[h4 Accuracy]
@@ -374,7 +374,7 @@
[[quantile][Since the cdf is non-linear in variate /k/ none of the inverse
incomplete beta functions can be used here. Instead the quantile
is found numerically using a derivative free method
- ([link math_toolkit.toolkit.internals1.roots2 TOMS Algorithm 748]).]]
+ ([link math_toolkit.internals1.roots2 TOMS Algorithm 748]).]]
[[quantile from the complement][Found numerically as above.]]
[[mean][ `p * n` ]]
[[variance][ `p * n * (1-p)` ]]
Modified: sandbox/math/libs/math/doc/distributions/cauchy.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/cauchy.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/cauchy.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -72,12 +72,12 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
Note however that the Cauchy distribution does not have a mean,
standard deviation, etc. See __math_undefined
-[/link math_toolkit.policy.pol_ref.assert_undefined mathematically undefined function]
+[/link math_toolkit.pol_ref.assert_undefined mathematically undefined function]
to control whether these should fail to compile with a BOOST_STATIC_ASSERTION_FAILURE,
which is the default.
Modified: sandbox/math/libs/math/doc/distributions/chi_squared.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/chi_squared.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/chi_squared.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -102,7 +102,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
(We have followed the usual restriction of the mode to degrees of freedom >= 2,
@@ -114,13 +114,13 @@
[h4 Examples]
-Various [link math_toolkit.dist.stat_tut.weg.cs_eg worked examples]
+Various [link math_toolkit.stat_tut.weg.cs_eg worked examples]
are available illustrating the use of the Chi Squared Distribution.
[h4 Accuracy]
The Chi-Squared distribution is implemented in terms of the
-[link math_toolkit.special.sf_gamma.igamma incomplete gamma functions]:
+[link math_toolkit.sf_gamma.igamma incomplete gamma functions]:
please refer to the accuracy data for those functions.
[h4 Implementation]
Modified: sandbox/math/libs/math/doc/distributions/chi_squared_examples.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/chi_squared_examples.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/chi_squared_examples.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -364,7 +364,7 @@
is borderline, a legitimate question to ask is "How large would the sample size
have to be in order to produce a definitive result?"
-The class template [link math_toolkit.dist.dist_ref.dists.chi_squared_dist
+The class template [link math_toolkit.dist_ref.dists.chi_squared_dist
chi_squared_distribution] has a static method
`find_degrees_of_freedom` that will calculate this value for
some acceptable risk of type I failure /alpha/, type II failure
Modified: sandbox/math/libs/math/doc/distributions/dist_algorithms.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/dist_algorithms.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/dist_algorithms.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -65,7 +65,7 @@
If the choice of arguments would give a negative scale, __domain_error is called, unless the policy is to ignore, when the negative (impossible) value of scale is returned.
-[link math_toolkit.dist.stat_tut.weg.find_eg Find Mean and standard deviation examples]
+[link math_toolkit.stat_tut.weg.find_eg Find Mean and standard deviation examples]
gives simple examples of use of both find_scale and find_location, and a longer example finding means and standard deviations of normally distributed weights to meet a specification.
[endsect] [/section:dist_algorithms dist_algorithms]
Modified: sandbox/math/libs/math/doc/distributions/dist_reference.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/dist_reference.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/dist_reference.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -110,7 +110,7 @@
InputIterator b,
typename std::iterator_traits<InputIterator>::value_type expected_mean);
-Returns the probability that the data in the sequence [a,b) has the mean
+Returns the probability that the data in the sequence \[a,b) has the mean
/expected_mean/.
[h4 Integration With Statistical Accumulators]
Modified: sandbox/math/libs/math/doc/distributions/dist_tutorial.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/dist_tutorial.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/dist_tutorial.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,10 +1,10 @@
[/ def names all end in distrib to avoid clashes with names of functions]
-[def __binomial_distrib [link math_toolkit.dist.dist_ref.dists.binomial_dist Binomial Distribution]]
-[def __chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.chi_squared_dist Chi Squared Distribution]]
-[def __normal_distrib [link math_toolkit.dist.dist_ref.dists.normal_dist Normal Distribution]]
-[def __F_distrib [link math_toolkit.dist.dist_ref.dists.f_dist Fisher F Distribution]]
-[def __students_t_distrib [link math_toolkit.dist.dist_ref.dists.students_t_dist Students t Distribution]]
+[def __binomial_distrib [link math_toolkit.dist_ref.dists.binomial_dist Binomial Distribution]]
+[def __chi_squared_distrib [link math_toolkit.dist_ref.dists.chi_squared_dist Chi Squared Distribution]]
+[def __normal_distrib [link math_toolkit.dist_ref.dists.normal_dist Normal Distribution]]
+[def __F_distrib [link math_toolkit.dist_ref.dists.f_dist Fisher F Distribution]]
+[def __students_t_distrib [link math_toolkit.dist_ref.dists.students_t_dist Students t Distribution]]
[def __handbook [@http://www.itl.nist.gov/div898/handbook/
NIST/SEMATECH e-Handbook of Statistical Methods.]]
@@ -41,14 +41,14 @@
Each kind of distribution in this library is a class type - an object.
-[link math_toolkit.policy Policies] provide fine-grained control
+[link policy Policies] provide fine-grained control
of the behaviour of these classes, allowing the user to customise
behaviour such as how errors are handled, or how the quantiles
of discrete distribtions behave.
[tip If you are familiar with statistics libraries using functions,
and 'Distributions as Objects' seem alien, see
-[link math_toolkit.dist.stat_tut.weg.nag_library the comparison to
+[link math_toolkit.stat_tut.weg.nag_library the comparison to
other statistics libraries.]
] [/tip]
@@ -216,7 +216,7 @@
but except for a few special cases (in the Normal and Cauchy distributions)
this implementation limits random variates to finite values from the `max`
to `min` for the `RealType`.
-(See [link math_toolkit.backgrounders.implementation.handling_of_floating_point_infinity
+(See [link math_toolkit.implementation0.handling_of_floating_point_infin
Handling of Floating-Point Infinity] for rationale).
@@ -250,12 +250,12 @@
This behaviour can be changed so that the quantile functions are rounded
differently, or return a real-valued result using
-[link math_toolkit.policy.pol_overview Policies]. It is strongly
+[link math_toolkit.pol_overview Policies]. It is strongly
recommended that you read the tutorial
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant
+[link math_toolkit.pol_tutorial.understand_dis_quant
Understanding Quantiles of Discrete Distributions] before
using the quantile function on a discrete distribtion. The
-[link math_toolkit.policy.pol_ref.discrete_quant_ref reference docs]
+[link math_toolkit.pol_ref.discrete_quant_ref reference docs]
describe how to change the rounding policy
for these distributions.
@@ -269,7 +269,6 @@
[endsect] [/ section:generic Generic operations common to all distributions are non-member functions]
-[#complements]
[section:complements Complements are supported too - and when to use them]
Often you don't want the value of the CDF, but its complement, which is
Modified: sandbox/math/libs/math/doc/distributions/error_handling_example.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/error_handling_example.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/error_handling_example.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,6 +1,6 @@
[section:error_eg Error Handling Example]
-See [link math_toolkit.main_overview.error_handling error handling documentation]
+See [link math_toolkit.error_handling error handling documentation]
for a detailed explanation of the mechanism of handling errors,
including the common "bad" arguments to distributions and functions,
and how to use __policy_section to control it.
Modified: sandbox/math/libs/math/doc/distributions/exponential.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/exponential.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/exponential.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -52,7 +52,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is \[0, +[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/extreme_value.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/extreme_value.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/extreme_value.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -76,7 +76,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random parameter is \[-[infin], +[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/fisher.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/fisher.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/fisher.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -64,21 +64,21 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is \[0, +[infin]\].
[h4 Examples]
-Various [link math_toolkit.dist.stat_tut.weg.f_eg worked examples] are
+Various [link math_toolkit.stat_tut.weg.f_eg worked examples] are
available illustrating the use of the F Distribution.
[h4 Accuracy]
The normal distribution is implemented in terms of the
-[link math_toolkit.special.sf_beta.ibeta_function incomplete beta function]
-and its [link math_toolkit.special.sf_beta.ibeta_inv_function inverses],
+[link math_toolkit.sf_beta.ibeta_function incomplete beta function]
+and its [link math_toolkit.sf_beta.ibeta_inv_function inverses],
refer to those functions for accuracy data.
[h4 Implementation]
Modified: sandbox/math/libs/math/doc/distributions/gamma.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/gamma.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/gamma.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -94,7 +94,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[0,+[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/geometric.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/geometric.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/geometric.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -161,7 +161,7 @@
p``[sub min]`` = geometric_distribution<RealType>::
find_lower_bound_on_p(failures, 0.05);
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative_binomial confidence interval example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative_binomial confidence interval example.]
This function uses the Clopper-Pearson method of computing the lower bound on the
success fraction, whilst many texts refer to this method as giving an "exact"
@@ -195,7 +195,7 @@
p``[sub max]`` = geometric_distribution<RealType>::find_upper_bound_on_p(
k, 0.05);
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
This function uses the Clopper-Pearson method of computing the lower bound on the
success fraction, whilst many texts refer to this method as giving an "exact"
@@ -230,7 +230,7 @@
Returns the smallest number of trials we must conduct to be 95% (1-0.05) sure
of seeing 10 failures that occur with frequency one half.
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_size_eg Worked Example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_size_eg Worked Example.]
This function uses numeric inversion of the geometric distribution
to obtain the result: another interpretation of the result is that it finds
@@ -267,7 +267,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
However it's worth taking a moment to define what these actually mean in
Modified: sandbox/math/libs/math/doc/distributions/geometric_example.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/geometric_example.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/geometric_example.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -7,7 +7,7 @@
See full source C++ of this example at
[@../../example/geometric_examples.cpp geometric_examples.cpp]
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative_binomial confidence interval example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative_binomial confidence interval example.]
[endsect] [/section:geometric_eg Geometric Distribution Examples]
Modified: sandbox/math/libs/math/doc/distributions/hypergeometric.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/hypergeometric.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/hypergeometric.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -75,7 +75,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is the unsigned integers in the range
@@ -93,12 +93,12 @@
This behaviour can be changed so that the quantile functions are rounded
differently using
-[link math_toolkit.policy.pol_overview Policies]. It is strongly
+[link math_toolkit.pol_overview Policies]. It is strongly
recommended that you read the tutorial
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant
+[link math_toolkit.pol_tutorial.understand_dis_quant
Understanding Quantiles of Discrete Distributions] before
using the quantile function on the Hypergeometric distribution. The
-[link math_toolkit.policy.pol_ref.discrete_quant_ref reference docs]
+[link math_toolkit.pol_ref.discrete_quant_ref reference docs]
describe how to change the rounding policy
for these distributions.
Modified: sandbox/math/libs/math/doc/distributions/inverse_chi_squared.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/inverse_chi_squared.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/inverse_chi_squared.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -118,7 +118,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variate is \[0,+[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/inverse_gamma.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/inverse_gamma.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/inverse_gamma.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -81,7 +81,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variate is \[0,+[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/inverse_gaussian.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/inverse_gaussian.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/inverse_gaussian.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -108,7 +108,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variate is \[0,+[infin]).
Modified: sandbox/math/libs/math/doc/distributions/laplace.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/laplace.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/laplace.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -72,7 +72,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[-[infin],+[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/logistic.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/logistic.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/logistic.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -55,7 +55,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is \[-\[max_value\], +\[min_value\]\].
Modified: sandbox/math/libs/math/doc/distributions/lognormal.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/lognormal.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/lognormal.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -75,7 +75,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[0,+[infin]\].
@@ -84,7 +84,7 @@
The lognormal distribution is implemented in terms of the
standard library log and exp functions, plus the
-[link math_toolkit.special.sf_erf.error_function error function],
+[link math_toolkit.sf_erf.error_function error function],
and as such should have very low error rates.
[h4 Implementation]
Modified: sandbox/math/libs/math/doc/distributions/nc_beta.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/nc_beta.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/nc_beta.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -79,7 +79,7 @@
[h4 Non-member Accessors]
-Most of the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+Most of the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
are supported: __cdf, __pdf, __quantile, __mean, __variance, __sd,
__median, __mode, __hazard, __chf, __range and __support.
@@ -195,7 +195,7 @@
[equation nc_beta_ref1]
Quantiles are computed using a specially modified version of
-[link math_toolkit.toolkit.internals1.roots2 bracket_and_solve_root],
+[link math_toolkit.internals1.roots2 bracket_and_solve_root],
starting the search for the root at the mean of the distribution.
(A Cornish-Fisher type expansion was also tried, but while this gets
quite close to the root in many cases, when it is wrong it tends to
Modified: sandbox/math/libs/math/doc/distributions/nc_chi_squared.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/nc_chi_squared.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/nc_chi_squared.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -115,7 +115,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is \[0, +[infin]\].
@@ -123,7 +123,7 @@
[h4 Examples]
There is a
-[link math_toolkit.dist.stat_tut.weg.nccs_eg worked example]
+[link math_toolkit.stat_tut.weg.nccs_eg worked example]
for the noncentral chi-squared distribution.
[h4 Accuracy]
Modified: sandbox/math/libs/math/doc/distributions/nc_f.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/nc_f.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/nc_f.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -76,7 +76,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is \[0, +[infin]\].
Modified: sandbox/math/libs/math/doc/distributions/nc_t.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/nc_t.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/nc_t.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -69,7 +69,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is \[-[infin], +[infin]\].
@@ -194,7 +194,7 @@
N. Balkrishnan. 1995. John Wiley and Sons New York.
The quantile is calculated via the usual
-[link math_toolkit.toolkit.internals1.roots2
+[link math_toolkit.internals1.roots2
derivative-free root-finding techniques],
with the initial guess taken as the quantile of a normal approximation
to the noncentral T.
Modified: sandbox/math/libs/math/doc/distributions/negative_binomial.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/negative_binomial.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/negative_binomial.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -156,7 +156,7 @@
p``[sub min]`` = negative_binomial_distribution<RealType>::find_lower_bound_on_p(
failures, successes, 0.05);
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
This function uses the Clopper-Pearson method of computing the lower bound on the
success fraction, whilst many texts refer to this method as giving an "exact"
@@ -192,7 +192,7 @@
p``[sub max]`` = negative_binomial_distribution<RealType>::find_upper_bound_on_p(
r, k, 0.05);
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
This function uses the Clopper-Pearson method of computing the lower bound on the
success fraction, whilst many texts refer to this method as giving an "exact"
@@ -227,7 +227,7 @@
Returns the smallest number of trials we must conduct to be 95% sure
of seeing 10 failures that occur with frequency one half.
-[link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_size_eg Worked Example.]
+[link math_toolkit.stat_tut.weg.neg_binom_eg.neg_binom_size_eg Worked Example.]
This function uses numeric inversion of the negative binomial distribution
to obtain the result: another interpretation of the result, is that it finds
@@ -264,7 +264,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
However it's worth taking a moment to define what these actually mean in
Modified: sandbox/math/libs/math/doc/distributions/non_members.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/non_members.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/non_members.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -4,61 +4,61 @@
getter functions: non-membership allows more of these functions to be added over time,
as the need arises. Unfortunately the literature uses many different and
confusing names to refer to a rather small number of actual concepts; refer
-to the [link concept_index concept index] to find the property you
+to the [link math_toolkit.dist_ref.nmp.concept_index concept index] to find the property you
want by the name you are most familiar with.
-Or use the [link function_index function index]
+Or use the [link math_toolkit.dist_ref.nmp.function_index function index]
to go straight to the function you want if you already know its name.
-[h4 [#function_index]Function Index]
+[h4:function_index Function Index]
-* [link math.dist.cdf cdf].
-* [link math.dist.ccdf cdf complement].
-* [link math.dist.chf chf].
-* [link math.dist.hazard hazard].
+* __cdf.
+* __ccdf.
+* __chf.
+* __hazard.
* __kurtosis.
* __kurtosis_excess
* __mean.
-* [link math.dist.median median].
+* __median.
* __mode.
-* [link math.dist.pdf pdf].
-* [link math.dist.range range].
-* [link math.dist.quantile quantile].
-* [link math.dist.quantile_c quantile from the complement].
+* __pdf.
+* __range.
+* __quantile.
+* __quantile_c.
* __skewness.
-* [link math.dist.sd standard_deviation].
-* [link math.dist.support support].
+* __sd.
+* __support.
* __variance.
-[h4 [#concept_index]Conceptual Index]
+[h4:concept_index Conceptual Index]
* __ccdf.
* __cdf.
* __chf.
-* [link cdf_inv Inverse Cumulative Distribution Function].
-* [link survival_inv Inverse Survival Function].
+* [link math_toolkit.dist_ref.nmp.cdf_inv Inverse Cumulative Distribution Function].
+* [link math_toolkit.dist_ref.nmp.survival_inv Inverse Survival Function].
* __hazard
-* [link lower_critical Lower Critical Value].
+* [link math_toolkit.dist_ref.nmp.lower_critical Lower Critical Value].
* __kurtosis.
* __kurtosis_excess
* __mean.
-* [link math.dist.median median].
+* __median.
* __mode.
-* [link cdfPQ P].
-* [link percent Percent Point Function].
+* [link math_toolkit.dist_ref.nmp.cdfPQ P].
+* [link math_toolkit.dist_ref.nmp.percent Percent Point Function].
* __pdf.
-* [link pmf Probability Mass Function].
-* [link math.dist.range range].
-* [link cdfPQ Q].
+* [link math_toolkit.dist_ref.nmp.pmf Probability Mass Function].
+* __range.
+* [link math_toolkit.dist_ref.nmp.cdfPQ Q].
* __quantile.
-* [link math.dist.quantile_c Quantile from the complement of the probability].
+* [link math_toolkit.dist_ref.nmp.quantile_c Quantile from the complement of the probability].
* __skewness.
* __sd
-* [link survival Survival Function].
-* [link math.dist.support support].
-* [link upper_critical Upper Critical Value].
+* [link math_toolkit.dist_ref.nmp.survival Survival Function].
+* [link math_toolkit.dist_ref.nmp.support support].
+* [link math_toolkit.dist_ref.nmp.upper_critical Upper Critical Value].
* __variance.
-[h4 [#math.dist.cdf]Cumulative Distribution Function]
+[h4:cdf Cumulative Distribution Function]
template <class RealType, class ``__Policy``>
RealType cdf(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist, const RealType& x);
@@ -75,7 +75,7 @@
[$../graphs/cdf.png]
-[h4 [#math.dist.ccdf]Complement of the Cumulative Distribution Function]
+[h4:ccdf Complement of the Cumulative Distribution Function]
template <class Distribution, class RealType>
RealType cdf(const ``['Unspecified-Complement-Type]``<Distribution, RealType>& comp);
@@ -105,7 +105,7 @@
See __why_complements for why the complement is useful and when it should be used.
-[h4 [#math.dist.hazard]Hazard Function]
+[h4:hazard Hazard Function]
template <class RealType, class ``__Policy``>
RealType hazard(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist, const RealType& x);
@@ -121,7 +121,7 @@
Some authors refer to this as the conditional failure
density function rather than the hazard function.]
-[h4 [#math.dist.chf]Cumulative Hazard Function]
+[h4:chf Cumulative Hazard Function]
template <class RealType, class ``__Policy``>
RealType chf(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist, const RealType& x);
@@ -136,7 +136,7 @@
[caution
Some authors refer to this as simply the "Hazard Function".]
-[h4 [#math.dist.mean]mean]
+[h4:mean mean]
template<class RealType, class ``__Policy``>
RealType mean(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -146,14 +146,14 @@
This function may return a __domain_error if the distribution does not have
a defined mean (for example the Cauchy distribution).
-[h4 [#math.dist.median]median]
+[h4:median median]
template<class RealType, class ``__Policy``>
RealType median(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
Returns the median of the distribution /dist/.
-[h4 [#math.dist.mode]mode]
+[h4:mode mode]
template<class RealType, ``__Policy``>
RealType mode(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -163,7 +163,7 @@
This function may return a __domain_error if the distribution does not have
a defined mode.
-[h4 [#math.dist.pdf]Probability Density Function]
+[h4:pdf Probability Density Function]
template <class RealType, class ``__Policy``>
RealType pdf(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist, const RealType& x);
@@ -184,14 +184,14 @@
[$../graphs/pdf.png]
-[h4 [#math.dist.range]Range]
+[h4:range Range]
template<class RealType, class ``__Policy``>
std::pair<RealType, RealType> range(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
Returns the valid range of the random variable over distribution /dist/.
-[h4 [#math.dist.quantile]Quantile]
+[h4:quantile Quantile]
template <class RealType, class ``__Policy``>
RealType quantile(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist, const RealType& p);
@@ -211,8 +211,8 @@
[$../graphs/quantile.png]
-[h4 [#math.dist.quantile_c]Quantile from the complement of the probability.]
-[link complements complements]
+[h4:quantile_c Quantile from the complement of the probability.]
+See also [link math_toolkit.stat_tut.overview.complements complements].
template <class Distribution, class RealType>
@@ -246,7 +246,7 @@
[$../graphs/survival_inv.png]
-[h4 [#math.dist.sd]Standard Deviation]
+[h4:sd Standard Deviation]
template <class RealType, class ``__Policy``>
RealType standard_deviation(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -256,7 +256,7 @@
This function may return a __domain_error if the distribution does not have
a defined standard deviation.
-[h4 [#math.dist.support]support]
+[h4:support support]
template<class RealType, class ``__Policy``>
std::pair<RealType, RealType> support(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -270,7 +270,7 @@
of random variate x that has the cdf going from zero to unity.
Outside are uninteresting zones where the pdf is zero, and the cdf zero or unity.
-[h4 [#math.dist.variance]Variance]
+[h4:variance Variance]
template <class RealType, class ``__Policy``>
RealType variance(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -280,7 +280,7 @@
This function may return a __domain_error if the distribution does not have
a defined variance.
-[h4 [#math.dist.skewness]Skewness]
+[h4:skewness Skewness]
template <class RealType, class ``__Policy``>
RealType skewness(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -290,7 +290,7 @@
This function may return a __domain_error if the distribution does not have
a defined skewness.
-[h4 [#math.dist.kurtosis]Kurtosis]
+[h4:kurtosis Kurtosis]
template <class RealType, class ``__Policy``>
RealType kurtosis(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -322,7 +322,7 @@
'Proper' kurtosis can have a value from zero to + infinity.
-[h4 [#math.dist.kurtosis_excess]Kurtosis excess]
+[h4:kurtosis_excess Kurtosis excess]
template <class RealType, ``__Policy``>
RealType kurtosis_excess(const ``['Distribution-Type]``<RealType, ``__Policy``>& dist);
@@ -347,50 +347,50 @@
The kurtosis excess of a normal distribution is zero.
-[h4 [#cdfPQ]P and Q]
+[h4:cdfPQ P and Q]
The terms P and Q are sometimes used to refer to the __cdf
-and its [link math.dist.ccdf complement] respectively.
+and its [link math_toolkit.dist_ref.nmp.ccdf complement] respectively.
Lowercase p and q are sometimes used to refer to the values returned
by these functions.
-[h4 [#percent]Percent Point Function or Percentile]
+[h4:percent Percent Point Function or Percentile]
The percent point function, also known as the percentile, is the same as
the __quantile.
-[h4 [#cdf_inv]Inverse CDF Function.]
+[h4:cdf_inv Inverse CDF Function.]
The inverse of the cumulative distribution function, is the same as the
__quantile.
-[h4 [#survival_inv]Inverse Survival Function.]
+[h4:survival_inv Inverse Survival Function.]
The inverse of the survival function, is the same as computing the
-[link math.dist.quantile_c quantile
+[link math_toolkit.dist_ref.nmp.quantile_c quantile
from the complement of the probability].
-[h4 [#pmf]Probability Mass Function]
+[h4:pmf Probability Mass Function]
The Probability Mass Function is the same as the __pdf.
The term Mass Function is usually applied to discrete distributions,
while the term __pdf applies to continuous distributions.
-[h4 [#lower_critical]Lower Critical Value.]
+[h4:lower_critical Lower Critical Value.]
The lower critical value calculates the value of the random variable
given the area under the left tail of the distribution.
It is equivalent to calculating the __quantile.
-[h4 [#upper_critical]Upper Critical Value.]
+[h4: upper_critical Upper Critical Value.]
The upper critical value calculates the value of the random variable
given the area under the right tail of the distribution. It is equivalent to
-calculating the [link math.dist.quantile_c quantile from the complement of the
+calculating the [link math_toolkit.dist_ref.nmp.quantile_c quantile from the complement of the
probability].
-[h4 [#survival]Survival Function]
+[h4:survival Survival Function]
Refer to the __ccdf.
Modified: sandbox/math/libs/math/doc/distributions/normal.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/normal.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/normal.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -74,7 +74,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[-[max_value], +[min_value]\].
@@ -86,7 +86,7 @@
[h4 Accuracy]
The normal distribution is implemented in terms of the
-[link math_toolkit.special.sf_erf.error_function error function],
+[link math_toolkit.sf_erf.error_function error function],
and as such should have very low error rates.
[h4 Implementation]
Modified: sandbox/math/libs/math/doc/distributions/pareto.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/pareto.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/pareto.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -70,7 +70,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The supported domain of the random variable is \[scale, [infin]\].
Modified: sandbox/math/libs/math/doc/distributions/poisson.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/poisson.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/poisson.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -57,7 +57,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[0, [infin]\].
Modified: sandbox/math/libs/math/doc/distributions/rayleigh.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/rayleigh.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/rayleigh.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -72,7 +72,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[0, max_value\].
Modified: sandbox/math/libs/math/doc/distributions/skew_normal.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/skew_normal.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/skew_normal.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -112,7 +112,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is ['-[max_value], +[min_value]].
@@ -145,7 +145,7 @@
The skew_normal distribution with shape = zero is implemented as a special case,
equivalent to the normal distribution in terms of the
-[link math_toolkit.special.sf_erf.error_function error function],
+[link math_toolkit.sf_erf.error_function error function],
and therefore should have excellent accuracy.
The PDF and mean, variance, skewness and kurtosis are also accurately evaluated using
Modified: sandbox/math/libs/math/doc/distributions/students_t.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/students_t.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/students_t.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -105,21 +105,21 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[-[infin], +[infin]\].
[h4 Examples]
-Various [link math_toolkit.dist.stat_tut.weg.st_eg worked examples] are available illustrating the use of the Student's t
+Various [link math_toolkit.stat_tut.weg.st_eg worked examples] are available illustrating the use of the Student's t
distribution.
[h4 Accuracy]
The normal distribution is implemented in terms of the
-[link math_toolkit.special.sf_beta.ibeta_function incomplete beta function]
-and [link math_toolkit.special.sf_beta.ibeta_inv_function its inverses],
+[link math_toolkit.sf_beta.ibeta_function incomplete beta function]
+and [link math_toolkit.sf_beta.ibeta_inv_function its inverses],
refer to accuracy data on those functions for more information.
[h4 Implementation]
Modified: sandbox/math/libs/math/doc/distributions/students_t_examples.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/students_t_examples.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/students_t_examples.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -759,13 +759,13 @@
That means we can:
-* [link math_toolkit.dist.stat_tut.weg.st_eg.tut_mean_intervals Calculate confidence intervals of the mean].
+* [link math_toolkit.stat_tut.weg.st_eg.tut_mean_intervals Calculate confidence intervals of the mean].
If the endpoints of the interval differ in sign then we are unable to reject
the null-hypothesis that there is no change.
-* [link math_toolkit.dist.stat_tut.weg.st_eg.tut_mean_test Test whether the true mean is zero]. If the
+* [link math_toolkit.stat_tut.weg.st_eg.tut_mean_test Test whether the true mean is zero]. If the
result is consistent with a true mean of zero, then we are unable to reject the
null-hypothesis that there is no change.
-* [link math_toolkit.dist.stat_tut.weg.st_eg.tut_mean_size Calculate how many pairs of readings we would need
+* [link math_toolkit.stat_tut.weg.st_eg.tut_mean_size Calculate how many pairs of readings we would need
in order to obtain a significant result].
[endsect]
Modified: sandbox/math/libs/math/doc/distributions/triangular.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/triangular.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/triangular.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -102,7 +102,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \lower\ to \upper\,
@@ -151,7 +151,7 @@
* [@http://en.wikipedia.org/wiki/Triangular_distribution Wikpedia triangular distribution]
* [@http://mathworld.wolfram.com/TriangularDistribution.html Weisstein, Eric W. "Triangular Distribution." From MathWorld--A Wolfram Web Resource.]
-* Evans, M.; Hastings, N.; and Peacock, B. "Triangular Distribution." Ch. 40 in Statistical Distributions, 3rd ed. New York: Wiley, pp. 187-188, 2000, ISBN - 0471371246]
+* Evans, M.; Hastings, N.; and Peacock, B. "Triangular Distribution." Ch. 40 in Statistical Distributions, 3rd ed. New York: Wiley, pp. 187-188, 2000, ISBN - 0471371246.
* [@http://www.brighton-webs.co.uk/distributions/triangular.asp Brighton Webs Ltd. BW D-Calc 1.0 Distribution Calculator]
* [@http://www.worldscibooks.com/mathematics/etextbook/5720/5720_chap1.pdf The Triangular Distribution including its history.]
* [@http://www.measurement.sk/2002/S1/Wimmer2.pdf Gejza Wimmer, Viktor Witkovsky and Tomas Duby,
Modified: sandbox/math/libs/math/doc/distributions/uniform.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/uniform.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/uniform.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -87,7 +87,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions]
that are generic to all distributions are supported: __usual_accessors.
The domain of the random variable is any finite value,
Modified: sandbox/math/libs/math/doc/distributions/weibull.qbk
==============================================================================
--- sandbox/math/libs/math/doc/distributions/weibull.qbk (original)
+++ sandbox/math/libs/math/doc/distributions/weibull.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -84,7 +84,7 @@
[h4 Non-member Accessors]
-All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions] that are generic to all
+All the [link math_toolkit.dist_ref.nmp usual non-member accessor functions] that are generic to all
distributions are supported: __usual_accessors.
The domain of the random variable is \[0, [infin]\].
Modified: sandbox/math/libs/math/doc/gcd/math-gcd.qbk
==============================================================================
--- sandbox/math/libs/math/doc/gcd/math-gcd.qbk (original)
+++ sandbox/math/libs/math/doc/gcd/math-gcd.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,4 +1,5 @@
-[section:gcd_lcm Integer Utilities (Greatest Common Divisor and Least Common Multiple)]
+
+[mathpart gcd_lcm Integer Utilities (Greatest Common Divisor and Least Common Multiple)]
[section Introduction]
@@ -233,5 +234,5 @@
[endsect]
-[endsect]
+[endmathpart]
Modified: sandbox/math/libs/math/doc/html4_symbols.qbk
==============================================================================
--- sandbox/math/libs/math/doc/html4_symbols.qbk (original)
+++ sandbox/math/libs/math/doc/html4_symbols.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -11,7 +11,7 @@
[/Unicode Latin extended http://www.unicode.org/charts/U0080.pdf]
[/ Also some miscellaneous math characters added to this list - see the end.]
-[/ For others see also math_symbols.qbk]
+[/ For others see also math_toolkit.symbols.qbk]
[/ To use, enclose the template name in square brackets, for example: [pi]]
Modified: sandbox/math/libs/math/doc/internals/minimax.qbk
==============================================================================
--- sandbox/math/libs/math/doc/internals/minimax.qbk (original)
+++ sandbox/math/libs/math/doc/internals/minimax.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -13,7 +13,7 @@
algorithm is, and the general form of the approximation you want to achieve.
Unless you already familar with the Remez method,
-you should first read the [link math_toolkit.backgrounders.remez
+you should first read the [link math_toolkit.remez
brief background article explaining the principles behind the
Remez algorithm].
@@ -35,7 +35,7 @@
after the existing examples.
In addition to those two files, the program needs to be linked to
-a [link math_toolkit.using_udt.high_precision.use_ntl patched NTL library to compile].
+a [link math_toolkit.high_precision.use_ntl patched NTL library to compile].
Note that the function /f/ must return the rational part of the
approximation: for example if you are approximating a function
Modified: sandbox/math/libs/math/doc/internals/rational.qbk
==============================================================================
--- sandbox/math/libs/math/doc/internals/rational.qbk (original)
+++ sandbox/math/libs/math/doc/internals/rational.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -159,10 +159,10 @@
tuned using various configuration macros to provide optimal performance
for a particular combination of compiler and platform. This includes
support for second-order Horner's methods. The various options are
-[link math_toolkit.perf.tuning documented here]. However, the performance
+[link math_toolkit.tuning documented here]. However, the performance
benefits to be gained from these are marginal on most current hardware,
consequently it's best to run the
-[link math_toolkit.perf.perf_test_app performance test application] before
+[link math_toolkit.perf_test_app performance test application] before
changing the default settings.
[endsect][/section:rational Polynomial and Rational Function Evaluation]
Modified: sandbox/math/libs/math/doc/internals/roots.qbk
==============================================================================
--- sandbox/math/libs/math/doc/internals/roots.qbk (original)
+++ sandbox/math/libs/math/doc/internals/roots.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -34,10 +34,10 @@
These functions all perform iterative root finding using derivatives:
* `newton_raphson_iterate` performs second order
-[link newton Newton-Raphson iteration],
+[link math_toolkit.internals1.roots.newton Newton-Raphson iteration],
* `halley_iterate` and`schroeder_iterate` perform third order
-[link halley Halley] and [link schroeder Schroeder] iteration.
+[link math_toolkit.internals1.roots.halley Halley] and [link math_toolkit.internals1.roots.schroeder Schroeder] iteration.
The functions all take the same parameters:
@@ -109,8 +109,7 @@
than computing the derivatives themselves. As ever, algebraic simplification can
be a big win.
-[#newton]
-[h4 Newton Raphson Method]
+[h4:newton Newton Raphson Method]
Given an initial guess x0 the subsequent values are computed using:
[equation roots1]
@@ -119,8 +118,7 @@
Under ideal conditions, the number of correct digits doubles with each iteration.
-[#halley]
-[h4 Halley's Method]
+[h4:halley Halley's Method]
Given an initial guess x0 the subsequent values are computed using:
@@ -134,8 +132,7 @@
Under ideal conditions, the number of correct digits trebles with each iteration.
-[#schroeder]
-[h4 Schroeder's Method]
+[h4:schroeder Schroeder's Method]
Given an initial guess x0 the subsequent values are computed using:
Modified: sandbox/math/libs/math/doc/internals/test_data.qbk
==============================================================================
--- sandbox/math/libs/math/doc/internals/test_data.qbk (original)
+++ sandbox/math/libs/math/doc/internals/test_data.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -389,7 +389,6 @@
of a and z.
[h4 reference]
-[#test_data_reference]
Most of this tool has been described already in the examples above, we'll
just add the following notes on the non-member functions:
Modified: sandbox/math/libs/math/doc/math.qbk
==============================================================================
--- sandbox/math/libs/math/doc/math.qbk (original)
+++ sandbox/math/libs/math/doc/math.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,16 +1,21 @@
-[article Math Toolkit
- [quickbook 1.5]
- [copyright 2006, 2007, 2008, 2009, 2010, 2012, 2013 John Maddock, Paul A. Bristow, Hubert Holin, Xiaogang Zhang, Bruno Lalande, Johan RÃ¥de, Gautam Sewani, Thijs van den Berg, Benjamin Sobotta and Christopher Kormanyos]
+[book Math Toolkit
+ [quickbook 1.6]
+ [copyright 2006, 2007, 2008, 2009, 2010, 2012, 2013 John Maddock, Paul A. Bristow, Hubert Holin, Xiaogang Zhang, Bruno Lalande, Johan RÃ¥de, Gautam Sewani, Thijs van den Berg, Daryle Walker, Benjamin Sobotta and Christopher Kormanyos]
[/purpose ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22]
[license
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
[@http://www.boost.org/LICENSE_1_0.txt])
]
- [authors [Bristow, Paul A.], [Holin, Hubert], [Kormanyos, Christopher], [Lalande, Bruno], [Maddock, John], [RÃ¥de, Johan], [Sobotta, Benjamin], [Sewani, Gautam], [van den Berg, Thijs], [Zhang, Xiaogang] ]
+ [authors [Bristow, Paul A.], [Holin, Hubert], [Kormanyos, Christopher], [Lalande, Bruno], [Maddock, John], [RÃ¥de, Johan], [Sobotta, Benjamin], [Sewani, Gautam], [van den Berg, Thijs], [Walker, Daryle], [Zhang, Xiaogang] ]
[/last-revision $Date$]
]
+[template mathpart[id title]
+[block '''<chapter id="'''[id]'''"><title>'''[title]'''</title>''']]
+[template endmathpart[]
+[block '''</chapter>''']]
+
[/ \u00E5 = Latin small letter A with ring above doesn't seem to work in authors with Quickbook 1.5]
[template equation[name] '''<inlinemediaobject>
@@ -31,14 +36,14 @@
</imageobject>
</inlinemediaobject>''']
-[include ../../../tools/auto_index/include/auto_index_helpers.qbk]
+[import ../../../tools/auto_index/include/auto_index_helpers.qbk]
[/ Must be first included file!]
-[include html4_symbols.qbk]
+[import html4_symbols.qbk]
-[include overview/common_overviews.qbk] [/ overviews that appear in more than one place!]
-[include overview/tr1.qbk] [/tr1 docs also appear in more than one place!]
-[include overview/roadmap.qbk] [/ for history]
+[import overview/common_overviews.qbk] [/ overviews that appear in more than one place!]
+[import overview/tr1.qbk] [/tr1 docs also appear in more than one place!]
+[import overview/roadmap.qbk] [/ for history]
[def __effects [*Effects: ]]
[def __formula [*Formula: ]]
@@ -65,238 +70,238 @@
[template tr1[] [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Technical Report on C++ Library Extensions]]
[template C99[] [@http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf C99 Standard ISO/IEC 9899:1999]]
-[template jm_rationals[] [link math_toolkit.backgrounders.implementation.rational_approximations_used devised by JM]]
+[template jm_rationals[] [link math_toolkit.implementation0.rational_approximations_used devised by JM]]
-[def __domain_error [link domain_error domain_error]]
-[def __pole_error [link pole_error pole_error]]
-[def __overflow_error [link overflow_error overflow_error]]
-[def __underflow_error [link underflow_error underflow_error]]
-[def __denorm_error [link denorm_error denorm_error]]
-[def __evaluation_error [link evaluation_error evaluation_error]]
-[def __rounding_error [link rounding_error rounding_error]]
-[def __indeterminate_result_error [link indeterminate_result_error indeterminate_result_error]]
-[def __checked_narrowing_cast [link checked_narrowing_cast checked_narrowing_cast]]
+[def __domain_error [link math_toolkit.error_handling.domain_error domain_error]]
+[def __pole_error [link math_toolkit.error_handling.pole_error pole_error]]
+[def __overflow_error [link math_toolkit.error_handling.overflow_error overflow_error]]
+[def __underflow_error [link math_toolkit.error_handling.underflow_error underflow_error]]
+[def __denorm_error [link math_toolkit.error_handling.denorm_error denorm_error]]
+[def __evaluation_error [link math_toolkit.error_handling.evaluation_error evaluation_error]]
+[def __rounding_error [link math_toolkit.error_handling.rounding_error rounding_error]]
+[def __indeterminate_result_error [link math_toolkit.error_handling.indeterminate_result_error indeterminate_result_error]]
+[def __checked_narrowing_cast [link math_toolkit.error_handling.checked_narrowing_cast checked_narrowing_cast]]
-[def __arg_pomotion_rules [link math_toolkit.main_overview.result_type ['result type calculation rules]]]
-[def __sf_result [link math_toolkit.main_overview.result_type ['calculated-result-type]]]
+[def __arg_pomotion_rules [link math_toolkit.result_type ['result type calculation rules]]]
+[def __sf_result [link math_toolkit.result_type ['calculated-result-type]]]
[/ The following macros expand to links to the various special functions
and use the function's name as the link text.]
[/Misc]
-[def __lanczos [link math_toolkit.backgrounders.lanczos Lanczos approximation]]
-[def __zero_error [link zero_error effectively zero error]]
-[def __relative_error [link math_toolkit.backgrounders.relative_error relative zero error]]
-[def __root_finding_with_derivatives [link math_toolkit.toolkit.internals1.roots root-finding with derivatives]]
+[def __lanczos [link math_toolkit.lanczos Lanczos approximation]]
+[def __zero_error [link math_toolkit.relative_error.zero_error effectively zero error]]
+[def __relative_error [link math_toolkit.relative_error relative zero error]]
+[def __root_finding_with_derivatives [link math_toolkit.internals1.roots root-finding with derivatives]]
[/gammas]
-[def __lgamma [link math_toolkit.special.sf_gamma.lgamma lgamma]]
-[def __digamma [link math_toolkit.special.sf_gamma.digamma digamma]]
-[def __tgamma_ratio [link math_toolkit.special.sf_gamma.gamma_ratios tgamma_ratio]]
-[def __tgamma_delta_ratio [link math_toolkit.special.sf_gamma.gamma_ratios tgamma_delta_ratio]]
-[def __tgamma [link math_toolkit.special.sf_gamma.tgamma tgamma]]
-[def __tgamma1pm1 [link math_toolkit.special.sf_gamma.tgamma tgamma1pm1]]
-[def __tgamma_lower [link math_toolkit.special.sf_gamma.igamma tgamma_lower]]
-[def __gamma_p [link math_toolkit.special.sf_gamma.igamma gamma_p]]
-[def __gamma_q [link math_toolkit.special.sf_gamma.igamma gamma_q]]
-[def __gamma_q_inv [link math_toolkit.special.sf_gamma.igamma_inv gamma_q_inv]]
-[def __gamma_p_inv [link math_toolkit.special.sf_gamma.igamma_inv gamma_p_inv]]
-[def __gamma_q_inva [link math_toolkit.special.sf_gamma.igamma_inv gamma_q_inva]]
-[def __gamma_p_inva [link math_toolkit.special.sf_gamma.igamma_inv gamma_p_inva]]
-[def __gamma_p_derivative [link math_toolkit.special.sf_gamma.gamma_derivatives gamma_p_derivative]]
+[def __lgamma [link math_toolkit.sf_gamma.lgamma lgamma]]
+[def __digamma [link math_toolkit.sf_gamma.digamma digamma]]
+[def __tgamma_ratio [link math_toolkit.sf_gamma.gamma_ratios tgamma_ratio]]
+[def __tgamma_delta_ratio [link math_toolkit.sf_gamma.gamma_ratios tgamma_delta_ratio]]
+[def __tgamma [link math_toolkit.sf_gamma.tgamma tgamma]]
+[def __tgamma1pm1 [link math_toolkit.sf_gamma.tgamma tgamma1pm1]]
+[def __tgamma_lower [link math_toolkit.sf_gamma.igamma tgamma_lower]]
+[def __gamma_p [link math_toolkit.sf_gamma.igamma gamma_p]]
+[def __gamma_q [link math_toolkit.sf_gamma.igamma gamma_q]]
+[def __gamma_q_inv [link math_toolkit.sf_gamma.igamma_inv gamma_q_inv]]
+[def __gamma_p_inv [link math_toolkit.sf_gamma.igamma_inv gamma_p_inv]]
+[def __gamma_q_inva [link math_toolkit.sf_gamma.igamma_inv gamma_q_inva]]
+[def __gamma_p_inva [link math_toolkit.sf_gamma.igamma_inv gamma_p_inva]]
+[def __gamma_p_derivative [link math_toolkit.sf_gamma.gamma_derivatives gamma_p_derivative]]
[/factorials]
-[def __factorial [link math_toolkit.special.factorials.sf_factorial factorial]]
-[def __unchecked_factorial [link math_toolkit.special.factorials.sf_factorial unchecked_factorial]]
-[def __max_factorial [link math_toolkit.special.factorials.sf_factorial max_factorial]]
-[def __double_factorial [link math_toolkit.special.factorials.sf_double_factorial double_factorial]]
-[def __rising_factorial [link math_toolkit.special.factorials.sf_rising_factorial rising_factorial]]
-[def __falling_factorial [link math_toolkit.special.factorials.sf_falling_factorial falling_factorial]]
+[def __factorial [link math_toolkit.factorials.sf_factorial factorial]]
+[def __unchecked_factorial [link math_toolkit.factorials.sf_factorial unchecked_factorial]]
+[def __max_factorial [link math_toolkit.factorials.sf_factorial max_factorial]]
+[def __double_factorial [link math_toolkit.factorials.sf_double_factorial double_factorial]]
+[def __rising_factorial [link math_toolkit.factorials.sf_rising_factorial rising_factorial]]
+[def __falling_factorial [link math_toolkit.factorials.sf_falling_factorial falling_factorial]]
[/error functions]
-[def __erf [link math_toolkit.special.sf_erf.error_function erf]]
-[def __erfc [link math_toolkit.special.sf_erf.error_function erfc]]
-[def __erf_inv [link math_toolkit.special.sf_erf.error_inv erf_inv]]
-[def __erfc_inv [link math_toolkit.special.sf_erf.error_inv erfc_inv]]
+[def __erf [link math_toolkit.sf_erf.error_function erf]]
+[def __erfc [link math_toolkit.sf_erf.error_function erfc]]
+[def __erf_inv [link math_toolkit.sf_erf.error_inv erf_inv]]
+[def __erfc_inv [link math_toolkit.sf_erf.error_inv erfc_inv]]
[/beta functions]
-[def __beta [link math_toolkit.special.sf_beta.beta_function beta]]
-[def __beta3 [link math_toolkit.special.sf_beta.ibeta_function beta]]
-[def __betac [link math_toolkit.special.sf_beta.ibeta_function betac]]
-[def __ibeta [link math_toolkit.special.sf_beta.ibeta_function ibeta]]
-[def __ibetac [link math_toolkit.special.sf_beta.ibeta_function ibetac]]
-[def __ibeta_inv [link math_toolkit.special.sf_beta.ibeta_inv_function ibeta_inv]]
-[def __ibetac_inv [link math_toolkit.special.sf_beta.ibeta_inv_function ibetac_inv]]
-[def __ibeta_inva [link math_toolkit.special.sf_beta.ibeta_inv_function ibeta_inva]]
-[def __ibetac_inva [link math_toolkit.special.sf_beta.ibeta_inv_function ibetac_inva]]
-[def __ibeta_invb [link math_toolkit.special.sf_beta.ibeta_inv_function ibeta_invb]]
-[def __ibetac_invb [link math_toolkit.special.sf_beta.ibeta_inv_function ibetac_invb]]
-[def __ibeta_derivative [link math_toolkit.special.sf_beta.beta_derivative ibeta_derivative]]
+[def __beta [link math_toolkit.sf_beta.beta_function beta]]
+[def __beta3 [link math_toolkit.sf_beta.ibeta_function beta]]
+[def __betac [link math_toolkit.sf_beta.ibeta_function betac]]
+[def __ibeta [link math_toolkit.sf_beta.ibeta_function ibeta]]
+[def __ibetac [link math_toolkit.sf_beta.ibeta_function ibetac]]
+[def __ibeta_inv [link math_toolkit.sf_beta.ibeta_inv_function ibeta_inv]]
+[def __ibetac_inv [link math_toolkit.sf_beta.ibeta_inv_function ibetac_inv]]
+[def __ibeta_inva [link math_toolkit.sf_beta.ibeta_inv_function ibeta_inva]]
+[def __ibetac_inva [link math_toolkit.sf_beta.ibeta_inv_function ibetac_inva]]
+[def __ibeta_invb [link math_toolkit.sf_beta.ibeta_inv_function ibeta_invb]]
+[def __ibetac_invb [link math_toolkit.sf_beta.ibeta_inv_function ibetac_invb]]
+[def __ibeta_derivative [link math_toolkit.sf_beta.beta_derivative ibeta_derivative]]
[/elliptic integrals]
-[def __ellint_rj [link math_toolkit.special.ellint.ellint_carlson ellint_rj]]
-[def __ellint_rf [link math_toolkit.special.ellint.ellint_carlson ellint_rf]]
-[def __ellint_rc [link math_toolkit.special.ellint.ellint_carlson ellint_rc]]
-[def __ellint_rd [link math_toolkit.special.ellint.ellint_carlson ellint_rd]]
-[def __ellint_1 [link math_toolkit.special.ellint.ellint_1 ellint_1]]
-[def __ellint_2 [link math_toolkit.special.ellint.ellint_2 ellint_2]]
-[def __ellint_3 [link math_toolkit.special.ellint.ellint_3 ellint_3]]
+[def __ellint_rj [link math_toolkit.ellint.ellint_carlson ellint_rj]]
+[def __ellint_rf [link math_toolkit.ellint.ellint_carlson ellint_rf]]
+[def __ellint_rc [link math_toolkit.ellint.ellint_carlson ellint_rc]]
+[def __ellint_rd [link math_toolkit.ellint.ellint_carlson ellint_rd]]
+[def __ellint_1 [link math_toolkit.ellint.ellint_1 ellint_1]]
+[def __ellint_2 [link math_toolkit.ellint.ellint_2 ellint_2]]
+[def __ellint_3 [link math_toolkit.ellint.ellint_3 ellint_3]]
[/Bessel functions]
-[def __cyl_bessel_j [link math_toolkit.special.bessel.bessel cyl_bessel_j]]
-[def __cyl_neumann [link math_toolkit.special.bessel.bessel cyl_neumann]]
-[def __cyl_bessel_i [link math_toolkit.special.bessel.mbessel cyl_bessel_i]]
-[def __cyl_bessel_k [link math_toolkit.special.bessel.mbessel cyl_bessel_k]]
-[def __sph_bessel [link math_toolkit.special.bessel.sph_bessel sph_bessel]]
-[def __sph_neumann [link math_toolkit.special.bessel.sph_bessel sph_neumann]]
+[def __cyl_bessel_j [link math_toolkit.bessel.bessel cyl_bessel_j]]
+[def __cyl_neumann [link math_toolkit.bessel.bessel cyl_neumann]]
+[def __cyl_bessel_i [link math_toolkit.bessel.mbessel cyl_bessel_i]]
+[def __cyl_bessel_k [link math_toolkit.bessel.mbessel cyl_bessel_k]]
+[def __sph_bessel [link math_toolkit.bessel.sph_bessel sph_bessel]]
+[def __sph_neumann [link math_toolkit.bessel.sph_bessel sph_neumann]]
[/Hankel Functions]
-[def __cyl_hankel_1 [link math_toolkit.special.hankel.cyl_hankel cyl_hankel_1]]
-[def __cyl_hankel_2 [link math_toolkit.special.hankel.cyl_hankel cyl_hankel_2]]
-[def __sph_hankel_1 [link math_toolkit.special.hankel.sph_hankel sph_hankel_1]]
-[def __sph_hankel_2 [link math_toolkit.special.hankel.sph_hankel sph_hankel_2]]
+[def __cyl_hankel_1 [link math_toolkit.hankel.cyl_hankel cyl_hankel_1]]
+[def __cyl_hankel_2 [link math_toolkit.hankel.cyl_hankel cyl_hankel_2]]
+[def __sph_hankel_1 [link math_toolkit.hankel.sph_hankel sph_hankel_1]]
+[def __sph_hankel_2 [link math_toolkit.hankel.sph_hankel sph_hankel_2]]
[/Airy Functions]
-[def __airy_ai [link math_toolkit.special.airy.ai airy_ai]]
-[def __airy_bi [link math_toolkit.special.airy.bi airy_bi]]
-[def __airy_bi_prime [link math_toolkit.special.airy.bip airy_bi_prime]]
-[def __airy_ai_prime [link math_toolkit.special.airy.aip airy_ai_prime]]
+[def __airy_ai [link math_toolkit.airy.ai airy_ai]]
+[def __airy_bi [link math_toolkit.airy.bi airy_bi]]
+[def __airy_bi_prime [link math_toolkit.airy.bip airy_bi_prime]]
+[def __airy_ai_prime [link math_toolkit.airy.aip airy_ai_prime]]
[/Jacobi Elliptic Functions]
-[def __jacobi_elliptic [link math_toolkit.special.jacobi.jacobi_elliptic jacobi_elliptic]]
-[def __jacobi_cd [link math_toolkit.special.jacobi.jacobi_cd jacobi_cd]]
-[def __jacobi_cn [link math_toolkit.special.jacobi.jacobi_cn jacobi_cn]]
-[def __jacobi_cs [link math_toolkit.special.jacobi.jacobi_cs jacobi_cs]]
-[def __jacobi_dc [link math_toolkit.special.jacobi.jacobi_dc jacobi_dc]]
-[def __jacobi_dn [link math_toolkit.special.jacobi.jacobi_dn jacobi_dn]]
-[def __jacobi_ds [link math_toolkit.special.jacobi.jacobi_ds jacobi_ds]]
-[def __jacobi_nd [link math_toolkit.special.jacobi.jacobi_nd jacobi_nd]]
-[def __jacobi_nc [link math_toolkit.special.jacobi.jacobi_nc jacobi_nc]]
-[def __jacobi_ns [link math_toolkit.special.jacobi.jacobi_ns jacobi_ns]]
-[def __jacobi_sd [link math_toolkit.special.jacobi.jacobi_sd jacobi_sd]]
-[def __jacobi_sn [link math_toolkit.special.jacobi.jacobi_sn jacobi_sn]]
-[def __jacobi_sc [link math_toolkit.special.jacobi.jacobi_sc jacobi_sc]]
+[def __jacobi_elliptic [link math_toolkit.jacobi.jacobi_elliptic jacobi_elliptic]]
+[def __jacobi_cd [link math_toolkit.jacobi.jacobi_cd jacobi_cd]]
+[def __jacobi_cn [link math_toolkit.jacobi.jacobi_cn jacobi_cn]]
+[def __jacobi_cs [link math_toolkit.jacobi.jacobi_cs jacobi_cs]]
+[def __jacobi_dc [link math_toolkit.jacobi.jacobi_dc jacobi_dc]]
+[def __jacobi_dn [link math_toolkit.jacobi.jacobi_dn jacobi_dn]]
+[def __jacobi_ds [link math_toolkit.jacobi.jacobi_ds jacobi_ds]]
+[def __jacobi_nd [link math_toolkit.jacobi.jacobi_nd jacobi_nd]]
+[def __jacobi_nc [link math_toolkit.jacobi.jacobi_nc jacobi_nc]]
+[def __jacobi_ns [link math_toolkit.jacobi.jacobi_ns jacobi_ns]]
+[def __jacobi_sd [link math_toolkit.jacobi.jacobi_sd jacobi_sd]]
+[def __jacobi_sn [link math_toolkit.jacobi.jacobi_sn jacobi_sn]]
+[def __jacobi_sc [link math_toolkit.jacobi.jacobi_sc jacobi_sc]]
[/sinus cardinals]
-[def __sinc_pi [link math_toolkit.special.sinc.sinc_pi sinc_pi]]
-[def __sinhc_pi [link math_toolkit.special.sinc.sinhc_pi sinhc_pi]]
+[def __sinc_pi [link math_toolkit.sinc.sinc_pi sinc_pi]]
+[def __sinhc_pi [link math_toolkit.sinc.sinhc_pi sinhc_pi]]
[/Inverse hyperbolics]
-[def __acosh [link math_toolkit.special.inv_hyper.acosh acosh]]
-[def __asinh [link math_toolkit.special.inv_hyper.asinh asinh]]
-[def __atanh [link math_toolkit.special.inv_hyper.atanh atanh]]
+[def __acosh [link math_toolkit.inv_hyper.acosh acosh]]
+[def __asinh [link math_toolkit.inv_hyper.asinh asinh]]
+[def __atanh [link math_toolkit.inv_hyper.atanh atanh]]
[/classify]
-[def __fpclassify [link math_toolkit.special.fpclass fpclassify]]
-[def __isfinite [link math_toolkit.special.fpclass isfinite]]
-[def __isnan [link math_toolkit.special.fpclass isnan]]
-[def __isinf [link math_toolkit.special.fpclass isinf]]
-[def __isnormal [link math_toolkit.special.fpclass isnormal]]
-[def __fp_facets [link math_toolkit.utils.fp_facets nonfinite fp_facets]]
+[def __fpclassify [link math_toolkit.fpclass fpclassify]]
+[def __isfinite [link math_toolkit.fpclass isfinite]]
+[def __isnan [link math_toolkit.fpclass isnan]]
+[def __isinf [link math_toolkit.fpclass isinf]]
+[def __isnormal [link math_toolkit.fpclass isnormal]]
+[def __fp_facets [link math_toolkit.fp_facets nonfinite fp_facets]]
[/powers etc]
-[def __expm1 [link math_toolkit.special.powers.expm1 expm1]]
-[def __log1p [link math_toolkit.special.powers.log1p log1p]]
-[def __cbrt [link math_toolkit.special.powers.cbrt cbrt]]
-[def __sqrt1pm1 [link math_toolkit.special.powers.sqrt1pm1 sqrt1pm1]]
-[def __powm1 [link math_toolkit.special.powers.powm1 powm1]]
-[def __hypot [link math_toolkit.special.powers.hypot hypot]]
-[def __pow [link math_toolkit.special.powers.ct_pow pow]]
+[def __expm1 [link math_toolkit.powers.expm1 expm1]]
+[def __log1p [link math_toolkit.powers.log1p log1p]]
+[def __cbrt [link math_toolkit.powers.cbrt cbrt]]
+[def __sqrt1pm1 [link math_toolkit.powers.sqrt1pm1 sqrt1pm1]]
+[def __powm1 [link math_toolkit.powers.powm1 powm1]]
+[def __hypot [link math_toolkit.powers.hypot hypot]]
+[def __pow [link math_toolkit.powers.ct_pow pow]]
[/zeta]
-[def __zeta [link math_toolkit.special.zetas.zeta zeta]]
+[def __zeta [link math_toolkit.zetas.zeta zeta]]
[/expint]
-[def __expint_i [link math_toolkit.special.expint.expint_i zeta]]
-[def __expint_n [link math_toolkit.special.expint.expint_n zeta]]
+[def __expint_i [link math_toolkit.expint.expint_i zeta]]
+[def __expint_n [link math_toolkit.expint.expint_n zeta]]
[/rounding]
-[def __round [link math_toolkit.utils.rounding.round round]]
-[def __lround [link math_toolkit.utils.rounding.round round]]
-[def __llround [link math_toolkit.utils.rounding.round round]]
-[def __trunc [link math_toolkit.utils.rounding.trunc trunc]]
-[def __modf [link math_toolkit.utils.rounding.modf modf]]
+[def __round [link math_toolkit.rounding.round round]]
+[def __lround [link math_toolkit.rounding.round round]]
+[def __llround [link math_toolkit.rounding.round round]]
+[def __trunc [link math_toolkit.rounding.trunc trunc]]
+[def __modf [link math_toolkit.rounding.modf modf]]
[/polynomials]
-[def __laguerre [link math_toolkit.special.sf_poly.laguerre laguerre]]
-[def __legendre [link math_toolkit.special.sf_poly.legendre legendre_p]]
-[def __hermite [link math_toolkit.special.sf_poly.hermite hermite]]
+[def __laguerre [link math_toolkit.sf_poly.laguerre laguerre]]
+[def __legendre [link math_toolkit.sf_poly.legendre legendre_p]]
+[def __hermite [link math_toolkit.sf_poly.hermite hermite]]
[/Misc]
-[def __expint [link math_toolkit.special.expint.expint_i expint]]
-[def __spherical_harmonic [link math_toolkit.special.sf_poly.sph_harm spherical_harmonic]]
-[def __owens_t [link math_toolkit.special.owens_t Owens T]]
+[def __expint [link math_toolkit.expint.expint_i expint]]
+[def __spherical_harmonic [link math_toolkit.sf_poly.sph_harm spherical_harmonic]]
+[def __owens_t [link math_toolkit.owens_t Owens T]]
[/tools]
-[def __tuple [link math_toolkit.toolkit.internals1.tuples boost::math::tuple]]
+[def __tuple [link math_toolkit.internals1.tuples boost::math::tuple]]
[/ distribution non-members]
-[def __cdf [link math.dist.cdf Cumulative Distribution Function]]
-[def __pdf [link math.dist.pdf Probability Density Function]]
-[def __ccdf [link math.dist.ccdf Complement of the Cumulative Distribution Function]]
-[def __quantile [link math.dist.quantile Quantile]]
-[def __quantile_c [link math.dist.quantile_c Quantile from the complement of the probability]]
-[def __mean [link math.dist.mean mean]]
-[def __median [link math.dist.median median]]
-[def __mode [link math.dist.mode mode]]
-[def __skewness [link math.dist.skewness skewness]]
-[def __kurtosis [link math.dist.kurtosis kurtosis]]
-[def __kurtosis_excess [link math.dist.kurtosis_excess kurtosis_excess]]
-[def __variance [link math.dist.variance variance]]
-[def __sd [link math.dist.sd standard deviation]]
-[def __hazard [link math.dist.hazard Hazard Function]]
-[def __chf [link math.dist.chf Cumulative Hazard Function]]
-[def __range [link math.dist.range range]]
-[def __support [link math.dist.support support]]
+[def __cdf [link math_toolkit.dist_ref.nmp.cdf Cumulative Distribution Function]]
+[def __pdf [link math_toolkit.dist_ref.nmp.pdf Probability Density Function]]
+[def __ccdf [link math_toolkit.dist_ref.nmp.ccdf Complement of the Cumulative Distribution Function]]
+[def __quantile [link math_toolkit.dist_ref.nmp.quantile Quantile]]
+[def __quantile_c [link math_toolkit.dist_ref.nmp.quantile_c Quantile from the complement of the probability]]
+[def __mean [link math_toolkit.dist_ref.nmp.mean mean]]
+[def __median [link math_toolkit.dist_ref.nmp.median median]]
+[def __mode [link math_toolkit.dist_ref.nmp.mode mode]]
+[def __skewness [link math_toolkit.dist_ref.nmp.skewness skewness]]
+[def __kurtosis [link math_toolkit.dist_ref.nmp.kurtosis kurtosis]]
+[def __kurtosis_excess [link math_toolkit.dist_ref.nmp.kurtosis_excess kurtosis_excess]]
+[def __variance [link math_toolkit.dist_ref.nmp.variance variance]]
+[def __sd [link math_toolkit.dist_ref.nmp.sd standard deviation]]
+[def __hazard [link math_toolkit.dist_ref.nmp.hazard Hazard Function]]
+[def __chf [link math_toolkit.dist_ref.nmp.chf Cumulative Hazard Function]]
+[def __range [link math_toolkit.dist_ref.nmp.range range]]
+[def __support [link math_toolkit.dist_ref.nmp.support support]]
[/ distribution def names end in distrib to avoid clashes]
-[def __beta_distrib [link math_toolkit.dist.dist_ref.dists.beta_dist Beta Distribution]]
-[def __binomial_distrib [link math_toolkit.dist.dist_ref.dists.binomial_dist Binomial Distribution]]
-[def __cauchy_distrib [link math_toolkit.dist.dist_ref.dists.cauchy_dist Cauchy Distribution]]
-[def __chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.chi_squared_dist Chi Squared Distribution]]
-[def __extreme_distrib [link math_toolkit.dist.dist_ref.dists.extreme_dist Extreme Distributions]]
-[def __exp_distrib [link math_toolkit.dist.dist_ref.dists.exp_dist Exponential Distribution]]
-[def __F_distrib [link math_toolkit.dist.dist_ref.dists.f_dist Fisher F Distribution]]
-[def __gamma_distrib [link math_toolkit.dist.dist_ref.dists.gamma_dist Gamma Distribution]]
-[def __geometric_distrib [link math_toolkit.dist.dist_ref.dists.geometric_dist Geometric Distribution]]
-[def __hypergeometric_distrib [link math_toolkit.dist.dist_ref.dists.hypergeometric_dist hypergeometric Distribution]]
-[def __inverse_gamma_distrib [link math_toolkit.dist.dist_ref.dists.inverse_gamma_dist Inverse Gamma Distribution]]
-[def __inverse_gaussian_distrib [link math_toolkit.dist.dist_ref.dists.inverse_gaussian_dist Inverse Gaussian Distribution]]
-[def __inverse_chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.inverse_chi_squared_dist Inverse chi squared Distribution]]
-[def __laplace_distrib [link math_toolkit.dist.dist_ref.dists.laplace_dist Laplace Distribution]]
-[def __logistic_distrib [link math_toolkit.dist.dist_ref.dists.logistic_dist Logistic Distribution]]
-[def __lognormal_distrib [link math_toolkit.dist.dist_ref.dists.lognormal_dist Log-normal Distribution]]
-[def __negative_binomial_distrib [link math_toolkit.dist.dist_ref.dists.negative_binomial_dist Negative Binomial Distribution]]
-[def __non_central_chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.nc_chi_squared_dist Noncentral Chi Squared Distribution]]
-[def __non_central_beta_distrib [link math_toolkit.dist.dist_ref.dists.nc_beta_dist Noncentral Beta Distribution]]
-[def __non_central_F_distrib [link math_toolkit.dist.dist_ref.dists.nc_f_dist Noncentral F Distribution]]
-[def __non_central_T_distrib [link math_toolkit.dist.dist_ref.dists.nc_t_dist Noncentral T Distribution]]
-[def __non_central_t_distrib [link math_toolkit.dist.dist_ref.dists.nc_t_dist noncentral T distribution]]
-[def __normal_distrib [link math_toolkit.dist.dist_ref.dists.normal_dist Normal Distribution]]
-[def __poisson_distrib [link math_toolkit.dist.dist_ref.dists.poisson_dist Poisson Distribution]]
-[def __pareto_distrib [link math_toolkit.dist.dist_ref.dists.pareto_dist Pareto Distribution]]
-[def __students_t_distrib [link math_toolkit.dist.dist_ref.dists.students_t_dist Students t Distribution]]
-[def __skew_normal_distrib [link math_toolkit.dist.dist_ref.dists.skew_normal_dist Skew Normal Distribution]]
-[def __weibull_distrib [link math_toolkit.dist.dist_ref.dists.weibull_dist Weibull Distribution]]
+[def __beta_distrib [link math_toolkit.dist_ref.dists.beta_dist Beta Distribution]]
+[def __binomial_distrib [link math_toolkit.dist_ref.dists.binomial_dist Binomial Distribution]]
+[def __cauchy_distrib [link math_toolkit.dist_ref.dists.cauchy_dist Cauchy Distribution]]
+[def __chi_squared_distrib [link math_toolkit.dist_ref.dists.chi_squared_dist Chi Squared Distribution]]
+[def __extreme_distrib [link math_toolkit.dist_ref.dists.extreme_dist Extreme Distributions]]
+[def __exp_distrib [link math_toolkit.dist_ref.dists.exp_dist Exponential Distribution]]
+[def __F_distrib [link math_toolkit.dist_ref.dists.f_dist Fisher F Distribution]]
+[def __gamma_distrib [link math_toolkit.dist_ref.dists.gamma_dist Gamma Distribution]]
+[def __geometric_distrib [link math_toolkit.dist_ref.dists.geometric_dist Geometric Distribution]]
+[def __hypergeometric_distrib [link math_toolkit.dist_ref.dists.hypergeometric_dist hypergeometric Distribution]]
+[def __inverse_gamma_distrib [link math_toolkit.dist_ref.dists.inverse_gamma_dist Inverse Gamma Distribution]]
+[def __inverse_gaussian_distrib [link math_toolkit.dist_ref.dists.inverse_gaussian_dist Inverse Gaussian Distribution]]
+[def __inverse_chi_squared_distrib [link math_toolkit.dist_ref.dists.inverse_chi_squared_dist Inverse chi squared Distribution]]
+[def __laplace_distrib [link math_toolkit.dist_ref.dists.laplace_dist Laplace Distribution]]
+[def __logistic_distrib [link math_toolkit.dist_ref.dists.logistic_dist Logistic Distribution]]
+[def __lognormal_distrib [link math_toolkit.dist_ref.dists.lognormal_dist Log-normal Distribution]]
+[def __negative_binomial_distrib [link math_toolkit.dist_ref.dists.negative_binomial_dist Negative Binomial Distribution]]
+[def __non_central_chi_squared_distrib [link math_toolkit.dist_ref.dists.nc_chi_squared_dist Noncentral Chi Squared Distribution]]
+[def __non_central_beta_distrib [link math_toolkit.dist_ref.dists.nc_beta_dist Noncentral Beta Distribution]]
+[def __non_central_F_distrib [link math_toolkit.dist_ref.dists.nc_f_dist Noncentral F Distribution]]
+[def __non_central_T_distrib [link math_toolkit.dist_ref.dists.nc_t_dist Noncentral T Distribution]]
+[def __non_central_t_distrib [link math_toolkit.dist_ref.dists.nc_t_dist noncentral T distribution]]
+[def __normal_distrib [link math_toolkit.dist_ref.dists.normal_dist Normal Distribution]]
+[def __poisson_distrib [link math_toolkit.dist_ref.dists.poisson_dist Poisson Distribution]]
+[def __pareto_distrib [link math_toolkit.dist_ref.dists.pareto_dist Pareto Distribution]]
+[def __students_t_distrib [link math_toolkit.dist_ref.dists.students_t_dist Students t Distribution]]
+[def __skew_normal_distrib [link math_toolkit.dist_ref.dists.skew_normal_dist Skew Normal Distribution]]
+[def __weibull_distrib [link math_toolkit.dist_ref.dists.weibull_dist Weibull Distribution]]
[/links to policy]
-[def __Policy [link math_toolkit.policy Policy]] [/ Used in distribution template specifications]
-[def __policy_section [link math_toolkit.policy Policies]] [/ Used in text to refer to.]
-[def __policy_class [link math_toolkit.policy.pol_ref.pol_ref_ref policies::policy<>]]
-[def __math_undefined [link math_toolkit.policy.pol_ref.assert_undefined mathematically undefined function]]
-[def __policy_ref [link math_toolkit.policy.pol_ref policy reference]]
-[def __math_discrete [link math_toolkit.policy.pol_ref.discrete_quant_ref discrete functions]]
-[def __error_policy [link math_toolkit.policy.pol_ref.error_handling_policies error handling policies]]
-[def __changing_policy_defaults [link math_toolkit.policy.pol_ref.policy_defaults changing policies defaults]]
-[def __user_error_handling [link math_toolkit.policy.pol_tutorial.user_def_err_pol user error handling]]
-[def __promotion_policy [link math_toolkit.policy.pol_ref.internal_promotion internal promotion policy]]
-[def __precision_policy [link math_toolkit.policy.pol_ref.precision_pol precision policy]]
-[def __policy_macros [link math_toolkit.policy.pol_ref.policy_defaults Using Macros to Change the Policy Defaults]]
+[def __Policy [link policy Policy]] [/ Used in distribution template specifications]
+[def __policy_section [link policy Policies]] [/ Used in text to refer to.]
+[def __policy_class [link math_toolkit.pol_ref.pol_ref_ref policies::policy<>]]
+[def __math_undefined [link math_toolkit.pol_ref.assert_undefined mathematically undefined function]]
+[def __policy_ref [link math_toolkit.pol_ref policy reference]]
+[def __math_discrete [link math_toolkit.pol_ref.discrete_quant_ref discrete functions]]
+[def __error_policy [link math_toolkit.pol_ref.error_handling_policies error handling policies]]
+[def __changing_policy_defaults [link math_toolkit.pol_ref.policy_defaults changing policies defaults]]
+[def __user_error_handling [link math_toolkit.pol_tutorial.user_def_err_pol user error handling]]
+[def __promotion_policy [link math_toolkit.pol_ref.internal_promotion internal promotion policy]]
+[def __precision_policy [link math_toolkit.pol_ref.precision_pol precision policy]]
+[def __policy_macros [link math_toolkit.pol_ref.policy_defaults Using Macros to Change the Policy Defaults]]
[def __random_variate [@http://en.wikipedia.org/wiki/Random_variate random variate]]
[def __random_variable [@http://en.wikipedia.org/wiki/Random_variable random variable]]
-[def __probability_distribution [@[@http://en.wikipedia.org/wiki/Probability_distribution probability_distribution]]
+[def __probability_distribution [@http://en.wikipedia.org/wiki/Probability_distribution probability_distribution]]
[def __usual_accessors __cdf, __pdf, __quantile, __hazard,
__chf, __mean, __median, __mode, __variance, __sd, __skewness,
@@ -324,9 +329,9 @@
[def __TOMS748 [@http://portal.acm.org/citation.cfm?id=210111 TOMS Algorithm 748: enclosing zeros of continuous functions]]
[def __TOMS910 [@http://portal.acm.org/citation.cfm?id=1916469 TOMS Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations]]
[def __why_complements [link why_complements why complements?]]
-[def __complements [link complements complements]]
-[def __performance [link math_toolkit.perf performance]]
-[def __building [link math_toolkit.main_overview.building building libraries]]
+[def __complements [link math_toolkit.stat_tut.overview.complements complements]]
+[def __performance [link perf performance]]
+[def __building [link math_toolkit.building building libraries]]
[def __e_float [@http://calgo.acm.org/910.zip e_float (TOMS Algorithm 910)]]
[def __Abramowitz_Stegun M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions, NBS (1964)]
[def _DMLF [@http://dlmf.nist.gov/ NIST Digital Library of Mathematical Functions]]
@@ -344,7 +349,7 @@
The final __Policy argument is optional and can be used to
control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the
-[link math_toolkit.policy policy documentation for more details].]
+[link policy policy documentation for more details].]
[template discrete_quantile_warning[NAME]
[caution
@@ -364,23 +369,25 @@
This behaviour can be changed so that the quantile functions are rounded
differently, or even return a real-valued result using
-[link math_toolkit.policy.pol_overview Policies]. It is strongly
+[link math_toolkit.pol_overview Policies]. It is strongly
recommended that you read the tutorial
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant
+[link math_toolkit.pol_tutorial.understand_dis_quant
Understanding Quantiles of Discrete Distributions] before
using the quantile function on the [NAME] distribution. The
-[link math_toolkit.policy.pol_ref.discrete_quant_ref reference docs]
+[link math_toolkit.pol_ref.discrete_quant_ref reference docs]
describe how to change the rounding policy
for these distributions.
] [/ caution]
] [/ template discrete_quantile_warning]
+[/
This manual is also available in
[@http://sourceforge.net/projects/boost/files/boost-docs/
printer friendly PDF format],
and as a CD ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22.
+]
-[section:main_overview Overview]
+[mathpart overview Overview]
[include overview/overview.qbk]
[include overview/structure.qbk] [/getting about, directory and file structure.]
[include overview/result_type_calc.qbk]
@@ -409,14 +416,14 @@
[include overview/faq.qbk]
[include overview/contact_info.qbk]
-[endsect] [/section:main_overview Overview]
+[endmathpart] [/section:main_overview Overview]
-[section:dist Statistical Distributions and Functions]
+[mathpart dist Statistical Distributions and Functions]
[include distributions/dist_tutorial.qbk]
[include distributions/dist_reference.qbk] [/includes all individual distribution.qbk files]
-[endsect] [/section:dist Statistical Distributions and Functions]
+[endmathpart] [/section:dist Statistical Distributions and Functions]
-[section:special Special Functions]
+[mathpart special Special Functions]
[section:sf_gamma Gamma Functions]
[include sf/tgamma.qbk]
@@ -482,23 +489,23 @@
[include sf/owens_t.qbk]
-[endsect] [/section:special Special Functions]
+[endmathpart] [/section:special Special Functions]
-[section:utils Floating Point Utilities]
+[mathpart utils Floating Point Utilities]
[include fp_utilities/rounding_func.qbk]
[include fp_utilities/fpclassify.qbk]
[include fp_utilities/sign.qbk]
[include fp_utilities/fp_facets.qbk]
[include fp_utilities/float_next.qbk]
-[endsect]
+[endmathpart]
-[section:extern_c TR1 and C99 external "C" Functions]
+[mathpart extern_c TR1 and C99 external "C" Functions]
[section:tr1 C99 and TR1 C Functions Overview]
[tr1_overview]
[endsect]
[include tr1/c99_ref.qbk]
[include tr1/tr1_ref.qbk]
-[endsect]
+[endmathpart]
[include constants/constants.qbk]
@@ -507,7 +514,7 @@
[include octonion/math-octonion.qbk]
[include gcd/math-gcd.qbk]
-[section:toolkit Internals and Internal Details]
+[mathpart toolkit Internals and Internal Details]
[include internals/internals_overview.qbk]
@@ -528,25 +535,25 @@
[include internals/test_data.qbk]
[endsect] [/section:internals2 Testing and Development]
-[endsect] [/section:toolkit Toolkit]
+[endmathpart] [/section:toolkit Toolkit]
-[section:using_udt Use with User-Defined Floating-Point Types]
+[mathpart using_udt Use with User-Defined Floating-Point Types]
[include concepts/concepts.qbk]
-[endsect] [/section:using_udt Use with User Defined Floating-Point Types]
+[endmathpart] [/section:using_udt Use with User Defined Floating-Point Types]
[include policies/policy.qbk]
[include performance/performance.qbk]
-[section:backgrounders Backgrounders]
+[mathpart backgrounders Backgrounders]
[include background/implementation.qbk]
[include background/error.qbk] [/relative error NOT handling]
[include background/lanczos.qbk]
[include background/remez.qbk]
[include background/references.qbk]
-[endsect] [/section:backgrounders Backgrounders]
+[endmathpart] [/section:backgrounders Backgrounders]
-[section:status Library Status]
+[mathpart status Library Status]
[section:history1 History and What's New]
[history]
[endsect]
@@ -555,9 +562,9 @@
[/include test_HTML4_symbols.qbk]
[/include test_Latin1_symbols.qbk]
-[endsect] [/section:status Status and Roadmap]
+[endmathpart] [/section:status Status and Roadmap]
-[section:indexes Indexes]
+[mathpart indexes Indexes]
[named_index function_name Function Index]
[named_index class_name Class Index]
@@ -565,7 +572,7 @@
[named_index macro_name Macro Index]
[index]
-[endsect]
+[endmathpart]
[/ math.qbk
Copyright 2008, 2010, 2012 John Maddock and Paul A. Bristow.
Modified: sandbox/math/libs/math/doc/octonion/math-octonion.qbk
==============================================================================
--- sandbox/math/libs/math/doc/octonion/math-octonion.qbk (original)
+++ sandbox/math/libs/math/doc/octonion/math-octonion.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -11,7 +11,7 @@
[def __oct_quat_formula ['[^o = ('''α + βi + γj + δk) + (ε + ζi + ηj - θj)e' ''']]]
[def __oct_not_equal ['[^x(yz) '''≠''' (xy)z]]]
-[section:octonions Octonions]
+[mathpart octonions Octonions]
[section:overview Overview]
@@ -55,96 +55,96 @@
namespace boost{ namespace math{
- template<typename T> class ``[link math_toolkit.octonions.octonion octonion]``;
- template<> class ``[link math_toolkit.octonions.oct_specialization octonion<float>]``;
- template<> class ``[link math_toolkit.octonion_double octonion<double>]``;
- template<> class ``[link math_toolkit.octonion_long_double octonion<long double>]``;
+ template<typename T> class ``[link math_toolkit.octonion octonion]``;
+ template<> class ``[link math_toolkit.oct_specialization octonion<float>]``;
+ template<> class ``[link math_octonion_double octonion<double>]``;
+ template<> class ``[link math_octonion_long_double octonion<long double>]``;
// operators
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.non_mem.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
-
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
-
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.octonions.non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
+
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.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 math_toolkit.octonions.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, octonion<T> & o);
+ ::std::basic_istream<charT,traits> & ``[link math_toolkit.non_mem0.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 math_toolkit.octonions.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
+ ::std::basic_ostream<charT,traits> & ``[link math_toolkit.non_mem0.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
// values
- template<typename T> T ``[link math_toolkit.octonions.oct_value_ops.real_and_unreal real]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_value_ops.real_and_unreal unreal]``(octonion<T> const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.real_and_unreal real]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.real_and_unreal unreal]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.octonions.oct_value_ops.sup sup]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.octonions.oct_value_ops.l1 l1]``(octonion<T>const & o);
- template<typename T> T ``[link math_toolkit.octonions.oct_value_ops.abs abs]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.octonions.oct_value_ops.norm norm]``(octonion<T>const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_value_ops.conj conj]``(octonion<T> const & o);
-
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_create spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2, T const & phi3, T const & phi4, T const & phi5, T const & phi6);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_create multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_create cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.sup sup]``(octonion<T> const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.l1 l1]``(octonion<T>const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.abs abs]``(octonion<T> const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.norm norm]``(octonion<T>const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.conj conj]``(octonion<T> const & o);
+
+ template<typename T> octonion<T> ``[link math_toolkit.oct_create spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2, T const & phi3, T const & phi4, T const & phi5, T const & phi6);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_create multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_create cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);
// transcendentals
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.exp exp]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.cos cos]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.sin sin]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.tan tan]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.cosh cosh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.sinh sinh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.tanh tanh]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.exp exp]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cos cos]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sin sin]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tan tan]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cosh cosh]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sinh sinh]``(octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tanh tanh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.octonions.oct_trans.pow pow]``(octonion<T> const & o, int n);
+ template<typename T> octonion<T> ``[link math_toolkit.oct_trans.pow pow]``(octonion<T> const & o, int n);
} } // namespaces
@@ -160,62 +160,62 @@
public:
typedef T value_type;
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
template<typename X>
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<X> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<X> const & a_recopier);
- T ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts real]``() const;
- octonion<T> ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts unreal]``() const;
+ T ``[link math_toolkit.mem_fun0.real_and_unreal_parts real]``() const;
+ octonion<T> ``[link math_toolkit.mem_fun0.real_and_unreal_parts unreal]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_1]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_2]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_3]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_4]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_5]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_6]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_7]``() const;
- T ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_8]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_1]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_2]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_3]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_4]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_5]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_6]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_7]``() const;
+ T ``[link math_toolkit.mem_fun0.individual_real_components R_component_8]``() const;
- ::std::complex<T> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<T> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<T> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<T> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_4]``() const;
+ ::std::complex<T> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_1]``() const;
+ ::std::complex<T> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_2]``() const;
+ ::std::complex<T> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_3]``() const;
+ ::std::complex<T> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_4]``() const;
- ::boost::math::quaternion<T> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<T> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_2]``() const;
+ ::boost::math::quaternion<T> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<T> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<T> const & a_affecter);
+ octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<T> const & a_affecter);
template<typename X>
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (T const & a_affecter);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
+ octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (T const & a_affecter);
+ octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
+ octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
template<typename X>
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
template<typename X>
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
template<typename X>
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (T const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
template<typename X>
- octonion<T> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
} } // namespaces
@@ -232,65 +232,65 @@
public:
typedef float value_type;
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
-
- float ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts real]``() const;
- octonion<float> ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts unreal]``() const;
-
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_1]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_2]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_3]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_4]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_5]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_6]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_7]``() const;
- float ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_8]``() const;
-
- ::std::complex<float> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<float> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<float> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<float> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<float> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<float> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_2]``() const;
-
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<float> const & a_affecter);
- template<typename X>
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (float const & a_affecter);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
-
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<double> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<long double> const & a_recopier);
+
+ float ``[link math_toolkit.mem_fun0.real_and_unreal_parts real]``() const;
+ octonion<float> ``[link math_toolkit.mem_fun0.real_and_unreal_parts unreal]``() const;
+
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_1]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_2]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_3]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_4]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_5]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_6]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_7]``() const;
+ float ``[link math_toolkit.mem_fun0.individual_real_components R_component_8]``() const;
+
+ ::std::complex<float> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_1]``() const;
+ ::std::complex<float> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_2]``() const;
+ ::std::complex<float> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_3]``() const;
+ ::std::complex<float> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<float> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<float> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
+
+ octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<float> const & a_affecter);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (float const & a_affecter);
+ octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
+ octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
+
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
+ template<typename X>
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (float const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
template<typename X>
- octonion<float> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
-[#math_toolkit.octonion_double]
+[#math_octonion_double]
template<>
class octonion<double>
@@ -298,65 +298,65 @@
public:
typedef double value_type;
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
-
- double ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts real]``() const;
- octonion<double> ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts unreal]``() const;
-
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_1]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_2]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_3]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_4]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_5]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_6]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_7]``() const;
- double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_8]``() const;
-
- ::std::complex<double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<double> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<double> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_2]``() const;
-
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<double> const & a_affecter);
- template<typename X>
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (double const & a_affecter);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
-
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<float> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<long double> const & a_recopier);
+
+ double ``[link math_toolkit.mem_fun0.real_and_unreal_parts real]``() const;
+ octonion<double> ``[link math_toolkit.mem_fun0.real_and_unreal_parts unreal]``() const;
+
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_1]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_2]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_3]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_4]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_5]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_6]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_7]``() const;
+ double ``[link math_toolkit.mem_fun0.individual_real_components R_component_8]``() const;
+
+ ::std::complex<double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_1]``() const;
+ ::std::complex<double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_2]``() const;
+ ::std::complex<double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_3]``() const;
+ ::std::complex<double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<double> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<double> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
+
+ octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<double> const & a_affecter);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (double const & a_affecter);
+ octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
+ octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
+
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
+ template<typename X>
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (double const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
template<typename X>
- octonion<double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
-[#math_toolkit.octonion_long_double]
+[#math_octonion_long_double]
template<>
class octonion<long double>
@@ -364,62 +364,62 @@
public:
typedef long double value_type;
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``( ::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & z1 = ::boost::math::quaternion<long double>());
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link math_toolkit.octonions.mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
-
- long double ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts real]``() const;
- octonion<long double> ``[link math_toolkit.octonions.mem_fun.real_and_unreal_parts unreal]``() const;
-
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_1]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_2]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_3]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_4]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_5]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_6]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_7]``() const;
- long double ``[link math_toolkit.octonions.mem_fun.individual_real_components R_component_8]``() const;
-
- ::std::complex<long double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<long double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<long double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<long double> ``[link math_toolkit.octonions.mem_fun.individual_complex_components C_component_4]``() const;
-
- ::boost::math::quaternion<long double> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<long double> ``[link math_toolkit.octonions.mem_fun.individual_quaternion_components H_component_2]``() const;
-
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (long double const & a_affecter);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
-
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
-
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``( ::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & z1 = ::boost::math::quaternion<long double>());
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<float> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<double> const & a_recopier);
+
+ long double ``[link math_toolkit.mem_fun0.real_and_unreal_parts real]``() const;
+ octonion<long double> ``[link math_toolkit.mem_fun0.real_and_unreal_parts unreal]``() const;
+
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_1]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_2]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_3]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_4]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_5]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_6]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_7]``() const;
+ long double ``[link math_toolkit.mem_fun0.individual_real_components R_component_8]``() const;
+
+ ::std::complex<long double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_1]``() const;
+ ::std::complex<long double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_2]``() const;
+ ::std::complex<long double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_3]``() const;
+ ::std::complex<long double> ``[link math_toolkit.mem_fun0.individual_complex_components C_component_4]``() const;
+
+ ::boost::math::quaternion<long double> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_1]``() const;
+ ::boost::math::quaternion<long double> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
+
+ octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (long double const & a_affecter);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
+
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
+
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
+
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
+ template<typename X>
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
+
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (long double const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
template<typename X>
- octonion<long double> & ``[link math_toolkit.octonions.mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
+ octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
} } // namespaces
@@ -979,4 +979,4 @@
[endsect]
-[endsect]
+[endmathpart]
Modified: sandbox/math/libs/math/doc/overview/building.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/building.qbk (original)
+++ sandbox/math/libs/math/doc/overview/building.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -10,7 +10,7 @@
including a header (or few) is best for compile time and program size.
Refer to
-[link math_toolkit.extern_c C99 and C++ TR1 C-style Functions]
+[link extern_c C99 and C++ TR1 C-style Functions]
for pros and cons of using
the TR1 components as opposed to the header only ones.
Modified: sandbox/math/libs/math/doc/overview/common_overviews.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/common_overviews.qbk (original)
+++ sandbox/math/libs/math/doc/overview/common_overviews.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -4,11 +4,11 @@
Policies are a powerful fine-grain mechanism that allow you to customise the
behaviour of this library according to your needs. There is more information
-available in the [link math_toolkit.policy.pol_tutorial policy tutorial]
-and the [link math_toolkit.policy.pol_ref policy reference].
+available in the [link math_toolkit.pol_tutorial policy tutorial]
+and the [link math_toolkit.pol_ref policy reference].
Generally speaking, unless you find that the
-[link math_toolkit.policy.pol_tutorial.policy_tut_defaults
+[link math_toolkit.pol_tutorial.policy_tut_defaults
default policy behaviour]
when encountering 'bad' argument values does not meet your needs,
you should not need to worry about policies.
@@ -22,13 +22,13 @@
Using policies you can control:
-* [link math_toolkit.policy.pol_ref.error_handling_policies How results from 'bad' arguments are handled],
+* [link math_toolkit.pol_ref.error_handling_policies How results from 'bad' arguments are handled],
including those that cannot be fully evaluated.
-* How [link math_toolkit.policy.pol_ref.internal_promotion accuracy is controlled by internal promotion] to use more precise types.
-* What working [link math_toolkit.policy.pol_ref.precision_pol precision] should be used to calculate results.
-* What to do when a [link math_toolkit.policy.pol_ref.assert_undefined mathematically undefined function]
+* How [link math_toolkit.pol_ref.internal_promotion accuracy is controlled by internal promotion] to use more precise types.
+* What working [link math_toolkit.pol_ref.precision_pol precision] should be used to calculate results.
+* What to do when a [link math_toolkit.pol_ref.assert_undefined mathematically undefined function]
is used: Should this raise a run-time or compile-time error?
-* Whether [link math_toolkit.policy.pol_ref.discrete_quant_ref discrete functions],
+* Whether [link math_toolkit.pol_ref.discrete_quant_ref discrete functions],
like the binomial, should return real or only integral values, and how they are rounded.
* How many iterations a special function is permitted to perform in
a series evaluation or root finding algorithm before it gives up and raises an
@@ -36,16 +36,16 @@
You can control policies:
-* Using [link math_toolkit.policy.pol_ref.policy_defaults macros] to
+* Using [link math_toolkit.pol_ref.policy_defaults macros] to
change any default policy: the is the prefered method for installation
wide policies.
-* At your chosen [link math_toolkit.policy.pol_ref.namespace_pol
+* At your chosen [link math_toolkit.pol_ref.namespace_pol
namespace scope] for distributions and/or functions: this is the
prefered method for project, namespace, or translation unit scope
policies.
-* In an ad-hoc manner [link math_toolkit.policy.pol_tutorial.ad_hoc_sf_policies
+* In an ad-hoc manner [link math_toolkit.pol_tutorial.ad_hoc_sf_policies
by passing a specific policy to a special function], or to a
-[link math_toolkit.policy.pol_tutorial.ad_hoc_dist_policies
+[link math_toolkit.pol_tutorial.ad_hoc_dist_policies
statistical distribution].
]
@@ -70,12 +70,12 @@
from this library are:
# Turn on your compilers optimisations: the difference between "release"
-and "debug" builds can easily be a [link math_toolkit.perf.getting_best factor of 20].
-# Pick your compiler carefully: [link math_toolkit.perf.comp_compilers
+and "debug" builds can easily be a [link math_toolkit.getting_best factor of 20].
+# Pick your compiler carefully: [link math_toolkit.comp_compilers
performance differences of up to
8 fold] have been found between some Windows compilers for example.
-The [link math_toolkit.perf performance section] contains more
+The [link perf performance section] contains more
information on the performance
of this library, what you can do to fine tune it, and how this library
compares to some other open source alternatives.
Modified: sandbox/math/libs/math/doc/overview/config_macros.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/config_macros.qbk (original)
+++ sandbox/math/libs/math/doc/overview/config_macros.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -49,10 +49,10 @@
[table Boost.Math Tuning
[[ Macros for Tuning performance options for specific compilers] [Notes]]
-[[`BOOST_MATH_POLY_METHOD`] [See the [link math_toolkit.perf.tuning performance tuning section].]]
-[[`BOOST_MATH_RATIONAL_METHOD`] [See the [link math_toolkit.perf.tuning performance tuning section].]]
-[[`BOOST_MATH_MAX_POLY_ORDER`] [See the [link math_toolkit.perf.tuning performance tuning section].]]
-[[`BOOST_MATH_INT_TABLE_TYPE`] [See the [link math_toolkit.perf.tuning performance tuning section].]]
+[[`BOOST_MATH_POLY_METHOD`] [See the [link math_toolkit.tuning performance tuning section].]]
+[[`BOOST_MATH_RATIONAL_METHOD`] [See the [link math_toolkit.tuning performance tuning section].]]
+[[`BOOST_MATH_MAX_POLY_ORDER`] [See the [link math_toolkit.tuning performance tuning section].]]
+[[`BOOST_MATH_INT_TABLE_TYPE`] [See the [link math_toolkit.tuning performance tuning section].]]
[[`BOOST_MATH_INT_VALUE_SUFFIX`] [Helper macro for appending the correct suffix to integer constants
which may actually be stored as reals depending on the value of BOOST_MATH_INT_TABLE_TYPE.]]
] [/table]
Modified: sandbox/math/libs/math/doc/overview/error_handling.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/error_handling.qbk (original)
+++ sandbox/math/libs/math/doc/overview/error_handling.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -53,7 +53,7 @@
appropriate result]]
[[ignore_error][Ignores the error and simply the returns the most appropriate result.]]
[[user_error][Calls a
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol user-supplied error handler].]]
+ [link math_toolkit.pol_tutorial.user_def_err_pol user-supplied error handler].]]
]
The following tables show all the permutations of errors and actions,
@@ -65,7 +65,7 @@
[[errno_on_error][Sets `::errno` to `EDOM` and returns `std::numeric_limits<T>::quiet_NaN()`]]
[[ignore_error][Returns `std::numeric_limits<T>::quiet_NaN()`]]
[[user_error][Returns the result of `boost::math::policies::user_domain_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -75,7 +75,7 @@
[[errno_on_error][Sets `::errno` to `EDOM` and returns `std::numeric_limits<T>::quiet_NaN()`]]
[[ignore_error][Returns `std::numeric_limits<T>::quiet_NaN()`]]
[[user_error][Returns the result of `boost::math::policies::user_pole_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -85,7 +85,7 @@
[[errno_on_error][Sets `::errno` to `ERANGE` and returns `std::numeric_limits<T>::infinity()`]]
[[ignore_error][Returns `std::numeric_limits<T>::infinity()`]]
[[user_error][Returns the result of `boost::math::policies::user_overflow_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -95,7 +95,7 @@
[[errno_on_error][Sets `::errno` to `ERANGE` and returns 0.]]
[[ignore_error][[*Returns 0]]]
[[user_error][Returns the result of `boost::math::policies::user_underflow_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -105,7 +105,7 @@
[[errno_on_error][Sets `::errno` to `ERANGE` and returns the denormalised value.]]
[[ignore_error][[*Returns the denormalised value.]]]
[[user_error][Returns the result of `boost::math::policies::user_denorm_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -117,7 +117,7 @@
[[ignore_error][[*Returns the largest representable value of the target integer type
(or the most negative value if the argument to the function was less than zero).]]]
[[user_error][Returns the result of `boost::math::policies::user_rounding_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -127,7 +127,7 @@
[[errno_on_error][Sets `::errno` to `EDOM` and returns the closest approximation found.]]
[[ignore_error][Returns the closest approximation found.]]
[[user_error][Returns the result of `boost::math::policies::user_evaluation_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -137,7 +137,7 @@
[[errno_on_error][Sets `::errno` to `EDOM` and returns the same value as `ignore_error`.]]
[[ignore_error][[*Returns a default result that depends on the function where the error occurred.]]]
[[user_error][Returns the result of `boost::math::policies::user_indeterminate_result_error`:
- [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+ [link math_toolkit.pol_tutorial.user_def_err_pol
this function must be defined by the user].]]
]
@@ -162,21 +162,21 @@
[heading Finding More Information]
There are some pre-processor macro defines that can be used to
-[link math_toolkit.policy.pol_ref.policy_defaults
-change the policy defaults]. See also the [link math_toolkit.policy
+[link math_toolkit.pol_ref.policy_defaults
+change the policy defaults]. See also the [link policy
policy section].
An example is at the Policy tutorial in
-[link math_toolkit.policy.pol_tutorial.changing_policy_defaults
+[link math_toolkit.pol_tutorial.changing_policy_defaults
Changing the Policy Defaults].
Full source code of this typical example of passing a 'bad' argument
(negative degrees of freedom) to Student's t distribution
-is [link math_toolkit.dist.stat_tut.weg.error_eg in the error handling example].
+is [link math_toolkit.stat_tut.weg.error_eg in the error handling example].
The various kind of errors are described in more detail below.
-[heading [#domain_error]Domain Errors]
+[heading:domain_error Domain Errors]
When a special function is passed an argument that is outside the range
of values for which that function is defined, then the function returns
@@ -224,7 +224,7 @@
`Val` to the full precision of T, where as "%.3g" would contain the value of
`Val` to 3 digits. See the __format documentation for more details.
-[heading [#pole_error]Evaluation at a pole]
+[heading:pole_error Evaluation at a pole]
When a special function is passed an argument that is at a pole
without a well defined residual value, then the function returns
@@ -251,7 +251,7 @@
`val` to the full precision of T, where as "%.3g" would contain the value of
`val` to 3 digits. See the __format documentation for more details.
-[heading [#overflow_error]Numeric Overflow]
+[heading:overflow_error Numeric Overflow]
When the result of a special function is too large to fit in the argument
floating-point type, then the function returns the result of:
@@ -270,7 +270,7 @@
In this situation if the type `T` doesn't support infinities,
the maximum value for the type is returned.
-[heading [#underflow_error]Numeric Underflow]
+[heading:underflow_error Numeric Underflow]
If the result of a special function is known to be non-zero, but the
calculated result underflows to zero, then the function returns the result of:
@@ -287,7 +287,7 @@
But with another policy, like `throw_on_error`,
throws an `std::underflow_error` C++ exception.
-[heading [#denorm_error]Denormalisation Errors]
+[heading:denorm_error Denormalisation Errors]
If the result of a special function is a denormalised value /z/ then the function
returns the result of:
@@ -304,7 +304,7 @@
But with another policy, like `throw_on_error`
throws an `std::underflow_error` C++ exception.
-[heading [#evaluation_error]Evaluation Errors]
+[heading:evaluation_error Evaluation Errors]
When a special function calculates a result that is known to be erroneous,
or where the result is incalculable then it calls:
@@ -329,7 +329,7 @@
`val` to the full precision of T, where as "%.3g" would contain the value of
`val` to 3 digits. See the __format documentation for more details.
-[heading [#indeterminate_result_error]Indeterminate Result Errors]
+[heading:indeterminate_result_error Indeterminate Result Errors]
When the result of a special function is indeterminate for the value that was
passed to it, then the function returns the result of:
@@ -350,7 +350,7 @@
the result should be: for example the C99 standard specifies that the result
of 0[super 0] is 1, even though the result is actually mathematically indeterminate.
-[heading [#rounding_error]Rounding Errors]
+[heading:rounding_error Rounding Errors]
When one of the rounding functions __round, __trunc or __modf is
called with an argument that has no integer representation, or
@@ -376,7 +376,7 @@
`val` to the full precision of T, where as "%.3g" would contain the value of
`val` to 3 digits. See the __format documentation for more details.
-[heading [#checked_narrowing_cast]Errors from typecasts]
+[heading:checked_narrowing_cast Errors from typecasts]
Many special functions evaluate their results at a higher precision
than their arguments in order to ensure full machine precision in
@@ -389,8 +389,8 @@
T checked_narrowing_cast(U const& val, const char* function);
Is used to perform these conversions, and will call the error handlers
-listed above on [link overflow_error overflow],
-[link underflow_error underflow] or [link denorm_error denormalisation].
+listed above on [link math_toolkit.error_handling.overflow_error overflow],
+[link math_toolkit.error_handling.underflow_error underflow] or [link math_toolkit.error_handling.denorm_error denormalisation].
[endsect][/section:error_handling Error Handling]
Modified: sandbox/math/libs/math/doc/overview/overview.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/overview.qbk (original)
+++ sandbox/math/libs/math/doc/overview/overview.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -5,29 +5,29 @@
[h4 Statistical Distributions]
Provides a reasonably comprehensive set of
-[link math_toolkit.dist statistical distributions],
+[link dist statistical distributions],
upon which higher level statistical tests can be built.
The initial focus is on the central
[@http://en.wikipedia.org/wiki/Univariate univariate ]
[@http://mathworld.wolfram.com/StatisticalDistribution.html distributions].
Both [@http://mathworld.wolfram.com/ContinuousDistribution.html continuous]
-(like [link math_toolkit.dist.dist_ref.dists.normal_dist normal]
-& [link math_toolkit.dist.dist_ref.dists.f_dist Fisher])
+(like [link math_toolkit.dist_ref.dists.normal_dist normal]
+& [link math_toolkit.dist_ref.dists.f_dist Fisher])
and [@http://mathworld.wolfram.com/DiscreteDistribution.html discrete]
-(like [link math_toolkit.dist.dist_ref.dists.binomial_dist binomial]
-& [link math_toolkit.dist.dist_ref.dists.poisson_dist Poisson])
+(like [link math_toolkit.dist_ref.dists.binomial_dist binomial]
+& [link math_toolkit.dist_ref.dists.poisson_dist Poisson])
distributions are provided.
-A [link math_toolkit.dist.stat_tut comprehensive tutorial is provided],
+A [link math_toolkit.stat_tut comprehensive tutorial is provided],
along with a series of
-[link math_toolkit.dist.stat_tut.weg worked examples] illustrating
+[link math_toolkit.stat_tut.weg worked examples] illustrating
how the library is used to conduct statistical tests.
[h4 Mathematical Special Functions]
Provides a small number of high quality
-[link math_toolkit.special special functions],
+[link special special functions],
initially these were concentrated on functions used in statistical applications
along with those in the [tr1].
@@ -49,7 +49,7 @@
[h4 Implementation Toolkit]
-Provides [link math_toolkit.toolkit many of the tools] required to implement
+Provides [link toolkit many of the tools] required to implement
mathematical special functions: hopefully the presence of
these will encourage other authors to contribute more special
function implementations in the future. These tools are currently
@@ -57,27 +57,27 @@
whose interfaces and\/or implementations may change.
There are helpers for the
-[link math_toolkit.toolkit.internals1.series_evaluation
+[link math_toolkit.internals1.series_evaluation
evaluation of infinite series],
-[link math_toolkit.toolkit.internals1.cf continued
-fractions] and [link math_toolkit.toolkit.internals1.rational
+[link math_toolkit.internals1.cf continued
+fractions] and [link math_toolkit.internals1.rational
rational approximations].
There is a fairly comprehensive set of root finding and
-[link math_toolkit.toolkit.internals1.minima function minimisation
+[link math_toolkit.internals1.minima function minimisation
algorithms]: the root finding algorithms are both
-[link math_toolkit.toolkit.internals1.roots with] and
-[link math_toolkit.toolkit.internals1.roots2 without] derivative support.
+[link math_toolkit.internals1.roots with] and
+[link math_toolkit.internals1.roots2 without] derivative support.
-A [link math_toolkit.toolkit.internals2.minimax
+A [link math_toolkit.internals2.minimax
Remez algorithm implementation] allows for the locating of minimax rational
approximations.
There are also (experimental) classes for the
-[link math_toolkit.toolkit.internals2.polynomials manipulation of polynomials], for
-[link math_toolkit.toolkit.internals2.error_test
+[link math_toolkit.internals2.polynomials manipulation of polynomials], for
+[link math_toolkit.internals2.error_test
testing a special function against tabulated test data], and for
-the [link math_toolkit.toolkit.internals2.test_data
+the [link math_toolkit.internals2.test_data
rapid generation of test data] and/or data for output to an
external graphing application.
Modified: sandbox/math/libs/math/doc/overview/result_type_calc.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/result_type_calc.qbk (original)
+++ sandbox/math/libs/math/doc/overview/result_type_calc.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -68,7 +68,7 @@
In the last case, `quad_float` is convertible to `RR`, but not vice-versa, so
the result will be an `NTL::RR`. Note that this assumes that you are using
-a [link math_toolkit.using_udt.high_precision.use_ntl patched NTL library].
+a [link math_toolkit.high_precision.use_ntl patched NTL library].
These rules are chosen to be compatible with the behaviour of
['ISO/IEC 9899:1999 Programming languages - C]
Modified: sandbox/math/libs/math/doc/overview/roadmap.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/roadmap.qbk (original)
+++ sandbox/math/libs/math/doc/overview/roadmap.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -39,7 +39,7 @@
[h4 Boost-1.52]
* Corrected moments for small degrees of freedom [@https://svn.boost.org/trac/boost/ticket/7177 #7177] (reported by Thomas Mang).
-* Added [link math_toolkit.special.airy Airy functions] and [link math_toolkit.special.jacobi Jacobi Elliptic functions].
+* Added [link math_toolkit.airy Airy functions] and [link math_toolkit.jacobi Jacobi Elliptic functions].
* Corrected failure to detect bad parameters in many distributions
[@https://svn.boost.org/trac/boost/ticket/6934 #6934] (reported by Florian Schoppmann)
by adding a function check_out_of_range to test many possible bad parameters.
Modified: sandbox/math/libs/math/doc/overview/tr1.qbk
==============================================================================
--- sandbox/math/libs/math/doc/overview/tr1.qbk (original)
+++ sandbox/math/libs/math/doc/overview/tr1.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -93,13 +93,13 @@
runtimes - since the externally compiled libraries can be
compiler optimised, rather than built using full settings - the difference
in performance between
-[link math_toolkit.perf.getting_best
+[link math_toolkit.getting_best
release and debug builds can be as much as 20 times],
so for complex applications this can be a big win.
[h4 Supported C99 Functions]
-See also the [link math_toolkit.extern_c.c99
+See also the [link math_toolkit.c99
quick reference guide for these functions].
namespace boost{ namespace math{ namespace tr1{ extern "C"{
@@ -191,7 +191,7 @@
[h4 Supported TR1 Functions]
-See also the [link math_toolkit.extern_c.tr1
+See also the [link math_toolkit.tr1
quick reference guide for these functions].
namespace boost{ namespace math{ namespace tr1{ extern "C"{
Modified: sandbox/math/libs/math/doc/performance/performance.qbk
==============================================================================
--- sandbox/math/libs/math/doc/performance/performance.qbk (original)
+++ sandbox/math/libs/math/doc/performance/performance.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,7 +1,7 @@
[template perf[name value] [value]]
[template para[text] '''<para>'''[text]'''</para>''']
-[section:perf Performance]
+[mathpart perf Performance]
[section:perf_over Performance Overview]
[performance_overview]
@@ -202,18 +202,18 @@
]
There is one final performance tuning option that is available as a compile time
-[link math_toolkit.policy policy]. Normally when evaluating functions at `double`
+[link policy policy]. Normally when evaluating functions at `double`
precision, these are actually evaluated at `long double` precision internally:
this helps to ensure that as close to full `double` precision as possible is
achieved, but may slow down execution in some environments. The defaults for
this policy can be changed by
-[link math_toolkit.policy.pol_ref.policy_defaults
+[link math_toolkit.pol_ref.policy_defaults
defining the macro `BOOST_MATH_PROMOTE_DOUBLE_POLICY`]
to `false`, or
-[link math_toolkit.policy.pol_ref.internal_promotion
+[link math_toolkit.pol_ref.internal_promotion
by specifying a specific policy] when calling the special
functions or distributions. See also the
-[link math_toolkit.policy.pol_tutorial policy tutorial].
+[link math_toolkit.pol_tutorial policy tutorial].
[table Performance Comparison with and Without Internal Promotion to long double
[[Function]
@@ -432,7 +432,7 @@
your usual release-build settings. Run the application with --help
to see a full list of options, or with --all to test everything
(which takes quite a while), or with --tune to test the
-[link math_toolkit.perf.tuning available performance tuning options].
+[link math_toolkit.tuning available performance tuning options].
If you want to use this application to test the effect of changing
any of the __policy_section, then you will need to build and run it twice:
@@ -441,7 +441,7 @@
[endsect]
-[endsect]
+[endmathpart]
[/
Copyright 2006 John Maddock and Paul A. Bristow.
@@ -451,15 +451,3 @@
]
-
-
-
-
-
-
-
-
-
-
-
-
Modified: sandbox/math/libs/math/doc/policies/policy.qbk
==============================================================================
--- sandbox/math/libs/math/doc/policies/policy.qbk (original)
+++ sandbox/math/libs/math/doc/policies/policy.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -1,4 +1,6 @@
-[section:policy Policies]
+[def foo______ bar]
+
+[mathpart policy Policies]
[section:pol_overview Policy Overview]
[policy_overview]
@@ -123,7 +125,7 @@
should be replaced with the value of ['val].
There is more information on user-defined error handlers in
-the [link math_toolkit.policy.pol_tutorial.user_def_err_pol
+the [link math_toolkit.pol_tutorial.user_def_err_pol
tutorial here].
[h4 Kinds of Error Raised]
@@ -884,9 +886,9 @@
[endsect][/section:pol_ref_ref Policy Class Reference]
[endsect][/section:pol_ref Policy Reference]
-[endsect][/section:policy Policies]
+[endmathpart][/section:policy Policies]
-[/ policy.qbk
+[/ qbk
Copyright 2007, 2010 John Maddock and Paul A. Bristow.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
Modified: sandbox/math/libs/math/doc/policies/policy_tutorial.qbk
==============================================================================
--- sandbox/math/libs/math/doc/policies/policy_tutorial.qbk (original)
+++ sandbox/math/libs/math/doc/policies/policy_tutorial.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -65,12 +65,12 @@
This behaviour can be changed so that the quantile functions are rounded
differently, or even return a real-valued result using
- [link math_toolkit.policy.pol_overview Policies]. It is strongly
+ [link math_toolkit.pol_overview Policies]. It is strongly
recommended that you read the tutorial
- [link math_toolkit.policy.pol_tutorial.understand_dis_quant
+ [link math_toolkit.pol_tutorial.understand_dis_quant
Understanding Quantiles of Discrete Distributions] before
using the quantile function on a discrete distribution. The
- [link math_toolkit.policy.pol_ref.discrete_quant_ref reference docs]
+ [link math_toolkit.pol_ref.discrete_quant_ref reference docs]
describe how to change the rounding policy
for these distributions.
]]
Modified: sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk
==============================================================================
--- sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk (original)
+++ sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -9,7 +9,7 @@
[def __quat_complex_formula ['[^q = ('''α + βi) + (γ + δi)j''' ]]]
[def __not_equal ['[^xy '''≠''' yx]]]
-[section:quaternions Quaternions]
+[mathpart quaternions Quaternions]
[section:overview Overview]
@@ -61,82 +61,82 @@
namespace boost{ namespace math{
- template<typename T> class ``[link math_toolkit.quaternions.quat quaternion]``;
- template<> class ``[link math_toolkit.quaternions.spec quaternion<float>]``;
- template<> class ``[link math_toolkit.quaternion_double quaternion<double>]``;
- template<> class ``[link math_toolkit.quaternion_long_double quaternion<long double>]``;
+ template<typename T> class ``[link math_toolkit.quat quaternion]``;
+ template<> class ``[link math_toolkit.spec quaternion<float>]``;
+ template<> class ``[link math_quaternion_double quaternion<double>]``;
+ template<> class ``[link math_quaternion_long_double quaternion<long double>]``;
// operators
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_subtraction_operators operator -]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_multiplication_operators operator *]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_division_operators operator /]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.unary_plus operator +]`` (quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.non_mem.unary_minus operator -]`` (quaternion<T> const & q);
-
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.equality_operators operator ==]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
-
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.inequality_operators operator !=]`` (T const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_subtraction_operators operator -]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_multiplication_operators operator *]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.unary_plus operator +]`` (quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.unary_minus operator -]`` (quaternion<T> const & q);
+
+ template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+
+ template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (T const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
template<typename T, typename charT, class traits>
- ::std::basic_istream<charT,traits>& ``[link math_toolkit.quaternions.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, quaternion<T> & q);
+ ::std::basic_istream<charT,traits>& ``[link math_toolkit.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, quaternion<T> & q);
template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits>& operator ``[link math_toolkit.quaternions.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);
+ ::std::basic_ostream<charT,traits>& operator ``[link math_toolkit.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);
// values
- template<typename T> T ``[link math_toolkit.quaternions.value_op.real_and_unreal real]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.value_op.real_and_unreal unreal]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.real_and_unreal real]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.value_op.real_and_unreal unreal]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.quaternions.value_op.sup sup]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.quaternions.value_op.l1 l1]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.quaternions.value_op.abs abs]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.quaternions.value_op.norm norm]``(quaternion<T>const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.value_op.conj conj]``(quaternion<T> const & q);
-
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.creation_spherical spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2);
+ template<typename T> T ``[link math_toolkit.value_op.sup sup]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.l1 l1]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.abs abs]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.norm norm]``(quaternion<T>const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.value_op.conj conj]``(quaternion<T> const & q);
+
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2);
// transcendentals
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.exp exp]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.cos cos]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.sin sin]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.tan tan]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.cosh cosh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.sinh sinh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.tanh tanh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.quaternions.trans.pow pow]``(quaternion<T> const & q, int n);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.exp exp]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.cos cos]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.sin sin]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.tan tan]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.cosh cosh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.sinh sinh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.tanh tanh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.pow pow]``(quaternion<T> const & q, int n);
} // namespace math
} // namespace boost
@@ -152,47 +152,47 @@
{
public:
- typedef T ``[link math_toolkit.quaternions.mem_typedef value_type]``;
+ typedef T ``[link math_toolkit.mem_typedef value_type]``;
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
template<typename X>
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<X> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<X> const & a_recopier);
- T ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<T> ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- T ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- T ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- T ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- T ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<T> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<T> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
+ T ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<T> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
+ T ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
+ T ``[link math_toolkit.mem_fun.individual_real_components R_component_2]``() const;
+ T ``[link math_toolkit.mem_fun.individual_real_components R_component_3]``() const;
+ T ``[link math_toolkit.mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<T> ``[link math_toolkit.mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<T> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<T> const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<T> const & a_affecter);
template<typename X>
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(T const & a_affecter);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<T> const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(T const & a_affecter);
+ quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<T> const & a_affecter);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(T const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(::std::complex<T> const & rhs);
template<typename X>
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(T const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(::std::complex<T> const & rhs);
template<typename X>
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(T const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(::std::complex<T> const & rhs);
template<typename X>
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(T const & rhs);
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<T> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(T const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(::std::complex<T> const & rhs);
template<typename X>
- quaternion<T>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<T>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
};
} // namespace math
@@ -208,145 +208,145 @@
class quaternion<float>
{
public:
- typedef float ``[link math_toolkit.quaternions.mem_typedef value_type]``;
+ typedef float ``[link math_toolkit.mem_typedef value_type]``;
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
- float ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<float> ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- float ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- float ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- float ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- float ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<float> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<float> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
+ float ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<float> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
+ float ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
+ float ``[link math_toolkit.mem_fun.individual_real_components R_component_2]``() const;
+ float ``[link math_toolkit.mem_fun.individual_real_components R_component_3]``() const;
+ float ``[link math_toolkit.mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<float> ``[link math_toolkit.mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<float> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<float> const & a_affecter);
+ quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<float> const & a_affecter);
template<typename X>
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(float const & a_affecter);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);
+ quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(float const & a_affecter);
+ quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(float const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<float> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(::std::complex<float> const & rhs);
template<typename X>
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(float const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<float> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(::std::complex<float> const & rhs);
template<typename X>
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(float const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<float> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(::std::complex<float> const & rhs);
template<typename X>
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(float const & rhs);
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<float> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(float const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(::std::complex<float> const & rhs);
template<typename X>
- quaternion<float>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<float>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
};
-[#math_toolkit.quaternion_double]
+[#math_quaternion_double]
template<>
class quaternion<double>
{
public:
- typedef double ``[link math_toolkit.quaternions.mem_typedef value_type]``;
+ typedef double ``[link math_toolkit.mem_typedef value_type]``;
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
- double ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<double> ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<double> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<double> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
+ double ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<double> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
+ double ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
+ double ``[link math_toolkit.mem_fun.individual_real_components R_component_2]``() const;
+ double ``[link math_toolkit.mem_fun.individual_real_components R_component_3]``() const;
+ double ``[link math_toolkit.mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<double> ``[link math_toolkit.mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<double> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<double> const & a_affecter);
+ quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<double> const & a_affecter);
template<typename X>
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(double const & a_affecter);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);
+ quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(double const & a_affecter);
+ quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(double const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<double> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(::std::complex<double> const & rhs);
template<typename X>
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(double const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<double> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(::std::complex<double> const & rhs);
template<typename X>
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(double const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<double> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(::std::complex<double> const & rhs);
template<typename X>
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(double const & rhs);
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<double> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(double const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(::std::complex<double> const & rhs);
template<typename X>
- quaternion<double>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<double>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
};
-[#math_toolkit.quaternion_long_double]
+[#math_quaternion_long_double]
template<>
class quaternion<long double>
{
public:
- typedef long double ``[link math_toolkit.quaternions.mem_typedef value_type]``;
+ typedef long double ``[link math_toolkit.mem_typedef value_type]``;
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
- explicit ``[link math_toolkit.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
+ explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
- long double ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts real]``() const;
- quaternion<long double> ``[link math_toolkit.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
- long double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_1]``() const;
- long double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_2]``() const;
- long double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_3]``() const;
- long double ``[link math_toolkit.quaternions.mem_fun.individual_real_components R_component_4]``() const;
- ::std::complex<long double> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
- ::std::complex<long double> ``[link math_toolkit.quaternions.mem_fun.individual_complex__components C_component_2]``() const;
+ long double ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
+ quaternion<long double> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
+ long double ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
+ long double ``[link math_toolkit.mem_fun.individual_real_components R_component_2]``() const;
+ long double ``[link math_toolkit.mem_fun.individual_real_components R_component_3]``() const;
+ long double ``[link math_toolkit.mem_fun.individual_real_components R_component_4]``() const;
+ ::std::complex<long double> ``[link math_toolkit.mem_fun.individual_complex_components C_component_1]``() const;
+ ::std::complex<long double> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<long double> const & a_affecter);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<long double> const & a_affecter);
template<typename X>
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(long double const & a_affecter);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(long double const & a_affecter);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(long double const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<long double> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(::std::complex<long double> const & rhs);
template<typename X>
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(long double const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs);
template<typename X>
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(long double const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs);
template<typename X>
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(long double const & rhs);
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<long double> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(long double const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(::std::complex<long double> const & rhs);
template<typename X>
- quaternion<long double>& ``[link math_toolkit.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
+ quaternion<long double>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
};
} // namespace math
@@ -709,7 +709,7 @@
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.
-[#math_toolkit.quaternions.creation_spherical] `spherical` is a simple transposition of `polar`, it takes as inputs
+[#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
@@ -718,23 +718,23 @@
outside their natural ranges. The expected degeneracies (a magnitude of
zero ignores the angles settings...) do happen however.
-[#math_toolkit.quaternions.creation_cylindrical] `cylindrical` is likewise a simple transposition of the usual
+[#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.
-[#math_toolkit.quaternions.creation_multipolar] `multipolar` is yet another simple generalization of polar coordinates.
+[#math_quaternions.creation_multipolar] `multipolar` is yet another simple generalization of polar coordinates.
This time, both __C components of the quaternion are given in polar coordinates.
-[#math_toolkit.quaternions.creation_cylindrospherical] `cylindrospherical` is specific to quaternions. It is often interesting to
+[#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.
-[#math_toolkit.quaternions.creation_semipolar] `semipolar` is another generator which is specific to quaternions.
+[#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
@@ -843,7 +843,7 @@
([@../../../quaternion/output.txt sample output], with message output
enabled).
-If you define the symbol math_toolkit_TEST_VERBOSE, you will get
+If you define the symbol TEST_VERBOSE, you will get
additional output ([@../../../quaternion/output_more.txt verbose output]);
this will only be helpfull if you enable message output at the same time,
of course (by uncommenting the relevant line in the test or by adding
@@ -903,4 +903,4 @@
implementation to an efficient one).
[endsect]
-[endsect]
+[endmathpart]
Modified: sandbox/math/libs/math/doc/sf/ellint_introduction.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/ellint_introduction.qbk (original)
+++ sandbox/math/libs/math/doc/sf/ellint_introduction.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -25,7 +25,7 @@
All variables are real numbers unless otherwise noted.
-[h4 [#ellint_def]Definition]
+[h4 Definition]
[equation ellint1]
@@ -138,13 +138,13 @@
['R[sub D](x, y, z) = R[sub J](x, y, z, z)]]
-[h4 [#ellint_theorem]Duplication Theorem]
+[h4 Duplication Theorem]
Carlson proved in [[link ellint_ref_carlson78 Carlson78]] that
[equation ellint13]
-[h4 [#ellint_formula]Carlson's Formulas]
+[h4 Carlson's Formulas]
The Legendre form and Carlson form of elliptic integrals are related
by equations:
@@ -165,7 +165,7 @@
provides a unified method for all three kinds of elliptic integrals
with satisfactory precisions.
-[h4 [#ellint_refs]References]
+[h4 References]
Special mention goes to:
Modified: sandbox/math/libs/math/doc/sf/erf.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/erf.qbk (original)
+++ sandbox/math/libs/math/doc/sf/erf.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -180,7 +180,7 @@
region is very low: the last bit is incorrect in only a very small number of
cases.
-For `z > 0.5` we observe that over a small interval [a, b) then:
+For `z > 0.5` we observe that over a small interval \[a, b) then:
erfc(z) * exp(z*z) * z ~ c
Modified: sandbox/math/libs/math/doc/sf/erf_inv.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/erf_inv.qbk (original)
+++ sandbox/math/libs/math/doc/sf/erf_inv.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -60,7 +60,7 @@
For types up to and including 80-bit long doubles the approximations used
are accurate to less than ~ 2 epsilon. For higher precision types these
functions have the same accuracy as the
-[link math_toolkit.special.sf_erf.error_function forward error functions].
+[link math_toolkit.sf_erf.error_function forward error functions].
[h4 Testing]
Modified: sandbox/math/libs/math/doc/sf/inv_hyper.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/inv_hyper.qbk (original)
+++ sandbox/math/libs/math/doc/sf/inv_hyper.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -84,7 +84,7 @@
``__sf_result`` acosh(const T x, const ``__Policy``&);
Computes the reciprocal of (the restriction to the range of __form1)
-[link math_toolkit.special.inv_hyper.inv_hyper_over
+[link math_toolkit.inv_hyper.inv_hyper_over
the hyperbolic cosine function], at x. Values returned are positive.
If x is in the range __form2 then returns the result of __domain_error.
@@ -150,7 +150,7 @@
``__sf_result`` asinh(const T x, const ``__Policy``&);
Computes the reciprocal of
-[link math_toolkit.special.inv_hyper.inv_hyper_over
+[link math_toolkit.inv_hyper.inv_hyper_over
the hyperbolic sine function].
The return type of this function is computed using the __arg_pomotion_rules:
@@ -213,7 +213,7 @@
``__sf_result`` atanh(const T x, const ``__Policy``&);
Computes the reciprocal of
-[link math_toolkit.special.inv_hyper.inv_hyper_over
+[link math_toolkit.inv_hyper.inv_hyper_over
the hyperbolic tangent function], at x.
[optional_policy]
Deleted: sandbox/math/libs/math/doc/sf/math.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/math.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
+++ (empty file)
@@ -1,571 +0,0 @@
-[article Math Toolkit
- [quickbook 1.5]
- [copyright 2006, 2007, 2008, 2009, 2010, 2012, 2013 John Maddock, Paul A. Bristow, Hubert Holin, Xiaogang Zhang, Bruno Lalande, Johan RÃ¥de, Gautam Sewani, Thijs van den Berg, Benjamin Sobotta and Christopher Kormanyos]
- [/purpose ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22]
- [license
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
- ]
- [authors [Maddock, John], [Bristow, Paul A.], [Holin, Hubert], [Zhang, Xiaogang], [Lalande, Bruno], [RÃ¥de, Johan], [Sewani, Gautam], [van den Berg, Thijs], [Sobotta, Benjamin], [Kormanyos, Christopher] ]
- [/last-revision $Date$]
-]
-
-[/ \u00E5 = Latin small letter A with ring above doesn't seem to work in authors with Quickbook 1.5]
-
-[template equation[name] '''<inlinemediaobject>
-<imageobject role="html">
-<imagedata fileref="../equations/'''[name]'''.png"></imagedata>
-</imageobject>
-<imageobject role="print">
-<imagedata fileref="../equations/'''[name]'''.svg"></imagedata>
-</imageobject>
-</inlinemediaobject>''']
-
-[template graph[name] '''<inlinemediaobject>
-<imageobject role="html">
-<imagedata align="center" fileref="../graphs/'''[name]'''.png"></imagedata>
-</imageobject>
-<imageobject role="print">
-<imagedata align="center" fileref="../graphs/'''[name]'''.svg"></imagedata>
-</imageobject>
-</inlinemediaobject>''']
-
-[include ../../../../tools/auto_index/include/auto_index_helpers.qbk]
-[/ Must be first included file!]
-
-[include html4_symbols.qbk]
-[/include math_symbols.qbk]
-
-[/include latin1_symbols.qbk] [/ just for testing]
-[include common_overviews.qbk] [/ overviews that appear in more than one place!]
-[include tr1.qbk] [/tr1 docs also appear in more than one place!]
-[include roadmap.qbk] [/ for history]
-
-[def __effects [*Effects: ]]
-[def __formula [*Formula: ]]
-[def __exm1 '''<code>e<superscript>x</superscript> - 1</code>'''] [/e^x -1]
-[def __ex '''<code>e<superscript>x</superscript></code>'''] [/e^x]
-[def __te '''2ɛ'''] [/small Latin letter open e]
-
-[def __ceilR '''⌉''']
-[def __ceilL '''ऄ''']
-[def __floorR '''⌋''']
-[def __floorL '''⌊''']
-[def __infin '''∞''']
-[def __integral '''∫''']
-[def __aacute '''á''']
-[def __eacute '''é''']
-[def __quarter '''¼''']
-[def __nearequal '''≊''']
-[def __spaces '''  '''] [/ two spaces - useful for an indent.]
-
-[def __caution This is now an official Boost library, but remains a library under
- development, the code is fully functional and robust, but
- interfaces, library structure, and function and distribution names
- may still be changed without notice.]
-
-[template tr1[] [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Technical Report on C++ Library Extensions]]
-[template C99[] [@http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf C99 Standard ISO/IEC 9899:1999]]
-[template jm_rationals[] [link math_toolkit.backgrounders.implementation.rational_approximations_used devised by JM]]
-
-[def __domain_error [link domain_error domain_error]]
-[def __pole_error [link pole_error pole_error]]
-[def __overflow_error [link overflow_error overflow_error]]
-[def __underflow_error [link underflow_error underflow_error]]
-[def __denorm_error [link denorm_error denorm_error]]
-[def __evaluation_error [link evaluation_error evaluation_error]]
-[def __rounding_error [link rounding_error rounding_error]]
-[def __indeterminate_result_error [link indeterminate_result_error indeterminate_result_error]]
-[def __checked_narrowing_cast [link checked_narrowing_cast checked_narrowing_cast]]
-
-[def __arg_pomotion_rules [link math_toolkit.main_overview.result_type ['result type calculation rules]]]
-[def __sf_result [link math_toolkit.main_overview.result_type ['calculated-result-type]]]
-
-[/ The following macros expand to links to the various special functions
-and use the function's name as the link text.]
-
-[/Misc]
-[def __lanczos [link math_toolkit.backgrounders.lanczos Lanczos approximation]]
-[def __zero_error [link zero_error effectively zero error]]
-[def __relative_error [link math_toolkit.backgrounders.relative_error relative zero error]]
-[def __root_finding_with_derivatives [link math_toolkit.toolkit.internals1.roots root-finding with derivatives]]
-
-[/gammas]
-[def __lgamma [link math_toolkit.special.sf_gamma.lgamma lgamma]]
-[def __digamma [link math_toolkit.special.sf_gamma.digamma digamma]]
-[def __tgamma_ratio [link math_toolkit.special.sf_gamma.gamma_ratios tgamma_ratio]]
-[def __tgamma_delta_ratio [link math_toolkit.special.sf_gamma.gamma_ratios tgamma_delta_ratio]]
-[def __tgamma [link math_toolkit.special.sf_gamma.tgamma tgamma]]
-[def __tgamma1pm1 [link math_toolkit.special.sf_gamma.tgamma tgamma1pm1]]
-[def __tgamma_lower [link math_toolkit.special.sf_gamma.igamma tgamma_lower]]
-[def __gamma_p [link math_toolkit.special.sf_gamma.igamma gamma_p]]
-[def __gamma_q [link math_toolkit.special.sf_gamma.igamma gamma_q]]
-[def __gamma_q_inv [link math_toolkit.special.sf_gamma.igamma_inv gamma_q_inv]]
-[def __gamma_p_inv [link math_toolkit.special.sf_gamma.igamma_inv gamma_p_inv]]
-[def __gamma_q_inva [link math_toolkit.special.sf_gamma.igamma_inv gamma_q_inva]]
-[def __gamma_p_inva [link math_toolkit.special.sf_gamma.igamma_inv gamma_p_inva]]
-[def __gamma_p_derivative [link math_toolkit.special.sf_gamma.gamma_derivatives gamma_p_derivative]]
-
-[/factorials]
-[def __factorial [link math_toolkit.special.factorials.sf_factorial factorial]]
-[def __unchecked_factorial [link math_toolkit.special.factorials.sf_factorial unchecked_factorial]]
-[def __max_factorial [link math_toolkit.special.factorials.sf_factorial max_factorial]]
-[def __double_factorial [link math_toolkit.special.factorials.sf_double_factorial double_factorial]]
-[def __rising_factorial [link math_toolkit.special.factorials.sf_rising_factorial rising_factorial]]
-[def __falling_factorial [link math_toolkit.special.factorials.sf_falling_factorial falling_factorial]]
-
-[/error functions]
-[def __erf [link math_toolkit.special.sf_erf.error_function erf]]
-[def __erfc [link math_toolkit.special.sf_erf.error_function erfc]]
-[def __erf_inv [link math_toolkit.special.sf_erf.error_inv erf_inv]]
-[def __erfc_inv [link math_toolkit.special.sf_erf.error_inv erfc_inv]]
-
-[/beta functions]
-[def __beta [link math_toolkit.special.sf_beta.beta_function beta]]
-[def __beta3 [link math_toolkit.special.sf_beta.ibeta_function beta]]
-[def __betac [link math_toolkit.special.sf_beta.ibeta_function betac]]
-[def __ibeta [link math_toolkit.special.sf_beta.ibeta_function ibeta]]
-[def __ibetac [link math_toolkit.special.sf_beta.ibeta_function ibetac]]
-[def __ibeta_inv [link math_toolkit.special.sf_beta.ibeta_inv_function ibeta_inv]]
-[def __ibetac_inv [link math_toolkit.special.sf_beta.ibeta_inv_function ibetac_inv]]
-[def __ibeta_inva [link math_toolkit.special.sf_beta.ibeta_inv_function ibeta_inva]]
-[def __ibetac_inva [link math_toolkit.special.sf_beta.ibeta_inv_function ibetac_inva]]
-[def __ibeta_invb [link math_toolkit.special.sf_beta.ibeta_inv_function ibeta_invb]]
-[def __ibetac_invb [link math_toolkit.special.sf_beta.ibeta_inv_function ibetac_invb]]
-[def __ibeta_derivative [link math_toolkit.special.sf_beta.beta_derivative ibeta_derivative]]
-
-[/elliptic integrals]
-[def __ellint_rj [link math_toolkit.special.ellint.ellint_carlson ellint_rj]]
-[def __ellint_rf [link math_toolkit.special.ellint.ellint_carlson ellint_rf]]
-[def __ellint_rc [link math_toolkit.special.ellint.ellint_carlson ellint_rc]]
-[def __ellint_rd [link math_toolkit.special.ellint.ellint_carlson ellint_rd]]
-[def __ellint_1 [link math_toolkit.special.ellint.ellint_1 ellint_1]]
-[def __ellint_2 [link math_toolkit.special.ellint.ellint_2 ellint_2]]
-[def __ellint_3 [link math_toolkit.special.ellint.ellint_3 ellint_3]]
-
-[/Bessel functions]
-[def __cyl_bessel_j [link math_toolkit.special.bessel.bessel cyl_bessel_j]]
-[def __cyl_neumann [link math_toolkit.special.bessel.bessel cyl_neumann]]
-[def __cyl_bessel_i [link math_toolkit.special.bessel.mbessel cyl_bessel_i]]
-[def __cyl_bessel_k [link math_toolkit.special.bessel.mbessel cyl_bessel_k]]
-[def __sph_bessel [link math_toolkit.special.bessel.sph_bessel sph_bessel]]
-[def __sph_neumann [link math_toolkit.special.bessel.sph_bessel sph_neumann]]
-
-[/Hankel Functions]
-[def __cyl_hankel_1 [link math_toolkit.special.hankel.cyl_hankel cyl_hankel_1]]
-[def __cyl_hankel_2 [link math_toolkit.special.hankel.cyl_hankel cyl_hankel_2]]
-[def __sph_hankel_1 [link math_toolkit.special.hankel.sph_hankel sph_hankel_1]]
-[def __sph_hankel_2 [link math_toolkit.special.hankel.sph_hankel sph_hankel_2]]
-
-[/Airy Functions]
-[def __airy_ai [link math_toolkit.special.airy.ai airy_ai]]
-[def __airy_bi [link math_toolkit.special.airy.bi airy_bi]]
-[def __airy_bi_prime [link math_toolkit.special.airy.bip airy_bi_prime]]
-[def __airy_ai_prime [link math_toolkit.special.airy.aip airy_ai_prime]]
-
-[/Jacobi Elliptic Functions]
-[def __jacobi_elliptic [link math_toolkit.special.jacobi.jacobi_elliptic jacobi_elliptic]]
-[def __jacobi_cd [link math_toolkit.special.jacobi.jacobi_cd jacobi_cd]]
-[def __jacobi_cn [link math_toolkit.special.jacobi.jacobi_cn jacobi_cn]]
-[def __jacobi_cs [link math_toolkit.special.jacobi.jacobi_cs jacobi_cs]]
-[def __jacobi_dc [link math_toolkit.special.jacobi.jacobi_dc jacobi_dc]]
-[def __jacobi_dn [link math_toolkit.special.jacobi.jacobi_dn jacobi_dn]]
-[def __jacobi_ds [link math_toolkit.special.jacobi.jacobi_ds jacobi_ds]]
-[def __jacobi_nd [link math_toolkit.special.jacobi.jacobi_nd jacobi_nd]]
-[def __jacobi_nc [link math_toolkit.special.jacobi.jacobi_nc jacobi_nc]]
-[def __jacobi_ns [link math_toolkit.special.jacobi.jacobi_ns jacobi_ns]]
-[def __jacobi_sd [link math_toolkit.special.jacobi.jacobi_sd jacobi_sd]]
-[def __jacobi_sn [link math_toolkit.special.jacobi.jacobi_sn jacobi_sn]]
-[def __jacobi_sc [link math_toolkit.special.jacobi.jacobi_sc jacobi_sc]]
-
-[/sinus cardinals]
-[def __sinc_pi [link math_toolkit.special.sinc.sinc_pi sinc_pi]]
-[def __sinhc_pi [link math_toolkit.special.sinc.sinhc_pi sinhc_pi]]
-
-[/Inverse hyperbolics]
-[def __acosh [link math_toolkit.special.inv_hyper.acosh acosh]]
-[def __asinh [link math_toolkit.special.inv_hyper.asinh asinh]]
-[def __atanh [link math_toolkit.special.inv_hyper.atanh atanh]]
-
-[/classify]
-[def __fpclassify [link math_toolkit.special.fpclass fpclassify]]
-[def __isfinite [link math_toolkit.special.fpclass isfinite]]
-[def __isnan [link math_toolkit.special.fpclass isnan]]
-[def __isinf [link math_toolkit.special.fpclass isinf]]
-[def __isnormal [link math_toolkit.special.fpclass isnormal]]
-[def __fp_facets [link math_toolkit.utils.fp_facets nonfinite fp_facets]]
-
-[/powers etc]
-[def __expm1 [link math_toolkit.special.powers.expm1 expm1]]
-[def __log1p [link math_toolkit.special.powers.log1p log1p]]
-[def __cbrt [link math_toolkit.special.powers.cbrt cbrt]]
-[def __sqrt1pm1 [link math_toolkit.special.powers.sqrt1pm1 sqrt1pm1]]
-[def __powm1 [link math_toolkit.special.powers.powm1 powm1]]
-[def __hypot [link math_toolkit.special.powers.hypot hypot]]
-[def __pow [link math_toolkit.special.powers.ct_pow pow]]
-
-[/zeta]
-[def __zeta [link math_toolkit.special.zetas.zeta zeta]]
-
-[/expint]
-[def __expint_i [link math_toolkit.special.expint.expint_i zeta]]
-[def __expint_n [link math_toolkit.special.expint.expint_n zeta]]
-
-[/rounding]
-[def __round [link math_toolkit.utils.rounding.round round]]
-[def __lround [link math_toolkit.utils.rounding.round round]]
-[def __llround [link math_toolkit.utils.rounding.round round]]
-[def __trunc [link math_toolkit.utils.rounding.trunc trunc]]
-[def __modf [link math_toolkit.utils.rounding.modf modf]]
-
-[/polynomials]
-[def __laguerre [link math_toolkit.special.sf_poly.laguerre laguerre]]
-[def __legendre [link math_toolkit.special.sf_poly.legendre legendre_p]]
-[def __hermite [link math_toolkit.special.sf_poly.hermite hermite]]
-
-[/Misc]
-[def __expint [link math_toolkit.special.expint.expint_i expint]]
-[def __spherical_harmonic [link math_toolkit.special.sf_poly.sph_harm spherical_harmonic]]
-[def __owens_t [link math_toolkit.special.owens_t Owens T]]
-
-
-[/tools]
-[def __tuple [link math_toolkit.toolkit.internals1.tuples boost::math::tuple]]
-
-[/ distribution non-members]
-[def __cdf [link math.dist.cdf Cumulative Distribution Function]]
-[def __pdf [link math.dist.pdf Probability Density Function]]
-[def __ccdf [link math.dist.ccdf Complement of the Cumulative Distribution Function]]
-[def __quantile [link math.dist.quantile Quantile]]
-[def __quantile_c [link math.dist.quantile_c Quantile from the complement of the probability]]
-[def __mean [link math.dist.mean mean]]
-[def __median [link math.dist.median median]]
-[def __mode [link math.dist.mode mode]]
-[def __skewness [link math.dist.skewness skewness]]
-[def __kurtosis [link math.dist.kurtosis kurtosis]]
-[def __kurtosis_excess [link math.dist.kurtosis_excess kurtosis_excess]]
-[def __variance [link math.dist.variance variance]]
-[def __sd [link math.dist.sd standard deviation]]
-[def __hazard [link math.dist.hazard Hazard Function]]
-[def __chf [link math.dist.chf Cumulative Hazard Function]]
-[def __range [link math.dist.range range]]
-[def __support [link math.dist.support support]]
-
-[/ distribution def names end in distrib to avoid clashes]
-[def __beta_distrib [link math_toolkit.dist.dist_ref.dists.beta_dist Beta Distribution]]
-[def __binomial_distrib [link math_toolkit.dist.dist_ref.dists.binomial_dist Binomial Distribution]]
-[def __cauchy_distrib [link math_toolkit.dist.dist_ref.dists.cauchy_dist Cauchy Distribution]]
-[def __chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.chi_squared_dist Chi Squared Distribution]]
-[def __extreme_distrib [link math_toolkit.dist.dist_ref.dists.extreme_dist Extreme Distributions]]
-[def __exp_distrib [link math_toolkit.dist.dist_ref.dists.exp_dist Exponential Distribution]]
-[def __F_distrib [link math_toolkit.dist.dist_ref.dists.f_dist Fisher F Distribution]]
-[def __gamma_distrib [link math_toolkit.dist.dist_ref.dists.gamma_dist Gamma Distribution]]
-[def __geometric_distrib [link math_toolkit.dist.dist_ref.dists.geometric_dist Geometric Distribution]]
-[def __hypergeometric_distrib [link math_toolkit.dist.dist_ref.dists.hypergeometric_dist hypergeometric Distribution]]
-[def __inverse_gamma_distrib [link math_toolkit.dist.dist_ref.dists.inverse_gamma_dist Inverse Gamma Distribution]]
-[def __inverse_gaussian_distrib [link math_toolkit.dist.dist_ref.dists.inverse_gaussian_dist Inverse Gaussian Distribution]]
-[def __inverse_chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.inverse_chi_squared_dist Inverse chi squared Distribution]]
-[def __laplace_distrib [link math_toolkit.dist.dist_ref.dists.laplace_dist Laplace Distribution]]
-[def __logistic_distrib [link math_toolkit.dist.dist_ref.dists.logistic_dist Logistic Distribution]]
-[def __lognormal_distrib [link math_toolkit.dist.dist_ref.dists.lognormal_dist Log-normal Distribution]]
-[def __negative_binomial_distrib [link math_toolkit.dist.dist_ref.dists.negative_binomial_dist Negative Binomial Distribution]]
-[def __non_central_chi_squared_distrib [link math_toolkit.dist.dist_ref.dists.nc_chi_squared_dist Noncentral Chi Squared Distribution]]
-[def __non_central_beta_distrib [link math_toolkit.dist.dist_ref.dists.nc_beta_dist Noncentral Beta Distribution]]
-[def __non_central_F_distrib [link math_toolkit.dist.dist_ref.dists.nc_f_dist Noncentral F Distribution]]
-[def __non_central_T_distrib [link math_toolkit.dist.dist_ref.dists.nc_t_dist Noncentral T Distribution]]
-[def __non_central_t_distrib [link math_toolkit.dist.dist_ref.dists.nc_t_dist noncentral T distribution]]
-[def __normal_distrib [link math_toolkit.dist.dist_ref.dists.normal_dist Normal Distribution]]
-[def __poisson_distrib [link math_toolkit.dist.dist_ref.dists.poisson_dist Poisson Distribution]]
-[def __pareto_distrib [link math_toolkit.dist.dist_ref.dists.pareto_dist Pareto Distribution]]
-[def __students_t_distrib [link math_toolkit.dist.dist_ref.dists.students_t_dist Students t Distribution]]
-[def __skew_normal_distrib [link math_toolkit.dist.dist_ref.dists.skew_normal_dist Skew Normal Distribution]]
-[def __weibull_distrib [link math_toolkit.dist.dist_ref.dists.weibull_dist Weibull Distribution]]
-
-[/links to policy]
-[def __Policy [link math_toolkit.policy Policy]] [/ Used in distribution template specifications]
-[def __policy_section [link math_toolkit.policy Policies]] [/ Used in text to refer to.]
-[def __policy_class [link math_toolkit.policy.pol_ref.pol_ref_ref policies::policy<>]]
-[def __math_undefined [link math_toolkit.policy.pol_ref.assert_undefined mathematically undefined function]]
-[def __policy_ref [link math_toolkit.policy.pol_ref policy reference]]
-[def __math_discrete [link math_toolkit.policy.pol_ref.discrete_quant_ref discrete functions]]
-[def __error_policy [link math_toolkit.policy.pol_ref.error_handling_policies error handling policies]]
-[def __changing_policy_defaults [link math_toolkit.policy.pol_ref.policy_defaults changing policies defaults]]
-[def __user_error_handling [link math_toolkit.policy.pol_tutorial.user_def_err_pol user error handling]]
-[def __promotion_policy [link math_toolkit.policy.pol_ref.internal_promotion internal promotion policy]]
-[def __precision_policy [link math_toolkit.policy.pol_ref.precision_pol precision policy]]
-[def __policy_macros [link math_toolkit.policy.pol_ref.policy_defaults Using Macros to Change the Policy Defaults]]
-
-[def __random_variate [@http://en.wikipedia.org/wiki/Random_variate random variate]]
-[def __random_variable [@http://en.wikipedia.org/wiki/Random_variable random variable]]
-[def __probability_distribution [@[@http://en.wikipedia.org/wiki/Probability_distribution probability_distribution]]
-
-[def __usual_accessors __cdf, __pdf, __quantile, __hazard,
- __chf, __mean, __median, __mode, __variance, __sd, __skewness,
- __kurtosis, __kurtosis_excess, __range and __support]
-
-[def __gsl [@http://www.gnu.org/software/gsl/ GSL-1.9]]
-[def __glibc [@http://www.gnu.org/software/libc/ GNU C Lib]]
-[def __hpc [@http://docs.hp.com/en/B9106-90010/index.html HP-UX C Library]]
-[def __cephes [@http://www.netlib.org/cephes/ Cephes]]
-[def __NTL [@http://www.shoup.net/ntl/ NTL A Library for doing Number Theory]]
-[def __NTL_RR [@http://shoup.net/ntl/doc/RR.txt NTL::RR]]
-[def __NTL_quad_float [@http://shoup.net/ntl/doc/quad_float.txt NTL::quad_float]]
-[def __MPFR [@http://www.mpfr.org/ GNU MPFR library]]
-[def __GMP [@http://gmplib.org/ GNU Multiple Precision Arithmetic Library]]
-[def __multiprecision [@http://www.boost.org/doc/libs/1_53_0_beta1/libs/multiprecision/doc/html/index.html Boost.Multiprecision]]
-[def __cpp_dec_float [@http://www.boost.org/doc/libs/1_53_0_beta1/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html cpp_dec_float]]
-[def __R [@http://www.r-project.org/ The R Project for Statistical Computing]]
-[def __godfrey [link godfrey Godfrey]]
-[def __pugh [link pugh Pugh]]
-[def __NaN [@http://en.wikipedia.org/wiki/NaN NaN]]
-[def __errno [@http://en.wikipedia.org/wiki/Errno `::errno`]]
-[def __Mathworld [@http://mathworld.wolfram.com Wolfram MathWorld]]
-[def __Mathematica [@http://www.wolfram.com/products/mathematica/index.html Wolfram Mathematica]]
-[def __WolframAlpha [@http://www.wolframalpha.com/ Wolfram Alpha]]
-[def __TOMS748 [@http://portal.acm.org/citation.cfm?id=210111 TOMS Algorithm 748: enclosing zeros of continuous functions]]
-[def __TOMS910 [@http://portal.acm.org/citation.cfm?id=1916469 TOMS Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations]]
-[def __why_complements [link why_complements why complements?]]
-[def __complements [link complements complements]]
-[def __performance [link math_toolkit.perf performance]]
-[def __building [link math_toolkit.main_overview.building building libraries]]
-[def __e_float [@http://calgo.acm.org/910.zip e_float (TOMS Algorithm 910)]]
-[def __Abramowitz_Stegun M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions, NBS (1964)]
-[def _DMLF [@http://dlmf.nist.gov/ NIST Digital Library of Mathematical Functions]]
-
-[/ Some composite templates]
-[template super[x]'''<superscript>'''[x]'''</superscript>''']
-[template sub[x]'''<subscript>'''[x]'''</subscript>''']
-[template floor[x]'''⌊'''[x]'''⌋''']
-[template floorlr[x][lfloor][x][rfloor]]
-[template ceil[x] '''⌈'''[x]'''⌉''']
-
-[template header_file[file] [@../../../../../[file] [file]]]
-
-[template optional_policy[]
-The final __Policy argument is optional and can be used to
-control the behaviour of the function: how it handles errors,
-what level of precision to use etc. Refer to the
-[link math_toolkit.policy policy documentation for more details].]
-
-[template discrete_quantile_warning[NAME]
-[caution
-The [NAME] distribution is a discrete distribution: internally,
-functions like the `cdf` and `pdf` are treated "as if" they are continuous
-functions, but in reality the results returned from these functions
-only have meaning if an integer value is provided for the random variate
-argument.
-
-The quantile function will by default return an integer result that has been
-/rounded outwards/. That is to say lower quantiles (where the probability is
-less than 0.5) are rounded downward, and upper quantiles (where the probability
-is greater than 0.5) are rounded upwards. This behaviour
-ensures that if an X% quantile is requested, then /at least/ the requested
-coverage will be present in the central region, and /no more than/
-the requested coverage will be present in the tails.
-
-This behaviour can be changed so that the quantile functions are rounded
-differently, or even return a real-valued result using
-[link math_toolkit.policy.pol_overview Policies]. It is strongly
-recommended that you read the tutorial
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant
-Understanding Quantiles of Discrete Distributions] before
-using the quantile function on the [NAME] distribution. The
-[link math_toolkit.policy.pol_ref.discrete_quant_ref reference docs]
-describe how to change the rounding policy
-for these distributions.
-] [/ caution]
-] [/ template discrete_quantile_warning]
-
-This manual is also available in
-[@http://sourceforge.net/projects/boost/files/boost-docs/
-printer friendly PDF format],
-and as a CD ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22.
-
-[section:main_overview Overview]
-[include overview.qbk]
-[include structure.qbk] [/getting about, directory and file structure.]
-[include result_type_calc.qbk]
-[include error_handling.qbk]
-
-[section:compilers_overview Compilers]
-[compilers_overview]
-[endsect]
-[include config_macros.qbk]
-[section:pol_overview Policies]
-[policy_overview]
-[endsect]
-
-[include thread_safety.qbk]
-
-[section:perf_over Performance]
-[performance_overview]
-[endsect]
-[include building.qbk]
-[section:history1 History and What's New]
-[history]
-[endsect]
-[section:tr1 C99 and C++ TR1 C-style Functions]
-[tr1_overview]
-[endsect]
-[include faq.qbk]
-[include contact_info.qbk]
-
-[endsect] [/section:main_overview Overview]
-
-[section:dist Statistical Distributions and Functions]
-[include dist_tutorial.qbk]
-[include dist_reference.qbk] [/includes all individual distribution.qbk files]
-[endsect] [/section:dist Statistical Distributions and Functions]
-
-[section:special Special Functions]
-
-[section:sf_gamma Gamma Functions]
-[include tgamma.qbk]
-[include lgamma.qbk]
-[include digamma.qbk]
-[include gamma_ratios.qbk]
-[include igamma.qbk]
-[include igamma_inv.qbk]
-[include gamma_derivatives.qbk]
-[endsect] [/section:sf_gamma Gamma Functions]
-
-[include factorials.qbk]
-
-[section:sf_beta Beta Functions]
-[include beta.qbk]
-[include ibeta.qbk]
-[include ibeta_inv.qbk]
-[include beta_derivative.qbk]
-[endsect] [/section:sf_beta Beta Functions]
-
-[section:sf_erf Error Functions]
-[include erf.qbk]
-[include erf_inv.qbk]
-[endsect] [/section:sf_erf Error Functions]
-
-[section:sf_poly Polynomials]
-[include legendre.qbk]
-[include laguerre.qbk]
-[include hermite.qbk]
-[include spherical_harmonic.qbk]
-[endsect] [/section:sf_poly Polynomials]
-
-[section:bessel Bessel Functions]
-[include bessel_introduction.qbk]
-[include bessel_jy.qbk]
-[include bessel_ik.qbk]
-[include bessel_spherical.qbk]
-[endsect] [/section:bessel Bessel Functions]
-
-[/Hankel functions]
-[include hankel.qbk]
-
-[/Airy Functions]
-[include airy.qbk]
-
-[section:ellint Elliptic Integrals]
-[include ellint_introduction.qbk]
-[include ellint_carlson.qbk]
-[include ellint_legendre.qbk]
-[endsect] [/section:ellint Elliptic Integrals]
-
-[include jacobi_elliptic.qbk]
-
-[section:zetas Zeta Functions]
-[include zeta.qbk]
-[endsect]
-
-[include expint.qbk]
-
-[include powers.qbk]
-[include sinc.qbk]
-[include inv_hyper.qbk]
-
-[include owens_t.qbk]
-
-[endsect] [/section:special Special Functions]
-
-[section:utils Floating Point Utilities]
-[include rounding_func.qbk]
-[include fpclassify.qbk]
-[include sign.qbk]
-[include fp_facets.qbk]
-[include float_next.qbk]
-[endsect]
-
-[section:extern_c TR1 and C99 external "C" Functions]
-[section:tr1 C99 and TR1 C Functions Overview]
-[tr1_overview]
-[endsect]
-[include c99_ref.qbk]
-[include tr1_ref.qbk]
-[endsect]
-
-[include constants.qbk]
-
-[section:toolkit Tools and Internal Details]
-
-[include internals_overview.qbk]
-
-[section:internals1 Utilities & Tools]
-[include series.qbk]
-[include fraction.qbk]
-[include rational.qbk]
-[include roots.qbk]
-[include roots_without_derivatives.qbk]
-[include minima.qbk]
-[include tuple.qbk]
-[endsect] [/section:internals1 Utilities & Tools]
-
-[section:internals2 Testing and Development]
-[include polynomial.qbk]
-[include minimax.qbk]
-[include relative_error.qbk] [/ uncertainty of floating-point calculations.]
-[include test_data.qbk]
-[endsect] [/section:internals2 Testing and Development]
-
-[endsect] [/section:toolkit Toolkit]
-
-[section:using_udt Use with User-Defined Floating-Point Types]
-[include concepts.qbk]
-[endsect] [/section:using_udt Use with User Defined Floating-Point Types]
-
-[include policy.qbk]
-
-[include performance.qbk]
-
-[section:backgrounders Backgrounders]
-[include implementation.qbk]
-[include error.qbk] [/relative error NOT handling]
-[include lanczos.qbk]
-[include remez.qbk]
-[include references.qbk]
-[endsect] [/section:backgrounders Backgrounders]
-
-[section:status Library Status]
-[section:history1 History and What's New]
-[history]
-[endsect]
-[include issues.qbk]
-[include credits.qbk]
-[/include test_HTML4_symbols.qbk]
-[/include test_Latin1_symbols.qbk]
-
-[endsect] [/section:status Status and Roadmap]
-
-[named_index function_name Function Index]
-[named_index class_name Class Index]
-[named_index typedef_name Typedef Index]
-[named_index macro_name Macro Index]
-[index]
-
-[/ math.qbk
- Copyright 2008, 2010, 2012 John Maddock and Paul A. Bristow.
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-]
-
-
-
Modified: sandbox/math/libs/math/doc/sf/pow.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/pow.qbk (original)
+++ sandbox/math/libs/math/doc/sf/pow.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -73,7 +73,7 @@
* In case of null base and null exponent, an __indeterminate_result_error
occurs since the result of this operation is indeterminate.
Those errors follow the
-[link math_toolkit.main_overview.error_handling
+[link math_toolkit.error_handling
general policies of error handling in Boost.Math].
The default overflow error policy is `throw_on_error`. A call like `pow<-2>(0)`
Modified: sandbox/math/libs/math/doc/sf/sinc.qbk
==============================================================================
--- sandbox/math/libs/math/doc/sf/sinc.qbk (original)
+++ sandbox/math/libs/math/doc/sf/sinc.qbk 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -55,7 +55,7 @@
U<T> sinc_pi(const U<T> x, const ``__Policy``&);
Computes
-[link math_toolkit.special.sinc.sinc_overview
+[link math_toolkit.sinc.sinc_overview
the Sinus Cardinal] of x:
sinc_pi(x) = sin(x) / x
@@ -89,7 +89,7 @@
U<T> sinhc_pi(const U<T> x, const ``__Policy``&);
Computes http://mathworld.wolfram.com/SinhcFunction.html
-[link math_toolkit.special.sinc.sinc_overview
+[link math_toolkit.sinc.sinc_overview
the Hyperbolic Sinus Cardinal] of x:
sinhc_pi(x) = sinh(x) / x
Modified: sandbox/math/libs/math/example/binomial_quiz_example.cpp
==============================================================================
--- sandbox/math/libs/math/example/binomial_quiz_example.cpp (original)
+++ sandbox/math/libs/math/example/binomial_quiz_example.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -345,13 +345,13 @@
//[discrete_quantile_real
/*`
Quantiles values are controlled by the
-[link math_toolkit.policy.pol_ref.discrete_quant_ref discrete quantile policy]
+[link math_toolkit.pol_ref.discrete_quant_ref discrete quantile policy]
chosen.
The default is `integer_round_outwards`,
so the lower quantile is rounded down, and the upper quantile is rounded up.
But we might believe that the real values tell us a little more - see
-[link math_toolkit.policy.pol_tutorial.understand_dis_quant Understanding Discrete Quantile Policy].
+[link math_toolkit.pol_tutorial.understand_dis_quant Understanding Discrete Quantile Policy].
We could control the policy for *all* distributions by
Modified: sandbox/math/libs/math/example/fft_sines_table.cpp
==============================================================================
--- sandbox/math/libs/math/example/fft_sines_table.cpp (original)
+++ sandbox/math/libs/math/example/fft_sines_table.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -188,7 +188,7 @@
std::cout << "Close file " << sines_name << " for output OK." << std::endl;
}
-//`The output file generated can be seen at [@..\sines.hpp]
+//`The output file generated can be seen at [@..\\sines.hpp]
//] [/fft_sines_table_example_1]
return EXIT_SUCCESS;
Modified: sandbox/math/libs/math/example/find_location_example.cpp
==============================================================================
--- sandbox/math/libs/math/example/find_location_example.cpp (original)
+++ sandbox/math/libs/math/example/find_location_example.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -133,7 +133,7 @@
l = find_location<normal>(z, p, sd, policy<domain_error<ignore_error> >());
/*`
If we want to use a probability that is the
-[link complements complement of our probability],
+[link math_toolkit.stat_tut.overview.complements complement of our probability],
we should not even think of writing `find_location<normal>(z, 1 - p, sd)`,
but, [link why_complements to avoid loss of accuracy], use the complement version.
*/
Modified: sandbox/math/libs/math/example/find_mean_and_sd_normal.cpp
==============================================================================
--- sandbox/math/libs/math/example/find_mean_and_sd_normal.cpp (original)
+++ sandbox/math/libs/math/example/find_mean_and_sd_normal.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -117,7 +117,7 @@
/*`
This calculation is generalized as the free function called
-[link math_toolkit.dist.dist_ref.dist_algorithms find_location].
+[link math_toolkit.dist_ref.dist_algorithms find_location].
To use this we will need to
*/
@@ -205,7 +205,7 @@
For other applications, where it is more difficult or expensive to make many observations,
the confidence intervals are depressingly wide.
-See [link math_toolkit.dist.stat_tut.weg.cs_eg.chi_sq_intervals Confidence Intervals on the standard deviation]
+See [link math_toolkit.stat_tut.weg.cs_eg.chi_sq_intervals Confidence Intervals on the standard deviation]
for a worked example
[@../../../example/chi_square_std_dev_test.cpp chi_square_std_dev_test.cpp]
of estimating these intervals.
@@ -262,7 +262,7 @@
Now we are getting really close, but to do the job properly,
we might need to use root finding method, for example the tools provided,
and used elsewhere, in the Math Toolkit, see
-[link math_toolkit.toolkit.internals1.roots2 Root Finding Without Derivatives].
+[link math_toolkit.internals1.roots2 Root Finding Without Derivatives].
But in this (normal) distribution case, we can and should be even smarter
and make a direct calculation.
Modified: sandbox/math/libs/math/example/find_root_example.cpp
==============================================================================
--- sandbox/math/libs/math/example/find_root_example.cpp (original)
+++ sandbox/math/libs/math/example/find_root_example.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -132,7 +132,7 @@
Now we are getting really close, but to do the job properly,
we could use root finding method, for example the tools provided, and used elsewhere,
in the Math Toolkit, see
-[link math_toolkit.toolkit.internals1.roots2 Root Finding Without Derivatives].
+[link math_toolkit.internals1.roots2 Root Finding Without Derivatives].
But in this normal distribution case, we could be even smarter and make a direct calculation.
*/
Modified: sandbox/math/libs/math/example/geometric_examples.cpp
==============================================================================
--- sandbox/math/libs/math/example/geometric_examples.cpp (original)
+++ sandbox/math/libs/math/example/geometric_examples.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -127,7 +127,7 @@
/*`Note that the value returned is not an integer:
if you want an integer result you should use either floor, round or ceil functions,
or use the policies mechanism.
-See [link math_toolkit.policy.pol_tutorial.understand_dis_quant
+See [link math_toolkit.pol_tutorial.understand_dis_quant
Understanding Quantiles of Discrete Distributions]
The geometric distribution is related to the negative binomial
Modified: sandbox/math/libs/math/example/negative_binomial_example1.cpp
==============================================================================
--- sandbox/math/libs/math/example/negative_binomial_example1.cpp (original)
+++ sandbox/math/libs/math/example/negative_binomial_example1.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -137,7 +137,7 @@
The random variable of interest is the number of houses
that must be visited to sell five candy bars,
so we substitute k = n - 5 into a negative_binomial(5, 0.4)
-and obtain the [link math.dist.pdf probability mass (density) function (pdf or pmf)]
+and obtain the [link math_toolkit.dist_ref.nmp.pdf probability mass (density) function (pdf or pmf)]
of the distribution of houses visited.
Obviously, the best possible case is that Pat makes sales on all the first five houses.
Modified: sandbox/math/libs/math/example/normal_misc_examples.cpp
==============================================================================
--- sandbox/math/libs/math/example/normal_misc_examples.cpp (original)
+++ sandbox/math/libs/math/example/normal_misc_examples.cpp 2013-05-09 05:04:20 EDT (Thu, 09 May 2013)
@@ -354,7 +354,7 @@
Now we are getting really close, but to do the job properly,
we could use root finding method, for example the tools provided, and used elsewhere,
in the Math Toolkit, see
-[link math_toolkit.toolkit.internals1.roots2 Root Finding Without Derivatives].
+[link math_toolkit.internals1.roots2 Root Finding Without Derivatives].
But in this normal distribution case, we could be even smarter and make a direct calculation.
*/
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