[Boost-commit] svn:boost r77240 - in sandbox/gtl/boost/polygon: . detail

Subject: [Boost-commit] svn:boost r77240 - in sandbox/gtl/boost/polygon: . detail
From: sydorchuk.andriy_at_[hidden]
Date: 2012-03-05 16:22:18

Author: asydorchuk
Date: 2012-03-05 16:22:16 EST (Mon, 05 Mar 2012)
New Revision: 77240
URL: http://svn.boost.org/trac/boost/changeset/77240

Log:
Spell fixes for comments.

Text files modified: 
   sandbox/gtl/boost/polygon/detail/voronoi_predicates.hpp |     8 ++++----                                
   sandbox/gtl/boost/polygon/detail/voronoi_robust_fpt.hpp |    12 ++++++------                            
   sandbox/gtl/boost/polygon/detail/voronoi_structures.hpp |    18 +++++++++---------                      
   sandbox/gtl/boost/polygon/voronoi_builder.hpp           |    10 +++++-----                              
   sandbox/gtl/boost/polygon/voronoi_diagram.hpp           |     6 +++---                                  
   sandbox/gtl/boost/polygon/voronoi_utils.hpp             |     8 ++++----                                
   6 files changed, 31 insertions(+), 31 deletions(-)

Modified: sandbox/gtl/boost/polygon/detail/voronoi_predicates.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/voronoi_predicates.hpp	(original)
+++ sandbox/gtl/boost/polygon/detail/voronoi_predicates.hpp	2012-03-05 16:22:16 EST (Mon, 05 Mar 2012)
@@ -301,7 +301,7 @@
                                             const point_type &point) const {
             fpt_type dx = to_fpt(site.x()) - to_fpt(point.x());
             fpt_type dy = to_fpt(site.y()) - to_fpt(point.y());
-            // The relative error is atmost 3EPS.
+            // The relative error is at most 3EPS.
             return (dx * dx + dy * dy) / (to_fpt(2.0) * dx);
         }
 
@@ -317,13 +317,13 @@
                 fpt_type a3 = to_fpt(point.x()) - to_fpt(segment0.x());
                 fpt_type b3 = to_fpt(point.y()) - to_fpt(segment0.y());
                 fpt_type k = get_sqrt(a1 * a1 + b1 * b1);
-                // Avoid substraction while computing k.
+                // Avoid subtraction while computing k.
                 if (!is_neg(b1)) {
                     k = to_fpt(1.0) / (b1 + k);
                 } else {
                     k = (k - b1) / (a1 * a1);
                 }
-                // The relative error is atmost 7EPS.
+                // The relative error is at most 7EPS.
                 return robust_cross_product(a1, b1, a3, b3) * k;
             }
         }
@@ -390,7 +390,7 @@
         // be represented as a straight horizontal line.
         bool operator() (const node_type &node1,
                          const node_type &node2) const {
-            // Get x coordinate of the righmost site from both nodes.
+            // Get x coordinate of the rightmost site from both nodes.
             const site_type &site1 = get_comparison_site(node1);
             const site_type &site2 = get_comparison_site(node2);
 

Modified: sandbox/gtl/boost/polygon/detail/voronoi_robust_fpt.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/voronoi_robust_fpt.hpp	(original)
+++ sandbox/gtl/boost/polygon/detail/voronoi_robust_fpt.hpp	2012-03-05 16:22:16 EST (Mon, 05 Mar 2012)
@@ -26,7 +26,7 @@
 // Let EPS be machine epsilon, then next inequalities have place:
 // 1 EPS <= 1 ULP <= 2 EPS (1), 0.5 ULP <= 1 EPS <= 1 ULP (2).
 // ULPs are good for measuring rounding errors and comparing values.
-// Relative erros are good for computation of general relative
+// Relative errors are good for computation of general relative
 // error of formulas or expressions. So to calculate epsilon
 // interval within which epsilon robust predicates have undefined result
 // next schema is used:
@@ -44,10 +44,10 @@
 //     2) r(A * B) <= r(A) + r(B);
 //     3) r(A / B) <= r(A) + r(B);
 // In addition rounding error should be added, that is always equal to
-// 0.5 ULP or atmost 1 epsilon. As you might see from the above formulas
-// substraction relative error may be extremely large, that's why
+// 0.5 ULP or at most 1 epsilon. As you might see from the above formulas
+// subtraction relative error may be extremely large, that's why
 // epsilon robust comparator class is used to store floating point values
-// and compute substraction as the final step of the evaluation.
+// and compute subtraction as the final step of the evaluation.
 // For further information about relative errors and ULPs try this link:
 // http://docs.sun.com/source/806-3568/ncg_goldberg.html
 
@@ -247,8 +247,8 @@
 
 // robust_dif consists of two not negative values: value1 and value2.
 // The resulting expression is equal to the value1 - value2.
-// Substraction of a positive value is equivalent to the addition to value2
-// and substraction of a negative value is equivalent to the addition to
+// Subtraction of a positive value is equivalent to the addition to value2
+// and subtraction of a negative value is equivalent to the addition to
 // value1. The structure implicitly avoids difference computation.
 template <typename T>
 class robust_dif {

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-03-05 16:22:16 EST (Mon, 05 Mar 2012)
@@ -64,19 +64,19 @@
 // Site event type.
 // Occurs when the sweepline sweeps over one of the initial sites:
 //   1) point site;
-//   2) startpoint of the segment site;
+//   2) start-point of the segment site;
 //   3) endpoint of the segment site.
-// Implicit segment direction is defined: the startpoint of
+// Implicit segment direction is defined: the start-point of
 // the segment compares less than its endpoint.
 // Each input segment is divided onto two site events:
-//   1) One going from the startpoint to the endpoint
+//   1) One going from the start-point to the endpoint
 //      (is_inverse_ = false);
-//   2) Another going from the endpoint to the startpoint
+//   2) Another going from the endpoint to the start-point
 //      (is_inverse_ = true).
 // In beach line data structure segment sites of the first
-// type preceed sites of the second type for the same segment.
+// type precede sites of the second type for the same segment.
 // Variables:
-//   point0_ - point site or segment's startpoint;
+//   point0_ - point site or segment's start-point;
 //   point1_ - segment's endpoint if site is a segment;
 //   index_ - the last bit encodes if the site is inverse;
 //            the last-1 bit encodes initial site direction;
@@ -221,9 +221,9 @@
 };
 
 // Circle event type.
-// Occrus 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 consequtive nodes in the beach line data
+// Circle event is made of the two consecutive nodes in the beach line data
 // structure. In case another node was inserted during algorithm execution
 // between the given two nodes circle event becomes inactive.
 // Variables:
@@ -411,7 +411,7 @@
   site_type right_site_;
 };
 
-// Represents edge data sturcture from the voronoi output, that is
+// Represents edge data structure from the voronoi output, that is
 // associated as a value with beach line bisector in the beach
 // line. Contains pointer to the circle event in the circle event
 // queue if the edge corresponds to the right bisector of the circle event.

Modified: sandbox/gtl/boost/polygon/voronoi_builder.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/voronoi_builder.hpp	(original)
+++ sandbox/gtl/boost/polygon/voronoi_builder.hpp	2012-03-05 16:22:16 EST (Mon, 05 Mar 2012)
@@ -31,7 +31,7 @@
     // along the x-axis positive direction. Each of the input objects is
     // wrapped into the site event. Each event is characterized by its
     // coordinates: the point site event is defined by the point itself,
-    // the segment site event is defined by its startpoint. At any moment we
+    // the segment site event is defined by its start-point. At any moment we
     // consider only the sites that lie to the left of the sweepline. Beach
     // line is a curve formed by the parabolic arcs and line segments, that
     // consists of the points equidistant from the sweepline and the nearest
@@ -90,7 +90,7 @@
         void insert_segment(const int_type& x1, const int_type& y1,
                             const int_type& x2, const int_type& y2) {
             // Each segment creates three segment sites:
-            //   1) the startpoint of the segment;
+            //   1) the start-point of the segment;
             //   2) the endpoint of the segment;
             //   3) the segment itself.
             point_type p1(x1, y1);
@@ -344,7 +344,7 @@
                 beach_line_iterator left_it = right_it;
 
                 // Do further processing depending on the above node position.
-                // For any two neighbouring nodes the second site of the first node
+                // For any two neighboring nodes the second site of the first node
                 // is the same as the first site of the second node.
                 if (right_it == beach_line_.end()) {
                     // The above arc corresponds to the second arc of the last node.
@@ -414,11 +414,11 @@
             }
         }
 
-        // In general case circle event is made of the three consequtive sites
+        // In general case circle event is made of the three consecutive sites
         // that form two bisector nodes in the beach line data structure.
         // Let circle event sites be A, B, C, two bisectors that define
         // circle event are (A, B), (B, C). During circle event processing
-        // we remove (A, B), (B, C) and insert (A, C). As beach line comparer
+        // we remove (A, B), (B, C) and insert (A, C). As beach line comparison
         // works correctly only if one of the nodes is a new one we remove
         // (B, C) bisector and change (A, B) bisector to the (A, C). That's
         // why we use const_cast there and take all the responsibility that

Modified: sandbox/gtl/boost/polygon/voronoi_diagram.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/voronoi_diagram.hpp	(original)
+++ sandbox/gtl/boost/polygon/voronoi_diagram.hpp	2012-03-05 16:22:16 EST (Mon, 05 Mar 2012)
@@ -464,7 +464,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();
 
@@ -509,7 +509,7 @@
         // Insert a new half-edge into the output data structure with the
         // start at the point where two previously added half-edges intersect.
         // Takes as input two sites that create a new bisector, circle event
-        // that correponds to the intersection point of the two old half-edges,
+        // that corresponds to the intersection point of the two old half-edges,
         // pointers to those half-edges. Half-edges' direction goes out of the
         // new voronoi vertex point. Returns a pointer to the new half-edge.
         template <typename SEvent, typename CEvent>
@@ -568,7 +568,7 @@
             edge_iterator edge_it = edges_.begin();
             num_cells_ = cells_.size();
 
-            // All the initial sites are colinear.
+            // All the initial sites are collinear.
             if (vertices_.empty()) {
                 // Update edges counter.
                 num_edges_ = num_cells_ - 1;

Modified: sandbox/gtl/boost/polygon/voronoi_utils.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/voronoi_utils.hpp	(original)
+++ sandbox/gtl/boost/polygon/voronoi_utils.hpp	2012-03-05 16:22:16 EST (Mon, 05 Mar 2012)
@@ -36,7 +36,7 @@
     } ctype_converter_type;
 };
 
-// Voronoi output postprocessing tools.
+// Voronoi output post-processing tools.
 template <typename T, typename TRAITS = voronoi_utils_traits<T> >
 class voronoi_utils {
 public:
@@ -127,7 +127,7 @@
             const point_type &point1 = (cell1->contains_segment()) ?
                 get_point(cell2->point0()) : get_point(cell1->point0());
 
-            // point2 - startpoint of the segment site;
+            // point2 - start-point of the segment site;
             const point_type &point2 = (cell1->contains_segment()) ?
                 get_point(cell1->point0()) : get_point(cell2->point0());
 
@@ -288,7 +288,7 @@
                                  segment_site_start,
                                  segment_site_end);
 
-        // Compute parabola parameterers in the transformed space.
+        // Compute parabola parameters in the transformed space.
         // Parabola has next representation:
         // f(x) = ((x-rot_x)^2 + rot_y^2) / (2.0*rot_y).
         fpt_type point_vec_x = point_site.x() - segment_site_start.x();
@@ -402,7 +402,7 @@
     // This is made to avoid sqrt computation during transformation from
     // the initial space to the transformed one and vice versa.
     // Assumption is made that projection of the point lies
-    // between the startpoint and endpoint of the segment.
+    // between the start-point and endpoint of the segment.
     static fpt_type get_point_projection(
             const point_type &point,
             const point_type &segment_start,