/*
用户窗口初始化
*/
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
//去除标题栏、窗口置顶
//setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
//设置窗口大小
//背景透明
setAttribute(Qt::WA_TranslucentBackground, true);
//播放音乐 加载音乐路径
LoadMusic();
//定时器设置
TimeStart();
//当前动作
nowAction = 1;
//加载图像
image.load("image/database");
//changeAction();
//窗口开始位置
resize(image.width(), image.height());
QDesktopWidget* desktop = QApplication::desktop();
move((desktop->width() - this->width()), 0);
}
void Newton::Make_bMat(InputData& inputData,
Solutions& currentPt,
WorkVariables& work,
ComputeTime& com)
{
TimeStart(START3);
if (bMat_type == SPARSE){
// set sparse_bMat zero
for (int iter=0 ; iter < sparse_bMat.NonZeroCount;++iter) {
sparse_bMat.sp_ele[iter] = 0.0;
}
compute_bMat_sparse_SDP(inputData,currentPt,work,com);
// compute_bMat_sparse_SOCP(inputData,currentPt,work,com);
compute_bMat_sparse_LP(inputData,currentPt,work,com);
} else {
bMat.setZero();
compute_bMat_dense_SDP(inputData,currentPt,work,com);
// compute_bMat_dense_SOCP(inputData,currentPt,work,com);
compute_bMat_dense_LP(inputData,currentPt,work,com);
}
// rMessage("bMat = ");
// bMat.display();
// sparse_bMat.display();
TimeEnd(END3);
com.makebMat += TimeCal(START3,END3);
}
void Newton::compute_DxMat(Solutions& currentPt,
WorkVariables& work,
ComputeTime& com)
{
TimeStart(START_DX);
// work.DLS1 = dX dZ Z^{-1}
Jal::ns_jordan_triple_product(work.DLS1,currentPt.xMat,DzMat,
currentPt.invzMat,work.DLS2);
// dX = R Z^{-1} - dX dZ Z^{-1}
Lal::let(DxMat,'=',r_zinvMat,'+',work.DLS1,&DMONE);
TimeEnd(END_DX);
TimeStart(START_SYMM);
Lal::getSymmetrize(DxMat);
TimeEnd(END_SYMM);
// rMessage("DxMat = ");
// DxMat.display();
com.makedX += TimeCal(START_DX,END_DX);
com.symmetriseDx += TimeCal(START_SYMM,END_SYMM);
}
bool Newton::compute_DyVec(Newton::WHICH_DIRECTION direction,
InputData& inputData,
Solutions& currentPt,
WorkVariables& work,
ComputeTime& com)
{
if (direction == PREDICTOR) {
TimeStart(START3_2);
if (bMat_type == SPARSE){
bool ret = Lal::getCholesky(sparse_bMat,diagonalIndex);
if (ret == SDPA_FAILURE) {
return SDPA_FAILURE;
}
} else {
bool ret = Lal::choleskyFactorWithAdjust(bMat);
if (ret == SDPA_FAILURE) {
return SDPA_FAILURE;
}
}
// rMessage("Cholesky of bMat = ");
// bMat.display();
// sparse_bMat.display();
TimeEnd(END3_2);
com.choleskybMat += TimeCal(START3_2,END3_2);
}
// bMat is already cholesky factorized.
TimeStart(START4);
if (bMat_type == SPARSE){
permuteVec(gVec,work.DV1);
Lal::let(work.DV2,'=',sparse_bMat,'/',work.DV1);
reverse_permuteVec(work.DV2,DyVec);
} else {
Lal::let(DyVec,'=',bMat,'/',gVec);
}
TimeEnd(END4);
com.solve += TimeCal(START4,END4);
// rMessage("DyVec = ");
// DyVec.display();
return SDPA_SUCCESS;
}
bool Newton::Mehrotra(Newton::WHICH_DIRECTION direction,
InputData& inputData,
Solutions& currentPt,
Residuals& currentRes,
AverageComplementarity& mu,
DirectionParameter& beta,
Switch& reduction,
Phase& phase,
WorkVariables& work,
ComputeTime& com)
{
// rMessage("xMat, yVec, zMat = ");
// currentPt.xMat.display();
// currentPt.yVec.display();
// currentPt.zMat.display();
Make_gVec(direction, inputData, currentPt, currentRes,
mu, beta, phase, work, com);
if (direction == PREDICTOR) {
Make_bMat(inputData, currentPt, work, com);
}
//rMessage("gVec, bMat = ");
// gVec.display();
// bMat.display();
// sparse_bMat.display(); //
// display_sparse_bMat(); // with reverse ordering
bool ret = compute_DyVec(direction, inputData, currentPt, work, com);
if (ret == SDPA_FAILURE) {
return SDPA_FAILURE;
}
// rMessage("cholesky factorization = ");
// sparse_bMat.display();
TimeStart(START5);
compute_DzMat(inputData, currentRes, phase, com);
compute_DxMat(currentPt, work, com);
TimeEnd(END5);
com.makedXdZ += TimeCal(START5,END5);
// rMessage("DxMat, DyVec, DzMat = ");
// DxMat.display();
// DyVec.display();
// DzMat.display();
return true;
}
void Newton::compute_DzMat(InputData& inputData,
Residuals& currentRes,
Phase& phase,
ComputeTime& com)
{
TimeStart(START_SUMDZ);
inputData.multi_plusToA(DyVec, DzMat);
Lal::let(DzMat,'=',DzMat,'*',&DMONE);
if (phase.value == SolveInfo:: pFEAS
|| phase.value == SolveInfo::noINFO) {
Lal::let(DzMat,'=',DzMat,'+',currentRes.dualMat);
}
TimeEnd(END_SUMDZ);
com.sumDz += TimeCal(START_SUMDZ,END_SUMDZ);
}
int main(void)
{
double d,dd;
MICRO_TIME tim;
TimeStart(&tim);
int i=1;
while(/*!kbhit()*/i<1e3)
{
d = microTime();
// usleep(1E6);
dd = microTime() - d;
//d = dd*(dd+1.0)/(dd-1.0);
printf("[%d] Time in microseconds: %lf = %lf s\n",i, dd,dd/1E6);
i++;
}
printf("%lf sec\n",TimeStop(&tim)/1E6);
return(0);
}
bool pinpal(char* dataFile, char* initFile, char* outFile,
char* paraFile, bool isInitFile, bool isInitSparse,
bool isDataSparse, bool isParameter,
Parameter::parameterType parameterType,
FILE* Display)
{
TimeStart(TOTAL_TIME_START1);
TimeStart(FILE_READ_START1);
ComputeTime com;
FILE* fpData = NULL;
FILE* fpOut = NULL;
if ((fpOut=fopen(outFile,"w"))==NULL) {
rError("Cannot open out file " << outFile);
}
Parameter param;
param.setDefaultParameter(parameterType);
if (isParameter) {
FILE* fpParameter = NULL;
if ((fpParameter=fopen(paraFile,"r"))==NULL) {
fprintf(Display,"Cannot open parameter file %s \n",
paraFile);
exit(0);
} else {
param.readFile(fpParameter);
fclose(fpParameter);
}
}
// param.display(Display,param.infPrint);
if ((fpData=fopen(dataFile,"r"))==NULL) {
rError("Cannot open data file " << dataFile);
}
char titleAndComment[LengthOfBuffer];
int m;
time_t ltime;
time( <ime );
fprintf(fpOut,"SDPA start at %s",ctime(<ime));
IO::read(fpData,fpOut,m,titleAndComment);
fprintf(fpOut,"data is %s\n",dataFile);
if (paraFile) {
fprintf(fpOut,"parameter is %s\n",paraFile);
}
if (initFile) {
fprintf(fpOut,"initial is %s\n",initFile);
}
fprintf(fpOut,"out is %s\n",outFile);
#if 1 // 2007/11/28 nakata for multi LP block
int SDP_nBlock, SOCP_nBlock,LP_nBlock, nBlock;
IO::read(fpData,nBlock);
int* blockStruct = NULL;
IO::BlockType* blockType = NULL;
int* blockNumber = NULL;
int* SDP_blockStruct = NULL;
int* SOCP_blockStruct = NULL;
NewArray(blockStruct,int,nBlock);
NewArray(blockType, IO::BlockType, nBlock);
NewArray(blockNumber,int,nBlock);
IO::read(fpData,nBlock,blockStruct);
SDP_nBlock = 0;
SOCP_nBlock = 0;
LP_nBlock = 0;
for (int l=0; l<nBlock; l++){
if (blockStruct[l] >= 2) {
blockType[l] = IO::btSDP;
blockNumber[l] = SDP_nBlock;
SDP_nBlock++;
} else if (blockStruct[l] < 0) {
blockType[l] = IO::btLP;
blockStruct[l] = - blockStruct[l];
blockNumber[l] = LP_nBlock;
LP_nBlock += blockStruct[l];
} else if (blockStruct[l] == 1) {
blockType[l] = IO::btLP;
blockNumber[l] = LP_nBlock;
LP_nBlock += blockStruct[l];
} else {
rError("block struct");
}
}
NewArray(SDP_blockStruct, int,SDP_nBlock);
NewArray(SOCP_blockStruct,int,SOCP_nBlock);
SDP_nBlock = 0;
for (int l=0; l<nBlock; l++){
if (blockType[l] == IO::btSDP) {
SDP_blockStruct[SDP_nBlock] = blockStruct[l];
SDP_nBlock++;
}
}
InputData inputData;
// rMessage("read input data: start");
IO::read(fpData, m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock,
nBlock, blockStruct, blockType, blockNumber,
inputData,isDataSparse);
// rMessage("read input data: end");
inputData.initialize_index(SDP_nBlock,SOCP_nBlock,LP_nBlock,com);
#else
int SDP_nBlock, SOCP_nBlock,LP_nBlock;
IO::read(fpData,SDP_nBlock,SOCP_nBlock,LP_nBlock);
int* SDP_blockStruct;
int* SOCP_blockStruct;
NewArray(SDP_blockStruct ,int,SDP_nBlock);
NewArray(SOCP_blockStruct,int,SOCP_nBlock);
IO::read(fpData,SDP_nBlock,SDP_blockStruct,
SOCP_nBlock,SOCP_blockStruct, LP_nBlock);
for (int l=0; l<SDP_nBlock-1; l++){
if (SDP_blockStruct[l] < 0){
rError("LP block must be in the last block");
}
}
// muriyari nyuuryoku saseru
if (SDP_blockStruct[SDP_nBlock-1] < 0){
LP_nBlock = - SDP_blockStruct[SDP_nBlock-1];
SDP_nBlock--;
}
InputData inputData;
IO::read(fpData, m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock,
inputData,isDataSparse);
inputData.initialize_index(SDP_nBlock,SOCP_nBlock,LP_nBlock,com);
#endif
fclose(fpData);
// inputData.display();
#if 1
TimeStart(FILE_CHANGE_START1);
// if possible , change C and A to Dense
inputData.C.changeToDense();
for (int k=0; k<m; ++k) {
inputData.A[k].changeToDense();
}
TimeEnd(FILE_CHANGE_END1);
com.FileChange += TimeCal(FILE_CHANGE_START1,
FILE_CHANGE_END1);
#endif
// rMessage("C = ");
// inputData.C.display(Display);
// for (int k=0; k<m; ++k) {
// rMessage("A["<<k<<"] = ");
// inputData.A[k].display(Display);
// }
// the end of initialization of C and A
Newton newton(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock);
int nBlock2 = SDP_nBlock+SOCP_nBlock+LP_nBlock;
// 2008/03/12 kazuhide nakata
Chordal chordal;
// rMessage("ordering bMat: start");
chordal.ordering_bMat(m, nBlock2, inputData, fpOut);
// rMessage("ordering bMat: end");
newton.initialize_bMat(m, chordal,inputData, fpOut);
chordal.terminate();
// rMessage("newton.computeFormula_SDP: start");
newton.computeFormula_SDP(inputData,0.0,KAPPA);
// rMessage("newton.computeFormula_SDP: end");
// set initial solutions.
Solutions currentPt;
WorkVariables work;
DenseLinearSpace initPt_xMat;
DenseLinearSpace initPt_zMat;
currentPt.initialize(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock,
param.lambdaStar,com);
work.initialize(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock);
if (isInitFile) {
FILE* fpInit = NULL;
if ((fpInit=fopen(initFile,"r"))==NULL) {
rError("Cannot open init file " << initFile);
}
IO::read(fpInit,currentPt.xMat,currentPt.yVec,currentPt.zMat,
SDP_nBlock,SDP_blockStruct,
SOCP_nBlock,SOCP_blockStruct,
LP_nBlock, nBlock, blockStruct,
blockType, blockNumber,
isInitSparse);
#if 0
rMessage("intial X = ");
currentPt.xMat.display();
rMessage("intial Z = ");
currentPt.zMat.display();
#endif
fclose(fpInit);
currentPt.computeInverse(work,com);
initPt_xMat.initialize(SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct,
LP_nBlock);
initPt_zMat.initialize(SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct,
LP_nBlock);
initPt_xMat.copyFrom(currentPt.xMat);
initPt_zMat.copyFrom(currentPt.zMat);
}
// rMessage("initial xMat = "); initPt_xMat.display(Display);
// rMessage("initial yVec = "); currentPt.yVec.display(Display);
// rMessage("initial zMat = "); initPt_zMat.display(Display);
// rMessage("current pt = "); currentPt.display(Display);
TimeEnd(FILE_READ_END1);
com.FileRead += TimeCal(FILE_READ_START1,
FILE_READ_END1);
// -------------------------------------------------------------
// the end of file read
// -------------------------------------------------------------
Residuals initRes(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct,
LP_nBlock, inputData, currentPt);
Residuals currentRes;
currentRes.copyFrom(initRes);
// rMessage("initial currentRes = ");
// currentRes.display(Display);
StepLength alpha;
DirectionParameter beta(param.betaStar);
Switch reduction(Switch::ON);
AverageComplementarity mu(param.lambdaStar);
// rMessage("init mu"); mu.display();
if (isInitFile) {
mu.initialize(currentPt);
}
RatioInitResCurrentRes theta(param, initRes);
SolveInfo solveInfo(inputData, currentPt,
mu.initial, param.omegaStar);
Phase phase(initRes, solveInfo, param, currentPt.nDim);
int pIteration = 0;
IO::printHeader(fpOut, Display);
// -----------------------------------------------------
// Here is MAINLOOP
// -----------------------------------------------------
TimeStart(MAIN_LOOP_START1);
// explicit maxIteration for debug
// param.maxIteration = 2;
while (phase.updateCheck(currentRes, solveInfo, param)
&& pIteration < param.maxIteration) {
// rMessage(" turn hajimari " << pIteration );
// Mehrotra's Predictor
TimeStart(MEHROTRA_PREDICTOR_START1);
// set variable of Mehrotra
reduction.MehrotraPredictor(phase);
beta.MehrotraPredictor(phase, reduction, param);
// rMessage("reduction = "); reduction.display();
// rMessage("phase = "); phase.display();
// rMessage("beta.predictor.value = " << beta.value);
// rMessage(" mu = " << mu.current);
// rMessage("currentPt = "); currentPt.display();
bool isSuccessCholesky;
isSuccessCholesky = newton.Mehrotra(Newton::PREDICTOR,
inputData, currentPt,
currentRes,
mu, beta, reduction,
phase,work,com);
if (isSuccessCholesky == false) {
break;
}
// rMessage("newton predictor = "); newton.display();
TimeEnd(MEHROTRA_PREDICTOR_END1);
com.Predictor += TimeCal(MEHROTRA_PREDICTOR_START1,
MEHROTRA_PREDICTOR_END1);
TimeStart(STEP_PRE_START1);
alpha.MehrotraPredictor(inputData, currentPt, phase, newton,
work, com);
// rMessage("alpha predictor = "); alpha.display();
TimeStart(STEP_PRE_END1);
com.StepPredictor += TimeCal(STEP_PRE_START1,STEP_PRE_END1);
// rMessage("alphaStar = " << param.alphaStar);
// Mehrotra's Corrector
// rMessage(" Corrector ");
TimeStart(CORRECTOR_START1);
beta.MehrotraCorrector(phase,alpha,currentPt, newton,mu,param);
// rMessage("beta corrector = " << beta.value);
#if 1 // 2007/08/29 kazuhide nakata
// add stopping criteria: objValPrimal < ObjValDual
// if ((pIteration > 10) &&
if (phase.value == SolveInfo::pdFEAS
&& ( beta.value> 5.0
|| solveInfo.objValPrimal < solveInfo.objValDual)){
break;
}
#endif
newton.Mehrotra(Newton::CORRECTOR,
inputData, currentPt, currentRes,
mu, beta, reduction, phase,work,com);
// rMessage("currentPt = "); currentPt.display();
// rMessage("newton corrector = "); newton.display();
TimeEnd(CORRECTOR_END1);
com.Corrector += TimeCal(CORRECTOR_START1,
CORRECTOR_END1);
TimeStart(CORRECTOR_STEP_START1);
alpha.MehrotraCorrector(inputData, currentPt, phase,
reduction, newton, mu, theta,
work, param, com);
// rMessage("alpha corrector = "); alpha.display();
TimeEnd(CORRECTOR_STEP_END1);
com.StepCorrector += TimeCal(CORRECTOR_STEP_START1,
CORRECTOR_STEP_END1);
// the end of Corrector
IO::printOneIteration(pIteration, mu, theta, solveInfo,
alpha, beta, fpOut, Display);
if (currentPt.update(alpha,newton,work,com)==false) {
// if step length is too short,
// we finish algorithm
rMessage("cannot move: step length is too short");
// memo by kazuhide nakata
// StepLength::MehrotraCorrector
// thetaMax*mu.initial -> thetamax*thetaMax*mu.initial
break;
}
// rMessage("currentPt = "); currentPt.display();
// rMessage("updated");
theta.update(reduction,alpha);
mu.update(currentPt);
currentRes.update(m,inputData, currentPt, com);
theta.update_exact(initRes,currentRes);
if (isInitFile) {
solveInfo.update(inputData, initPt_xMat, initPt_zMat, currentPt,
currentRes, mu, theta, param);
} else {
solveInfo.update(param.lambdaStar,inputData, currentPt,
currentRes, mu, theta, param);
}
// 2007/09/18 kazuhide nakata
// print information of ObjVal, residual, gap, complementarity
// solveInfo.check(inputData, currentPt,
// currentRes, mu, theta, param);
pIteration++;
} // end of MAIN_LOOP
TimeEnd(MAIN_LOOP_END1);
com.MainLoop = TimeCal(MAIN_LOOP_START1,
MAIN_LOOP_END1);
currentRes.compute(m,inputData,currentPt);
TimeEnd(TOTAL_TIME_END1);
com.TotalTime = TimeCal(TOTAL_TIME_START1,
TOTAL_TIME_END1);
#if REVERSE_PRIMAL_DUAL
phase.reverse();
#endif
#if 1
IO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
nBlock, blockStruct, blockType, blockNumber,
inputData, work, com, param, fpOut, Display);
#else
IO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
inputData, work, com, param, fpOut, Display);
#endif
// com.display(fpOut);
DeleteArray(SDP_blockStruct);
DeleteArray(blockStruct);
DeleteArray(blockType);
DeleteArray(blockNumber);
fprintf(Display, " main loop time = %.6f\n",com.MainLoop);
fprintf(fpOut, " main loop time = %.6f\n",com.MainLoop);
fprintf(Display, " total time = %.6f\n",com.TotalTime);
fprintf(fpOut, " total time = %.6f\n",com.TotalTime);
#if 0
fprintf(Display, "file check time = %.6f\n",com.FileCheck);
fprintf(fpOut, " file check time = %.6f\n",com.FileCheck);
fprintf(Display, "file change time = %.6f\n",com.FileChange);
fprintf(fpOut, " file change time = %.6f\n",com.FileChange);
#endif
fprintf(Display, "file read time = %.6f\n",com.FileRead);
fprintf(fpOut, " file read time = %.6f\n",com.FileRead);
fclose(fpOut);
#if 0
rMessage("memory release");
currentRes.terminate();
initRes.terminate();
currentPt.terminate();
initPt_xMat.terminate();
initPt_zMat.terminate();
newton.terminate();
work.terminate();
inputData.terminate();
com.~ComputeTime();
param.~Parameter();
alpha.~StepLength();
beta.~DirectionParameter();
reduction.~Switch();
mu.~AverageComplementarity();
theta.~RatioInitResCurrentRes();
solveInfo.~SolveInfo();
phase.~Phase();
#endif
return true;
}
void Newton::compute_bMat_dense_SDP(InputData& inputData,
Solutions& currentPt,
WorkVariables& work,
ComputeTime& com)
{
int m = currentPt.mDim;
int SDP_nBlock = inputData.SDP_nBlock;
for (int l=0; l<SDP_nBlock; ++l) {
DenseMatrix& xMat = currentPt.xMat.SDP_block[l];
DenseMatrix& invzMat = currentPt.invzMat.SDP_block[l];
DenseMatrix& work1 = work.DLS1.SDP_block[l];
DenseMatrix& work2 = work.DLS2.SDP_block[l];
for (int k1=0; k1<inputData.SDP_nConstraint[l]; k1++) {
int i = inputData.SDP_constraint[l][k1];
int ib = inputData.SDP_blockIndex[l][k1];
int inz = inputData.A[i].SDP_sp_block[ib].NonZeroEffect;
SparseMatrix& Ai = inputData.A[i].SDP_sp_block[ib];
FormulaType formula = useFormula[i*SDP_nBlock + l];
// ---------------------------------------------------
// formula = F3; // this is force change
// ---------------------------------------------------
TimeStart(B_NDIAG_START1);
TimeStart(B_NDIAG_START2);
bool hasF2Gcal = false;
if (formula==F1) {
Lal::let(work1,'=',Ai,'*',invzMat);
Lal::let(work2,'=',xMat,'*',work1);
} else if (formula==F2) {
Lal::let(work1,'=',Ai,'*',invzMat);
hasF2Gcal = false;
// Lal::let(gMat.ele[l],'=',xMat.ele[l],'*',fMat.ele[l]);
}
TimeEnd(B_NDIAG_END2);
com.B_PRE += TimeCal(B_NDIAG_START2,B_NDIAG_END2);
for (int k2=0; k2<inputData.SDP_nConstraint[l]; k2++) {
int j = inputData.SDP_constraint[l][k2];
int jb = inputData.SDP_blockIndex[l][k2];
int jnz = inputData.A[j].SDP_sp_block[jb].NonZeroEffect;
SparseMatrix& Aj = inputData.A[j].SDP_sp_block[jb];
// Select the formula A[i] or the formula A[j].
// Use formula that has more NonZeroEffects than others.
// We must calculate i==j.
if ((inz < jnz) || ( (inz == jnz) && (i<j))) {
continue;
}
double value;
switch (formula) {
case F1:
// rMessage("calF1");
calF1(value,work2,Aj);
break;
case F2:
// rMessage("calF2 ");
calF2(value,work1,work2,xMat,Aj,hasF2Gcal);
// calF1(value2,gMat.ele[l],A[j].ele[l]);
// rMessage("calF2: " << (value-value2));
break;
case F3:
// rMessage("calF3");
calF3(value,work1,work2,xMat,invzMat,Ai,Aj);
break;
} // end of switch
if (i!=j) {
bMat.de_ele[i+m*j] += value;
bMat.de_ele[j+m*i] += value;
} else {
bMat.de_ele[i+m*i] += value;
}
} // end of 'for (int j)'
TimeEnd(B_NDIAG_END1);
double t = TimeCal(B_NDIAG_START1,B_NDIAG_END1);
switch (formula) {
case F1: com.B_F1 += t; break;
case F2: com.B_F2 += t; break;
case F3: com.B_F3 += t; break;
}
} // end of 'for (int i)'
} // end of 'for (int l)'
}
void Newton::Make_gVec(Newton::WHICH_DIRECTION direction,
InputData& inputData,
Solutions& currentPt,
Residuals& currentRes,
AverageComplementarity& mu,
DirectionParameter& beta,
Phase& phase,
WorkVariables& work,
ComputeTime& com)
{
TimeStart(START1);
// rMessage("mu = " << mu.current);
// rMessage("beta = " << beta.value);
compute_rMat(direction,mu,beta,currentPt,work);
TimeEnd(END1);
com.makerMat += TimeCal(START1,END1);
TimeStart(START2);
TimeStart(START_GVEC_MUL);
// work.DLS1 = R Z^{-1} - X D Z^{-1} = r_zinv - X D Z^{-1}
if (phase.value == SolveInfo:: pFEAS
|| phase.value == SolveInfo::noINFO) {
if (direction == CORRECTOR) {
// x_rd_zinvMat is computed in PREDICTOR step
Lal::let(work.DLS1,'=',r_zinvMat,'+',x_rd_zinvMat,&DMONE);
} else {
// currentPt is infeasilbe, that is the residual
// dualMat is not 0.
// x_rd_zinvMat = X D Z^{-1}
Jal::ns_jordan_triple_product(x_rd_zinvMat,currentPt.xMat,
currentRes.dualMat,currentPt.invzMat,
work.DLS2);
Lal::let(work.DLS1,'=',r_zinvMat,'+',x_rd_zinvMat,&DMONE);
} // if (direction == CORRECTOR)
} else {
// dualMat == 0
work.DLS1.copyFrom(r_zinvMat);
}
// rMessage("work.DLS1");
// work.DLS1.display();
TimeEnd(END_GVEC_MUL);
com.makegVecMul += TimeCal(START_GVEC_MUL,END_GVEC_MUL);
inputData.multi_InnerProductToA(work.DLS1,gVec);
Lal::let(gVec,'=',gVec,'*',&DMONE);
// rMessage("gVec = ");
// gVec.display();
#if 0
if (phase.value == SolveInfo:: dFEAS
|| phase.value == SolveInfo::noINFO) {
#endif
Lal::let(gVec,'=',gVec,'+',currentRes.primalVec);
#if 0
}
#endif
TimeEnd(END2);
com.makegVec += TimeCal(START2,END2);
}
void Newton::compute_bMat_sparse_SDP(InputData& inputData,
Solutions& currentPt,
WorkVariables& work,
ComputeTime& com)
{
TimeStart(B_NDIAG_START1);
TimeStart(B_NDIAG_START2);
for (int l=0; l<SDP_nBlock; ++l) {
DenseMatrix& xMat = currentPt.xMat.SDP_block[l];
DenseMatrix& invzMat = currentPt.invzMat.SDP_block[l];
DenseMatrix& work1 = work.DLS1.SDP_block[l];
DenseMatrix& work2 = work.DLS2.SDP_block[l];
int previous_i = -1;
for (int iter = 0; iter < SDP_number[l]; iter++){
// TimeStart(B_NDIAG_START1);
int i = SDP_constraint1[l][iter];
int ib = SDP_blockIndex1[l][iter];
SparseMatrix& Ai = inputData.A[i].SDP_sp_block[ib];
FormulaType formula = useFormula[i*SDP_nBlock + l];
bool hasF2Gcal;
if (i != previous_i){
// ---------------------------------------------------
// formula = F3; // this is force change
// ---------------------------------------------------
TimeStart(B_NDIAG_START2);
hasF2Gcal = false;
if (formula==F1) {
Lal::let(work1,'=',Ai,'*',invzMat);
Lal::let(work2,'=',xMat,'*',work1);
} else if (formula==F2) {
Lal::let(work1,'=',Ai,'*',invzMat);
hasF2Gcal = false;
// Lal::let(gMat.ele[l],'=',xMat.ele[l],'*',fMat.ele[l]);
}
TimeEnd(B_NDIAG_END2);
com.B_PRE += TimeCal(B_NDIAG_START2,B_NDIAG_END2);
}
int j = SDP_constraint2[l][iter];
int jb = SDP_blockIndex2[l][iter];
SparseMatrix& Aj = inputData.A[j].SDP_sp_block[jb];
double value;
switch (formula) {
case F1:
// rMessage("calF1");
calF1(value,work2,Aj);
break;
case F2:
// rMessage("calF2 ");
calF2(value,work1,work2,xMat,Aj,hasF2Gcal);
// calF1(value2,gMat.ele[l],A[j].ele[l]);
// rMessage("calF2: " << (value-value2));
break;
case F3:
// rMessage("calF3");
calF3(value,work1,work2,xMat,invzMat,Ai,Aj);
break;
} // end of switch
sparse_bMat.sp_ele[SDP_location_sparse_bMat[l][iter]] += value;
previous_i = i;
} // end of 'for (int index)'
#if 0
TimeEnd(B_NDIAG_END1);
double t = TimeCal(B_NDIAG_START1,B_NDIAG_END1);
switch (formula) {
case F1: com.B_F1 += t; break;
case F2: com.B_F2 += t; break;
case F3: com.B_F3 += t; break;
}
#endif
} // end of 'for (int l)'
}
void MPointCreator::ProcessCurve(const SimpleLine& rCurve,
const Interval<Instant> TimeInterval,
double dCurveLength)
{
double dLength = dCurveLength < 0.0 ?
MMUtil::CalcLengthCurve(&rCurve, m_dNetworkScale) :
dCurveLength;
if (AlmostEqual(dLength, 0.0))
{
AttributePtr<UPoint> pUPoint(new UPoint(TimeInterval,
rCurve.StartPoint(),
rCurve.EndPoint()));
m_pResMPoint->Add(*pUPoint);
return;
}
DateTime Duration = TimeInterval.end - TimeInterval.start;
Duration.Abs();
const bool bStartsSmaller = rCurve.GetStartSmaller();
Instant TimeStart(TimeInterval.start);
const int nHalfSegments = rCurve.Size();
if (nHalfSegments <= 0)
return;
assert(nHalfSegments % 2 == 0);
LRS lrs(bStartsSmaller ? 0.0 : rCurve.Length(), 0);
int lrsPosAkt = 0;
if (!const_cast<SimpleLine&>(rCurve).Get(lrs, lrsPosAkt))
{
assert(false);
return;
}
LRS lrsAkt;
rCurve.Get(lrsPosAkt, lrsAkt);
HalfSegment hs;
rCurve.Get(lrsAkt.hsPos, hs);
double dLengthHS = MMUtil::CalcDistance(hs.GetLeftPoint(),
hs.GetRightPoint(),
m_dNetworkScale);
DateTime TimeEnd = TimeStart +
DateTime(datetime::durationtype,
(uint64_t)(((Duration.millisecondsToNull()
/ dLength) * dLengthHS) + .5));
Interval<Instant> TimeIntervalAkt(TimeStart, TimeEnd,
true, TimeStart == TimeEnd);
Point Pt1(false);
Point Pt2(false);
if (const_cast<SimpleLine&>(rCurve).StartsSmaller())
{
Pt1 = hs.GetDomPoint();
Pt2 = hs.GetSecPoint();
}
else
{
Pt1 = hs.GetSecPoint();
Pt2 = hs.GetDomPoint();
}
AttributePtr<UPoint> pUPoint(new UPoint(TimeIntervalAkt, Pt1, Pt2));
m_pResMPoint->Add(*pUPoint);
TimeStart = TimeEnd;
if (bStartsSmaller)
++lrsPosAkt;
else
--lrsPosAkt;
while (lrsPosAkt >= 0 && lrsPosAkt < nHalfSegments / 2)
{
rCurve.Get(lrsPosAkt, lrsAkt);
rCurve.Get(lrsAkt.hsPos, hs);
double dLengthHS = MMUtil::CalcDistance(hs.GetLeftPoint(),
hs.GetRightPoint(),
m_dNetworkScale);
DateTime TimeEnd = TimeStart +
DateTime(datetime::durationtype,
(uint64_t)(((Duration.millisecondsToNull()
/ dLength) * dLengthHS) + .5));
Interval<Instant> TimeIntervalAkt(TimeStart, TimeEnd,
true, TimeStart == TimeEnd);
if (AlmostEqual(Pt2, hs.GetDomPoint()))
{
Pt1 = hs.GetDomPoint();
Pt2 = hs.GetSecPoint();
}
else
{
Pt1 = hs.GetSecPoint();
Pt2 = hs.GetDomPoint();
}
/*if (AlmostEqual(Pt2, rCurve.EndPoint()))
TimeStart = TimeInterval.end;*/
AttributePtr<UPoint> pUPoint(new UPoint(TimeIntervalAkt, Pt1, Pt2));
m_pResMPoint->Add(*pUPoint);
TimeStart = TimeEnd;
if (bStartsSmaller)
++lrsPosAkt;
else
--lrsPosAkt;
}
}
