Beispiel #1
0
int
isequal(Node *a, Node *b)
{
	if (!a && !b)
		return 1;

	if (!a || !b)
	{	if (!a)
		{	if (b->ntyp == TRUE)
				return 1;
		} else
		{	if (a->ntyp == TRUE)
				return 1;
		}
		return 0;
	}
	if (a->ntyp != b->ntyp)
		return 0;

	if (a->sym
	&&  b->sym
	&&  strcmp(a->sym->name, b->sym->name) != 0)
		return 0;

	if (isequal(a->lft, b->lft)
	&&  isequal(a->rgt, b->rgt))
		return 1;

	return sameform(a, b);
}
Beispiel #2
0
static int
all_bucky(State *a, State *b)
{	Transition *s, *t;
	int found, result = 0;

	for (s = a->trans; s; s = s->nxt)
	{	if (s->redundant) continue;
		found = 0;
		for (t = b->trans; t; t = t->nxt)
		{	if (t->redundant) continue;

			if (isequal(s->cond, t->cond))
			{	if (strcmp(s->name->name, b->name->name) == 0
				&&  strcmp(t->name->name, a->name->name) == 0)
				{	found = 1;	/* they point to each other */
					t->marked = 1;
					break;
				}
				if (strcmp(s->name->name, t->name->name) == 0
				&&  strcmp(s->name->name, "accept_all") == 0)
				{	found = 1;
					t->marked = 1;
					break;
				/* same exit from which there is no return */
				}
			}
		}
		if (!found)
			goto done;
	}
	for (s = b->trans; s; s = s->nxt)
	{	if (s->redundant || s->marked) continue;
		found = 0;
		for (t = a->trans; t; t = t->nxt)
		{	if (t->redundant) continue;

			if (isequal(s->cond, t->cond))
			{	if (strcmp(s->name->name, a->name->name) == 0
				&&  strcmp(t->name->name, b->name->name) == 0)
				{	found = 1;
					t->marked = 1;
					break;
				}
				if (strcmp(s->name->name, t->name->name) == 0
				&&  strcmp(s->name->name, "accept_all") == 0)
				{	found = 1;
					t->marked = 1;
					break;
				}
			}
		}
		if (!found)
			goto done;
	}
	result = 1;
done:
	for (s = b->trans; s; s = s->nxt)
		s->marked = 0;
	return result;
}
Beispiel #3
0
var_type max(var_type p1,var_type p2){
	if(!isnumeric(p1) || !isnumeric(p2))
		return NULL;
	else if(isequal(p1,TYPE_FLOAT) || isequal(p2,TYPE_FLOAT))
		return TYPE_FLOAT;
	else if(isequal(p1,TYPE_INT) || isequal(p2,TYPE_INT))
		return TYPE_INT;
	else
		return TYPE_CHAR;
}
Beispiel #4
0
static int
sametrans(Transition *s, Transition *t)
{
	if (strcmp(s->name->name, t->name->name) != 0)
		return 0;
	return isequal(s->cond, t->cond);
}
Beispiel #5
0
/* 
 * There are two problems here, both resulting from rd and rs conflicts:
 *	1. rr is used to store the initial value of rs
 *	2. rd == rs, then conflict.
 */
static void mgeni (v_reg_type rd, v_reg_type rs, v_reg_type t, int x) {
     char *p = mlookup[x];
     v_reg_type rr, t2 = 0, lastr;
     int equal;
     demand(x, bogus value);
     if (x >= LSIZE) {
	  v_mulii(rd, rs, x);
	  return;
     }
     p++;
     lastr = rd;
     if((equal = isequal(rd,rs))) {
	  if(v_getreg(&rd, V_I, V_TEMP) < 0) 
	       v_fatal("mgen: out of registers\n");
	  t2 = rd;
     }
     rr = rs;
     while(1) {
	  switch(*p++) {
	  case NEGATE: if(*p == DONE) rd = lastr;
	       v_negi(rd, rr);
	       break;
	  case SHIFT_ADD: v_lshii(t, rr, *p++);
	       if(*p == DONE) rd = lastr;
	       v_addi(rd, t, rs);
	       break;
	  case SHIFT_SUB: v_lshii(t, rr, *p++);
	       if(*p == DONE) rd = lastr;
	       v_subi(rd, t, rs);
	       break;
	  case SHIFT_REV: v_lshii(t, rr, *p++);
	       if(*p == DONE) rd = lastr;
	       v_subi(rd, rs, t);
	       break;
	  case FACTOR_ADD: v_lshii(t, rr, *p++);
	       if(*p == DONE) v_addi(lastr, t, rd);
	       else    v_addi(rd, t, rd);
	       break;
	  case FACTOR_SUB: 
	       v_lshii(t, rr, *p++);
	       if(*p == DONE) v_subi(lastr, t, rd);
	       else v_subi(rd, t, rd);
	       break;
	  case FACTOR_REV: 
	       v_lshii(t, rr, *p++);
	       if(*p == DONE) v_subi(lastr, rd, t);
	       else    v_subi(rd, rd, t);
	       break;
	  case SHIFT:	  if(p[1] == DONE) rd = lastr;
	       v_lshii(rd, rr, *p++);
	       break;
	  case DONE:	  goto quit;
	  default:	  demand(0, bogus op);
	  }	  
	  rr = rd;
     }	  
quit:	 
	  if(equal) 
	       v_putreg(t2, V_I );
} 
void* gencthreadfunc(void* thearg){
	gencstruct* arg=(gencstruct*)thearg;
	gencreturnstruct* ret=&arg->ret;
	aprioriset tset;
	aprioriset* pset=&tset;

	int i, j=0, k, flag, ccount=0;

	ret->num=0;
	for(i=arg->num;i<arg->l->num;i++){
		flag=0;
		if(numofmatch(&arg->l->valuelist[i], arg->s)==arg->length-1){
			mergeset(pset, &arg->l->valuelist[i], arg->s);
				pset->length=arg->length+1;
			for(k=0;k<j;k++){
				if(isequal(pset, &ret->valuelist[k])){
					flag=1;
					break;
				}
			}
			if(flag){
				deleteaprioriset(&pset);
			}
			else{
				ret->valuelist[j]=*pset;
				ret->proper[j]=isproper(&ret->valuelist[j], arg->l);
				ret->num++;
				j++;
			}
		}
	}
}
Beispiel #7
0
int already_done(Node *p) /* finds the id of the node, if already explored */
{
  int i;
  for(i = 1; i<node_id; i++) 
    if (isequal(p, label[i])) 
      return i;
  return -1;
}
/**
 * @brief isequal
 * @param Tree one and tree two to compare
 * @return 0 if they are not structurally identical
 */
int isequal(const node* t1, const node *t2){
    /* Both Empty -> True */
    if ( t1 == NULL && t2 == NULL) {
        return 1 ;
    }
    else if( t1!= NULL && t2 != NULL){
        if( strcmp(t1->name,t2->name)==0 && strcmp(t1->name,"value")){
            return (t1->value == t2->value);
        }
        else {
            return ( strcmp(t1->name,t2->name)==0 &&
                    isequal(t1->left,t2->left) &&
                    isequal(t1->right,t2->right));
        }
    }
    /* One tree is empty, other is not */
    else return 0;
}
Beispiel #9
0
banlrec *Banlist_ban(char *ban)
{
	banlrec	*b;

	for(b=Banlist->banlist; b!=NULL; b=b->next)
		if(isequal(b->ban,ban))
			return b;

	return NULL;
}
Beispiel #10
0
 bool contains(HASHTABLE<KEY,VALUE> *ht, KEY k){
 	//tmp point to the  root
 	HASHTABLE<KEY,VALUE> *tmp;

 	for (tmp = ht[hashfunc(ht,k)].next; tmp != NULL; tmp=tmp->next)
 	{
 		if(isequal(k,tmp->key))
 			return true;
 	}
 	return false;
 }
Beispiel #11
0
/* copies upvalues between lua states' stacks */
static int luaproc_copyupvalues( lua_State *Lfrom, lua_State *Lto, 
                                 int funcindex ) {

  int i = 1;
  const char *str;
  size_t len;

  /* test the type of each upvalue and, if it's supported, copy it */
  while ( lua_getupvalue( Lfrom, funcindex, i ) != NULL ) {
    switch ( lua_type( Lfrom, -1 )) {
      case LUA_TBOOLEAN:
        lua_pushboolean( Lto, lua_toboolean( Lfrom, -1 ));
        break;
      case LUA_TNUMBER:
        copynumber( Lto, Lfrom, -1 );
        break;
      case LUA_TSTRING: {
        str = lua_tolstring( Lfrom, -1, &len );
        lua_pushlstring( Lto, str, len );
        break;
      }
      case LUA_TNIL:
        lua_pushnil( Lto );
        break;
      /* if upvalue is a table, check whether it is the global environment
         (_ENV) from the source state Lfrom. in case so, push in the stack of
         the destination state Lto its own global environment to be set as the
         corresponding upvalue; otherwise, treat it as a regular non-supported
         upvalue type. */
      case LUA_TTABLE:
        lua_pushglobaltable( Lfrom );
        if ( isequal( Lfrom, -1, -2 )) {
          lua_pop( Lfrom, 1 );
          lua_pushglobaltable( Lto );
          break;
        }
        lua_pop( Lfrom, 1 );
        /* FALLTHROUGH */
      default: /* value type not supported: table, function, userdata, etc. */
        lua_pushnil( Lfrom );
        lua_pushfstring( Lfrom, "failed to copy upvalue of unsupported type "
                                "'%s'", luaL_typename( Lfrom, -2 ));
        return FALSE;
    }
    lua_pop( Lfrom, 1 );
    if ( lua_setupvalue( Lto, 1, i ) == NULL ) {
      lua_pushnil( Lfrom );
      lua_pushstring( Lfrom, "failed to set upvalue" );
      return FALSE;
    }
    i++;
  }
  return TRUE;
}
Beispiel #12
0
NT2_TEST_CASE_TPL( cov_scalar, NT2_REAL_TYPES )
{
  T x = nt2::cov(T(42));
  NT2_TEST_EQUAL( x, T(0) );

  x = nt2::cov(T(42),1);
  NT2_TEST_EQUAL( x, T(0) );

  nt2::table<T> y = nt2::cov(T(42),T(1));
  NT2_TEST( isequal(y, nt2::zeros(2, 2, nt2::meta::as_<T>())));
}
Beispiel #13
0
int
any_term(Node *srch, Node *in)
{
	if (!in) return 0;

	if (in->ntyp == AND)
		return	any_term(srch, in->lft) ||
			any_term(srch, in->rgt);

	return isequal(in, srch);
}
Beispiel #14
0
int
any_lor(Node *srch, Node *in)
{
	if (!in) return 0;

	if (in->ntyp == OR)
		return	any_lor(srch, in->lft) ||
			any_lor(srch, in->rgt);

	return isequal(in, srch);
}
Beispiel #15
0
Node *
in_cache(Node *n)
{	Cache *d; int nr=0;

	for (d = stored; d; d = d->nxt, nr++)
		if (isequal(d->before, n))
		{	CacheHits++;
			if (d->same && ismatch(n, d->before)) return n;
			return dupnode(d->after);
		}
	return ZN;
}
void add(aprioristruct* data, aprioriset* value, int equal){
	int i;
	if(equal){
		for(i=0;i<data->num;i++){
			if(isequal(value, &data->valuelist[i])){
				deleteaprioriset(&value);
				return;
			}
		}
	}
	data->valuelist[data->num]=*value;
	data->num++;
}
int isequal(genpt a,genpt b){
	genpt temp_a=a,temp_b=b;

	while(temp_a!=NULL && temp_b!=NULL){
		if(isequalnode(temp_a,temp_b))
			return -1;
		if(temp_a->tag==sublist){
			genpt la=temp_a->u.list;
			genpt lb=temp_b->u.list;
			if(isequal(la,lb))
				return -1;
		}
		temp_a=temp_a->link;
		temp_b=temp_b->link;
	}
	return 0;
}
Beispiel #18
0
 VALUE get(HASHTABLE<KEY,VALUE> *ht, KEY k){
 	HASHTABLE<KEY,VALUE> *tmp = ht[hashfunc(ht,k)].next;
 	if (contains(ht,k))
 	{
 		while(tmp!=NULL){

 			if (isequal(tmp->key,k))
 				return tmp->value;
 			tmp = tmp->next;

 		}
 	}else{
 		cout <<"Cannot be found!\n";
 		VALUE z_v;
 		return z_v;
 	}
 }
Beispiel #19
0
static int
implies(Node *a, Node *b, int *cnt, char *uform, int *tl_yychar, Miscellaneous *miscell)
{
  return
    (isequal(a,b, cnt, uform, tl_yychar, miscell) ||
     b->ntyp == TRUE ||
     a->ntyp == FALSE ||
     (b->ntyp == AND && implies(a, b->lft, cnt, uform, tl_yychar, miscell) && implies(a, b->rgt, cnt, uform, tl_yychar, miscell)) ||
     (a->ntyp == OR && implies(a->lft, b, cnt, uform, tl_yychar, miscell) && implies(a->rgt, b, cnt, uform, tl_yychar, miscell)) ||
     (a->ntyp == AND && (implies(a->lft, b, cnt, uform, tl_yychar, miscell) || implies(a->rgt, b, cnt, uform, tl_yychar, miscell))) ||
     (b->ntyp == OR && (implies(a, b->lft, cnt, uform, tl_yychar, miscell) || implies(a, b->rgt, cnt, uform, tl_yychar, miscell))) ||
     (b->ntyp == U_OPER && implies(a, b->rgt, cnt, uform, tl_yychar, miscell)) ||
     (a->ntyp == V_OPER && implies(a->rgt, b, cnt, uform, tl_yychar, miscell)) ||
     (a->ntyp == U_OPER && implies(a->lft, b, cnt, uform, tl_yychar, miscell) && implies(a->rgt, b, cnt, uform, tl_yychar, miscell)) ||
     (b->ntyp == V_OPER && implies(a, b->lft, cnt, uform, tl_yychar, miscell) && implies(a, b->rgt, cnt, uform, tl_yychar, miscell)) ||
     ((a->ntyp == U_OPER || a->ntyp == V_OPER) && a->ntyp == b->ntyp && 
         implies(a->lft, b->lft, cnt, uform, tl_yychar, miscell) && implies(a->rgt, b->rgt, cnt, uform, tl_yychar, miscell)));
}
Beispiel #20
0
static cmdrec_t *cmdrec_cmd(cmdrec_t **list, cmdrec_t **last, char *name)
{
	cmdrec_t *c, *lastchecked = NULL;

	for(c=*list; c!=NULL; c=c->next)
	{
		if(isequal(c->name,name))
		{
			/* found it.  do a movetofront. */
			cmdrec_movetofront(list,last,lastchecked,c);

			return c;
		}
		lastchecked = c;
	}

	return NULL;
}
Beispiel #21
0
static int
implies(Node *a, Node *b)
{
  return
    (isequal(a,b) ||
     b->ntyp == TRUE ||
     a->ntyp == FALSE ||
     (b->ntyp == AND && implies(a, b->lft) && implies(a, b->rgt)) ||
     (a->ntyp == OR && implies(a->lft, b) && implies(a->rgt, b)) ||
     (a->ntyp == AND && (implies(a->lft, b) || implies(a->rgt, b))) ||
     (b->ntyp == OR && (implies(a, b->lft) || implies(a, b->rgt))) ||
     (b->ntyp == U_OPER && implies(a, b->rgt)) ||
     (a->ntyp == V_OPER && implies(a->rgt, b)) ||
     (a->ntyp == U_OPER && implies(a->lft, b) && implies(a->rgt, b)) ||
     (b->ntyp == V_OPER && implies(a, b->lft) && implies(a, b->rgt)) ||
     ((a->ntyp == U_OPER || a->ntyp == V_OPER) && a->ntyp == b->ntyp && 
         implies(a->lft, b->lft) && implies(a->rgt, b->rgt)));
}
Beispiel #22
0
void v_cmuli (v_reg_type rd, v_reg_type rs, int x) {
     v_reg_type t1;
     if(!x) {
	  v_seti(rd, 0);
	  return;
     } else if(x == 1) {
	  if(isequal(rd, rs))	  
	       return;
	  v_movi(rd, rs);
	  return;
     }	     v_getreg(&t1, V_I, V_TEMP);
     if(x >= 0) {
	  mgeni(rd, rs, t1, x);
     } else {
	  mgeni(rd, rs, t1, -x);
	  v_negi(rd, rd);
     }
     v_putreg(t1, V_I);
} 
Beispiel #23
0
void v_cmulu (v_reg_type rd, v_reg_type rs, unsigned x) {
     v_reg_type t1;
     if(!x) {
	  v_setu(rd, 0);
	  return;
     } else if(x == 1) {
	  if(isequal(rd, rs))
	       return;
	  v_movu(rd, rs);
	  return;
     }
     v_getreg(&t1, V_U, V_TEMP);
     if(x >= 0) {
	  mgenu(rd, rs, t1, x);
     } else {
	  mgenu(rd, rs, t1, -x);
	  v_negu(rd, rd);
     }	     
     v_putreg(t1, V_U);
} 
Beispiel #24
0
banlrec *Banlist_match(char *ban, chanrec *chan)
{
	banlrec	*bl;

	for(bl=Banlist->banlist; bl!=NULL; bl=bl->next)
	{
		if(bl->chan == NULL)
		{
			if(wild_match(bl->ban,ban) || wild_match(ban,bl->ban))
				return bl;
		}
		else if(isequal(bl->chan->name,chan->name))
		{
			if(wild_match(bl->ban,ban) || wild_match(ban,bl->ban))
				return bl;
		}
	}
		

	return NULL;
}
Beispiel #25
0
NT2_TEST_CASE_TPL( tsxfun_1, NT2_TYPES)
{
  nt2::table<T> a = nt2::rif(nt2::of_size(3, 1), nt2::meta::as_<T>()),
    b = nt2::cif(nt2::of_size(1, 3), nt2::meta::as_<T>()),
    c = nt2::ones(3, 3, nt2::meta::as_<T>()), 
    d, e;
  NT2_DISPLAY(a);
  NT2_DISPLAY(b);
  NT2_DISPLAY(c);
  d = nt2::bsxfun(nt2::functor<nt2::tag::plus_>(), nt2::bsxfun(nt2::functor<nt2::tag::multiplies_>(), a, b), c);
  NT2_DISPLAY(d);
  e = tsxfun(nt2::functor<nt2::tag::fma_>(),  a, b, c);
  NT2_DISPLAY(e);
  NT2_TEST(isequal(e, d)); 
//   for(unsigned int i=1; i <= length(a); i++)
//    {
//      for(unsigned int j=1; j <= length(a); j++)
//        {
//          NT2_TEST_EQUAL(e(i, j), d(i, j)); 
//        }
//    }
}
int isproper(aprioriset* set, aprioristruct* str){
	aprioriset* tset;
	int strcount;
	int setcount=set->length-1;
	initaprioriset(&tset, setcount);
	int i;
	for(i=0;i<set->length-1;i++){
		if(i==setcount)
			continue;
		else if(i<setcount){
			tset->value[i]=set->value[i];
		}
		else{
			tset->value[i-1]=set->value[i];
		}
	}
	
	for(strcount=0;strcount<str->num;strcount++){
		if(isequal(tset, &str->valuelist[strcount])){
			if(setcount==0)
				return 1;
			else{
				setcount--;
				for(i=0;i<set->length;i++){
					if(i==setcount)
						continue;
					else if(i<setcount){
						tset->value[i]=set->value[i];
					}
					else{
						tset->value[i-1]=set->value[i];
					}
				}
			}
		}
	}
	return 0;
}
Beispiel #27
0
static int
implies(Node *a, Node *b)
{
  return
    (isequal(a,b) ||
     b->ntyp == TRUE ||
     a->ntyp == FALSE ||
     (b->ntyp == AND && implies(a, b->lft) && implies(a, b->rgt)) ||
     (a->ntyp == OR && implies(a->lft, b) && implies(a->rgt, b)) ||
     (a->ntyp == AND && (implies(a->lft, b) || implies(a->rgt, b))) ||
     (b->ntyp == OR && (implies(a, b->lft) || implies(a, b->rgt))) ||
     (b->ntyp == U_OPER && implies(a, b->rgt)) ||
     (a->ntyp == V_OPER && implies(a->rgt, b)) ||
     (a->ntyp == U_OPER && implies(a->lft, b) && implies(a->rgt, b)) ||
     (b->ntyp == V_OPER && implies(a, b->lft) && implies(a, b->rgt)) ||
     ((a->ntyp == U_OPER || a->ntyp == V_OPER) && a->ntyp == b->ntyp && 
         implies(a->lft, b->lft) && implies(a->rgt, b->rgt))
#ifdef NXT
     || (b->ntyp == NEXT && is_G(a) && implies(a, b->lft))
     || (a->ntyp == NEXT && is_F(b) && implies(a->lft, b))
     || (a->ntyp == NEXT && b->ntyp == NEXT && implies(a->lft, b->lft)));
     
#else
     );
Beispiel #28
0
//  main
void main(){
    int i;  
    FILE *fp;

    
    // Obtain output of ASM and inline using test vectors for verification 
    for (i = 0; i < NUM_INPUTS ; i++) {
        a0[i] = exp2(a[i]);
    }
    for (i = 0; i < NUM_INPUTS ; i++) {
        a1[i] = exp2dp(a[i]);
    }
    for (i = 0; i < NUM_INPUTS; i++) {
        a2[i] = exp2dp_c(a[i]);
    }
	for (i = 0; i < NUM_INPUTS ; i++) {
        a3[i] = exp2dp_i(a[i]);
    }
    exp2dp_v(a, a4, NUM_INPUTS);
    

    
    //  Random Data
    //  Load in a new random number seed from seedfile, or if seedfile
    //  does not exist, pick an initial fixed seed.  Then seed rand().
    
    //  intialize seed if the file does not exist
    seed = 0x2A3A4A5A;
    
    // if the seed file exist read and seed the value to seed
    if ((fp = fopen(seed_fname,"r")) != NULL)   /* open seed file   */
    {
        fscanf(fp,"%d",&seed);                  /* get current seed */
        fclose(fp);
    }
    srand(seed);

    // Generate random test vectors.
    arg = array0;
    
    for (i = 0 ; i < BUF_SIZE; i++) {
        arg[i] = gimme_random();
    }   

    // Compute the overhead of calling clock twice to get timing info
    t_start = clock();
    t_stop = clock();
    t_offset = t_stop - t_start;
    
    output0 = array1;
    output1 = array2;
    output2 = array3;
    output3 = array4;
    output4 = array5;
    
    // Time the RTS function 
    t_start = clock();
    for (i = 0; i < BUF_SIZE; i++) {
        output0[i] = exp2(arg[i]);
    }
    t_stop = clock();

    clockdata[0] = t_stop - t_start - t_offset;
    clockdata[0] = clockdata[0] / BUF_SIZE;

    // Time the fastRTS ASM function
    t_start = clock();
    for (i = 0; i < BUF_SIZE; i++) {
        output1[i] = exp2dp(arg[i]);
    }
    t_stop = clock();

    clockdata[1] = t_stop - t_start - t_offset;
    clockdata[1] = clockdata[1] / BUF_SIZE;

    // Time the fastRTS C intrinsic function
    t_start = clock();
    for (i = 0; i < BUF_SIZE; i++) {
        output2[i] = exp2dp_c(arg[i]);
    }
    t_stop = clock();

    clockdata[2] = t_stop - t_start - t_offset;
    clockdata[2] = clockdata[2] / BUF_SIZE;

    // Time the fastRTS inlined function    
    t_start = clock();  
    for (i = 0; i < BUF_SIZE; i++) {
        output3[i] = exp2dp_i(arg[i]);
    }
    t_stop = clock();
    
    clockdata[3] = t_stop - t_start - t_offset;
    clockdata[3] = clockdata[3] / BUF_SIZE;
    
    // Time the fastRTS vector function
    t_start = clock();  
    exp2dp_v(arg, output4, BUF_SIZE);
    t_stop = clock();
    
    clockdata[4] = t_stop - t_start - t_offset;
    clockdata[4] = clockdata[4] / BUF_SIZE;
    

    // Display Test Vector Verificaition Results 
    printf ("Verification Results:\n");
    printf ("-------------------------------------------------------------------------------------------------------\n");
    printf ("Predefined Test Vector: ");

    pass_flag1 =    (isequal(a0, a1, NUM_INPUTS, RET_VAL_TOL)) && 
                    (isequal(a0, a2, NUM_INPUTS, RET_VAL_TOL)) &&
                    (isequal(a0, a3, NUM_INPUTS, RET_VAL_TOL)) &&
                    (isequal(a0, a4, NUM_INPUTS, RET_VAL_TOL));
    
    
    if (pass_flag1){
        printf ("Passed\n");
    }
    else{
        printf ("Failed\n");
    }


    // Display Random Test Vector Results   
    printf ("Random Test Vector (seed = %d): ", seed);


    pass_flag2 =    (isequal(output0, output1, BUF_SIZE, RET_VAL_TOL)) && 
                    (isequal(output0, output2, BUF_SIZE, RET_VAL_TOL)) &&
                    (isequal(output0, output3, BUF_SIZE, RET_VAL_TOL)) &&
                    (isequal(output0, output4, BUF_SIZE, RET_VAL_TOL));


    if (pass_flag2)
    {
        printf ("Passed\n");
    }
    else{
        printf ("Failed\n");
    }


    if (pass_flag2)
    {
        seed = rand();                      /* get next seed  */
        if (!(fp = fopen(seed_fname,"w")))  /* open seed file */
        {   
            printf("failure writing seed file \"%s\"\n", seed_fname);
            exit(1);
        }
        fprintf(fp,"%d\n",seed);            /* set next seed  */
        fclose(fp);
    }   
    printf ("-------------------------------------------------------------------------------------------------------\n");
    

    // Display average clock for RTS, ASM, Inlined and Vector methods
    printf ("\n");
    printf ("Number of Clocks for exp2:\n");
    printf ("-------------------------------------------------------------------------------------------------------\n");
    printf ("RTS\t\tASM\t\tC\t\tInlined\t\tVector \n");
    printf ("-------------------------------------------------------------------------------------------------------\n");
    
    printf ("%d\t\t%d\t\t%d\t\t%d\t\t%d\n",
            (int)clockdata[0], (int)clockdata[1], (int)clockdata[2], (int)clockdata[3], (int)clockdata[4]);
}
static Node *
bin_simpler(Node *ptr)
{	Node *a, *b;

	if (ptr)
	switch (ptr->ntyp) {
	case U_OPER:
#ifndef NO_OPT
		if (ptr->rgt->ntyp == TRUE
		||  ptr->rgt->ntyp == FALSE
		||  ptr->lft->ntyp == FALSE)
		{	ptr = ptr->rgt;
			break;
		}
		if (isequal(ptr->lft, ptr->rgt))
		{	/* p U p = p */	
			ptr = ptr->rgt;
			break;
		}
		if (ptr->lft->ntyp == U_OPER
		&&  isequal(ptr->lft->lft, ptr->rgt))
		{	/* (p U q) U p = (q U p) */
			ptr->lft = ptr->lft->rgt;
			break;
		}
		if (ptr->rgt->ntyp == U_OPER
		&&  ptr->rgt->lft->ntyp == TRUE)
		{	/* p U (T U q)  = (T U q) */
			ptr = ptr->rgt;
			break;
		}
#ifdef NXT
		/* X p U X q == X (p U q) */
		if (ptr->rgt->ntyp == NEXT
		&&  ptr->lft->ntyp == NEXT)
		{	ptr = tl_nn(NEXT,
				tl_nn(U_OPER,
					ptr->lft->lft,
					ptr->rgt->lft), ZN);
		}
#endif
#endif
		break;
	case V_OPER:
#ifndef NO_OPT
		if (ptr->rgt->ntyp == FALSE
		||  ptr->rgt->ntyp == TRUE
		||  ptr->lft->ntyp == TRUE)
		{	ptr = ptr->rgt;
			break;
		}
		if (isequal(ptr->lft, ptr->rgt))
		{	/* p V p = p */	
			ptr = ptr->rgt;
			break;
		}
		/* F V (p V q) == F V q */
		if (ptr->lft->ntyp == FALSE
		&&  ptr->rgt->ntyp == V_OPER)
		{	ptr->rgt = ptr->rgt->rgt;
			break;
		}
		/* p V (F V q) == F V q */
		if (ptr->rgt->ntyp == V_OPER
		&&  ptr->rgt->lft->ntyp == FALSE)
		{	ptr->lft = False;
			ptr->rgt = ptr->rgt->rgt;
			break;
		}
#endif
		break;
	case IMPLIES:
#ifndef NO_OPT
		if (isequal(ptr->lft, ptr->rgt))
		{	ptr = True;
			break;
		}
#endif
		ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt);
		ptr = rewrite(ptr);
		break;
	case EQUIV:
#ifndef NO_OPT
		if (isequal(ptr->lft, ptr->rgt))
		{	ptr = True;
			break;
		}
#endif
		a = rewrite(tl_nn(AND,
			dupnode(ptr->lft),
			dupnode(ptr->rgt)));
		b = rewrite(tl_nn(AND,
			Not(ptr->lft),
			Not(ptr->rgt)));
		ptr = tl_nn(OR, a, b);
		ptr = rewrite(ptr);
		break;
	case AND:
#ifndef NO_OPT
		/* p && (q U p) = p */
		if (ptr->rgt->ntyp == U_OPER
		&&  isequal(ptr->rgt->rgt, ptr->lft))
		{	ptr = ptr->lft;
			break;
		}
		if (ptr->lft->ntyp == U_OPER
		&&  isequal(ptr->lft->rgt, ptr->rgt))
		{	ptr = ptr->rgt;
			break;
		}

		/* p && (q V p) == q V p */
		if (ptr->rgt->ntyp == V_OPER
		&&  isequal(ptr->rgt->rgt, ptr->lft))
		{	ptr = ptr->rgt;
			break;
		}
		if (ptr->lft->ntyp == V_OPER
		&&  isequal(ptr->lft->rgt, ptr->rgt))
		{	ptr = ptr->lft;
			break;
		}

		/* (p U q) && (r U q) = (p && r) U q*/
		if (ptr->rgt->ntyp == U_OPER
		&&  ptr->lft->ntyp == U_OPER
		&&  isequal(ptr->rgt->rgt, ptr->lft->rgt))
		{	ptr = tl_nn(U_OPER,
				tl_nn(AND, ptr->lft->lft, ptr->rgt->lft),
				ptr->lft->rgt);
			break;
		}

		/* (p V q) && (p V r) = p V (q && r) */
		if (ptr->rgt->ntyp == V_OPER
		&&  ptr->lft->ntyp == V_OPER
		&&  isequal(ptr->rgt->lft, ptr->lft->lft))
		{	ptr = tl_nn(V_OPER,
				ptr->rgt->lft,
				tl_nn(AND, ptr->lft->rgt, ptr->rgt->rgt));
			break;
		}
#ifdef NXT
		/* X p && X q == X (p && q) */
		if (ptr->rgt->ntyp == NEXT
		&&  ptr->lft->ntyp == NEXT)
		{	ptr = tl_nn(NEXT,
				tl_nn(AND,
					ptr->rgt->lft,
					ptr->lft->lft), ZN);
			break;
		}
#endif

		if (isequal(ptr->lft, ptr->rgt)	/* (p && p) == p */
		||  ptr->rgt->ntyp == FALSE	/* (p && F) == F */
		||  ptr->lft->ntyp == TRUE)	/* (T && p) == p */
		{	ptr = ptr->rgt;
			break;
		}	
		if (ptr->rgt->ntyp == TRUE	/* (p && T) == p */
		||  ptr->lft->ntyp == FALSE)	/* (F && p) == F */
		{	ptr = ptr->lft;
			break;
		}

		/* (p V q) && (r U q) == p V q */
		if (ptr->rgt->ntyp == U_OPER
		&&  ptr->lft->ntyp == V_OPER
		&&  isequal(ptr->lft->rgt, ptr->rgt->rgt))
		{	ptr = ptr->lft;
			break;
		}
#endif
		break;

	case OR:
#ifndef NO_OPT
		/* p || (q U p) == q U p */
		if (ptr->rgt->ntyp == U_OPER
		&&  isequal(ptr->rgt->rgt, ptr->lft))
		{	ptr = ptr->rgt;
			break;
		}

		/* p || (q V p) == p */
		if (ptr->rgt->ntyp == V_OPER
		&&  isequal(ptr->rgt->rgt, ptr->lft))
		{	ptr = ptr->lft;
			break;
		}

		/* (p U q) || (p U r) = p U (q || r) */
		if (ptr->rgt->ntyp == U_OPER
		&&  ptr->lft->ntyp == U_OPER
		&&  isequal(ptr->rgt->lft, ptr->lft->lft))
		{	ptr = tl_nn(U_OPER,
				ptr->rgt->lft,
				tl_nn(OR, ptr->lft->rgt, ptr->rgt->rgt));
			break;
		}

		if (isequal(ptr->lft, ptr->rgt)	/* (p || p) == p */
		||  ptr->rgt->ntyp == FALSE	/* (p || F) == p */
		||  ptr->lft->ntyp == TRUE)	/* (T || p) == T */
		{	ptr = ptr->lft;
			break;
		}	
		if (ptr->rgt->ntyp == TRUE	/* (p || T) == T */
		||  ptr->lft->ntyp == FALSE)	/* (F || p) == p */
		{	ptr = ptr->rgt;
			break;
		}

		/* (p V q) || (r V q) = (p || r) V q */
		if (ptr->rgt->ntyp == V_OPER
		&&  ptr->lft->ntyp == V_OPER
		&&  isequal(ptr->lft->rgt, ptr->rgt->rgt))
		{	ptr = tl_nn(V_OPER,
				tl_nn(OR, ptr->lft->lft, ptr->rgt->lft),
				ptr->rgt->rgt);
			break;
		}

		/* (p V q) || (r U q) == r U q */
		if (ptr->rgt->ntyp == U_OPER
		&&  ptr->lft->ntyp == V_OPER
		&&  isequal(ptr->lft->rgt, ptr->rgt->rgt))
		{	ptr = ptr->rgt;
			break;
		}		
#endif
		break;
	}
	return ptr;
}
Beispiel #30
0
Node *
Canonical(Node *n)
{	Node *m, *p, *k1, *k2, *prev, *dflt = ZN;
	int tok;

	if (!n) return n;

	tok = n->ntyp;
	if (tok != AND && tok != OR)
		return n;

	can = ZN;
	addcan(tok, n);
#if 0
	Debug("\nA0: "); Dump(can); 
	Debug("\nA1: "); Dump(n); Debug("\n");
#endif
	releasenode(1, n);

	/* mark redundant nodes */
	if (tok == AND)
	{	for (m = can; m; m = (m->ntyp == AND) ? m->rgt : ZN)
		{	k1 = (m->ntyp == AND) ? m->lft : m;
			if (k1->ntyp == TRUE)
			{	marknode(AND, m);
				dflt = True;
				continue;
			}
			if (k1->ntyp == FALSE)
			{	releasenode(1, can);
				can = False;
				goto out;
		}	}
		for (m = can; m; m = (m->ntyp == AND) ? m->rgt : ZN)
		for (p = can; p; p = (p->ntyp == AND) ? p->rgt : ZN)
		{	if (p == m
			||  p->ntyp == -1
			||  m->ntyp == -1)
				continue;
			k1 = (m->ntyp == AND) ? m->lft : m;
			k2 = (p->ntyp == AND) ? p->lft : p;

			if (isequal(k1, k2))
			{	marknode(AND, p);
				continue;
			}
			if (anywhere(OR, k1, k2))
			{	marknode(AND, p);
				continue;
			}
	}	}
	if (tok == OR)
	{	for (m = can; m; m = (m->ntyp == OR) ? m->rgt : ZN)
		{	k1 = (m->ntyp == OR) ? m->lft : m;
			if (k1->ntyp == FALSE)
			{	marknode(OR, m);
				dflt = False;
				continue;
			}
			if (k1->ntyp == TRUE)
			{	releasenode(1, can);
				can = True;
				goto out;
		}	}
		for (m = can; m; m = (m->ntyp == OR) ? m->rgt : ZN)
		for (p = can; p; p = (p->ntyp == OR) ? p->rgt : ZN)
		{	if (p == m
			||  p->ntyp == -1
			||  m->ntyp == -1)
				continue;
			k1 = (m->ntyp == OR) ? m->lft : m;
			k2 = (p->ntyp == OR) ? p->lft : p;

			if (isequal(k1, k2))
			{	marknode(OR, p);
				continue;
			}
			if (anywhere(AND, k1, k2))
			{	marknode(OR, p);
				continue;
			}
	}	}
	for (m = can, prev = ZN; m; )	/* remove marked nodes */
	{	if (m->ntyp == -1)
		{	k2 = m->rgt;
			releasenode(0, m);
			if (!prev)
			{	m = can = can->rgt;
			} else
			{	m = prev->rgt = k2;
				/* if deleted the last node in a chain */
				if (!prev->rgt && prev->lft
				&&  (prev->ntyp == AND || prev->ntyp == OR))
				{	k1 = prev->lft;
					prev->ntyp = prev->lft->ntyp;
					prev->sym = prev->lft->sym;
					prev->rgt = prev->lft->rgt;
					prev->lft = prev->lft->lft;
					releasenode(0, k1);
				}
			}
			continue;
		}
		prev = m;
		m = m->rgt;
	}
out:
#if 0
	Debug("A2: "); Dump(can); Debug("\n");
#endif
	if (!can)
	{	if (!dflt)
			fatal("cannot happen, Canonical", (char *) 0);
		return dflt;
	}

	return can;
}