예제 #1
0
/* Creation of an empty piecewise constraint for variable v */
void rp_ctr_piecewise_create(rp_ctr_piecewise * c, int v)
{
  rp_malloc(*c,rp_ctr_piecewise,sizeof(rp_ctr_piecewise_def));
  rp_ctr_piecewise_var(*c) = v;
  rp_ctr_piecewise_ptr(*c) = NULL;
  rp_ctr_piecewise_arity(*c) = 0;
  rp_union_create(&rp_ctr_piecewise_guard(*c));
}
예제 #2
0
char *rp_strdup(char *str)
{
	if (!str)
	    return NULL;

	char *ret = rp_malloc( strlen(str) + 1 , NULL, NULL);
	strcpy(ret, str);

	return ret;
}
예제 #3
0
/* Creation of the numerical constraint (l rel r) */
void rp_ctr_num_create(rp_ctr_num * c,
                       rp_erep * l, int rel, rp_erep * r)
{
  rp_malloc(*c,rp_ctr_num,sizeof(rp_ctr_num_def));

  /* creation of the constraint functional expression */
  if ((rp_erep_type(*l)==RP_EREP_NODE_CST) &&
      (rp_interval_zero(rp_erep_val(*l))))
  {
    /* 0 rel r */
    rp_erep rc;
    rp_erep_copy(&rc,*r);
    rp_expression_create(&rp_ctr_num_func(*c),&rc);
    switch( rel )
    {
      case RP_RELATION_EQUAL:
        rp_ctr_num_relfunc(*c) = RP_RELATION_EQUAL;
        break;

      case RP_RELATION_SUPEQUAL:
        rp_ctr_num_relfunc(*c) = RP_RELATION_INFEQUAL;
        break;

      case RP_RELATION_INFEQUAL:
        rp_ctr_num_relfunc(*c) = RP_RELATION_SUPEQUAL;
        break;
    }
  }
  else if((rp_erep_type(*r)==RP_EREP_NODE_CST) &&
          (rp_interval_zero(rp_erep_val(*r))))
  {
    /* l rel 0 */
    rp_erep lc;
    rp_erep_copy(&lc,*l);
    rp_expression_create(&rp_ctr_num_func(*c),&lc);
    rp_ctr_num_relfunc(*c) = rel;
  }
  else
  {
    /* l rel r */
    rp_erep lc, rc, f;
    rp_erep_copy(&lc,*l);
    rp_erep_copy(&rc,*r);
    rp_erep_create_binary(&f,RP_SYMBOL_SUB,lc,rc);
    rp_erep_destroy(&lc);
    rp_erep_destroy(&rc);
    rp_expression_create(&rp_ctr_num_func(*c),&f);
    rp_ctr_num_relfunc(*c) = rel;
  }

  /* creation of constraint */
  rp_expression_create(&rp_ctr_num_left(*c),l);
  rp_expression_create(&rp_ctr_num_right(*c),r);
  rp_ctr_num_rel(*c) = rel;
}
예제 #4
0
char *rp_strreverse(const char *target)
{
    register int i = 0,
    length         = strlen(target), 
    j              = length;

    register char *ret       = rp_malloc(length + 1, NULL, NULL);
    register const char *str = target;

    ret[length] = '\0';

    for (j--; j >= length / 2; i++, j--) 
    {
        ret[i] = str[j];
        ret[j] = str[i];
    }

    return ret;
}