|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r56098 - in sandbox/itl: boost/itl boost/itl/detail libs/itl/doc libs/itl/example/interval_container_ libs/itl/example/man_power_ libs/itl/example/partys_height_average_ libs/itl/example/partys_tallest_guests_ libs/itl/example/user_groups_ libs/itl_xt/example/amount_cube_
From: afojgo_at_[hidden]
Date: 2009-09-07 20:09:55
Author: jofaber
Date: 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
New Revision: 56098
URL: http://svn.boost.org/trac/boost/changeset/56098
Log:
Added documentation. Checked for typos.
Stable {msvc-8.0r+d, 9.0r+d; gcc-3.4.4r+d, 4.1.0r+d, 4.3.2r+d, inspected}
Text files modified:
sandbox/itl/boost/itl/detail/notate.hpp | 2 +-
sandbox/itl/boost/itl/interval_base_map.hpp | 4 ++--
sandbox/itl/boost/itl/interval_base_set.hpp | 4 ++--
sandbox/itl/boost/itl/map.hpp | 2 +-
sandbox/itl/boost/itl/predicates.hpp | 2 +-
sandbox/itl/boost/itl/split_interval_set.hpp | 2 +-
sandbox/itl/libs/itl/doc/acknowledgments.qbk | 2 +-
sandbox/itl/libs/itl/doc/concepts.qbk | 20 ++++++++++----------
sandbox/itl/libs/itl/doc/examples.qbk | 16 ++++++++--------
sandbox/itl/libs/itl/doc/functions.qbk | 18 +++++++++---------
sandbox/itl/libs/itl/doc/functions_addition.qbk | 12 ++++++------
sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk | 2 +-
sandbox/itl/libs/itl/doc/functions_containedness.qbk | 2 +-
sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk | 4 ++--
sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk | 6 +++---
sandbox/itl/libs/itl/doc/functions_erasure.qbk | 6 +++---
sandbox/itl/libs/itl/doc/functions_insertion.qbk | 2 +-
sandbox/itl/libs/itl/doc/functions_intersection.qbk | 6 +++---
sandbox/itl/libs/itl/doc/functions_iterator_related.qbk | 4 ++--
sandbox/itl/libs/itl/doc/functions_range.qbk | 4 ++--
sandbox/itl/libs/itl/doc/functions_selection.qbk | 2 +-
sandbox/itl/libs/itl/doc/functions_size.qbk | 2 +-
sandbox/itl/libs/itl/doc/functions_streaming.qbk | 2 +-
sandbox/itl/libs/itl/doc/functions_subtraction.qbk | 4 ++--
sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk | 6 +++---
sandbox/itl/libs/itl/doc/implementation.qbk | 18 +++++++++---------
sandbox/itl/libs/itl/doc/interface.qbk | 14 +++++++-------
sandbox/itl/libs/itl/doc/semantics.qbk | 16 ++++++++--------
sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp | 4 ++--
sandbox/itl/libs/itl/example/man_power_/man_power.cpp | 10 +++++-----
sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp | 2 +-
sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp | 2 +-
sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp | 8 ++++----
sandbox/itl/libs/itl_xt/example/amount_cube_/amount_cube.cpp | 2 +-
34 files changed, 106 insertions(+), 106 deletions(-)
Modified: sandbox/itl/boost/itl/detail/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/notate.hpp (original)
+++ sandbox/itl/boost/itl/detail/notate.hpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -21,7 +21,7 @@
#define ITL_FORALL_THIS(iter) for(iterator iter=begin(); (iter)!=end(); (iter)++)
#define ITL_const_FORALL_THIS(iter) for(const_iterator iter=this->begin(); (iter)!=this->end(); (iter)++)
-// Plain old array iteration (assuming memberfunction VecT::size()!)
+// Plain old array iteration (assuming member function VecT::size()!)
#define ITL_FORALL_VEC(idx, vec) for(int idx=0; idx<vec.size(); idx++)
namespace boost{namespace itl
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -266,7 +266,7 @@
size_type size()const { return cardinality(); }
/** The length of the interval container which is the sum of
- interval lenghts */
+ interval lengths */
difference_type length()const;
/** Number of intervals which is also the size of the
@@ -1154,7 +1154,7 @@
if( it_->first.touches(next_->first)
&& it_->second == next_->second )
{
- iterator fst_mem = it_; // hold the fist member
+ iterator fst_mem = it_; // hold the first member
// Go on while touching members are found
it_++; next_++;
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -206,7 +206,7 @@
/** An interval set's size is it's cardinality */
size_type size()const { return cardinality(); }
- /** The length of the interval container which is the sum of interval lenghts */
+ /** The length of the interval container which is the sum of interval lengths */
difference_type length()const;
/** Number of intervals which is also the size of the iteration over the object */
@@ -636,7 +636,7 @@
{
if( (*it_).touches(*next_) )
{
- iterator fst_mem = it_; // hold the fist member
+ iterator fst_mem = it_; // hold the first member
// Go on while touching members are found
it_++; next_++;
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -305,7 +305,7 @@
}
//==========================================================================
- //= Representaion
+ //= Representation
//==========================================================================
/** Represent this map as string */
Modified: sandbox/itl/boost/itl/predicates.hpp
==============================================================================
--- sandbox/itl/boost/itl/predicates.hpp (original)
+++ sandbox/itl/boost/itl/predicates.hpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -126,7 +126,7 @@
struct super_sub_set : public relation<Type,Type>
{
/// Apply the superset relation.
- /** <tt>containes(super, sub)</tt> is true if <tt>super</tt> containes
+ /** <tt>contains(super, sub)</tt> is true if <tt>super</tt> containes
<tt>sub</tt> */
bool operator()(const Type& super, const Type& sub)const
{
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -319,7 +319,7 @@
/** Equality on discrete interval sets. Discrete interval sets are equal, if
their elements are equal and their fragmentation is equal.
NOTE: This is not inline with the mathematical view.
- We have a distiction between 'element equality' and 'lexicographical
+ We have a distinction between 'element equality' and 'lexicographical
equality'. */
template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
inline bool operator == (const split_interval_set<DomainT,Compare,Interval,Alloc>& lhs,
Modified: sandbox/itl/libs/itl/doc/acknowledgments.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/acknowledgments.qbk (original)
+++ sandbox/itl/libs/itl/doc/acknowledgments.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -11,7 +11,7 @@
I would like to thank CEO Hermann Steppe and Chief Developer Peter Wuttke
of Cortex Software GmbH for their friendly support of my work on the
Itl and their permission to release the library as open source.
-For her genuine intersest in my work and many creative and
+For her genuine interest in my work and many creative and
uplifting talks I want to thank my colleague Axinja Ott who
contributed a lot to the success of the project.
Modified: sandbox/itl/libs/itl/doc/concepts.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/concepts.qbk (original)
+++ sandbox/itl/libs/itl/doc/concepts.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -11,7 +11,7 @@
[section Naming]
The *itl* is about sets and maps and a useful
-implementation of sets and maps usings intervals.
+implementation of sets and maps using intervals.
In the documentation of the *itl* the different
set and map types are grouped in various ways.
In order to distinguish those groups we use
@@ -25,7 +25,7 @@
concepts themselves but the set of types
that implement those concepts in the *itl*.
The main groups ['*itl containers*] can be
-devided in are summarized in the next table:
+divided in are summarized in the next table:
[table
[[] [] [] ]
@@ -163,7 +163,7 @@
[link boost_itl.semantics.sets semantics of itl Sets] and
[link boost_itl.semantics.maps Maps].
These semantical differences are mainly based on the implementation
-of the pivotal memberfunctions `add` and `subtract` for elements
+of the pivotal member functions `add` and `subtract` for elements
and intervals that again serve for implementing
`operator +=` and `operator -=`.
[endsect][/ Abstract Sets and Maps]
@@ -217,7 +217,7 @@
[table
[[] [`add<Combine<CodomainT> >((k,x))`] [`subtract<inverse<Combine<CodomainT> >::type>((k,x))`]]
[[Instance] [`add<inplace_plus<int> >((k,x))`] [`subtract<inplace_minus<int> >((k,x))`]]
-[[Inversion][adds `x` on overlap. This inverts a preceeding `subtract` of `x` on `k`][subtracts `x` on overlap. This inverts a preceeding `add` of `x` on `k`]]
+[[Inversion][adds `x` on overlap. This inverts a preceding `subtract` of `x` on `k`][subtracts `x` on overlap. This inverts a preceding `add` of `x` on `k`]]
]
@@ -236,8 +236,8 @@
the `Combine` functor is intended to be an invariant
of __itv_bmap_s__
template instance to avoid, that clients
-spoil the aggregation by accidently calling
-variing aggregation functors.
+spoil the aggregation by accidentally calling
+varying aggregation functors.
But you could instantiate an __itv_map__ to have
`insert/erase` semantics this way:
``
@@ -269,7 +269,7 @@
In the itl we call ['*neutral elements*] `neutrons` and all values
that [*are not] `neutrons` we call `protons`.
-In the pseudo code snipplets below `0` will be used to denote
+In the pseudo code snippets below `0` will be used to denote
`neutrons`, which can be
different objects like `const double 0.0`, empty sets, empty strings,
null-vectors etc. dependent of the instance type for parameter `CodomainT`.
@@ -345,7 +345,7 @@
Map traits are a late extension to the *itl*. Interval maps have
been used for a couple of years
in a variety of applications at Cortex Software GmbH
-with an implementaion that resembled the default trait.
+with an implementation that resembled the default trait.
Only the deeper analysis of the itl's ['*aggregating Map's
concept*] in the course of preparation of the library for boost
led to the introduction of map Traits.
@@ -353,7 +353,7 @@
[h5 Add-Subtract Antinomy in Aggregating Maps]
Constitutional for the absorber/enricher propery is a little
-antinomie.
+antinomy.
We can insert value pairs to the map by ['*adding*] them to the map
via operations `add, +=` or `+`:
@@ -458,7 +458,7 @@
(k,0) key k carries 0 : Pair (k,v) has been dealt with resulting in v=0
]
-Sometimes this subtle distiction is needed. Then a __penricher__
+Sometimes this subtle distinction is needed. Then a __penricher__
is the right choice. Also, If we want to give two `itl::Maps`
a common set of keys in order to, say, iterate synchronously
over both maps, we need /enrichers/.
Modified: sandbox/itl/libs/itl/doc/examples.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/examples.qbk (original)
+++ sandbox/itl/libs/itl/doc/examples.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -157,7 +157,7 @@
In the example `partys_height_average.cpp` we compute yet another aggregation:
The average height of guests. This is done by defining a `class counted_sum`
-that sums up heights and counts the numer of guests
+that sums up heights and counts the number of guests
via an `operator +=`.
Based on the `operator +=` we can aggregate counted sums on addition
@@ -181,15 +181,15 @@
defined classes will work fine, if they only implement
`operator +=`. Only if any of the `operator`s `-=` or `-`
is called on the interval_map, the user defined class has to
-implement it's own `operator -=` to provide the subractive
-aggreagtion on overlap.
+implement it's own `operator -=` to provide the subtractive
+aggregation on overlap.
[endsect]
[section:partys_tallest_guests Party's tallest guests]
-Defining `operator +=` (and `-=`) is proably the most important
+Defining `operator +=` (and `-=`) is probably the most important
method to implement arbitrary kinds of user defined aggregations.
An alternative way to choose a desired aggregation is to
instantiate an interval_map class template with an
@@ -251,16 +251,16 @@
Example [*user groups] shows the availability of set operations
on __itv_maps__.
-In the example there is a user group `med_users` of a hospial staff
+In the example there is a user group `med_users` of a hospital staff
that has the authorisation to handle medical data of patients.
-User group `admin_users` has access to aministrative data like
-health inshurance and financial data.
+User group `admin_users` has access to administrative data like
+health insurance and financial data.
The membership for each user in one of the user groups has a time
interval of validity. The group membership begins and ends.
* Using a union operation `+` we can have an overview over the unified
- user groups and the memebership dates of employees.
+ user groups and the membership dates of employees.
* Computing an intersection `&` shows who is member of both med_users
and admin_users at what times.
Modified: sandbox/itl/libs/itl/doc/functions.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -11,7 +11,7 @@
Section [link boost_itl.interface.function_synopsis Function Synopsis]
above gave an overview of the polymorphic functions of the itl.
-This is what you will need to find the desired possibilites to combine itl
+This is what you will need to find the desired possibilities to combine itl
functions and objects most of the time.
The functions and overloads that you intuitively expect
should be provided, so you won't need to refer to the documentation very often.
@@ -19,8 +19,8 @@
If you are interested
* in the ['*specific design of the function overloads*],
-* in ['*complexity charactersistics*] for certain overloads
-* or if the complier ['*refuses to resolve*] specific function application you want to use,
+* in ['*complexity characteristics*] for certain overloads
+* or if the compiler ['*refuses to resolve*] specific function application you want to use,
refer to this section that describes the polymorphic function families of the itl
in detail.
@@ -42,7 +42,7 @@
Many of the *itl's* functions are overloaded for
elements, segments, element and interval containers.
But not all type combinations are provided. Also
-the admissable type combinations are different for
+the admissible type combinations are different for
different functions and operations.
To concisely represent the overloads that can be
used we use synoptical tables that contain
@@ -68,16 +68,16 @@
of the tables.
The second argument type `P` is displayed as column headers
of the tables.
-If a combination of `T` and `P` is admissable the related
+If a combination of `T` and `P` is admissible the related
cell of the table is non empty.
It displays the result type of the operation. In this example
the result type is always equal to the first argument.
-The possible types that can be instaniated for `T` and `P`
+The possible types that can be instantiated for `T` and `P`
are element, interval and container types abbreviated by
placeholders that are defined
[link boost_itl.interface.function_synopsis here]
-and can be summerized as
+and can be summarized as
__s : element set, __S : interval sets, __e : elements, __i : intervals\n
__m:element map, __M:interval maps, __b:element-value pairs, __p:interval-value pairs
@@ -237,9 +237,9 @@
For `Sets`, the ['*key types*] defined for maps
are identical with the set types themselves.
-So the distiction between the function groups
+So the distinction between the function groups
['*selection by key*] and ['*generalized intersection*]
-fall thogether in the well known ['*set intersection*].
+fall together in the well known ['*set intersection*].
[endsect][/ Key Types]
Modified: sandbox/itl/libs/itl/doc/functions_addition.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_addition.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_addition.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -53,7 +53,7 @@
[section Member functions][/ Addition]
-The admissable combinations of types for memberfunction
+The admissible combinations of types for member function
`T& T::add(const P&)` can be summarized in the
['*overload table*] below:
@@ -85,7 +85,7 @@
[section Inplace operators]
The possible overloads of inplace `T& operator += (T&, const P&)`
-are given by two tables, that show admissable combinations of types.
+are given by two tables, that show admissible combinations of types.
Row types show instantiations of argument type `T`. Columns types
show show instantiations of argument type `P`. If a combination
of argument types is possible, the related table cell contains
@@ -110,10 +110,10 @@
m | m m M | M M M
``
-For the definition of admissable overloads
+For the definition of admissible overloads
we separate /element containers/ from /interval containers/.
Within each group all combinations of types are supported
-for an operation, that are inline with the *itl's*
+for an operation, that are in line with the *itl's*
design and the sets of laws, that establish the *itl's*
[link boost_itl.semantics semantics].
@@ -143,7 +143,7 @@
domain elements (__e) or element value pairs (__b)
is faster than a combination of intervals (__i) or
interval value pairs (__p) which in turn is faster than
-the combinatin of element or interval containers.
+the combination of element or interval containers.
The next table shows /time complexities/ of addition for
*itl's* element containers.
@@ -188,7 +188,7 @@
[section Infix operators]
-The admissable type combinations for infix `operator +`
+The admissible type combinations for infix `operator +`
are defined by the overload tables below.
``
Modified: sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -43,7 +43,7 @@
[[`void T::swap(T& src)`] [Swaps the content containers `*this` and `src` in constant time. ] ]
]
-In addition we have overloads of constructors and assingnment operators
+In addition we have overloads of constructors and assignment operators
for itl container types.
``
// overload tables for constructors
Modified: sandbox/itl/libs/itl/doc/functions_containedness.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_containedness.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_containedness.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -110,7 +110,7 @@
If both containers have same iterative_sizes so that /m = n/
we have the worst case ( __Onlgn__ ).
There is an alternative implementation that has a ['*linear*]
-complextity of __Onpm__.
+complexity of __Onpm__.
The loglinear implementation has been chosen,
because it can be faster, if the container argument is
small. In this case the loglinear implementation approaches
Modified: sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -30,9 +30,9 @@
[[`domain_type T::lower()const`] [__i __S __M][`x.lower()` returns the lower bound of an interval or interval container `x`.] ]
[[`domain_type T::upper()const`] [__i __S __M][`x.upper()` returns the upper bound of an interval or interval container `x`.] ]
[[`domain_type T::first()const`] [__i __S __M][`x.first()` returns the first element of an interval or interval container `x`.
- `T::first()` ist defined for a non continuous `domain_type` only.] ]
+ `T::first()` is defined for a non continuous `domain_type` only.] ]
[[`domain_type T::last()const`] [__i __S __M][`x.last()` returns the last element of an interval or interval container `x`.
- `T::last()` ist defined for a non continuous `domain_type` only.] ]
+ `T::last()` is defined for a non continuous `domain_type` only.] ]
]
``
Modified: sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -69,7 +69,7 @@
it's ['*segmentation*].
So these equality and compare operations can be applied within
-interval container types. The admissable type combinations are summarized
+interval container types. The admissible type combinations are summarized
in the next overload table.
``
@@ -91,7 +91,7 @@
For element containers lexicographical equality and
sequential element equality are identical.
-The *complexity* of sequential element comarison functions
+The *complexity* of sequential element comparison functions
is ['*linear*] in the `iterative_size` of the larger
container.
@@ -99,7 +99,7 @@
[section Protonic Equality][/ Equivalences and Orderings]
-['*Protonic Equality*] is an equality predicate that is availabe
+['*Protonic Equality*] is an equality predicate that is available
for __itl_maps__ and __itv_maps__. It yields true, if
two maps are sequential element equal except for value
pairs whose associated values are neutral elements.
Modified: sandbox/itl/libs/itl/doc/functions_erasure.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_erasure.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_erasure.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -51,7 +51,7 @@
M | M M
``
-The next table contains complexity characteristics for memberfunction `erase`.
+The next table contains complexity characteristics for member function `erase`.
[table Time Complexity for member function erase on itl containers
[[`T& T::erase(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
@@ -149,8 +149,8 @@
]
Erasing by a single iterator need only ['*amortized constant time*].
-Erasing via a range of iterators `[fist, past)` is of ['*linear time*]
-in the number `k` of iterators in range `[fist, past)`.
+Erasing via a range of iterators `[first, past)` is of ['*linear time*]
+in the number `k` of iterators in range `[first, past)`.
[endsect][/ Erasure by Iterators]
Modified: sandbox/itl/libs/itl/doc/functions_insertion.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_insertion.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_insertion.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -115,7 +115,7 @@
M | M
``
-[table Time Complexity for memberfunction `set`
+[table Time Complexity for member function `set`
[[`T& set(T&, const P&)`] [domain_mapping_type] [interval_mapping_type] ]
[[itl::map] [__Olgn__] [ ] ]
[[interval_maps] [] [__a_Olgn__] ]
Modified: sandbox/itl/libs/itl/doc/functions_intersection.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_intersection.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_intersection.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -53,7 +53,7 @@
[section Member functions][/ Intersection]
-The admissable combinations of types for memberfunction
+The admissible combinations of types for member function
`void T::add_intersection(T&, const P&)` can be summarized in the
['*overload table*] below.
Compared to other overload tables, placements of function arguments are
@@ -89,7 +89,7 @@
[section Inplace operators][/ Intersection]
-The overload tables below are giving admissable
+The overload tables below are giving admissible
type combinations for the intersection `operator &=`.
As for the overload patterns of /subtraction/
intersections are possible within Sets and Maps
@@ -194,7 +194,7 @@
['*selection by key object] functionality.
``
-// (Generealized) intersection
+// (Generalized) intersection
& | e b s m & | e i b p S1 S2 S3 M1 M3
---+-------- ---+---------------------------
e | s e | S1 S2 S3
Modified: sandbox/itl/libs/itl/doc/functions_iterator_related.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_iterator_related.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_iterator_related.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -43,10 +43,10 @@
``
]
[Returns a range `[first, past)` of iterators to all elements of the container
- that compare neighter less than nor greater than `key_value key`.
+ that compare neither less than nor greater than `key_value key`.
For element containers __itl_set__ and __itl_map__, `equal_range`
contains at most one iterator pointing the element equal to `key`,
- if it exitsts.
+ if it exists.
For interval containers `equal_range` contains iterators to all
intervals that overlap interval `key`.
Modified: sandbox/itl/libs/itl/doc/functions_range.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_range.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_range.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -30,9 +30,9 @@
[[`domain_type T::lower()const`] [__i __S __M][`x.lower()` returns the lower bound of an interval or interval container `x`.] ]
[[`domain_type T::upper()const`] [__i __S __M][`x.upper()` returns the upper bound of an interval or interval container `x`.] ]
[[`domain_type T::first()const`] [__i __S __M][`x.first()` returns the first element of an interval or interval container `x`.
- `T::first()` ist defined for a non continuous `domain_type` only.] ]
+ `T::first()` is defined for a non continuous `domain_type` only.] ]
[[`domain_type T::last()const`] [__i __S __M][`x.last()` returns the last element of an interval or interval container `x`.
- `T::last()` ist defined for a non continuous `domain_type` only.] ]
+ `T::last()` is defined for a non continuous `domain_type` only.] ]
]
``
Modified: sandbox/itl/libs/itl/doc/functions_selection.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_selection.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_selection.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -18,7 +18,7 @@
[[`codomain_type operator() (const domain_type&)const`] [ ] [__Olgn__] [ ] [__Olgn__] [`is_total<T>::value`] ]
]
-* All time *complexities* are ['*logarithmic*] in the containers `iteravive_size()`.
+* All time *complexities* are ['*logarithmic*] in the containers `iterative_size()`.
* `operator()` is available for total maps only.
Modified: sandbox/itl/libs/itl/doc/functions_size.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_size.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_size.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -34,7 +34,7 @@
[[['*Size*]] [Types] [Description] ]
[[`size_t T::interval_count()const`] [__S __M] [The number of intervals of an interval container.] ]
[[`size_t T::iterative_size()const`] [__S __M __s __m] [The number of objects in an itl container that can be iterated over.] ]
-[[`difference_type T::length()const`] [__i __S __M] [The length of an interval or the sum of lenghts of
+[[`difference_type T::length()const`] [__i __S __M] [The length of an interval or the sum of lengths of
an interval container's intervals, that's `domain_type` has a `difference_type`.] ]
[[`size_type T::cardinality()const`][__i __S __M __s __m] [The number of elements of an interval or a container.
For continuous data types cardinality can be /infinite/.] ]
Modified: sandbox/itl/libs/itl/doc/functions_streaming.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_streaming.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_streaming.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -17,7 +17,7 @@
]
[table
-[[['*Streaming, conversion*]] [Desctription] ]
+[[['*Streaming, conversion*]] [Description] ]
[[`std::basic_ostream operator << (basic_ostream&, const T&)`]
[Serializes the argument of type T to an output stream] ]
[[`std::string T::as_string()`] [Returns a string representation of the object of type `T`]]
Modified: sandbox/itl/libs/itl/doc/functions_subtraction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_subtraction.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_subtraction.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -47,7 +47,7 @@
[section Member functions][/ Subtraction]
-The admissable combinations of types for memberfunction
+The admissible combinations of types for member function
`T& T::add(const P&)` can be summarized in the
['*overload table*] below:
@@ -145,7 +145,7 @@
[section Infix operators][/-Subtraction]
-The admissable overloads for the infix
+The admissible overloads for the infix
/subtraction/ `operator -`
which is a non commutative
operation
Modified: sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -37,7 +37,7 @@
[section Member functions][/ Symmetric difference]
/Symmetric difference/ is implemented on interval containers
-by the memberfunction `T& T::flip(const P& operand)`.
+by the member function `T& T::flip(const P& operand)`.
``
y.flip(x)
@@ -48,7 +48,7 @@
`x` not contained in `y` are added.
[/ paratract, surtract, symetract, topple, symmetric_subtract]
-The admissable combinations of types for memberfunction
+The admissible combinations of types for member function
`T& T::flip(const P&)` can be summarized in the
['*overload table*] below:
@@ -80,7 +80,7 @@
[section Inplace operators][/ Symmetric Difference]
-The overload tables below are giving admissable
+The overload tables below are giving admissible
type combinations for `operator ^=`
that implements ['*symmetric difference*].
Modified: sandbox/itl/libs/itl/doc/implementation.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/implementation.qbk (original)
+++ sandbox/itl/libs/itl/doc/implementation.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -23,8 +23,8 @@
[h5 STL based implementation]
-The *implementation* of the *itl's* conainers is based on
-[*std::set] and [*std::map]. So the underlying datastructure of
+The *implementation* of the *itl's* containers is based on
+[*std::set] and [*std::map]. So the underlying data structure of
interval containers is a red black tree of intervals or
interval value pairs.
The element containers __itl_set__ and __itl_map__ are wrapper
@@ -32,7 +32,7 @@
Interval containers are then using __itl_sets__ of intervals
or __itl_maps__ of interval value pairs as implementing
containers.
-So all the ['*complexity characteristics*] of itl conainers
+So all the ['*complexity characteristics*] of itl containers
are based on and limited by the ['*red-black tree implementation*]
of the underlying std::AssociativeContainers.
@@ -40,8 +40,8 @@
[section Iterative size]
Throughout the documentation on complexity,
-big /O/ expressions like __On__ or __Omlgn__ refere to container sizes
-/n/ and /m/. In this documentaion these sizes ['*do not*] refer
+big /O/ expressions like __On__ or __Omlgn__ refer to container sizes
+/n/ and /m/. In this documentation these sizes ['*do not*] denote
to the familiar `size` function that returns
the ['*number of elements*] of a container. Because for an interval container
``
@@ -52,8 +52,8 @@
``
it's size and the number of contained intervals is usually different.
-To refer uniformely to a /size/ that matters for iteration, which is
-the decisive kind of size concering algorithmic behavior there is a function
+To refer uniformly to a /size/ that matters for iteration, which is
+the decisive kind of size concerning algorithmic behavior there is a function
``
bool T::iterative_size()const; // Number of entities that can be iterated over.
``
@@ -105,7 +105,7 @@
The instance types of `T` are given as column headers.
Instances of type parameter `P` are denoted in
the second column.
-The third column containes the specific kind of complexity statement.
+The third column contains the specific kind of complexity statement.
If column three is empty ['*worst case*] complexity is given
in the related row.
@@ -154,7 +154,7 @@
So for the ['*worst case*], where the container sizes /n/ and /m/
are equal and both containers cover the same ranges,
the complexity of container addition is ['*loglinear*].
-For other cases, that occur frequently in realworld applications
+For other cases, that occur frequently in real world applications
performance can be much better.
If the added container `operand` is much smaller than
`object` and the intervals in `operand` are relatively
Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -36,7 +36,7 @@
[[=std::set=] [`std::set`] [`<_Key, _Compare, _Alloc>`]]
]
-Templates and template parameters, given in the preceeding table are
+Templates and template parameters, given in the preceding table are
described in detail below.
__Itv_bsets__ represent three
class templates __itv_set__, __sep_itv_set__ and __spl_itv_set__
@@ -68,7 +68,7 @@
]
-Templates and template parameters, given in the preceeding table are
+Templates and template parameters, given in the preceding table are
described in detail below.
__Itv_bmaps__ represent two
class templates __itv_map__ and __spl_itv_map__
@@ -113,10 +113,10 @@
The choice of parameters and their positions follow the std::containers
as close a possible, so that usage of interval sets and maps does only
-require minimal additional knowlege.
+require minimal additional knowledge.
Additional knowledge is required when instantiating a comparison parameter
-`Compare` or an allocation parameter `Alloc`. In contrast to std::contianers
+`Compare` or an allocation parameter `Alloc`. In contrast to std::containers
these have to be instantiated as templates, like e.g.
``
interval_set<string, german_compare> sections; // 2nd parameter is a template
@@ -138,7 +138,7 @@
[[Interval type] [`interval_sets/maps`][`template`] [`Interval`] [`Interval<DomainT,Compare>`] [`...` the `Interval` parameter has to use the same element type and order. ] ]
[[Codomain aggregation][`Maps`] [`typename`] [`CodomainT`][] [For the type `CodomainT` of associated values `...`]]
[[] [] [`template`] [`Combine`] [`Combine<CodomainT>`] [`...` there is a binary functor `Combine<CodomainT>()` to combine them ] ]
-[[] [] [] [] [`Inverse<Combine<CodomainT>>`][`...` and implicity an `Inverse` functor to inversely combine them. ] ]
+[[] [] [] [] [`Inverse<Combine<CodomainT>>`][`...` and implicitly an `Inverse` functor to inversely combine them. ] ]
[[] [] [`template`] [`Section`] [`Section<CodomainT>`] [Intersection is propagated to CodomainT values via functor `Section<CodomainT>()`] ]
[[Memory allocation] [`Sets, Maps`] [`template`] [`Alloc`] [`Alloc<`/various/`>`] [An allocator can be chosen for memory allocation.]]
]
@@ -297,7 +297,7 @@
on type `CodomainT`
metafunction [classref boost::itl::inverse inverse]
will infer [classref boost::itl::inplace_minus inplace_minus]
-as inverse functor, that requries `operator -=` on type `CodomainT`.
+as inverse functor, that requires `operator -=` on type `CodomainT`.
In the itl's design we make the assumption,
in particular for the default setting of parameters
@@ -350,7 +350,7 @@
``
we can summarize the associated types as follows.
-Again two additional colums for easy comparison with stl
+Again two additional columns for easy comparison with stl
sets and maps are provided.
[table Itl Associated types
Modified: sandbox/itl/libs/itl/doc/semantics.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/semantics.qbk (original)
+++ sandbox/itl/libs/itl/doc/semantics.qbk 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -60,7 +60,7 @@
The induced equivalence of `operator <` is
lexicographical equality
-which is implementd as `operator ==`.
+which is implemented as `operator ==`.
``
//equivalence induced by strict weak ordering <
!(a<b) && !(b<a) implies a == b;
@@ -69,7 +69,7 @@
follows the semantics of the *stl*.
Lexicographical equality is stronger than the equality
of elements. Two containers that contain the same elements
-can be lexicographically unqueal, if their elements are
+can be lexicographically unequal, if their elements are
differently sorted. Lexicographical comparison belongs to
the __bi_iterative__ aspect. Of all the different sequences that are valid
for unordered sets and maps, one such sequence is
@@ -78,7 +78,7 @@
[h4 Subset Ordering and Element Equality]
-On the __conceptual__ aspect only membeship of elements
+On the __conceptual__ aspect only membership of elements
matters, not their sequence. So there are functions
`contained_in` and `element_equal` that implement
the subset relation and the equality on elements.
@@ -115,7 +115,7 @@
is implemented via function `is_element_equal`.
``
//equivalence induced by the partial ordering contained_in on itl::container a,b
-a.contained_in(b) && b.conainted_in(a) implies is_element_equal(a, b);
+a.contained_in(b) && b.contained_in(a) implies is_element_equal(a, b);
``
[endsect][/ Orderings and Equivalences]
@@ -291,7 +291,7 @@
the semantics of the *itl's* maps may be a different one, because
of it's aggregating facilities, where the aggregating combiner
operations are passed to combine the map's associated values.
-It turnes out, that the aggregation on overlap principle
+It turns out, that the aggregation on overlap principle
induces semantical properties to itl maps in such a way,
that the set of equations that are valid will depend on
the semantics of the type `CodomainT` of the map's associated
@@ -326,7 +326,7 @@
* ['*Maps of Sets*] that will be called ['*Collectors*] and
* ['*Maps of Numbers*] which will be called ['*Quantifiers*]
-both of which seem to have many interesting usecases for practical
+both of which seem to have many interesting use cases for practical
applications. The semantics associated with the term /Numbers/
is a
[@http://en.wikipedia.org/wiki/Monoid commutative monoid]
@@ -385,7 +385,7 @@
``
The equivalence of `m` and `s` is only violated if an
-empty set occures in `m` by subtraction of a value pair:
+empty set occurres in `m` by subtraction of a value pair:
``
m -= (2,1);
m == {(1->{1,2,3}), (2->{})}; //aggregated on collision of key value 2
@@ -681,7 +681,7 @@
For `operator &` the associativity is broken for all maps
that are partial absorbers. For total absorbers associativity
is valid for element equality. All maps having the neutron enricher
-Trait are associative wrt. lexicigraphical equality `==`.
+Trait are associative wrt. lexicographical equality `==`.
``
Associativity &
absorbs_neutrons && !is_total false
Modified: sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -10,7 +10,7 @@
+-----------------------------------------------------------------------------*/
/** Example interval_container.cpp \file interval_container.cpp
- Sample file interval_container.cpp demontrates basic charactersistics of
+ Sample file interval_container.cpp demontrates basic characteristics of
interval container objects.
Simple interactive shells for the manipulation of interval containers can be found
@@ -60,7 +60,7 @@
// A split interval set of type split_interval_set preserves all interval
// borders. On insertion of overlapping intervals the intervals in the
- // set are split up at the interval boreders of the inserted interval.
+ // set are split up at the interval borders of the inserted interval.
split_interval_set<Time> splitTimes;
splitTimes += night_and_day;
splitTimes += day_and_night; //overlapping in 'day' [07:00, 20:00)
Modified: sandbox/itl/libs/itl/example/man_power_/man_power.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/man_power_/man_power.cpp (original)
+++ sandbox/itl/libs/itl/example/man_power_/man_power.cpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -56,7 +56,7 @@
return weekends;
}
-// The avalable working time for the employees of a company is calculated
+// The available working time for the employees of a company is calculated
// for a period of 3 months accounting for weekends and holidays.
// The available daily working time for the employees is calculated
// using interval_sets and interval_maps demonstrating a number of
@@ -76,14 +76,14 @@
// Subtract the weekends
worktime -= weekends(scope);
// Subtract holidays
- worktime -= from_string("2008-10-03"); //german reunification ;)
+ worktime -= from_string("2008-10-03"); //German reunification ;)
// company holidays (fictitious ;)
worktime -= interval<date>::closed(from_string("2008-08-18"),
from_string("2008-08-22"));
//-------------------------------------------------------------------------
- // (2) Now we calculate the individual worktimes for some employees
+ // (2) Now we calculate the individual work times for some employees
//-------------------------------------------------------------------------
// In the company works Claudia.
// This is the map of her regular working times:
@@ -106,7 +106,7 @@
interval_set<date> claudias_absence_times(claudias_seminar);
claudias_absence_times += claudias_vacation;
- // All the absencetimes have to subtracted from the map of her working times
+ // All the absence times have to subtracted from the map of her working times
claudias_working_hours -= claudias_absence_times;
//-------------------------------------------------------------------------
@@ -127,7 +127,7 @@
interval_set<date> bodos_absence_times(bodos_flu);
bodos_absence_times += bodos_vacation;
- // All the absencetimes have to be subtracted from the map of his working times
+ // All the absence times have to be subtracted from the map of his working times
bodos_working_hours -= bodos_absence_times;
//-------------------------------------------------------------------------
Modified: sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -13,7 +13,7 @@
In partys_height_average.cpp we compute yet another aggregation:
The average height of guests. This is done by defining a class
- counted_sum that sums up heights and counts the numer of guests
+ counted_sum that sums up heights and counts the number of guests
via an operator +=.
Based on the operator += we can aggregate counted sums on addition
Modified: sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -45,7 +45,7 @@
typedef interval_map<ptime, int, partial_absorber, less, inplace_max>
PartyHeightHistoryT;
-// Using a split_interval_map we preserve interval splittings that occured via insertion.
+// Using a split_interval_map we preserve interval splittings that occurred via insertion.
typedef split_interval_map<ptime, int, partial_absorber, less, inplace_max>
PartyHeightSplitHistoryT;
Modified: sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp (original)
+++ sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -13,16 +13,16 @@
Example user_groups.cpp shows the availability of set operations
on interval maps.
- In the example there is a user group 'med_users' of a hospial staff
+ In the example there is a user group 'med_users' of a hosptial staff
that has the authorisation to handle medical data of patients.
- User group 'admin_users' has access to aministrative data like
- health inshurance and invoice data.
+ User group 'admin_users' has access to administrative data like
+ health insurance and invoice data.
The membership for each user in one of the user groups has a time
interval of validity. The group membership begins and ends.
Using a union operation '+' we can have an overview over both
- user groups and the memebership dates of employees.
+ user groups and the membership dates of employees.
Computing an intersection '&' shows the super users. The persons
that are members of both med_users and admin_users and the times
Modified: sandbox/itl/libs/itl_xt/example/amount_cube_/amount_cube.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/example/amount_cube_/amount_cube.cpp (original)
+++ sandbox/itl/libs/itl_xt/example/amount_cube_/amount_cube.cpp 2009-09-07 20:09:52 EDT (Mon, 07 Sep 2009)
@@ -45,7 +45,7 @@
We call it AmountTupelComputer or AmountCube.
A TupelComputer counts on insert. That is, it applies the += operation on
- associated values whenever the memberfunction 'insert' is called and an
+ associated values whenever the member function 'insert' is called and an
appropriate tupel is in the cube.
An AmountTupelComputer counts frequencies of tupels if the inserted associated
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