/* ------------------------------------------------------------- This file is a component of SDPA Copyright (C) 2004-2013 SDPA Project This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ------------------------------------------------------------- */ #ifndef __sdpa_newton_h__ #define __sdpa_newton_h__ #include "sdpa_chordal.h" // #include #define SparseCholesky 1 namespace sdpa { class Newton; class Solutions; class InputData; class Residuals; class ComputeTime; class Parameter; class StepLength; class DirectionParameter; class Switch; class RatioInitResCurrentRes; class SolveInfo; class Phase; class AverageComplementarity; class Newton { public: enum bMat_Sp_De {SPARSE, DENSE}; bMat_Sp_De bMat_type; SparseMatrix sparse_bMat; DenseMatrix bMat; // the coefficent of Schur complement Vector gVec; // the right hand side of Schur complement // Caution: // if SDPA doesn't use sparse bMat, following variables are indefinite. // // nBlock : number of block // nConstraint[k]: number of combination of nonzero matrices in k-th block // when A[k].block[i] and A[k].block[j] are nonzero matrices, // i <-> constraint1[k][t] // j <-> constraint2[k][t] // A[k].block[i] <-> A[k].sp_block[blockIndex1[k][t]] // A[k].block[j] <-> A[k].sp_block[blockIndex2[k][t]] // B_{ij} <-> sparse_bMat.sp_ele[location_sparse_bMat[k][t]] int SDP_nBlock; int* SDP_number; int** SDP_constraint1; int** SDP_constraint2; int** SDP_blockIndex1; int** SDP_blockIndex2; int** SDP_location_sparse_bMat; int* SDP_nStartIndex2; // start new j&jb from this index int** SDP_startIndex2; // start new j&jb from this index int LP_nBlock; int* LP_number; int** LP_constraint1; int** LP_constraint2; int** LP_blockIndex1; int** LP_blockIndex2; int** LP_location_sparse_bMat; int* LP_nStartIndex2; // start new j&jb from this index int** LP_startIndex2; // start new j&jb from this index // from index of aggrigate sparsity pattern to index of sparse_bMat // B_{ii} <-> sparse_bMat[diagonalIndex[i]] int* diagonalIndex; // B_{ij} for all i is between diagonalIndex[j] and rowStartIndex[j+1] Newton(); Newton(int m, BlockStruct& bs); ~Newton(); void initialize(int m, BlockStruct& bs); void finalize(); void initialize_dense_bMat(int m); // 2008/03/12 kazuhide nakata void initialize_sparse_bMat(int m); // 2008/03/12 kazuhide nakata void initialize_bMat(int m, Chordal& chordal, InputData& inputData, FILE* Display, FILE* fpOut); int binarySearchIndex(int i, int j); void make_aggrigateIndex_SDP(InputData& inputData); void make_aggrigateIndex_LP(InputData& inputData); void make_aggrigateIndex(InputData& inputData); enum WHICH_DIRECTION {PREDICTOR, CORRECTOR}; void compute_bMatgVec_dense(InputData& inputData, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Phase& phase, ComputeTime& com); static pthread_mutex_t job_mutex; static int Column_Number; static int Column_NumberDx; void compute_bMatgVec_dense_threads(InputData& inputData, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Phase& phase, ComputeTime& com); static void* compute_bMatgVec_dense_threads_SDP(void* arg); void compute_bMatgVec_sparse(InputData& inputData, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Phase& phase, ComputeTime& com); void compute_bMatgVec_sparse_threads(InputData& inputData, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Phase& phase, ComputeTime& com); static void* compute_bMatgVec_sparse_threads_SDP(void* arg); void Make_bMatgVec(InputData& inputData, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Phase& phase, ComputeTime& com); bool compute_DyVec(Newton::WHICH_DIRECTION direction, int m, InputData& inputData, Chordal& chordal, Solutions& currentPt, ComputeTime& com, FILE* Display, FILE* fpOut); void compute_DzMat(InputData& inputData, Solutions& currentPt, Residuals& currentRes, Phase& phase, ComputeTime& com); void compute_DxMat(Solutions& currentPt, AverageComplementarity& mu, DirectionParameter& beta, ComputeTime& com); void compute_DxMat_threads(Solutions& currentPt, AverageComplementarity& mu, DirectionParameter& beta, ComputeTime& com); static void* compute_DxMat_threads_SDP(void* arg); bool Mehrotra(WHICH_DIRECTION direction, int m, InputData& inputData, Chordal& chordal, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Switch& reduction, Phase& phase, ComputeTime& com, FILE* Display, FILE* fpOut); void checkDirection(int m, InputData& inputData, Solutions& currentPt, Residuals& currentRes, AverageComplementarity& mu, DirectionParameter& beta, Switch& reduction, Phase& phase, ComputeTime& com, FILE* Display, FILE* fpOut); void display(FILE* fpout=stdout); void display_index(FILE* fpout=stdout); void display_sparse_bMat(FILE* fpout=stdout); int NUM_THREADS; void setNumThreads(FILE* Display, FILE* fpOut, int NumThreads=0); }; typedef struct _thread_arg { int l; int m; double target_mu; int thread_num; InputData* addr_inputData; CholmodMatrix* addr_cholmodMatrix; DenseMatrix* addr_bMat; Vector* addr_gVec; Phase* addr_phase; } thread_arg_t; typedef struct _thread_arg_s { int l; int m; double target_mu; int thread_num; InputData* addr_inputData; CholmodMatrix* addr_cholmodMatrix; SparseMatrix* addr_sparse_bMat; Vector* addr_gVec; Phase* addr_phase; Newton* addr_newton; } thread_arg_s; typedef struct _thread_DX { int l; int thread_num; double target_mu; CholmodMatrix* addr_cholmodMatrix; OrderingMatrix* addr_order; } thread_DX_t; } // end of namespace 'sdpa' #endif // __sdpa_newton_h__