subdivisor_mv_binary.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * cell for bernstein systems
 * 2010-02-16
 *****************************************************************************
 *               Copyright (C) 2010 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/
# ifndef realroot_subdivisor_mv_binary_hpp
# define realroot_subdivisor_mv_binary_hpp

#include <realroot/tensor_bernstein.hpp>
#include <realroot/subdivisor.hpp>
//====================================================================
namespace mmx {

struct mv_binary_approx {
  
  static double m_eps;

  template<class Cell, class Stack>
  static void subdivide(Cell* cl, Stack* stack);

  template<class Cell>
  static bool reduce(Cell* cl);

  template<class Cell>
  static bool regular(Cell* cl);

} ;

double mv_binary_approx::m_eps=1e-6;

template<class Cell, class Stack> void 
mv_binary_approx::subdivide(Cell* cl, Stack* st) {
  //std::cout<<"Subdivide "<<cl->equation(0)<< " "<<cl->domain(0)<<std::endl;

  Cell* left  = new Cell(*cl);
  Cell* right = new Cell(*cl);

  unsigned v=0; 
  typename Cell::Scalar s=cl->domain(0).upper()-cl->domain(0).lower(),s0;
  for (unsigned i=0;i<cl->nbvar();i++)
    if((s0=cl->domain(i).upper()-cl->domain(i).lower())>s) {
    s=s0;v=i;
    }
  typename Cell::Scalar m=(cl->domain(v).upper()+cl->domain(v).lower())/2;

  for (unsigned i=0;i<cl->nbeq();i++)
    tensor::split(left->equation(i), right->equation(i), v);
  left->domain(v).upper()=m;
  right->domain(v).lower()=m;

  //  std::cout<<"==> "<<left->equation(0)<< " "<<left->domain(0)<<std::endl;
  //  std::cout<<"==> "<<right->equation(0)<< " "<<right->domain(0)<<std::endl;
  //  std::cout<<std::endl;

  st->push(left); 
  st->push(right);
};

template<class Cell> bool
mv_binary_approx::reduce(Cell* cl) {  
  if(cl->size() < m_eps) return false;
  for(unsigned i=0;i<cl->nbeq();i++)
    if(!has_sign_variation(cl->equation(i))) return false;
  return true; 
}

template<class Cell> bool
mv_binary_approx::regular(Cell* cl) { 
  for(unsigned i=0;i<cl->nbeq();i++)
    if(!has_sign_variation(cl->equation(i))) return false;
  return true;
}

//--------------------------------------------------------------------
struct mv_binary_isolate: mv_binary_approx {
  
  template<class Cell>
  static bool reduce(Cell* cl);

} ;

template<class Cell> bool
mv_binary_isolate::reduce(Cell* cl) {  
  if(cl->size() < m_eps) return false;
  std::cout<<"isolate"<<std::endl;
  for(unsigned i=0;i<cl->nbeq();i++)
    if(!has_sign_variation(cl->equation(i))) return false;
  
  return true; 
}

//====================================================================
} // namespace mmx
//====================================================================
# endif