int con_branching()
{
CONSTRAINT *row0,*row1;
double old_lowerb = lowerb;
#ifdef STAMP
std::cout << " >>>>>>>>>>>>> constraint branching " << std::endl;
if(branchs==0) write_sol(fsolution);
#endif
if( upperb < ceil(lowerb-ZERO)+ZERO ) return(1);
//// constraint_branching(nbetter,better,&row0,&row1);
constraint_branching(nsupport,support,&row0,&row1);
if( upperb < ceil(lowerb-ZERO)+ZERO ) return(1);
if(row0==NULL && row1==NULL)return(-1);
if(row0==NULL || row1==NULL)return(0);
/***
to do not use the branch-cuts
***/
//// return(-1);
branchs++;
#ifdef STAMP
std::cout << "branching " << branchs << " on constraint" << std::endl;
#endif
/* making the left child */
row0->stat = LP_BA;
add_rows(1,&row0);
lowerb = solve_lp(0);
get_solution();
get_base();
write_prob();
deletelastrow();
row0->stat = FIX_LB;
/* making the left child */
row1->stat = LP_BA;
add_rows(1,&row1);
lowerb = solve_lp(0);
get_solution();
get_base();
write_prob();
deletelastrow();
row1->stat = FIX_LB;
lowerb = old_lowerb;
return(1);
}
int MtxLP::addRow(string name, double lb, double ub){
int i = nrow(name);
if (i == 0)
i = add_rows(1);
set_row_name(i, name.data());
setRowBnds(name, lb, ub);
return i;
}
Table<T>::Table(size_t numRows, size_t numCols) :
m_numRows(0),
m_numCols(0)
{
m_defaultColSeperator = ' ';
m_defaultRowSeperator = ' ';
m_defaultColAlignment = 'l';
add_rows(numRows);
add_cols(numCols);
}
T& Table<T>::operator() (size_t rowInd, size_t colInd)
{
if(rowInd >= num_rows())
add_rows((rowInd + 1) - num_rows());
if(colInd >= num_cols())
add_cols((colInd + 1) - num_cols());
return *m_data[rowInd][colInd];
}
void insert_objective_function(problem* prob, matrix* tableau){
/* Insert objective function: min sum of virtual variables */
size_t c;
for (c = prob->variable_count*2 + prob->inequality_count + 1; c < tableau->columns; c++){
insert_value_without_check(-1, tableau->rows, c, tableau);
}
/* Adjust objective so it does not contain any virtual variables */
/* Remove vars from equality constraints */
size_t r;
for (r = 1; r <= prob->equality_count; r++){
add_rows(r, tableau->rows, tableau);
}
}
void bi::standardise(const ExpGaussianPdf<V1,M1>& p, M2 X) {
/* pre-condition */
BI_ASSERT(p.size() == X.size2());
typename sim_temp_vector<M2>::type mu(X.size2());
log_columns(X, p.getLogs());
mean(X, mu);
sub_rows(X, mu);
trsm(1.0, p.std(), X, 'R', 'U');
add_rows(X, mu);
sub_rows(X, p.mean());
exp_columns(X, p.getLogs());
}
/* Die factorize-Methode führt die LR-Zerlegung für eine Matrix aus.
Die Methode wird im Konstruktor der Klasse mit aufgerufen und ist außerhalb der Klasse NICHT aufrufbar.
Das garantiert, dass für die weiterführenden Methoden(det, inv, solve) immer schon eine gültige LR-Zerlegung vorhanden ist (falls man die Matrix A außerhalb der Klasse nicht noch irgendwie verändert).
Die LR-Zerlegung wird über die Matrix A gespeichert (insbes. gehen die Einträge von A dabei verloren!).
Die Matrix R sind dabei die Einträge oberhalb der Diagonalen, die Matrix L die Einträge unterhalb. Für die Diagonale der Matrix L (die ja nur aus Einsen besteht) werden die Einträge nicht extra gespeichert.
*/
bool CLR_Fact::factorize()
{
double max_elem, scalar;
int k, temp2;
double * temp1;
for (int i = 0; i < m_n; i++) // Die Matrix wird Spaltenweise durchlaufen
{
max_elem = std::abs(m_matrix[i][i]); // Pivotelement wird zunächst mit dem Diagonalelement der aktuellen Spalte initialisiert
k = i; // Speichert die Zeile, in der das Pivotelement gefunden wird
for (int j = i; j < m_n; j++)
if (std::abs(m_matrix[j][i]) > max_elem) // Falls in der aktuellen Spalte ein betragsmäßig größeres Element gefunden wird, wird dieses als Pivotelement gesetzt
{
max_elem = std::abs(m_matrix[j][i]);
k = j;
}
if (max_elem <= s_epsilon) // Falls in der aktuellen Spalte kein Pivotelement gefunden werden kann, so ist A nicht invertierbar.
return false;
if (k != i) // Vertauschen der k-ten mit der i-ten Zeile
{
// Die Einträge der Zeilen müssen nicht kopiert werden, stattdessen kopiert man einfach die Zeiger auf die i-te und k-te Zeile
temp1 = m_matrix[i];
m_matrix[i] = m_matrix[k];
m_matrix[k] = temp1;
// Die Vertauschung wird im Indexvektor gespeichert
temp2 = m_indizes[i];
m_indizes[i] = m_indizes[k];
m_indizes[k] = temp2;
}
for (int j = i+1; j < m_n; j++) // Elimination der weiter unten stehenden Einträge der aktuellen Spalte
{
scalar = m_matrix[j][i]/m_matrix[i][i];
add_rows(j,i,-scalar);
m_matrix[j][i] = scalar; // Der Skalar, der zur Elimination des Eintrags einer Spalte benutzt wurde, wird an genau diese Stelle gespeichert -> Matrix L
}
}
return true; // Wenn die Faktorisierung erfolgreich war, wird true zurückgegeben, da die Matrix A dann invertierbar ist
}
int sub_function(int fd)
{
char *line;
int gnl_check;
t_rows **begin;
if (!(begin = (t_rows**)malloc(sizeof(t_rows*))))
return (-1);
if ((gnl_check = get_next_line(fd, &line)) == -1)
return (-1);
if (get_first_row(begin, line) == -1)
return (-1);
while ((gnl_check = get_next_line(fd, &line)))
{
if (fd == 0 && (ft_isspace(line[0]) || line[0] == 0))
break ;
if (gnl_check == -1 || add_rows(begin, line) == -1)
return (-1);
}
free(line);
ft_screenclr();
play_the_game(begin);
return (0);
}
// Operators for constant recursators
super& operator+= (const virtual_recursator<value_type, true>& other)
{
add_rows(*this, other);
return *this;
}
// Operators for matrices
super& operator+= (const super& other)
{
add_rows(*this, other);
return *this;
}
static void constraint_branching(int nvar,VARIABLE **xvar,CONSTRAINT **con0,CONSTRAINT **con1)
{
int k,card;
double rhs,rhs0,rhs1,lb0,lb1;
VARIABLE **x;
double *c;
CONSTRAINT *row0,*row1;
*con0 = *con1 = NULL;
rhs = 0;
card = 0;
for(k=0;k<nvar;k++)
if( fabs( xvar[k]->val - 0.5 ) < FRAC-ZERO ){
rhs += xvar[k]->val;
card++;
}
if( card==0 ){
#ifdef STAMP
std::cout << "Warning: no fractional variables for branch-constraint" << std::endl;
#endif
return;
}
rhs0 = ceil(rhs-ZERO);
rhs1 = floor(rhs+ZERO);
#ifdef STAMP
std::cout << rhs1 << "<" << rhs << "<" << rhs0 << std::endl;
#endif
if( rhs0 - rhs1 < ZERO ){
#ifdef STAMP
std::cout << "Warning: no fractional branch-constraint (sum=" << rhs << std::endl;
#endif
return;
}
x = (VARIABLE **)malloc( card*sizeof(VARIABLE *) );
if( x==NULL ){
std::cout << " ERROR: not enough memory for the SORT" << std::endl;
CSPexit(EXIT_MEMO); //exit(1);
}
c = (double *)malloc( card*sizeof(double) );
if( c==NULL ){
std::cout << " ERROR: not enough memory for the SORT" << std::endl;
CSPexit(EXIT_MEMO); //exit(1);
}
card = 0;
for(k=0;k<nvar;k++)
if( fabs( xvar[k]->val - 0.5 ) < FRAC-ZERO ){
x[card] = xvar[k];
c[card] = 1.0;
card++;
}
row0 = (CONSTRAINT *)malloc( sizeof(CONSTRAINT) );
if(row0==NULL){
std::cout << "There is not enough memory for ROW" << std::endl;
CSPexit(EXIT_MEMO); //exit(1);
}
row0->rhs = rhs0;
row0->card = card;
row0->stack = x;
row0->coef = c;
row0->sense = 'G';
row0->type = BRANCHCUT;
row0->stat = FIX_LB;
row0->lp = -1;
row0->con = NULL;
row1 = (CONSTRAINT *)malloc( sizeof(CONSTRAINT) );
if(row1==NULL){
std::cout << "There is not enough memory for ROW" << std::endl;
CSPexit(EXIT_MEMO); //exit(1);
}
row1->rhs = rhs1;
row1->card = card;
row1->stack = x;
row1->coef = c;
row1->sense = 'L';
row1->type = BRANCHCUT;
row1->stat = FIX_LB;
row1->lp = -1;
row1->con = NULL;
add_rows(1,&row0);
activa_pricing();
lb0 = ceil( solve_lp(0) - ZERO ) + ZERO;
deletelastrow();
add_rows(1,&row1);
activa_pricing();
lb1 = ceil( solve_lp(0) - ZERO ) + ZERO;
deletelastrow();
if( lb0 > upperb && lb1 > upperb ) {
lowerb = upperb;
free( row0 );
row0 = NULL; /*PWOF*/
free( row1 );
row1 = NULL; /*PWOF*/
return;
}
if( lb0 > upperb ) {
row1->stat = LP_BA;
add_rows(1,&row1);
free( row0 );
row0 = NULL; /*PWOF*/
rows[nrows++] = *con1 = row1;
return;
}
if( lb1 > upperb ) {
row0->stat = LP_BA;
add_rows(1,&row0);
rows[nrows++] = *con0 = row0;
free( row1 );
row1 = NULL; /*PWOF*/
return;
}
rows[nrows++] = *con0 = row0;
rows[nrows++] = *con1 = row1;
}
int read_prob()
{
int k,l,lcuts,cont;
CONSTRAINT **stack = NULL;
long offset;
struct BRANCH *ptr;
VARIABLE *col;
FILE *pfile;
// float t1;
do{
if( tree==NULL ) return(0);
offset = tree->file;
lowerb = tree->val;
ptr = tree->next;
free(tree);
tree = ptr;
}while( ceil(lowerb-ZERO)+ZERO > upperb );
#ifdef STAMP
std::cout << " >>>>>>>>>>>>> reading problem " << (float)lowerb << std::endl;
#endif
// t1 = seconds();
pfile = fopen(fbranch,"r");
if(pfile==NULL){
std::cout << "ERROR: not possible to write on " << fbranch << std::endl;
CSPexit(EXIT_ERROR); //exit(1);
}
fseek(pfile,offset,SEEK_SET);
for(k=0;k<ncols;k++)
columns[k].stat = FIX_LB;
fscanf(pfile,"%d",&cont);
for(k=0;k<cont;k++){
fscanf(pfile,"%p %d",&col,&l);
col->stat = l;
}
fscanf(pfile,"%d",&lcuts);
if(lcuts){
stack = (CONSTRAINT **)malloc( lcuts * sizeof( CONSTRAINT *) );
if( stack==NULL ){
std::cout << "ERROR: not enought memory for STACK" << std::endl;
CSPexit(EXIT_MEMO); //exit(1);
}
for(k=0;k<lcuts;k++){
fscanf(pfile,"%p",stack+k);
stack[k]->stat = 0;
}
}
fclose(pfile);
load_lp();
if(lcuts){
add_rows(lcuts,stack);
free( (void *)stack );
stack = NULL; /*PWOF*/
}
put_base();
setup_lp();
get_solution();
return(1);
}
