SEAL-4.1-x64-windows.zip

// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT license. #pragma once #include "seal/util/common.h" #include "seal/util/defines.h" #include "seal/util/pointer.h" #include <algorithm> #include <cstddef> #include <cstdint> #include <iostream> #include <iterator> #include <stdexcept> #include <tuple> #include <type_traits> #include <utility> #include <vector> namespace seal { class Ciphertext; namespace util { class NTTTables; /** @par PolyIter, RNSIter, and CoeffIter In this file we define a set of custom iterator classes ("SEAL iterators") that are used throughout Microsoft SEAL for easier iteration over ciphertext polynomials, their RNS components, and the coefficients in the RNS components. All SEAL iterators satisfy the C++ LegacyRandomAccessIterator requirements. SEAL iterators are ideal to use with the SEAL_ITERATE macro, which expands to std::for_each_n in C++17 and to seal::util::seal_for_each_n in C++14. All SEAL iterators derive from SEALIterBase. The most important SEAL iterator classes behave as illustrated by the following diagram: +-------------------+ | Pointer & Size | Construct +-----------------+ | or Ciphertext |------------>| (Const)PolyIter | Iterates over RNS polynomials in a ciphertext +-------------------+ +--------+--------+ (coeff_modulus_size-many RNS components) | | | Dereference | | v +----------------+ Construct +----------------+ | Pointer & Size |------------->| (Const)RNSIter | Iterates over RNS components in an RNS polynomial +----------------+ +-------+--------+ (poly_modulus_degree-many coefficients) | | | Dereference | | v +----------------+ Construct +------------------+ | Pointer & Size |------------>| (Const)CoeffIter | Iterates over coefficients (std::uint64_t) in a single +----------------+ +---------+--------+ RNS polynomial component | | | Dereference | | v +-------------------------+ | (const) std::uint64_t & | +-------------------------+ @par PtrIter and StrideIter PtrIter<T *> and StrideIter<T *> are both templated SEAL iterators that wrap raw pointers. The difference between these two types is that advancing PtrIter<T *> always advances the wrapped pointer by one, whereas the step size (stride) can be set to be anything for a StrideIter<T *>. CoeffIter is a typedef of PtrIter<std::uint64_t *> and and RNSIter is almost the same as StrideIter<std::uint64_t *>, but still a different type. +----------+ Construct +-------------------+ | MyType * |------------->| PtrIter<MyType *> | Simple wrapper for raw pointers +----------+ +----+----------+---+ | | | | Dereference | | PtrIter<MyType *>::ptr() | | or implicit conversion | | v v +----------+ +----------+ | MyType & | | MyType * | +----------+ +----------+ +----------+ Construct +----------------------+ | MyType * |------------->| StrideIter<MyType *> | Simple wrapper for raw pointers with custom stride size +----------+ +-----+----------+-----+ | | | | Dereference | | StrideIter<MyType *>::ptr() | | or implicit conversion | | v v +----------+ +----------+ | MyType & | | MyType * | +----------+ +----------+ @par IterTuple An extremely useful template class is the (variadic) IterTuple<...> that allows multiple SEAL iterators to be zipped together. An IterTuple is itself a SEAL iterator and nested IterTuple types are used commonly in the library. Dereferencing an IterTuple always yields an std::tuple, with each IterTuple element dereferenced. Since an IterTuple can be constructed from an std::tuple holding the respective single-parameter constructor arguments for each iterator, the dereferenced std::tuple can often be directly passed on to functions expecting an IterTuple. The individual components of an IterTuple can be accessed with the seal::util::get<i>(...) functions. The behavior of IterTuple is summarized in the following diagram: +-----------------------------------------+ | IterTuple<PolyIter, RNSIter, CoeffIter> | +--------------------+--------------------+ | | | Dereference | | v +--------------------------------------------------+ | std::tuple<RNSIter, CoeffIter, std::uint64_t &>> | +------+-------------------+-------------------+---+ | | | | | | | std::get<0> | std::get<1> | std::get<2> | | | | | | v v v +-------------+ +---------------+ +-----------------+ | RNSIter | | CoeffIter | | std::uint64_t & | +-------------+ +---------------+ +-----------------+ Sometimes we have to use multiple nested iterator tuples. In this case accessing the nested iterators can be tedious with nested get<...> calls. Consider the following, where encrypted1 and encrypted2 are Ciphertexts and destination is either a Ciphertext or a PolyIter: IterTuple<PolyIter, PolyIter> I(encrypted1, encrypted2); IterTuple<decltype(I), PolyIter> J(I, destination); auto encrypted1_iter = get<0>(get<0>(J)); auto encrypted2_iter = get<1>(get<0>(J)); An easier way is to use another form of get<...> that accepts multiple indices and accesses the structure in a nested manner. For example, in the above we could also write: auto encrypted1_iter = get<0, 0>(J)); auto encr