Welcome to generalized niederreiter sequence’s documentation!

namespace gns

Typedefs

typedef testing::Types<Matrix<2>, Matrix<4>> IsIdentityTestType

Enums

enum EnumPolynomialExpression

Values:

INTEGER = 0

if base is 2, binary expression. If base is 16, this is same as hexadecimal expression. For example, base=16, coeffs = {0, 1, 0}.

COEFFICIENTS
POLYNOMIAL

Functions

template <int N>
unsigned char getLowestSiginicantBit(const unsigned char value, const int base)

Return
Parameters
  • value:
  • base:

template <int N>
unsigned char add(const unsigned char left, const unsigned char right)

Return
Parameters
  • left:
  • right:

template <int N>
unsigned char sub(const unsigned char left, const unsigned char right)

Return
Parameters
  • left:
  • right:

template <int N>
unsigned char mult(const unsigned char left, const unsigned char right)

Return
Parameters
  • left:
  • right:

template <int N>
unsigned char div(const unsigned char left, const unsigned char right)

Return
Parameters
  • left:
  • right:

template <>
template<>
unsigned char add<2>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char sub<2>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char mult<2>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char div<2>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char add<4>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char sub<4>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char mult<4>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char div<4>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char add<16>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char sub<16>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char mult<16>(const unsigned char left, const unsigned char right)
template <>
template<>
unsigned char div<16>(const unsigned char left, const unsigned char right)
template <int Base>
std::ostream &operator<<(std::ostream &os, const GaloisField<Base> &x)
template <int Base>
GaloisField<Base> operator+(const GaloisField<Base> &e1, const GaloisField<Base> &e2)
template <int Base>
GaloisField<Base> operator+(const GaloisField<Base> &e1, const unsigned int e2)
template <int Base>
GaloisField<Base> operator+(const unsigned int e1, const GaloisField<Base> &e2)
template <int Base>
GaloisField<Base> operator-(const GaloisField<Base> &e1, const GaloisField<Base> &e2)
template <int Base>
GaloisField<Base> operator*(const GaloisField<Base> &e1, const GaloisField<Base> &e2)
template <int Base>
GaloisField<Base> operator/(const GaloisField<Base> &e1, const GaloisField<Base> &e2)
template <int Base>
GaloisField<Base> operator-(const GaloisField<Base> &e1)
template <>
GaloisField<2> operator+(const GaloisField<2> &e1, const GaloisField<2> &e2)
template <>
GaloisField<2> operator+(const GaloisField<2> &e1, const unsigned int e2)
template <>
GaloisField<2> operator+(const unsigned int e1, const GaloisField<2> &e2)
template <>
GaloisField<2> operator-(const GaloisField<2> &e1, const GaloisField<2> &e2)
template <>
GaloisField<2> operator*(const GaloisField<2> &e1, const GaloisField<2> &e2)
template <>
GaloisField<2> operator/(const GaloisField<2> &e1, const GaloisField<2> &e2)
template <>
GaloisField<2> operator-(const GaloisField<2> &e1)
template <>
GaloisField<4> operator+(const GaloisField<4> &e1, const GaloisField<4> &e2)
template <>
GaloisField<4> operator-(const GaloisField<4> &e1, const GaloisField<4> &e2)
template <>
GaloisField<4> operator*(const GaloisField<4> &e1, const GaloisField<4> &e2)
template <>
GaloisField<4> operator/(const GaloisField<4> &e1, const GaloisField<4> &e2)
template <>
GaloisField<4> operator-(const GaloisField<4> &e1)
template <>
GaloisField<16> operator+(const GaloisField<16> &e1, const GaloisField<16> &e2)
template <>
GaloisField<16> operator-(const GaloisField<16> &e1, const GaloisField<16> &e2)
template <>
GaloisField<16> operator*(const GaloisField<16> &e1, const GaloisField<16> &e2)
template <>
GaloisField<16> operator/(const GaloisField<16> &e1, const GaloisField<16> &e2)
template <>
GaloisField<16> operator-(const GaloisField<16> &e1)
template <int Base>
void check_operator_add(const std::vector<unsigned int> &test_case_data, std::vector<GaloisField<Base>> &test_case)
TEST(GaloisFieldOperatorTest, OperatorAdd)
template <int Base>
void check_operator_sub(const std::vector<unsigned int> &test_case_data, std::vector<GaloisField<Base>> &test_case)
TEST(GaloisFieldOperatorTest, OperatorSub)
template <int Base>
void check_operator_mult(const std::vector<unsigned int> &test_case_data, std::vector<GaloisField<Base>> &test_case)
TEST(GaloisFieldOperatorTest, OperatorMult)
template <int Base>
void check_operator_div(const std::vector<unsigned int> &test_case_data, std::vector<GaloisField<Base>> &test_case)
TEST(GaloisFieldOperatorTest, OperatorDiv)
template <int Base>
void CheckOperatorAddMultiply(const std::vector<unsigned int> &test_case_data)
TEST(galois_field_operator, OperatorAddMultiplyTest)
template <int Base>
GaloisFieldPolynomial<Base> MakeGaloisFieldPolynomial(const char *str_data)
gns::TEMPLATE_INSTANTIATION(2)
gns::TEMPLATE_INSTANTIATION(4)
TEST(IrreduciblePolynomial, GetNextTest01)
TEST(IrreduciblePolynomial, GetNextTest02)
TEST(IrreduciblePolynomial, ConstructorTest)
TEST(IrreduciblePolynomial, OperatorParenthesisTest)
TEST(irreducible_polynomial_test, GetNext)
template <int Base>
int LaurentSeriesDivisionFirstEquations(const GaloisFieldPolynomial<Base> &a, const GaloisFieldPolynomial<Base> &b, std::unique_ptr<GaloisField<Base>[]> &c, const size_t array_size)

Solve the first part of equations up to array_size.

Return
the number of array size after solving equations. Negative value/zero means no space left.
Template Parameters
  • Base:
Parameters
  • a:
  • b:
  • c:
  • array_size:

template <int Base>
int LaurentSeriesDivisionSecondEquations(const GaloisFieldPolynomial<Base> &a, const GaloisFieldPolynomial<Base> &b, std::unique_ptr<GaloisField<Base>[]> &c, const size_t array_room)

Solve the second part of equations up to array_size.

Return
The number of room for array after solving equations. Negative value/zero means no space left.
Template Parameters
  • Base:
Parameters
  • a:
  • b:
  • c:
  • array_room: from 1 to maximum array size.

template <int Base>
void LaurentSeriesDivisionLastEquations(const GaloisFieldPolynomial<Base> &a, const GaloisFieldPolynomial<Base> &b, std::unique_ptr<GaloisField<Base>[]> &c, const size_t array_size)

Solve equiations and substitute the solution up to array_size.

Template Parameters
  • Base:
Parameters
  • a:
  • b:
  • c:
  • array_size: the size of array c.

template <int Base>
std::unique_ptr<GaloisField<Base>[]> SolveLaurentSeriesDivision(const GaloisFieldPolynomial<Base> &a, const GaloisFieldPolynomial<Base> &b, const size_t max_degree)

Return
Template Parameters
  • Base:
Parameters
  • a:
  • b:
  • max_degree:

TEST(laurent_series_test, LaurentSeriesDivisionFirstEquations)
TEST(laurent_series_test, LaurentSeriesDivisionSecondEquations)
TEST(laurent_series_test, LaurentSeriesDivisionLastEquations)
TEST(laurent_series_test, SolveLaurentSeriesDivision)
template <int Base>
std::ostream &operator<<(std::ostream &os, const Matrix<Base> &matrix)
template <int Base>
bool IsIdentity(const Matrix<Base> &matrix)
gns::TEMPLATE_INSTANTIATION(16)
TYPED_TEST_CASE(TypedTest, IsIdentityTestType)
TYPED_TEST(TypedTest, IsIdentity)
template <int Base>
Vector<Base> operator*(const Matrix<Base> &m, const Vector<Base> &v)

Return
Template Parameters
  • Base:
Parameters
  • m:
  • v:

TEST(matrix_operator, OperatorMultiplyMatrixVectorTest)
TEST(Matrix, ConstructorTest)
TEST(Matrix, RowSizeTest)
TEST(Matrix, ColSizeTest)
TEST(Matrix, OperatorParenthesisTest)
template <int Base>
std::ostream &operator<<(std::ostream &os, const GaloisFieldPolynomial<Base> &x)

Return
Template Parameters
  • Base:
Parameters
  • os:
  • x:

template <int Base>
GaloisFieldPolynomial<Base> MakeBasePolynomial(const size_t degree, const GaloisField<Base> &coeff)

Return
Template Parameters
  • Base:
Parameters
  • degree:
  • coeff:

template <int Base>
std::pair<GaloisFieldPolynomial<Base>, GaloisFieldPolynomial<Base>> EuclideanDivision(const GaloisFieldPolynomial<Base> &dividend, const GaloisFieldPolynomial<Base> &divisor)

Return
Template Parameters
  • Base:
Parameters
  • dividend:
  • divisor: dividend = quotient * divisor + residual

TEST(Polynomial, ConstructorTest)
TEST(Polynomial, CopyConstructorTest)
TEST(Polynomial, OperatorAssignTest)
TEST(Polynomial, OperatorPlusTest01)
TEST(Polynomial, OperatorPlusTest02)
TEST(Polynomial, OperatorPlusTest03)
TEST(Polynomial, OperatorPlusTest04)
TEST(Polynomial, OperatorPlusTest05)
TEST(Polynomial, OperatorPlusTest06)
TEST(PolynomialTest, OperatorSubTest)
TEST(PolynomialTest, operatorMultiplyTest)
TEST(PolynomialTest, IsZeroTest)
TEST(PolynomialTest, MakeBasePolynomial)
TEST(PolynomialTest, EuclidianDivisionTest)
TEST(polynomial, ToStringTest)
template <int Base>
GaloisFieldPolynomial<Base> GetSobolGeneratorPolynomial(const size_t dim, const size_t i, const size_t k)

Return
Template Parameters
  • Base:
Parameters
  • dim: dimension of generator polynomial. 1 to maximum dimension.
  • i:
  • k:

template <int Base>
Matrix<Base> MakeSobolGeneratorMatrix(const size_t dim, const std::vector<GaloisFieldPolynomial<Base>> &irreducibles, const size_t max_bit)

Return
Template Parameters
  • Base:
Parameters
  • dim: dimension of generator matrix. 1 to maximum dimension.
  • irreducibles:
  • max_bit:

template <int Base>
std::vector<Matrix<Base>> MakeSobolGeneratorMatrices(const size_t dimension, const size_t max_bit)

Return
Template Parameters
  • Base:

TEST(sequence_sobol_test, MakeSobolGeneratorMatrix1)
TEST(sequence_sobol_test, MakeSobolGeneratorMatrix4)
TEST(sequence_sobol_test, MakeSobolGeneratorMatrix2)
TEST(sequence_sobol_test, Next)
TEST(sequence_sobol_test, SobolGrayMapNext)
TEST(sequence_sobol_test, Next4)
template <typename T1, typename T2>
inline testing::AssertionResult IsElementEqual(const std::vector<T1> &v1, const std::vector<T2> &v2)
template <int Base>
inline testing::AssertionResult IsGaloisFieldOperatorCorrect(const std::vector<GaloisField<Base>> &test_case, std::function<GaloisField<Base>(const GaloisField<Base>&, const GaloisField<Base>&)> operation)
template <typename T1, typename T2, typename Index>
inline testing::AssertionResult IsExpectEqualWithIndex(const T1 &expect, const T2 &actual, const Index &i)
template <typename T>
std::reverse_iterator<T *> rbegin(T *v)
template <typename T>
std::reverse_iterator<T *> rend(T *v)
template <int Base>
std::pair<size_t, std::unique_ptr<GaloisField<Base>[]>> CalculateBaseAdic(size_t num)
template <int Base>
double BaseAdicToDouble(const Vector<Base> &base_adic)
TEST(util_test, CalculateBaseAdic2)
TEST(util_test, CalculateBaseAdic4)
TEST(util_test, BaseAdicToDouble2)
TEST(util_test, BaseAdicToDouble4)
template <int Base>
std::ostream &operator<<(std::ostream &os, const Vector<Base> &vector)
TEST(Vector, ConstructorTest)
TEST(Vector, SizeTest)
TEST(Vector, OperatorParenthesisTest)
template <int Base>
class IrreduciblePolynomialGenerator
#include <irreducible_polynomial.h>

Template Parameters
  • Base:

template <int Base>
class Sobol
#include <sequence_sobol.h>

Template Parameters
  • Base:

template <int Base>
class SobolGrayMap
#include <sequence_sobol.h>

Template Parameters
  • Base:

template <typename T>
class TypedTest

Inherits from Test

namespace test_util

Functions

template <int Base>
std::unique_ptr<GaloisField<Base>[]> MakeGaloisFieldArray(std::initializer_list<unsigned int> data)

Return
Template Parameters
  • Base:
Parameters
  • max_degree:
  • data:

gns::test_util::TEMPLATE_INSTANTIATION(2)
gns::test_util::TEMPLATE_INSTANTIATION(4)
gns::test_util::TEMPLATE_INSTANTIATION(16)

Indices and tables