mubintvecfxd.h

// @file mubintvecfxd.h This file contains the vector manipulation
// functionality.
// @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_BIGINTFXD_MUBINVECFXD_H
#define LBCRYPTO_MATH_BIGINTFXD_MUBINVECFXD_H

#include <iostream>
#include <string>

#include "utils/inttypes.h"
#include "utils/serializable.h"

#include "math/bigintfxd/ubintfxd.h"

namespace bigintfxd {

template <class IntegerType>
class BigVectorImpl
    : public lbcrypto::BigVectorInterface<BigVectorImpl<IntegerType>,
                                          IntegerType>,
      public lbcrypto::Serializable {
 public:
  // CONSTRUCTORS

  BigVectorImpl();

  static inline BigVectorImpl Single(const IntegerType &val,
                                     const IntegerType &modulus) {
    BigVectorImpl vec(1, modulus);
    vec[0] = val;
    return vec;
  }

  explicit BigVectorImpl(usint length, const IntegerType &modulus = 0);

  BigVectorImpl(const BigVectorImpl &bigVector);

  BigVectorImpl(BigVectorImpl &&bigVector);  // move copy constructor

  BigVectorImpl(usint length, const IntegerType &modulus,
                std::initializer_list<std::string> rhs);

  BigVectorImpl(usint length, const IntegerType &modulus,
                std::initializer_list<uint64_t> rhs);

  virtual ~BigVectorImpl();

  // ASSIGNMENT OPERATORS

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

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

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

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

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

  // ACCESSORS

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

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

  IntegerType &operator[](size_t idx) { return (this->m_data[idx]); }

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

  void SetModulus(const IntegerType &value);

  void SwitchModulus(const IntegerType &value);

  const IntegerType &GetModulus() const { return this->m_modulus; }

  size_t GetLength() const { return this->m_length; }

  // MODULAR ARITHMETIC OPERATIONS

  BigVectorImpl Mod(const IntegerType &modulus) const;

  const BigVectorImpl &ModEq(const IntegerType &modulus);

  BigVectorImpl ModAdd(const IntegerType &b) const;

  const BigVectorImpl &ModAddEq(const IntegerType &b);

  BigVectorImpl ModAddAtIndex(usint i, const IntegerType &b) const;

  const BigVectorImpl &ModAddAtIndexEq(usint i, const IntegerType &b);

  BigVectorImpl ModAdd(const BigVectorImpl &b) const;

  const BigVectorImpl &ModAddEq(const BigVectorImpl &b);

  BigVectorImpl ModSub(const IntegerType &b) const;

  const BigVectorImpl &ModSubEq(const IntegerType &b);

  BigVectorImpl ModSub(const BigVectorImpl &b) const;

  const BigVectorImpl &ModSubEq(const BigVectorImpl &b);

  BigVectorImpl ModMul(const IntegerType &b) const;

  const BigVectorImpl &ModMulEq(const IntegerType &b);

  BigVectorImpl ModMul(const BigVectorImpl &b) const;

  const BigVectorImpl &ModMulEq(const BigVectorImpl &b);

  BigVectorImpl ModExp(const IntegerType &b) const;

  const BigVectorImpl &ModExpEq(const IntegerType &b);

  BigVectorImpl ModInverse() const;

  const BigVectorImpl &ModInverseEq();

  BigVectorImpl ModByTwo() const;

  const BigVectorImpl &ModByTwoEq();

  BigVectorImpl MultWithOutMod(const BigVectorImpl &b) const;

  const BigVectorImpl &MultWithOutModEq(const BigVectorImpl &b);

  BigVectorImpl MultiplyAndRound(const IntegerType &p,
                                 const IntegerType &q) const;

  const BigVectorImpl &MultiplyAndRoundEq(const IntegerType &p,
                                          const IntegerType &q);

  BigVectorImpl DivideAndRound(const IntegerType &q) const;

  const BigVectorImpl &DivideAndRoundEq(const IntegerType &q);

  // OTHER FUNCTIONS

  BigVectorImpl GetDigitAtIndexForBase(usint index, usint base) const;

  // STRINGS & STREAMS

  template <class IntegerType_c>
  friend std::ostream &operator<<(std::ostream &os,
                                  const BigVectorImpl<IntegerType_c> &ptr_obj) {
    auto len = ptr_obj.m_length;
    os << "[";
    for (usint i = 0; i < len; i++) {
      os << ptr_obj.m_data[i];
      os << ((i == (len - 1)) ? "]" : " ");
    }
    os << " modulus: " << ptr_obj.m_modulus;
    return os;
  }

  // SERIALIZATION

  template <class Archive>
  typename std::enable_if<!cereal::traits::is_text_archive<Archive>::value,
                          void>::type
  save(Archive &ar, std::uint32_t const version) const {
    ar(::cereal::make_nvp("m", m_modulus));
    ar(::cereal::make_nvp("l", m_length));
    ar(::cereal::binary_data(m_data, sizeof(IntegerType) * m_length));
  }

  template <class Archive>
  typename std::enable_if<cereal::traits::is_text_archive<Archive>::value,
                          void>::type
  save(Archive &ar, std::uint32_t const version) const {
    ar(::cereal::make_nvp("m", m_modulus));
    ar(::cereal::make_nvp("l", m_length));
    for (size_t i = 0; i < m_length; i++) {
      ar(m_data[i]);
    }
  }

  template <class Archive>
  typename std::enable_if<!cereal::traits::is_text_archive<Archive>::value,
                          void>::type
  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("m", m_modulus));
    ar(::cereal::make_nvp("l", m_length));
    m_data = new IntegerType[m_length]();
    ar(::cereal::binary_data(m_data, sizeof(IntegerType) * m_length));
  }

  template <class Archive>
  typename std::enable_if<cereal::traits::is_text_archive<Archive>::value,
                          void>::type
  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("m", m_modulus));
    ar(::cereal::make_nvp("l", m_length));
    m_data = new IntegerType[m_length]();
    for (size_t i = 0; i < m_length; i++) {
      ar(m_data[i]);
    }
  }

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

  static uint32_t SerializedVersion() { return 1; }

 private:
  // m_data is a pointer to the vector
  IntegerType *m_data;
  // m_length stores the length of the vector
  usint m_length;
  // m_modulus stores the internal modulus of the vector.
  IntegerType m_modulus = 0;

  // function to check if the index is a valid index.
  bool IndexCheck(size_t length) const {
    if (length > this->m_length) {
      return false;
    }
    return true;
  }
};

extern template class BigVectorImpl<
    BigInteger<integral_dtype, BigIntegerBitLength>>;

}  // namespace bigintfxd

#endif  // LBCRYPTO_MATH_BIGINTFXD_MUBINVECFXD_H