本文介绍了一种针对高速铁路列车开行方案的设计算法。该算法结合了非合作博弈论和多目标优化方法，旨在平衡铁路运输企业的净收益与列车空座位走行公里数之间的关系。通过使用NAGA-Ⅱ算法实现上层非支配排序，以及QPSO算法求解下层非合作博弈，最终得到一系列帕累托最优解。
前言
标题该算法针对高速铁路列车开行方案设计，在VS2017 .NETFramework 4.7.1平台 RAM 8G 配置上跑了173分钟。优化模型未包含在论文中，暂不能公布。说明的一点是，算法约束用的是简单的罚函数–内点法，未采用拉格朗日罚函数。精通算法的前辈大佬若扫到该文，如能提出复杂度更低的优化算法，晚辈感激不尽！初衷不变，以便日后查看。
窗体应用程序+Chart控件，该算法可复制。
代码
1.编写LinkExcel类，针对特点Excel表进行存取
public class LinkExcel
{
string[] sheetName = new string[] { };//客流数据表
/// <summary>
/// 连接EXCEL并读取客流数据
/// </summary>
/// <param name="filePath">客流数据表路径</param>
/// <returns>数据集</returns>
public DataSet LoadDataFormExcel(string filePath)
{
try
{
string strConn;
strConn = "Provider=Microsoft.Ace.OleDb.12.0;Data Source=" + filePath + ";Extended Properties='Excel 12.0;HDR=Yes;IMEX=1'";
OleDbConnection oleConn = new OleDbConnection(strConn);
oleConn.Open();
string sql="";
OleDbDataAdapter oleDaExcel;
DataSet oleDsExcel = new DataSet();
for (int i = 0; i < sheetName.Length; i++)
{
if (i < 3)
{
sql = "SELECT * FROM [" + sheetName[i] + "$] where OD is not null";
}
else
{
sql = "SELECT Factors,1,2,3,4 FROM [" + sheetName[i] + "$] where Factors is not null";
}
oleDaExcel = new OleDbDataAdapter(sql, oleConn);
oleDaExcel.Fill(oleDsExcel, sheetName[i]);
}
oleConn.Close();
return oleDsExcel;
}
catch (Exception err)
{
MessageBox.Show("数据绑定Excel失败!!\n失败原因：" + err.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Information);
return null;
}
}
/// <summary>
/// 更新Excel中数据
/// </summary>
/// <param name="filePath">客流数据路径</param>
/// <param name="dataTable">待传入数据表</param>
/// <param name="strSheet">待修改数据表表名</param>
public void DSToExcel(string filePath, DataTable dataTable, string strSheet)
{
string strCon = "Provider=Microsoft.Ace.OleDb.12.0;" + "data source=" + filePath + ";Extended Properties='Excel 12.0;HDR=Yes;IMEX=0'";
using (OleDbConnection myConn = new OleDbConnection(strCon))
{
myConn.Open();
using (OleDbCommand dbComm = myConn.CreateCommand())
{
for (int i = 0; i < dataTable.Rows.Count; i++)
{
for (int j = 1; j < dataTable.Columns.Count; j++)
{
dbComm.CommandText = "update [" + strSheet + "$] " + "set " + j.ToString() +
"=" + dataTable.Rows[i][j]+" where Factors="+(i+1).ToString();
dbComm.ExecuteNonQuery();
}
}
//MessageBox.Show("数据更新成功！！", "操作成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
/// <summary>
/// 将数据写入Excel中--重载
/// </summary>
/// <param name="filePath">路径</param>
/// <param name="dataSet">数据集</param>
public void DSToExcel(string filePath, DataSet dataSet)
{
string strCon = "Provider=Microsoft.Ace.OleDb.12.0;" + "data source=" + filePath + ";Extended Properties='Excel 12.0;HDR=Yes;IMEX=0'";
using (OleDbConnection myConn = new OleDbConnection(strCon))
{
myConn.Open();
for (int k = 0; k < dataSet.Tables.Count; k++)
{
using (OleDbCommand dbComm = myConn.CreateCommand())
{
for (int i = 0; i < dataSet.Tables[k].Rows.Count; i++)
{
for (int j = 1; j < dataSet.Tables[k].Columns.Count; j++)
{
dbComm.CommandText = "update [" + dataSet.Tables[k].TableName + "$] " + "set " + j.ToString() +
"=" + dataSet.Tables[k].Rows[i][j] + " where Factors=" + (i + 1).ToString();
dbComm.ExecuteNonQuery();
}
}
//MessageBox.Show("数据更新成功！！", "操作成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
}
/// <summary>
/// 构造函数
/// </summary>
public LinkExcel()
{
StringBuilder strb = new StringBuilder();
for (int i = 1; i <= 21; i++)
{
for (int j = i+1; j <= 22; j++)
{
for (int k = 1; k <= 3; k++)
{
strb.AppendLine(i + "-" + j + "g" + k + "Customer");
}
}
}
string str = strb.ToString();
string[] tempStr = str.Split(new char[] { '\n', '\r', ' ' }, StringSplitOptions.RemoveEmptyEntries);
sheetName = new string[tempStr.Length + 3];
sheetName[0] = "g1Customer";
sheetName[1] = "g2Customer";
sheetName[2] = "g3Customer";
for (int i = 0; i < tempStr.Length; i++)
{
sheetName[i + 3] = tempStr[i];
}
}
}
2.编写NAGA-Ⅱ算法，各算子针对模型设计
//染色体--解结构
public struct Chromosome
{
//解的数据
public int[][] x;//二进制解
public double[] f;//目标函数数组
//解的Pareto属性
public int n;//强帕累托支配该解的解个数
public int[] S;//被该解强帕累托支配的解集合--运用索引下标进行访问；
public double N;//拥挤度
//开行频率
public int[,] Frequent;
}
//上层非支配排序算法
public class NSGA_Ⅱ
{
//全局变量
public static int popsize = 100;//种群规模
public static int f_num = 2;//目标函数个数
double pc = 0.95;//交叉概率
double pm = 0.01;//变异概率
internal Chromosome[] chromosomes = new Chromosome[popsize];//种群数组--粒子集合
internal Chromosome[][] f_sort;//父代非支配排序交错数组--存储分层后的粒子
internal Chromosome[][] c_sort;//子代非支配排序交错数组--存储分层后的粒子
Random rand = new Random(DateTime.Now.Millisecond);//随机产生器
LinkExcel linkExcel = new LinkExcel();//Excel连接器--读取数据
internal DataSet dS = new DataSet();//数据集--存储从Excel中读取的数据
internal DataSet dSCustomer = new DataSet();//数据集--存储下层客流博弈结果
string strDataPath = "客流数据.xlsx";//"E:\\CajDocuments\\高速铁路开行方案\\客流数据.xlsx";
//NAGA-Ⅱ特有方法（非支配排序、拥挤度、精英保留策略）
/// <summary>
/// 初始化种群
/// </summary>
internal void UpperInitation()
{
dS = linkExcel.LoadDataFormExcel(strDataPath);//加载Excel数据
//初始化g1Customer、g2Customer、g3Customer数组
for (int i = 0; i < dS.Tables[0].Rows.Count; i++)
{
for (int j = 1; j < dS.Tables[0].Columns.Count; j++)
{
g1Customer[i, j - 1] = Convert.ToInt32(dS.Tables[0].Rows[i][j]);
g2Customer[i, j - 1] = Convert.ToInt32(dS.Tables[1].Rows[i][j]);
g3Customer[i, j - 1] = Convert.ToInt32(dS.Tables[2].Rows[i][j]);
}
}
//初始化开行区段
trainDepartureSection[0] = new int[5] { 1, 2, 3, 4, 5 };//开行区段1
trainDepartureSection[1] = new int[9] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };//开行区段2
trainDepartureSection[2] = new int[14] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };//开行区段3
trainDepartureSection[3] = new int[22] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 };//开行区段4
trainDepartureSection[4] = new int[3] { 20, 21, 22 };//开行区段5
trainDepartureSection[5] = new int[6] { 17, 18, 19, 20, 21, 22 };//开行区段6
//初始化上层解x并满足停站率约束
for (int i = 0; i < popsize; i++)
{
chromosomes[i].x = new int[trainDepartureSection.GetLength(0)][];
for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
{
chromosomes[i].x[j] = new int[trainDepartureSection[j].Length];
chromosomes[i].x[j][0] = 1;//始发站停车
chromosomes[i].x[j][trainDepartureSection[j].Length - 1] = 1;//终到站停车
for (int k = 1; k < trainDepartureSection[j].Length - 1; k++)
{
chromosomes[i].x[j][k] = rand.Next(2);
}
int istrue = 0;//停站次数
List<int> listIndexPassing = new List<int>();//不停站站点下标集合
for (int k = 0; k < chromosomes[i].x[j].Length; k++)
{
if (chromosomes[i].x[j][k] == 1)
{
istrue++;
}
else
{
listIndexPassing.Add(k);
}
}
double _beta = istrue * 1.0 / chromosomes[i].x[j].Length;
while (_beta < beta)
{
chromosomes[i].x[j][listIndexPassing[0]] = 1;
listIndexPassing.RemoveAt(0);
istrue++;
_beta = istrue * 1.0 / chromosomes[i].x[j].Length;
}
}
//chromosomes[i].f = new double[f_num];
//chromosomes[i].f[0] = F1Object(chromosomes[i]);
//chromosomes[i].f[1] = F2Object(chromosomes[i]);
}
}
/// <summary>
/// 非支配排序
/// </summary>
/// <param name="chromosome">父代种群</param>
internal void NonDominationSort(Chromosome[] chromosome)
{
f_sort = new Chromosome[popsize][];
List<Chromosome> tempList = new List<Chromosome>();//临时存储同一层粒子个体
List<int> tempS = new List<int>();//临时存储被粒子支配的个体集合
//计算种群中每个个体被支配个数n和被该个体支配的解集合S
int less;//解劣于粒子chromosome[i]的个体数目
int equal;//解无差别于粒子chromosome[i]的个体数目
int greater;//解优于粒子chromosome[i]的个体数目
for (int i = 0; i < popsize; i++)
{
for (int j = 0; j < popsize; j++)
{
less = 0;
equal = 0;
greater = 0;
for (int k = 0; k < f_num; k++)
{
if (k == 0)//k=0表示铁路运输企业的净收益函数
{
if (chromosome[i].f[k] > chromosome[j].f[k])
less += 1;
else if (chromosome[i].f[k] == chromosome[j].f[k])
equal += 1;
else
greater += 1;
}
else
{
if (chromosome[i].f[k] < chromosome[j].f[k])
less += 1;
else if (chromosome[i].f[k] == chromosome[j].f[k])
equal += 1;
else
greater += 1;
}
}
if (less == 0 && equal != f_num)
{
chromosome[i].n += 1;
}
else if (greater == 0 && equal != f_num)
{
tempS.Add(j);
}
}
chromosome[i].S = new int[tempS.Count];
for (int j = 0; j < tempS.Count; j++)
{
chromosome[i].S[j] = tempS[j];
}
if (chromosome[i].n == 0)
tempList.Add(chromosome[i]);
tempS.Clear();
}
int pareto_rank = 1;//初始化Pareto等级
//Pareto等级为1的层级
f_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
for (int i = 0; i < tempList.Count; i++)
{
f_sort[pareto_rank - 1][i] = tempList[i];
}
//Pareto等级为i(i>1)的层级
while (f_sort[pareto_rank - 1] != null)
{
if (pareto_rank == popsize)//若非支配排序层级达到种群规模，则退出循环，防止死循环
break;
tempList.Clear();//清空操作，为存储下一层粒子做准备
for (int i = 0; i < f_sort[pareto_rank - 1].Length; i++)
{
for (int j = 0; j < f_sort[pareto_rank - 1][i].S.Length; j++)
{
chromosome[f_sort[pareto_rank - 1][i].S[j]].n -= 1;
if (chromosome[f_sort[pareto_rank - 1][i].S[j]].n == 0)
{
tempList.Add(chromosome[f_sort[pareto_rank - 1][i].S[j]]);
}
}
}
pareto_rank += 1;
if (tempList.Count > 0)
{
f_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
for (int j = 0; j < tempList.Count; j++)
{
f_sort[pareto_rank - 1][j] = tempList[j];
}
}
}
}
/// <summary>
/// 非支配排序
/// </summary>
/// <param name="childchromosome">子代种群</param>
internal void ChildNonDominationSort(Chromosome[] childchromosome)
{
c_sort = new Chromosome[popsize][];
int pareto_rank = 1;//初始化Pareto等级
List<Chromosome> tempList = new List<Chromosome>();//临时存储同一层粒子个体
List<int> tempS = new List<int>();//临时存储被粒子支配的个体集合
//计算种群中每个个体被支配个数n和被该个体支配的解集合S
for (int i = 0; i < popsize; i++)
{
for (int j = 0; j < popsize; j++)
{
int less = 0;//解劣于粒子chromosome[i]的个体数目
int equal = 0;//解无差别于粒子chromosome[i]的个体数目
int greater = 0;//解优于粒子chromosome[i]的个体数目
for (int k = 0; k < f_num; k++)
{
if (k == 0)//k=0表示铁路运输企业的净收益函数
{
if (childchromosome[i].f[k] > childchromosome[j].f[k])
less += 1;
else if (childchromosome[i].f[k] == childchromosome[j].f[k])
equal += 1;
else
greater += 1;
}
else
{
if (childchromosome[i].f[k] < childchromosome[j].f[k])
less += 1;
else if (childchromosome[i].f[k] == childchromosome[j].f[k])
equal += 1;
else
greater += 1;
}
}
if (less == 0 && equal != f_num)
{
childchromosome[i].n += 1;
}
else if (greater == 0 && equal != f_num)
{
tempS.Add(j);
}
}
childchromosome[i].S = new int[tempS.Count];
for (int j = 0; j < tempS.Count; j++)
{
childchromosome[i].S[j] = tempS[j];
}
if (childchromosome[i].n == 0)
tempList.Add(childchromosome[i]);
tempS.Clear();
}
//Pareto等级为1的层级
c_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
for (int i = 0; i < tempList.Count; i++)
{
c_sort[pareto_rank - 1][i] = tempList[i];
}
//Pareto等级为i(i>1)的层级
while (c_sort[pareto_rank - 1] != null)
{
if (pareto_rank == popsize)
break;
tempList.Clear();
for (int i = 0; i < c_sort[pareto_rank - 1].Length; i++)
{
if (c_sort[pareto_rank - 1][i].S.Length > 0)
{
for (int j = 0; j < c_sort[pareto_rank - 1][i].S.Length; j++)
{
childchromosome[c_sort[pareto_rank - 1][i].S[j]].n -= 1;
if (childchromosome[c_sort[pareto_rank - 1][i].S[j]].n == 0)
{
tempList.Add(childchromosome[c_sort[pareto_rank - 1][i].S[j]]);
}
}
}
}
pareto_rank += 1;
if (tempList.Count > 0)
{
c_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
for (int i = 0; i < tempList.Count; i++)
{
c_sort[pareto_rank - 1][i] = tempList[i];
}
}
}
}
/// <summary>
/// 拥挤度
/// </summary>
/// <param name="f_sort">非支配排序后的粒子集合</param>
internal void CrowdingDistanceSort(Chromosome[][] _sort)
{
int rank = -1;//记录非空层级
//计算层数及对相应层级拥挤度赋初值0--后期优化
for (int i = 0; i < _sort.GetLength(0); i++)
{
if (_sort[i] != null)
{
rank += 1;
for (int j = 0; j < _sort[i].Length; j++)
{
_sort[i][j].N = 0;
}
}
else
break;
}
//交错数组二维化
double[,] arrayThreeDimension = new double[popsize, f_num + 2];
for (int i = 0; i < _sort[0].Length; i++)
{
arrayThreeDimension[i, 0] = i;//存储粒子对应层级--此处存储第一层级
arrayThreeDimension[i, 1] = _sort[0][i].f[0];//存储粒子对应的第一个目标函数值
arrayThreeDimension[i, 2] = _sort[0][i].f[1];//存储粒子对应的第二个目标函数值
}
int intTempLength = 0;
for (int i = 1; i < rank + 1; i++)
{
intTempLength = 0;
for (int j = 0; j < i; j++)
{
intTempLength += _sort[j].Length;
}
for (int j = 0; j < _sort[i].Length; j++)
{
arrayThreeDimension[intTempLength + j, 0] = intTempLength + j;
arrayThreeDimension[intTempLength + j, 1] = _sort[i][j].f[0];
arrayThreeDimension[intTempLength + j, 2] = _sort[i][j].f[1];
}
}
//拥挤度计算
for (int k = 0; k < f_num; k++)
{
//按照第k个目标函数升序排序
int arrMin;
for (int i = 0; i < arrayThreeDimension.GetLength(0) - 1; i++)
{
arrMin = i;
for (int j = i + 1; j < arrayThreeDimension.GetLength(0); j++)
{
if (arrayThreeDimension[j, k + 1] < arrayThreeDimension[arrMin, k + 1])
{
arrMin = j;
}
}
double douTemp1 = arrayThreeDimension[arrMin, 0],
douTemp2 = arrayThreeDimension[arrMin, 1],
douTemp3 = arrayThreeDimension[arrMin, 2];
arrayThreeDimension[arrMin, 0] = arrayThreeDimension[i, 0];
arrayThreeDimension[arrMin, 1] = arrayThreeDimension[i, 1];
arrayThreeDimension[arrMin, 2] = arrayThreeDimension[i, 2];
arrayThreeDimension[i, 0] = douTemp1;
arrayThreeDimension[i, 1] = douTemp2;
arrayThreeDimension[i, 2] = douTemp3;
}
//边界点拥挤度为无穷大
arrayThreeDimension[0, 3] = arrayThreeDimension[popsize - 1, 3] = double.MaxValue;
//计算其它各点拥挤度
double douMinCrowding = arrayThreeDimension[0, k + 1];
double douMaxCrowding = arrayThreeDimension[popsize - 1, k + 1];
for (int i = 1; i < popsize - 1; i++)
{
arrayThreeDimension[i, 3] += Math.Abs(arrayThreeDimension[i - 1, k + 1] - arrayThreeDimension[i + 1, k + 1]) * 1.0 / (douMaxCrowding - douMinCrowding);
}
}
//填充具有拥挤度值的_sort[][]
for (int i = 0; i < arrayThreeDimension.GetLength(0); i++)
{
intTempLength = 0;
for (int j = 0; j < rank + 1; j++)
{
intTempLength += _sort[j].Length;
if (arrayThreeDimension[i, 0] < intTempLength)
{
if (j != 0)
{
int intColumn = (int)arrayThreeDimension[i, 0] % (intTempLength - _sort[j].Length);
_sort[j][intColumn].N = arrayThreeDimension[i, 3];
break;
}
else
{
int intColumn = (int)arrayThreeDimension[i, 0];
_sort[j][intColumn].N = arrayThreeDimension[i, 3];
break;
}
}
}
}
}
//遗传算子（模拟二进制交叉（Simulated Binary Crossover,SBX)、多项式变异（Polynomial Mutation）、锦标赛选择（Tournament Selection））
/// <summary>
/// 锦标赛法选择算子
/// </summary>
/// <param name="chromosome">上一代群体</param>
/// <returns>从前代种群中选择出较优种群</returns>
internal Chromosome[] TournamentSelection(Chromosome[] chromosome)
{
int childIndex1;//选择个体1
int childIndex2;//选择个体2
Chromosome[] chromoselect = new Chromosome[popsize];//选择的解个体集合
for (int i = 0; i < popsize; i++)
{
childIndex1 = rand.Next(0, chromosome.Length);
childIndex2 = rand.Next(0, chromosome.Length);
while (childIndex1 == childIndex2)
{
childIndex2 = rand.Next(0, chromosome.Length);
}
if ((chromosome[childIndex1].f[0] >= chromosome[childIndex2].f[0]) ||
(chromosome[childIndex1].f[1] <= chromosome[childIndex2].f[1]))
{
chromoselect[i].x = new int[trainDepartureSection.GetLength(0)][];
for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
{
chromoselect[i].x[j] = new int[trainDepartureSection[j].Length];
for (int k = 0; k < trainDepartureSection[j].Length; k++)
{
chromoselect[i].x[j][k] = chromosome[childIndex1].x[j][k];
}
}
chromoselect[i].f = new double[f_num];
chromoselect[i].f[0] = chromosome[childIndex1].f[0];
chromoselect[i].f[1] = chromosome[childIndex1].f[1];
}
else
{
chromoselect[i].x = new int[trainDepartureSection.GetLength(0)][];
for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
{
chromoselect[i].x[j] = new int[trainDepartureSection[j].Length];
for (int k = 0; k < trainDepartureSection[j].Length; k++)
{
chromoselect[i].x[j][k] = chromosome[childIndex2].x[j][k];
}
}
chromoselect[i].f = new double[f_num];
chromoselect[i].f[0] = chromosome[childIndex2].f[0];
chromoselect[i].f[1] = chromosome[childIndex2].f[1];
}
}
return chromoselect;
}
/// <summary>
/// 交叉、变异算子
/// </summary>
/// <param name="preChromosome">由锦标赛选择出来的种群</param>
internal void NewChromosomes(Chromosome[] preChromosome)
{
Chromosome[] tempNewChildren = new Chromosome[popsize];
int randPL = 0;//开行区段
int randGene = 0;//基因位
int randParent1 = 0;//父代索引1
int randParent2 = 0;//父代索引2
double doueta = 2;//SBX算子中的参数η
double dougamma;//SBX算子中的参数γ
for (int i = 0; i < popsize; i++)
{
//二进制交叉
randParent1 = rand.Next(0, preChromosome.Length);
randParent2 = rand.Next(0, preChromosome.Length);
while (randParent1 == randParent2)
randParent2 = rand.Next(0, preChromosome.Length);
Chromosome _child1 = new Chromosome();
Chromosome _child2 = new Chromosome();
_child1.x = new int[preChromosome[randParent1].x.GetLength(0)][];
_child2.x = new int[preChromosome[randParent2].x.GetLength(0)][];
for (int j = 0; j < preChromosome[randParent1].x.GetLength(0); j++)
{
_child1.x[j] = new int[preChromosome[randParent1].x[j].Length];
_child2.x[j] = new int[preChromosome[randParent1].x[j].Length];
for (int k = 0; k < preChromosome[randParent1].x[j].Length; k++)
{
_child1.x[j][k] = preChromosome[randParent1].x[j][k];
_child2.x[j][k] = preChromosome[randParent2].x[j][k];
}
}
_child1.f = new double[f_num];
_child2.f = new double[f_num];
_child1.f[0] = preChromosome[randParent1].f[0];
_child1.f[1] = preChromosome[randParent1].f[1];
_child2.f[0] = preChromosome[randParent2].f[0];
_child2.f[1] = preChromosome[randParent2].f[1];
int temp1 = 0;//父代1交叉基因位数值
int temp2 = 0;//父代2交叉基因位数值
double x1 = 0;//父代1基因位更新后数值
double x2 = 0;//父代2基因位更新后数值
double _rand = rand.NextDouble();
if (_rand < pc)
{
randPL = rand.Next(0, _child1.x.GetLength(0));
randGene = rand.Next(0, _child1.x[randPL].Length);
for (int j = randGene; j < _child1.x[randPL].Length; j++)
{
temp1 = _child1.x[randPL][j];
temp2 = _child2.x[randPL][j];
_rand = rand.NextDouble();
if (_rand < 0.5)
{
dougamma = Math.Pow(2 * _rand, 1.0 / (doueta + 1));
}
else
{
dougamma = Math.Pow(1.0 / (2 * (1 - _rand)), 1.0 / (doueta + 1));
}
x1 = 0.5 * ((1 + dougamma) * temp1 + (1 - dougamma) * temp2);
x2 = 0.5 * ((1 - dougamma) * temp1 + (1 + dougamma) * temp2);
temp1 = (int)Math.Round(x1);
temp2 = (int)Math.Round(x2);
_child1.x[randPL][j] = temp1;
_child2.x[randPL][j] = temp2;
}
//计算_child1对应函数值
upperSolutionIndex = 0;
ds[upperSolutionIndex] = new DataSet();
for (int j = 1; j < stationNum; j++)//客流博弈分配
{
for (int k = j + 1; k <= stationNum; k++)
{
customersAssigned(_child1, g1Customer[j - 1, k - 1],
g2Customer[j - 1, k - 1], g3Customer[j - 1, k - 1], j, k);
}
}
//根据旅客分配情况确定列车开行频率
_child1.Frequent = new int[pLNum, trainType];
_child1.Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
//根据旅客分配情况确定上层各函数值
_child1.f = new double[f_num];
dSCustomer = ds[upperSolutionIndex];
_child1.f[0] =
F1Object(_child1);
_child1.f[1] =
F2Object(_child1);
//计算_child2对应函数值
ds[upperSolutionIndex] = new DataSet();
for (int j = 1; j < stationNum; j++)//客流博弈分配
{
for (int k = j + 1; k <= stationNum; k++)
{
customersAssigned(_child2, g1Customer[j - 1, k - 1],
g2Customer[j - 1, k - 1], g3Customer[j - 1, k - 1], j, k);
}
}
//根据旅客分配情况确定列车开行频率
_child2.Frequent = new int[pLNum, trainType];
_child2.Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
//根据旅客分配情况确定上层各函数值
_child2.f = new double[f_num];
dSCustomer = ds[upperSolutionIndex];
_child2.f[0] =
F1Object(_child2);
_child2.f[1] =
F2Object(_child2);
//选取较优解
if (_child1.f[0] > _child2.f[0] && _child1.f[1] < _child2.f[1])
{
tempNewChildren[i] = _child1;
}
else
{
tempNewChildren[i] = _child2;
}
}
else
{
if (_child1.f[0] > _child2.f[0] && _child1.f[1] < _child2.f[1])
{
tempNewChildren[i] = _child1;
}
else
{
tempNewChildren[i] = _child2;
}
}
//变异
if (rand.NextDouble() < pm)
{
randPL = rand.Next(0, tempNewChildren[i].x.GetLength(0));
randGene = rand.Next(0, tempNewChildren[i].x[randPL].Length);
tempNewChildren[i].x[randPL][randGene] = 1 - tempNewChildren[i].x[randPL][randGene];
//计算tempNewChildren[i]对应函数值
upperSolutionIndex = 0;
ds[upperSolutionIndex] = new DataSet();
for (int j = 1; j < stationNum; j++)//客流博弈分配
{
for (int k = j + 1; k <= stationNum; k++)
{
customersAssigned(tempNewChildren[i], g1Customer[j - 1, k - 1],
g2Customer[j - 1, k - 1], g3Customer[j - 1, k - 1], j, k);
}
}
//根据旅客分配情况确定列车开行频率
tempNewChildren[i].Frequent = new int[pLNum, trainType];
tempNewChildren[i].Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
//根据旅客分配情况确定上层各函数值
tempNewChildren[i].f = new double[f_num];
dSCustomer = ds[upperSolutionIndex];
tempNewChildren[i].f[0] =
F1Object(tempNewChildren[i]);
tempNewChildren[i].f[1] =
F2Object(tempNewChildren[i]);
}
}
ChildNonDominationSort(tempNewChildren);
CrowdingDistanceSort(c_sort);
}
/// <summary>
/// 新一代群体（精英保留策略）
/// </summary>
/// <param name="f_sort">父代种群</param>
/// <param name="c_sort">子代种群</param>
internal void Elitism(Chromosome[][] f_sort, Chromosome[][] c_sort)
{
Chromosome[][] _Chromosome;
List<Chromosome> listChromosome = new List<Chromosome>();//存储精英解
int rankf = 0;//父代层级数
int rankc = 0;//子代层级数
int rankmax = 0;//最大层级数
for (int i = 0; i < f_sort.GetLength(0); i++)
{
if (f_sort[i] != null)
rankf++;
else
break;
}
for (int i = 0; i < c_sort.GetLength(0); i++)
{
if (c_sort[i] != null)
rankc++;
else
break;
}
if (rankf > rankc)
{
rankmax = rankf;
}
else
{
rankmax = rankc;
}
_Chromosome = new Chromosome[rankmax][];
for (int i = 0; i < rankmax; i++)
{
listChromosome.Clear();
if (f_sort[i] != null)
{
for (int j = 0; j < f_sort[i].Length; j++)
{
listChromosome.Add(f_sort[i][j]);
}
}
if (c_sort[i] != null)
{
for (int j = 0; j < c_sort[i].Length; j++)
{
listChromosome.Add(c_sort[i][j]);
}
}
_Chromosome[i] = new Chromosome[listChromosome.Count];
_Chromosome[i] = listChromosome.ToArray();
}
int currentNum = 0;//已存储解个体数目
int remainNum = 0;//仍缺解个体数目
int index = 0;//种群索引下标
for (int i = 0; i < _Chromosome.GetLength(0); i++)
{
if (currentNum < popsize)
{
if (_Chromosome[i].Length + currentNum <= popsize)
{
for (int j = 0; j < _Chromosome[i].Length; j++)
{
chromosomes[index++] = _Chromosome[i][j];
}
currentNum += _Chromosome[i].Length;
}
else
{
remainNum = popsize - currentNum;
ChromSort(_Chromosome[i]);
for (int j = 0; j < remainNum; j++)
{
chromosomes[index++] = _Chromosome[i][_Chromosome[i].Length - 1 - j];
}
currentNum += remainNum;
}
}
else
break;
}
}
//其它方法
/// <summary>
/// 选择排序(重载)--拥挤度
/// </summary>
/// <param name="chromosome">解个体</param>
void ChromSort(Chromosome[] chromosome)
{
int min;
for (int i = 0; i < chromosome.Length - 1; i++)
{
min = i;
for (int j = i + 1; j < chromosome.Length; j++)
{
if (chromosome[j].N < chromosome[min].N)
{
min = j;
}
}
Chromosome temp = new Chromosome();
temp = chromosome[min];
chromosome[min] = chromosome[i];
chromosome[i] = temp;
}
}
/// <summary>
/// 选择排序--非支配序
/// </summary>
/// <param name="chromosome">待排序同层级个体集合</param>
/// <param name="k">指示函数，k=1代表对第一个目标函数进行排序，k=2表示对第二个目标函数进行排序</param>
/// <returns>排序后同层级个体集合</returns>
void ChromSort(Chromosome[] chromosome, int k)
{
int min;
if (k == 1)
{
for (int i = 0; i < chromosome.Length - 1; ++i)
{
min = i;
for (int j = i + 1; j < chromosome.Length; j++)
{
if (chromosome[j].f[k - 1] < chromosome[i].f[k - 1])
{
min = j;
}
}
Chromosome temp = chromosome[min];
chromosome[min] = chromosome[i];
chromosome[i] = temp;
}
}
else
{
for (int i = 0; i < chromosome.Length - 1; ++i)
{
min = i;
for (int j = i + 1; j < chromosome.Length; j++)
{
if (chromosome[j].f[k - 1] < chromosome[i].f[k - 1])
{
min = j;
}
}
Chromosome temp = chromosome[min];
chromosome[min] = chromosome[i];
chromosome[i] = temp;
}
}
}
internal static int stationNum = 22;//单线高速铁路客运站点数量
internal static int trainType = 4;//列车种类--一站直达、大站停、择站停、站站停
internal static int pLNum = 6;//开行区段数量
public int[][] trainDepartureSection = new int[pLNum][];//列车开行区段
double[] stationsDistance
= new double[] { 87, 45, 31, 25, 43, 55, 105, 64, 35, 46, 49, 61, 21, 126, 163, 261, 249, 32, 91, 158, 9 };//站间距
double cT = 500;//列车公里费用
double cTFix = 1000;//列车固定使用费用
//int g = 3;//客流层次
double[,] rateTicket = new double[,]
{ { 0.9, 0.8, 0.7, 0.6 },{ 0.6, 0.5, 0.4, 0.3 },{0.4,0.3,0.2,0.1 } };//票价率
internal double alphMax = 1.1;//最大上座率
internal double alphMin = 0.6;//最小上座率
internal int seatNum = 90;//列车座位数
internal double douCustomerFluctuateRate = 1.3;//客流波动系数
internal int[,] g1Customer = new int[stationNum, stationNum];//消费层次为g1的铁路旅客集合
internal int[,] g2Customer = new int[stationNum, stationNum];//消费层次为g2的铁路旅客集合
internal int[,] g3Customer = new int[stationNum, stationNum];//消费层次为g3的铁路旅客集合
int[,] g1customerTrainSelection = new int[pLNum, trainType];//客流分配表（i，j)
int[,] g2customerTrainSelection = new int[pLNum, trainType];
int[,] g3customerTrainSelection = new int[pLNum, trainType];
int[,] customerTrainSelection = new int[pLNum, trainType];//选择各类列车的总旅客数
int[] stationCapcity = new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200 };//站点通过能力
int[] sectionCapcity = new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200 };//区间通过能力
double beta = 0.6;//停站率
double violationFactor = 500000;//罚因子
/// <summary>
/// 铁路净收益目标函数
/// </summary>
/// <param name="chromosome">解粒子</param>
/// <returns>带惩罚值的函数值</returns>
internal double F1Object(Chromosome chromosome)
{
//各费用、票价函数值
double costT = 0;//列车公里费用
double costTFix = 0;//列车固定使用费用
double benefitTicket = 0;//客票收入
double _distance;//距离
int q;//各类列车总数
for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
{
_distance = 0;
q = 0;
for (int j = 0; j < trainType; j++)
{
q += chromosome.Frequent[i, j];
}
_distance = IJDistance(trainDepartureSection[i][0], trainDepartureSection[i][trainDepartureSection[i].Length - 1]);
costT += _distance * q * cT;
costTFix += q * cTFix;
}
string strTableName1 = "";//表名
string strTableName2 = "";
string strTableName3 = "";
double[] _douCustomerSum = new double[3];//乘坐同一种类列车的旅客人数
for (int i = 1; i < stationNum; i++)
{
for (int j = i + 1; j <= stationNum; j++)
{
_distance = IJDistance(i, j);
strTableName1 = i + "-" + j + "g1Customer";
strTableName2 = i + "-" + j + "g2Customer";
strTableName3 = i + "-" + j + "g3Customer";
for (int k = 1; k <= trainType; k++)
{
_douCustomerSum[0] = 0;
_douCustomerSum[1] = 0;
_douCustomerSum[2] = 0;
for (int m = 0; m < pLNum; m++)
{
_douCustomerSum[0] += Convert.ToInt32(dSCustomer.Tables[strTableName1].Rows[m][k]);
_douCustomerSum[1] += Convert.ToInt32(dSCustomer.Tables[strTableName2].Rows[m][k]);
_douCustomerSum[2] += Convert.ToInt32(dSCustomer.Tables[strTableName3].Rows[m][k]);
}
benefitTicket += (_douCustomerSum[0] * rateTicket[0, k - 1] + _douCustomerSum[1] * rateTicket[1, k - 1] +
_douCustomerSum[1] * rateTicket[1, k - 1]) * _distance;
}
}
}
//判断解是否可行
double violationConstraints1 = 0;//违反停站率的惩罚值
double violationConstraints2 = 0;//违反通过能力的惩罚值
for (int i = 0; i < chromosome.x.GetLength(0); i++)//判断解是否满足停站率约束
{
int istrue = 0;//停站次数
for (int j = 0; j < chromosome.x[i].Length; j++)
{
if (chromosome.x[i][j] == 1)
{
istrue++;
}
}
double _beta = istrue * 1.0 / chromosome.x[i].Length;
if (_beta < beta)
violationConstraints1 += violationFactor * (beta - _beta) * (beta - _beta);
else
violationConstraints1 += 0;
}
List<int> tempListStationIndex = new List<int>();//存储站点可能所在区段下标
for (int i = 2; i < stationNum; i++) //判断解是否满足站点通过能力约束
{
tempListStationIndex.Clear();
for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
{
for (int k = 0; k < trainDepartureSection[j].Length; k++)
{
if (i == trainDepartureSection[j][k])
{
tempListStationIndex.Add(j);
break;
}
}
}
int int_qT = 0;//开行频率总数
for (int j = 0; j < tempListStationIndex.Count; j++)
{
for (int k = 0; k < trainType; k++)
{
int_qT += chromosome.Frequent[tempListStationIndex[j], k];
}
}
if (int_qT <= stationCapcity[i - 1])
violationConstraints2 += 0;
else
violationConstraints2 += violationFactor * (int_qT - stationCapcity[i - 1]) * (int_qT - stationCapcity[i - 1]);
}
List<int> tempListSectionIndex = new List<int>();//存储站间可能所在区段下标
for (int i = 1; i < stationNum; i++)//判断解是否满足区间通过能力
{
tempListStationIndex.Clear();
for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
{
for (int k = 0; k < trainDepartureSection[j].Length - 1; k++)
{
if (i == trainDepartureSection[j][k])
{
tempListSectionIndex.Add(j);
break;
}
}
}
int int_qT = 0;//区间列车开行频率总和
for (int j = 0; j < tempListSectionIndex.Count; j++)
{
for (int k = 0; k < trainType; k++)
{
int_qT += chromosome.Frequent[tempListSectionIndex[j], k];
}
}
if (int_qT <= sectionCapcity[i - 1])
violationConstraints2 += 0;
else
violationConstraints2 += violationFactor * (int_qT - sectionCapcity[i - 1]) * (int_qT - sectionCapcity[i - 1]);
}
return benefitTicket - costT - costTFix - violationConstraints1 - violationConstraints2;
}
/// <summary>
/// 列车空座位走行公里
/// </summary>
/// <param name="chromosome">解粒子</param>
/// <returns>带惩罚值的函数值</returns>
internal double F2Object(Chromosome chromosome)
{
double douSeatValue = 0;//上座率值
int[] sectionStation;//开行区段站点集合
int[] sectionCustomer;//区间客流数集合
for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
{
sectionStation = new int[trainDepartureSection[i].Length];
sectionCustomer = new int[trainDepartureSection[i].Length - 1];
for (int j = 0; j < sectionStation.Length; j++)
{
sectionStation[j] = trainDepartureSection[i][j];
}
int douValueCustomer;//区间客流总和
string strTableName1 = "";//表名
string strTableName2 = "";
string strTableName3 = "";
for (int j = 0; j < sectionCustomer.Length; j++)
{
douValueCustomer = 0;
for (int k = 0; k <= j; k++)
{
for (int m = j + 1; m < sectionStation.Length; m++)
{
strTableName1 = sectionStation[k].ToString() + "-" +
sectionStation[m].ToString() + "g1Customer";
strTableName2 = sectionStation[k].ToString() + "-" +
sectionStation[m].ToString() + "g2Customer";
strTableName3 = sectionStation[k].ToString() + "-" +
sectionStation[m].ToString() + "g3Customer";
for (int l = 0; l < trainType; l++)
{
douValueCustomer += Convert.ToInt32(dSCustomer.Tables[strTableName1].Rows[i][l + 1]) +
Convert.ToInt32(dSCustomer.Tables[strTableName2].Rows[i][l + 1]) +
Convert.ToInt32(dSCustomer.Tables[strTableName3].Rows[i][l + 1]);
}
}
}
sectionCustomer[j] = douValueCustomer;
}
double douQ = 0;//区段列车开行频率总和
for (int j = 0; j < trainType; j++)
{
douQ += chromosome.Frequent[i, j];
}
for (int j = 0; j < sectionCustomer.Length; j++)
{
douSeatValue += IJDistance(sectionStation[j], sectionStation[j + 1]) *
(sectionCustomer[j] - douQ * seatNum * 1.0 * (alphMax + alphMin) / 2) *
(sectionCustomer[j] - douQ * seatNum * 1.0 * (alphMax + alphMin) / 2);
}
}
return douSeatValue;
}
/// <summary>
/// 站间距
/// </summary>
/// <param name="startPoint">起始站点</param>
/// <param name="endPoint">终到站点</param>
/// <returns>距离</returns>
internal double IJDistance(int startPoint, int endPoint)
{
double _distance = 0;
for (int i = startPoint - 1; i < endPoint - 1; i++)
{
_distance += stationsDistance[i];
}
return _distance;
}
internal List<Chromosome> iterValue = new List<Chromosome>();//输出对象
public struct Particles //定义粒子的结构体
{
public int x;//粒子当前位置(选择的列车种类)
public double fitness;//粒子的当前位置适应值
}
//全局变量定义
static int popsize1;//消费水平层次为1的群体规模
static int popsize2;//消费水平层次为2的群体规模
static int popsize3;//消费水平层次为3的群体规模
Particles[] g1Particles;//消费水平层次为1的客流个体集合
Particles[] g2Particles;//消费水平层次为2的客流个体集合
Particles[] g3Particles;//消费水平层次为3的客流个体集合
int[] gbest1;//消费层次为1的客流局势
int[] gbest2;//消费层次为2的客流局势
int[] gbest3;//消费层次为3的客流局势
double gbestfitness1;//消费水平层次为1的赢得函数值
double gbestfitness2;//消费水平层次为2的赢得函数值
double gbestfitness3;//消费水平层次为3的赢得函数值
LinkExcel _linkExcel = new LinkExcel();//表读取对象
internal int upperSolutionIndex = 0;//上层解粒子下标索引
DataTable dt = new DataTable();//数据表
internal DataSet[] ds;//数据集
//string _strDataPath = "客流数据.xlsx";//数据所在相对位置
//下层客流博弈分配全局变量
double w1 = 200, w2 = 100, w3 = 50;//各消费层次客流时间价值系数
double lamda11 = 0.1, lamda12 = 0.9;//消费层次等级为1的客流的权重系数
double lamda21 = 0.5, lamda22 = 0.5;//消费层次等级为2的客流的权重系数
double lamda31 = 0.9, lamda32 = 0.1;//消费层次等级为3的客流的权重系数
//double violationM = 50000;//惩罚函数值
double velocity = 250;//列车速度值
double timeAverage = 4;//在站停留平均时间
int[] bigStation = new int[] { 1, 5, 22 };//客流量较大站点集合
double[,] ticketRate = new double[,] { { 0.9, 0.8, 0.7, 0.6 }, { 0.6, 0.5, 0.4, 0.3 }, { 0.4, 0.3, 0.2, 0.1 } };//票价率
//方法定义
int sectionIndex = 0;//客流博弈所在开行区段下标
List<int> sectionListIndexSets = new List<int>();//始发、终到站均含于相同开行区段的开行区段下标集合
List<int> strategySets = new List<int>();//策略集
/// <summary>
/// OD客流选择列车出行博弈方法
/// </summary>
/// <param name="xchromosome">上层解粒子</param>
/// <param name="g1CustomerNum">消费层次为1的OD客流规模</param>
/// <param name="g2CustomerNum">消费层次为2的OD客流规模</param>
/// <param name="g3CustomerNum">消费层次为3的OD客流规模</param>
/// <param name="startStation">O点</param>
/// <param name="endStation">D点</param>
internal void customersAssigned(Chromosome xchromosome, int g1CustomerNum, int g2CustomerNum,
int g3CustomerNum, int startStation, int endStation)
{
sectionIndex = 0;//开行区段索引赋初值
sectionListIndexSets.Clear();//清空开行区段索引集合
strategySets.Clear();//清空策略集
for (int i = 0; i < xchromosome.x.GetLength(0); i++)//填充均包含O、D的开行区段下标集合
{
if (trainDepartureSection[i][0] <= startStation &&
trainDepartureSection[i][xchromosome.x[i].Length - 1] >= endStation)
{
sectionListIndexSets.Add(i);
}
}
//随机选择一个同时包含起始、终点站的列车开行区段
sectionIndex = sectionListIndexSets[rand.Next(sectionListIndexSets.Count)];
//填充策略集StrategySets
//--一站直达
if (startStation == trainDepartureSection[sectionIndex][0] &&
endStation == trainDepartureSection[sectionIndex][trainDepartureSection[sectionIndex].Length - 1])
{
strategySets.Add(1);
}
//--大站停
int isAllbigStation = 0;//指标--指示OD客流是否可以乘坐大站停列车完成出现
for (int i = 0; i < bigStation.Length; i++)
{
if (startStation == bigStation[i])
{
isAllbigStation += 1;
continue;
}
if (endStation == bigStation[i])
{
isAllbigStation += 1;
break;
}
}
if (isAllbigStation == 2)
{
strategySets.Add(2);
}
//--择站停
int startStationIndex = 0;//客流出发站的站点在x解集中对应的下标
int endStationIndex = 0;//客流终到站的站点在x解集中对应的下标
for (int i = 0; i < trainDepartureSection[sectionIndex].Length; i++)
{
if (trainDepartureSection[sectionIndex][i] == startStation)
{
startStationIndex = i;
continue;
}
if (trainDepartureSection[sectionIndex][i] == endStation)
{
endStationIndex = i;
break;
}
}
if (xchromosome.x[sectionIndex][startStationIndex] == 1 && xchromosome.x[sectionIndex][endStationIndex] == 1)
strategySets.Add(3);
//--站站停：对OD(始发站为startStation,终点站为endStation)来说，站站停列车为必备策略
strategySets.Add(4);
//客流列车分配初始化
popsize1 = g1CustomerNum;//初始化各消费层次客流规模
popsize2 = g2CustomerNum;
popsize3 = g3CustomerNum;
g1Particles = new Particles[popsize1];//创建各消费层次客流集合
g2Particles = new Particles[popsize2];
g3Particles = new Particles[popsize3];
gbest1 = new int[popsize1];//创建各消费层次客流局势
gbest2 = new int[popsize2];
gbest3 = new int[popsize3];
//分情况初始化各消费层次客流出行列车选择
if (strategySets.Count == 1)
{
//消费层次为1的客流初始化
g1Particles[0].x = strategySets[0];
gbest1[0] = g1Particles[0].x;
g1Particles[0].fitness = SatisficationValue(g1Particles[0].x, 1, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
for (int i = 1; i < popsize1; i++)
{
g1Particles[i].x = g1Particles[0].x;
g1Particles[i].fitness = g1Particles[0].fitness;
gbest1[i] = g1Particles[i].x;
}
//消费层次为2的客流初始化
g2Particles[0].x = strategySets[0];
gbest2[0] = g2Particles[0].x;
g2Particles[0].fitness = SatisficationValue(g2Particles[0].x, 2, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
for (int i = 1; i < popsize2; i++)
{
g2Particles[i].x = g2Particles[0].x;
g2Particles[i].fitness = g2Particles[0].fitness;
gbest2[i] = g2Particles[i].x;
}
//消费层次为3的客流初始化
g3Particles[0].x = strategySets[0];
gbest3[0] = g3Particles[0].x;
g3Particles[0].fitness = SatisficationValue(g3Particles[0].x, 3, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
for (int i = 1; i < popsize3; i++)
{
g3Particles[i].x = g3Particles[0].x;
g3Particles[i].fitness = g3Particles[0].fitness;
gbest3[i] = g3Particles[i].x;
}
}
else
{
//消费层次为1的客流初始化
double douValue = 0;
for (int i = 0; i < popsize1; i++)
{
g1Particles[i].x = strategySets[rand.Next(strategySets.Count)];
g1Particles[i].fitness = SatisficationValue(g1Particles[i].x, 1, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
gbest1[i] = g1Particles[i].x;
douValue += g1Particles[i].fitness;
}
//消费层次为2的客流初始化
douValue = 0;
for (int i = 0; i < popsize2; i++)
{
g2Particles[i].x = strategySets[rand.Next(strategySets.Count)];
g2Particles[i].fitness = SatisficationValue(g2Particles[i].x, 2, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
gbest2[i] = g2Particles[i].x;
douValue += g2Particles[i].fitness;
}
//消费层次为3的客流初始化
douValue = 0;
for (int i = 0; i < popsize3; i++)
{
g3Particles[i].x = strategySets[rand.Next(strategySets.Count)];
g3Particles[i].fitness = SatisficationValue(g3Particles[i].x, 3, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
gbest3[i] = g3Particles[i].x;
douValue += g3Particles[i].fitness;
}
}
//算法开始迭代
RunIteration(g1Particles, 1, strategySets, sectionIndex, startStationIndex, endStationIndex,
startStation, endStation, xchromosome);
RunIteration(g2Particles, 2, strategySets, sectionIndex, startStationIndex, endStationIndex,
startStation, endStation, xchromosome);
RunIteration(g3Particles, 3, strategySets, sectionIndex, startStationIndex, endStationIndex,
startStation, endStation, xchromosome);
}
/// <summary>
/// 铁路旅客满意度评价函数
/// </summary>
/// <param name="_trainType">列车种类</param>
/// <param name="_costLevel">消费层次</param>
/// <param name="_sectionIndex">博弈区段下标</param>
/// <param name="_startStationIndex">O点对应数组下标</param>
/// <param name="_endStationIndex">D点对应数组下标</param>
/// <param name="_oStation">O点</param>
/// <param name="_dStation">D点</param>
/// <param name="_xchromosome">上层解个体</param>
/// <returns>满意度值</returns>
double SatisficationValue(int _trainType, int _costLevel, int _sectionIndex, int _startStationIndex,
int _endStationIndex, int _oStation, int _dStation, Chromosome _xchromosome)
{
double ticketSatiVal = 0;//票价满意度
double timeSatiVal = 0;//时间满意度
double distance = IJDistance(_oStation, _dStation);//OD距离
//若为一站直达列车
if (_trainType == 1)
{
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * 1.0 * distance / velocity;
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * 1.0 * distance / velocity;
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * 1.0 * distance / velocity;
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
//若为大站停列车
else if (_trainType == 2)
{
int middleStop = 0;
for (int i = 0; i < bigStation.Length; i++)
{
if (_oStation < bigStation[i] && bigStation[i] < _dStation)
{
middleStop += 1;
}
}
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
//若为择站停列车
else if (_trainType == 3)
{
int middleStop = 0;
for (int i = _startStationIndex + 1; i < _endStationIndex; i++)
{
if (_xchromosome.x[_sectionIndex][i] == 1)
{
middleStop += 1;
}
}
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
//若为站站停列车
else
{
int middleStop = 0;
if (_xchromosome.x[_sectionIndex].Length == 2)
middleStop = 0;
else
middleStop = _endStationIndex - _startStationIndex - 1;
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
}
/// <summary>
/// QPSO程序迭代器
/// </summary>
/// <param name="_particles">粒子种群</param>
/// <param name="_costLevel">消费层次</param>
/// <param name="_strategySets">可选策略集</param>
/// <param name="_sectionIndex">开行区段索引下标</param>
/// <param name="_startStationIndex">O点对应数组下标</param>
/// <param name="_endStationIndex">D点对应数组下标</param>
/// <param name="_oStation">O点</param>
/// <param name="_dStation">D点</param>
/// <param name="_xchromosome">上层解个体</param>
void RunIteration(Particles[] _particles, int _costLevel, List<int> _strategySets,
int _sectionIndex, int _startStationIndex, int _endStationIndex, int _oStation,
int _dStation, Chromosome _xchromosome)
{
//字段
double a;//QPSO迭代式中的收缩-扩张系数值
double douMax;//群体最大值
int douMaxIndex;//群体最大值下标
double douGest;//客流个体的较优策略--QPSO迭代式中的局部吸引子
double douMBest;//QPSO迭代式中的平均最好位置
double u;//QPSO迭代式中的随机变量，服从U(0,1)
double b;//QPSO迭代式中的特征长度
double v;//QPSO迭代式中的Log值
double z;//迭代结果小数部分
//循环迭代
double[] douBestStrategy = new double[_strategySets.Count];//各个策略对应赢得函数值
double douValueStrategy = double.MaxValue;//最优策略函数值
int douIndexStrategy = -1;//最优策略
for (int i = 0; i < douBestStrategy.Length; i++)//寻找最优策略及其下标
{
douBestStrategy[i] = SatisficationValue(_strategySets[i], _costLevel,
_sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (douBestStrategy[i] < douValueStrategy)
{
douValueStrategy = douBestStrategy[i];
douIndexStrategy = i;
}
}
int t = 0;
while (t <= int.MaxValue)//循环迭代,寻找纳什均衡策略
{
a = (1.0 - 0.5) * (int.MaxValue - t) / int.MaxValue + 0.5;//收缩-扩张系数值
douMax = _particles[0].fitness;
douMaxIndex = 0;
//寻找适应度值最差粒子
for (int i = 1; i < _particles.Length; i++)
{
if (_particles[i].fitness > douMax)
{
douMax = _particles[i].fitness;
douMaxIndex = i;
}
}
//迭代公式
douGest = 0;
douMBest = 0;
if (_costLevel == 1)
{
douGest = gbest1[douMaxIndex];
}
else if (_costLevel == 2)
{
douGest = gbest2[douMaxIndex];
}
else
{
douGest = gbest3[douMaxIndex];
}
for (int i = 0; i < _particles.Length; i++)
{
douMBest += _particles[i].x;
}
douMBest = douMBest * 1.0 / _particles.Length;
u = rand.NextDouble();
b = 2 * a * Math.Abs(douMBest - _particles[douMaxIndex].x);
v = Math.Log(1.0 / u);
z = ((douGest + (b / 2) * v) * 1.0) % Math.Floor(douGest + (b / 2) * v);
//更新粒子位置
if (z > rand.NextDouble())
_particles[douMaxIndex].x = (int)Math.Floor(douGest + b * v);
else
_particles[douMaxIndex].x = (int)Math.Floor(douGest - b * v);
//粒子位置限制在搜索范围内
bool inContainStrategySets = false;//粒子更新解是否包含在策略空间中
//若粒子更新解不在策略空间中，则在策略空间中选择较优策略
for (int i = 0; i < _strategySets.Count; i++)
{
if (_particles[douMaxIndex].x == _strategySets[i])
{
inContainStrategySets = true;
break;
}
}
if (inContainStrategySets == false)
{
_particles[douMaxIndex].x = _strategySets[douIndexStrategy];
}
_particles[douMaxIndex].fitness = SatisficationValue(_particles[douMaxIndex].x,
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_costLevel == 1)
{
gbestfitness1 = SatisficationValue(gbest1[douMaxIndex],
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_particles[douMaxIndex].fitness < gbestfitness1)
{
gbest1[douMaxIndex] = _particles[douMaxIndex].x;
}
else
{
gbest1[douMaxIndex] = _strategySets[douIndexStrategy];
}
}
else if (_costLevel == 2)
{
gbestfitness2 = SatisficationValue(gbest2[douMaxIndex],
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_particles[douMaxIndex].fitness < gbestfitness2)
{
gbest2[douMaxIndex] = _particles[douMaxIndex].x;
}
else
{
gbest2[douMaxIndex] = _strategySets[douIndexStrategy];
}
}
else
{
gbestfitness3 = SatisficationValue(gbest3[douMaxIndex],
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_particles[douMaxIndex].fitness < gbestfitness3)
{
gbest3[douMaxIndex] = _particles[douMaxIndex].x;
}
else
{
gbest3[douMaxIndex] = _strategySets[douIndexStrategy];
}
}
bool intNashNum = true;//判断是否实现了纳什均衡
if (_costLevel == 1)
{
for (int i = 1; i < _particles.Length; i++)
{
if (gbest1[i] != gbest1[0])
{
intNashNum = false;
break;
}
}
}
else if (_costLevel == 2)
{
for (int i = 1; i < _particles.Length; i++)
{
if (gbest2[i] != gbest2[0])
{
intNashNum = false;
break;
}
}
}
else
{
for (int i = 1; i < _particles.Length; i++)
{
if (gbest3[i] != gbest3[0])
{
intNashNum = false;
break;
}
}
}
if (intNashNum == false)
{
t++;
}
else
{
break;
}
}
//写入数据集ds中
dt = new DataTable();
//构建表结构
dt.Columns.Add("Factors", typeof(Int32));
dt.Columns.Add("1", typeof(Int32));
dt.Columns.Add("2", typeof(Int32));
dt.Columns.Add("3", typeof(Int32));
dt.Columns.Add("4", typeof(Int32));
DataRow dr;
for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
{
dr = dt.NewRow();
dr[0] = i + 1;
for (int j = 1; j < dt.Columns.Count; j++)
{
dr[j] = 0;
}
dt.Rows.Add(dr);
}
int intColumn = 0;
if (_costLevel == 1)
{
intColumn = gbest1[0];
}
else if (_costLevel == 2)
{
intColumn = gbest2[0];
}
else
{
intColumn = gbest3[0];
}
dt.Rows[_sectionIndex][intColumn] = _particles.Length;
ds[upperSolutionIndex].Tables.Add(dt);
ds[upperSolutionIndex].Tables[ds[upperSolutionIndex].Tables.Count - 1].TableName =
_oStation.ToString() + "-" + _dStation + "g" + _costLevel.ToString() + "Customer";
}
/// <summary>
/// 列车开行频率
/// </summary>
/// <returns>列车开行数量</returns>
internal int[,] TrainRunningFrequency(DataSet _ds)
{
int[,] intqT = new int[NSGA_Ⅱ.pLNum, NSGA_Ⅱ.trainType];//列车开行频率
int intMaxValue;//区间最大客流量
int[] sectionStation;//开行区段站点集合
int[] sectionCustomer;//乘坐某一类列车的各区间客流数集合
for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
{
intMaxValue = 0;
sectionStation = new int[trainDepartureSection[i].Length];
sectionCustomer = new int[trainDepartureSection[i].Length - 1];
for (int j = 0; j < sectionStation.Length; j++)
{
sectionStation[j] = trainDepartureSection[i][j];
}
for (int m = 0; m < intqT.GetLength(1); m++)
{
int douValueCustomer;//区间客流总和
string strTableName1 = "";//表名
string strTableName2 = "";
string strTableName3 = "";
for (int j = 0; j < sectionCustomer.Length; j++)
{
douValueCustomer = 0;
for (int k = 0; k <= j; k++)
{
for (int l = j + 1; l < sectionStation.Length; l++)
{
strTableName1 = sectionStation[k].ToString() + "-" +
sectionStation[l].ToString() + "g1Customer";
strTableName2 = sectionStation[k].ToString() + "-" +
sectionStation[l].ToString() + "g2Customer";
strTableName3 = sectionStation[k].ToString() + "-" +
sectionStation[l].ToString() + "g3Customer";
for (int p = 0; p < intqT.GetLength(0); p++)
{
douValueCustomer += Convert.ToInt32(_ds.Tables[strTableName1].Rows[p][m + 1]) +
Convert.ToInt32(_ds.Tables[strTableName2].Rows[p][m + 1]) +
Convert.ToInt32(_ds.Tables[strTableName3].Rows[p][m + 1]);
}
}
}
sectionCustomer[j] = douValueCustomer;
}
intMaxValue = sectionCustomer[0];
for (int j = 1; j < sectionCustomer.Length; j++)
{
if (sectionCustomer[j] > intMaxValue)
{
intMaxValue = sectionCustomer[j];
}
}
intqT[i, m] = Convert.ToInt32(Math.Floor(intMaxValue * douCustomerFluctuateRate / (seatNum * (alphMax + alphMin) / 2)));
}
}
return intqT;
}
}
3.编写求解下层非合作博弈的QPSO算法，各算子针对模型设计
public class LowerCustomerAssigned
{
internal List<Chromosome> iterValue = new List<Chromosome>();//输出对象
public struct Particles //定义粒子的结构体
{
public int x;//粒子当前位置(选择的列车种类)
public double fitness;//粒子的当前位置适应值
}
//全局变量定义
static int popsize1;//消费水平层次为1的群体规模
static int popsize2;//消费水平层次为2的群体规模
static int popsize3;//消费水平层次为3的群体规模
Particles[] g1Particles;//消费水平层次为1的客流个体集合
Particles[] g2Particles;//消费水平层次为2的客流个体集合
Particles[] g3Particles;//消费水平层次为3的客流个体集合
int[] gbest1;//消费层次为1的客流局势
int[] gbest2;//消费层次为2的客流局势
int[] gbest3;//消费层次为3的客流局势
double gbestfitness1;//消费水平层次为1的赢得函数值
double gbestfitness2;//消费水平层次为2的赢得函数值
double gbestfitness3;//消费水平层次为3的赢得函数值
Random rand = new Random();//随机数产生器
LinkExcel _linkExcel = new LinkExcel();//表读取对象
internal int upperSolutionIndex = 0;//上层解粒子下标索引
DataTable dt = new DataTable();//数据表
internal DataSet[] ds;//数据集
//string _strDataPath = "客流数据.xlsx";//数据所在相对位置
//下层客流博弈分配全局变量
double w1 = 200, w2 = 100, w3 = 50;//各消费层次客流时间价值系数
double lamda11 = 0.1, lamda12 = 0.9;//消费层次等级为1的客流的权重系数
double lamda21 = 0.5, lamda22 = 0.5;//消费层次等级为2的客流的权重系数
double lamda31 = 0.9, lamda32 = 0.1;//消费层次等级为3的客流的权重系数
//double violationM = 50000;//惩罚函数值
double velocity = 250;//列车速度值
double timeAverage = 4;//在站停留平均时间
int[] bigStation = new int[] { 1, 5, 22 };//客流量较大站点集合
double[,] ticketRate = new double[,] { { 0.9, 0.8, 0.7, 0.6 }, { 0.6, 0.5, 0.4, 0.3 }, { 0.4, 0.3, 0.2, 0.1 } };//票价率
internal NSGA_Ⅱ upperObject = new NSGA_Ⅱ();//上层对象
//方法定义
int sectionIndex = 0;//客流博弈所在开行区段下标
List<int> sectionListIndexSets = new List<int>();//始发、终到站均含于相同开行区段的开行区段下标集合
List<int> strategySets = new List<int>();//策略集
/// <summary>
/// OD客流选择列车出行博弈方法
/// </summary>
/// <param name="xchromosome">上层解粒子</param>
/// <param name="g1CustomerNum">消费层次为1的OD客流规模</param>
/// <param name="g2CustomerNum">消费层次为2的OD客流规模</param>
/// <param name="g3CustomerNum">消费层次为3的OD客流规模</param>
/// <param name="startStation">O点</param>
/// <param name="endStation">D点</param>
internal void customersAssigned(Chromosome xchromosome, int g1CustomerNum, int g2CustomerNum,
int g3CustomerNum, int startStation, int endStation)
{
sectionIndex = 0;//开行区段索引赋初值
sectionListIndexSets.Clear();//清空开行区段索引集合
strategySets.Clear();//清空策略集
for (int i = 0; i < xchromosome.x.GetLength(0); i++)//填充均包含O、D的开行区段下标集合
{
if (upperObject.trainDepartureSection[i][0] <= startStation &&
upperObject.trainDepartureSection[i][xchromosome.x[i].Length - 1] >= endStation)
{
sectionListIndexSets.Add(i);
}
}
//随机选择一个同时包含起始、终点站的列车开行区段
sectionIndex = sectionListIndexSets[rand.Next(sectionListIndexSets.Count)];
//填充策略集StrategySets
//--一站直达
if (startStation == upperObject.trainDepartureSection[sectionIndex][0] &&
endStation == upperObject.trainDepartureSection[sectionIndex][upperObject.trainDepartureSection[sectionIndex].Length - 1])
{
strategySets.Add(1);
}
//--大站停
int isAllbigStation = 0;//指标--指示OD客流是否可以乘坐大站停列车完成出现
for (int i = 0; i < bigStation.Length; i++)
{
if (startStation == bigStation[i])
{
isAllbigStation += 1;
continue;
}
if (endStation == bigStation[i])
{
isAllbigStation += 1;
break;
}
}
if (isAllbigStation == 2)
{
strategySets.Add(2);
}
//--择站停
int startStationIndex = 0;//客流出发站的站点在x解集中对应的下标
int endStationIndex = 0;//客流终到站的站点在x解集中对应的下标
for (int i = 0; i < upperObject.trainDepartureSection[sectionIndex].Length; i++)
{
if (upperObject.trainDepartureSection[sectionIndex][i] == startStation)
{
startStationIndex = i;
continue;
}
if (upperObject.trainDepartureSection[sectionIndex][i] == endStation)
{
endStationIndex = i;
break;
}
}
if (xchromosome.x[sectionIndex][startStationIndex] == 1 && xchromosome.x[sectionIndex][endStationIndex] == 1)
strategySets.Add(3);
//--站站停：对OD(始发站为startStation,终点站为endStation)来说，站站停列车为必备策略
strategySets.Add(4);
//客流列车分配初始化
popsize1 = g1CustomerNum;//初始化各消费层次客流规模
popsize2 = g2CustomerNum;
popsize3 = g3CustomerNum;
g1Particles = new Particles[popsize1];//创建各消费层次客流集合
g2Particles = new Particles[popsize2];
g3Particles = new Particles[popsize3];
gbest1 = new int[popsize1];//创建各消费层次客流局势
gbest2 = new int[popsize2];
gbest3 = new int[popsize3];
//分情况初始化各消费层次客流出行列车选择
if (strategySets.Count == 1)
{
//消费层次为1的客流初始化
g1Particles[0].x = strategySets[0];
gbest1[0] = g1Particles[0].x;
g1Particles[0].fitness = SatisficationValue(g1Particles[0].x, 1, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
for (int i = 1; i < popsize1; i++)
{
g1Particles[i].x = g1Particles[0].x;
g1Particles[i].fitness = g1Particles[0].fitness;
gbest1[i] = g1Particles[i].x;
}
//消费层次为2的客流初始化
g2Particles[0].x = strategySets[0];
gbest2[0] = g2Particles[0].x;
g2Particles[0].fitness = SatisficationValue(g2Particles[0].x, 2, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
for (int i = 1; i < popsize2; i++)
{
g2Particles[i].x = g2Particles[0].x;
g2Particles[i].fitness = g2Particles[0].fitness;
gbest2[i] = g2Particles[i].x;
}
//消费层次为3的客流初始化
g3Particles[0].x = strategySets[0];
gbest3[0] = g3Particles[0].x;
g3Particles[0].fitness = SatisficationValue(g3Particles[0].x, 3, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
for (int i = 1; i < popsize3; i++)
{
g3Particles[i].x = g3Particles[0].x;
g3Particles[i].fitness = g3Particles[0].fitness;
gbest3[i] = g3Particles[i].x;
}
}
else
{
//消费层次为1的客流初始化
double douValue = 0;
for (int i = 0; i < popsize1; i++)
{
g1Particles[i].x = strategySets[rand.Next(strategySets.Count)];
g1Particles[i].fitness = SatisficationValue(g1Particles[i].x, 1, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
gbest1[i] = g1Particles[i].x;
douValue += g1Particles[i].fitness;
}
//消费层次为2的客流初始化
douValue = 0;
for (int i = 0; i < popsize2; i++)
{
g2Particles[i].x = strategySets[rand.Next(strategySets.Count)];
g2Particles[i].fitness = SatisficationValue(g2Particles[i].x, 2, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
gbest2[i] = g2Particles[i].x;
douValue += g2Particles[i].fitness;
}
//消费层次为3的客流初始化
douValue = 0;
for (int i = 0; i < popsize3; i++)
{
g3Particles[i].x = strategySets[rand.Next(strategySets.Count)];
g3Particles[i].fitness = SatisficationValue(g3Particles[i].x, 3, sectionIndex, startStationIndex,
endStationIndex, startStation, endStation, xchromosome);
gbest3[i] = g3Particles[i].x;
douValue += g3Particles[i].fitness;
}
}
//算法开始迭代
RunIteration(g1Particles, 1, strategySets, sectionIndex, startStationIndex, endStationIndex,
startStation, endStation, xchromosome);
RunIteration(g2Particles, 2, strategySets, sectionIndex, startStationIndex, endStationIndex,
startStation, endStation, xchromosome);
RunIteration(g3Particles, 3, strategySets, sectionIndex, startStationIndex, endStationIndex,
startStation, endStation, xchromosome);
}
/// <summary>
/// 铁路旅客满意度评价函数
/// </summary>
/// <param name="_trainType">列车种类</param>
/// <param name="_costLevel">消费层次</param>
/// <param name="_sectionIndex">博弈区段下标</param>
/// <param name="_startStationIndex">O点对应数组下标</param>
/// <param name="_endStationIndex">D点对应数组下标</param>
/// <param name="_oStation">O点</param>
/// <param name="_dStation">D点</param>
/// <param name="_xchromosome">上层解个体</param>
/// <returns>满意度值</returns>
double SatisficationValue(int _trainType, int _costLevel, int _sectionIndex, int _startStationIndex,
int _endStationIndex, int _oStation, int _dStation, Chromosome _xchromosome)
{
double ticketSatiVal = 0;//票价满意度
double timeSatiVal = 0;//时间满意度
double distance = upperObject.IJDistance(_oStation, _dStation);//OD距离
//若为一站直达列车
if (_trainType == 1)
{
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * 1.0 * distance / velocity;
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * 1.0 * distance / velocity;
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * 1.0 * distance / velocity;
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
//若为大站停列车
else if (_trainType == 2)
{
int middleStop = 0;
for (int i = 0; i < bigStation.Length; i++)
{
if (_oStation < bigStation[i] && bigStation[i] < _dStation)
{
middleStop += 1;
}
}
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
//若为择站停列车
else if (_trainType == 3)
{
int middleStop = 0;
for (int i = _startStationIndex + 1; i < _endStationIndex; i++)
{
if (_xchromosome.x[_sectionIndex][i] == 1)
{
middleStop += 1;
}
}
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
//若为站站停列车
else
{
int middleStop = 0;
if (_xchromosome.x[_sectionIndex].Length == 2)
middleStop = 0;
else
middleStop = _endStationIndex - _startStationIndex - 1;
ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
if (_costLevel == 1)
{
timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
}
else if (_costLevel == 2)
{
timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
}
else
{
timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
}
}
}
/// <summary>
/// QPSO程序迭代器
/// </summary>
/// <param name="_particles">粒子种群</param>
/// <param name="_costLevel">消费层次</param>
/// <param name="_strategySets">可选策略集</param>
/// <param name="_sectionIndex">开行区段索引下标</param>
/// <param name="_startStationIndex">O点对应数组下标</param>
/// <param name="_endStationIndex">D点对应数组下标</param>
/// <param name="_oStation">O点</param>
/// <param name="_dStation">D点</param>
/// <param name="_xchromosome">上层解个体</param>
void RunIteration(Particles[] _particles, int _costLevel, List<int> _strategySets,
int _sectionIndex, int _startStationIndex, int _endStationIndex, int _oStation,
int _dStation, Chromosome _xchromosome)
{
//字段
double a;//QPSO迭代式中的收缩-扩张系数值
double douMax;//群体最大值
int douMaxIndex;//群体最大值下标
double douGest;//客流个体的较优策略--QPSO迭代式中的局部吸引子
double douMBest;//QPSO迭代式中的平均最好位置
double u;//QPSO迭代式中的随机变量，服从U(0,1)
double b;//QPSO迭代式中的特征长度
double v;//QPSO迭代式中的Log值
double z;//迭代结果小数部分
//循环迭代
double[] douBestStrategy = new double[_strategySets.Count];//各个策略对应赢得函数值
double douValueStrategy = double.MaxValue;//最优策略函数值
int douIndexStrategy = -1;//最优策略
for (int i = 0; i < douBestStrategy.Length; i++)//寻找最优策略及其下标
{
douBestStrategy[i] = SatisficationValue(_strategySets[i], _costLevel,
_sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (douBestStrategy[i] < douValueStrategy)
{
douValueStrategy = douBestStrategy[i];
douIndexStrategy = i;
}
}
int t = 0;
while (t <= int.MaxValue)//循环迭代,寻找纳什均衡策略
{
a = (1.0 - 0.5) * (int.MaxValue - t) / int.MaxValue + 0.5;//收缩-扩张系数值
douMax = _particles[0].fitness;
douMaxIndex = 0;
//寻找适应度值最差粒子
for (int i = 1; i < _particles.Length; i++)
{
if (_particles[i].fitness > douMax)
{
douMax = _particles[i].fitness;
douMaxIndex = i;
}
}
//迭代公式
douGest = 0;
douMBest = 0;
if (_costLevel == 1)
{
douGest = gbest1[douMaxIndex];
}
else if (_costLevel == 2)
{
douGest = gbest2[douMaxIndex];
}
else
{
douGest = gbest3[douMaxIndex];
}
for (int i = 0; i < _particles.Length; i++)
{
douMBest += _particles[i].x;
}
douMBest = douMBest * 1.0 / _particles.Length;
u = rand.NextDouble();
b = 2 * a * Math.Abs(douMBest - _particles[douMaxIndex].x);
v = Math.Log(1.0 / u);
z = ((douGest + (b / 2) * v) * 1.0) % Math.Floor(douGest + (b / 2) * v);
//更新粒子位置
if (z > rand.NextDouble())
_particles[douMaxIndex].x = (int)Math.Floor(douGest + b * v);
else
_particles[douMaxIndex].x = (int)Math.Floor(douGest - b * v);
//粒子位置限制在搜索范围内
bool inContainStrategySets = false;//粒子更新解是否包含在策略空间中
//若粒子更新解不在策略空间中，则在策略空间中选择较优策略
for (int i = 0; i < _strategySets.Count; i++)
{
if (_particles[douMaxIndex].x == _strategySets[i])
{
inContainStrategySets = true;
break;
}
}
if (inContainStrategySets == false)
{
_particles[douMaxIndex].x = _strategySets[douIndexStrategy];
}
_particles[douMaxIndex].fitness = SatisficationValue(_particles[douMaxIndex].x,
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_costLevel == 1)
{
gbestfitness1 = SatisficationValue(gbest1[douMaxIndex],
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_particles[douMaxIndex].fitness < gbestfitness1)
{
gbest1[douMaxIndex] = _particles[douMaxIndex].x;
}
else
{
gbest1[douMaxIndex] = _strategySets[douIndexStrategy];
}
}
else if (_costLevel == 2)
{
gbestfitness2 = SatisficationValue(gbest2[douMaxIndex],
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_particles[douMaxIndex].fitness < gbestfitness2)
{
gbest2[douMaxIndex] = _particles[douMaxIndex].x;
}
else
{
gbest2[douMaxIndex] = _strategySets[douIndexStrategy];
}
}
else
{
gbestfitness3 = SatisficationValue(gbest3[douMaxIndex],
_costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
_dStation, _xchromosome);
if (_particles[douMaxIndex].fitness < gbestfitness3)
{
gbest3[douMaxIndex] = _particles[douMaxIndex].x;
}
else
{
gbest3[douMaxIndex] = _strategySets[douIndexStrategy];
}
}
bool intNashNum = true;//判断是否实现了纳什均衡
if (_costLevel == 1)
{
for (int i = 1; i < _particles.Length; i++)
{
if (gbest1[i] != gbest1[0])
{
intNashNum = false;
break;
}
}
}
else if (_costLevel == 2)
{
for (int i = 1; i < _particles.Length; i++)
{
if (gbest2[i] != gbest2[0])
{
intNashNum = false;
break;
}
}
}
else
{
for (int i = 1; i < _particles.Length; i++)
{
if (gbest3[i] != gbest3[0])
{
intNashNum = false;
break;
}
}
}
if (intNashNum == false)
{
t++;
}
else
{
break;
}
}
//写入数据集ds中
dt = new DataTable();
//构建表结构
dt.Columns.Add("Factors", typeof(Int32));
dt.Columns.Add("1", typeof(Int32));
dt.Columns.Add("2", typeof(Int32));
dt.Columns.Add("3", typeof(Int32));
dt.Columns.Add("4", typeof(Int32));
DataRow dr;
for (int i = 0; i < upperObject.trainDepartureSection.GetLength(0); i++)
{
dr = dt.NewRow();
dr[0] = i + 1;
for (int j = 1; j < dt.Columns.Count; j++)
{
dr[j] = 0;
}
dt.Rows.Add(dr);
}
int intColumn = 0;
if (_costLevel == 1)
{
intColumn = gbest1[0];
}
else if (_costLevel == 2)
{
intColumn = gbest2[0];
}
else
{
intColumn = gbest3[0];
}
dt.Rows[_sectionIndex][intColumn] = _particles.Length;
ds[upperSolutionIndex].Tables.Add(dt);
ds[upperSolutionIndex].Tables[ds[upperSolutionIndex].Tables.Count - 1].TableName =
_oStation.ToString() + "-" + _dStation + "g" + _costLevel.ToString() + "Customer";
}
/// <summary>
/// 双层规划算法迭代
/// </summary>
public void BiLevelAlgorithmRunning()
{
//下层数据集个数--数量与种群规模一致
ds = new DataSet[upperObject.chromosomes.Length];
//上层解粒子索引
upperSolutionIndex = 0;
//上层解集初始化
upperObject.UpperInitation();
//针对每一个上层解，求下层客流分配纳什均衡解及上层函数
for (int i = 0; i < upperObject.chromosomes.Length; i++)
{
upperSolutionIndex = i;//记录当前上层解粒子索引
ds[upperSolutionIndex] = new DataSet();
for (int j = 1; j < NSGA_Ⅱ.stationNum; j++)//客流博弈分配
{
for (int k = j + 1; k <= NSGA_Ⅱ.stationNum; k++)
{
customersAssigned(upperObject.chromosomes[upperSolutionIndex], upperObject.g1Customer[j - 1, k - 1],
upperObject.g2Customer[j - 1, k - 1], upperObject.g3Customer[j - 1, k - 1], j, k);
}
}
//根据旅客分配情况确定列车开行频率
upperObject.chromosomes[upperSolutionIndex].Frequent = new int[NSGA_Ⅱ.pLNum, NSGA_Ⅱ.trainType];
upperObject.chromosomes[upperSolutionIndex].Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
//根据旅客分配情况确定上层各函数值
upperObject.chromosomes[upperSolutionIndex].f = new double[NSGA_Ⅱ.f_num];
upperObject.dSCustomer = ds[upperSolutionIndex];
upperObject.chromosomes[upperSolutionIndex].f[0] =
upperObject.F1Object(upperObject.chromosomes[upperSolutionIndex]);
upperObject.chromosomes[upperSolutionIndex].f[1] =
upperObject.F2Object(upperObject.chromosomes[upperSolutionIndex]);
}
//非支配排序算子
upperObject.NonDominationSort(upperObject.chromosomes);
//拥挤度算子
upperObject.CrowdingDistanceSort(upperObject.f_sort);
//锦标赛选择算子
Chromosome[] chro = new Chromosome[upperObject.chromosomes.Length];
chro = upperObject.TournamentSelection(upperObject.chromosomes);
//交叉、变异算子
upperObject.NewChromosomes(chro);
//下一代种群形成
upperObject.Elitism(upperObject.f_sort, upperObject.c_sort);
double d = 0;
//_linkExcel.DSToExcel(_strDataPath, ds);
}
/// <summary>
/// 列车开行频率
/// </summary>
/// <returns>列车开行数量</returns>
internal int[,] TrainRunningFrequency(DataSet _ds)
{
int[,] intqT = new int[NSGA_Ⅱ.pLNum, NSGA_Ⅱ.trainType];//列车开行频率
int intMaxValue;//区间最大客流量
int[] sectionStation;//开行区段站点集合
int[] sectionCustomer;//乘坐某一类列车的各区间客流数集合
for (int i = 0; i < upperObject.trainDepartureSection.GetLength(0); i++)
{
intMaxValue = 0;
sectionStation = new int[upperObject.trainDepartureSection[i].Length];
sectionCustomer = new int[upperObject.trainDepartureSection[i].Length - 1];
for (int j = 0; j < sectionStation.Length; j++)
{
sectionStation[j] = upperObject.trainDepartureSection[i][j];
}
for (int m = 0; m < intqT.GetLength(1); m++)
{
int douValueCustomer;//区间客流总和
string strTableName1 = "";//表名
string strTableName2 = "";
string strTableName3 = "";
for (int j = 0; j < sectionCustomer.Length; j++)
{
douValueCustomer = 0;
for (int k = 0; k <= j; k++)
{
for (int l = j + 1; l < sectionStation.Length; l++)
{
strTableName1 = sectionStation[k].ToString() + "-" +
sectionStation[l].ToString() + "g1Customer";
strTableName2 = sectionStation[k].ToString() + "-" +
sectionStation[l].ToString() + "g2Customer";
strTableName3 = sectionStation[k].ToString() + "-" +
sectionStation[l].ToString() + "g3Customer";
for (int p = 0; p < intqT.GetLength(0); p++)
{
douValueCustomer += Convert.ToInt32(_ds.Tables[strTableName1].Rows[p][m + 1]) +
Convert.ToInt32(_ds.Tables[strTableName2].Rows[p][m + 1]) +
Convert.ToInt32(_ds.Tables[strTableName3].Rows[p][m + 1]);
}
}
}
sectionCustomer[j] = douValueCustomer;
}
intMaxValue = sectionCustomer[0];
for (int j = 1; j < sectionCustomer.Length; j++)
{
if (sectionCustomer[j] > intMaxValue)
{
intMaxValue = sectionCustomer[j];
}
}
intqT[i, m] = Convert.ToInt32(Math.Floor(intMaxValue * upperObject.douCustomerFluctuateRate / (upperObject.seatNum * (upperObject.alphMax + upperObject.alphMin) / 2)));
}
}
return intqT;
}
}
3.运行程序
private void Form1_Load(object sender, EventArgs e)
{
this.Text = "QPSO(Test)";
this.Icon = new Icon(@"E:\VS2017\Icon\1.ico");
QPSO_Test qPSO_Test = new QPSO_Test();
qPSO_Test.RunAlgorithm();
double[] value = qPSO_Test.Value();
double[] gvalue = qPSO_Test.GValue();
chart1.ChartAreas["ChartArea1"].Name = "MyChartArea";
chart1.ChartAreas["MyChartArea"].AxisX.Interval = 4;
chart1.Series[0].ChartArea = "MyChartArea";
chart1.Series[0].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Line;
chart1.Series[0].Name = "每次运行结果";
chart1.Series.Add("MSeries");
chart1.Series["MSeries"].ChartArea = "MyChartArea";
chart1.Series["MSeries"].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.FastPoint;
chart1.Series["MSeries"].Color = Color.Red;
chart1.Series["MSeries"].Name = "种群迭代结果";
chart1.Series[1].YAxisType = System.Windows.Forms.DataVisualization.Charting.AxisType.Secondary;
chart1.ChartAreas[0].AxisY2.MajorGrid.Enabled = false;
chart1.ChartAreas[0].AxisY.MajorGrid.Enabled = false;
chart1.ChartAreas[0].AxisX.MajorGrid.Enabled = false;
chart1.Titles.Add("量子粒子群测试");
chart1.Titles[0].Alignment = ContentAlignment.TopCenter;
chart1.Titles[0].Font = new Font(new FontFamily("Arial"), 12, FontStyle.Bold);
chart1.ChartAreas["MyChartArea"].AxisY2.Title = "第50次运行时种群迭代最佳适应值";
chart1.ChartAreas["MyChartArea"].AxisY.Title = "每次运行种群最佳适应值";
chart1.ChartAreas["MyChartArea"].AxisX.Title = "迭代次数";
for (int i = 0; i < 50; i++)
{
chart1.Series[0].Points.AddXY(i + 1, value[i]);
chart1.Series[1].Points.AddXY(i + 1, gvalue[i]);
}
}
扫一扫
696
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
