647 lines
23 KiB
Plaintext
647 lines
23 KiB
Plaintext
[article Document To Test Formatting
|
|
[quickbook 1.4]
|
|
[copyright 2007 John Maddock, Joel de Guzman, Eric Niebler and Matias Capeletto]
|
|
[purpose Test Formatting Document]
|
|
[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], [de Guzman, Joel], [Niebler, Eric], [Capeletto, Matias] ]
|
|
[category math]
|
|
[/last-revision $Date: 2007-05-07 10:21:52 +0100 (Mon, 07 May 2007) $]
|
|
]
|
|
|
|
[include HTML4_symbols.qbk]
|
|
|
|
[/ 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]'''⌉''']
|
|
|
|
[section Introduction]
|
|
|
|
This document is purely a test case to test out HTML and PDF generation and style.
|
|
|
|
This is some body text.
|
|
|
|
int main()
|
|
{
|
|
double d = 2.345;
|
|
return d;
|
|
}
|
|
|
|
We can count in Greek too: [alpha], [beta], [gamma].
|
|
|
|
Try some superscrips and subscripts: x[super 2], x[sub i][super 3], [alpha][super 2],
|
|
[beta][super [alpha]], [floor x], [floor [alpha]], [ceil a].
|
|
|
|
[endsect]
|
|
|
|
[section Code Blocks]
|
|
|
|
[section Embedded code]
|
|
|
|
These should be syntax highlighted:
|
|
|
|
#include <iostream>
|
|
|
|
int main()
|
|
{
|
|
// Sample code
|
|
std::cout << "Hello, World\n";
|
|
return 0;
|
|
}
|
|
|
|
[endsect]
|
|
|
|
[section Code With a Very Long Line]
|
|
|
|
template <class RealType> RealType inline foo(const RealType& a, const RealType& b, const RealType& c, const RealType& d, const RealType& e, const RealType& f, const RealType& g, const RealType& h){ return 0; }
|
|
|
|
[endsect]
|
|
|
|
[section Imported code and callouts]
|
|
|
|
[import stub.cpp]
|
|
|
|
Here's some code with left-placed callouts:
|
|
|
|
[class_]
|
|
|
|
And again with callouts placed exactly where we put them:
|
|
|
|
[foo_bar]
|
|
|
|
[endsect]
|
|
|
|
[section Larger example]
|
|
|
|
Now let's include a larger example, this may span several pages
|
|
and should not be chopped off half way through... some FO processors
|
|
get this wrong!
|
|
|
|
namespace boost{
|
|
|
|
template <class BidirectionalIterator>
|
|
class sub_match;
|
|
|
|
typedef sub_match<const char*> csub_match;
|
|
typedef sub_match<const wchar_t*> wcsub_match;
|
|
typedef sub_match<std::string::const_iterator> ssub_match;
|
|
typedef sub_match<std::wstring::const_iterator> wssub_match;
|
|
|
|
template <class BidirectionalIterator>
|
|
class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator>
|
|
{
|
|
public:
|
|
typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
|
|
typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
|
|
typedef BidirectionalIterator iterator;
|
|
|
|
bool matched;
|
|
|
|
difference_type length()const;
|
|
operator basic_string<value_type>()const;
|
|
basic_string<value_type> str()const;
|
|
|
|
int compare(const sub_match& s)const;
|
|
int compare(const basic_string<value_type>& s)const;
|
|
int compare(const value_type* s)const;
|
|
#ifdef BOOST_REGEX_MATCH_EXTRA
|
|
typedef implementation-private capture_sequence_type;
|
|
const capture_sequence_type& captures()const;
|
|
#endif
|
|
};
|
|
//
|
|
// comparisons to another sub_match:
|
|
//
|
|
template <class BidirectionalIterator>
|
|
bool operator == (const sub_match<BidirectionalIterator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator != (const sub_match<BidirectionalIterator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator < (const sub_match<BidirectionalIterator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator > (const sub_match<BidirectionalIterator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
|
|
|
|
//
|
|
// comparisons to a basic_string:
|
|
//
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator == (const sub_match<BidirectionalIterator>& lhs,
|
|
const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator != (const sub_match<BidirectionalIterator>& lhs,
|
|
const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator < (const sub_match<BidirectionalIterator>& lhs,
|
|
const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator > (const sub_match<BidirectionalIterator>& lhs,
|
|
const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
|
|
const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& rhs);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
|
|
const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& rhs);
|
|
|
|
//
|
|
// comparisons to a pointer to a character array:
|
|
//
|
|
template <class BidirectionalIterator>
|
|
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
|
|
template <class BidirectionalIterator>
|
|
bool operator == (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator != (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator < (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator > (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
|
|
|
|
//
|
|
// comparisons to a single character:
|
|
//
|
|
template <class BidirectionalIterator>
|
|
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
|
|
const sub_match<BidirectionalIterator>& rhs);
|
|
|
|
template <class BidirectionalIterator>
|
|
bool operator == (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator != (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator < (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator > (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
|
|
template <class BidirectionalIterator>
|
|
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
|
|
//
|
|
// addition operators:
|
|
//
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
|
|
operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& s,
|
|
const sub_match<BidirectionalIterator>& m);
|
|
template <class BidirectionalIterator, class traits, class Allocator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
|
|
operator + (const sub_match<BidirectionalIterator>& m,
|
|
const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
|
|
traits,
|
|
Allocator>& s);
|
|
template <class BidirectionalIterator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
|
|
operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
|
|
const sub_match<BidirectionalIterator>& m);
|
|
template <class BidirectionalIterator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
|
|
operator + (const sub_match<BidirectionalIterator>& m,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const * s);
|
|
template <class BidirectionalIterator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
|
|
operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
|
|
const sub_match<BidirectionalIterator>& m);
|
|
template <class BidirectionalIterator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
|
|
operator + (const sub_match<BidirectionalIterator>& m,
|
|
typename iterator_traits<BidirectionalIterator>::value_type const& s);
|
|
template <class BidirectionalIterator>
|
|
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
|
|
operator + (const sub_match<BidirectionalIterator>& m1,
|
|
const sub_match<BidirectionalIterator>& m2);
|
|
|
|
//
|
|
// stream inserter:
|
|
//
|
|
template <class charT, class traits, class BidirectionalIterator>
|
|
basic_ostream<charT, traits>&
|
|
operator << (basic_ostream<charT, traits>& os,
|
|
const sub_match<BidirectionalIterator>& m);
|
|
|
|
} // namespace boost
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|
|
|
|
[section Basic Formatting]
|
|
|
|
[section Font Styles]
|
|
|
|
Here we go with some inline formatting:
|
|
['italic], [*bold], [_underline], [^teletype], [-strikethrough],
|
|
we can combine styles as well: ['[*bold italic]], [_[^teletype with underline]].
|
|
|
|
[endsect]
|
|
|
|
[section Replaceable Text]
|
|
|
|
Text that is intended to be user-replaceable is [~rendered like this].
|
|
|
|
[endsect]
|
|
|
|
[section Quotations]
|
|
|
|
Here we go: ["A question that sometimes drives me hazy: am I or are the others crazy?]--Einstein
|
|
|
|
Note the proper left and right quote marks. Also, while you can simply use ordinary quote marks like "quoted", our quotation, above, will generate correct DocBook quotations (e.g. <quote>quoted</quote>).
|
|
|
|
Like all phrase elements, quotations may be nested. Example:
|
|
|
|
["Here's the rule for bargains: ["Do other men, for they would do you.] That's
|
|
the true business precept.]
|
|
|
|
[endsect]
|
|
|
|
[section Inline Code]
|
|
|
|
This text has inlined code `int main() { return 0; }` in it.
|
|
The code should be syntax highlighted.
|
|
|
|
[endsect]
|
|
|
|
[section Links]
|
|
|
|
Try this: [@http://www.boost.org this is [*boost's] website....] it should
|
|
be visible as a link.
|
|
|
|
This is [@../../../boost/math/distributions.hpp a link to a header file (boost/math/distributions.hpp)],
|
|
it should be rewritable and point to the website when built as a PDF.
|
|
|
|
This is [@boost:libs/regex/index.html a link to another library's documentation (Boost.Regex)], using the boost: protocol,
|
|
it should be rewritten to point to the website when building a PDF.
|
|
|
|
This is [@boost:/libs/regex/index.html a link to another library's documentation (Boost.Regex)], using the boost:/ protocol,
|
|
it should be rewritten to point to the website when building a PDF.
|
|
|
|
This is [@../weighted_tail_quantile.hpp a relative link to a header file within the test source],
|
|
it should be rewritten to point to the website when building a PDF.
|
|
Although it might be on the website yet.
|
|
|
|
[endsect]
|
|
|
|
[section Footnotes]
|
|
|
|
Here's one [footnote A sample footnote].
|
|
|
|
And here's another [footnote Another sample footnote].
|
|
|
|
[endsect]
|
|
|
|
[section Blockquote]
|
|
|
|
Lets indent the next paragraph:
|
|
|
|
[:Here we go!!!]
|
|
|
|
[endsect]
|
|
|
|
[section Headings]
|
|
|
|
Now try rendering some heading styles:
|
|
|
|
[h1 Heading 1]
|
|
|
|
[h2 Heading 2]
|
|
|
|
[h3 Heading 3]
|
|
|
|
[h4 Heading 4]
|
|
|
|
[h5 Heading 5]
|
|
|
|
[h6 Heading 6]
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|
|
|
|
[section Blurbs]
|
|
|
|
[section Preformatted text]
|
|
|
|
Here's some sample program output:
|
|
|
|
[pre
|
|
'''F test for equal standard deviations
|
|
____________________________________
|
|
|
|
Sample 1:
|
|
Number of Observations = 240
|
|
Sample Standard Deviation = 65.549
|
|
|
|
Sample 2:
|
|
Number of Observations = 240
|
|
Sample Standard Deviation = 61.854
|
|
|
|
Test Statistic = 1.123
|
|
|
|
CDF of test statistic: = 8.148e-001
|
|
Upper Critical Value at alpha: = 1.238e+000
|
|
Upper Critical Value at alpha/2: = 1.289e+000
|
|
Lower Critical Value at alpha: = 8.080e-001
|
|
Lower Critical Value at alpha/2: = 7.756e-001
|
|
|
|
Results for Alternative Hypothesis and alpha = 0.0500
|
|
|
|
Alternative Hypothesis Conclusion
|
|
Standard deviations are unequal (two sided test) REJECTED
|
|
Standard deviation 1 is less than standard deviation 2 REJECTED
|
|
Standard deviation 1 is greater than standard deviation 2 REJECTED'''
|
|
]
|
|
|
|
[endsect]
|
|
|
|
[section Admonishments]
|
|
|
|
There are four admonishments supported by Docbook XML:
|
|
|
|
[note This is a note]
|
|
|
|
[tip This is a tip]
|
|
|
|
[important This is important]
|
|
|
|
[caution This is a caution]
|
|
|
|
[warning This is a warning
|
|
|
|
They can contain more than one paragraph.
|
|
]
|
|
|
|
[endsect]
|
|
|
|
[section Blurbs]
|
|
|
|
[blurb [*An eye catching advertisement or note...]
|
|
|
|
These should be rendered in a manner similar to admonishments.
|
|
|
|
They can contain more than one paragraph.
|
|
]
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|
|
|
|
[section Lists and Tables]
|
|
|
|
[section Lists]
|
|
|
|
A numbered list:
|
|
|
|
# One
|
|
# Two
|
|
# Three
|
|
# Three.a
|
|
# Three.b
|
|
# Three.c
|
|
# Four
|
|
# Four.a
|
|
# Four.a.i
|
|
# Four.a.ii
|
|
# Five
|
|
|
|
An unordered list:
|
|
|
|
* First
|
|
* Second
|
|
* Third
|
|
|
|
A mixture of the two:
|
|
|
|
# 1
|
|
* 1.a
|
|
# 1.a.1
|
|
# 1.a.2
|
|
* 1.b
|
|
# 2
|
|
* 2.a
|
|
* 2.b
|
|
# 2.b.1
|
|
# 2.b.2
|
|
* 2.b.2.a
|
|
* 2.b.2.b
|
|
|
|
|
|
[endsect]
|
|
|
|
[section Variable Lists]
|
|
|
|
[variablelist A Variable List
|
|
[[term 1] [The definition of term 1]]
|
|
[[term 2] [The definition of term 2]]
|
|
[[term 3] [The definition of term 3]]
|
|
]
|
|
|
|
[endsect]
|
|
|
|
[section Tables]
|
|
|
|
Here's a big table with code and other tricky things:
|
|
|
|
[table Notes on the Implementation of the Beta Distribution
|
|
[[Function][Implementation Notes]]
|
|
[[pdf]
|
|
[f(x;[alpha],[beta]) = x[super[alpha] - 1] (1 - x)[super[beta] -1] / B([alpha], [beta])
|
|
|
|
Implemented using ibeta_derivative(a, b, x).]]
|
|
|
|
[[cdf][Using the incomplete beta function ibeta(a, b, x)]]
|
|
[[cdf complement][ibetac(a, b, x)]]
|
|
[[quantile][Using the inverse incomplete beta function ibeta_inv(a, b, p)]]
|
|
[[quantile from the complement][ibetac_inv(a, b, q)]]
|
|
[[mean][`a/(a+b)`]]
|
|
[[variance][`a * b / (a+b)^2 * (a + b + 1)`]]
|
|
[[mode][`(a-1) / (a + b + 2)`]]
|
|
[[skewness][`2 (b-a) sqrt(a+b+1)/(a+b+2) * sqrt(a * b)`]]
|
|
[[kurtosis excess][ [$images/beta_dist_kurtosis.png] ]]
|
|
[[kurtosis][`kurtosis + 3`]]
|
|
[[parameter estimation][ ]]
|
|
[[alpha
|
|
|
|
from mean and variance][`mean * (( (mean * (1 - mean)) / variance)- 1)`]]
|
|
[[beta
|
|
|
|
from mean and variance][`(1 - mean) * (((mean * (1 - mean)) /variance)-1)`]]
|
|
[[The member functions `estimate_alpha` and `estimate_beta`
|
|
|
|
from cdf and probability x
|
|
|
|
and *either* `alpha` or `beta`]
|
|
[Implemented in terms of the inverse incomplete beta functions
|
|
|
|
ibeta_inva, and ibeta_invb respectively.]]
|
|
[[`estimate_alpha`][`ibeta_inva(beta, x, probability)`]]
|
|
[[`estimate_beta`][`ibeta_invb(alpha, x, probability)`]]
|
|
]
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|
|
|
|
[section Images]
|
|
|
|
These are tricky enough that they warrent their own section.
|
|
|
|
Let's start with a PNG file that's set to 120dpi, it should render at
|
|
a sensible size in both html and PDF forms. It should print OK too!
|
|
|
|
[$images/digamma3.png]
|
|
|
|
Now try again with a sample SVG image:
|
|
|
|
[$images/open_clipart_library_logo.svg]
|
|
|
|
|
|
[endsect]
|
|
|
|
[section Equations]
|
|
|
|
This page is largely to test equation handling in various browsers, unfortunately none of this works as well as it should (or at all?)
|
|
in Internet Explorer....
|
|
|
|
This equation is formatted from Latex text:
|
|
|
|
'''<inlinemediaobject><textobject role="tex">ax^2 + bx + c = 0</textobject></inlinemediaobject>'''
|
|
|
|
This equation is formed from MathML:
|
|
|
|
'''<inlinemediaobject><textobject role="MathML"><?dbhtml-include href="test.mml"?></textobject></inlinemediaobject>'''
|
|
|
|
This equation is SVG:
|
|
|
|
'''<inlinemediaobject><imageobject><imagedata format="SVG" fileref="../test.svg"></imagedata></imageobject></inlinemediaobject>'''
|
|
|
|
|
|
[endsect]
|
|
|
|
[include test_HTML4_symbols.qbk]
|
|
|
|
[include remez.qbk]
|
|
|
|
[section:array Array Example Boostbook XML Documentation]
|
|
[xinclude array.xml]
|
|
[xinclude array1.xml]
|
|
[xinclude array2.xml]
|
|
[xinclude array3.xml]
|
|
[xinclude array4.xml]
|
|
[endsect]
|
|
|
|
[section:accumulators Accumulators Example Doxygen Documentation]
|
|
[xinclude statsdoc.xml]
|
|
[endsect]
|
|
|
|
|
|
|