$\f, for each order $s > 1$. More...

#include <latticetester/FigureOfMeritM.h>

Inheritance diagram for LatticeTester::FigureOfMeritM< Int, Real >:

Public Member Functions
	FigureOfMeritM (const NTL::vector< int64_t > &t, Weights &w, Normalizer &norma, ReducerBB< Int, Real > *red=0, bool includeFirst=false)

virtual	~FigureOfMeritM ()

void	setTVector (const NTL::vector< int64_t > &t, bool includeFirst=false)

void	setWeights (Weights &w)

void	setNormalizer (Normalizer &norma)

void	setLLL (double delta=0.99999)

void	setBKZ (double delta=0.99999, int64_t blocksize=10)

void	setBB (bool redBB)

void	setReducerBB (ReducerBB< Int, Real > *red)

void	setLowBound (double low)

void	setVerbosity (int64_t verbose)

void	setCollectLevel (int64_t collect)

double	getMinMeritSqlen ()

Coordinates	getMinMeritProj ()

double	computeMerit (IntLatticeExt< Int, Real > &lat, IntLattice< Int, Real > &proj, double minmerit=DBL_MAX)

virtual double	computeMeritSucc (IntLatticeExt< Int, Real > &lat, double minmerit=DBL_MAX)

virtual double	computeMeritNonSucc (IntLatticeExt< Int, Real > &lat, IntLattice< Int, Real > &proj, double minmerit=DBL_MAX)

double	computeMeritOneProj (IntLattice< Int, Real > &proj, const Coordinates &coord, double minmerit=DBL_MAX)

Public Attributes
NTL::vector< int64_t >	m_t

int64_t	m_tsize = 0

Weights *	m_weights

Normalizer *	m_norma

double	m_deltaLLL = 0.0

double	m_deltaBKZ = 0.99999

int64_t	m_blocksizeBKZ = 10

bool	m_redBB = true

CoordinateSets::FromRanges *	m_coordRange

ReducerBB< Int, Real > *	m_red

NTL::vector< Real >	m_sqlen

bool	m_includeFirst = false

double	m_lowbound = 0.0

double	m_minMerit = DBL_MAX

double	m_minMeritSqlen = 0

Coordinates	m_minMeritProj

Coordinates	m_worstproj

int64_t	m_verbose = 0

int64_t	m_collectLevel = 0

Detailed Description

template<typename Int, typename Real>
class LatticeTester::FigureOfMeritM< Int, Real >

$\f, for each order $s > 1$.

There are two variants for the latter: the first (default) variant takes $S(s,t_s)$ as just defined (also defined in the guide), and the other considers only the set $S^{(1)}(s,t_s)$ of projections that contain coordinate 1. The parameter includeFirst in the constructor determines which variant is taken: the latter option is taken when includeFirst is set to true.

The lengths of the shortest vectors in the projections can be calculated exactly by using the BB algorithm after applying some pre-reduction, or they can be just approximated by the lengths of the shortest basis vector obtained after applying some pre-reduction such as LLL or BKZ. The latter is much faster but not exact.

The constructor has two template parameters to specify which Int and Real types are used. It also requires the vector $(t_1,\dots,t_d)$, a Weights object that gives a weight to each projection, a Normalizer object used to normalize the merit values, a ReducerBB object used for the reduction in case we want to apply BB, and the includeFirst parameter in case we want to change it to false. The last two parameters are optional. The BB is applied if and only if a (nonzero) ReducerBB is given. Otherwise, we just use static methods for the reduction and need no Reducer. By default, the pre-reduction method is only BKZ with delta = 0.99999 and blocksize = 10. To change these values and/or apply LLL, one can use setBKZ and/or setLLL. The reductions are always applied in the order: LLL, BKZ, BB. To remove LLL or BKZ, it suffices to set its delta parameter to 0.0.

After a FigureOfMeritM has been created by the constructor, one can use setTVector to set (or reset) the vector $(t_1,\dots,t_d)$, setWeights to change the weights, setLLL or setBKZ to change the LLL or BKZ parameters, etc.

The method computeMerit computes the FOM for a given lattice. The computation is stopped (early exit) as soon as we know that the value of the FOM will be below the lower bound, whose value can be changed via setLowBound. The default value is 0.

***** WARNING: For now, this class works only for the Euclidean norm, right? *****