bkz_param.h

Go to the documentation of this file.

#ifndef BKZ_PARAM_H
#define BKZ_PARAM_H
 
/* (C) 2014-2016 Martin Albrecht.
 
   This file is part of fplll. fplll is free software: you can
   redistribute it and/or modify it under the terms of the GNU Lesser
   General Public License as published by the Free Software
   Foundation, either version 2.1 of the License, or (at your option)
   any later version.
 
   fplll is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public
   License along with fplll. If not, see
   <http://www.gnu.org/licenses/>.
 
*/
 
#include "defs.h"
#include "pruner/pruner.h"
#include <string>
#include <vector>
 
FPLLL_BEGIN_NAMESPACE
 
class Strategy
{
public:
  size_t block_size;                         //< block size
  vector<PruningParams> pruning_parameters;  //< Pruning parameters
  vector<size_t> preprocessing_block_sizes;  //< For each block size we run one tour
 
  static Strategy EmptyStrategy(size_t block_size)
  {
    Strategy strat;
    strat.block_size = block_size;
    strat.pruning_parameters.emplace_back(PruningParams());
    return strat;
  };
 
  const PruningParams &get_pruning(double radius, double gh) const;
};
 
class BKZParam
{
public:
  BKZParam(int block_size, vector<Strategy> &strategies, double delta = LLL_DEF_DELTA,
           int flags = BKZ_DEFAULT, int max_loops = 0, double max_time = 0,
           double auto_abort_scale        = BKZ_DEF_AUTO_ABORT_SCALE,
           int auto_abort_max_no_dec      = BKZ_DEF_AUTO_ABORT_MAX_NO_DEC,
           double gh_factor               = BKZ_DEF_GH_FACTOR,
           double min_success_probability = BKZ_DEF_MIN_SUCCESS_PROBABILITY,
           int rerandomization_density    = BKZ_DEF_RERANDOMIZATION_DENSITY)
      : block_size(block_size), strategies(strategies), delta(delta), flags(flags),
        max_loops(max_loops), max_time(max_time), auto_abort_scale(auto_abort_scale),
        auto_abort_max_no_dec(auto_abort_max_no_dec), gh_factor(gh_factor),
        dump_gso_filename("gso.json"), min_success_probability(min_success_probability),
        rerandomization_density(rerandomization_density)
  {
 
    // we create dummy strategies
    if (strategies.empty())
    {
      strategies = vector<Strategy>();
      for (long b = 0; b <= block_size; ++b)
      {
        strategies.emplace_back(Strategy::EmptyStrategy(b));
      }
    }
  };
 
  int block_size;
 
  vector<Strategy> &strategies;
 
  double delta;
 
  int flags;
 
  int max_loops;
 
  double max_time;
 
  double auto_abort_scale;
  int auto_abort_max_no_dec;
 
  double gh_factor;
 
  string dump_gso_filename;
 
  double min_success_probability;
 
  int rerandomization_density;
};
 
vector<Strategy> load_strategies_json(const std::string &filename);
 
const std::string &default_strategy_path();
 
const std::string &default_strategy();
 
const std::string strategy_full_path(const string &strategy_path);
 
FPLLL_END_NAMESPACE
#endif /* BKZ_PARAM_H */