Exemple #1
0
/* 
 * Improved q-intersection algorithm.
 */
IntervalVector qinter2(const Array<IntervalVector>& _boxes, int q) {
	

#ifndef _WIN32
	assert(q>0);
	assert(_boxes.size()>0);
	int n = _boxes[0].size();
	
	/* Remove the empty boxes from the list */
	
	int p=0;
	for (int i=0; i<_boxes.size(); i++) { 
		if (!_boxes[i].is_empty()) p++;
	}
	
	if (p==0) return IntervalVector::empty(n);
	
	Array<IntervalVector> boxes(p);
	int j=0;
	for (int i=0; i<_boxes.size(); i++) {
		if (!_boxes[i].is_empty()) boxes.set_ref(j++,_boxes[i]);
	}
	
	/* Create the sets of available boxes for each direction */
	
	IntStack ***dirboxes = (IntStack ***)malloc(n*sizeof(IntStack **));
	for (int i=0; i<n; i++) {
		dirboxes[i] = (IntStack **)malloc(2*sizeof(IntStack *));
		for (int j=0; j<2;j++) {
			dirboxes[i][j] = new IntStack(0,p-1,true);
		}
	}
	
	/* Create the original intersection graph */
	
	KCoreGraph *origin = new KCoreGraph(p,q-1,true);
	
	/* Add edges */
	
	for (int i=0; i<p; i++) {
		for (int j=i+1; j<p; j++) {
			if (boxes[i].intersects(boxes[j])) origin->add_edge(i,j);
		}
	}
	
	/* Initialize the data structures */
	
	vector<BitSet *> nogoods;
	nogoods.reserve(2*n);
	BitSet *curr_set = new BitSet(0,p-1,BitSet::empt);
	
	IntervalVector curr_qinter(n);
	curr_qinter.set_empty();
	IntervalVector hull_qinter(n);
	hull_qinter.set_empty();
	
	vector<IntervalVector *> neighboxes;
	neighboxes.reserve(p);
	vector<int> n_indices;
	n_indices.reserve(p);
	
	int b,b2,nboxes;
	pair<double,int>  *x = new pair<double,int>[p];
	bool first_pass = true;
	bool ng;
	
	/* Compute the q-inter hull */
	
	for (int i=0; i<n; i++) {
		
		/* ######################################################## */
		/* #####                                              ##### */
		/* #####               Left ----> Right               ##### */
		/* #####                                              ##### */
		/* ######################################################## */

		nboxes = dirboxes[i][0]->size;
		
		/* Sort the boxes by increasing order of their left bounds */
		
		b = dirboxes[i][0]->head();
		for (int k=0; k<nboxes; k++) {
			x[k] = make_pair(boxes[b][i].lb(), b);
			b = dirboxes[i][0]->next(b);
		}
		
		sort(x,x+nboxes,leftpaircomp);
		
		/* For each box, look for a (q-1)-inter in its left neighbourhood */
		
		for (int k=q-1; k<nboxes; k++) {
			curr_set->clear();
			b = x[k].second;
			curr_set->add(b);
			
			/* Find the left neighbors */
			neighboxes.clear();
			n_indices.clear();
			for (int l=0; l<k; l++) {
				b2 = x[l].second;
				if (origin->is_edge(b,b2)) {
					neighboxes.push_back(&(boxes[b2]));
					n_indices.push_back(b2);
					curr_set->add(b2);
				}
			}
			
			if (((int)neighboxes.size() )< q-1) continue;
			
			/* Check if it's a nogood */
			ng = false;
			for (unsigned int z=0; z<nogoods.size(); z++) {
				if (nogoods.at(z)->includes(curr_set)) {
					ng = true;
					break;
				}
			}
			
			if (ng) continue;
			
			/* Call to the existence procedure */
			curr_qinter = qinterex_cliquer(neighboxes, n_indices, q-1, origin);
			curr_qinter = curr_qinter & boxes[b];
		
			if (curr_qinter.is_empty()) continue;
			
			/* Optimal q-inter found : extend the q-inter hull and propagate the bounds */
			hull_qinter = hull_qinter | curr_qinter;
			propagate(boxes, dirboxes, i, true, curr_qinter, nogoods);
			break;
		}
		
		if (first_pass && curr_qinter.is_empty()) {
			/* No q-inter on the whole problem. No need to process the other dimensions. */
			break;
		}
		
		first_pass = false;
		
		if (curr_qinter.is_empty()) {
			/* A face of the q-inter hull has been proved optimal, but has not been updated.
			 * There is still some information we can propagate. */
			propagate_no_ub(boxes, dirboxes, i, true, hull_qinter, nogoods);
		}
		
		/* ######################################################## */
		/* #####                                              ##### */
		/* #####               Right ----> Left               ##### */
		/* #####                                              ##### */
		/* ######################################################## */
		
		nboxes = dirboxes[i][1]->size;
		
		/* Sort the boxes by decreasing order of their right bounds */
		
		b = dirboxes[i][1]->head();
		for (int k=0; k<nboxes; k++) {
			x[k] = make_pair(boxes[b][i].ub(), b);
			b = dirboxes[i][1]->next(b);
		}
		
		sort(x,x+nboxes,rightpaircomp);
		
		/* For each box, look for a (q-1)-inter in its right neighbourhood */
		
		for (int k=q-1; k<nboxes; k++) {
			curr_set->clear();
			b = x[k].second;
			curr_set->add(b);
			
			/* Find the right neighbors */
			neighboxes.clear();
			n_indices.clear();
			for (int l=0; l<k; l++) {
				b2 = x[l].second;
				if (origin->is_edge(b,b2)) {
					neighboxes.push_back(&(boxes[b2]));
					n_indices.push_back(b2);
					curr_set->add(b2);
				}
			}
			
			if (((int)neighboxes.size()) < q-1) continue;
			
			/* Check if it's a nogood */
			ng = false;
			for (unsigned int z=0; z<nogoods.size(); z++) {
				if (nogoods.at(z)->includes(curr_set)) {
					ng = true;
					break;
				}
			}
			
			if (ng) continue;
			
			/* Call to the existence procedure */
			curr_qinter = qinterex_cliquer(neighboxes, n_indices, q-1, origin);
			curr_qinter = curr_qinter & boxes[b];
			
			if (curr_qinter.is_empty()) continue;
			
			/* Optimal q-inter found : extend the q-inter hull and propagate the bounds */
			hull_qinter = hull_qinter | curr_qinter;
			if (i!=n) propagate(boxes, dirboxes, i, false, curr_qinter, nogoods);
			break;
		}
		
		if (curr_qinter.is_empty() && (i!=n)) {
			/* A face of the q-inter hull has been proved optimal, but has not been updated.
			 * There is still some information we can propagate. */
			propagate_no_ub(boxes, dirboxes, i, false, hull_qinter, nogoods);
		}
	}
	
	/* Cleanup */
	for (int i=0; i<n; i++) {
		for (int j=0; j<2;j++) {
			delete(dirboxes[i][j]);
		}
		free(dirboxes[i]);
	}
	free(dirboxes);
	
	delete [] x;
	delete(origin);
	
	delete(curr_set);
	for (unsigned int i=0; i<nogoods.size(); i++) delete(nogoods.at(i));
	
	return hull_qinter;
#else
	not_implemented("Cliquer-based q-intersection under Windows");
	return IntervalVector::empty(_boxes[0].size());
#endif

}
Exemple #2
0
siglist realPropagate (Tree slotenv, Tree path, Tree box, const siglist&  lsig)
{
	int		i;
	double	r;
	prim0	p0;
	prim1	p1;
	prim2	p2;
	prim3	p3;
	prim4	p4;
	prim5	p5;
	
    Tree	t1, t2, ff, label, cur, min, max, step, type, name, file, slot, body, chan;
    tvec    wf;
	
	
	xtended* xt = (xtended*)getUserData(box);
	
	// Extended Primitives
	
	if (xt)	{
		faustassert(lsig.size() == xt->arity());
		return makeList(xt->computeSigOutput(lsig));
	}
		
	// Numbers and Constants
	
	else if (isBoxInt(box, &i)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigInt(i)); 
	}
	else if (isBoxReal(box, &r)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigReal(r)); 
	}

    // A Waveform has two outputs it size and a period signal representing its content

    else if (isBoxWaveform(box)) 	{
        faustassert(lsig.size()==0);
        const tvec br = box->branches();
        return listConcat(makeList(sigInt(int(br.size()))), makeList(sigWaveform(br)));
    }

    else if (isBoxFConst(box, type, name, file))    { 
        faustassert(lsig.size()==0); 
        return makeList(sigFConst(type, name, file)); 
    }
    
    else if (isBoxFVar(box, type, name, file))    { 
        faustassert(lsig.size()==0); 
        return makeList(sigFVar(type, name, file)); 
    }
	
	// Wire and Cut
	
	else if (isBoxCut(box)) 				{ 
		faustassert(lsig.size()==1); 
		return siglist(); 
	}
	
	else if (isBoxWire(box)) 				{ 
		faustassert(lsig.size()==1); 
		return lsig;  
	}
	
	// Slots and Symbolic Boxes
	
	else if (isBoxSlot(box)) 				{ 
		Tree sig;
		faustassert(lsig.size()==0); 
		if (!searchEnv(box,sig,slotenv)) {
			// test YO simplification des diagrames
			//fprintf(stderr, "propagate : internal error (slot undefined)\n");
			sig = sigInput(++gGlobal->gDummyInput);
		}
		return makeList(sig);
	}
	
	else if (isBoxSymbolic(box, slot, body)) 				{ 
		faustassert(lsig.size()>0); 
		return propagate(pushEnv(slot,lsig[0],slotenv), path, body, listRange(lsig, 1, (int)lsig.size()));
	}
	
	// Primitives
	
	else if (isBoxPrim0(box, &p0)) 			{ 
		faustassert(lsig.size()==0); 
		return makeList(p0());
	}
	
	else if (isBoxPrim1(box, &p1)) 				{ 
		faustassert(lsig.size()==1); 
		return makeList(p1(lsig[0]));
	}
	
	else if (isBoxPrim2(box, &p2)) 				{ 
//		printf("prim2 recoit : "); print(lsig); printf("\n");
		faustassert(lsig.size()==2);
        if (p2 == &sigEnable) {
            if (gGlobal->gEnableFlag) {
                // special case for sigEnable that requires a transformation
                // enable(X,Y) -> sigEnable(X*Y, Y>0)
                return makeList(sigEnable( sigMul(lsig[0],lsig[1]), sigGT(lsig[1],sigReal(0.0))));
            } else {
                // We gEnableFlag is false we replace enable by a simple multiplication
                return makeList(sigMul(lsig[0],lsig[1]));
            }
        } else if (p2 == &sigControl) {
            if (gGlobal->gEnableFlag) {
                // special case for sigEnable that requires a transformation
                // enable(X,Y) -> sigEnable(X*Y, Y>0)
                return makeList(sigEnable( lsig[0], lsig[1]));
            } else {
                // We gEnableFlag is false we replace control by identity function
                return makeList(lsig[0]);
            }
        }
        return makeList( p2(lsig[0],lsig[1]) );
	}
	
	else if (isBoxPrim3(box, &p3)) 				{ 
		faustassert(lsig.size()==3); 
		return makeList(p3(lsig[0],lsig[1],lsig[2]));
	}
	
	else if (isBoxPrim4(box, &p4)) 				{ 
		faustassert(lsig.size()==4); 
		return makeList(p4(lsig[0],lsig[1],lsig[2],lsig[3]));
	}
	
	else if (isBoxPrim5(box, &p5)) 				{ 
		faustassert(lsig.size()==5); 
		return makeList(p5(lsig[0],lsig[1],lsig[2],lsig[3],lsig[4]));
	}
	
	else if (isBoxFFun(box, ff)) 				{ 
		//cerr << "propagate en boxFFun of arity " << ffarity(ff) << endl;
		faustassert(int(lsig.size())==ffarity(ff)); 
		return makeList(sigFFun(ff, listConvert(lsig)));  
	}
	
	// User Interface Widgets
	
	else if (isBoxButton(box, label)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigButton(normalizePath(cons(label, path)))); 
	}
	
	else if (isBoxCheckbox(box, label)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigCheckbox(normalizePath(cons(label, path)))); 
	}
	
	else if (isBoxVSlider(box, label, cur, min, max, step)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigVSlider(normalizePath(cons(label, path)), cur, min, max, step)); 
	}
	
	else if (isBoxHSlider(box, label, cur, min, max, step)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigHSlider(normalizePath(cons(label, path)), cur, min, max, step)); 
	}

	else if (isBoxNumEntry(box, label, cur, min, max, step)) 	{ 
		faustassert(lsig.size()==0); 
		return makeList(sigNumEntry(normalizePath(cons(label, path)), cur, min, max, step)); 
	}
	
	else if (isBoxVBargraph(box, label, min, max)) 	{ 
		faustassert(lsig.size()==1); 
		return makeList(sigVBargraph(normalizePath(cons(label, path)), min, max, lsig[0])); 
	}
	
	else if (isBoxHBargraph(box, label, min, max)) 	{ 
		faustassert(lsig.size()==1); 
		return makeList(sigHBargraph(normalizePath(cons(label, path)), min, max, lsig[0])); 
	}
	
	else if (isBoxSoundfile(box, label, chan)) 	{ 
		faustassert(lsig.size()==1);
        Tree fullpath = normalizePath(cons(label, path));
        Tree soundfile = sigSoundfile(fullpath);
        int c = tree2int(chan);
        siglist lsig2(c+3);
        lsig2[0] = sigSoundfileLength(soundfile);
        lsig2[1] = sigSoundfileRate(soundfile);
        lsig2[2] = sigSoundfileChannels(soundfile);

		// compute bound limited read index : int(max(0, min(ridx,length-1)))
		Tree ridx = sigIntCast(tree(gGlobal->gMaxPrim->symbol(), sigInt(0), tree(gGlobal->gMinPrim->symbol(), lsig[0], sigAdd(lsig2[0],sigInt(-1)))));
		for (int i = 0; i<c; i++) {
			lsig2[i+3] = sigSoundfileBuffer(soundfile, sigInt(i), ridx);
		}
		return lsig2; 
	}
	
	// User Interface Groups
	
	else if (isBoxVGroup(box, label, t1)) 	{ 
		return propagate(slotenv,cons(cons(tree(0),label), path), t1, lsig); 
	}
	
	else if (isBoxHGroup(box, label, t1)) 	{ 
		return propagate(slotenv, cons(cons(tree(1),label), path), t1, lsig); 
	}
	
	else if (isBoxTGroup(box, label, t1)) 	{ 
		return propagate(slotenv, cons(cons(tree(2),label), path), t1, lsig); 
	}
	
	// Block Diagram Composition Algebra
	
	else if (isBoxSeq(box, t1, t2)) 	{ 
		int in1, out1, in2, out2;
		getBoxType(t1, &in1, &out1);
		getBoxType(t2, &in2, &out2);

        faustassert(out1==in2);

		if (out1 == in2) {
			return propagate(slotenv, path, t2, propagate(slotenv, path,t1,lsig));
		} else if (out1 > in2) {
			siglist lr = propagate(slotenv, path, t1,lsig);
			return listConcat(propagate(slotenv, path, t2, listRange(lr, 0, in2)), listRange(lr, in2, out1));
		} else {
			return propagate(slotenv, path, t2, listConcat( propagate(slotenv, path, t1, listRange(lsig,0,in1)), listRange(lsig,in1,in1+in2-out1)));
		}
	}
	
	else if (isBoxPar(box, t1, t2)) 	{ 
		int in1, out1, in2, out2;
		getBoxType(t1, &in1, &out1);
		getBoxType(t2, &in2, &out2);
			
		return listConcat(propagate(slotenv, path, t1, listRange(lsig, 0,  in1)),
                          propagate(slotenv, path, t2, listRange(lsig, in1, in1+in2)));
	}
	
	else if (isBoxSplit(box, t1, t2)) 	{ 
		int in1, out1, in2, out2;
		getBoxType(t1, &in1, &out1);
		getBoxType(t2, &in2, &out2);
		
		siglist l1 = propagate(slotenv, path, t1, lsig);
		siglist l2 = split(l1, in2);
		return propagate(slotenv, path, t2, l2);
	}
	
	else if (isBoxMerge(box, t1, t2)) 	{ 
		int in1, out1, in2, out2;
		getBoxType(t1, &in1, &out1);
		getBoxType(t2, &in2, &out2);
		
		siglist l1 = propagate(slotenv, path, t1, lsig);
		siglist l2 = mix(l1, in2);
		return propagate(slotenv, path, t2, l2);
	}

    else if (isBoxRec(box, t1, t2)) 	{
        // Bug Corrected
        int in1, out1, in2, out2;
        getBoxType(t1, &in1, &out1);
        getBoxType(t2, &in2, &out2);

        Tree slotenv2 = lift(slotenv); // the environment must also be lifted

        siglist l0 = makeMemSigProjList(ref(1), in2);
        siglist l1 = propagate(slotenv2, path, t2, l0);
        siglist l2 = propagate(slotenv2, path, t1, listConcat(l1,listLift(lsig)));
		siglist l3 = (gGlobal->gFTZMode > 0) ? wrapWithFTZ(l2) : l2;
        Tree g = rec(listConvert(l3));
        return makeSigProjList(g, out1);
    }

    stringstream error;
    error << "ERROR in file " << __FILE__ << ':' << __LINE__ << ", unrecognised box expression : " << boxpp(box) << endl;
    throw faustexception(error.str());

	return siglist();
}
Exemple #3
0
 void operator() ( double t, grid2D<> & u0, grid2D<> & v0, grid2D<> & u1, grid2D<> & v1 )
 {
     propagate( t, u0, v0, u1, v1 );
 }
Exemple #4
0
pass2()
{
    register struct dinode *dp;
    register struct inoinfo **inpp, *inp;
    struct inoinfo **inpend;
    struct inodesc curino;
    struct dinode dino;
    char pathbuf[MAXPATHLEN + 1];

    switch (statemap[ROOTINO]) {

    case USTATE:
        pfatal("ROOT INODE UNALLOCATED");
        if (reply("ALLOCATE") == 0)
            errexit("");
        if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
            errexit("CANNOT ALLOCATE ROOT INODE\n");
        break;

    case DCLEAR:
        pfatal("DUPS/BAD IN ROOT INODE");
        if (reply("REALLOCATE")) {
            freeino(ROOTINO);
            if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
                errexit("CANNOT ALLOCATE ROOT INODE\n");
            break;
        }
        if (reply("CONTINUE") == 0)
            errexit("");
        break;

    case FSTATE:
    case FCLEAR:
        pfatal("ROOT INODE NOT DIRECTORY");
        if (reply("REALLOCATE")) {
            freeino(ROOTINO);
            if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
                errexit("CANNOT ALLOCATE ROOT INODE\n");
            break;
        }
        if (reply("FIX") == 0)
            errexit("");
        dp = ginode(ROOTINO);
        dp->di_mode &= ~IFMT;
        dp->di_mode |= IFDIR;
        inodirty();
        break;

    case DSTATE:
        break;

    default:
        errexit("BAD STATE %d FOR ROOT INODE", statemap[ROOTINO]);
    }
    statemap[ROOTINO] = DFOUND;
    /*
     * Sort the directory list into disk block order.
     */
    qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
    /*
     * Check the integrity of each directory.
     */
    bzero((char *)&curino, sizeof(struct inodesc));
    curino.id_type = DATA;
    curino.id_func = pass2check;
    dp = &dino;
    inpend = &inpsort[inplast];
    for (inpp = inpsort; inpp < inpend; inpp++) {
        inp = *inpp;
        if (inp->i_isize == 0)
            continue;
        if (inp->i_isize < MINDIRSIZE) {
            direrror(inp->i_number, "DIRECTORY TOO SHORT");
            inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
            if (reply("FIX") == 1) {
                dp = ginode(inp->i_number);
                dp->di_size = inp->i_isize;
                inodirty();
                dp = &dino;
            }
        } else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
            getpathname(pathbuf, inp->i_number, inp->i_number);
            pwarn("DIRECTORY %s: LENGTH %d NOT MULTIPLE OF %d",
                  pathbuf, inp->i_isize, DIRBLKSIZ);
            if (preen)
                printf(" (ADJUSTED)\n");
            inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
            if (preen || reply("ADJUST") == 1) {
                dp = ginode(inp->i_number);
                dp->di_size = roundup(inp->i_isize, DIRBLKSIZ);
                inodirty();
                dp = &dino;
            }
        }
        bzero((char *)&dino, sizeof(struct dinode));
        dino.di_mode = IFDIR;
        dp->di_size = inp->i_isize;
        bcopy((char *)&inp->i_blks[0], (char *)&dp->di_db[0],
              (size_t)inp->i_numblks);
        curino.id_number = inp->i_number;
        curino.id_parent = inp->i_parent;
        (void)ckinode(dp, &curino);
    }
    /*
     * Now that the parents of all directories have been found,
     * make another pass to verify the value of `..'
     */
    for (inpp = inpsort; inpp < inpend; inpp++) {
        inp = *inpp;
        if (inp->i_parent == 0 || inp->i_isize == 0)
            continue;
        if (statemap[inp->i_parent] == DFOUND &&
                statemap[inp->i_number] == DSTATE)
            statemap[inp->i_number] = DFOUND;
        if (inp->i_dotdot == inp->i_parent ||
                inp->i_dotdot == (ino_t)-1)
            continue;
        if (inp->i_dotdot == 0) {
            inp->i_dotdot = inp->i_parent;
            fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
            if (reply("FIX") == 0)
                continue;
            (void)makeentry(inp->i_number, inp->i_parent, "..");
            lncntp[inp->i_parent]--;
            continue;
        }
        fileerror(inp->i_parent, inp->i_number,
                  "BAD INODE NUMBER FOR '..'");
        if (reply("FIX") == 0)
            continue;
        lncntp[inp->i_dotdot]++;
        lncntp[inp->i_parent]--;
        inp->i_dotdot = inp->i_parent;
        (void)changeino(inp->i_number, "..", inp->i_parent);
    }
    /*
     * Mark all the directories that can be found from the root.
     */
    propagate();
}
Exemple #5
0
int propagate( int state , Config_set *A , Config_set *B )
{
    
    STATE *shift_state;
    Config_set *C_ptr , *ptr;
    TOKEN *T_ptr , *first;
    TOKEN *dot;
    TOKEN *L2;
    TOKEN *L1;
    int i;
    
    L1 = A->lookahead;
    dot = A->dot;
    L2 = B->lookahead;
    
    
    //First(£^L)
    for( T_ptr = dot->next ; T_ptr != NULL ; T_ptr = T_ptr->next )
    {
        first = search_token( first_set_start , T_ptr->string );
        if (first == NULL )
            continue;
        if ( search_set(first,"£f") == TRUE )
        {
            add_set(L2,first);
            delete_set( &(L2->set) , "£f" );
            continue;
        }
        else
        {
            if ( add_set(L2,first) == FALSE ) 
                return 0;
            break;
        }
    }
    //First(£^L) ,  £^ is lambda
    if(T_ptr == NULL)
    {
        add_set( L2 , L1 );         
    }
    
    //printf("%d\n", parser_table[state][make_id(dot->string)].go_to );
    if( B->dot == NULL )
        return 0;
    
    i = parser_table[state][make_id(B->dot->string)-1].go_to;
    //printf("%d  %s -> %d\n",state , B->dot->string , i );
    //view_state(state);


    if( i == state )
        return 0;
    // shift state
    for( shift_state = state_start ; i != shift_state->statenum ; shift_state = shift_state->next );
    
    for( C_ptr = shift_state->config_set ; C_ptr != NULL && B->rule != C_ptr->rule ; C_ptr = C_ptr->set_next );
    {
//        if ( i == 105 )
//            printf("hit\n");
        propagate_link( i , B , C_ptr );
    }
    
    //comput lookahead by closue 0
    C_ptr = shift_state->config_set;
    
    
    for( C_ptr = shift_state->config_set ; C_ptr != NULL && C_ptr->set_next != NULL ; C_ptr = C_ptr->set_next )
    {
        for( ptr = shift_state->config_set ; ptr != NULL ; ptr = ptr->set_next )
        {
            if ( C_ptr->dot == NULL ) 
                continue;
            if ( strcmp( C_ptr->dot->string , ptr->rule->lhs ) == 0 )
            {
                propagate( shift_state->statenum , C_ptr , ptr );
            }
        }
    }
	return 0;    
}
Exemple #6
0
 void propagate (Treelog& msg) const
 {
   daisy_assert (!closed);
   for (size_t i = 0; i < entries.size (); i++)
     propagate (msg, entries[i].nest, entries[i].text);
 }
 void assign(int varIndex)
 {
     assert(connected());
     wcsp->revise(this);
     if (x->assigned() && y->assigned()) {
         deconnect();
         if (x->getValue() >= xinfty && y->getValue() >= yinfty && costx + costy > deltaCost) {
             projectLB(costx + costy - deltaCost);
         } else if (x->getValue() >= xinfty && y->getValue() < yinfty && costx > deltaCost) {
             projectLB(costx - deltaCost);
         } else if (y->getValue() >= yinfty && x->getValue() < xinfty && costy > deltaCost) {
             projectLB(costy - deltaCost);
         } else if (x->getValue() < xinfty && y->getValue() < yinfty && x->getValue() < y->getValue() + csty && y->getValue() < x->getValue() + cstx) {
             THROWCONTRADICTION;
         }
     } else {
         if (varIndex == 0 && x->getValue() >= xinfty) {
             if (y->getInf() == deltaValueYinf) {
                 Cost cost = deltaCostYinf;
                 deltaCostYinf = MIN_COST;
                 y->projectInfCost(-cost);
             }
             if (y->getSup() == deltaValueYsup) {
                 Cost cost = deltaCostYsup;
                 deltaCostYsup = MIN_COST;
                 y->projectSupCost(-cost);
             }
             Cost cost = costx - deltaCost;
             if (cost > MIN_COST) {
                 deltaCost += cost;
                 projectLB(cost);
             }
             if (y->getSup() < yinfty) {
                 deconnect();
             } else {
                 assert(y->getSup() == yinfty);
                 deltaValueYsup = yinfty;
                 deltaCostYsup = costy;
                 y->projectSupCost(costy);
             }
         } else if (varIndex == 1 && y->getValue() >= yinfty) {
             if (x->getInf() == deltaValueXinf) {
                 Cost cost = deltaCostXinf;
                 deltaCostXinf = MIN_COST;
                 x->projectInfCost(-cost);
             }
             if (x->getSup() == deltaValueXsup) {
                 Cost cost = deltaCostXsup;
                 deltaCostXsup = MIN_COST;
                 x->projectSupCost(-cost);
             }
             Cost cost = costy - deltaCost;
             if (cost > MIN_COST) {
                 deltaCost += cost;
                 projectLB(cost);
             }
             if (x->getSup() < xinfty) {
                 deconnect();
             } else {
                 assert(x->getSup() == xinfty);
                 deltaValueXsup = xinfty;
                 deltaCostXsup = costx;
                 x->projectSupCost(costx);
             }
         } else {
             propagate();
         }
     }
 }
Exemple #8
0
void FlatUCBMod::propagate(Node* node, double score, bool invalidate, int UCTPlayer)
{
	if (!node->isRoot && node->playerPlaying != UCTPlayer)
		propagate(node->parentPtr, score, invalidate, UCTPlayer);
	else
	{
		node->visited++;
		if (true)
		{
			if (node->opt.type != DRAW && node->opt.type != THIEFFLIP)
			{
				node->sum += score;
				node->value = double(node->sum) / double(node->visited);
			}
		}
		else
		{
			/* Explanation
			If we are calculating the score for a node, that is not a node HAVING -CHILDREN,
			then we simply take the SCORE and check whether it is better than what we already have.
			If it is, then we replace the old score with the new score (optimal and guaranteed path)

			However, if we are calculating the score for a node that HAS draw-children, (either all or none are draw-children),
			then we calculate the score to be child.value * child.probability / totalAccumulatedProbability.
			Where the totalAccumulatedProbability is equal to all the addition of all VISITED children's probability.
			(Visited = 2 or more, since we initialize all to Draw-Nodes to visited = 1).
			Note that we omit the propagated score value from the last node.
			After the value is calculated, we propagate this new value, instead of the old score, forcing ancestors to receive it, regardless of old score,
			so that the ancestor-nodes receive a weighted average of the draws, instead of the best possible node, based on an unlikely draw.
			The reasoning behind the force is (not midi-clorians) that as more draws are explored, their weighted average is becoming more precise,
			thus we want to propagate a precise value, rather than the best value.		*/

			if (node->childrenPtrs.size() == 0)
			{
				node->value = score;
			}
			else if (node->childrenPtrs[0]->opt.type == DRAW)
			{
				double totalAccumulatedProbability = 0;
				for (std::vector<Node*>::iterator child = node->childrenPtrs.begin(); child != node->childrenPtrs.end(); ++child)
				{
					if ((*child)->visited > 1)
						totalAccumulatedProbability += (*child)->probability;
				}
				double newValue = 0;
				for (std::vector<Node*>::iterator child = node->childrenPtrs.begin(); child != node->childrenPtrs.end(); ++child)
				{
					if ((*child)->visited > 1)
					{
						if ((*child)->value < 0)
							int n = 5;
						newValue += ((*child)->probability / totalAccumulatedProbability) * (*child)->value;
					}
				}
				node->value = newValue;
				score = newValue;
				invalidate = true;
			}
			else if (0 == node->childrenPtrs[0]->playerPlaying)	// Maximize value
			{
				/*if (invalidate)
				{*/
				node->value = score;
				for (std::vector<Node*>::iterator child = node->childrenPtrs.begin(); child != node->childrenPtrs.end(); ++child)
				{
					if ((*child)->value > node->value && (*child)->visited > 0)
					{
						if ((*child)->value < 0)
							int n = 5;
						node->value = (*child)->value;
					}
				}
				/*}
				else
				{
				if (score > node->value)
				node->value = score;

				}*/
			}
			else// Minimize value
			{
				/*if (invalidate)
				{*/
				node->value = score;
				for (std::vector<Node*>::iterator child = node->childrenPtrs.begin(); child != node->childrenPtrs.end(); ++child)
				{
					if ((*child)->value < node->value && (*child)->visited > 0)
					{
						if ((*child)->value < 0)
							int n = 5;
						node->value = (*child)->value;
					}
				}
				/*}
				else
				{
				if (score < node->value)
				node->value = score;
				}*/
			}
		}

		if (!node->isRoot)	// As long as root is not reached, we should keep propagating recursively.
			propagate(node->parentPtr, score, invalidate, UCTPlayer);
	}
}
Exemple #9
0
void
pass2(void)
{
	struct ext2fs_dinode *dp;
	struct inoinfo **inpp, *inp;
	struct inoinfo **inpend;
	struct inodesc curino;
	struct ext2fs_dinode dino;
	char pathbuf[MAXPATHLEN + 1];

	switch (statemap[EXT2_ROOTINO]) {

	case USTATE:
		pfatal("ROOT INODE UNALLOCATED");
		if (reply("ALLOCATE") == 0)
			errexit("%s\n", "");
		if (allocdir(EXT2_ROOTINO, EXT2_ROOTINO, 0755) != EXT2_ROOTINO)
			errexit("CANNOT ALLOCATE ROOT INODE\n");
		break;

	case DCLEAR:
		pfatal("DUPS/BAD IN ROOT INODE");
		if (reply("REALLOCATE")) {
			freeino(EXT2_ROOTINO);
			if (allocdir(EXT2_ROOTINO, EXT2_ROOTINO, 0755) != EXT2_ROOTINO)
				errexit("CANNOT ALLOCATE ROOT INODE\n");
			break;
		}
		if (reply("CONTINUE") == 0)
			errexit("%s\n", "");
		break;

	case FSTATE:
	case FCLEAR:
		pfatal("ROOT INODE NOT DIRECTORY");
		if (reply("REALLOCATE")) {
			freeino(EXT2_ROOTINO);
			if (allocdir(EXT2_ROOTINO, EXT2_ROOTINO, 0755) != EXT2_ROOTINO)
				errexit("CANNOT ALLOCATE ROOT INODE\n");
			break;
		}
		if (reply("FIX") == 0)
			errexit("%s\n", "");
		dp = ginode(EXT2_ROOTINO);
		dp->e2di_mode = htole16((letoh16(dp->e2di_mode) & ~IFMT) | IFDIR);
		inodirty();
		break;

	case DSTATE:
		break;

	default:
		errexit("BAD STATE %d FOR ROOT INODE\n", statemap[EXT2_ROOTINO]);
	}

	/*
	 * Sort the directory list into disk block order.
	 */
	qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
	/*
	 * Check the integrity of each directory.
	 */
	memset(&curino, 0, sizeof(struct inodesc));
	curino.id_type = DATA;
	curino.id_func = pass2check;
	inpend = &inpsort[inplast];
	for (inpp = inpsort; inpp < inpend; inpp++) {
		inp = *inpp;
		if (inp->i_isize == 0)
			continue;
		if (inp->i_isize < MINDIRSIZE) {
			direrror(inp->i_number, "DIRECTORY TOO SHORT");
			inp->i_isize = roundup(MINDIRSIZE, sblock.e2fs_bsize);
			if (reply("FIX") == 1) {
				dp = ginode(inp->i_number);
				inossize(dp, inp->i_isize);
				inodirty();
			}
		} else if ((inp->i_isize & (sblock.e2fs_bsize - 1)) != 0) {
			getpathname(pathbuf, sizeof pathbuf, inp->i_number,
			    inp->i_number);
			pwarn("DIRECTORY %s: LENGTH %lu NOT MULTIPLE OF %d",
			    pathbuf, (u_long)inp->i_isize, sblock.e2fs_bsize);
			if (preen)
				printf(" (ADJUSTED)\n");
			inp->i_isize = roundup(inp->i_isize, sblock.e2fs_bsize);
			if (preen || reply("ADJUST") == 1) {
				dp = ginode(inp->i_number);
				inossize(dp, inp->i_isize);
				inodirty();
			}
		}
		memset(&dino, 0, sizeof(struct ext2fs_dinode));
		dino.e2di_mode = htole16(IFDIR);
		inossize(&dino, inp->i_isize);
		memcpy(&dino.e2di_blocks[0], &inp->i_blks[0], (size_t)inp->i_numblks);
		curino.id_number = inp->i_number;
		curino.id_parent = inp->i_parent;
		(void)ckinode(&dino, &curino);
	}
	/*
	 * Now that the parents of all directories have been found,
	 * make another pass to verify the value of `..'
	 */
	for (inpp = inpsort; inpp < inpend; inpp++) {
		inp = *inpp;
		if (inp->i_parent == 0 || inp->i_isize == 0)
			continue;
		if (inp->i_dotdot == inp->i_parent ||
		    inp->i_dotdot == (ino_t)-1)
			continue;
		if (inp->i_dotdot == 0) {
			inp->i_dotdot = inp->i_parent;
			fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
			if (reply("FIX") == 0)
				continue;
			(void)makeentry(inp->i_number, inp->i_parent, "..");
			lncntp[inp->i_parent]--;
			continue;
		}
		fileerror(inp->i_parent, inp->i_number,
		    "BAD INODE NUMBER FOR '..'");
		if (reply("FIX") == 0)
			continue;
		lncntp[inp->i_dotdot]++;
		lncntp[inp->i_parent]--;
		inp->i_dotdot = inp->i_parent;
		(void)changeino(inp->i_number, "..", inp->i_parent);
	}
	/*
	 * Mark all the directories that can be found from the root.
	 */
	propagate();
}
        void gradient_descent_local_planner_t::gradient_steer(const state_t* start, const state_t* goal, plan_t& plan)
        {
            //for now only going to do piecewise constant plans
            plan.clear();
            traj.link_space(world_model->get_state_space());
            plan.append_onto_front(max_multiple * simulation::simulation_step);
            const space_t* control_space = world_model->get_control_space();
            sampler->sample(control_space, plan[0].control);
            unsigned count = 0;
            std::vector<double> old_control(control_space->get_dimension());
            std::vector<double> test_control(control_space->get_dimension());
            std::vector<double> control_below(control_space->get_dimension());
            std::vector<double> control_above(control_space->get_dimension());
            std::vector<std::pair<double, double> > diffs(control_space->get_dimension());
            while( count < attempts )
            {
                traj.clear();
                plan[0].duration = max_multiple * simulation::simulation_step;
                propagate(start, plan, traj);
                unsigned num_sim_steps = 0;
                unsigned best_sim_step = 0;
                double best_dist = PRX_INFINITY;
                for( trajectory_t::iterator it = traj.begin(); it != traj.end(); it++ )
                {
                    num_sim_steps++;
                    if( metric->distance_function(*it, goal) < best_dist )
                    {
                        best_dist = metric->distance_function(*it, goal);
                        best_sim_step = num_sim_steps;
                    }
                }
                plan[0].duration = best_sim_step * simulation::simulation_step;
                if( best_dist < accepted_radius )
                {
                    return;
                }
                else
                {
                    state_t* state = world_model->get_state_space()->alloc_point();
                    for( unsigned i = 0; i < control_space->get_dimension(); i++ )
                    {
                        old_control[i] = plan[0].control->at(i);
                        control_below[i] = old_control[i] - .01 * (control_space->get_bounds()[i]->get_upper_bound() - control_space->get_bounds()[i]->get_lower_bound());
                        control_above[i] = old_control[i] + .01 * (control_space->get_bounds()[i]->get_upper_bound() - control_space->get_bounds()[i]->get_lower_bound());
                        diffs[i].first = diffs[i].second = 0;
                    }
                    for( unsigned i = 0; i < control_space->get_dimension(); i++ )
                    {
                        test_control = old_control;
                        test_control[i] = control_below[i];
                        control_space->set_from_vector(test_control, plan[0].control);
                        propagate_step(start, plan, state);
                        diffs[i].first = metric->distance_function(state, goal);
                        test_control[i] = control_above[i];
                        control_space->set_from_vector(test_control, plan[0].control);
                        propagate_step(start, plan, state);
                        diffs[i].second = metric->distance_function(state, goal);
                    }
                    world_model->get_state_space()->free_point(state);

                    //now that all the differences have been computed, determine the direction to move
                    test_control = old_control;
                    for( unsigned i = 0; i < control_space->get_dimension(); i++ )
                    {
                        test_control[i] += (diffs[i].first - diffs[i].second)*(learning_rate);
                    }
                    control_space->set_from_vector(test_control, plan[0].control);
                }

                count++;
            }

            //    PRX_INFO_S(plan.print());

        }
Exemple #11
0
int main(int argc, const char * argv[]) {

    // Implementing MNIST character recognition

    /*
     * RESULTS:
     * 50 trainings - 50 hidden, .45 learning : 96.77% (only trial) <-- CURRENT BEST!!
     * 50 trainings - 45 hidden, .4 learning : 96.74% (only trial) 
     * 50 trainings - 40 hidden, .25 learning : 96.16% (best trial of 2)
     * 50 trainings - 35 hidden, .35 learning : 96.18% (only trial)
     * 50 trainings - 30 hidden, .4 learning : 95.47% (only trial)
     * 50 trainings - 25 hidden, .4 learning : 94.95% (only trial)
     * 50 trainings - 20 hidden, .5 learning : 93.97% (only trial)
     *
     *
     * Note: It seems I was overfitting, not sure if this was
     * a waste of time or a lesson (probably both). I can train
     * 10 or more times less than the 50 trainings I was using
     * before and still get ~96% accuracy on the testing set.
     * However, with less training, I don't overfit the training
     * set as much, allowing better accuracy with more general
     * testing data, e.g. the handwritten digits collected from
     * my friends and colleagues.
     *
     * P.S. Even with only 3 trainings, 96% accuracy is still achievable
     *
     * P.S.S. Two trainings yielded poorer results on friend set
     *
     * Higher hidden layer widths seem to do better - getting into 97%
     *
     */

    // If changing parameters, make sure to change export filename


/*
 * Preprocessor macros/conditionals to make
 * switching between training and utilizing
 * easier - relies on this TRAINING definition
 */

// #define TRAINING


#define IMAGE_START 16
#define LABEL_START 8
#define NUM_PIXELS 784
#define NUM_OUTPUTS 10

#ifdef TRAINING
    // EACH LEARNING FROM SCRATCH VERSION
    std::vector<unsigned int> hiddenSizes = {80};
    auto netTest = new NeuralNetwork(NUM_PIXELS, 1, NUM_OUTPUTS, hiddenSizes, sigmoid, sigmoidPrime, 0.5, 0.4, 0.2);
#endif

#ifndef TRAINING
    // CONTINUED LESSONS VERSION
    auto netTest = new NeuralNetwork("saved/mnist_048545.json");
#endif

    std::vector<double> input = {};
    std::vector<double> expected = {};

#ifdef TRAINING
    std::ifstream trainingImages;
    std::ifstream trainingLabels;
    trainingImages.open("mnist_data/train_images", ios::in | ios::binary);
    trainingLabels.open("mnist_data/train_labels", ios::in | ios::binary);
#endif

    char read;

#define NUM_TRAININGS 4
#define NUM_TRAINING_DIGITS 60000
#define HUNDREDTHS_OF_PERCENT_PER_TRAINING 2500 // 100 * (100 / NUM_TRAININGS)
#define TRAININGS_PER_HUNDREDTH_OF_PERCENT 24 // NUM_TRAINING_DIGITS / HUNDREDTHS_OF_PERCENT_PER_TRAINING

#ifdef TRAINING
    //Training loop
    for (unsigned int j = 0; j < NUM_TRAININGS; j++) {
        trainingImages.seekg(IMAGE_START);
        trainingLabels.seekg(LABEL_START);

        for (unsigned int i = 0; i < NUM_TRAINING_DIGITS; i++) {
            if (i % TRAININGS_PER_HUNDREDTH_OF_PERCENT == 0) {
                int curr_percent = (j * HUNDREDTHS_OF_PERCENT_PER_TRAINING) + (1 * i/TRAININGS_PER_HUNDREDTH_OF_PERCENT);
                if (curr_percent) printf("\r");
                std::cout << curr_percent/100 << ".";
                std::cout << ((curr_percent%100 < 10) ? "0" : "") << curr_percent%100;
                std::cout << "% done training..." << std::flush;
            }

            // Setup
            input.clear();
            expected.clear();
            for (unsigned int k = 0; k < NUM_PIXELS; k++) {
                trainingImages.read((&read), 1);
                input.push_back((double)((unsigned char)read)/255);
            }
            trainingLabels.read((&read), 1);
            for (unsigned int k = 0; k < 10; k++) {
                    expected.push_back(0);
            }
            expected.at(read) = 1;

            netTest->propagate(&input, &expected);
        }
    }

    std::cout << "\r100% done training!" << std::endl;
#endif

    std::ifstream testImages;
    std::ifstream testLabels;

#ifndef TRAINING
    testImages.open("mnist_preprocessing/converted/converted_images", ios::in | ios::out | ios::binary);
    testLabels.open("mnist_preprocessing/converted/converted_labels", ios::in | ios::out | ios::binary);
#endif

#ifdef TRAINING    
    testImages.open("mnist_data/test_images", ios::in | ios::out | ios::binary);
    testLabels.open("mnist_data/test_labels", ios::in | ios::out | ios::binary);
#endif

    testImages.seekg(IMAGE_START);
    testLabels.seekg(LABEL_START);

    unsigned int numCorrect = 0;

#ifndef TRAINING
    #define NUM_TESTS 80
#else
    #define NUM_TESTS 10000
#endif

    for (unsigned int j = 0; j < NUM_TESTS; j++) {
        // Setup
        input.clear();
        expected.clear();

        for (unsigned int k = 0; k < NUM_PIXELS; k++) {
            testImages.read((&read), 1);
            input.push_back((double)((unsigned char)read)/255);
        }
        testLabels.read((&read), 1);
        for (unsigned int k = 0; k < 10; k++) {
                expected.push_back(0);
        }
        expected.at(read) = 1;

        std::cout << "Expected digit: " << (unsigned int)read << std::endl;

        printDigitAscii(&input);

        std::vector<double> output = netTest->getOutputs(&input);

        unsigned int outputDigit = determineDigit(&output);

        std::cout << "Output digit: " << outputDigit << std::endl;

        if (outputDigit == (unsigned int)read) {
            numCorrect++;
        }
    }

#ifndef TRAINING
    #define DIVISOR 0.8
#else
    #define DIVISOR 100
#endif

    std::cout << "Total number correct: " << numCorrect << std::endl;
    std::cout << "Percentage correct: " << (double)numCorrect / DIVISOR << '%' << std::endl;

#ifdef TRAINING
    std::cout << "Writing network to file..." << std::endl;
    netTest->exportNN("saved/mnist_0480504020.json"); // Export network to file
    std::cout << "File written!" << std::endl;
#endif

    return 0;
}
void PbSolver::solve(solve_Command cmd)
{
    if (!ok) return;

    // Convert constraints:
    pb_n_vars = nVars();
    pb_n_constrs = constrs.size();
    if (opt_verbosity >= 1) reportf("Converting %d PB-constraints to clauses...\n", constrs.size());
    propagate();
    if (!convertPbs(true)){ assert(!ok); return; }

    // Freeze goal function variables (for SatELite):
    if (goal != NULL){
        for (int i = 0; i < goal->size; i++)
            sat_solver.freeze(var((*goal)[i]));
    }

    // Solver (optimize):
    sat_solver.setVerbosity(opt_verbosity);

    vec<Lit> goal_ps; if (goal != NULL){ for (int i = 0; i < goal->size; i++) goal_ps.push((*goal)[i]); }
    vec<Int> goal_Cs; if (goal != NULL){ for (int i = 0; i < goal->size; i++) goal_Cs.push((*goal)(i)); }
    assert(best_goalvalue == Int_MAX);

    if (opt_polarity_sug != 0){
        for (int i = 0; i < goal_Cs.size(); i++)
            sat_solver.suggestPolarity(var(goal_ps[i]), ((goal_Cs[i]*opt_polarity_sug > 0 && !sign(goal_ps[i])) || (goal_Cs[i]*opt_polarity_sug < 0 && sign(goal_ps[i]))) ? l_False : l_True);
    }

    if (opt_convert_goal != ct_Undef)
        opt_convert = opt_convert_goal;
    opt_sort_thres *= opt_goal_bias;

    if (opt_goal != Int_MAX)
        addConstr(goal_ps, goal_Cs, opt_goal, -1),
        convertPbs(false);

    if (opt_cnf != NULL)
        reportf("Exporting CNF to: \b%s\b\n", opt_cnf),
        sat_solver.exportCnf(opt_cnf),
        exit(0);

    bool    sat = false;
    int     n_solutions = 0;    // (only for AllSolutions mode)
    while (sat_solver.solve()){
        sat = true;
        if (cmd == sc_AllSolutions){
            vec<Lit>    ban;
            n_solutions++;
            reportf("MODEL# %d:", n_solutions);
            for (Var x = 0; x < pb_n_vars; x++){
                assert(sat_solver.model()[x] != l_Undef);
                ban.push(Lit(x, sat_solver.model()[x] == l_True));
                reportf(" %s%s", (sat_solver.model()[x] == l_False)?"-":"", index2name[x]);
            }
            reportf("\n");
            sat_solver.addClause(ban);

        }else{
            best_model.clear();
            for (Var x = 0; x < pb_n_vars; x++)
                assert(sat_solver.model()[x] != l_Undef),
                best_model.push(sat_solver.model()[x] == l_True);

            if (goal == NULL)   // ((fix: moved here Oct 4, 2005))
                break;

            best_goalvalue = evalGoal(*goal, sat_solver.model());
            if (cmd == sc_FirstSolution) break;

            if (opt_verbosity >= 1){
                char* tmp = toString(best_goalvalue);
                reportf("\bFound solution: %s\b\n", tmp);
                xfree(tmp); }
            if (!addConstr(goal_ps, goal_Cs, best_goalvalue, -2))
                break;
            convertPbs(false);
        }
    }
    if (goal == NULL && sat)
        best_goalvalue = Int_MIN;       // (found model, but don't care about it)
    if (opt_verbosity >= 1){
        if      (!sat)
            reportf("\bUNSATISFIABLE\b\n");
        else if (goal == NULL)
            reportf("\bSATISFIABLE: No goal function specified.\b\n");
        else if (cmd == sc_FirstSolution){
            char* tmp = toString(best_goalvalue);
            reportf("\bFirst solution found: %s\b\n", tmp);
            xfree(tmp);
        }else{
            char* tmp = toString(best_goalvalue);
            reportf("\bOptimal solution: %s\b\n", tmp);
            xfree(tmp);
        }
    }
}
Exemple #13
0
/*!

*/
double
RBFNetwork::train( const input_vector & input,
                   const output_vector & teacher )
{
    if ( input.size() != M_input_dim )
    {
        std::cerr << __FILE__ << ":" << __LINE__
                  << "  illegal input vector size. " << input.size()
                  << "(input) != " << M_input_dim << "(required)"
                  << std::endl;
        return 0.0;
    }

    if ( teacher.size() != M_output_dim )
    {
        std::cerr << __FILE__ << ":" << __LINE__
                  << "  illegal output vector size. " << teacher.size()
                  << "(input) != " << M_output_dim << "(required)"
                  << std::endl;
        return 0.0;
    }

    const std::size_t OUTPUT = M_output_dim;

    output_vector output( OUTPUT, 0.0 );
    propagate( input, output );

    output_vector output_back( OUTPUT, 0.0 );

    // calculate output error back
    for ( std::size_t i = 0; i < OUTPUT; ++i )
    {
        output_back[i] = teacher[i] - output[i];
    }

    // update each unit
    const std::vector< Unit >::iterator end = M_units.end();
    for ( std::vector< Unit >::iterator it = M_units.begin();
          it != end;
          ++it )
    {
        const double unit_value = it->calc( input );
#if 0
        const double dist2 = it->dist2( input );
        const double sigma3 = std::pow( it->sigma_, 3 );

        double back_sum = 0.0;
        for ( std::size_t i = 0; i < OUTPUT; ++i )
        {
            back_sum += output_back[i] * it->weights_[i];
        }

        // update sigma (d_gaussian)
        it->delta_sigma_
            = M_eta * back_sum * ( dist2 / sigma3 ) * unit_value
            + M_alpha * it->delta_sigma_;
        it->sigma_ += it->delta_sigma_;
#endif
        // update weights
        for ( std::size_t i = 0; i < OUTPUT; ++i )
        {
            it->delta_weights_[i]
                = M_eta * output_back[i] * unit_value
                + M_alpha * it->delta_weights_[i];

            it->weights_[i] += it->delta_weights_[i];
        }
    }

    propagate( input, output );
    double total_error = 0.0;
    for ( std::size_t i = 0; i < OUTPUT; ++i )
    {
        double err = teacher[i] - output[i];
        total_error += err * err;
    }

    return total_error;
}
Exemple #14
0
void localizerGVG::handleOdom(const nav_msgs::Odometry::ConstPtr& odom) {
  double x=odom->pose.pose.position.x;
  double y=odom->pose.pose.position.y;
  tf::Pose pose;
  tf::poseMsgToTF(odom->pose.pose, pose);
  double yaw=tf::getYaw(pose.getRotation());
  ROS_DEBUG("IN [x=%f, y=%f, yaw=%f]",x,y,yaw);
  if(std::isnan(yaw) || std::isnan(x) || std::isnan(y)){
    ROS_WARN("Odom read nan, skipping iteration of publishing and hoping for recovery.");
    return;
  }
  if(!initOdom) {
    oldX=x;
    oldY=y;
    oldYaw=yaw;
    initOdom=true;
    oldStamp=odom->header.stamp;
    Vector3d odomVector(x, y, yaw);
    X.segment(0, 3) = odomVector;
    return;
  }
  if(this->filterOn) {
    if((oldX==x)&&(oldY==y)&&(oldYaw==yaw)){
      oldStamp=odom->header.stamp;
      return;
    }
    // Calculate the measurement
    double dx=x-oldX;
    double dy=y-oldY;
    double dYaw=angleDiff(yaw,oldYaw);
    double dt=odom->header.stamp.toSec()-oldStamp.toSec();
    if(dt==0) {
      ROS_DEBUG("dt in localizer equal to zero, will lead to nan. skipping and hoping for recovery");
      return;
    }
    double Vm=sqrt(dx*dx+dy*dy)/dt;
    double Wm=dYaw/dt;
    X(0)=X(0)+Vm*dt*cos(X(2));
    X(1)=X(1)+Vm*dt*sin(X(2));
    X(2)=thetapp(X(2)+Wm*dt);
    propagate(Vm,Wm,dt);
    // Publish the odometry with covariance topic
    geometry_msgs::Quaternion odom_quat = tf::createQuaternionMsgFromYaw(X(2));
    nav_msgs::Odometry outputPose;
    outputPose.header.frame_id = "odom";
    outputPose.header.stamp =odom->header.stamp;
    outputPose.pose.pose.position.x = X(0);
    outputPose.pose.pose.position.y = X(1);
    outputPose.pose.pose.position.z = 0;
    outputPose.pose.pose.orientation=odom_quat;

    if(std::isnan(X(0)),std::isnan(X(1)))
    {
      ROS_WARN("Filter made something nan, skipping publishing and hoping for recovery.");
      return;
    }
    for (unsigned int i=0; i<2; i++)
      for (unsigned int j=0; j<2; j++)
    	outputPose.pose.covariance[6*i+j] = P(i,j);
    posePub.publish(outputPose);
  }
  oldX=x;
  oldY=y;
  oldYaw=yaw;
  oldStamp=odom->header.stamp;
}
// This doesn't rewrite changes through properly so needs to have a substitution
// applied to its output.
ASTNode PropagateEqualities::propagate(const ASTNode& a, ArrayTransformer* at)
{
  ASTNode output;
  // if the variable has been solved for, then simply return it
  if (simp->InsideSubstitutionMap(a, output))
    return output;

  if (!alreadyVisited.insert(a.GetNodeNum()).second)
  {
    return a;
  }

  output = a;

  // traverse a and populate the SubstitutionMap
  const Kind k = a.GetKind();
  if (SYMBOL == k && BOOLEAN_TYPE == a.GetType())
  {
    bool updated = simp->UpdateSubstitutionMap(a, ASTTrue);
    output = updated ? ASTTrue : a;
  }
  else if (NOT == k)
  {
    bool updated = searchXOR(a[0], ASTFalse);
    output = updated ? ASTTrue : a;
  }
  else if (IFF == k || EQ == k)
  {
    const ASTVec& c = a.GetChildren();

    if (c[0] == c[1])
      return ASTTrue;

    bool updated = simp->UpdateSubstitutionMap(c[0], c[1]);

    if (updated)
    {
      // fill the arrayname readindices vector if e0 is a
      // READ(Arr,index) and index is a BVCONST
      int to;
      if ((to = TermOrder(c[0], c[1])) == 1 && c[0].GetKind() == READ)
        at->FillUp_ArrReadIndex_Vec(c[0], c[1]);
      else if (to == -1 && c[1].GetKind() == READ)
        at->FillUp_ArrReadIndex_Vec(c[1], c[0]);
    }

    if (!updated)
      updated = searchTerm(c[0], c[1]);

    if (!updated)
      updated = searchTerm(c[1], c[0]);

    output = updated ? ASTTrue : a;
  }
  else if (XOR == k)
  {
    bool updated = searchXOR(a, ASTTrue);
    output = updated ? ASTTrue : a;

    if (updated)
      return output;

// The below block should be subsumed by the searchXOR function which
// generalises it.
// So the below block should never do anything..
#ifndef NDEBUG
    if (a.Degree() != 2)
      return output;

    int to = TermOrder(a[0], a[1]);
    if (0 == to)
    {
      if (a[0].GetKind() == NOT && a[0][0].GetKind() == EQ &&
          a[0][0][0].GetValueWidth() == 1 && a[0][0][1].GetKind() == SYMBOL)
      {
        // (XOR (NOT(= (1 v)))  ... )
        const ASTNode& symbol = a[0][0][1];
        const ASTNode newN = nf->CreateTerm(
            ITE, 1, a[1], a[0][0][0], nf->CreateTerm(BVNEG, 1, a[0][0][0]));

        if (simp->UpdateSolverMap(symbol, newN))
        {
          assert(false);
          output = ASTTrue;
        }
      }
      else if (a[1].GetKind() == NOT && a[1][0].GetKind() == EQ &&
               a[1][0][0].GetValueWidth() == 1 &&
               a[1][0][1].GetKind() == SYMBOL)
      {
        const ASTNode& symbol = a[1][0][1];
        const ASTNode newN = nf->CreateTerm(
            ITE, 1, a[0], a[1][0][0], nf->CreateTerm(BVNEG, 1, a[1][0][0]));

        if (simp->UpdateSolverMap(symbol, newN))
        {
          assert(false);
          output = ASTTrue;
        }
      }
      else if (a[0].GetKind() == EQ && a[0][0].GetValueWidth() == 1 &&
               a[0][1].GetKind() == SYMBOL)
      {
        // XOR ((= 1 v) ... )

        const ASTNode& symbol = a[0][1];
        const ASTNode newN = nf->CreateTerm(
            ITE, 1, a[1], nf->CreateTerm(BVNEG, 1, a[0][0]), a[0][0]);

        if (simp->UpdateSolverMap(symbol, newN))
        {
          assert(false);
          output = ASTTrue;
        }
      }
      else if (a[1].GetKind() == EQ && a[1][0].GetValueWidth() == 1 &&
               a[1][1].GetKind() == SYMBOL)
      {
        const ASTNode& symbol = a[1][1];
        const ASTNode newN = nf->CreateTerm(
            ITE, 1, a[0], nf->CreateTerm(BVNEG, 1, a[1][0]), a[1][0]);

        if (simp->UpdateSolverMap(symbol, newN))
        {
          assert(false);
          output = ASTTrue;
        }
      }
      else
        return output;
    }
    else
    {
      ASTNode symbol, rhs;
      if (to == 1)
      {
        symbol = a[0];
        rhs = a[1];
      }
      else
      {
        symbol = a[1];
        rhs = a[0];
      }

      assert(symbol.GetKind() == SYMBOL);

      if (simp->UpdateSolverMap(symbol, nf->CreateNode(NOT, rhs)))
      {
        assert(false);
        output = ASTTrue;
      }
    }
#endif
  }
  else if (AND == k)
  {
    const ASTVec& c = a.GetChildren();
    ASTVec o;
    o.reserve(c.size());

    for (ASTVec::const_iterator it = c.begin(), itend = c.end(); it != itend;
         it++)
    {
      if (always_true)
        simp->UpdateAlwaysTrueFormSet(*it);
      ASTNode aaa = propagate(*it, at);

      if (ASTTrue != aaa)
      {
        if (ASTFalse == aaa)
          return ASTFalse;
        else
          o.push_back(aaa);
      }
    }
    if (o.size() == 0)
      output = ASTTrue;
    else if (o.size() == 1)
      output = o[0];
    else if (o != c)
      output = nf->CreateNode(AND, o);
    else
      output = a;
  }

  return output;
}
Exemple #16
0
void
pass2(void)
{
	union dinode *dp;
	struct inoinfo **inpp, *inp, *pinp;
	struct inoinfo **inpend;
	struct inodesc curino;
	union dinode dino;
	char pathbuf[MAXPATHLEN + 1];
	int i;

	switch (GET_ISTATE(ROOTINO)) {

	case USTATE:
		pfatal("ROOT INODE UNALLOCATED");
		if (reply("ALLOCATE") == 0) {
			ckfini(0);
			errexit("%s", "");
		}
		if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
			errexit("CANNOT ALLOCATE ROOT INODE\n");
		break;

	case DCLEAR:
		pfatal("DUPS/BAD IN ROOT INODE");
		if (reply("REALLOCATE")) {
			freeino(ROOTINO);
			if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
				errexit("CANNOT ALLOCATE ROOT INODE\n");
			break;
		}
		if (reply("CONTINUE") == 0) {
			ckfini(0);
			errexit("%s", "");
		}
		break;

	case FSTATE:
	case FCLEAR:
		pfatal("ROOT INODE NOT DIRECTORY");
		if (reply("REALLOCATE")) {
			freeino(ROOTINO);
			if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
				errexit("CANNOT ALLOCATE ROOT INODE\n");
			break;
		}
		if (reply("FIX") == 0) {
			ckfini(0);
			errexit("%s", "");
		}
		dp = ginode(ROOTINO);
		DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT);
		DIP_SET(dp, di_mode, DIP(dp, di_mode) | IFDIR);
		inodirty();
		break;

	case DSTATE:
		break;

	default:
		errexit("BAD STATE %d FOR ROOT INODE\n", GET_ISTATE(ROOTINO));
	}
	SET_ISTATE(ROOTINO, DFOUND);
	/*
	 * Sort the directory list into disk block order.
	 */
	qsort(inpsort, (size_t)inplast, sizeof *inpsort, blksort);
	/*
	 * Check the integrity of each directory.
	 */
	memset(&curino, 0, sizeof(struct inodesc));
	curino.id_type = DATA;
	curino.id_func = pass2check;
	inpend = &inpsort[inplast];
	info_pos = 0;
	info_max = inpend - inpsort;
	info_fn = pass2_info1;
	for (inpp = inpsort; inpp < inpend; inpp++) {
		inp = *inpp;
		info_pos ++;
		if (inp->i_isize == 0)
			continue;
		if (inp->i_isize < MINDIRSIZE) {
			direrror(inp->i_number, "DIRECTORY TOO SHORT");
			inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
			if (reply("FIX") == 1) {
				dp = ginode(inp->i_number);
				DIP_SET(dp, di_size, inp->i_isize);
				inodirty();
			}
		} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
			getpathname(pathbuf, sizeof pathbuf,
			    inp->i_number, inp->i_number);
			if (usedsoftdep)
			        pfatal("%s %s: LENGTH %ld NOT MULTIPLE of %d",
				       "DIRECTORY", pathbuf, (long)inp->i_isize,
				       DIRBLKSIZ);
			else
				pwarn("%s %s: LENGTH %ld NOT MULTIPLE OF %d",
				      "DIRECTORY", pathbuf, (long)inp->i_isize,
				      DIRBLKSIZ);
			if (preen)
				printf(" (ADJUSTED)\n");
			inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
			if (preen || reply("ADJUST") == 1) {
				dp = ginode(inp->i_number);
				DIP_SET(dp, di_size, inp->i_isize);
				inodirty();
			}
		}
		memset(&dino, 0, sizeof(union dinode));
		dp = &dino;
		DIP_SET(dp, di_mode, IFDIR);
		DIP_SET(dp, di_size, inp->i_isize);
		for (i = 0;
		     i < (inp->i_numblks<NDADDR ? inp->i_numblks : NDADDR);
		     i++)
			DIP_SET(dp, di_db[i], inp->i_blks[i]);
		if (inp->i_numblks > NDADDR)
			for (i = 0; i < NIADDR; i++)
				DIP_SET(dp, di_ib[i], inp->i_blks[NDADDR + i]);
		curino.id_number = inp->i_number;
		curino.id_parent = inp->i_parent;
		(void)ckinode(dp, &curino);
	}
	/*
	 * Now that the parents of all directories have been found,
	 * make another pass to verify the value of `..'
	 */
	info_pos = 0;
	info_fn = pass2_info2;
	for (inpp = inpsort; inpp < inpend; inpp++) {
		inp = *inpp;
		info_pos++;
		if (inp->i_parent == 0 || inp->i_isize == 0)
			continue;
		if (inp->i_dotdot == inp->i_parent ||
		    inp->i_dotdot == (ino_t)-1)
			continue;
		if (inp->i_dotdot == 0) {
			inp->i_dotdot = inp->i_parent;
			fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
			if (reply("FIX") == 0)
				continue;
			(void)makeentry(inp->i_number, inp->i_parent, "..");
			lncntp[inp->i_parent]--;
			continue;
		}
		fileerror(inp->i_parent, inp->i_number,
		    "BAD INODE NUMBER FOR '..'");
		if (reply("FIX") == 0)
			continue;
		lncntp[inp->i_dotdot]++;
		lncntp[inp->i_parent]--;
		inp->i_dotdot = inp->i_parent;
		(void)changeino(inp->i_number, "..", inp->i_parent);
	}
	info_fn = NULL;
	/*
	 * Create a list of children for each directory.
	 */
	inpend = &inpsort[inplast];
	for (inpp = inpsort; inpp < inpend; inpp++) {
		inp = *inpp;
		if (inp->i_parent == 0 ||
		    inp->i_number == ROOTINO)
			continue;
		pinp = getinoinfo(inp->i_parent);
		inp->i_parentp = pinp;
		inp->i_sibling = pinp->i_child;
		pinp->i_child = inp;
	}
	/*
	 * Mark all the directories that can be found from the root.
	 */
	propagate(ROOTINO);
}
Exemple #17
0
 void add_client (boost::shared_ptr<Treelog> msg)
 {
   daisy_assert (msg.get ());
   client.push_back (msg);
   propagate (*msg);
 }
Exemple #18
0
void thread_liveness(void *args)
{
	arg_struct_t* t = (arg_struct_t*)args;
	arena_list_t** worklist = t->worklist;
	size_t		id = t->size;
	set_t* prev;
	vertex_t* u;
	size_t		j;
	list_t*		p;
	list_t*		h;
	vertex_t*	v;
	size_t 		count = 0;
	size_t		sum = 0;
	//printf("this shoudl be zero workload %zu, id %zu\n", count,id);

	do{
		pthread_mutex_lock(&work_mutex);
		u = aremove_first(worklist);
		pthread_mutex_unlock(&work_mutex);
		count++;
		if(u ==NULL){
			printf("workload %zu, id %zu\n", count,id);
			return;
		}
		u->listed = false;
		reset(u->set[OUT]);

		//pthread_mutex_lock(&work_mutex);
		for( j = 0; j< u->nsucc; ++j){
      pthread_mutex_lock(&u->succ[j]->mutex);
			or(u->set[OUT], u->set[OUT], u->succ[j]->set[IN]);
      pthread_mutex_unlock(&u->succ[j]->mutex);
    }


		/* in our case liveness information... */
    pthread_mutex_lock(&u->mutex);
		prev = u->prev;
		u->prev = u->set[IN];
		u->set[IN] = prev;
		propagate(u->set[IN], u->set[OUT], u->set[DEF], u->set[USE]);
    pthread_mutex_unlock(&u->mutex);

		if (u->pred != NULL && !equal(u->prev, u->set[IN])) {
			p = h = u->pred;
			do {
				v = p->data;
				if (!v->listed) {
					v->listed = true;
					pthread_mutex_lock(&work_mutex);
					ainsert_last(worklist, v);
					pthread_mutex_unlock(&work_mutex);
				}

				p = p->succ;

			} while (p != h);
		//pthread_mutex_unlock(&work_mutex);
		}
	}while(u != NULL);


}
Exemple #19
0
 void propagate (int nest, const std::string& text)
 {
   for (size_t i = 0; i < client.size (); i++)
     propagate (*client[i], nest, text);
 }
Exemple #20
0
// Modified line
// bool MiniSATP::addClause(vec<Lit>& ps, Enode * e)
bool MiniSATP::addClause(vec<Lit>& psin, Enode * e)
{
    assert( decisionLevel() == 0 );
    assert( ok );

    // Added Lines
    vec< Lit > ps;
    psin.copyTo( ps );

    if (!ok)
      return false;

    // Check if clause is satisfied and remove false/duplicate literals:
    sort(ps);
    Lit p; int i, j;
    for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
    {
      if (value(ps[i]) == l_True || ps[i] == ~p)
	return true;
      else if (value(ps[i]) != l_False && ps[i] != p)
	ps[j++] = p = ps[i];
    }
    ps.shrink(i - j);

//=================================================================================================
// Modified Code

    assert( psin.size( ) == 1 || ps.size() > 0 );

    //
    // This case happens only when deductions are enabled
    //
    if (ps.size() == 0)
    {
      Clause * confl = Clause_new( psin );
      if ( confl == NULL ) return ok = true;
      initExpDup( );
      explanation.push_back( e );
      storeExpDup( e );
      fillExplanation( confl );
      doneExpDup( );
      assert( !explanation.empty( ) );
      return ok = false;
    }

    if (ps.size() == 1)
    {
      assert(value(ps[0]) == l_Undef);
      uncheckedEnqueue(ps[0]);
      /*
      const Var v = var(ps[0]);
      if ( var_to_enode.size( ) <= v )
	var_to_enode.resize( v + 1, NULL );
      var_to_enode[ v ] = e;
      */
      /*
      if ( e != NULL && seen_in_conflict.insert( e->getId( ) ).second )
	explanation.push_back( e );
      */
      // undo_stack_oper.push_back( NEWUNIT );
      // undo_stack_elem.push_back( (void *)v );

#define LAZY_PROPAGATION 0
#if LAZY_PROPAGATION
#else
      // Modified Line
      // return ok = (propagate() == NULL);
#if LIMIT_DEDUCTIONS
      deductions_done_in_call = 0;
#endif
      Clause * confl = propagate( theory_prop );
      if ( confl == NULL ) return ok = true;
      initExpDup( );
      fillExplanation( confl );
      doneExpDup( );
      assert( !explanation.empty( ) );
      return ok = false;
#endif

// Modified Code
//=================================================================================================

    }
    else
    {
      Clause* c = Clause_new(ps, false);
      clauses.push(c);
      attachClause(*c);

      // Added Lines
      undo_stack_oper.push_back( NEWCLAUSE );
      undo_stack_elem.push_back( (void *)c );
    }

    return true;
}
 void assign(int varIndex)
 {
     if (x->assigned() && y->assigned())
         deconnect();
     propagate();
 }
Exemple #22
0
/*_________________________________________________________________________________________________
|
|  search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&)  ->  [lbool]
|  
|  Description:
|    Search for a model the specified number of conflicts, keeping the number of learnt clauses
|    below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to
|    indicate infinity.
|  
|  Output:
|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
|_________________________________[email protected]*/
lbool MiniSATP::search(int nof_conflicts, int nof_learnts)
{
    assert(ok);
    int         backtrack_level;
    int         conflictC = 0;
    vec<Lit>    learnt_clause;

    starts++;

    bool first = true;

    for (;;){
        Clause* confl = propagate();
        if (confl != NULL){
            // CONFLICT
            conflicts++; conflictC++;

            if (decisionLevel() == 0) 
	    {
	      // Added Lines
	      fillExplanation(confl);
	      return l_False;
	    }

            first = false;

            learnt_clause.clear();
            analyze(confl, learnt_clause, backtrack_level);
            cancelUntil(backtrack_level);
            assert(value(learnt_clause[0]) == l_Undef);

            if (learnt_clause.size() == 1){
                uncheckedEnqueue(learnt_clause[0]);
            }else{
                Clause* c = Clause_new(learnt_clause, true);
                learnts.push(c);
                attachClause(*c);
		
                claBumpActivity(*c);
                uncheckedEnqueue(learnt_clause[0], c);
            }

            varDecayActivity();
            claDecayActivity();

        }else{
            // NO CONFLICT

            if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
                // Reached bound on number of conflicts:
                progress_estimate = progressEstimate();
                cancelUntil(0);
                return l_Undef; }

            // Simplify the set of problem clauses:
            if (decisionLevel() == 0 && !simplify())
	    {
                return l_False;
	    }

            if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts)
                // Reduce the set of learnt clauses:
                reduceDB();

            Lit next = lit_Undef;
            while (decisionLevel() < assumptions.size()){
                // Perform user provided assumption:
                Lit p = assumptions[decisionLevel()];
                if (value(p) == l_True){
                    // Dummy decision level:
                    newDecisionLevel();
                }else if (value(p) == l_False){
                    analyzeFinal(~p, conflict);
                    return l_False;
                }else{
                    next = p;
                    break;
                }
            }

            if (next == lit_Undef){
                // New variable decision:
                decisions++;
                next = pickBranchLit(polarity_mode, random_var_freq);

                if (next == lit_Undef)
		{
		    // Added Line
		    // Clear explanation vector if satisfiable
		    explanation.clear( );

                    // Model found:
                    return l_True;
		}
            }

            // Increase decision level and enqueue 'next'
            assert(value(next) == l_Undef);
            newDecisionLevel();
            uncheckedEnqueue(next);
        }
    }
}
Exemple #23
0
bool SPTGSolver::makeImpSwitchesP2(){
	cout << "==>Imp2" << endl;
	bool allDone = false;
	bool changed = false;
	while (!allDone){
		//For all states
		allDone = true;
		for (unsigned int state = 1; state < size; ++state){
			//Owned by P2 because we are checking the improving switches for the P2
			if(!sptg->getOwner(state)){
				cout << "State: " << state << endl;
				cout << "Actual value: " << (*vals)[state][0] << "+" << (*vals)[state][1] << "e" << endl;

				//We don't need to take a look at the bottom transitions because the lambda transitions will always be better for P2
				/*if(solvePTG && ((*bottoms)[state] > (*vals)[state][0])){//If we have an improvement, we update the values found
					(*vals)[state][0] = (*bottoms)[state];
					(*vals)[state][1] = 0;
					strategies->front().insert(state, 0, 2);
					allDone = false;
					changed = true;
				}*/
				//Check the lambda transition
				if((lambdas[state][0] > (*vals)[state][0]) ||
						((lambdas[state][0] == (*vals)[state][0]) && (lambdas[state][1] > (*vals)[state][1]))){
					cout << "lambda is better" << endl;
					//If we have an improvement, we update the values found
					(*vals)[state][0] = lambdas[state][0];
					(*vals)[state][1] = lambdas[state][1];
					cout << (*vals)[state][0] << "+" << (*vals)[state][1] << "e" << endl;
					strategies->front().insert(state, 0, 1);
					(*pathsLengths)[state] = 1;
					allDone = false;
					changed = true;
				}

				for (unsigned int nextState = 0; nextState < size; ++nextState){
					if(sptg->getTransition(state, nextState) != -1){//If the transition exists
						Fraction tempVal = (*vals)[nextState][0] + sptg->getTransition(state, nextState);
						if(tempVal > ifnty)
							tempVal = ifnty;
						unsigned int tempLength = (*pathsLengths)[nextState] + 1;

						//Check if the reset exists and is better
						if(solvePTG && ((*resets)[state][nextState] != -1) &&  ((*resets)[state][nextState] > (*vals)[state][0])){//If we have an improvement, we update the values found
							cout << "reset to " << nextState << "is better" << endl;
							(*vals)[state][0] = (*resets)[state][nextState];
							(*vals)[state][1] = 0;
							cout << (*vals)[state][0] << "+" << (*vals)[state][1] << "e" << endl;

							strategies->front().insert(state, nextState, 3);
							allDone = false;
							changed = true;
						}

						//cout << state << ": " << (*vals)[state][0] << " " << (*vals)[state][1] << endl;
						//cout << "to: " << nextState << ": " << tempVal <<  " " << (*vals)[nextState][1] << endl;
						if((tempVal > (*vals)[state][0]) || ((tempVal == (*vals)[state][0]) && ((*vals)[nextState][1] > (*vals)[state][1]))
								||((tempVal == (*vals)[state][0]) && ((*vals)[nextState][1] == (*vals)[state][1]) && (tempLength > (*pathsLengths)[state]))){
							cout << "to " << nextState << " is better" << endl;
							//If we have an improvement, we update the values found
							(*vals)[state][0] = tempVal;
							(*vals)[state][1] = (*vals)[nextState][1];
							cout << (*vals)[state][0] << "+" << (*vals)[state][1] << "e" << endl;
							cout << tempLength << endl;

							(*pathsLengths)[state] = tempLength;
							strategies->front().insert(state, nextState, 0);
							allDone = false;
							changed = true;
						}
					}
				}
			}
			if(changed)//If a change has been made, it can have an impact on the values of other states
				propagate(state);
		}
	}

	return changed;
}
Exemple #24
0
void
pass2(void)
{
	union dinode *dp;
	struct inoinfo **inpp, *inp;
	struct inoinfo **inpend;
	struct inodesc curino;
	union dinode dino;
	int i;
	char pathbuf[MAXPATHLEN + 1];

	switch (inoinfo(ROOTINO)->ino_state) {

	case USTATE:
		pfatal("ROOT INODE UNALLOCATED");
		if (reply("ALLOCATE") == 0) {
			ckfini(0);
			exit(EEXIT);
		}
		if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
			errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
		break;

	case DCLEAR:
		pfatal("DUPS/BAD IN ROOT INODE");
		if (reply("REALLOCATE")) {
			freeino(ROOTINO);
			if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
				errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
			break;
		}
		if (reply("CONTINUE") == 0) {
			ckfini(0);
			exit(EEXIT);
		}
		break;

	case FSTATE:
	case FCLEAR:
	case FZLINK:
		pfatal("ROOT INODE NOT DIRECTORY");
		if (reply("REALLOCATE")) {
			freeino(ROOTINO);
			if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
				errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
			break;
		}
		if (reply("FIX") == 0) {
			ckfini(0);
			exit(EEXIT);
		}
		dp = ginode(ROOTINO);
		DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT);
		DIP_SET(dp, di_mode, DIP(dp, di_mode) | IFDIR);
		inodirty();
		break;

	case DSTATE:
	case DZLINK:
		break;

	default:
		errx(EEXIT, "BAD STATE %d FOR ROOT INODE",
		    inoinfo(ROOTINO)->ino_state);
	}
	inoinfo(ROOTINO)->ino_state = DFOUND;
	inoinfo(WINO)->ino_state = FSTATE;
	inoinfo(WINO)->ino_type = DT_WHT;
	/*
	 * Sort the directory list into disk block order.
	 */
	qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
	/*
	 * Check the integrity of each directory.
	 */
	memset(&curino, 0, sizeof(struct inodesc));
	curino.id_type = DATA;
	curino.id_func = pass2check;
	inpend = &inpsort[inplast];
	for (inpp = inpsort; inpp < inpend; inpp++) {
		if (got_siginfo) {
			printf("%s: phase 2: dir %td of %d (%d%%)\n", cdevname,
			    inpp - inpsort, (int)inplast,
			    (int)((inpp - inpsort) * 100 / inplast));
			got_siginfo = 0;
		}
		if (got_sigalarm) {
			setproctitle("%s p2 %d%%", cdevname,
			    (int)((inpp - inpsort) * 100 / inplast));
			got_sigalarm = 0;
		}
		inp = *inpp;
		if (inp->i_isize == 0)
			continue;
		if (inp->i_isize < MINDIRSIZE) {
			direrror(inp->i_number, "DIRECTORY TOO SHORT");
			inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
			if (reply("FIX") == 1) {
				dp = ginode(inp->i_number);
				DIP_SET(dp, di_size, inp->i_isize);
				inodirty();
			}
		} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
			getpathname(pathbuf, inp->i_number, inp->i_number);
			if (usedsoftdep)
				pfatal("%s %s: LENGTH %jd NOT MULTIPLE OF %d",
					"DIRECTORY", pathbuf,
					(intmax_t)inp->i_isize, DIRBLKSIZ);
			else
				pwarn("%s %s: LENGTH %jd NOT MULTIPLE OF %d",
					"DIRECTORY", pathbuf,
					(intmax_t)inp->i_isize, DIRBLKSIZ);
			if (preen)
				printf(" (ADJUSTED)\n");
			inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
			if (preen || reply("ADJUST") == 1) {
				dp = ginode(inp->i_number);
				DIP_SET(dp, di_size,
				    roundup(inp->i_isize, DIRBLKSIZ));
				inodirty();
			}
		}
		dp = &dino;
		memset(dp, 0, sizeof(struct ufs2_dinode));
		DIP_SET(dp, di_mode, IFDIR);
		DIP_SET(dp, di_size, inp->i_isize);
		for (i = 0;
		     i < (inp->i_numblks<NDADDR ? inp->i_numblks : NDADDR);
		     i++)
			DIP_SET(dp, di_db[i], inp->i_blks[i]);
		if (inp->i_numblks > NDADDR)
			for (i = 0; i < NIADDR; i++)
				DIP_SET(dp, di_ib[i], inp->i_blks[NDADDR + i]);
		curino.id_number = inp->i_number;
		curino.id_parent = inp->i_parent;
		(void)ckinode(dp, &curino);
	}
	/*
	 * Now that the parents of all directories have been found,
	 * make another pass to verify the value of `..'
	 */
	for (inpp = inpsort; inpp < inpend; inpp++) {
		inp = *inpp;
		if (inp->i_parent == 0 || inp->i_isize == 0)
			continue;
		if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
		    INO_IS_DUNFOUND(inp->i_number))
			inoinfo(inp->i_number)->ino_state = DFOUND;
		if (inp->i_dotdot == inp->i_parent ||
		    inp->i_dotdot == (ino_t)-1)
			continue;
		if (inp->i_dotdot == 0) {
			inp->i_dotdot = inp->i_parent;
			fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
			if (reply("FIX") == 0)
				continue;
			(void)makeentry(inp->i_number, inp->i_parent, "..");
			inoinfo(inp->i_parent)->ino_linkcnt--;
			continue;
		}
		/*
		 * Here we have:
		 *    inp->i_number is directory with bad ".." in it.
		 *    inp->i_dotdot is current value of "..".
		 *    inp->i_parent is directory to which ".." should point.
		 */
		getpathname(pathbuf, inp->i_parent, inp->i_number);
		printf("BAD INODE NUMBER FOR '..' in DIR I=%d (%s)\n",
		    inp->i_number, pathbuf);
		getpathname(pathbuf, inp->i_dotdot, inp->i_dotdot);
		printf("CURRENTLY POINTS TO I=%d (%s), ", inp->i_dotdot,
		    pathbuf);
		getpathname(pathbuf, inp->i_parent, inp->i_parent);
		printf("SHOULD POINT TO I=%d (%s)", inp->i_parent, pathbuf);
		if (cursnapshot != 0) {
			/*
			 * We need to:
			 *    setcwd(inp->i_number);
			 *    setdotdot(inp->i_dotdot, inp->i_parent);
			 */
			cmd.value = inp->i_number;
			if (sysctlbyname("vfs.ffs.setcwd", 0, 0,
			    &cmd, sizeof cmd) == -1) {
				/* kernel lacks support for these functions */
				printf(" (IGNORED)\n");
				continue;
			}
			cmd.value = inp->i_dotdot; /* verify same value */
			cmd.size = inp->i_parent;  /* new parent */
			if (sysctlbyname("vfs.ffs.setdotdot", 0, 0,
			    &cmd, sizeof cmd) == -1) {
				printf(" (FIX FAILED: %s)\n", strerror(errno));
				continue;
			}
			printf(" (FIXED)\n");
			inoinfo(inp->i_parent)->ino_linkcnt--;
			inp->i_dotdot = inp->i_parent;
			continue;
		}
		if (preen)
			printf(" (FIXED)\n");
		else if (reply("FIX") == 0)
			continue;
		inoinfo(inp->i_dotdot)->ino_linkcnt++;
		inoinfo(inp->i_parent)->ino_linkcnt--;
		inp->i_dotdot = inp->i_parent;
		(void)changeino(inp->i_number, "..", inp->i_parent);
	}
	/*
	 * Mark all the directories that can be found from the root.
	 */
	propagate();
}
int genPlacementRoutingMatrix( BOARD* aBrd, EDA_MSG_PANEL* messagePanel )
{
    wxString msg;

    RoutingMatrix.UnInitRoutingMatrix();

    EDA_RECT bbox = aBrd->ComputeBoundingBox( true );

    if( bbox.GetWidth() == 0 || bbox.GetHeight() == 0 )
    {
        DisplayError( NULL, _( "No PCB edge found, unknown board size!" ) );
        return 0;
    }

    RoutingMatrix.ComputeMatrixSize( aBrd, true );
    int nbCells = RoutingMatrix.m_Ncols * RoutingMatrix.m_Nrows;

    messagePanel->EraseMsgBox();
    msg.Printf( wxT( "%d" ), RoutingMatrix.m_Ncols );
    messagePanel->SetMessage( 1, _( "Cols" ), msg, GREEN );
    msg.Printf( wxT( "%d" ), RoutingMatrix.m_Nrows );
    messagePanel->SetMessage( 7, _( "Lines" ), msg, GREEN );
    msg.Printf( wxT( "%d" ), nbCells );
    messagePanel->SetMessage( 14, _( "Cells." ), msg, YELLOW );

    // Choose the number of board sides.
    RoutingMatrix.m_RoutingLayersCount = 2;

    RoutingMatrix.InitRoutingMatrix();

    // Display memory usage.
    msg.Printf( wxT( "%d" ), RoutingMatrix.m_MemSize / 1024 );
    messagePanel->SetMessage( 24, wxT( "Mem(Kb)" ), msg, CYAN );

    g_Route_Layer_BOTTOM = LAYER_N_FRONT;

    if( RoutingMatrix.m_RoutingLayersCount > 1 )
        g_Route_Layer_BOTTOM = LAYER_N_BACK;

    g_Route_Layer_TOP = LAYER_N_FRONT;

    // Place the edge layer segments
    TRACK TmpSegm( NULL );

    TmpSegm.SetLayer( UNDEFINED_LAYER );
    TmpSegm.SetNet( -1 );
    TmpSegm.SetWidth( RoutingMatrix.m_GridRouting / 2 );

    EDA_ITEM* PtStruct = aBrd->m_Drawings;

    for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
    {
        DRAWSEGMENT* DrawSegm;

        switch( PtStruct->Type() )
        {
        case PCB_LINE_T:
            DrawSegm = (DRAWSEGMENT*) PtStruct;

            if( DrawSegm->GetLayer() != EDGE_N )
                break;

            TmpSegm.SetStart( DrawSegm->GetStart() );
            TmpSegm.SetEnd( DrawSegm->GetEnd() );
            TmpSegm.SetShape( DrawSegm->GetShape() );
            TmpSegm.m_Param = DrawSegm->GetAngle();

            TraceSegmentPcb( &TmpSegm, HOLE | CELL_is_EDGE,
                             RoutingMatrix.m_GridRouting, WRITE_CELL );
            break;

        case PCB_TEXT_T:
        default:
            break;
        }
    }

    // Mark cells of the routing matrix to CELL_is_ZONE
    // (i.e. availlable cell to place a module )
    // Init a starting point of attachment to the area.
    RoutingMatrix.OrCell( RoutingMatrix.m_Nrows / 2, RoutingMatrix.m_Ncols / 2,
                          BOTTOM, CELL_is_ZONE );

    // find and mark all other availlable cells:
    for( int ii = 1; ii != 0; )
        ii = propagate();

    // Initialize top layer. to the same value as the bottom layer
    if( RoutingMatrix.m_BoardSide[TOP] )
        memcpy( RoutingMatrix.m_BoardSide[TOP], RoutingMatrix.m_BoardSide[BOTTOM],
                nbCells * sizeof(MATRIX_CELL) );

    return 1;
}
Exemple #26
0
void SemanticObject::update(const Evidence& ev) {

    propagate(ev.getTimestamp());

    // first update class property

    Attribute class_att = AttributeConv::attribute("class_label");
    const Property* ev_class = ev.getProperty(class_att);

    if (ev_class) {
        Property* my_class = getProperty(class_att);

        if (my_class) {
            my_class->update(ev_class->getValue(), ev.getTimestamp());
        } else {
            const IStateEstimator* prototype = getExpectedObjectModel().getEstimator(class_att);
            if (prototype) {
                Property* new_prop = new Property(class_att, *prototype);
                new_prop->update(ev_class->getValue(), ev.getTimestamp());
                addProperty(new_prop);
            } else {
                printf("Could not find prototype estimator for attribute '%s'\n", AttributeConv::attribute_str(class_att).c_str());
            }
        }
    }

    bool class_changed = false;
    const ClassModel& class_model = getExpectedObjectModel();

    if (expected_class_ != class_model.getModelName()) {
        expected_class_ = class_model.getModelName();
        class_changed = true;
    }

    // then update rest

    for(map<Attribute, Property*>::const_iterator it = ev.getPropertyMap().begin(); it != ev.getPropertyMap().end(); ++it) {

        const Attribute& attribute = it->first;
        const Property* ev_prop = it->second;

        if (attribute != class_att) {
            Property* my_prop = getProperty(attribute);

            if (my_prop && !class_changed) {
                my_prop->update(ev_prop->getValue(), ev.getTimestamp());
                //cout << "Updating " << AttributeConv::attribute_str(attribute) << " with " << ev_prop->getValue().toString() << endl;
                //cout << "Result: " << my_prop->toString() << endl;
            } else {
                const IStateEstimator* prototype = getExpectedObjectModel().getEstimator(attribute);
                if (prototype) {
                    Property* new_prop = new Property(attribute, *prototype);
                    new_prop->update(ev_prop->getValue(), ev.getTimestamp());
                    addProperty(new_prop);
                } else {
                    printf("Could not find prototype estimator for attribute '%s'\n", AttributeConv::attribute_str(it->first).c_str());
                }
            }
        }
    }

}
Exemple #27
0
Tree boxPropagateSig (Tree path, Tree box, const siglist& lsig)
{
	return listConvert(propagate(gGlobal->nil, path, box, lsig));
}
Exemple #28
0
void ArcAgenda::propagate(const HyperGraph& g, const BitSet& m) {
	for (int i=0; i<nb_var; i++)
		if (m[i]) propagate(g,-1,i);
}
Exemple #29
0
static int
searchnode(int level, int n, int *e, int nblue, int nred)
{
    boolean ok;
    int i,status,nbest;
    addrval *valptr;
    int best,score,bestscore;
    int fe,fc;
    long ran;
     
    ok = propagate(n,e,&nblue,&nred);

#if DEBUG
    if (ok) dumpdata(level,nblue,nred,n);
    else { printf("FAIL\n"); return NO; }
#else
    if (!ok) return NO;
#endif

    if (nblue == n && nred == n) return YES;

#if FISHTAIL
    status = fishtail(n,&nblue,&nred);
    if (status == NO) return NO;
    if (status == YES) return searchnode(level+1,n,e,nblue,nred);
#endif

    valptr = valstacktop;

    bestscore = -1;
    nbest = 0;
    for (i = 0; i < 2*n; ++i)
	if (colour[i] == WHITE)
        {
	    score = (bluedeg[v1[i]] == 1) + (bluedeg[v2[i]] == 1) +
                    (reddeg[v1[i]] == 1) + (reddeg[v2[i]] == 1);
	    if (score > bestscore)
	    {
		bestscore = score;
		beste[0] = i;
		nbest = 1;
	    }
	    else if (score == bestscore)
	        beste[nbest++] = i;
        }

    if (bestscore == 0 && nred + nblue > 0)
	return FALSE;   /* Disconnected */

    ran = KRAN(2*nbest);
    best = beste[ran/2];

    if ((ran&1))
    {
        if (makeblue(best,nblue==n-1))
        {
#if DEBUG
            printf("   setting %d(%d-%d) blue\n",best,v1[best],v2[best]);
#endif
	    status = searchnode(level+1,n,e,nblue+1,nred);
	    if (status != NO) return status;
	    while (valstacktop > valptr) UNSETVAL;
        }

        if (++nodes == limit) return TIMEOUT;

        if (makered(best,nred==n-1))
        {
#if DEBUG
            printf("   setting %d(%d-%d) red\n",best,v1[best],v2[best]);
#endif
	    status = searchnode(level+1,n,e,nblue,nred+1);
	    if (status != NO) return status;
	    while (valstacktop > valptr) UNSETVAL;
        }
    }
    else
    {
        if (makered(best,nred==n-1))
        {
#if DEBUG
            printf("   setting %d(%d-%d) red\n",best,v1[best],v2[best]);
#endif
	    status = searchnode(level+1,n,e,nblue,nred+1);
	    if (status != NO) return status;
	    while (valstacktop > valptr) UNSETVAL;
        }

        if (++nodes == limit) return TIMEOUT;

        if (makeblue(best,nblue==n-1))
        {
#if DEBUG
            printf("   setting %d(%d-%d) blue\n",best,v1[best],v2[best]);
#endif
	    status = searchnode(level+1,n,e,nblue+1,nred);
	    if (status != NO) return status;
	    while (valstacktop > valptr) UNSETVAL;
        }
    }

    return NO;
}
Exemple #30
0
RESULT Engine::search() {
	int starts = 0;
	int nof_conflicts = so.restart_base;
	int conflictC = 0;

	while (true) {
		if (so.parallel && slave.checkMessages()) return RES_UNK;

		if (!propagate()) {

			clearPropState();

			Conflict:
			conflicts++; conflictC++;

			if (time(NULL) > so.time_out) {
				printf("Time limit exceeded!\n");
				return RES_UNK;
			}

			if (decisionLevel() == 0) { return RES_GUN; }

			// Derive learnt clause and perform backjump
			if (so.lazy) {
				sat.analyze();
			}	else {
				sat.confl = NULL;
				DecInfo& di = dec_info.last();
				sat.btToLevel(decisionLevel()-1);
				makeDecision(di, 1);
			}

            if (!so.vsids && !so.toggle_vsids &&  conflictC >= so.switch_to_vsids_after) {
	    	if (so.restart_base >= 1000000000) so.restart_base = 100;
                sat.btToLevel(0);
                toggleVSIDS();
            }

		} else {

			if (conflictC >= nof_conflicts) {
				starts++;
				nof_conflicts += getRestartLimit((starts+1)/2);
				sat.btToLevel(0);
				sat.confl = NULL;
				if (so.lazy && so.toggle_vsids && (starts % 2 == 0)) toggleVSIDS();
				continue;
			}
			
			if (decisionLevel() == 0) {
				topLevelCleanUp();
				if (opt_var && so.verbosity >= 3) {
					printf("%% root level bounds on objective: min %d max %d\n", opt_var->getMin(), opt_var->getMax());
				}
			}

			DecInfo *di = NULL;
			
			// Propagate assumptions
			while (decisionLevel() < assumptions.size()) {
				int p = assumptions[decisionLevel()];
				if (sat.value(toLit(p)) == l_True) {
					// Dummy decision level:
					assert(sat.trail.last().size() == sat.qhead.last());
					engine.dec_info.push(DecInfo(NULL, p));
					newDecisionLevel();
				} else if (sat.value(toLit(p)) == l_False) {
					return RES_LUN;
				} else {
					di = new DecInfo(NULL, p);
					break;
				}
			}

			if (!di) di = branching->branch();

			if (!di) {
				solutions++;
				if (so.print_sol) {
					problem->print();
					printf("----------\n");
          fflush(stdout);
				}
				if (!opt_var) {
					if (solutions == so.nof_solutions) return RES_SAT;
					if (so.lazy) blockCurrentSol();
					goto Conflict;
				}
				if (!constrain()) {
					return RES_GUN;
				}
				continue;
			}


			engine.dec_info.push(*di);
      newDecisionLevel();

			doFixPointStuff();

			makeDecision(*di, 0);
			delete di;

		}
	}
}