/** Check for partial stutter insensitiveness using * the nba and the complement nba */ public void checkNBAs(NBA nba, NBA nba_complement) { APSet apset = nba.getAPSet_cp(); bool nba_is_smaller = (nba.size() < nba_complement.size()); //if (_printInfo) { // std::cerr << "Checking for insensitiveness" << std::endl; //} bool one_insensitive = false; bool all_insensitive = true; //for (APSet::element_iterator it=apset->all_elements_begin(); it!=apset->all_elements_end();++it) for (int it = apset.all_elements_begin(); it != apset.all_elements_end(); ++it) { APElement elem = new APElement(it); if (_partiallyInsensitive.get(it)) { // don't recheck something we already now is stutter insensitive one_insensitive = true; continue; } // if (_printInfo) { //std::cerr << "Checking " << elem.toString(*apset) << ": "; //std::cerr.flush(); // } bool insensitive; if (nba_is_smaller) { insensitive = is_stutter_insensitive(nba, nba_complement, elem); } else { insensitive = is_stutter_insensitive(nba_complement, nba, elem); } if (insensitive) { _partiallyInsensitive.set(it); one_insensitive = true; //if (_printInfo) { // std::cerr << "+" << std::endl; //} } else { all_insensitive = false; //if (_printInfo) { // std::cerr << "-" << std::endl; //} } } _hasCheckedNBAs = true; _partiallyStutterInsensitive = one_insensitive; }
/** * Print the DA in DOT format to the output stream. * This functions expects that the DA is compact. * @param da_type a string specifying the type of automaton ("DRA", "DSA"). * @param out the output stream */ public Graph AutomatonToDot() { Graph g = new Graph("graph"); g.Directed = true; APSet ap_set = getAPSet(); Dictionary <int, string> stateToNumber = new Dictionary <int, string>(); for (int i_state = 0; i_state < this.size(); i_state++) { //out << "\"" << i_state << "\" ["; Node d = formatStateForDOT(i_state, g); stateToNumber.Add(i_state, d.Id); } //out << "]\n"; // close parameters for state for (int i_state = 0; i_state < this.size(); i_state++) { // transitions DA_State cur_state = this.get(i_state); if (cur_state.hasOnlySelfLoop()) { // get first to-state, as all the to-states are the same DA_State to = cur_state.edges().get(new APElement(ap_set.all_elements_begin())); //out << "\"" << i_state << "\" -> \"" << to->getName(); //out << "\" [label=\" true\", color=blue]\n"; Edge edge = g.AddEdge(stateToNumber[i_state], "\u03A3", stateToNumber[to.getName()]); //edge.Attr.Color = Color.Blue; } else { //for (APSet::element_iterator el_it=ap_set.all_elements_begin();el_it!=ap_set.all_elements_end();++el_it) for (int el_it = ap_set.all_elements_begin(); el_it != ap_set.all_elements_end(); ++el_it) { APElement label = new APElement(el_it); DA_State to_state = cur_state.edges().get(label); int to_state_index = to_state.getName(); //out << "\"" << i_state << "\" -> \"" << to_state_index; //out << "\" [label=\" " << label.toString(getAPSet(), false) << "\"]\n"; Edge edge = g.AddEdge(stateToNumber[i_state], label.toString(getAPSet(), false), stateToNumber[to_state_index]); //edge.Attr.Color = Color.Blue; } } } return(g); }
public EdgeContainerExplicit_APElement <BitSet> _container; //<BitSet> /** * Constructor. * @param state the NBA_State owning this EdgeManager * @param apset the underlying APSet */ public NBA_State_EdgeManager(NBA_State state, APSet apset) { _state = state; _container = new EdgeContainerExplicit_APElement <BitSet>(apset.size()); //for (APSet::element_iterator eit=apset.all_elements_begin(); eit!=apset.all_elements_end(); ++eit) { for (int i = apset.all_elements_begin(); i != apset.all_elements_end(); i++) { _container.addEdge(new APElement(i), new BitSet()); } }
/** Make this automaton into an never accepting automaton */ public void constructEmpty() { DA_State n = this.newState(); setStartState(n); //for (APSet::element_iterator it_elem= DA<Label,EdgeContainer,RabinAcceptance>::getAPSet().all_elements_begin();it_elem!=DA<Label,EdgeContainer,RabinAcceptance>::getAPSet().all_elements_end();++it_elem) APSet ap_set = getAPSet(); for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) { APElement label = new APElement(it_elem); n.edges().addEdge(label, n); } }
//typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; //typedef TreeWithAcceptance<algo_state_t, typename Acceptance::signature_type> stuttered_state_t; //typedef typename stuttered_state_t::ptr stuttered_state_ptr_t; //typedef std::pair<stuttered_state_ptr_t, da_state_t*> unprocessed_value_t; //typedef std::stack<unprocessed_value_t> unprocessed_stack_t; /** Convert the NBA to the DA */ public void convert() { APSet ap_set = _da_result.getAPSet(); if (_algo.checkEmpty()) { _da_result.constructEmpty(); return; } _algo.prepareAcceptance(_da_result.acceptance()); TreeWithAcceptance s_start = new TreeWithAcceptance(_algo.getStartState()); DA_State start_state = _da_result.newState(); s_start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { //start_state->setDescription(s_start->toHTML()); start_state.setDescription("hahahahah"); } _state_mapper.add(s_start, start_state); _da_result.setStartState(start_state); Stack <KeyValuePair <TreeWithAcceptance, DA_State> > unprocessed; _unprocessed.Push(new KeyValuePair <TreeWithAcceptance, DA_State>(s_start, start_state)); bool all_insensitive = _stutter_information.isCompletelyInsensitive(); BitSet partial_insensitive = _stutter_information.getPartiallyInsensitiveSymbols(); while (_unprocessed.Count > 0) { KeyValuePair <TreeWithAcceptance, DA_State> top = _unprocessed.Pop(); //_unprocessed.pop(); TreeWithAcceptance from = top.Key; DA_State da_from = top.Value; //for (APSet::element_iterator it_elem=ap_set.all_elements_begin();it_elem!=ap_set.all_elements_end();++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) { APElement elem = new APElement(it_elem); if (da_from.edges().get(elem) == null) { // the edge was not yet calculated... if (!all_insensitive && partial_insensitive.get(it_elem) == null) { // can't stutter for this symbol, do normal step UnionState next_tree = _algo.delta(from.getTree() as UnionState, elem).getState(); TreeWithAcceptance next_state = new TreeWithAcceptance(next_tree); add_transition(da_from, next_state, elem); continue; } // normal stuttering... calc_delta(from, da_from, elem); if (_limit != 0 && _da_result.size() > _limit) { //THROW_EXCEPTION(LimitReachedException, ""); throw new Exception("LimitReachedException"); } } } } }
public EdgeContainerExplicit_APElement<BitSet> _container; //<BitSet> /** * Constructor. * @param state the NBA_State owning this EdgeManager * @param apset the underlying APSet */ public NBA_State_EdgeManager(NBA_State state, APSet apset) { _state = state; _container = new EdgeContainerExplicit_APElement<BitSet>(apset.size()); //for (APSet::element_iterator eit=apset.all_elements_begin(); eit!=apset.all_elements_end(); ++eit) { for (int i = apset.all_elements_begin(); i != apset.all_elements_end(); i++) { _container.addEdge(new APElement(i), new BitSet()); } }
/** * Generate a DA using the Algorithm * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DA than the limit. * @param algo the algorithm * @param da_result the DA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ public void convert(SafraAlgorithm algo, DRA da_result, int limit) { /** The hash map from DA_State to StateInterface */ StateMapper <StateInterface, DA_State> state_mapper = new StateMapper <StateInterface, DA_State>(); APSet ap_set = da_result.getAPSet();////////////************where dose this dra have ap_set? if (algo.checkEmpty()) { da_result.constructEmpty(); return; } //typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; //* Creates new acceptance pairs according to da_result's acceptance. algo.prepareAcceptance(da_result.acceptance());////*********don't understand well StateInterface start = algo.getStartState(); DA_State start_state = da_result.newState();/////************?? what is in this newState? start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { start_state.setDescription(start.toHTML()); } state_mapper.add(start, start_state); da_result.setStartState(start_state); //typedef std::pair<algo_state_t, da_state_t*> unprocessed_value; Stack <KeyValuePair <StateInterface, DA_State> > unprocessed = new Stack <KeyValuePair <StateInterface, DA_State> >(); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(start, start_state)); while (unprocessed.Count > 0) { KeyValuePair <StateInterface, DA_State> top = unprocessed.Pop(); //unprocessed.pop(); StateInterface cur = top.Key; //safratreeNode DA_State from = top.Value; //DA_state //for (APSet::element_iterator it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) ///from 0 to 2^ap_set.size { APElement elem = new APElement(it_elem); /////////set simpleBitset = it_elem ResultStateInterface <SafraTree> result = algo.delta(cur as SafraTree, elem); /////get a new safraTree through elem DA_State to = state_mapper.find(result.getState()); if (to == null)////////////////result is not in state mapper. { to = da_result.newState(); result.getState().generateAcceptance(to.acceptance()); if (_detailed_states) { to.setDescription(result.getState().toHTML()); } state_mapper.add(result.getState(), to); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(result.getState(), to)); } from.edges().set(elem, to);//////////////add this edge. if (limit != 0 && da_result.size() > limit) { throw new LimitReachedException(""); } } } }
/** * Generate a DA using the Algorithm * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DA than the limit. * @param algo the algorithm * @param da_result the DA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ public void convert(DAUnionAlgorithm algo, DRA da_result, int limit) { StateMapper <StateInterface, DA_State> state_mapper = new StateMapper <StateInterface, DA_State>(); APSet ap_set = da_result.getAPSet(); if (algo.checkEmpty()) { da_result.constructEmpty(); return; } //typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; algo.prepareAcceptance(da_result.acceptance()); StateInterface start = algo.getStartState(); DA_State start_state = da_result.newState(); start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { start_state.setDescription(start.toHTML()); } state_mapper.add(start, start_state); da_result.setStartState(start_state); //typedef std::pair<algo_state_t, da_state_t*> unprocessed_value; Stack <KeyValuePair <StateInterface, DA_State> > unprocessed = new Stack <KeyValuePair <StateInterface, DA_State> >(); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(start, start_state)); while (unprocessed.Count > 0) { KeyValuePair <StateInterface, DA_State> top = unprocessed.Pop(); //unprocessed.pop(); StateInterface cur = top.Key; DA_State from = top.Value; //for (APSet::element_iterator it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) { APElement elem = new APElement(it_elem); ResultStateInterface <UnionState> result = algo.delta(cur as UnionState, elem); DA_State to = state_mapper.find(result.getState()); if (to == null) { to = da_result.newState(); result.getState().generateAcceptance(to.acceptance()); if (_detailed_states) { to.setDescription(result.getState().toHTML()); } state_mapper.add(result.getState(), to); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(result.getState(), to)); } from.edges().set(elem, to); if (limit != 0 && da_result.size() > limit) { throw new LimitReachedException(""); } } } }
public static NBA product_automaton(NBA nba_1, NBA nba_2) { Debug.Assert(nba_1.getAPSet() == nba_2.getAPSet()); NBA product_nba = new NBA(nba_1.getAPSet_cp()); APSet apset = nba_1.getAPSet(); Debug.Assert(apset == nba_2.getAPSet()); for (int s_1 = 0; s_1 < nba_1.size(); s_1++) { for (int s_2 = 0; s_2 < nba_2.size(); s_2++) { for (int copy = 0; copy < 2; copy++) { int s_r = product_nba.nba_i_newState(); Debug.Assert(s_r == (s_1 * nba_2.size() + s_2) * 2 + copy); int to_copy = copy; if (copy == 0 && nba_1[s_1].isFinal()) { to_copy = 1; } if (copy == 1 && nba_2[s_2].isFinal()) { product_nba[s_r].setFinal(true); to_copy = 0; } //for (typename APSet::element_iterator it=apset.all_elements_begin();it!=apset.all_elements_end();++it) for (int it = apset.all_elements_begin(); it != apset.all_elements_end(); it++) { APElement label = new APElement(it); BitSet to_s1 = nba_1[s_1].getEdge(label); BitSet to_s2 = nba_2[s_2].getEdge(label); BitSet to_set = new BitSet(); //for (BitSetIterator it_e_1 = BitSetIterator(*to_s1); it_e_1 != BitSetIterator::end(*to_s1); ++it_e_1) //for (int it_e_1 = 0; it_e_1 != to_s1.bitset.Count; ++it_e_1) for (int it_e_1 = BitSetIterator.start(to_s1); it_e_1 != BitSetIterator.end(to_s1); it_e_1 = BitSetIterator.increment(to_s1, it_e_1)) { //for (BitSetIterator it_e_2 = BitSetIterator(*to_s2); it_e_2 != BitSetIterator::end(*to_s2); ++it_e_2) //for (int it_e_2 = 0; it_e_2 != to_s2.bitset.Count; ++it_e_2) for (int it_e_2 = BitSetIterator.start(to_s2); it_e_2 != BitSetIterator.end(to_s2); it_e_2 = BitSetIterator.increment(to_s2, it_e_2)) { int to = it_e_1 * nba_2.size() + it_e_2 * 2 + to_copy; to_set.set(to); } } product_nba[s_r].getEdge(label).Assign(to_set); } } } } int start_1 = nba_1.getStartState().getName(); int start_2 = nba_2.getStartState().getName(); product_nba.setStartState(product_nba[start_1 * nba_2.size() + start_2]); return(product_nba); }
/** * Generate a new DRA from a coloring */ DRA generateDRAfromColoring(DRA oldDRA, Coloring coloring, bool detailedStates) { DRA newDRA = oldDRA.createInstance(oldDRA.getAPSet()) as DRA; newDRA.acceptance().newAcceptancePairs(oldDRA.acceptance().size()); for (int color = 0; color < coloring.countColors(); ++color) { newDRA.newState(); } int old_start_state = oldDRA.getStartState().getName(); int start_state_color = coloring.state2color(old_start_state); newDRA.setStartState(newDRA.get(start_state_color)); APSet apset = newDRA.getAPSet(); for (int color = 0; color < coloring.countColors(); ++color) { DA_State new_state = newDRA.get(color); int old_state_representative = coloring.color2state(color); DA_State old_state = oldDRA[old_state_representative]; if (detailedStates) { BitSet old_states = coloring.color2states(color); // create new description... if (old_states.cardinality() == 1) { if (old_state.hasDescription()) { new_state.setDescription(old_state.getDescription()); } } else { //std::ostringstream s; //s << "<TABLE BORDER=\"1\" CELLBORDER=\"0\"><TR><TD>{</TD>"; StringBuilder s = new StringBuilder(@"<TABLE BORDER=\""1\"" CELLBORDER=\""0\""><TR><TD>{</TD>"); bool first = true; for (int it = BitSetIterator.start(old_states); it != BitSetIterator.end(old_states); it = BitSetIterator.increment(old_states, it)) { if (first) { first = false; } else { s.Append("<TD>,</TD>"); } s.Append("<TD>"); if (!oldDRA[it].hasDescription()) { s.Append(it); } else { s.Append(oldDRA[it].getDescription()); } s.Append("</TD>"); } s.Append("<TD>}</TD></TR></TABLE>"); new_state.setDescription(s.ToString()); ; } } // Create appropriate acceptance conditions int old_state_index = old_state.getName(); for (int i = 0; i < oldDRA.acceptance().size(); ++i) { if (oldDRA.acceptance().isStateInAcceptance_L(i, old_state_index)) { new_state.acceptance().addTo_L(i); } if (oldDRA.acceptance().isStateInAcceptance_U(i, old_state_index)) { new_state.acceptance().addTo_U(i); } } //for (APSet::element_iterator label=apset.all_elements_begin();label!=apset.all_elements_end();++label) for (int label = apset.all_elements_begin(); label != apset.all_elements_end(); ++label) { DA_State old_to = old_state.edges().get(new APElement(label)); int to_color = coloring.state2color(old_to.getName()); new_state.edges().addEdge(new APElement(label), newDRA.get(to_color)); } } return(newDRA); }
public static void dba2dra(NBA nba, DRA dra_result, bool complement) { //complement=false DRA dra = dra_result; APSet ap_set = dra.getAPSet();; dra.acceptance().newAcceptancePair(); for (int i = 0; i < nba.size(); i++) { dra.newState(); if (complement) { // Final states -> U_0, all states -> L_0 if (nba[i].isFinal()) { dra.acceptance().stateIn_U(0, i); } dra.acceptance().stateIn_L(0, i); } else { // Final states -> L_0, U_0 is empty if (nba[i].isFinal()) { dra.acceptance().stateIn_L(0, i); } } } if (nba.getStartState() != null) { dra.setStartState(dra[nba.getStartState().getName()]); } DA_State sink_state = null; for (int i = 0; i < nba.size(); i++) { NBA_State nba_state = nba[i]; DA_State dra_from = dra[i]; //for (APSet::element_iterator label=ap_set->all_elements_begin();label!=ap_set->all_elements_end(); ++label) for (int label = ap_set.all_elements_begin(); label != ap_set.all_elements_end(); ++label) { BitSet to = nba_state.getEdge(new APElement(label)); int to_cardinality = 0; if (to != null) { to_cardinality = to.cardinality(); } DA_State dra_to = null; if (to == null || to_cardinality == 0) { // empty to -> go to sink state if (sink_state == null) { // we have to create the sink sink_state = dra.newState(); // if we complement, we have to add the sink to // L_0 if (complement) { sink_state.acceptance().addTo_L(0); } } dra_to = sink_state; } else if (to_cardinality == 1) { int to_index = to.nextSetBit(0); // std::cerr << "to: " << to_index << std::endl; dra_to = dra[to_index]; } else { // to_cardinality>1 ! throw new IllegalArgumentException("NBA is no DBA!"); } dra_from.edges().addEdge(new APElement(label), dra_to); } } if (sink_state != null) { // there is a sink state // make true-loop from sink state to itself //for (APSet::element_iterator label=ap_set->all_elements_begin();label!=ap_set->all_elements_end();++label) { for (int label = ap_set.all_elements_begin(); label != ap_set.all_elements_end(); ++label) { sink_state.edges().addEdge(new APElement(label), sink_state); } } }