Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r77815 - in sandbox/gtl: boost/polygon boost/polygon/detail doc
From: sydorchuk.andriy_at_[hidden]
Date: 2012-04-07 09:13:17

Next message: lorcaminiti_at_[hidden]: "[Boost-commit] svn:boost r77816 - trunk/boost/local_function/aux_"
Previous message: joel_at_[hidden]: "[Boost-commit] svn:boost r77814 - trunk/boost/fusion/container/deque"

Author: asydorchuk
Date: 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
New Revision: 77815
URL: http://svn.boost.org/trac/boost/changeset/77815

Log:
Running spell checker over sources and docs.

Text files modified:
   sandbox/gtl/boost/polygon/detail/voronoi_structures.hpp | 2 +-
   sandbox/gtl/boost/polygon/voronoi_builder.hpp | 2 +-
   sandbox/gtl/boost/polygon/voronoi_diagram.hpp | 2 +-
   sandbox/gtl/boost/polygon/voronoi_utils.hpp | 2 +-
   sandbox/gtl/doc/index.htm | 8 ++++----
   sandbox/gtl/doc/voronoi_advanced_tutorial.htm | 18 +++++++++---------
   sandbox/gtl/doc/voronoi_basic_tutorial.htm | 2 +-
   sandbox/gtl/doc/voronoi_builder.htm | 16 ++++++++--------
   sandbox/gtl/doc/voronoi_diagram.htm | 10 +++++-----
   sandbox/gtl/doc/voronoi_main.htm | 30 ++++++++++++++++++++----------
   sandbox/gtl/doc/voronoi_predicates.htm | 16 ++++++++--------
   sandbox/gtl/doc/voronoi_robust_fpt.htm | 10 +++++-----
   sandbox/gtl/doc/voronoi_utils.htm | 8 ++++----
   13 files changed, 68 insertions(+), 58 deletions(-)

Modified: sandbox/gtl/boost/polygon/detail/voronoi_structures.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/voronoi_structures.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/voronoi_structures.hpp 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -221,7 +221,7 @@
};

// Circle event type.
-// Occurs when the sweepline sweeps over the rightmost point of the voronoi
+// Occurs when the sweepline sweeps over the rightmost point of the Voronoi
// circle (with the center at the intersection point of the bisectors).
// Circle event is made of the two consecutive nodes in the beach line data
// structure. In case another node was inserted during algorithm execution

Modified: sandbox/gtl/boost/polygon/voronoi_builder.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/voronoi_builder.hpp (original)
+++ sandbox/gtl/boost/polygon/voronoi_builder.hpp 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -107,7 +107,7 @@
 insert_segments(first_segment, last_segment);
 }

- // Run sweepline algorithm and fill output datastucture.
+ // Run sweepline algorithm and fill output data structure.
 template <typename OUTPUT>
 void construct(OUTPUT *output) {
 // Init structures.

Modified: sandbox/gtl/boost/polygon/voronoi_diagram.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/voronoi_diagram.hpp (original)
+++ sandbox/gtl/boost/polygon/voronoi_diagram.hpp 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -391,7 +391,7 @@
 template <typename SEvent>
 std::pair<void*, void*> insert_new_edge(
 const SEvent &site1, const SEvent &site2) {
- // Get sites' indices.
+ // Get sites' indexes.
 int site_index1 = site1.index();
 int site_index2 = site2.index();

Modified: sandbox/gtl/boost/polygon/voronoi_utils.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/voronoi_utils.hpp (original)
+++ sandbox/gtl/boost/polygon/voronoi_utils.hpp 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -133,7 +133,7 @@
 }

 // Discretizes finite Voronoi edge.
- // Disretization absolute error is defined by max_error value.
+ // Discretization absolute error is defined by max_error value.
 template <typename CT>
 static void discretize(const voronoi_edge<CT> &edge,
 coordinate_type max_error, point_set_type &discretization) {

Modified: sandbox/gtl/doc/index.htm
==============================================================================
--- sandbox/gtl/doc/index.htm (original)
+++ sandbox/gtl/doc/index.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -95,7 +95,7 @@
An example of the disjoint-union (XOR) of figure a and figure b is shown below
in figure c. 
These so-called Boolean algorithms are of significant interest in GIS (Geospatial Information
-Systems), VLSI CAD as well al other fields of CAD, and many more application
+Systems), VLSI CAD as well all other fields of CAD, and many more application
areas, and providing them is the primary focus of this library.  The
Boost.Polygon library is not intended to cover all of computational
geometry in its scope, and provides a set of capabilities for working with
@@ -103,10 +103,10 @@
implementing and interacting with polygon data structures and algorithms.  <img src="images/hand.png" border="0" height="277" width="837" />
One of important features of the library is implementation of
generic sweepline algorithm to build Voronoi diagrams in 2D (developed
-as part of GSoC 2010 program). Voronoi diagram datastructure has
+as part of GSoC 2010 program). Voronoi diagram data structure has
applications in image segmentation, optical character recognition,
nearest neighbor queries execution. It is closely related with other
-computational geometry concepts: delaunay triangulation, medial axis,
+computational geometry concepts: Delaunay triangulation, medial axis,
straight skeleton, largest empty circle. Boost.Polygon library
provides interface to construct Voronoi diagrams of points figure a and
line segments figure b (the last could be used to discretize any
@@ -241,7 +241,7 @@
 to construct, traverse, visualize, associate data with Voronoi diagrams without digging into library details.</li>
 <li>Voronoi Advanced Tutorial
 Learn how to configure Voronoi builder and Voronoi diagram
- datastructure with user provided coordinate types. </li>
+ data structure with user provided coordinate types. </li>
</ul>

</li></ul>

Modified: sandbox/gtl/doc/voronoi_advanced_tutorial.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_advanced_tutorial.htm (original)
+++ sandbox/gtl/doc/voronoi_advanced_tutorial.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -19,8 +19,8 @@
examples of a real world problems that default configuration of Voronoi
library is capable to solve. By default configuration we mean the one that accepts
signed 32-bit integer and outputs floating-point (64-bit
-double) coordinates. We provide those examples to convience even the
-most sceptical users that they probably don't need to configure library
+double) coordinates. We provide those examples to convince even the
+most skeptical users that they probably don't need to configure library
for higher-precision input or output coordinate types. However if the
posed problem really requires those, fully featured configuration of
both input and output coordinate types is provided in the second part
@@ -66,10 +66,10 @@
grid with a side of 1.2 * 10^9 centimetres.  To make Voronoi graph
precise on the boundaries of that grid we will replicate input map 9
times (3x3), thus Voronoi diagram within a central  piece will
-provide us with a correct connectivity graph. This step will increse
+provide us with a correct connectivity graph. This step will increase
the size of our grid to 3.6 * 10^9 centimetres that is less than 2^32.
So we are able to discretize Red planet surface within a 1 centimetre
-precision using default input coordinate type (signed 32 bit integer). That would imply maximum absolut error to be
+precision using default input coordinate type (signed 32 bit integer). That would imply maximum absolute error to be
equal up to 0.5 centimetres per coordinate. Considering the radius of our robot to be
0.3 metres and for security reasons avoiding any large enough obstacles
that are within 1 metre distance from it that error would be irrelevant. 
@@ -135,7 +135,7 @@
the Voronoi main page very small edges
are removed from the Voronoi diagram. However user should not worry
because the edge that correspond to the minimal distance won't be among
-those. That means that we would be able to 100% correclty identify a
+those. That means that we would be able to 100% correctly identify a
pair of closest objects within the discretization precision. 

@@ -146,7 +146,7 @@

<h2>Conclusions</h2>
Above two examples show usage of the default Voronoi coordinate types
-in the marcro and micro world. The main point of those was to give user
+in the macro and micro world. The main point of those was to give user
understanding of a scale default coordinate types provide. There are
two main points we didn't mention before, but that would be relevant to
the most real world problems: 
@@ -182,7 +182,7 @@
should give clear understanding of how the library supports user
provided coordinate types. 
 
-So the main step would be to declare voronoi coordinate type traits that satisfy set of restrictions expalined here: 
+So the main step would be to declare voronoi coordinate type traits that satisfy set of restrictions explained here: 
 
struct my_voronoi_ctype_traits { 
  typedef boost::int64_t int_type; 
@@ -196,11 +196,11 @@
  typedef my_fpt_converter to_efpt_converter_type; 
}; 
 
-It is always better to use C++ builtin types wherever it's
+It is always better to use C++ built-in types wherever it's
possible. That's why we use 64 bit signed integer type to handle our
input coordinates. int_x2_type and uint_x2_type
is required to handle 96 bit signed/unsigned integers. As there is no
-such builtin type we use library provided efficient fixed integer type.
+such built-in type we use library provided efficient fixed integer type.
Big int type should be capable to handle 48 * 64 bit integers, that is
less than 32 * 128, and so far we are good with extended_int<128> type. We use the same floating point type for both fpt_type and efpt_type
as it has enough exponent bits to represent both 48 * 32 bit and 48 *

Modified: sandbox/gtl/doc/voronoi_basic_tutorial.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_basic_tutorial.htm (original)
+++ sandbox/gtl/doc/voronoi_basic_tutorial.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -56,7 +56,7 @@
  int y() const { return y_; } 
 
private: 
-  // Don't forget should be castable to the signed int32 type! 
+  // Don't forget should be cast to the signed int32 type! 
  int x_; 
  int y_; 
};

Modified: sandbox/gtl/doc/voronoi_builder.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_builder.htm (original)
+++ sandbox/gtl/doc/voronoi_builder.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -94,15 +94,15 @@
 Voronoi builder is event generator structure. It implements
 <a href="http://www.ams.org/samplings/feature-column/fcarc-voronoi">sweepline algorithm</a> that scans 2D space and generates two types of
 events: site events and circle events (we won't go into details what
- those are exactly). Each event is reported to the output datastructure builder. The structure
+ those are exactly). Each event is reported to the output data structure builder. The structure
 shares Voronoi name as the events generated by it correspond to the
- Voronoi diagram edges and vertices and give enought information to
+ Voronoi diagram edges and vertices and give enough information to
 construct Voronoi diagram of a set of points and segments. The
 requirements for the input / output coordinate types of the builder
 geometries are not the same as for the rest of the Boost.Polygon library.
 The main differences are in the following: 1) The input coordinate type
 is not required to be integral (while it still should be integer type);
- 2) The output coordinate type (for voronoi vertices) is required to be
+ 2) The output coordinate type (for Voronoi vertices) is required to be
 IEEE-754 floating point type. Let's have a closer look at the voronoi_builder declaration: 
 
 
@@ -123,12 +123,12 @@
 VP
 - predicates kernel, that provides builder with robust and efficient
 predicates. 
- The Voronoi builder datastructure is ready to use from the box with
+ The Voronoi builder data structure is ready to use from the box with
 32-bit signed integer input coordinate type. The user may extend input
 coordinate range to other integer types (e.g. 64-bit integer), however
 this will also require manual set up of coordinate type traits. Default
 voronoi_predicates<CTT>
- implementaiton provides correct predicates as soon as
+ implementation provides correct predicates as soon as
 
 CTT
 types satisfy requirements explained below. In case those requirements
@@ -245,11 +245,11 @@
 </td>
 <td style="vertical-align: top;" width="693">Runs sweepline
 algorithm over the set of the inserted geometries, outputs site
- and circle events to the OUTPUT datastructure. It's
+ and circle events to the OUTPUT data structure. It's
 responsibility of the output structure builder to process them. For
 example both Voronoi diagram and Delaunay triangulation could be
 constructed from the Voronoi builder events, however internally
- they are different datastructures, so it's up to them to process
+ they are different data structures, so it's up to them to process
 properly events produced by the builder object. 
 </td>
 </tr>
@@ -344,7 +344,7 @@
 <td style="vertical-align: top; font-family: 'Courier New',Courier,monospace;">
 ulp_cmp_type 
 </td>
- <td style="vertical-align: top;">Ulp comarison structure that
+ <td style="vertical-align: top;">Ulp comparison structure that
 checks if two fpt_type values are withing given ulp range
 (relative error range). 
 </td>

Modified: sandbox/gtl/doc/voronoi_diagram.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_diagram.htm (original)
+++ sandbox/gtl/doc/voronoi_diagram.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -110,26 +110,26 @@
Voronoi
diagram is a computational geometry concept that represents partition
of a given space onto regions, with bounds determined by distances to a
-specified family of objects. The application area of this concept vary from Archaology to Zoology. Boost.Polygon provides implementation of
+specified family of objects. The application area of this concept vary from Archaeology to Zoology. Boost.Polygon provides implementation of
Voronoi diagram data structure in 2D space. Internal representation
consists of a three arrays, that respectively contain: Voronoi cells
(area around input sites bounded by Voronoi edges), Voronoi vertices
(points where three or more Voronoi edges intersect), Voronoi edges
-(one dimensonal curves containing points equidistant from the two
+(one dimensional curves containing points equidistant from the two
closest input sites). Each of the primitives (cell, vertex, edge)
contains pointers to other linked primitives, so that it's always
possible to efficiently traverse Voronoi diagram. Picture below shows
Voronoi vertices in red, Voronoi edges in black, input sites that
correspond to the Voronoi cells in blue (it is considered that each
input segment consists of three sites: segment itself and two
-endpoints). As one may notice each segment is splitted onto segment
+endpoints). As one may notice each segment is split onto segment
site itself and both its endpoints. As the result two additional
Voronoi edges are constructed per each segment. This is made to
simplify representation of the Voronoi diagram. 
 
 <img style="border: 1px solid ; width: 300px; height: 300px;" alt="" src="images/voronoi2.png"> 
 
-Voronoi diagram declaration and list of member fucntions is following: 
+Voronoi diagram declaration and list of member functions is following: 
 
 template <typename T, typename TRAITS = voronoi_diagram_traits<T> > 
 class voronoi_diagram; 
@@ -209,7 +209,7 @@
 <tr>
 <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">voronoi_cell_type *cell() 
 </td>
- <td style="vertical-align: top;">Retruns pointer to the Voronoi cell that edge belongs to. 
+ <td style="vertical-align: top;">Returns pointer to the Voronoi cell that edge belongs to. 
 </td>
 </tr>
 <tr>

Modified: sandbox/gtl/doc/voronoi_main.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_main.htm (original)
+++ sandbox/gtl/doc/voronoi_main.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -32,6 +32,7 @@

+
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252"><title>Contents</title><meta http-equiv="content-type" content="text/html; charset=utf-8"><meta http-equiv="content-type" content="text/html; charset=utf-8"><meta http-equiv="content-type" content="text/html; charset=utf-8"></head><body>

@@ -121,7 +122,7 @@
limitations: 1) coordinates of input points and endpoints of segments
should be of integer type; 2) input segments should not intersect
except their endpoints. While the first restriction is permanent (it
-allows to give waranties for algorithm output precision and execution),
+allows to give warranties for algorithm output precision and execution),
the second one may be resolved using Boost.Polygon functionality.
Strong sides of the
library and main benefits comparing to other implementations are
@@ -141,11 +142,11 @@
fail and produces valid output in 100% of cases, thus user can rely on
it. Robustness is the weak place of the most non-commercial
implementations of any complex geometric algorithm. The main issues of
-that could be devided onto two main categories: memory management
+that could be divided onto two main categories: memory management
issues, numeric stability issues. Voronoi implementation avoids the
first type of issues using pure STL data structure, thus you won't find
any operator new in the code. The second category of problems is
-resolved using multi-precision geometric predicates.
+resolved using multiprecision-precision geometric predicates.
Even for commercial implementations usage of such predicates usually
results in huge performance slowdown. Here is another strong side of
Voronoi: we avoid multiprecision computations in 95% of cases using
@@ -180,7 +181,7 @@
 
During finalization step library unites Voronoi vertices whose both
coordinates are situated within relative error range equal to 128
-machine epsilons and removes any voronoi edges between them. That is
+machine epsilons and removes any Voronoi edges between them. That is
the only case that might cause differences between algorithm output
topology and the precise one.  Now lets see what is the practical
impact of this. Consider following example: we are going to construct
@@ -198,7 +199,7 @@

There are not many implementations of Voronoi diagrams that could
handle segment inputs, even considering commercial ones. Support of
-segments allows to discretize any input geometry (circle, elipse,
+segments allows to discretize any input geometry (circle, ellipse,
parabola). Of course as the result those might have floating-point
coordinates, but that is resolved using scaling and snapping to the
integer grid. This functionality is very handy as allows to compute
@@ -252,15 +253,24 @@
 construct_voronoi(points, segments, &vd); 
 
Isn't that simple? The library also provides clear interfaces to associate user data with output geometries, efficiently traverse Voronoi graph and utilities to visualize output primitives (e.g. discretization of parabolic edges, clipping of linear edges). More details on those is covered in the basic Voronoi tutorial.  Advanced usage of the library with configuration of the coordinate types is explained in the advanced Voronoi tutorial. 
+ 
+ <h2>No Third-party Dependencies 
+ </h2>
+Yes, the library doesn't depend on any 3rd party code. Even more than
+that there is only one dependency on Boost library: boost/cstdint.hpp.
+All the required multiprecision types functionality is implemented as
+part of the library and is not exposed to the user. Considering the
+fact that Voronoi implementation consists of just 8 headers (4 public
+and 4 private) it is easy to compile it within a minute after download. 


- <h2>Extendable for User Provided Coordinate Types</h2>
+ <h2>Extensible for User Provided Coordinate Types</h2>

Voronoi implementation is coordinate type agnostic. That means that as soon as user provided types satisfy set of Voronoi builder coordinate type traits restrictions
-and implement library required methods no changes are requied neither
+and implement library required methods no changes are required neither
from algorithm, nor from predicates implementation. So it's possible to
construct Voronoi diagram for 256 bit integer input coordinate type and
-512 bit output floating-pont type without changing any internal code. 
+512 bit output floating-point type without changing any internal code. 


 <h2>Bright Future 
@@ -279,11 +289,11 @@
user is not interested in diagram inside hole regions. The main point
of this data structure is to automatically filter Voronoi edges that
belong to those areas.</li>
- <li>Implementing data structure built on top of Voronoi diagram that allows to execute nearest neighbour queries in O(log N) time. 
+ <li>Implementing data structure built on top of Voronoi diagram that allows to execute nearest neighbor queries in O(log N) time. 
Note: this would be sort of kd-tree data structure built on top of bounding rectangles around Voronoi cells.</li>

 <li>Providing interface to retrieve convex hull of a set of
-points and segments from Voronoi builder one's the Voronoi diagram is
+points and segments from Voronoi builder once the Voronoi diagram is
constructed in O(N) time. 
</li>
 <li>Closer integration with interfaces and functionality of Boost Polygon Library.

Modified: sandbox/gtl/doc/voronoi_predicates.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_predicates.htm (original)
+++ sandbox/gtl/doc/voronoi_predicates.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -101,7 +101,7 @@
Voronoi predicates contain implementation of a set of geometric
predicates used by Voronoi builder. Except of those it also provides
functors that allow to compute coordinates of centers of inscribed
-circles (those correspond to the voronoi vertices) within the given
+circles (those correspond to the Voronoi vertices) within the given
relative error precision range. This means that the more mantissa bits
your floating point type has the better precision of the output
geometries you'll get. This
@@ -113,7 +113,7 @@
The main issues with implementation of any complex geometric
algorithm arise when dealing with robustness of geometric predicates.
Usually this
-is also the point where commercial projects stand strong agains
+is also the point where commercial projects stand strong against
noncommercial implementations (it's not the case with our
implementation).
For the short example let's consider following code snippet, that could
@@ -135,7 +135,7 @@
the correct one is "1.000". In terms of the orientation test this means
that points are collinear instead of being CCW oriented. This is one of
the basic predicates used in any geometric algorithm and taking wrong
-output from it may influence the further algorithm exectuion:
+output from it may influence the further algorithm execution:
corrupting algorithm underlying structures or producing completely
invalid output. Voronoi uses
slightly more complex predicates. To insure that they are robust and
@@ -152,15 +152,15 @@
result of the expression compute the relative error of it also. This will
give us the range of values evaluated result belongs to and based on that we can
come up with two decisions: 1) output the value; 2) recompute the
-expression using multi precision type. The way relative errors are
+expression using multiprecision precision type. The way relative errors are
evaluated is explained in the Voronoi Robust FPT section. 
 <h2>Multiple Precision Arithmetic</h2>
In the vast majority of cases
-lazy arithmetic approach produces correct result thus furhter
+lazy arithmetic approach produces correct result thus further
processing is not required. In other cases Voronoi defined or user
provided multiple precision types are used to produce correct result.
However even that doesn't solve all the cases. Multiprecision geometric
-predicates could be devided onto two categories: 
+predicates could be divided onto two categories: 
1) mathematical transformation of the predicate exists that evaluates exact result: 
 
Predicate: A/B + C/D ?< 0; 
@@ -177,13 +177,13 @@
Imagine that value of the expression to the left is very close to 1.2; 
 
 Predicate: sin(x) ?< 0.57; 
-Relativer error of sin function should be known; 
+Relative error of sin function should be known; 
 
 Voronoi of points could be implemented using only predicates of the first type, however Voronoi of segments could not.
The predicate that doesn't fall into the first category is responsible
for comparison of Voronoi circle events. However it appears that properly used
this predicate can't corrupt algorithm internal structures and produces
-output technically the same as produced in case this predicate falt in
+output technically the same as produced in case this predicate fell in
the first category.  The main reasons for this are: 1) algorithm
operates with integer coordinate type of input geometries; 2) closely
situated Voronoi vertices are considered to be the same in the output

Modified: sandbox/gtl/doc/voronoi_robust_fpt.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_robust_fpt.htm (original)
+++ sandbox/gtl/doc/voronoi_robust_fpt.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -111,7 +111,7 @@
- represents IEEE-754 floating-point type wrapper that also contains
information about relative error of the underlying value. The
implementation overloads 5 standard operations: +, -, *, /, sqrt and
-apart from evaluating value of the expression also computes its relativer
+apart from evaluating value of the expression also computes its relative
error. Let's consider two values A and B; C - rounding error; re
- correspond to relative error, then following rules apply: 
 
@@ -140,9 +140,9 @@
1) all of the formulas evaluate upper bound of the relative error, while it could be a lot lower; 
2) relative error of the expression depends on the order operations are evaluated; 
3) relative error of difference of two positive numbers may be
-exteremely large in case their values are close to each other (this is
+extremely large in case their values are close to each other (this is
also called cancellation error). 
-To explain this a bit consider following experssion (~ - stands for almost equal, << - many times larger than): 
+To explain this a bit consider following expression (~ - stands for almost equal, << - many times larger than): 
 
 A - B + C, where A ~ B and C << B; 
 
@@ -157,7 +157,7 @@
 While both estimates are valid (they define upper bound of the relative error), of course the second one is preferable. 
Here is the place where robust difference type comes useful. Basically
it splits expression onto positive and negative partial sums and evaluates the
-diference only when the result is required. And did I mention that
+difference only when the result is required. And did I mention that
positive and negative values might be of robust fpt type, that's why
relative error is always known for the expression result. 
 <h2>Robust Sqrt Expression Structure</h2>
@@ -173,7 +173,7 @@
 
(A * A * a - B * B * b) / (A * sqrt(a) + B * sqrt(b)); 
 
-Numerator and denominator of this epxression could be computed directly as those won't lead to the cancellation errors. 
+Numerator and denominator of this expression could be computed directly as those won't lead to the cancellation errors. 
In general case robust sqrt expression structure allows to evaluate following set of expressions: 
 
sum(A[i] * sqrt(a[i]), i = 1 .. N), N <= 4;

Modified: sandbox/gtl/doc/voronoi_utils.htm
==============================================================================
--- sandbox/gtl/doc/voronoi_utils.htm (original)
+++ sandbox/gtl/doc/voronoi_utils.htm 2012-04-07 09:13:15 EDT (Sat, 07 Apr 2012)
@@ -101,7 +101,7 @@
 
 
 <h1>Voronoi Utils</h1>Voronoi
-utilities imlements a set of tools that users may find useful
+utilities implements a set of tools that users may find useful
especially for
the visualization of Voronoi diagrams or discretization of parabolic
edges. Keep in mind that there are no warranties about precision of the
@@ -151,7 +151,7 @@
    const brect_type &brect, 
    point_set_type &clipped_edge) 
 </td>
- <td style="vertical-align: top;">Clips the input voronoi edges with specified rectangle. 
+ <td style="vertical-align: top;">Clips the input Voronoi edges with specified rectangle. 
If the edge is a parabolic arc doesn't fill output point set. 
 </td>
 </tr><tr>
@@ -219,7 +219,7 @@
   coordinate_type x, 
   coordinate_type y) const 
 </td>
- <td style="vertical-align: top;">Retruns true if rectangle contains given point defined by its coordinates, else false. 
+ <td style="vertical-align: top;">Returns true if rectangle contains given point defined by its coordinates, else false. 
 </td>
 </tr>
 <tr>
@@ -250,7 +250,7 @@
 </table>
 <h1>Voronoi Utils Traits 
 </h1>
-Below is shown the default voronoi utilities traits: 
+Below is shown the default Voronoi utilities traits: 
 
 template <typename fpt_> 
 struct voronoi_utils_traits;

Next message: lorcaminiti_at_[hidden]: "[Boost-commit] svn:boost r77816 - trunk/boost/local_function/aux_"
Previous message: joel_at_[hidden]: "[Boost-commit] svn:boost r77814 - trunk/boost/fusion/container/deque"

Date view	Thread view	Subject view	Author view

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