tripassignment.cs

交通分配算法

                    }
                }
            }
        }
        //**************************************************************************************************

        //**************************************************************************************************
        //Logit模型，按多路径分配的方法得到的流量分配
        public static void LogitAssignmentMethod
            (
            double[,] OD,       //IN,需要分配的各节点之间的OD量
            double[,] weight,   //IN,各节点之间的路权
            double[,] result,   //OUT,各节点之间流量按STOCH算法进行的多路径分配结果
            double theta        //IN,Logit模型参数
            )
        {
            int dimensions = OD.GetLength(0);
            //调用Floyd最短路算法
            double[,] tempD = new double[dimensions, dimensions];
            int[,] tempP = new int[dimensions, dimensions];
            Floyd(weight, tempD, tempP);
            //step0:初始化
            for (int r = 0; r <dimensions ; r++)
            {
                for (int s = 0; s<dimensions ; s++)
                {
                    if (OD[r, s] >= 0)
                    {
                        double[] rNode = new double[dimensions];
                        double[] sNode = new double[dimensions];
                        List<int>[] down = new List<int>[dimensions];
                        List<int>[] up = new List<int>[dimensions];
                        double[,] L = new double[dimensions, dimensions];  //边权
                        double[,] w = new double[dimensions, dimensions];  //路权
                        double[,] x = new double[dimensions, dimensions];  //一次分配的流量
                        for (int i = 0; i < dimensions; i++)
                        {
                            down[i] = new List<int>();
                            up[i] = new List<int>();
                        }
                        for (int i = 0; i < dimensions; i++)
                        {
                            rNode[i] = tempD[r, i];
                            sNode[i] = tempD[i, s];
                        }

                        for (int i = 0; i < dimensions; i++)
                        {
                            for (int j = 0; j < dimensions; j++)
                            {
                                if (rNode[i] < rNode[j] && sNode[i] > sNode[j])
                                {
                                    L[i, j] = Math.Exp(theta * (rNode[j] - rNode[i] - weight[i, j]));
                                }
                                else
                                {
                                    L[i, j] = 0;
                                }
                                if (rNode[i] > rNode[j])
                                {
                                    up[i].Add(j);
                                }
                                else if (rNode[i] < rNode[j])
                                {
                                    down[i].Add(j);
                                }
                            }
                        }
                        //step1:前推
                        int[] sortedRNode = new int[dimensions];
                        List<double> temp = new List<double>(dimensions);
                        for (int i = 0; i < dimensions; i++)
                        {
                            temp.Add(rNode[i]);
                        }
                        temp.Sort();
                        bool[] isVisited = new bool[dimensions];
                        for (int i = 0; i < dimensions; i++)
                        {
                            for (int j = 0; j < dimensions; j++)
                            {
                                if (temp[j] == rNode[i] && isVisited[j] == false)
                                {
                                    sortedRNode[j] = i;
                                    isVisited[j] = true;
                                    break;
                                }
                            }
                        }
                        for (int i = 0; i < dimensions; i++)
                        {
                            for (int j = 0; j < dimensions; j++)
                            {
                                if (down[sortedRNode[i]].Contains(j))
                                {
                                    if (sortedRNode[i] == r)
                                    {
                                        w[sortedRNode[i], j] = L[sortedRNode[i], j];
                                    }
                                    else
                                    {
                                        double sum = 0;
                                        for (int m = 0; m < dimensions; m++)
                                        {
                                            if (up[sortedRNode[i]].Contains(m))
                                            {
                                                sum += w[m, sortedRNode[i]];
                                            }
                                        }
                                        w[sortedRNode[i], j] = L[sortedRNode[i], j] * sum;
                                    }
                                }
                            }
                        }
                        //step2:反推
                        //按sNode[i]值从小到大对节点排序
                        int[] sortedSNode = new int[dimensions];
                        List<double> temp2 = new List<double>(dimensions);
                        for (int i = 0; i < dimensions; i++)
                        {
                            temp2.Add(sNode[i]);
                        }
                        temp2.Sort();
                        bool[] isVisited2 = new bool[dimensions];
                        for (int i = 0; i < dimensions; i++)
                        {
                            for (int j = 0; j < dimensions; j++)
                            {
                                if (temp2[j] == sNode[i] && isVisited2[j] == false)
                                {
                                    sortedSNode[j] = i;
                                    isVisited2[j] = true;
                                    break;
                                }
                            }
                        }

                        for (int j = 0; j < dimensions; j++)
                        {
                            for (int i = 0; i < dimensions; i++)
                            {
                                if (sortedSNode[j] == s)
                                {
                                    double sum = 0;
                                    for (int m = 0; m < dimensions; m++)
                                    {
                                        if (up[sortedSNode[j]].Contains(m))
                                        {
                                            sum += w[m, sortedSNode[j]];
                                        }
                                    }
                                    if (sum > 0)
                                    {
                                        x[i, sortedSNode[j]] += OD[r, s] * w[i, sortedSNode[j]] / sum;
                                    }
                                }
                                else
                                {
                                    double sumDown = 0.0;
                                    double sumUp = 0.0;
                                    for (int m = 0; m < dimensions; m++)
                                    {
                                        if (down[sortedSNode[j]].Contains(m))
                                        {
                                            sumDown += x[sortedSNode[j], m];
                                        }
                                    }
                                    for (int m = 0; m < dimensions; m++)
                                    {
                                        if (up[sortedSNode[j]].Contains(m))
                                        {
                                            sumUp += w[m, sortedSNode[j]];
                                        }
                                    }
                                    if (sumUp > 0)
                                    {
                                        x[i, sortedSNode[j]] += sumDown * w[i, sortedSNode[j]] / sumUp;
                                    }
                                }
                            }
                        }
                        //将每一次分配的流量加入总的分配流量
                        for (int i = 0; i < dimensions; i++)
                        {
                            for (int j = 0; j < dimensions; j++)
                            {
                                result[i, j] += x[i, j];
                            }
                        }
                    }
                }
            }
        }
        //****************************************************************************************************
    }