PolyMod.h

/* Copyright (C) 2019 IBM Corp.
 * This program is Licensed under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *   http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. See accompanying LICENSE file.
 */
 
#ifndef HELIB_POLYMOD_H
#define HELIB_POLYMOD_H
 
#include <NTL/ZZX.h>
#include <vector>
#include <memory>
#include <helib/PolyModRing.h>
 
namespace helib {
 
class PolyMod
{
public:
  PolyMod();
 
  explicit PolyMod(const std::shared_ptr<PolyModRing>& ringDescriptor);
 
  PolyMod(long input, const std::shared_ptr<PolyModRing>& ringDescriptor);
 
  PolyMod(const std::vector<long>& input,
          const std::shared_ptr<PolyModRing>& ringDescriptor);
 
  PolyMod(const NTL::ZZX& input,
          const std::shared_ptr<PolyModRing>& ringDescriptor);
 
  PolyMod(const PolyMod& input) = default;
 
  PolyMod(PolyMod&& input) noexcept = default;
 
  ~PolyMod() = default;
 
  PolyMod& operator=(const PolyMod& input) = default;
 
  PolyMod& operator=(PolyMod&& input) =
      default; // noexcept removed as NTL has non-noexcept move constructors
  PolyMod& operator=(long input);
 
  PolyMod& operator=(const std::vector<long>& input);
 
  PolyMod& operator=(const std::initializer_list<long>& input);
 
  PolyMod& operator=(const NTL::ZZX& input);
 
  explicit operator long() const;
 
  explicit operator std::vector<long>() const;
 
  explicit operator NTL::ZZX() const;
 
  bool isValid() const;
 
  long getp2r() const;
 
  NTL::ZZX getG() const;
 
  const NTL::ZZX& getData() const;
 
  bool operator==(const PolyMod& rhs) const;
 
  bool operator==(long rhs) const;
 
  bool operator==(const std::vector<long>& rhs) const;
 
  bool operator==(const NTL::ZZX& rhs) const;
 
  template <typename T>
  bool operator!=(T&& rhs) const
  {
    return !operator==(std::forward<T>(rhs));
  }
 
  PolyMod& negate();
 
  PolyMod operator-() const;
 
  PolyMod operator*(const PolyMod& rhs) const;
 
  PolyMod operator*(long rhs) const;
 
  PolyMod operator*(const NTL::ZZX& rhs) const;
 
  PolyMod operator+(const PolyMod& rhs) const;
 
  PolyMod operator+(long rhs) const;
 
  PolyMod operator+(const NTL::ZZX& rhs) const;
 
  PolyMod operator-(const PolyMod& rhs) const;
 
  PolyMod operator-(long rhs) const;
 
  PolyMod operator-(const NTL::ZZX& rhs) const;
 
  PolyMod& operator*=(const PolyMod& otherPoly);
 
  PolyMod& operator*=(long scalar);
 
  PolyMod& operator*=(const NTL::ZZX& otherPoly);
 
  PolyMod& operator+=(const PolyMod& otherPoly);
 
  PolyMod& operator+=(long scalar);
 
  PolyMod& operator+=(const NTL::ZZX& otherPoly);
 
  PolyMod& operator-=(const PolyMod& otherPoly);
 
  PolyMod& operator-=(long scalar);
 
  PolyMod& operator-=(const NTL::ZZX& otherPoly);
 
  friend void deserialize(std::istream& is, PolyMod& poly);
 
  friend void serialize(std::ostream& os, const PolyMod& slot);
 
  friend std::istream& operator>>(std::istream& is, PolyMod& poly);
 
  friend std::ostream& operator<<(std::ostream& os, const PolyMod& poly);
 
private:
  std::shared_ptr<PolyModRing> ringDescriptor;
 
  NTL::ZZX data;
 
  void modularReduce();
 
  static void assertValidity(const PolyMod& poly);
 
  static void assertInterop(const PolyMod& lhs, const PolyMod& rhs);
};
 
} // namespace helib
#endif