Exemple #1
0
// Construction
rp_operator_newton::rp_operator_newton(const rp_problem * p,
                                       int n, double improve):
  rp_operator(RP_OPERATOR_NEWTON_PRIORITY,n,n),
//  _problem(const_cast<rp_problem*>(p)),
  _improve(improve),
  _arity(n),
  _vi(0),
  _fi(0)
{
  rp_malloc(_v,int*,n*sizeof(int));
  rp_malloc(_f,rp_expression*,n*sizeof(rp_expression));
  rp_malloc(_vf,int**,n*sizeof(int*));

  rp_box_create(&_midpoint,rp_problem_nvar(*p));

  rp_interval zero;
  rp_interval_set_point(zero,0.0);
  rp_interval_matrix_create(&_jacobi,_arity,_arity);
  rp_interval_matrix_create(&_izero,_arity,_arity);
  rp_interval_matrix_set(_izero,zero);

  rp_interval_vector_create(&_negfmid,_arity);
  rp_interval_vector_create(&_unknown,_arity);

  rp_real_matrix_create(&_midjacobi,_arity,_arity);
  rp_real_matrix_create(&_precond,_arity,_arity);
  rp_real_matrix_create(&_identity,_arity,_arity);
  rp_real_matrix_setid(_identity);

  rp_interval_matrix_create(&_precond_jacobi,_arity,_arity);
  rp_interval_vector_create(&_precond_negfmid,_arity);

//test type
  type = 3;
}
Exemple #2
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 #3
0
/* fact_aux ::= ^ NUMBER | epsilon */
int rp_rule_fact_aux(rp_parser p, rp_erep * out, rp_erep unit)
{
  int res = 0;
  /* ^ */
  if (rp_parser_accept(p,RP_TOKEN_POW))
  {
    rp_erep exponent;
    if (rp_rule_unit(p,&exponent))
    {
      long sign, num, den;
      if (rp_erep_is_rational(exponent,&sign,&num,&den))
      {
        if (den==0)
        {
          rp_parser_stop(p,"division by zero");
        }

        /* exponent is integer */
        else if (den==1)
        {
          res = 1;

          /* positive integer => f^n */
          if (sign==1)
          {
            rp_erep exp;
            rp_interval i;
            rp_interval_set_point(i,num);
            rp_erep_create_cst(&exp,"",i);
            rp_erep_create_binary(out,RP_SYMBOL_POW,unit,exp);
            rp_erep_destroy(&exp);
          }

          /* negative integer => 1/f^n*/
          else
          {
            rp_erep exp, aux, one;
            rp_interval i;
            rp_interval_set_point(i,num);
            rp_erep_create_cst(&exp,"",i);
            rp_interval_set_point(i,1.0);
            rp_erep_create_cst(&one,"",i);
            rp_erep_create_binary(&aux,RP_SYMBOL_POW,unit,exp);
            rp_erep_create_binary(out,RP_SYMBOL_DIV,one,aux);
            rp_erep_destroy(&exp);
            rp_erep_destroy(&one);
            rp_erep_destroy(&aux);
          }
        }

        /* general case */
        else
        {
          rp_erep log_unit, mul_exp_log;
          rp_erep_create_unary(&log_unit,RP_SYMBOL_LOG,unit);
          rp_erep_create_binary(&mul_exp_log,RP_SYMBOL_MUL,exponent,log_unit);
          rp_erep_create_unary(out,RP_SYMBOL_EXP,mul_exp_log);
          rp_erep_destroy(&log_unit);
          rp_erep_destroy(&mul_exp_log);
          res = 1;
        }
      }

      /* general case: f^exponent <=> exp(exponent * log(f)) */
      else
      {
        rp_erep log_unit, mul_exp_log;
        rp_erep_create_unary(&log_unit,RP_SYMBOL_LOG,unit);
        rp_erep_create_binary(&mul_exp_log,RP_SYMBOL_MUL,exponent,log_unit);
        rp_erep_create_unary(out,RP_SYMBOL_EXP,mul_exp_log);
        rp_erep_destroy(&log_unit);
        rp_erep_destroy(&mul_exp_log);
        res = 1;
      }
      rp_erep_destroy(&exponent);
    }
  }
  else
  {
    /* epsilon */
    rp_erep_set(out,unit);
    res = 1;
  }
  return( res );
}