lp_rlpt.c

lp_solve_5.5.0.13_xli_CPLEX_source.tar优化问题的求解

  case 57:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->isign = 0;
  pv->f = -1.0;
}
    break;

  case 58:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->isign = pv->isign0;
  pv->f = pv->f0;
}
    break;

  case 59:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_bounds(pp, TRUE))
    YYABORT;
}
    break;

  case 60:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  /* pv->HadConstraint = FALSE; */
  pv->HadVar = FALSE;
  pv->isign = 0;
  pv->make_neg = 0;
  null_tmp_store(pp, TRUE);
}
    break;

  case 61:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_re_op(pp, pv->OP, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;
  pv->make_neg = 1;
}
    break;

  case 62:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_bounds(pp, TRUE))
    YYABORT;
  /* pv->HadConstraint = FALSE; */
  pv->HadVar = FALSE;
  pv->isign = 0;
  pv->make_neg = 0;
  null_tmp_store(pp, TRUE);
}
    break;

  case 63:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_re_op(pp, '>', pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;
  pv->make_neg = 1;
  pv->isign = 0;
  pv->f = -DEF_INFINITE;
}
    break;

  case 64:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_bounds(pp, FALSE))
    YYABORT;

  if(!store_re_op(pp, '<', pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;
  pv->f = DEF_INFINITE;
  pv->isign = 0;
}
    break;

  case 65:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_bounds(pp, FALSE))
    YYABORT;
  /* pv->HadConstraint = FALSE; */
  pv->HadVar = FALSE;
  pv->isign = 0;
  pv->make_neg = 0;
  null_tmp_store(pp, TRUE);
}
    break;

  case 67:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_re_op(pp, (char) ((pv->OP == '<') ? '>' : (pv->OP == '>') ? '<' : pv->OP), (int) pv->HadConstraint, (int) pv->HadVar, (int) pv->Had_lineair_sum))
    YYABORT;
  pv->make_neg = 0;
  pv->isign = 0;
}
    break;

  case 68:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_bounds(pp, TRUE))
    YYABORT;
}
    break;

  case 71:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if (    (pv->isign || !pv->make_neg)
      && !(pv->isign && !pv->make_neg)) /* but not both! */
    pv->f = -pv->f;
  if(!rhs_store(pp, pv->f, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;
  pv->isign = 0;
}
    break;

  case 72:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->isign = 0;
}
    break;

  case 73:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->isign = pv->Sign;
  pv->HadSign = TRUE;
}
    break;

  case 74:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if (    (pv->isign || pv->make_neg)
      && !(pv->isign && pv->make_neg)) /* but not both! */
    pv->f = -pv->f;
  if(!var_store(pp, pv->Last_var, pv->f, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum)) {
    lpt_yyerror(pp, pp->scanner, "var_store failed");
    YYABORT;
  }
  /* pv->HadConstraint |= pv->HadVar; */
  pv->HadVar = TRUE;
  pv->isign = 0;
}
    break;

  case 80:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  storevarandweight(pp, pv->Last_var);
}
    break;

  case 81:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->SOSNr++;
  pv->weight = pv->SOSNr;
  storevarandweight(pp, pv->Last_var);
  set_sos_weight(pp, pv->weight, 2);
}
    break;

  case 82:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  storevarandweight(pp, pv->Last_var);
}
    break;

  case 83:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->weight = (int) (pv->f + .1);
  set_sos_weight(pp, pv->weight, 2);
}
    break;

  case 88:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  check_int_sec_sos_free_decl(pp, pv->Within_gen_decl ? 1 : pv->Within_bin_decl ? 2 : 0, 0, 0, 0);
}
    break;

  case 94:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  check_int_sec_sos_free_decl(pp, 0, 1, 0, 0);
}
    break;

  case 105:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char buf[16], *ptr, *var;

  check_int_sec_sos_free_decl(pp, 0, 0, 1, 0);
  pv->SOSweight++;
  for (ptr = pv->Last_var; (*ptr) && (*ptr != ':'); ptr++);
  if (ptr[1] == ':') {
    sprintf(buf, "SOS%d", pv->SOSweight);
    var = buf;
    ptr = pv->Last_var;
  }
  else {
    var = ptr + 1;
    while ((ptr > pv->Last_var) && (isspace(ptr[-1]))) ptr--;
    *ptr = 0;
    ptr = var;
    var = pv->Last_var;
    while (isspace(*ptr)) ptr++;
  }
  storevarandweight(pp, var);
  pv->SOStype = ptr[1] - '0';
  set_sos_type(pp, pv->SOStype);
  check_int_sec_sos_free_decl(pp, 0, 0, 2, 0);
  pv->weight = 0;
  pv->SOSNr = 0;
}
    break;

  case 106:

    {
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  set_sos_weight(pp, pv->SOSweight, 1);
}
    break;


/* Line 1267 of yacc.c.  */

      default: break;
    }
  YY_SYMBOL_PRINT ("-> $$ =", lpt_yyr1[lpt_yyn], &lpt_yyval, &lpt_yyloc);

  YYPOPSTACK (lpt_yylen);
  lpt_yylen = 0;
  YY_STACK_PRINT (lpt_yyss, lpt_yyssp);

  *++lpt_yyvsp = lpt_yyval;


  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  lpt_yyn = lpt_yyr1[lpt_yyn];

  lpt_yystate = lpt_yypgoto[lpt_yyn - YYNTOKENS] + *lpt_yyssp;
  if (0 <= lpt_yystate && lpt_yystate <= YYLAST && lpt_yycheck[lpt_yystate] == *lpt_yyssp)
    lpt_yystate = lpt_yytable[lpt_yystate];
  else
    lpt_yystate = lpt_yydefgoto[lpt_yyn - YYNTOKENS];

  goto lpt_yynewstate;


/*------------------------------------.
| lpt_yyerrlab -- here on detecting error |
`------------------------------------*/
lpt_yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!lpt_yyerrstatus)
    {
      ++lpt_yynerrs;
#if ! YYERROR_VERBOSE
      lpt_yyerror (parm, scanner, YY_("syntax error"));
#else
      {
	YYSIZE_T lpt_yysize = lpt_yysyntax_error (0, lpt_yystate, lpt_yychar);
	if (lpt_yymsg_alloc < lpt_yysize && lpt_yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
	  {
	    YYSIZE_T lpt_yyalloc = 2 * lpt_yysize;
	    if (! (lpt_yysize <= lpt_yyalloc && lpt_yyalloc <= YYSTACK_ALLOC_MAXIMUM))
	      lpt_yyalloc = YYSTACK_ALLOC_MAXIMUM;
	    if (lpt_yymsg != lpt_yymsgbuf)
	      YYSTACK_FREE (lpt_yymsg);
	    lpt_yymsg = (char *) YYSTACK_ALLOC (lpt_yyalloc);
	    if (lpt_yymsg)
	      lpt_yymsg_alloc = lpt_yyalloc;
	    else
	      {
		lpt_yymsg = lpt_yymsgbuf;
		lpt_yymsg_alloc = sizeof lpt_yymsgbuf;
	      }
	  }

	if (0 < lpt_yysize && lpt_yysize <= lpt_yymsg_alloc)
	  {
	    (void) lpt_yysyntax_error (lpt_yymsg, lpt_yystate, lpt_yychar);
	    lpt_yyerror (parm, scanner, lpt_yymsg);
	  }
	else
	  {
	    lpt_yyerror (parm, scanner, YY_("syntax error"));
	    if (lpt_yysize != 0)
	      goto lpt_yyexhaustedlab;
	  }
      }
#endif
    }



  if (lpt_yyerrstatus == 3)
    {
      /* If just tried and failed to reuse look-ahead token after an
	 error, discard it.  */

      if (lpt_yychar <= YYEOF)
	{
	  /* Return failure if at end of input.  */
	  if (lpt_yychar == YYEOF)
	    YYABORT;
	}
      else
	{
	  lpt_yydestruct ("Error: discarding",
		      lpt_yytoken, &lpt_yylval, parm, scanner);
	  lpt_yychar = YYEMPTY;
	}
    }

  /* Else will try to reuse look-ahead token after shifting the error
     token.  */
  goto lpt_yyerrlab1;


/*---------------------------------------------------.
| lpt_yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
lpt_yyerrorlab:

  /* Pacify compilers like GCC when the user code never invokes
     YYERROR and the label lpt_yyerrorlab therefore never appears in user
     code.  */
  if (/*CONSTCOND*/ 0)
     goto lpt_yyerrorlab;

  /* Do not reclaim the symbols of the rule which action triggered
     this YYERROR.  */
  YYPOPSTACK (lpt_yylen);
  lpt_yylen = 0;
  YY_STACK_PRINT (lpt_yyss, lpt_yyssp);
  lpt_yystate = *lpt_yyssp;
  goto lpt_yyerrlab1;


/*-------------------------------------------------------------.
| lpt_yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
lpt_yyerrlab1:
  lpt_yyerrstatus = 3;	/* Each real token shifted decrements this.  */

  for (;;)
    {
      lpt_yyn = lpt_yypact[lpt_yystate];
      if (lpt_yyn != YYPACT_NINF)
	{
	  lpt_yyn += YYTERROR;
	  if (0 <= lpt_yyn && lpt_yyn <= YYLAST && lpt_yycheck[lpt_yyn] == YYTERROR)
	    {
	      lpt_yyn = lpt_yytable[lpt_yyn];
	      if (0 < lpt_yyn)
		break;
	    }
	}

      /* Pop the current state because it cannot handle the error token.  */
      if (lpt_yyssp == lpt_yyss)
	YYABORT;


      lpt_yydestruct ("Error: popping",
		  lpt_yystos[lpt_yystate], lpt_yyvsp, parm, scanner);
      YYPOPSTACK (1);