futucompetedlg.cpp

考虑未来竞争的空间交互选址问题求解

		XYCom[i].x = atof(str1);
		XYCom[i].y = atof(str2);
		double d = XYCom[i].x;
		double d1= XYCom[i].y;
	}
}

void CFutuCompeteDlg::GetRequireQuantum()
{
	for(int i=0; i<m_nmRequireNum; i++)
	{
		CString str = m_listRequireCoord.GetItemText(1,i+1);
		RequireQuantum[i] = atof(str);
		double d = RequireQuantum[i];
	}
}

void CFutuCompeteDlg::GetDistance22()
{
	int m,n;

	for(m=0; m<m_nmRequireNum; m++)
		for(n=0; n<m_nnCompeteNum; n++)
		{
			DistCom22[m][n] = (XYCom[n].x-XYReq[m].x)*(XYCom[n].x-XYReq[m].x)  
							+ (XYCom[n].y-XYReq[m].y)*(XYCom[n].y-XYReq[m].y);
			double d = DistCom22[m][n];
		}
		
	for(m=0; m<m_nmRequireNum; m++)
		for(n=0; n<m_ncExistOfANum; n++)
		{
			DistExi22[m][n] = (XYExi[n].x-XYReq[m].x)*(XYExi[n].x-XYReq[m].x)  
							+ (XYExi[n].y-XYReq[m].y)*(XYExi[n].y-XYReq[m].y);
			double d1 = DistExi22[m][n];
		}
}

void CFutuCompeteDlg::GetUseToRequire()
{
	int m,n;
	CString str;

	for(m=0; m<m_nmRequireNum; m++)
		for(n=0; n<m_nnCompeteNum; n++)
		{
			str = m_listCompeteUse.GetItemText(m,n+1);
			UseCom[m][n] = atof(str);
			double d = UseCom[m][n];
			//double d2 = UseCom[i][j];
		}
		
	for(m=0; m<m_nmRequireNum; m++)
		for(n=0; n<m_ncExistOfANum; n++)
		{
			str = m_listExistOfAUse.GetItemText(m,n+1);
			UseExi[m][n] = atof(str);
			double d = UseExi[m][n];
		}

	for(m=0; m<m_nmRequireNum; m++)
	{
		str = m_listUVUse.GetItemText(0,m+1);
		UseUV[m] = atof(str);
		double d = UseUV[m];
	}

	for(m=0; m<m_nmRequireNum; m++)
	{
		str = m_listXYUse.GetItemText(0,m+1);
		UseXY[m] = atof(str);
		double d = UseUV[m];
	}
}

void CFutuCompeteDlg::GetCoeOfDistance()
{
	int m,n;
	CString str;
	
	for(m=0; m<m_nmRequireNum; m++)
		for(n=0; n<m_nnCompeteNum; n++)
		{
			str = m_listCompeteCoe.GetItemText(m,n+1);
			CoeCom[m][n]= atof(str);
			double d = CoeCom[m][n];
		}	
		
	for(m=0; m<m_nmRequireNum; m++)
		for(n=0; n<m_ncExistOfANum; n++)
		{
			str = m_listExistOfACoe.GetItemText(m,n+1);
			CoeExi[m][n]= atof(str);
			double d = CoeCom[m][n];
		}
		
	for(m=0; m<m_nmRequireNum; m++)
	{
		str = m_listUVCoe.GetItemText(0,m+1);
		CoeUV[m] = atof(str);
		double d = CoeUV[m];
	}

	for(m=0; m<m_nmRequireNum; m++)
	{
		str = m_listXYCoe.GetItemText(0,m+1);
		CoeXY[m] = atof(str);
		double d = CoeXY[m];
	}
}

void CFutuCompeteDlg::ComputeEQ(double XYx, double XYy, 
								double UVx, double UVy)
{
	Result_MAXEQ1 = 0.0;
	Result_MAXEQ2 = 0.0;
	
	int m, n, c, l;
	double sumcom=0.0, sumcoml=0.0, sumexi=0.0, sumcho=0.0;
	double valXY, valUV;
	
	for(m=0; m<m_nmRequireNum; m++)
	{
		for(n=0; n<m_nnCompeteNum; n++)
		{
			sumcom += UseCom[m][n]/(CoeCom[m][n]*DistCom22[m][n]);
		}

		for(l=0; l<m_nlCompOfBNum; l++)
		{
			sumcoml += UseCom[m][l]/(CoeCom[m][l]*DistCom22[m][l]);
		}
		
		for(c=0; c<m_ncExistOfANum; c++)
		{
			sumexi += UseExi[m][c]/(CoeExi[m][c]*DistExi22[m][c]);
		}
		
		double d22xy = (XYx-XYReq[m].x)*(XYx-XYReq[m].x) + 
					   (XYy-XYReq[m].y)*(XYy-XYReq[m].y);
		double d22uv = (UVx-XYReq[m].x)*(UVx-XYReq[m].x) + 
					   (UVy-XYReq[m].y)*(UVy-XYReq[m].y);
		
		valXY = UseXY[m]/(CoeXY[m]*d22xy);
		valUV = UseUV[m]/(CoeUV[m]*d22uv);

		Result_MAXEQ1 += 
			RequireQuantum[m]*(sumexi+valXY)/(sumcom+sumexi+valXY+valUV);
		Result_MAXEQ2 += 
			RequireQuantum[m]*(sumcoml+valUV)/(sumcom+sumexi+valXY+valUV);
	}
}

GradeDxDy CFutuCompeteDlg::ComputeGrads(double XYx, double XYy, 
								        double UVx, double UVy)
{
	GradeDxDy gdxdy;

	double N,M,L,D,E;
	double A, B, C, DT;
	double dEQ1XVdx, dEQ1XVdy;
	double d2iuv,d2ixy;
	double pEQ1XVpx, pEQ1XVpy, pEQ1XVpu, pEQ2XVpu, pEQ2XVpv, pEQ1XVpv;
	double p2EQ2XVpupx, p2EQ2XVpupy, p2EQ2XVpvpx, p2EQ2XVpvpy;
	double p2EQ2XVpu2, p2EQ2XVpv2, p2EQ2XVpupv;
	
	pEQ1XVpx=pEQ1XVpy=pEQ1XVpu=pEQ2XVpu=pEQ2XVpv=pEQ1XVpv=0.0;
	p2EQ2XVpupx=p2EQ2XVpupy=p2EQ2XVpvpx=p2EQ2XVpvpy=0.0;
	p2EQ2XVpu2=p2EQ2XVpv2=p2EQ2XVpupv=0.0;

	int n, c, l;

	for(int i=0; i<m_nmRequireNum; i++)
	{
		N = M = L = D = E = 0.0;

		for(n=0; n<m_nnCompeteNum; n++)
		{
			N += UseCom[i][n]/(CoeCom[i][n]*DistCom22[i][n]);
		}

		for(l=0; l<m_nlCompOfBNum; l++)
		{
			L += UseCom[i][l]/(CoeCom[i][l]*DistCom22[i][l]);
		}
		
		for(c=0; c<m_ncExistOfANum; c++)
		{
			M += UseExi[i][c]/(CoeExi[i][c]*DistExi22[i][c]);
		}

		d2iuv = (UVx-XYReq[i].x)*(UVx-XYReq[i].x) +
			   (UVy-XYReq[i].y)*(UVy-XYReq[i].y) ; 
		d2ixy = (XYx-XYReq[i].x)*(XYx-XYReq[i].x) +
			   (XYy-XYReq[i].y)*(XYy-XYReq[i].y) ; 

		D = N + M + UseUV[i]/(CoeUV[i]*d2iuv);
		E = N + M + UseXY[i]/(CoeXY[i]*d2ixy);

		pEQ1XVpx += (-2)*RequireQuantum[i]*(UseXY[i]*(N+UseUV[i]/d2iuv)*(XYx-XYReq[i].x)/((D*d2ixy+UseXY[i])*(D*d2ixy+UseXY[i])));
		pEQ1XVpy += (-2)*RequireQuantum[i]*(UseXY[i]*(N+UseUV[i]/d2iuv)*(XYy-XYReq[i].y)/((D*d2ixy+UseXY[i])*(D*d2ixy+UseXY[i])));
//		pEQ1XVpu += 2*RequireQuantum[i]*(UseUV[i]*(M+UseXY[i]/d2ixy)(UVx-XYReq[i].x)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
//		pEQ2XVpu += 2*RequireQuantum[i]*(UseUV[i]*(L-E)(UVx-XYReq[i].x)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
//		pEQ2XVpv += 2*RequireQuantum[i]*(UseUV[i]*(L-E)(UVy-XYReq[i].y)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
//		pEQ1XVpv += 2*RequireQuantum[i]*(UseUV[i]*(M+UseXY[i]/d2ixy)(UVy-XYReq[i].y)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
		p2EQ2XVpupx += 4*RequireQuantum[i]*(UseUV[i]*UseXY[i]*((2*L-E)*d2iuv+UseUV[i])*(UVx-XYReq[i].x)*(XYx-XYReq[i].x)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*d2ixy*d2ixy));
		p2EQ2XVpupy += 4*RequireQuantum[i]*(UseUV[i]*UseXY[i]*((2*L-E)*d2iuv+UseUV[i])*(UVx-XYReq[i].x)*(XYy-XYReq[i].y)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*d2ixy*d2ixy));
		p2EQ2XVpvpx += 4*RequireQuantum[i]*(UseUV[i]*UseXY[i]*((2*L-E)*d2iuv+UseUV[i])*(UVy-XYReq[i].y)*(XYx-XYReq[i].x)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*d2ixy*d2ixy));
		p2EQ2XVpvpy += 4*RequireQuantum[i]*(UseUV[i]*UseXY[i]*((2*L-E)*d2iuv+UseUV[i])*(UVy-XYReq[i].y)*(XYy-XYReq[i].y)/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*d2ixy*d2ixy));
		p2EQ2XVpu2 += 2*RequireQuantum[i]*(UseUV[i]*(L-E)*(E*d2iuv+UseUV[i]-4*E*(UVx-XYReq[i].x)*(UVx-XYReq[i].x))/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
		p2EQ2XVpv2 += 2*RequireQuantum[i]*(UseUV[i]*(L-E)*(E*d2iuv+UseUV[i]-4*E*(UVy-XYReq[i].y)*(UVy-XYReq[i].y))/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
		p2EQ2XVpupv += 8*RequireQuantum[i]*((UseUV[i]*E*(L-E)*(UVx-XYReq[i].x)*(UVy-XYReq[i].y))/((E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])*(E*d2iuv+UseUV[i])));
	}

	DT= p2EQ2XVpu2 * p2EQ2XVpv2 - p2EQ2XVpupx * p2EQ2XVpupx ;
	A = p2EQ2XVpu2 / DT ;
	B = p2EQ2XVpupv/ DT ;
	C = p2EQ2XVpv2 / DT ;

	dEQ1XVdx = pEQ1XVpx - 
			   pEQ1XVpu * ( C * p2EQ2XVpupx - B * p2EQ2XVpvpx ) -
			   pEQ1XVpv * ( A * p2EQ2XVpvpx - B * p2EQ2XVpupx )	;

	dEQ1XVdy = pEQ1XVpy - 
			   pEQ1XVpu * ( C * p2EQ2XVpupy - B * p2EQ2XVpvpy ) -
			   pEQ1XVpv * ( A * p2EQ2XVpvpy - B * p2EQ2XVpupy ) ;

	gdxdy.dx = dEQ1XVdx;
	gdxdy.dy = dEQ1XVdy;
  
	return gdxdy;
}

CFutuCompeteDlg::CFutuCompeteDlg(int m, int n, int l, int c)
{
	m_nmRequireNum = m;
	m_nnCompeteNum = n;
	m_nlCompOfBNum = l;
	m_ncExistOfANum = c;
}

CoordXY CFutuCompeteDlg::GetInitX()
{
	double  totalNeededAmount = 0;
	double  tempX=0.0 , tempY = 0.0;
	CoordXY initCor;
	
	for(int i = 0; i < m_nmRequireNum; i++)
	{
		totalNeededAmount += RequireQuantum[i];
		tempX += RequireQuantum[i]*XYReq[i].x;
		tempY += RequireQuantum[i]*XYReq[i].y;
	}
	
	double x = tempX/totalNeededAmount;
	double y = tempY/totalNeededAmount;
	initCor.x = tempX/totalNeededAmount;
	initCor.y = tempY/totalNeededAmount;
	return initCor;
}

CoordXY  CFutuCompeteDlg::GetVFromX(CoordXY X)
{
	CoordXY Vtemp;
	double u0, u0son=0.0, v0, v0son=0.0, mth=0.0;
	double upre, vpre, ucur = 100, vcur = 100;
	int i;
//	long count = 0;

	for(i=0; i<m_nmRequireNum; i++)
	{
		m_dE[i] = m_dN[i] + m_dM[i] + UseXY[i]/DistXY22[i];
	}
	double ei = m_dE[1];

	// 以下获得u0,v0
	for(i=0; i<m_nmRequireNum; i++)
	{
		u0son += RequireQuantum[i]*(m_dL[i]-m_dE[i])*XYReq[i].x/UseUV[i];
		v0son += RequireQuantum[i]*(m_dL[i]-m_dE[i])*XYReq[i].y/UseUV[i];
		mth   += RequireQuantum[i]*(m_dL[i]-m_dE[i])/UseUV[i];
	}
	u0 = u0son/mth;
	v0 = v0son/mth;
	ucur = u0;
	vcur = v0;

	double dist22 = 0.0, uson, vson;
	double ustatus = 0.1, vstatus = 0.1;
	
	// 将第P＋1循环得出的结果与0进行比较，是否满足给定的容忍误差，
	// 如果小于则认为此时的upre,vpre即是使E(Q)2最大的值，停止计算；
	do
	{
		uson = 0.0; vson = 0.0; mth = 0.0; 
		ustatus = 0.0; vstatus = 0.0;
		upre = ucur; vpre = vcur;
		
		for(i=0; i<m_nmRequireNum; i++)
		{
			dist22 = (upre - XYReq[i].x)*(upre - XYReq[i].x) + 
					 (vpre - XYReq[i].y)*(vpre - XYReq[i].y) ;
			uson += RequireQuantum[i]*(m_dL[i]-m_dE[i])*UseUV[i]*XYReq[i].x/
					((m_dE[i]*dist22 + UseUV[i])*(m_dE[i]*dist22 + UseUV[i]));
			vson += RequireQuantum[i]*(m_dL[i]-m_dE[i])*UseUV[i]*XYReq[i].y/
					((m_dE[i]*dist22 + UseUV[i])*(m_dE[i]*dist22 + UseUV[i]));
			mth  += RequireQuantum[i]*(m_dL[i]-m_dE[i])*UseUV[i]/
					((m_dE[i]*dist22 + UseUV[i])*(m_dE[i]*dist22 + UseUV[i]));
		}

		ucur = uson/mth;
		vcur = vson/mth;

		for(i=0; i<m_nmRequireNum; i++)
		{
			dist22 = (ucur - XYReq[i].x)*(ucur - XYReq[i].x) + 
					 (vcur - XYReq[i].y)*(vcur - XYReq[i].y) ;
			ustatus += RequireQuantum[i]*UseUV[i]*(m_dL[i]-m_dE[i])*(ucur-XYReq[i].x)/
					   ((m_dE[i]*dist22 + UseUV[i])*(m_dE[i]*dist22 + UseUV[i])) ;
			vstatus += RequireQuantum[i]*UseUV[i]*(m_dL[i]-m_dE[i])*(vcur-XYReq[i].y)/
					   ((m_dE[i]*dist22 + UseUV[i])*(m_dE[i]*dist22 + UseUV[i])) ;
		}
		ustatus *= 2;
		vstatus *= 2;
		if (ustatus<0.0) 
		{
			ustatus *= -1;
		}
		if (vstatus<0.0) 
		{
			vstatus *= -1;
		}
//		count++;
	}
	while((ustatus > 1e-6)|(vstatus > 1e-6));

	Vtemp.x = ucur;
	Vtemp.y = vcur;
	return Vtemp;
}

void CFutuCompeteDlg::setN()
{
	double ntemp;
	for(int i=0; i<m_nmRequireNum; i++)
	{
		ntemp = 0.0;
		for(int j=0; j<m_nnCompeteNum; j++)
		{
			ntemp += UseCom[i][j]/DistCom22[i][j];
		}
		m_dN[i] = ntemp;
	}
}

void CFutuCompeteDlg::setM()
{
	double mtemp;
	for(int i=0; i<m_nmRequireNum; i++)
	{
		mtemp = 0.0;
		for(int j=0; j<m_ncExistOfANum; j++)
		{
			mtemp += UseExi[i][j]/DistExi22[i][j];
		}
		m_dM[i] = mtemp;
	}
}

void CFutuCompeteDlg::setL()
{
	double ltemp;
	for(int i=0; i<m_nmRequireNum; i++)
	{
		ltemp = 0.0;
		for(int j=0; j<m_nlCompOfBNum; j++)
		{
			double d1 = DistCom22[i][j];
			double d2 = UseCom[i][j];
			ltemp += UseCom[i][j]/DistCom22[i][j];
		}
		m_dL[i] = ltemp;
	}
}

void CFutuCompeteDlg::setD()
{
	for(int i=0; i<m_nmRequireNum; i++)
	{
		m_dD[i] = m_dN[i] + m_dM[i] + UseUV[i]/DistUV22[i];
	}
	double di = m_dD[1];
}

void CFutuCompeteDlg::setE()
{
	for(int i=0; i<m_nmRequireNum; i++)
	{
		m_dE[i] = m_dN[i] + m_dM[i] + UseXY[i]/DistXY22[i];
	}
}

double CFutuCompeteDlg::P1EQ1_Px(double x)
{
	int i;
	double EQ1_x_temp = 0.0;
	double son, mth;

	for(i=0; i<m_nmRequireNum; i++)
	{
		son = m_dN[i] + UseUV[i]/DistUV22[i];
		son *= (-2*UseXY[i] * (x - XYReq[i].x));
		mth = pow(m_dD[i]*DistXY22[i] + UseXY[i], 2.0);
		EQ1_x_temp += RequireQuantum[i]*son/mth;
	}
	
	return EQ1_x_temp;
}

double CFutuCompeteDlg::P1EQ1_Pu(double u)
{
	int i;
	double EQ1_u_temp = 0.0;
	double son, mth;

	for(i=0; i<m_nmRequireNum; i++)
	{
		son = m_dM[i] + UseXY[i]/DistXY22[i];
		son *= (2*UseUV[i] * (u - XYReq[i].x));
		mth = pow(m_dE[i]*DistUV22[i] + UseUV[i], 2.0);
		EQ1_u_temp += RequireQuantum[i]*son/mth;
	}

	return EQ1_u_temp;
}

double CFutuCompeteDlg::P1EQ1_Pv(double v)
{
	int i;
	double EQ1_v_temp = 0.0;
	double son, mth;

	for(i=0; i<m_nmRequireNum; i++)
	{
		son = m_dM[i] + UseXY[i]/DistXY22[i];
		son *= (2*UseUV[i] * (v - XYReq[i].y));
		mth = pow(m_dE[i]*DistUV22[i] + UseUV[i], 2.0);
		EQ1_v_temp += RequireQuantum[i]*son/mth;
	}

	return EQ1_v_temp;
}

double CFutuCompeteDlg::P2EQ2_PuPx(double u, double x)
{
	int i;
	double EQ2_ux_temp = 0.0;
	double son, mth;

	for(i=0; i<m_nmRequireNum; i++)
	{
		son = 4*UseUV[i]*UseXY[i];
		son *= (u - XYReq[i].x)*(x - XYReq[i].x);
		son *= ((2*m_dL[i] - m_dE[i])*DistUV22[i] + UseUV[i]);
		mth = pow(m_dE[i]*DistUV22[i] + UseUV[i], 3.0);
		mth *= pow(DistXY22[i], 2.0);
		EQ2_ux_temp += RequireQuantum[i]*son/mth;
	}

	return EQ2_ux_temp;
}

double CFutuCompeteDlg::P2EQ2_PuPy(double u, double y)
{
	int i;
	double EQ2_uy_temp = 0.0;
	double son, mth;