Uint8_Box.java

Go to the documentation of this file.

/* PPL Java interface: Uint8_Box definition.
   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;

public class Uint8_Box extends PPL_Object {
    protected native void finalize();





    public Uint8_Box(long num_dimensions,
                        Degenerate_Element kind) {
        build_cpp_object(num_dimensions, kind);
    }

    private Uint8_Box() {
    }





    public Uint8_Box(Int8_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Int16_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Int32_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Int64_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Uint8_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Uint16_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Uint32_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Uint64_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Z_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Rational_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_int8_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_int16_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_int32_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_int64_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_mpz_class y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_mpq_class y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_int8_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_int16_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_int32_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_int64_t y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_mpz_class y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_mpq_class y) {
        build_cpp_object(y);
    }

    public Uint8_Box(C_Polyhedron y) {
        build_cpp_object(y);
    }

    public Uint8_Box(NNC_Polyhedron y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Grid y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Float_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_float y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_float y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Double_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_double y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_double y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Long_Double_Box y) {
        build_cpp_object(y);
    }

    public Uint8_Box(BD_Shape_long_double y) {
        build_cpp_object(y);
    }

    public Uint8_Box(Octagonal_Shape_long_double y) {
        build_cpp_object(y);
    }






    public Uint8_Box(Int8_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Int16_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Int32_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Int64_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Uint8_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Uint16_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Uint32_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Uint64_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Z_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Rational_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_int8_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_int16_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_int32_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_int64_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_mpz_class y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_mpq_class y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_int8_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_int16_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_int32_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_int64_t y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_mpz_class y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_mpq_class y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(C_Polyhedron y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(NNC_Polyhedron y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Grid y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Float_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_float y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_float y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Double_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_double y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_double y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Long_Double_Box y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(BD_Shape_long_double y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }

    public Uint8_Box(Octagonal_Shape_long_double y, Complexity_Class complexity) {
        build_cpp_object(y, complexity);
    }






    public Uint8_Box(Constraint_System cs) {
        build_cpp_object(cs);
    }

    public Uint8_Box(Congruence_System cs) {
        build_cpp_object(cs);
    }

    public Uint8_Box(Generator_System cs) {
        build_cpp_object(cs);
    }






    public native void swap(Uint8_Box y);




    public native long space_dimension();

    public native long affine_dimension();





    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 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 contains_integer_point();

    public native boolean is_topologically_closed();

    public native boolean is_discrete();





    public native void topological_closure_assign();





    public native boolean bounds_from_above(Linear_Expression expr);

    public native boolean bounds_from_below(Linear_Expression expr);





    public native boolean has_upper_bound(Variable var,
                                   Coefficient bound_n, Coefficient bound_d,
                                   By_Reference<Boolean> closed);

    public native boolean has_lower_bound(Variable var,
                                   Coefficient bound_n, Coefficient bound_d,
                                   By_Reference<Boolean> closed);





    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 sup_n, Coefficient sup_d,
                                   By_Reference<Boolean> maximum);





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

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





    public native boolean frequency(Linear_Expression expr,
                                    Coefficient freq_n, Coefficient freq_d,
                                    Coefficient val_n, Coefficient val_d);




    public native boolean contains(Uint8_Box y);

    public native boolean strictly_contains(Uint8_Box y);

    public native boolean is_disjoint_from(Uint8_Box y);





    public native boolean equals(Uint8_Box p);

    public boolean equals(Object y) {
   if (this == y)
     return true;
   if (y == null || y.getClass() != this.getClass())
     return false;
   return this.equals((Uint8_Box) y);
  }



    public native boolean OK();




    public native void add_constraint(Constraint c);

    public native void add_congruence(Congruence c);





    public native void add_constraints(Constraint_System c);

    public native void add_congruences(Congruence_System c);





    public native void refine_with_constraint(Constraint c);

    public native void refine_with_congruence(Congruence c);





    public native void refine_with_constraints(Constraint_System c);

    public native void refine_with_congruences(Congruence_System c);





    public native void intersection_assign(Uint8_Box p);

    public native void upper_bound_assign(Uint8_Box p);

    public native void difference_assign(Uint8_Box p);

    public native void concatenate_assign(Uint8_Box p);

    public native void time_elapse_assign(Uint8_Box p);





    public native boolean upper_bound_assign_if_exact(Uint8_Box y);






    public native boolean simplify_using_context_assign(Uint8_Box p);




  public native boolean constrains(Variable var);




    public native void unconstrain_space_dimension(Variable var);




    public native void
      unconstrain_space_dimensions(Variables_Set vars);




    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 add_space_dimensions_and_embed(long m);

    public native void add_space_dimensions_and_project(long m);





    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 void drop_some_non_integer_points
      (Complexity_Class complexity);




    public native void drop_some_non_integer_points
      (Variables_Set vars, Complexity_Class complexity);




    public native String ascii_dump();




  public native long external_memory_in_bytes();

  public native long total_memory_in_bytes();







public native void CC76_widening_assign(Uint8_Box y,
                                By_Reference<Integer> tp);







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






    public native
        void limited_CC76_extrapolation_assign(Uint8_Box y,
                                                 Constraint_System cs,
                                                 By_Reference<Integer> tp);







    public native void
    CC76_narrowing_assign(Uint8_Box arg);







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





    public native void wrap_assign(Variables_Set vars,
                                   Bounded_Integer_Type_Width w,
                                   Bounded_Integer_Type_Representation r,
                                   Bounded_Integer_Type_Overflow o,
                                   Constraint_System cs,
                                   long complexity_threshold,
                                   boolean wrap_individually);




    public native void free();





    public native int hashCode();




    public native String toString();




    private native void build_cpp_object(Constraint_System cs);

    private native void build_cpp_object(Congruence_System cs);

    private native void build_cpp_object(Generator_System cs);





    private native void build_cpp_object(long num_dimensions,
                                         Degenerate_Element kind);




    private native void build_cpp_object(Int8_Box y);

    private native void build_cpp_object(Int8_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Int16_Box y);

    private native void build_cpp_object(Int16_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Int32_Box y);

    private native void build_cpp_object(Int32_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Int64_Box y);

    private native void build_cpp_object(Int64_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Uint8_Box y);

    private native void build_cpp_object(Uint8_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Uint16_Box y);

    private native void build_cpp_object(Uint16_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Uint32_Box y);

    private native void build_cpp_object(Uint32_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Uint64_Box y);

    private native void build_cpp_object(Uint64_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Z_Box y);

    private native void build_cpp_object(Z_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Rational_Box y);

    private native void build_cpp_object(Rational_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_int8_t y);

    private native void build_cpp_object(BD_Shape_int8_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_int16_t y);

    private native void build_cpp_object(BD_Shape_int16_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_int32_t y);

    private native void build_cpp_object(BD_Shape_int32_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_int64_t y);

    private native void build_cpp_object(BD_Shape_int64_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_mpz_class y);

    private native void build_cpp_object(BD_Shape_mpz_class y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_mpq_class y);

    private native void build_cpp_object(BD_Shape_mpq_class y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_int8_t y);

    private native void build_cpp_object(Octagonal_Shape_int8_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_int16_t y);

    private native void build_cpp_object(Octagonal_Shape_int16_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_int32_t y);

    private native void build_cpp_object(Octagonal_Shape_int32_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_int64_t y);

    private native void build_cpp_object(Octagonal_Shape_int64_t y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_mpz_class y);

    private native void build_cpp_object(Octagonal_Shape_mpz_class y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_mpq_class y);

    private native void build_cpp_object(Octagonal_Shape_mpq_class y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(C_Polyhedron y);

    private native void build_cpp_object(C_Polyhedron y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(NNC_Polyhedron y);

    private native void build_cpp_object(NNC_Polyhedron y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Grid y);

    private native void build_cpp_object(Grid y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Float_Box y);

    private native void build_cpp_object(Float_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_float y);

    private native void build_cpp_object(BD_Shape_float y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_float y);

    private native void build_cpp_object(Octagonal_Shape_float y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Double_Box y);

    private native void build_cpp_object(Double_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_double y);

    private native void build_cpp_object(BD_Shape_double y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_double y);

    private native void build_cpp_object(Octagonal_Shape_double y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Long_Double_Box y);

    private native void build_cpp_object(Long_Double_Box y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(BD_Shape_long_double y);

    private native void build_cpp_object(BD_Shape_long_double y,
                                         Complexity_Class complexity);

    private native void build_cpp_object(Octagonal_Shape_long_double y);

    private native void build_cpp_object(Octagonal_Shape_long_double y,
                                         Complexity_Class complexity);






}