| 
        
    
int
        
         | 
        
    S.dimension ()
        
         | 
    returns the dimension of the ambient space.
         | 
        
  | 
        | 
        
    
Point_d<Kernel>
        
         | 
        
    S.point ( int i)
        
         | 
    returns the ith defining
point. | Precondition:  | 0  ≤ i  ≤ dim. |   
         | 
        
  | 
        | 
        
    
point_iterator
        
         | 
        
    S.points_begin ()
        
         | 
    returns an iterator
  pointing to the first defining point.
         | 
        
  | 
        | 
        
    
point_iterator
        
         | 
        
    S.points_end ()
        
         | 
    returns an iterator pointing
  beyond the last defining point.
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.is_degenerate ()
        
         | 
    returns true iff the defining points
  are not full dimensional.
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.is_legal ()
        
         | 
    returns true iff the set of defining
  points is legal.  A set of defining points is legal iff their
  orientation is non-zero or if they are all equal.
         | 
        
  | 
        | 
        
    
Point_d<Kernel>
        
         | 
        
    S.center ()
        
         | 
    returns the center of S.
  | Precondition:  | S is legal. |   
         | 
        
  | 
        | 
        
    
FT
        
         | 
        
    S.squared_radius ()
        
         | 
    returns the squared radius of the
  sphere. | Precondition:  | S is legal. |   
         | 
        
  | 
        | 
        
    
Orientation
        
         | 
        
    S.orientation ()
        
         | 
    returns the orientation of
  S.
         | 
        
  | 
        | 
        
    
Oriented_side
        
         | 
        
    S.oriented_side (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  either the constant ON_ORIENTED_BOUNDARY,
  ON_POSITIVE_SIDE, or ON_NEGATIVE_SIDE, iff p lies on the
  boundary, properly on the positive side, or properly on the negative
  side of sphere, resp. | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
Bounded_side
        
         | 
        
    S.bounded_side (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  ON_BOUNDED_SIDE, ON_BOUNDARY, or ON_UNBOUNDED_SIDE
  iff p lies properly inside, on the boundary, or properly outside of
  sphere, resp. | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.has_on_positive_side (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  S.oriented_side(p)==ON_POSITIVE_SIDE. | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.has_on_negative_side (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  S.oriented_side(p)==ON_NEGATIVE_SIDE. | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.has_on_boundary (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  S.oriented_side(p)==ON_ORIENTED_BOUNDARY, which is the same as
  S.bounded_side(p)==ON_BOUNDARY. | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.has_on_bounded_side (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  S.bounded_side(p)==ON_BOUNDED_SIDE. | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
bool
        
         | 
        
    S.has_on_unbounded_side (  Point_d<Kernel> p)
        
         | 
 |  | 
    returns
  S.bounded_side(p)==ON_UNBOUNDED_SIDE.  | Precondition:  | S.dimension()==p.dimension(). |   
         | 
        
  | 
        | 
        
    
Sphere_d<Kernel>
        
         | 
        
    S.opposite ()
        
         | 
    returns the sphere with the same
  center and squared radius as S but with opposite orientation.
         | 
        
  | 
        | 
        
    
Sphere_d<Kernel>
        
         | 
        
     S + 
 Vector_d<Kernel> v
        
         | 
    returns the
  sphere translated by v. | Precondition:  | S.dimension()==v.dimension(). |   
         | 
        
Spheres are implemented by a vector of points as a handle type.  All
operations like creation, initialization, tests, input and output of a
sphere s take time O(s.dimension()). dimension(),
point access take constant time.  The center()-operation takes
time O(d3) on its first call and constant time thereafter. The
sidedness and orientation tests take time O(d3).  The space
requirement for spheres is O(s.dimension()) neglecting the
storage room of the points.