00001
00002 #include <basix/double.hpp>
00003 #include <basix/int.hpp>
00004 #include <basix/vector.hpp>
00005 #include <basix/port.hpp>
00006 #include <basix/literal.hpp>
00007 #include <numerix/integer.hpp>
00008 #include <numerix/modular.hpp>
00009 #include <numerix/modular_integer.hpp>
00010 #include <numerix/rational.hpp>
00011 #include <numerix/floating.hpp>
00012 #include <numerix/complex.hpp>
00013 #include <numerix/complex_double.hpp>
00014 #include <numerix/ball.hpp>
00015 #include <numerix/ball_complex.hpp>
00016 #include <algebramix/vector_unrolled.hpp>
00017 #include <algebramix/vector_simd.hpp>
00018 #include <algebramix/vector_modular.hpp>
00019 #include <analyziz/vector_double.hpp>
00020 #include <analyziz/vector_floating.hpp>
00021 #include <analyziz/vector_ball.hpp>
00022 #include <basix/compound.hpp>
00023 #include <basix/mmx_syntax.hpp>
00024 #include <basix/lisp_syntax.hpp>
00025 #include <basix/cpp_syntax.hpp>
00026 #include <basix/syntactic.hpp>
00027 #include <algebramix/polynomial.hpp>
00028 #include <algebramix/polynomial_polynomial.hpp>
00029 #include <algebramix/polynomial_integer.hpp>
00030 #include <algebramix/polynomial_rational.hpp>
00031 #include <algebramix/polynomial_modular.hpp>
00032 #include <algebramix/polynomial_modular_integer.hpp>
00033 #include <algebramix/polynomial_complex.hpp>
00034 #include <algebramix/polynomial_schonhage.hpp>
00035 #include <analyziz/polynomial_numeric.hpp>
00036 #include <analyziz/polynomial_double.hpp>
00037 #include <analyziz/polynomial_floating.hpp>
00038 #include <analyziz/polynomial_ball.hpp>
00039 #include <analyziz/solver.hpp>
00040 #include <analyziz/solver_aberth.hpp>
00041 #include <analyziz/solver_floating.hpp>
00042 #include <analyziz/solver_ball.hpp>
00043 #include <algebramix/permutation.hpp>
00044 #include <basix/row_tuple.hpp>
00045 #include <algebramix/matrix.hpp>
00046 #include <algebramix/matrix_ring_naive.hpp>
00047 #include <algebramix/matrix_integer.hpp>
00048 #include <algebramix/matrix_modular_integer.hpp>
00049 #include <algebramix/matrix_quotient.hpp>
00050 #include <algebramix/matrix_complex.hpp>
00051 #include <analyziz/matrix_jacobian.hpp>
00052 #include <analyziz/matrix_double.hpp>
00053 #include <analyziz/matrix_floating.hpp>
00054 #include <analyziz/matrix_ball.hpp>
00055 #include <analyziz/matrix_numeric.hpp>
00056 #include <analyziz/eigen.hpp>
00057 #include <analyziz/eigen_homotopy.hpp>
00058 #include <analyziz/eigen_floating.hpp>
00059 #include <analyziz/eigen_ball.hpp>
00060 #include <multimix/multivariate_coordinates.hpp>
00061 #include <multimix/multivariate_monomial.hpp>
00062 #include <multimix/multivariate_polynomial.hpp>
00063 #include <multimix/sparse_polynomial_integer.hpp>
00064 #include <multimix/sparse_polynomial_rational.hpp>
00065 #include <multimix/sparse_polynomial_modular.hpp>
00066 #include <multimix/sparse_polynomial_modular_integer.hpp>
00067 #include <continewz/homotopy_euler.hpp>
00068 #include <continewz/homotopy_floating.hpp>
00069 #include <continewz/homotopy_post_certify.hpp>
00070 #include <basix/routine.hpp>
00071 #include <basix/glue.hpp>
00072
00073 #define int_literal(x) as_int (as_string (x))
00074 #define is_generic_literal is<literal>
00075 #define gen_literal_apply(f,v) gen (as<generic> (f), v)
00076 #define gen_literal_access(f,v) access (as<generic> (f), v)
00077 #define double_literal(x) as_double (as_string (x))
00078 #define is_generic_compound is<compound>
00079 #define compound_arguments(x) cdr (as_vector (x))
00080 #define gen_compound_apply(f,v) gen (as<generic> (f), v)
00081 namespace mmx {
00082 template<typename C> polynomial<C>
00083 polynomial_reverse (const vector<C>& v) {
00084 return polynomial<C> (reverse (v)); }
00085
00086 template<typename C> polynomial<modular<modulus<C>, modular_local> >
00087 as_polynomial_modular (const polynomial<C>& f, const modulus<C>& p) {
00088 modular<modulus<C>, modular_local>::set_modulus (p);
00089 return as<polynomial<modular<modulus<C>, modular_local> > > (f); }
00090
00091 template<typename C> vector<generic>
00092 wrap_subresultants (const polynomial<C>& f, const polynomial<C>& g) {
00093 return as<vector<generic> > (subresultants (f, g)); }
00094
00095 }
00096 namespace mmx { POLYNOMIAL_GENERIC_USES_SCHONHAGE }
00097 #define identity_matrix_integer identity_matrix<integer>
00098 #define hilbert_matrix_rational hilbert_matrix<rational>
00099
00100 namespace mmx {
00101 template<typename C> matrix<C>
00102 matrix_new (const vector<row_tuple<C> >& t) {
00103 if (N(t) == 0) return matrix<C> ();
00104 nat i, j, rows= N(t), cols= N(t[0]);
00105 C dummy= zero_cst<C> ();
00106 matrix<C> r (dummy, rows, cols);
00107 for (i=0; i<rows; i++) {
00108 ASSERT (N(t[i]) == cols, "unequal row lengths");
00109 for (j=0; j<cols; j++)
00110 r(i,j)= t[i][j];
00111 }
00112 return r;
00113 }
00114
00115 template<typename C> matrix<C>
00116 matrix_new (const vector<C>& t) {
00117 nat j, rows= 1, cols= N(t);
00118 C dummy= zero_cst<C> ();
00119 matrix<C> r (dummy, rows, cols);
00120 for (j=0; j<cols; j++)
00121 r(0,j)= t[j];
00122 return r;
00123 }
00124
00125 template<typename C> vector<generic>
00126 wrap_column_reduced_echelon_with_permutation (const matrix<C>& m) {
00127 permutation permut;
00128 generic tp=as<generic> (column_reduced_echelon (m, permut));
00129 return vec (tp, as<generic> (permut));
00130 }
00131
00132 template<typename C> vector<generic>
00133 wrap_column_reduced_echelon_with_transform (const matrix<C>& m) {
00134 matrix<C> k;
00135 generic tp=as<generic> (column_reduced_echelon (m, k));
00136 return vec (tp, as<generic> (k));
00137 }
00138
00139 template<typename C> vector<generic>
00140 wrap_row_reduced_echelon_with_transform (const matrix<C>& m) {
00141 matrix<C> k;
00142 generic tp=as<generic> (row_reduced_echelon (m, k));
00143 return vec (tp, as<generic> (k));
00144 }
00145 }
00146
00147 #define mmx_coordinate multivariate_coordinate<>
00148 #define mmx_coordinates multivariate_coordinates<>
00149 #define mv_monomial multivariate<monomial<> >
00150
00151 #define mv_polynomial(C) multivariate<sparse_polynomial<C> >
00152
00153
00154 namespace mmx {
00155 #define Polynomial \
00156 multivariate<sparse_polynomial<modular<modulus<C>, modular_local> > >
00157 template<typename C> Polynomial
00158 as_mv_polynomial_modular (const mv_polynomial(C)& f, const modulus<C>& p) {
00159 modular<modulus<C>, modular_local>::set_modulus (p);
00160 return as<Polynomial> (f); }
00161 #undef Polynomial
00162 }
00163
00164 namespace mmx {
00165 static vector<integer>
00166 GLUE_1 (const vector<int> &arg_1) {
00167 return as<vector<integer> > (arg_1);
00168 }
00169
00170 static vector<rational>
00171 GLUE_2 (const vector<int> &arg_1) {
00172 return as<vector<rational> > (arg_1);
00173 }
00174
00175 static vector<complex<rational> >
00176 GLUE_3 (const vector<int> &arg_1) {
00177 return as<vector<complex<rational> > > (arg_1);
00178 }
00179
00180 static vector<int>
00181 GLUE_4 (const vector<integer> &arg_1) {
00182 return as<vector<int> > (arg_1);
00183 }
00184
00185 static vector<mmx_ball(mmx_floating, mmx_floating) >
00186 GLUE_5 (const vector<integer> &arg_1) {
00187 return as<vector<mmx_ball(mmx_floating, mmx_floating) > > (arg_1);
00188 }
00189
00190 static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00191 GLUE_6 (const vector<integer> &arg_1) {
00192 return as<vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > > (arg_1);
00193 }
00194
00195 static vector<mmx_ball(mmx_floating, mmx_floating) >
00196 GLUE_7 (const vector<rational> &arg_1) {
00197 return as<vector<mmx_ball(mmx_floating, mmx_floating) > > (arg_1);
00198 }
00199
00200 static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00201 GLUE_8 (const vector<rational> &arg_1) {
00202 return as<vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > > (arg_1);
00203 }
00204
00205 static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00206 GLUE_9 (const vector<complex<rational> > &arg_1) {
00207 return as<vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > > (arg_1);
00208 }
00209
00210 static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00211 GLUE_10 (const vector<mv_polynomial(rational) > &arg_1, const vector<mmx_coordinate> &arg_2, const vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > &arg_3, const mmx_coordinate &arg_4, const mmx_ball(mmx_floating, complex<mmx_floating> ) &arg_5) {
00212 return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00213 }
00214
00215 static vector<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00216 GLUE_11 (const vector<mv_polynomial(rational) > &arg_1, const vector<mmx_coordinate> &arg_2, const vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > &arg_3, const mmx_coordinate &arg_4, const vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > &arg_5) {
00217 return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00218 }
00219
00220 static matrix<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00221 GLUE_12 (const vector<mv_polynomial(rational) > &arg_1, const vector<mmx_coordinate> &arg_2, const matrix<mmx_ball(mmx_floating, complex<mmx_floating> ) > &arg_3, const mmx_coordinate &arg_4, const mmx_ball(mmx_floating, complex<mmx_floating> ) &arg_5) {
00222 return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00223 }
00224
00225 static matrix<mmx_ball(mmx_floating, complex<mmx_floating> ) >
00226 GLUE_13 (const vector<mv_polynomial(rational) > &arg_1, const vector<mmx_coordinate> &arg_2, const matrix<mmx_ball(mmx_floating, complex<mmx_floating> ) > &arg_3, const mmx_coordinate &arg_4, const vector<mmx_ball(mmx_floating, complex<mmx_floating> ) > &arg_5) {
00227 return homotopy (arg_1, arg_2, arg_3, arg_4, arg_5);
00228 }
00229
00230 void
00231 glue_homotopy_ball_floating () {
00232 static bool done = false;
00233 if (done) return;
00234 done = true;
00235 call_glue (string ("glue_matrix_ball_floating"));
00236 call_glue (string ("glue_mvpolynomial_rational"));
00237 define_converter (":>", GLUE_1, PENALTY_INCLUSION);
00238 define_converter (":>", GLUE_2, PENALTY_INCLUSION);
00239 define_converter (":>", GLUE_3, PENALTY_HOMOMORPHISM);
00240 define_converter (":>", GLUE_4, PENALTY_INCLUSION);
00241 define_converter (":>", GLUE_5, PENALTY_INCLUSION);
00242 define_converter (":>", GLUE_6, PENALTY_HOMOMORPHISM);
00243 define_converter (":>", GLUE_7, PENALTY_INCLUSION);
00244 define_converter (":>", GLUE_8, PENALTY_HOMOMORPHISM);
00245 define_converter (":>", GLUE_9, PENALTY_INCLUSION);
00246 define ("homotopy", GLUE_10);
00247 define ("homotopy", GLUE_11);
00248 define ("homotopy", GLUE_12);
00249 define ("homotopy", GLUE_13);
00250 }
00251 }
