Zn (math 2.1.0 API)

java.lang.Object
- org.cryptimeleon.math.structures.rings.zn.Zn

All Implemented Interfaces:

RepresentationRestorer, Representable, StandaloneRepresentable, Ring, Structure

Direct Known Subclasses:

Zp
```
public class Zn
extends java.lang.Object
implements Ring
```
The ring of integers modulo n.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class Zn.ZnElement
An equivalence class of integers with the same remainder when divided by n.

Nested Classes
Modifier and Type	Class and Description
`class`	`Zn.ZnElement` An equivalence class of integers with the same remainder when divided by n.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`maxByteLength` Maximum value (over all elements elem) of `elem.getInteger().toByteArray().length;`.
`protected java.math.BigInteger`	`n` The modulus.
`protected java.lang.Boolean`	`nIsPrime` Whether the modulus `n` is prime.
`protected Zn.ZnElement`	`ONE` The neutral element of this ring's unit group (the one element).
`protected Zn.ZnElement`	`ZERO` The neutral element of this ring's additive group (the zero element).

Constructor Summary

Constructors
Constructor and Description

Zn(java.math.BigInteger n)
Constructs the ring.

Zn(Representation repr)
Constructs the ring from a Representation.

Constructors
Constructor and Description
`Zn(java.math.BigInteger n)` Constructs the ring.
`Zn(Representation repr)` Constructs the ring from a `Representation`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Zn.ZnElement`	`createZnElement(java.math.BigInteger v)` Creates an element from a `BigInteger` (formally, the projection of \(v\) from \(\mathbb{Z}\) to \(\mathbb{Z}_n\)).
`protected Zn.ZnElement`	`createZnElementUnsafe(java.math.BigInteger vBetween0andN)` Instantiates a `ZnElement` without checking that the given representative is within the proper range.
`boolean`	`equals(java.lang.Object obj)`
`double`	`estimateCostInvPerOp()` Estimates the number of inversions that can be done per group operation for the same cost.
`double`	`estimateCostNegPerOp()` Estimates the number of negations (additive inversions) that can be done per group operation for the same cost.
`java.math.BigInteger`	`getCharacteristic()` Returns the characteristic of the ring.
`Zn.ZnElement`	`getElement(java.math.BigInteger i)` Maps the integer i into this ring \(R\), such that this map is a ring homomorphism \(\mathbb{Z}_{\text{getCharacteristic()}} \rightarrow R\).
`Zn.ZnElement`	`getOneElement()` Returns the multiplicative neutral element of this ring.
`Representation`	`getRepresentation()` The representation of this object.
`Zn.ZnElement`	`getUniformlyRandomElement()` Returns an element of this structure that is drawn uniformly at random using a cryptographically strong RNG.
`Zn.ZnElement`	`getUniformlyRandomNonzeroElement()` Generates a nonzero element from this ring uniformly at random using a cryptographically strong RNG.
`Zn.ZnElement`	`getUniformlyRandomUnit()` Generates an invertible element from this ring uniformly at random using a cryptographically strong RNG.
`java.util.Optional<java.lang.Integer>`	`getUniqueByteLength()` Returns the number of bytes returned by this structure's `UniqueByteRepresentable.getUniqueByteRepresentation()`, or an empty `Optional` if this structure's elements do not guarantee a fixed length.
`Zn.ZnElement`	`getZeroElement()` Returns the additive neutral element of this ring.
`int`	`hashCode()`
`boolean`	`hasPrimeSize()` Checks if the structure has prime size.
`Zn.ZnElement`	`injectiveValueOf(byte[] bytes)` For all `k < floor((n.bitLength()-1)/8)`, this is an injective map `byte^k -> Zn`.
`boolean`	`isCommutative()` Returns true if this ring is known to be commutative.
`Zn.ZnElement`	`restoreElement(Representation repr)` Creates an element of this structure from its representation.
`java.math.BigInteger`	`size()` Returns the number of elements in this structure (the size).
`java.math.BigInteger`	`sizeUnitGroup()` Returns the number of units in this ring.
`java.lang.String`	`toString()`
`int`	`upperBoundForUniqueRepresentation()` Returns the length of the representation of the largest element in this ring in terms of number of bytes.
`Zn.ZnElement`	`valueOf(java.math.BigInteger representative)` Creates the corresponding element mod n.
`static Zn.ZnElement`	`valueOf(java.math.BigInteger representative, java.math.BigInteger modulus)` Create the Zn element "representative mod modulus" (convenience method)
`Zn.ZnElement`	`valueOf(byte[] bytes)` Interprets given bytes as an integer and projects that number into Zn.
`Zn.ZnElement`	`valueOf(long representative)` Creates the corresponding element mod n.
`static Zn.ZnElement`	`valueOf(long representative, java.math.BigInteger modulus)` Create the Zn element "representative mod modulus"
`static Zn.ZnElement`	`valueOf(long representative, long modulus)` Create the element "representative mod modulus"

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.cryptimeleon.math.structures.rings.Ring
asAdditiveGroup, asUnitGroup, extendedEuclideanAlgorithm, extendedEuclideanAlgorithm, getElement, getUniformlyRandomElements, getUniformlyRandomNonzeroElements, getUniformlyRandomUnits, restoreFromRepresentation, restoreVector

- Field Detail
  - ONE
```
protected final Zn.ZnElement ONE
```
    The neutral element of this ring's unit group (the one element).
  - ZERO
```
protected final Zn.ZnElement ZERO
```
    The neutral element of this ring's additive group (the zero element).
  - n
```
protected final java.math.BigInteger n
```
    The modulus.
  - nIsPrime
```
protected java.lang.Boolean nIsPrime
```
    Whether the modulus n is prime.
  - maxByteLength
```
protected final int maxByteLength
```
    Maximum value (over all elements elem) of elem.getInteger().toByteArray().length;. The value is exactly the number of bytes needed to represent n.
- Constructor Detail
  - Zn
```
public Zn(java.math.BigInteger n)
```
    Constructs the ring.
    
    Parameters:
    
    n - number of elements in the ring
  - Zn
```
public Zn(Representation repr)
```
    Constructs the ring from a Representation.
- Method Detail
  - size
```
public java.math.BigInteger size()
```
    Description copied from interface: Structure
    
    Returns the number of elements in this structure (the size).
    
    Specified by:
    
    size in interface Structure
    
    Returns:
    
    the number of elements contained in this structure or null if infinite
  - hasPrimeSize
```
public boolean hasPrimeSize()
                     throws java.lang.UnsupportedOperationException
```
    Description copied from interface: Structure
    
    Checks if the structure has prime size.
    
    Specified by:
    
    hasPrimeSize in interface Structure
    
    Returns:
    
    true if the structure has prime size, else false.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the primality of the size cannot be determined
  - sizeUnitGroup
```
public java.math.BigInteger sizeUnitGroup()
```
    Description copied from interface: Ring
    
    Returns the number of units in this ring.
    
    Specified by:
    
    sizeUnitGroup in interface Ring
    
    Returns:
    
    size of the unit group or null if infinite
  - getZeroElement
```
public Zn.ZnElement getZeroElement()
```
    Description copied from interface: Ring
    
    Returns the additive neutral element of this ring.
    
    Specified by:
    
    getZeroElement in interface Ring
  - getOneElement
```
public Zn.ZnElement getOneElement()
```
    Description copied from interface: Ring
    
    Returns the multiplicative neutral element of this ring.
    
    Specified by:
    
    getOneElement in interface Ring
  - getUniformlyRandomElement
```
public Zn.ZnElement getUniformlyRandomElement()
                                       throws java.lang.UnsupportedOperationException
```
    Description copied from interface: Structure
    
    Returns an element of this structure that is drawn uniformly at random using a cryptographically strong RNG.
    
    Specified by:
    
    getUniformlyRandomElement in interface Ring
    
    Specified by:
    
    getUniformlyRandomElement in interface Structure
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the operation is not supported
  - getUniformlyRandomUnit
```
public Zn.ZnElement getUniformlyRandomUnit()
                                    throws java.lang.UnsupportedOperationException
```
    Description copied from interface: Ring
    
    Generates an invertible element from this ring uniformly at random using a cryptographically strong RNG.
    The default implementation generates random ring elements until it hits a unit. Implementors should override if this is not feasible or if there is a better way!
    
    Specified by:
    
    getUniformlyRandomUnit in interface Ring
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the ring does not support this method
  - getUniformlyRandomNonzeroElement
```
public Zn.ZnElement getUniformlyRandomNonzeroElement()
```
    Description copied from interface: Ring
    
    Generates a nonzero element from this ring uniformly at random using a cryptographically strong RNG.
    
    Specified by:
    
    getUniformlyRandomNonzeroElement in interface Ring
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - upperBoundForUniqueRepresentation
```
public final int upperBoundForUniqueRepresentation()
```
    Returns the length of the representation of the largest element in this ring in terms of number of bytes.
  - getRepresentation
```
public Representation getRepresentation()
```
    Description copied from interface: Representable
    
    The representation of this object. Used for serialization. A convenient way to implement this is using @link ReprUtil
    
    Specified by:
    
    getRepresentation in interface Representable
    
    Returns:
    
    a Representation or null if an equal object can be recreated without any information.
    
    See Also:
    
    Representation
  - restoreElement
```
public Zn.ZnElement restoreElement(Representation repr)
```
    Description copied from interface: Structure
    
    Creates an element of this structure from its representation.
    
    Specified by:
    
    restoreElement in interface Ring
    
    Specified by:
    
    restoreElement in interface Structure
    
    Parameters:
    
    repr - the Representation returned by Representable.getRepresentation()
    
    Returns:
    
    the decoded element corresponding to the representation
  - valueOf
```
public static Zn.ZnElement valueOf(java.math.BigInteger representative,
                                   java.math.BigInteger modulus)
```
    Create the Zn element "representative mod modulus" (convenience method)
    
    Parameters:
    
    representative - the integer representative of the element
    
    modulus - the ring size
  - valueOf
```
public static Zn.ZnElement valueOf(long representative,
                                   java.math.BigInteger modulus)
```
    Create the Zn element "representative mod modulus"
    
    Parameters:
    
    representative - the integer representative of the element
    
    modulus - the ring size
  - valueOf
```
public static Zn.ZnElement valueOf(long representative,
                                   long modulus)
```
    Create the element "representative mod modulus"
    
    Parameters:
    
    representative - the integer representative of the element
    
    modulus - the ring size
  - valueOf
```
public Zn.ZnElement valueOf(long representative)
```
    Creates the corresponding element mod n.
    
    Parameters:
    
    representative - the integer representative of the element
  - valueOf
```
public Zn.ZnElement valueOf(java.math.BigInteger representative)
```
    Creates the corresponding element mod n.
    
    Parameters:
    
    representative - the integer representative of the element
  - injectiveValueOf
```
public Zn.ZnElement injectiveValueOf(byte[] bytes)
                              throws java.lang.IllegalArgumentException
```
    For all k < floor((n.bitLength()-1)/8), this is an injective map byte^k -> Zn.
    Note that there may be collisions between injectiveValueOf(bytes1) and injectiveValueOf(bytes2) if bytes1.length != bytes2.length.
    
    Parameters:
    
    bytes - the bytes to map injectively into Zn.
    
    Returns:
    
    the resulting Zn element
    
    Throws:
    
    java.lang.IllegalArgumentException - if the byte array is too long
  - valueOf
```
public Zn.ZnElement valueOf(byte[] bytes)
```
    Interprets given bytes as an integer and projects that number into Zn. For short byte[], this map is injective.
  - getCharacteristic
```
public java.math.BigInteger getCharacteristic()
```
    Description copied from interface: Ring
    
    Returns the characteristic of the ring.
    The characteristic of a ring is defined to be the number n such that there is a ring homomorphism from Zn to the ring.
    
    Specified by:
    
    getCharacteristic in interface Ring
  - createZnElement
```
public Zn.ZnElement createZnElement(java.math.BigInteger v)
```
    Creates an element from a BigInteger (formally, the projection of \(v\) from \(\mathbb{Z}\) to \(\mathbb{Z}_n\)).
    Implementation detail: This factory method allows the subclass Zp to use its own kind of elements while reusing the Zn implementation.
  - createZnElementUnsafe
```
protected Zn.ZnElement createZnElementUnsafe(java.math.BigInteger vBetween0andN)
```
    Instantiates a ZnElement without checking that the given representative is within the proper range.
    
    Parameters:
    
    vBetween0andN - the representative of the element to instantiate. Must be between 0 (inclusive) and n (exclusive).
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getUniqueByteLength
```
public java.util.Optional<java.lang.Integer> getUniqueByteLength()
```
    Description copied from interface: Structure
    
    Returns the number of bytes returned by this structure's UniqueByteRepresentable.getUniqueByteRepresentation(), or an empty Optional if this structure's elements do not guarantee a fixed length.
    For example, elements of Zp will always be represented by ceil(ceil(log(p))/8) bytes, hence getUniqueByteLength() would return ceil(ceil(log(p))/8).
    A polynomial ring would return an empty Optional since a polynomial's unique byte representation length depends on its degree.
    
    Specified by:
    
    getUniqueByteLength in interface Structure
    
    Returns:
    
    the guaranteed fixed length of getUniqueByteRepresentation(), or an empty Optional, if no guarantee
  - getElement
```
public Zn.ZnElement getElement(java.math.BigInteger i)
```
    Description copied from interface: Ring
    
    Maps the integer i into this ring \(R\), such that this map is a ring homomorphism \(\mathbb{Z}_{\text{getCharacteristic()}} \rightarrow R\).
    
    Specified by:
    
    getElement in interface Ring
    
    Parameters:
    
    i - the integer to map
    
    Returns:
    
    an element of the ring
  - estimateCostInvPerOp
```
public double estimateCostInvPerOp()
```
    Description copied from interface: Ring
    
    Estimates the number of inversions that can be done per group operation for the same cost. For example, 2 would mean that an inversion costs half as much as a group operation, on average.
    
    Specified by:
    
    estimateCostInvPerOp in interface Ring
    
    Returns:
    
    estimated number of inversions that can be done per group operation for the same cost
  - estimateCostNegPerOp
```
public double estimateCostNegPerOp()
```
    Description copied from interface: Ring
    
    Estimates the number of negations (additive inversions) that can be done per group operation for the same cost. For example, 2 would mean that a negation costs half as much as a group operation, on average.
    
    Specified by:
    
    estimateCostNegPerOp in interface Ring
    
    Returns:
    
    estimated number of inversions that can be done per group operation for the same cost
  - isCommutative
```
public boolean isCommutative()
```
    Description copied from interface: Ring
    
    Returns true if this ring is known to be commutative.
    
    Specified by:
    
    isCommutative in interface Ring

Class Zn

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.cryptimeleon.math.structures.rings.Ring

Field Detail

ONE

ZERO

n

nIsPrime

maxByteLength

Constructor Detail

Zn

Zn

Method Detail

size

hasPrimeSize

sizeUnitGroup

getZeroElement

getOneElement

getUniformlyRandomElement

getUniformlyRandomUnit

getUniformlyRandomNonzeroElement

equals

hashCode

upperBoundForUniqueRepresentation

getRepresentation

restoreElement

valueOf

valueOf

valueOf

valueOf

valueOf

injectiveValueOf

valueOf

getCharacteristic

createZnElement

createZnElementUnsafe

toString

getUniqueByteLength

getElement

estimateCostInvPerOp

estimateCostNegPerOp

isCommutative