// reachability test, from ni -> nj, according to weight bool Graph::Reachable(int ni, int nj) { MyStack * stack; int tmp,result[1000],result_e[1000],neib_no=0,k; int nt,i; for(i=0;i<node_num;i++) NODE_PTR(i)->color = 0; stack = new MyStack; stack->stack_push(ni,0); NODE_PTR(i)->color = 1; while(stack->stack_pop(&nt,&tmp)!=-1) { neib_no = GetNeighborNodeAndEdge(nt, result,result_e); for(k=0;k<neib_no;k++) { if(result[k]==nj && EDGE_PTR(result_e[k])->weight > 0.5) { delete stack; return true; } if(NODE_PTR(result[k])->color==0 && EDGE_PTR(result_e[k])->weight > 0.5) // hasn't been dried { stack->stack_push(result[k],0); NODE_PTR(result[k])->color=1; } } }; delete stack; return false; }
/* function to write compressed file * @return: total number of written bytes to compressed file i.e. size of compressed file */ f_type write_outfile(char *filename,f_type *freq,struct huffcode *codeTable,struct node *root, f_type total_bytes){ f_type written_bytes=0,read_bytes=0; NODE_PTR(ptr); struct buffer buff={0,-1}; unsigned b; string outfilename=string(filename) + extension; FILE *infile=fopen(filename,"rb"); if(!infile){ fprintf(stderr,"Source file opening error: %s\n",strerror(errno)); return 0; } FILE *outfile=fopen(outfilename.c_str(),"wbx"); for(int i=1;i<=5 && !outfile;i++){ outfilename.insert(outfilename.begin()+outfilename.find_last_of('.'),'1'); outfile=fopen(outfilename.c_str(),"wbx"); } if(!outfile){ fclose(infile); fprintf(stderr,"Destination file opening error: %s\n",strerror(errno)); return 0; } written_bytes=fwrite(freq,sizeof(f_type),TABLE_SIZE,outfile); if(written_bytes==0){ fclose(outfile); fclose(infile); return 0; } while((b=fgetc(infile))!=EOF){ read_bytes++; for(int i=0;i<codeTable[b].length;i++){ buff.byte[++buff.top]=codeTable[b].code[i]; if(buff.top==7){//buffer is full, so write it to file fputc(buff.byte.to_ulong(),outfile); written_bytes++; buff.byte=0; buff.top=-1; } } PROGRESS(read_bytes,total_bytes); } printf("\n"); if(buff.top!=-1){ written_bytes+=2; fputc(buff.byte.to_ulong(),outfile); fputc(buff.top + 1,outfile);//this is length of code in last byte } else{ written_bytes++; fputc(8,outfile);//length of code in last byte is 8 } fclose(infile); fclose(outfile); return written_bytes; }
// Depth-First-Search to get the maximum likelihood assignment of matching // used by Gibbs sampling void MatchMRFGraph::DFSSearch(int * state_seq) { SortMachine sm; int *node_fill, *state_fill,i,j,n,nid,sid; memset(state_seq,0,sizeof(int)*node_num); sm.Init(node_num*m_state_num); for(i=0;i<node_num;i++) for(j=0;j<m_state_num;j++) { sm.m_Arr[i*m_state_num+j].ind = i; sm.m_Arr[i*m_state_num+j].ind2 = j; sm.m_Arr[i*m_state_num+j].d = ((IGraphNode *)NODE_PTR(i))->phi[j]; } sm.Sort(); // occupation array node_fill = new int[node_num]; memset(node_fill,0,node_num*sizeof(int)); state_fill = new int[m_state_num]; memset(state_fill,0,m_state_num*sizeof(int)); state_seq[sm.m_Arr[0].ind] = sm.m_Arr[0].ind2; node_fill[sm.m_Arr[0].ind] = 1; state_fill[sm.m_Arr[0].ind2] = 1; n = 1; while(n<node_num*m_state_num) { nid = sm.m_Arr[n].ind; sid = sm.m_Arr[n++].ind2; if(node_fill[nid]>0 || state_fill[sid]>0) continue; state_seq[nid] = sid; node_fill[nid] = 1; state_fill[sid] = 1; } delete state_fill; delete node_fill; }
/**Function******************************************************************** Synopsis [Executes a trace on the fsm given at construction time using BDDs] Description [The trace is executed using BDDs, that is a proof that the fsm is compatible with the trace is built (if such proof exists). Incomplete traces are filled-in with compatible values for state and input variables. Given trace can be either complete or incomplete. The number of performed steps (transitions) is returned in *n_steps, if a non-NULL pointer is given. If the initial state is not compatible -1 is written.] SideEffects [None] SeeAlso [] ******************************************************************************/ static Trace_ptr bdd_partial_trace_executor_execute (const PartialTraceExecutor_ptr partial_executor, const Trace_ptr trace, const NodeList_ptr language, int* n_steps) { /* local references to self */ const BDDPartialTraceExecutor_ptr self = \ BDD_PARTIAL_TRACE_EXECUTOR(partial_executor); const BaseTraceExecutor_ptr executor = \ BASE_TRACE_EXECUTOR(partial_executor); Trace_ptr res = TRACE(NULL); /* failure */ int count = -1; boolean success = true; DdManager* dd; BddStates trace_states; TraceIter step = TRACE_END_ITER; BddStates fwd_image = (BddStates) NULL; node_ptr path = Nil; /* forward constrained images will be used later to compute the complete trace */ const char* trace_description = "BDD Execution"; /* 0- Check prerequisites */ BDD_PARTIAL_TRACE_EXECUTOR_CHECK_INSTANCE(self); TRACE_CHECK_INSTANCE(trace); BDD_FSM_CHECK_INSTANCE(self->fsm); BDD_ENC_CHECK_INSTANCE(self->enc); dd = BddEnc_get_dd_manager(self->enc); step = trace_first_iter(trace); nusmv_assert(TRACE_END_ITER != step); trace_states = TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_SF_SYMBOLS, self->enc); /* 1- Check Start State */ { bdd_ptr init_bdd = BddFsm_get_init(self->fsm); bdd_ptr invar_bdd = BddFsm_get_state_constraints(self->fsm); BddStates source_states; /* last known states */ source_states = bdd_and(dd, init_bdd, invar_bdd); bdd_and_accumulate(dd, &source_states, trace_states); bdd_free(dd, invar_bdd); bdd_free(dd, init_bdd); bdd_free(dd, trace_states); if (!bdd_is_false(dd, source_states)) { boolean terminate = false; path = cons(NODE_PTR(bdd_dup(source_states)), Nil); ++ count; /* 2- Check Consecutive States are related by transition relation */ do { BddStates last_state; /* (unshifted) next state */ BddStates next_state; /* next state constraints */ BddInputs next_input; /* next input constraints */ BddStatesInputsNexts next_combo; /* state-input-next constraints */ BddStatesInputsNexts constraints; step = TraceIter_get_next(step); if (TRACE_END_ITER != step) { next_input = \ TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_I_SYMBOLS, self->enc); next_combo = \ TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_COMBINATORIAL, self->enc); last_state = \ TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_SF_SYMBOLS, self->enc); next_state = BddEnc_state_var_to_next_state_var(self->enc, last_state); if (0 < BaseTraceExecutor_get_verbosity(executor)) { fprintf(BaseTraceExecutor_get_output_stream(executor), "-- executing step %d ... ", 1 + count); fflush(BaseTraceExecutor_get_output_stream(executor)); } /* building constrained fwd image */ constraints = bdd_and(dd, next_input, next_combo); bdd_and_accumulate(dd, &constraints, next_state); fwd_image = BddFsm_get_sins_constrained_forward_image(self->fsm, source_states, constraints); /* test whether the constrained fwd image is not empty */ if (!bdd_is_false(dd, fwd_image)) { if (0 < BaseTraceExecutor_get_verbosity(executor)) { fprintf(BaseTraceExecutor_get_output_stream(executor), "done\n"); } path = cons(NODE_PTR(fwd_image), path); ++ count; } else { if (0 < BaseTraceExecutor_get_verbosity(executor)) { fprintf(BaseTraceExecutor_get_output_stream(executor), "failed!\n"); } terminate = true; success = false; } /* no longer used bdd refs */ bdd_free(dd, next_input); bdd_free(dd, next_combo); bdd_free(dd, last_state); bdd_free(dd, next_state); bdd_free(dd, source_states); source_states = bdd_dup(fwd_image); } else { if (0 == count) { fprintf(BaseTraceExecutor_get_error_stream(executor), "Warning: trace has no transitions.\n"); } terminate = true; } } while (!terminate); /* loop on state/input pairs */ } /* if has initial state */ else { fprintf(BaseTraceExecutor_get_error_stream(executor), "Error: starting state is not initial state.\n"); success = false; } /* 3- If last state could be reached a complete trace exists */ if (success) { if (0 < count) { res = \ bdd_partial_trace_executor_generate(self, fwd_image, path, count, language, trace_description); } else { /* generates a complete state of trace of length 0 */ res = \ bdd_partial_trace_executor_generate(self, source_states, Nil, 0, language, trace_description); } nusmv_assert(TRACE(NULL) != res); /* cleanup */ walk_dd(dd, bdd_free, path); free_list(path); } bdd_free(dd, source_states); } /* as a final stage, verify loopbacks consistency using internal service. The incomplete trace is compatible (that is, a valid completion exists) iff exactly len(Trace) steps have been performed *and* loopback data for the incomplete trace applies to the complete one as well. */ if (TRACE(NULL) != res) { if (Trace_get_length(trace) == count && partial_trace_executor_check_loopbacks(partial_executor, trace, res)) { fprintf(BaseTraceExecutor_get_output_stream(executor), "-- Trace was successfully completed.\n"); } else { Trace_destroy(res); res = TRACE(NULL); } } if (TRACE(NULL) == res) { fprintf(BaseTraceExecutor_get_output_stream(executor), "-- Trace could not be completed.\n"); } if (NIL(int) != n_steps) { *n_steps = count; } return res; }
int Graph::Ypos(int nodei) { Node * n1; n1 = NODE_PTR(nodei); return n1->vy; }
/** * CAIManager::linkNode * @date Modified April 26, 2006 */ void CAIManager::linkNode(CAINode* poNode) { CObjectManager* poObjectManager = CObjectManager::getInstancePtr(); CCollisionGeometry* poGeo = CCollisionGeometry::getInstancePtr(); CObjectManager::ObjectList oNodeList; poObjectManager->getObjects(OBJ_AI_NODE, &oNodeList); CObjectManager::ObjectList::iterator oNodeIter; float fLength = 0.0f; D3DXVECTOR3 vDirection; std::vector<D3DXVECTOR3> vPoints; std::vector<float> vLengths; bool bLink = true; for (oNodeIter = oNodeList.begin(); oNodeIter != oNodeList.end(); ++oNodeIter) { bLink = true; // don't check against same node if (poNode == NODE_PTR(oNodeIter)) continue; D3DXVec3Subtract(&vDirection, &NODE_PTR(oNodeIter)->getPosition(), &poNode->getPosition()); D3DXVec3Normalize(&fLength, &vDirection, &vDirection); // if the node is too far away, don't even try to link to it // make it relative to the radius es if (fLength > (MAX_LINK_DISTANCE + NODE_PTR(oNodeIter)->m_fRadius + poNode->m_fRadius)) continue; // collision check if (poGeo->checkRayCollision(vPoints, vLengths, poGeo->getRoot(), poNode->getPosition(), vDirection)) { // have to check to see if the collision happened after the node we want to link to for (unsigned int i = 0; i < vLengths.size(); ++i) { if (vLengths[i] < fLength) { // no link bLink = false; break; } } if (bLink) { // will most likely to be a goal node connection // and for the sake of iteration we want it first poNode->m_loLinks.push_front(NODE_PTR(oNodeIter)); // link it both ways NODE_PTR(oNodeIter)->m_loLinks.push_front(poNode); } } // not a single collision so they can link else { // will most likely to be a goal node connection // and for the sake of iteration we want it first poNode->m_loLinks.push_front(NODE_PTR(oNodeIter)); // link it both ways NODE_PTR(oNodeIter)->m_loLinks.push_front(poNode); } vPoints.clear(); vLengths.clear(); } }
/** * CAIManager::createNodeLinks * @date Modified April 26, 2006 */ void CAIManager::createNodeLinks(void) { CObjectManager* poObjectManager = CObjectManager::getInstancePtr(); CCollisionGeometry* poGeo = CCollisionGeometry::getInstancePtr(); CObjectManager::ObjectList oNodeList; poObjectManager->getObjects(OBJ_AI_NODE, &oNodeList); CObjectManager::ObjectList::iterator PrimaryIter, SecondIter; float fLength = 0.0f; D3DXVECTOR3 vDirection; std::vector<D3DXVECTOR3> vPoints; std::vector<float> vLengths; bool bLink = true; for (PrimaryIter = oNodeList.begin(); PrimaryIter != oNodeList.end(); ++PrimaryIter) { for (SecondIter = oNodeList.begin(); SecondIter != oNodeList.end(); ++SecondIter) { bLink = true; // don't check against same node if (NODE_PTR(PrimaryIter) == NODE_PTR(SecondIter)) continue; D3DXVec3Subtract(&vDirection, &NODE_PTR(SecondIter)->getPosition(), &NODE_PTR(PrimaryIter)->getPosition()); D3DXVec3Normalize(&fLength, &vDirection, &vDirection); // if the node is too far away, don't even try to link to it if (fLength > (MAX_LINK_DISTANCE + NODE_PTR(PrimaryIter)->m_fRadius + NODE_PTR(SecondIter)->m_fRadius)) continue; // collision check if (poGeo->checkRayCollision(vPoints, vLengths, poGeo->getRoot(), NODE_PTR(PrimaryIter)->getPosition(), vDirection)) { // have to check to see if the collision happened after the node we want to link to for (unsigned int i = 0; i < vLengths.size(); ++i) { if (vLengths[i] < fLength) { // no link bLink = false; break; } } if (bLink) { NODE_PTR(PrimaryIter)->m_loLinks.push_back(NODE_PTR(SecondIter)); } } // not a single collision so they can link else { NODE_PTR(PrimaryIter)->m_loLinks.push_back(NODE_PTR(SecondIter)); } vPoints.clear(); vLengths.clear(); } } }