/** 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;
        }
Exemple #2
0
        /**
         * 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);
        }
Exemple #3
0
        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());
            }
        }
Exemple #4
0
        /** 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);
            }
        }
Exemple #5
0
        //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");
                        }
                    }
                }
            }
        }
Exemple #6
0
  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());
      }

  }
Exemple #7
0
        /**
         * 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("");
                    }
                }
            }
        }
Exemple #8
0
        /**
         * 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("");
                    }
                }
            }
        }
Exemple #9
0
        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);
        }
Exemple #10
0
        /**
         * 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);
        }
Exemple #11
0
        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);
                }
            }
        }