/// <summary>
        /// Function randomizeTimetable stage off a train line, only between stations off and to.
        /// </summary>
        /// <param name="line"></param>
        /// <param name="off"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static Stage generateStage(TrainLine line, TrainStation from, TrainStation to)
        {
            List <Edge> edges = FloydWarshallUtil.createEdges(line);

            return(generateStage(edges, from, to));
            // with null checking
            //return generateStage(edges);
        }
Esempio n. 2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Stage"/> class.
 /// </summary>
 /// <param name="from">From station.</param>
 /// <param name="to">To station.</param>
 /// <param name="line_">By the line.</param>
 public Stage(TrainStation from, TrainStation to, TrainLine line_)
 {
     edges       = FloydWarshallUtil.createEdges(line_, from, to);
     line        = line_;
     fromStation = from;
     toStation   = to;
     time        = TrainConnection.calculateTime(edges);
     distance    = TrainConnection.calculateDistance(edges);
 }
Esempio n. 3
0
        /// <summary>
        /// Optimizations by function with respect to same line.
        /// </summary>
        /// <param name="edges">The edges.</param>
        /// <param name="edgeCache">The edge cache.</param>
        /// <returns></returns>
        private static List <Edge> optimizationFunctionSameLine(List <Edge> edges, List <Edge> edgeCache)
        {
            // retreive all lines
            List <TrainLine> allLines = TrainLineCache.getInstance().getCacheContent();
            List <Edge>      newPath  = edges;

            // loop over all lines
            foreach (TrainLine line in allLines)
            {
                // find if one line contains first and last stop on path
                if (containsTrainStations(line, edges[0].From, edges[edges.Count - 1].To))
                {
                    // prepare new path
                    newPath = FloydWarshallUtil.createEdges(line, edges[0].From, edges[edges.Count - 1].To);
                }
            }
            // return the same or new
            return(newPath);
        }
Esempio n. 4
0
 private void createFloydWarshall(List <TrainLine> lines, List <TrainStation> stations)
 {
     // createConstraintSet node array, assign stationId toStation index of node
     nodes = FloydWarshallUtil.createArrayOfNode(stations);
     // initialize size n
     if (stations.Count == nodes.Length)
     {
         n = nodes.Length;
     }
     // createConstraintSet multidimensional arrays of size n
     time     = FloydWarshallUtil.crateArrayOfTimeNxN(n);
     distance = FloydWarshallUtil.createArrayOfNxN(n);
     //line_ = FloydWarshallUtil.createArrayOfNxN(n);
     throughStation = FloydWarshallUtil.createArrayOfNxN(n);
     // createConstraintSet list of edges according the stops of trainlines
     edges = FloydWarshallUtil.createEdges(lines);
     // initialize all useful arrays by edges
     initializeArrays(edges);
 }
Esempio n. 5
0
        /// <summary>
        /// Optimizations by function - zig zag by stages.
        /// </summary>
        /// <param name="edges">The edges.</param>
        /// <param name="edgesCache">The edges cache.</param>
        /// <returns></returns>
        private static List <Edge> optimizationFunctionZigZagByStages(List <Edge> edges, List <Edge> edgesCache)
        {
            List <Edge> newEdges = new List <Edge>();

            // loop over all edges with index
            for (int i = 0; i < edges.Count; i++)
            {
                // define last index
                int last = edges.Count - 1;
                // find last edges where the line is the same
                while (i < last)
                {
                    // if edges on the last current index has the same line
                    if (edges[last].Line.Equals(edges[i].Line))
                    {
                        break;
                    }
                    last--;
                }
                // if there is path > 1
                if ((last - i) > 1)
                {
                    // between thouse indices replace edges for
                    List <Edge> alternative = FloydWarshallUtil.createEdges(TrainLineCache.getInstance().getCacheContentOnNumber(edges[i].Line),
                                                                            edges[i].From, edges[last].To);
                    // add alternative path instead
                    newEdges.AddRange(alternative);
                    // index += path
                    i = last;
                }
                else
                {
                    // add original edge
                    newEdges.Add(edges[i]);
                    // index ++, in for loop
                }
            }
            return(newEdges);
        }