Lattice Tester Online Documentation 0.1.0-861
Software Package For Testing The Uniformity Of Integral Lattices In The Real Space
Loading...
Searching...
No Matches
NTLWrap.h File Reference
#include <NTL/vector.h>
#include <NTL/matrix.h>
#include <NTL/ZZ.h>
#include <NTL/vec_ZZ.h>
#include <NTL/mat_ZZ.h>
#include <cstdint>
#include <cmath>

Classes

class  NTL::vector< T >
 A subclass of the NTL::Vec<T> class. More...
 
class  NTL::matrix< T >
 A subclass of the NTL::Mat<T> class. More...
 
class  NTL::matrix_row< M >
 An extension of NTL::vector<T> implemented in this module to be used as a matrix row. More...
 

Namespaces

namespace  NTL
 This module extends the Vec and Mat classes of NTL.
 

Functions

Other utilities for compatibility with NTL.

These functions perform conversions between different types.

Most of them do not really need explanations, but sometimes a specific logic is used when doing the conversion.

void NTL::conv (std::int64_t &l, const char *c)
 Converts the array of characters (string) c into an std::int64_t l using the strtol() function of cstdlib.h.
 
void NTL::conv (double &r, const char *c)
 Converts the array of characters (string) c into a double r using the strtod() function of cstdlib.h.
 
Function overloads

These functions are already implemented in NTL for NTL::ZZ or NTL::RR types, but not for the other standard types we use.

These overloads allow us to make a simple call to the function in the NTL namespace without worrying about types and still have working algorithms.

bool NTL::IsZero (const std::int64_t &x)
 Returns the bool resulting of the statement x == 0.
 
void NTL::clear (double &x)
 Sets x to 0.
 
void NTL::clear (std::int64_t &x)
 Sets x to 0.
 
std::int64_t NTL::IsOdd (const std::int64_t &x)
 Tests if x is odd.
 
void NTL::set (std::int64_t &x)
 Sets x to 1.
 

Mathematical functions

These are complementary overloads to NTL power functions.

typedef NTL::matrix< int64_t > NTL::matrix64
 
typedef NTL::vector< int64_t > NTL::vector64
 
typedef Mat< std::int64_t > NTL::Mat_64
 
typedef Vec< std::int64_t > NTL::Vec_64
 
std::int64_t NTL::power (std::int64_t p, std::int64_t i)
 Returns \(p^i\).
 
void NTL::power2 (std::int64_t &z, std::int64_t i)
 Sets \(z = 2^i\).
 
void NTL::power2 (NTL::ZZ &z, std::int64_t i)
 Sets \(z = 2^i\).
 
double NTL::inv (const double x)
 
template<typename T >
static void NTL::transpose (NTL::Mat< T > &X, const NTL::Mat< T > &A)
 Transposes A into X.
 
template<typename T >
static NTL::Mat< T > NTL::transpose (const NTL::Mat< T > &a)
 Another implementation of the transpose function.
 
static void NTL::add (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::sub (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::SubPos (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::negate (int64_t &x, const int64_t a)
 
static void NTL::mul (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::div (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::rem (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::sqr (int64_t &x, const int64_t a)
 
static void NTL::MulAddTo (int64_t &x, const int64_t a, const int64_t b)
 
static void NTL::MulSubFrom (int64_t &x, int64_t a, int64_t b)
 
static void NTL::LeftShift (int64_t &x, const int64_t a, int64_t k)
 
static void NTL::RightShift (int64_t &x, const int64_t a, int64_t k)
 
static void NTL::mul (vector64 &x, const vector64 &a, const int64_t b)
 
static void NTL::add (vector64 &x, const vector64 &a, const vector64 &b)
 
static void NTL::sub (vector64 &x, const vector64 &a, const vector64 &b)
 
Vec_64 NTL::operator* (const Vec_64 &vec, std::int64_t a)
 These are operator overloads for Mat_64 and Vec_64 types.
 
Vec_64 NTL::operator* (std::int64_t a, const Vec_64 &vec)
 
std::int64_t NTL::operator* (const Vec_64 &vec1, const Vec_64 &vec2)
 
Vec_64NTL::operator+= (Vec_64 &vec1, const Vec_64 &vec2)
 
Vec_64NTL::operator-= (Vec_64 &vec1, const Vec_64 &vec2)
 
Vec_64NTL::operator*= (Vec_64 &vec, std::int64_t a)
 
Mat_64NTL::operator*= (Mat_64 &mat, std::int64_t a)
 
Mat_64 NTL::operator* (const Mat_64 &mat1, const Mat_64 &mat2)
 
void NTL::ident (Mat_64 &mat, int64_t dim)
 Transforms mat into the identity matrix of dimensions \(\text{dim}\times\text{dim}\).
 
double NTL::determinant (const Mat_64 &mat)
 Computes and returns the determinant of ‘mat’.