Exemplo n.º 1
0
// check whether the subtree rooted at x is ordered
static bool is_ordered(rba_buffer_t *b, uint32_t x) {
  uint32_t i, j;
  pprod_t *r, *s, *t;

  assert(x < b->num_nodes);

  if (x == 0) return true;

  i = b->child[x][0];  // left child
  j = b->child[x][1];  // right child
  r = b->mono[x].prod;
  s = b->mono[i].prod;
  t = b->mono[j].prod;

  // the expected order is s < r < t
  if (i != 0 && !pprod_precedes(s, r)) {
    printf("tree not ordered at node %"PRIu32" (for left child %"PRIu32")\n", x, i);
    fflush(stdout);
    return false;
  }

  if (j != 0 && !pprod_precedes(r, t)) {
    printf("tree not ordered at node %"PRIu32" (for right child = %"PRIu32")\n", x, j);
    fflush(stdout);
    return false;
  }

  return is_ordered(b, i) && is_ordered(b, j);
}
Exemplo n.º 2
0
void		quicksort(t_env *env)
{
	t_elem	*tmp;

	while (!is_ordered(env))
	{
		env->pivot = choose_pivot(env);
		while (env->a_start->value < env->pivot)
			pushing_to_b(env);
		while (1)
		{
			tmp = env->a_start;
			while (tmp && tmp->value >= env->pivot)
				tmp = tmp->next;
			if (!tmp)
				break ;
			while (env->a_start->value < env->pivot)
				pushing_to_b(env);
			if (env->a_start->next && ASTA > ANEX &&
				ANEX > env->pivot)
				move_sa(env);
			(!is_ordered(env)) ? move_ra(env) : 0;
		}
	}
	optimize_order(env);
	while (env->b_start)
		move_pa(env);
}
Exemplo n.º 3
0
bool is_ordered(tree* T, elem lower, elem upper, bst B) {
  if (T == NULL) return true;
  return T->data != NULL
    && (lower == NULL || B->elem_compare(lower, T->data) < 0)
    && (upper == NULL || B->elem_compare(T->data, upper) < 0)
    && is_ordered(T->left, lower, T->data, B)
    && is_ordered(T->right, T->data, upper, B);
}
int alphabet_score(std::vector<std::string> const& words, alphabet_t const& alpabet)
{
	return std::count_if(
		words.begin(), words.end(),
		[&alpabet](std::string const& word) { return is_ordered(word, alpabet); }
	);
}
Exemplo n.º 5
0
 /*override*/void* operator()( void* item ) {
     Harness::ConcurrencyTracker ct;
     if( is_serial() )
         ASSERT( !my_is_running, "premature entry to serial stage" );
     my_is_running = true;
     Buffer* b = get_buffer(item);
     if( b ) {
         if( is_ordered() ) {
             if( b->sequence_number == Buffer::unused ) 
                 b->sequence_number = current_token-1;
             else
                 ASSERT( b->sequence_number==current_token-1, "item arrived out of order" );
         } else if( is_serial() ) {
             if( b->sequence_number != current_token-1 && b->sequence_number != Buffer::unused )
                 out_of_order_count++;
         }
         ASSERT( b->id < StreamSize, NULL ); 
         ASSERT( !my_done[b->id], "duplicate processing of token?" ); 
         ASSERT( b->is_busy, NULL );
         my_done[b->id] = true;
         if( my_is_last ) {
             b->id = Buffer::unused;
             b->sequence_number = Buffer::unused;
             __TBB_store_with_release(b->is_busy, false);
         }
     }
     my_is_running = false;
     return b;  
 }
Exemplo n.º 6
0
int		main(int argc, char **argv)
{
	t_pretty	*first;
	t_pretty	*second;
	int			data;
	int			index;

	error_handling(argc, argv);
	index = 2;
	first = new_node(ft_atoi(argv[1]));
	while (index < argc)
	{
		data = ft_atoi(argv[index]);
		add_node(first, data);
		index++;
	}
	if (is_ordered(first))
	{
		ft_putstr("\n");
		return (0);
	}
	fill_second(first, &second);
	filler(second);
	first = second;
	ft_putstr("\n");
	return (0);
}
Exemplo n.º 7
0
bool ValueFilter::validate() const {
    if (mask == 0) {
        return false;
    }
    if ((mask & (1 << LT)) && (mask & (1 << LE))) {
        return false;
    }
    if ((mask & (1 << GT)) && (mask & (1 << GE))) {
        return false;
    }
    return is_ordered();
}
Exemplo n.º 8
0
// ordering constraints for the full tree
static bool tree_is_ordered(rba_buffer_t *b) {
  return is_ordered(b, b->root);
}
Exemplo n.º 9
0
bool is_tree(tree* T, bst B) {
  return is_ordered(T, NULL, NULL, B)
    && is_specified_height(T)
    && is_balanced(T);
}