#! /bin/sh # This is a shell archive, meaning: # 1. Remove everything above the #! /bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create the files: # Ada/ # Ada/Continuation/ # Ada/Continuation/READ_ME # Ada/Homotopy/ # Ada/Homotopy/READ_ME # Ada/Homotopy/makefile # Ada/Main/ # Ada/Main/READ_ME # Ada/Math_Lib/ # Ada/Math_Lib/Matrices/ # Ada/Math_Lib/Matrices/READ_ME # Ada/Math_Lib/Numbers/ # Ada/Math_Lib/Numbers/READ_ME # Ada/Math_Lib/Polynomials/ # Ada/Math_Lib/Polynomials/READ_ME # Ada/Math_Lib/READ_ME # Ada/Math_Lib/Supports/ # Ada/Math_Lib/Supports/READ_ME # Ada/Objects/ # Ada/Objects/Continuation/ # Ada/Objects/Continuation/makefile # Ada/Objects/Homotopy/ # Ada/Objects/Homotopy/makefile # Ada/Objects/Main/ # Ada/Objects/Main/makefile # Ada/Objects/Math_Lib/ # Ada/Objects/Math_Lib/Matrices/ # Ada/Objects/Math_Lib/Matrices/makefile # Ada/Objects/Math_Lib/Numbers/ # Ada/Objects/Math_Lib/Numbers/makefile # Ada/Objects/Math_Lib/Polynomials/ # Ada/Objects/Math_Lib/Polynomials/makefile # Ada/Objects/Math_Lib/Supports/ # Ada/Objects/Math_Lib/Supports/makefile # Ada/Objects/Math_Lib/makeall # Ada/Objects/Math_Lib/makeclean # Ada/Objects/Math_Lib/makefile # Ada/Objects/READ_ME # Ada/Objects/Root_Counts/ # Ada/Objects/Root_Counts/Dynlift/ # Ada/Objects/Root_Counts/Dynlift/makefile # Ada/Objects/Root_Counts/Implift/ # Ada/Objects/Root_Counts/Implift/makefile # Ada/Objects/Root_Counts/Product/ # Ada/Objects/Root_Counts/Product/makefile # Ada/Objects/Root_Counts/Stalift/ # Ada/Objects/Root_Counts/Stalift/makefile # Ada/Objects/Root_Counts/Symmetry/ # Ada/Objects/Root_Counts/Symmetry/makefile # Ada/Objects/Root_Counts/makeall # Ada/Objects/Root_Counts/makeclean # Ada/Objects/Root_Counts/makefile # Ada/Objects/Root_Counts/makelog # Ada/Objects/System/ # Ada/Objects/System/makefile # Ada/Objects/makeall # Ada/Objects/makeclean # Ada/Objects/makefile # Ada/Objects/makelib # Ada/READ_ME # Ada/Root_Counts/ # Ada/Root_Counts/Dynlift/ # Ada/Root_Counts/Dynlift/READ_ME # Ada/Root_Counts/Implift/ # Ada/Root_Counts/Implift/READ_ME # Ada/Root_Counts/Product/ # Ada/Root_Counts/Product/READ_ME # Ada/Root_Counts/READ_ME # Ada/Root_Counts/Stalift/ # Ada/Root_Counts/Stalift/READ_ME # Ada/Root_Counts/Symmetry/ # Ada/Root_Counts/Symmetry/READ_ME # Ada/System/ # Ada/System/READ_ME # Demo/ # Demo/READ_ME # Demo/boon # Demo/butcher # Demo/butcher8 # Demo/camera1s # Demo/caprasse # Demo/cassou # Demo/chemequ # Demo/chemequs # Demo/cohn2 # Demo/cohn3 # Demo/comb3000 # Demo/comb3000s # Demo/conform1 # Demo/cpdm5 # Demo/cyclic5 # Demo/cyclic6 # Demo/cyclic7 # Demo/cyclic8 # Demo/d1 # Demo/des18_3 # Demo/des22_24 # Demo/discret3s # Demo/eco5 # Demo/eco6 # Demo/eco7 # Demo/eco8 # Demo/extcyc5 # Demo/extcyc6 # Demo/extcyc7 # Demo/extcyc8 # Demo/fbrfive12 # Demo/fbrfive4 # Demo/fourbar # Demo/gaukwa2 # Demo/gaukwa3 # Demo/gaukwa4 # Demo/geneig # Demo/heart # Demo/i1 # Demo/ipp # Demo/ipp2 # Demo/katsura5 # Demo/kin1 # Demo/kinema # Demo/ku10 # Demo/lorentz # Demo/lumped # Demo/mickey # Demo/noon3 # Demo/noon4 # Demo/noon5 # Demo/proddeco # Demo/puma # Demo/quadfor2 # Demo/quadgrid # Demo/rabmo # Demo/rbpl # Demo/rbpl24 # Demo/rbpl24es # Demo/rbpl24s # Demo/redcyc5 # Demo/redcyc6 # Demo/redcyc7 # Demo/redcyc8 # Demo/redeco5 # Demo/redeco6 # Demo/redeco7 # Demo/redeco8 # Demo/rediff3 # Demo/reimer5 # Demo/rose # Demo/s9_1 # Demo/sendra # Demo/solotarev # Demo/sparse5 # Demo/speer # Demo/trinks # Demo/virasoro # Demo/wood # Demo/wright # GNAT/ # GNAT/Continuation/ # GNAT/Continuation/bablpoco.adb # GNAT/Continuation/bablpoco.ads # GNAT/Continuation/black_box_polynomial_continuations.adb # GNAT/Continuation/black_box_polynomial_continuations.ads # GNAT/Continuation/continuation_data.adb # GNAT/Continuation/continuation_data.ads # GNAT/Continuation/continuation_parameters.adb # GNAT/Continuation/continuation_parameters.ads # GNAT/Continuation/continuation_parameters_io.adb # GNAT/Continuation/continuation_parameters_io.ads # GNAT/Continuation/correctors.adb # GNAT/Continuation/correctors.ads # GNAT/Continuation/directions_of_solution_paths.adb # GNAT/Continuation/directions_of_solution_paths.ads # GNAT/Continuation/dispatch_predictors.adb # GNAT/Continuation/dispatch_predictors.ads # GNAT/Continuation/driver_for_winding_numbers.adb # GNAT/Continuation/driver_for_winding_numbers.ads # GNAT/Continuation/drivers_for_path_directions.adb # GNAT/Continuation/drivers_for_path_directions.ads # GNAT/Continuation/drivers_for_polynomial_continuation.adb # GNAT/Continuation/drivers_for_polynomial_continuation.ads # GNAT/Continuation/increment_and_fix_continuation.adb # GNAT/Continuation/increment_and_fix_continuation.ads # GNAT/Continuation/mainpoco.adb # GNAT/Continuation/mainpoco.ads # GNAT/Continuation/makefile # GNAT/Continuation/path_trackers.adb # GNAT/Continuation/path_trackers.ads # GNAT/Continuation/predictors.adb # GNAT/Continuation/predictors.ads # GNAT/Continuation/process_io.adb # GNAT/Continuation/process_io.ads # GNAT/Continuation/root_refiners.adb # GNAT/Continuation/root_refiners.ads # GNAT/Continuation/scanners_for_continuation.adb # GNAT/Continuation/scanners_for_continuation.ads # GNAT/Continuation/valipoco.adb # GNAT/Continuation/valipoco.ads # GNAT/Continuation/vlprs_algorithm.adb # GNAT/Continuation/vlprs_algorithm.ads # GNAT/Continuation/vlprs_tables.adb # GNAT/Continuation/vlprs_tables.ads # GNAT/Homotopy/ # GNAT/Homotopy/driver_for_homotopy_construction.adb # GNAT/Homotopy/driver_for_homotopy_construction.ads # GNAT/Homotopy/drivers_for_reduction.adb # GNAT/Homotopy/drivers_for_reduction.ads # GNAT/Homotopy/drivers_for_scaling.adb # GNAT/Homotopy/drivers_for_scaling.ads # GNAT/Homotopy/floating_equalities.adb # GNAT/Homotopy/floating_equalities.ads # GNAT/Homotopy/homogenization.adb # GNAT/Homotopy/homogenization.ads # GNAT/Homotopy/homotopy.adb # GNAT/Homotopy/homotopy.ads # GNAT/Homotopy/mainred.adb # GNAT/Homotopy/mainred.ads # GNAT/Homotopy/mainscal.adb # GNAT/Homotopy/mainscal.ads # GNAT/Homotopy/makefile # GNAT/Homotopy/projective_transformations.adb # GNAT/Homotopy/projective_transformations.ads # GNAT/Homotopy/reduction_of_overconstrained_systems.adb # GNAT/Homotopy/reduction_of_overconstrained_systems.ads # GNAT/Homotopy/reduction_of_polynomial_systems.adb # GNAT/Homotopy/reduction_of_polynomial_systems.ads # GNAT/Homotopy/reduction_of_polynomials.adb # GNAT/Homotopy/reduction_of_polynomials.ads # GNAT/Homotopy/scaling.adb # GNAT/Homotopy/scaling.ads # GNAT/Homotopy/solutions.adb # GNAT/Homotopy/solutions.ads # GNAT/Homotopy/solutions_io.adb # GNAT/Homotopy/solutions_io.ads # GNAT/Main/ # GNAT/Main/bablphc.adb # GNAT/Main/bablphc.ads # GNAT/Main/bablroco.adb # GNAT/Main/bablroco.ads # GNAT/Main/bablvali.adb # GNAT/Main/bablvali.ads # GNAT/Main/black_box_root_counting.adb # GNAT/Main/black_box_root_counting.ads # GNAT/Main/dispatch.adb # GNAT/Main/dispatch.ads # GNAT/Main/driver_for_own_start_system.adb # GNAT/Main/driver_for_own_start_system.ads # GNAT/Main/driver_for_root_counts.adb # GNAT/Main/driver_for_root_counts.ads # GNAT/Main/driver_for_root_refining.adb # GNAT/Main/driver_for_root_refining.ads # GNAT/Main/mainphc.adb # GNAT/Main/mainphc.ads # GNAT/Main/mainroco.adb # GNAT/Main/mainroco.ads # GNAT/Main/mainvali.adb # GNAT/Main/mainvali.ads # GNAT/Main/makefile # GNAT/Main/makelog # GNAT/Main/phcpack.adb # GNAT/Main/phcpack.ads # GNAT/Main/use_phc.adb # GNAT/Math_Lib/ # GNAT/Math_Lib/Matrices/ # GNAT/Math_Lib/Matrices/complex_linear_system_solvers.adb # GNAT/Math_Lib/Matrices/complex_linear_system_solvers.ads # GNAT/Math_Lib/Matrices/complex_matrices.adb # GNAT/Math_Lib/Matrices/complex_matrices.ads # GNAT/Math_Lib/Matrices/complex_matrices_io.adb # GNAT/Math_Lib/Matrices/complex_matrices_io.ads # GNAT/Math_Lib/Matrices/complex_norms.adb # GNAT/Math_Lib/Matrices/complex_norms.ads # GNAT/Math_Lib/Matrices/complex_vectors.ads # GNAT/Math_Lib/Matrices/complex_vectors_io.adb # GNAT/Math_Lib/Matrices/complex_vectors_io.ads # GNAT/Math_Lib/Matrices/complex_vectors_of_vectors.ads # GNAT/Math_Lib/Matrices/complex_vectors_of_vectors_io.adb # GNAT/Math_Lib/Matrices/complex_vectors_of_vectors_io.ads # GNAT/Math_Lib/Matrices/float_linear_system_solvers.adb # GNAT/Math_Lib/Matrices/float_linear_system_solvers.ads # GNAT/Math_Lib/Matrices/float_matrices.adb # GNAT/Math_Lib/Matrices/float_matrices.ads # GNAT/Math_Lib/Matrices/float_matrices_io.adb # GNAT/Math_Lib/Matrices/float_matrices_io.ads # GNAT/Math_Lib/Matrices/float_vectors.ads # GNAT/Math_Lib/Matrices/float_vectors_io.adb # GNAT/Math_Lib/Matrices/float_vectors_io.ads # GNAT/Math_Lib/Matrices/float_vectors_of_vectors.ads # GNAT/Math_Lib/Matrices/float_vectors_of_vectors_io.adb # GNAT/Math_Lib/Matrices/float_vectors_of_vectors_io.ads # GNAT/Math_Lib/Matrices/greatest_common_divisor.adb # GNAT/Math_Lib/Matrices/greatest_common_divisor.ads # GNAT/Math_Lib/Matrices/integer_linear_inequality_solvers.adb # GNAT/Math_Lib/Matrices/integer_linear_inequality_solvers.ads # GNAT/Math_Lib/Matrices/integer_linear_system_solvers.adb # GNAT/Math_Lib/Matrices/integer_linear_system_solvers.ads # GNAT/Math_Lib/Matrices/integer_matrices.adb # GNAT/Math_Lib/Matrices/integer_matrices.ads # GNAT/Math_Lib/Matrices/integer_matrices_io.adb # GNAT/Math_Lib/Matrices/integer_matrices_io.ads # GNAT/Math_Lib/Matrices/integer_vectors.ads # GNAT/Math_Lib/Matrices/integer_vectors_io.adb # GNAT/Math_Lib/Matrices/integer_vectors_io.ads # GNAT/Math_Lib/Matrices/integer_vectors_of_vectors.ads # GNAT/Math_Lib/Matrices/integer_vectors_of_vectors_io.adb # GNAT/Math_Lib/Matrices/integer_vectors_of_vectors_io.ads # GNAT/Math_Lib/Matrices/makefile # GNAT/Math_Lib/Matrices/natural_vectors.ads # GNAT/Math_Lib/Matrices/natural_vectors_io.adb # GNAT/Math_Lib/Matrices/natural_vectors_io.ads # GNAT/Math_Lib/Matrices/natural_vectors_of_vectors.ads # GNAT/Math_Lib/Matrices/natural_vectors_of_vectors_io.adb # GNAT/Math_Lib/Matrices/natural_vectors_of_vectors_io.ads # GNAT/Math_Lib/Matrices/vectors.adb # GNAT/Math_Lib/Matrices/vectors.ads # GNAT/Math_Lib/Numbers/ # GNAT/Math_Lib/Numbers/complex_instantiation_parameters.adb # GNAT/Math_Lib/Numbers/complex_instantiation_parameters.ads # GNAT/Math_Lib/Numbers/complex_numbers.adb # GNAT/Math_Lib/Numbers/complex_numbers.ads # GNAT/Math_Lib/Numbers/complex_numbers_io.adb # GNAT/Math_Lib/Numbers/complex_numbers_io.ads # GNAT/Math_Lib/Numbers/float_instantiation_parameters.adb # GNAT/Math_Lib/Numbers/float_instantiation_parameters.ads # GNAT/Math_Lib/Numbers/floating_point_numbers.ads # GNAT/Math_Lib/Numbers/integer_instantiation_parameters.adb # GNAT/Math_Lib/Numbers/integer_instantiation_parameters.ads # GNAT/Math_Lib/Numbers/integer_io.ads # GNAT/Math_Lib/Numbers/makefile # GNAT/Math_Lib/Numbers/mathematical_functions.adb # GNAT/Math_Lib/Numbers/mathematical_functions.ads # GNAT/Math_Lib/Numbers/natural_instantiation_parameters.adb # GNAT/Math_Lib/Numbers/natural_instantiation_parameters.ads # GNAT/Math_Lib/Numbers/numbers_io.adb # GNAT/Math_Lib/Numbers/numbers_io.ads # GNAT/Math_Lib/Numbers/random_number_generators.adb # GNAT/Math_Lib/Numbers/random_number_generators.ads # GNAT/Math_Lib/Numbers/strings_to_natural_numbers.adb # GNAT/Math_Lib/Numbers/strings_to_natural_numbers.ads # GNAT/Math_Lib/Polynomials/ # GNAT/Math_Lib/Polynomials/complex_laurent_polynomial_systems.adb # GNAT/Math_Lib/Polynomials/complex_laurent_polynomial_systems.ads # GNAT/Math_Lib/Polynomials/complex_multivariate_laurent_polynomials.ads # GNAT/Math_Lib/Polynomials/complex_multivariate_polynomials.ads # GNAT/Math_Lib/Polynomials/complex_multivariate_polynomials_io.adb # GNAT/Math_Lib/Polynomials/complex_multivariate_polynomials_io.ads # GNAT/Math_Lib/Polynomials/complex_polynomial_systems.adb # GNAT/Math_Lib/Polynomials/complex_polynomial_systems.ads # GNAT/Math_Lib/Polynomials/complex_polynomial_systems_io.adb # GNAT/Math_Lib/Polynomials/complex_polynomial_systems_io.ads # GNAT/Math_Lib/Polynomials/exponent_vectors.adb # GNAT/Math_Lib/Polynomials/exponent_vectors.ads # GNAT/Math_Lib/Polynomials/integer_graded_lexicographical_ordening.adb # GNAT/Math_Lib/Polynomials/integer_graded_lexicographical_ordening.ads # GNAT/Math_Lib/Polynomials/jacobi_matrices.adb # GNAT/Math_Lib/Polynomials/jacobi_matrices.ads # GNAT/Math_Lib/Polynomials/laurent_jacobi_matrices.adb # GNAT/Math_Lib/Polynomials/laurent_jacobi_matrices.ads # GNAT/Math_Lib/Polynomials/laurent_polynomial_randomizers.adb # GNAT/Math_Lib/Polynomials/laurent_polynomial_randomizers.ads # GNAT/Math_Lib/Polynomials/laurent_to_polynomial_converters.adb # GNAT/Math_Lib/Polynomials/laurent_to_polynomial_converters.ads # GNAT/Math_Lib/Polynomials/lists.adb # GNAT/Math_Lib/Polynomials/lists.ads # GNAT/Math_Lib/Polynomials/makefile # GNAT/Math_Lib/Polynomials/multivariate_laurent_polynomials.adb # GNAT/Math_Lib/Polynomials/multivariate_laurent_polynomials.ads # GNAT/Math_Lib/Polynomials/multivariate_polynomials.adb # GNAT/Math_Lib/Polynomials/multivariate_polynomials.ads # GNAT/Math_Lib/Polynomials/natural_graded_lexicographical_ordening.adb # GNAT/Math_Lib/Polynomials/natural_graded_lexicographical_ordening.ads # GNAT/Math_Lib/Polynomials/polynomial_randomizers.adb # GNAT/Math_Lib/Polynomials/polynomial_randomizers.ads # GNAT/Math_Lib/Polynomials/polynomial_to_laurent_converters.adb # GNAT/Math_Lib/Polynomials/polynomial_to_laurent_converters.ads # GNAT/Math_Lib/Polynomials/substitutors.adb # GNAT/Math_Lib/Polynomials/substitutors.ads # GNAT/Math_Lib/Polynomials/symbol_table.adb # GNAT/Math_Lib/Polynomials/symbol_table.ads # GNAT/Math_Lib/Polynomials/symbol_table_io.adb # GNAT/Math_Lib/Polynomials/symbol_table_io.ads # GNAT/Math_Lib/Supports/ # GNAT/Math_Lib/Supports/arrays_of_float_vector_lists.adb # GNAT/Math_Lib/Supports/arrays_of_float_vector_lists.ads # GNAT/Math_Lib/Supports/arrays_of_float_vector_lists_io.adb # GNAT/Math_Lib/Supports/arrays_of_float_vector_lists_io.ads # GNAT/Math_Lib/Supports/arrays_of_integer_vector_lists.adb # GNAT/Math_Lib/Supports/arrays_of_integer_vector_lists.ads # GNAT/Math_Lib/Supports/arrays_of_integer_vector_lists_io.adb # GNAT/Math_Lib/Supports/arrays_of_integer_vector_lists_io.ads # GNAT/Math_Lib/Supports/dictionaries.adb # GNAT/Math_Lib/Supports/dictionaries.ads # GNAT/Math_Lib/Supports/face_enumerators.adb # GNAT/Math_Lib/Supports/face_enumerators.ads # GNAT/Math_Lib/Supports/face_enumerators_utilities.adb # GNAT/Math_Lib/Supports/face_enumerators_utilities.ads # GNAT/Math_Lib/Supports/farkas_lemma.adb # GNAT/Math_Lib/Supports/farkas_lemma.ads # GNAT/Math_Lib/Supports/float_face_enumerators.adb # GNAT/Math_Lib/Supports/float_face_enumerators.ads # GNAT/Math_Lib/Supports/float_faces_of_polytope.adb # GNAT/Math_Lib/Supports/float_faces_of_polytope.ads # GNAT/Math_Lib/Supports/float_linear_inequality_solvers.adb # GNAT/Math_Lib/Supports/float_linear_inequality_solvers.ads # GNAT/Math_Lib/Supports/float_support_functions.adb # GNAT/Math_Lib/Supports/float_support_functions.ads # GNAT/Math_Lib/Supports/float_to_integer_rounding.adb # GNAT/Math_Lib/Supports/float_to_integer_rounding.ads # GNAT/Math_Lib/Supports/givens_rotations.adb # GNAT/Math_Lib/Supports/givens_rotations.ads # GNAT/Math_Lib/Supports/integer_faces_of_polytope.adb # GNAT/Math_Lib/Supports/integer_faces_of_polytope.ads # GNAT/Math_Lib/Supports/integer_faces_of_polytope_io.adb # GNAT/Math_Lib/Supports/integer_faces_of_polytope_io.ads # GNAT/Math_Lib/Supports/integer_farkas_lemma.adb # GNAT/Math_Lib/Supports/integer_farkas_lemma.ads # GNAT/Math_Lib/Supports/integer_support_functions.adb # GNAT/Math_Lib/Supports/integer_support_functions.ads # GNAT/Math_Lib/Supports/linear_programming.adb # GNAT/Math_Lib/Supports/linear_programming.ads # GNAT/Math_Lib/Supports/lists_of_float_vectors.adb # GNAT/Math_Lib/Supports/lists_of_float_vectors.ads # GNAT/Math_Lib/Supports/lists_of_float_vectors_io.adb # GNAT/Math_Lib/Supports/lists_of_float_vectors_io.ads # GNAT/Math_Lib/Supports/lists_of_integer_vectors.adb # GNAT/Math_Lib/Supports/lists_of_integer_vectors.ads # GNAT/Math_Lib/Supports/lists_of_integer_vectors_io.adb # GNAT/Math_Lib/Supports/lists_of_integer_vectors_io.ads # GNAT/Math_Lib/Supports/makefile # GNAT/Objects/ # GNAT/Objects/READ_ME # GNAT/Objects/dispatch.adb # GNAT/Objects/makefile # GNAT/Objects/use_phc.adb # GNAT/READ_ME # GNAT/Root_Counts/ # GNAT/Root_Counts/Dynlift/ # GNAT/Root_Counts/Dynlift/babldmvc.adb # GNAT/Root_Counts/Dynlift/babldmvc.ads # GNAT/Root_Counts/Dynlift/black_box_mixed_volume_computations.adb # GNAT/Root_Counts/Dynlift/black_box_mixed_volume_computations.ads # GNAT/Root_Counts/Dynlift/cayley_embedding.adb # GNAT/Root_Counts/Dynlift/cayley_embedding.ads # GNAT/Root_Counts/Dynlift/cayley_trick.adb # GNAT/Root_Counts/Dynlift/cayley_trick.ads # GNAT/Root_Counts/Dynlift/common_faces_of_polytope.adb # GNAT/Root_Counts/Dynlift/common_faces_of_polytope.ads # GNAT/Root_Counts/Dynlift/driver_for_minkowski_polynomials.adb # GNAT/Root_Counts/Dynlift/driver_for_minkowski_polynomials.ads # GNAT/Root_Counts/Dynlift/drivers_for_dynamic_lifting.adb # GNAT/Root_Counts/Dynlift/drivers_for_dynamic_lifting.ads # GNAT/Root_Counts/Dynlift/dynamic_bkk_computations.adb # GNAT/Root_Counts/Dynlift/dynamic_bkk_computations.ads # GNAT/Root_Counts/Dynlift/dynamic_lifting_functions.adb # GNAT/Root_Counts/Dynlift/dynamic_lifting_functions.ads # GNAT/Root_Counts/Dynlift/dynamic_mixed_subdivisions.adb # GNAT/Root_Counts/Dynlift/dynamic_mixed_subdivisions.ads # GNAT/Root_Counts/Dynlift/dynamic_polyhedral_continuation.adb # GNAT/Root_Counts/Dynlift/dynamic_polyhedral_continuation.ads # GNAT/Root_Counts/Dynlift/dynamic_triangulations.adb # GNAT/Root_Counts/Dynlift/dynamic_triangulations.ads # GNAT/Root_Counts/Dynlift/enumerate_faces_of_polytope.adb # GNAT/Root_Counts/Dynlift/enumerate_faces_of_polytope.ads # GNAT/Root_Counts/Dynlift/flatten_mixed_subdivisions.adb # GNAT/Root_Counts/Dynlift/flatten_mixed_subdivisions.ads # GNAT/Root_Counts/Dynlift/frequency_graph.adb # GNAT/Root_Counts/Dynlift/frequency_graph.ads # GNAT/Root_Counts/Dynlift/global_dynamic_triangulation.adb # GNAT/Root_Counts/Dynlift/global_dynamic_triangulation.ads # GNAT/Root_Counts/Dynlift/initial_mixed_cell.adb # GNAT/Root_Counts/Dynlift/initial_mixed_cell.ads # GNAT/Root_Counts/Dynlift/makefile # GNAT/Root_Counts/Dynlift/minkowski_polynomials.adb # GNAT/Root_Counts/Dynlift/minkowski_polynomials.ads # GNAT/Root_Counts/Dynlift/simplices.adb # GNAT/Root_Counts/Dynlift/simplices.ads # GNAT/Root_Counts/Dynlift/simplices_io.adb # GNAT/Root_Counts/Dynlift/simplices_io.ads # GNAT/Root_Counts/Dynlift/triangulations.adb # GNAT/Root_Counts/Dynlift/triangulations.ads # GNAT/Root_Counts/Dynlift/triangulations_and_subdivisions.adb # GNAT/Root_Counts/Dynlift/triangulations_and_subdivisions.ads # GNAT/Root_Counts/Dynlift/triangulations_io.adb # GNAT/Root_Counts/Dynlift/triangulations_io.ads # GNAT/Root_Counts/Dynlift/unfolding_subdivisions.adb # GNAT/Root_Counts/Dynlift/unfolding_subdivisions.ads # GNAT/Root_Counts/Implift/ # GNAT/Root_Counts/Implift/arrays_of_lists_utilities.adb # GNAT/Root_Counts/Implift/arrays_of_lists_utilities.ads # GNAT/Root_Counts/Implift/binomials.adb # GNAT/Root_Counts/Implift/binomials.ads # GNAT/Root_Counts/Implift/driver_for_polyhedral_continuation.adb # GNAT/Root_Counts/Implift/driver_for_polyhedral_continuation.ads # GNAT/Root_Counts/Implift/drivers_for_implicit_lifting.adb # GNAT/Root_Counts/Implift/drivers_for_implicit_lifting.ads # GNAT/Root_Counts/Implift/drivers_for_vertex_points.adb # GNAT/Root_Counts/Implift/drivers_for_vertex_points.ads # GNAT/Root_Counts/Implift/durand_kerner.adb # GNAT/Root_Counts/Implift/durand_kerner.ads # GNAT/Root_Counts/Implift/face_enumerator_of_sum.adb # GNAT/Root_Counts/Implift/face_enumerator_of_sum.ads # GNAT/Root_Counts/Implift/fewnomials.adb # GNAT/Root_Counts/Implift/fewnomials.ads # GNAT/Root_Counts/Implift/generic_position.adb # GNAT/Root_Counts/Implift/generic_position.ads # GNAT/Root_Counts/Implift/integer_vectors_utilities.adb # GNAT/Root_Counts/Implift/integer_vectors_utilities.ads # GNAT/Root_Counts/Implift/lists_of_vectors_utilities.adb # GNAT/Root_Counts/Implift/lists_of_vectors_utilities.ads # GNAT/Root_Counts/Implift/makefile # GNAT/Root_Counts/Implift/mixed_homotopy_continuation.adb # GNAT/Root_Counts/Implift/mixed_homotopy_continuation.ads # GNAT/Root_Counts/Implift/power_lists.adb # GNAT/Root_Counts/Implift/power_lists.ads # GNAT/Root_Counts/Implift/set_structures_and_volumes.adb # GNAT/Root_Counts/Implift/set_structures_and_volumes.ads # GNAT/Root_Counts/Implift/transformations.adb # GNAT/Root_Counts/Implift/transformations.ads # GNAT/Root_Counts/Implift/transformations_io.adb # GNAT/Root_Counts/Implift/transformations_io.ads # GNAT/Root_Counts/Implift/transforming_integer_vector_lists.adb # GNAT/Root_Counts/Implift/transforming_integer_vector_lists.ads # GNAT/Root_Counts/Implift/transforming_laurent_systems.adb # GNAT/Root_Counts/Implift/transforming_laurent_systems.ads # GNAT/Root_Counts/Implift/transforming_solutions.adb # GNAT/Root_Counts/Implift/transforming_solutions.ads # GNAT/Root_Counts/Implift/trees_of_vectors.adb # GNAT/Root_Counts/Implift/trees_of_vectors.ads # GNAT/Root_Counts/Implift/trees_of_vectors_io.adb # GNAT/Root_Counts/Implift/trees_of_vectors_io.ads # GNAT/Root_Counts/Implift/vertices.adb # GNAT/Root_Counts/Implift/vertices.ads # GNAT/Root_Counts/Implift/volumes.adb # GNAT/Root_Counts/Implift/volumes.ads # GNAT/Root_Counts/Product/ # GNAT/Root_Counts/Product/construct_random_product_start_system.adb # GNAT/Root_Counts/Product/construct_random_product_start_system.ads # GNAT/Root_Counts/Product/degree_sets_tables.adb # GNAT/Root_Counts/Product/degree_sets_tables.ads # GNAT/Root_Counts/Product/degree_sets_tables_io.adb # GNAT/Root_Counts/Product/degree_sets_tables_io.ads # GNAT/Root_Counts/Product/degree_structure.adb # GNAT/Root_Counts/Product/degree_structure.ads # GNAT/Root_Counts/Product/degrees_in_sets_of_unknowns.adb # GNAT/Root_Counts/Product/degrees_in_sets_of_unknowns.ads # GNAT/Root_Counts/Product/driver_for_interpolating_homotopies.adb # GNAT/Root_Counts/Product/driver_for_interpolating_homotopies.ads # GNAT/Root_Counts/Product/drivers_for_m_homogenization.adb # GNAT/Root_Counts/Product/drivers_for_m_homogenization.ads # GNAT/Root_Counts/Product/drivers_for_multi_homogenization.adb # GNAT/Root_Counts/Product/drivers_for_multi_homogenization.ads # GNAT/Root_Counts/Product/drivers_for_set_structures.adb # GNAT/Root_Counts/Product/drivers_for_set_structures.ads # GNAT/Root_Counts/Product/generate.adb # GNAT/Root_Counts/Product/generate.ads # GNAT/Root_Counts/Product/interpolating_homotopies.adb # GNAT/Root_Counts/Product/interpolating_homotopies.ads # GNAT/Root_Counts/Product/m_homogeneous_bezout_numbers.adb # GNAT/Root_Counts/Product/m_homogeneous_bezout_numbers.ads # GNAT/Root_Counts/Product/m_homogeneous_start_systems.adb # GNAT/Root_Counts/Product/m_homogeneous_start_systems.ads # GNAT/Root_Counts/Product/makefile # GNAT/Root_Counts/Product/partitions_of_sets_of_unknowns.adb # GNAT/Root_Counts/Product/partitions_of_sets_of_unknowns.ads # GNAT/Root_Counts/Product/partitions_of_sets_of_unknowns_io.adb # GNAT/Root_Counts/Product/partitions_of_sets_of_unknowns_io.ads # GNAT/Root_Counts/Product/random_product_start_systems.adb # GNAT/Root_Counts/Product/random_product_start_systems.ads # GNAT/Root_Counts/Product/random_product_system.adb # GNAT/Root_Counts/Product/random_product_system.ads # GNAT/Root_Counts/Product/random_product_system_io.adb # GNAT/Root_Counts/Product/random_product_system_io.ads # GNAT/Root_Counts/Product/set_structure.adb # GNAT/Root_Counts/Product/set_structure.ads # GNAT/Root_Counts/Product/set_structure_io.adb # GNAT/Root_Counts/Product/set_structure_io.ads # GNAT/Root_Counts/Product/sets_of_unknowns.adb # GNAT/Root_Counts/Product/sets_of_unknowns.ads # GNAT/Root_Counts/Product/sets_of_unknowns_io.adb # GNAT/Root_Counts/Product/sets_of_unknowns_io.ads # GNAT/Root_Counts/Product/total_degree_start_systems.adb # GNAT/Root_Counts/Product/total_degree_start_systems.ads # GNAT/Root_Counts/Stalift/ # GNAT/Root_Counts/Stalift/bkk_bound_computations.adb # GNAT/Root_Counts/Stalift/bkk_bound_computations.ads # GNAT/Root_Counts/Stalift/contributions_to_mixed_volume.adb # GNAT/Root_Counts/Stalift/contributions_to_mixed_volume.ads # GNAT/Root_Counts/Stalift/driver_for_criterion.adb # GNAT/Root_Counts/Stalift/driver_for_criterion.ads # GNAT/Root_Counts/Stalift/drivers_for_lifting_functions.adb # GNAT/Root_Counts/Stalift/drivers_for_lifting_functions.ads # GNAT/Root_Counts/Stalift/drivers_for_mixed_contributions.adb # GNAT/Root_Counts/Stalift/drivers_for_mixed_contributions.ads # GNAT/Root_Counts/Stalift/drivers_for_static_lifting.adb # GNAT/Root_Counts/Stalift/drivers_for_static_lifting.ads # GNAT/Root_Counts/Stalift/float_integer_convertors.adb # GNAT/Root_Counts/Stalift/float_integer_convertors.ads # GNAT/Root_Counts/Stalift/float_lifting_functions.adb # GNAT/Root_Counts/Stalift/float_lifting_functions.ads # GNAT/Root_Counts/Stalift/float_lifting_utilities.adb # GNAT/Root_Counts/Stalift/float_lifting_utilities.ads # GNAT/Root_Counts/Stalift/float_mixed_subdivisions.adb # GNAT/Root_Counts/Stalift/float_mixed_subdivisions.ads # GNAT/Root_Counts/Stalift/float_mixed_subdivisions_io.adb # GNAT/Root_Counts/Stalift/float_mixed_subdivisions_io.ads # GNAT/Root_Counts/Stalift/float_polyhedral_continuation.adb # GNAT/Root_Counts/Stalift/float_polyhedral_continuation.ads # GNAT/Root_Counts/Stalift/float_pruning_methods.adb # GNAT/Root_Counts/Stalift/float_pruning_methods.ads # GNAT/Root_Counts/Stalift/inner_normal_cones.adb # GNAT/Root_Counts/Stalift/inner_normal_cones.ads # GNAT/Root_Counts/Stalift/integer_lifting_functions.adb # GNAT/Root_Counts/Stalift/integer_lifting_functions.ads # GNAT/Root_Counts/Stalift/integer_lifting_utilities.adb # GNAT/Root_Counts/Stalift/integer_lifting_utilities.ads # GNAT/Root_Counts/Stalift/integer_mixed_subdivisions.adb # GNAT/Root_Counts/Stalift/integer_mixed_subdivisions.ads # GNAT/Root_Counts/Stalift/integer_mixed_subdivisions_io.adb # GNAT/Root_Counts/Stalift/integer_mixed_subdivisions_io.ads # GNAT/Root_Counts/Stalift/integer_polyhedral_continuation.adb # GNAT/Root_Counts/Stalift/integer_polyhedral_continuation.ads # GNAT/Root_Counts/Stalift/integer_pruning_methods.adb # GNAT/Root_Counts/Stalift/integer_pruning_methods.ads # GNAT/Root_Counts/Stalift/makefile # GNAT/Root_Counts/Stalift/mixed_coherent_subdivisions.adb # GNAT/Root_Counts/Stalift/mixed_coherent_subdivisions.ads # GNAT/Root_Counts/Stalift/mixed_volume_computation.adb # GNAT/Root_Counts/Stalift/mixed_volume_computation.ads # GNAT/Root_Counts/Stalift/normal_cone_intersections.adb # GNAT/Root_Counts/Stalift/normal_cone_intersections.ads # GNAT/Root_Counts/Stalift/pruning_statistics.adb # GNAT/Root_Counts/Stalift/pruning_statistics.ads # GNAT/Root_Counts/Symmetry/ # GNAT/Root_Counts/Symmetry/drivers_for_orbits_of_solutions.adb # GNAT/Root_Counts/Symmetry/drivers_for_orbits_of_solutions.ads # GNAT/Root_Counts/Symmetry/drivers_for_symmetric_lifting.adb # GNAT/Root_Counts/Symmetry/drivers_for_symmetric_lifting.ads # GNAT/Root_Counts/Symmetry/drivers_for_symmetric_set_structures.adb # GNAT/Root_Counts/Symmetry/drivers_for_symmetric_set_structures.ads # GNAT/Root_Counts/Symmetry/drivers_for_symmetry_group_io.adb # GNAT/Root_Counts/Symmetry/drivers_for_symmetry_group_io.ads # GNAT/Root_Counts/Symmetry/equivariant_polynomial_systems.adb # GNAT/Root_Counts/Symmetry/equivariant_polynomial_systems.ads # GNAT/Root_Counts/Symmetry/faces_of_symmetric_polytopes.adb # GNAT/Root_Counts/Symmetry/faces_of_symmetric_polytopes.ads # GNAT/Root_Counts/Symmetry/generating_mixed_cells.adb # GNAT/Root_Counts/Symmetry/generating_mixed_cells.ads # GNAT/Root_Counts/Symmetry/linear_symmetric_reduction.adb # GNAT/Root_Counts/Symmetry/linear_symmetric_reduction.ads # GNAT/Root_Counts/Symmetry/mainsmvc.adb # GNAT/Root_Counts/Symmetry/mainsmvc.ads # GNAT/Root_Counts/Symmetry/makefile # GNAT/Root_Counts/Symmetry/orbits_of_solutions.adb # GNAT/Root_Counts/Symmetry/orbits_of_solutions.ads # GNAT/Root_Counts/Symmetry/orbits_of_solutions_io.adb # GNAT/Root_Counts/Symmetry/orbits_of_solutions_io.ads # GNAT/Root_Counts/Symmetry/permutations.adb # GNAT/Root_Counts/Symmetry/permutations.ads # GNAT/Root_Counts/Symmetry/permutations_of_faces.adb # GNAT/Root_Counts/Symmetry/permutations_of_faces.ads # GNAT/Root_Counts/Symmetry/permute_operations.adb # GNAT/Root_Counts/Symmetry/permute_operations.ads # GNAT/Root_Counts/Symmetry/symbolic_symmetry_group_io.adb # GNAT/Root_Counts/Symmetry/symbolic_symmetry_group_io.ads # GNAT/Root_Counts/Symmetry/symmetric_bkk_bound_solvers.adb # GNAT/Root_Counts/Symmetry/symmetric_bkk_bound_solvers.ads # GNAT/Root_Counts/Symmetry/symmetric_lifting_functions.adb # GNAT/Root_Counts/Symmetry/symmetric_lifting_functions.ads # GNAT/Root_Counts/Symmetry/symmetric_polyhedral_continuation.adb # GNAT/Root_Counts/Symmetry/symmetric_polyhedral_continuation.ads # GNAT/Root_Counts/Symmetry/symmetric_randomize.adb # GNAT/Root_Counts/Symmetry/symmetric_randomize.ads # GNAT/Root_Counts/Symmetry/symmetric_set_structure.adb # GNAT/Root_Counts/Symmetry/symmetric_set_structure.ads # GNAT/Root_Counts/Symmetry/symmetry_group.adb # GNAT/Root_Counts/Symmetry/symmetry_group.ads # GNAT/Root_Counts/Symmetry/symmetry_group_io.adb # GNAT/Root_Counts/Symmetry/symmetry_group_io.ads # GNAT/Root_Counts/Symmetry/templates.adb # GNAT/Root_Counts/Symmetry/templates.ads # GNAT/System/ # GNAT/System/READ_ME # GNAT/System/bye_bye_message.adb # GNAT/System/bye_bye_message.ads # GNAT/System/communications_with_user.adb # GNAT/System/communications_with_user.ads # GNAT/System/file_operations.adb # GNAT/System/file_operations.ads # GNAT/System/machines.adb # GNAT/System/machines.ads # GNAT/System/makefile # GNAT/System/sun_timing_package.adb # GNAT/System/system_call.adb # GNAT/System/system_call.ads # GNAT/System/timing_package.adb # GNAT/System/timing_package.ads # GNAT/System/unix_command_line.adb # GNAT/System/unix_command_line.ads # GNAT/System/unix_resource_usage.adb # GNAT/System/unix_resource_usage.ads # READ_ME # This archive created: Tue Nov 7 15:37:36 2000 export PATH; PATH=/bin:$PATH if test ! -d 'Ada' then mkdir 'Ada' fi cd 'Ada' if test ! -d 'Continuation' then mkdir 'Continuation' fi cd 'Continuation' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Increment-and-fix tracking of solution paths of polynomial homotopies. This library of continuation routines is organized in three layers: 0. The basic data structures 1. Increment-and-Fix continuation 2. Driver routines conpar_io : 0.0. Continuation_Parameters_io |-- conpar : 0.0.0. Continuation_Parameters |-- cont_data : 0.0.1. Continuation_Data process_io : 0.1. Process_io continue : 1.0. Increment_and_Fix_Continuation |-- pathtrac : 1.0.1. Path_Trackers |-- dispred : 1.0.2. Dispatch_Predictors |-----|-- predictors : 1.0.3. Predictors |-- correctors : 1.0.4. Correctors |-- dirpaths : 1.0.5. Directions_of_Solution_Paths |-- vlprsalg : 1.0.5.0. vLpRs_Algorithm |-- vlrpstab : 1.0.5.0.0. vLpRs_Tables rootrefi : 1.1. Root_Refiners drivwind : 2.0. Driver_for_Winding_Numbers |-- drivpoco : 2.0.0. Drivers_for_Polynomial_Continuation | |-- drivpadi : 2.0.0.0. Drivers_for_Path_Directions |-----|-- drivproc : 2.0.1. Driver_for_Process_io 0. The basic data structures The package Continuation_Data defines records of data to allow better management during continuation. Settings of the continuation parameters can be determined interactively by the routines in Continuation_Parameters_io, default values are contained in the package Continuation_Parameters. In Process_io are the primitive operations for output during continuation, depending on the output mode. 1. Increment-and-Fix continuation There is a rich variety of predictors available. Increment-and-fix continuation with a polyhedral end game for the computation of the directions of the solution paths. 2. Driver routines batchpoco Batch_Polynomial_Continuations mainpoco poco as called by the main program scanpoco Scanners_for_Continuation bablpoco batch processing and black box version of poco valipoco validation of computed path directions 3. target routines : poco poco (Polynomial Continuation) postpoco stand-alone routine for validation of path directions SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Homotopy' then mkdir 'Homotopy' fi cd 'Homotopy' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Polynomial homotopies, solutions of systems, scaling and reduction. 1. Representation of solutions of families of systems : equals Floating_Equalities solutions Solutions solutions_io Solutions_io 2. Homotopy with homogenization : homzers Homogenization projtrans Projective_Transformations homotopy Homotopy drivhoco Driver_for_Homotopy_Construction 3. Scaling and reduction : scaling Scaling drivscals Drivers_for_Scaling mainscal mainscal (as tool called by phc) redupoly Reduction_of_Polynomials redufull Reduction_of_Polynomial_Systems reduover Reduction_of_Overconstrained_Systems drivreds Driver_for_Reduction mainred mainred (as tool called by phc) SHAR_EOF fi # end of overwriting check if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' ADAPATH=/cw/vads.dec/v6.1.0d all: solutions sparsity projtrans drivhoco drivscal drivred climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling commands : # ada : invoke the Ada compiler directly # a.make : check dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: a.mklib . $(ADAPATH)/verdixlib a.path -a ../System a.path -a ../Math_Lib/Numbers a.path -a ../Math_Lib/Matrices a.path -a ../Math_Lib/Polynomials # Cleaning unnecessary instantiations : cleaninst: a.cleaninst # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # The solutions : sols: ada.lib equals.a equalsB.a solutions.a solutionsB.a $(compile) equals.a equalsB.a solutions.a solutionsB.a solutions: sols solutions_io.a solutions_ioB.a condsols.a condsolsB.a $(compile) solutions_io.a solutions_ioB.a $(compile) condsols.a condsolsB.a # The homotopy : homotopy: ada.lib homotopy.a homotopyB.a $(compile) homotopy.a homotopyB.a # Adding homogeneous equations : homzers: ada.lib homzers.a homzersB.a $(compile) homzers.a homzersB.a projtrans: homzers projtrans.a projtransB.a $(compile) projtrans.a projtransB.a # The interactive driver for the construction of the homotopy : drivhoco: homotopy homzers drivhoco.a drivhocoB.a $(compile) drivhoco.a drivhocoB.a # Scaling and reduction : scaling: solutions scaling.a scalingB.a $(compile) scaling.a scalingB.a drivscal: scaling drivscals.a drivscalsB.a mainscal.a mainscalB.a $(compile) drivscals.a drivscalsB.a mainscal.a mainscalB.a redufull: ada.lib redupoly.a redupolyB.a redufull.a redufullB.a $(compile) redupoly.a redupolyB.a redufull.a redufullB.a reduover: redufull reduover.a reduoverB.a $(compile) reduover.a reduoverB.a drivred: reduover ratio.a drivreds.a drivredsB.a mainred.a mainredB.a $(compile) ratio.a drivreds.a drivredsB.a mainred.a mainredB.a # Some tools usepert: ada.lib perturb.a pert.a $(compile) perturb.a pert.a a.ld -o /tmp/pert Use_Perturb evalfj: ada.lib evalfj.a $(compile) evalfj.a a.ld -o /tmp/evalfj evalfj # Sampling polynomial systems : samplers: ada.lib samplers.a samplersB.a $(compile) samplers.a samplersB.a # Measuring the sparsity of a polynomial system : sparsity: ada.lib sparsity.a sparsityB.a $(compile) sparsity.a sparsityB.a avsp: sparsity avsp.a $(compile) avsp.a @-make climp a.ld -o /tmp/avsp avsp # Test routines : ts_drivred: drivred ts_drivred.a $(compile) ts_drivred.a @-make climp a.ld -o /tmp/ts_drivred ts_drivred ts_drivscal: drivscal ts_drivscal.a $(compile) ts_drivscal.a @-make climp a.ld -o /tmp/ts_drivscal ts_drivscal ts_nterms: sparsity ts_nterms.a $(compile) ts_nterms.a @-make climp a.ld -o /tmp/ts_nterms ts_nterms ts_sam: samplers ts_samplers.a $(compile) ts_samplers.a @-make climp a.ld -o /tmp/ts_sam ts_samplers SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Main' then mkdir 'Main' fi cd 'Main' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Main interactive drivers and dispatcher for the software package phc. 1. Separate drivers : drivroco Driver_for_Root_Counts drivowst Driver_for_Own_Start_System drivrore Driver_for_Root_Refining 2. Main drivers : mainroco root counting mainvali validation of the results bablvali black-box version of validation mainphc the program bablphc black-box version of the program 3. PHCPACK : phcpack the package as server package use_phc an example of how to use phcpack 4. The main dispatcher : dispatch scans options and arguments and calls drivers SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Math_Lib' then mkdir 'Math_Lib' fi cd 'Math_Lib' if test ! -d 'Matrices' then mkdir 'Matrices' fi cd 'Matrices' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Integer and floating-point vectors, matrices and linear-system solvers. 1. Vectors of natural, integer, floating-point, and complex numbers vectors Vectors nat_vec Natural_Vectors nat_vec_io Natural_Vectors_io int_vec Integer_Vectors int_vec_io Integer_Vectors_io flt_vec Float_Vectors flt_vec_io Float_Vectors_io cmp_vec Complex_Vectors cmp_vec_io Complex_Vectors_io 2. Vectors of vectors nat_vvc Natural_Vectors_of_Vectors nat_vvc_io Natural_Vectors_of_Vectors_io int_vvc Integer_Vectors_of_Vectors int_vvc_io Integer_Vectors_of_Vectors_io flt_vvc Float_Vectors_of_Vectors flt_vvc_io Float_Vectors_of_Vectors_io cmp_vvc Complex_Vectors_of_Vectors cmp_vvc_io Complex_Vectors_of_Vectors_io 3. Matrices of natural, integer, floating-point, and complex numbers nat_mat Natural_Matrices nat_mat_io Natural_Matrices_io int_mat Integer_Matrices int_mat_io Integer_Matrices_io flt_mat Float_Matrices flt_mat_io Float_Matrices_io cmp_mat Complex_Matrices cmp_mat_io Complex_Matrices_io 4. The linear-system solvers gcd Greatest_Common_Divisor int_lss Integer_Linear_System_Solvers int_lis Integer_Linear_Inequality_Solvers flt_lss Float_Linear_System_Solvers cmp_lss Complex_Linear_System_Solvers SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Numbers' then mkdir 'Numbers' fi cd 'Numbers' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Basic number definitions and coefficient rings and fields. The definition of floating-point numbers is such that it is independent of the pre-defined type "float". 1. Floating-point and complex numbers float Floating_Point_Numbers mathfun Mathematical_Functions complex Complex_Numbers complex_io Complex_Numbers_io numbers_io Numbers_io 2. Instantiation packages to define coefficient rings nat_inst Natural_Instantiation_Parameters int_inst Integer_Instantiation_Parameters flt_inst Float_Instantiation_Parameters cmp_inst Complex_Instantiation_Parameters 3. Random number generators random Random_Number_Generators 4. Conversions: strings to numbers. strnum Strings_to_Natural_Numbers SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Polynomials' then mkdir 'Polynomials' fi cd 'Polynomials' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Multivariate polynomials and polynomial systems over any ring or field. Three different representations of polynomials are implemented: as a list of terms, a nested Horner scheme with fixed coefficient and with parametric coefficients. The i/o-routines provide readable formats. 1. Multivariate Polynomials : nat_grad_lex Natural_Graded_Lexicographical_Ordening int_grad_lex Integer_Graded_Lexicographical_Ordening lists generic lists of items mul_poly Multivariate_Polynomials mul_laur Multivariate_Laurent_Polynomials cmp_mpoly Complex_Multivariate_Polynomials cmp_mlaur Complex_Multivariate_Laurent_Polynomials symtab Symbol_Table symtab_io Symbol_Table_io cmp_mpoly_io Complex_Multivariate_Polynomials_io 2. Vectors of polynomials : cmp_polsys Complex_Polynomial_Systems cmp_polsys_io Complex_Polynomial_Systems_io jacobi Jacobi_Matrices cmp_laursys Complex_Laurent_Systems laurjaco Laurent_Jacobi_Matrices expvec Exponent_Vectors 3. Converters, randomizers and substitutors : pollaco Polynomial_to_Laurent_Converters lapolco Laurent_to_Polynomial_Converters polrand Polynomial_Randomizers laurrand Laurent_Polynomial_Randomizers substits Substitutors SHAR_EOF fi # end of overwriting check cd .. if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Mathematical library with basic data structures and operations. Math_Lib : 1. general mathematical library |-- Numbers : 1.1. number representations |-- Matrices : 1.2. matrices and linear-system solvers |-- Polynomials : 1.3. multivariate polynomial systems |-- Supports : 1.4. support sets and linear programming The directory Numbers specifies the coefficient rings and contains definitions of floating-point and complex numbers. The coefficient rings are implemented by means of packages that can be used for instantiating generic packages. In Matrices we find a generic package vectors, matrices of integer, floating-point and complex numbers. Solvers of linear systems are provided. The directory Polynomials contains the packages to deal with multivariate polynomials and systems. To deal with support sets and polytopes, linear-programming methods have been implemented in the directory Supports. SHAR_EOF fi # end of overwriting check if test ! -d 'Supports' then mkdir 'Supports' fi cd 'Supports' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Support sets, polytopes, and feasibility of linear-inequality systems. This library contains three different methods for deciding on the feasibility of a linear-inequality system. These algorithms are independent from the data structures for support sets and faces of polytopes. 1. Linear-programming solver, efficient to extract vertices : dictios Dictionaries lp Linear_Programming 2. Implementation of Farkas lemma with generation of k-faces : givens Givens_Rotations farkas Farkas_Lemma int_farkas Integer_Farkas_Lemma facenu_ut Face_Enumerators_Utilities facenum Face_Enumerators fltfanum Float_Face_Enumerators 3. Primal-dual algorithm with inconsistency proof : flt_lis Float_Linear_Inequality_Solvers 4. Integer and floating-point lists, support function and faces : lstivc Lists_of_Integer_Vectors lstivc_io Lists_of_Integer_Vectors_io arrlivc Arrays_of_Integer_Vector_Lists arrlivc_io Arrays_of_Integer_Vector_Lists_io intsupfu Integer_Support_Functions intfaces Integer_Faces_of_Polytope intfaces_io Integer_Faces_of_Polytope_io lstfvc Lists_of_Float_Vectors lstfvc_io Lists_of_Float_Vectors_io arrlfvc Arrays_of_Float_Vector_Lists arrlfvc_io Arrays_of_Float_Vector_Lists_io fltsupfu Float_Support_Functions fltfaces Float_Faces_of_Polytope SHAR_EOF fi # end of overwriting check cd .. cd .. if test ! -d 'Objects' then mkdir 'Objects' fi cd 'Objects' if test ! -d 'Continuation' then mkdir 'Continuation' fi cd 'Continuation' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: bablpoco drivwind valipoco climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling commands : # ada : invoke the Ada compiler directly # a.make : check dependencies before compiling compile=ada $(options) # compile=a.make $(makeoptions) # Making an Ada library : ada.lib: @-../makelib a.path -a ../System a.path -a ../Math_Lib/Numbers a.path -a ../Math_Lib/Matrices a.path -a ../Math_Lib/Polynomials a.path -a ../Homotopy # Cleaning superfluous instantations : cleaninst: @-a.cleaninst # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../Continuation links: @-ln -s $(linkrc)/process_io.a process_io.a @-ln -s $(linkrc)/process_ioB.a process_ioB.a @-ln -s $(linkrc)/cont_data.a cont_data.a @-ln -s $(linkrc)/cont_dataB.a cont_dataB.a @-ln -s $(linkrc)/conpar.a conpar.a @-ln -s $(linkrc)/conparB.a conparB.a @-ln -s $(linkrc)/conpar_io.a conpar_io.a @-ln -s $(linkrc)/conpar_ioB.a conpar_ioB.a @-ln -s $(linkrc)/predictors.a predictors.a @-ln -s $(linkrc)/predictorsB.a predictorsB.a @-ln -s $(linkrc)/dispred.a dispred.a @-ln -s $(linkrc)/dispredB.a dispredB.a @-ln -s $(linkrc)/correctors.a correctors.a @-ln -s $(linkrc)/correctorsB.a correctorsB.a @-ln -s $(linkrc)/pathtrac.a pathtrac.a @-ln -s $(linkrc)/pathtracB.a pathtracB.a @-ln -s $(linkrc)/continue.a continue.a @-ln -s $(linkrc)/continueB.a continueB.a @-ln -s $(linkrc)/rootrefi.a rootrefi.a @-ln -s $(linkrc)/rootrefiB.a rootrefiB.a @-ln -s $(linkrc)/drivpoco.a drivpoco.a @-ln -s $(linkrc)/drivpocoB.a drivpocoB.a @-ln -s $(linkrc)/vlprstab.a vlrpstab.a @-ln -s $(linkrc)/vlprstabB.a vlrpstabB.a @-ln -s $(linkrc)/vlprsalg.a vlrpsalg.a @-ln -s $(linkrc)/vlprsalgB.a vlrpsalgB.a @-ln -s $(linkrc)/dirpaths.a dirpaths.a @-ln -s $(linkrc)/dirpathsB.a dirpathsB.a @-ln -s $(linkrc)/drivpadi.a drivpadi.a @-ln -s $(linkrc)/drivpadiB.a drivpadiB.a @-ln -s $(linkrc)/drivwind.a drivwind.a @-ln -s $(linkrc)/drivwindB.a drivwindB.a @-ln -s $(linkrc)/mainpoco.a mainpoco.a @-ln -s $(linkrc)/mainpocoB.a mainpocoB.a @-ln -s $(linkrc)/scanpoco.a scanpoco.a @-ln -s $(linkrc)/scanpocoB.a scanpocoB.a @-ln -s $(linkrc)/blackpoco.a blackpoco.a @-ln -s $(linkrc)/blackpocoB.a blackpocoB.a @-ln -s $(linkrc)/bablpoco.a bablpoco.a @-ln -s $(linkrc)/bablpocoB.a bablpocoB.a @-ln -s $(linkrc)/valipoco.a valipoco.a @-ln -s $(linkrc)/valipocoB.a valipocoB.a # the package the manages the i/o during continuation : proc_io: ada.lib process_io.a process_ioB.a $(compile) process_io.a process_ioB.a # The data and parameters for the continuation : condat: ada.lib cont_data.a cont_dataB.a $(compile) cont_data.a cont_dataB.a conpar: condat conpar.a conparB.a conpar_io.a conpar_ioB.a $(compile) conpar.a conparB.a conpar_io.a conpar_ioB.a # predictor-corrector based on increment-and-fix : pc_fix: proc_io condat predictors.a predictorsB.a correctors.a correctorsB.a $(compile) predictors.a predictorsB.a correctors.a correctorsB.a # The vLpRs-Algorithm for extrapolating path directions : vlprs: ada.lib vlprstab.a vlprstabB.a vlprsalg.a vlprsalgB.a $(compile) vlprstab.a vlprstabB.a vlprsalg.a vlprsalgB.a dirpaths: vlprs dirpaths.a dirpathsB.a $(compile) dirpaths.a dirpathsB.a # the path trackers and the main continuation routines : # ( Note : optimizing causes run-time error on IBM RS/6000...) pathtrac: conpar pc_fix dirpaths dispred.a dispredB.a pathtrac.a pathtracB.a ada dispred.a dispredB.a pathtrac.a pathtracB.a continue: pathtrac continue.a continueB.a ada continue.a continueB.a # roots refinement : roots: ada.lib rootrefi.a rootrefiB.a $(compile) rootrefi.a rootrefiB.a # The interactive drivers : drivpadi : continue drivpadi.a drivpadiB.a $(compile) drivpadi.a drivpadiB.a drivpoco: drivpadi proc_io roots drivpoco.a drivpocoB.a mainpoco.a mainpocoB.a $(compile) drivpoco.a drivpocoB.a mainpoco.a mainpocoB.a drivwind: drivpoco drivwind.a drivwindB.a $(compile) drivwind.a drivwindB.a blackpoco: drivpoco scanpoco.a scanpocoB.a blackpoco.a blackpocoB.a $(compile) scanpoco.a scanpocoB.a blackpoco.a blackpocoB.a bablpoco: blackpoco bablpoco.a bablpocoB.a $(compile) bablpoco.a bablpocoB.a valipoco: ada.lib valipoco.a valipocoB.a $(compile) valipoco.a valipocoB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Homotopy' then mkdir 'Homotopy' fi cd 'Homotopy' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: solutions projtrans drivhoco drivscal drivred climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../makelib a.path -a ../System a.path -a ../Math_Lib/Numbers a.path -a ../Math_Lib/Matrices a.path -a ../Math_Lib/Polynomials # Cleaning unnecessary instantiations : cleaninst: a.cleaninst # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../Homotopy links: @-ln -s $(linkrc)/equals.a equals.a @-ln -s $(linkrc)/equalsB.a equalsB.a @-ln -s $(linkrc)/solutions.a solutions.a @-ln -s $(linkrc)/solutionsB.a solutionsB.a @-ln -s $(linkrc)/solutions_io.a solutions_io.a @-ln -s $(linkrc)/solutions_ioB.a solutions_ioB.a @-ln -s $(linkrc)/homotopy.a homotopy.a @-ln -s $(linkrc)/homotopyB.a homotopyB.a @-ln -s $(linkrc)/homzers.a homzers.a @-ln -s $(linkrc)/homzersB.a homzersB.a @-ln -s $(linkrc)/drivhoco.a drivhoco.a @-ln -s $(linkrc)/drivhocoB.a drivhocoB.a @-ln -s $(linkrc)/projtrans.a projtrans.a @-ln -s $(linkrc)/projtransB.a projtransB.a @-ln -s $(linkrc)/scaling.a scaling.a @-ln -s $(linkrc)/scalingB.a scalingB.a @-ln -s $(linkrc)/drivscals.a drivscals.a @-ln -s $(linkrc)/drivscalsB.a drivscalsB.a @-ln -s $(linkrc)/mainscal.a mainscal.a @-ln -s $(linkrc)/mainscalB.a mainscalB.a @-ln -s $(linkrc)/redupoly.a redupoly.a @-ln -s $(linkrc)/redupolyB.a redupolyB.a @-ln -s $(linkrc)/redufull.a redufull.a @-ln -s $(linkrc)/redufullB.a redufullB.a @-ln -s $(linkrc)/reduover.a reduover.a @-ln -s $(linkrc)/reduoverB.a reduoverB.a @-ln -s $(linkrc)/drivreds.a drivreds.a @-ln -s $(linkrc)/drivredsB.a drivredsB.a @-ln -s $(linkrc)/mainred.a mainred.a @-ln -s $(linkrc)/mainredB.a mainredB.a # The solutions : # for IBM RS/6000 optimizer on solutions causes STORAGE_ERROR # when clustering of solutions during continuation appears. sols: ada.lib equals.a equalsB.a solutions.a solutionsB.a $(compile) equals.a equalsB.a solutions.a ada solutionsB.a solutions: sols solutions_io.a solutions_ioB.a $(compile) solutions_io.a solutions_ioB.a # The homotopy : homotopy: ada.lib homotopy.a homotopyB.a $(compile) homotopy.a homotopyB.a # parametric homotopies : parahoms: ada.lib parahoms.a parahomsB.a parahoms_io.a parahoms_ioB.a ada parahoms.a parahomsB.a parahoms_io.a parahoms_ioB.a # Adding homogeneous equations : homzers: ada.lib homzers.a homzersB.a $(compile) homzers.a homzersB.a projtrans: homzers projtrans.a projtransB.a $(compile) projtrans.a projtransB.a # The interactive driver for the construction of the homotopy : drivhoco: homotopy homzers drivhoco.a drivhocoB.a $(compile) drivhoco.a drivhocoB.a # Scaling and reduction : scaling: solutions scaling.a scalingB.a $(compile) scaling.a scalingB.a drivscal: scaling drivscals.a drivscalsB.a mainscal.a mainscalB.a $(compile) drivscals.a drivscalsB.a mainscal.a mainscalB.a redufull: ada.lib redupoly.a redupolyB.a redufull.a redufullB.a $(compile) redupoly.a redupolyB.a redufull.a redufullB.a reduover: redufull reduover.a reduoverB.a $(compile) reduover.a reduoverB.a drivred: reduover drivreds.a drivredsB.a mainred.a mainredB.a $(compile) drivreds.a drivredsB.a mainred.a mainredB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Main' then mkdir 'Main' fi cd 'Main' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: drivroco drivrore climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) # Making an Ada library : ada.lib: @-../makelib a.path -a ../System a.path -a ../Math_Lib/Numbers a.path -a ../Math_Lib/Matrices a.path -a ../Math_Lib/Supports a.path -a ../Math_Lib/Polynomials a.path -a ../Homotopy a.path -a ../Continuation a.path -a ../Root_Counts/Product a.path -a ../Root_Counts/Implift a.path -a ../Root_Counts/Stalift a.path -a ../Root_Counts/Dynlift a.path -a ../Root_Counts/Symmetry # Cleaning the Ada library : clean: a.rmlib -f # Cleaning imports : climp: @-rm -f .imports/* # Cleaning superfluous instantiations : cleaninst: @-a.cleaninst # Installing everything : install: @-./makeall # Cleaning everything : cleanall: @-./makeclean # Establishing the links : linkrc = ../../Main links: @-ln -s $(linkrc)/drivowst.a drivowst.a @-ln -s $(linkrc)/drivowstB.a drivowstB.a @-ln -s $(linkrc)/drivroco.a drivroco.a @-ln -s $(linkrc)/drivrocoB.a drivrocoB.a @-ln -s $(linkrc)/blackroco.a blackroco.a @-ln -s $(linkrc)/blackrocoB.a blackrocoB.a @-ln -s $(linkrc)/bablroco.a bablroco.a @-ln -s $(linkrc)/bablrocoB.a bablrocoB.a @-ln -s $(linkrc)/mainroco.a mainroco.a @-ln -s $(linkrc)/mainrocoB.a mainrocoB.a @-ln -s $(linkrc)/drivrore.a drivrore.a @-ln -s $(linkrc)/drivroreB.a drivroreB.a @-ln -s $(linkrc)/mainvali.a mainvali.a @-ln -s $(linkrc)/mainvaliB.a mainvaliB.a @-ln -s $(linkrc)/bablvali.a bablvali.a @-ln -s $(linkrc)/bablvaliB.a bablvaliB.a @-ln -s $(linkrc)/bablphc.a bablphc.a @-ln -s $(linkrc)/bablphcB.a bablphcB.a @-ln -s $(linkrc)/mainphc.a mainphc.a @-ln -s $(linkrc)/mainphcB.a mainphcB.a @-ln -s $(linkrc)/dispatch.a dispatch.a @-ln -s $(linkrc)/dispatchB.a dispatchB.a @-ln -s $(linkrc)/phcpack.a phcpack.a @-ln -s $(linkrc)/phcpackB.a phcpackB.a @-ln -s $(linkrc)/use_phc.a use_phc.a # The interactive driver for the preprocessing : drivprep: ada.lib drivprep.a drivprepB.a ada $(options) drivprep.a drivprepB.a # The interactive driver for the root counting methods : drivowst: ada.lib drivowst.a drivowstB.a ada $(options) drivowst.a drivowstB.a drivroco: drivowst drivroco.a drivrocoB.a mainroco.a mainrocoB.a ada $(options) drivroco.a drivrocoB.a mainroco.a mainrocoB.a roco: drivroco blackroco.a blackrocoB.a bablroco.a bablrocoB.a ada $(options) blackroco.a bablroco.a bablrocoB.a ada blackrocoB.a # The driver for root refining : validate: ada.lib mainvali.a mainvaliB.a bablvali.a bablvaliB.a ada $(options) mainvali.a mainvaliB.a bablvali.a bablvaliB.a drivrore: validate drivrore.a drivroreB.a ada $(options) drivrore.a drivroreB.a # The main interactive dispatcher: bablphc: roco drivrore mainphc.a mainphcB.a bablphc.a bablphcB.a ada $(options) mainphc.a mainphcB.a bablphc.a bablphcB.a phc: bablphc dispatch.a dispatchB.a ada $(options) dispatch.a dispatchB.a @-make climp a.ld -o ../../../bin/phc dispatch SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Math_Lib' then mkdir 'Math_Lib' fi cd 'Math_Lib' if test ! -d 'Matrices' then mkdir 'Matrices' fi cd 'Matrices' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: vec vec_io mat_io lss vvc vvc_io climp vec: vectors nat_vec int_vec flt_vec cmp_vec cmp_norms vec_io: vec nat_vec_io int_vec_io flt_vec_io cmp_vec_io mat: vec nat_mat int_mat flt_mat cmp_mat mat_io: mat int_mat_io flt_mat_io cmp_mat_io lss: mat gcd int_lss int_lis flt_lss cmp_lss vvc: vec nat_vvc int_vvc flt_vvc cmp_vvc vvc_io: vvc nat_vvc_io int_vvc_io flt_vvc_io cmp_vvc_io # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../Numbers # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Math_Lib/Matrices links: @-ln -s $(linkrc)/gcd.a gcd.a @-ln -s $(linkrc)/gcdB.a gcdB.a @-ln -s $(linkrc)/vectors.a vectors.a @-ln -s $(linkrc)/vectorsB.a vectorsB.a @-ln -s $(linkrc)/nat_vec.a nat_vec.a @-ln -s $(linkrc)/nat_vec_io.a nat_vec_io.a @-ln -s $(linkrc)/nat_vec_ioB.a nat_vec_ioB.a @-ln -s $(linkrc)/int_vec.a int_vec.a @-ln -s $(linkrc)/int_vec_io.a int_vec_io.a @-ln -s $(linkrc)/int_vec_ioB.a int_vec_ioB.a @-ln -s $(linkrc)/flt_vec.a flt_vec.a @-ln -s $(linkrc)/flt_vec_io.a flt_vec_io.a @-ln -s $(linkrc)/flt_vec_ioB.a flt_vec_ioB.a @-ln -s $(linkrc)/cmp_vec.a cmp_vec.a @-ln -s $(linkrc)/cmp_vec_io.a cmp_vec_io.a @-ln -s $(linkrc)/cmp_vec_ioB.a cmp_vec_ioB.a @-ln -s $(linkrc)/cmp_norms.a cmp_norms.a @-ln -s $(linkrc)/cmp_normsB.a cmp_normsB.a @-ln -s $(linkrc)/nat_vvc.a nat_vvc.a @-ln -s $(linkrc)/nat_vvc_io.a nat_vvc_io.a @-ln -s $(linkrc)/nat_vvc_ioB.a nat_vvc_ioB.a @-ln -s $(linkrc)/nat_mat.a nat_mat.a @-ln -s $(linkrc)/nat_matB.a nat_matB.a @-ln -s $(linkrc)/nat_mat_io.a nat_mat_io.a @-ln -s $(linkrc)/nat_mat_ioB.a nat_mat_ioB.a @-ln -s $(linkrc)/int_mat.a int_mat.a @-ln -s $(linkrc)/int_matB.a int_matB.a @-ln -s $(linkrc)/int_mat_io.a int_mat_io.a @-ln -s $(linkrc)/int_mat_ioB.a int_mat_ioB.a @-ln -s $(linkrc)/int_lss.a int_lss.a @-ln -s $(linkrc)/int_lssB.a int_lssB.a @-ln -s $(linkrc)/int_lis.a int_lis.a @-ln -s $(linkrc)/int_lisB.a int_lisB.a @-ln -s $(linkrc)/int_vvc.a int_vvc.a @-ln -s $(linkrc)/int_vvc_io.a int_vvc_io.a @-ln -s $(linkrc)/int_vvc_ioB.a int_vvc_ioB.a @-ln -s $(linkrc)/flt_mat.a flt_mat.a @-ln -s $(linkrc)/flt_matB.a flt_matB.a @-ln -s $(linkrc)/flt_mat_io.a flt_mat_io.a @-ln -s $(linkrc)/flt_mat_ioB.a flt_mat_ioB.a @-ln -s $(linkrc)/flt_lss.a flt_lss.a @-ln -s $(linkrc)/flt_lssB.a flt_lssB.a @-ln -s $(linkrc)/flt_vvc.a flt_vvc.a @-ln -s $(linkrc)/flt_vvc_io.a flt_vvc_io.a @-ln -s $(linkrc)/flt_vvc_ioB.a flt_vvc_ioB.a @-ln -s $(linkrc)/cmp_mat.a cmp_mat.a @-ln -s $(linkrc)/cmp_matB.a cmp_matB.a @-ln -s $(linkrc)/cmp_mat_io.a cmp_mat_io.a @-ln -s $(linkrc)/cmp_mat_ioB.a cmp_mat_ioB.a @-ln -s $(linkrc)/cmp_lss.a cmp_lss.a @-ln -s $(linkrc)/cmp_lssB.a cmp_lssB.a @-ln -s $(linkrc)/cmp_vvc.a cmp_vvc.a @-ln -s $(linkrc)/cmp_vvc_io.a cmp_vvc_io.a @-ln -s $(linkrc)/cmp_vvc_ioB.a cmp_vvc_ioB.a # Greatest common divisor : gcd: ada.lib gcd.a gcdB.a $(compile) gcd.a gcdB.a # The vectors package : vectors: ada.lib vectors.a vectorsB.a $(compile) vectors.a vectorsB.a # Instantiation of natural, integer, float and complex vectors : nat_vec: vectors nat_vec.a $(compile) nat_vec.a int_vec: vectors int_vec.a $(compile) int_vec.a flt_vec: vectors flt_vec.a $(compile) flt_vec.a cmp_vec: vectors cmp_vec.a $(compile) cmp_vec.a # Norms of complex vectors : cmp_norms: cmp_vec cmp_norms.a cmp_normsB.a $(compile) cmp_norms.a cmp_normsB.a # Input/Output operations of all the vector packages : nat_vec_io: nat_vec nat_vec_io.a nat_vec_ioB.a $(compile) nat_vec_io.a nat_vec_ioB.a int_vec_io: int_vec int_vec_io.a int_vec_ioB.a $(compile) int_vec_io.a int_vec_ioB.a flt_vec_io: flt_vec flt_vec_io.a flt_vec_ioB.a $(compile) flt_vec_io.a flt_vec_ioB.a cmp_vec_io: cmp_vec cmp_vec_io.a cmp_vec_ioB.a $(compile) cmp_vec_io.a cmp_vec_ioB.a # Matrices with natural, integer, float and complex components : nat_mat: nat_vec nat_mat.a nat_matB.a $(compile) nat_mat.a nat_matB.a int_mat: int_vec int_mat.a int_matB.a $(compile) int_mat.a int_matB.a flt_mat: flt_vec flt_mat.a flt_matB.a $(compile) flt_mat.a flt_matB.a cmp_mat: cmp_vec cmp_mat.a cmp_matB.a $(compile) cmp_mat.a cmp_matB.a # Input/Output operations of all the vector packages : nat_mat_io: nat_mat nat_mat_io.a nat_mat_ioB.a $(compile) nat_mat_io.a nat_mat_ioB.a int_mat_io: int_mat int_mat_io.a int_mat_ioB.a $(compile) int_mat_io.a int_mat_ioB.a flt_mat_io: flt_mat flt_mat_io.a flt_mat_ioB.a $(compile) flt_mat_io.a flt_mat_ioB.a cmp_mat_io: cmp_mat cmp_mat_io.a cmp_mat_ioB.a $(compile) cmp_mat_io.a cmp_mat_ioB.a # Linear system solvers : int_lss: int_mat gcd int_lss.a int_lssB.a ada int_lss.a int_lssB.a flt_lss: flt_mat int_vec flt_lss.a flt_lssB.a $(compile) flt_lss.a flt_lssB.a cmp_lss: cmp_mat int_vec cmp_lss.a cmp_lssB.a $(compile) cmp_lss.a cmp_lssB.a # Linear inequality solvers : int_lis: int_lss int_lis.a int_lisB.a $(compile) int_lis.a int_lisB.a # Vectors of Vectors : nat_vvc: nat_vec nat_vvc.a $(compile) nat_vvc.a int_vvc: int_vec int_vvc.a $(compile) int_vvc.a flt_vvc: flt_vec flt_vvc.a $(compile) flt_vvc.a cmp_vvc: cmp_vec cmp_vvc.a $(compile) cmp_vvc.a # Input/Output operations of all the vectors of vectors packages : nat_vvc_io: nat_vvc nat_vvc_io.a nat_vvc_ioB.a $(compile) nat_vvc_io.a nat_vvc_ioB.a int_vvc_io: int_vvc int_vvc_io.a int_vvc_ioB.a $(compile) int_vvc_io.a int_vvc_ioB.a flt_vvc_io: flt_vvc flt_vvc_io.a flt_vvc_ioB.a $(compile) flt_vvc_io.a flt_vvc_ioB.a cmp_vvc_io: cmp_vvc cmp_vvc_io.a cmp_vvc_ioB.a $(compile) cmp_vvc_io.a cmp_vvc_ioB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Numbers' then mkdir 'Numbers' fi cd 'Numbers' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: complex_io random nat_inst int_inst flt_inst cmp_inst strnum climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc=../../../Math_Lib/Numbers links: @-ln -s $(linkrc)/float.a float.a @-ln -s $(linkrc)/mathfun.a mathfun.a @-ln -s $(linkrc)/mathfunB.a mathfunB.a @-ln -s $(linkrc)/numbers_io.a numbers_io.a @-ln -s $(linkrc)/numbers_ioB.a numbers_ioB.a @-ln -s $(linkrc)/complex.a complex.a @-ln -s $(linkrc)/complexB.a complexB.a @-ln -s $(linkrc)/complex_io.a complex_io.a @-ln -s $(linkrc)/complex_ioB.a complex_ioB.a @-ln -s $(linkrc)/random.a random.a @-ln -s $(linkrc)/randomB.a randomB.a @-ln -s $(linkrc)/nat_inst.a nat_inst.a @-ln -s $(linkrc)/nat_instB.a nat_instB.a @-ln -s $(linkrc)/int_inst.a int_inst.a @-ln -s $(linkrc)/int_instB.a int_instB.a @-ln -s $(linkrc)/flt_inst.a flt_inst.a @-ln -s $(linkrc)/flt_instB.a flt_instB.a @-ln -s $(linkrc)/cmp_inst.a cmp_inst.a @-ln -s $(linkrc)/cmp_instB.a cmp_instB.a @-ln -s $(linkrc)/strnum.a strnum.a @-ln -s $(linkrc)/strnumB.a strnumB.a # Floating point numbers and user friendly i/o of numbers : float: ada.lib float.a numbers_io.a numbers_ioB.a mathfun.a mathfunB.a $(compile) float.a numbers_io.a numbers_ioB.a mathfun.a mathfunB.a # Complex numbers : complex: float complex.a complexB.a $(compile) complex.a complexB.a complex_io: complex complex_io.a complex_ioB.a $(compile) complex_io.a complex_ioB.a # Random number generators : random: complex random.a randomB.a $(compile) random.a randomB.a # instantiation packages : nat_inst: ada.lib nat_inst.a nat_instB.a $(compile) nat_inst.a nat_instB.a int_inst: ada.lib int_inst.a int_instB.a $(compile) int_inst.a int_instB.a flt_inst: float flt_inst.a flt_instB.a $(compile) flt_inst.a flt_instB.a cmp_inst: complex cmp_inst.a cmp_instB.a $(compile) cmp_inst.a cmp_instB.a # string conversions : strnum: ada.lib strnum.a strnumB.a $(compile) strnum.a strnumB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Polynomials' then mkdir 'Polynomials' fi cd 'Polynomials' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: cmp_polsys_io jacobi pollaco tools climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../Numbers a.path -a ../Matrices # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Math_Lib/Polynomials links: @-ln -s $(linkrc)/nat_grad_lex.a nat_grad_lex.a @-ln -s $(linkrc)/nat_grad_lexB.a nat_grad_lexB.a @-ln -s $(linkrc)/int_grad_lex.a int_grad_lex.a @-ln -s $(linkrc)/int_grad_lexB.a int_grad_lexB.a @-ln -s $(linkrc)/lists.a lists.a @-ln -s $(linkrc)/listsB.a listsB.a @-ln -s $(linkrc)/expvec.a expvec.a @-ln -s $(linkrc)/expvecB.a expvecB.a @-ln -s $(linkrc)/mul_poly.a mul_poly.a @-ln -s $(linkrc)/mul_polyB.a mul_polyB.a @-ln -s $(linkrc)/mul_laur.a mul_laur.a @-ln -s $(linkrc)/mul_laurB.a mul_laurB.a @-ln -s $(linkrc)/cmp_mpoly.a cmp_mpoly.a @-ln -s $(linkrc)/cmp_mlaur.a cmp_mlaur.a @-ln -s $(linkrc)/symtab.a symtab.a @-ln -s $(linkrc)/symtabB.a symtabB.a @-ln -s $(linkrc)/symtab_io.a symtab_io.a @-ln -s $(linkrc)/symtab_ioB.a symtab_ioB.a @-ln -s $(linkrc)/cmp_mpoly_io.a cmp_mpoly_io.a @-ln -s $(linkrc)/cmp_mpoly_ioB.a cmp_mpoly_ioB.a @-ln -s $(linkrc)/cmp_polsys.a cmp_polsys.a @-ln -s $(linkrc)/cmp_polsysB.a cmp_polsysB.a @-ln -s $(linkrc)/cmp_laursys.a cmp_laursys.a @-ln -s $(linkrc)/cmp_laursysB.a cmp_laursysB.a @-ln -s $(linkrc)/pollaco.a pollaco.a @-ln -s $(linkrc)/pollacoB.a pollacoB.a @-ln -s $(linkrc)/lapolco.a lapolco.a @-ln -s $(linkrc)/lapolcoB.a lapolcoB.a @-ln -s $(linkrc)/cmp_polsys_io.a cmp_polsys_io.a @-ln -s $(linkrc)/cmp_polsys_ioB.a cmp_polsys_ioB.a @-ln -s $(linkrc)/jacobi.a jacobi.a @-ln -s $(linkrc)/jacobiB.a jacobiB.a @-ln -s $(linkrc)/laurjaco.a laurjaco.a @-ln -s $(linkrc)/laurjacoB.a laurjacoB.a @-ln -s $(linkrc)/polrand.a polrand.a @-ln -s $(linkrc)/polrandB.a polrandB.a @-ln -s $(linkrc)/laurrand.a laurrand.a @-ln -s $(linkrc)/laurrandB.a laurrandB.a @-ln -s $(linkrc)/substits.a substits.a @-ln -s $(linkrc)/substitsB.a substitsB.a # Term ordenings : nat_grad_lex: ada.lib nat_grad_lex.a nat_grad_lexB.a $(compile) nat_grad_lex.a nat_grad_lexB.a int_grad_lex: ada.lib int_grad_lex.a int_grad_lexB.a $(compile) int_grad_lex.a int_grad_lexB.a # Generic lists : lists: ada.lib lists.a listsB.a $(compile) lists.a listsB.a # Generic multivariate polynomials : mul_poly: lists mul_poly.a mul_polyB.a $(compile) mul_poly.a mul_polyB.a mul_laur: lists mul_laur.a mul_laurB.a $(compile) mul_laur.a mul_laurB.a # Complex multivariate polynomials : cmp_mpoly: mul_poly nat_grad_lex cmp_mpoly.a $(compile) cmp_mpoly.a cmp_mlaur: mul_laur int_grad_lex cmp_mlaur.a $(compile) cmp_mlaur.a # Input/Output operations of multivariate polynomials : symtab: ada.lib symtab.a symtabB.a symtab_io.a symtab_ioB.a ada symtab.a symtabB.a symtab_io.a symtab_ioB.a # Optimizing causes a run time error : cmp_mpoly_io: symtab cmp_mpoly cmp_mpoly_io.a cmp_mpoly_ioB.a ada cmp_mpoly_io.a cmp_mpoly_ioB.a # Complex polynomial systems : cmp_polsys: cmp_mpoly cmp_polsys.a cmp_polsysB.a $(compile) cmp_polsys.a cmp_polsysB.a cmp_laursys: cmp_mlaur cmp_laursys.a cmp_laursysB.a expvec.a expvecB.a $(compile) cmp_laursys.a cmp_laursysB.a expvec.a expvecB.a # Converters between the polynomial systems : pollaco: cmp_polsys cmp_laursys pollaco.a pollacoB.a lapolco.a lapolcoB.a $(compile) pollaco.a pollacoB.a lapolco.a lapolcoB.a # Input/Output operations of complex polynomial systems : cmp_polsys_io: cmp_polsys cmp_mpoly_io cmp_polsys_io.a cmp_polsys_ioB.a $(compile) cmp_polsys_io.a cmp_polsys_ioB.a # The package Jacobi_Matrices : jacobi: cmp_polsys cmp_laursys jacobi.a jacobiB.a laurjaco.a laurjacoB.a $(compile) jacobi.a jacobiB.a laurjaco.a laurjacoB.a # Some tools: randomizers and substitutors : tools: rand substits rand: cmp_polsys cmp_laursys polrand.a polrandB.a laurrand.a laurrandB.a $(compile) polrand.a polrandB.a $(compile) laurrand.a laurrandB.a substits: cmp_polsys substits.a substitsB.a $(compile) substits.a substitsB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Supports' then mkdir 'Supports' fi cd 'Supports' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: lp facenum fltfanum data climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../Numbers a.path -a ../Matrices a.path -a ../Polynomials # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Math_Lib/Supports links: @-ln -s $(linkrc)/dictios.a dictios.a @-ln -s $(linkrc)/dictiosB.a dictiosB.a @-ln -s $(linkrc)/lp.a lp.a @-ln -s $(linkrc)/lpB.a lpB.a @-ln -s $(linkrc)/givens.a givens.a @-ln -s $(linkrc)/givensB.a givensB.a @-ln -s $(linkrc)/farkas.a farkas.a @-ln -s $(linkrc)/farkasB.a farkasB.a @-ln -s $(linkrc)/int_farkas.a int_farkas.a @-ln -s $(linkrc)/int_farkasB.a int_farkasB.a @-ln -s $(linkrc)/facenu_ut.a facenu_ut.a @-ln -s $(linkrc)/facenu_utB.a facenu_utB.a @-ln -s $(linkrc)/facenum.a facenum.a @-ln -s $(linkrc)/facenumB.a facenumB.a @-ln -s $(linkrc)/flt_lis.a flt_lis.a @-ln -s $(linkrc)/flt_lisB.a flt_lisB.a @-ln -s $(linkrc)/fltintro.a fltintro.a @-ln -s $(linkrc)/fltintroB.a fltintroB.a @-ln -s $(linkrc)/fltfanum.a fltfanum.a @-ln -s $(linkrc)/fltfanumB.a fltfanumB.a @-ln -s $(linkrc)/lstivc.a lstivc.a @-ln -s $(linkrc)/lstivcB.a lstivcB.a @-ln -s $(linkrc)/lstivc_io.a lstivc_io.a @-ln -s $(linkrc)/lstivc_ioB.a lstivc_ioB.a @-ln -s $(linkrc)/arrlivc.a arrlivc.a @-ln -s $(linkrc)/arrlivcB.a arrlivcB.a @-ln -s $(linkrc)/arrlivc_io.a arrlivc_io.a @-ln -s $(linkrc)/arrlivc_ioB.a arrlivc_ioB.a @-ln -s $(linkrc)/intsupfu.a intsupfu.a @-ln -s $(linkrc)/intsupfuB.a intsupfuB.a @-ln -s $(linkrc)/intfaces.a intfaces.a @-ln -s $(linkrc)/intfacesB.a intfacesB.a @-ln -s $(linkrc)/intfaces_io.a intfaces_io.a @-ln -s $(linkrc)/intfaces_ioB.a intfaces_ioB.a @-ln -s $(linkrc)/lstfvc.a lstfvc.a @-ln -s $(linkrc)/lstfvcB.a lstfvcB.a @-ln -s $(linkrc)/lstfvc_io.a lstfvc_io.a @-ln -s $(linkrc)/lstfvc_ioB.a lstfvc_ioB.a @-ln -s $(linkrc)/arrlfvc.a arrlfvc.a @-ln -s $(linkrc)/arrlfvcB.a arrlfvcB.a @-ln -s $(linkrc)/arrlfvc_io.a arrlfvc_io.a @-ln -s $(linkrc)/arrlfvc_ioB.a arrlfvc_ioB.a @-ln -s $(linkrc)/fltsupfu.a fltsupfu.a @-ln -s $(linkrc)/fltsupfuB.a fltsupfuB.a @-ln -s $(linkrc)/fltfaces.a fltfaces.a @-ln -s $(linkrc)/fltfacesB.a fltfacesB.a # Linear programming and the simplex method : lp: ada.lib dictios.a dictiosB.a lp.a lpB.a $(compile) dictios.a dictiosB.a lp.a lpB.a # Farkas lemma and complementary slackness : farkas: ada.lib givens.a givensB.a farkas.a farkasB.a flt_lis.a flt_lisB.a ada givens.a givensB.a flt_lis.a flt_lisB.a ada farkas.a farkasB.a int_farkas: farkas int_farkas.a int_farkasB.a fltintro.a fltintroB.a $(compile) int_farkas.a int_farkasB.a ada fltintro.a fltintroB.a # Enumeration of faces : facenum: int_farkas facenu_ut.a facenu_utB.a facenum.a facenumB.a $(compile) facenu_ut.a facenu_utB.a facenum.a facenumB.a fltfanum: farkas fltfanum.a fltfanumB.a $(compile) fltfanum.a fltfanumB.a # data structures: lstivc: ada.lib lstivc.a lstivcB.a lstivc_io.a lstivc_ioB.a $(compile) lstivc.a lstivcB.a lstivc_io.a lstivc_ioB.a arrlivc: lstivc arrlivc.a arrlivcB.a arrlivc_io.a arrlivc_ioB.a $(compile) arrlivc.a arrlivcB.a arrlivc_io.a arrlivc_ioB.a intfaces: lstivc intfaces.a intfacesB.a intfaces_io.a intfaces_ioB.a $(compile) intfaces.a intfacesB.a intfaces_io.a intfaces_ioB.a intsupfu: lstivc intsupfu.a intsupfuB.a $(compile) intsupfu.a intsupfuB.a lstfvc: ada.lib lstfvc.a lstfvcB.a lstfvc_io.a lstfvc_ioB.a $(compile) lstfvc.a lstfvcB.a lstfvc_io.a lstfvc_ioB.a arrlfvc: lstfvc arrlfvc.a arrlfvcB.a arrlfvc_io.a arrlfvc_ioB.a $(compile) arrlfvc.a arrlfvcB.a arrlfvc_io.a arrlfvc_ioB.a fltfaces: lstfvc fltsupfu.a fltsupfuB.a fltfaces.a fltfacesB.a $(compile) fltsupfu.a fltsupfuB.a fltfaces.a fltfacesB.a data: arrlivc intfaces intsupfu arrlfvc fltfaces SHAR_EOF fi # end of overwriting check cd .. if test -f 'makeall' then echo shar: will not over-write existing file "'makeall'" else cat << "SHAR_EOF" > 'makeall' echo '**** Making the Numbers Library ****' cd Numbers make all echo '**** Making the Matrices Library ****' cd ../Matrices make all echo '**** Making the Polynomials Library ****' cd ../Polynomials make all echo '**** Making the Supports Library ****' cd ../Supports make all cd .. SHAR_EOF fi # end of overwriting check if test -f 'makeclean' then echo shar: will not over-write existing file "'makeclean'" else cat << "SHAR_EOF" > 'makeclean' echo '**** Cleaning the Supports Library ****' cd Supports make clean echo '**** Cleaning the Polynomials Library ****' cd ../Polynomials make clean echo '**** Cleaning the Matrices Library ****' cd ../Matrices make clean echo '**** Cleaning the Numbers Library ****' cd ../Numbers make clean cd .. SHAR_EOF fi # end of overwriting check if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' # Making the library with the root counts: all: @-./makeall clean: @-./makeclean SHAR_EOF fi # end of overwriting check cd .. if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' This directory mirrors the tree structure of the package and contains the makefiles to install phc with the VADS compiler, for DEC/Ultrix, IBM RS6000/AIX and SUN/Solaris. To install the packages, do : 0. Make sure you have a VADS compiler installed, the file PHC/READ_ME contains information on obtaining it; 1. Set the right ADAPATH in makelib. 2. Type make all > makelog & If all goes well, you can find the executable as file phc in the directory PHC/bin. To clean the auxiliary files type make clean SHAR_EOF fi # end of overwriting check if test ! -d 'Root_Counts' then mkdir 'Root_Counts' fi cd 'Root_Counts' if test ! -d 'Dynlift' then mkdir 'Dynlift' fi cd 'Dynlift' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: drivdynl babldmvc climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # compile=a.make $(makeoptions) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../../Math_Lib/Numbers a.path -a ../../Math_Lib/Matrices a.path -a ../../Math_Lib/Polynomials a.path -a ../../Math_Lib/Supports a.path -a ../../Homotopy a.path -a ../../Continuation a.path -a ../Product a.path -a ../Implift a.path -a ../Stalift # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Root_Counts/Dynlift links: @-ln -s $(linkrc)/simplex.a simplex.a @-ln -s $(linkrc)/simplexB.a simplexB.a @-ln -s $(linkrc)/simplex_io.a simplex_io.a @-ln -s $(linkrc)/simplex_ioB.a simplex_ioB.a @-ln -s $(linkrc)/triangle.a triangle.a @-ln -s $(linkrc)/triangleB.a triangleB.a @-ln -s $(linkrc)/triangle_io.a triangle_io.a @-ln -s $(linkrc)/triangle_ioB.a triangle_ioB.a @-ln -s $(linkrc)/glodyntri.a glodyntri.a @-ln -s $(linkrc)/glodyntriB.a glodyntriB.a @-ln -s $(linkrc)/dynlift.a dynlift.a @-ln -s $(linkrc)/dynliftB.a dynliftB.a @-ln -s $(linkrc)/dyntri.a dyntri.a @-ln -s $(linkrc)/dyntriB.a dyntriB.a @-ln -s $(linkrc)/cayemb.a cayemb.a @-ln -s $(linkrc)/cayembB.a cayembB.a @-ln -s $(linkrc)/cayley.a cayley.a @-ln -s $(linkrc)/cayleyB.a cayleyB.a @-ln -s $(linkrc)/minkpoly.a minkpoly.a @-ln -s $(linkrc)/minkpolyB.a minkpolyB.a @-ln -s $(linkrc)/drivmink.a drivmink.a @-ln -s $(linkrc)/drivminkB.a drivminkB.a @-ln -s $(linkrc)/commfaces.a commfaces.a @-ln -s $(linkrc)/commfacesB.a commfacesB.a @-ln -s $(linkrc)/enumfaces.a enumfaces.a @-ln -s $(linkrc)/enumfacesB.a enumfacesB.a @-ln -s $(linkrc)/freqgraph.a freqgraph.a @-ln -s $(linkrc)/freqgraphB.a freqgraphB.a @-ln -s $(linkrc)/initmice.a initmice.a @-ln -s $(linkrc)/initmiceB.a initmiceB.a @-ln -s $(linkrc)/flatmisu.a flatmisu.a @-ln -s $(linkrc)/flatmisuB.a flatmisuB.a @-ln -s $(linkrc)/unfolding.a unfolding.a @-ln -s $(linkrc)/unfoldingB.a unfoldingB.a @-ln -s $(linkrc)/triamisu.a triamisu.a @-ln -s $(linkrc)/triamisuB.a triamisuB.a @-ln -s $(linkrc)/dymisudi.a dymisudi.a @-ln -s $(linkrc)/dymisudiB.a dymisudiB.a @-ln -s $(linkrc)/dynpolco.a dynpolco.a @-ln -s $(linkrc)/dynpolcoB.a dynpolcoB.a @-ln -s $(linkrc)/drivdynl.a drivdynl.a @-ln -s $(linkrc)/drivdynlB.a drivdynlB.a @-ln -s $(linkrc)/dbkkcomp.a dbkkcomp.a @-ln -s $(linkrc)/dbkkcompB.a dbkkcompB.a @-ln -s $(linkrc)/blackmvc.a blackmvc.a @-ln -s $(linkrc)/blackmvcB.a blackmvcB.a @-ln -s $(linkrc)/babldmvc.a babldmvc.a @-ln -s $(linkrc)/babldmvcB.a babldmvcB.a # simplices : simplex: ada.lib simplex.a simplexB.a simplex_io.a simplex_ioB.a $(compile) simplex.a simplexB.a simplex_io.a simplex_ioB.a # triangulations : triangle: simplex triangle.a triangleB.a triangle_io.a triangle_ioB.a $(compile) triangle.a triangleB.a triangle_io.a triangle_ioB.a # utilities and dynamic lifting dyntri: triangle glodyntri.a glodyntriB.a dynlift.a dynliftB.a dyntri.a dyntriB.a $(compile) glodyntri.a glodyntriB.a dynlift.a dynliftB.a $(compile) dyntri.a dyntriB.a # The Cayley trick : flatmisu: ada.lib flatmisu.a flatmisuB.a $(compile) flatmisu.a flatmisuB.a cayley: dyntri flatmisu cayemb.a cayembB.a cayley.a cayleyB.a $(compile) cayemb.a cayembB.a cayley.a cayleyB.a minkpoly: cayley minkpoly.a minkpolyB.a drivmink.a drivminkB.a $(compile) minkpoly.a minkpolyB.a drivmink.a drivminkB.a # Dynamic mixed subdivisions : fac_util: ada.lib commfaces.a commfacesB.a enumfaces.a enumfacesB.a $(compile) commfaces.a commfacesB.a enumfaces.a enumfacesB.a initmice: ada.lib freqgraph.a freqgraphB.a initmice.a initmiceB.a $(compile) freqgraph.a freqgraphB.a initmice.a initmiceB.a unfolding: flatmisu unfolding.a unfoldingB.a triamisu.a triamisuB.a $(compile) unfolding.a unfoldingB.a triamisu.a triamisuB.a dymisudi: dyntri fac_util initmice unfolding dymisudi.a dymisudiB.a $(compile) dymisudi.a dymisudiB.a dynpolco: dymisudi dynpolco.a dynpolcoB.a $(compile) dynpolco.a dynpolcoB.a # The drivers : drivdynl: minkpoly dynpolco drivdynl.a drivdynlB.a $(compile) drivdynl.a drivdynlB.a blackmvc: dynpolco dbkkcomp.a dbkkcompB.a blackmvc.a blackmvcB.a ada dbkkcomp.a dbkkcompB.a $(compile) blackmvc.a blackmvcB.a babldmvc: blackmvc babldmvc.a babldmvcB.a $(compile) babldmvc.a babldmvcB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Implift' then mkdir 'Implift' fi cd 'Implift' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: drivimpl climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../../Math_Lib/Numbers a.path -a ../../Math_Lib/Matrices a.path -a ../../Math_Lib/Polynomials a.path -a ../../Math_Lib/Supports a.path -a ../../Homotopy a.path -a ../../Continuation a.path -a ../Product # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Root_Counts/Implift links: @-ln -s $(linkrc)/transfo.a transfo.a @-ln -s $(linkrc)/transfoB.a transfoB.a @-ln -s $(linkrc)/transfo_io.a transfo_io.a @-ln -s $(linkrc)/transfo_ioB.a transfo_ioB.a @-ln -s $(linkrc)/intvec_ut.a intvec_ut.a @-ln -s $(linkrc)/intvec_utB.a intvec_utB.a @-ln -s $(linkrc)/lstivc_ut.a lstivc_ut.a @-ln -s $(linkrc)/lstivc_utB.a lstivc_utB.a @-ln -s $(linkrc)/arrlivc_ut.a arrlivc_ut.a @-ln -s $(linkrc)/arrlivc_utB.a arrlivc_utB.a @-ln -s $(linkrc)/transols.a transols.a @-ln -s $(linkrc)/transolsB.a transolsB.a @-ln -s $(linkrc)/tranlaur.a tranlaur.a @-ln -s $(linkrc)/tranlaurB.a tranlaurB.a @-ln -s $(linkrc)/tranlists.a tranlists.a @-ln -s $(linkrc)/tranlistsB.a tranlistsB.a @-ln -s $(linkrc)/binom.a binom.a @-ln -s $(linkrc)/binomB.a binomB.a @-ln -s $(linkrc)/fewnom.a fewnom.a @-ln -s $(linkrc)/fewnomB.a fewnomB.a @-ln -s $(linkrc)/tv.a tv.a @-ln -s $(linkrc)/tvB.a tvB.a @-ln -s $(linkrc)/tv_io.a tv_io.a @-ln -s $(linkrc)/tv_ioB.a tv_ioB.a @-ln -s $(linkrc)/powlis.a powlis.a @-ln -s $(linkrc)/powlisB.a powlisB.a @-ln -s $(linkrc)/durker.a durker.a @-ln -s $(linkrc)/durkerB.a durkerB.a @-ln -s $(linkrc)/mihoco.a mihoco.a @-ln -s $(linkrc)/mihocoB.a mihocoB.a @-ln -s $(linkrc)/facenusu.a facenusu.a @-ln -s $(linkrc)/facenusuB.a facenusuB.a @-ln -s $(linkrc)/volumes.a volumes.a @-ln -s $(linkrc)/volumesB.a volumesB.a @-ln -s $(linkrc)/vertices.a vertices.a @-ln -s $(linkrc)/verticesB.a verticesB.a @-ln -s $(linkrc)/setsvol.a setsvol.a @-ln -s $(linkrc)/setsvolB.a setsvolB.a @-ln -s $(linkrc)/genpos.a genpos.a @-ln -s $(linkrc)/genposB.a genposB.a @-ln -s $(linkrc)/drivpts.a drivpts.a @-ln -s $(linkrc)/drivptsB.a drivptsB.a @-ln -s $(linkrc)/drivplc.a drivplc.a @-ln -s $(linkrc)/drivplcB.a drivplcB.a @-ln -s $(linkrc)/drivimpl.a drivimpl.a @-ln -s $(linkrc)/drivimplB.a drivimplB.a # Unimodular transformations : transfo: ada.lib transfo.a transfoB.a transfo_io.a transfo_ioB.a $(compile) transfo.a transfoB.a transfo_io.a transfo_ioB.a intvec_ut: transfo intvec_ut.a intvec_utB.a $(compile) intvec_ut.a intvec_utB.a tranlists: intvec_ut tranlists.a tranlistsB.a $(compile) tranlists.a tranlistsB.a transform: tranlists transols.a transolsB.a tranlaur.a tranlaurB.a $(compile) transols.a transolsB.a tranlaur.a tranlaurB.a # Utilities for lists of integer vectors : lstivc_ut: intvec_ut lstivc_ut.a lstivc_utB.a $(compile) lstivc_ut.a lstivc_utB.a arrlivc_ut: transform lstivc_ut arrlivc_ut.a arrlivc_utB.a $(compile) arrlivc_ut.a arrlivc_utB.a # solving binomial and fewnomial systems : bi: ada.lib transform binom.a binomB.a $(compile) binom.a binomB.a few: bi fewnom.a fewnomB.a $(compile) fewnom.a fewnomB.a # auxiliairy data structure : tv: ada.lib tv.a tvB.a tv_io.a tv_ioB.a $(compile) tv.a tvB.a tv_io.a tv_ioB.a # computing volumes and mixed volumes : vol: arrlivc_ut tv facenusu.a facenusuB.a volumes.a volumesB.a $(compile) facenusu.a facenusuB.a volumes.a volumesB.a # constructing support sets powlis: ada.lib powlis.a powlisB.a $(compile) powlis.a powlisB.a # The method of Durand-Kerner : durker: ada.lib durker.a durkerB.a $(compile) durker.a durkerB.a # mixed homotopy continuation : mihoco: few vol powlis durker mihoco.a mihocoB.a $(compile) mihoco.a mihocoB.a # extracting the vertices : vertices: ada.lib vertices.a verticesB.a drivpts.a drivptsB.a $(compile) vertices.a verticesB.a drivpts.a drivptsB.a # checking generic position : genpos: powlis tv genpos.a genposB.a $(compile) genpos.a genposB.a # an interactive driver for computing the BKK bound and for # constructing a random coefficient start system : drivplc: ada.lib drivplc.a drivplcB.a $(compile) drivplc.a drivplcB.a setsvol: mihoco vol setsvol.a setsvolB.a $(compile) setsvol.a setsvolB.a drivimpl: setsvol vertices genpos drivplc drivimpl.a drivimplB.a $(compile) drivimpl.a drivimplB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Product' then mkdir 'Product' fi cd 'Product' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: startsys drivmhom drivmuho drivss climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks # WARNING : Optimizer produces wrong results with enumeration strategy # in the package m_Homogeneous_Bezout_Numbers! normal= optim= -O suppress= -O -S options=$(normal) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../../Math_Lib/Numbers a.path -a ../../Math_Lib/Matrices a.path -a ../../Math_Lib/Polynomials a.path -a ../../Math_Lib/Supports a.path -a ../../Homotopy # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Root_Counts/Product links: @-ln -s $(linkrc)/startsys.a startsys.a @-ln -s $(linkrc)/startsysB.a startsysB.a @-ln -s $(linkrc)/sets.a sets.a @-ln -s $(linkrc)/setsB.a setsB.a @-ln -s $(linkrc)/sets_io.a sets_io.a @-ln -s $(linkrc)/sets_ioB.a sets_ioB.a @-ln -s $(linkrc)/partsets.a partsets.a @-ln -s $(linkrc)/partsetsB.a partsetsB.a @-ln -s $(linkrc)/partsets_io.a partsets_io.a @-ln -s $(linkrc)/partsets_ioB.a partsets_ioB.a @-ln -s $(linkrc)/degsets.a degsets.a @-ln -s $(linkrc)/degsetsB.a degsetsB.a @-ln -s $(linkrc)/mhombez.a mhombez.a @-ln -s $(linkrc)/mhombezB.a mhombezB.a @-ln -s $(linkrc)/mhomstart.a mhomstart.a @-ln -s $(linkrc)/mhomstartB.a mhomstartB.a @-ln -s $(linkrc)/generate.a generate.a @-ln -s $(linkrc)/generateB.a generateB.a @-ln -s $(linkrc)/intehom.a intehom.a @-ln -s $(linkrc)/intehomB.a intehomB.a @-ln -s $(linkrc)/drivinho.a drivinho.a @-ln -s $(linkrc)/drivinhoB.a drivinhoB.a @-ln -s $(linkrc)/drivmhom.a drivmhom.a @-ln -s $(linkrc)/drivmhomB.a drivmhomB.a @-ln -s $(linkrc)/rps.a rps.a @-ln -s $(linkrc)/rpsB.a rpsB.a @-ln -s $(linkrc)/rps_io.a rps_io.a @-ln -s $(linkrc)/rps_ioB.a rps_ioB.a @-ln -s $(linkrc)/rpss.a rpss.a @-ln -s $(linkrc)/rpssB.a rpssB.a @-ln -s $(linkrc)/ds.a ds.a @-ln -s $(linkrc)/dsB.a dsB.a @-ln -s $(linkrc)/drivmuho.a drivmuho.a @-ln -s $(linkrc)/drivmuhoB.a drivmuhoB.a @-ln -s $(linkrc)/ss.a ss.a @-ln -s $(linkrc)/ssB.a ssB.a @-ln -s $(linkrc)/ss_io.a ss_io.a @-ln -s $(linkrc)/ss_ioB.a ss_ioB.a @-ln -s $(linkrc)/crpss.a crpss.a @-ln -s $(linkrc)/crpssB.a crpssB.a @-ln -s $(linkrc)/persets.a persets.a @-ln -s $(linkrc)/persetsB.a persetsB.a @-ln -s $(linkrc)/drivss.a drivss.a @-ln -s $(linkrc)/drivssB.a drivssB.a # Start systems based on the total degree : startsys: ada.lib startsys.a startsysB.a $(compile) startsys.a startsysB.a # Sets of unknowns : sets: ada.lib sets.a setsB.a sets_io.a sets_ioB.a $(compile) sets.a setsB.a sets_io.a sets_ioB.a partsets: sets partsets.a partsetsB.a partsets_io.a partsets_ioB.a $(compile) partsets.a partsetsB.a partsets_io.a partsets_ioB.a degsets: partsets degsets.a degsetsB.a generate.a generateB.a $(compile) degsets.a degsetsB.a generate.a generateB.a # Random product systems : rps: ada.lib rps.a rpsB.a rps_io.a rps_ioB.a $(compile) rps.a rpsB.a rps_io.a rps_ioB.a # m-homogenization (interpolating and linear-product start systems) : mhom: degsets mhombez.a mhombezB.a rps mhomstart.a mhomstartB.a $(compile) mhombez.a mhombezB.a $(compile) mhomstart.a mhomstartB.a intehom: degsets intehom.a intehomB.a drivinho.a drivinhoB.a $(compile) intehom.a intehomB.a drivinho.a drivinhoB.a drivmhom: mhom intehom drivmhom.a drivmhomB.a $(compile) drivmhom.a drivmhomB.a # Projective transformations: mprojtrans: sets mprojtrans.a mprojtransB.a $(compile) mprojtrans.a mprojtransB.a # multi-homogenization (the GBQ-Algorithm) : muho: degsets ds.a dsB.a rps rpss.a rpssB.a $(compile) ds.a dsB.a $(compile) rpss.a rpssB.a drivmuho: muho drivmuho.a drivmuhoB.a $(compile) drivmuho.a drivmuhoB.a # set-structure analysis (Symbolic Homotopy Construction) : ss: degsets ss.a ssB.a ss_io.a ss_ioB.a rps crpss.a crpssB.a $(compile) ss.a ssB.a ss_io.a ss_ioB.a crpss.a crpssB.a drivss: ss persets.a persetsB.a drivss.a drivssB.a $(compile) persets.a persetsB.a drivss.a drivssB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Stalift' then mkdir 'Stalift' fi cd 'Stalift' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: bkkcomp drivstal climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../../Math_Lib/Numbers a.path -a ../../Math_Lib/Matrices a.path -a ../../Math_Lib/Polynomials a.path -a ../../Math_Lib/Supports a.path -a ../../Homotopy a.path -a ../../Continuation a.path -a ../Product a.path -a ../Implift # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Root_Counts/Stalift links: @-ln -s $(linkrc)/intlift.a intlift.a @-ln -s $(linkrc)/intliftB.a intliftB.a @-ln -s $(linkrc)/intlift_ut.a intlift_ut.a @-ln -s $(linkrc)/intlift_utB.a intlift_utB.a @-ln -s $(linkrc)/intmisu.a intmisu.a @-ln -s $(linkrc)/intmisuB.a intmisuB.a @-ln -s $(linkrc)/intmisu_io.a intmisu_io.a @-ln -s $(linkrc)/intmisu_ioB.a intmisu_ioB.a @-ln -s $(linkrc)/intprune.a intprune.a @-ln -s $(linkrc)/intpruneB.a intpruneB.a @-ln -s $(linkrc)/comisudi.a comisudi.a @-ln -s $(linkrc)/comisudiB.a comisudiB.a @-ln -s $(linkrc)/mivoco.a mivoco.a @-ln -s $(linkrc)/mivocoB.a mivocoB.a @-ln -s $(linkrc)/intpolco.a intpolco.a @-ln -s $(linkrc)/intpolcoB.a intpolcoB.a @-ln -s $(linkrc)/bkkcomp.a bkkcomp.a @-ln -s $(linkrc)/bkkcompB.a bkkcompB.a @-ln -s $(linkrc)/fltmisu.a fltmisu.a @-ln -s $(linkrc)/fltmisuB.a fltmisuB.a @-ln -s $(linkrc)/fltmisu_io.a fltmisu_io.a @-ln -s $(linkrc)/fltmisu_ioB.a fltmisu_ioB.a @-ln -s $(linkrc)/fltpolco.a fltpolco.a @-ln -s $(linkrc)/fltpolcoB.a fltpolcoB.a @-ln -s $(linkrc)/fltlift.a fltlift.a @-ln -s $(linkrc)/fltliftB.a fltliftB.a @-ln -s $(linkrc)/fltlift_ut.a fltlift_ut.a @-ln -s $(linkrc)/fltlift_utB.a fltlift_utB.a @-ln -s $(linkrc)/fltprune.a fltprune.a @-ln -s $(linkrc)/fltpruneB.a fltpruneB.a @-ln -s $(linkrc)/cofltint.a cofltint.a @-ln -s $(linkrc)/cofltintB.a cofltintB.a @-ln -s $(linkrc)/inncones.a inncones.a @-ln -s $(linkrc)/innconesB.a innconesB.a @-ln -s $(linkrc)/noconint.a noconint.a @-ln -s $(linkrc)/noconintB.a noconintB.a @-ln -s $(linkrc)/contrimv.a contrimv.a @-ln -s $(linkrc)/contrimvB.a contrimvB.a @-ln -s $(linkrc)/drivcomv.a drivcomv.a @-ln -s $(linkrc)/drivcomvB.a drivcomvB.a @-ln -s $(linkrc)/drivcrit.a drivcrit.a @-ln -s $(linkrc)/drivcritB.a drivcritB.a @-ln -s $(linkrc)/drivlift.a drivlift.a @-ln -s $(linkrc)/drivliftB.a drivliftB.a @-ln -s $(linkrc)/prunstat.a prunstat.a @-ln -s $(linkrc)/prunstatB.a prunstatB.a @-ln -s $(linkrc)/drivstal.a drivstal.a @-ln -s $(linkrc)/drivstalB.a drivstalB.a # Integer regular mixed subdivisions : lift: ada.lib intlift.a intliftB.a $(compile) intlift.a intliftB.a misudi: ada.lib intmisu.a mivoco.a intmisuB.a intmisu_io.a intmisu_ioB.a $(compile) intmisu.a mivoco.a intmisuB.a $(compile) intmisu_io.a intmisu_ioB.a intlift_ut: misudi lift intlift_ut.a intlift_utB.a $(compile) intlift_ut.a intlift_utB.a comisudi: intlift_ut intprune.a intpruneB.a comisudi.a comisudiB.a $(compile) intprune.a intpruneB.a comisudi.a comisudiB.a # Floating-point regular mixed subdivisions : fltmisu: ada.lib fltmisu.a fltmisuB.a $(compile) fltmisu.a fltmisuB.a fltpolco: fltmisu fltpolco.a fltpolcoB.a $(compile) fltpolco.a fltpolcoB.a fltprune: fltpolco fltprune.a fltpruneB.a fltlift.a fltliftB.a $(compile) fltprune.a fltpruneB.a fltlift.a fltliftB.a cofltint: fltmisu cofltint.a cofltintB.a fltlift_ut.a fltlift_utB.a $(compile) cofltint.a cofltintB.a fltlift_ut.a fltlift_utB.a fltmisu_io: cofltint fltmisu_io.a fltmisu_ioB.a $(compile) fltmisu_io.a fltmisu_ioB.a drivlift: fltmisu_io fltprune drivlift.a drivliftB.a $(compile) drivlift.a drivliftB.a # Computing the mixed volume, based on a coherent mixed subdivision : mixvol: comisudi mixvol.a $(compile) mixvol.a @-make climp a.ld -o /tmp/mixvol mixed_volume mivoco: comisudi misudi mivocoB.a $(compile) mivocoB.a # Polyhedral homotopy continuation : intpolco: misudi bkkcomp.a intpolco.a intpolcoB.a $(compile) bkkcomp.a $(compile) intpolco.a intpolcoB.a # Black box routines for computing BKK bound : bkkcomp: mivoco intpolco bkkcompB.a ada bkkcompB.a # note that optimization for bkkcompB.a causes an assertion_error # Computing zero contributions and essential sets : norcones: ada.lib inncones.a innconesB.a noconint.a noconintB.a $(compile) inncones.a innconesB.a noconint.a noconintB.a drivcomv: norcones contrimv.a contrimvB.a drivcomv.a drivcomvB.a $(compile) contrimv.a contrimvB.a drivcomv.a drivcomvB.a drivcrit: drivcomv drivcrit.a drivcritB.a $(compile) drivcrit.a drivcritB.a # Drivers for constructing a regular mixed subdivision : prunstat: ada.lib prunstat.a prunstatB.a $(compile) prunstat.a prunstatB.a drivstal: intlift_ut bkkcomp drivcrit prunstat drivlift drivstal.a drivstalB.a $(compile) drivstal.a drivstalB.a SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Symmetry' then mkdir 'Symmetry' fi cd 'Symmetry' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: drivsss drivsyml climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # compile=a.make $(makeoptions) # NOTE : # drivgrp_io raises exceptions when optimized # Making an Ada library : ada.lib: @-../../makelib a.path -a ../../System a.path -a ../../Math_Lib/Numbers a.path -a ../../Math_Lib/Matrices a.path -a ../../Math_Lib/Polynomials a.path -a ../../Math_Lib/Supports a.path -a ../../Homotopy a.path -a ../../Continuation a.path -a ../Product a.path -a ../Implift a.path -a ../Stalift a.path -a ../Dynlift # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # Establishing the links : linkrc = ../../../Root_Counts/Symmetry links: @-ln -s $(linkrc)/perms.a perms.a @-ln -s $(linkrc)/permsB.a permsB.a @-ln -s $(linkrc)/permops.a permops.a @-ln -s $(linkrc)/permopsB.a permopsB.a @-ln -s $(linkrc)/templates.a templates.a @-ln -s $(linkrc)/templatesB.a templatesB.a @-ln -s $(linkrc)/symgrp.a symgrp.a @-ln -s $(linkrc)/symgrpB.a symgrpB.a @-ln -s $(linkrc)/symgrp_io.a symgrp_io.a @-ln -s $(linkrc)/symgrp_ioB.a symgrp_ioB.a @-ln -s $(linkrc)/sbsymgrp_io.a sbsymgrp_io.a @-ln -s $(linkrc)/sbsymgrp_ioB.a sbsymgrp_ioB.a @-ln -s $(linkrc)/orbits.a orbits.a @-ln -s $(linkrc)/orbitsB.a orbitsB.a @-ln -s $(linkrc)/orbits_io.a orbits_io.a @-ln -s $(linkrc)/orbits_ioB.a orbits_ioB.a @-ln -s $(linkrc)/equpsys.a equpsys.a @-ln -s $(linkrc)/equpsysB.a equpsysB.a @-ln -s $(linkrc)/sym_ss.a sym_ss.a @-ln -s $(linkrc)/sym_ssB.a sym_ssB.a @-ln -s $(linkrc)/lsymred.a lsymred.a @-ln -s $(linkrc)/lsymredB.a lsymredB.a @-ln -s $(linkrc)/drivgrp_io.a drivgrp_io.a @-ln -s $(linkrc)/drivgrp_ioB.a drivgrp_ioB.a @-ln -s $(linkrc)/drivorbi.a drivorbi.a @-ln -s $(linkrc)/drivorbiB.a drivorbiB.a @-ln -s $(linkrc)/drivsss.a drivsss.a @-ln -s $(linkrc)/drivsssB.a drivsssB.a @-ln -s $(linkrc)/symlift.a symlift.a @-ln -s $(linkrc)/symliftB.a symliftB.a @-ln -s $(linkrc)/symrand.a symrand.a @-ln -s $(linkrc)/symrandB.a symrandB.a @-ln -s $(linkrc)/symbkk.a symbkk.a @-ln -s $(linkrc)/symbkkB.a symbkkB.a @-ln -s $(linkrc)/sympolco.a sympolco.a @-ln -s $(linkrc)/sympolcoB.a sympolcoB.a @-ln -s $(linkrc)/faceperm.a faceperm.a @-ln -s $(linkrc)/facepermB.a facepermB.a @-ln -s $(linkrc)/facesypo.a facesypo.a @-ln -s $(linkrc)/facesypoB.a facesypoB.a @-ln -s $(linkrc)/gencells.a gencells.a @-ln -s $(linkrc)/gencellsB.a gencellsB.a @-ln -s $(linkrc)/drivsyml.a drivsyml.a @-ln -s $(linkrc)/drivsymlB.a drivsymlB.a @-ln -s $(linkrc)/mainsmvc.a mainsmvc.a @-ln -s $(linkrc)/mainsmvcB.a mainsmvcB.a # Working with permutation groups : perms: ada.lib perms.a permsB.a $(compile) perms.a permsB.a symgrp: perms symgrp.a symgrpB.a symgrp_io.a symgrp_ioB.a $(compile) symgrp.a symgrpB.a symgrp_io.a symgrp_ioB.a sbsymgrp_io: symgrp sbsymgrp_io.a sbsymgrp_ioB.a ada sbsymgrp_io.a sbsymgrp_ioB.a drivgrp_io: sbsymgrp_io drivgrp_io.a drivgrp_ioB.a ada drivgrp_io.a drivgrp_ioB.a # Applying the symmetry : permops: symgrp permops.a permopsB.a $(compile) permops.a permopsB.a orbits: permops orbits.a orbitsB.a orbits_io.a orbits_ioB.a $(compile) orbits.a orbitsB.a orbits_io.a orbits_ioB.a drivorbi: orbits drivorbi.a drivorbiB.a $(compile) drivorbi.a drivorbiB.a equpsys: permops equpsys.a equpsysB.a $(compile) equpsys.a equpsysB.a # Symmetric set structure analysis : sym_ss: permops templates.a templatesB.a sym_ss.a sym_ssB.a $(compile) templates.a templatesB.a $(compile) sym_ss.a sym_ssB.a lsymred: permops lsymred.a lsymredB.a $(compile) lsymred.a lsymredB.a # The interactive driver needed in the main program : drivsss: drivgrp_io sym_ss lsymred drivorbi equpsys drivsss.a drivsssB.a $(compile) drivsss.a drivsssB.a # Symmetric lifting algorithm : symlift: ada.lib symlift.a symliftB.a $(compile) symlift.a symliftB.a sympolco: ada.lib symbkk.a sympolco.a sympolcoB.a $(compile) symbkk.a sympolco.a sympolcoB.a symbkk: symlift sympolco symbkk.a symbkkB.a ada symbkkB.a # Symmetric randomize : symrand: ada.lib symrand.a symrandB.a $(compile) symrand.a symrandB.a # Computing the mixed volume, based on a symmetric subdivision : facesypo: ada.lib faceperm.a facepermB.a facesypo.a facesypoB.a $(compile) faceperm.a facepermB.a facesypo.a facesypoB.a gencells: facesypo gencells.a gencellsB.a $(compile) gencells.a gencellsB.a drivsyml: symrand gencells symbkk drivsyml.a drivsymlB.a mainsmvc.a mainsmvcB.a $(compile) drivsyml.a drivsymlB.a mainsmvc.a mainsmvcB.a SHAR_EOF fi # end of overwriting check cd .. if test -f 'makeall' then echo shar: will not over-write existing file "'makeall'" else cat << "SHAR_EOF" > 'makeall' echo '**** Making the Product Library ****' cd Product make echo '**** Making the Implift Library ****' cd ../Implift make echo '**** Making the Stalift Library ****' cd ../Stalift make echo '**** Making the Dynlift Library ****' cd ../Dynlift make echo '**** Making the Symmetry Library ****' cd ../Symmetry make cd .. SHAR_EOF fi # end of overwriting check if test -f 'makeclean' then echo shar: will not over-write existing file "'makeclean'" else cat << "SHAR_EOF" > 'makeclean' echo '**** Cleaning the Symmetry Library ****' cd Symmetry make clean echo '**** Cleaning the Dynlift Library ****' cd ../Dynlift make clean echo '**** Cleaning the Stalift Library ****' cd ../Stalift make clean echo '**** Cleaning the Implift Library ****' cd ../Implift make clean echo '**** Cleaning the Product Library ****' cd ../Product make clean cd .. SHAR_EOF fi # end of overwriting check if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' # Making the library with the root counts: all: @-./makeall clean: @-./makeclean SHAR_EOF fi # end of overwriting check if test -f 'makelog' then echo shar: will not over-write existing file "'makelog'" else cat << "SHAR_EOF" > 'makelog' **** Making the directory Bezout **** ada -O -S startsys.a startsysB.a startsys.a: startsysB.a: ada -O -S sets.a setsB.a sets_io.a sets_ioB.a sets.a: setsB.a: sets_io.a: sets_ioB.a: ada -O -S partsets.a partsetsB.a partsets_io.a partsets_ioB.a partsets.a: partsetsB.a: partsets_io.a: partsets_ioB.a: ada -O -S degsets.a degsetsB.a degsets.a: degsetsB.a: ada -O -S lstivc.a lstivcB.a lstivc_io.a lstivc_ioB.a lstivc.a: lstivcB.a: lstivc_io.a: lstivc_ioB.a: ada -O -S rps.a rpsB.a rps_io.a rps_ioB.a rps.a: rpsB.a: rps_io.a: rps_ioB.a: ada -O -S mhombez.a mhombezB.a mhombez.a: mhombezB.a: ada -O -S mhomstart.a mhomstartB.a mhomstart.a: mhomstartB.a: ada -O -S intehom.a intehomB.a drivinho.a drivinhoB.a intehom.a: intehomB.a: drivinho.a: drivinhoB.a: ada -O -S drivmhom.a drivmhomB.a drivmhom.a: drivmhomB.a: ada -O -S ds.a dsB.a ds.a: dsB.a: ada -O -S rpss.a rpssB.a rpss.a: rpssB.a: ada -O -S drivmuho.a drivmuhoB.a drivmuho.a: drivmuhoB.a: ada -O -S ss.a ssB.a ss_io.a ss_ioB.a crpss.a crpssB.a ss.a: ssB.a: ss_io.a: ss_ioB.a: crpss.a: crpssB.a: ada -O -S persets.a persetsB.a drivss.a drivssB.a persets.a: persetsB.a: drivss.a: drivssB.a: **** Making the directory BKK **** ada -O -S arrlivc.a arrlivcB.a arrlivc_io.a arrlivc_ioB.a arrlivc.a: arrlivcB.a: arrlivc_io.a: arrlivc_ioB.a: ada -O -S transfo.a transfoB.a transfo_io.a transfo_ioB.a transfo.a: transfoB.a: transfo_io.a: transfo_ioB.a: ada -O -S intvec_ut.a intvec_utB.a intvec_ut.a: intvec_utB.a: ada -O -S lstivc_ut.a lstivc_utB.a lstivc_ut.a: lstivc_utB.a: ada -O -S arrlivc_ut.a arrlivc_utB.a arrlivc_ut.a: arrlivc_utB.a: ada -O -S tv.a tvB.a tv_io.a tv_ioB.a tv.a: tvB.a: tv_io.a: tv_ioB.a: ada -O -S facenusu.a facenusuB.a volumes.a volumesB.a facenusu.a: facenusuB.a: volumes.a: volumesB.a: ada -O -S transols.a transolsB.a tranlaur.a tranlaurB.a transols.a: transolsB.a: tranlaur.a: tranlaurB.a: ada -O -S binom.a binomB.a binom.a: binomB.a: ada -O -S fewnom.a fewnomB.a fewnom.a: fewnomB.a: ada -O -S durker.a durkerB.a durker.a: durkerB.a: ada -O -S mixcont.a mixcontB.a mixcont.a: mixcontB.a: ada -O -S powlis.a powlisB.a powlis.a: powlisB.a: ada -O -S mihoco.a mihocoB.a mihoco.a: mihocoB.a: ada -O -S vertices.a verticesB.a drivpts.a drivptsB.a vertices.a: verticesB.a: drivpts.a: drivptsB.a: ada -O -S setsvol.a setsvolB.a setsvol.a: setsvolB.a: ada -O -S drivmibb.a drivmibbB.a drivmibb.a: drivmibbB.a: ada -O -S lattipts.a lattiptsB.a lattspar.a lattsparB.a lattipts.a: lattiptsB.a: lattspar.a: lattsparB.a: **** Making the directory MVC **** ada -O -S subdiv.a subdivB.a subdiv.a: subdivB.a: ada -O -S subdiv_io.a subdiv_ioB.a subdiv_io.a: subdiv_ioB.a: ada -O -S int_rand.a int_randB.a int_rand.a: int_randB.a: ada -O -S lift.a liftB.a lift.a: liftB.a: ada -O -S cosubdiv.a cosubdivB.a cosubdiv.a: cosubdivB.a: ada -O -S faces.a facesB.a faces_io.a faces_ioB.a faces.a: facesB.a: faces_io.a: faces_ioB.a: ada -O -S misudi.a misudiB.a misudi.a: misudiB.a: ada -O -S mivoco.a ada -O -S misudi_io.a misudi_ioB.a misudi_io.a: misudi_ioB.a: ada -O -S lift_ut.a lift_utB.a lift_ut.a: lift_utB.a: ada -O -S liftfaces.a liftfacesB.a liftfaces.a: liftfacesB.a: ada -O -S statlift.a statliftB.a comisudi.a comisudiB.a statlift.a: statliftB.a: comisudi.a: comisudiB.a: ada -O -S mivocoB.a ada -O -S bkkcomp.a ada -O -S polyhoco.a polyhocoB.a polyhoco.a: polyhocoB.a: ada -O -S bkkcompB.a ada -O -S connect.a connectB.a drivconn.a drivconnB.a connect.a: connectB.a: drivconn.a: drivconnB.a: ada -O -S drivmvc.a drivmvcB.a drivmvc.a: drivmvcB.a: **** Making the directory DMVC **** ada -O -S simplex.a simplexB.a simplex_io.a simplex_ioB.a simplex.a: simplexB.a: simplex_io.a: simplex_ioB.a: ada -O -S triangle.a triangleB.a triangle_io.a triangle_ioB.a triangle.a: triangleB.a: triangle_io.a: triangle_ioB.a: ada -O -S glodyntri.a glodyntriB.a dynlift.a dynliftB.a glodyntri.a: glodyntriB.a: dynlift.a: dynliftB.a: ada -O -S dyntri.a dyntriB.a dyntri.a: dyntriB.a: ada -O -S cayuti.a cayutiB.a cayley.a cayleyB.a cayuti.a: cayutiB.a: cayley.a: cayleyB.a: ada -O -S commfaces.a commfacesB.a enumfaces.a enumfacesB.a commfaces.a: commfacesB.a: enumfaces.a: enumfacesB.a: ada -O -S freqgraph.a freqgraphB.a initmice.a initmiceB.a freqgraph.a: freqgraphB.a: initmice.a: initmiceB.a: ada -O -S flatmisu.a flatmisuB.a flatmisu.a: flatmisuB.a: ada -O -S unfolding.a unfoldingB.a unfolding.a: unfoldingB.a: ada -O -S dymisudi.a dymisudiB.a dymisudi.a: dymisudiB.a: ada -O -S dypolhoc.a dypolhocB.a dypolhoc.a: dypolhocB.a: ada -O -S drivdmvc.a drivdmvcB.a maindmvc.a maindmvcB.a drivdmvc.a: drivdmvcB.a: maindmvc.a: maindmvcB.a: ada -O -S dbkkcomp.a dbkkcompB.a batchmvc.a batchmvcB.a dbkkcomp.a: dbkkcompB.a: batchmvc.a: batchmvcB.a: ada -O -S babldmvc.a babldmvcB.a babldmvc.a: babldmvcB.a: SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'System' then mkdir 'System' fi cd 'System' if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' all: cmdline timing byemess communication file_ops climp # possible options for the compiler (normal,optim,suppress): # normal : without optimizations # optim : optimize as far as possible # suppress : same as optim, but with the suppression of all checks normal= optim= -O suppress= -O -S options=$(suppress) makeoptions=$(options) -v -f # compiling command : # ada : compile the file # a.make : verifies dependencies before compiling compile=ada $(options) # Making an Ada library : ada.lib: @-../makelib # Cleaning the Ada library : clean: a.rmlib -f # Cleaning the .imports directory : climp: @-rm -f .imports/* # command line package : cmdline: ada.lib ucmdline.a ucmdlineB.a $(compile) ucmdline.a ucmdlineB.a # The timing package : timing: ada.lib rusage.a rusageB.a timing.a timingB.a $(compile) rusage.a rusageB.a timing.a timingB.a # System calls : machines: ada.lib system_call.a system_callB.a machines.a machinesB.a $(compile) system_call.a system_callB.a $(compile) machines.a machinesB.a byemess: machines byemess.a byemessB.a $(compile) byemess.a byemessB.a # Communications with user : communication: ada.lib commuser.a commuserB.a $(compile) commuser.a commuserB.a # file operations : file_ops: ada.lib file_ops.a file_opsB.a $(compile) file_ops.a file_opsB.a # Making the links with the original sources : linkrc = ../../System links: @-ln -s $(linkrc)/byemess.a byemess.a @-ln -s $(linkrc)/byemessB.a byemessB.a @-ln -s $(linkrc)/commuser.a commuser.a @-ln -s $(linkrc)/commuserB.a commuserB.a @-ln -s $(linkrc)/rusage.a rusage.a @-ln -s $(linkrc)/rusageB.a rusageB.a @-ln -s $(linkrc)/timing.a timing.a @-ln -s $(linkrc)/timingB.a timingB.a @-ln -s $(linkrc)/ucmdline.a ucmdline.a @-ln -s $(linkrc)/ucmdlineB.a ucmdlineB.a @-ln -s $(linkrc)/system_call.a system_call.a @-ln -s $(linkrc)/system_callB.a system_callB.a @-ln -s $(linkrc)/machines.a machines.a @-ln -s $(linkrc)/machinesB.a machinesB.a @-ln -s $(linkrc)/file_ops.a file_ops.a @-ln -s $(linkrc)/file_opsB.a file_opsB.a SHAR_EOF fi # end of overwriting check cd .. if test -f 'makeall' then echo shar: will not over-write existing file "'makeall'" else cat << "SHAR_EOF" > 'makeall' echo '**** Making the System Library ****' cd System make all echo '**** Making the Mathematical Library ****' cd ../Math_Lib make all echo '**** Making the Homotopy Library ****' cd ../Homotopy make all echo '**** Making the Continuation Library ****' cd ../Continuation make all echo '**** Making the Root Count Library ****' cd ../Root_Counts make all echo '**** Making the Main Driver ****' cd ../Main make phc cd .. SHAR_EOF fi # end of overwriting check if test -f 'makeclean' then echo shar: will not over-write existing file "'makeclean'" else cat << "SHAR_EOF" > 'makeclean' echo '**** Cleaning the Main Library ****' cd Main make clean echo '**** Cleaning the Root Count Library ****' cd ../Root_Counts make clean echo '**** Cleaning the Continuation Library ****' cd ../Continuation make clean echo '**** Cleaning the Homotopy Library ****' cd ../Homotopy make clean echo '**** Cleaning the Mathematical Library ****' cd ../Math_Lib make clean echo '**** Cleaning the System Library ****' cd ../System make clean cd .. SHAR_EOF fi # end of overwriting check if test -f 'makefile' then echo shar: will not over-write existing file "'makefile'" else cat << "SHAR_EOF" > 'makefile' # Making the Ada libraries all: @-./makeall # Cleaning all Ada libraries clean: @-./makeclean SHAR_EOF fi # end of overwriting check if test -f 'makelib' then echo shar: will not over-write existing file "'makelib'" else cat << "SHAR_EOF" > 'makelib' #!/bin/csh -f # # Create an ada.lib for VADS compiler with settings of ADAPATH. # # USAGE : remove # for target of interest. # # for SUN/Solaris : # set ADAPATH=/cw/sun5ada/Ada6.2.3-0/self # # for IBM/RS6000 AIX : # set ADAPATH=/disks/zeno/lv02/vads/self # # for DEC/Ultrix : set ADAPATH=/cw/vads.dec/v6.1.0d # a.mklib . $ADAPATH/verdixlib SHAR_EOF fi # end of overwriting check cd .. if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' The Ada sources of PHC are organized in the following tree of directories: Ada : sources of PHC |-- System : 0. UNIX dependencies, e.g.: timing package |-- Math_Lib : 1. general mathematical library | |-- Numbers : 1.1. number representations | |-- Matrices : 1.2. matrices and linear-system solvers | |-- Polynomials : 1.3. multivariate polynomial systems | |-- Supports : 1.4. support sets and linear programming |-- Homotopy : 2. homotopy and solution lists |-- Continuation : 3. path-tracking routines |-- Root_Counts : 4. root counts and homotopy construction | |-- Product : 4.1. linear-product start systems | |-- Implift : 4.2. implicit lifting | |-- Stalift : 4.3. static lifting | |-- Dynlift : 4.4. dynamic lifting | |-- Symmetry : 4.5. exploitation of symmetry relations |-- Main : 5. main dispatcher |-- Objects : 6. to install, type: make all SHAR_EOF fi # end of overwriting check if test ! -d 'Root_Counts' then mkdir 'Root_Counts' fi cd 'Root_Counts' if test ! -d 'Dynlift' then mkdir 'Dynlift' fi cd 'Dynlift' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Mixed-volume computation and polyhedral continuation by dynamic lifting. The aim of dynamic lifting is to control the heights of the lifting values, to obtain a stable evaluation of the polyhedral homotopy. When all supports are equal, then the mixed volume is reduced to an ordinary volume, which is computed by a regular triangulation. 1. Dynamic construction of regular triangulations : simplex Simplices simplex_io Simplices_io triangle Triangulations triangle_io Triangulations_io glodyntri Global_Dynamic_Triangulation dynlift Dynamic_Lifting_Functions dyntri Dynamic_Triangulations 2. The Cayley trick : cayemb Cayley_Embedding cayley Cayley_Trick minkpoly Minkowski_Polynomials drivmink Driver_for_Minkowski_Polynomials 3. Dynamic construction of mixed subdivisions : commfaces Common_Faces_of_Polytope enumfaces Enumerate_Faces_of_Polytope freqgraph Frequency_Graph initmice Initial_Mixed_Cell flatmisu Flatten_Mixed_Subdivisions unfolding Unfolding_Subdivisions triamisu Triangulations_and_Subdivisions dymisudi Dynamic_Mixed_Subdivisions dynpolco Dynamic_Polyhedral_Continuation 4. The drivers and black-box computing : drivdynl Drivers_for_Dynamic_Lifting dbkkcomp Dynamic_BKK_Bound_Computations blackmvc Black_Box_Mixed_Volume_Computations babldmvc babldmvc maindmvc maindmvc SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Implift' then mkdir 'Implift' fi cd 'Implift' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Mixed-volume computation and polyhedral continuation by implicit lifting. This directory contains software for the computation of mixed volumes, according to the recursive formula Bershtein used in his proof. Also the homotopy method of Bernshtein has been implemented. 1. Utilities : arr_livc_ut Arrays_of_Integer_Vector_Lists_Utilities intvec_ut Integer_Vectors_Utilities 2. Computation of the mixed volume : volumes Volumes tv Trees_of_Vectors tv_io Trees_of_Vectors_io 3. Univariate, binomial and fewnomial system solvers : durker Durand_Kerner (procedure) binom Binomials fewnom Fewnomials 4. Transformations, applied to solutions and systems : transfo Transformations transfo_io Transformations_io transols Transforming_Solutions tranlaur Transforming_Laurent_Systems tranlists Transforming_Integer_Vector_Lists 5. Mixed-homotopy continuation : mihoco Mixed_Homotopy_Continuation setsvol Set_Structures_and_Volumes 6. Support sets and vertices of polytopes : powlis Power_Lists vertices Vertices 7. Main drivers : drivpts Driver_for_Vertex_Points drivimpl Drivers_for_Implicit_Lifting SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Product' then mkdir 'Product' fi cd 'Product' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Generalized Bezout numbers and linear-product start systems. Four types of start systems are implemented, based on total degree, m-homogeneous, multi-homegenous, and generalized Bezout number. 1. Total degree startsys Total_Degree_Start_Systems 2. m-homogeneous Bezout number sets Sets_of_Unknowns sets_io Sets_of_Unknowns_io degsets Degrees_In_Sets partsets Partitions_of_Sets_of_Unknowns partsets_io Partitions_of_Sets_of_Unknowns_io mhombez m_Homogeneous_Bezout_Numbers rps Random_Product_System rps_io Random_Product_System_io mhomstart m_Homogeneous_Start_Systems intehom Interpolating_Homotopies drivinho Driver_for_Interpolating_Homotopies drivmhom Drivers_for_m_homogenization 3. multi-homogeneous Bezout number ds Degree_Structure rpss Random_Product_Start_Systems drivmuho Drivers_for_Multi_Homogenization 4. Bezout number based on set structure ss Set_Structure ss_io Set_Structure_io generate Generate persets Degree_Sets_Tables crpss Construct_Random_Product_Start_System drivss Drivers_for_Set_Structures SHAR_EOF fi # end of overwriting check cd .. if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' The root-counting library is organized as follows : Root_Counts : 4. root counts and homotopy construction |-- Product : 4.1. linear-product start systems |-- Implift : 4.2. implicit lifting |-- Stalift : 4.3. static lifting |-- Dynlift : 4.4. dynamic lifting |-- Symmetry : 4.5. exploitation of symmetry relations The root counts that are available in the directory Product are based on Bezout's theorem. The corresponding start systems are in general linear-product systems. Implicit lifting is the name we gave to the algorithm Bernshtein used in his proof that the mixed volume of the Newton polytopes of a polynomial system is a generically exact upper bound on the number of its isolated complex solutions with all components different from zero. Static lifting is the general procedure to compute mixed volumes of polytopes. Subdivisions induced by an integer-valued or floating-point lifting functions can be computed. In order to deal with non-fine subdivisions induced by a nongeneric integer lifting, recursive algorithms have been implemented. Dynamic lifting allows to have a control of the lifting values to obtain a numerically stable polyhedral continuation. When some or all supports are equal, the Cayley trick is recommended to use. The Symmetry library provides routines to construct start systems that are invariant under a given permutation symmetry. Hereby symmetric homotopies can be constructed, so that only the generating solution paths need to be computed. SHAR_EOF fi # end of overwriting check if test ! -d 'Stalift' then mkdir 'Stalift' fi cd 'Stalift' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Mixed-volume computation and polyhedral continuation by static lifting. The algorithm used is based on the construction of a mixed subdivision, based on Betke's formula for mixed volumes and the polyhedral homotopy continuation methods developed by Huber and Sturmfels. This library features integer-valued and floating-point lifting functions. The implementation of integer static lifting typically induces nested subdivisions, with non-fine cells recursively refined by subdivisions. 1. Integer-valued lifting, mixed subdivisions and polyhedral continuation : intlift Integer_Lifting_Functions intlift_ut Integer_Lifting_Utilities intmisu Integer_Mixed_Subdivisions intmisu_io Integer_Mixed_Subdivisions_io comisudi Mixed_Coherent_Subdivisions bkkcomp BKK_Bound_Computations mivoco Mixed_Volume_Computation intprune Integer_Pruning_Methods intpolco Integer_Polyhedral_Continuation 2. Floating-point lifting, mixed subdivisions and polyhedral continuation : cofltint Float_Integer_Convertors fltlift Float_Lifting_Functions fltlift_ut Float_Lifting_Utilities fltmisu Float_Mixed_Subdivisions fltmisu_io Float_Mixed_Subdivisions_io fltprune Float_Pruning_Methods fltpolco Float_Polyhedral_Continuation 3. Influence of points to mixed volume : inncones Inner_Normal_Cones noconint Normal_Cone_Intersections contrimv Contributions_to_Mixed_Volume 4. Driver packages : drivcomv Drivers_for_Mixed_Contributions drivcrit Driver_for_Criterion drivlift Driver_for_Lifting_Functions prunstat Pruning_Statistics drivstal Drivers_for_Static_Lifting SHAR_EOF fi # end of overwriting check cd .. if test ! -d 'Symmetry' then mkdir 'Symmetry' fi cd 'Symmetry' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' Exploitation of permutation symmetry to construct symmetric homotopies. If the polynomial system is invariant under permutations of its unknowns, then it suffices to compute the generators of the solution set. This is accomplished by the construction of a homotopy that has the same symmetric structure as the polynomial system. 1. Permutations, symmetry groups and equivariant systems : perms Permutations permops Permute_Operations symgrp Symmetry_Group symgrp_io Symmetry_Group_io sbsymgrp_io Symbolic_Symmetry_Group_io equpsys Equivariant_Polynomial_Systems 2. Symmetric linear-product start systems with drivers : sym_ss Symmetric_Set_Structure lsymred Linear_Symmetric_Reduce templates Templates orbits Orbits_of_Solutions orbits_io Orbits_of_Solutions_io drivgrp_io Drivers_for_Symmetry_Group_io drivorbi Drivers_for_Orbits_of_Solutions drivsss Driver_for_Symmetric_Set_Structures 3. Data structures for symmetric lifting : faceperm Permutations_of_Faces facesypo Faces_of_Symmetric_Polytopes gencells Generating_Mixed_Cells 4. Symmetric integer and floating-point lifting : symlift Symmetric_Lifting_Functions symrand function Symmetric_Randomize sympolco Symmetric_Polyhedral_Continuation symbkk Symmetric_BBK_Bound_Solvers 5. Drivers and target routine : drivsyml Driver_for_Symmetric_Lifting mainsmvc mainsmvc, as called by phc SHAR_EOF fi # end of overwriting check cd .. cd .. if test ! -d 'System' then mkdir 'System' fi cd 'System' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' UNIX dependent features and general utilities. 1. Command-line arguments, timing and system calls : ucmdline Unix_Command_Line rusage Unix_Resource_Usage timing Timing_Package system_call System_Call machines Machines byemess Bye_Bye_Message 2. Dialogues with user commuser Communications_with_User file_ops File_Operations SHAR_EOF fi # end of overwriting check cd .. cd .. if test ! -d 'Demo' then mkdir 'Demo' fi cd 'Demo' if test -f 'READ_ME' then echo shar: will not over-write existing file "'READ_ME'" else cat << "SHAR_EOF" > 'READ_ME' This directory contains the test database of polynomial systems. Besides the algebraic formulation and a short decription, every file contains various root counts, references and the list of solutions. Below is an overview of the application database. ------------------------------------------------------------------------------ filename : title contains short description of the application ============================================================================== boon : neurofysiology, posted by Sjirk Boon butcher : Butcher's problem, from PoSSo test suite butcher8 : 8-variable version of Butcher's problem camera1s : camera displacement between two positions, scaled 1st frame caprasse : the system caprasse of the PoSSo test suite cassou : the system of Pierrette Cassou-Nogues chemequ : chemical equilibrium of hydrocarbon combustion cohn2 : the system cohn2 from the PoSSo test suite cohn3 : the system cohn3 from the PoSSo test suite comb3000 : Model A combustion chemistry example for a temparature of 3000 deg conform1 : conformal analysis of cyclic molecules, first instance cpdm5 : 5-dimensional system of Caprasse and Demaret cyclic5 : cyclic 5-roots problem cyclic6 : cyclic 6-roots problem cyclic7 : cyclic 7-roots problem cyclic8 : cyclic 8-roots problem d1 : a sparse system, known as benchmark D1 des18_3 : a "dessin d'enfant", called des18_3 des22_24 : a "dessin d'enfant", called des22_24 discret3s : system discret3, every eq