ring

package

Go to main page

Versions in this module

v2

deprecated

v2.4.1

Nov 15, 2023

v2.4.0

Jan 10, 2022

Changes in this version

+ const ConjugateInvariant

+ const Standard

+ func AddScalarNoModAndNegTwoQiNoModVec(p1, p2 []uint64, scalar, qi uint64)

+ func AddScalarNoModVec(p1, p2 []uint64, scalar uint64)

+ func AddScalarVec(p1, p2 []uint64, scalar, qi uint64)

+ func AddVec(p1, p2, p3 []uint64, qi uint64)

+ func AddVecNoMod(p1, p2, p3 []uint64)

+ func AddVecNoModAndMulScalarMontgomeryVec(p1, p2, p3 []uint64, scalarMont, qi, mredParams uint64)

+ func InvMFormVec(p1, p2 []uint64, qi, mredParams uint64)

+ func InvNTTConjugateInvariant(coeffsIn, coeffsOut []uint64, N int, nttPsiInv []uint64, ...)

+ func InvNTTConjugateInvariantLazy(coeffsIn, coeffsOut []uint64, N int, nttPsiInv []uint64, ...)

+ func MFormConstantVec(p1, p2 []uint64, qi uint64, bredParams []uint64)

+ func ModVec(p1, p2 []uint64, m uint64, bredParams []uint64)

+ func MulByPow2Vec(p1, p2 []uint64, pow2 int, qi, mredParams uint64)

+ func MulCoeffsAndAddNoModVec(p1, p2, p3 []uint64, qi uint64, bredParams []uint64)

+ func MulCoeffsAndAddVec(p1, p2, p3 []uint64, qi uint64, bredParams []uint64)

+ func MulCoeffsConstantVec(p1, p2, p3 []uint64, qi uint64, bredParams []uint64)

+ func MulCoeffsMontgomeryAndAddNoModVec(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryAndAddVec(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryAndSubNoMod(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryAndSubVec(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryConstantAndAddNoModVec(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryConstantAndNeg(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryConstantAndSubNoMod(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryConstantVec(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsMontgomeryVec(p1, p2, p3 []uint64, qi, mredParams uint64)

+ func MulCoeffsVec(p1, p2, p3 []uint64, qi uint64, bredParams []uint64)

+ func MulScalarMontgomeryAndAddVec(p1, p2 []uint64, scalarMont, qi, mredParams uint64)

+ func MulScalarMontgomeryConstantVec(p1, p2 []uint64, scalarMont, qi, mredParams uint64)

+ func MulScalarMontgomeryVec(p1, p2 []uint64, scalarMont, qi, mredParams uint64)

+ func NTTConjugateInvariant(coeffsIn, coeffsOut []uint64, N int, nttPsi []uint64, Q, QInv uint64, ...)

+ func NTTConjugateInvariantLazy(coeffsIn, coeffsOut []uint64, N int, nttPsi []uint64, Q, QInv uint64, ...)

+ func NegVec(p1, p2 []uint64, qi uint64)

+ func PadDefaultRingToConjuateInvariant(p1 *Poly, ringQ *Ring, p2 *Poly)

+ func ReduceConstantVec(p1, p2 []uint64, qi uint64, bredParams []uint64)

+ func ReduceVec(p1, p2 []uint64, qi uint64, bredParams []uint64)

+ func SubScalarVec(p1, p2 []uint64, scalar, qi uint64)

+ func SubVec(p1, p2, p3 []uint64, qi uint64)

+ func SubVecAndMulScalarMontgomeryTwoQiVec(p1, p2, p3 []uint64, scalarMont, qi, mredParams uint64)

+ func SubVecNomod(p1, p2, p3 []uint64, qi uint64)

+ type NumberTheoreticTransformer interface

+ Backward func(r *Ring, p1, p2 *Poly)

+ BackwardLazy func(r *Ring, p1, p2 *Poly)

+ BackwardLazyLvl func(r *Ring, level int, p1, p2 *Poly)

+ BackwardLazyVec func(r *Ring, level int, p1, p2 []uint64)

+ BackwardLvl func(r *Ring, level int, p1, p2 *Poly)

+ BackwardVec func(r *Ring, level int, p1, p2 []uint64)

+ Forward func(r *Ring, p1, p2 *Poly)

+ ForwardLazy func(r *Ring, p1, p2 *Poly)

+ ForwardLazyLvl func(r *Ring, level int, p1, p2 *Poly)

+ ForwardLazyVec func(r *Ring, level int, p1, p2 []uint64)

+ ForwardLvl func(r *Ring, level int, p1, p2 *Poly)

+ ForwardVec func(r *Ring, level int, p1, p2 []uint64)

+ type NumberTheoreticTransformerConjugateInvariant struct

+ func (rntt NumberTheoreticTransformerConjugateInvariant) Backward(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) BackwardLazy(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) BackwardLazyLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) BackwardLazyVec(r *Ring, level int, p1, p2 []uint64)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) BackwardLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) BackwardVec(r *Ring, level int, p1, p2 []uint64)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) Forward(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) ForwardLazy(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) ForwardLazyLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) ForwardLazyVec(r *Ring, level int, p1, p2 []uint64)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) ForwardLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerConjugateInvariant) ForwardVec(r *Ring, level int, p1, p2 []uint64)

+ type NumberTheoreticTransformerStandard struct

+ func (rntt NumberTheoreticTransformerStandard) Backward(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) BackwardLazy(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) BackwardLazyLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) BackwardLazyVec(r *Ring, level int, p1, p2 []uint64)

+ func (rntt NumberTheoreticTransformerStandard) BackwardLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) BackwardVec(r *Ring, level int, p1, p2 []uint64)

+ func (rntt NumberTheoreticTransformerStandard) Forward(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) ForwardLazy(r *Ring, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) ForwardLazyLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) ForwardLazyVec(r *Ring, level int, p1, p2 []uint64)

+ func (rntt NumberTheoreticTransformerStandard) ForwardLvl(r *Ring, level int, p1, p2 *Poly)

+ func (rntt NumberTheoreticTransformerStandard) ForwardVec(r *Ring, level int, p1, p2 []uint64)

type Ring

+ NthRoot uint64

+ func NewRingConjugateInvariant(N int, Moduli []uint64) (r *Ring, err error)

+ func NewRingFromType(N int, Moduli []uint64, ringType Type) (r *Ring, err error)

+ func NewRingWithCustomNTT(N int, Moduli []uint64, ntt NumberTheoreticTransformer, NthRoot int) (r *Ring, err error)

+ func (r *Ring) AddScalarBigintLvl(level int, p1 *Poly, scalar *big.Int, p2 *Poly)

+ func (r *Ring) AddScalarLvl(level int, p1 *Poly, scalar uint64, p2 *Poly)

+ func (r *Ring) ConjugateInvariantRing() (*Ring, error)

+ func (r *Ring) FoldStandardToConjugateInvariant(level int, polyStandard *Poly, permuteNTTIndexInv []uint64, ...)

+ func (r *Ring) InvNTTSingle(level int, p1, p2 []uint64)

+ func (r *Ring) InvNTTSingleLazy(level int, p1, p2 []uint64)

+ func (r *Ring) MFormConstantLvl(level int, p1, p2 *Poly)

+ func (r *Ring) ModLvl(level int, p1 *Poly, m uint64, p2 *Poly)

+ func (r *Ring) MulByVectorMontgomeryAndAddNoModLvl(level int, p1 *Poly, vector []uint64, p2 *Poly)

+ func (r *Ring) MulByVectorMontgomeryLvl(level int, p1 *Poly, vector []uint64, p2 *Poly)

+ func (r *Ring) MulCoeffsAndAddLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsAndAddNoModLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsConstantLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndSubNoModLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryConstantAndNegLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryConstantAndSubNoModLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) NTTSingle(level int, p1, p2 []uint64)

+ func (r *Ring) NTTSingleLazy(level int, p1, p2 []uint64)

+ func (r *Ring) PermuteNTT(polIn *Poly, gen uint64, polOut *Poly)

+ func (r *Ring) PermuteNTTIndex(galEl uint64) (index []uint64)

+ func (r *Ring) PermuteNTTLvl(level int, polIn *Poly, gen uint64, polOut *Poly)

+ func (r *Ring) PermuteNTTWithIndexAndAddNoModLvl(level int, polIn *Poly, index []uint64, polOut *Poly)

+ func (r *Ring) PermuteNTTWithIndexLvl(level int, polIn *Poly, index []uint64, polOut *Poly)

+ func (r *Ring) StandardRing() (*Ring, error)

+ func (r *Ring) SubScalarBigintLvl(level int, p1 *Poly, scalar *big.Int, p2 *Poly)

+ func (r *Ring) SubScalarLvl(level int, p1 *Poly, scalar uint64, p2 *Poly)

+ func (r *Ring) Type() Type

+ func (r *Ring) UnfoldConjugateInvariantToStandard(level int, polyConjugateInvariant, polyStd *Poly)

+ type Type int

+ func (rt *Type) UnmarshalJSON(b []byte) error

+ func (rt Type) MarshalJSON() ([]byte, error)

+ func (rt Type) String() string

v2.3.0

Oct 12, 2021

Changes in this version

+ func MFormVec(p0, p1 []uint64, qi uint64, bredParams []uint64)

+ func MapSmallDimensionToLargerDimensionNTT(polSmall, polLarge *Poly)

+ func ModexpMontgomery(x uint64, e int, q, qInv uint64, bredParams []uint64) (result uint64)

type FastBasisExtender

+ func (basisextender *FastBasisExtender) ModDownQPtoP(levelQ, levelP int, p1Q, p1P, p2P *Poly)

+ func (basisextender *FastBasisExtender) ModDownQPtoQ(levelQ, levelP int, p1Q, p1P, p2Q *Poly)

+ func (basisextender *FastBasisExtender) ModDownQPtoQNTT(levelQ, levelP int, p1Q, p1P, p2Q *Poly)

+ func (basisextender *FastBasisExtender) ModUpPtoQ(levelP, levelQ int, polP, polQ *Poly)

+ func (basisextender *FastBasisExtender) ModUpQtoP(levelQ, levelP int, polQ, polP *Poly)

type Ring

+ func (r *Ring) DivFloorByLastModulusLvl(level int, p0, p1 *Poly)

+ func (r *Ring) DivFloorByLastModulusManyLvl(level, nbRescales int, p0, pool, p1 *Poly)

+ func (r *Ring) DivFloorByLastModulusManyNTTLvl(level, nbRescales int, p0, pool, p1 *Poly)

+ func (r *Ring) DivFloorByLastModulusNTTLvl(level int, p0, pool, p1 *Poly)

+ func (r *Ring) DivRoundByLastModulusLvl(level int, p0, p1 *Poly)

+ func (r *Ring) DivRoundByLastModulusManyLvl(level, nbRescales int, p0, pool, p1 *Poly)

+ func (r *Ring) DivRoundByLastModulusManyNTTLvl(level, nbRescales int, p0, pool, p1 *Poly)

+ func (r *Ring) DivRoundByLastModulusNTTLvl(level int, p0, pool, p1 *Poly)

+ type Sampler interface

+ Read func(pOut *Poly)

v2.2.0

Jul 15, 2021

Changes in this version

+ func Copy(p0, p1 *Poly)

+ func CopyLvl(level int, p0, p1 *Poly)

+ func CopyValues(p0, p1 *Poly)

+ func CopyValuesLvl(level int, p0, p1 *Poly)

type FastBasisExtender

+ func (basisextender *FastBasisExtender) ShallowCopy() *FastBasisExtender

type GaussianSampler

+ func (gaussianSampler *GaussianSampler) ReadAndAddFromDistLvl(level int, pol *Poly, ring *Ring, sigma float64, bound int)

+ func (gaussianSampler *GaussianSampler) ReadFromDistLvl(level int, pol *Poly, ring *Ring, sigma float64, bound int)

type Poly

+ IsMForm bool

+ IsNTT bool

+ func (pol *Poly) CopyValues(p1 *Poly)

+ func (pol *Poly) Degree() int

+ func (pol *Poly) Equals(other *Poly) bool

+ func (pol *Poly) LenModuli() int

+ func (pol *Poly) Level() int

type Ring

+ func (r *Ring) MulCoeffsMontgomeryAndSubLvl(level int, p1, p2, p3 *Poly)

+ func (r *Ring) PolyToBigintCenteredLvl(level int, p1 *Poly, coeffsBigint []*big.Int)

+ func (r *Ring) PolyToBigintLvl(level int, p1 *Poly, coeffsBigint []*big.Int)

type UniformSampler

+ func (uniformSampler *UniformSampler) ReadLvl(level int, Pol *Poly)

v2.1.1

Dec 23, 2020

v2.1.0

Dec 11, 2020

Changes in this version

+ func InvNTTLazy(coeffsIn, coeffsOut []uint64, N uint64, nttPsiInv []uint64, ...)

+ func NTTLazy(coeffsIn, coeffsOut []uint64, N uint64, nttPsi []uint64, Q, QInv uint64, ...)

+ func NextNTTPrime(q, NthRoot uint64) (qNext uint64, err error)

+ func PreviousNTTPrime(q, NthRoot uint64) (qPrev uint64, err error)

type GaussianSampler

+ func (gaussianSampler *GaussianSampler) ReadLvlNew(level uint64) (pol *Poly)

type Ring

+ func (r *Ring) InvMFormLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) InvNTTLazy(p1, p2 *Poly)

+ func (r *Ring) InvNTTLazyLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryConstantAndAddNoMod(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryConstantLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) NTTLazy(p1, p2 *Poly)

+ func (r *Ring) NTTLazyLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) ReduceConstant(p1, p2 *Poly)

+ func (r *Ring) ReduceConstantLvl(level uint64, p1, p2 *Poly)

type TernarySampler

+ func (ts *TernarySampler) ReadLvl(lvl uint64, pol *Poly)

+ func (ts *TernarySampler) ReadLvlNew(lvl uint64) (pol *Poly)

type UniformSampler

+ func (uniformSampler *UniformSampler) ReadLvlNew(level uint64) (Pol *Poly)

v2.0.0

Oct 9, 2020

Changes in this version

+ const SimpleScalerFloatPrecision

+ var DefaultParams = []*Parameters

+ var Pi60 = []uint64

+ var Qi60 = []uint64

+ func BRed(x, y, q uint64, u []uint64) (r uint64)

+ func BRedAdd(a, q uint64, u []uint64) (r uint64)

+ func BRedAddConstant(x, q uint64, u []uint64) uint64

+ func BRedConstant(x, y, q uint64, u []uint64) (r uint64)

+ func BRedParams(q uint64) (params []uint64)

+ func CRed(a, q uint64) uint64

+ func Cos(x *big.Float) (cosx *big.Float)

+ func DecodeCoeffs(pointer, N, numberModuli uint64, coeffs [][]uint64, data []byte) (uint64, error)

+ func DecodeCoeffsNew(pointer, N, numberModuli uint64, coeffs [][]uint64, data []byte) (uint64, error)

+ func DecodeCoeffsNew32(pointer, N, numberModuli uint64, coeffs [][]uint64, data []byte) (uint64, error)

+ func DivRound(a, b, i *big.Int)

+ func GenGaloisParams(n, gen uint64) (galElRotCol []uint64)

+ func GenerateNTTPrimes(logQ, logN, levels uint64) (primes []uint64)

+ func GenerateNTTPrimesP(logP, logN, n uint64) (primes []uint64)

+ func GenerateNTTPrimesQ(logQ, logN, levels uint64) (primes []uint64)

+ func InvMForm(a, q, qInv uint64) (r uint64)

+ func InvMFormConstant(a, q, qInv uint64) (r uint64)

+ func InvNTT(coeffsIn, coeffsOut []uint64, N uint64, nttPsiInv []uint64, ...)

+ func InvNTTBarrett(coeffsIn, coeffsOut []uint64, N uint64, nttPsiInv []uint64, nttNInv, Q uint64, ...)

+ func IsPrime(num uint64) bool

+ func MForm(a, q uint64, u []uint64) (r uint64)

+ func MFormConstant(a, q uint64, u []uint64) (r uint64)

+ func MRed(x, y, q, qInv uint64) (r uint64)

+ func MRedConstant(x, y, q, qInv uint64) (r uint64)

+ func MRedParams(q uint64) (qInv uint64)

+ func Min(x, y int) int

+ func ModExp(x, e, p uint64) (result uint64)

+ func NTT(coeffsIn, coeffsOut []uint64, N uint64, nttPsi []uint64, Q, mredParams uint64, ...)

+ func NTTBarrett(coeffsIn, coeffsOut []uint64, N uint64, nttPsi []uint64, Q uint64, ...)

+ func NewFloat(x float64, logPrecision uint64) (y *big.Float)

+ func NewInt(v int64) *big.Int

+ func NewIntFromString(s string) *big.Int

+ func NewUint(v uint64) *big.Int

+ func PermuteNTT(polIn *Poly, gen uint64, polOut *Poly)

+ func PermuteNTTIndex(gen, power, N uint64) (index []uint64)

+ func PermuteNTTLvl(level uint64, polIn *Poly, gen uint64, polOut *Poly)

+ func PermuteNTTWithIndexAndAddNoModLvl(level uint64, polIn *Poly, index []uint64, polOut *Poly)

+ func PermuteNTTWithIndexLvl(level uint64, polIn *Poly, index []uint64, polOut *Poly)

+ func PowerOf2(x, n, q, qInv uint64) (r uint64)

+ func RandInt(max *big.Int) (n *big.Int)

+ func RandUniform(prng utils.PRNG, v uint64, mask uint64) (randomInt uint64)

+ func WriteCoeffsTo(pointer, N, numberModuli uint64, coeffs [][]uint64, data []byte) (uint64, error)

+ func WriteCoeffsTo32(pointer, N, numberModuli uint64, coeffs [][]uint64, data []byte) (uint64, error)

+ type Complex [2]*big.Float

+ func NewComplex(a, b *big.Float) (c *Complex)

+ func (c *Complex) Add(a, b *Complex)

+ func (c *Complex) Copy() *Complex

+ func (c *Complex) Float64() complex128

+ func (c *Complex) Imag() *big.Float

+ func (c *Complex) Real() *big.Float

+ func (c *Complex) Set(a *Complex)

+ func (c *Complex) Sub(a, b *Complex)

+ type ComplexMultiplier struct

+ func NewComplexMultiplier() (cEval *ComplexMultiplier)

+ func (cEval *ComplexMultiplier) Div(a, b, c *Complex)

+ func (cEval *ComplexMultiplier) Mul(a, b, c *Complex)

+ type Decomposer struct

+ PInt *big.Int

+ QInt *big.Int

+ func NewDecomposer(Q, P []uint64) (decomposer *Decomposer)

+ func (decomposer *Decomposer) Decompose(level, crtDecompLevel uint64, p0, p1 *Poly)

+ func (decomposer *Decomposer) DecomposeAndSplit(level, crtDecompLevel uint64, p0, p1Q, p1P *Poly)

+ func (decomposer *Decomposer) Xalpha() (xalpha []uint64)

+ type FastBasisExtender struct

+ func NewFastBasisExtender(ringQ, ringP *Ring) *FastBasisExtender

+ func (basisextender *FastBasisExtender) ModDownNTTPQ(level uint64, p1, p2 *Poly)

+ func (basisextender *FastBasisExtender) ModDownPQ(level uint64, p1, p2 *Poly)

+ func (basisextender *FastBasisExtender) ModDownSplitNTTPQ(level uint64, p1Q, p1P, p2 *Poly)

+ func (basisextender *FastBasisExtender) ModDownSplitPQ(level uint64, p1Q, p1P, p2 *Poly)

+ func (basisextender *FastBasisExtender) ModDownSplitQP(levelQ, levelP uint64, p1Q, p1P, p2 *Poly)

+ func (basisextender *FastBasisExtender) ModUpSplitPQ(level uint64, p1, p2 *Poly)

+ func (basisextender *FastBasisExtender) ModUpSplitQP(level uint64, p1, p2 *Poly)

+ type GaussianSampler struct

+ func NewGaussianSampler(prng utils.PRNG, baseRing *Ring, sigma float64, bound uint64) *GaussianSampler

+ func (gaussianSampler *GaussianSampler) Read(pol *Poly)

+ func (gaussianSampler *GaussianSampler) ReadAndAdd(pol *Poly)

+ func (gaussianSampler *GaussianSampler) ReadAndAddLvl(level uint64, pol *Poly)

+ func (gaussianSampler *GaussianSampler) ReadLvl(level uint64, pol *Poly)

+ func (gaussianSampler *GaussianSampler) ReadNew() (pol *Poly)

+ type Parameters struct

+ type Poly struct

+ Coeffs [][]uint64

+ func NewPoly(N, nbModuli uint64) (pol *Poly)

+ func (pol *Poly) Copy(p1 *Poly)

+ func (pol *Poly) CopyNew() (p1 *Poly)

+ func (pol *Poly) DecodePolyNew(data []byte) (pointer uint64, err error)

+ func (pol *Poly) DecodePolyNew32(data []byte) (pointer uint64, err error)

+ func (pol *Poly) GetCoefficients() (coeffs [][]uint64)

+ func (pol *Poly) GetDataLen(WithMetadata bool) (cnt uint64)

+ func (pol *Poly) GetDataLen32(WithMetadata bool) (cnt uint64)

+ func (pol *Poly) GetDegree() int

+ func (pol *Poly) GetLenModuli() int

+ func (pol *Poly) MarshalBinary() (data []byte, err error)

+ func (pol *Poly) SetCoefficients(coeffs [][]uint64)

+ func (pol *Poly) UnmarshalBinary(data []byte) (err error)

+ func (pol *Poly) WriteCoeffs(data []byte) (uint64, error)

+ func (pol *Poly) WriteTo(data []byte) (uint64, error)

+ func (pol *Poly) WriteTo32(data []byte) (uint64, error)

+ func (pol *Poly) Zero()

+ type RNSScaler struct

+ func NewRNSScaler(t uint64, ringQ *Ring) (rnss *RNSScaler)

+ func (rnss *RNSScaler) DivByQOverTRounded(p1Q, p2T *Poly)

+ type Ring struct

+ BredParams [][]uint64

+ Mask []uint64

+ Modulus []uint64

+ ModulusBigint *big.Int

+ MredParams []uint64

+ N uint64

+ NttNInv []uint64

+ NttPsi [][]uint64

+ NttPsiInv [][]uint64

+ PsiInvMont []uint64

+ PsiMont []uint64

+ RescaleParams [][]uint64

+ func NewRing(N uint64, Moduli []uint64) (r *Ring, err error)

+ func (r *Ring) AND(p1 *Poly, m uint64, p2 *Poly)

+ func (r *Ring) Add(p1, p2, p3 *Poly)

+ func (r *Ring) AddLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) AddNoMod(p1, p2, p3 *Poly)

+ func (r *Ring) AddNoModLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) AddScalar(p1 *Poly, scalar uint64, p2 *Poly)

+ func (r *Ring) AddScalarBigint(p1 *Poly, scalar *big.Int, p2 *Poly)

+ func (r *Ring) AllowsNTT() bool

+ func (r *Ring) BitReverse(p1, p2 *Poly)

+ func (r *Ring) Copy(p0, p1 *Poly)

+ func (r *Ring) CopyLvl(level uint64, p0, p1 *Poly)

+ func (r *Ring) DivFloorByLastModulus(p0 *Poly)

+ func (r *Ring) DivFloorByLastModulusMany(p0 *Poly, nbRescales uint64)

+ func (r *Ring) DivFloorByLastModulusManyNTT(p0 *Poly, nbRescales uint64)

+ func (r *Ring) DivFloorByLastModulusNTT(p0 *Poly)

+ func (r *Ring) DivRoundByLastModulus(p0 *Poly)

+ func (r *Ring) DivRoundByLastModulusMany(p0 *Poly, nbRescales uint64)

+ func (r *Ring) DivRoundByLastModulusManyNTT(p0 *Poly, nbRescales uint64)

+ func (r *Ring) DivRoundByLastModulusNTT(p0 *Poly)

+ func (r *Ring) Equal(p1, p2 *Poly) bool

+ func (r *Ring) EqualLvl(level uint64, p1, p2 *Poly) bool

+ func (r *Ring) Exp(p1 *Poly, e uint64, p2 *Poly)

+ func (r *Ring) GetBredParams() [][]uint64

+ func (r *Ring) GetMredParams() []uint64

+ func (r *Ring) GetNttNInv() []uint64

+ func (r *Ring) GetNttPsi() [][]uint64

+ func (r *Ring) GetNttPsiInv() [][]uint64

+ func (r *Ring) GetPsi() []uint64

+ func (r *Ring) GetPsiInv() []uint64

+ func (r *Ring) InvMForm(p1, p2 *Poly)

+ func (r *Ring) InvNTT(p1, p2 *Poly)

+ func (r *Ring) InvNTTBarrett(p1, p2 *Poly)

+ func (r *Ring) InvNTTLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) MForm(p1, p2 *Poly)

+ func (r *Ring) MFormLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) MarshalBinary() ([]byte, error)

+ func (r *Ring) Mod(p1 *Poly, m uint64, p2 *Poly)

+ func (r *Ring) MulByPow2(p1 *Poly, pow2 uint64, p2 *Poly)

+ func (r *Ring) MulByPow2Lvl(level uint64, p1 *Poly, pow2 uint64, p2 *Poly)

+ func (r *Ring) MulByPow2New(p1 *Poly, pow2 uint64) (p2 *Poly)

+ func (r *Ring) MulByVectorMontgomery(p1 *Poly, vector []uint64, p2 *Poly)

+ func (r *Ring) MulByVectorMontgomeryAndAddNoMod(p1 *Poly, vector []uint64, p2 *Poly)

+ func (r *Ring) MulCoeffs(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsAndAdd(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsAndAddNoMod(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsConstant(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomery(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndAdd(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndAddLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndAddNoMod(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndAddNoModLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndSub(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryAndSubNoMod(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryConstant(p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryConstantAndAddNoModLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) MulCoeffsMontgomeryLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) MulPoly(p1, p2, p3 *Poly)

+ func (r *Ring) MulPolyMontgomery(p1, p2, p3 *Poly)

+ func (r *Ring) MulPolyNaive(p1, p2, p3 *Poly)

+ func (r *Ring) MulPolyNaiveMontgomery(p1, p2, p3 *Poly)

+ func (r *Ring) MulScalar(p1 *Poly, scalar uint64, p2 *Poly)

+ func (r *Ring) MulScalarBigint(p1 *Poly, scalar *big.Int, p2 *Poly)

+ func (r *Ring) MulScalarBigintLvl(level uint64, p1 *Poly, scalar *big.Int, p2 *Poly)

+ func (r *Ring) MulScalarLvl(level uint64, p1 *Poly, scalar uint64, p2 *Poly)

+ func (r *Ring) MultByMonomial(p1 *Poly, monomialDeg uint64, p2 *Poly)

+ func (r *Ring) MultByMonomialNew(p1 *Poly, monomialDeg uint64) (p2 *Poly)

+ func (r *Ring) NTT(p1, p2 *Poly)

+ func (r *Ring) NTTBarrett(p1, p2 *Poly)

+ func (r *Ring) NTTLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) Neg(p1, p2 *Poly)

+ func (r *Ring) NegLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) NewPoly() *Poly

+ func (r *Ring) NewPolyLvl(level uint64) *Poly

+ func (r *Ring) OR(p1 *Poly, m uint64, p2 *Poly)

+ func (r *Ring) Permute(polIn *Poly, gen uint64, polOut *Poly)

+ func (r *Ring) PolyToBigint(p1 *Poly, coeffsBigint []*big.Int)

+ func (r *Ring) PolyToBigintNoAlloc(p1 *Poly, coeffsBigint []*big.Int)

+ func (r *Ring) PolyToString(p1 *Poly) []string

+ func (r *Ring) Reduce(p1, p2 *Poly)

+ func (r *Ring) ReduceLvl(level uint64, p1, p2 *Poly)

+ func (r *Ring) Rotate(p1 *Poly, n uint64, p2 *Poly)

+ func (r *Ring) SetCoefficientsBigint(coeffs []*big.Int, p1 *Poly)

+ func (r *Ring) SetCoefficientsBigintLvl(level uint64, coeffs []*big.Int, p1 *Poly)

+ func (r *Ring) SetCoefficientsInt64(coeffs []int64, p1 *Poly)

+ func (r *Ring) SetCoefficientsString(coeffs []string, p1 *Poly)

+ func (r *Ring) SetCoefficientsUint64(coeffs []uint64, p1 *Poly)

+ func (r *Ring) Shift(p1 *Poly, n uint64, p2 *Poly)

+ func (r *Ring) Sub(p1, p2, p3 *Poly)

+ func (r *Ring) SubLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) SubNoMod(p1, p2, p3 *Poly)

+ func (r *Ring) SubNoModLvl(level uint64, p1, p2, p3 *Poly)

+ func (r *Ring) SubScalar(p1 *Poly, scalar uint64, p2 *Poly)

+ func (r *Ring) SubScalarBigint(p1 *Poly, scalar *big.Int, p2 *Poly)

+ func (r *Ring) UnmarshalBinary(data []byte) error

+ func (r *Ring) XOR(p1 *Poly, m uint64, p2 *Poly)

+ type Scaler interface

+ DivByQOverTRounded func(p1, p2 *Poly)

+ type SimpleScaler struct

+ func NewSimpleScaler(t uint64, ringQ *Ring) (ss *SimpleScaler)

+ func (ss *SimpleScaler) DivByQOverTRounded(p1, p2 *Poly)

+ type TernarySampler struct

+ func NewTernarySampler(prng utils.PRNG, baseRing *Ring, p float64, montgomery bool) *TernarySampler

+ func NewTernarySamplerSparse(prng utils.PRNG, baseRing *Ring, hw uint64, montgomery bool) *TernarySampler

+ func (ts *TernarySampler) Read(pol *Poly)

+ func (ts *TernarySampler) ReadNew() (pol *Poly)

+ type UniformSampler struct

+ func NewUniformSampler(prng utils.PRNG, baseRing *Ring) *UniformSampler

+ func (uniformSampler *UniformSampler) Read(Pol *Poly)

+ func (uniformSampler *UniformSampler) ReadNew() (Pol *Poly)

+ func (uniformSampler *UniformSampler) Readlvl(level uint64, Pol *Poly)

Other modules containing this package

github.com/ldsec/lattigo

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL