Fake_Class_for_Doxygen.java

Go to the documentation of this file.

/* Doxumentation for the Java interface.
   Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
   Copyright (C) 2010-2016 BUGSENG srl (http://bugseng.com)

This file is part of the Parma Polyhedra Library (PPL).

The PPL is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.

The PPL is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.

For the most up-to-date information see the Parma Polyhedra Library
site: http://bugseng.com/products/ppl/ . */

package parma_polyhedra_library;

// A fake class, just to cheat Doxygen.
public class Fake_Class_For_Doxygen {}


public class Polyhedron extends PPL_Object {



    public native long space_dimension();

    public native long affine_dimension();

    public native Constraint_System constraints();

    public native Congruence_System congruences();

    public native Constraint_System minimized_constraints();

    public native Congruence_System minimized_congruences();

    public native boolean is_empty();

    public native boolean is_universe();

    public native boolean is_bounded();

    public native boolean is_discrete();

    public native boolean is_topologically_closed();

    public native boolean contains_integer_point();

    public native boolean constrains(Variable var);

    public native boolean bounds_from_above(Linear_Expression expr);

    public native boolean bounds_from_below(Linear_Expression expr);

    public native boolean maximize(Linear_Expression expr,
                                   Coefficient sup_n, Coefficient sup_d,
                                   By_Reference<Boolean> maximum);

    public native boolean minimize(Linear_Expression expr,
                                   Coefficient inf_n, Coefficient inf_d,
                                   By_Reference<Boolean> minimum);

    public native boolean maximize(Linear_Expression expr,
                                   Coefficient sup_n, Coefficient sup_d,
                                   By_Reference<Boolean> maximum,
                                   Generator g);

    public native boolean minimize(Linear_Expression expr,
                                   Coefficient inf_n, Coefficient inf_d,
                                   By_Reference<Boolean> minimum,
                                   Generator g);

    public native Poly_Con_Relation relation_with(Constraint c);

    public native Poly_Gen_Relation relation_with(Generator c);

    public native Poly_Con_Relation relation_with(Congruence c);


    public native boolean contains(Polyhedron y);


    public native boolean strictly_contains(Polyhedron y);


    public native boolean is_disjoint_from(Polyhedron y);

    public native boolean equals(Polyhedron y);

    public boolean equals(Object y);


    public native int hashCode();

    public native long external_memory_in_bytes();

    public native long total_memory_in_bytes();

    public native String toString();

    public native String ascii_dump();

    public native boolean OK();




    public native void add_constraint(Constraint c);

    public native void add_congruence(Congruence cg);

    public native void add_constraints(Constraint_System cs);

    public native void add_congruences(Congruence_System cgs);

    public native void refine_with_constraint(Constraint c);

    public native void refine_with_congruence(Congruence cg);

    public native void refine_with_constraints(Constraint_System cs);

    public native void refine_with_congruences(Congruence_System cgs);

    public native void intersection_assign(Polyhedron y);

    public native void upper_bound_assign(Polyhedron y);

    public native void difference_assign(Polyhedron y);

    public native void time_elapse_assign(Polyhedron y);

    public native void topological_closure_assign();

    public native boolean simplify_using_context_assign(Polyhedron y);

    public native void affine_image(Variable var, Linear_Expression expr,
                                    Coefficient denominator);

    public native void affine_preimage(Variable var, Linear_Expression expr,
                                       Coefficient denominator);

    public native void bounded_affine_image(Variable var,
                                            Linear_Expression lb_expr,
                                            Linear_Expression ub_expr,
                                            Coefficient denominator);

    public native void bounded_affine_preimage(Variable var,
                                               Linear_Expression lb_expr,
                                               Linear_Expression ub_expr,
                                               Coefficient denominator);

    public native void generalized_affine_image(Variable var,
                                                Relation_Symbol relsym,
                                                Linear_Expression expr,
                                                Coefficient denominator);

    public native void generalized_affine_preimage(Variable var,
                                                   Relation_Symbol relsym,
                                                   Linear_Expression expr,
                                                   Coefficient denominator);

    public native void generalized_affine_image(Linear_Expression lhs,
                                                Relation_Symbol relsym,
                                                Linear_Expression rhs);

    public native void generalized_affine_preimage(Linear_Expression lhs,
                                                   Relation_Symbol relsym,
                                                   Linear_Expression rhs);

    public native void unconstrain_space_dimension(Variable var);

    public native void unconstrain_space_dimensions(Variables_Set vars);

    public native void widening_assign(Polyhedron y,
                                       By_Reference<Integer> tp);




    public native void swap(Polyhedron y);

    public native void add_space_dimensions_and_embed(long m);

    public native void add_space_dimensions_and_project(long m);

    public native void concatenate_assign(Polyhedron y);


    public native void remove_space_dimensions(Variables_Set vars);

    public native void remove_higher_space_dimensions(long
                                                      new_dimension);


    public native void expand_space_dimension(Variable var, long m);


    public native void fold_space_dimensions(Variables_Set vars,
                                             Variable dest);

    public native void map_space_dimensions(Partial_Function pfunc);



    public native Generator_System generators();

    public native Generator_System minimized_generators();

    public native void add_generator(Generator g);

    public native void add_generators(Generator_System gs);

    public native void poly_hull_assign(Polyhedron y);

    public native void poly_difference_assign(Polyhedron y);

    public native void BHRZ03_widening_assign(Polyhedron y,
                                              By_Reference<Integer> tp);

    public native void H79_widening_assign(Polyhedron y,
                                           By_Reference<Integer> tp);

    public native
        void limited_BHRZ03_extrapolation_assign(Polyhedron y,
                                                 Constraint_System cs,
                                                 By_Reference<Integer> tp);

    public native
        void limited_H79_extrapolation_assign(Polyhedron y,
                                              Constraint_System cs,
                                              By_Reference<Integer> tp);

    public native
        void bounded_BHRZ03_extrapolation_assign(Polyhedron y,
                                                 Constraint_System cs,
                                                 By_Reference<Integer> tp);

    public native
        void bounded_H79_extrapolation_assign(Polyhedron y,
                                              Constraint_System cs,
                                              By_Reference<Integer> tp);


} // class Polyhedron



public class C_Polyhedron extends Polyhedron {




    public C_Polyhedron(long d, Degenerate_Element kind);

    public C_Polyhedron(C_Polyhedron y);


    public C_Polyhedron(C_Polyhedron y, Complexity_Class complexity);


    public C_Polyhedron(Constraint_System cs);


    public C_Polyhedron(Congruence_System cgs);

    public native void free();



    public C_Polyhedron(NNC_Polyhedron y);

    public C_Polyhedron(NNC_Polyhedron y, Complexity_Class complexity);


    public C_Polyhedron(Generator_System gs);




    public native boolean upper_bound_assign_if_exact(C_Polyhedron y);



    public static native
        Pair<C_Polyhedron, Pointset_Powerset_NNC_Polyhedron>
        linear_partition(C_Polyhedron p, C_Polyhedron q);

    protected native void finalize();

} // class C_Polyhedron



public class Pointset_Powerset_C_Polyhedron extends PPL_Object {


    public native void omega_reduce();


    public native long size();

    public native boolean
        geometrically_covers(Pointset_Powerset_C_Polyhedron y);

    public native boolean
        geometrically_equals(Pointset_Powerset_C_Polyhedron y);

    public native Pointset_Powerset_C_Polyhedron_Iterator begin_iterator();

    public native Pointset_Powerset_C_Polyhedron_Iterator end_iterator();

    public native void add_disjunct(C_Polyhedron d);

    // FIXME: this method needs correction, as it returns nothing.
    public native void
        drop_disjunct(Pointset_Powerset_C_Polyhedron_Iterator iter);


    public native void
        drop_disjuncts(Pointset_Powerset_C_Polyhedron_Iterator first,
                       Pointset_Powerset_C_Polyhedron_Iterator last);


    public native void pairwise_reduce();
 /* Ad Hoc Functions for Pointset_Powerset domains */

} // class Pointset_Powerset_C_Polyhedron



public class Pointset_Powerset_C_Polyhedron_Iterator extends PPL_Object {

    public Pointset_Powerset_C_Polyhedron_Iterator
        (Pointset_Powerset_C_Polyhedron_Iterator y);

    public native boolean equals(Pointset_Powerset_C_Polyhedron_Iterator itr);

    public native void next();

    public native void prev();


    public native C_Polyhedron get_disjunct();

    public native void free();

    protected native void finalize();

} // class Pointset_Powerset_C_Polyhedron_Iterator