text: // ============================================================================
  //
  // Copyright (c) 1997 The CGAL Consortium
  //
  // This software and related documentation is part of an INTERNAL release
  // of the Computational Geometry Algorithms Library (CGAL). It is not
  // intended for general use.
  //
  // ----------------------------------------------------------------------------
  //
  // release       : $CGAL_Revision: CGAL-wip $
  // release_date  : $CGAL_Date$
  //
  // chapter       : $CGAL_Chapter: Optimisation $
  // package       : $CGAL_Package: MinSphere $
  // file          : min_sphere_test.C
  // source        : web/Optimisation/Min_sphere_d.aw
  // revision      : $Id$
  // revision_date : $Date$
  // author(s)     : Sven Schönherr <sven@inf.fu-berlin.de>
  //                 Bernd Gärtner
  //
  // coordinator   : ETH Zurich (Bernd Gärtner <gaertner@inf.ethz.ch>)
  //
  // implementation: dD Smallest Enclosing Sphere
  // ============================================================================
  
  // hack to overcome external linkage conflict warning in MIPS
  #define __SGI_STL_INTERNAL_RELOPS
  
  
  #include <CGAL/Exact_rational.h>
  #include <CGAL/Random.h>
  #include <CGAL/Cartesian_d.h>
  #include <CGAL/Homogeneous_d.h>
  #include <sstream>
  #include <cassert>
  #include <CGAL/Min_sphere_annulus_d_traits_d.h>
  #include <CGAL/Min_sphere_d.h>
  
  using namespace CGAL;
  
  // leda_rational, or Gmpq, or Quotient<MP_float>
  typedef CGAL::Exact_rational                NT;
  typedef NT                                  FT;
  typedef NT                                  RT;
  typedef Cartesian_d<FT>                     C;
  typedef Homogeneous_d<RT>                   H;
  typedef Min_sphere_annulus_d_traits_d<C>    Cartesian_traits;
  typedef Min_sphere_annulus_d_traits_d<H>    Homogeneous_traits;
  typedef Min_sphere_d<Cartesian_traits>      Min_sphereC;
  typedef Min_sphere_d<Homogeneous_traits>    Min_sphereH;
  typedef Point_d<C>                          PointC;
  typedef Point_d<H>                          PointH;
  
  
  // checked traits
  Cartesian_traits                                    tC;
  Homogeneous_traits                                  tH;
  
  const int n = 10;                           // number of points
  const int D = 2;                            // dimension of points
  const int r = 128;                          // coordinate range
  bool verbose = true;
  
  // NT == Quotient<NT> ?
  bool equals (NT x, Quotient<NT> y)
  {
      return (Quotient<NT>(x) == y);
  }
  
  // PointC == Point H ?
  bool equals (PointC p, PointH q)
  {
      int dim =  p.dimension();
      if (q.dimension() != dim) return false;
      for (int j=0; j<dim; ++j)
         if (!equals(p.cartesian(j),q.cartesian(j)))
              return false;
      return true;
  }
  
  
  
  
  int main ()
  {
      Point_d<C>  PC[n];          // cartesian point set
      Point_d<H>  PH[n];          // homogeneous point set
      int         coord[D];       // arrays for random coordinates
      FT          coordC[D];      // ... cartesian version
      RT          coordH[D+1];    // ... homogeneous version
      Random      my_random;      // random number generator
  
  
      for (int i=0; i<n; ++i) {
          int j;
          // random coordinates
          for (j=0; j<D; ++j)
              coord[j] = my_random (r);
  
          // cartesian point
          for (j=0; j<D; ++j)
              coordC[j] = FT (coord[j]);
          PC[i] = Point_d<C>(D, coordC, coordC+D);
  
          // homogeneous point
          for (j=0; j<D; ++j)
              coordH[j] = RT(2*coord[j]);
          coordH[D] = RT(2);
          PH[i] = Point_d<H>(D, coordH, coordH+D+1);
      }
  
  
      // test constructors
  
      // default
      Min_sphereC         msC_empty; assert(msC_empty.is_valid(verbose));
      Min_sphereH         msH_empty; assert(msH_empty.is_valid(verbose));
  
      // from range
      Min_sphereC         msC (PC, PC+n, tC); assert(msC.is_valid(verbose));
      Min_sphereH         msH (PH, PH+n, tH); assert(msH.is_valid(verbose));
  
      // copy
      Min_sphereC         msC1 (msC); assert(msC1.is_valid(verbose));
      Min_sphereH         msH1 (msH); assert(msH1.is_valid(verbose));
  
      PointC              centerC (msC.center()), centerC1 (msC1.center());
      PointH              centerH (msH.center()), centerH1 (msH1.center());
  
      FT                  radiusC (msC.squared_radius()),
                          radiusC1 (msC1.squared_radius());
      Quotient<RT>        radiusH (msH.squared_radius()),
                          radiusH1 (msH1.squared_radius());
  
      assert(equals (centerC, centerH));
      assert(centerC == centerC1); assert(centerH == centerH1);
      assert(equals (radiusC, radiusH));
      assert(radiusC == radiusC1); assert(radiusH == radiusH1);
  
      // assignment
      msC1 = msC; msH1 = msH;
      assert(centerC == centerC1); assert(centerH == centerH1);
      assert(radiusC == radiusC1); assert(radiusH == radiusH1);
  
  
      // test set method
      msC.set (PC, PC+n); assert(msC.is_valid(verbose));
      msH.set (PH, PH+n); assert(msH.is_valid(verbose));
      assert(centerC == msC.center());
      assert(centerH == msH.center());
      assert(radiusC == msC.squared_radius());
      assert(radiusH == msH.squared_radius());
  
      // test clear and insert methods
      msC.clear(); assert(msC.is_valid(verbose));
      msH.clear(); assert(msH.is_valid(verbose));
      msC.insert (PC, PC+n); assert(msC.is_valid(verbose));
      msH.insert (PH, PH+n); assert(msH.is_valid(verbose));
      assert(centerC == msC.center());
      assert(centerH == msH.center());
      assert(radiusC == msC.squared_radius());
      assert(radiusH == msH.squared_radius());
  
      // combined set and insert
      msC.set (PC, PC+n/2); msC.insert (PC+n/2, PC+n);
      assert(msC.is_valid(verbose));
      msH.set (PH, PH+n/2); msH.insert (PH+n/2, PH+n);
      assert(msH.is_valid(verbose));
      assert(centerC == msC.center());
      assert(centerH == msH.center());
      assert(radiusC == msC.squared_radius());
      assert(radiusH == msH.squared_radius());
  
  
      // test access functions
  
      // number_of_points
      assert(msC.number_of_points() == n);
      assert(msH.number_of_points() == n);
  
      // number_of_support_points
      assert(msC.number_of_support_points() == msH.number_of_support_points());
  
      // points_begin, points_end
      std::ptrdiff_t m;
      m = std::distance (msC.points_begin(), msC.points_end());
      assert(m == n);
      m = std::distance (msH.points_begin(), msH.points_end());
      assert(m == n);
  
      // support_points_begin, support_points_end
      m =
      std::distance (msC.support_points_begin(), msC.support_points_end());
      assert(m == msC.number_of_support_points());
      m =
      std::distance (msH.support_points_begin(), msH.support_points_end());
      assert(m == msH.number_of_support_points());
  
      // ambient dim
      assert(msC.ambient_dimension() == D);
      assert(msH.ambient_dimension() == D);
  
      // center and squared radius already tested
  
  
      // test predicates
  
      // bounded_side
      assert(msC.bounded_side (centerC) == ON_BOUNDED_SIDE);
      assert(msH.bounded_side (centerH) == ON_BOUNDED_SIDE);
  
      // has_on_bounded_side
      assert(msC.has_on_bounded_side (centerC));
      assert(msH.has_on_bounded_side (centerH));
  
      // has_on_boundary already tested in is_valid method
      // has_on_unbounded_side already tested in is_valid method
  
      // is_empty
      assert(!msC.is_empty());
      assert(!msH.is_empty());
  
      // is_degenerate
      assert(!msC.is_degenerate());
      assert(!msH.is_degenerate());
  
  
      std::ostringstream ost;           // output string
      IO::set_ascii_mode (ost);
      ost << msC << msH << std::endl;      // write spheres
  
      std::istringstream ist (ost.str().c_str());  // input string
      IO::set_ascii_mode (ist);
      ist >> msC >> msH;              // read spheres
  
      assert(centerC == msC.center());
      assert(centerH == msH.center());
      assert(radiusC == msC.squared_radius());
      assert(radiusH == msH.squared_radius());
  
      return 0;
  }
  
  
  // ===== EOF ==================================================================
  
  