Z2_field.h

Go to the documentation of this file.

/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
 *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
 *    Author(s):       Hannah Schreiber
 *
 *    Copyright (C) 2022 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */

 
#ifndef MATRIX_FIELD_Z2_H_
#define MATRIX_FIELD_Z2_H_
 
#include <utility>
 
namespace Gudhi {
namespace persistence_fields {

class Z2_field_element
{
 public:
  using Element = bool; 
  template <class T>
  using isInteger = std::enable_if_t<std::is_integral_v<T> >;

  Z2_field_element() : element_(false) {}

  template <typename Integer_type, class = isInteger<Integer_type> >
  Z2_field_element(Integer_type element) : element_(_get_value(element))
  {}

  Z2_field_element(const Z2_field_element& toCopy) = default;

  Z2_field_element(Z2_field_element&& toMove) noexcept : element_(std::exchange(toMove.element_, false)) {}
 
  ~Z2_field_element() = default;

  friend void operator+=(Z2_field_element& f1, Z2_field_element const& f2)
  {
    f1.element_ = (f1.element_ != f2.element_);
  }

  friend Z2_field_element operator+(Z2_field_element f1, Z2_field_element const& f2)
  {
    f1 += f2;
    return f1;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend void operator+=(Z2_field_element& f, const Integer_type& v)
  {
    f.element_ = (f.element_ != _get_value(v));
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend Z2_field_element operator+(Z2_field_element f, const Integer_type& v)
  {
    f += v;
    return f;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend Integer_type operator+(const Integer_type& v, const Z2_field_element& f)
  {
    return f.element_ != _get_value(v);
  }

  friend void operator-=(Z2_field_element& f1, Z2_field_element const& f2)
  {
    f1.element_ = (f1.element_ != f2.element_);
  }

  friend Z2_field_element operator-(Z2_field_element f1, Z2_field_element const& f2)
  {
    f1 -= f2;
    return f1;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend void operator-=(Z2_field_element& f, const Integer_type& v)
  {
    f.element_ = (f.element_ != _get_value(v));
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend Z2_field_element operator-(Z2_field_element f, const Integer_type& v)
  {
    f -= v;
    return f;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend Integer_type operator-(const Integer_type v, Z2_field_element const& f)
  {
    return f.element_ != _get_value(v);
  }

  friend void operator*=(Z2_field_element& f1, Z2_field_element const& f2)
  {
    f1.element_ = (f1.element_ && f2.element_);
  }

  friend Z2_field_element operator*(Z2_field_element f1, Z2_field_element const& f2)
  {
    f1 *= f2;
    return f1;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend void operator*=(Z2_field_element& f, const Integer_type& v)
  {
    f.element_ = (f.element_ && _get_value(v));
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend Z2_field_element operator*(Z2_field_element f, const Integer_type& v)
  {
    f *= v;
    return f;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend Integer_type operator*(const Integer_type& v, Z2_field_element const& f)
  {
    return f.element_ && _get_value(v);
  }

  friend bool operator==(const Z2_field_element& f1, const Z2_field_element& f2) { return f1.element_ == f2.element_; }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend bool operator==(const Integer_type& v, const Z2_field_element& f)
  {
    return _get_value(v) == f.element_;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend bool operator==(const Z2_field_element& f, const Integer_type& v)
  {
    return _get_value(v) == f.element_;
  }

  friend bool operator!=(const Z2_field_element& f1, const Z2_field_element& f2) { return !(f1 == f2); }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend bool operator!=(const Integer_type v, const Z2_field_element& f)
  {
    return !(v == f);
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  friend bool operator!=(const Z2_field_element& f, const Integer_type v)
  {
    return !(v == f);
  }

  Z2_field_element& operator=(Z2_field_element other)
  {
    std::swap(element_, other.element_);
    return *this;
  }

  Z2_field_element& operator=(Z2_field_element&& other) noexcept
  {
    if (this == &other) return *this;
 
    element_ = std::exchange(other.element_, false);
    return *this;
  }

  template <typename Integer_type, class = isInteger<Integer_type> >
  Z2_field_element& operator=(const Integer_type value)
  {
    element_ = _get_value(value);
    return *this;
  }

  friend void swap(Z2_field_element& f1, Z2_field_element& f2) noexcept { std::swap(f1.element_, f2.element_); }

  operator unsigned int() const { return static_cast<unsigned int>(element_); }

  [[nodiscard]] Z2_field_element get_inverse() const { return element_ ? Z2_field_element(1) : Z2_field_element(); }

  [[nodiscard]] std::pair<Z2_field_element, unsigned int> get_partial_inverse(
      unsigned int productOfCharacteristics) const
  {
    return {get_inverse(), productOfCharacteristics};
  }

  static Z2_field_element get_additive_identity() { return {}; }

  static Z2_field_element get_multiplicative_identity() { return {1}; }

  static Z2_field_element get_partial_multiplicative_identity([[maybe_unused]] unsigned int productOfCharacteristics)
  {
    return {1};
  }

  static constexpr unsigned int get_characteristic() { return 2; }

  [[nodiscard]] Element get_value() const { return element_; }
 
 private:
  Element element_;
 
  template <typename Integer_type, class = isInteger<Integer_type> >
  static constexpr Element _get_value(Integer_type e)
  {
    if constexpr (std::is_same_v<Integer_type, bool>) {
      return e;
    } else {
      return e < 2 && e >= 0 ? e : e % 2;  // returns bool, so %2 won't be negative and is optimized to &
    }
  }
};
 
}  // namespace persistence_fields
}  // namespace Gudhi
 
#endif  // MATRIX_FIELD_Z2_H_