public static void Change_Node(nodeBlock old_node, nodeBlock new_node)
        {
            LinkedListNode <nodeBlock> mark = lists.nodelist.Find(old_node);

            lists.nodelist.AddAfter(mark, new_node);
            lists.nodelist.Remove(mark);
        }
        /// <summary>
        /// Search a block by name and remove it
        /// Output parameter is bool, which is tell you  the function is suceeded.
        /// </summary>
        /// <param name="name"></param>
        public static bool RemoveBlockFromList(string name)
        {
            bool found = false;

            tfBlock tf = new tfBlock();

            if (SearchTf_byName(name, out tf))
            {
                LinkedListNode <tfBlock> mark = lists.tflist.Find(tf);
                lists.tflist.Remove(mark);
                return(true);
            }
            sumBlock Sum = new sumBlock();

            if (SearchSum_byName(name, out Sum))
            {
                LinkedListNode <sumBlock> mark = lists.sumlist.Find(Sum);
                lists.sumlist.Remove(mark);
                return(true);
            }
            nodeBlock Node = new nodeBlock();

            if (SearchNode_byName(name, out Node))
            {
                LinkedListNode <nodeBlock> mark = lists.nodelist.Find(Node);
                lists.nodelist.Remove(mark);
                return(true);
            }
            else
            {
                return(false);
            }
        }
        public static bool Scanning_Parallel(out tfBlock tf1, out tfBlock tf2, out nodeBlock node, out sumBlock sum)
        {
            tfBlock TempTf = tf1 = tf2 = new tfBlock();

            node = new nodeBlock();
            sum  = new sumBlock();

            foreach (tfBlock element in lists.tflist)
            {
                if ((element.input == TempTf.input) && (element.output == TempTf.output))
                {
                    tf1 = element;
                    tf2 = TempTf;
                    if (blockmanager.SearchSum_byName(tf1.output, out sum))
                    {
                        if (blockmanager.SearchNode_byName(tf1.input, out node))
                        {
                            Console.WriteLine("\tFound a parallel connection: ({0}) --> ({1}) , ({2}) --> ({3})", node.name, tf1.name, tf2.name, sum.name);
                            return(true);
                        }
                    }
                }
                TempTf = element;
            }
            return(false);
        }
Esempio n. 4
0
 public Node(string input, string output1, string output2, out nodeBlock node)
 {
     node.name    = "";
     node.input   = input;
     node.output1 = output1;
     node.output2 = output2;
 }
 /// <summary>
 /// Functino for collect all information from a Node
 /// </summary>
 /// <param name="node"></param>
 public static void NodeDatas(nodeBlock node)
 {
     Console.WriteLine("\n####### Details of a Node block #######");
     Console.WriteLine("node name: {0}", node.name);
     Console.WriteLine("node graph: ");
     Console.WriteLine();
     Console.Write("{0} --> [{1}] --> {2}\n\t\t     -> {3}", node.input, node.name, node.output1, node.output2);
     Console.WriteLine();
 }
        /// <summary>
        /// This function is useful for creating a new element inside the system.
        /// \nSearch the block, which is on the new block input, and change its output pin and return its name
        /// </summary>
        /// <param name="old_InputPin"></param>
        /// <param name="new_BlockName"></param>
        /// <param name="old_inputBlockName"></param>
        /// <returns></returns>
        public static string InputChange(string old_InputPin, string new_BlockName, string old_inputBlockName)
        {
            string    newInputPin = "";
            tfBlock   TempTf      = new tfBlock();
            sumBlock  TempSum     = new sumBlock();
            nodeBlock TempNode    = new nodeBlock();

            if (String.Equals(old_InputPin, "start", StringComparison.OrdinalIgnoreCase))
            {
                return("start");
            }
            if (SearchTf_byName(old_InputPin, out TempTf))
            {
                LinkedListNode <tfBlock> mark = lists.tflist.Find(TempTf);
                TempTf.output = new_BlockName;
                lists.tflist.AddAfter(mark, TempTf);
                lists.tflist.Remove(mark);
                return(TempTf.name);
            }
            if (SearchSum_byName(old_InputPin, out TempSum))
            {
                LinkedListNode <sumBlock> mark = lists.sumlist.Find(TempSum);
                TempSum.output = new_BlockName;
                lists.sumlist.AddAfter(mark, TempSum);
                lists.sumlist.Remove(mark);
                return(TempSum.name);
            }
            if (SearchNode_byName(old_InputPin, out TempNode))
            {
                LinkedListNode <nodeBlock> mark = lists.nodelist.Find(TempNode);
                if (TempNode.output1 == old_inputBlockName)
                {
                    TempNode.output1 = new_BlockName;
                }
                else
                {
                    TempNode.output2 = new_BlockName;
                }
                lists.nodelist.AddAfter(mark, TempNode);
                lists.nodelist.Remove(mark);
                return(TempNode.name);
            }
            else
            {
                Console.WriteLine("[ERR]: could not found block with this name: {0}", old_InputPin);
                Console.ReadKey();
            }


            return(newInputPin);
        }
        /// <summary>
        /// Search Node Block by name
        /// The output paramter is bool, becaouse it is make simple the work with this.
        /// The founded parameter is defined in parameters field.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="node"></param>
        /// <returns></returns>
        public static bool SearchNode_byName(string name, out nodeBlock node)
        {
            bool result = false;

            new Node("", "", "", out node);
            foreach (nodeBlock element in lists.nodelist)
            {
                if (element.name == name)
                {
                    result = true;
                    node   = element;
                    break;
                }
            }
            return(result);
        }
        /// <summary>
        /// Implementation of feedback connection reducing
        /// </summary>
        /// <param name="tf1"></param>
        /// <param name="tf2"></param>
        /// <param name="sum"></param>
        /// <param name="node"></param>
        public static void feedback(tfBlock tf1, tfBlock tf2, sumBlock sum, nodeBlock node)
        {
            tfBlock tf;

            if (sum.sign2 < 0)
            {
                tf = parallel(identicalTf(), series(tf1, tf2, true), SIGN.plus, SIGN.plus);
            }
            else
            {
                tf = parallel(identicalTf(), series(tf1, tf2, true), SIGN.plus, SIGN.minus);
            }
            tf = series(tf1, inverseTf(tf, true), true);

            tf.name  = blockmanager.NameCounter("feedback", Blocktypes.tf);
            tf.input = blockmanager.InputChange(sum.input1, tf.name, sum.name);
            //tf.output:
            blockmanager.SearchTf_byName(node.output1, out TempTf); //előfordulhat, hogy a node outpu1-én van a visszacsatolás ága!
            if (TempTf.name == tf2.name)                            //ha az első outputon van a visszacsatolási ág
            {
                tf.output = blockmanager.OutputChange(node.output2, tf.name, node.name);
            }
            else //egyébként
            {
                tf.output = blockmanager.OutputChange(node.output1, tf.name, node.name);
            }

            blockmanager.Change_Tf(tf1, tf);
            blockmanager.RemoveBlockFromList(tf2.name, Blocktypes.tf);
            blockmanager.RemoveBlockFromList(sum.name, Blocktypes.sum);
            blockmanager.RemoveBlockFromList(node.name, Blocktypes.node);

            Console.WriteLine("\tSimplified a feedback connection: ({0})", tf.name);
            ConsistencyResult result = Check.consistency();

            if (!result.success)
            {
                Check.ReadConsistencyResult(result);
                Console.ReadKey();
            }
        }
        public static void swapper(tfBlock old_tf, nodeBlock old_node)
        {
            tfBlock new_tf = old_tf;

            //az eredeti tf lecserélése az eltoltra a listában
            new_tf.input  = old_node.name;
            new_tf.output = old_node.output1;
            blockmanager.Change_Tf(old_tf, new_tf);
            //párhuzamos tf létrehozása
            string para_tfname = blockmanager.NameCounter(old_tf.name, Blocktypes.tf);

            new TransferFunction(para_tfname, old_tf.num, old_tf.den, old_node.name, old_node.output2);
            //eltolt node létrehozása, és a régi törlése
            blockmanager.RemoveBlockFromList(old_node.name, Blocktypes.node);
            new Node(old_node.name, old_tf.input, old_tf.name, para_tfname);
            //in- és outputokra kötött blokkok megfelelő PIN-jeinek átírása
            blockmanager.InputChange(old_tf.input, old_node.name, old_tf.name);
            blockmanager.OutputChange(old_node.output1, old_tf.name, old_node.name);
            blockmanager.OutputChange(old_node.output2, para_tfname, old_node.name);
            //konzisztencia check
            Check.Consistency_CheckAndPause();
        }
Esempio n. 10
0
        public static void swapper(nodeBlock node1, nodeBlock node2)
        {
            nodeBlock new_node1, new_node2;

            new_node1.name    = node2.name;
            new_node1.input   = node1.input;
            new_node1.output1 = node1.name;
            new_node1.output2 = node2.output2;

            new_node2.name    = node1.name;
            new_node2.input   = new_node1.name;
            new_node2.output1 = node2.output2;
            new_node2.output2 = node1.output2;

            blockmanager.Change_Node(node1, new_node1);
            blockmanager.Change_Node(node2, new_node2);

            blockmanager.InputChange(node1.input, new_node1.name, node1.name);
            blockmanager.OutputChange(node2.output1, new_node2.name, node2.name);

            Check.Consistency_CheckAndPause();
        }
Esempio n. 11
0
        public static void swapper(nodeBlock old_node, tfBlock old_tf)
        {
            tfBlock new_tf = old_tf;

            //az eredeti tf lecserélése az eltoltra
            new_tf.input  = old_node.input;
            new_tf.output = old_node.name;
            blockmanager.Change_Tf(old_tf, new_tf);
            //párhuzamos inverz tf létrehozása
            tfBlock inv_tf = inverseTf(old_tf, true);

            inv_tf.name = blockmanager.NameCounter(old_tf.name, Blocktypes.tf);
            lists.tflist.AddLast(inv_tf);
            //eltolt node létrehozása
            blockmanager.RemoveBlockFromList(old_node.name, Blocktypes.node);
            new Node(old_node.name, new_tf.input, old_tf.output, inv_tf.name);
            //in- és outputokra kötött blokkok megfelelő PIN.jeinek átírása
            blockmanager.InputChange(old_node.input, new_tf.name, old_node.name);
            blockmanager.OutputChange(old_tf.output, old_node.name, old_tf.name);
            blockmanager.OutputChange(old_node.output2, inv_tf.name, old_node.name);
            //konzisztencia check
            Check.Consistency_CheckAndPause();
        }
Esempio n. 12
0
        /// <summary>
        /// This function will be reduce a parallel connection.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="tf1"></param>
        /// <param name="tf2"></param>
        /// <param name="sum"></param>
        public static void parallel(tfBlock tf1, tfBlock tf2, nodeBlock node, sumBlock sum)
        {
            tfBlock newtf = new tfBlock();

            newtf.num    = MathExtended.PolySum(MathExtended.convolution(tf1.num, tf2.den), MathExtended.convolution(tf2.num, tf1.den), sum.sign1, sum.sign2);
            newtf.den    = MathExtended.convolution(tf1.den, tf2.den);
            newtf.name   = blockmanager.NameCounter("parallel", Blocktypes.tf);
            newtf.input  = blockmanager.InputChange(node.input, newtf.name, node.name);
            newtf.output = blockmanager.OutputChange(sum.output, newtf.name, sum.name);
            blockmanager.Change_Tf(tf1, newtf);
            blockmanager.RemoveBlockFromList(tf2.name, Blocktypes.tf);
            blockmanager.RemoveBlockFromList(node.name, Blocktypes.node);
            blockmanager.RemoveBlockFromList(sum.name, Blocktypes.sum);

            Console.WriteLine("\tSimplified a parallel connection: ({0})", newtf.name);
            ConsistencyResult result;

            result = Check.consistency();
            if (!result.success)
            {
                Check.ReadConsistencyResult(result);
            }
        }
        public static bool Scanning_Feedback(out tfBlock tf1, out tfBlock tf2, out nodeBlock node, out sumBlock sum)
        {
            tfBlock TempTf = tf1 = tf2 = new tfBlock();

            node = new nodeBlock();
            sum  = new sumBlock();
            foreach (tfBlock element in lists.tflist)
            {
                if ((element.input == TempTf.output) && (element.output == TempTf.input))
                {
                    if (blockmanager.SearchSum_byName(element.input, out sum))
                    {
                        tf1 = element;
                        tf2 = TempTf;
                        //a folyamatos konzisztencia check-ek miatt nem kell külön megvizsgálni, hogy ez a node az a node-e, mert annak kell lennie.
                        if (blockmanager.SearchNode_byName(tf1.output, out node))
                        {
                            Console.WriteLine("\tFound a feedback connection: ({0}) --> ({1}) --> ({2}) --> ({3})", sum.name, tf1.name, node.name, tf2.name);
                            return(true);
                        }
                    }
                    if (blockmanager.SearchSum_byName(TempTf.input, out sum))
                    {
                        tf1 = TempTf;
                        tf2 = element;
                        if (blockmanager.SearchNode_byName(tf1.output, out node))
                        {
                            Console.WriteLine("\tFound a feedback connection: ({0}) --> ({1}) --> ({2}) --> ({3})", sum.name, tf1.name, node.name, tf2.name);
                            return(true);
                        }
                    }
                }
                TempTf = element;
            }
            return(false);
        }
Esempio n. 14
0
        public static void swapper(nodeBlock node1, nodeBlock node2, string output1, string output2, string output3)
        {
            nodeBlock new_node1, new_node2;

            new_node1.name    = node2.name;
            new_node1.input   = node1.input;
            new_node1.output1 = node2.name;
            new_node2.name    = node1.name;
            new_node2.input   = new_node1.name;
            new_node2.output1 = output1;
            new_node1.output2 = output2;
            new_node2.output2 = output3;

            blockmanager.Change_Node(node1, new_node1);
            blockmanager.Change_Node(node2, new_node2);

            blockmanager.InputChange(node1.input, new_node1.name, node1.name);

            //eldöntjük melyik output melyik old_node-hoz tartozik,
            //és ez alapján már ki tudjuk cserélni a PIN túloldalán levő block inputját
            //out1
            if (output1 == node1.output1)
            {
                blockmanager.OutputChange(node1.output1, new_node2.name, node1.name);
            }
            if (output1 == node1.output2)
            {
                blockmanager.OutputChange(node1.output2, new_node2.name, node1.name);
            }
            if (output1 == node2.output1)
            {
                blockmanager.OutputChange(node2.output1, new_node2.name, node2.name);
            }
            if (output1 == node2.output2)
            {
                blockmanager.OutputChange(node2.output2, new_node2.name, node2.name);
            }

            //out2
            if (output2 == node1.output1)
            {
                blockmanager.OutputChange(node1.output1, new_node1.name, node1.name);
            }
            if (output2 == node1.output2)
            {
                blockmanager.OutputChange(node1.output2, new_node1.name, node1.name);
            }
            if (output2 == node2.output1)
            {
                blockmanager.OutputChange(node2.output1, new_node1.name, node2.name);
            }
            if (output2 == node2.output2)
            {
                blockmanager.OutputChange(node2.output2, new_node1.name, node2.name);
            }

            //out3
            if (output3 == node1.output1)
            {
                blockmanager.OutputChange(node1.output1, new_node2.name, node1.name);
            }
            if (output3 == node1.output2)
            {
                blockmanager.OutputChange(node1.output2, new_node2.name, node1.name);
            }
            if (output3 == node2.output1)
            {
                blockmanager.OutputChange(node2.output1, new_node2.name, node2.name);
            }
            if (output3 == node2.output2)
            {
                blockmanager.OutputChange(node2.output2, new_node2.name, node2.name);
            }

            //konzisztencia viszgálat
            Check.Consistency_CheckAndPause();
        }