/* Test PIP_Problem Java test class of the Parma Polyhedra Library Java interface. Copyright (C) 2001-2010 Roberto Bagnara Copyright (C) 2010-2016 BUGSENG srl (http://bugseng.com) This file is part of the Parma Polyhedra Library (PPL). The PPL is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. The PPL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA. For the most up-to-date information see the Parma Polyhedra Library site: http://bugseng.com/products/ppl/ . */ import parma_polyhedra_library.*; public class PIP_Problem_test1 { static { try { System.loadLibrary("ppl_java"); } catch (UnsatisfiedLinkError e) { System.out.println("Unable to load the library"); System.out.println(e.getMessage()); System.exit(-1); } } // This code tests the PIP_Problem methods. public static boolean test01() { Variable A = new Variable(0); Variable B = new Variable(1); Variable C = new Variable(2); Variable D = new Variable(3); Variables_Set var_set_D = new Variables_Set(); var_set_D.add(D); Linear_Expression_Variable le_b = new Linear_Expression_Variable(B); Linear_Expression_Variable le_c = new Linear_Expression_Variable(C); Linear_Expression_Variable le_a = new Linear_Expression_Variable(A); Linear_Expression_Variable le_d = new Linear_Expression_Variable(D); Coefficient coeff_1 = new Coefficient(1); Coefficient coeff_3 = new Coefficient(3); Coefficient coeff_5 = new Coefficient(5); Linear_Expression le_1 = new Linear_Expression_Coefficient(coeff_1); Linear_Expression le_3 = new Linear_Expression_Coefficient(coeff_3); Linear_Expression le_5 = new Linear_Expression_Coefficient(coeff_5); // Constraint declarations. Constraint c_a_geq_1 = new Constraint(le_a, Relation_Symbol.GREATER_OR_EQUAL, le_1); Constraint c_a_leq_5 = new Constraint(le_a, Relation_Symbol.LESS_OR_EQUAL, le_5); Constraint c_b_geq_3 = new Constraint(le_b, Relation_Symbol.GREATER_OR_EQUAL, le_3); Constraint c_d_leq_1 = new Constraint(le_d, Relation_Symbol.LESS_OR_EQUAL, le_1); Constraint constraint1 = c_a_geq_1; Constraint constraint2 = c_b_geq_3; Constraint_System constraints1 = new Constraint_System(); constraints1.add(constraint1); C_Polyhedron ph1 = new C_Polyhedron(3, Degenerate_Element.UNIVERSE); ph1.add_constraints(constraints1); C_Polyhedron ph2 = new C_Polyhedron(4, Degenerate_Element.UNIVERSE); ph2.add_constraints(constraints1); ph2.add_constraint(constraint2); PIP_Problem pip1 = new PIP_Problem(3); pip1.add_constraints(constraints1); Constraint pip1_c1 = pip1.constraint_at_index(0); long pip1_dim = pip1.space_dimension(); PIP_Problem pip2 = new PIP_Problem(pip1_dim); pip2.add_constraints(constraints1); boolean ok = (pip2.space_dimension() == 3); if (!ok) return false; PIP_Problem pip3 = new PIP_Problem(3); pip3.add_constraints(constraints1); pip3.add_space_dimensions_and_embed(0, 1); pip3.add_constraint(constraint2); ok = ok && (pip3.space_dimension() == 4); Constraint constraint4 = c_d_leq_1; Constraint_System constraints4 = new Constraint_System(); constraints4.add(constraint1); constraints4.add(constraint4); PIP_Problem pip4 = new PIP_Problem(4, constraints4, var_set_D); ok = ok && (pip4.space_dimension() == 4) && (pip4.number_of_parameter_space_dimensions() == 1); return ok; } // This code tests more PIP_Problem methods. public static boolean test02() { Variable A = new Variable(0); Variable B = new Variable(1); Linear_Expression_Variable le_a = new Linear_Expression_Variable(A); Coefficient coeff_0 = new Coefficient(0); Coefficient coeff_1 = new Coefficient(1); Coefficient coeff_5 = new Coefficient(5); Coefficient coeff_8 = new Coefficient(8); Linear_Expression le_1 = new Linear_Expression_Coefficient(coeff_1); Linear_Expression le_5 = new Linear_Expression_Coefficient(coeff_5); Linear_Expression le_8 = new Linear_Expression_Coefficient(coeff_8); // Constraint declarations. Constraint c_a_geq_1 = new Constraint(le_a, Relation_Symbol.GREATER_OR_EQUAL, le_1); Constraint c_a_leq_5 = new Constraint(le_a, Relation_Symbol.LESS_OR_EQUAL, le_5); Constraint c_a_eq_8 = new Constraint(le_a, Relation_Symbol.EQUAL, le_8); Constraint constraint1 = c_a_geq_1; Constraint_System constraints1 = new Constraint_System(); constraints1.add(constraint1); Variables_Set var_set_B = new Variables_Set(); var_set_B.add(B); PIP_Problem pip1 = new PIP_Problem(2); pip1.add_constraints(constraints1); long pip1_dim = pip1.space_dimension(); pip1.add_to_parameter_space_dimensions(var_set_B); Variables_Set var_set1 = pip1.parameter_space_dimensions(); boolean ok = (var_set1.contains(B)); if (!ok) return false; ok = pip1.is_satisfiable(); if (!ok) return false; PIP_Problem_Status pip1_status; pip1_status = pip1.solve(); ok = ok && (pip1_status == PIP_Problem_Status.OPTIMIZED_PIP_PROBLEM); PIP_Problem_Status pip2_status; pip1.add_constraint(c_a_leq_5); pip2_status = pip1.solve(); ok = ok && (pip2_status == PIP_Problem_Status.OPTIMIZED_PIP_PROBLEM); if (!ok) return false; PPL_Test.println_if_noisy("Testing toString() and wrap_string(): "); PPL_Test.println_if_noisy(IO.wrap_string(pip1.toString(), 4, 64, 60)); PPL_Test.println_if_noisy(); PPL_Test.print_if_noisy("Testing max_space_dimension(): "); long max_space_dim = pip1.max_space_dimension(); PPL_Test.println_if_noisy(max_space_dim); PIP_Problem_Control_Parameter_Value cp_value1 = pip1.get_pip_problem_control_parameter (PIP_Problem_Control_Parameter_Name.CUTTING_STRATEGY); pip1.set_pip_problem_control_parameter( PIP_Problem_Control_Parameter_Value.CUTTING_STRATEGY_FIRST); PIP_Problem_Control_Parameter_Value cp_value2 = pip1.get_pip_problem_control_parameter (PIP_Problem_Control_Parameter_Name.CUTTING_STRATEGY); ok = ok && (cp_value2 == PIP_Problem_Control_Parameter_Value.CUTTING_STRATEGY_FIRST); if (!ok) return false; pip1.set_pip_problem_control_parameter( PIP_Problem_Control_Parameter_Value.PIVOT_ROW_STRATEGY_MAX_COLUMN); PIP_Problem_Control_Parameter_Value cp_value3 = pip1.get_pip_problem_control_parameter (PIP_Problem_Control_Parameter_Name.PIVOT_ROW_STRATEGY); ok = ok && (cp_value3 == PIP_Problem_Control_Parameter_Value .PIVOT_ROW_STRATEGY_MAX_COLUMN); pip1.set_pip_problem_control_parameter( PIP_Problem_Control_Parameter_Value.CUTTING_STRATEGY_ALL); PIP_Problem_Control_Parameter_Value cp_value4 = pip1.get_pip_problem_control_parameter (PIP_Problem_Control_Parameter_Name.CUTTING_STRATEGY); ok = ok && (cp_value4 == PIP_Problem_Control_Parameter_Value.CUTTING_STRATEGY_ALL); return ok && pip1.OK(); } // This code tests PIP_Tree and its methods. public static boolean test03() { Variable A = new Variable(0); Variable B = new Variable(1); Variable C = new Variable(2); Variable D = new Variable(3); Variables_Set var_set_D = new Variables_Set(); var_set_D.add(D); Linear_Expression_Variable le_b = new Linear_Expression_Variable(B); Linear_Expression_Variable le_c = new Linear_Expression_Variable(C); Linear_Expression_Variable le_a = new Linear_Expression_Variable(A); Linear_Expression_Variable le_d = new Linear_Expression_Variable(D); Coefficient coeff_0 = new Coefficient(0); Coefficient coeff_1 = new Coefficient(1); Coefficient coeff_3 = new Coefficient(3); Coefficient coeff_5 = new Coefficient(5); Coefficient coeff_8 = new Coefficient(8); Linear_Expression le_1 = new Linear_Expression_Coefficient(coeff_1); Linear_Expression le_3 = new Linear_Expression_Coefficient(coeff_3); Linear_Expression le_5 = new Linear_Expression_Coefficient(coeff_5); Linear_Expression le_8 = new Linear_Expression_Coefficient(coeff_8); // Constraint declarations. Constraint c_a_geq_1 = new Constraint(le_a, Relation_Symbol.GREATER_OR_EQUAL, le_1); Constraint c_a_leq_5 = new Constraint(le_a, Relation_Symbol.LESS_OR_EQUAL, le_5); Constraint c_a_eq_8 = new Constraint(le_a, Relation_Symbol.EQUAL, le_8); Constraint c_d_leq_1 = new Constraint(le_d, Relation_Symbol.LESS_OR_EQUAL, le_1); Constraint constraint1 = c_a_geq_1; Constraint_System constraints1 = new Constraint_System(); constraints1.add(constraint1); Variables_Set var_set_B = new Variables_Set(); var_set_B.add(B); PIP_Problem pip1 = new PIP_Problem(2); pip1.add_constraints(constraints1); long pip1_dim = pip1.space_dimension(); pip1.add_to_parameter_space_dimensions(var_set_B); Variables_Set var_set1 = pip1.parameter_space_dimensions(); boolean ok = pip1.is_satisfiable(); if (!ok) return false; PIP_Tree_Node ptree1 = pip1.solution(); long num_of_arts1 = ptree1.number_of_artificials(); Artificial_Parameter_Sequence arts1 = ptree1.artificials(); ok = ptree1.OK() && num_of_arts1 == 0 && arts1.size() == 0; if (!ok) return false; PIP_Solution_Node psol1 = ptree1.as_solution(); PIP_Decision_Node pdec1 = ptree1.as_decision(); if (psol1 == null || pdec1 != null) return false; Constraint_System ptree1_constraints = ptree1.constraints(); C_Polyhedron pip1_ph = new C_Polyhedron(pip1_dim, Degenerate_Element.UNIVERSE); C_Polyhedron ph1 = new C_Polyhedron(pip1_dim, Degenerate_Element.UNIVERSE); ph1.add_constraint(constraint1); pip1_ph.add_constraints(ptree1_constraints); ok = ok && !pip1_ph.equals(ph1); if (!ok) return false; PPL_Test.println_if_noisy("Testing toString() and wrap_string(): "); PPL_Test.println_if_noisy(IO.wrap_string(ptree1.toString(), 4, 64, 60)); PPL_Test.println_if_noisy(); Constraint constraint2 = c_d_leq_1; Constraint_System constraints2 = new Constraint_System(); constraints2.add(constraint1); constraints2.add(constraint2); PIP_Problem pip2 = new PIP_Problem(4, constraints2, var_set_D); PIP_Tree_Node ptree2 = pip2.solution(); long num_of_arts2 = ptree2.number_of_artificials(); ok = (ptree2.OK() && (num_of_arts2 == 0)); if (!ok) return false; PIP_Solution_Node psol2 = ptree2.as_solution(); PIP_Decision_Node pdec2 = ptree2.as_decision(); Artificial_Parameter_Sequence arts2 = ptree2.artificials(); if (psol2 == null || pdec2 != null) return false; ok = arts2.isEmpty(); if (!ok) return false; PPL_Test.println_if_noisy("Testing toString() and wrap_string(): "); PPL_Test.println_if_noisy(IO.wrap_string(ptree2.toString(), 4, 64, 60)); PPL_Test.println_if_noisy(); return true; } // This code is based on test02 in pipproblem1.cc. public static boolean test04() { Variable I = new Variable(0); Variable J = new Variable(1); Variable N = new Variable(2); Variable M = new Variable(3); Variables_Set params = new Variables_Set(); params.add(N); params.add(M); Linear_Expression_Variable le_i = new Linear_Expression_Variable(I); Linear_Expression_Variable le_j = new Linear_Expression_Variable(J); Linear_Expression_Variable le_n = new Linear_Expression_Variable(N); Linear_Expression_Variable le_m = new Linear_Expression_Variable(M); Coefficient coeff_0 = new Coefficient(0); Coefficient coeff_1 = new Coefficient(1); Coefficient coeff_2 = new Coefficient(2); Coefficient coeff_3 = new Coefficient(3); Coefficient coeff_4 = new Coefficient(4); Coefficient coeff_7 = new Coefficient(7); Coefficient coeff_8 = new Coefficient(8); Coefficient coeff_10 = new Coefficient(10); Linear_Expression le_0 = new Linear_Expression_Coefficient(coeff_0); Linear_Expression le_1 = new Linear_Expression_Coefficient(coeff_1); Linear_Expression le_2 = new Linear_Expression_Coefficient(coeff_2); Linear_Expression le_3 = new Linear_Expression_Coefficient(coeff_3); Linear_Expression le_4 = new Linear_Expression_Coefficient(coeff_4); Linear_Expression le_7 = new Linear_Expression_Coefficient(coeff_7); Linear_Expression le_8 = new Linear_Expression_Coefficient(coeff_8); Linear_Expression le_10 = new Linear_Expression_Coefficient(coeff_10); Linear_Expression le_2i = le_i.times(coeff_2); Linear_Expression le_3j = le_j.times(coeff_3); Linear_Expression le_2i_plus_3j = le_2i.sum(le_3j); Linear_Expression le_4i = le_i.times(coeff_4); Linear_Expression le_4i_diff_j = le_4i.subtract(le_j); Linear_Expression le_m_diff_j = le_m.subtract(le_j); Linear_Expression le_n_diff_i = le_n.subtract(le_i); // Constraint declarations. Constraint c_1 = new Constraint(le_2i_plus_3j, Relation_Symbol.GREATER_OR_EQUAL, le_8); Constraint c_2 = new Constraint(le_4i_diff_j, Relation_Symbol.GREATER_OR_EQUAL, le_4); Constraint c_3 = new Constraint(le_m_diff_j, Relation_Symbol.GREATER_OR_EQUAL, le_0); Constraint c_4 = new Constraint(le_n_diff_i, Relation_Symbol.GREATER_OR_EQUAL, le_0); Constraint_System cs = new Constraint_System(); cs.add(c_1); cs.add(c_2); cs.add(c_3); cs.add(c_4); PIP_Problem pip = new PIP_Problem(4, cs, params); // Known to overflow if PPL uses 8-bits checked integers. try { pip.solve(); } catch (Overflow_Error_Exception ex) { if (Coefficient.bits() != 8) throw ex; PPL_Test.println_if_noisy("Expected overflow exception caught:"); PPL_Test.println_if_noisy(ex.getMessage()); return true; } PIP_Problem_Status pip_status = pip.solve(); boolean ok = (pip_status == PIP_Problem_Status.OPTIMIZED_PIP_PROBLEM); if (!ok) return false; PIP_Tree_Node solution = pip.solution(); ok = solution.OK(); if (!ok) return false; PPL_Test.println_if_noisy(); PPL_Test.println_if_noisy("Testing toString():"); PPL_Test.println_if_noisy(solution.toString()); PPL_Test.println_if_noisy(); PIP_Decision_Node root = solution.as_decision(); if (root == null || !root.OK()) return false; if (root.number_of_artificials() != 0) return false; Constraint_System cs1 = root.constraints(); if (cs1.size() != 1) return false; Constraint c = cs.get(0); Linear_Expression le_left = c.left_hand_side(); Linear_Expression le_right = c.right_hand_side(); Relation_Symbol relsym = c.kind(); if (relsym != Relation_Symbol.GREATER_OR_EQUAL || (le_left.is_zero()) || (le_right.is_zero())) return false; PIP_Tree_Node root_true_branch = root.child_node(true); if (root_true_branch == null) return false; PPL_Test.println_if_noisy("PIP Tree root node Constraint: "); PPL_Test.println_if_noisy(IO.wrap_string(c.toString(), 4, 64, 60)); PPL_Test.println_if_noisy(); PIP_Decision_Node t_child = root_true_branch.as_decision(); if (t_child == null || !t_child.OK()) return false; // Check t_child node context. if (t_child.number_of_artificials() != 0) return false; Constraint_System cs2 = t_child.constraints(); if (cs2.size() != 1) return false; Constraint c2 = cs2.get(0); Linear_Expression le_left2 = c2.left_hand_side(); Linear_Expression le_right2 = c2.right_hand_side(); Relation_Symbol relsym2 = c2.kind(); if (relsym2 != Relation_Symbol.GREATER_OR_EQUAL || (le_left2.is_zero()) || (le_right2.is_zero())) return false; if (t_child.child_node(true) == null) return false; PIP_Solution_Node t_t_child = t_child.child_node(true).as_solution(); if (t_t_child == null || !t_t_child.OK()) return false; // Check t_t_child node. if (t_t_child.number_of_artificials() != 0) return false; Constraint_System cs3 = t_t_child.constraints(); if (cs3.size() != 0) return false; Linear_Expression v_i = t_t_child.parametric_values(I); Linear_Expression v_j = t_t_child.parametric_values(J); PIP_Solution_Node t_f_child = t_child.child_node(false).as_solution(); if (t_f_child == null || !t_f_child.OK()) return false; // Check t_f_child node. // Check artificial parameter. if (t_f_child.number_of_artificials() != 1) return false; Artificial_Parameter ap = t_f_child.artificials().get(0); Linear_Expression ap_le = ap.linear_expression(); Coefficient ap_den = ap.denominator(); PPL_Test.println_if_noisy("Artificial_Parameter linear_expression: "); PPL_Test.println_if_noisy(IO.wrap_string(ap_le.toString(), 4, 64, 60)); PPL_Test.println_if_noisy(); PPL_Test.println_if_noisy("Artificial_Parameter denominator: "); PPL_Test.println_if_noisy(IO.wrap_string(ap_den.toString(), 4, 64, 60)); PPL_Test.println_if_noisy(); // Check context. Constraint_System cs4 = t_f_child.constraints(); if (cs4.size() != 1) return false; Constraint c4 = cs4.get(0); if (c4.kind() != Relation_Symbol.GREATER_OR_EQUAL) return false; // Check parametric values. Linear_Expression v_i4 = t_f_child.parametric_values(I); Linear_Expression v_j4 = t_f_child.parametric_values(J); return true; } public static void main(String[] args) { Parma_Polyhedra_Library.initialize_library(); boolean test_result_ok = Test_Executor.executeTests(PIP_Problem_test1.class); Parma_Polyhedra_Library.finalize_library(); if (!test_result_ok) System.exit(1); System.exit(0); } }