public override void isSatiesfied <T>(Modest.Teaching.TransitionSystem <T> transition_system, LinkedList <T> states, out HashSet <T> sat, ref Pre_Compute_Factory <T> factory)
        {
            if (factory.prop_sats.ContainsKey(this))
            {
                factory.prop_sats.TryGetValue(this, out sat);
                return;
            }


            //Console.WriteLine("Until start");
            HashSet <T> t;                                                                    //Sat(right)

            right.isSatiesfied <T>(transition_system, states, out t, ref factory);
            List <T>    e;                                                                   //Sat(right) <-- still to be expanded
            HashSet <T> temp;

            right.isSatiesfied <T>(transition_system, states, out temp, ref factory);
            e = temp.ToList <T>();
            Queue <T> e_queue = new Queue <T>();

            HashSet <T> left_sat;                                                              //Sat(left)

            left.isSatiesfied <T>(transition_system, states, out left_sat, ref factory);

            left_sat.ExceptWith(t);

            foreach (var entry in e)
            {
                e_queue.Enqueue(entry);
            }

            //HashSet<T> x;



            int e_queue_size = e_queue.Count;

            //Console.WriteLine("59");

            while (e_queue_size > 0)
            {
                var s_prime = e_queue.Dequeue();
                //Console.WriteLine("pre start");
                HashSet <T> pre = factory.getPreSet(ref s_prime);
                //Console.WriteLine("pre stop");
                //left_sat.ExceptWith(t);

                foreach (var s in pre)
                {
                    if (left_sat.Contains(s))
                    {
                        t.Add(s);
                        left_sat.ExceptWith(t);

                        e_queue.Enqueue(s);
                    }
                }
                e_queue_size = e_queue.Count;
            }

            factory.prop_sats.Add(this, t);

            sat = t;

            //Console.WriteLine("Until stop");
        }
示例#2
0
        public override void isSatiesfied <T>(Modest.Teaching.TransitionSystem <T> transition_system, LinkedList <T> states, out HashSet <T> sat, ref Pre_Compute_Factory <T> factory)
        {
            if (factory.prop_sats.ContainsKey(this))
            {
                factory.prop_sats.TryGetValue(this, out sat);
                return;
            }


            //Console.WriteLine("Always start");
            HashSet <T> v;                                                                        //Sat(operand)

            operand.isSatiesfied <T>(transition_system, states, out v, ref factory);
            HashSet <T> e = new HashSet <T>();                                                    //S\V

            foreach (var entry in states)
            {
                e.Add(entry);
            }

            e.ExceptWith(v);

            Queue <T> e_queue = new Queue <T>();

            foreach (var entry in e)
            {
                e_queue.Enqueue(entry);
            }

            Dictionary <T, int> state_c = new Dictionary <T, int>();



            // Initialize c[s] for every state in Sat(operand)
            foreach (var entry in v)
            {
                var         temp = entry;
                HashSet <T> post = factory.getPostSet(ref temp);

                state_c.Add(temp, post.Count);
            }

            int e_queue_size = e_queue.Count;

            while (e_queue_size > 0)
            {
                var         s_prime     = e_queue.Dequeue();
                HashSet <T> pre_s_prime = factory.getPreSet(ref s_prime);

                foreach (var s in pre_s_prime)
                {
                    if (v.Contains(s))
                    {
                        int current_c;
                        state_c.TryGetValue(s, out current_c);
                        state_c.Remove(s);

                        current_c--;

                        state_c.Add(s, current_c);

                        if (current_c == 0)
                        {
                            v.Remove(s);
                            e_queue.Enqueue(s);
                        }
                    }
                }

                e_queue_size = e_queue.Count;
            }

            factory.prop_sats.Add(this, v);

            sat = v;

            //Console.WriteLine("Always stop");
        }