IntegerRing (math 2.1.0 API)

java.lang.Object
- org.cryptimeleon.math.structures.rings.integers.IntegerRing

All Implemented Interfaces:

RepresentationRestorer, Representable, StandaloneRepresentable, Ring, Structure
```
public class IntegerRing
extends java.lang.Object
implements Ring
```
The ring of integers \(\mathbb{Z}\).

Constructor Summary

Constructors
Constructor and Description

IntegerRing()

IntegerRing(Representation repr)

Constructors
Constructor and Description
`IntegerRing()`
`IntegerRing(Representation repr)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static java.math.BigInteger[]`	`decomposeIntoDigits(java.math.BigInteger number, java.math.BigInteger base)` Decomposes a given number into digits with the given base.
`static java.math.BigInteger[]`	`decomposeIntoDigits(java.math.BigInteger number, java.math.BigInteger base, int numDigits)` Decomposes a given number into the given number of digits with the given base.
`static java.math.BigInteger[]`	`decomposeIntoDigits(java.math.BigInteger number, long base)` Decomposes a given number into digits with the given base.
`static java.math.BigInteger[]`	`decomposeIntoDigits(java.math.BigInteger number, long base, int numDigits)` Decomposes a given number into the given number of digits with the given base.
`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.
`IntegerElement`	`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\).
`IntegerElement`	`getOneElement()` Returns the multiplicative neutral element of this ring.
`Representation`	`getRepresentation()` The representation of this object.
`IntegerElement`	`getUniformlyRandomElement()` Returns an element of this structure that is drawn uniformly at random using a cryptographically strong RNG.
`RingElement`	`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.
`IntegerElement`	`getZeroElement()` Returns the additive neutral element of this ring.
`int`	`hashCode()`
`boolean`	`isCommutative()` Returns true if this ring is known to be commutative.
`IntegerElement`	`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.

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

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

Methods inherited from interface org.cryptimeleon.math.structures.Structure
hasPrimeSize

- Constructor Detail
  - IntegerRing
```
public IntegerRing()
```
  - IntegerRing
```
public IntegerRing(Representation repr)
```
- Method Detail
  - size
```
public java.math.BigInteger size()
                          throws java.lang.UnsupportedOperationException
```
    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
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the number of elements is unknown or too expensive to compute
  - 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
  - sizeUnitGroup
```
public java.math.BigInteger sizeUnitGroup()
                                   throws java.lang.UnsupportedOperationException
```
    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
    
    Throws:
    
    java.lang.UnsupportedOperationException - if size is unknown or is computationally too expensive to compute
  - getZeroElement
```
public IntegerElement getZeroElement()
```
    Description copied from interface: Ring
    
    Returns the additive neutral element of this ring.
    
    Specified by:
    
    getZeroElement in interface Ring
  - getOneElement
```
public IntegerElement getOneElement()
```
    Description copied from interface: Ring
    
    Returns the multiplicative neutral element of this ring.
    
    Specified by:
    
    getOneElement in interface Ring
  - getElement
```
public IntegerElement 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
  - restoreElement
```
public IntegerElement 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
  - getUniformlyRandomElement
```
public IntegerElement 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 RingElement 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
  - 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
  - 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
  - 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
  - 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
  - decomposeIntoDigits
```
public static java.math.BigInteger[] decomposeIntoDigits(java.math.BigInteger number,
                                                         java.math.BigInteger base)
```
    Decomposes a given number into digits with the given base.
    For example, for base = 2, this does bit decomposition.
    
    Returns:
    
    an array A containing values A[i] < base such that \(\sum_i{ \text{A}[i] \cdot \text{base}^i} = \text{number}\)
  - decomposeIntoDigits
```
public static java.math.BigInteger[] decomposeIntoDigits(java.math.BigInteger number,
                                                         java.math.BigInteger base,
                                                         int numDigits)
```
    Decomposes a given number into the given number of digits with the given base.
    For example, for base = 2, this does bit decomposition.
    
    Returns:
    
    an array A containing values A[i] < base such that \(\sum_i{ \text{A}[i] \cdot \text{base}^i} = \text{number}\)
    
    Throws:
    
    java.lang.IllegalArgumentException - if numDigits is not enough to represent the given number
  - decomposeIntoDigits
```
public static java.math.BigInteger[] decomposeIntoDigits(java.math.BigInteger number,
                                                         long base)
```
    Decomposes a given number into digits with the given base.
    For example, for base = 2, this does bit decomposition.
    
    Returns:
    
    an array A containing values A[i] < base such that \(\sum_i{ \text{A}[i] \cdot \text{base}^i} = \text{number}\)
  - decomposeIntoDigits
```
public static java.math.BigInteger[] decomposeIntoDigits(java.math.BigInteger number,
                                                         long base,
                                                         int numDigits)
```
    Decomposes a given number into the given number of digits with the given base.
    For example, for base = 2, this does bit decomposition.
    
    Returns:
    
    an array A containing values A[i] < base such that \(\sum_i{ \text{A}[i] \cdot \text{base}^i} = \text{number}\)
    
    Throws:
    
    java.lang.IllegalArgumentException - if numDigits is not enough to represent the given number

Class IntegerRing

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.cryptimeleon.math.structures.Structure

Constructor Detail

IntegerRing

IntegerRing

Method Detail

size

getRepresentation

sizeUnitGroup

getZeroElement

getOneElement

getElement

estimateCostInvPerOp

estimateCostNegPerOp

restoreElement

getUniformlyRandomElement

getUniformlyRandomUnit

getCharacteristic

equals

hashCode

getUniqueByteLength

isCommutative

decomposeIntoDigits

decomposeIntoDigits

decomposeIntoDigits

decomposeIntoDigits