Exemple #1
0
void rp_operator_newton::compute_midpoint(rp_box b)
{
  for (int i=0; i<_arity; ++i)
  {
    rp_interval_set_point(rp_box_elem(_midpoint,_v[i]),
                          rp_interval_midpoint(rp_box_elem(b,_v[i])));
  }
}
Exemple #2
0
void rp_splitter_time::apply(rp_box_set& bs, int var) {
  rp_interval i1, i2;
  rp_box b1 = bs.remove_insert();
  this->observe(b1, var);
  rp_box b2 = bs.insert(b1);

  if (quick_split_vars[&b1] == NULL){
    quick_split_vars[&b1] = new std::set<int>();
  }
  quick_split_vars[&b2] = new std::set<int>(*quick_split_vars[&b1]);

  if (is_time_variable(var) && !did_quick_split(&b1, var)){
    if (this->real_hole(rp_box_elem(b1, var),
                        rp_variable_domain(rp_problem_var(*_problem, var)),
                        i1, i2)){
      rp_interval_copy(rp_box_elem(b1, var), i1);
      rp_interval_copy(rp_box_elem(b2, var), i2);
    } else {
      // std::cout << "TIME SPLIT" << std::endl;
      rp_interval &vi = rp_box_elem(b1, var);
      double split =  std::min(rp_binf(vi) + precision, rp_split_point(rp_binf(vi), rp_bsup(vi), 1000, 1));

      // Real variable: [a,b] --> [center,b] and [a,center]
      rp_binf(rp_box_elem(b1, var)) =
        rp_bsup(rp_box_elem(b2, var)) =
        split;

      quick_split_vars[&b1]->insert(var);
      quick_split_vars[&b2]->insert(var);
        // rp_interval_midpoint(rp_box_elem(b1,var));
    }
  } else if (rp_variable_integer(rp_problem_var(*_problem, var))){
    if (this->integer_hole(rp_box_elem(b1, var),
                           rp_variable_domain(rp_problem_var(*_problem, var)),
                           i1, i2)) {
      rp_interval_copy(rp_box_elem(b1, var), i1);
      rp_interval_copy(rp_box_elem(b2, var), i2);
    } else { // no hole found
      // Integer variable: [a,b] --> [a+1,b] and [a,a]
      ++rp_binf(rp_box_elem(b1, var));
      rp_bsup(rp_box_elem(b2, var)) = rp_binf(rp_box_elem(b2, var));
    }
  } else {
    if (this->real_hole(rp_box_elem(b1, var),
                        rp_variable_domain(rp_problem_var(*_problem, var)),
                        i1, i2)) {
      rp_interval_copy(rp_box_elem(b1, var), i1);
      rp_interval_copy(rp_box_elem(b2, var), i2);
    } else {
      // Real variable: [a,b] --> [center,b] and [a,center]
      rp_binf(rp_box_elem(b1, var)) =
        rp_bsup(rp_box_elem(b2, var)) =
          rp_interval_midpoint(rp_box_elem(b1, var));
    }
  }
}
Exemple #3
0
int rp_operator_newton::compute_precond()
{
  // midpoint of Jacobian matrix
  for (int i=0; i<_arity; ++i)
  {
    for (int j=0; j<_arity; ++j)
    {
      rp_rmatrix_elem(_midjacobi,i,j) =
         rp_interval_midpoint(rp_imatrix_elem(_jacobi,i,j));
    }
  }

  // Inversion of midpoint of Jacobian matrix
  if (rp_real_matrix_inverse(_precond,_midjacobi,_identity))
  {
    rp_matrix_mul_rm_im(_precond_jacobi,_precond,_jacobi);
    rp_matrix_mul_rm_iv(_precond_negfmid,_precond,_negfmid);
    return( 1 );
  }
  else
  {
    return( 0 );
  }
}
void rp_splitter_mixed_hybrid::apply(rp_box_set& bs, int var) {
  rp_interval i1, i2;
  rp_box b1 = bs.remove_insert();
  this->observe(b1, var);
  rp_box b2 = bs.insert(b1);

  rp_box b1_copy;
  rp_box_clone(&b1_copy, b1);
  rp_box suggestion = m_ode_sim_heuristic->sim(b1_copy, var);


  DREAL_LOG_DEBUG << "rp_splitter_mixed_hybrid::apply() "
                  << "suggestion = " << var << " [" << rp_binf(rp_box_elem(suggestion, var)) << ", "
                  << rp_bsup(rp_box_elem(suggestion, var))
                  << "]";
  if (rp_variable_integer(rp_problem_var(*_problem, var)))  {
    if (this->integer_hole(rp_box_elem(b1, var),
                           rp_variable_domain(rp_problem_var(*_problem, var)),
                           i1, i2)){
      if (rp_interval_included(i1, rp_box_elem(suggestion, var))){
        rp_interval_copy(rp_box_elem(b1, var), i1);
        rp_interval_copy(rp_box_elem(b2, var), i2);
      } else{
        rp_interval_copy(rp_box_elem(b1, var), i2);
        rp_interval_copy(rp_box_elem(b2, var), i1);
      }
    } else  { // no hole found
      ++rp_binf(rp_box_elem(b1, var));
      if (rp_interval_included(rp_box_elem(b1, var), rp_box_elem(suggestion, var))){
        // Integer variable: [a,b] --> [a+1,b] and [a,a]
        rp_bsup(rp_box_elem(b2, var)) = rp_binf(rp_box_elem(b2, var));
      } else {
        --rp_binf(rp_box_elem(b1, var));
        ++rp_binf(rp_box_elem(b2, var));
        rp_bsup(rp_box_elem(b1, var)) = rp_binf(rp_box_elem(b1, var));
      }
    }
  }  else  {
    if (this->real_hole(rp_box_elem(b1, var),
                        rp_variable_domain(rp_problem_var(*_problem, var)),
                        i1, i2)) {
      if (rp_interval_included(i1, rp_box_elem(suggestion,  var))){
        rp_interval_copy(rp_box_elem(b1, var), i1);
        rp_interval_copy(rp_box_elem(b2, var), i2);
      }  else {
        rp_interval_copy(rp_box_elem(b1, var), i2);
        rp_interval_copy(rp_box_elem(b2, var), i1);
      }
    }  else {
      // Real variable: [a,b] --> [center,b] and [a,center]
      double mid = rp_interval_midpoint(rp_box_elem(b1, var));

      rp_binf(rp_box_elem(b1, var)) =
        rp_bsup(rp_box_elem(b2, var)) =
          mid;

      double b1Intersection =
        std::min(rp_bsup(rp_box_elem(b1, var)), rp_bsup(rp_box_elem(suggestion, var))) -
        std::max(rp_binf(rp_box_elem(b1, var)), rp_binf(rp_box_elem(suggestion, var)));
      double b2Intersection =
        std::min(rp_bsup(rp_box_elem(b2, var)), rp_bsup(rp_box_elem(suggestion, var))) -
        std::max(rp_binf(rp_box_elem(b2, var)), rp_binf(rp_box_elem(suggestion, var)));

      if (b2Intersection > b1Intersection
          // rp_interval_included(rp_box_elem(suggestion, var), rp_box_elem(b2, var))
          ){
        // okay
        DREAL_LOG_DEBUG << "rp_splitter_mixed_hybrid::apply() "
                        << "*[" << rp_binf(rp_box_elem(b2, var)) << ", " << rp_bsup(rp_box_elem(b2, var))
                        << "]* [" << rp_binf(rp_box_elem(b1, var)) << ", " << rp_bsup(rp_box_elem(b1, var))
                        << "]";
        // cout  << "*[" << rp_binf(rp_box_elem(b2, var)) << ", " << rp_bsup(rp_box_elem(b2, var))
        //                 << "]* [" << rp_binf(rp_box_elem(b1, var)) << ", " << rp_bsup(rp_box_elem(b1, var))
        //                 << "] \t";
      } else if (b2Intersection < b1Intersection){
          // rp_interval_included(rp_box_elem(suggestion, var), rp_box_elem(b1, var))){
        // reverse

        double b2_sup = rp_bsup(rp_box_elem(b1, var));
        rp_binf(rp_box_elem(b1, var)) = rp_binf(rp_box_elem(b2, var));
        rp_bsup(rp_box_elem(b1, var)) = mid;
        rp_binf(rp_box_elem(b2, var)) = mid;
        rp_bsup(rp_box_elem(b2, var)) = b2_sup;
        DREAL_LOG_DEBUG << "rp_splitter_mixed_hybrid::apply() "
                        << "[" << rp_binf(rp_box_elem(b1, var)) << ", " << rp_bsup(rp_box_elem(b1, var))
                        << "] *[" << rp_binf(rp_box_elem(b2, var)) << ", " << rp_bsup(rp_box_elem(b2, var))
                        << "]*";
        // cout << "[" << rp_binf(rp_box_elem(b1, var)) << ", " << rp_bsup(rp_box_elem(b1, var))
        //                 << "] *[" << rp_binf(rp_box_elem(b2, var)) << ", " << rp_bsup(rp_box_elem(b2, var))
        //                 << "]* \t";
      } else {
        DREAL_LOG_DEBUG << "rp_splitter_mixed_hybrid::apply() suggestion not found";
        DREAL_LOG_DEBUG << "rp_splitter_mixed_hybrid::apply() "
                        << "-[" << rp_binf(rp_box_elem(b2, var)) << ", " << rp_bsup(rp_box_elem(b2, var))
                        << "]- [" << rp_binf(rp_box_elem(b1, var)) << ", " << rp_bsup(rp_box_elem(b1, var))
                        << "]";
        // cout << "-[" << rp_binf(rp_box_elem(b2, var)) << ", " << rp_bsup(rp_box_elem(b2, var))
        //      << "]- [" << rp_binf(rp_box_elem(b1, var)) << ", " << rp_bsup(rp_box_elem(b1, var))
        //      << "] \t";
      }
    }
  }
  rp_box_destroy(&b1_copy);
}