00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "ppl_java_common.defs.hh"
00025 #include "parma_polyhedra_library_Artificial_Parameter.h"
00026 #include "parma_polyhedra_library_Artificial_Parameter_Sequence.h"
00027 #include "parma_polyhedra_library_Bounded_Integer_Type_Overflow.h"
00028 #include "parma_polyhedra_library_Bounded_Integer_Type_Representation.h"
00029 #include "parma_polyhedra_library_Bounded_Integer_Type_Width.h"
00030 #include "parma_polyhedra_library_By_Reference.h"
00031 #include "parma_polyhedra_library_Coefficient.h"
00032 #include "parma_polyhedra_library_Complexity_Class.h"
00033 #include "parma_polyhedra_library_Congruence.h"
00034 #include "parma_polyhedra_library_Congruence_System.h"
00035 #include "parma_polyhedra_library_Constraint.h"
00036 #include "parma_polyhedra_library_Constraint_System.h"
00037 #include "parma_polyhedra_library_Degenerate_Element.h"
00038 #include "parma_polyhedra_library_Generator.h"
00039 #include "parma_polyhedra_library_Generator_System.h"
00040 #include "parma_polyhedra_library_Generator_Type.h"
00041 #include "parma_polyhedra_library_Grid_Generator.h"
00042 #include "parma_polyhedra_library_Grid_Generator_System.h"
00043 #include "parma_polyhedra_library_Grid_Generator_Type.h"
00044 #include "parma_polyhedra_library_IO.h"
00045 #include "parma_polyhedra_library_Linear_Expression.h"
00046 #include "parma_polyhedra_library_Linear_Expression_Coefficient.h"
00047 #include "parma_polyhedra_library_Linear_Expression_Difference.h"
00048 #include "parma_polyhedra_library_Linear_Expression_Sum.h"
00049 #include "parma_polyhedra_library_Linear_Expression_Times.h"
00050 #include "parma_polyhedra_library_Linear_Expression_Unary_Minus.h"
00051 #include "parma_polyhedra_library_Linear_Expression_Variable.h"
00052 #include "parma_polyhedra_library_MIP_Problem.h"
00053 #include "parma_polyhedra_library_MIP_Problem_Status.h"
00054 #include "parma_polyhedra_library_Optimization_Mode.h"
00055 #include "parma_polyhedra_library_Pair.h"
00056 #include "parma_polyhedra_library_Parma_Polyhedra_Library.h"
00057 #include "parma_polyhedra_library_Partial_Function.h"
00058 #include "parma_polyhedra_library_PIP_Problem.h"
00059 #include "parma_polyhedra_library_PIP_Problem_Status.h"
00060 #include "parma_polyhedra_library_PIP_Decision_Node.h"
00061 #include "parma_polyhedra_library_PIP_Solution_Node.h"
00062 #include "parma_polyhedra_library_PIP_Tree_Node.h"
00063 #include "parma_polyhedra_library_Poly_Con_Relation.h"
00064 #include "parma_polyhedra_library_Poly_Gen_Relation.h"
00065 #include "parma_polyhedra_library_PPL_Object.h"
00066 #include "parma_polyhedra_library_Relation_Symbol.h"
00067 #include "parma_polyhedra_library_Variable.h"
00068 #include "parma_polyhedra_library_Variables_Set.h"
00069
00070 using namespace Parma_Polyhedra_Library;
00071 using namespace Parma_Polyhedra_Library::Interfaces::Java;
00072
00073 JNIEXPORT void JNICALL
00074 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_initialize_1library
00075 (JNIEnv* env, jclass ) {
00076 initialize();
00077 cached_classes.init_cache(env);
00078 }
00079
00080 JNIEXPORT void JNICALL
00081 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_finalize_1library
00082 (JNIEnv* env, jclass ) {
00083 cached_classes.clear_cache(env);
00084 finalize();
00085 }
00086
00087
00088 JNIEXPORT void JNICALL
00089 Java_parma_1polyhedra_1library_By_1Reference_initIDs
00090 (JNIEnv* env, jclass j_by_ref_class) {
00091 jfieldID fID;
00092 fID = env->GetFieldID(j_by_ref_class, "obj", "Ljava/lang/Object;");
00093 CHECK_RESULT_ASSERT(env, fID);
00094 cached_FMIDs.By_Reference_obj_ID = fID;
00095 jmethodID mID;
00096 mID = env->GetMethodID(j_by_ref_class, "<init>", "(Ljava/lang/Object;)V");
00097 CHECK_RESULT_ASSERT(env, mID);
00098 cached_FMIDs.By_Reference_init_ID = mID;
00099 }
00100
00101 JNIEXPORT jint JNICALL
00102 Java_parma_1polyhedra_1library_Coefficient_bits(JNIEnv*, jclass) {
00103 return PPL_COEFFICIENT_BITS;
00104 }
00105
00106 JNIEXPORT void JNICALL
00107 Java_parma_1polyhedra_1library_Coefficient_initIDs
00108 (JNIEnv* env, jclass j_coeff_class) {
00109 jfieldID fID;
00110 fID = env->GetFieldID(j_coeff_class, "value", "Ljava/math/BigInteger;");
00111 CHECK_RESULT_ASSERT(env, fID);
00112 cached_FMIDs.Coefficient_value_ID = fID;
00113 jmethodID mID;
00114 mID = env->GetMethodID(j_coeff_class, "<init>", "(Ljava/lang/String;)V");
00115 CHECK_RESULT_ASSERT(env, mID);
00116 cached_FMIDs.Coefficient_init_from_String_ID = mID;
00117 mID = env->GetMethodID(j_coeff_class, "toString", "()Ljava/lang/String;");
00118 CHECK_RESULT_ASSERT(env, mID);
00119 cached_FMIDs.Coefficient_toString_ID = mID;
00120
00121 mID = env->GetStaticMethodID(cached_classes.Boolean, "valueOf",
00122 "(Z)Ljava/lang/Boolean;");
00123 CHECK_RESULT_ASSERT(env, mID);
00124 cached_FMIDs.Boolean_valueOf_ID = mID;
00125
00126 mID = env->GetStaticMethodID(cached_classes.Integer, "valueOf",
00127 "(I)Ljava/lang/Integer;");
00128 CHECK_RESULT_ASSERT(env, mID);
00129 cached_FMIDs.Integer_valueOf_ID = mID;
00130 mID = env->GetMethodID(cached_classes.Integer, "intValue", "()I");
00131 CHECK_RESULT_ASSERT(env, mID);
00132 cached_FMIDs.Integer_intValue_ID = mID;
00133
00134 mID = env->GetStaticMethodID(cached_classes.Long, "valueOf",
00135 "(J)Ljava/lang/Long;");
00136 CHECK_RESULT_ASSERT(env, mID);
00137 cached_FMIDs.Long_valueOf_ID = mID;
00138 mID = env->GetMethodID(cached_classes.Long, "longValue", "()J");
00139 CHECK_RESULT_ASSERT(env, mID);
00140 cached_FMIDs.Long_longValue_ID = mID;
00141 }
00142
00143 JNIEXPORT void JNICALL
00144 Java_parma_1polyhedra_1library_Complexity_1Class_initIDs
00145 (JNIEnv* env, jclass j_complexity_class) {
00146 jmethodID mID = env->GetMethodID(j_complexity_class, "ordinal", "()I");
00147 CHECK_RESULT_ASSERT(env, mID);
00148 cached_FMIDs.Complexity_Class_ordinal_ID = mID;
00149 }
00150
00151 JNIEXPORT void JNICALL
00152 Java_parma_1polyhedra_1library_Congruence_initIDs
00153 (JNIEnv* env, jclass j_congruence_class) {
00154 jfieldID fID;
00155 fID = env->GetFieldID(j_congruence_class, "mod",
00156 "Lparma_polyhedra_library/Coefficient;");
00157 CHECK_RESULT_ASSERT(env, fID);
00158 cached_FMIDs.Congruence_mod_ID = fID;
00159 fID = env->GetFieldID(j_congruence_class, "lhs",
00160 "Lparma_polyhedra_library/Linear_Expression;");
00161 CHECK_RESULT_ASSERT(env, fID);
00162 cached_FMIDs.Congruence_lhs_ID = fID;
00163 fID = env->GetFieldID(j_congruence_class, "rhs",
00164 "Lparma_polyhedra_library/Linear_Expression;");
00165 CHECK_RESULT_ASSERT(env, fID);
00166 cached_FMIDs.Congruence_rhs_ID = fID;
00167 jmethodID mID;
00168 mID = env->GetMethodID(j_congruence_class, "<init>",
00169 "(Lparma_polyhedra_library/Linear_Expression;"
00170 "Lparma_polyhedra_library/Linear_Expression;"
00171 "Lparma_polyhedra_library/Coefficient;)V");
00172 CHECK_RESULT_ASSERT(env, mID);
00173 cached_FMIDs.Congruence_init_ID = mID;
00174 }
00175
00176 JNIEXPORT void JNICALL
00177 Java_parma_1polyhedra_1library_Congruence_1System_initIDs
00178 (JNIEnv* env, jclass j_con_sys_class) {
00179 jmethodID mID;
00180 mID = env->GetMethodID(j_con_sys_class, "<init>", "()V");
00181 CHECK_RESULT_ASSERT(env, mID);
00182 cached_FMIDs.Congruence_System_init_ID = mID;
00183 mID = env->GetMethodID(j_con_sys_class, "add", "(Ljava/lang/Object;)Z");
00184 CHECK_RESULT_ASSERT(env, mID);
00185 cached_FMIDs.Congruence_System_add_ID = mID;
00186 }
00187
00188 JNIEXPORT void JNICALL
00189 Java_parma_1polyhedra_1library_Constraint_initIDs
00190 (JNIEnv* env, jclass j_constraint_class) {
00191 jfieldID fID;
00192 fID = env->GetFieldID(j_constraint_class, "lhs",
00193 "Lparma_polyhedra_library/Linear_Expression;");
00194 CHECK_RESULT_ASSERT(env, fID);
00195 cached_FMIDs.Constraint_lhs_ID = fID;
00196 fID = env->GetFieldID(j_constraint_class, "rhs",
00197 "Lparma_polyhedra_library/Linear_Expression;");
00198 CHECK_RESULT_ASSERT(env, fID);
00199 cached_FMIDs.Constraint_rhs_ID = fID;
00200 fID = env->GetFieldID(j_constraint_class, "kind",
00201 "Lparma_polyhedra_library/Relation_Symbol;");
00202 CHECK_RESULT_ASSERT(env, fID);
00203 cached_FMIDs.Constraint_kind_ID = fID;
00204 jmethodID mID;
00205 mID = env->GetMethodID(j_constraint_class, "<init>",
00206 "(Lparma_polyhedra_library/Linear_Expression;"
00207 "Lparma_polyhedra_library/Relation_Symbol;"
00208 "Lparma_polyhedra_library/Linear_Expression;)V");
00209 CHECK_RESULT_ASSERT(env, mID);
00210 cached_FMIDs.Constraint_init_ID = mID;
00211 }
00212
00213 JNIEXPORT void JNICALL
00214 Java_parma_1polyhedra_1library_Constraint_1System_initIDs
00215 (JNIEnv* env, jclass j_con_sys_class) {
00216 jmethodID mID;
00217 mID = env->GetMethodID(j_con_sys_class, "<init>", "()V");
00218 CHECK_RESULT_ASSERT(env, mID);
00219 cached_FMIDs.Constraint_System_init_ID = mID;
00220 mID = env->GetMethodID(j_con_sys_class, "add", "(Ljava/lang/Object;)Z");
00221 CHECK_RESULT_ASSERT(env, mID);
00222 cached_FMIDs.Constraint_System_add_ID = mID;
00223
00224 mID = env->GetMethodID(j_con_sys_class, "iterator",
00225 "()Ljava/util/Iterator;");
00226 CHECK_RESULT_ASSERT(env, mID);
00227 cached_FMIDs.System_iterator_ID = mID;
00228 mID = env->GetMethodID(cached_classes.Iterator, "hasNext", "()Z");
00229 CHECK_RESULT_ASSERT(env, mID);
00230 cached_FMIDs.System_Iterator_has_next_ID = mID;
00231 assert(cached_classes.Iterator != NULL);
00232 mID = env->GetMethodID(cached_classes.Iterator, "next",
00233 "()Ljava/lang/Object;");
00234 CHECK_RESULT_ASSERT(env, mID);
00235 cached_FMIDs.System_Iterator_next_ID = mID;
00236 }
00237
00238 JNIEXPORT void JNICALL
00239 Java_parma_1polyhedra_1library_Degenerate_1Element_initIDs
00240 (JNIEnv* env, jclass j_degenerate_class) {
00241 jmethodID mID = env->GetMethodID(j_degenerate_class, "ordinal", "()I");
00242 CHECK_RESULT_ASSERT(env, mID);
00243 cached_FMIDs.Degenerate_Element_ordinal_ID = mID;
00244 }
00245
00246 JNIEXPORT void JNICALL
00247 Java_parma_1polyhedra_1library_Generator_initIDs
00248 (JNIEnv* env, jclass j_generator_class) {
00249 jfieldID fID;
00250 fID = env->GetFieldID(j_generator_class, "gt",
00251 "Lparma_polyhedra_library/Generator_Type;");
00252 CHECK_RESULT_ASSERT(env, fID);
00253 cached_FMIDs.Generator_gt_ID = fID;
00254 fID = env->GetFieldID(j_generator_class, "le",
00255 "Lparma_polyhedra_library/Linear_Expression;");
00256 CHECK_RESULT_ASSERT(env, fID);
00257 cached_FMIDs.Generator_le_ID = fID;
00258 fID = env->GetFieldID(j_generator_class, "div",
00259 "Lparma_polyhedra_library/Coefficient;");
00260 CHECK_RESULT_ASSERT(env, fID);
00261 cached_FMIDs.Generator_div_ID = fID;
00262 jmethodID mID;
00263 mID = env->GetStaticMethodID(j_generator_class, "line",
00264 "(Lparma_polyhedra_library/Linear_Expression;)"
00265 "Lparma_polyhedra_library/Generator;");
00266 CHECK_RESULT_ASSERT(env, mID);
00267 cached_FMIDs.Generator_line_ID = mID;
00268 mID = env->GetStaticMethodID(j_generator_class, "ray",
00269 "(Lparma_polyhedra_library/Linear_Expression;)"
00270 "Lparma_polyhedra_library/Generator;");
00271 CHECK_RESULT_ASSERT(env, mID);
00272 cached_FMIDs.Generator_ray_ID = mID;
00273 mID = env->GetStaticMethodID(j_generator_class, "point",
00274 "(Lparma_polyhedra_library/Linear_Expression;"
00275 "Lparma_polyhedra_library/Coefficient;)"
00276 "Lparma_polyhedra_library/Generator;");
00277 CHECK_RESULT_ASSERT(env, mID);
00278 cached_FMIDs.Generator_point_ID = mID;
00279 mID = env->GetStaticMethodID(j_generator_class, "closure_point",
00280 "(Lparma_polyhedra_library/Linear_Expression;"
00281 "Lparma_polyhedra_library/Coefficient;)"
00282 "Lparma_polyhedra_library/Generator;");
00283 CHECK_RESULT_ASSERT(env, mID);
00284 cached_FMIDs.Generator_closure_point_ID = mID;
00285 }
00286
00287 JNIEXPORT void JNICALL
00288 Java_parma_1polyhedra_1library_Generator_1System_initIDs
00289 (JNIEnv* env, jclass j_gen_sys_class) {
00290 jmethodID mID;
00291 mID = env->GetMethodID(j_gen_sys_class, "<init>", "()V");
00292 CHECK_RESULT_ASSERT(env, mID);
00293 cached_FMIDs.Generator_System_init_ID = mID;
00294 mID = env->GetMethodID(j_gen_sys_class, "add", "(Ljava/lang/Object;)Z");
00295 CHECK_RESULT_ASSERT(env, mID);
00296 cached_FMIDs.Generator_System_add_ID = mID;
00297 }
00298
00299 JNIEXPORT void JNICALL
00300 Java_parma_1polyhedra_1library_Generator_1Type_initIDs
00301 (JNIEnv* env, jclass j_gen_type_class) {
00302 jmethodID mID;
00303 mID = env->GetMethodID(j_gen_type_class, "ordinal", "()I");
00304 CHECK_RESULT_ASSERT(env, mID);
00305 cached_FMIDs.Generator_Type_ordinal_ID = mID;
00306 }
00307
00308 JNIEXPORT void JNICALL
00309 Java_parma_1polyhedra_1library_Grid_1Generator_initIDs
00310 (JNIEnv* env, jclass j_grid_generator_class) {
00311 jfieldID fID;
00312 fID = env->GetFieldID(j_grid_generator_class, "gt",
00313 "Lparma_polyhedra_library/Grid_Generator_Type;");
00314 CHECK_RESULT_ASSERT(env, fID);
00315 cached_FMIDs.Grid_Generator_gt_ID = fID;
00316 fID = env->GetFieldID(j_grid_generator_class, "le",
00317 "Lparma_polyhedra_library/Linear_Expression;");
00318 CHECK_RESULT_ASSERT(env, fID);
00319 cached_FMIDs.Grid_Generator_le_ID = fID;
00320 fID = env->GetFieldID(j_grid_generator_class, "div",
00321 "Lparma_polyhedra_library/Coefficient;");
00322 CHECK_RESULT_ASSERT(env, fID);
00323 cached_FMIDs.Grid_Generator_div_ID = fID;
00324 jmethodID mID;
00325 mID = env->GetStaticMethodID(j_grid_generator_class, "grid_line",
00326 "(Lparma_polyhedra_library/Linear_Expression;)"
00327 "Lparma_polyhedra_library/Grid_Generator;");
00328 CHECK_RESULT_ASSERT(env, mID);
00329 cached_FMIDs.Grid_Generator_grid_line_ID = mID;
00330 mID = env->GetStaticMethodID(j_grid_generator_class, "parameter",
00331 "(Lparma_polyhedra_library/Linear_Expression;"
00332 "Lparma_polyhedra_library/Coefficient;)"
00333 "Lparma_polyhedra_library/Grid_Generator;");
00334 CHECK_RESULT_ASSERT(env, mID);
00335 cached_FMIDs.Grid_Generator_parameter_ID = mID;
00336 mID = env->GetStaticMethodID(j_grid_generator_class, "grid_point",
00337 "(Lparma_polyhedra_library/Linear_Expression;"
00338 "Lparma_polyhedra_library/Coefficient;)"
00339 "Lparma_polyhedra_library/Grid_Generator;");
00340 CHECK_RESULT_ASSERT(env, mID);
00341 cached_FMIDs.Grid_Generator_grid_point_ID = mID;
00342 }
00343
00344 JNIEXPORT void JNICALL
00345 Java_parma_1polyhedra_1library_Grid_1Generator_1System_initIDs
00346 (JNIEnv* env, jclass j_gen_sys_class) {
00347 jmethodID mID;
00348 mID = env->GetMethodID(j_gen_sys_class, "<init>", "()V");
00349 CHECK_RESULT_ASSERT(env, mID);
00350 cached_FMIDs.Grid_Generator_System_init_ID = mID;
00351 mID = env->GetMethodID(j_gen_sys_class, "add", "(Ljava/lang/Object;)Z");
00352 CHECK_RESULT_ASSERT(env, mID);
00353 cached_FMIDs.Grid_Generator_System_add_ID = mID;
00354 }
00355
00356 JNIEXPORT void JNICALL
00357 Java_parma_1polyhedra_1library_Grid_1Generator_1Type_initIDs
00358 (JNIEnv* env, jclass j_grid_gen_type_class) {
00359 jmethodID mID;
00360 mID = env->GetMethodID(j_grid_gen_type_class, "ordinal", "()I");
00361 CHECK_RESULT_ASSERT(env, mID);
00362 cached_FMIDs.Grid_Generator_Type_ordinal_ID = mID;
00363 }
00364
00365 JNIEXPORT void JNICALL
00366 Java_parma_1polyhedra_1library_Linear_1Expression_initIDs
00367 (JNIEnv* env, jclass j_le_class) {
00368 jmethodID mID;
00369 mID = env->GetMethodID(j_le_class, "sum",
00370 "(Lparma_polyhedra_library/Linear_Expression;)"
00371 "Lparma_polyhedra_library/Linear_Expression;");
00372 CHECK_RESULT_ASSERT(env, mID);
00373 cached_FMIDs.Linear_Expression_sum_ID = mID;
00374 mID = env->GetMethodID(j_le_class, "times",
00375 "(Lparma_polyhedra_library/Coefficient;)"
00376 "Lparma_polyhedra_library/Linear_Expression;");
00377 CHECK_RESULT_ASSERT(env, mID);
00378 cached_FMIDs.Linear_Expression_times_ID = mID;
00379 }
00380
00381 JNIEXPORT void JNICALL
00382 Java_parma_1polyhedra_1library_Linear_1Expression_1Coefficient_initIDs
00383 (JNIEnv* env, jclass j_le_coeff_class) {
00384 jfieldID fID;
00385 fID = env->GetFieldID(j_le_coeff_class, "coeff",
00386 "Lparma_polyhedra_library/Coefficient;");
00387 CHECK_RESULT_ASSERT(env, fID);
00388 cached_FMIDs.Linear_Expression_Coefficient_coeff_ID = fID;
00389 jmethodID mID;
00390 mID = env->GetMethodID(j_le_coeff_class, "<init>",
00391 "(Lparma_polyhedra_library/Coefficient;)V");
00392 CHECK_RESULT_ASSERT(env, mID);
00393 cached_FMIDs.Linear_Expression_Coefficient_init_ID = mID;
00394 }
00395
00396 JNIEXPORT void JNICALL
00397 Java_parma_1polyhedra_1library_Linear_1Expression_1Difference_initIDs
00398 (JNIEnv* env, jclass j_le_diff_class) {
00399 jfieldID fID;
00400 fID = env->GetFieldID(j_le_diff_class, "lhs",
00401 "Lparma_polyhedra_library/Linear_Expression;");
00402 CHECK_RESULT_ASSERT(env, fID);
00403 cached_FMIDs.Linear_Expression_Difference_lhs_ID = fID;
00404 fID = env->GetFieldID(j_le_diff_class, "rhs",
00405 "Lparma_polyhedra_library/Linear_Expression;");
00406 CHECK_RESULT_ASSERT(env, fID);
00407 cached_FMIDs.Linear_Expression_Difference_rhs_ID = fID;
00408 }
00409
00410 JNIEXPORT void JNICALL
00411 Java_parma_1polyhedra_1library_Linear_1Expression_1Sum_initIDs
00412 (JNIEnv* env, jclass j_le_sum_class) {
00413 jfieldID fID;
00414 fID = env->GetFieldID(j_le_sum_class, "lhs",
00415 "Lparma_polyhedra_library/Linear_Expression;");
00416 CHECK_RESULT_ASSERT(env, fID);
00417 cached_FMIDs.Linear_Expression_Sum_lhs_ID = fID;
00418 fID = env->GetFieldID(j_le_sum_class, "rhs",
00419 "Lparma_polyhedra_library/Linear_Expression;");
00420 CHECK_RESULT_ASSERT(env, fID);
00421 cached_FMIDs.Linear_Expression_Sum_rhs_ID = fID;
00422 }
00423
00424 JNIEXPORT void JNICALL
00425 Java_parma_1polyhedra_1library_Linear_1Expression_1Times_initIDs
00426 (JNIEnv* env, jclass j_le_times_class) {
00427 jfieldID fID;
00428 fID = env->GetFieldID(j_le_times_class, "coeff",
00429 "Lparma_polyhedra_library/Coefficient;");
00430 CHECK_RESULT_ASSERT(env, fID);
00431 cached_FMIDs.Linear_Expression_Times_coeff_ID = fID;
00432 fID = env->GetFieldID(j_le_times_class, "lin_expr",
00433 "Lparma_polyhedra_library/Linear_Expression;");
00434 CHECK_RESULT_ASSERT(env, fID);
00435 cached_FMIDs.Linear_Expression_Times_lin_expr_ID = fID;
00436 jmethodID mID;
00437 mID = env->GetMethodID(j_le_times_class, "<init>",
00438 "(Lparma_polyhedra_library/Coefficient;"
00439 "Lparma_polyhedra_library/Variable;)V");
00440 CHECK_RESULT_ASSERT(env, mID);
00441 cached_FMIDs.Linear_Expression_Times_init_from_coeff_var_ID = mID;
00442 }
00443
00444 JNIEXPORT void JNICALL
00445 Java_parma_1polyhedra_1library_Linear_1Expression_1Unary_1Minus_initIDs
00446 (JNIEnv* env, jclass j_le_uminus_class) {
00447 jfieldID fID;
00448 fID = env->GetFieldID(j_le_uminus_class, "arg",
00449 "Lparma_polyhedra_library/Linear_Expression;");
00450 CHECK_RESULT_ASSERT(env, fID);
00451 cached_FMIDs.Linear_Expression_Unary_Minus_arg_ID = fID;
00452 }
00453
00454 JNIEXPORT void JNICALL
00455 Java_parma_1polyhedra_1library_Linear_1Expression_1Variable_initIDs
00456 (JNIEnv* env, jclass j_le_var_class) {
00457 jmethodID mID;
00458 mID = env->GetMethodID(j_le_var_class, "<init>",
00459 "(Lparma_polyhedra_library/Variable;)V");
00460 CHECK_RESULT_ASSERT(env, mID);
00461 cached_FMIDs.Linear_Expression_Variable_init_ID = mID;
00462 mID = env->GetMethodID(j_le_var_class, "var_id", "()I");
00463 CHECK_RESULT_ASSERT(env, mID);
00464 cached_FMIDs.Linear_Expression_Variable_var_id_ID = mID;
00465 }
00466
00467 JNIEXPORT jboolean JNICALL
00468 Java_parma_1polyhedra_1library_Linear_1Expression_is_1zero
00469 (JNIEnv* env, jobject j_this) {
00470 try {
00471 return build_cxx_linear_expression(env, j_this).is_zero();
00472 }
00473 CATCH_ALL
00474 return false;
00475 }
00476
00477 JNIEXPORT jboolean JNICALL
00478 Java_parma_1polyhedra_1library_Linear_1Expression_all_1homogeneous_1terms_1are_1zero
00479 (JNIEnv* env, jobject j_this) {
00480 try {
00481 return build_cxx_linear_expression(env, j_this).all_homogeneous_terms_are_zero();
00482 }
00483 CATCH_ALL
00484 return false;
00485 }
00486
00487 JNIEXPORT void JNICALL
00488 Java_parma_1polyhedra_1library_MIP_1Problem_1Status_initIDs
00489 (JNIEnv* env, jclass j_mip_status_class) {
00490 jfieldID fID;
00491 fID = env->GetStaticFieldID(j_mip_status_class, "UNFEASIBLE_MIP_PROBLEM",
00492 "Lparma_polyhedra_library/MIP_Problem_Status;");
00493 CHECK_RESULT_ASSERT(env, fID);
00494 cached_FMIDs.MIP_Problem_Status_UNFEASIBLE_MIP_PROBLEM_ID = fID;
00495 fID = env->GetStaticFieldID(j_mip_status_class, "UNBOUNDED_MIP_PROBLEM",
00496 "Lparma_polyhedra_library/MIP_Problem_Status;");
00497 CHECK_RESULT_ASSERT(env, fID);
00498 cached_FMIDs.MIP_Problem_Status_UNBOUNDED_MIP_PROBLEM_ID = fID;
00499 fID = env->GetStaticFieldID(j_mip_status_class, "OPTIMIZED_MIP_PROBLEM",
00500 "Lparma_polyhedra_library/MIP_Problem_Status;");
00501 CHECK_RESULT_ASSERT(env, fID);
00502 cached_FMIDs.MIP_Problem_Status_OPTIMIZED_MIP_PROBLEM_ID = fID;
00503 jmethodID mID;
00504 mID = env->GetMethodID(j_mip_status_class, "ordinal", "()I");
00505 CHECK_RESULT_ASSERT(env, mID);
00506 cached_FMIDs.MIP_Problem_Status_ordinal_ID = mID;
00507 }
00508
00509 JNIEXPORT void JNICALL
00510 Java_parma_1polyhedra_1library_PIP_1Problem_1Status_initIDs
00511 (JNIEnv* env, jclass j_mip_status_class) {
00512 jfieldID fID;
00513 fID = env->GetStaticFieldID(j_mip_status_class, "UNFEASIBLE_PIP_PROBLEM",
00514 "Lparma_polyhedra_library/PIP_Problem_Status;");
00515 CHECK_RESULT_ASSERT(env, fID);
00516 cached_FMIDs.PIP_Problem_Status_UNFEASIBLE_PIP_PROBLEM_ID = fID;
00517 fID = env->GetStaticFieldID(j_mip_status_class, "OPTIMIZED_PIP_PROBLEM",
00518 "Lparma_polyhedra_library/PIP_Problem_Status;");
00519 CHECK_RESULT_ASSERT(env, fID);
00520 cached_FMIDs.PIP_Problem_Status_OPTIMIZED_PIP_PROBLEM_ID = fID;
00521 jmethodID mID;
00522 mID = env->GetMethodID(j_mip_status_class, "ordinal", "()I");
00523 CHECK_RESULT_ASSERT(env, mID);
00524 cached_FMIDs.PIP_Problem_Status_ordinal_ID = mID;
00525 }
00526
00527 JNIEXPORT void JNICALL
00528 Java_parma_1polyhedra_1library_Optimization_1Mode_initIDs
00529 (JNIEnv* env, jclass j_opt_mode_class) {
00530 jfieldID fID;
00531 fID = env->GetStaticFieldID(j_opt_mode_class, "MAXIMIZATION",
00532 "Lparma_polyhedra_library/Optimization_Mode;");
00533 CHECK_RESULT_ASSERT(env, fID);
00534 cached_FMIDs.Optimization_Mode_MAXIMIZATION_ID = fID;
00535 fID = env->GetStaticFieldID(j_opt_mode_class, "MINIMIZATION",
00536 "Lparma_polyhedra_library/Optimization_Mode;");
00537 CHECK_RESULT_ASSERT(env, fID);
00538 cached_FMIDs.Optimization_Mode_MINIMIZATION_ID = fID;
00539 jmethodID mID;
00540 mID = env->GetMethodID(j_opt_mode_class, "ordinal", "()I");
00541 CHECK_RESULT_ASSERT(env, mID);
00542 cached_FMIDs.Optimization_Mode_ordinal_ID = mID;
00543 }
00544
00545 JNIEXPORT void JNICALL
00546 Java_parma_1polyhedra_1library_Pair_initIDs
00547 (JNIEnv* env, jclass j_pair_class) {
00548 jfieldID fID;
00549 fID = env->GetFieldID(j_pair_class, "first", "Ljava/lang/Object;");
00550 CHECK_RESULT_ASSERT(env, fID);
00551 cached_FMIDs.Pair_first_ID = fID;
00552 fID = env->GetFieldID(j_pair_class, "second", "Ljava/lang/Object;");
00553 CHECK_RESULT_ASSERT(env, fID);
00554 cached_FMIDs.Pair_second_ID = fID;
00555 }
00556
00557 JNIEXPORT void JNICALL
00558 Java_parma_1polyhedra_1library_Poly_1Con_1Relation_initIDs
00559 (JNIEnv* env, jclass j_poly_con_relation_class) {
00560 jmethodID mID;
00561 mID = env->GetMethodID(j_poly_con_relation_class, "<init>", "(I)V");
00562 CHECK_RESULT_ASSERT(env, mID);
00563 cached_FMIDs.Poly_Con_Relation_init_ID = mID;
00564 }
00565
00566 JNIEXPORT void JNICALL
00567 Java_parma_1polyhedra_1library_Poly_1Gen_1Relation_initIDs
00568 (JNIEnv* env, jclass j_poly_gen_relation_class) {
00569 jmethodID mID;
00570 mID = env->GetMethodID(j_poly_gen_relation_class, "<init>", "(I)V");
00571 CHECK_RESULT_ASSERT(env, mID);
00572 cached_FMIDs.Poly_Gen_Relation_init_ID = mID;
00573 }
00574
00575 JNIEXPORT void JNICALL
00576 Java_parma_1polyhedra_1library_PPL_1Object_initIDs
00577 (JNIEnv* env, jclass j_ppl_object_class) {
00578 jfieldID fID = env->GetFieldID(j_ppl_object_class, "ptr", "J");
00579 CHECK_RESULT_ASSERT(env, fID);
00580 cached_FMIDs.PPL_Object_ptr_ID = fID;
00581 }
00582
00583 JNIEXPORT void JNICALL
00584 Java_parma_1polyhedra_1library_Relation_1Symbol_initIDs
00585 (JNIEnv* env, jclass j_rel_sym_class) {
00586 jfieldID fID;
00587 fID = env->GetStaticFieldID(j_rel_sym_class, "EQUAL",
00588 "Lparma_polyhedra_library/Relation_Symbol;");
00589 CHECK_RESULT_ASSERT(env, fID);
00590 cached_FMIDs.Relation_Symbol_EQUAL_ID = fID;
00591 fID = env->GetStaticFieldID(j_rel_sym_class, "GREATER_THAN",
00592 "Lparma_polyhedra_library/Relation_Symbol;");
00593 CHECK_RESULT_ASSERT(env, fID);
00594 cached_FMIDs.Relation_Symbol_GREATER_THAN_ID = fID;
00595 fID = env->GetStaticFieldID(j_rel_sym_class, "GREATER_OR_EQUAL",
00596 "Lparma_polyhedra_library/Relation_Symbol;");
00597 CHECK_RESULT_ASSERT(env, fID);
00598 cached_FMIDs.Relation_Symbol_GREATER_OR_EQUAL_ID = fID;
00599 jmethodID mID;
00600 mID = env->GetMethodID(j_rel_sym_class, "ordinal", "()I");
00601 CHECK_RESULT_ASSERT(env, mID);
00602 cached_FMIDs.Relation_Symbol_ordinal_ID = mID;
00603 }
00604
00605 JNIEXPORT void JNICALL
00606 Java_parma_1polyhedra_1library_Bounded_1Integer_1Type_1Overflow_initIDs
00607 (JNIEnv* env, jclass j_bounded_overflow_class) {
00608 jfieldID fID;
00609 fID = env->GetStaticFieldID(j_bounded_overflow_class, "OVERFLOW_WRAPS",
00610 "Lparma_polyhedra_library/Bounded_Integer_Type_Overflow;");
00611 CHECK_RESULT_ASSERT(env, fID);
00612 cached_FMIDs.Bounded_Integer_Type_Overflow_OVERFLOW_WRAPS_ID = fID;
00613 fID = env->GetStaticFieldID(j_bounded_overflow_class, "OVERFLOW_UNDEFINED",
00614 "Lparma_polyhedra_library/Bounded_Integer_Type_Overflow;");
00615 CHECK_RESULT_ASSERT(env, fID);
00616 cached_FMIDs.Bounded_Integer_Type_Overflow_OVERFLOW_UNDEFINED_ID = fID;
00617 fID = env->GetStaticFieldID(j_bounded_overflow_class, "OVERFLOW_IMPOSSIBLE",
00618 "Lparma_polyhedra_library/Bounded_Integer_Type_Overflow;");
00619 CHECK_RESULT_ASSERT(env, fID);
00620 cached_FMIDs.Bounded_Integer_Type_Overflow_OVERFLOW_IMPOSSIBLE_ID = fID;
00621 jmethodID mID;
00622 mID = env->GetMethodID(j_bounded_overflow_class, "ordinal", "()I");
00623 CHECK_RESULT_ASSERT(env, mID);
00624 cached_FMIDs.Bounded_Integer_Type_Overflow_ordinal_ID = mID;
00625 }
00626
00627 JNIEXPORT void JNICALL
00628 Java_parma_1polyhedra_1library_Bounded_1Integer_1Type_1Representation_initIDs
00629 (JNIEnv* env, jclass j_bounded_rep_class) {
00630 jfieldID fID;
00631 fID = env->GetStaticFieldID(j_bounded_rep_class, "UNSIGNED",
00632 "Lparma_polyhedra_library/Bounded_Integer_Type_Representation;");
00633 CHECK_RESULT_ASSERT(env, fID);
00634 cached_FMIDs.Bounded_Integer_Type_Representation_UNSIGNED_ID = fID;
00635 fID = env->GetStaticFieldID(j_bounded_rep_class, "SIGNED_2_COMPLEMENT",
00636 "Lparma_polyhedra_library/Bounded_Integer_Type_Representation;");
00637 CHECK_RESULT_ASSERT(env, fID);
00638 cached_FMIDs.Bounded_Integer_Type_Representation_SIGNED_2_COMPLEMENT_ID = fID;
00639 jmethodID mID;
00640 mID = env->GetMethodID(j_bounded_rep_class, "ordinal", "()I");
00641 CHECK_RESULT_ASSERT(env, mID);
00642 cached_FMIDs.Bounded_Integer_Type_Representation_ordinal_ID = mID;
00643 }
00644
00645 JNIEXPORT void JNICALL
00646 Java_parma_1polyhedra_1library_Bounded_1Integer_1Type_1Width_initIDs
00647 (JNIEnv* env, jclass j_bounded_width_class) {
00648 jfieldID fID;
00649 fID = env->GetStaticFieldID(j_bounded_width_class, "BITS_8",
00650 "Lparma_polyhedra_library/Bounded_Integer_Type_Width;");
00651 CHECK_RESULT_ASSERT(env, fID);
00652 cached_FMIDs.Bounded_Integer_Type_Width_BITS_8_ID = fID;
00653 fID = env->GetStaticFieldID(j_bounded_width_class, "BITS_16",
00654 "Lparma_polyhedra_library/Bounded_Integer_Type_Width;");
00655 CHECK_RESULT_ASSERT(env, fID);
00656 cached_FMIDs.Bounded_Integer_Type_Width_BITS_16_ID = fID;
00657 fID = env->GetStaticFieldID(j_bounded_width_class, "BITS_32",
00658 "Lparma_polyhedra_library/Bounded_Integer_Type_Width;");
00659 CHECK_RESULT_ASSERT(env, fID);
00660 cached_FMIDs.Bounded_Integer_Type_Width_BITS_32_ID = fID;
00661 fID = env->GetStaticFieldID(j_bounded_width_class, "BITS_64",
00662 "Lparma_polyhedra_library/Bounded_Integer_Type_Width;");
00663 CHECK_RESULT_ASSERT(env, fID);
00664 cached_FMIDs.Bounded_Integer_Type_Width_BITS_64_ID = fID;
00665 fID = env->GetStaticFieldID(j_bounded_width_class, "BITS_128",
00666 "Lparma_polyhedra_library/Bounded_Integer_Type_Width;");
00667 CHECK_RESULT_ASSERT(env, fID);
00668 cached_FMIDs.Bounded_Integer_Type_Width_BITS_128_ID = fID;
00669 jmethodID mID;
00670 mID = env->GetMethodID(j_bounded_width_class, "ordinal", "()I");
00671 CHECK_RESULT_ASSERT(env, mID);
00672 cached_FMIDs.Bounded_Integer_Type_Width_ordinal_ID = mID;
00673 }
00674
00675 JNIEXPORT void JNICALL
00676 Java_parma_1polyhedra_1library_Variable_initIDs
00677 (JNIEnv* env, jclass j_variable_class) {
00678 jfieldID fID = env->GetFieldID(j_variable_class, "varid", "I");
00679 CHECK_RESULT_ASSERT(env, fID);
00680 cached_FMIDs.Variable_varid_ID = fID;
00681 jmethodID mID = env->GetMethodID(j_variable_class, "<init>", "(I)V");
00682 CHECK_RESULT_ASSERT(env, mID);
00683 cached_FMIDs.Variable_init_ID = mID;
00684 }
00685
00686 JNIEXPORT void JNICALL
00687 Java_parma_1polyhedra_1library_Variables_1Set_initIDs
00688 (JNIEnv* env, jclass j_vset_class) {
00689 jmethodID mID;
00690 mID = env->GetMethodID(j_vset_class, "<init>", "()V");
00691 CHECK_RESULT_ASSERT(env, mID);
00692 cached_FMIDs.Variables_Set_init_ID = mID;
00693 mID = env->GetMethodID(j_vset_class, "add", "(Ljava/lang/Object;)Z");
00694 CHECK_RESULT_ASSERT(env, mID);
00695 cached_FMIDs.Variables_Set_add_ID = mID;
00696 mID = env->GetMethodID(j_vset_class, "iterator", "()Ljava/util/Iterator;");
00697 CHECK_RESULT_ASSERT(env, mID);
00698 cached_FMIDs.Variables_Set_iterator_ID = mID;
00699
00700 jclass j_vset_iter_class = env->FindClass("java/util/Iterator");
00701 CHECK_RESULT_ASSERT(env, j_vset_iter_class);
00702 mID = env->GetMethodID(j_vset_iter_class, "hasNext", "()Z");
00703 CHECK_RESULT_ASSERT(env, mID);
00704 cached_FMIDs.Variables_Set_Iterator_has_next_ID = mID;
00705 mID = env->GetMethodID(j_vset_iter_class, "next", "()Ljava/lang/Object;");
00706 CHECK_RESULT_ASSERT(env, mID);
00707 cached_FMIDs.Variables_Set_Iterator_next_ID = mID;
00708 }
00709
00710
00711 JNIEXPORT jint JNICALL
00712 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_version_1major
00713 (JNIEnv *, jclass) {
00714 return version_major();
00715 }
00716
00717 JNIEXPORT jint JNICALL
00718 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_version_1minor
00719 (JNIEnv *, jclass) {
00720 return version_minor();
00721 }
00722
00723 JNIEXPORT jint JNICALL
00724 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_version_1revision
00725 (JNIEnv *, jclass) {
00726 return version_revision();
00727 }
00728
00729 JNIEXPORT jint JNICALL
00730 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_version_1beta
00731 (JNIEnv *, jclass) {
00732 return version_beta();
00733 }
00734
00735 JNIEXPORT jstring JNICALL
00736 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_version
00737 (JNIEnv* env, jclass) {
00738 return env->NewStringUTF(version());
00739 }
00740
00741 JNIEXPORT jstring JNICALL
00742 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_banner
00743 (JNIEnv* env, jclass) {
00744 return env->NewStringUTF(banner());
00745 }
00746
00747 JNIEXPORT void JNICALL
00748 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_set_1rounding_1for_1PPL
00749 (JNIEnv* env, jclass) {
00750 try {
00751 set_rounding_for_PPL();
00752 }
00753 CATCH_ALL;
00754 }
00755
00756 JNIEXPORT void JNICALL
00757 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_restore_1pre_1PPL_1rounding
00758 (JNIEnv* env, jclass) {
00759 try {
00760 restore_pre_PPL_rounding();
00761 }
00762 CATCH_ALL;
00763 }
00764
00765 JNIEXPORT jint JNICALL
00766 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_irrational_1precision
00767 (JNIEnv* env , jclass) {
00768 try {
00769 return irrational_precision();
00770 }
00771 CATCH_ALL;
00772 return 0;
00773 }
00774
00775 JNIEXPORT void JNICALL
00776 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_set_1irrational_1precision
00777 (JNIEnv* env , jclass, jint p) {
00778 try {
00779 unsigned cxx_p = jtype_to_unsigned<unsigned>(p);
00780 set_irrational_precision(cxx_p);
00781 }
00782 CATCH_ALL;
00783 }
00784
00785 JNIEXPORT void JNICALL
00786 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_set_1timeout
00787 (JNIEnv* env, jclass, jint hsecs) {
00788 try {
00789 #ifndef PPL_WATCHDOG_LIBRARY_ENABLED
00790 const char* what = "PPL Java interface error:\n"
00791 "Parma_Polyhedra_Library::set_timeout: "
00792 "the PPL Watchdog library is not enabled.";
00793 throw std::runtime_error(what);
00794 #else
00795
00796 reset_timeout();
00797 assert(hsecs > 0);
00798 unsigned cxx_hsecs = jtype_to_unsigned<unsigned>(hsecs);
00799 assert(cxx_hsecs > 0);
00800 static timeout_exception e;
00801 using Parma_Watchdog_Library::Watchdog;
00802 p_timeout_object
00803 = new Watchdog(cxx_hsecs, abandon_expensive_computations, e);
00804 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00805 }
00806 CATCH_ALL;
00807 }
00808
00809 JNIEXPORT void JNICALL
00810 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_reset_1timeout
00811 (JNIEnv* env, jclass) {
00812 try {
00813 #ifndef PPL_WATCHDOG_LIBRARY_ENABLED
00814 const char* what = "PPL Java interface error:\n"
00815 "Parma_Polyhedra_Library.reset_timeout(): "
00816 "the PPL Watchdog library is not enabled.";
00817 throw std::runtime_error(what);
00818 #else
00819 reset_timeout();
00820 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00821 }
00822 CATCH_ALL;
00823 }
00824
00825 JNIEXPORT void JNICALL
00826 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_set_1deterministic_1timeout
00827 (JNIEnv* env, jclass, jint weight) {
00828 try {
00829 #ifndef PPL_WATCHDOG_LIBRARY_ENABLED
00830 const char* what = "PPL Java interface error:\n"
00831 "Parma_Polyhedra_Library::set_deterministic_timeout: "
00832 "the PPL Watchdog library is not enabled.";
00833 throw std::runtime_error(what);
00834 #else
00835
00836 reset_deterministic_timeout();
00837 assert(weight > 0);
00838 unsigned cxx_weight = jtype_to_unsigned<unsigned>(weight);
00839 assert(cxx_weight > 0);
00840 static deterministic_timeout_exception e;
00841 p_deterministic_timeout_object
00842 = new Weightwatch(cxx_weight, abandon_expensive_computations, e);
00843 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00844 }
00845 CATCH_ALL;
00846 }
00847
00848 JNIEXPORT void JNICALL
00849 Java_parma_1polyhedra_1library_Parma_1Polyhedra_1Library_reset_1deterministic_1timeout
00850 (JNIEnv* env, jclass) {
00851 try {
00852 #ifndef PPL_WATCHDOG_LIBRARY_ENABLED
00853 const char* what = "PPL Java interface error:\n"
00854 "Parma_Polyhedra_Library.reset_deterministic_timeout(): "
00855 "the PPL Watchdog library is not enabled.";
00856 throw std::runtime_error(what);
00857 #else
00858 reset_deterministic_timeout();
00859 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00860 }
00861 CATCH_ALL;
00862 }
00863
00864 JNIEXPORT jlong JNICALL
00865 Java_parma_1polyhedra_1library_MIP_1Problem_max_1space_1dimension
00866 (JNIEnv* env , jobject j_this_mip_problem) {
00867 try {
00868 MIP_Problem* mip
00869 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00870 return mip->max_space_dimension();
00871 }
00872 CATCH_ALL;
00873 return 0;
00874 }
00875
00876 JNIEXPORT jlong JNICALL
00877 Java_parma_1polyhedra_1library_MIP_1Problem_space_1dimension
00878 (JNIEnv* env , jobject j_this_mip_problem) {
00879 try {
00880 MIP_Problem* mip
00881 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00882 return mip->space_dimension();
00883 }
00884 CATCH_ALL;
00885 return 0;
00886 }
00887
00888 JNIEXPORT jobject JNICALL
00889 Java_parma_1polyhedra_1library_MIP_1Problem_integer_1space_1dimensions
00890 (JNIEnv* env , jobject j_this_mip_problem) {
00891 try {
00892 MIP_Problem* mip
00893 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00894 return build_java_variables_set(env, mip->integer_space_dimensions());
00895 }
00896 CATCH_ALL;
00897 jobject null = 0;
00898 return null;
00899 }
00900
00901 JNIEXPORT jobject JNICALL
00902 Java_parma_1polyhedra_1library_MIP_1Problem_objective_1function
00903 (JNIEnv* env , jobject j_this_mip_problem) {
00904 try {
00905 MIP_Problem* mip
00906 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00907 PPL_DIRTY_TEMP_COEFFICIENT(inhomogeneous_term);
00908 inhomogeneous_term = mip->objective_function().inhomogeneous_term();
00909 jobject j_coeff_inhomogeneous_term
00910 = build_java_coeff(env, inhomogeneous_term);
00911 jobject j_le_coeff
00912 = env->NewObject(cached_classes.Linear_Expression_Coefficient,
00913 cached_FMIDs.Linear_Expression_Coefficient_init_ID,
00914 j_coeff_inhomogeneous_term);
00915 CHECK_RESULT_RETURN(env, j_le_coeff, 0);
00916
00917 jobject j_le = build_linear_expression(env, mip->objective_function());
00918 return env->CallObjectMethod(j_le,
00919 cached_FMIDs.Linear_Expression_sum_ID,
00920 j_le_coeff);
00921 }
00922 CATCH_ALL;
00923 jobject null = 0;
00924 return null;
00925 }
00926
00927 JNIEXPORT jobject JNICALL
00928 Java_parma_1polyhedra_1library_MIP_1Problem_optimization_1mode
00929 (JNIEnv* env , jobject j_this_mip_problem) {
00930 try {
00931 MIP_Problem* mip
00932 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00933 return build_java_optimization_mode(env, mip->optimization_mode());
00934 }
00935 CATCH_ALL;
00936 jobject null = 0;
00937 return null;
00938 }
00939
00940 JNIEXPORT jobject JNICALL
00941 Java_parma_1polyhedra_1library_MIP_1Problem_get_1control_1parameter
00942 (JNIEnv* env , jobject j_this_mip_problem,
00943 jobject j_cpn) {
00944 try {
00945 MIP_Problem* mip
00946 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00947 MIP_Problem::Control_Parameter_Name cpn
00948 = build_cxx_control_parameter_name(env, j_cpn);
00949 return
00950 build_java_control_parameter_value(env,
00951 mip->get_control_parameter(cpn));
00952 }
00953 CATCH_ALL;
00954 jobject null = 0;
00955 return null;
00956 }
00957
00958 JNIEXPORT void JNICALL
00959 Java_parma_1polyhedra_1library_MIP_1Problem_set_1control_1parameter
00960 (JNIEnv* env , jobject j_this_mip_problem,
00961 jobject j_cpv) {
00962 try {
00963 MIP_Problem* mip
00964 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00965 MIP_Problem::Control_Parameter_Value cpv
00966 = build_cxx_control_parameter_value(env, j_cpv);
00967 mip->set_control_parameter(cpv);
00968 }
00969 CATCH_ALL;
00970 }
00971
00972 JNIEXPORT jobject JNICALL
00973 Java_parma_1polyhedra_1library_MIP_1Problem_constraints
00974 (JNIEnv* env, jobject j_this_mip_problem) {
00975 try {
00976 jobject j_cs = env->NewObject(cached_classes.Constraint_System,
00977 cached_FMIDs.Constraint_System_init_ID);
00978 CHECK_RESULT_RETURN(env, j_cs, 0);
00979
00980 MIP_Problem* mip
00981 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
00982 for (MIP_Problem::const_iterator cs_it = mip->constraints_begin(),
00983 cs_end = mip->constraints_end(); cs_it != cs_end; ++cs_it) {
00984 jobject j_constraint = build_java_constraint(env, *cs_it);
00985 env->CallBooleanMethod(j_cs,
00986 cached_FMIDs.Constraint_System_add_ID,
00987 j_constraint);
00988 CHECK_EXCEPTION_RETURN(env, 0);
00989 }
00990 return j_cs;
00991 }
00992 CATCH_ALL;
00993 jobject null = 0;
00994 return null;
00995 }
00996
00997 JNIEXPORT void JNICALL
00998 Java_parma_1polyhedra_1library_MIP_1Problem_clear
00999 (JNIEnv* env , jobject j_this_mip_problem) {
01000 try {
01001 MIP_Problem* mip
01002 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01003 mip->clear();
01004 }
01005 CATCH_ALL;
01006 }
01007
01008 JNIEXPORT void JNICALL
01009 Java_parma_1polyhedra_1library_MIP_1Problem_add_1space_1dimensions_1and_1embed
01010 (JNIEnv* env , jobject j_this_mip_problem, jlong j_dim) {
01011 try {
01012 MIP_Problem* mip
01013 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01014 dimension_type ppl_dim = jtype_to_unsigned<dimension_type>(j_dim);
01015 mip->add_space_dimensions_and_embed(ppl_dim);
01016 }
01017 CATCH_ALL;
01018 }
01019
01020 JNIEXPORT void JNICALL
01021 Java_parma_1polyhedra_1library_MIP_1Problem_add_1to_1integer_1space_1dimensions
01022 (JNIEnv* env , jobject j_this_mip_problem, jobject j_vset) {
01023 try {
01024 MIP_Problem* mip
01025 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01026 Variables_Set v_set = build_cxx_variables_set(env, j_vset);
01027 mip->add_to_integer_space_dimensions(v_set);
01028 }
01029 CATCH_ALL;
01030 }
01031
01032 JNIEXPORT void JNICALL
01033 Java_parma_1polyhedra_1library_MIP_1Problem_add_1constraint
01034 (JNIEnv* env , jobject j_this_mip_problem, jobject j_c) {
01035 try {
01036 MIP_Problem* mip
01037 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01038 Constraint c = build_cxx_constraint(env, j_c);
01039 mip->add_constraint(c);
01040 }
01041 CATCH_ALL;
01042 }
01043
01044 JNIEXPORT void JNICALL
01045 Java_parma_1polyhedra_1library_MIP_1Problem_add_1constraints
01046 (JNIEnv* env , jobject j_this_mip_problem, jobject j_cs) {
01047 try {
01048 MIP_Problem* mip
01049 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01050 Constraint_System cs = build_cxx_constraint_system(env, j_cs);
01051 mip->add_constraints(cs);
01052 }
01053 CATCH_ALL;
01054 }
01055
01056 JNIEXPORT void JNICALL
01057 Java_parma_1polyhedra_1library_MIP_1Problem_set_1objective_1function
01058 (JNIEnv* env , jobject j_this_mip_problem, jobject j_le) {
01059 try {
01060 MIP_Problem* mip
01061 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01062 Linear_Expression le = build_cxx_linear_expression(env, j_le);
01063 mip->set_objective_function(le);
01064 }
01065 CATCH_ALL;
01066 }
01067
01068 JNIEXPORT void JNICALL
01069 Java_parma_1polyhedra_1library_MIP_1Problem_set_1optimization_1mode
01070 (JNIEnv* env , jobject j_this_mip_problem, jobject j_opt_mode) {
01071 try {
01072 MIP_Problem* mip
01073 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01074 Optimization_Mode opt_mode = build_cxx_optimization_mode(env, j_opt_mode);
01075 mip->set_optimization_mode(opt_mode);
01076 }
01077 CATCH_ALL;
01078 }
01079
01080 JNIEXPORT jboolean JNICALL
01081 Java_parma_1polyhedra_1library_MIP_1Problem_is_1satisfiable
01082 (JNIEnv* env , jobject j_this_mip_problem) {
01083 try {
01084 MIP_Problem* mip
01085 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01086 return mip->is_satisfiable();
01087 }
01088 CATCH_ALL;
01089 return false;
01090 }
01091
01092 JNIEXPORT jobject JNICALL Java_parma_1polyhedra_1library_MIP_1Problem_solve
01093 (JNIEnv* env , jobject j_this_mip_problem) {
01094 try {
01095 MIP_Problem* mip
01096 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01097 return build_java_mip_status(env, mip->solve());
01098 }
01099 CATCH_ALL;
01100 jobject null = 0;
01101 return null;
01102 }
01103
01104 JNIEXPORT void JNICALL
01105 Java_parma_1polyhedra_1library_MIP_1Problem_evaluate_1objective_1function
01106 (JNIEnv* env, jobject j_this_mip_problem, jobject j_gen,
01107 jobject j_coeff_num, jobject j_coeff_den) {
01108 try {
01109 MIP_Problem* mip
01110 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01111 Generator g = build_cxx_generator(env, j_gen);
01112 PPL_DIRTY_TEMP_COEFFICIENT(num);
01113 PPL_DIRTY_TEMP_COEFFICIENT(den);
01114 mip->evaluate_objective_function(g, num, den);
01115 set_coefficient(env, j_coeff_num, build_java_coeff(env, num));
01116 set_coefficient(env, j_coeff_den, build_java_coeff(env, den));
01117 }
01118 CATCH_ALL;
01119 }
01120
01121 JNIEXPORT jobject JNICALL
01122 Java_parma_1polyhedra_1library_MIP_1Problem_feasible_1point
01123 (JNIEnv* env , jobject j_this_mip_problem) {
01124 try {
01125 MIP_Problem* mip
01126 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01127 Generator g = mip->feasible_point();
01128 return build_java_generator(env, g);
01129 }
01130 CATCH_ALL;
01131 jobject null = 0;
01132 return null;
01133 }
01134
01135 JNIEXPORT jobject JNICALL
01136 Java_parma_1polyhedra_1library_MIP_1Problem_optimizing_1point
01137 (JNIEnv* env , jobject j_this_mip_problem) {
01138 try {
01139 MIP_Problem* mip
01140 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01141 Generator g = mip->optimizing_point();
01142 return build_java_generator(env, g);
01143 }
01144 CATCH_ALL;
01145 jobject null = 0;
01146 return null;
01147 }
01148
01149 JNIEXPORT void JNICALL
01150 Java_parma_1polyhedra_1library_MIP_1Problem_optimal_1value
01151 (JNIEnv* env, jobject j_this_mip_problem,
01152 jobject j_coeff_num, jobject j_coeff_den) {
01153 try {
01154 PPL_DIRTY_TEMP_COEFFICIENT(coeff_num);
01155 PPL_DIRTY_TEMP_COEFFICIENT(coeff_den);
01156 MIP_Problem* mip
01157 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01158 mip->optimal_value(coeff_num, coeff_den);
01159 set_coefficient(env, j_coeff_num, build_java_coeff(env, coeff_num));
01160 set_coefficient(env, j_coeff_den, build_java_coeff(env, coeff_den));
01161 }
01162 CATCH_ALL;
01163 }
01164
01165 JNIEXPORT jboolean JNICALL
01166 Java_parma_1polyhedra_1library_MIP_1Problem_OK
01167 (JNIEnv* env , jobject j_this_mip_problem) {
01168 try {
01169 MIP_Problem* mip
01170 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01171 return mip->OK();
01172 }
01173 CATCH_ALL;
01174 return false;
01175 }
01176
01177 JNIEXPORT void JNICALL
01178 Java_parma_1polyhedra_1library_MIP_1Problem_build_1cpp_1object__J
01179 (JNIEnv* env, jobject j_this_mip_problem, jlong j_dim) {
01180 try {
01181 dimension_type ppl_dim = jtype_to_unsigned<dimension_type>(j_dim);
01182 MIP_Problem* mip_ptr = new MIP_Problem(ppl_dim);
01183 set_ptr(env, j_this_mip_problem, mip_ptr);
01184 }
01185 CATCH_ALL;
01186 }
01187
01188 JNIEXPORT void JNICALL
01189 Java_parma_1polyhedra_1library_MIP_1Problem_build_1cpp_1object__JLparma_1polyhedra_1library_Constraint_1System_2Lparma_1polyhedra_1library_Linear_1Expression_2Lparma_1polyhedra_1library_Optimization_1Mode_2
01190 (JNIEnv* env , jobject j_this_mip_problem, jlong j_dim, jobject j_cs,
01191 jobject j_le, jobject j_opt_mode) {
01192 try {
01193 dimension_type ppl_dim = jtype_to_unsigned<dimension_type>(j_dim);
01194 Constraint_System cs = build_cxx_constraint_system(env, j_cs);
01195 Linear_Expression le = build_cxx_linear_expression(env, j_le);
01196 Optimization_Mode opt_mode = build_cxx_optimization_mode(env, j_opt_mode);
01197 MIP_Problem* mip_ptr = new MIP_Problem(ppl_dim, cs, le, opt_mode);
01198 set_ptr(env, j_this_mip_problem, mip_ptr);
01199 }
01200 CATCH_ALL;
01201 }
01202
01203 JNIEXPORT void JNICALL
01204 Java_parma_1polyhedra_1library_MIP_1Problem_build_1cpp_1object__Lparma_1polyhedra_1library_MIP_1Problem_2
01205 (JNIEnv* env, jobject j_this, jobject j_y)
01206 {
01207 MIP_Problem* y_ptr = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_y));
01208 MIP_Problem* this_ptr = new MIP_Problem(*y_ptr);
01209 set_ptr(env, j_this, this_ptr);
01210 }
01211
01212 JNIEXPORT void JNICALL
01213 Java_parma_1polyhedra_1library_MIP_1Problem_free
01214 (JNIEnv* env, jobject j_this) {
01215 MIP_Problem* mip = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this));
01216 if (!is_java_marked(env, j_this)) {
01217 delete mip;
01218 void* null_ptr = 0;
01219 set_ptr(env, j_this, null_ptr);
01220 }
01221 }
01222
01223 JNIEXPORT void JNICALL
01224 Java_parma_1polyhedra_1library_MIP_1Problem_finalize
01225 (JNIEnv* env, jobject j_this) {
01226 MIP_Problem* mip = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this));
01227 if (!is_java_marked(env, j_this))
01228 delete mip;
01229 }
01230
01231 JNIEXPORT jlong JNICALL
01232 Java_parma_1polyhedra_1library_MIP_1Problem_total_1memory_1in_1bytes
01233 (JNIEnv* env , jobject j_this_mip_problem) {
01234 try {
01235 MIP_Problem* mip
01236 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this_mip_problem));
01237 return mip->total_memory_in_bytes();
01238 }
01239 CATCH_ALL;
01240 return 0;
01241 }
01242
01243 JNIEXPORT jstring JNICALL
01244 Java_parma_1polyhedra_1library_MIP_1Problem_toString
01245 (JNIEnv* env, jobject j_this) {
01246 MIP_Problem* this_ptr
01247 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this));
01248 using namespace Parma_Polyhedra_Library::IO_Operators;
01249 std::ostringstream s;
01250 s << *this_ptr;
01251 return env->NewStringUTF(s.str().c_str());
01252 }
01253
01254 JNIEXPORT jstring JNICALL
01255 Java_parma_1polyhedra_1library_MIP_1Problem_ascii_1dump
01256 (JNIEnv* env, jobject j_this) {
01257 try {
01258 MIP_Problem* this_ptr
01259 = reinterpret_cast<MIP_Problem*>(get_ptr(env, j_this));
01260 std::ostringstream s;
01261 this_ptr->ascii_dump(s);
01262 return env->NewStringUTF(s.str().c_str());
01263 }
01264 CATCH_ALL;
01265 return 0;
01266 }
01267
01268 JNIEXPORT jstring JNICALL
01269 Java_parma_1polyhedra_1library_Linear_1Expression_toString
01270 (JNIEnv* env, jobject j_this) {
01271 using namespace Parma_Polyhedra_Library::IO_Operators;
01272 Linear_Expression ppl_le = build_cxx_linear_expression(env, j_this);
01273 std::ostringstream s;
01274 s << ppl_le;
01275 return env->NewStringUTF(s.str().c_str());
01276 }
01277
01278 JNIEXPORT jstring JNICALL
01279 Java_parma_1polyhedra_1library_Linear_1Expression_ascii_1dump
01280 (JNIEnv* env, jobject j_this) {
01281 try {
01282 std::ostringstream s;
01283 Linear_Expression le = build_cxx_linear_expression(env, j_this);
01284 le.ascii_dump(s);
01285 return env->NewStringUTF(s.str().c_str());
01286 }
01287 CATCH_ALL;
01288 return 0;
01289 }
01290
01291 JNIEXPORT jstring JNICALL
01292 Java_parma_1polyhedra_1library_Generator_toString
01293 (JNIEnv* env, jobject g) {
01294 using namespace Parma_Polyhedra_Library::IO_Operators;
01295 std::ostringstream s;
01296 Generator ppl_g = build_cxx_generator(env, g);
01297 s << ppl_g;
01298 return env->NewStringUTF(s.str().c_str());
01299 }
01300
01301 JNIEXPORT jstring JNICALL
01302 Java_parma_1polyhedra_1library_Generator_ascii_1dump
01303 (JNIEnv* env, jobject j_this) {
01304 try {
01305 std::ostringstream s;
01306 Generator g = build_cxx_generator(env, j_this);
01307 g.ascii_dump(s);
01308 return env->NewStringUTF(s.str().c_str());
01309 }
01310 CATCH_ALL;
01311 return 0;
01312 }
01313
01314 JNIEXPORT jstring JNICALL
01315 Java_parma_1polyhedra_1library_Constraint_toString
01316 (JNIEnv* env, jobject c) {
01317 using namespace Parma_Polyhedra_Library::IO_Operators;
01318 std::ostringstream s;
01319 Constraint ppl_c = build_cxx_constraint(env, c);
01320 s << ppl_c;
01321 return env->NewStringUTF(s.str().c_str());
01322 }
01323
01324 JNIEXPORT jstring JNICALL
01325 Java_parma_1polyhedra_1library_Constraint_ascii_1dump
01326 (JNIEnv* env, jobject j_this) {
01327 try {
01328 std::ostringstream s;
01329 Constraint c = build_cxx_constraint(env, j_this);
01330 c.ascii_dump(s);
01331 return env->NewStringUTF(s.str().c_str());
01332 }
01333 CATCH_ALL;
01334 return 0;
01335 }
01336
01337 JNIEXPORT jstring JNICALL
01338 Java_parma_1polyhedra_1library_Grid_1Generator_toString
01339 (JNIEnv* env, jobject g) {
01340 using namespace Parma_Polyhedra_Library::IO_Operators;
01341 std::ostringstream s;
01342 Grid_Generator ppl_g = build_cxx_grid_generator(env, g);
01343 s << ppl_g;
01344 return env->NewStringUTF(s.str().c_str());
01345 }
01346
01347 JNIEXPORT jstring JNICALL
01348 Java_parma_1polyhedra_1library_Grid_1Generator_ascii_1dump
01349 (JNIEnv* env, jobject j_this) {
01350 try {
01351 std::ostringstream s;
01352 Grid_Generator g = build_cxx_grid_generator(env, j_this);
01353 g.ascii_dump(s);
01354 return env->NewStringUTF(s.str().c_str());
01355 }
01356 CATCH_ALL;
01357 return 0;
01358 }
01359
01360 JNIEXPORT jstring JNICALL
01361 Java_parma_1polyhedra_1library_Congruence_toString
01362 (JNIEnv* env, jobject g) {
01363 using namespace Parma_Polyhedra_Library::IO_Operators;
01364 std::ostringstream s;
01365 Congruence ppl_g = build_cxx_congruence(env, g);
01366 s << ppl_g;
01367 return env->NewStringUTF(s.str().c_str());
01368 }
01369
01370 JNIEXPORT jstring JNICALL
01371 Java_parma_1polyhedra_1library_Congruence_ascii_1dump
01372 (JNIEnv* env, jobject j_this) {
01373 try {
01374 std::ostringstream s;
01375 Congruence c = build_cxx_congruence(env, j_this);
01376 c.ascii_dump(s);
01377 return env->NewStringUTF(s.str().c_str());
01378 }
01379 CATCH_ALL;
01380 return 0;
01381 }
01382
01383 JNIEXPORT jstring JNICALL
01384 Java_parma_1polyhedra_1library_Grid_1Generator_1System_toString
01385 (JNIEnv* env, jobject ggs) {
01386 using namespace Parma_Polyhedra_Library::IO_Operators;
01387 std::ostringstream s;
01388 Grid_Generator_System ppl_ggs = build_cxx_grid_generator_system(env, ggs);
01389 s << ppl_ggs;
01390 return env->NewStringUTF(s.str().c_str());
01391 }
01392
01393 JNIEXPORT jstring JNICALL
01394 Java_parma_1polyhedra_1library_Grid_1Generator_1System_ascii_1dump
01395 (JNIEnv* env, jobject j_this) {
01396 try {
01397 std::ostringstream s;
01398 Grid_Generator_System gs = build_cxx_grid_generator_system(env, j_this);
01399 gs.ascii_dump(s);
01400 return env->NewStringUTF(s.str().c_str());
01401 }
01402 CATCH_ALL;
01403 return 0;
01404 }
01405
01406 JNIEXPORT jstring JNICALL
01407 Java_parma_1polyhedra_1library_Generator_1System_toString
01408 (JNIEnv* env, jobject gs) {
01409 using namespace Parma_Polyhedra_Library::IO_Operators;
01410 std::ostringstream s;
01411 Generator_System ppl_gs = build_cxx_generator_system(env, gs);
01412 s << ppl_gs;
01413 return env->NewStringUTF(s.str().c_str());
01414 }
01415
01416 JNIEXPORT jstring JNICALL
01417 Java_parma_1polyhedra_1library_Generator_1System_ascii_1dump
01418 (JNIEnv* env, jobject j_this) {
01419 try {
01420 std::ostringstream s;
01421 Generator_System gs = build_cxx_generator_system(env, j_this);
01422 gs.ascii_dump(s);
01423 return env->NewStringUTF(s.str().c_str());
01424 }
01425 CATCH_ALL;
01426 return 0;
01427 }
01428
01429 JNIEXPORT jstring JNICALL
01430 Java_parma_1polyhedra_1library_Constraint_1System_toString
01431 (JNIEnv* env, jobject cs) {
01432 using namespace Parma_Polyhedra_Library::IO_Operators;
01433 std::ostringstream s;
01434 Constraint_System ppl_cs = build_cxx_constraint_system(env, cs);
01435 s << ppl_cs;
01436 return env->NewStringUTF(s.str().c_str());
01437 }
01438
01439
01440 JNIEXPORT jstring JNICALL
01441 Java_parma_1polyhedra_1library_Constraint_1System_ascii_1dump
01442 (JNIEnv* env, jobject j_this) {
01443 try {
01444 std::ostringstream s;
01445 Constraint_System cs = build_cxx_constraint_system(env, j_this);
01446 cs.ascii_dump(s);
01447 return env->NewStringUTF(s.str().c_str());
01448 }
01449 CATCH_ALL;
01450 return 0;
01451 }
01452
01453 JNIEXPORT jstring JNICALL
01454 Java_parma_1polyhedra_1library_Congruence_1System_toString
01455 (JNIEnv* env, jobject cgs) {
01456 using namespace Parma_Polyhedra_Library::IO_Operators;
01457 std::ostringstream s;
01458 Congruence_System ppl_cgs = build_cxx_congruence_system(env, cgs);
01459 s << ppl_cgs;
01460 return env->NewStringUTF(s.str().c_str());
01461 }
01462
01463 JNIEXPORT jstring JNICALL
01464 Java_parma_1polyhedra_1library_Congruence_1System_ascii_1dump
01465 (JNIEnv* env, jobject j_this) {
01466 try {
01467 std::ostringstream s;
01468 Congruence_System cs = build_cxx_congruence_system(env, j_this);
01469 cs.ascii_dump(s);
01470 return env->NewStringUTF(s.str().c_str());
01471 }
01472 CATCH_ALL;
01473 return 0;
01474 }
01475
01476 JNIEXPORT jstring JNICALL
01477 Java_parma_1polyhedra_1library_IO_wrap_1string
01478 (JNIEnv* env, jclass, jstring str, jint indent_depth,
01479 jint preferred_first_line_length, jint preferred_line_length) {
01480 try {
01481 unsigned ind = jtype_to_unsigned<unsigned int>(indent_depth);
01482 unsigned pfll = jtype_to_unsigned<unsigned int>
01483 (preferred_first_line_length);
01484 unsigned pll = jtype_to_unsigned<unsigned int>(preferred_line_length);
01485 const char* chars = env->GetStringUTFChars(str, 0);
01486 CHECK_RESULT_RETURN(env, chars, 0);
01487 using namespace Parma_Polyhedra_Library::IO_Operators;
01488 std::string s = wrap_string(chars, ind, pfll, pll);
01489 env->ReleaseStringUTFChars(str, chars);
01490 return env->NewStringUTF(s.c_str());
01491 }
01492 CATCH_ALL;
01493 return 0;
01494 }
01495
01496 JNIEXPORT void JNICALL
01497 Java_parma_1polyhedra_1library_PIP_1Problem_build_1cpp_1object__J
01498 (JNIEnv* env, jobject j_this_pip_problem, jlong j_dim) {
01499 try {
01500 dimension_type ppl_dim = jtype_to_unsigned<dimension_type>(j_dim);
01501 PIP_Problem* pip_ptr = new PIP_Problem(ppl_dim);
01502 set_ptr(env, j_this_pip_problem, pip_ptr);
01503 }
01504 CATCH_ALL;
01505 }
01506
01507 JNIEXPORT void JNICALL
01508 Java_parma_1polyhedra_1library_PIP_1Problem_build_1cpp_1object__JLparma_1polyhedra_1library_Constraint_1System_2Lparma_1polyhedra_1library_Variables_1Set_2
01509 (JNIEnv* env , jobject j_this_pip_problem, jlong j_dim,
01510 jobject j_cs, jobject j_vars) {
01511 try {
01512 dimension_type p_dim = jtype_to_unsigned<dimension_type>(j_dim);
01513 Constraint_System p_cs = build_cxx_constraint_system(env, j_cs);
01514 Variables_Set p_vars = build_cxx_variables_set(env, j_vars);
01515 PIP_Problem* pip_ptr = new PIP_Problem(p_dim, p_cs.begin(),
01516 p_cs.end(), p_vars);
01517 set_ptr(env, j_this_pip_problem, pip_ptr);
01518 }
01519 CATCH_ALL;
01520 }
01521
01522 JNIEXPORT void JNICALL
01523 Java_parma_1polyhedra_1library_PIP_1Problem_build_1cpp_1object__Lparma_1polyhedra_1library_PIP_1Problem_2
01524 (JNIEnv* env, jobject j_this, jobject j_y)
01525 {
01526 PIP_Problem* y_ptr = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_y));
01527 PIP_Problem* this_ptr = new PIP_Problem(*y_ptr);
01528 set_ptr(env, j_this, this_ptr);
01529 }
01530
01531 JNIEXPORT jboolean JNICALL
01532 Java_parma_1polyhedra_1library_PIP_1Problem_OK
01533 (JNIEnv* env , jobject j_this_pip_problem) {
01534 try {
01535 PIP_Problem* pip
01536 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01537 return pip->OK();
01538 }
01539 CATCH_ALL;
01540 return false;
01541 }
01542
01543 JNIEXPORT jlong JNICALL
01544 Java_parma_1polyhedra_1library_PIP_1Problem_total_1memory_1in_1bytes
01545 (JNIEnv* env , jobject j_this_pip_problem) {
01546 try {
01547 PIP_Problem* pip
01548 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01549 return pip->total_memory_in_bytes();
01550 }
01551 CATCH_ALL;
01552 return 0;
01553 }
01554
01555 JNIEXPORT jlong JNICALL
01556 Java_parma_1polyhedra_1library_PIP_1Problem_external_1memory_1in_1bytes
01557 (JNIEnv* env , jobject j_this_pip_problem) {
01558 try {
01559 PIP_Problem* pip
01560 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01561 return pip->external_memory_in_bytes();
01562 }
01563 CATCH_ALL;
01564 return 0;
01565 }
01566
01567 JNIEXPORT jstring JNICALL
01568 Java_parma_1polyhedra_1library_PIP_1Problem_toString
01569 (JNIEnv* env, jobject j_this) {
01570 PIP_Problem* this_ptr
01571 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this));
01572 using namespace Parma_Polyhedra_Library::IO_Operators;
01573 std::ostringstream s;
01574 s << *this_ptr;
01575 return env->NewStringUTF(s.str().c_str());
01576 }
01577
01578 JNIEXPORT jstring JNICALL
01579 Java_parma_1polyhedra_1library_PIP_1Problem_ascii_1dump
01580 (JNIEnv* env, jobject j_this) {
01581 try {
01582 PIP_Problem* this_ptr
01583 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this));
01584 std::ostringstream s;
01585 this_ptr->ascii_dump(s);
01586 return env->NewStringUTF(s.str().c_str());
01587 }
01588 CATCH_ALL;
01589 return 0;
01590 }
01591
01592 JNIEXPORT void JNICALL
01593 Java_parma_1polyhedra_1library_PIP_1Problem_free
01594 (JNIEnv* env, jobject j_this) {
01595 PIP_Problem* pip = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this));
01596 if (!is_java_marked(env, j_this)) {
01597 delete pip;
01598 void* null_ptr = 0;
01599 set_ptr(env, j_this, null_ptr);
01600 }
01601 }
01602
01603 JNIEXPORT void JNICALL
01604 Java_parma_1polyhedra_1library_PIP_1_problem_finalize
01605 (JNIEnv* env, jobject j_this) {
01606 PIP_Problem* pip = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this));
01607 if (!is_java_marked(env, j_this))
01608 delete pip;
01609 }
01610
01611 JNIEXPORT jlong JNICALL
01612 Java_parma_1polyhedra_1library_PIP_1Problem_max_1space_1dimension
01613 (JNIEnv* env , jobject j_this_pip_problem) {
01614 try {
01615 PIP_Problem* pip
01616 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01617 return pip->max_space_dimension();
01618 }
01619 CATCH_ALL;
01620 return 0;
01621 }
01622
01623 JNIEXPORT jlong JNICALL
01624 Java_parma_1polyhedra_1library_PIP_1Problem_space_1dimension
01625 (JNIEnv* env , jobject j_this_pip_problem) {
01626 try {
01627 PIP_Problem* pip
01628 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01629 return pip->space_dimension();
01630 }
01631 CATCH_ALL;
01632 return 0;
01633 }
01634
01635 JNIEXPORT jlong JNICALL
01636 Java_parma_1polyhedra_1library_PIP_1Problem_get_1big_1parameter_1dimension
01637 (JNIEnv* env , jobject j_this_pip_problem) {
01638 try {
01639 PIP_Problem* pip
01640 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01641 return pip->get_big_parameter_dimension();
01642 }
01643 CATCH_ALL;
01644 return 0;
01645 }
01646
01647 JNIEXPORT jobject JNICALL
01648 Java_parma_1polyhedra_1library_PIP_1Problem_parameter_1space_1dimensions
01649 (JNIEnv* env , jobject j_this_pip_problem) {
01650 try {
01651 PIP_Problem* pip
01652 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01653 return build_java_variables_set(env, pip->parameter_space_dimensions());
01654 }
01655 CATCH_ALL;
01656 jobject null = 0;
01657 return null;
01658 }
01659
01660 JNIEXPORT void JNICALL
01661 Java_parma_1polyhedra_1library_PIP_1Problem_set_1big_1parameter_1dimension
01662 (JNIEnv* env , jobject j_this_pip_problem, jlong j_dim) {
01663 try {
01664 PIP_Problem* pip
01665 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01666 dimension_type ppl_dim = jtype_to_unsigned<dimension_type>(j_dim);
01667 pip->set_big_parameter_dimension(ppl_dim);
01668 }
01669 CATCH_ALL;
01670 }
01671
01672 JNIEXPORT jlong JNICALL
01673 Java_parma_1polyhedra_1library_PIP_1Problem_number_1of_1parameter_1space_1dimensions
01674 (JNIEnv* env , jobject j_this_pip_problem) {
01675 try {
01676 PIP_Problem* pip
01677 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01678 return pip->parameter_space_dimensions().size();
01679 }
01680 CATCH_ALL;
01681 return 0;
01682 }
01683
01684 JNIEXPORT void JNICALL
01685 Java_parma_1polyhedra_1library_PIP_1Problem_add_1space_1dimensions_1and_1embed
01686 (JNIEnv* env , jobject j_this_pip_problem, jlong j_dim_vars, jlong j_dim_pars) {
01687 try {
01688 PIP_Problem* pip
01689 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01690 dimension_type ppl_dim_vars = jtype_to_unsigned<dimension_type>(j_dim_vars);
01691 dimension_type ppl_dim_pars = jtype_to_unsigned<dimension_type>(j_dim_pars);
01692 pip->add_space_dimensions_and_embed(ppl_dim_vars, ppl_dim_pars);
01693 }
01694 CATCH_ALL;
01695 }
01696
01697 JNIEXPORT void JNICALL
01698 Java_parma_1polyhedra_1library_PIP_1Problem_add_1to_1parameter_1space_1dimensions
01699 (JNIEnv* env , jobject j_this_pip_problem, jobject j_vars) {
01700 try {
01701 PIP_Problem* pip
01702 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01703 Variables_Set ppl_vars = build_cxx_variables_set(env, j_vars);
01704 pip->add_to_parameter_space_dimensions(ppl_vars);
01705 }
01706 CATCH_ALL;
01707 }
01708
01709 JNIEXPORT jlong JNICALL
01710 Java_parma_1polyhedra_1library_PIP_1Problem_number_1of_1constraints
01711 (JNIEnv* env , jobject j_this_pip_problem) {
01712 try {
01713 PIP_Problem* pip
01714 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01715 return pip->constraints_end() - pip->constraints_begin();
01716 }
01717 CATCH_ALL;
01718 return 0;
01719 }
01720
01721 JNIEXPORT void JNICALL
01722 Java_parma_1polyhedra_1library_PIP_1Problem_add_1constraint
01723 (JNIEnv* env , jobject j_this_pip_problem, jobject j_c) {
01724 try {
01725 PIP_Problem* pip
01726 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01727 Constraint c = build_cxx_constraint(env, j_c);
01728 pip->add_constraint(c);
01729 }
01730 CATCH_ALL;
01731 }
01732
01733 JNIEXPORT void JNICALL
01734 Java_parma_1polyhedra_1library_PIP_1Problem_add_1constraints
01735 (JNIEnv* env , jobject j_this_pip_problem, jobject j_cs) {
01736 try {
01737 PIP_Problem* pip
01738 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01739 Constraint_System cs = build_cxx_constraint_system(env, j_cs);
01740 pip->add_constraints(cs);
01741 }
01742 CATCH_ALL;
01743 }
01744
01745 JNIEXPORT jboolean JNICALL
01746 Java_parma_1polyhedra_1library_PIP_1Problem_is_1satisfiable
01747 (JNIEnv* env , jobject j_this_pip_problem) {
01748 try {
01749 PIP_Problem* pip
01750 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01751 return pip->is_satisfiable();
01752 }
01753 CATCH_ALL;
01754 return false;
01755 }
01756
01757 JNIEXPORT jobject JNICALL Java_parma_1polyhedra_1library_PIP_1Problem_solve
01758 (JNIEnv* env , jobject j_this_pip_problem) {
01759 try {
01760 PIP_Problem* pip
01761 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01762 return build_java_pip_status(env, pip->solve());
01763 }
01764 CATCH_ALL;
01765 jobject null = 0;
01766 return null;
01767 }
01768
01769 JNIEXPORT jobject JNICALL Java_parma_1polyhedra_1library_PIP_1Problem_solution
01770 (JNIEnv* env , jobject j_this_pip_problem) {
01771 try {
01772 PIP_Problem* pip
01773 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01774 const PIP_Tree_Node* solution = pip->solution();
01775
01776 jclass j_class_s = env->FindClass("parma_polyhedra_library/PIP_Tree_Node");
01777 CHECK_RESULT_ASSERT(env, j_class_s);
01778 jmethodID j_ctr_id_s = env->GetMethodID(j_class_s, "<init>", "()V");
01779 CHECK_RESULT_ASSERT(env, j_ctr_id_s);
01780 jobject j_obj_s = env->NewObject(j_class_s, j_ctr_id_s);
01781 CHECK_RESULT_RETURN(env, j_obj_s, 0);
01782 set_ptr(env, j_obj_s, solution);
01783 return j_obj_s;
01784 }
01785 CATCH_ALL;
01786 jobject null = 0;
01787 return null;
01788 }
01789
01790 JNIEXPORT jobject JNICALL
01791 Java_parma_1polyhedra_1library_PIP_1Problem_optimizing_1solution
01792 (JNIEnv* env , jobject j_this_pip_problem) {
01793 try {
01794 PIP_Problem* pip
01795 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01796 const PIP_Tree_Node* solution = pip->optimizing_solution();
01797
01798 jclass j_class_s = env->FindClass("parma_polyhedra_library/PIP_Tree_Node");
01799 CHECK_RESULT_ASSERT(env, j_class_s);
01800 jmethodID j_ctr_id_s = env->GetMethodID(j_class_s, "<init>", "()V");
01801 CHECK_RESULT_ASSERT(env, j_ctr_id_s);
01802 jobject j_obj_s = env->NewObject(j_class_s, j_ctr_id_s);
01803 CHECK_RESULT_RETURN(env, j_obj_s, 0);
01804 set_ptr(env, j_obj_s, solution);
01805 return j_obj_s;
01806 }
01807 CATCH_ALL;
01808 jobject null = 0;
01809 return null;
01810 }
01811
01812 JNIEXPORT jobject JNICALL
01813 Java_parma_1polyhedra_1library_PIP_1Problem_get_1pip_1problem_1control_1parameter
01814 (JNIEnv* env , jobject j_this_pip_problem,
01815 jobject j_cpn) {
01816 try {
01817 PIP_Problem* pip
01818 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01819 PIP_Problem::Control_Parameter_Name ppl_cpn
01820 = build_cxx_pip_problem_control_parameter_name(env, j_cpn);
01821 return
01822 build_java_pip_problem_control_parameter_value
01823 (env, pip->get_control_parameter(ppl_cpn));
01824 }
01825 CATCH_ALL;
01826 jobject null = 0;
01827 return null;
01828 }
01829
01830 JNIEXPORT jobject JNICALL
01831 Java_parma_1polyhedra_1library_PIP_1Problem_constraint_1at_1index
01832 (JNIEnv* env, jobject j_this_pip_problem, jlong j_index) {
01833 try {
01834 PIP_Problem* pip
01835 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01836 dimension_type p_index = jtype_to_unsigned<dimension_type>(j_index);
01837 return build_java_constraint(env, *(pip->constraints_begin() + p_index));
01838 }
01839 CATCH_ALL;
01840 jobject null = 0;
01841 return null;
01842 }
01843
01844 JNIEXPORT jobject JNICALL
01845 Java_parma_1polyhedra_1library_PIP_1Problem_constraints
01846 (JNIEnv* env, jobject j_this_pip_problem) {
01847 try {
01848 jobject j_cs = env->NewObject(cached_classes.Constraint_System,
01849 cached_FMIDs.Constraint_System_init_ID);
01850 CHECK_RESULT_RETURN(env, j_cs, 0);
01851
01852 PIP_Problem* pip
01853 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01854 for (PIP_Problem::const_iterator cs_it = pip->constraints_begin(),
01855 cs_end = pip->constraints_end(); cs_it != cs_end; ++cs_it) {
01856 jobject j_constraint = build_java_constraint(env, *cs_it);
01857 env->CallBooleanMethod(j_cs,
01858 cached_FMIDs.Constraint_System_add_ID,
01859 j_constraint);
01860 CHECK_EXCEPTION_RETURN(env, 0);
01861 }
01862 return j_cs;
01863 }
01864 CATCH_ALL;
01865 jobject null = 0;
01866 return null;
01867 }
01868
01869 JNIEXPORT void JNICALL
01870 Java_parma_1polyhedra_1library_PIP_1Problem_set_1pip_1problem_1control_1parameter
01871 (JNIEnv* env, jobject j_this_pip_problem, jobject j_cpv) {
01872 try {
01873 PIP_Problem* pip
01874 = reinterpret_cast<PIP_Problem*>(get_ptr(env, j_this_pip_problem));
01875 PIP_Problem::Control_Parameter_Value ppl_cpv
01876 = build_cxx_pip_problem_control_parameter_value(env, j_cpv);
01877 pip->set_control_parameter(ppl_cpv);
01878 }
01879 CATCH_ALL;
01880 }
01881
01882 JNIEXPORT jboolean JNICALL
01883 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_OK
01884 (JNIEnv* env, jobject j_this_pip_tree) {
01885 try {
01886 PIP_Tree_Node* pip
01887 = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this_pip_tree));
01888 return pip->OK();
01889 }
01890 CATCH_ALL;
01891 return false;
01892 }
01893
01894 JNIEXPORT void JNICALL
01895 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_free
01896 (JNIEnv* env, jobject j_this) {
01897 PIP_Tree_Node* pip = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this));
01898 if (!is_java_marked(env, j_this)) {
01899 delete pip;
01900 void* null_ptr = 0;
01901 set_ptr(env, j_this, null_ptr);
01902 }
01903 }
01904
01905 JNIEXPORT void JNICALL
01906 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_finalize
01907 (JNIEnv* env, jobject j_this) {
01908 PIP_Tree_Node* pip = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this));
01909 if (!is_java_marked(env, j_this))
01910 delete pip;
01911 }
01912
01913 JNIEXPORT jobject JNICALL
01914 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_constraints
01915 (JNIEnv* env, jobject j_this_pip_node) {
01916 try {
01917 jobject j_cs = env->NewObject(cached_classes.Constraint_System,
01918 cached_FMIDs.Constraint_System_init_ID);
01919 CHECK_RESULT_RETURN(env, j_cs, 0);
01920
01921 PIP_Tree_Node* pip
01922 = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this_pip_node));
01923 return build_java_constraint_system(env, pip->constraints());
01924 }
01925 CATCH_ALL;
01926 jobject null = 0;
01927 return null;
01928 }
01929
01930 JNIEXPORT jobject JNICALL
01931 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_as_1solution
01932 (JNIEnv* env, jobject j_this) {
01933 try {
01934 PIP_Tree_Node* pip = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this));
01935 const PIP_Solution_Node* solution = pip->as_solution();
01936 if (solution == 0) {
01937 jobject null = 0;
01938 return null;
01939 }
01940
01941 jclass j_class_s
01942 = env->FindClass("parma_polyhedra_library/PIP_Solution_Node");
01943 CHECK_RESULT_ASSERT(env, j_class_s);
01944 jmethodID j_ctr_id_s = env->GetMethodID(j_class_s, "<init>", "()V");
01945 CHECK_RESULT_ASSERT(env, j_ctr_id_s);
01946 jobject j_obj_s = env->NewObject(j_class_s, j_ctr_id_s);
01947 CHECK_RESULT_RETURN(env, j_obj_s, 0);
01948 set_ptr(env, j_obj_s, solution);
01949 return j_obj_s;
01950 }
01951 CATCH_ALL;
01952 jobject null = 0;
01953 return null;
01954 }
01955
01956 JNIEXPORT jobject JNICALL
01957 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_as_1decision
01958 (JNIEnv* env, jobject j_this) {
01959 try {
01960 PIP_Tree_Node* pip = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this));
01961 const PIP_Decision_Node* decision = pip->as_decision();
01962 if (decision == 0) {
01963 jobject null = 0;
01964 return null;
01965 }
01966
01967 jclass j_class_d
01968 = env->FindClass("parma_polyhedra_library/PIP_Decision_Node");
01969 CHECK_RESULT_ASSERT(env, j_class_d);
01970 jmethodID j_ctr_id_d = env->GetMethodID(j_class_d, "<init>", "()V");
01971 CHECK_RESULT_ASSERT(env, j_ctr_id_d);
01972 jobject j_obj_d = env->NewObject(j_class_d, j_ctr_id_d);
01973 CHECK_RESULT_RETURN(env, j_obj_d, 0);
01974 set_ptr(env, j_obj_d, decision);
01975 return j_obj_d;
01976 }
01977 CATCH_ALL;
01978 jobject null = 0;
01979 return null;
01980 }
01981
01982 JNIEXPORT jlong JNICALL
01983 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_number_1of_1artificials
01984 (JNIEnv* env , jobject j_this) {
01985 try {
01986 PIP_Tree_Node* pip = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this));
01987 return pip->art_parameter_count();
01988 }
01989 CATCH_ALL;
01990 return 0;
01991 }
01992
01993 JNIEXPORT jobject JNICALL
01994 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_artificials
01995 (JNIEnv* env, jobject j_this_pip_node) {
01996 try {
01997 jobject j_arts
01998 = env->NewObject(cached_classes.Artificial_Parameter_Sequence,
01999 cached_FMIDs.Artificial_Parameter_Sequence_init_ID);
02000 CHECK_RESULT_RETURN(env, j_arts, 0);
02001
02002 const PIP_Tree_Node* pip_node
02003 = reinterpret_cast<const PIP_Tree_Node*>(get_ptr(env, j_this_pip_node));
02004 for (PIP_Tree_Node::Artificial_Parameter_Sequence::const_iterator
02005 i = pip_node->art_parameter_begin(),
02006 i_end = pip_node->art_parameter_end(); i != i_end; ++i) {
02007 jobject j_art = build_java_artificial_parameter(env, *i);
02008 env->CallBooleanMethod(j_arts,
02009 cached_FMIDs.Artificial_Parameter_Sequence_add_ID,
02010 j_art);
02011 CHECK_EXCEPTION_RETURN(env, 0);
02012 }
02013 return j_arts;
02014 }
02015 CATCH_ALL;
02016 jobject null = 0;
02017 return null;
02018 }
02019
02020 JNIEXPORT jstring JNICALL
02021 Java_parma_1polyhedra_1library_PIP_1Tree_1Node_toString
02022 (JNIEnv* env, jobject j_this) {
02023 PIP_Tree_Node* this_ptr
02024 = reinterpret_cast<PIP_Tree_Node*>(get_ptr(env, j_this));
02025 using namespace Parma_Polyhedra_Library::IO_Operators;
02026 std::ostringstream s;
02027 s << *this_ptr;
02028 return env->NewStringUTF(s.str().c_str());
02029 }
02030
02031 JNIEXPORT jobject JNICALL
02032 Java_parma_1polyhedra_1library_PIP_1Decision_1Node_child_1node
02033 (JNIEnv* env, jobject j_this, jboolean j_branch) {
02034 try {
02035 PIP_Decision_Node* dec_node
02036 = reinterpret_cast<PIP_Decision_Node*>(get_ptr(env, j_this));
02037 const PIP_Tree_Node* child = dec_node->child_node(j_branch);
02038 if (child == 0) {
02039 jobject null = 0;
02040 return null;
02041 }
02042 jclass j_class_s = env->FindClass("parma_polyhedra_library/PIP_Tree_Node");
02043 CHECK_RESULT_ASSERT(env, j_class_s);
02044 jmethodID j_ctr_id_s = env->GetMethodID(j_class_s, "<init>", "()V");
02045 CHECK_RESULT_ASSERT(env, j_ctr_id_s);
02046 jobject j_obj_s = env->NewObject(j_class_s, j_ctr_id_s);
02047 CHECK_RESULT_RETURN(env, j_obj_s, 0);
02048 set_ptr(env, j_obj_s, child);
02049 return j_obj_s;
02050 }
02051 CATCH_ALL;
02052 jobject null = 0;
02053 return null;
02054 }
02055
02056 JNIEXPORT jobject JNICALL
02057 Java_parma_1polyhedra_1library_PIP_1Solution_1Node_parametric_1values
02058 (JNIEnv* env, jobject j_this, jobject j_var) {
02059 PIP_Solution_Node* pip
02060 = reinterpret_cast<PIP_Solution_Node*>(get_ptr(env, j_this));
02061 Variable v = build_cxx_variable(env, j_var);
02062 return build_linear_expression(env, pip->parametric_values(v));
02063 }
02064
02065 JNIEXPORT void JNICALL
02066 Java_parma_1polyhedra_1library_Artificial_1Parameter_initIDs
02067 (JNIEnv* env, jclass j_artificial_parameter_class) {
02068 jfieldID fID;
02069 fID = env->GetFieldID(j_artificial_parameter_class, "le",
02070 "Lparma_polyhedra_library/Linear_Expression;");
02071 CHECK_RESULT_ASSERT(env, fID);
02072 cached_FMIDs.Artificial_Parameter_le_ID = fID;
02073 fID = env->GetFieldID(j_artificial_parameter_class, "den",
02074 "Lparma_polyhedra_library/Coefficient;");
02075 CHECK_RESULT_ASSERT(env, fID);
02076 cached_FMIDs.Artificial_Parameter_den_ID = fID;
02077 jmethodID mID;
02078 mID = env->GetMethodID(j_artificial_parameter_class, "<init>",
02079 "(Lparma_polyhedra_library/Linear_Expression;"
02080 "Lparma_polyhedra_library/Coefficient;)V");
02081 CHECK_RESULT_ASSERT(env, mID);
02082 cached_FMIDs.Artificial_Parameter_init_ID = mID;
02083 }
02084
02085 JNIEXPORT jstring JNICALL
02086 Java_parma_1polyhedra_1library_Artificial_1Parameter_ascii_1dump
02087 (JNIEnv* env, jobject j_this) {
02088 try {
02089 std::ostringstream s;
02090 PIP_Tree_Node::Artificial_Parameter art
02091 = build_cxx_artificial_parameter(env, j_this);
02092 art.ascii_dump(s);
02093 return env->NewStringUTF(s.str().c_str());
02094 }
02095 CATCH_ALL;
02096 return 0;
02097 }
02098
02099 JNIEXPORT jstring JNICALL
02100 Java_parma_1polyhedra_1library_Artificial_1Parameter_toString
02101 (JNIEnv* env, jobject j_this) {
02102 using namespace Parma_Polyhedra_Library::IO_Operators;
02103 std::ostringstream s;
02104 PIP_Tree_Node::Artificial_Parameter ppl_art
02105 = build_cxx_artificial_parameter(env, j_this);
02106 s << ppl_art;
02107 return env->NewStringUTF(s.str().c_str());
02108 }
02109
02110 JNIEXPORT void JNICALL
02111 Java_parma_1polyhedra_1library_Artificial_1Parameter_1Sequence_initIDs
02112 (JNIEnv* env, jclass j_aps_class) {
02113 jmethodID mID;
02114 mID = env->GetMethodID(j_aps_class, "<init>", "()V");
02115 CHECK_RESULT_ASSERT(env, mID);
02116 cached_FMIDs.Artificial_Parameter_Sequence_init_ID = mID;
02117 mID = env->GetMethodID(j_aps_class, "add", "(Ljava/lang/Object;)Z");
02118 CHECK_RESULT_ASSERT(env, mID);
02119 cached_FMIDs.Artificial_Parameter_Sequence_add_ID = mID;
02120 }
02121
02122
02123 JNIEXPORT void JNICALL
02124 Java_parma_1polyhedra_1library_Partial_1Function_build_1cpp_1object
02125 (JNIEnv* env, jobject j_this_pfunc) {
02126 try {
02127 Partial_Function* pfunc_ptr = new Partial_Function;
02128 set_ptr(env, j_this_pfunc, pfunc_ptr);
02129 }
02130 CATCH_ALL;
02131 }
02132
02133 JNIEXPORT jboolean JNICALL
02134 Java_parma_1polyhedra_1library_Partial_1Function_has_1empty_1codomain
02135 (JNIEnv* env , jobject j_this_pfunc) {
02136 try {
02137 Partial_Function* pfunc
02138 = reinterpret_cast<Partial_Function*>(get_ptr(env, j_this_pfunc));
02139 return pfunc->has_empty_codomain();
02140 }
02141 CATCH_ALL;
02142 return 0;
02143 }
02144
02145 JNIEXPORT jlong JNICALL
02146 Java_parma_1polyhedra_1library_Partial_1Function_max_1in_1codomain
02147 (JNIEnv* env , jobject j_this_pfunc) {
02148 try {
02149 Partial_Function* pfunc
02150 = reinterpret_cast<Partial_Function*>(get_ptr(env, j_this_pfunc));
02151 return pfunc->max_in_codomain();
02152 }
02153 CATCH_ALL;
02154 return 0;
02155 }
02156
02157 JNIEXPORT jlong JNICALL
02158 Java_parma_1polyhedra_1library_Partial_1Function_maps
02159 (JNIEnv* env, jobject j_this_pfunc, jlong j_i) {
02160 Partial_Function* pfunc
02161 = reinterpret_cast<Partial_Function*>(get_ptr(env, j_this_pfunc));
02162 dimension_type i = jtype_to_unsigned<dimension_type>(j_i);
02163 dimension_type j;
02164 if (pfunc->maps(i, j))
02165 return j;
02166 else
02167 return -1;
02168 }
02169
02170 JNIEXPORT void JNICALL
02171 Java_parma_1polyhedra_1library_Partial_1Function_insert
02172 (JNIEnv* env , jobject j_this_pfunc, jlong i, jlong j) {
02173 try {
02174 Partial_Function* pfunc
02175 = reinterpret_cast<Partial_Function*>(get_ptr(env, j_this_pfunc));
02176 pfunc->insert(i, j);
02177 }
02178 CATCH_ALL;
02179 }
02180
02181 JNIEXPORT void JNICALL
02182 Java_parma_1polyhedra_1library_Partial_1Function_free
02183 (JNIEnv* env, jobject j_this) {
02184 Partial_Function* pfunc
02185 = reinterpret_cast<Partial_Function*>(get_ptr(env, j_this));
02186 if (!is_java_marked(env, j_this)) {
02187 delete pfunc;
02188 void* null_ptr = 0;
02189 set_ptr(env, j_this, null_ptr);
02190 }
02191 }
02192
02193 JNIEXPORT void JNICALL
02194 Java_parma_1polyhedra_1library_Partial_1Function_finalize
02195 (JNIEnv* env, jobject j_this) {
02196 Partial_Function* pfunc
02197 = reinterpret_cast<Partial_Function*>(get_ptr(env, j_this));
02198 if (!is_java_marked(env, j_this))
02199 delete pfunc;
02200 }