Example #1
0
        //typedef std::vector<algo_state_t> intermediate_state_vector_t;

        /**
         * Calculate Acceptance for RabinAcceptance conditon
         */
        private bool calculate_acceptance(List <StateInterface> state_vector, int cycle_point, RabinSignature prefix_signature, RabinSignature cycle_signature)
        {
            int states = state_vector.Count;

            state_vector[cycle_point].generateAcceptance(cycle_signature); // start
            for (int i = cycle_point + 1; i < states; i++)
            {
                cycle_signature.maxMerge(state_vector[i].generateAcceptance());
            }

            if (prefix_signature != null)
            {
                prefix_signature = new RabinSignature(cycle_signature);
                for (int i = 1; i < cycle_point; i++)
                {
                    prefix_signature.maxMerge(state_vector[i].generateAcceptance());
                }
            }

            if (prefix_signature != null)
            {
                // check if prefix can be ommited
                RabinSignature p0_signature = new RabinSignature(prefix_signature.getSize());
                state_vector[0].generateAcceptance(p0_signature);

                for (int j = 0; j < prefix_signature.getSize(); j++)
                {
                    if (prefix_signature.getColor(j) <= cycle_signature.getColor(j) ||
                        prefix_signature.getColor(j) <= p0_signature.getColor(j))
                    {
                        // acceptance pair j is ok
                        ;
                    }
                    else
                    {
                        return(false);
                    }
                }
                // all acceptance pairs are ok, return true
                return(true);
            }

            return(false);
        }
Example #2
0
        /** Calculate the prefix and the cycle state */
        prefix_and_cycle_state_t calculate_prefix_and_cycle_state(List <StateInterface> state_vector, int cycle_point)
        {
            //TreeWithAcceptance prefix_state, cycle_state;
            TreeWithAcceptance prefix_state = null;
            TreeWithAcceptance cycle_state  = null;
            int states = state_vector.Count; //.size();

            int smallest = cycle_point;

            for (int i = cycle_point + 1; i < states; i++)
            {
                if (state_vector[i] < state_vector[smallest])
                {
                    smallest = i;
                }
            }

#if STUTTERED_VERBOSE
            std::cerr << "Smallest: " << smallest << std::endl;
#endif

            cycle_state = new TreeWithAcceptance(state_vector[smallest]);
            if (!(cycle_point == 0 || cycle_point == 1))
            {
                prefix_state = new TreeWithAcceptance(state_vector[smallest]);
            }

            RabinSignature signature_prefix = null; //(typename Acceptance::signature_type*)NULL;
            if (prefix_state != null)
            {
                signature_prefix = prefix_state.getSignature();
            }
            RabinSignature signature_cycle = cycle_state.getSignature();


            bool omit_prefix = calculate_acceptance(state_vector, cycle_point, signature_prefix, signature_cycle);

            if (omit_prefix)
            {
                prefix_state = null;
            }

            //  if (_detailed_states) {
            //    std::ostringstream prefix_description;
            //    std::ostringstream cycle_description;

            //if (prefix_state) {
            //  prefix_description << "<TABLE><TR><TD>Prefix</TD><TD>Cycle (" << (smallest-cycle_point) <<")</TD></TR>"
            //             << "<TR><TD>";

            //  prefix_description << "<TABLE><TR>";
            //  for (unsigned int i=1;i<cycle_point;i++) {
            //    prefix_description << "<TD>" << state_vector[i]->toHTML() << "</TD>";
            //  }
            //  prefix_description << "</TR></TABLE></TD>";
            //}

            //cycle_description << "<TD><TABLE><TR>";
            //for (unsigned int i=cycle_point; i<state_vector.size();i++) {
            //  cycle_description << "<TD>";
            //  cycle_description << state_vector[i]->toHTML();
            //  cycle_description << "</TD>";
            //}
            //cycle_description << "</TR></TABLE></TD>";


            //if (prefix_state) {
            //  prefix_description << cycle_description.str();
            //  prefix_description << "</TR></TABLE>";

            //  prefix_state->setDescription(prefix_description.str());
            //}

            //cycle_description << "</TR></TABLE>";
            //cycle_state->setDescription("<TABLE><TR><TD>Cycle ("+
            //                boost::lexical_cast<std::string>(smallest-cycle_point) +
            //                ")</TD></TR><TR>" + cycle_description.str());
            //  }

            return(new prefix_and_cycle_state_t(prefix_state, cycle_state));
        }