ppl-1.2/src/ppl.hh.dist

64955     <CODE>q == sc_expr[u]/sc_denom</CODE> is greater than zero. In particular:
64962                                const Linear_Expression& sc_expr,
65044     <CODE>q == sc_expr[u]/sc_denom</CODE> is greater than zero.
65052                                const Linear_Expression& sc_expr,
69323     computed according to \p sc_expr and \p sc_denom.
69331     <CODE>q == sc_expr[u]/sc_denom</CODE> of \c u in \p sc_expr
69346                             const Linear_Expression& sc_expr,
69356     for \c v computed according to \p sc_expr and \p sc_denom.
69365     <CODE>q == sc_expr[u]/sc_denom</CODE> of \c u in \p sc_expr
69380                                   const Linear_Expression& sc_expr,
75238                        const Linear_Expression& sc_expr,
75262   for (Linear_Expression::const_iterator u = sc_expr.begin(),
75263       u_end = sc_expr.lower_bound(Variable(last_id + 1)); u != u_end; ++u) {
75357                              const Linear_Expression& sc_expr,
75379   for (Linear_Expression::const_iterator u = sc_expr.begin(),
75380       u_end = sc_expr.lower_bound(Variable(last_id + 1)); u != u_end; ++u) {
75753     const Linear_Expression& sc_expr = is_sc ? expr : minus_expr;
75774         // Approximate the homogeneous part of `sc_expr'.
75780         // a zero coefficient in `sc_expr'.
75790           const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
75794             // Approximating `sc_expr'.
75807             // Approximating `-sc_expr'.
75824             // Approximating `sc_expr'.
75837             // Approximating `-sc_expr'.
75882             deduce_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom, sum);
75888                 = sc_expr.coefficient(Variable(pinf_index));
75934             deduce_minus_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom,
75941                 = sc_expr.coefficient(Variable(neg_pinf_index));
75978         // Approximate the homogeneous part of `sc_expr'.
75993           const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
75998           // Choose carefully: we are approximating `sc_expr'.
76035           deduce_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom, sum);
76065         // Compute an upper approximation for `-sc_expr' into `sum'.
76066         // Note: approximating `-sc_expr' from above and then negating the
76067         // result is the same as approximating `sc_expr' from below.
76072         // Approximate the homogeneous part of `-sc_expr'.
76085           const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
76090           // Choose carefully: we are approximating `-sc_expr'.
76129           deduce_minus_v_pm_u_bounds(var_id, pinf_index, sc_expr, sc_denom,
76368   const Linear_Expression& sc_expr = is_sc ? expr : minus_expr;
76383   // Approximate the homogeneous part of `sc_expr'.
76389   // a zero coefficient in `sc_expr'.
76399     const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
76403       // Approximating `sc_expr'.
76416       // Approximating `-sc_expr'.
76433       // Approximating `sc_expr'.
76446       // Approximating `-sc_expr'.
76493       deduce_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom, pos_sum);
76498         const Coefficient& ppi = sc_expr.coefficient(Variable(pos_pinf_index));
76543       deduce_minus_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom, neg_sum);
76548         const Coefficient& npi = sc_expr.coefficient(Variable(neg_pinf_index));
77349   const Linear_Expression& sc_expr = is_sc ? expr : minus_expr;
77360       // Compute an upper approximation for `sc_expr' into `sum'.
77364       // Approximate the homogeneous part of `sc_expr'.
77369       // a zero coefficient in `sc_expr'.
77378         const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
77383         // Choose carefully: we are approximating `sc_expr'.
77430         deduce_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom, sum);
77462       // Compute an upper approximation for `-sc_expr' into `sum'.
77463       // Note: approximating `-sc_expr' from above and then negating the
77464       // result is the same as approximating `sc_expr' from below.
77471       // Approximate the homogeneous part of `-sc_expr'.
77480         const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
77485         // Choose carefully: we are approximating `-sc_expr'.
77533         deduce_minus_v_pm_u_bounds(var_id, pinf_index, sc_expr, sc_denom, sum);
77942   const Linear_Expression& sc_expr = is_sc ? lb_expr : minus_expr;
77953   // Approximate the homogeneous part of `sc_expr'.
77959   // a zero coefficient in `sc_expr'.
77968     const Coefficient& sc_i = sc_expr.coefficient(Variable(id));
77972       // Approximating `-sc_expr'.
77989       // Approximating `-sc_expr'.
78039       deduce_minus_v_pm_u_bounds(var_id, w_id, sc_expr, sc_denom, neg_sum);
78044         const Coefficient& npi = sc_expr.coefficient(Variable(neg_pinf_index));
83957                           const Linear_Expression& sc_expr,
83978   for (Linear_Expression::const_iterator u = sc_expr.begin(),
83979         u_end = sc_expr.lower_bound(Variable(last_v)); u != u_end; ++u) {
83999         // rational coefficient of `u' in `sc_expr/sc_denom',
84024                           const Linear_Expression& sc_expr,
84047   for (Linear_Expression::const_iterator u = sc_expr.begin(),
84048         u_end = sc_expr.lower_bound(Variable(last_v)); u != u_end; ++u) {
84069         // rational coefficient of `u' in `sc_expr/sc_denom',
84281   const Linear_Expression& sc_expr = is_sc ? expr : minus_expr;
84310       // Approximate the homogeneous part of `sc_expr'.
84313       for (Linear_Expression::const_iterator i = sc_expr.begin(),
84314             i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
84321           // Approximating `sc_expr'.
84332           // Approximating `-sc_expr'.
84349           // Approximating `sc_expr'.
84360           // Approximating `-sc_expr'.
84401           deduce_v_minus_u_bounds(v, w, sc_expr, sc_denom, sum);
84406               && sc_expr.get(Variable(pinf_index - 1)) == sc_denom) {
84425           deduce_u_minus_v_bounds(v, w, sc_expr, sc_denom, neg_sum);
84429               && sc_expr.get(Variable(neg_pinf_index - 1)) == sc_denom) {
84445     // Approximate the homogeneous part of `sc_expr'.
84448     for (Linear_Expression::const_iterator i = sc_expr.begin(),
84449           i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
84454       // Choose carefully: we are approximating `sc_expr'.
84489       deduce_v_minus_u_bounds(v, w, sc_expr, sc_denom, sum);
84500     // Compute an upper approximation for `-sc_expr' into `sum'.
84501     // Note: approximating `-sc_expr' from above and then negating the
84502     // result is the same as approximating `sc_expr' from below.
84507     // Approximate the homogeneous part of `-sc_expr'.
84508     for (Linear_Expression::const_iterator i = sc_expr.begin(),
84509           i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
84514       // Choose carefully: we are approximating `-sc_expr'.
84549       deduce_u_minus_v_bounds(v, w, sc_expr, sc_denom, sum);
84755   const Linear_Expression& sc_expr = is_sc ? expr : minus_expr;
84770   // Approximate the homogeneous part of `sc_expr'.
84777   // a zero coefficient in `sc_expr'.
84778   for (Linear_Expression::const_iterator i = sc_expr.begin(),
84779         i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
84785       // Approximating `sc_expr'.
84796       // Approximating `-sc_expr'.
84813       // Approximating `sc_expr'.
84824       // Approximating `-sc_expr'.
84871       deduce_v_minus_u_bounds(v, w, sc_expr, sc_denom, pos_sum);
84874           && sc_expr.get(Variable(pos_pinf_index - 1)) == sc_denom) {
84899       deduce_u_minus_v_bounds(v, w, sc_expr, sc_denom, neg_sum);
84903           && sc_expr.get(Variable(neg_pinf_index - 1)) == sc_denom) {
85933   const Linear_Expression& sc_expr = is_sc ? ub_expr : minus_expr;
85944   // Approximate the homogeneous part of `sc_expr'.
85950   // a zero coefficient in `sc_expr'.
85951   for (Linear_Expression::const_iterator i = sc_expr.begin(),
85952         i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
85958       // Approximating `sc_expr'.
85975       // Approximating `sc_expr'.
86019       deduce_v_minus_u_bounds(v, w, sc_expr, sc_denom, pos_sum);
86023              && sc_expr.get(Variable(pos_pinf_index - 1)) == sc_denom) {
86353   const Linear_Expression& sc_expr = is_sc ? expr : minus_expr;
86367     // Compute an upper approximation for `sc_expr' into `sum'.
86371     // Approximate the homogeneous part of `sc_expr'.
86373     // a zero coefficient in `sc_expr'.
86375     for (Linear_Expression::const_iterator i = sc_expr.begin(),
86376         i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
86381       // Choose carefully: we are approximating `sc_expr'.
86428       deduce_v_minus_u_bounds(v, w, sc_expr, sc_denom, sum);
86440     // Compute an upper approximation for `-sc_expr' into `sum'.
86441     // Note: approximating `-sc_expr' from above and then negating the
86442     // result is the same as approximating `sc_expr' from below.
86446     // Approximate the homogeneous part of `-sc_expr'.
86447     for (Linear_Expression::const_iterator i = sc_expr.begin(),
86448         i_end = sc_expr.lower_bound(Variable(w)); i != i_end; ++i) {
86453       // Choose carefully: we are approximating `-sc_expr'.
86500       deduce_u_minus_v_bounds(v, w, sc_expr, sc_denom, sum);