文件原位置SEAL/smallmodulus.h

介紹

加密參數plain_modulus和coeff_modulus中的素數由SmallModulus的實例表示。整數模數的表示高達62位。此類的目的是執行和存儲Barrett約簡（Barrett reduction）所需的預計算。

@par 線程安全
通常，只要沒有其他線程同時改變它，從SmallModulus讀取就是線程安全的。

@see EncryptionParameters用於描述加密參數。

overview

private

成員

SmallModulus(std::uint64_t value, std::array<std::uint64_t, 3> const_ratio, int bit_count, int uint64_count) :
            value_(value), const_ratio_(const_ratio), bit_count_(bit_count), uint64_count_(uint64_count)
        {
        }
std::uint64_t value_ = 0;

// C++11 compatibility
std::array<std::uint64_t, 3> const_ratio_{ { 0 } };

int bit_count_ = 0;

int uint64_count_ = 0;

set_value

void SmallModulus::set_value(uint64_t value)
{
  if (value == 0)
  {
      // Zero settings
      bit_count_ = 0;
      uint64_count_ = 1;
      value_ = 0;

      // C++11 compatibility
      const_ratio_ = { { 0 } };
  }
  else if (value >> 62 != 0 || value == 0x4000000000000000 || value == 1)
  {
      throw invalid_argument("value can be at most 62 bits and cannot be 1");
  }
  else
  {
      // All normal, compute const_ratio and set everything
      value_ = value;
      bit_count_ = get_significant_bit_count(value_);

      // Compute Barrett ratios for 64-bit words (barrett_reduce_128)
      uint64_t numerator[3]{ 0, 0, 1 };
      uint64_t quotient[3]{ 0 };

      // Use a special method to avoid using memory pool
      divide_uint192_uint64_inplace(numerator, value_, quotient);

      const_ratio_[0] = quotient[0];
      const_ratio_[1] = quotient[1];

      // We store also the remainder
      const_ratio_[2] = numerator[0];

      uint64_count_ = 1;
  }
}

public

構造函數1

/**
創建一個SmallModulus實例。 SmallModulus的值設置爲
給定值，或默認爲零。

@param [in] value整數模數
@throws std :: invalid_argument如果value爲1或大於62位
*/
SmallModulus(std::uint64_t value = 0)
{
    set_value(value);
}

構造函數2

/**
通過複製給定的一個SmallModulus來創建一個新的SmallModulus。

@param [in] copy要複製的SmallModulus
*/
SmallModulus(const SmallModulus &copy) = default;

構造函數3

/**
通過複製給定的一個SmallModulus來創建一個新的SmallModulus。

@param [in] source SmallModulus來自
*/
SmallModulus(SmallModulus &&source) = default;

運算符重載1(=)

/**
將給定的SmallModulus複製到當前的SmallModulus。

@param [in]assign SmallModulus從中複製
*/
SmallModulus &operator =(const SmallModulus &assign) = default;

運算符重載2(=)

/**
將給定的SmallModulus移動到當前的SmallModulus。

@param [in]assign SmallModulus移動
*/
SmallModulus &operator =(SmallModulus &&assign) = default;

運算符重載3(=)

/**
設置SmallModulus的值。

@param [in] value新的整數模數
@throws std :: invalid_argument如果value爲1或大於62位
*/
inline SmallModulus &operator =(std::uint64_t value)
{
    set_value(value);
    return *this;
}

bit_count()

/**
返回當前SmallModulus值的有效位數。
*/
inline int bit_count() const
{
    return bit_count_;
}

uint64_count()

/**
返回當前SmallModulus值的大小（以64位字爲單位）。
*/
inline int uint64_count() const
{
    return uint64_count_;
}

*pointer()

/**
返回指向當前SmallModulus值的常量指針。
*/
inline const uint64_t *pointer() const
{
    return &value_;
}

value()

/**
返回當前SmallModulus的值。
*/
inline std::uint64_t value() const
{
    return value_;
}

const_ratio()

/**
返回爲當前SmallModulus的值計算的Barrett比率。 
Barrett比率的前兩個分量是2 ^ 128 /值的底限，第三個分量是餘數。
*/
inline const std::array<std::uint64_t, 3> &const_ratio() const
{
    return const_ratio_;
}

is_zero()

/**
返回當前SmallModulus的值是否爲零。
*/
inline bool is_zero() const
{
    return value_ == 0;
}

運算符重載4(==)

/**
比較兩個SmallModulus實例。

@param[in] compare The SmallModulus to compare against
*/
inline bool operator ==(const SmallModulus &compare) const
{
    return value_ == compare.value_;
}

運算符重載5(==)

/**
將當前SmallModulus的值與給定值進行比較。

@param[in] compare The value to compare against
*/
inline bool operator ==(std::uint64_t compare) const
{
    return value_ == compare;
}

運算符重載6(!=)

/**
比較兩個SmallModulus實例。

@param[in] compare The SmallModulus to compare against
*/
inline bool operator !=(const SmallModulus &compare) const
{
    return !(value_ == compare.value_);
}

運算符重載7(!=)

/**
將當前SmallModulus的值與給定值進行比較。

@param[in] compare The value to compare against
*/
inline bool operator !=(std::uint64_t compare) const
{
    return !(value_ == compare);
}

save()

/**
將SmallModulus保存到輸出流。 模數的完整狀態是序列化的。
輸出是二進制格式，不是人類可讀的。 輸出流必須設置“二進制”標誌。

@param [in] stream 將SmallModulus保存到的流
*/
void SmallModulus::save(ostream &stream) const
{
    int bit_count32 = bit_count_;
    stream.write(reinterpret_cast<const char*>(&bit_count32), sizeof(int32_t));
    int uint64_count32 = uint64_count_;
    stream.write(reinterpret_cast<const char*>(&uint64_count32), sizeof(int32_t));
    stream.write(reinterpret_cast<const char*>(&value_), bytes_per_uint64);
    stream.write(reinterpret_cast<const char*>(const_ratio_.data()), 3 * bytes_per_uint64);
}

load()

/**
從輸入流加載SmallModulus，覆蓋當前的SmallModulus。

@param [in] stream從中加載SmallModulus的流
*/
void SmallModulus::load(istream &stream)
{
    int bit_count32;
    stream.read(reinterpret_cast<char*>(&bit_count32), sizeof(int32_t));
    bit_count_ = bit_count32;
    int uint64_count32;
    stream.read(reinterpret_cast<char*>(&uint64_count32), sizeof(int32_t));
    uint64_count_ = uint64_count32;
    stream.read(reinterpret_cast<char*>(&value_), bytes_per_uint64);
    stream.read(reinterpret_cast<char*>(const_ratio_.data()), 3 * bytes_per_uint64);
}

模數實例（SEAL/smallmodulus.h 2.3.0）

模數實例（SEAL/smallmodulus.h）

介紹