main.cpp

关于一个求解线性规划问题的程序

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "Main.h"
#include "about.h"
#include "reset.h"
#include "global.h"
#include "Matrix.h"
#include "MatrixOp.h"
#include "xzDcx_solve.h"
#include "xzDcx_display.h"
#include "xzDcx_Inputx.h"
#include "vcl/inifiles.hpp"

#include <shellapi.h>
//---------------------------------------------------------------------------
#pragma link "Grids"
#pragma resource "*.dfm"
Tfrm_main *frm_main;

//---------------------------------------------------------------------------
__fastcall Tfrm_main::Tfrm_main(TComponent* Owner)
	: TForm(Owner)
{
   //默认的维数
   fRowCount = ROWCOUNT;
   fColCount = COLCOUNT;

   fDcxQ = new TDcxQuestion(fRowCount,fColCount);
   fRuleDcxQ = new TDcxQuestion(fRowCount,fColCount);              //规范型线性规划问题
   fAssistantDcxQ = new TDcxQuestion(fRowCount,fColCount);         //辅助线性规划问题

   fMatTranForm = new TMatrix(fRowCount,fColCount); //从规范型问题到原问题的变换矩阵

   fIxzDcxChannel = new TxzDcxChannel;   //修正单纯型算法通道(第一阶段)
   fIIxzDcxChannel = new TxzDcxChannel;  //修正单纯型算法通道(第二阶段)
   fILResult = new KTList<TxzDcx*>;
   fIILResult = new KTList<TxzDcx*>;


   SetGrids();
}
//---------------------------------------------------------------------------
void __fastcall Tfrm_main::FormClose(TObject *Sender, TCloseAction &Action)
{
   delete fDcxQ;
   delete fRuleDcxQ;              //规范型线性规划问题
   delete fAssistantDcxQ;         //辅助线性规划问题
   delete fMatTranForm;           //从规范型问题到原问题的变换矩阵

   //清空原来的数据
   for (fILResult->First();!fILResult->IsEof();fILResult->Next())
      delete fILResult->GetData();
   for (fIILResult->First();!fIILResult->IsEof();fIILResult->Next())
      delete fIILResult->GetData();

   delete fILResult;
   delete fIILResult;

   delete fIxzDcxChannel;   //修正单纯型算法通道(第一阶段)
   delete fIIxzDcxChannel;  //修正单纯型算法通道(第二阶段)
}
//---------------------------------------------------------------------------
//根据维数[fRowCount,fColCount]重新设置数据
void Tfrm_main::ResetData()
{
   fDcxQ->Reset(fRowCount,fColCount);
}
//---------------------------------------------------------------------------
//根据字符串珊格得到数据
bool Tfrm_main::GetData()
{
   int i;

   //系数矩阵
   if (!glb_GetData(fDcxQ->mMatA,sg_A,"A"))
      return false;

   //标号集I
   for (i=1;i<sg_I->RowCount;i++) {
      if (sg_I->Cells[1][i] == ">=")
         (*fDcxQ->mCVetI)(i) = 1;
      else if (sg_I->Cells[1][i] == "<=")
         (*fDcxQ->mCVetI)(i) = -1;
      else if (sg_I->Cells[1][i] == "=")
         (*fDcxQ->mCVetI)(i) = 0;
      else {
         glb_UserInfo("标号集I的数据元素I["+IntToStr(i)+"]不合法,必须为'='或者'>='或者'<='!");
         return false;
      }
   }

   //条件向量b
   if (!glb_GetCVetData(fDcxQ->mCVetb,sg_b,true,"b"))
      return false;

   //费用向量~c
   if (!glb_GetCVetData(fDcxQ->mCVetc,sg_c,false,"c"))
      return false;

   //符号约束sign
   for (i=1;i<sg_sign->ColCount;i++) {
      if (sg_sign->Cells[i][1] == ">=")
         (*fDcxQ->mCVetsign)(i) = 0;
      else if (sg_sign->Cells[i][1] == "")
         (*fDcxQ->mCVetsign)(i) = 1;
      else {
         glb_UserInfo("符号约束sign的数据元素sign["+IntToStr(i)+"]不合法,必须为空或者'>='!");
         return false;
      }
   }

   return true;
}
//---------------------------------------------------------------------------
//根据数据设置字符串珊格
void Tfrm_main::SetGrids()
{
   int i;

   //系数矩阵
   glb_SetGrid(fDcxQ->mMatA,sg_A);

   //标号集
   sg_I->RowCount = fRowCount + 1;
   sg_I->ColCount = 2;
   sg_I->Cells[0][0] = "("+IntToStr(fRowCount)+")";
   for (i=1;i<sg_I->RowCount;i++) {
      sg_I->Cells[0][i] = IntToStr(i);
      if ((*fDcxQ->mCVetI)(i) == 1)
        sg_I->Cells[1][i] = ">=";
      else if ((*fDcxQ->mCVetI)(i) == -1)
        sg_I->Cells[1][i] = "<=";
      else
        sg_I->Cells[1][i] = "=";
   }

   //条件向量b
   sg_b->RowCount = fRowCount + 1;
   sg_b->ColCount = 2;
   sg_b->Cells[0][0] = "("+IntToStr(fRowCount)+")";
   for (i=1;i<sg_b->RowCount;i++) {
      sg_b->Cells[0][i] = IntToStr(i);
      sg_b->Cells[1][i] = (*fDcxQ->mCVetb)(i);
   }

   //费用向量~c
   sg_c->RowCount = 2;
   sg_c->ColCount = fColCount + 1;
   sg_c->Cells[0][0] = "("+IntToStr(fColCount)+")";
   for (i=1;i<sg_c->ColCount;i++) {
      sg_c->Cells[i][0] = IntToStr(i);
      sg_c->Cells[i][1] = (*fDcxQ->mCVetc)(i);
   }

   //符号约束sign
   sg_sign->RowCount = 2;
   sg_sign->ColCount = fColCount + 1;
   sg_sign->Cells[0][0] = "("+IntToStr(fColCount)+")";
   for (i=1;i<sg_sign->ColCount;i++) {
      sg_sign->Cells[i][0] = IntToStr(i);
      if ((*fDcxQ->mCVetsign)(i) == 0)
        sg_sign->Cells[i][1] = ">=";
      else
        sg_sign->Cells[i][1] = "";
   }
}
//---------------------------------------------------------------------------
void __fastcall Tfrm_main::btn_resetClick(TObject *Sender)
{
   frm_reset->fRowCount = fDcxQ->mMatA->GetRowCount();
   frm_reset->fColCount = fDcxQ->mMatA->GetColCount();
   if (frm_reset->ShowModal() == mrOk) {
       fRowCount = frm_reset->fRowCount;
       fColCount = frm_reset->fColCount;
       ResetData();
       SetGrids();
   }
}
//---------------------------------------------------------------------------

void __fastcall Tfrm_main::btn_MetirxOpClick(TObject *Sender)
{
   //系数矩阵
   if (!glb_GetData(fDcxQ->mMatA,sg_A,"A"))
      return;

   //取得规范型
   fDcxQ->GenRule(fRuleDcxQ,fMatTranForm);

   //拷贝矩阵A
   delete frm_MatrixOp->fMatA;
   frm_MatrixOp->fMatA = new TMatrix(fRuleDcxQ->mMatA->GetRowCount(),fRuleDcxQ->mMatA->GetColCount());
   *frm_MatrixOp->fMatA = *fRuleDcxQ->mMatA;
   glb_SetGrid(frm_MatrixOp->fMatA,frm_MatrixOp->sg_A);
   glb_SetGrid(frm_MatrixOp->fMatB,frm_MatrixOp->sg_B);
   glb_SetGrid(frm_MatrixOp->fMatC,frm_MatrixOp->sg_C);

   frm_MatrixOp->Show();
}
//---------------------------------------------------------------------------
void __fastcall Tfrm_main::btn_xzDcxClick(TObject *Sender)
{
   //先得到数据
   if (!GetData())
      return;

   fdoRule = true;       //是否要变成规范型
   fdoFirst = true;

   if (!fDcxQ->IsRule()) {  //如果不是规范型
      //取得规范型
      fDcxQ->GenRule(fRuleDcxQ,fMatTranForm);
      fdoRule = true;
   }
   else {
      fdoRule = false;       //是否要变成规范型
      //取得规范型
      fDcxQ->GenRule(fRuleDcxQ,fMatTranForm);

      frm_xzDcx_Inputx->fCVetx = new TCVector(fRuleDcxQ->mMatA->GetColCount());
      glb_SetCVetGrid(frm_xzDcx_Inputx->fCVetx,frm_xzDcx_Inputx->sg_x,false);

      if (frm_xzDcx_Inputx->ShowModal() == mrCancel) {
         delete frm_xzDcx_Inputx->fCVetx;
         return;
      }
      delete frm_xzDcx_Inputx->fCVetx;

      if (frm_xzDcx_Inputx->rb_II->Checked) {
         fdoFirst = false;
      }
   }

   //如果是退化问题
   if (fRuleDcxQ->IsDegrade()) {
      glb_UserInfo("该线性规划问题是退化的线性规划问题,此单纯型方法无法求解.");
      return;
   }

   //如果需要进行第一阶段
   if (fdoFirst) {
      fRuleDcxQ->GenAssistant(fAssistantDcxQ);

      //提交数据,执行算法
      (*fIxzDcxChannel)<<(fAssistantDcxQ);

      //取得数据
      (*fIxzDcxChannel)>>fILResult;

      fILResult->Last();

      //如果辅助问题的目标函数值不为0
      if (fILResult->GetData()->GetValz0() != 0) {
         frm_xzDcx_display->Reset(fDcxQ,fRuleDcxQ,fdoRule,fAssistantDcxQ,fdoFirst,false,fILResult,fIILResult,fMatTranForm);
         frm_xzDcx_display->ShowModal();
         return;
      }

     //通过辅助问题取得规范型问题的一个初始基可行解
     //当前最优解
     TCVector lCVetx(fAssistantDcxQ->mCVetx->GetDimCount());
     unsigned int j;
     for (j=1,fILResult->GetData()->GetLB()->First();!fILResult->GetData()->GetLB()->IsEof();fILResult->GetData()->GetLB()->Next(),j++)
        lCVetx(fILResult->GetData()->GetLB()->GetData()) = (*fILResult->GetData()->GetCVetBx())(j);

     for (unsigned int i=1;i<=fRuleDcxQ->mCVetx->GetDimCount();i++)
        (*fRuleDcxQ->mCVetx)(i) = lCVetx(i);

   }

   //从一个初始基可行解求解规范型问题

   (*fIIxzDcxChannel)<<(fRuleDcxQ);    //提交数据,执行算法
   (*fIIxzDcxChannel)>>fIILResult;     //取得数据

    frm_xzDcx_display->Reset(fDcxQ,fRuleDcxQ,fdoRule,fAssistantDcxQ,fdoFirst,true,fILResult,fIILResult,fMatTranForm);

    //显示窗口
    frm_xzDcx_display->ShowModal();

}
//---------------------------------------------------------------------------
//读写文件
void __fastcall Tfrm_main::menu_saveClick(TObject *Sender)
{
   if (!GetData())
      return;

   if (dlg_save->Execute()) {
      TIniFile* lIniF_save = new TIniFile(dlg_save->FileName);

      lIniF_save->WriteString("Dim","RowCount",IntToStr(fRowCount));
      lIniF_save->WriteString("Dim","ColCount",IntToStr(fColCount));

      for (unsigned int i=1;i<=fDcxQ->mMatA->GetRowCount();i++)
         for (unsigned int j=1;j<=fDcxQ->mMatA->GetColCount();j++)
           lIniF_save->WriteString("MatA","MatA["+IntToStr(i)+","+IntToStr(j)+"]",(*fDcxQ->mMatA)(i,j));

      for (unsigned int i=1;i<=fDcxQ->mCVetI->GetDimCount();i++)
        lIniF_save->WriteString("CVetI","CVetI["+IntToStr(i)+"]",(*fDcxQ->mCVetI)(i));
      for (unsigned int i=1;i<=fDcxQ->mCVetb->GetDimCount();i++)
        lIniF_save->WriteString("CVetb","CVetb["+IntToStr(i)+"]",(*fDcxQ->mCVetb)(i));
      for (unsigned int i=1;i<=fDcxQ->mCVetc->GetDimCount();i++)
        lIniF_save->WriteString("CVetc","CVetc["+IntToStr(i)+"]",(*fDcxQ->mCVetc)(i));
      for (unsigned int i=1;i<=fDcxQ->mCVetsign->GetDimCount();i++)
        lIniF_save->WriteString("CVetsign","CVetsign["+IntToStr(i)+"]",(*fDcxQ->mCVetsign)(i));

      delete lIniF_save;  
   }
}
//---------------------------------------------------------------------------
void __fastcall Tfrm_main::menu_openClick(TObject *Sender)
{
   if (dlg_open->Execute()) {
      TIniFile* lIniF_open = new TIniFile(dlg_open->FileName);

      fRowCount = StrToInt(lIniF_open->ReadString("Dim","RowCount", "0"));
      fColCount = StrToInt(lIniF_open->ReadString("Dim","ColCount", "0"));
      ResetData();

      for (unsigned int i=1;i<=fDcxQ->mMatA->GetRowCount();i++)
         for (unsigned int j=1;j<=fDcxQ->mMatA->GetColCount();j++)
          (*fDcxQ->mMatA)(i,j) = lIniF_open->ReadString("MatA","MatA["+IntToStr(i)+","+IntToStr(j)+"]", "0");

      for (unsigned int i=1;i<=fDcxQ->mCVetI->GetDimCount();i++)
        (*fDcxQ->mCVetI)(i) = lIniF_open->ReadString("CVetI","CVetI["+IntToStr(i)+"]", "0");
      for (unsigned int i=1;i<=fDcxQ->mCVetb->GetDimCount();i++)
        (*fDcxQ->mCVetb)(i) = lIniF_open->ReadString("CVetb","CVetb["+IntToStr(i)+"]", "0");
      for (unsigned int i=1;i<=fDcxQ->mCVetc->GetDimCount();i++)
        (*fDcxQ->mCVetc)(i) = lIniF_open->ReadString("CVetc","CVetc["+IntToStr(i)+"]", "0");
      for (unsigned int i=1;i<=fDcxQ->mCVetsign->GetDimCount();i++)
        (*fDcxQ->mCVetsign)(i) = lIniF_open->ReadString("CVetsign","CVetsign["+IntToStr(i)+"]", "0");

      delete lIniF_open;  
   }

   SetGrids();
}
//---------------------------------------------------------------------------

void __fastcall Tfrm_main::menu_exitClick(TObject *Sender)
{
   Close();
}
//---------------------------------------------------------------------------

void __fastcall Tfrm_main::menu_aboutClick(TObject *Sender)
{
   ShellAbout(Handle,"","\n线性规划问题求解(V1.0)\nAll Rights Reverse\n98164236 黄可坤,98164237 黄舒怀.",NULL);
}
//---------------------------------------------------------------------------

void __fastcall Tfrm_main::menu_contentClick(TObject *Sender)
{
   frm_about->ShowModal();
}
//---------------------------------------------------------------------------

void __fastcall Tfrm_main::btn_ruleClick(TObject *Sender)
{
   //先得到数据
   if (!GetData())
      return;

   //取得规范型
   fDcxQ->GenRule(fRuleDcxQ,fMatTranForm);
   fRuleDcxQ->GenAssistant(fAssistantDcxQ);

   //刷新数据
   frm_xzDcx_display->ResetRule(fDcxQ,fRuleDcxQ,fAssistantDcxQ);

   //显示窗口
   frm_xzDcx_display->ShowModal();
}
//---------------------------------------------------------------------------