glue/glue_matrix_integer.cpp

Go to the documentation of this file.

#include <basix/int.hpp>
#include <basix/vector.hpp>
#include <basix/port.hpp>
#include <basix/literal.hpp>
#include <numerix/integer.hpp>
#include <algebramix/vector_unrolled.hpp>
#include <algebramix/vector_simd.hpp>
#include <algebramix/permutation.hpp>
#include <numerix/modular.hpp>
#include <numerix/modular_integer.hpp>
#include <numerix/rational.hpp>
#include <basix/row_tuple.hpp>
#include <algebramix/matrix.hpp>
#include <algebramix/matrix_ring_naive.hpp>
#include <algebramix/matrix_integer.hpp>
#include <algebramix/matrix_modular_integer.hpp>
#include <algebramix/matrix_quotient.hpp>
#include <basix/tuple.hpp>
#include <basix/alias.hpp>
#include <basix/glue.hpp>

#define int_literal(x) as_int (as_string (x))
#define is_generic_literal is<literal>
#define gen_literal_apply(f,v) gen (as<generic> (f), v)
#define gen_literal_access(f,v) access (as<generic> (f), v)
#define identity_matrix_integer identity_matrix<integer>
#define hilbert_matrix_rational hilbert_matrix<rational>

namespace mmx {
  template<typename C> matrix<C>
  matrix_new (const vector<row_tuple<C> >& t) {
    if (N(t) == 0) return matrix<C> ();
    nat i, j, rows= N(t), cols= N(t[0]);
    C dummy= zero_cst<C> ();
    matrix<C> r (dummy, rows, cols);
    for (i=0; i<rows; i++) {
      ASSERT (N(t[i]) == cols, "unequal row lengths");
      for (j=0; j<cols; j++)
        r(i,j)= t[i][j];
    }
    return r;
  }

  template<typename C> matrix<C>
  matrix_new (const vector<C>& t) {
    nat j, rows= 1, cols= N(t);
    C dummy= zero_cst<C> ();
    matrix<C> r (dummy, rows, cols);
    for (j=0; j<cols; j++)
      r(0,j)= t[j];
    return r;
  }

  template<typename C> vector<generic>
  wrap_column_reduced_echelon_with_permutation (const matrix<C>& m) {
    permutation permut;
    generic tp=as<generic> (column_reduced_echelon (m, permut));
    return vec (tp, as<generic> (permut));
  }

  template<typename C> vector<generic>
  wrap_column_reduced_echelon_with_transform (const matrix<C>& m) {
    matrix<C> k;
    generic tp=as<generic> (column_reduced_echelon (m, k));
    return vec (tp, as<generic> (k));
  }

  template<typename C> vector<generic>
  wrap_row_reduced_echelon_with_transform (const matrix<C>& m) {
    matrix<C> k;
    generic tp=as<generic> (row_reduced_echelon (m, k));
    return vec (tp, as<generic> (k));
  }
}


namespace mmx {
  static generic
  GLUE_1 (const integer &arg_1, const integer &arg_2) {
    return old_integer_pow (arg_1, arg_2);
  }
  
  static matrix<integer>
  GLUE_2 (const int &arg_1) {
    return identity_matrix_integer (arg_1);
  }
  
  static row_tuple<integer>
  GLUE_3 (const tuple<integer> &arg_1) {
    return row_tuple<integer > (as_vector (arg_1));
  }
  
  static matrix<integer>
  GLUE_4 (const tuple<integer> &arg_1) {
    return matrix_new (as_vector (arg_1));
  }
  
  static matrix<integer>
  GLUE_5 (const tuple<row_tuple<integer> > &arg_1) {
    return matrix_new (as_vector (arg_1));
  }
  
  static matrix<integer>
  GLUE_6 (const tuple<row_tuple<integer> > &arg_1) {
    return matrix_new (as_vector (arg_1));
  }
  
  static int
  GLUE_7 (const matrix<integer> &arg_1) {
    return N (arg_1);
  }
  
  static int
  GLUE_8 (const matrix<integer> &arg_1) {
    return rows (arg_1);
  }
  
  static int
  GLUE_9 (const matrix<integer> &arg_1) {
    return cols (arg_1);
  }
  
  static integer
  GLUE_10 (const matrix<integer> &arg_1, const int &arg_2, const int &arg_3) {
    return arg_1 (arg_2, arg_3);
  }
  
  static alias<integer>
  GLUE_11 (const alias<matrix<integer> > &arg_1, const int &arg_2, const int &arg_3) {
    return alias_access<integer > (arg_1, arg_2, arg_3);
  }
  
  static matrix<integer>
  GLUE_12 (const matrix<integer> &arg_1, const int &arg_2, const int &arg_3, const int &arg_4, const int &arg_5) {
    return range (arg_1, arg_2, arg_3, arg_4, arg_5);
  }
  
  static matrix<integer>
  GLUE_13 (const matrix<integer> &arg_1) {
    return transpose (arg_1);
  }
  
  static matrix<integer>
  GLUE_14 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return horizontal_join (arg_1, arg_2);
  }
  
  static matrix<integer>
  GLUE_15 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return vertical_join (arg_1, arg_2);
  }
  
  static matrix<integer>
  GLUE_16 (const matrix<integer> &arg_1, const permutation &arg_2) {
    return arg_1 * arg_2;
  }
  
  static matrix<integer>
  GLUE_17 (const permutation &arg_1, const matrix<integer> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static matrix<integer>
  GLUE_18 (const integer &arg_1, const int &arg_2, const int &arg_3) {
    return fill_matrix (arg_1, arg_2, arg_3);
  }
  
  static matrix<integer>
  GLUE_19 (const integer &arg_1, const int &arg_2) {
    return jordan_matrix (arg_1, arg_2);
  }
  
  static matrix<integer>
  GLUE_20 (const matrix<integer> &arg_1) {
    return -arg_1;
  }
  
  static matrix<integer>
  GLUE_21 (const matrix<integer> &arg_1) {
    return square (arg_1);
  }
  
  static matrix<integer>
  GLUE_22 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return arg_1 + arg_2;
  }
  
  static matrix<integer>
  GLUE_23 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return arg_1 - arg_2;
  }
  
  static matrix<integer>
  GLUE_24 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static matrix<integer>
  GLUE_25 (const integer &arg_1, const matrix<integer> &arg_2) {
    return arg_1 + arg_2;
  }
  
  static matrix<integer>
  GLUE_26 (const matrix<integer> &arg_1, const integer &arg_2) {
    return arg_1 + arg_2;
  }
  
  static matrix<integer>
  GLUE_27 (const integer &arg_1, const matrix<integer> &arg_2) {
    return arg_1 - arg_2;
  }
  
  static matrix<integer>
  GLUE_28 (const matrix<integer> &arg_1, const integer &arg_2) {
    return arg_1 - arg_2;
  }
  
  static matrix<integer>
  GLUE_29 (const integer &arg_1, const matrix<integer> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static matrix<integer>
  GLUE_30 (const matrix<integer> &arg_1, const integer &arg_2) {
    return arg_1 * arg_2;
  }
  
  static bool
  GLUE_31 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_32 (const matrix<integer> &arg_1, const matrix<integer> &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_33 (const matrix<integer> &arg_1, const integer &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_34 (const matrix<integer> &arg_1, const integer &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_35 (const integer &arg_1, const matrix<integer> &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_36 (const integer &arg_1, const matrix<integer> &arg_2) {
    return arg_1 != arg_2;
  }
  
  static row_tuple<generic>
  GLUE_37 (const row_tuple<integer> &arg_1) {
    return as<row_tuple<generic> > (arg_1);
  }
  
  static matrix<generic>
  GLUE_38 (const matrix<integer> &arg_1) {
    return as<matrix<generic> > (arg_1);
  }
  
  static vector<integer>
  GLUE_39 (const vector<int> &arg_1) {
    return as<vector<integer> > (arg_1);
  }
  
  static vector<int>
  GLUE_40 (const vector<integer> &arg_1) {
    return as<vector<int> > (arg_1);
  }
  
  static vector<integer>
  GLUE_41 (const matrix<integer> &arg_1, const int &arg_2) {
    return row (arg_1, arg_2);
  }
  
  static vector<integer>
  GLUE_42 (const matrix<integer> &arg_1, const int &arg_2) {
    return column (arg_1, arg_2);
  }
  
  static matrix<integer>
  GLUE_43 (const vector<integer> &arg_1) {
    return toeplitz_matrix (arg_1);
  }
  
  static matrix<integer>
  GLUE_44 (const vector<integer> &arg_1) {
    return hankel_matrix (arg_1);
  }
  
  static matrix<integer>
  GLUE_45 (const vector<integer> &arg_1, const vector<integer> &arg_2) {
    return tensor_matrix (arg_1, arg_2);
  }
  
  static matrix<integer>
  GLUE_46 (const vector<integer> &arg_1) {
    return vandermonde (arg_1);
  }
  
  static vector<integer>
  GLUE_47 (const matrix<integer> &arg_1, const vector<integer> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static vector<integer>
  GLUE_48 (const vector<integer> &arg_1, const matrix<integer> &arg_2) {
    return arg_1 * arg_2;
  }
  
  void
  glue_matrix_integer () {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_vector_integer"));
    call_glue (string ("glue_matrix_generic"));
    define ("^", GLUE_1);
    define_type<row_tuple<integer> > (gen (lit ("Row"), lit ("Integer")));
    define_type<matrix<integer> > (gen (lit ("Matrix"), lit ("Integer")));
    define ("identity_matrix", GLUE_2);
    define ("(.)", GLUE_3);
    define ("matrix", GLUE_4);
    define ("matrix", GLUE_5);
    define ("[]", GLUE_6);
    define ("#", GLUE_7);
    define ("rows", GLUE_8);
    define ("columns", GLUE_9);
    define (".[]", GLUE_10);
    define (".[]", GLUE_11);
    define (".[]", GLUE_12);
    define ("transpose", GLUE_13);
    define ("horizontal_join", GLUE_14);
    define ("vertical_join", GLUE_15);
    define ("*", GLUE_16);
    define ("*", GLUE_17);
    define ("fill_matrix", GLUE_18);
    define ("jordan_matrix", GLUE_19);
    define ("-", GLUE_20);
    define ("square", GLUE_21);
    define ("+", GLUE_22);
    define ("-", GLUE_23);
    define ("*", GLUE_24);
    define ("+", GLUE_25);
    define ("+", GLUE_26);
    define ("-", GLUE_27);
    define ("-", GLUE_28);
    define ("*", GLUE_29);
    define ("*", GLUE_30);
    define ("=", GLUE_31);
    define ("!=", GLUE_32);
    define ("=", GLUE_33);
    define ("!=", GLUE_34);
    define ("=", GLUE_35);
    define ("!=", GLUE_36);
    define_converter (":>", GLUE_37, PENALTY_PROMOTE_GENERIC);
    define_converter (":>", GLUE_38, PENALTY_PROMOTE_GENERIC);
    define_converter (":>", GLUE_39, PENALTY_INCLUSION);
    define_converter (":>", GLUE_40, PENALTY_INCLUSION);
    define ("row", GLUE_41);
    define ("column", GLUE_42);
    define ("toeplitz_matrix", GLUE_43);
    define ("hankel_matrix", GLUE_44);
    define ("tensor_matrix", GLUE_45);
    define ("vandermonde", GLUE_46);
    define ("*", GLUE_47);
    define ("*", GLUE_48);
  }
}

---