private void RemoveUnusedNodes(INetwork network)
 {
     if (allowRemoveUnusedNodes)
     {
         NetworkHelper.RemoveUnusedNodes(network);
     }
 }

 public void ModifyIsDirectedProperty(INetwork network, bool isDirected)
 {
     if (network != null && network is BasicAdjList)
     {
         ModifyIsDirectedProperty(network as BasicAdjList, isDirected);
     }
 }

        public DataTable ToDataTable(INetwork network)
        {
            if (network == null)
                throw new ArgumentNullException("network", "The input network must not be null.");
            if (!(network is IEdgeAttributes))
                throw new ArgumentException(string.Format("The input network must implement {0}.", typeof(IEdgeAttributes).Name), "network");
            IEdgeAttributes src = network as IEdgeAttributes;
            DataTable table = new DataTable("Edge data");
            AttributeListMgr mgr = src.EdgeAttributeMgr as AttributeListMgr;
            if (mgr == null)
                throw new ArgumentException("The EdgeAttributeMgr of the input network must not be null.", "network");

            string[] colNames = EnsureUniqueColNames(mgr);
            int ctr = 0;
            foreach (IAttributeList list in mgr.Lists)
            {
                table.Columns.Add(new DataColumn(colNames[ctr++], list.DataType));
            }

            if (table.Columns.Count>0)
                for (int i = 0; i < mgr.Depth; i++)
                {
                    table.Rows.Add(mgr.GetRow(i));
                }

            table.AcceptChanges();
            return table;
        }

        public CellNet(INetwork network, ModelVisual3D mophology, Dictionary<Guid, ICell> cells, Dictionary<Guid, ICellNet> childcellnet)
        {
            this.network = network;
            this.mophology = mophology;
            this.cells = cells;
            this.childcellnet = childcellnet;
            IsPushing = true;

            var transforms = new Transform3DGroup();
            Rotate = new RotateTransform3D(new QuaternionRotation3D());
            Translate = new TranslateTransform3D(network.Position.X, network.Position.Y, network.Position.Z);
            Scale = new ScaleTransform3D();
            transforms.Children.Add(Rotate);
            transforms.Children.Add(Translate);
            transforms.Children.Add(Scale);
            Mophology.Transform = transforms;

            var binding = new Binding()
            {
                Source = network,
                Path = new PropertyPath("Position"),
                Mode = BindingMode.OneWay
            };
            BindingOperations.SetBinding(this, CellNet.PositionProperty, binding);
        }

 public string GetProperties(INetwork network)
 {
     var sb = new StringBuilder();
     if (network == null)
     {
         sb.AppendLine("network is null");
     }
     else
     {
         ListPropertiesOfNetworkBase(network, sb);
         if (network is IAdjList)
         {
             ListPropertiesOfAdjList((IAdjList)network, sb);
         }
         else
         {
             var isMatrix = network.GetType().GetInterfaces()
                                   .Where(t => t.IsGenericType)
                                   .Select(t => t.GetGenericTypeDefinition())
                                   .Any(t => t.Equals(typeof(IMatrix<>)));
             if (isMatrix)
                 ListPropertiesOfMatrix(network, sb);
         }
     }
     return sb.ToString();
 }

 /// <summary>
 /// Creates an instance of ICopyNetwork appropriate to the underlying 
 /// Type of <paramref name="network"/>.
 /// The returned object can be used to create a copy of the input network.
 /// </summary>
 /// <param name="network">The network to be copied.</param>
 /// <returns>An ICopyNetwork instance</returns>
 public ICopyNetwork CreateCopier(INetwork network)
 {
     ICopyNetwork tool = null;
     if (network != null)
     {
         if (network is BlueSpider.Blob.Regular.Network.AdjList.SimpleAdjList)
         {
             tool = new BlueSpider.Blob.Regular.Network.AdjList.SimpleAdjListCopier();
         }
         else if (network is AdjList)
         {
             tool = new AdjacentList.Y.AdjListCopier();
         }
         else if (network is Matrix.CSpace.DirectedNetworkMatrix)
         {
             tool = new Matrix.CSpace.MatrixCopier();
         }
         else if (network is Matrix.CSpace.UnDirectedNetworkMatrix)
         {
             tool = new Matrix.CSpace.MatrixCopier();
         }
         else if (network is BlueSpider.Blob.Regular.Network.Matrix.SimpleFullMatrix)
         {
             throw new NotImplementedException();
         }
         else if (network is BlueSpider.Blob.Regular.Network.Matrix.SimpleSymmetricMatrix)
         {
             throw new NotImplementedException();
         }
     }
     return tool;
 }

 /// <summary>
 /// Initializes a new instance of the DummyInputNetworkPort class, This class maintains the dataObj
 /// as a member, does NOT use the backingStore of the pipe.
 /// </summary>
 /// <param name="parent"></param>
 /// <param name="inPipe"></param>
 /// <param name="dataObj"></param>
 /// <param name="isValid"></param>
 public DummyInputNetworkPort(IElement parent, INetworkPipe inPipe, INetwork dataObj, bool isValid)
 {
     _parent = parent;
     _inPipe = inPipe;
     _netObj = dataObj;
     _IsValid = isValid;
 }

 public World(INetwork network)
     : base(0, 0, 1000, 1000)
 {
     color = System.Drawing.Brushes.White;
     bigBrain = (FloatFastConcurrentNetwork)network;
     size = height;
 }

 private NetworkEvent(INetwork network, IEventType type, IEventSource source)
 {
     Network = network;
     Type = type;
     TimeStamp = DateTime.UtcNow;
     Source = source;
 }

 public NetworkDispatcher(ConcurrentQueue<Request> queue, INetwork network, ICache cache, IResponseDelivery delivery)
 {
     this.mQueue = queue;
     this.mNetwork = network;
     this.mCache = cache;
     this.mDelivery = delivery;
 }

        public static void SetOrderForBranch(INetwork network, IBranch branch)
        {
            // node is new if it is exclusive to branch
            var connectionsFromNodeCount = branch.Source.IncomingBranches.Count + branch.Source.OutgoingBranches.Count;
            var connectionsToNodeCount = branch.Target.IncomingBranches.Count + branch.Target.OutgoingBranches.Count;
            if (connectionsFromNodeCount == 1 && connectionsToNodeCount == 1)
            {
                // new branch, not connected (do not assign -1 since user might have assigned it when constructing object)
                return;
            }

            if(connectionsFromNodeCount > 2 || connectionsToNodeCount > 2)
            {
                branch.OrderNumber = -1;
                return;
            }
            if (connectionsFromNodeCount == 1 && connectionsToNodeCount == 2)
            {
                branch.OrderNumber = ComputeMaximumOrderForNode(network, branch.Target);
                return;
            }
            if (connectionsFromNodeCount == 2 && connectionsToNodeCount == 1)
            {
                branch.OrderNumber = ComputeMaximumOrderForNode(network, branch.Source);
                return;
            }
        }

        public INetwork CopyNetwork(INetwork source)
        {
            if (source == null)
                throw new ArgumentNullException("source", "The network to be copied is null.");
            if (!(source is IBasicAdjList))
                throw new ArgumentException(
                    string.Format("The network to be copied must implement {0}.", typeof (IBasicAdjList).Name),
                    "source");

            if (NewNetworkId == Guid.Empty)
                NewNetworkId = Guid.NewGuid();

            IBasicAdjList copy = null;
            IBasicAdjList src = source as IBasicAdjList;

            // copy the network; *Note this copies the network structure (nodes & edges) but
            // does not structure or populate the attributes
            using (var fac = new BasicAdjListFactory())
            {
                fac.IsDirected = src.IsDirected;
                fac.EnableNodeDataAttributes = (CopyNodeData );
                fac.EnableEdgeDataAttributes = (CopyEdgeData );
                copy = fac.CreateNetwork(NewNetworkId, src.NodeCount) as IBasicAdjList;
                copy.Name = src.Name != null ? string.Copy(src.Name) : null;
            }

            INode copySrcNode = null;
            INode copyDestNode = null;
            int srcNodeIndex = -1;
            int destNodeIndex = -1;
            IEdge copiedEdge = null;
            for (int i = 0; i < src.Edges.Count; i++)
            {
                srcNodeIndex = src.Edges[i].SourceNode.Index;
                destNodeIndex = src.Edges[i].DestinationNode.Index;
                copySrcNode = copy.Nodes[srcNodeIndex];
                copyDestNode = copy.Nodes[destNodeIndex];
                copiedEdge = copy.CreateEdge(copySrcNode, copyDestNode);
            }

            using (var fac = new DataAttributeCopierProvider())
            {
                if (CopyNodeData && src.NodeData != null)
                {
                    using (var copier = fac.GetCopier(src.NodeData))
                    {
                        copier.Copy(src.NodeData, copy.NodeData);
                    }
                }
                if (CopyEdgeData && src.EdgeData != null)
                {
                    using (var copier = fac.GetCopier(src.EdgeData))
                    {
                        copier.Copy(src.EdgeData, copy.EdgeData);
                    }
                }
            }

            return copy;
        }

        /// <summary>
        /// Creates and returns a writer.
        /// </summary>
        /// <param name="fileType">A <see cref="NetworkFileTypes"/> value specifying the intended output format.</param>
        /// <param name="network">The source INetwork to be written.</param>
        /// <returns>INetworkFileWriter</returns>
        public static INetworkFileWriter CreateWriter(NetworkFileTypes fileType, INetwork network)
        {
            INetworkFileWriter writer = null;

            if (network!=null)
            {
                switch (fileType)
                {
                    case NetworkFileTypes.Pajek_Net:
                        if (network is IBasicAdjList)
                            writer = new PajekBasicAdjListWriter();
                        break;
                    case NetworkFileTypes.GraphML:
                        if (network is IBasicAdjList)
                            writer = new GraphMlBasicAdjListWriter();
                        break;
                    case NetworkFileTypes.NetDraw_VNA:
                        if (network is IBasicAdjList)
                            writer = new VNABasicAdjListWriter();
                        break;
                    default:
                        writer = null;
                        break;
                }
            }

            return writer;
        }

        public int numBrains; // Schrum: Total number

        public AgentBrain(bool homogenous, int numAgents, SubstrateDescription substrateDescription, INetwork genome,
            bool normalizeANNWeights, bool adaptableANN, bool modulatoryANN, bool multi, int brains, bool evolveSubstrate, bool preferenceNeurons, bool forcedSituationalPolicyGeometry)
        {
            this.evolveSubstrate = evolveSubstrate;
            this.normalizeANNWeights = normalizeANNWeights;
            this.adaptableANN = adaptableANN;
            this.modulatoryANN = modulatoryANN;
            this.genome = genome;
            this.substrateDescription = substrateDescription;
            this.numRobots = numAgents;
            this.homogenous = homogenous;
            this.multipleBrains = multi;
            this.forcedSituationalPolicyGeometry = forcedSituationalPolicyGeometry;
            // Schrum: When preference neurons are used, the number of modules in the network is the
            // more reliable source of information. Especially if Module Mutation will allow more modules
            // to be created, each creating a new brain.
            this.numBrains = genome != null && preferenceNeurons ? genome.NumOutputModules : brains;
            this.preferenceNeurons = preferenceNeurons;

            //inputCounter = 0;
            teamInput = new float[numAgents * substrateDescription.InputCount];
            activated = new bool[numAgents];

            createBrains();

            robotListeners = new List<Robot>();
        }

 public RequestQueue(ICache cache, INetwork network, int threadPoolSize, IResponseDelivery delivery)
 {
     this.mCache = cache;
     this.mNetwork = network;
     this.mDispatchers = new NetworkDispatcher[threadPoolSize];
     this.mDelivery = delivery;
 }

        public BranchReorderAction(INetwork network, int oldIndex, int newIndex) : base("Reorder branch position")
        {
            Network = network;
            OldIndex = oldIndex;
            NewIndex = newIndex;

            Branch = Network.Branches[oldIndex];
        }

 public Message(INetwork network, ILogSource source, IUser user, string message, bool highlight)
     : base(network, source, user)
 {
     this.User = user;
     this.NicknameContinuity = user.Nickname;
     this.MessageBody = message;
     this.Highlight = highlight;
 }

        /// <summary>
        /// Constructs a new AgentBrain object from the specified parameters. This brain is designed to be used as a multiagent hivemind, but can also be used to control a single agent by setting numAgents equal to 1. 
        /// </summary>
        /// <param name="homogeneous">Is the team homogeneous? Agents in a homogeneous team all have identical copies of the same brain, while those in a heterogeneous team do not, instead each contributing to one central, distributed hive brain.</param>
        /// <param name="numAgents">Set to 1 for an individual agent, or >1 for a multiagent team.</param>
        /// <param name="substrateDescription">HyperNEAT substrate</param>
        /// <param name="genome">If using NEAT, this should be the already-decoded neural network. Otherwise, if using HyperNEAT, this should be the CPPN that encodes the neural network.</param>
        /// <param name="normalizeANNWeights"></param>
        /// <param name="adaptableANN"></param>
        /// <param name="modulatoryANN"></param>
        /// <param name="multi">Multiple brains with situational policies?</param>
        /// <param name="evolveSubstrate">Set to true to enable ES-HyperNEAT.</param>
        /// <param name="useNeatBrain">If false, the system will use HyperNEAT as the EA.</param>
        /// <param name="useCTRNNs">Set to true to use continuous time recurrent neural networks.</param>
        public AgentBrain(bool homogeneous, int numAgents, SubstrateDescription substrateDescription, INetwork genome,
            bool normalizeANNWeights, bool adaptableANN, bool modulatoryANN, bool multi, bool evolveSubstrate, bool useNeatBrain, bool useCTRNNs = false)
        {
            // Set instance variables
            EvolveSubstrate = evolveSubstrate;
            NormalizeANNWeights = normalizeANNWeights;
            AdaptableANN = adaptableANN;
            ModulatoryANN = modulatoryANN;
            Genome = genome;
            SubstrateDescription = substrateDescription;
            NumRobots = numAgents;
            Homogeneous = homogeneous;
            MultipleBrains = multi;
            NeatBrain = useNeatBrain;
            UseCTRNNs = useCTRNNs;

            // Initialiaze team arrays
            TeamInput = new float[numAgents * substrateDescription.InputCount];
            TeamInputOld = new float[numAgents * substrateDescription.InputCount];
            TeamOutput = new float[numAgents * substrateDescription.OutputCount];
            TeamOutputOld = new float[numAgents * substrateDescription.OutputCount];
            TeamHidden = new float[numAgents * 5];
            TeamHiddenOld = new float[numAgents * 5];
			RobotInput = new float[substrateDescription.InputCount];
			RobotInputOld = new float[substrateDescription.InputCount];
            Activated = new bool[numAgents];

            // Initialize the agents' brains
            createBrains();
            
            // Register listeners for the robots' neural network outputs
            RobotListeners = new List<Robot>();

            if (OutputComms)
            {
                // If the robots' input and output streams have already been initialized, reset them
                if (OutputsInitialized)
                {
                    for (int j = 0; j < numAgents; j++)
                    {
                        OutStreams[j].Close();
                        InStreams[j].Close();
                        OutStreams[j] = null;
                        InStreams[j] = null;
                    }
                }

                // Initialize the robots' input and output streams
                OutStreams = new List<StreamWriter>(numAgents);
                InStreams = new List<StreamWriter>(numAgents);
                for (int j = 0; j < numAgents; j++)
                {
                    OutStreams.Add(new StreamWriter("agentO" + j + ".txt"));
                    InStreams.Add(new StreamWriter("agentI" + j + ".txt"));
                }
                OutputsInitialized = true;
            }
        }

 public Predator(float x, float y, float w, float h,INetwork network)
     : base(x, y, w, h, network)
 {
     radius = 200;
     sensors = new float[5];
     angledelta = (float)Math.PI / sensors.Length;
     halfangledelta = angledelta / 2.0f;
     brain = (FloatFastConcurrentNetwork)network;
 }

        // find the branch that has the highest order for all branches connected to this node, and return its order number.
        private static int ComputeMaximumOrderForNode(INetwork network, INode node)
        {
            if (node == null)
            {
                return -1;
            }

            return network.Branches.Where(c => c.Source == node || c.Target == node).Max(d => d.OrderNumber);
        }