int main(void) {
//---------------------------------------------------------------------------------
tblu = bluCreate();
initRes();
bsp = *((bluSprite*)tblu->System_ResourceFactory());
tblu->Input_Init();
tblu->GFX_Initiate();
tblu->GFX_LDSprite(&bsp);
tblu->GFX_InitAnimationFrames(&tban, 2);
tblu->GFX_AddAnimationFrame(&tban, 0, sgunTiles, sgunPal, sgunTilesLen, sgunPalLen);
tblu->GFX_AddAnimationFrame(&tban, 1, sgunTiles+512, sgunPal, sgunTilesLen, sgunPalLen);
tblu->System_SetFunc(FrameProc, BLUFRAMFUNC);
consoleDemoInit(); //setup the sub screen for printing
tblu->System_Start();
tblu->GFX_Init3DDevice();
while(1){
DrawGLScene();
glFlush(0);
}
/* tblu->Release();
while(1) {
touchRead(&touch);
iprintf("Touch y = %04i, %04i\n", touch.rawy, touch.py);
swiWaitForVBlank();
}
*/ return 0;
}
BoxGrid::BoxGrid(const Mesh & mesh,const int res,string filename)
{
initRes(res);
if(exists(filename))
initFromFile(filename);
else
initVoxels(mesh,res);
initStructure();
compute();
}
void little::init(HINSTANCE hInst)
{
m_hInst = hInst;
initWindow();
initGdiplus();
initRes();
initUrl();
m_hWorkThread = nullptr;
m_hSuperviseThread = nullptr;
m_hScreenThread = nullptr;
}
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;
}
bool pinpal(char* dataFile, char* initFile, char* outFile,
char* paraFile, bool isInitFile, bool isInitSparse,
bool isDataSparse, bool isParameter,
rParameter::parameterType parameterType,
FILE* Display)
{
rTimeStart(TOTAL_TIME_START1);
rTimeStart(FILE_READ_START1);
rComputeTime com;
FILE* fpData = NULL;
FILE* fpOut = NULL;
if ((fpOut=fopen(outFile,"w"))==NULL) {
rError("Cannot open out file " << outFile);
}
rParameter 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);
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));
rIO::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);
int nBlock;
rIO::read(fpData,nBlock);
int* blockStruct = NULL;
blockStruct = new int[nBlock];
if (blockStruct==NULL) {
rError("Memory exhausted about blockStruct");
}
rIO::read(fpData,nBlock,blockStruct);
int nDim = 0;
for (int l=0; l<nBlock; ++l) {
nDim += abs(blockStruct[l]);
}
// rMessage("b has not been read yet , m = " << m);
rVector b(m);
rIO::read(fpData,b);
// rMessage("b has been read");
rBlockSparseMatrix C;
rBlockSparseMatrix* A = NULL;
A = new rBlockSparseMatrix[m];
if (A==NULL) {
rError("Memory exhausted about blockStruct");
}
long position = ftell(fpData);
// C,A must be accessed "twice".
// count numbers of elements of C and A
int* CNonZeroCount = NULL;
CNonZeroCount = new int[nBlock];
if (CNonZeroCount==NULL) {
rError("Memory exhausted about blockStruct");
}
int* ANonZeroCount = NULL;
ANonZeroCount = new int[nBlock*m];
if (ANonZeroCount==NULL) {
rError("Memory exhausted about blockStruct");
}
// initialize C and A
rIO::read(fpData,m,nBlock,blockStruct,
CNonZeroCount,ANonZeroCount,isDataSparse);
// rMessage(" C and A count over");
C.initialize(nBlock,blockStruct);
for (int l=0; l<nBlock; ++l) {
int size = blockStruct[l];
if (size > 0) {
C.ele[l].initialize(size,size,rSparseMatrix::SPARSE,
CNonZeroCount[l]);
} else {
C.ele[l].initialize(-size,-size,rSparseMatrix::DIAGONAL,
-size);
}
}
for (int k=0; k<m; ++k) {
A[k].initialize(nBlock,blockStruct);
for (int l=0; l<nBlock; ++l) {
int size = blockStruct[l];
if (size > 0) {
A[k].ele[l].initialize(size,size,rSparseMatrix::SPARSE,
ANonZeroCount[k*nBlock+l]);
} else {
A[k].ele[l].initialize(-size,-size,rSparseMatrix::DIAGONAL,
-size);
}
}
}
delete[] CNonZeroCount;
CNonZeroCount = NULL;
delete[] ANonZeroCount;
ANonZeroCount = NULL;
// rMessage(" C and A initialize over");
rIO::read(fpData, C, A, m, nBlock, blockStruct, position, isDataSparse);
// rMessage(" C and A have been read");
fclose(fpData);
#if 0
fprintf(Display,"C = \n");
C.display(Display);
for (int k=0; k<m; ++k) {
fprintf(Display,"A[%d] = \n",k);
A[k].display(Display);
}
#endif
#if 0
// write C and A in SDPA sparse data format to file
ofstream output;
output.open("dumped.rsdpa.dat-s");
if (output.fail()) {
rError("Cannot Open dumped.rsdpa.dat-s");
}
output << m << endl;
output << nBlock << endl;
for (l = 0; l<nBlock ; ++l) {
output << blockStruct[l] << " " ;
}
output << endl;
for (k=0; k<m; ++k) {
output << b.ele[k] << " ";
}
output << endl;
int index=0;
for (l=0; l<nBlock; ++l) {
switch (C.ele[l].Sp_De_Di) {
case rSparseMatrix::SPARSE:
for (index = 0; index < C.ele[l].NonZeroCount; ++index) {
int i = C.ele[l].row_index[index];
int j = C.ele[l].column_index[index];
double value = C.ele[l].sp_ele[index];
if (value!=0.0) {
output << "0 " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< -value << endl;
}
}
break;
case rSparseMatrix::DENSE:
break;
case rSparseMatrix::DIAGONAL:
for (int index = 0; index < C.ele[l].nRow; ++index) {
double value = C.ele[l].di_ele[index];
if (value!=0.0) {
output << "0 " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< -value << endl;
}
}
break;
} // end of switch
}// end of 'for (int l)'
for (k=0; k<m; ++k) {
for (int l=0; l<nBlock; ++l) {
switch (A[k].ele[l].Sp_De_Di) {
case rSparseMatrix::SPARSE:
for (index = 0; index < A[k].ele[l].NonZeroCount; ++index) {
int i = A[k].ele[l].row_index[index];
int j = A[k].ele[l].column_index[index];
double value = A[k].ele[l].sp_ele[index];
if (value!=0.0) {
output << k+1 << " " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< value << endl;
}
}
break;
case rSparseMatrix::DENSE:
break;
case rSparseMatrix::DIAGONAL:
for (int index = 0; index < A[k].ele[l].nRow; ++index) {
double value = A[k].ele[l].di_ele[index];
if (value!=0.0) {
output << k+1 << " " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< value << endl;
}
}
break;
} // end of switch
} // end of 'for (int l)'
} // end of 'for (int k)'
output.close();
#endif
#if 0
rTimeStart(FILE_CHECK_START1);
// check whether C,A are symmetric or not.
int lin,iin,jin;
if (C.sortSparseIndex(lin,iin,jin)==FAILURE) {
fprintf(Display,"C is not symmetric, block %d,"
"(%d,%d) ", lin+1,iin+1,jin+1);
exit(0);
}
for (int k=0; k<m; ++k) {
if (A[k].sortSparseIndex(lin,iin,jin)==FAILURE) {
fprintf(Display,"A[%d] is not symmetric, block %d,"
"(%d,%d) ", k+1,lin+1,iin+1,jin+1);
exit(0);
}
}
rTimeEnd(FILE_CHECK_END1);
com.FileCheck += rTimeCal(FILE_CHECK_START1,
FILE_CHECK_END1);
#endif
#if 1
rTimeStart(FILE_CHANGE_START1);
// if possible , change C and A to Dense
C.changeToDense();
for (int k=0; k<m; ++k) {
A[k].changeToDense();
}
rTimeEnd(FILE_CHANGE_END1);
com.FileChange += rTimeCal(FILE_CHANGE_START1,
FILE_CHANGE_END1);
#endif
// rMessage("C = ");
// C.display(Display);
// for (int k=0; k<m; ++k) {
// rMessage("A["<<k<<"] = ");
// A[k].display(Display);
// }
// the end of initialization of C and A
// set initial solutions.
rSolutions initPt;
rSolutions currentPt;
if (isInitFile) {
initPt.initializeZero(m,nBlock,blockStruct,com);
FILE* fpInit = NULL;
if ((fpInit=fopen(initFile,"r"))==NULL) {
rError("Cannot open init file " << initFile);
}
rIO::read(fpInit,initPt.xMat,initPt.yVec,initPt.zMat, nBlock,
blockStruct, isInitSparse);
fclose(fpInit);
initPt.initializeResetup(m,nBlock,blockStruct,com);
currentPt.copyFrom(initPt);
} else {
initPt.initialize(m,nBlock,blockStruct,param.lambdaStar,com);
currentPt.initialize(m,nBlock,blockStruct,param.lambdaStar,com);
}
// rMessage("initial pt = ");
// initPt.display(Display);
// rMessage("current pt = ");
// currentPt.display(Display);
rTimeEnd(FILE_READ_END1);
com.FileRead += rTimeCal(FILE_READ_START1,
FILE_READ_END1);
// -------------------------------------------------------------
// the end of file read
// -------------------------------------------------------------
rResiduals initRes(m, nBlock, blockStruct, b, C, A, currentPt);
rResiduals currentRes;
currentRes.copyFrom(initRes);
// rMessage("initial currentRes = ");
// currentRes.display(Display);
rNewton newton(m, nBlock, blockStruct);
newton.computeFormula(m,A,0.0,KAPPA);
rStepLength alpha(1.0,1.0,nBlock, blockStruct);
rDirectionParameter beta(param.betaStar);
rSwitch reduction(rSwitch::ON);
rAverageComplementarity mu(param.lambdaStar);
rLanczos lanczos(nBlock,blockStruct);
// rMessage("init mu");
// mu.display();
if (isInitFile) {
mu.initialize(nDim, initPt);
}
rRatioInitResCurrentRes theta(param, initRes);
rSolveInfo solveInfo(nDim, b, C, A, initPt, mu.initial,
param.omegaStar);
rPhase phase(initRes, solveInfo, param, nDim);
int pIteration = 0;
rIO::printHeader(fpOut, Display);
// -----------------------------------------------------
// Here is MAINLOOP
// -----------------------------------------------------
rTimeStart(MAIN_LOOP_START1);
// explicit maxIteration
// param.maxIteration = 2;
while (phase.updateCheck(currentRes, solveInfo, param)
&& pIteration < param.maxIteration) {
// rMessage(" turn hajimari " << pIteration );
// Mehrotra's Predictor
rTimeStart(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("xMat = ");
// currentPt.xMat.display();
// rMessage("zMat = ");
// currentPt.zMat.display();
// rMessage(" mu = " << mu.current);
bool isSuccessCholesky;
isSuccessCholesky = newton.Mehrotra(rNewton::PREDICTOR,
m, A, C, mu,
beta, reduction,
phase, currentPt,
currentRes, com);
if (isSuccessCholesky == false) {
break;
}
// rMessage("newton predictor = ");
// newton.display();
// rMessage("newton Dy predictor = ");
// newton.DyVec.display();
// newton.bMat.display();
rTimeEnd(MEHROTRA_PREDICTOR_END1);
com.Predictor += rTimeCal(MEHROTRA_PREDICTOR_START1,
MEHROTRA_PREDICTOR_END1);
rTimeStart(STEP_PRE_START1);
alpha.MehrotraPredictor(b,C,A, currentPt, phase, newton,
lanczos, com);
// rMessage("xMat = ");
// currentPt.xMat.display();
// rMessage("zMat = ");
// currentPt.zMat.display();
// rMessage("alpha predictor = ");
// alpha.display();
// phase.display();
// rMessage("newton predictor = ");
// newton.display();
// rMessage("currentPt = ");
// currentPt.display();
rTimeStart(STEP_PRE_END1);
com.StepPredictor += rTimeCal(STEP_PRE_START1,STEP_PRE_END1);
// rMessage("alphaStar = " << param.alphaStar);
// Mehrotra's Corrector
// rMessage(" Corrector ");
rTimeStart(CORRECTOR_START1);
beta.MehrotraCorrector(nDim,phase,alpha,currentPt,
newton,mu,param);
// rMessage("beta corrector = " << beta.value);
newton.Mehrotra(rNewton::CORRECTOR,m,A,C,mu,beta,reduction,
phase, currentPt, currentRes, com);
// rMessage("currentPt = ");
// currentPt.display();
// rMessage("newton corrector = ");
// newton.display();
// rMessage("newton Dy corrector = ");
// newton.DyVec.display();
rTimeEnd(CORRECTOR_END1);
com.Corrector += rTimeCal(CORRECTOR_START1,
CORRECTOR_END1);
rTimeStart(CORRECTOR_STEP_START1);
alpha.MehrotraCorrector(nDim, b, C, A, currentPt, phase,
reduction, newton, mu, theta,
lanczos, param, com);
// rMessage("alpha corrector = ");
// alpha.display();
rTimeEnd(CORRECTOR_STEP_END1);
com.StepCorrector += rTimeCal(CORRECTOR_STEP_START1,
CORRECTOR_STEP_END1);
// the end of Corrector
rIO::printOneIteration(pIteration, mu, theta, solveInfo,
alpha, beta, currentRes, fpOut, Display);
if (currentPt.update(alpha,newton,com)==false) {
// if step length is too short,
// we finish algorithm
rMessage("cannot move");
pIteration++;
break;
}
// rMessage("currentPt = ");
// currentPt.display();
// rMessage("newton = ");
// newton.display();
// rMessage("updated");
theta.update(reduction,alpha);
mu.update(nDim,currentPt);
currentRes.update(m,nBlock,blockStruct,b,C,A,
initRes, theta, currentPt, phase, mu,com);
theta.update_exact(initRes,currentRes);
solveInfo.update(nDim, b, C, initPt, currentPt,
currentRes, mu, theta, param);
pIteration++;
} // end of MAIN_LOOP
rTimeEnd(MAIN_LOOP_END1);
com.MainLoop = rTimeCal(MAIN_LOOP_START1,
MAIN_LOOP_END1);
currentPt.update_last(com);
currentRes.compute(m,nBlock,blockStruct,b,C,A,currentPt,mu);
rTimeEnd(TOTAL_TIME_END1);
com.TotalTime = rTimeCal(TOTAL_TIME_START1,
TOTAL_TIME_END1);
#if REVERSE_PRIMAL_DUAL
phase.reverse();
#endif
#if 1
rIO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
nDim, b, C, A, com, param, fpOut, Display);
#endif
// com.display(fpOut);
if (blockStruct) {
delete[] blockStruct;
blockStruct = NULL;
}
C.~rBlockSparseMatrix();
for (int k=0; k<m; ++k) {
A[k].~rBlockSparseMatrix();
}
delete[] A;
A = NULL;
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);
return true;
}
int main(int argc, char* argv[])
{
std::shared_ptr<Empty> blank;
std::shared_ptr<Program> prg(new Program());
std::shared_ptr<SharedDecl> shDecl1(new SharedDecl("y", blank));
prg->Add(shDecl1);
std::shared_ptr<Node> initX(new Atom("2"));
std::shared_ptr<SharedDecl> shDecl2(new SharedDecl("x", initX));
prg->Add(shDecl2);
std::shared_ptr<Sub> sub1(new Sub("Main"));
sub1->AddParam("a");
sub1->AddParam("b");
prg->Add(sub1);
std::shared_ptr<Atom> atomA(new Atom("a"));
std::shared_ptr<Atom> atomB(new Atom("b"));
std::shared_ptr<BinaryOp> initRes(new BinaryOp("add", atomA, atomB));
std::shared_ptr<VarDecl> resDecl(new VarDecl("res", initRes));
sub1->Add(resDecl);
std::shared_ptr<Atom> atom3i(new Atom("3"));
std::shared_ptr<Atom> atom5i(new Atom("5"));
std::shared_ptr<BinaryOp> newParam(new BinaryOp("add", atom3i, atom5i));
std::shared_ptr<Allocation> allocat(new Allocation(newParam));
std::shared_ptr<Atom> atomArr(new Atom("arr"));
std::shared_ptr<Assignation> asignNew3(new Assignation(atomArr, allocat));
sub1->Add(asignNew3);
std::shared_ptr<Atom> atomArrBis(new Atom("arr"));
std::shared_ptr<Deallocation> deallocat(new Deallocation(atomArrBis));
sub1->Add(deallocat);
std::shared_ptr<Atom> atomC(new Atom("res"));
std::shared_ptr<BinaryOp> subCsumAB(new BinaryOp("substract", atomC, initRes));
std::shared_ptr<Assignation> incC(new Assignation(atomC, subCsumAB));
sub1->Add(incC);
std::shared_ptr<Atom> atom0(new Atom("0"));
std::shared_ptr<BinaryOp> cond1cond(new BinaryOp("equals", atomC, atom0));
std::shared_ptr<If> cond1(new If(cond1cond, "10", "20"));
sub1->Add(cond1);
std::shared_ptr<Atom> atom1(new Atom("1"));
std::shared_ptr<Atom> atom10(new Atom("10"));
std::shared_ptr<For> for1(new For("i", atom1, atom10, atom1));
sub1->Add(for1);
std::shared_ptr<BinaryOp> addC1(new BinaryOp("add", atomC, atom1));
std::shared_ptr<Assignation> incResActually(new Assignation(atomC, addC1));
for1->Add(incResActually);
std::shared_ptr<Loop> loop1(new Loop(cond1cond));
loop1->Add(for1); // don't double reference ever in practice...
loop1->Add(addC1);
sub1->Add(loop1);
std::shared_ptr<Call> call1(new Call("testFun", ""));
call1->AddParam(atomA);
call1->AddParam(addC1);
sub1->Add(call1);
std::shared_ptr<Return> ret1(new Return(atom0));
sub1->Add(ret1);
XMLDumpVisitor v;
prg->Accept(&v);
return 0;
}
GameManager::GameManager() {
hero=nullptr;
initRes();
initPhysicsWorld(GRAVITY);
}
