/* Various tests on the Prolog interface.
   Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
   Copyright (C) 2010-2011 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://www.cs.unipr.it/ppl/ . */


% noisy(F)
% When F = 1, a message is displayed if a time out occurs
% when running the `timeout'` predicate.
% Also, the values of the PPL versions and banner are displayed.
% When F = 0, no 'time out' message or versions are displayed.
% When F = 2, if a test fails and the backtracking returns to a polyhedron
% constructor, the caught error will cause the constraint and generator systems
% for the polyhedron to be displayed.
% noisy/1 can be reset by calling make_noisy/0 or make_quiet/0.

:- dynamic(noisy/1).

% check_all/0
% This executes all the test predicates which, together, check all
% the ppl interface predicates.

check_all :-
   (noisy(_) -> true ; make_quiet),
   list_groups(Groups),
   catch(run_all(Groups), Exception,
         (print_exception_term(Exception), fail)).

% check_quiet/0
% This also executes all the test predicates with no output.

check_quiet :-
   make_quiet,
   check_all.

% check_noisy/0
% check_extra_noisy/0
%
% These also execute all the test predicates but also outputs
% information including the banner, version numbers and expected
% output from the exception tests.

check_noisy :-
   make_noisy,
   check_all.

check_extra_noisy :-
   make_extra_noisy,
   check_all.

% run_all/1
% This executes all the given list of tests, catching any exceptions.
% If any test fails then an error message is output and then it fails.

run_all([Group|Groups]):-
   ppl_initialize,
   (catch(run_one(Group), Exception, run_exception(Group, Exception)) ->
       ppl_finalize,
       run_all(Groups)
   ;
       run_fail(Group)
   ).
run_all([]).

% run_fail/1
% This is used when a test in run_all/1 fails.
% A message is output saying which group of tests has failed;
% then it finalizes the ppl and fails.

run_fail(Group) :-
   group_predicates(Group, Predicates),
   prolog_system(System),
   error_message(['Error occurred while performing test', Group,
                  'which checks predicates:', Predicates]),
   error_message(['Prolog interface checks failed on', System,
                  'Prolog.']),
   ppl_finalize,
   fail.

% run_exception/2
% This is used when a test in run_all/1 causes an exception to be thrown.
% A message is output saying which group of tests was being run when
% the exception was thrown and then it fails.

run_exception(Group, Exception) :-
	group_predicates(Group, Predicates),
	(Exception = ppl_overflow_error(_) ->
	    Kind = 'Overflow exception'
	;
	    Kind = 'Exception'
	),
        prolog_system(System),
 	display_message([Kind, 'occurred while performing test ', Group,
                        'which checks predicates ', nl, Predicates]),
        display_message(['Prolog interface checks failed on', System,
                  'Prolog.']),
	print_exception_term(Exception),
	% Do fail for all but overflow exceptions.
	Exception = ppl_overflow_error(_).

% run_one/1
% Runs the named group of tests.

% Tests predicates that return PPL version information and the PPL banner.
% If noisy(0) holds, there is no output but if not,
% all the versions are printed and the banner is pretty printed.
run_one(all_versions_and_banner) :-
  \+ ppl_version_major(-1),
  ppl_version_major(Vmajor),
  ppl_version_minor(Vminor),
  ppl_version_revision(Vrevision),
  ppl_version_beta(Vbeta),
  ppl_version(V),
  ppl_banner(B),
  (noisy(0) -> true ;
     (
      nl,
      write('Version major is '), write(Vmajor), nl,
      write('Version minor is '), write(Vminor), nl,
      write('Version revision is '), write(Vrevision), nl,
      write('Version beta is '), write(Vbeta), nl,
      write('Version is '), write(V), nl,
      banner_pp(B), nl
     )
  ).

% Tests predicates that return the maximum allowed dimension and coefficients.
% If noisy(0) holds, there is no output but if not, the maximums/minimums
% are printed.
run_one(numeric_bounds) :-
  max_dimension,
  coefficient_bounds,
  set_restore_rounding,
  set_restore_irrational_precision.

run_one(new_polyhedron_from_dimension) :-
  new_polyhedron_from_dim.

run_one(new_polyhedron_from_polyhedron) :-
  new_polyhedron_from_polyhedron.

run_one(new_polyhedron_from_representations) :-
  new_polyhedron_from_cons,
  new_polyhedron_from_gens.

run_one(swap_polyhedra) :-
  swap.

run_one(polyhedron_dimension) :-
   space,
   affine_dim,
   constrains,
   unconstrain_space_dimension,
   unconstrain_space_dimensions.

run_one(basic_operators) :-
   inters_assign,
   polyhull_assign,
   polydiff_assign,
   time_elapse,
   top_close_assign.

run_one(add_to_system) :-
   add_con,
   add_gen,
   add_cons,
   add_gens.

run_one(revise_dimensions) :-
   project,
   embed,
   conc_assign,
   remove_dim,
   remove_high_dim,
   expand_dim,
   map_dim,
   fold_dims.

run_one(transform_polyhedron) :-
   affine_image,
   affine_preimage,
   bounded_affine_image,
   bounded_affine_preimage,
   affine_image_gen,
   affine_preimage_gen,
   affine_image_genlr,
   affine_preimage_genlr.

run_one(extrapolation_operators) :-
   widen_BHRZ03,
   widen_BHRZ03_with_tokens,
   lim_extrapolate_BHRZ03,
   lim_extrapolate_BHRZ03_with_tokens,
   bound_extrapolate_BHRZ03,
   bound_extrapolate_BHRZ03_with_tokens,
   widen_H79,
   widen_H79_with_tokens,
   lim_extrapolate_H79,
   lim_extrapolate_H79_with_tokens,
   bound_extrapolate_H79,
   bound_extrapolate_H79_with_tokens.

run_one(get_system) :-
   get_cons,
   get_min_cons,
   get_gens,
   get_min_gens.

run_one(check_polyhedron) :-
   rel_cons,
   rel_gens,
   checks,
   bounds_from_above,
   bounds_from_below.

run_one(minmax_polyhedron) :-
   maximize,
   minimize,
   maximize_with_point,
   minimize_with_point.

run_one(compare_polyhedra) :-
   contains,
   strict_contains,
   disjoint_from,
   equals,
   ok.

run_one(catch_time) :-
   time_out.

run_one(mip_problem) :-
   mip_problem.

run_one(pip_problem) :-
   pip_problem.

% Checks how the PPL Prolog system performs with large integers
% XSB has problems with large numbers - hence tests for XSB disallowed.
% We catch the exception if it is caused by integer overflow in C++
% and suppress output as this is expected when C++ uses checked_integers.
run_one(large_integers) :-
   prolog_system(Prolog_System),
   (Prolog_System \== 'XSB' ->
     catch(large_integers, ppl_overflow_error(Cause),
        check_exception_term(ppl_overflow_error(Cause)))
   ;
     true
   ).

% Checks the handling of exceptions.
run_one(handle_exceptions) :-
   exceptions.

%%%%%%%%%%%%%%%%% numeric bounds %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

max_dimension :-
  ppl_max_space_dimension(M),
  (noisy(0) -> true ;
     display_message(['Maximum possible dimension is', M, nl])
  ).

% coefficient_bounds/0
% This is mainly to check ppl_Coefficient_is_bounded/0,
% ppl_Coefficient_max/1, ppl_Coefficient_min/1.
% But it has to catch the case when the numeric bounds in the
% prolog system are smaller than any finite bounds in C++
% As the test does not know the configuration, all that can be tested
% here is that the results are consistent and the bounds are
% in a list of possible bounds.

coefficient_bounds :-
    (pl_check_prolog_flag(bounded, true) ->
     (pl_check_prolog_flag(max_integer, PLMax),
      pl_check_prolog_flag(min_integer, PLMin))
   ;
     PLMax = 0, PLMin = 0
  ),
  (ppl_Coefficient_is_bounded ->
     (cpp_bounded_values(Max, Min) -> true
      ;
       (Max = PLMax, Min = PLMin)
     )
  ;
     (cpp_unbounded_check, Max = PLMax, Min = PLMin)
  ),
  (noisy(0) -> true ;
     display_message(['Maximum possible coefficient is', Max, nl]),
     display_message(['Minimum possible coefficient is', Min, nl])
  ).

cpp_unbounded_check :-
  \+ ppl_Coefficient_max(_),
  \+ ppl_Coefficient_min(_).

cpp_bounded_values(Max, Min) :-
  ppl_Coefficient_max(Max),
  ppl_Coefficient_min(Min).

set_restore_rounding :-
  ppl_set_rounding_for_PPL,
  ppl_restore_pre_PPL_rounding.

set_restore_irrational_precision :-
  ppl_irrational_precision(Default),
  Default == 128,
  Non_Default = 100,
  ppl_set_irrational_precision(Non_Default),
  ppl_irrational_precision(Changed),
  Changed == Non_Default,
  ppl_set_irrational_precision(Default),
  ppl_irrational_precision(Restored),
  Restored == Default.

%%%%%%%%%%%%%%%%% New Polyhedron %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Note that throughout the tests, all "new_Polyhedron_from_...(...,P)" calls
% are made in such a way that, if the test fails, P is deleted.
% This is done by using special "clean_new_Polyhedron_from_...(...,P)"
% forms of the predicates that are defined later.
%
% As we also delete P on success of the test, to prevent trying to
% delete P again when a later test fails, we always have a cut before these
% in-line calls to ppl_Polyhedron_delete(P).

% Tests new_C_Polyhedron_from_space_dimension/3,
%       new_NNC_Polyhedron_from_space_dimension/3 and
%       ppl_delete_Polyhedron/1.
new_polyhedron_from_dim :-
  new_polyhedron_from_dim(c, universe),
  new_polyhedron_from_dim(nnc, universe),
  new_polyhedron_from_dim(c, empty),
  new_polyhedron_from_dim(nnc, empty).

% This also uses ppl_Polyhedron_is_universe/1
% and ppl_Polyhedron_is_empty.
new_polyhedron_from_dim(T, Universe_Or_Empty) :-
  \+ clean_ppl_new_Polyhedron_from_space_dimension(T, 3, Universe_Or_Empty, 0),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, Universe_Or_Empty, P),
  (Universe_Or_Empty = universe ->
      (ppl_Polyhedron_is_universe(P),
      \+ ppl_Polyhedron_is_empty(P))
   ;
      (ppl_Polyhedron_is_empty(P),
      \+ ppl_Polyhedron_is_universe(P))
  ),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_new_C_Polyhedron_from_C_Polyhedron/2,
%       ppl_new_C_Polyhedron_from_NNC_Polyhedron/2,
%       ppl_new_NNC_Polyhedron_from_C_Polyhedron/2, and
%       ppl_new_NNC_Polyhedron_from_NNC_Polyhedron/2,
new_polyhedron_from_polyhedron :-
  new_polyhedron_from_polyhedron(c, c),
  new_polyhedron_from_polyhedron(nnc, nnc),
  new_polyhedron_from_polyhedron(c, nnc),
  new_polyhedron_from_polyhedron(nnc, c).

% This also uses ppl_new_Polyhedron_from_constraints/3 and
% ppl_Polyhedron_equals_Polyhedron/2.
new_polyhedron_from_polyhedron(T1, T2) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T1, 3, universe, P1),
  \+ clean_ppl_new_Polyhedron_from_Polyhedron(T1, P1, T2, 0),
  clean_ppl_new_Polyhedron_from_Polyhedron(T1, P1, T2, P2),
  clean_ppl_new_Polyhedron_from_Polyhedron(T2, P2, T1, P1a),
  ppl_Polyhedron_equals_Polyhedron(P1, P1a),
  clean_ppl_new_Polyhedron_from_Polyhedron(T1, P1a, T2, P2a),
  ppl_Polyhedron_equals_Polyhedron(P2, P2a),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P1a),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P2a),
  make_vars(3, [A, B, C]),
  (T1 = c
          -> CS = [3 >= A, 4 >= A, 4*A + B - 2*C >= 5]
          ;  CS = [3 >= A, 4 >  A, 4*A + B - 2*C >= 5]
  ),
  clean_ppl_new_Polyhedron_from_constraints(T1, CS, P3),
  clean_ppl_new_Polyhedron_from_Polyhedron(T1, P3, T2, P4),
  clean_ppl_new_Polyhedron_from_Polyhedron(T2, P4, T1, P3a),
  clean_ppl_new_Polyhedron_from_Polyhedron(T1, P3a, T2, P4a),
  ppl_Polyhedron_equals_Polyhedron(P3, P3a),
  ppl_Polyhedron_equals_Polyhedron(P4, P4a),
  !,
  ppl_delete_Polyhedron(P3),
  ppl_delete_Polyhedron(P4),
  ppl_delete_Polyhedron(P3a),
  ppl_delete_Polyhedron(P4a).

% Tests ppl_new_Polyhedron_from_constraints/2
%       ppl_new_Polyhedron_from_constraints/2.
new_polyhedron_from_cons :-
  new_polyhedron_from_cons(c, [3 >= '$VAR'(1)]),
  make_vars(4, [A, B, C, D]),
  new_polyhedron_from_cons(c, [3 >= A, 4*A + B - 2*C >= 5, D = 1]),
  new_polyhedron_from_cons(c, [B >= A, 4*A + B - 2*C >= 5, D = 1]),
  new_polyhedron_from_cons(nnc, [3 > A, 4*A + B - 2*C >= 5, D = 1]),
  new_polyhedron_from_cons(nnc, [B > A, 4*A + B - 2*C >= 5, D = 1]).

new_polyhedron_from_cons(T, CS) :-
  clean_ppl_new_Polyhedron_from_constraints(T, [], P),
  \+ clean_ppl_new_Polyhedron_from_constraints(T, [], 0),
  ppl_Polyhedron_is_universe(P),
  clean_ppl_new_Polyhedron_from_constraints(T, CS, Pa),
  \+ ppl_Polyhedron_is_universe(Pa),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Pa).

% Tests ppl_new_Polyhedron_from_generators/2 and
%       ppl_new_Polyhedron_from_generators/2.
new_polyhedron_from_gens :-
  make_vars(3, [A, B, C]),
  new_polyhedron_from_gens(c,[point(A + B + C, 1), point(A + B + C)] ),
  new_polyhedron_from_gens(nnc,  [point(A + B + C), closure_point(A + B + C)]).

new_polyhedron_from_gens(T, GS) :-
  \+ clean_ppl_new_Polyhedron_from_generators(T, [], 0),
  clean_ppl_new_Polyhedron_from_generators(T, [], P),
  ppl_Polyhedron_is_empty(P),
  clean_ppl_new_Polyhedron_from_generators(T, GS, Pa),
  \+ ppl_Polyhedron_is_empty(Pa),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Pa).


%%%%%%%%%%%%%%%%% Swap Polyhedra %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_swap/2.
swap :-
  swap(c), swap(nnc).

swap(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, empty, Q),
  ppl_Polyhedron_swap(P, Q),
  ppl_Polyhedron_is_empty(P),
  ppl_Polyhedron_is_universe(Q),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

%%%%%%%%%%%%%%%%%% Poly Dimension %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_space_dimension/2.
space :-
 space(c), space(nnc).

space(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_space_dimension(P, N),
  N = 3,
  \+ ppl_Polyhedron_space_dimension(P, 4),
  clean_ppl_new_Polyhedron_from_generators(T, [], Q),
  ppl_Polyhedron_space_dimension(Q, M),
  M == 0,
  clean_ppl_new_Polyhedron_from_constraints(T, [], Q1),
  ppl_Polyhedron_space_dimension(Q1, M1),
  M1 == 0,
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q),
  ppl_delete_Polyhedron(Q1).


% Tests ppl_Polyhedron_affine_dimension/2.
affine_dim :-
 affine_dim(c), affine_dim(nnc).

affine_dim(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_affine_dimension(P, N),
  N == 3,
  \+ ppl_Polyhedron_affine_dimension(P, 2),
  clean_ppl_new_Polyhedron_from_generators(T, [], Q),
  ppl_Polyhedron_affine_dimension(Q, M),
  M == 0,
  clean_ppl_new_Polyhedron_from_constraints(T, [], Q1),
  ppl_Polyhedron_affine_dimension(Q1, M1),
  M1 == 0,
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q),
  ppl_delete_Polyhedron(Q1),
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(A), ray(B)],
                                     P1),
  ppl_Polyhedron_space_dimension(P1, 2),
  ppl_Polyhedron_affine_dimension(P1, 1),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(A + B, 2)],
                                     P2),
  ppl_Polyhedron_space_dimension(P2, 2),
  ppl_Polyhedron_affine_dimension(P2, 0),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B >= 0, B >= 0,
                                       A + B =< 1, B =< 0],
                                      P3),
  ppl_Polyhedron_space_dimension(P3, 2),
  ppl_Polyhedron_affine_dimension(P3, 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B >= 0, B >= 1,
                                       A + B =< 1],
                                      P4),
  (T = c ->
            ppl_Polyhedron_add_constraint(P4, B =< 0)
         ;
            ppl_Polyhedron_add_constraint(P4, B < 1)
  ),
  ppl_Polyhedron_space_dimension(P4, 2),
  ppl_Polyhedron_affine_dimension(P4, 0),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P3),
  ppl_delete_Polyhedron(P4).

% Tests ppl_Polyhedron_constrains/2.
constrains :-
  constrains(c), constrains(nnc).

constrains(T) :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [B >= 0, B - C >= 2]),
  ppl_Polyhedron_constrains(P, B),
  \+ppl_Polyhedron_constrains(P, A),
  ppl_Polyhedron_OK(P),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_unconstrain_space_dimension/2.
unconstrain_space_dimension :-
  unconstrain_space_dimension(c), unconstrain_space_dimension(nnc).

unconstrain_space_dimension(T) :-
  make_vars(3, [_A, B, C]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [B >= 0, B - C >= 2]),
  ppl_Polyhedron_unconstrain_space_dimension(P, B),
  \+ppl_Polyhedron_constrains(P, B),
  ppl_Polyhedron_OK(P),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_unconstrain_space_dimensions/2.
unconstrain_space_dimensions :-
  unconstrain_space_dimensions(c), unconstrain_space_dimensions(nnc).

unconstrain_space_dimensions(T) :-
  make_vars(3, [_A, B, C]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [B >= 0, B - C >= 2]),
  ppl_Polyhedron_unconstrain_space_dimensions(P, []),
  ppl_Polyhedron_constrains(P, B),
  ppl_Polyhedron_unconstrain_space_dimensions(P, [B]),
  \+ppl_Polyhedron_constrains(P, B),
  ppl_Polyhedron_unconstrain_space_dimensions(P, [B]),
  \+ppl_Polyhedron_constrains(P, B),
  ppl_Polyhedron_OK(P),
  !,
  ppl_delete_Polyhedron(P).

%%%%%%%%%%%%%%%% Basic Operators %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_intersection_assign/2.
inters_assign :-
  inters_assign(c), inters_assign(nnc).

inters_assign(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(0), point(B),
                                      point(A), point(A, 2)],
                                     P1),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(0), point(A),
                                      point(A + B), point(A, 2)],
                                     P2),
  ppl_Polyhedron_intersection_assign(P1, P2),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(A + B, 2),
                                      point(A), point(0)],
                                     P1a),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B >= 0, B >= 0,
                                       A + B =< 1],
                                      P1b),
  ppl_Polyhedron_equals_Polyhedron(P1, P1a),
  ppl_Polyhedron_equals_Polyhedron(P1, P1b),
  clean_ppl_new_Polyhedron_from_constraints(T, [A =< -1, B =< -1], P3),
  ppl_Polyhedron_intersection_assign(P1, P3),
  ppl_Polyhedron_is_empty(P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P3),
  ppl_delete_Polyhedron(P1a),
  ppl_delete_Polyhedron(P1b).

% Tests ppl_Polyhedron_concatenate_assign/2.
conc_assign :-
  conc_assign(c), conc_assign(nnc).

conc_assign(T) :-
  make_vars(5, [A, B, C, D, E]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  clean_ppl_new_Polyhedron_from_constraints(T, [A >= 1, B >= 0, C >= 0], Q),
  ppl_Polyhedron_concatenate_assign(P, Q),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [C >= 1, D >= 0, E >= 0],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_poly_hull_assign/2.
polyhull_assign :-
  polyhull_assign(c), polyhull_assign(nnc).

polyhull_assign(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(0), point(B),
                                      point(A), point(A,2)],
                                     P1),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(0), point(A),
                                      point(A + B), point(A, 2)],
                                     P2),
  ppl_Polyhedron_poly_hull_assign(P1, P2),
  clean_ppl_new_Polyhedron_from_generators(T,
      [point(1*A+1*B), point(1*A, 2), point(1*A), point(1*B), point(0)], P1a),
  clean_ppl_new_Polyhedron_from_constraints(T,
      [1*A>=0, 1*B>=0, -1*B>= -1, -1*A>= -1], P1b),
  ppl_Polyhedron_equals_Polyhedron(P1, P1a),
  ppl_Polyhedron_equals_Polyhedron(P1, P1b),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P1a),
  ppl_delete_Polyhedron(P1b).

% Tests ppl_Polyhedron_poly_difference_assign/2.
polydiff_assign :-
  make_vars(2, [A, B]),
  GS0 = [point(2*A)],
  GS1 = [point(0), point(2*A)],
  GS2 = [point(0), point(A)],
  GS3 = [point(A), point(2*A)],
  GS4 = [closure_point(A), point(2*A)],
  GS4a = [closure_point(A), point(3*A, 2), closure_point(2*A)],
  polydiff_assign(c, GS1, GS2, GS3),
  polydiff_assign(c, GS1, GS3, GS2),
  polydiff_assign(c, GS3, GS0, GS3),
  polydiff_assign(nnc, GS1, GS2, GS4),
  polydiff_assign(nnc, GS1, GS4, GS2),
  polydiff_assign(nnc, GS4, GS0, GS4a),
  GS5 = [point(0), point(B), point(A)],
  GS6 = [point(0), point(A), point(A + B)],
  GS6a = [point(0), point(A), point(A + B, 2)],
  GS7 = [point(A + B, 2), point(B), point(0)],
  GS8 = [closure_point(A + B, 2), point(B), closure_point(0)],
  polydiff_assign(c, GS5, GS6, GS7),
  polydiff_assign(c, GS5, GS7, GS6a),
  polydiff_assign(nnc, GS5, GS6, GS8),
  polydiff_assign(nnc, GS5, GS8, GS6a),
  GS_empty = [],
  polydiff_assign(c, GS0, GS0, GS_empty),
  polydiff_assign(nnc, GS4, GS4, GS_empty),
  polydiff_assign(nnc, GS4, GS3, GS_empty).

polydiff_assign(T, GS1, GS2, GS3) :-
  clean_ppl_new_Polyhedron_from_generators(T, GS1, P1),
  ppl_Polyhedron_space_dimension(P1, Dim),
  clean_ppl_new_Polyhedron_from_space_dimension(T, Dim, empty, P2),
  ppl_Polyhedron_add_generators(P2, GS2),
  ppl_Polyhedron_poly_difference_assign(P1, P2),
  clean_ppl_new_Polyhedron_from_space_dimension(T, Dim, empty, P3),
  ppl_Polyhedron_add_generators(P3, GS3),
  ppl_Polyhedron_equals_Polyhedron(P1, P3),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P3).

% Tests ppl_Polyhedron_time_elapse_assign/2.
time_elapse :-
  time_elapse(c), time_elapse(nnc).

% Tests ppl_Polyhedron_time_elapse for C Polyhedra.
time_elapse(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraints(P,
                          [A >= 1, A =< 3, B >= 1, B =< 3]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, Q),
  ppl_Polyhedron_add_constraints(Q, [B = 5]),
  ppl_Polyhedron_time_elapse_assign(P, Q),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, Pa),
  ppl_Polyhedron_add_constraints(Pa, [B >= 1]),
  clean_ppl_new_Polyhedron_from_constraints(T, [B = 5], Qa),
  ppl_Polyhedron_equals_Polyhedron(Q, Qa),
  ppl_Polyhedron_equals_Polyhedron(P, Pa),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q),
  ppl_delete_Polyhedron(Pa),
  ppl_delete_Polyhedron(Qa).

% Tests ppl_Polyhedron_topological_closure_assign/1.
top_close_assign :-
  make_vars(3, [A, B, C]),
  GS_close = [point(A + B), point(0), ray(A), ray(B)],
  GS_not_close = [point(A + B), closure_point(0), ray(A), ray(B)],
  CS_close = [4*A + B + -2*C >= 5, A =< 3],
  CS_not_close = [4*A + B - 2*C >= 5, A < 3],
  top_close_assign(c, gensys, GS_close, GS_close),
  top_close_assign(nnc, gensys, GS_not_close, GS_close),
  top_close_assign(c, consys, CS_close, CS_close),
  top_close_assign(nnc, consys, CS_not_close, CS_close).

top_close_assign(T, gensys, GS, GS_close) :-
  clean_ppl_new_Polyhedron_from_generators(T, GS, P),
  ppl_Polyhedron_topological_closure_assign(P),
  clean_ppl_new_Polyhedron_from_generators(T, GS_close, Pa),
  ppl_Polyhedron_equals_Polyhedron(P, Pa),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Pa).

top_close_assign(T, consys, CS, CS_close) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P),
  ppl_Polyhedron_topological_closure_assign(P),
  clean_ppl_new_Polyhedron_from_constraints(T, CS_close, Pa),
  ppl_Polyhedron_equals_Polyhedron(P, Pa),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Pa).


%%%%%%%%%%%%%%%%%% Add Constraints or Generators %%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_add_constraint/2.
add_con :-
  add_con(c), add_con(nnc).

add_con(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraint(P, A - B >= 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B >= 1],
                                      Pa),
  ppl_Polyhedron_equals_Polyhedron(P, Pa),
  ppl_Polyhedron_add_constraint(P, A = 0),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A = 0, B =< -1],
                                      Pb),
  ppl_Polyhedron_equals_Polyhedron(P, Pb),
  ppl_Polyhedron_add_constraint(P, A = 1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, empty, Pc),
  ppl_Polyhedron_equals_Polyhedron(P, Pc),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Pa),
  ppl_delete_Polyhedron(Pb),
  ppl_delete_Polyhedron(Pc).

% Tests ppl_Polyhedron_add_generator/2.
add_gen :-
  add_gen(c), add_gen(nnc).

add_gen(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_generator(P, point(A + B)),
  clean_ppl_new_Polyhedron_from_generators(T,
                                     [point(A + B), point(0),
                                      line(A), line(B)], P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1).

% Tests ppl_Polyhedron_add_constraints/2.
add_cons :-
  make_vars(3, [A, B, C]),
  add_cons(c, [A >= 1, B >= 0, 4*A + B - 2*C >= 5], [A =< 0]),
  add_cons(nnc, [A > 1, B >= 0, 4*A + B - 2*C > 5], [A < 0]).

add_cons(T, CS, CS1) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, CS),
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  ppl_Polyhedron_add_constraints(P, CS1),
  ppl_Polyhedron_is_empty(P),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1).

% Tests ppl_Polyhedron_add_generators/2.
add_gens :-
  make_vars(3, [A, B, C]),
  add_gens(c, [point(A + B + C), ray(A), ray(2*A), point(A + B + C, 1),
               point(100*A + 5*B, -8)]),
  add_gens(nnc, [point(A + B + C), ray(A), ray(2*A), point(A + B + C, 1),
                 closure_point(100*A + 5*B, -8)]).

add_gens(T, GS) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P),
  ppl_Polyhedron_add_generators(P, GS),
  clean_ppl_new_Polyhedron_from_generators(T, GS, P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1).

%%%%%%%%%%%%%%%%%% Change Dimensions %%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_add_space_dimensions_and_project/2.
project :-
  project(c), project(nnc).

project(T) :-
  make_vars(4, [A, B, C, D]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B >= 0]),
  ppl_Polyhedron_add_space_dimensions_and_project(P, 0),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 0],
                                      P0),
  ppl_Polyhedron_equals_Polyhedron(P, P0),
  ppl_delete_Polyhedron(P0),
  ppl_Polyhedron_add_space_dimensions_and_project(P, 2),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 0, C = 0, D = 0],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_add_space_dimensions_and_embed/2.
embed :-
  embed(c), embed(nnc).

embed(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B >= 0]),
  ppl_Polyhedron_add_space_dimensions_and_embed(P, 0),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 0],
                                      P0),
  ppl_Polyhedron_equals_Polyhedron(P, P0),
  ppl_delete_Polyhedron(P0),
  ppl_Polyhedron_add_space_dimensions_and_embed(P, 2),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 4, universe, P1),
  ppl_Polyhedron_add_constraints(P1, [A >= 1, B >= 0]),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_remove_space_dimensions/2.
remove_dim :-
  remove_dim(c), remove_dim(nnc).

remove_dim(T) :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B >= 0, C >= 2]),
  ppl_Polyhedron_remove_space_dimensions(P, []),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 0, C >= 2],
                                      P0),
  ppl_Polyhedron_equals_Polyhedron(P, P0),
  ppl_delete_Polyhedron(P0),
  ppl_Polyhedron_remove_space_dimensions(P,[B]),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 2],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  ppl_delete_Polyhedron(P1),
  % Note: now 'B' refers to the old 'C' variable.
  ppl_Polyhedron_remove_space_dimensions(P,[A, B]),
  ppl_Polyhedron_space_dimension(P, 0),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_remove_higher_space_dimensions/2.
remove_high_dim :-
  remove_high_dim(c), remove_high_dim(nnc).

remove_high_dim(T) :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B >= 0, C >= 0]),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 0, C >= 0],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  ppl_Polyhedron_remove_higher_space_dimensions(P, 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1],
                                      P2),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  ppl_Polyhedron_remove_higher_space_dimensions(P, 1),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  ppl_Polyhedron_remove_higher_space_dimensions(P, 0),
  ppl_Polyhedron_space_dimension(P, 0),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_expand_space_dimension/3.
expand_dim :-
  expand_dim(c), expand_dim(nnc).

expand_dim(T) :-
  make_vars(4, [A, B, C, D]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B >= 0, C >= 2]),
  ppl_Polyhedron_expand_space_dimension(P, B, 1),
  ppl_Polyhedron_space_dimension(P, 4),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A >= 1, B >= 0, C >= 2, D >= 0],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  ppl_delete_Polyhedron(P1),
  ppl_Polyhedron_remove_higher_space_dimensions(P, 2),
  ppl_Polyhedron_expand_space_dimension(P, A, 2),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [D >= 1, C >= 1, A >= 1, B >= 0],
                                      P2),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  ppl_delete_Polyhedron(P2),
  ppl_Polyhedron_space_dimension(P, 4),
  !,
  ppl_delete_Polyhedron(P),
% Example taken from [GopanDMDRS04], page 519.
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, empty, Ptacas),
  ppl_Polyhedron_add_generators(Ptacas,
       [point(A + 2*B), point(A + 3*B), point(A + 4*B)]),
  ppl_Polyhedron_expand_space_dimension(Ptacas, B, 1),
  ppl_Polyhedron_space_dimension(Ptacas, 3),
  clean_ppl_new_Polyhedron_from_generators(T,
       [point(A + 2*B + 2*C), point(A + 2*B + 3*C), point(A + 2*B + 4*C),
        point(A + 3*B + 2*C), point(A + 3*B + 3*C), point(A + 3*B + 4*C),
        point(A + 4*B + 2*C), point(A + 4*B + 3*C), point(A + 4*B + 4*C)],
                                      Ptacas1),
  ppl_Polyhedron_equals_Polyhedron(Ptacas, Ptacas1),
  !,
  ppl_delete_Polyhedron(Ptacas1),
  ppl_delete_Polyhedron(Ptacas).

% Tests ppl_Polyhedron_fold_space_dimension/3.
fold_dims :-
  fold_dims(c), fold_dims(nnc).

fold_dims(T) :-
  make_vars(4, [A, B, C, D]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 4, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B >= 0, C >= 2, D >= 0]),
  ppl_Polyhedron_fold_space_dimensions(P, [D], B),
  ppl_Polyhedron_space_dimension(P, 3),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P1),
  ppl_Polyhedron_add_constraints(P1, [A >= 1, B >= 0, C >= 2]),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_Polyhedron_fold_space_dimensions(P, [A, C], B),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 1, universe, P2),
  ppl_Polyhedron_add_constraints(P2, [A >= 0]),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  ppl_delete_Polyhedron(P2),
  ppl_Polyhedron_space_dimension(P, 1),
  !,
  ppl_delete_Polyhedron(P),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, Ptacas),
  ppl_Polyhedron_add_constraints(Ptacas, [A >= 1, A =< 3, B >= 7, B =< 12]),
  ppl_Polyhedron_fold_space_dimensions(Ptacas, [A], B),
  ppl_Polyhedron_space_dimension(Ptacas, 1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 1, universe, Ptacas1),
  ppl_Polyhedron_add_constraints(Ptacas1, [A >= 1, A =< 12]),
  ppl_Polyhedron_equals_Polyhedron(Ptacas, Ptacas1),
  !,
  ppl_delete_Polyhedron(Ptacas1),
  ppl_delete_Polyhedron(Ptacas).

% Tests ppl_Polyhedron_map_space_dimensions/2.
map_dim:-
  map_dim(c), map_dim(nnc).

map_dim(T) :-
  make_vars(7, [A, B, C, D, E, F, G]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 2, B >= 1, C >= 0]),
  ppl_Polyhedron_map_space_dimensions(P, [A-B, B-C, C-A]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, Q),
  ppl_Polyhedron_add_constraints(Q, [A >= 0, B >= 2, C >= 1]),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 4, empty, P0),
  ppl_Polyhedron_add_generators(P0, [point(2*C), line(A+B), ray(A+C)]),
  ppl_delete_Polyhedron(P0),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 4, empty, P1),
  ppl_Polyhedron_add_generators(P1, [point(2*C), line(A+B), ray(A+C)]),
  ppl_Polyhedron_map_space_dimensions(P1, [A-C, C-A, B-B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, Q1),
  ppl_Polyhedron_add_generators(Q1, [point(2*A), ray(A+C), line(B+C)]),
  ppl_Polyhedron_equals_Polyhedron(P1, Q1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(Q1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 5, universe, P2),
  ppl_Polyhedron_add_constraints(P2, [B = 2, E = 8]),
  ppl_Polyhedron_add_space_dimensions_and_embed(P2, 2),
  ppl_Polyhedron_map_space_dimensions(P2, [A-A, B-B, C-E, D-F, E-G, F-C, G-D]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 7, universe, Q2),
  ppl_Polyhedron_add_constraints(Q2, [B = 2, G = 8]),
  ppl_Polyhedron_equals_Polyhedron(P2, Q2),
  !,
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(Q2).


%%%%%%%%%%%%%%%%%% Affine Transformations %%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_affine_image/4.
affine_image :-
  affine_image(c), affine_image(nnc).

affine_image(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraint(P, A - B = 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B = 1],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  ppl_Polyhedron_affine_image(P, A, A + 1, 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B = 2],
                                      P2),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_affine_preimage/4.
affine_preimage :-
  affine_preimage(c), affine_preimage(nnc).

affine_preimage(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraint(P, A + B >= 10),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A + B >= 10],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  ppl_Polyhedron_affine_preimage(P, A, A + 1, 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A + B >= 9],
                                      P2),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_bounded_affine_image/5
bounded_affine_image :-
  bounded_affine_image(c), bounded_affine_image(nnc).

bounded_affine_image(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraint(P, A - B = 1),
  ppl_Polyhedron_bounded_affine_image(P, B, A - 1, A + 1, 2),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - 2*B =< 1, 2*B - A =< 1],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_bounded_affine_preimage/5
bounded_affine_preimage :-
  bounded_affine_preimage(c), bounded_affine_preimage(nnc).

bounded_affine_preimage(T) :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_Polyhedron_from_constraints(T,
            [A >= 0, A =< 4, B >= 0, B =< 4, A - B =< 2, A - B >= -2],
            P),
  clean_ppl_new_Polyhedron_from_Polyhedron(T, P, T, P1),
  ppl_Polyhedron_add_space_dimensions_and_embed(P1, 1),
  ppl_Polyhedron_bounded_affine_preimage(P, B, 7 - A, A + 3, 1),
  ppl_Polyhedron_add_constraint(P1, 7 - A =< B),
  ppl_Polyhedron_add_constraint(P1, B =< A + 3),
  ppl_Polyhedron_remove_space_dimensions(P1, [B]),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P),
  clean_ppl_new_Polyhedron_from_constraints(T,
            [A >= 0, A =< 4, B >= 0, B =< 4, A - B =< 2, A - B >= -2],
            Q),
  clean_ppl_new_Polyhedron_from_Polyhedron(T, Q, T, Q1),
  ppl_Polyhedron_add_space_dimensions_and_embed(Q1, 1),
  ppl_Polyhedron_bounded_affine_preimage(Q, B, 7 - 3*A + 2*B, B + 5*A - 3, 1),
  ppl_Polyhedron_add_constraint(Q1, 7 - 3*A + 2*C =< B),
  ppl_Polyhedron_add_constraint(Q1, B =< C + 5*A - 3),
  ppl_Polyhedron_remove_space_dimensions(Q1, [B]),
  ppl_Polyhedron_equals_Polyhedron(Q, Q1),
  !,
  ppl_delete_Polyhedron(Q1),
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_generalized_affine_image/5.
affine_image_gen :-
  affine_image_gen(c), affine_image_gen(nnc).

affine_image_gen(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraint(P, A - B = 1),
  ppl_Polyhedron_generalized_affine_image(P, A, =<, A + 1, 1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [A - B =< 2],
                                      P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_generalized_affine_preimage/5.
affine_preimage_gen :-
  affine_preimage_gen(c), affine_preimage_gen(nnc).

affine_preimage_gen(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraints(P, [A >= 0, A =< 4, B =< 5, A =< B]),
  ppl_Polyhedron_generalized_affine_preimage(P, B, >=, A+2, 1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P1),
  ppl_Polyhedron_add_constraints(P1, [A >= 0, A =< 3]),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_generalized_affine_image_lhs_rhs/4.
affine_image_genlr :-
  make_vars(2, [A, B]),
  affine_image_genlr(c, =<, [B - A =< 2], [A,B]),
  affine_image_genlr(c, =, [B - A = 2], [A,B]),
  affine_image_genlr(nnc, <, [B - A < 2], [A,B]),
  affine_image_genlr(nnc, =<, [B - A =< 2], [A,B]).

affine_image_genlr(T, R, CS, [A,B]) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraint(P, A - B = 1),
  ppl_Polyhedron_generalized_affine_image_lhs_rhs(P, B - 1, R, A + 1),
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P1),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

% % Tests ppl_Polyhedron_generalized_affine_preimage_lhs_rhs/4.
affine_preimage_genlr :-
  make_vars(2, [A, B]),
  affine_preimage_genlr(c, B - 1, =<,  A + 1,
      [A >= 0, A =< 4, B >= 0, B =< A], [A,B]),
  affine_preimage_genlr(c, B + 1, =, A + 1,
      [A >= 0, A =< 4, B >= 0, B =< A], [A,B]),
  affine_preimage_genlr(nnc, B - 1, <, A + 1,
      [A >= 0, A =< 4, B >= 0, B =< A], [A,B]),
  affine_preimage_genlr(nnc, B - 1, =<, A + 1,
      [A >= 0, A =< 4, B >= 0, B =< A], [A,B]).

affine_preimage_genlr(T, LHS, R, RHS, CS, [A,_B]) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_add_constraints(P, CS),
  ppl_Polyhedron_generalized_affine_preimage_lhs_rhs(P, LHS, R, RHS),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P1),
  ppl_Polyhedron_add_constraints(P1, [A >= 0, A =< 4]),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P).

%%%%%%%%%%%%%%%%%% Widen and Extrapolation Operators %%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_BHRZ03_widening_assign/2.
widen_BHRZ03 :-
  make_vars(2, [A, B]),
  widen_BHRZ03(c, [A >= 1, B >= 0], [A >= 1, B >= 1],
                  [A >= 1],         [A >= 1, B >= 1]
              ),
  widen_BHRZ03(nnc, [A > 1, B > 0], [A > 1, B > 1],
                    [A > 1],        [A > 1, B > 1]
              ).

widen_BHRZ03(Topology, CS_P, CS_Q, CS_Pa, CS_Qa) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  ppl_Polyhedron_BHRZ03_widening_assign(P, Q),
  widen_extrapolation_final(P, CS_Pa, Topology),
  widen_extrapolation_final(Q, CS_Qa, Topology).

% Tests ppl_Polyhedron_BHRZ03_widening_assign_with_tokens/4.
widen_BHRZ03_with_tokens :-
  make_vars(2, [A, B]),
  widen_BHRZ03_with_tokens(c, [A >= 1], [A >= 1, B >= 1],
                             [A >= 1], [A >= 1, B >= 1], 1, 1
                         ),
  widen_BHRZ03_with_tokens(c, [A >= 1, B >= 0], [A >= 1, B >= 1],
                             [A >= 1], [A >= 1, B >= 1], 1, 0
                         ),
  widen_BHRZ03_with_tokens(nnc, [A > 1], [A > 1, B > 1],
                               [A > 1], [A > 1, B > 1], 2, 2
                         ),
  widen_BHRZ03_with_tokens(nnc, [A > 1, B >= 0], [A > 1, B >= 1],
                               [A > 1, B >= 0], [A > 1, B >= 1], 3, 1
                         ).

widen_BHRZ03_with_tokens(Topology,
                      CS_P, CS_Q, CS_Pa, CS_Qa, Token_i, Token_o) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  \+ ppl_Polyhedron_BHRZ03_widening_assign_with_tokens(P, Q,
                                            Token_i, 4),
  \+ ppl_Polyhedron_BHRZ03_widening_assign_with_tokens(P, Q,
                                            Token_i, not_a_number),
  ppl_Polyhedron_BHRZ03_widening_assign_with_tokens(P, Q, Token_i, X),
  ppl_Polyhedron_BHRZ03_widening_assign_with_tokens(P, Q, X, Y),
  Y == Token_o,
  widen_extrapolation_final(P, CS_Pa, Topology),
  widen_extrapolation_final(Q, CS_Qa, Topology), !.

% Tests ppl_Polyhedron_limited_BHRZ03_extrapolation_assign/3.
lim_extrapolate_BHRZ03 :-
  make_vars(2, [A, B]),
  lim_extrapolate_BHRZ03(c, [A >= 1, B >= 0], [A >= 2, B >= 1],
                            [A >= 1, B >= 0], [A >= 1, B >= 0]
                        ),
  lim_extrapolate_BHRZ03(c, [A >= 1, B >= 0], [A >= 2, B >= 1],
                            [A >= 2],         []
                        ),
  lim_extrapolate_BHRZ03(nnc, [A > 1, B > 0], [A > 2, B > 1],
                              [A > 1, B > 0], [A > 1, B > 0]
                        ),
  lim_extrapolate_BHRZ03(nnc, [A > 1, B >= 0], [A > 2, B >= 1],
                              [A >= 2],        []
                        ).

lim_extrapolate_BHRZ03(Topology, CS_P, CS_Q, CS_lim, CS_Pa)  :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  ppl_Polyhedron_limited_BHRZ03_extrapolation_assign(P, Q, CS_lim),
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens/5.
lim_extrapolate_BHRZ03_with_tokens :-
  make_vars(2, [A, B]),
  lim_extrapolate_BHRZ03_with_tokens(c,
                  [A >= 1, B >= 0], [A >= 1, B >= 1],
                  [A >= 1, B >= 0], [A >= 1, B >= 0], 1, 0
                                   ),
  lim_extrapolate_BHRZ03_with_tokens(nnc,
                    [A > 1, B > 0], [A > 1, B > 1],
                    [A > 1, B > 0], [A > 1, B > 0], 1, 0
                                   ).

lim_extrapolate_BHRZ03_with_tokens(Topology,
                 CS_P, CS_Q, CS_lim, CS_Pa, Token_i, Token_o) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  Wrong_Token is Token_i + 1,
  \+ ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, Token_i, Wrong_Token),
  \+ ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, Token_i, not_a_number),
  ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, Token_i, X),
  ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, X, Y),
  Y == Token_o,
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).


% Tests ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign/3.
bound_extrapolate_BHRZ03 :-
  make_vars(2, [A, B]),
  bound_extrapolate_BHRZ03(c, [A >= 1, B >= 0], [A >= 2, B >= 1],
                              [A >= 1, B >= 0], [A >= 1, B >= 0]
                          ),
  bound_extrapolate_BHRZ03(c, [A >= 1, B >= 0], [A >= 2, B >= 1],
                              [A >= 2],         [A >= 1, B >= 0]
                          ),
  bound_extrapolate_BHRZ03(nnc, [A > 1, B > 0], [A > 2, B > 1],
                                [A > 1, B > 0], [A > 1, B > 0]
                          ),
  bound_extrapolate_BHRZ03(nnc, [A > 1, B >= 0], [A > 2, B >= 1],
                                [A >= 2],        [A > 1, B >= 0]
                          ).

bound_extrapolate_BHRZ03(Topology, CS_P, CS_Q, CS_lim, CS_Pa)  :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign(P, Q, CS_lim),
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens/5.
bound_extrapolate_BHRZ03_with_tokens :-
  make_vars(2, [A, B]),
  bound_extrapolate_BHRZ03_with_tokens(c,
                            [A >= 1, B >= 0], [A >= 1, B >= 1],
                            [A >= 1, B >= 0], [A >= 1, B >= 0], 1, 0
                                     ),
  bound_extrapolate_BHRZ03_with_tokens(nnc,
                            [A > 1, B > 0], [A > 1, B > 1],
                            [A > 1, B > 0], [A > 1, B > 0], 1, 0
                                     ).

bound_extrapolate_BHRZ03_with_tokens(Topology,
                 CS_P, CS_Q, CS_lim, CS_Pa, Token_i, Token_o) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  Wrong_Token is Token_i + 1,
  \+ ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, Token_i, Wrong_Token),
  \+ ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, Token_i, not-a_number),
  ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, Token_i, X),
  ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, X, Y),
  Y == Token_o,
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_H79_widening_assign/2.
widen_H79 :-
  make_vars(2, [A, B]),
  widen_H79(c,   [A >= 1, B >= 0], [A >= 1, B >= 1],
                 [A >= 1],         [A >= 1, B >= 1]
           ),
  widen_H79(nnc, [A > 1, B > 0], [A > 1, B > 1],
                 [A > 1], [A > 1, B > 1]
           ),
  widen_H79(c,   [A >= 0, A =< 1], [A = 0],
                 [A >= 0],         [A = 0]
           ),
  widen_H79(nnc, [A >= 0, A =< 1], [A = 0],
                 [A >= 0],         [A = 0]
           ).

widen_H79(Topology, CS_P, CS_Q, CS_Pa, CS_Qa) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  ppl_Polyhedron_H79_widening_assign(P, Q),
  widen_extrapolation_final(P, CS_Pa, Topology),
  widen_extrapolation_final(Q, CS_Qa, Topology).

% Tests ppl_Polyhedron_H79_widening_assign_with_tokens/4.
widen_H79_with_tokens :-
  make_vars(2, [A, B]),
  widen_H79_with_tokens(c, [A >= 1], [A >= 1, B >= 1],
                             [A >= 1], [A >= 1, B >= 1], 1, 1
                         ),
  widen_H79_with_tokens(c, [A >= 1, B >= 0], [A >= 1, B >= 1],
                             [A >= 1], [A >= 1, B >= 1], 1, 0
                         ),
  widen_H79_with_tokens(nnc, [A > 1], [A > 1, B > 1],
                               [A > 1], [A > 1, B > 1], 2, 2
                         ),
  widen_H79_with_tokens(nnc, [A > 1, B >= 0], [A > 1, B >= 1],
                               [A > 1, B >= 0], [A > 1, B >= 1], 3, 1
                         ).

widen_H79_with_tokens(Topology,
                      CS_P, CS_Q, CS_Pa, CS_Qa, Token_i, Token_o) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  \+ ppl_Polyhedron_H79_widening_assign_with_tokens(P, Q,
                                            Token_i, 4),
  \+ ppl_Polyhedron_H79_widening_assign_with_tokens(P, Q,
                                            Token_i, not_a_number),
  ppl_Polyhedron_H79_widening_assign_with_tokens(P, Q, Token_i, X),
  ppl_Polyhedron_H79_widening_assign_with_tokens(P, Q, X, Y),
  Y == Token_o,
  widen_extrapolation_final(P, CS_Pa, Topology),
  widen_extrapolation_final(Q, CS_Qa, Topology), !.

% Tests ppl_Polyhedron_limited_H79_extrapolation_assign/3.
lim_extrapolate_H79 :-
  make_vars(2, [A, B]),
  lim_extrapolate_H79(c,   [A >= 1, B >= 0], [A >= 2, B >= 1],
                           [A >= 1, B >= 0], [A >= 1, B >= 0]
                     ),
  lim_extrapolate_H79(c,   [A >= 1, B >= 0], [A >= 2, B >= 1],
                           [A >= 2],         []
                     ),
  lim_extrapolate_H79(nnc, [A > 1, B > 0], [A > 2, B > 1],
                           [A > 1, B > 0], [A > 1, B > 0]
                     ),
  lim_extrapolate_H79(nnc, [A > 1, B >= 0], [A > 2, B >= 1],
                           [A >= 2],        []
                     ),
  lim_extrapolate_H79(c,   [A >= 0, A =< 1], [A = 0],
                           [A >= 0], [A >= 0]
                     ),
  lim_extrapolate_H79(nnc, [A >= 0, A =< 1], [A = 0],
                           [A >= 0], [A >= 0]
                    ).

lim_extrapolate_H79(Topology, CS_P, CS_Q, CS_lim, CS_Pa)  :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  ppl_Polyhedron_limited_H79_extrapolation_assign(P, Q, CS_lim),
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens/5.
lim_extrapolate_H79_with_tokens :-
  make_vars(2, [A, B]),
  lim_extrapolate_H79_with_tokens(c,
                  [A >= 1, B >= 0], [A >= 1, B >= 1],
                  [A >= 1, B >= 0], [A >= 1, B >= 0], 1, 0
                                   ),
  lim_extrapolate_H79_with_tokens(nnc,
                    [A > 1, B > 0], [A > 1, B > 1],
                    [A > 1, B > 0], [A > 1, B > 0], 1, 0
                                   ).

lim_extrapolate_H79_with_tokens(Topology,
                 CS_P, CS_Q, CS_lim, CS_Pa, Token_i, Token_o) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  Wrong_Token is Token_i + 1,
  \+ ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, Token_i, Wrong_Token),
  \+ ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, Token_i, not_a_number),
  ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, Token_i, X),
  ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens(P, Q,
                                            CS_lim, X, Y),
  Y == Token_o,
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).


% Tests ppl_Polyhedron_bounded_H79_extrapolation_assign/3.
bound_extrapolate_H79 :-
  make_vars(2, [A, B]),
  bound_extrapolate_H79(c,   [A >= 1, B >= 0], [A >= 2, B >= 1],
                             [A >= 1, B >= 0], [A >= 1, B >= 0]
                       ),
  bound_extrapolate_H79(c,   [A >= 1, B >= 0], [A >= 2, B >= 1],
                             [A >= 2],         [A >= 1, B >= 0]
                       ),
  bound_extrapolate_H79(nnc, [A > 1, B > 0], [A > 2, B > 1],
                             [A > 1, B > 0], [A > 1, B > 0]
                       ),
  bound_extrapolate_H79(nnc, [A > 1, B >= 0], [A > 2, B >= 1],
                             [A >= 2],        [A > 1, B >= 0]
                       ).

bound_extrapolate_H79(Topology, CS_P, CS_Q, CS_lim, CS_Pa)  :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  ppl_Polyhedron_bounded_H79_extrapolation_assign(P, Q, CS_lim),
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).


% Tests ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens/5.
bound_extrapolate_H79_with_tokens :-
  make_vars(2, [A, B]),
  bound_extrapolate_H79_with_tokens(c,
                            [A >= 1, B >= 0], [A >= 1, B >= 1],
                            [A >= 1, B >= 0], [A >= 1, B >= 0], 1, 0
                                     ),
  bound_extrapolate_H79_with_tokens(nnc,
                            [A > 1, B > 0], [A > 1, B > 1],
                            [A > 1, B > 0], [A > 1, B > 0], 1, 0
                                     ).

bound_extrapolate_H79_with_tokens(Topology,
                 CS_P, CS_Q, CS_lim, CS_Pa, Token_i, Token_o) :-
  widen_extrapolation_init(P, CS_P, Topology),
  widen_extrapolation_init(Q, CS_Q, Topology),
  Wrong_Token is Token_i + 1,
  \+ ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, Token_i, Wrong_Token),
  \+ ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, Token_i, not_a_number),
  ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, Token_i, X),
  ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens(P, Q,
                                         CS_lim, X, Y),
  Y == Token_o,
  widen_extrapolation_final(P, CS_Pa, Topology),
  !,
  ppl_delete_Polyhedron(Q).

% widen_extrapolation_init/3 and widen_extrapolation_final/3
% are used in the tests for widening and extrapolation predicates.
widen_extrapolation_init(P, CS, Topology):-
  clean_ppl_new_Polyhedron_from_space_dimension(Topology, 2, universe, P),
  ppl_Polyhedron_add_constraints(P, CS).

widen_extrapolation_final(P,CS, Topology):-
  clean_ppl_new_Polyhedron_from_space_dimension(Topology, 2, universe, P1),
  ppl_Polyhedron_add_constraints(P1, CS),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1).

%%%%%%%%%%%%%%%%%% Get Constraint or Generator System %%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_get_constraints/2.
get_cons :-
  get_cons(c), get_cons(nnc).

get_cons(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_get_constraints(P, []),
  ppl_Polyhedron_add_constraint(P, A - B >= 1),
  \+  ppl_Polyhedron_get_constraints(P, []),
  ppl_Polyhedron_get_constraints(P, [C]),
  clean_ppl_new_Polyhedron_from_constraints(T, [C], Q),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_get_minimized_constraints/2.
get_min_cons :-
  get_min_cons(c), get_min_cons(nnc).

get_min_cons(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, universe, P),
  ppl_Polyhedron_get_minimized_constraints(P, []),
  ppl_Polyhedron_add_constraints(P, [A - B >= 1, A - B >= 0]),
  ppl_Polyhedron_get_minimized_constraints(P, [C]),
  clean_ppl_new_Polyhedron_from_constraints(T, [C], Q),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  ppl_Polyhedron_add_constraints(P, [A - B =< 0]),
  \+ppl_Polyhedron_get_minimized_constraints(P, [C]),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_get_generators/2.
get_gens :-
  get_gens(c), get_gens(nnc).

get_gens(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, empty, P),
  ppl_Polyhedron_get_generators(P, []),
  \+ ppl_Polyhedron_get_generators(P, [_]),
  ppl_Polyhedron_add_generator(P, point(A+B)),
  ppl_Polyhedron_get_generators(P, [G]),
  clean_ppl_new_Polyhedron_from_generators(T, [G], Q),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  ppl_Polyhedron_add_generator(P, point(A+B, 2)),
  ppl_Polyhedron_get_generators(P, GS1),
  ppl_Polyhedron_add_generators(Q, GS1),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  ppl_Polyhedron_add_generator(P, line(A)),
  ppl_Polyhedron_get_generators(P, GS2),
  ppl_Polyhedron_add_generators(Q, GS2),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

% Tests ppl_Polyhedron_get_minimized_generators/2.
get_min_gens :-
  get_min_gens(c), get_min_gens(nnc).

get_min_gens(T) :-
  make_vars(2, [A, B]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 2, empty, P),
  ppl_Polyhedron_add_generators(P, [point(2*A), point(A+B), point(2*B)]),
  \+ ppl_Polyhedron_get_minimized_generators(P, [_]),
  ppl_Polyhedron_get_minimized_generators(P, [G1, G2]),
  clean_ppl_new_Polyhedron_from_generators(T, [G1, G2], Q),
  ppl_Polyhedron_equals_Polyhedron(P, Q),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).


%%%%%%%%%%%%%%%%%% Polyhedral Relations %%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_relation_with_constraint/3.
rel_cons :-
  make_vars(3, [A, B, C]),
  rel_cons(c, [A >= 1, B >= 0, C = 0], [A, B, C]),
  rel_cons(nnc, [A > 1, B >= 0, C = 0], [A, B, C]).

rel_cons(T, CS, [A, B, C]) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  ppl_Polyhedron_add_constraints(P, CS),
  \+ ppl_Polyhedron_relation_with_constraint(P, A = 0, x),
  ppl_Polyhedron_relation_with_constraint(P, A = 0, R),
  R = [is_disjoint],
  ppl_Polyhedron_relation_with_constraint(P, B = 0, R1),
  R1 = [strictly_intersects],
  ppl_Polyhedron_relation_with_constraint(P, A >= 0, R2),
  R2 = [is_included],
  ppl_Polyhedron_relation_with_constraint(P, C >= 0, R3),
  (R3 = [is_included, saturates] ; R3 = [saturates, is_included]),
  ppl_Polyhedron_relation_with_constraint(P, A = B, R4),
  R4 = [strictly_intersects],
  ppl_Polyhedron_add_constraint(P, A = B),
  ppl_Polyhedron_relation_with_constraint(P, A = B, R5),
  (R5 = [is_included, saturates] ; R5 = [saturates, is_included]),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_relation_with_generator/3.
rel_gens :-
  make_vars(3, [A, B, C]),
  rel_gens(c, [point(A + B + C), ray(A)], [A, B, C]),
  rel_gens(nnc, [point(A + B + C), ray(A)], [A, B, C]).

rel_gens(T, GS, [A, _, _]) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P),
  ppl_Polyhedron_add_generators(P, GS),
  \+ppl_Polyhedron_relation_with_generator(P, point(A), x),
  ppl_Polyhedron_relation_with_generator(P, point(A), R),
  R = [],
  ppl_Polyhedron_relation_with_generator(P, ray(A), R1),
  R1 = [subsumes],
  !,
  ppl_delete_Polyhedron(P).

%%%%%%%%%%%%%%%%%% Check Properties %%%%%%%%%%%%%%%%%%%%%%%%%%

%  tests ppl_Polyhedron_is_universe/1,
%        ppl_Polyhedron_is_empty/1,
%        ppl_Polyhedron_is_bounded/1,
%        ppl_Polyhedron_is_topologically_closed/1,
%        ppl_Polyhedron_contains_integer_point/2.
checks :-
  checks(c), checks(nnc).

checks(T) :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P1),
  ppl_Polyhedron_is_universe(P),
  ppl_Polyhedron_is_empty(P1),
  \+ppl_Polyhedron_is_universe(P1),
  \+ppl_Polyhedron_is_empty(P),
  \+ppl_Polyhedron_contains_integer_point(P1),
  ppl_Polyhedron_contains_integer_point(P),
  ppl_Polyhedron_add_generators(P1, [point(A + B + C, 2)]),
  \+ppl_Polyhedron_contains_integer_point(P1),
  ppl_Polyhedron_add_generators(P1, [point(A + B + C)]),
  ppl_Polyhedron_is_bounded(P1),
  ppl_Polyhedron_contains_integer_point(P1),
  ppl_Polyhedron_add_generators(P1, [ray(A + B + C)]),
  \+ ppl_Polyhedron_is_bounded(P1),
  ppl_Polyhedron_add_constraints(P, [A >= 1, B =< 3, A =< 2]),
  ppl_Polyhedron_contains_integer_point(P),
  ppl_Polyhedron_is_topologically_closed(P),
   (T = nnc ->
     (ppl_Polyhedron_add_constraints(P, [A > 1, B =< 3, A =< 2]),
      \+ ppl_Polyhedron_is_topologically_closed(P),
      ppl_Polyhedron_contains_integer_point(P),
      ppl_Polyhedron_add_constraints(P, [A > 2]),
      ppl_Polyhedron_is_topologically_closed(P))
   ; true
   ),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1).

% Tests ppl_Polyhedron_contains_Polyhedron/2.
contains :-
  contains(c), contains(nnc).

contains(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P2),
  ppl_Polyhedron_contains_Polyhedron(P1, P2),
  \+ppl_Polyhedron_contains_Polyhedron(P2, P1),
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

% Tests ppl_Polyhedron_strictly_contains_Polyhedron for C/2.
strict_contains :-
  strict_contains(c), strict_contains(nnc).

strict_contains(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P2),
  ppl_Polyhedron_strictly_contains_Polyhedron(P1, P2),
  \+ppl_Polyhedron_strictly_contains_Polyhedron(P1, P1),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

% Tests ppl_Polyhedron_is_disjoint_from_Polyhedron/2.
disjoint_from :-
  disjoint_from(c), disjoint_from(nnc).

disjoint_from(T) :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [3 >= A, 4*A + B - 2*C >= 5],
                                      P1),
  clean_ppl_new_Polyhedron_from_constraints(T,
                                      [4 =< A, 4*A + B - 2*C >= 5],
                                      P2),
  ppl_Polyhedron_is_disjoint_from_Polyhedron(P1, P2),
  \+ppl_Polyhedron_is_disjoint_from_Polyhedron(P1, P1),
  (T = nnc ->
     (clean_ppl_new_Polyhedron_from_constraints(nnc,
                                      [3 < A, 4*A + B - 2*C >= 5],
                                      P2a),
    ppl_Polyhedron_is_disjoint_from_Polyhedron(P1, P2a),
    ppl_delete_Polyhedron(P2a))
  ; true
  ),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

% Tests ppl_Polyhedron_equals_Polyhedron/2.
equals :-
  equals(c), equals(nnc).

equals(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P2),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P3),
  ppl_Polyhedron_equals_Polyhedron(P1, P2),
  \+ ppl_Polyhedron_equals_Polyhedron(P1, P3),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P3).

% Tests ppl_Polyhedron_OK/1.
ok :-
  ok(c), ok(nnc).

ok(T) :-
  clean_ppl_new_Polyhedron_from_space_dimension(T, 0, universe, P1),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, universe, P2),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 0, empty, P3),
  clean_ppl_new_Polyhedron_from_space_dimension(T, 3, empty, P4),
  ppl_Polyhedron_OK(P1),
  ppl_Polyhedron_OK(P2),
  ppl_Polyhedron_OK(P3),
  ppl_Polyhedron_OK(P4),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2),
  ppl_delete_Polyhedron(P3),
  ppl_delete_Polyhedron(P4).

% Tests ppl_termination_test_C_Polyhedron_MS/2,
%       ppl_termination_test_C_Polyhedron_PR/2.
%       ppl_termination_test_NNC_Polyhedron_MS/2,
%       ppl_termination_test_NNC_Polyhedron_PR/2.
termination_test :-
  make_vars(4, [A, B, C, D]),
  clean_ppl_new_Polyhedron_from_constraints(c,
                                            [A - C >= 0,
                                             -A + C >= 0,
                                             -B + D >= 1,
                                             B >= 0,
                                             A >= 1], P1),
  ppl_termination_test_C_Polyhedron_MS(P1),
  ppl_termination_test_C_Polyhedron_PR(P1),
  clean_ppl_new_Polyhedron_from_constraints(nnc,
                                            [A - C >= 0,
                                             -A + C >= 0,
                                             -B + D >= 1,
                                             B >= 0],
					    P2),
  ppl_termination_test_NNC_Polyhedron_MS(P2),
  ppl_termination_test_NNC_Polyhedron_PR(P2),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

%%%%%%%%%%%%%%%%%%%%%%%%% Polyhedron Bounding Values %%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_bounds_from_above/2.
bounds_from_above :-
  make_vars(2, [A, B]),
  bounds_from_above(c, [A >= 1, B >= 0], [B =< 2], B),
  bounds_from_above(nnc, [A > 1, B > 0, B < 1], [A < 2], A).

bounds_from_above(T, CS1, CS2, Var) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS1, P),
  \+ ppl_Polyhedron_bounds_from_above(P, Var),
  ppl_Polyhedron_add_constraints(P, CS2),
  ppl_Polyhedron_bounds_from_above(P, Var),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_bounds_from_below/2.
bounds_from_below :-
  make_vars(2, [A, B]),
  bounds_from_below(c, [B >= 0, B =< 1], [A >= 1], A),
  bounds_from_below(nnc, [B > 0, B < 1], [A > 2], A).

bounds_from_below(T, CS1, CS2, Var) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS1, P),
  \+ ppl_Polyhedron_bounds_from_below(P, Var),
  ppl_Polyhedron_add_constraints(P, CS2),
  ppl_Polyhedron_bounds_from_below(P, Var),
  ppl_delete_Polyhedron(P).

%%%%%%%%%%%%%%%%%%%%%%%%% Maximize and Minimize %%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests ppl_Polyhedron_maximize/5.
maximize :-
  make_vars(2, [A, B]),
  maximize(c, [A >= -1, A =< 1, B >= -1, B =< 1], A + B, 2, 1, true),
  maximize(c, [B >= -1, B =< 1], B, 1, 1, true),
  maximize(nnc, [A > -1, A < 1, B > -1, B < 1], A + B -1, 1, 1, false),
  maximize(nnc, [B > -1, B < 1], B, 1, 1, false).

maximize(T, CS, LE, N, D, Max) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P),
  ppl_Polyhedron_maximize(P, LE, N, D, Max),
  ppl_Polyhedron_add_generator(P, ray(LE)),
  \+ ppl_Polyhedron_maximize(P, LE, _, _, _),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_maximize_with_point/5.
maximize_with_point :-
  make_vars(2, [A, B]),
  maximize_with_point(c, [A >= -1, A =< 1, B >= -1, B =< 1],
                                        A + B, 2, 1, true, point(A+B)),
  maximize_with_point(c, [A =< 0],
                                        A, 0, 1, true, point(0)),
  maximize_with_point(nnc, [A > -1, A < 1, B > -1, B < 1],
                                        A + B -1, 1, 1, false, point(A+B)).

maximize_with_point(T, CS, LE, N, D, Max, Point) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P),
  ppl_Polyhedron_maximize_with_point(P, LE, N, D, Max, Point_Max),
  (Point_Max = closure_point(E) ; Point_Max = point(E)),
  clean_ppl_new_Polyhedron_from_generators(T, [point(E)], Pm),
  clean_ppl_new_Polyhedron_from_generators(T, [Point], Qm),
  ppl_Polyhedron_equals_Polyhedron(Pm, Qm),
  !,
  ppl_delete_Polyhedron(Pm),
  ppl_delete_Polyhedron(Qm),
  \+ ppl_Polyhedron_maximize_with_point(P, LE, _N, 0, _, _),
  !,
  ppl_delete_Polyhedron(P).


% Tests ppl_Polyhedron_minimize/5.
minimize :-
  make_vars(2, [A, B]),
  minimize(c, [A >= -1, A =< 1, B >= -1, B =< 1], A + B, -2, 1, true),
  minimize(c, [B >= -1, B =< 1], B, -1, 1, true),
  minimize(nnc, [A > -2, A =< 2, B > -2, B =< 2], A + B + 1, -3, 1, false),
  minimize(nnc, [B > -1, B < 1], B, -1, 1, false).

minimize(T, CS, LE, N, D, Min) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P),
  ppl_Polyhedron_minimize(P, LE, N, D, Min),
  ppl_Polyhedron_add_generator(P, ray(-LE)),
  \+ ppl_Polyhedron_minimize(P, LE, _, _, _),
  !,
  ppl_delete_Polyhedron(P).

% Tests ppl_Polyhedron_minimize_with_point/5.
minimize_with_point :-
  make_vars(2, [A, B]),
  minimize_with_point(c, [A >= -1, A =< 1, B >= -1, B =< 1],
                                        A + B, -2, 1, true, point(-A-B)),
  minimize_with_point(c, [A >= 0],
                                        A, 0, 1, true, point(0)),
  minimize_with_point(nnc, [A > -2, A =< 2, B > -2, B =< 2],
                                        A + B, -4, 1, false, point(-2*A-2*B)).

minimize_with_point(T, CS, LE, N, D, Min, Point) :-
  clean_ppl_new_Polyhedron_from_constraints(T, CS, P),
  ppl_Polyhedron_minimize_with_point(P, LE, N, D, Min, Point_Min),
  (Point_Min = closure_point(E) ; Point_Min = point(E)),
  clean_ppl_new_Polyhedron_from_generators(T, [point(E)], Pm),
  clean_ppl_new_Polyhedron_from_generators(T, [Point], Qm),
  ppl_Polyhedron_equals_Polyhedron(Pm, Qm),
  !,
  ppl_delete_Polyhedron(Pm),
  ppl_delete_Polyhedron(Qm),
   \+ ppl_Polyhedron_minimize_with_point(P, LE, _N, 0, _, _),
  !,
  ppl_delete_Polyhedron(P).

%%%%%%%%%%%%%%%%% Watchdog tests %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Tests Watchdog predicates
% ppl_set_timeout/1
% ppl_set_timeout_exception_atom/1
% ppl_timeout_exception_atom/1
% ppl_reset_timeout/0
%

time_out :-
  %% FIXME!
  %% Ciao does not throw a timeout exception.
  prolog_system('Ciao'), !.
time_out :-
  time_out(c), time_out(nnc).

add_constraints_and_get_minimized_constraints(P, CS) :-
    ppl_Polyhedron_add_constraints(P, CS),
    ppl_Polyhedron_get_minimized_constraints(P, _).

% Find the constraints for a hypercube for a given dimension.
build_hypercube_constraints(0, [], []).
build_hypercube_constraints(Dim, [V|Vars], [V >= 0, V =< 1|CS]) :-
    Dim1 is Dim - 1,
    build_hypercube_constraints(Dim1, Vars, CS).

% Find the dimension and constraints for
% a hypercube that causes a timeout exception.
compute_timeout_hypercube(Hsecs, T, Dim_in, Dim_out, CS_out) :-
    Dim_in =< 100,
    clean_ppl_new_Polyhedron_from_space_dimension(T, Dim_in, universe, P),
    make_vars(Dim_in, Vars),
    build_hypercube_constraints(Dim_in, Vars, CS),
    ppl_timeout_exception_atom(Time_Out_Atom),
    catch((ppl_set_timeout(Hsecs),
           add_constraints_and_get_minimized_constraints(P, CS)),
          Time_Out_Atom, Catch_Exception = ok),
    ppl_reset_timeout,
    (Catch_Exception == ok ->
        Dim_out = Dim_in,
        ppl_delete_Polyhedron(P),
        CS_out = CS
    ;
        Dim1 is Dim_in+1,
        ppl_delete_Polyhedron(P),
        compute_timeout_hypercube(Hsecs, T, Dim1, Dim_out, CS_out)
    ).

time_out(T) :-
  ppl_set_timeout_exception_atom(pl_time_out),
  \+  ppl_timeout_exception_atom(pl_x),
  ppl_timeout_exception_atom(pl_time_out),
  compute_timeout_hypercube(10, T, 1, Dim, CS),
  !,
  N1 is 1,
  clean_ppl_new_Polyhedron_from_space_dimension(T, Dim, universe, P),
  catch((ppl_set_timeout(N1),
         add_constraints_and_get_minimized_constraints(P, CS)),
        pl_time_out, Catch_Exception = ok),
  ppl_reset_timeout,
  (Catch_Exception == ok ->
      display_message(['while testing time_out, polyhedron with topology',
                 T, 'timeout after', N1, ms])
  ;
      display_message(['while testing time_out, polyhedron with topology',
                 T, 'no timeout after', N1, ms]),
      fail
  ),
  ppl_Polyhedron_OK(P),
  !,
  ppl_delete_Polyhedron(P),
  N2 is 40,
  clean_ppl_new_Polyhedron_from_space_dimension(T, Dim, universe, Q),
  catch((ppl_set_timeout(N2),
         ppl_Polyhedron_is_universe(Q)),
        pl_time_out, Catch_Exception = not_ok),
  ppl_reset_timeout,
  (Catch_Exception == not_ok ->
      display_message(['while testing time_out, polyhedron with topology',
                 T, 'timeout after', N2, ms]),
      fail
  ;
      display_message(['while testing time_out, polyhedron with topology',
                 T, 'no timeout after', N2, ms])
  ),
  ppl_Polyhedron_OK(Q),
  !,
  ppl_delete_Polyhedron(Q).

%%%%%%%%%%%%%%%%% MIP_Problem tests %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

mip_problem :-
  mip_from_cons,
  mip_from_mip,
  mip_swap,
  mip_get,
  mip_control_parameters,
  mip_clear,
  mip_satisfiable,
  mip_add,
  mip_set,
  mip_solve,
  mip_eval.

mip_from_cons :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], C, max, MIP),
  ppl_MIP_Problem_space_dimension(MIP, 3),
  ppl_MIP_Problem_constraints(MIP, CS),
  ppl_MIP_Problem_objective_function(MIP, Obj),
  compare_lin_expressions(Obj, C),
  ppl_MIP_Problem_optimization_mode(MIP, max),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  clean_ppl_new_Polyhedron_from_constraints(c,
       [A >= -1, B >= 5, C >= 0, C =< 3], Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_MIP_Problem(MIP).

mip_from_mip :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(
    3, [A >= -1, B >= 5, C >= 0, C =< 3], C, max, MIP1),
  clean_ppl_new_MIP_Problem_from_MIP_Problem(MIP1, MIP),
  ppl_MIP_Problem_objective_function(MIP, Obj),
  compare_lin_expressions(Obj, C),
  ppl_MIP_Problem_optimization_mode(MIP, max),
  ppl_MIP_Problem_constraints(MIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  ppl_MIP_Problem_constraints(MIP1, Expect_CS),
  clean_ppl_new_Polyhedron_from_constraints(c, Expect_CS, Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_MIP_Problem(MIP1),
  ppl_delete_MIP_Problem(MIP).

mip_swap :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(0, [], 0, max, MIP),
  clean_ppl_new_MIP_Problem(
    3, [A >= -1, B >= 5, C >= 0, C =< 3], C, max, MIP1),
  ppl_MIP_Problem_swap(MIP, MIP1),
  ppl_MIP_Problem_constraints(MIP, CS),
  ppl_MIP_Problem_constraints(MIP1, CS1),
  clean_ppl_new_Polyhedron_from_constraints(c, CS1, PH1),
  ppl_Polyhedron_is_universe(PH1),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  clean_ppl_new_Polyhedron_from_constraints(c,
       [A >= -1, B >= 5, C >= 0, C =< 3], Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(PH1),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_MIP_Problem(MIP1),
  ppl_delete_MIP_Problem(MIP).

mip_get :-
  make_vars(3, [A, B, C]),

  ppl_new_MIP_Problem(3, [], A + 3, min, MIP0),
  ppl_MIP_Problem_objective_function(MIP0, Obj0),
  compare_lin_expressions(Obj0, A + 3),

  ppl_new_MIP_Problem(3, [], 3, min, MIP1),
  ppl_MIP_Problem_objective_function(MIP1, Obj1),
  compare_lin_expressions(Obj1, 3),

  clean_ppl_new_MIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], C, max, MIP),
  ppl_MIP_Problem_constraints(MIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  clean_ppl_new_Polyhedron_from_constraints(c,
       [A >= -1, B >= 5, C >= 0, C =< 3], Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  ppl_MIP_Problem_objective_function(MIP, Obj),
  compare_lin_expressions(Obj, C),
  ppl_MIP_Problem_optimization_mode(MIP, Opt),
  Opt = max,
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_MIP_Problem(MIP0),
  ppl_delete_MIP_Problem(MIP1),
  ppl_delete_MIP_Problem(MIP).

mip_control_parameters :-
  make_vars(1, [A]),

  ppl_new_MIP_Problem(3, [], A + 3, min, MIP0),
  clean_ppl_new_MIP_Problem_from_MIP_Problem(MIP0, MIP1),
  ppl_MIP_Problem_get_control_parameter(MIP0, pricing, Cp_value0),
  ppl_MIP_Problem_set_control_parameter(MIP1, Cp_value0),
  ppl_MIP_Problem_get_control_parameter(MIP1, pricing, Cp_value1),
  Cp_value0 == Cp_value1,
  ppl_MIP_Problem_set_control_parameter(MIP0, pricing_steepest_edge_float),
  ppl_MIP_Problem_get_control_parameter(MIP0, pricing, Cp_value2),
  Cp_value2 == pricing_steepest_edge_float,
  ppl_MIP_Problem_set_control_parameter(MIP0, pricing_steepest_edge_exact),
  ppl_MIP_Problem_get_control_parameter(MIP0, pricing, Cp_value3),
  Cp_value3 == pricing_steepest_edge_exact,
  ppl_MIP_Problem_set_control_parameter(MIP0, pricing_textbook),
  ppl_MIP_Problem_get_control_parameter(MIP0, pricing, Cp_value4),
  Cp_value4 == pricing_textbook,
  !,
  ppl_delete_MIP_Problem(MIP0),
  ppl_delete_MIP_Problem(MIP1).

mip_clear :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], C, min, MIP),
  ppl_MIP_Problem_clear(MIP),
  ppl_MIP_Problem_space_dimension(MIP, D),
  D == 0,
  ppl_MIP_Problem_constraints(MIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  ppl_Polyhedron_is_universe(PH),
  ppl_MIP_Problem_objective_function(MIP, Obj),
  compare_lin_expressions(Obj, 0),
  ppl_MIP_Problem_optimization_mode(MIP, Opt),
  Opt == max,
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_MIP_Problem(MIP).

mip_satisfiable :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], C, max, MIP),
  ppl_MIP_Problem_is_satisfiable(MIP),
  ppl_MIP_Problem_add_constraint(MIP, A + B =< 0),
  \+ ppl_MIP_Problem_is_satisfiable(MIP),
  !,
  ppl_delete_MIP_Problem(MIP).

mip_add :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem_from_space_dimension(0, MIP),
  ppl_MIP_Problem_add_space_dimensions_and_embed(MIP, 1),
  ppl_MIP_Problem_add_constraint(MIP, A >= 0),
  ppl_MIP_Problem_add_space_dimensions_and_embed(MIP, 2),
  ppl_MIP_Problem_add_constraints(
    MIP,[A =< 3, A + B + C >= 9, B >= 5, C =< 5]),
  clean_ppl_new_MIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], 2*B-C, max, MIP1),
  ppl_MIP_Problem_solve(MIP, Status),
  Status == optimized,
  ppl_MIP_Problem_solve(MIP1, Status1),
  Status1 == unbounded,
  ppl_MIP_Problem_optimal_value(MIP, N, D),
  N == 0,
  D == 1,
  ppl_MIP_Problem_constraints(MIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  ppl_MIP_Problem_constraints(MIP1, Expect_CS),
  clean_ppl_new_Polyhedron_from_constraints(c, Expect_CS, Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_MIP_Problem(MIP),
  ppl_delete_MIP_Problem(MIP1).

mip_set :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], 0, max, MIP),
  ppl_MIP_Problem_objective_function(MIP, 0),
  ppl_MIP_Problem_optimization_mode(MIP, max),
  ppl_MIP_Problem_set_objective_function(MIP, 2*B-C),
  ppl_MIP_Problem_set_optimization_mode(MIP, min),
  ppl_MIP_Problem_objective_function(MIP, Obj),
  compare_lin_expressions(Obj, 2*B-C),
  ppl_MIP_Problem_optimization_mode(MIP, min),
  ppl_MIP_Problem_solve(MIP, optimized),
  !,
  ppl_delete_MIP_Problem(MIP).

mip_solve :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], 0, max, MIP),
  ppl_MIP_Problem_objective_function(MIP, 0),
  ppl_MIP_Problem_optimization_mode(MIP, max),
  ppl_MIP_Problem_set_objective_function(MIP, 2*B-C),
  ppl_MIP_Problem_set_optimization_mode(MIP, min),
  ppl_MIP_Problem_solve(MIP, optimized),
  ppl_MIP_Problem_set_objective_function(MIP, C),
  ppl_MIP_Problem_solve(MIP, unbounded),
  ppl_MIP_Problem_add_constraint(MIP, B = 0),
  ppl_MIP_Problem_solve(MIP, unfeasible),
  \+ppl_MIP_Problem_solve(MIP, invalid_status),
  !,
  ppl_delete_MIP_Problem(MIP).

mip_eval :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_MIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], 2*B-C, min, MIP),
  \+ ppl_MIP_Problem_optimizing_point(MIP, closure_point(_X)),
  ppl_MIP_Problem_optimizing_point(MIP, Point),
  ppl_MIP_Problem_feasible_point(MIP, Point),
  \+ ppl_MIP_Problem_feasible_point(MIP, point(B)),
  clean_ppl_new_Polyhedron_from_generators(c, [Point], PH),
  clean_ppl_new_Polyhedron_from_generators(c, [point(5*B+5*C)], Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  \+ ppl_MIP_Problem_optimal_value(MIP, 2, 1),
  ppl_MIP_Problem_optimal_value(MIP, N, D),
  \+ ppl_MIP_Problem_evaluate_objective_function(MIP, Point, 2, 1),
  ppl_MIP_Problem_evaluate_objective_function(MIP, Point, N1, D1),
  N == N1,
  D == D1,
  ppl_MIP_Problem_OK(MIP),
  !,
  ppl_delete_MIP_Problem(MIP),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_Polyhedron(PH).

%%%%%%%%%%%%%%%%% PIP_Problem tests %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

pip_problem :-
  pip_from_cons,
  pip_from_pip,
  pip_swap,
  pip_control_parameters,
  pip_clear,
  pip_satisfiable,
  pip_add,
  pip_set,
  pip_solve,
  pip_solution.

pip_from_cons :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem_from_space_dimension(3, PIP1),
  ppl_PIP_Problem_space_dimension(PIP1, 3),
  ppl_PIP_Problem_OK(PIP1),
  clean_ppl_new_PIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], [C], PIP),
  ppl_PIP_Problem_space_dimension(PIP, 3),
  ppl_PIP_Problem_parameter_space_dimensions(PIP, [C]),
  ppl_PIP_Problem_constraints(PIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  clean_ppl_new_Polyhedron_from_constraints(c,
       [A >= -1, B >= 5, C >= 0, C =< 3], Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_PIP_Problem(PIP1),
  ppl_delete_PIP_Problem(PIP).

pip_from_pip :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem(
    3, [A >= -1, B >= 5, C >= 0, C =< 3], [C], PIP1),
  clean_ppl_new_PIP_Problem_from_PIP_Problem(PIP1, PIP),
  ppl_PIP_Problem_constraints(PIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  ppl_PIP_Problem_constraints(PIP1, Expect_CS),
  clean_ppl_new_Polyhedron_from_constraints(c, Expect_CS, Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_PIP_Problem(PIP1),
  ppl_delete_PIP_Problem(PIP).

pip_swap :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem_from_space_dimension(0, PIP),
  clean_ppl_new_PIP_Problem(
    3, [A >= -1, B >= 5, C >= 0, C =< 3], [C], PIP1),
  ppl_PIP_Problem_swap(PIP, PIP1),
  ppl_PIP_Problem_constraints(PIP, CS),
  ppl_PIP_Problem_constraints(PIP1, CS1),
  clean_ppl_new_Polyhedron_from_constraints(c, CS1, PH1),
  ppl_Polyhedron_is_universe(PH1),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  clean_ppl_new_Polyhedron_from_constraints(c,
       [A >= -1, B >= 5, C >= 0, C =< 3], Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(PH1),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_PIP_Problem(PIP1),
  ppl_delete_PIP_Problem(PIP).

pip_control_parameters :-
  make_vars(1, [A]),

  ppl_new_PIP_Problem(3, [], [A], PIP0),
  clean_ppl_new_PIP_Problem_from_PIP_Problem(PIP0, PIP1),
  ppl_PIP_Problem_get_control_parameter(PIP0, cutting_strategy, Cp_value0),
  ppl_PIP_Problem_set_control_parameter(PIP1, Cp_value0),
  ppl_PIP_Problem_get_control_parameter(PIP1, cutting_strategy, Cp_value1),
  Cp_value0 == Cp_value1,
  ppl_PIP_Problem_set_control_parameter(PIP0, cutting_strategy_first),
  ppl_PIP_Problem_get_control_parameter(PIP0, cutting_strategy, Cp_value2),
  Cp_value2 == cutting_strategy_first,
  ppl_PIP_Problem_set_control_parameter(PIP0, cutting_strategy_deepest),
  ppl_PIP_Problem_get_control_parameter(PIP0, cutting_strategy, Cp_value3),
  Cp_value3 == cutting_strategy_deepest,
  ppl_PIP_Problem_set_control_parameter(PIP0, cutting_strategy_all),
  ppl_PIP_Problem_get_control_parameter(PIP0, cutting_strategy, Cp_value4),
  Cp_value4 == cutting_strategy_all,

  ppl_PIP_Problem_get_control_parameter(PIP0, pivot_row_strategy, Cp_value5),
  ppl_PIP_Problem_set_control_parameter(PIP1, Cp_value5),
  ppl_PIP_Problem_get_control_parameter(PIP1, pivot_row_strategy, Cp_value6),
  Cp_value5 == Cp_value6,
  ppl_PIP_Problem_set_control_parameter(PIP0, pivot_row_strategy_first),
  ppl_PIP_Problem_get_control_parameter(PIP0, pivot_row_strategy, Cp_value7),
  Cp_value7 == pivot_row_strategy_first,
  ppl_PIP_Problem_set_control_parameter(PIP0, pivot_row_strategy_max_column),
  ppl_PIP_Problem_get_control_parameter(PIP0, pivot_row_strategy, Cp_value8),
  Cp_value8 == pivot_row_strategy_max_column,
 !,
  ppl_delete_PIP_Problem(PIP0),
  ppl_delete_PIP_Problem(PIP1).

pip_clear :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], [C], PIP),
  ppl_PIP_Problem_clear(PIP),
  ppl_PIP_Problem_space_dimension(PIP, D),
  D == 0,
  ppl_PIP_Problem_constraints(PIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  ppl_Polyhedron_is_universe(PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_PIP_Problem(PIP).

pip_satisfiable :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem(3, [A >= -1, B >= 5, C >= 0, C =< 3], [C], PIP),
  ppl_PIP_Problem_is_satisfiable(PIP),
  ppl_PIP_Problem_add_constraint(PIP, A + B =< 0),
  \+ ppl_PIP_Problem_is_satisfiable(PIP),
  !,
  ppl_delete_PIP_Problem(PIP).

pip_add :-
  make_vars(4, [A, B, C, D]),
  clean_ppl_new_PIP_Problem_from_space_dimension(0, PIP),
  ppl_PIP_Problem_add_space_dimensions_and_embed(PIP, 1, 0),
  ppl_PIP_Problem_add_constraint(PIP, A >= 0),
  ppl_PIP_Problem_add_space_dimensions_and_embed(PIP, 2, 1),
  ppl_PIP_Problem_add_constraints(
    PIP, [A =< 3, A + B + C >= 9, B >= 5, C =< 5]),
  clean_ppl_new_PIP_Problem(
    4, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], [D], PIP1),
  ppl_PIP_Problem_constraints(PIP, CS),
  clean_ppl_new_Polyhedron_from_constraints(c, CS, PH),
  ppl_PIP_Problem_constraints(PIP1, Expect_CS),
  clean_ppl_new_Polyhedron_from_constraints(c, Expect_CS, Expect_PH),
  ppl_Polyhedron_equals_Polyhedron(PH, Expect_PH),
  !,
  ppl_delete_Polyhedron(PH),
  ppl_delete_Polyhedron(Expect_PH),
  ppl_delete_PIP_Problem(PIP),
  ppl_delete_PIP_Problem(PIP1).

pip_set :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], [B], PIP),
  \+ ppl_PIP_Problem_has_big_parameter_dimension(PIP, _X),
  ppl_PIP_Problem_solve(PIP, optimized),
  !,
  ppl_delete_PIP_Problem(PIP),

  make_vars(4, [X, Y, P, M]),
  clean_ppl_new_PIP_Problem(
    4, [Y - M >= -2*X + 2*M - 4, 2*Y - 2*M =< X - M + 2*P], [P, M], PIP1),
  ppl_PIP_Problem_set_big_parameter_dimension(PIP1, 3),
  ppl_PIP_Problem_has_big_parameter_dimension(PIP1, 3),
  ppl_PIP_Problem_solve(PIP1, optimized),
  !,
  ppl_delete_PIP_Problem(PIP1).

pip_solve :-
  make_vars(3, [A, B, C]),
  clean_ppl_new_PIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], [B], PIP),
  ppl_PIP_Problem_solve(PIP, Status),
  Status == optimized,
  clean_ppl_new_PIP_Problem(
    3, [A >= 0, A =< 3, A + B + C >= 9, B >= 5, C =< 5], [B,C], PIP1),
  ppl_PIP_Problem_add_constraint(PIP1, C >= 6),
  ppl_PIP_Problem_solve(PIP1, Status1),
  Status1 == unfeasible,
  ppl_PIP_Problem_add_constraint(PIP, B = 0),
  ppl_PIP_Problem_solve(PIP, unfeasible),
  \+ppl_PIP_Problem_solve(PIP, invalid_status),
  !,
  ppl_delete_PIP_Problem(PIP),
  ppl_delete_PIP_Problem(PIP1).

pip_solution :-
  make_vars(4, [I, J, M, N]),
  clean_ppl_new_PIP_Problem(
    4, [3*J >= -2*I + 8, J =< 4*I - 4, J =< M, I =< N], [M,N], PIP),
  ppl_PIP_Problem_solution(PIP, Node),
  ppl_PIP_Tree_Node_artificials(Node, Artificials),
  Artificials = [],
  \+ ppl_PIP_Tree_Node_is_solution(Node),
  ppl_PIP_Tree_Node_constraints(Node, _CS),
  ppl_PIP_Tree_Node_is_decision(Node),
  ppl_PIP_Tree_Node_constraints(Node, _CS1),
  ppl_PIP_Tree_Node_true_child(Node, TChild),
  ppl_PIP_Tree_Node_false_child(Node, _FChild),
  ppl_PIP_Tree_Node_is_decision(TChild),
  ppl_PIP_Tree_Node_true_child(TChild, TTChild),
  \+ ppl_PIP_Tree_Node_is_decision(TTChild),
  ppl_PIP_Tree_Node_is_solution(TTChild),
  ppl_PIP_Tree_Node_parametric_values(TTChild, I, _TPV),
  ppl_PIP_Tree_Node_false_child(TChild, FTChild),
  ppl_PIP_Tree_Node_artificials(FTChild, FTChild_Artificials),
  FTChild_Artificials = [Art_LinExpr/Art_Den],
  compare_lin_expressions(Art_LinExpr, M),
  Art_Den = 2,
  ppl_PIP_Tree_Node_is_solution(FTChild),
  ppl_PIP_Tree_Node_parametric_values(FTChild, I, _FPV),
  ppl_PIP_Problem_OK(PIP),
  ppl_PIP_Tree_Node_OK(Node),
  !,
  ppl_delete_PIP_Problem(PIP).

%%%%%%%%%%%%%%%% Tool to compare linear expressions %%%%%%%%%%%%%%%%%%%%%%%

% compare_lin_expressions/2 checks if 2 linear expressions
% are semantically the same.
%
% If we need to compare 2 linear expressions, then this is better
% than a syntactic check- since we want 1*C equal to C.

compare_lin_expressions(LE1, LE2) :-
  clean_ppl_new_Polyhedron_from_constraints(c, [LE1 = 0], PH1),
  clean_ppl_new_Polyhedron_from_constraints(c, [LE2 = 0], PH2),
  ppl_Polyhedron_equals_Polyhedron(PH1, PH2),
  !,
  ppl_delete_Polyhedron(PH1),
  ppl_delete_Polyhedron(PH2).

%%%%%%%%%%%%%%%% Check C++ <--> Prolog numbers %%%%%%%%%%%%%%%%%%%%%%%

/*
 This test checks the transfer of large numbers between Prolog and C++.
 We test all numbers (BigNum) which are +/- (2^E +/- A) where E is one of
 the numbers in the list defined by large_integers_exponents/1 and
 A is one of the numbers in the list defined by large_integers_additions/1.

 Thus we pass a BigNum from the Prolog to C++ and construct a polyhedron
 P (space dimension = 1) consisting of a single point A = BigNum.
 We also get the constraint defining P and then construct a second
 polyhedron P1 from this constraint; P is then compared with P1.
 To ensure that errors from Prolog to C++ and C++ to Prolog do not cancel
 each other out, we also construct a polyhedron P2 consisting of just
 the point A = 1 and use affine transformations (on polyhedra) to change P2
 to a polyhedron with the point A = BigNum; then P2 is compared with P.

 To see exactly which numbers are tested, first make the test "extra noisy"
 using make_extra_noisy/0; i.e., type:
 make_extra_noisy, large_integers.
*/

large_integers_exponents([0, 7, 8, 15, 16, 27, 28, 29, 30, 31, 32, 63, 64]).

large_integers_additions([-3, -2, -1, 0, 1, 2, 3]).

large_integers :-
  large_integers_exponents(Exps),
  large_integers_additions(Adds),
  out(large_int, init),
  pl_check_prolog_flag(bounded, Y),
  (Y == true ->
     large_integers_prolog_cpp_bounded(Exps, Adds, 0),
     out(sys_large_int, init),
     large_integers_sys_prolog_cpp(Adds)
   ;
     large_integers_prolog_cpp_unbounded(Exps, Adds)
  ).

large_integers_prolog_cpp_bounded([], _, _).
large_integers_prolog_cpp_bounded([Exp|Exps], Adds, Prev_value) :-
  /* If the test value is too large, it may be wrap.
     So we compare it with the previous value that was ok
     as well as checking it against the maximum value. */
  Test_value is 1 << Exp + 3,
  ( ( Test_value =< Prev_value ;
      (pl_check_prolog_flag(max_integer, Max_int),
         Max_int >> 1 =< Test_value)
    ) ->
     true
   ;
     large_integers_prolog_cpp1(Adds, Exp),
     large_integers_prolog_cpp_bounded(Exps, Adds, Test_value)
  ).

large_integers_prolog_cpp_unbounded([], _).
large_integers_prolog_cpp_unbounded([Exp|Exps], Adds) :-
   large_integers_prolog_cpp1(Adds, Exp),
   large_integers_prolog_cpp_unbounded(Exps, Adds).

large_integers_prolog_cpp1([], _).
large_integers_prolog_cpp1([Add|Adds], Exp) :-
  large_integers_prolog_cpp2(Exp, Add, 1),
  large_integers_prolog_cpp2(Exp, Add, -1),
  large_integers_prolog_cpp1(Adds, Exp).

large_integers_prolog_cpp2(Exp, Add, Sign) :-
  Inhomo is Sign * ((1 << Exp) + Add),
  out(large_int, Inhomo, Sign, Add, Exp),
  make_vars(1, [A]),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 1, universe, P),
  ppl_Polyhedron_add_constraints(P, [A = Inhomo]),
  ppl_Polyhedron_get_constraints(P, CS),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 1, universe, P1),
  ppl_Polyhedron_add_constraints(P1, CS),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 1, universe, P2),
  ppl_Polyhedron_add_constraint(P2, A = 1),
  large_integers_affine_transform_loop(Exp, P2, A),
  ppl_Polyhedron_affine_image(P2, A, Sign * (A + Add), 1),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

large_integers_sys_prolog_cpp([]).
large_integers_sys_prolog_cpp([Add|Adds]) :-
  pl_check_prolog_flag(max_integer, Max_int),
  pl_check_prolog_flag(min_integer, Min_int),
  Max is Max_int-3,
  Min is Min_int+3,
  large_integers_sys_prolog_cpp2(Max, Add, 1),
  large_integers_sys_prolog_cpp2(Min, Add, -1),
  large_integers_sys_prolog_cpp(Adds).

large_integers_sys_prolog_cpp2(MaxMin, Add, Sign) :-
  make_vars(1, [A]),
  Inhomo is MaxMin + Sign* Add,
  out(sys_large_int, Inhomo),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 1, universe, P),
  ppl_Polyhedron_add_constraints(P, [A = Inhomo]),
  ppl_Polyhedron_get_constraints(P, CS),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 1, universe, P1),
  ppl_Polyhedron_add_constraints(P1, CS),
  ppl_Polyhedron_equals_Polyhedron(P, P1),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 1, universe, P2),
  InhomoDiv2 is Inhomo // 2,
  InhomoMod2 is Inhomo mod 2,
  ppl_Polyhedron_add_constraint(P2, A = InhomoDiv2),
  ppl_Polyhedron_affine_image(P2, A, 2*A + Sign* InhomoMod2, 1),
  ppl_Polyhedron_equals_Polyhedron(P, P2),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

large_integers_affine_transform_loop(0, _P, _).
large_integers_affine_transform_loop(Exp, P, A) :-
  Exp >= 1,
  ppl_Polyhedron_affine_image(P, A, 2*A, 1),
  Exp1 is Exp - 1,
  large_integers_affine_transform_loop(Exp1, P, A).

%%%%%%%%%%%%%%%%% Exceptions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% exceptions/0 tests both Prolog and C++ exceptions using:
%
% exception_prolog(+N, +V)
% exception_sys_prolog(+N, +V)
% exception_cplusplus(+N, +V)
%
% N is the number of the test while V is a list of 3 PPL variables
%
% In exceptions/0, the calls to these predicates should fail
% so that all the tests are tried on backtracking.
% When all the tests have been tried,
% (and, for the Prolog interface, providing the correct
% exception message),
% the call to exceptions/0 succeeds.
% If one of the tests succeeds or a Prolog interface exception
% has a wrong exception message, then exceptions/0 will fail.

exceptions :-
   pl_check_prolog_flag(bounded, Y),
   make_vars(3, V),
   exception_prolog(V),
   ((Y == true,\+prolog_system('XSB'))  -> exception_sys_prolog(V) ; true),
   exception_cplusplus(V),
   !.
exceptions :-
   prolog_system('XSB').

%% TEST: Prolog_unsigned_out_of_range
exception_yap :-
     I = 21474836470, J = 3, K = 0,
     ppl_new_C_Polyhedron_from_generators(
        [point('$VAR'(I)),point('$VAR'(J))], P),
     ppl_Polyhedron_get_generators(P, GS),
     nl, write(GS), nl,
     ppl_new_C_Polyhedron_from_generators(
        [point('$VAR'(I)),point('$VAR'(K))], P1),
     ppl_Polyhedron_get_generators(P1, GS1),
     nl, write(GS1), nl,
     ppl_delete_Polyhedron(P),
     ppl_delete_Polyhedron(P1).

% exception_prolog(+N, +V) checks exceptions thrown by the Prolog interface.
% It does not check those that are dependent on a specific Prolog system.

exception_prolog(V) :-
   exception_prolog1(14, V).

exception_prolog1(0, _) :- !.
exception_prolog1(N, V) :-
   exception_prolog(N, V),
   N1 is N - 1,
   exception_prolog1(N1, V).

%% TEST: Prolog_unsigned_out_of_range.
%% This test accepts any one of three exceptions:
%% ppl_invalid_argument: with a 32 bit system, the number 1 << 59 is expected
%%                       to throw this Prolog exception;
%% out_of_memory:        with a 64 bit system, the number 1 << 59 does not
%%                       throw an exception on the Prolog side, but the
%%                       large number of dimensions will cause a bad_alloc
%%                       exception in C++.
%%
exception_prolog(1, _) :-
    pl_check_prolog_flag(bounded, Y),
   (Y == true ->
     true
    ;
     (I is 1 << 59,
        must_catch(ppl_new_C_Polyhedron_from_generators([point('$VAR'(I))], _),
                   prolog_exception_error)
      )
   ).

%% TEST: not_unsigned_integer
exception_prolog(2, _) :-
  must_catch(ppl_new_C_Polyhedron_from_space_dimension(n, universe, _),
             ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_space_dimension(-1, universe,  _),
             ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_generators([point('$VAR'(n))], _),
             ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_generators([point('$VAR'(-1))], _),
             ppl_invalid_argument).

%% TEST: not_unsigned_integer
exception_prolog(3, _) :-
    must_catch(ppl_set_timeout(-1), ppl_invalid_argument).

%% TEST: not_unsigned_integer
exception_prolog(4, _) :-
  clean_ppl_new_Polyhedron_from_space_dimension(c, 3, universe, P),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 3, universe, Q),
  must_catch(ppl_Polyhedron_BHRZ03_widening_assign_with_tokens(
             Q, P, -1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens(
             Q, P, [], -1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens(
             Q, P, [], -1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_H79_widening_assign_with_tokens(
             Q, P, -1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens(
             Q, P, [], -1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens(
             Q, P, [], -1, _), ppl_invalid_argument),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

%% TEST: non_linear
exception_prolog(5, [A,B,C]) :-
  must_catch(ppl_new_C_Polyhedron_from_generators([point(B + A*C)], _),
             ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_generators(
                     [point(C), ray(B + C, 1)], _), ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_generators(
                     [point], _), ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_generators(
                     [point(_D)], _), ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_constraints(
                     [_E >= 3], _), ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_constraints(
                     [A*B = 0], _), ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_constraints(
                     [A], _), ppl_invalid_argument).

%% TEST: not_a_variable
exception_prolog(6, [A,_,_]) :-
  clean_ppl_new_Polyhedron_from_space_dimension(c, 3, universe, P),
  must_catch(ppl_Polyhedron_remove_space_dimensions(P, [A,1]),
             ppl_invalid_argument),
  !,
  ppl_delete_Polyhedron(P).

%% TEST: not_an_integer
exception_prolog(7, [A,B,_]) :-
  clean_ppl_new_Polyhedron_from_generators(c,
               [point(A + B), ray(A), ray(B)], P),
  must_catch(ppl_Polyhedron_affine_image(P, A, A + B + 1, i),
             ppl_invalid_argument),
  !,
  ppl_delete_Polyhedron(P).

%% TEST: not_a_polyhedron_handle
exception_prolog(8, _) :-
  must_catch(ppl_Polyhedron_space_dimension(_, _N), ppl_invalid_argument).

%% TEST: not_a_complexity_class
exception_prolog(9, [A, _, _]) :-
   clean_ppl_new_Polyhedron_from_generators(c,
               [point(A)], P),
   must_catch(
     clean_ppl_new_Polyhedron_from_Polyhedron_with_complexity(a, c, P,
                                                              c, _P_copy),
              ppl_invalid_argument),
   !,
   ppl_delete_Polyhedron(P).

%% TEST: not_universe_or_empty
exception_prolog(10, _) :-
  must_catch(ppl_new_C_Polyhedron_from_space_dimension(3, xxx, _),
             ppl_invalid_argument).

%% TEST: not_relation
exception_prolog(11, [A, B, _]) :-
  clean_ppl_new_Polyhedron_from_generators(c,
               [point(A)], P),
  must_catch(ppl_Polyhedron_generalized_affine_image(P, A, x, A + 1, 1),
             ppl_invalid_argument),
  must_catch(
     ppl_Polyhedron_generalized_affine_image_lhs_rhs(P, B - 1, x, A + 1),
             ppl_invalid_argument),
  must_catch(
     ppl_Polyhedron_generalized_affine_image_lhs_rhs(P, B - 1, x + y, A + 1),
             ppl_invalid_argument),
   !,
   ppl_delete_Polyhedron(P).

%% TEST: not_a_nil_terminated_list
exception_prolog(12, [A, B, C]) :-
  must_catch(ppl_new_C_Polyhedron_from_generators(
     [point(A + B + C, 1) | not_a_list], _), ppl_invalid_argument),
  must_catch(ppl_new_C_Polyhedron_from_constraints(
     [A = 0, B >= C | not_a_list], _), ppl_invalid_argument),
  clean_ppl_new_Polyhedron_from_space_dimension(nnc, 3, universe, P),
  must_catch(ppl_Polyhedron_add_constraints(P, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_add_constraints(P, not_a_list),
             ppl_invalid_argument),
  must_catch(ppl_Polyhedron_add_generators(P, not_a_list),
             ppl_invalid_argument),
  must_catch(ppl_Polyhedron_add_generators(P, _), ppl_invalid_argument),
  clean_ppl_new_Polyhedron_from_space_dimension(c, 3, empty, Q),
  must_catch(ppl_Polyhedron_map_space_dimensions(Q, not_a_list),
             ppl_invalid_argument),
  must_catch(ppl_Polyhedron_fold_space_dimensions(Q, not_a_list, B),
             ppl_invalid_argument),
  must_catch(ppl_Polyhedron_remove_space_dimensions(Q, not_a_list),
             ppl_invalid_argument),
  must_catch(ppl_Polyhedron_limited_H79_extrapolation_assign(
             Q, P, not_a_list), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_limited_H79_extrapolation_assign_with_tokens(
             Q, P, not_a_list, 1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_bounded_H79_extrapolation_assign(
             Q, P, not_a_list), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_bounded_H79_extrapolation_assign_with_tokens(
             Q, P, not_a_list, 1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_limited_BHRZ03_extrapolation_assign(
             Q, P, not_a_list), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_tokens(
             Q, P, not_a_list, 1, _), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign(
             Q, P, not_a_list), ppl_invalid_argument),
  must_catch(ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_tokens(
             Q, P, not_a_list, 1, _), ppl_invalid_argument),
  !,
  ppl_delete_Polyhedron(P),
  ppl_delete_Polyhedron(Q).

%% TEST: not_an_mip_problem_handle
exception_prolog(13, _) :-
  must_catch(ppl_MIP_Problem_space_dimension(_, _N), ppl_invalid_argument),
  must_catch(ppl_MIP_Problem_constraints(p, []), ppl_invalid_argument).

%% TEST: not_an_pip_problem_handle
exception_prolog(14, _) :-
  must_catch(ppl_PIP_Problem_space_dimension(_, _N), ppl_invalid_argument),
  must_catch(ppl_PIP_Problem_constraints(p, []), ppl_invalid_argument).

% exception_sys_prolog(+N, +V) checks exceptions thrown by Prolog interfaces
% that are dependent on a specific Prolog system.
% These are only checked if current_prolog_flag(bounded, true) holds.

exception_sys_prolog(V) :-
   exception_sys_prolog1(4, V).

exception_sys_prolog1(0, _) :- !.
exception_sys_prolog1(N, V) :-
   exception_sys_prolog(N, V),
   N1 is N - 1,
   exception_sys_prolog1(N1, V).

exception_sys_prolog(1, [A,B,_]) :-
  pl_check_prolog_flag(max_integer, Max_Int),
  catch((
          clean_ppl_new_Polyhedron_from_constraints(c,
               [Max_Int * A - B =< 0, 3 >= A], P),
          must_catch(ppl_Polyhedron_get_generators(P, _GS),
                ppl_sys_prolog_error),
          !,
          ppl_delete_Polyhedron(P)
        ),
        ppl_overflow_error(Cause),
        check_exception_term(ppl_overflow_error(Cause))
       ).

 exception_sys_prolog(2, [A,B,_]) :-
  pl_check_prolog_flag(min_integer, Min_Int),
  catch((
          clean_ppl_new_Polyhedron_from_constraints(c,
               [Min_Int * A - B =< 0, 2 >= A], P),
          must_catch(ppl_Polyhedron_get_generators(P, _GS),
                ppl_sys_prolog_error),
          !,
          ppl_delete_Polyhedron(P)
        ),
        ppl_overflow_error(Cause),
        check_exception_term(ppl_overflow_error(Cause))
       ).

exception_sys_prolog(3, [A,B,_]) :-
  pl_check_prolog_flag(max_integer, Max_Int),
  catch((
          clean_ppl_new_Polyhedron_from_generators(c,
               [point(Max_Int * A + B)], P),
          ppl_Polyhedron_affine_image(P, A, A + 1, 1),
          must_catch(ppl_Polyhedron_get_generators(P, _GS),
                ppl_sys_prolog_error),
          !,
          ppl_delete_Polyhedron(P)
        ),
        ppl_overflow_error(Cause),
        check_exception_term(ppl_overflow_error(Cause))
       ).

exception_sys_prolog(4, [A,_,_]) :-
   pl_check_prolog_flag(min_integer, Min_Int),
   catch((
          clean_ppl_new_Polyhedron_from_generators(c,
                                                   [point(Min_Int*A)], P),
          ppl_Polyhedron_affine_image(P, A, A - 1, 1),
          must_catch(ppl_Polyhedron_get_generators(P, _GS),
                     ppl_sys_prolog_error),
          !,
          ppl_delete_Polyhedron(P)
         ),
         ppl_overflow_error(Cause),
         check_exception_term(ppl_overflow_error(Cause))
        ).

% exception_cplusplus(+N, +V) checks exceptions thrown by the C++
% interface for the PPL.

exception_cplusplus(V) :-
   exception_cplusplus1(10, V).

exception_cplusplus1(0, _) :- !.
exception_cplusplus1(N, V) :-
   exception_cplusplus(N, V),
   N1 is N - 1,
   exception_cplusplus1(N1, V).

exception_cplusplus(1, [A, B, C]) :-
  must_catch(ppl_new_C_Polyhedron_from_generators([point(A + B + C, 0)], _),
             cpp_error).

exception_cplusplus(2, [A, B, _]) :-
  clean_ppl_new_Polyhedron_from_generators(c,
               [point(A + B), ray(A), ray(B)], P),
  must_catch(ppl_Polyhedron_affine_image(P, A, A + B + 1, 0),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).

exception_cplusplus(3, [A, B, _]) :-
  clean_ppl_new_Polyhedron_from_space_dimension(c, 0, universe, P1),
  clean_ppl_new_Polyhedron_from_generators(c,
               [point(A + B)], P2),
  must_catch(ppl_Polyhedron_poly_hull_assign(P1, P2),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P1),
  ppl_delete_Polyhedron(P2).

exception_cplusplus(4, [A, B, C]) :-
   must_catch(ppl_new_C_Polyhedron_from_generators([line(A + B + C)], _),
             cpp_error).

exception_cplusplus(5, [A,B,C]) :-
  clean_ppl_new_Polyhedron_from_generators(c, [point(B + 2*C)], P),
  ppl_Polyhedron_remove_space_dimensions(P, [C]),
  must_catch(ppl_Polyhedron_remove_space_dimensions(P, [A, C]),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).

exception_cplusplus(6, [A, B, _]) :-
  clean_ppl_new_Polyhedron_from_constraints(c,
               [A >= 1], P),
  must_catch(ppl_Polyhedron_affine_image(P, B, A + 1, 1),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).

exception_cplusplus(7, [A, B, C]) :-
  clean_ppl_new_Polyhedron_from_constraints(c,
               [A >= 1, B>= 1], P),
  must_catch(ppl_Polyhedron_affine_image(P, B, A + C + 1, 1),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).

exception_cplusplus(8, [A, B, _]) :-
  clean_ppl_new_Polyhedron_from_constraints(c,
               [A >= B], P),
  must_catch(ppl_Polyhedron_affine_preimage(P, A, A + B + 1, 0),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).

exception_cplusplus(9, [A, B, C]) :-
  clean_ppl_new_Polyhedron_from_generators(c,
               [point(0), ray(A + B), ray(A)], P),
  must_catch(ppl_Polyhedron_affine_preimage(P, C, A + 1, 1),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).


exception_cplusplus(10, [A, B, C]) :-
  clean_ppl_new_Polyhedron_from_generators(c,
               [point(0), point(A), line(A + B)], P),
  must_catch(ppl_Polyhedron_affine_preimage(P, B, A + C, 1),
             cpp_error),
  !,
  ppl_delete_Polyhedron(P).

% must_catch(+Call) calls Call using catch and checks exception.
% If expected exception is caught, it succeeds and fails if not.

must_catch(Call, prolog_exception_error) :-
   !,
   catch( Call, Message, format_exception_message( Message ) ),
   ( \+var(Message) ->
       ((Message =.. [ppl_invalid_argument|_] ; Message = out_of_memory) ->
           true
       ;
           check_exception_term(Message)
       )
   ;
       fail
   ).
must_catch(Call, cpp_error) :-
   !,
   catch( Call, Message, format_exception_message( cpp_error(Message) ) ),
   ( ( \+ var(Message),
       functor(Message, ppl_invalid_argument, _) ) ->
       true
   ;
       fail
   ).
must_catch(Call, ppl_sys_prolog_error) :-
   !,
   catch( Call, Message, format_exception_message(Message) ),
   ( ( \+ var(Message),
         (Message =.. [ppl_representation_error|_] )) ->
       true
   ;
       fail
   ).
must_catch(Call, Expected) :-
   catch(Call, Message, format_exception_message(Message) ),
   (\+ var(Message), Message = ppl_overflow_error(_) ->
       true
   ;
       ( \+ var(Message), Message =.. [Expected|_] ->
           true
       ;
           fail
       )
   ).

%%%%%%%%%%%% predicate for making list of ppl variables %%%%%%

% make_var_list(+I,+Dimension,?Variable_List)
% constructs a list of variables with indices from I to Dimension - 1.
% It is assumed that I =< Dimension.

make_vars(Dim, Var_List):-
  make_var_list(0, Dim, Var_List).
make_var_list(Dim,Dim,[]):- !.
make_var_list(I,Dim,['$VAR'(I)|Var_List]):-
  I1 is I + 1,
  make_var_list(I1,Dim,Var_List).

%%%%%%%%%%%% predicate for safely deleting polyhedra on failure %

cleanup_ppl_Polyhedron(_).
cleanup_ppl_Polyhedron(P) :-
  out(cs, P),
  out(gs, P),
  ppl_delete_Polyhedron(P), fail.

cleanup_ppl_Polyhedra([]).
cleanup_ppl_Polyhedra([_|_]).
cleanup_ppl_Polyhedra([P|Ps]) :-
  delete_all_ppl_Polyhedra([P|Ps]).

delete_all_ppl_Polyhedra([]).
delete_all_ppl_Polyhedra([P|Ps]) :-
  ppl_delete_Polyhedron(P),
  delete_all_ppl_Polyhedra(Ps).

cleanup_ppl_MIP_Problem(_).
cleanup_ppl_MIP_Problem(MIP) :-
  out(mip, MIP),
  ppl_delete_MIP_Problem(MIP), fail.

cleanup_ppl_PIP_Problem(_).
cleanup_ppl_PIP_Problem(PIP) :-
  out(pip, PIP),
  ppl_delete_PIP_Problem(PIP), fail.

out(cs, P):-
  ((noisy(N), N < 2) -> true ;
    ppl_Polyhedron_get_constraints(P, CS),
    nl, write(CS), nl
  ).

out(gs, P):-
  ((noisy(N), N < 2) -> true ;
    ppl_Polyhedron_get_generators(P, GS),
    nl, write(GS), nl
  ).

out(mip, MIP):-
  ((noisy(N), N < 2) -> true ;
    ppl_MIP_Problem_constraints(MIP, CS),
    ppl_MIP_Problem_objective_function(MIP, Obj),
    ppl_MIP_Problem_optimization_mode(MIP, Opt),
    ppl_MIP_Problem_get_control_parameter(MIP, pricing, Cp_value),
    nl,
    write(' constraint system is: '), write(CS), nl,
    write(' objective function is: '), write(Obj), nl,
    write(' optimization mode is: '), write(Opt),
    write(' control_parameter_value is: '), write(Cp_value),
    nl
  ).

out(pip, PIP):-
  ((noisy(N), N < 2) -> true ;
    ppl_PIP_Problem_constraints(PIP, CS),
    ppl_PIP_Problem_parameter_space_dimensions(PIP, Dims),
    ppl_PIP_Problem_get_control_parameter(PIP, cutting_strategy, Cp_value),
    nl,
    write(' constraint system is: '), write(CS), nl,
    write(' parameter space dimensions are: '), write(Dims), nl,
    write(' control_parameter_value is: '), write(Cp_value),
    nl
  ).

out(sys_large_int, init):-
  !,
  prolog_system(System),
  ((noisy(N), N < 2) -> true ;
    nl, write_all([' At the Prolog/C++ interface, for', System, 'Prolog', nl,
       ' the extra numbers tested are: ']),
    nl
  ).

out(sys_large_int, Num):-
  ((noisy(N), N < 2) -> true ;
      write_all([Num, ',  '])
  ).

out(large_int, init):-
  !,
  ((noisy(N), N < 2) -> true ;
    nl, write(' At the Prolog/C++ interface, the numbers tested are: '),
    nl
  ).

out(large_int, Num, Sign, Add, Exp):-
  ((noisy(N), N < 2) -> true ;
    write_all([Num, ' = ', Sign, ' * ', '((1 << ', Exp, ') + ', Add, '),  '])
  ).

%%% predicates for ensuring new polyhedra are always deleted on failure %

clean_ppl_new_Polyhedron_from_space_dimension(T, D, Universe_or_Empty, P) :-
  (T = c ->
    ppl_new_C_Polyhedron_from_space_dimension(D, Universe_or_Empty, P)
  ;
    ppl_new_NNC_Polyhedron_from_space_dimension(D, Universe_or_Empty, P)
  ),
  cleanup_ppl_Polyhedron(P).

clean_ppl_new_Polyhedron_from_constraints(T, CS, P) :-
  (T = c ->
    ppl_new_C_Polyhedron_from_constraints(CS, P)
   ;
    ppl_new_NNC_Polyhedron_from_constraints(CS, P)
  ),
  cleanup_ppl_Polyhedron(P).

clean_ppl_new_Polyhedron_from_generators(T, GS, P) :-
  (T = c ->
    ppl_new_C_Polyhedron_from_generators(GS, P)
   ;
    ppl_new_NNC_Polyhedron_from_generators(GS, P)
  ),
  cleanup_ppl_Polyhedron(P).

clean_ppl_new_Polyhedron_from_Polyhedron(TQ, Q, TP, P) :-
  ((TP == c, TQ == c) ->
    ppl_new_C_Polyhedron_from_C_Polyhedron(Q, P)
   ;
    ((TP == c, TQ == nnc) ->
      ppl_new_C_Polyhedron_from_NNC_Polyhedron(Q, P)
    ;
      ((TP == nnc, TQ == c) ->
        ppl_new_NNC_Polyhedron_from_C_Polyhedron(Q, P)
      ;
        ppl_new_NNC_Polyhedron_from_NNC_Polyhedron(Q, P)
      )
    )
  ),
  cleanup_ppl_Polyhedron(P).

clean_ppl_new_Polyhedron_from_Polyhedron_with_complexity(C, TQ, Q, TP, P) :-
  ((TP == c, TQ == c) ->
    ppl_new_C_Polyhedron_from_C_Polyhedron_with_complexity(C, Q, P)
   ;
    ((TP == c, TQ == nnc) ->
      ppl_new_C_Polyhedron_from_NNC_Polyhedron_with_complexity(C, Q, P)
    ;
      ((TP == nnc, TQ == c) ->
        ppl_new_NNC_Polyhedron_from_C_Polyhedron_with_complexity(C, Q, P)
      ;
        ppl_new_NNC_Polyhedron_from_NNC_Polyhedron_with_complexity(C, Q, P)
      )
    )
  ),
  cleanup_ppl_Polyhedron(P).

clean_ppl_new_MIP_Problem_from_space_dimension(Dim, MIP) :-
  ppl_new_MIP_Problem_from_space_dimension(Dim, MIP),
  cleanup_ppl_MIP_Problem(MIP).

clean_ppl_new_MIP_Problem(Dim, CS, Obj, Opt, MIP) :-
  ppl_new_MIP_Problem(Dim, CS, Obj, Opt, MIP),
  cleanup_ppl_MIP_Problem(MIP).

clean_ppl_new_MIP_Problem_from_MIP_Problem(MIP1, MIP) :-
  ppl_new_MIP_Problem_from_MIP_Problem(MIP1, MIP),
  cleanup_ppl_MIP_Problem(MIP).

clean_ppl_new_PIP_Problem_from_space_dimension(Dim, PIP) :-
  ppl_new_PIP_Problem_from_space_dimension(Dim, PIP),
  cleanup_ppl_PIP_Problem(PIP).

clean_ppl_new_PIP_Problem(Dim, CS, Vars, PIP) :-
  ppl_new_PIP_Problem(Dim, CS, Vars, PIP),
  cleanup_ppl_PIP_Problem(PIP).

clean_ppl_new_PIP_Problem_from_PIP_Problem(PIP1, PIP) :-
  ppl_new_PIP_Problem_from_PIP_Problem(PIP1, PIP),
  cleanup_ppl_PIP_Problem(PIP).

%%%%%%%%%%%% predicates for switching on/off output messages %

make_extra_noisy :-
  (retract(noisy(_)) ->
      make_extra_noisy
  ;
      assertz(noisy(2))
  ).

make_noisy :-
  (retract(noisy(_)) ->
      make_noisy
  ;
      assertz(noisy(1))
  ).

make_quiet :-
  (retract(noisy(_)) ->
      make_quiet
   ; assertz(noisy(0))
  ).

%%%%%%%%%%%% predicates for pretty printing the PPL banner %%%%%%%%%%
%
% The banner is read as an atom with"/n" denoting where there should
% new lines. Here we print the banner as intended with new lines instead
% of "/n".
%

banner_pp(B) :-
  name(B,Bcodes),
  nl,
  !,
  format_banner(Bcodes).

format_banner([]) :- nl.
format_banner([C]) :- put_code(C), nl.
format_banner([C,C1|Chars]):-
  ([C,C1] == "/n" ->
     (nl,
     format_banner(Chars))
   ;
     (put_code(C),
     format_banner([C1|Chars]))
  ).

%%%%%%%%%%%% predicate for handling an unintended exception %%%%

check_exception_term(ppl_overflow_error(Cause)) :-
  ((Cause == 'Negative overflow.'; Cause == 'Positive overflow.') ->
    true
  ;
    print_exception_term(ppl_overflow_error(Cause))
  ),
  !.

print_exception_term(ppl_overflow_error(Cause)) :-
  nl,
  write('Error: an overflow has been detected by the PPL: '),
  write(Cause),
  nl,
  !.

print_exception_term(Exception) :-
  write('exception'), nl,
  nl,
  writeq(Exception),
  nl.

%%%%%%%%%%%% predicate for printing exception messages %%%%%%%%%%

format_exception_message(
             ppl_invalid_argument( found(F), expected(E), where(W))
                        ) :-
  !,
  display_message(['PPL Prolog Interface Exception:', nl, '   ',
                   F, 'is an invalid argument for', W, nl, '   ',
                  F, 'should be', E, '.']).

format_exception_message(
             ppl_representation_error(I, where(W))
                        ) :-
  !,
  display_message(['PPL Prolog Interface Exception:', nl, '   ',
                   'This Prolog system has bounded integers', nl, '   ',
                   I, 'is not in the allowed range of integers', nl, '   ',
                   'in call to', W, '.']).

format_exception_message(out_of_memory) :-
  !,
  display_message(['PPL Prolog Interface Exception: ', nl, '   ',
                   'out of memory']).

format_exception_message(ppl_overflow_error(Type)) :-
  !,
  display_message(['PPL Prolog Interface Exception: ', nl, '   ',
                   'ppl_overflow_error: ', Type]).

format_exception_message(cpp_error(Error)) :-
  !,
  display_message(['PPL C++ Interface Exception:', nl, '   ', Error]).

format_exception_message(Error) :-
  display_message(['Unknown exception: ', Error]), fail.

%%%%%%%%%%%% predicates for output messages %%%%%%%%%%%%%%%%%%

error_message(Message):-
   write_all(Message).

display_message(Message):-
    noisy(_),
    (noisy(0) -> true ;
     (nl, write_all(Message))
    ).

write_all([]) :- nl.
write_all([Phrase|Phrases]):-
   (Phrase == nl ->
      nl
   ;
      write(Phrase),
      write(' ')
   ),
   write_all(Phrases).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% list_groups(G)
% The interface predicates are partitioned into related sets called
% groups and here is a list of the groups.

list_groups( [
   large_integers,
   all_versions_and_banner,
   numeric_bounds,
   new_polyhedron_from_dimension,
   new_polyhedron_from_polyhedron,
   new_polyhedron_from_representations,
   swap_polyhedra,
   polyhedron_dimension,
   basic_operators,
%   transform_polyhedron,
   extrapolation_operators,
   get_system,
%   add_to_system,
   revise_dimensions,
   check_polyhedron,
   minmax_polyhedron,
   compare_polyhedra,
   mip_problem,
   pip_problem,
   transform_polyhedron,
   add_to_system,
   catch_time,
   handle_exceptions
             ] ).

% group_predicates(G, P)
% P is a list of the interface predicates checked by test for group G.
% This is used to generate more informative error and exception messages.

group_predicates(all_versions_and_banner,
  [ppl_version_major/1,
   ppl_version_minor/1,
   ppl_version_revision/1,
   ppl_version_beta/1,
   ppl_version/1,
   ppl_banner/1
  ]).

group_predicates(numeric_bounds,
  [ppl_max_space_dimension/1,
   ppl_Coefficient_is_bounded/0,
   ppl_Coefficient_max/1,
   ppl_Coefficient_min/1,
   ppl_set_rounding_for_PPL/0,
   ppl_restore_pre_PPL_rounding/0
  ]).

group_predicates(new_polyhedron_from_dimension,
  [ppl_new_C_Polyhedron_from_space_dimension/4,
   ppl_new_NNC_Polyhedron_from_space_dimension/4,
   ppl_Polyhedron_is_universe/1,
   ppl_Polyhedron_is_empty/1,
   ppl_delete_polyhedron/1
  ]).

group_predicates(new_polyhedron_from_polyhedron,
  [ppl_new_C_Polyhedron_from_C_Polyhedron/3,
   ppl_new_C_Polyhedron_from_NNC_Polyhedron/3,
   ppl_new_NNC_Polyhedron_from_C_Polyhedron/3,
   ppl_new_NNC_Polyhedron_from_NNC_Polyhedron/3,
   ppl_new_C_Polyhedron_from_constraints/2,
   ppl_new_NNC_Polyhedron_from_constraints/2,
   ppl_Polyhedron_equals_Polyhedron/2
  ]).

group_predicates(new_polyhedron_from_representations,
  [ppl_new_C_Polyhedron_from_constraints/2,
   ppl_new_NNC_Polyhedron_from_constraints/2,
   ppl_new_C_Polyhedron_from_generators/2,
   ppl_new_NNC_Polyhedron_from_generators/2
  ]).

group_predicates(swap_polyhedra,
  [ppl_Polyhedron_swap/2
  ]).

group_predicates(polyhedron_dimension,
  [ppl_Polyhedron_affine_dimension/2,
   ppl_Polyhedron_space_dimension/2,
   ppl_Polyhedron_constrains/2,
   ppl_Polyhedron_unconstrain_space_dimension/2,
   ppl_Polyhedron_unconstrain_space_dimensions/2]).

group_predicates(basic_operators,
  [ppl_Polyhedron_intersection_assign/2,
   ppl_Polyhedron_poly_hull_assign/2,
   ppl_Polyhedron_poly_difference_assign/2,
   ppl_Polyhedron_time_elapse_assign/2,
   ppl_Polyhedron_topological_closure_assign/1
  ]).

group_predicates(add_to_system,
  [ppl_Polyhedron_add_constraint/2,
   ppl_Polyhedron_add_generator/2,
   ppl_Polyhedron_add_constraints/2,
   ppl_Polyhedron_add_generators/2
  ]).

group_predicates(revise_dimensions,
  [ppl_Polyhedron_remove_space_dimensions/2,
   ppl_Polyhedron_remove_higher_space_dimensions/2,
   ppl_Polyhedron_expand_space_dimension/3,
   ppl_Polyhedron_fold_space_dimensions/3,
   ppl_Polyhedron_map_space_dimensions/2,
   ppl_Polyhedron_concatenate_assign/2
  ]).

group_predicates(transform_polyhedron,
  [ppl_Polyhedron_affine_image/4,
   ppl_Polyhedron_affine_preimage/4,
   ppl_Polyhedron_bounded_affine_image/5,
   ppl_Polyhedron_bounded_affine_preimage/5,
   ppl_Polyhedron_generalized_affine_image/5,
   ppl_Polyhedron_generalized_affine_preimage/5,
   ppl_Polyhedron_generalized_affine_image_lhs_rhs/4,
   ppl_Polyhedron_generalized_affine_preimage_lhs_rhs/4
  ]).

group_predicates(extrapolation_operators,
  [ppl_Polyhedron_BHRZ03_widening_assign_with_token/3,
   ppl_Polyhedron_BHRZ03_widening_assign/2,
   ppl_Polyhedron_limited_BHRZ03_extrapolation_assign_with_token/4,
   ppl_Polyhedron_limited_BHRZ03_extrapolation_assign/3,
   ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign_with_token/4,
   ppl_Polyhedron_bounded_BHRZ03_extrapolation_assign/3,
   ppl_Polyhedron_H79_widening_assign_with_token/3,
   ppl_Polyhedron_H79_widening_assign/2,
   ppl_Polyhedron_limited_H79_extrapolation_assign_with_token/4,
   ppl_Polyhedron_limited_H79_extrapolation_assign/3,
   ppl_Polyhedron_bounded_H79_extrapolation_assign_with_token/4,
   ppl_Polyhedron_bounded_H79_extrapolation_assign/3
  ]).

group_predicates(get_system,
  [ppl_Polyhedron_get_constraints/2,
   ppl_Polyhedron_get_minimized_constraints/2,
   ppl_Polyhedron_get_generators/2,
   ppl_Polyhedron_get_minimized_generators/2
  ]).

group_predicates(check_polyhedron,
  [ppl_Polyhedron_relation_with_constraint/3,
   ppl_Polyhedron_relation_with_generator/3,
   ppl_Polyhedron_is_topologically_closed/1,
   ppl_Polyhedron_is_universe,
   ppl_Polyhedron_is_empty,
   ppl_Polyhedron_is_bounded,
   ppl_Polyhedron_contains_integer_point,
   ppl_Polyhedron_contains_Polyhedron/2,
   ppl_Polyhedron_strictly_contains_Polyhedron/2,
   ppl_Polyhedron_is_disjoint_from_Polyhedron/2,
   ppl_Polyhedron_equals_Polyhedron/2,
   ppl_Polyhedron_termination_test_MS/2,
   ppl_Polyhedron_termination_test_PR/2,
   ppl_Polyhedron_OK/1
  ]).

group_predicates(minmax_polyhedron,
  [ppl_Polyhedron_maximize/5,
   ppl_Polyhedron_maximize_with_point/6,
   ppl_Polyhedron_minimize/5,
   ppl_Polyhedron_minimize_with_point/6
  ]).

group_predicates(compare_polyhedra,
  [ppl_Polyhedron_contains_Polyhedron/2,
   ppl_Polyhedron_strictly_contains_Polyhedron/2,
   ppl_Polyhedron_is_disjoint_from_Polyhedron/2,
   ppl_Polyhedron_equals_Polyhedron/2
  ]).

group_predicates(catch_time,
  [ppl_set_timeout_exception_atom/1,
   ppl_timeout_exception_atom/1,
   ppl_set_timeout/1,
   ppl_reset_timeout/0
  ]).

group_predicates(mip_problem,
  ['all MIP_Prolog predicates'
  ]).

group_predicates(pip_problem,
  ['all PIP_Prolog predicates'
  ]).

group_predicates(large_integers,
  ['large integer tests '
  ]).

group_predicates(handle_exceptions,
  'all predicates'' exception handling.'
  ).

%%%%%%%%%%%%%%%%%%%%%%% System flags %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% pl_check_prolog_flag/2
% returns true or false (if the 1st argument is 'bounded')
% or (if the 1st argument is 'max_integer' or  'min_integer')
% the maximum or minimum integer for Prolog
% systems that have bounded integers.
% Note that 268435456 is 2^28.

pl_check_prolog_flag(bounded, TF) :-
  current_prolog_flag(bounded, TF).

pl_check_prolog_flag(max_integer, Max_Int) :-
  \+ prolog_system('XSB'),
  current_prolog_flag(max_integer, Max_Int).

pl_check_prolog_flag(max_integer, Max_Int) :-
  prolog_system('XSB'), Max_Int is 268435455.

pl_check_prolog_flag(min_integer, Min_Int) :-
  \+ prolog_system('XSB'),
  current_prolog_flag(min_integer, Min_Int).

pl_check_prolog_flag(min_integer, Min_Int) :-
  prolog_system('XSB'), Min_Int is -268435456.
