matrix.h

Go to the documentation of this file.

/* Copyright (C) 2005-2008 Damien Stehle.
   Copyright (C) 2007 David Cade.
   Copyright (C) 2011 Xavier Pujol.
 
   This file is part of fplll. fplll is free software: you
   can redistribute it and/or modify it under the terms of the GNU Lesser
   General Public License as published by the Free Software Foundation,
   either version 2.1 of the License, or (at your option) any later version.
 
   fplll is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
   along with fplll. If not, see <http://www.gnu.org/licenses/>. */
 
#ifndef FPLLL_MATRIX_H
#define FPLLL_MATRIX_H
 
#include "fplll/nr/numvect.h"
 
FPLLL_BEGIN_NAMESPACE
 
enum MatPrintMode
{
  MAT_PRINT_COMPACT = 0,
  MAT_PRINT_REGULAR = 1
};
 
template <class T> class Matrix;
 
template <class T> class MatrixRow
{
public:
  T &operator[](int i) { return row[i]; }
  const T &operator[](int i) const { return row[i]; }
  int size() const { return row.size(); }
  void print(ostream &os) const { os << row; }
 
  bool is_zero(int from = 0) const { return row.is_zero(from); }
  int size_nz() const { return row.size_nz(); }
  void fill(long value) { row.fill(value); }
  void add(const MatrixRow<T> &v) { row.add(v.row); }
  void add(const MatrixRow<T> &v, int n) { row.add(v.row, n); }
  void sub(const MatrixRow<T> &v) { row.sub(v.row); }
  void sub(const MatrixRow<T> &v, int n) { row.sub(v.row, n); }
  void mul(const MatrixRow<T> &v, int b, int n, T x) { row.mul(v.row, b, n, x); }
  void div(const MatrixRow<T> &v, int b, int n, T x) { row.div(v.row, b, n, x); }
  void addmul(const MatrixRow<T> &v, T x) { row.addmul(v.row, x); }
  void addmul(const MatrixRow<T> &v, T x, int n) { row.addmul(v.row, x, n); }
  void addmul(const MatrixRow<T> &v, T x, int b, int n) { row.addmul(v.row, x, b, n); }
  void addmul_2exp(const MatrixRow<T> &v, const T &x, long expo, T &tmp)
  {
    row.addmul_2exp(v.row, x, expo, tmp);
  }
  void addmul_2exp(const MatrixRow<T> &v, const T &x, long expo, int /*n*/, T &tmp)
  {
    row.addmul_2exp(v.row, x, expo, tmp);
  }
  void addmul_si(const MatrixRow<T> &v, long x) { row.addmul_si(v.row, x); }
  void addmul_si(const MatrixRow<T> &v, long x, int n) { row.addmul_si(v.row, x, n); }
  void addmul_si_2exp(const MatrixRow<T> &v, long x, long expo, T &tmp)
  {
    row.addmul_si_2exp(v.row, x, expo, tmp);
  }
  void addmul_si_2exp(const MatrixRow<T> &v, long x, long expo, int n, T &tmp)
  {
    row.addmul_si_2exp(v.row, x, expo, n, tmp);
  }
 
  inline void dot_product(T &result, const MatrixRow<T> &v0, int beg, int n) const
  {
    fplll::dot_product(result, this->row, v0.row, beg, n);
  }
 
  inline void dot_product(T &result, const MatrixRow<T> &v0, int n) const
  {
    fplll::dot_product(result, this->row, v0.row, n);
  }
 
  inline void dot_product(T &result, const MatrixRow<T> &v0) const
  {
    fplll::dot_product(result, this->row, v0.row);
  }
 
  friend class Matrix<T>;
 
private:
  MatrixRow(const NumVect<T> &row) : row(const_cast<NumVect<T> &>(row)) {}
  NumVect<T> &row;
};
 
template <class T> ostream &operator<<(ostream &os, const MatrixRow<T> &row)
{
  row.print(os);
  return os;
}
 
template <class T> class Matrix
{
public:
  Matrix() : r(0), c(0) {}
  Matrix(int rows, int cols) : r(0), c(0) { resize(rows, cols); }
 
  void clear()
  {
    r = c = 0;
    matrix.clear();
  }
  bool empty() const { return r == 0; }
  void resize(int rows, int cols);
  void set_rows(int rows) { resize(rows, c); }
  void set_cols(int cols) { resize(r, cols); }
  template <class U> void fill(U value);
  void swap(Matrix<T> &m)
  {
    matrix.swap(m.matrix);
    std::swap(r, m.r);
    std::swap(c, m.c);
  }
 
  int get_rows() const { return r; }
  int get_cols() const { return c; }
  T &operator()(int i, int j)
  {
    FPLLL_DEBUG_CHECK(i >= 0 && i < r && j >= 0 && j < c);
    return matrix[i][j];
  }
  const T &operator()(int i, int j) const
  {
    FPLLL_DEBUG_CHECK(i >= 0 && i < r && j >= 0 && j < c);
    return matrix[i][j];
  }
  MatrixRow<T> operator[](int i)
  {
    FPLLL_DEBUG_CHECK(i >= 0 && i < r);
    return MatrixRow<T>(matrix[i]);
  }
  const MatrixRow<T> operator[](int i) const
  {
    FPLLL_DEBUG_CHECK(i >= 0 && i < r);
    return MatrixRow<T>(matrix[i]);
  }
  void swap_rows(int r1, int r2) { matrix[r1].swap(matrix[r2]); }
  void rotate_left(int first, int last) { rotate_left_by_swap(matrix, first, last); }
  void rotate_right(int first, int last) { rotate_right_by_swap(matrix, first, last); }
  void rotate(int first, int middle, int last) { rotate_by_swap(matrix, first, middle, last); }
  void rotate_gram_left(int first, int last, int n_valid_rows);
  void rotate_gram_right(int first, int last, int n_valid_rows);
  void transpose();
  T get_max();
  long get_max_exp();
  void print(ostream &os, int nrows = -1, int ncols = -1) const;
  void read(istream &is);
  ostream &print_comma(ostream &os) const;
  static int set_print_mode(int new_print_mode)
  {
    int old_mode = print_mode;
    print_mode   = new_print_mode;
    return old_mode;
  }
 
protected:
  int r, c;
  vector<NumVect<T>> matrix;
 
  static int print_mode;
};
 
template <class T> int Matrix<T>::print_mode = MAT_PRINT_COMPACT;
 
template <class T> ostream &operator<<(ostream &os, const Matrix<T> &m)
{
  m.print(os);
  return os;
}
 
template <class T> istream &operator>>(istream &is, Matrix<T> &m)
{
  m.read(is);
  return is;
}
 
template <class ZT> class ZZ_mat : public Matrix<Z_NR<ZT>>
{
public:
  typedef Z_NR<ZT> T;
  using Matrix<T>::r;
  using Matrix<T>::c;
  using Matrix<T>::matrix;
  using Matrix<T>::resize;
  using Matrix<T>::get_cols;
  using Matrix<T>::get_rows;
 
  ZZ_mat() : Matrix<T>() {}
  ZZ_mat(int rows, int cols) : Matrix<T>(rows, cols) {}
 
  void gen_zero(int d, int n)
  {
    resize(d, n);
    for (int i = 0; i < d; i++)
      matrix[i].fill(0);
  }
  void gen_identity(int d)
  {
    gen_zero(d, d);
    for (int i = 0; i < d; i++)
      matrix[i][i] = 1;
  }
  void gen_intrel(int bits);
  void gen_simdioph(int bits, int bits2);
  void gen_uniform(int bits);
 
  void gen_ntrulike(int bits);
  void gen_ntrulike_withq(int q);
 
  void gen_ntrulike2(int bits);
  void gen_ntrulike2_withq(int q);
 
  void gen_qary(int k, Z_NR<ZT> &q);
 
  void gen_qary(int k, int bits)
  {
    Z_NR<ZT> q;
    q.randb(bits);
    gen_qary(k, q);
  }
 
  void gen_qary_withq(int k, int q)
  {
    Z_NR<ZT> q2;
    q2 = q;
    gen_qary(k, q2);
  }
 
  void gen_qary_prime(int k, int bits)
  {
    Z_NR<ZT> q;
    q.randb(bits);
    q.nextprime(q);
    gen_qary(k, q);
  }
 
  void gen_trg(double alpha);
  void gen_trg2(FP_NR<mpfr_t> *w);
};
 
template <class ZTto, class ZTfrom>
bool convert(ZZ_mat<ZTto> &Ato, const ZZ_mat<ZTfrom> &Afrom, int buffer = 0);
 
template <class FT> class FP_mat : public Matrix<FP_NR<FT>>
{
public:
  typedef FP_NR<FT> T;
  FP_mat() : Matrix<T>() {}
  FP_mat(int rows, int cols) : Matrix<T>(rows, cols) {}
};
 
FPLLL_END_NAMESPACE
 
#include "fplll/nr/matrix.cpp"
 
#endif