lpkit.c

利用c语言编写

        (REALLOC(lp->lambda, lp->nr_lagrange) == NULL) ||
        (REALLOC(lp->lag_con_type, lp->nr_lagrange) == NULL)
       ) {
      lp->spx_status = OUT_OF_MEMORY;
      ok = FALSE;
    }
  }
  if (ok) {
    if (CALLOC(lp->lag_row[lp->nr_lagrange - 1], lp->columns + 1) == NULL) {
      lp->spx_status = OUT_OF_MEMORY;
      ok = FALSE;
    }
    else {
      lp->lag_rhs[lp->nr_lagrange - 1] = rhs * sign;
      for(i = 1; i <= lp->columns; i++)
	lp->lag_row[lp->nr_lagrange - 1][i] = row[i] * sign;
      lp->lambda[lp->nr_lagrange - 1] = 0;
      lp->lag_con_type[lp->nr_lagrange - 1] = (MYBOOL) con_type;
    }
  }
  return(ok);
}

int str_add_lag_con(lprec *lp, char *row, short con_type, REAL rhs)
{
  int  i, ok = TRUE;
  REAL *a_row;
  char *p, *new_p;

  if (CALLOC(a_row, lp->columns + 1) == NULL) {
    lp->spx_status = OUT_OF_MEMORY;
    ok = FALSE;
  }
  else {
    p = row;

    for(i = 1; i <= lp->columns; i++) {
      a_row[i] = (REAL) strtod(p, &new_p);
      if(p == new_p) {
	report(lp, IMPORTANT, "str_add_lag_con: Bad string");
	ok = FALSE;
	lp->spx_status = IGNORED;
	break;
      }
      else
	p = new_p;
    }
    if(ok)
      if (!add_lag_con(lp, a_row, con_type, rhs))
        ok = FALSE;
    free(a_row);
  }
  return(ok);
}

int add_column(lprec *lp, REAL *column)
{
  int i, elmnr;

  /* if the column has only one entry, this should be handled as
     a bound, but this currently is not the case */

  lp->columns++;
  lp->sum++;
  if ((!inc_col_space(lp)) || (!inc_mat_space(lp, lp->rows + 1)))
    return(FALSE);

 /* if scaling is enabled, we can only scale rows, since
    the column scalar has not been computed */
  if(lp->scaling_used) {
    for(i = 0; i <= lp->rows; i++)
      column[i] *= lp->scale[i];
    for(i = 0; i < lp->nr_lagrange; i++)
      column[lp->rows + 1 + i] *= lp->scale[lp->sum + 1 + i];
  }
  if(lp->scale != NULL) {
    for(i = lp->sum + lp->nr_lagrange; i > lp->sum; i--)
      lp->scale[i] = lp->scale[i - 1];
    lp->scale[lp->sum] = 1;
  }

  elmnr = lp->col_end[lp->columns - 1];
  for(i = 0 ; i <= lp->rows ; i++)
    if(column[i] != 0) {
      lp->mat[elmnr].row_nr = i;
      if(lp->ch_sign[i])
	lp->mat[elmnr].value = -column[i];
      else
	lp->mat[elmnr].value = column[i];
      lp->non_zeros++;
      elmnr++;
    }
  for(i = 0; i < lp->nr_lagrange; i++)
    lp->lag_row[i][lp->columns] = column[lp->rows + 1 + i];

  lp->var_is_sc[lp->columns] = 0;
  lp->var_is_free[lp->columns] = 0;
  lp->col_end[lp->columns] = elmnr;
  lp->orig_lowbo[lp->sum] = 0;
  lp->orig_upbo[lp->sum] = lp->infinite;
  lp->lower[lp->sum] = TRUE;
  lp->basis[lp->sum] = FALSE;
  lp->must_be_int[lp->columns] = ISREAL;

#if 0
  lp->var_to_orig[lp->sum] = lp->columns;
  lp->orig_to_var[lp->sum] = lp->columns;
#endif

  lp->row_end_valid = FALSE;
  return(TRUE);
}

int str_add_column(lprec *lp, char *col_string)
{
  int  i, ok = TRUE;
  REAL *aCol;
  char *p, *newp;

  if (CALLOC(aCol, lp->rows + 1) == NULL) {
    lp->spx_status = OUT_OF_MEMORY;
    ok = FALSE;
  }
  else {
    p = col_string;

    for(i = 0; i <= lp->rows; i++) {
      aCol[i] = (REAL) strtod(p, &newp);
      if(p == newp) {
	report(lp, IMPORTANT, "str_add_column: Bad string");
	ok = FALSE;
	lp->spx_status = IGNORED;
	break;
      }
      else
	p = newp;
    }
    if(ok)
      if (!add_column(lp, aCol))
        ok = FALSE;
    free(aCol);
  }
  return(ok);
}

int del_column(lprec *lp, int column)
{
  int i, j, from_elm, to_elm, elm_in_col;
#if 0
  int k;
#endif
  if(column > lp->columns || column < 1) {
    report(lp, IMPORTANT, "del_column: Column %d out of range", column);
    return(FALSE);
  }
#if 0
  k = lp->var_to_orig[lp->rows+column];
#endif
  for(i = 1; i <= lp->rows; i++) {
    if(lp->bas[i] == lp->rows + column)
      lp->basis_valid = FALSE;
    else if(lp->bas[i] > lp->rows + column)
      lp->bas[i]--;
  }
  for(i = lp->rows + column; i < lp->sum; i++) {
    if(lp->names_used) {
      j = i - lp->rows;
      lp->col_name[j] = lp->col_name[j + 1];
    }
    lp->orig_upbo[i] = lp->orig_upbo[i + 1];
    lp->orig_lowbo[i] = lp->orig_lowbo[i + 1];
    lp->upbo[i] = lp->upbo[i + 1];
    lp->lowbo[i] = lp->lowbo[i + 1];
    lp->basis[i] = lp->basis[i + 1];
    lp->lower[i] = lp->lower[i + 1];
#if 0
    lp->var_to_orig[i] = lp->var_to_orig[i + 1];
#endif
  }
  if(lp->scaling_used) {
    for(i = lp->rows + column; i < lp->sum + lp->nr_lagrange; i++)
      lp->scale[i] = lp->scale[i + 1];
  }

  for(i = 0; i < lp->nr_lagrange; i++)
    for(j = column; j <= lp->columns; j++)
      lp->lag_row[i][j] = lp->lag_row[i][j+1];

  to_elm = lp->col_end[column-1];
  from_elm = lp->col_end[column];
  elm_in_col = from_elm-to_elm;
  for(i = from_elm; i < lp->non_zeros; i++) {
    lp->mat[to_elm] = lp->mat[i];
    to_elm++;
  }
  for(i = column; i < lp->columns; i++) {
    lp->col_end[i] = lp->col_end[i + 1] - elm_in_col;
    lp->must_be_int[i] = lp->must_be_int[i + 1];
    lp->var_is_sc[i] = lp->var_is_sc[i + 1];
    lp->var_is_free[i] = lp->var_is_free[i + 1];
  }
  lp->non_zeros -= elm_in_col;
  lp->row_end_valid = FALSE;
  lp->eta_valid = FALSE;

#if 0
  lp->orig_to_var[k] = -column;
  for(i = k + 1; i <= lp->orig_columns; i++)
    if(lp->orig_to_var[lp->orig_rows+i] >= 0)
      lp->orig_to_var[lp->orig_rows+i]--;
#endif

  lp->sum--;
  lp->columns--;
  return(TRUE);
}

int set_upbo(lprec *lp, int column, REAL value)
{
  if(column > lp->columns || column < 1) {
    report(lp, IMPORTANT, "set_upbo: Column %d out of range", column);
    return(FALSE);
  }
  if(value<lp->infinite && lp->scaling_used)
    value /= lp->scale[lp->rows + column];
  /* we don't test here if upper bound is smaller than lower bound. This condition could be temporary.
     The test is moved to the isvalid() routine which is called just before the model is optimized */
  /*
  if(value < lp->orig_lowbo[lp->rows + column]) {
    report(lp, IMPORTANT, "set_upbo: Upperbound must be >= lowerbound");
    return(FALSE);
  }
  */
  /* allow to set a value larger than the previous set bound. It is up to the user to check if this may happen */
  /* he can use get_upbo() to get the previous bound and determine of he may set it or not */
  /* if(value < lp->orig_upbo[lp->rows + column]) */
  {
    lp->eta_valid = FALSE;
    lp->orig_upbo[lp->rows + column] = value;
  }
  return(TRUE);
}

REAL get_upbo(lprec *lp, int column)
{
  REAL value;
  value = lp->orig_upbo[lp->rows + column];
  if((value<lp->infinite) && lp->columns_scaled) {
    value *= lp->scale[lp->rows + column];
  }
  return(value);
}

int set_lowbo(lprec *lp, int column, REAL value)
{
  if(column > lp->columns || column < 1) {
    report(lp, IMPORTANT, "set_lowbo: Column %d out of range", column);
    return(FALSE);
  }
  if(value > -lp->infinite && lp->scaling_used)
    value /= lp->scale[lp->rows + column];
  /* we don't test here if lower bound is larger than upper bound. This condition could be temporary.
     The test is moved to the isvalid() routine which is called just before the model is optimized */
  /*
  if(value > lp->orig_upbo[lp->rows + column]) {
    report(lp, IMPORTANT, "set_lowbo: Upperbound must be >= lowerbound");
    return(FALSE);
  }
  */
  /* allow to set a value smaller than the previous set bound. It is up to the user to check if this may happen */
  /* he can use get_lowbo() to get the previous bound and determine of he may set it or not */
  /* if((value < 0) || (value > lp->orig_lowbo[lp->rows + column])) */
  {
    lp->eta_valid = FALSE;
    lp->orig_lowbo[lp->rows + column] = value;
  }
  return(TRUE);
}

REAL get_lowbo(lprec *lp, int column)
{
  REAL value;
  value = lp->orig_lowbo[lp->rows + column];
  if((value<lp->infinite) && lp->columns_scaled) {
    value *= lp->scale[lp->rows + column];
  }
  return(value);
}

int set_bounds(lprec *lp, int column, REAL lower, REAL upper)
{
  if(column > lp->columns || column < 1) {
    report(lp, IMPORTANT, "set_bounds: Column %d out of range", column);
    return(FALSE);
  }
  if(lp->scaling_used) {
    if(lower > -lp->infinite)
      lower /= lp->scale[lp->rows + column];
    if(upper < lp->infinite)
      upper /= lp->scale[lp->rows + column];
  }
  /* following test is moved to isvalid() routine */
  /*
  if(lower > upper)
    report(lp, IMPORTANT, "set_bounds: Column %d Upper bound must be >= lower bound", column);
  */
  lp->eta_valid = FALSE;
  lp->orig_lowbo[lp->rows+column] = lower;
  lp->orig_upbo[lp->rows+column] = upper;
  return(TRUE);
}

int set_uprange(lprec *lp, int row, REAL value)
{
  if(row > lp->rows || row < 1) {
    report(lp, CRITICAL, "set_uprange: row %d out of range", row);
    return(FALSE);
  }
  if(lp->scaling_used)
    value *= lp->scale[row];
  /* following test is moved to isvalid() routine */
  /*
  if(value < lp->orig_lowbo[row]) {
    report(lp, CRITICAL, "set_uprange: Upperbound must be >= lowerbound");
    return(FALSE);
  }
  */
  /* if(value<lp->orig_upbo[row]) */
  {
    lp->eta_valid = FALSE;
    lp->orig_upbo[row] = value;
  }
  return(TRUE);
}

int set_lowrange(lprec *lp, int row, REAL value)
{
  if(row > lp->rows || row < 1) {
    report(lp, CRITICAL, "set_lowrange: row %d out of range", row);
    return(FALSE);
  }
  if(lp->scaling_used)
    value *= lp->scale[row];
  /* following test is moved to isvalid() routine */
  /*
  if(value > lp->orig_upbo[row]) {
    report(lp, CRITICAL, "set_lowrange: Upperbound must be >= lowerbound");
    return(FALSE);
  }
  */
  /*
    if(value < 0) {
     report(lp, CRITICAL, "set_lowrange: Lower bound cannot be < 0");
     return(FALSE);
    }
    */
  /* if((value<0) || (value>lp->orig_lowbo[row])) */
  {
    lp->eta_valid = FALSE;
    lp->orig_lowbo[row] = value;
  }
  return(TRUE);
}

int set_int(lprec *lp, int column, short must_be_int)
{
  if(column > lp->columns || column < 1) {
    report(lp, IMPORTANT, "set_int: Column %d out of range", column);
    return(FALSE);
  }
  if(lp->must_be_int[column] & ISINTEGER) {
    lp->int_count--;
    lp->must_be_int[column] &= !ISINTEGER;
  }
  if(must_be_int) {
    lp->must_be_int[column] |= ISINTEGER;
    lp->int_count++;
    if(lp->scaling_used && lp->columns_scaled && ((lp->scalemode & INTEGERSCALE) == 0))
      unscale_columns(lp);
  }
  return(TRUE);
}

void set_verbose(lprec *lp, short verbose)
{
  lp->verbose = verbose;
}

short get_verbose(lprec *lp)
{
  return(lp->verbose);
}

void set_timeout(lprec *lp, long sectimeout)
{
  lp->sectimeout = sectimeout;
}

long get_timeout(lprec *lp)
{
  return(lp->sectimeout);
}

void put_abortfunc(lprec *lp, abortfunc newabort, void *aborthandle)
{
  lp->abort = newabort;
  lp->aborthandle = aborthandle;
}

void put_logfunc(lprec *lp, logfunc newlog, void *loghandle)
{
  lp->writelog = newlog;
  lp->loghandle = loghandle;
}

void put_msgfunc(lprec *lp, msgfunc newmsg, void *msghandle)
{
  lp->usermessage = newmsg;
  lp->msghandle = msghandle;
}

void set_print_duals(lprec *lp, MYBOOL print_duals)
{
  lp->print_duals = print_duals;
}

MYBOOL is_print_duals(lprec *lp)
{
  return(lp->print_duals);
}

void set_print_sol(lprec *lp, MYBOOL print_sol)
{
  lp->print_sol = print_sol;
}

MYBOOL is_print_sol(lprec *lp)
{
  return(lp->print_sol);
}

void set_debug(lprec *lp, MYBOOL debug)
{
  lp->debug = debug;
}

MYBOOL is_debug(lprec *lp)
{
  return(lp->debug);
}

void set_print_at_invert(lprec *lp, short print_at_invert)
{
  lp->print_at_invert = print_at_invert;
}

short is_print_at_invert(lprec *lp)
{
  return(lp->print_at_invert);
}

void set_trace(lprec *lp, MYBOOL trace)
{
  lp->trace = trace;
}

MYBOOL is_trace(lprec *lp)
{
  return(lp->trace);
}

void set_anti_degen(lprec *lp, MYBOOL anti_degen)
{
  lp->anti_degen = anti_degen;
}

MYBOOL is_anti_degen(lprec *lp)
{
  return(lp->anti_degen);
}

void set_do_presolve(lprec *lp, MYBOOL do_presolve)
{
  lp->do_presolve = do_presolve;
}

MYBOOL is_do_presolve(lprec *lp)
{
  return(lp->do_presolve);
}

void set_max_num_inv(lprec *lp, int max_num_inv)
{
  lp->max_num_inv = max_num_inv;
}

int get_max_num_inv(lprec *lp)
{
  return(lp->max_num_inv);
}

void set_bb_rule(lprec *lp, MYBOOL bb_rule)
{
  lp->bb_rule = bb_rule;
}

MYBOOL get_bb_rule(lprec *lp)
{
  return(lp->bb_rule);
}

void set_obj_bound(lprec *lp, REAL obj_bound)
{
  lp->obj_bound = obj_bound;
}

REAL get_obj_bound(lprec *lp)
{
  return(lp->obj_bound);
}

void set_floor_first(lprec *lp, MYBOOL floor_first)
{
  lp->floor_first = floor_first;
}

MYBOOL get_floor_first(lprec *lp)
{
  return(lp->floor_first);
}