mubintvecdyn.h

// @file This file contains mubintvecdyn, a <vector> of buintdyn, with
// associated modulus and modulo math operators.
// @author TPOC: contact@palisade-crypto.org
//
// @copyright Copyright (c) 2019, New Jersey Institute of Technology (NJIT)
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution. THIS SOFTWARE IS
// PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef LBCRYPTO_MATH_BIGINTDYN_MUBINTVECDYN_H
#define LBCRYPTO_MATH_BIGINTDYN_MUBINTVECDYN_H

#include <initializer_list>
#include <iostream>
#include <string>
#include <vector>

#include "math/bigintfxd/mubintvecfxd.h"
#include "utils/inttypes.h"
#include "utils/serializable.h"

namespace bigintdyn {
template <class ubint_el_t>
class mubintvec
    : public lbcrypto::BigVectorInterface<mubintvec<ubint_el_t>, ubint_el_t>,
      public lbcrypto::Serializable {
 public:
  // CONSTRUCTORS

  mubintvec();

  static mubintvec Single(const ubint_el_t &val, const ubint_el_t &modulus) {
    mubintvec vec(1);
    vec.m_data[0] = val;
    vec.SetModulus(modulus);
    return vec;
  }

  explicit mubintvec(usint length);

  explicit mubintvec(const usint length, const usint &modulus);

  explicit mubintvec(const usint length, const ubint_el_t &modulus);

  explicit mubintvec(const usint length, const std::string &modulus);

  explicit mubintvec(const mubintvec &rhs);

  mubintvec(mubintvec &&rhs);

  explicit mubintvec(const usint length, const ubint_el_t &modulus,
                     std::initializer_list<std::string> rhs);

  explicit mubintvec(const usint length, const ubint_el_t &modulus,
                     std::initializer_list<uint64_t> rhs);

  // constructor specifying the mubintvec as a vector of strings and modulus
  explicit mubintvec(const std::vector<std::string> &s,
                     const ubint_el_t &modulus);

  // constructor specifying the mubintvec as a vector of strings and modulus
  explicit mubintvec(const std::vector<std::string> &s,
                     const std::string &modulus);

  virtual ~mubintvec();

  // ASSIGNMENT OPERATORS

  const mubintvec &operator=(const mubintvec &rhs);

  const mubintvec &operator=(mubintvec &&rhs);

  const mubintvec &operator=(std::initializer_list<std::string> rhs);

  const mubintvec &operator=(std::initializer_list<uint64_t> rhs);

  const mubintvec &operator=(uint64_t val) {
    this->m_data[0] = val;
    for (size_t i = 1; i < GetLength(); ++i) {
      this->m_data[i] = 0;
    }
    return *this;
  }

  const mubintvec &operator=(const ubint_el_t &val) {
    this->m_data[0] = val;
    for (size_t i = 1; i < this->m_data.size(); ++i) {
      this->m_data[i] = 0;
    }
    return *this;
  }

  size_t GetLength() const { return m_data.size(); }

  // ACCESSORS

  ubint_el_t &at(size_t i) {
    if (!this->IndexCheck(i)) {
      PALISADE_THROW(lbcrypto::math_error, "index out of range");
    }
    return this->m_data[i];
  }

  const ubint_el_t &at(size_t i) const {
    if (!this->IndexCheck(i)) {
      PALISADE_THROW(lbcrypto::math_error, "index out of range");
    }
    return this->m_data[i];
  }

  ubint_el_t &operator[](size_t i) { return this->m_data[i]; }

  const ubint_el_t &operator[](size_t i) const { return this->m_data[i]; }

  bool isModulusSet(void) const { return true; }

  void SetModulus(const usint &value);

  void SetModulus(const ubint_el_t &value);

  void SetModulus(const std::string &value);

  void SetModulus(const mubintvec &value);

  void SwitchModulus(const ubint_el_t &value);

  const ubint_el_t &GetModulus() const;

  // MODULUS ARITHMETIC OPERATIONS

  mubintvec Mod(const ubint_el_t &modulus) const;

  const mubintvec &ModEq(const ubint_el_t &modulus);

  mubintvec ModAdd(const ubint_el_t &b) const;

  const mubintvec &ModAddEq(const ubint_el_t &b);

  mubintvec ModAddAtIndex(usint i, const ubint_el_t &b) const;

  const mubintvec &ModAddAtIndexEq(usint i, const ubint_el_t &b);

  mubintvec ModAdd(const mubintvec &b) const;

  const mubintvec &ModAddEq(const mubintvec &b);

  mubintvec ModSub(const ubint_el_t &b) const;

  const mubintvec &ModSubEq(const ubint_el_t &b);

  mubintvec ModSub(const mubintvec &b) const;

  const mubintvec &ModSubEq(const mubintvec &b);

  mubintvec ModMul(const ubint_el_t &b) const;

  const mubintvec &ModMulEq(const ubint_el_t &b);

  mubintvec ModMul(const mubintvec &b) const;

  const mubintvec &ModMulEq(const mubintvec &b);

  mubintvec ModExp(const ubint_el_t &b) const;

  const mubintvec &ModExpEq(const ubint_el_t &b);

  mubintvec ModInverse() const;

  const mubintvec &ModInverseEq();

  mubintvec ModByTwo() const;

  const mubintvec &ModByTwoEq();

  mubintvec MultiplyAndRound(const ubint_el_t &p, const ubint_el_t &q) const;

  const mubintvec &MultiplyAndRoundEq(const ubint_el_t &p, const ubint_el_t &q);

  mubintvec DivideAndRound(const ubint_el_t &q) const;

  const mubintvec &DivideAndRoundEq(const ubint_el_t &q);

  // OTHER FUNCTIONS

  mubintvec GetDigitAtIndexForBase(usint index, usint base) const;

  // STRINGS & STREAMS

  friend std::ostream &operator<<(std::ostream &os, const mubintvec &ptr_obj) {
#if 0  // old way
    os << std::endl;
    for (usint i = 0; i < ptr_obj.m_data.size(); i++) {
      os << ptr_obj.m_data[i] << std::endl;
    }
    os << "modulus: " << ptr_obj.m_modulus;
    os << std::endl;
#else
    auto len = ptr_obj.m_data.size();
    os << "[";
    for (usint i = 0; i < len; i++) {
      os << ptr_obj.m_data[i];
      os << ((i == (len - 1)) ? "]" : " ");
    }
    os << " modulus: " << ptr_obj.m_modulus;
#endif
    return os;
  }

  // SERIALIZATION

  template <class Archive>
  void save(Archive &ar, std::uint32_t const version) const {
    ar(::cereal::make_nvp("d", m_data));
    ar(::cereal::make_nvp("m", m_modulus));
    ar(::cereal::make_nvp("ms", m_modulus_state));
  }

  template <class Archive>
  void load(Archive &ar, std::uint32_t const version) {
    if (version > SerializedVersion()) {
      PALISADE_THROW(lbcrypto::deserialize_error,
                     "serialized object version " + std::to_string(version) +
                         " is from a later version of the library");
    }
    ar(::cereal::make_nvp("d", m_data));
    ar(::cereal::make_nvp("m", m_modulus));
    ar(::cereal::make_nvp("ms", m_modulus_state));
  }

  std::string SerializedObjectName() const { return "ExpVector"; }

  static uint32_t SerializedVersion() { return 1; }

 private:
  ubint_el_t m_modulus;

  enum State { INITIALIZED, GARBAGE };

  // enum to store the state of the
  State m_modulus_state;

  std::vector<ubint_el_t> m_data;

  bool IndexCheck(size_t length) const {
    if (length > m_data.size()) {
      return false;
    }
    return true;
  }
};
}  // namespace bigintdyn

#endif  // LBCRYPTO_MATH_BIGINTDYN_MUBINTVECDYN_H