Inheritance: SparseVector
Beispiel #1
0
 public void AssertMarkings(Marking m, Dictionary<int, int> markingsExpected)
 {
     foreach (var marking in markingsExpected)
     {
         Assert.AreEqual(marking.Value, m[marking.Key]);
     }
 }
Beispiel #2
0
        /// <summary>
        /// invokes the first enabled transition in the petri net under the supplied <see cref="Marking"/>.
        /// </summary>
        /// <param name="m">The marking under which transition activation is calculated.</param>
        /// <returns>A new <see cref="Marking"/> containing the result of transition firing on the marking.</returns>
        /// <remarks>
        /// This method will not have any side effects on the <see cref="Marking"/> passed into the function or on the net itself.
        ///
        /// This method works by choosing the next transition to fire randomly.
        /// </remarks>
        public virtual Marking Fire(Marking m)
        {
            var result       = new Marking(m);
            int?transitionId = GetNextTransitionToFire(m);

            if (!transitionId.HasValue)
            {
                return(result);
            }

            int tran = transitionId.Value;

            foreach (var place in GetInArcs(tran).Where(x => x.IsInhibitor == false))
            {
                result[place.Source] = m[place.Source] - 1;
            }

            foreach (var arc in GetOutArcs(tran))
            {
                result[arc.Target] = result[arc.Target] + arc.Weight;
            }

            if (TransitionFunctions.ContainsKey(tran))
            {
                TransitionFunctions[tran].ForEach(a => a(tran));
            }

            return(result);
        }
 public void TestConflictDetection()
 {
     var m = new Marking(3,
        new Dictionary<int, int>
             {
                 { 0, 1 } ,
                 { 1, 1 } ,
                 { 2, 1 }
             });
     var p = new GraphPetriNet("p",
        new Dictionary<int, string> {
             {0, "p0"},
             {1, "p1"},
             {2, "p2"}
         },
        new Dictionary<int, string>
             {
                 { 0, "t1" },
                 { 1, "t2" }
             },
        new Dictionary<int, List<InArc>>(){
             {0, new List<InArc>(){new InArc(0),new InArc(1)}},
             {1, new List<InArc>(){new InArc(1),new InArc(2)}}
         },
        new Dictionary<int, List<OutArc>>() { },
        new Dictionary<int, int>() { { 0, 1 }, { 1, 2 } });
     var enabledTransitions = p.AllEnabledTransitions(m);
     Assert.AreEqual(2, enabledTransitions.Count());
     Assert.IsTrue(enabledTransitions.Contains(0));
     Assert.IsTrue(enabledTransitions.Contains(1));
     Assert.IsTrue(p.IsConflicted(m));
 }
Beispiel #4
0
        public void Test2to1EnablementAndFiring()
        {
            var m = new Marking(3,
                new Dictionary<int, int> { { 0, 1 }, { 1, 0 }, { 2, 0 } });
            var p = new MatrixPetriNet("p",
                new Dictionary<int, string> {
                    {0, "p0"},
                    {1, "p1"},
                    {2, "p2"}
                },
                new Dictionary<int, string> { { 0, "t0" } },
                new Dictionary<int, List<InArc>>{
                    {0, new List<InArc>(){new InArc(0),new InArc(2)}}
                },
                new Dictionary<int, List<OutArc>>{
                    {0, new List<OutArc>(){new OutArc(1)}}
                });

            Assert.AreEqual(false, p.IsEnabled(0, m));
            m[2] = 1;
            Assert.AreEqual(true, p.IsEnabled(0, m));
            m = p.Fire(m);
            Assert.AreEqual(0, m[0]);
            Assert.AreEqual(1, m[1]);
            Assert.AreEqual(0, m[2]);
        }
Beispiel #5
0
        bool AllInArcPlacesHaveMoreTokensThanTheArcWeight(int transitionId, Marking m)
        {
            var arcs   = NonInhibitorsIntoTransition(transitionId);
            var result = arcs.All(placeid => m[placeid] >= GetWeight(placeid, transitionId));

            return(result);
        }
Beispiel #6
0
 public IEnumerable<int> GetEnabledTransitionsAdjacentToPlace(int placeId, Marking m)
 {
     var q = (from outArc in GetPlaceOutArcs(placeId)
              where IsEnabled(outArc, m)
              select outArc).ToArray();
     return q;
 }
Beispiel #7
0
        public IEnumerable <int> GetEnabledTransitionsAdjacentToPlace(int placeId, Marking m)
        {
            var q = (from outArc in GetPlaceOutArcs(placeId)
                     where IsEnabled(outArc, m)
                     select outArc).ToArray();

            return(q);
        }
        public int?GetNextTransitionToFire(Marking m)
        {
            var ets = GetEnabledTransitions(m);

            return((from t in ets
                    orderby GetTransitionPriority(t) descending
                    select t).FirstOrDefault());
        }
Beispiel #9
0
        public IEnumerable <int> GetConflictedPlaces(Marking m)
        {
            var q = from p in AllPlaces()
                    where PlaceIsConflicted(p, m)
                    select p;

            return(q);
        }
        bool AllInArcPlacesHaveMoreTokensThanTheArcWeight(int transitionId, Marking m)
        {
            Contract.Requires(Transitions.ContainsKey(transitionId));

            var arcs   = NonInhibitorsIntoTransition(transitionId);
            var result = arcs.All(ia => m[ia] >= InMatrix[ia, transitionId]);

            return(result);
        }
Beispiel #11
0
 public bool IsEnabled(int transitionId, Marking m)
 {
     var a = IsEmptyTransition(transitionId);
     var b = AllInhibitorsAreFromEmptyPlaces(transitionId, m);
     var c = AllInArcPlacesHaveMoreTokensThanTheArcWeight(transitionId, m);
     // if all inhibitors are empty and all non inhibitors have as many tokens in their origin place as their weight
     bool result = (a || (b && c));
     return result;
 }
Beispiel #12
0
        public bool IsEnabled(int transitionId, Marking m)
        {
            var a = IsEmptyTransition(transitionId);
            var b = AllInhibitorsAreFromEmptyPlaces(transitionId, m);
            var c = AllInArcPlacesHaveMoreTokensThanTheArcWeight(transitionId, m);
            // if all inhibitors are empty and all non inhibitors have as many tokens in their origin place as their weight
            bool result = (a || (b && c));

            return(result);
        }
Beispiel #13
0
 internal IEnumerable <int> AllMarkedPlaces(Marking m)
 {
     for (int i = 0; i < m.Count; i++)
     {
         if (m[i] > 0)
         {
             yield return(i);
         }
     }
 }
 public IEnumerable <int> GetEnabledTransitions(Marking m)
 {
     // subtract the weights from the markings then sum each element in the resulting vectir
     // if the result is greater than or equal to zero then the transition is enabled
     for (int i = 0; i < OutMatrix.Columns; i++)
     {
         if (IsEnabled(i, m))
         {
             yield return(i);
         }
     }
 }
Beispiel #15
0
        public int?GetNextTransitionToFire(Marking m)
        {
            var ets = AllEnabledTransitions(m);

            if (ets.Count() < 1)
            {
                return(null);
            }
            return((from t in ets
                    orderby GetTransitionPriority(t) descending
                    select t).First());
        }
Beispiel #16
0
        public Marking CreateMarking()
        {
            var result = new Marking(Places.Count);

            foreach (var marking in PlaceMarkings)
            {
                if (Places.ContainsValue(marking.Key))
                {
                    result[PlaceIndex(marking.Key)] = marking.Value;
                }
            }
            return(result);
        }
        public virtual Marking Fire(Marking m)
        {
            var firingTransitions = GetEnabledTransitions(m).ToList(); // no laziness here, since enabled trans will change after the flow equation has been evaluated
            var result            = new Marking(m + (OutMatrix - InMatrix) * CreateFiringPlan(m));

            foreach (var transId in firingTransitions)
            {
                if (TransitionFunctions.ContainsKey(transId))
                {
                    TransitionFunctions[transId].ForEach(a => a(transId));
                }
            }
            return(result);
        }
Beispiel #18
0
 public void Test1()
 {
     var m = new Marking(3, new Dictionary<int, int>{
         { 0, 1 },
         { 1, 1 },
         { 2, 0 } });
     var p = CreatePNTwoInOneOut();
     AssertMarkings(m, new Dictionary<int, int>{
         { 0, 1 },
         { 1, 1 },
         { 2, 0 } });
     m = p.Fire(m);
     AssertMarkings(m, new Dictionary<int, int>{
         { 0, 0 },
         { 1, 0 },
         { 2, 1 } });
 }
Beispiel #19
0
        public void Test1to1Enablement()
        {
            var m = new Marking(2,
                new Dictionary<int, int> { { 0, 0 }, { 1, 0 } });
            var p = new MatrixPetriNet("p",
                new Dictionary<int, string> {
                    {0, "p0"},
                    {1, "p1"}
                },
                new Dictionary<int, string> { { 0, "t0" } },
                new Dictionary<int, List<InArc>>(){
                    {0, new List<InArc>(){new InArc(0)}}
                },
                new Dictionary<int, List<OutArc>>(){
                    {0, new List<OutArc>(){new OutArc(1)}}
                });

            m[0] = 1;
            Assert.AreEqual(true, p.IsEnabled(0, m));
        }
        SparseVector CreateFiringPlan(Marking m)
        {
            SparseVector result = new SparseVector(Transitions.Count);

            if (IsConflicted(m))
            {
                var next = GetNextTransitionToFire(m);
                if (next.HasValue)
                {
                    result[next.Value] = 1.0;
                }
            }
            else
            {
                foreach (var transId in GetEnabledTransitions(m))
                {
                    result[transId] = 1;
                }
            }
            return(result);
        }
        public void TestBifurcatingTransition()
        {
            var m = new Marking(3,
                new Dictionary<int, int>
                    {
                        { (int)Places.p1, 0 },
                        { (int)Places.p2, 0 },
                        { (int)Places.p3, 0 }
                    });
            var p = CreatePetriNet.Parse(StdPetriNets.Bifurcation).CreateNet<GraphPetriNet>();

            m.Assert(p.Places, new Dictionary<string, int>{
                { "p1", 0 }, { "p2", 0 }, { "p3", 0 } });

            m.Set(p.Places, "p1", 1);
            m.Assert(p.Places, new Dictionary<string, int>{
                { "p1", 1 }, { "p2", 0 }, { "p3", 0 } });

            m = p.Fire(m);
            m.Assert(p.Places, new Dictionary<string, int>{
                { "p1", 0 }, { "p2", 1 }, { "p3", 1 } });
        }
Beispiel #22
0
 public void TestCreateMarkingWithInvalidSize4()
 {
     var m = new Marking(int.MaxValue);
 }
Beispiel #23
0
 public void TestCreateMarkingWithInvalidSize2()
 {
     var m = new Marking(-1);
 }
Beispiel #24
0
 public void TestCreateMarking()
 {
     var m = new Marking(1);
     Assert.IsNotNull(m);
     Assert.AreEqual(0, m[0]);
 }
Beispiel #25
0
 public void TestTransitionFunctionExecution()
 {
     var m = new Marking(2, new Dictionary<int, int>
             {
                 { 0, 2 } ,
                 { 1, 0 }
             });
     var p = new MatrixPetriNet("p",
         new Dictionary<int, string> {
             {0, "p0"},
             {1, "p1"}
         },
         new Dictionary<int, string>
             {
                 { 0, "t0" }
             },
         new Dictionary<int, List<InArc>>(){
             {0, new List<InArc>(){new InArc(0)}}
         },
         new Dictionary<int, List<OutArc>>(){
             {0, new List<OutArc>(){new OutArc(1)}}
         });
     Assert.AreEqual(2, m[0]);
     var someLocal = 0;
     m[0] = 1;
     p.RegisterFunction(0, (t) => someLocal += 1);
     m = p.Fire(m);
     Assert.AreEqual(1, someLocal);
 }
Beispiel #26
0
 internal void AssertMarkings(Marking m, Dictionary<Places, double> markingsExpected)
 {
     foreach (var marking in markingsExpected)
     {
         Assert.AreEqual(marking.Value, m[Convert.ToInt32(marking.Key)]);
     }
 }
Beispiel #27
0
 public bool PlaceIsConflicted(int placeId, Marking m)
 {
     return(GetEnabledTransitionsAdjacentToPlace(placeId, m).Count() > 1);
 }
Beispiel #28
0
 public bool IsConflicted(Marking m)
 {
     return(AllPlaces().Any(pid => PlaceIsConflicted(pid, m)));
 }
Beispiel #29
0
 public Marking(Marking m)
     : base(m)
 {
 }
Beispiel #30
0
 public void TestCreateMarkingWithInvalidSize5()
 {
     var m = new Marking(GraphPetriNet.MaxSize + 1);
 }
Beispiel #31
0
        /// <summary>
        /// invokes the first enabled transition in the petri net under the supplied <see cref="Marking"/>.
        /// </summary>
        /// <param name="m">The marking under which transition activation is calculated.</param>
        /// <returns>A new <see cref="Marking"/> containing the result of transition firing on the marking.</returns>
        /// <remarks>
        /// This method will not have any side effects on the <see cref="Marking"/> passed into the function or on the net itself.
        /// 
        /// This method works by choosing the next transition to fire randomly.
        /// </remarks>
        public virtual Marking Fire(Marking m)
        {
            var result = new Marking(m);
            int? transitionId = GetNextTransitionToFire(m);

            if (!transitionId.HasValue)
                return result;

            int tran = transitionId.Value;

            foreach (var place in GetInArcs(tran).Where(x => x.IsInhibitor == false))
                result[place.Source] = m[place.Source] - 1;

            foreach (var arc in GetOutArcs(tran))
                result[arc.Target] = result[arc.Target] + arc.Weight;

            if (TransitionFunctions.ContainsKey(tran))
                TransitionFunctions[tran].ForEach(a => a(tran));

            return result;
        }
Beispiel #32
0
        public void TestDrainTransition()
        {
            var m = new Marking(1, new Dictionary<int, int>
                    {
                        { 0, 5 }
                    });
            var p = new MatrixPetriNet("p",
                new Dictionary<int, string> {
                    {0, "p0"}
                },
                new Dictionary<int, string>
                    {
                        { 0, "Ti" }
                    },
                new Dictionary<int, List<InArc>>() {
                    {0, new List<InArc>(){new InArc(0)}}
                },
                new Dictionary<int, List<OutArc>>() { });

            for (int i = 5; i >= 0; i--)
            {
                Assert.AreEqual(i, m[0]);
                Assert.AreEqual(i > 0, p.IsEnabled(0, m));
                m = p.Fire(m);
            }
        }
Beispiel #33
0
        public void TestFireConflictingTransitions()
        {
            var m = new Marking(3, new Dictionary<int, int>
                    {
                        { 0, 1 } ,
                        { 2, 0 } ,
                        { 1, 0 }
                    });
            var p = new MatrixPetriNet("p",
                new Dictionary<int, string> {
                    {0, "p0"},
                    {1, "p1"},
                    {2, "p2"}
                },
                new Dictionary<int, string>
                    {
                        { 0, "t1" }
                    },
                new Dictionary<int, List<InArc>>(){
                    {0, new List<InArc>(){new InArc(0),new InArc(2)}}
                },
                new Dictionary<int, List<OutArc>>(){
                    {0, new List<OutArc>(){new OutArc(1)}}
                });

            Assert.AreEqual(false, p.IsEnabled(0, m));
            m[2] = 1;
            Assert.AreEqual(true, p.IsEnabled(0, m));
        }
Beispiel #34
0
 public void TestCreateMarkingWithMaxSize()
 {
     var m = new Marking(GraphPetriNet.MaxSize);
 }
Beispiel #35
0
 public void TestSelfTransition()
 {
     var m = new Marking(1,
         new Dictionary<int, int>
             {
                 { (int)Places.p1, 0 }
             });
     var p = new MatrixPetriNet("p",
         new Dictionary<int, string> {
             {(int)Places.p1, "p1"}
         },
         new Dictionary<int, string>
             {
                 { (int)Transitions.t1, "t1" }
             },
         new Dictionary<int, List<InArc>>(){
             {(int)Transitions.t1, new List<InArc>(){new InArc((int)Places.p1)}}
         },
         new Dictionary<int, List<OutArc>>(){
             {(int)Transitions.t1, new List<OutArc>(){new OutArc((int)Places.p1)}}
         });
     m[(int)Places.p1] = 1;
     Assert.AreEqual(1, m[(int)Places.p1]);
     m = p.Fire(m);
     Assert.AreEqual(1, m[(int)Places.p1]);
 }
        bool AllInhibitorsAreFromEmptyPlaces(int transitionId, Marking m)
        {
            Contract.Requires(Transitions.ContainsKey(transitionId));

            return(InhibitorsIntoTransition(transitionId).All(ia => m[ia] == 0));
        }
Beispiel #37
0
 public void TestSetMarkingAffectsEnablementszx()
 {
     var p = TestFixture2.CreatePNTwoInOneOut();
     var m = new Marking(3, new Dictionary<int, int>(){
         {0,1}, {1,1}, {2,0}
     });
     Assert.AreEqual(true, p.IsEnabled(0, m));
     m[0] = 0;
     Assert.AreEqual(false, p.IsEnabled(0, m));
 }
Beispiel #38
0
 public int? GetNextTransitionToFire(Marking m)
 {
     var ets = AllEnabledTransitions(m);
     if (ets.Count()< 1)
     {
         return null;
     }
     return (from t in ets
             orderby GetTransitionPriority(t) descending
             select t).First();
 }
Beispiel #39
0
 public IEnumerable <int> AllEnabledTransitions(Marking m)
 {
     return(from t in Transitions
            where IsEnabled(t.Key, m)
            select t.Key);
 }
Beispiel #40
0
 public void TestInputTransition()
 {
     var m = new Marking(1, new Dictionary<int, int>
             {
                 { 0, 0 }
             });
     var p = new MatrixPetriNet("p",
         new Dictionary<int, string> {
             {0, "p0"}
         },
         new Dictionary<int, string>
             {
                 { 0, "Ti" }
             },
         new Dictionary<int, List<InArc>>() { },
         new Dictionary<int, List<OutArc>>(){
             {0, new List<OutArc>(){new OutArc(0)}}
         });
     Assert.AreEqual(0, m[0]);
     Assert.IsTrue(p.IsEnabled(0, m));
     m = p.Fire(m);
     Assert.AreEqual(1, m[0]);
     Assert.IsTrue(p.IsEnabled(0, m));
     m = p.Fire(m);
     Assert.AreEqual(2, m[0]);
     Assert.IsTrue(p.IsEnabled(0, m));
 }
Beispiel #41
0
        bool AllInhibitorsAreFromEmptyPlaces(int transitionId, Marking m)
        {
            var inhibitorsIntoTransition = InhibitorsIntoTransition(transitionId);

            return(inhibitorsIntoTransition.All(placeid => m[placeid] == 0));
        }
Beispiel #42
0
 public Marking(Marking m) : base(m)
 {
 }
Beispiel #43
0
        public void TestMarkingFlowInBifurcatedTransition()
        {
            var m = new Marking(3);
            var p = new MatrixPetriNet("p",
                new Dictionary<int, string> {
                    {(int)Places.p1, "p1"},
                    {(int)Places.p2, "p2"},
                    {(int)Places.p3, "p3"}
                },
                new Dictionary<int, string>
                    {
                        { (int)Transitions.t1, "t1" }
                    },
                new Dictionary<int, List<InArc>>(){
                    {(int)Transitions.t1, new List<InArc>(){new InArc((int)Places.p1)}}
                },
                new Dictionary<int, List<OutArc>>(){
                    {(int)Transitions.t1, new List<OutArc>(){new OutArc((int)Places.p2),
                                                             new OutArc((int)Places.p3)}}
                });

            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 0 },
                { Places.p3, 0 } });

            m[(int)Places.p1] = 1;
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 1 },
                { Places.p2, 0 },
                { Places.p3, 0 } });

            m = p.Fire(m);
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 1 },
                { Places.p3, 1 } });
        }
Beispiel #44
0
 public IEnumerable<int> AllEnabledTransitions(Marking m)
 {
     return (from t in Transitions
             where IsEnabled(t.Key, m)
             select t.Key);
 }
Beispiel #45
0
        public void TestMarkingFlowInComplexNet()
        {
            var m = new Marking(4,
                new Dictionary<int, int>
                    {
                        { (int)Places.p1, 0 },
                        { (int)Places.p2, 0 },
                        { (int)Places.p3, 0 },
                        { (int)Places.p4, 0 }
                    });
            var p = new MatrixPetriNet("p",
                new Dictionary<int, string> {
                    {(int)Places.p1, "p1"},
                    {(int)Places.p2, "p2"},
                    {(int)Places.p3, "p3"},
                    {(int)Places.p4, "p4"}
                },
                new Dictionary<int, string>
                    {
                        { (int)Transitions.t1, "t1" },
                        { (int)Transitions.t2, "t2" },
                        { (int)Transitions.t3, "t3" }
                    },
                new Dictionary<int, List<InArc>>(){
                    {(int)Transitions.t1, new List<InArc>(){new InArc((int)Places.p1)}},
                    {(int)Transitions.t2, new List<InArc>(){new InArc((int)Places.p2)}},
                    {(int)Transitions.t3, new List<InArc>(){new InArc((int)Places.p4)}}
                },
                new Dictionary<int, List<OutArc>>(){
                    {(int)Transitions.t1, new List<OutArc>(){new OutArc((int)Places.p2)}},
                    {(int)Transitions.t2, new List<OutArc>(){new OutArc((int)Places.p3)}},
                    {(int)Transitions.t3, new List<OutArc>(){new OutArc((int)Places.p2)}}
                });

            /*
             * This model is a petri net in this shape
             *
             * P1 --> T1 --> P2 --> T2 --> P3
             *                ^
             *                |
             *                T3
             *                ^
             *                |
             *                P4
             * */
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 0 },
                { Places.p3, 0 },
                { Places.p4, 0 } });

            m[(int)Places.p1] = 1;
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 1 },
                { Places.p2, 0 },
                { Places.p3, 0 },
                { Places.p4, 0 } });

            m = p.Fire(m);
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 1 },
                { Places.p3, 0 },
                { Places.p4, 0 } });

            m = p.Fire(m);
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 0 },
                { Places.p3, 1 },
                { Places.p4, 0 } });

            m[(int)Places.p4] = 1;
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 0 },
                { Places.p3, 1 },
                { Places.p4, 1 } });

            m = p.Fire(m);
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 1 },
                { Places.p3, 1 },
                { Places.p4, 0 } });

            m = p.Fire(m);
            AssertMarkings(m, new Dictionary<Places, double>{
                { Places.p1, 0 },
                { Places.p2, 0 },
                { Places.p3, 2 },
                { Places.p4, 0 } });
        }
Beispiel #46
0
 public IEnumerable<int> GetConflictedPlaces(Marking m)
 {
     var q = from p in AllPlaces()
             where PlaceIsConflicted(p, m)
             select p;
     return q;
 }
Beispiel #47
0
 public void TestPrioritySelection2()
 {
     var m = new Marking(4, new Dictionary<int, int>
             {
                 { 0, 1 } ,
                 { 1, 1 } ,
                 { 2, 1 } ,
                 { 3, 1 }
             });
     var p = new MatrixPetriNet("p",
        new Dictionary<int, string> {
             {0, "p0"},
             {1, "p1"},
             {2, "p2"},
             {3, "p3"}
         },
        new Dictionary<int, string>
             {
                 { 0, "t1" },
                 { 1, "t2" },
                 { 2, "t3" }
             },
        new Dictionary<int, List<InArc>>(){
             {0, new List<InArc>(){new InArc(0),new InArc(1)}},
             {1, new List<InArc>(){new InArc(1),new InArc(2)}},
             {2, new List<InArc>(){new InArc(1),new InArc(2),new InArc(3)}}
         },
        new Dictionary<int, List<OutArc>>() { },
        new Dictionary<int, int>()
        {
             { 0, 1 } ,
             { 1, 1 } ,
             { 2, 4 }
        }); // t0 will be baseline at 0 and t1 will be 1, therefore next enabled transition should always be 1
     int? transId = p.GetNextTransitionToFire(m);
     Assert.IsTrue(transId.HasValue);
     Assert.AreEqual(2, transId.Value);
 }
Beispiel #48
0
 internal IEnumerable<int> AllMarkedPlaces(Marking m)
 {
     for (int i = 0; i < m.Count; i++)
     {
         if (m[i] > 0)
         {
             yield return i;
         }
     }
 }
Beispiel #49
0
 public void TestPrioritySetup()
 {
     var m = new Marking(3, new Dictionary<int, int>
             {
                 { 0, 1 } ,
                 { 1, 1 } ,
                 { 2, 1 }
             });
     var p = new MatrixPetriNet("p",
        new Dictionary<int, string> {
             {0, "p0"},
             {1, "p1"},
             {2, "p2"}
         },
        new Dictionary<int, string>
             {
                 { 0, "t1" },
                 { 1, "t2" }
             },
        new Dictionary<int, List<InArc>>(){
             {0, new List<InArc>(){new InArc(0),new InArc(1)}},
             {1, new List<InArc>(){new InArc(1),new InArc(2)}}
         },
        new Dictionary<int, List<OutArc>>() { },
        new Dictionary<int, int>() { { 0, 1 }, { 1, 2 } });
     Assert.AreEqual(1, p.GetTransitionPriority(0));
     Assert.AreEqual(2, p.GetTransitionPriority(1));
 }