/Users/mourrain/Devel/mmx/algebramix/glue/glue_matrix_generic.cpp

Go to the documentation of this file.

#include <basix/vector.hpp>
#include <basix/int.hpp>
#include <algebramix/vector_unrolled.hpp>
#include <algebramix/vector_simd.hpp>
#include <numerix/integer.hpp>
#include <numerix/rational.hpp>
#include <algebramix/permutation.hpp>
#include <basix/row_tuple.hpp>
#include <algebramix/matrix.hpp>
#include <algebramix/matrix_ring_naive.hpp>
#include <algebramix/matrix_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 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= 0;
    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= 0;
    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 int &arg_1) {
    return integer_construct (arg_1);
  }
  
  static row_tuple<generic>
  GLUE_2 (const tuple<generic> &arg_1) {
    return row_tuple<generic > (as_vector (arg_1));
  }
  
  static matrix<generic>
  GLUE_3 (const tuple<generic> &arg_1) {
    return matrix_new (as_vector (arg_1));
  }
  
  static matrix<generic>
  GLUE_4 (const tuple<row_tuple<generic> > &arg_1) {
    return matrix_new (as_vector (arg_1));
  }
  
  static matrix<generic>
  GLUE_5 (const tuple<row_tuple<generic> > &arg_1) {
    return matrix_new (as_vector (arg_1));
  }
  
  static int
  GLUE_6 (const matrix<generic> &arg_1) {
    return N (arg_1);
  }
  
  static int
  GLUE_7 (const matrix<generic> &arg_1) {
    return rows (arg_1);
  }
  
  static int
  GLUE_8 (const matrix<generic> &arg_1) {
    return cols (arg_1);
  }
  
  static generic
  GLUE_9 (const matrix<generic> &arg_1, const int &arg_2, const int &arg_3) {
    return arg_1 (arg_2, arg_3);
  }
  
  static alias<generic>
  GLUE_10 (const alias<matrix<generic> > &arg_1, const int &arg_2, const int &arg_3) {
    return alias_access<generic > (arg_1, arg_2, arg_3);
  }
  
  static matrix<generic>
  GLUE_11 (const matrix<generic> &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 vector<generic>
  GLUE_12 (const matrix<generic> &arg_1, const int &arg_2) {
    return row (arg_1, arg_2);
  }
  
  static vector<generic>
  GLUE_13 (const matrix<generic> &arg_1, const int &arg_2) {
    return column (arg_1, arg_2);
  }
  
  static matrix<generic>
  GLUE_14 (const matrix<generic> &arg_1) {
    return transpose (arg_1);
  }
  
  static matrix<generic>
  GLUE_15 (const matrix<generic> &arg_1, const matrix<generic> &arg_2) {
    return horizontal_join (arg_1, arg_2);
  }
  
  static matrix<generic>
  GLUE_16 (const matrix<generic> &arg_1, const matrix<generic> &arg_2) {
    return vertical_join (arg_1, arg_2);
  }
  
  static matrix<generic>
  GLUE_17 (const generic &arg_1, const int &arg_2, const int &arg_3) {
    return fill_matrix (arg_1, arg_2, arg_3);
  }
  
  static matrix<generic>
  GLUE_18 (const generic &arg_1, const int &arg_2) {
    return jordan_matrix (arg_1, arg_2);
  }
  
  static matrix<generic>
  GLUE_19 (const vector<generic> &arg_1) {
    return toeplitz_matrix (arg_1);
  }
  
  static matrix<generic>
  GLUE_20 (const vector<generic> &arg_1) {
    return hankel_matrix (arg_1);
  }
  
  static matrix<generic>
  GLUE_21 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
    return tensor_matrix (arg_1, arg_2);
  }
  
  static matrix<generic>
  GLUE_22 (const vector<generic> &arg_1) {
    return vandermonde (arg_1);
  }
  
  static matrix<generic>
  GLUE_23 (const matrix<generic> &arg_1) {
    return -arg_1;
  }
  
  static matrix<generic>
  GLUE_24 (const matrix<generic> &arg_1) {
    return square (arg_1);
  }
  
  static matrix<generic>
  GLUE_25 (const matrix<generic> &arg_1, const matrix<generic> &arg_2) {
    return arg_1 + arg_2;
  }
  
  static matrix<generic>
  GLUE_26 (const matrix<generic> &arg_1, const matrix<generic> &arg_2) {
    return arg_1 - arg_2;
  }
  
  static matrix<generic>
  GLUE_27 (const matrix<generic> &arg_1, const matrix<generic> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static vector<generic>
  GLUE_28 (const matrix<generic> &arg_1, const vector<generic> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static vector<generic>
  GLUE_29 (const vector<generic> &arg_1, const matrix<generic> &arg_2) {
    return arg_1 * arg_2;
  }
  
  static matrix<generic>
  GLUE_30 (const matrix<generic> &arg_1, const matrix<generic> &arg_2) {
    return krylov (arg_1, arg_2);
  }
  
  static generic
  GLUE_31 (const matrix<generic> &arg_1) {
    return det (arg_1);
  }
  
  static matrix<generic>
  GLUE_32 (const matrix<generic> &arg_1) {
    return row_echelon (arg_1);
  }
  
  static matrix<generic>
  GLUE_33 (const matrix<generic> &arg_1) {
    return column_echelon (arg_1);
  }
  
  static matrix<generic>
  GLUE_34 (const matrix<generic> &arg_1) {
    return row_reduced_echelon (arg_1);
  }
  
  static matrix<generic>
  GLUE_35 (const matrix<generic> &arg_1) {
    return column_reduced_echelon (arg_1);
  }
  
  static vector<generic>
  GLUE_36 (const matrix<generic> &arg_1) {
    return wrap_row_reduced_echelon_with_transform (arg_1);
  }
  
  static vector<generic>
  GLUE_37 (const matrix<generic> &arg_1) {
    return wrap_column_reduced_echelon_with_transform (arg_1);
  }
  
  static vector<generic>
  GLUE_38 (const matrix<generic> &arg_1) {
    return wrap_column_reduced_echelon_with_permutation (arg_1);
  }
  
  static matrix<generic>
  GLUE_39 (const matrix<generic> &arg_1) {
    return kernel (arg_1);
  }
  
  static matrix<generic>
  GLUE_40 (const matrix<generic> &arg_1) {
    return image (arg_1);
  }
  
  static int
  GLUE_41 (const matrix<generic> &arg_1) {
    return rank (arg_1);
  }
  
  static matrix<generic>
  GLUE_42 (const matrix<generic> &arg_1) {
    return invert (arg_1);
  }
  
  static matrix<generic>
  GLUE_43 (const matrix<generic> &arg_1) {
    return derive (arg_1);
  }
  
  static matrix<generic>
  GLUE_44 (const matrix<generic> &arg_1) {
    return integrate (arg_1);
  }
  
  void
  glue_matrix_generic () {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_vector_generic"));
    call_glue (string ("glue_vector_int"));
    define_constructor<int > (GLUE_1);
    define_type<row_tuple<generic> > (gen (lit ("Row"), lit ("Generic")));
    define_type<matrix<generic> > (gen (lit ("Matrix"), lit ("Generic")));
    define ("(.)", GLUE_2);
    define ("matrix", GLUE_3);
    define ("matrix", GLUE_4);
    define ("[]", GLUE_5);
    define ("#", GLUE_6);
    define ("rows", GLUE_7);
    define ("columns", GLUE_8);
    define (".[]", GLUE_9);
    define (".[]", GLUE_10);
    define (".[]", GLUE_11);
    define ("row", GLUE_12);
    define ("column", GLUE_13);
    define ("transpose", GLUE_14);
    define ("horizontal_join", GLUE_15);
    define ("vertical_join", GLUE_16);
    define ("fill_matrix", GLUE_17);
    define ("jordan_matrix", GLUE_18);
    define ("toeplitz_matrix", GLUE_19);
    define ("hankel_matrix", GLUE_20);
    define ("tensor_matrix", GLUE_21);
    define ("vandermonde", GLUE_22);
    define ("-", GLUE_23);
    define ("square", GLUE_24);
    define ("+", GLUE_25);
    define ("-", GLUE_26);
    define ("*", GLUE_27);
    define ("*", GLUE_28);
    define ("*", GLUE_29);
    define ("krylov", GLUE_30);
    define ("det", GLUE_31);
    define ("row_echelon", GLUE_32);
    define ("column_echelon", GLUE_33);
    define ("row_reduced_echelon", GLUE_34);
    define ("column_reduced_echelon", GLUE_35);
    define ("row_reduced_echelon_with_transform", GLUE_36);
    define ("column_reduced_echelon_with_transform", GLUE_37);
    define ("column_reduced_echelon_with_permutation", GLUE_38);
    define ("ker", GLUE_39);
    define ("im", GLUE_40);
    define ("rank", GLUE_41);
    define ("invert", GLUE_42);
    define ("derive", GLUE_43);
    define ("integrate", GLUE_44);
  }
}