replicate.h

/* Copyright (C) 2012-2020 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_REPLICATE_H
#define HELIB_REPLICATE_H
 
#include <helib/EncryptedArray.h>
#include <helib/Ptxt.h>
 
namespace helib {
 
// set to true to see some more info...
NTL_THREAD_LOCAL
extern bool replicateVerboseFlag;
 
class RepAux; // forward declarations
class RepAuxDim;
 
void replicate(const EncryptedArray& ea, Ctxt& ctx, long pos);
 
void replicate0(const EncryptedArray& ea, Ctxt& ctxt, long pos);
 
class ReplicateHandler
{
public:
  virtual void handle(const Ctxt& ctxt) = 0;
  virtual ~ReplicateHandler() {}
 
  // The earlyStop call can be used to quit the replication mid-way, leaving
  // a ciphertext with (e.g.) two different entries, each replicated n/2 times
  // FIXME: Why does this function have arguments? Maybe remove them and then
  // remove the pragma.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
  virtual bool earlyStop(long d, long k, long prodDim) { return false; }
#pragma GCC diagnostic pop
};
// Applications will derive from this class a handler that actually
// does something with the replicated ciphertexts. But it can be used
// by itself as a do-nothing replicator for debugging, or to calculate
// the required automorphisms (see automorphVals in numbTh.h)
 
void replicateAll(const EncryptedArray& ea,
                  const Ctxt& ctxt,
                  ReplicateHandler* handler,
                  long recBound = 64,
                  RepAuxDim* repAuxPtr = nullptr);
 
void replicateAll(std::vector<Ctxt>& v,
                  const EncryptedArray& ea,
                  const Ctxt& ctxt,
                  long recBound = 64,
                  RepAuxDim* repAuxPtr = nullptr);
 
template <typename Scheme>
void replicateAll(std::vector<Ptxt<Scheme>>& v,
                  const EncryptedArray&,
                  const Ptxt<Scheme>& ptxt)
{
  v = ptxt.replicateAll();
}
 
void replicateAllOrig(const EncryptedArray& ea,
                      const Ctxt& ctxt,
                      ReplicateHandler* handler,
                      RepAux* repAuxPtr = nullptr);
 
void replicate(const EncryptedArray& ea, PlaintextArray& pa, long i);
 
template <typename Scheme>
void replicate(const EncryptedArray&, Ptxt<Scheme>& ptxt, long i)
{
  ptxt.replicate(i);
}
 
// Structures to keep tables of masking constants that are used in
// replication. A calling application can either supply this structure
// itself (if it is going to replicate the same tables in multiple
// replicate operations), or is cal let the replication code use its
// own tables (in which case they are destroyed at the end of the
// replication process)
 
class RepAux
{ // one table for the whole thing
private:
  std::vector<copied_ptr<DoubleCRT>> _tab;
 
public:
  copied_ptr<DoubleCRT>& tab(long i)
  {
    if (i >= lsize(_tab))
      _tab.resize(i + 1);
    return _tab[i];
  }
};
 
class RepAuxDim
{ // two tables per dimension
private:
  std::vector<std::vector<copied_ptr<DoubleCRT>>> _tab, _tab1;
 
public:
  copied_ptr<DoubleCRT>& tab(long d, long i)
  {
    if (d >= lsize(_tab))
      _tab.resize(d + 1);
    if (i >= lsize(_tab[d]))
      _tab[d].resize(i + 1);
    return _tab[d][i];
  }
 
  copied_ptr<DoubleCRT>& tab1(long d, long i)
  {
    if (d >= lsize(_tab1))
      _tab1.resize(d + 1);
    if (i >= lsize(_tab1[d]))
      _tab1[d].resize(i + 1);
    return _tab1[d][i];
  }
};
 
} // namespace helib
 
#endif // ifndef HELIB_REPLICATE_H