read.c

利用c语言编写

        return(FALSE);
      Columns++; /* counter for calloc of final array */
      /* create a place to store bounds information */
      if ((h_tab_p->bnd = create_bound_rec()) == NULL)
        return(FALSE);
    }
    else if(h_tab_p->bnd == NULL)
      /* create a place to store bounds information */
      if ((h_tab_p->bnd = create_bound_rec()) == NULL)
        return(FALSE);

    /* else bound_rec already exists */

    if(tmp_store.value < 0) { /* divide by negative number, */
      /* relational operator may change */
      if(tmp_store.relat == GE)
	tmp_store.relat = LE;
      else if(tmp_store.relat == LE)
	tmp_store.relat = GE;
    }
    /* Check sanity of bound; all variables should be positive */
    boundvalue = tmp_store.rhs_value / tmp_store.value;
    if(   ((tmp_store.relat == EQ) && (boundvalue < 0))
       || ((tmp_store.relat == LE) && (boundvalue < 0))) { /* Error */
      if (Verbose >= CRITICAL)
        report(NULL, CRITICAL, "Error on line %d: variables must always be non-negative",
	        yylineno);
      return(FALSE);
    }

    if((tmp_store.relat == GE) && (boundvalue <= 0)) /* Warning */
      if (Verbose >= NORMAL)
        report(NULL, NORMAL,
	        "Warning on line %d: useless bound; variables are always >= 0",
	        yylineno);

    /* bound seems to be sane, add it */
    if((tmp_store.relat == GE) || (tmp_store.relat == EQ)) {
      if(h_tab_p->bnd->lowbo <  boundvalue)
	h_tab_p->bnd->lowbo = boundvalue;
      else
        if (Verbose >= NORMAL)
          report(NULL, NORMAL, "Ineffective lower bound on line %d, ignored",
		  yylineno);
    }
    if((tmp_store.relat == LE) || (tmp_store.relat == EQ)) {
      if(h_tab_p->bnd->upbo >  boundvalue)
	h_tab_p->bnd->upbo  = boundvalue;
      else
        if (Verbose >= NORMAL)
          report(NULL, NORMAL, "Ineffective upper bound on line %d, ignored",
		  yylineno);
    }

    /* check for empty range */
    if(h_tab_p->bnd->upbo < h_tab_p->bnd->lowbo) {
      if (Verbose >= CRITICAL)
        report(NULL, CRITICAL, "Error: bound on line %d contradicts earlier bounds, exiting",
	        yylineno);
      return(FALSE);
    }
  }
  else /* tmp_store.value = 0 ! */ {
    if (Verbose >= CRITICAL)
      report(NULL, CRITICAL, "Error, variable %s has an effective coefficient of 0 in bound on line %d. Exiting.",
	      tmp_store.name, yylineno);
    return(FALSE);
  }

  null_tmp_store();
  return(TRUE);
} /* store_bounds */

int add_constraint_name(char *name, int row)
{
  constraint_name *cnp;

  if(!First_constraint_name) { /* first time only */
    if (CALLOC(First_constraint_name, 1) == NULL)
      return(FALSE);
    cnp = First_constraint_name;
    rs = NULL;
  }
  else {
    cnp = First_constraint_name;
    while(cnp) {
      if (strcmp(cnp->name, name) == 0)
        break;
      cnp = cnp->next;
    }
    if (cnp) {
      row = cnp->row;

      rs = First_rside;
      while ((rs != NULL) && (rs->row != row))
        rs = rs->next;
    }
    else {
      cnp = First_constraint_name;
      if (CALLOC(First_constraint_name, 1) == NULL)
        return(FALSE);
      First_constraint_name->next = cnp;
      cnp = First_constraint_name;
      rs = NULL;
    }
  }
  strcpy(cnp->name, name);
  cnp->row = row;
  return(TRUE);
}

/*
 * transport the data from the intermediate structure to the sparse matrix
 * and free the intermediate structure
 */
int readinput(lprec *lp)
{
  int    i, j, index, nn_ind;
  column *cp,*tcp; /* tcp (temporary cp) points to memory-space to free */
  hashelem *hp,*thp;
  bound *bp;
  rside *rp;
  constraint_name *cnp;
  REAL *row;

  if (MALLOC(row, 1 + Rows) == NULL)
    return(FALSE);

  /* fill names with the rownames */
  for(cnp = First_constraint_name; cnp; cnp = cnp->next)
    if (!set_row_name(lp, cnp->row, cnp->name)) {
      free(row);
      return(FALSE);
    }

  for(i = Rows;i >= 0;i--) {
    rp = First_rside;
    if ((rp->range_relat >= 0) && (rp->range_value == rp->value)) {
      rp->relat = EQ;
      rp->range_relat = EQ;
    }
    relat[i] = rp->relat;
    lp->orig_rh[i] = rp->value;
    if (rp->range_relat >= 0)
      lp->orig_upbo[i] = my_abs(rp->range_value - rp->value);
    First_rside = rp->next;
    free(rp); /* free memory when data has been read */
  }

  /* change upperbound to zero if the relational operator is the equal sign */
  for(i = 1; i <= Rows; i++)
    if(relat[i] == EQ)
      lp->orig_upbo[i] = 0;

/*
  for(i = 0; i <= Rows; i++)
    if((!lp->names_used) || (lp->row_name[i] == NULL) || (strcmp(lp->row_name[i], "")==0)) {
      char holdstr[NAMELEN];
      sprintf(holdstr,ROWNAMEMASK,i);
      if (!set_row_name(lp,i,holdstr)) {
        free(row);
        return(FALSE);
      }
    }
*/

  /* start reading the Hash_list structure */
  index = 0;
  nn_ind = 0;

  for(i = 0; i < Hash_tab->size; i++) {
    hp = Hash_tab->table[i];
    while(hp != NULL) {
      /* put an index in the cend array when a new name is found */
      lp->col_end[index++] = nn_ind;

      /* check if it must be an integer variable */
      if(hp->must_be_int) {
	/* lp->must_be_int[Rows + index]=TRUE; */
        set_int(lp, index, TRUE);
      }
      /* check for bound */
      if(hp->bnd != NULL) {
	bp = hp->bnd;
	lp->orig_lowbo[Rows+index] = bp->lowbo;
	lp->orig_upbo[Rows+index] = bp->upbo;
	free(bp); /* free memory when data has been read*/
      }

      /* copy name of column variable */
      /* lp->col_name[index] = hp->name; */
      if (!set_col_name(lp, index, hp->name)) {
	free(row);
        return(FALSE);
      }

      for(j = 0; j <= Rows; j++)
        row[j] = 0.0;

      /* put matrix values in intermediate row */
      cp = hp->col;
      while(cp!=NULL) {
	row[cp->row] = cp->value;
	tcp = cp;
	cp = cp->next;
	free(tcp); /* free memory when data has been read */
      }
      thp = hp;
      hp = hp->next;
      free(thp->name);
      free(thp); /* free memory when data has been read */

      /* put matrix values in sparse matrix */
      /* this makes sure that values are in order in the sparse matrix. This is a requirement */
      for(j = 0; j <= Rows; j++)
        if(row[j]) {
	  lp->mat[nn_ind].row_nr = j;
	  lp->mat[nn_ind].value = row[j];
	  nn_ind++;
        }
    }
    Hash_tab->table[i] = NULL;
  }
  lp->col_end[index] = nn_ind;

  /* the following should be replaced by a call to the MPS print routine MB */

#if 0
  if(Verbose) {
    int j;

    printf("\n");
    printf("**********Data read**********\n");
    printf("Rows    : %d\n", Rows);
    printf("Columns : %d\n", Columns);
    printf("Nonnuls : %d\n", Non_zeros);
    printf("NAME          LPPROB\n");
    printf("ROWS\n");
    for(i = 0; i <= Rows; i++) {
      if(relat[i] == LE)
	printf(" L  ");
      else if(relat[i] == EQ)
	printf(" E  ");
      else if(relat[i] == GE)
	printf(" G  ");
      else if(relat[i] == OF)
	printf(" N  ");
      printf("%s\n", get_row_name(lp, i));
    }

    printf("COLUMNS\n");
    j = 0;
    for(i = 0; i < Non_zeros; i++) {
      if(i == lp->col_end[j])
	j++;
      printf("    %-8s  %-8s  %g\n", get_col_name(lp, j),
	     get_row_name(lp, lp->mat[i].row_nr), (double)lp->mat[i].value);
    }

    printf("RHS\n");
    for(i = 0; i <= Rows; i++) {
      printf("    RHS       %-8s  %g\n", get_row_name(lp, i),
	     (double)lp->orig_rh[i]);
    }

    printf("RANGES\n");
    for(i = 1; i <= Rows; i++)
      if((lp->orig_upbo[i] != lp->infinite) && (lp->orig_upbo[i] != 0)) {
	printf("    RGS       %-8s  %g\n", get_row_name(lp, i),
	       (double)lp->orig_upbo[i]);
      }
      else if((lp->orig_lowbo[i] != 0)) {
	printf("    RGS       %-8s  %g\n", get_row_name(lp, i),
	       (double)-lp->orig_lowbo[i]);
      }

    printf("BOUNDS\n");
    for(i = Rows + 1; i <= Rows + Columns; i++) {
      if((lp->orig_lowbo[i] != 0) && (lp->orig_upbo[i] < lp->infinite) &&
         (lp->orig_lowbo[i] == lp->orig_upbo[i])) {
        printf(" FX BND       %-8s  %g\n", get_col_name(lp, i - Rows),
               (double)lp->orig_upbo[i]);
      }
      else {
        if(lp->orig_upbo[i] < lp->infinite)
  	  printf(" UP BND       %-8s  %g\n", get_col_name(lp, i - Rows),
  		 (double)lp->orig_upbo[i]);
        if(lp->orig_lowbo[i] > 0)
  	  printf(" LO BND       %-8s  %g\n", get_col_name(lp, i - Rows),
  		 (double)lp->orig_lowbo[i]);
      }
    }

    printf("ENDATA\n");
  }
#endif

  free(row);
  return(TRUE);
} /* readinput */

lprec *read_LP(char *input, short verbose, char *lp_name)
{
  FILE *fpin;
  lprec *lp = NULL;

  if((fpin = fopen(input, "r")) != NULL) {
    lp = read_lp_file(fpin, verbose, lp_name);
    fclose(fpin);
  }
  return(lp);
}

lprec *read_lp_file(FILE *input, short verbose, char *lp_name)
{
  lprec *lp = NULL;
  int i;

  Verbose = verbose;

  yyin = input;
  Maximise = TRUE;
  yyparse();

  Rows--;

  if (CALLOC(relat, Rows + 1) != NULL) {
    lp = make_lpext(Rows, Columns, Non_zeros, Non_zeros, lp_name);
    if (lp != NULL) {
      lp->verbose = verbose;

      if (!readinput(lp)) {
        delete_lp(lp);
	lp = NULL;
      }
      else  {
	if(Maximise)
	  set_maxim(lp);

	for(i = 1; i <= Rows; i++) {
	  REAL a = lp->orig_upbo[i]; /* keep upper bound (range) */
	  set_constr_type(lp, i, relat[i]);
	  lp->orig_upbo[i] = a;      /* restore upper bound (range) */
	}

	/* lets free the temporary list of constraint names */
	while(First_constraint_name) {
	  constraint_name *cp;

	  cp = First_constraint_name;
	  First_constraint_name = First_constraint_name->next;
	  free(cp);
	}

	free_hash_table(Hash_tab);
      }
    }
    free(relat);
  }
  return(lp);
}