MOLS_generator.hpp

Go to the documentation of this file.

// Copyright 2020 Matthew Henderson

#ifndef SRC_MOLS_MOLS_GENERATOR_HPP_
#define SRC_MOLS_MOLS_GENERATOR_HPP_

#include <LiDIA/galois_field.h>
#include <LiDIA/gf_element.h>
#include <LiDIA/galois_field_iterator.h>

#include <set>
#include <vector>
#include <cmath>

#include <boost/range/functions.hpp>
#include <boost/range/metafunctions.hpp>

#include <boost/numeric/ublas/matrix.hpp>

#include <boost/assign/std/vector.hpp>
#include <boost/assert.hpp>

#include "Fields.hpp"

template <class Field, class Matrix>
Matrix aXpY(const Field& F,
        const typename FieldTraits<Field>::element& p,
        const typename FieldTraits<Field>::element& a) {
  int size;
  LiDIA::bigint no_of_elem(F.number_of_elements());
  no_of_elem.intify(size);
  Matrix L(size, size);
  for (int i = 0; i < L.size1(); ++i)
    for (int j = 0; j < L.size2(); ++j) {
      typename FieldTraits<Field>::element x, y;
      if (i == 0) {
        x.assign_zero(F);
      } else {
        LiDIA::bigint I(i);
        LiDIA::power(x, p, I);
      }
      if (j == 0) {
        y.assign_zero(F);
      } else {
        LiDIA::bigint J(j);
        LiDIA::power(y, p, J);
      }
      L(i, j) = a*x + y;
    }
  return L;
}

template <class Field, class Matrix>
class aXpYGenerator {
  Field F;
  int i;
  typename FieldTraits<Field>::element a, b;
 public:
  aXpYGenerator(const Field& F,
          const typename FieldTraits<Field>::element& a) : F(F), a(a), i(0) {}
  Matrix operator()() {
    LiDIA::bigint I(i);
    LiDIA::power(b, a, I);
    ++i;
    return aXpY<Field, Matrix>(F, a, b);
  }
};

template<class Matrix, class Field>
class MOLRange {
  typedef typename FieldTraits<Field>::characteristic_type characteristic_t;
  typedef typename FieldTraits<Field>::degree_type degree_t;
  typedef typename FieldTraits<Field>::order_type order_t;
  typedef typename FieldTraits<Field>::element FieldElement;
  typedef std::vector<Matrix> Range;
  typedef typename Range::iterator iterator;
  characteristic_t characteristic;
  degree_t degree;
  Range mol_range;

 public:
  typedef Matrix value_type;
  MOLRange(characteristic_t characteristic,
          degree_t degree) : characteristic(characteristic), degree(degree) {
    Field F(characteristic, degree);
    FieldElement a(F.generator());
    order_t order;
    LiDIA::power(order, characteristic, degree);
    int order_;
    order.intify(order_);
    mol_range.resize(order_ - 1);
    std::generate(mol_range.begin(),
            mol_range.end(),
            aXpYGenerator<Field, Matrix>(F, a));
  }
  iterator begin() { return mol_range.begin(); }
  iterator end() { return mol_range.end(); }
};

#endif  // SRC_MOLS_MOLS_GENERATOR_HPP_