lp_rlpt.c

来自「lp_solve_5.5.0.13_xli_CPLEX_source.tar优化」· C语言 代码 · 共 2,279 行 · 第 1/5 页

       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22
};

#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
   YYRHS.  */
static const lpt_yytype_uint16 lpt_yyprhs[] =
{
       0,     0,     3,     4,     5,    12,    13,    16,    19,    22,
      24,    25,    29,    31,    33,    35,    37,    40,    41,    42,
      47,    49,    52,    54,    56,    57,    61,    63,    65,    67,
      70,    72,    73,    77,    78,    84,    86,    88,    90,    93,
      94,    99,   104,   106,   108,   110,   113,   115,   117,   120,
     122,   124,   126,   129,   130,   135,   136,   137,   138,   139,
     140,   152,   153,   158,   159,   160,   166,   168,   169,   174,
     176,   178,   180,   182,   184,   186,   190,   192,   195,   197,
     200,   202,   204,   205,   209,   211,   213,   215,   218,   219,
     223,   225,   227,   229,   232,   233,   237,   239,   241,   243,
     246,   249,   251,   253,   255,   258,   259,   263,   265,   267,
     269
};

/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
static const lpt_yytype_int8 lpt_yyrhs[] =
{
      25,     0,    -1,    -1,    -1,    26,    27,    39,    54,    74,
      96,    -1,    -1,    28,    29,    -1,    18,    30,    -1,    17,
      30,    -1,    32,    -1,    -1,     6,    31,    32,    -1,    33,
      -1,    24,    -1,    34,    -1,    35,    -1,    34,    35,    -1,
      -1,    -1,    36,    72,    37,    38,    -1,    70,    -1,    95,
      73,    -1,    24,    -1,    40,    -1,    -1,    19,    41,    42,
      -1,    24,    -1,    43,    -1,    44,    -1,    43,    44,    -1,
      46,    -1,    -1,     6,    45,    46,    -1,    -1,    48,    52,
      47,    53,    71,    -1,    24,    -1,    49,    -1,    50,    -1,
      49,    50,    -1,    -1,    72,    95,    51,    73,    -1,    72,
      70,    95,    73,    -1,    14,    -1,    15,    -1,    16,    -1,
      72,    70,    -1,     7,    -1,    24,    -1,    20,    55,    -1,
      24,    -1,    56,    -1,    57,    -1,    56,    57,    -1,    -1,
      95,    58,    73,    64,    -1,    -1,    -1,    -1,    -1,    -1,
      53,    59,    52,    60,    95,    61,    73,    62,    71,    63,
      68,    -1,    -1,    52,    65,    53,    71,    -1,    -1,    -1,
       8,    66,    71,    67,    71,    -1,    24,    -1,    -1,    52,
      69,    53,    71,    -1,     5,    -1,     4,    -1,    24,    -1,
      24,    -1,    13,    -1,    24,    -1,    80,    84,    88,    -1,
      77,    -1,    75,    77,    -1,    78,    -1,    76,    78,    -1,
      95,    -1,    95,    -1,    -1,     6,    79,     5,    -1,    24,
      -1,    81,    -1,    82,    -1,    81,    82,    -1,    -1,     9,
      83,    75,    -1,    24,    -1,    85,    -1,    86,    -1,    85,
      86,    -1,    -1,    10,    87,    75,    -1,    24,    -1,    89,
      -1,    90,    -1,    89,    90,    -1,    11,    91,    -1,    24,
      -1,    92,    -1,    93,    -1,    92,    93,    -1,    -1,    12,
      94,    76,    -1,     3,    -1,     8,    -1,    24,    -1,    21,
      -1
};

/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
static const lpt_yytype_uint16 lpt_yyrline[] =
{
       0,    92,    92,    96,    96,   129,   129,   140,   145,   152,
     154,   153,   165,   185,   186,   189,   190,   195,   202,   195,
     213,   225,   261,   262,   266,   265,   281,   282,   285,   286,
     290,   292,   291,   305,   303,   329,   336,   339,   340,   346,
     344,   353,   359,   359,   359,   362,   364,   392,   393,   397,
     398,   401,   402,   407,   406,   417,   425,   434,   442,   450,
     416,   471,   470,   494,   505,   493,   533,   535,   534,   559,
     559,   562,   576,   583,   593,   614,   619,   620,   624,   625,
     629,   638,   649,   648,   666,   667,   670,   671,   676,   675,
     686,   687,   690,   691,   696,   695,   707,   708,   711,   712,
     716,   721,   722,   726,   727,   733,   732,   773,   773,   778,
     779
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const lpt_yytname[] =
{
  "$end", "error", "$undefined", "VAR", "CONS", "INTCONS",
  "VARIABLECOLON", "INF", "FRE", "SEC_INT", "SEC_SEC", "SEC_SOS",
  "SOSTYPE", "TOK_SIGN", "RE_OPEQ", "RE_OPLE", "RE_OPGE", "MINIMISE",
  "MAXIMISE", "SUBJECTTO", "BOUNDS", "END", "UNDEFINED", "$accept",
  "EMPTY", "inputfile", "@1", "objective_function", "@2",
  "objective_function1", "of", "@3", "real_of", "of_lineair_sum",
  "of_lineair_sum1", "of_lineair_term", "@4", "@5", "of_lineair_term1",
  "constraints", "constraints1", "@6", "constraints2", "constraints3",
  "constraint", "@7", "real_constraint", "@8", "x_lineair_sum",
  "lineair_sum", "lineair_term", "@9", "RE_OP", "cons_term", "bounds",
  "x_bounds", "x_bounds1", "bound", "@10", "@11", "@12", "@13", "@14",
  "@15", "bound2", "@16", "@17", "@18", "optionalbound", "@19", "REALCONS",
  "RHS_STORE", "x_SIGN", "VAR_STORE", "int_sec_sos_declarations",
  "VARIABLES", "SOSVARIABLES", "ONEVARIABLE", "ONESOSVARIABLE", "@20",
  "x_int_declarations", "int_declarations", "int_declaration", "@21",
  "x_sec_declarations", "sec_declarations", "sec_declaration", "@22",
  "x_sos_declarations", "sos_declarations", "sos_declaration",
  "x_single_sos_declarations", "single_sos_declarations",
  "single_sos_declaration", "@23", "VARIABLE", "end", 0
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   token YYLEX-NUM.  */
static const lpt_yytype_uint16 lpt_yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const lpt_yytype_uint8 lpt_yyr1[] =
{
       0,    23,    24,    26,    25,    28,    27,    29,    29,    30,
      31,    30,    32,    33,    33,    34,    34,    36,    37,    35,
      38,    38,    39,    39,    41,    40,    42,    42,    43,    43,
      44,    45,    44,    47,    46,    48,    48,    49,    49,    51,
      50,    50,    52,    52,    52,    53,    53,    54,    54,    55,
      55,    56,    56,    58,    57,    59,    60,    61,    62,    63,
      57,    65,    64,    66,    67,    64,    68,    69,    68,    70,
      70,    71,    72,    72,    73,    74,    75,    75,    76,    76,
      77,    78,    79,    78,    80,    80,    81,    81,    83,    82,
      84,    84,    85,    85,    87,    86,    88,    88,    89,    89,
      90,    91,    91,    92,    92,    94,    93,    95,    95,    96,
      96
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const lpt_yytype_uint8 lpt_yyr2[] =
{
       0,     2,     0,     0,     6,     0,     2,     2,     2,     1,
       0,     3,     1,     1,     1,     1,     2,     0,     0,     4,
       1,     2,     1,     1,     0,     3,     1,     1,     1,     2,
       1,     0,     3,     0,     5,     1,     1,     1,     2,     0,
       4,     4,     1,     1,     1,     2,     1,     1,     2,     1,
       1,     1,     2,     0,     4,     0,     0,     0,     0,     0,
      11,     0,     4,     0,     0,     5,     1,     0,     4,     1,
       1,     1,     1,     1,     1,     3,     1,     2,     1,     2,
       1,     1,     0,     3,     1,     1,     1,     2,     0,     3,
       1,     1,     1,     2,     0,     3,     1,     1,     1,     2,
       2,     1,     1,     1,     2,     0,     3,     1,     1,     1,
       1
};

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
   means the default is an error.  */
static const lpt_yytype_uint8 lpt_yydefact[] =
{
       3,     0,     5,     1,     2,     0,    24,    22,     2,    23,
       2,     2,     6,     2,     2,    47,     2,    10,    13,     8,
       9,    12,    14,    15,     2,     7,    31,    73,    26,    25,
       2,    28,    30,     0,     2,    37,     0,   107,    46,   108,
      49,    55,    48,    50,    51,     0,    53,    88,    84,     2,
       2,    85,    86,     2,    16,    72,    18,     2,    72,    29,
      42,    43,    44,    33,    38,    70,    69,     0,    39,     0,
      52,    45,     2,     0,   110,   109,     4,    94,    90,     2,
      91,    92,    87,    11,     0,    32,     2,     2,     2,    56,
      74,     0,    89,    76,    80,     0,     2,    96,    75,    97,
      98,    93,    19,    20,     2,     2,    41,    40,     0,    63,
      61,    54,    77,    95,   105,   101,   100,   102,   103,    99,
      21,    71,    34,    57,     2,     2,     0,   104,     2,    64,
       2,    82,   106,    78,    81,    58,     2,    62,     0,    79,
       2,    65,    83,    59,     2,    66,    67,    60,     2,     2,
      68
};

/* YYDEFGOTO[NTERM-NUM].  */
static const lpt_yytype_int16 lpt_yydefgoto[] =
{
      -1,    55,     1,     2,     4,     5,    12,    19,    53,    20,
      21,    22,    23,    24,    84,   102,     8,     9,    13,    29,
      30,    31,    57,    32,    86,    33,    34,    35,    88,    63,
      41,    16,    42,    43,    44,    72,    69,   108,   128,   140,
     144,   111,   125,   124,   136,   147,   148,    67,   122,    45,
      91,    49,    92,   132,    93,   133,   138,    50,    51,    52,
      73,    79,    80,    81,    95,    98,    99,   100,   116,   117,
     118,   126,    94,    76
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -109
static const lpt_yytype_int8 lpt_yypact[] =
{
    -109,    17,  -109,  -109,    16,     3,  -109,  -109,    19,  -109,
      83,    83,  -109,     5,   102,  -109,    34,  -109,  -109,  -109,
    -109,  -109,    77,  -109,    38,  -109,  -109,  -109,    58,  -109,
      27,  -109,  -109,   119,   114,  -109,   113,  -109,  -109,  -109,
      55,  -109,  -109,    99,  -109,    74,  -109,  -109,  -109,    46,
      59,    34,  -109,    77,  -109,  -109,  -109,    38,   123,  -109,
    -109,  -109,  -109,  -109,  -109,  -109,  -109,    90,  -109,   119,
    -109,  -109,  -109,    90,  -109,  -109,  -109,  -109,  -109,    65,
      59,  -109,  -109,  -109,   113,  -109,    57,  -109,  -109,  -109,
    -109,    42,    90,  -109,  -109,    90,    96,  -109,  -109,    65,
    -109,  -109,  -109,  -109,  -109,  -109,  -109,  -109,    90,  -109,
    -109,  -109,  -109,    90,  -109,  -109,  -109,    96,  -109,  -109,
    -109,  -109,  -109,  -109,  -109,    57,    91,  -109,  -109,  -109,
    -109,  -109,    91,  -109,  -109,  -109,  -109,  -109,   106,  -109,
    -109,  -109,  -109,  -109,   119,  -109,  -109,  -109,    57,  -109,
    -109
};

/* YYPGOTO[NTERM-NUM].  */
static const lpt_yytype_int8 lpt_yypgoto[] =
{
    -109,    -4,  -109,  -109,  -109,  -109,  -109,   103,  -109,    69,
    -109,  -109,   101,  -109,  -109,  -109,  -109,  -109,  -109,  -109,
    -109,    95,  -109,    84,  -109,  -109,  -109,    97,  -109,   -67,
     -83,  -109,  -109,  -109,   100,  -109,  -109,  -109,  -109,  -109,
    -109,  -109,  -109,  -109,  -109,  -109,  -109,   -40,  -108,    -5,
     -73,  -109,    47,  -109,   -79,    12,  -109,  -109,  -109,    98,
    -109,  -109,  -109,    66,  -109,  -109,  -109,    48,  -109,  -109,
      31,  -109,   -13,  -109
};

/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
   positive, shift that token.  If negative, reduce the rule which
   number is the opposite.  If zero, do what YYDEFACT says.
   If YYTABLE_NINF, syntax error.  */
#define YYTABLE_NINF -73
static const lpt_yytype_int16 lpt_yytable[] =
{
       7,    46,    89,   105,    15,    71,    18,    18,    36,    28,
      40,    26,    48,   112,   106,   107,   129,     3,    27,    56,
      10,    11,   137,    68,   110,    36,    58,   -27,   141,    36,
      46,   120,   143,    26,   112,     6,   -27,   -27,   -27,    14,
      27,   150,   130,    47,   103,    75,    78,   -27,   -27,    18,
     109,    27,    36,    58,    87,   135,    60,    61,    62,   -72,
     -72,   -72,   -72,   -72,    38,   149,   -72,    74,    90,    77,
      27,   104,   -35,   -35,   -35,    97,    96,   146,    65,    66,
     -17,   -17,   -17,    90,    90,   -17,   -17,   -17,   -17,    17,
     -17,   -17,   115,    37,    37,   123,   -17,   131,    39,    39,
      90,   121,    37,    -2,    -2,    37,    38,    39,   114,    38,
      39,   142,    27,   134,    25,    27,    37,    65,    66,   134,
     121,    39,    83,    54,    90,    59,   121,    27,   -36,   -36,
     -36,    64,   121,    60,    61,    62,   121,   -35,   -35,   -35,
     145,    85,   113,    70,   139,   121,   101,   119,   127,    82
};

static const lpt_yytype_uint8 lpt_yycheck[] =
{
       4,    14,    69,    86,     8,    45,    10,    11,    13,    13,
      14,     6,    16,    92,    87,    88,   124,     0,    13,    24,
      17,    18,   130,    36,    91,    30,    30,     0,   136,    34,
      43,   104,   140,     6,   113,    19,     9,    10,    11,    20,
      13,   149,   125,     9,    84,    49,    50,    20,    21,    53,
       8,    13,    57,    57,    67,   128,    14,    15,    16,     4,
       5,     3,     4,     5,     7,   148,     8,    21,    72,    10,
      13,    84,    14,    15,    16,    79,    11,   144,     4,     5,
       3,     4,     5,    87,    88,     8,     3,     4,     5,     6,
      13,     8,    96,     3,     3,   108,    13,     6,     8,     8,
     104,   105,     3,     4,     5,     3,     7,     8,    12,     7,
       8,     5,    13,   126,    11,    13,     3,     4,     5,   132,
     124,     8,    53,    22,   128,    30,   130,    13,    14,    15,
      16,    34,   136,    14,    15,    16,   140,    14,    15,    16,
     144,    57,    95,    43,   132,   149,    80,    99,   117,    51
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const lpt_yytype_uint8 lpt_yystos[] =
{
       0,    25,    26,     0,    27,    28,    19,    24,    39,    40,
      17,    18,    29,    41,    20,    24,    54,     6,    24,    30,
      32,    33,    34,    35,    36,    30,     6,    13,    24,    42,
      43,    44,    46,    48,    49,    50,    72,     3,     7,     8,
      24,    53,    55,    56,    57,    72,    95,     9,    24,    74,
      80,    81,    82,    31,    35,    24,    72,    45,    24,    44,
      14,    15,    16,    52,    50,     4,     5,    70,    95,    59,
      57,    70,    58,    83,    21,    24,    96,    10,    24,    84,
      85,    86,    82,    32,    37,    46,    47,    95,    51,    52,
      24,    73,    75,    77,    95,    87,    11,    24,    88,    89,
      90,    86,    38,    70,    95,    53,    73,    73,    60,     8,
      52,    64,    77,    75,    12,    24,    91,    92,    93,    90,
      73,    24,    71,    95,    66,    65,    94,    93,    61,    71,
      53,     6,    76,    78,    95,    73,    67,    71,    79,    78,
      62,    71,     5,    71,    63,    24,    52,    68,    69,    53,
      71
};

#define lpt_yyerrok		(lpt_yyerrstatus = 0)
#define lpt_yyclearin	(lpt_yychar = YYEMPTY)
#define YYEMPTY		(-2)
#define YYEOF		0

#define YYACCEPT	goto lpt_yyacceptlab
#define YYABORT		goto lpt_yyabortlab
#define YYERROR		goto lpt_yyerrorlab


/* Like YYERROR except do call lpt_yyerror.  This remains here temporarily
   to ease the transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */

#define YYFAIL		goto lpt_yyerrlab

#define YYRECOVERING()  (!!lpt_yyerrstatus)

#define YYBACKUP(Token, Value)					\
do								\
  if (lpt_yychar == YYEMPTY && lpt_yylen == 1)				\
    {								\
      lpt_yychar = (Token);						\
      lpt_yylval = (Value);						\
      lpt_yytoken = YYTRANSLATE (lpt_yychar);				\
      YYPOPSTACK (1);						\
      goto lpt_yybackup;						\
    }								\
  else								\
    {								\
      lpt_yyerror (parm, scanner, YY_("syntax error: cannot back up")); \
      YYERROR;							\
    }								\
while (YYID (0))


#define YYTERROR	1
#define YYERRCODE	256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#define YYRHSLOC(Rhs, K) ((Rhs)[K])
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)				\
    do									\
      if (YYID (N))                                                    \
	{								\
	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
	}								\
      else								\
	{								\
	  (Current).first_line   = (Current).last_line   =		\
	    YYRHSLOC (Rhs, 0).last_line;				\
	  (Current).first_column = (Current).last_column =		\
	    YYRHSLOC (Rhs, 0).last_column;				\
	}								\
    while (YYID (0))
#endif


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if YYLTYPE_IS_TRIVIAL
#  define YY_LOCATION_PRINT(File, Loc)			\
     fprintf (File, "%d.%d-%d.%d",			\
	      (Loc).first_line, (Loc).first_column,	\
	      (Loc).last_line,  (Loc).last_column)
# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


/* YYLEX -- calling `lpt_yylex' with the right arguments.  */

#ifdef YYLEX_PARAM
# define YYLEX lpt_yylex (&lpt_yylval, YYLEX_PARAM)
#else
# define YYLEX lpt_yylex (&lpt_yylval, scanner)
#endif

/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)			\
do {						\
  if (lpt_yydebug)					\
    YYFPRINTF Args;				\
} while (YYID (0))

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
do {									  \
  if (lpt_yydebug)								  \
    {									  \
      YYFPRINTF (stderr, "%s ", Title);					  \
      lpt_yy_symbol_print (stderr,						  \
		  Type, Value, parm, scanner); \
      YYFPRINTF (stderr, "\n");						  \
    }									  \
} while (YYID (0))


/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
lpt_yy_symbol_value_print (FILE *lpt_yyoutput, int lpt_yytype, YYSTYPE const * const lpt_yyvaluep, parse_parm *parm, void *scanner)
#else
static void
lpt_yy_symbol_value_print (lpt_yyoutput, lpt_yytype, lpt_yyvaluep, parm, scanner)
    FILE *lpt_yyoutput;
    int lpt_yytype;
    YYSTYPE const * const lpt_yyvaluep;
    parse_parm *parm;
    void *scanner;
#endif
{
  if (!lpt_yyvaluep)
    return;
  YYUSE (parm);
  YYUSE (scanner);
# ifdef YYPRINT
  if (lpt_yytype < YYNTOKENS)
    YYPRINT (lpt_yyoutput, lpt_yytoknum[lpt_yytype], *lpt_yyvaluep);
# else
  YYUSE (lpt_yyoutput);
# endif
  switch (lpt_yytype)
    {
      default:
	break;
    }
}


/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/