Zn.ZnElement (math 1.0.0 API)

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

All Implemented Interfaces:

UniqueByteRepresentable, Representable, Element, RingElement

Direct Known Subclasses:

Zp.ZpElement

Enclosing class:

Zn
```
public class Zn.ZnElement
extends java.lang.Object
implements RingElement, UniqueByteRepresentable
```
An equivalence class of integers with the same remainder when divided by n.

Field Summary

Fields
Modifier and Type Field and Description

protected java.math.BigInteger v
The unique integer v such that 0 <= v < n and v projects to the represented element in Zn.

Fields
Modifier and Type	Field and Description
`protected java.math.BigInteger`	`v` The unique integer `v` such that `0 <= v < n` and `v` projects to the represented element in `Zn`.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ZnElement()` Create the zero element.
`protected`	`ZnElement(java.math.BigInteger v)` Construct a new `ZnElement` initialized as `[v] mod n` (must reduce `v` before calling!).

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Zn.ZnElement`	`add(Element e)` Computes \(\text{this} + e\).
`ExponentConstantExpr`	`asExponentExpression()`
`java.math.BigInteger`	`asInteger()` Interprets this element as an integer.
`protected void`	`checkSameModulus(Element e)`
`boolean`	`divides(RingElement e)` Returns true iff there exists an \(x\) in the ring such that \(\text{this} \cdot x = e\).
`Zn.ZnElement[]`	`divideWithRemainder(RingElement e)` Divides this by e with remainder, returning both quotient and remainder.
`boolean`	`equals(java.lang.Object obj)`
`java.math.BigInteger`	`getInteger()` Returns the unique integer representative for this element in \([0,n)\).
`java.math.BigInteger`	`getRank()` Implements the euclidean function of a euclidean domain.
`Representation`	`getRepresentation()` The representation of this object.
`Zn`	`getStructure()` Returns the `Structure` that this `Element` belongs to.
`int`	`hashCode()`
`Zn.ZnElement`	`inv()` Computes the multiplicative inverse of this element.
`Zn.ZnElement`	`mul(java.math.BigInteger k)` Computes \(\text{this} \cdot k\) (equivalent to \(\text{this} + \text{this} + \cdots\) k-times).
`Zn.ZnElement`	`mul(Element e)` Computes \(\text{this} \cdot e\).
`Zn.ZnElement`	`mul(long k)` Computes \(\text{this} \cdot k\) (equivalent to \(\text{this} + \text{this} + \cdots\) k-times).
`Zn.ZnElement`	`neg()` Computes the additive inverse of this element.
`Zn.ZnElement`	`pow(java.math.BigInteger k)` Calculates \(\text{this}^k\).
`Zn.ZnElement`	`pow(long k)` Calculates \(\text{this}^k\).
`Zn.ZnElement`	`sub(Element e)` Computes \(\text{this} - e\).
`java.lang.String`	`toString()`
`ByteAccumulator`	`updateAccumulator(ByteAccumulator accumulator)` Updates the ByteAccumulator with the unique byte representation of this object.

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

Methods inherited from interface org.cryptimeleon.math.structures.rings.RingElement
div, isOne, isUnit, isZero, square, toAdditiveGroupElement, toUnitGroupElement

Methods inherited from interface org.cryptimeleon.math.hash.UniqueByteRepresentable
getUniqueByteRepresentation

- Field Detail
  - v
```
protected final java.math.BigInteger v
```
    The unique integer v such that 0 <= v < n and v projects to the represented element in Zn.
- Constructor Detail
  - ZnElement
```
protected ZnElement(java.math.BigInteger v)
```
    Construct a new ZnElement initialized as [v] mod n (must reduce v before calling!).
  - ZnElement
```
protected ZnElement()
```
    Create the zero element.
- Method Detail
  - getStructure
```
public Zn getStructure()
```
    Description copied from interface: Element
    
    Returns the Structure that this Element belongs to.
    
    Specified by:
    
    getStructure in interface Element
    
    Specified by:
    
    getStructure in interface RingElement
  - add
```
public Zn.ZnElement add(Element e)
```
    Description copied from interface: RingElement
    
    Computes \(\text{this} + e\).
    
    Specified by:
    
    add in interface RingElement
    
    Parameters:
    
    e - the addend
    
    Returns:
    
    the result
  - neg
```
public Zn.ZnElement neg()
```
    Description copied from interface: RingElement
    
    Computes the additive inverse of this element.
    
    Specified by:
    
    neg in interface RingElement
    
    Returns:
    
    the result
  - sub
```
public Zn.ZnElement sub(Element e)
```
    Description copied from interface: RingElement
    
    Computes \(\text{this} - e\).
    
    Specified by:
    
    sub in interface RingElement
    
    Parameters:
    
    e - the subtrahend
    
    Returns:
    
    the result
  - mul
```
public Zn.ZnElement mul(Element e)
```
    Description copied from interface: RingElement
    
    Computes \(\text{this} \cdot e\).
    
    Specified by:
    
    mul in interface RingElement
    
    Parameters:
    
    e - the factor
    
    Returns:
    
    the result
  - mul
```
public Zn.ZnElement mul(java.math.BigInteger k)
```
    Description copied from interface: RingElement
    
    Computes \(\text{this} \cdot k\) (equivalent to \(\text{this} + \text{this} + \cdots\) k-times).
    
    Specified by:
    
    mul in interface RingElement
    
    Parameters:
    
    k - the factor
    
    Returns:
    
    the result
  - mul
```
public Zn.ZnElement mul(long k)
```
    Description copied from interface: RingElement
    
    Computes \(\text{this} \cdot k\) (equivalent to \(\text{this} + \text{this} + \cdots\) k-times).
    
    Specified by:
    
    mul in interface RingElement
    
    Parameters:
    
    k - the factor
    
    Returns:
    
    the result
  - pow
```
public Zn.ZnElement pow(java.math.BigInteger k)
```
    Description copied from interface: RingElement
    
    Calculates \(\text{this}^k\).
    Note that \(a^0 = 1\) for any \(a\) in the ring, particularly \(0^0 = 1\).
    
    Specified by:
    
    pow in interface RingElement
  - pow
```
public Zn.ZnElement pow(long k)
```
    Description copied from interface: RingElement
    
    Calculates \(\text{this}^k\).
    Note that \(a^0 = 1\) for any \(a\) in the ring, particularly \(0^0 = 1\).
    
    Specified by:
    
    pow in interface RingElement
  - inv
```
public Zn.ZnElement inv()
                 throws java.lang.UnsupportedOperationException
```
    Description copied from interface: RingElement
    
    Computes the multiplicative inverse of this element.
    
    Specified by:
    
    inv in interface RingElement
    
    Returns:
    
    the result
    
    Throws:
    
    java.lang.UnsupportedOperationException - if this is not a unit
  - divides
```
public boolean divides(RingElement e)
                throws java.lang.UnsupportedOperationException
```
    Description copied from interface: RingElement
    
    Returns true iff there exists an \(x\) in the ring such that \(\text{this} \cdot x = e\).
    
    Specified by:
    
    divides in interface RingElement
    
    Throws:
    
    java.lang.UnsupportedOperationException - if this cannot be decided (efficiently)
  - divideWithRemainder
```
public Zn.ZnElement[] divideWithRemainder(RingElement e)
                                   throws java.lang.UnsupportedOperationException,
                                          java.lang.IllegalArgumentException
```
    Description copied from interface: RingElement
    
    Divides this by e with remainder, returning both quotient and remainder.
    Specifically, returns an array result such that the first entry contains the quotient and the second entry the remainder. Furthermore, result[1].getRank() < e.getRank() or result[1] = 0.
    This definition implies that the remainder is zero if and only if e divides this element.
    
    Specified by:
    
    divideWithRemainder in interface RingElement
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the ring is not a euclidean domain
    
    java.lang.IllegalArgumentException - if e is zero
  - getRank
```
public java.math.BigInteger getRank()
                             throws java.lang.UnsupportedOperationException
```
    Description copied from interface: RingElement
    Implements the euclidean function of a euclidean domain.
    The euclidean function is a function from \(R \setminus \{0\}\) to \(\mathbb{N}_0\) such that
    - a.getRank() >= 0 for any a in the ring
    - a.mul(b).getRank() >= a.getRank() for any a, b != 0
    - the remainder rank after divideWithRemainder is less than the divisor's rank
    For example, for a polynomial ring this corresponds to the degree of the polynomial.
    The rank of the zero element is undefined (no guarantee as to what this method returns in that case).
    Specified by:
    
    getRank in interface RingElement
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the ring is not a euclidean domain
  - checkSameModulus
```
protected void checkSameModulus(Element e)
```
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Specified by:
    
    equals in interface Element
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Element
    
    Overrides:
    
    hashCode in class java.lang.Object
  - 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
  - getInteger
```
public java.math.BigInteger getInteger()
```
    Returns the unique integer representative for this element in \([0,n)\).
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - updateAccumulator
```
public ByteAccumulator updateAccumulator(ByteAccumulator accumulator)
```
    Description copied from interface: UniqueByteRepresentable
    
    Updates the ByteAccumulator with the unique byte representation of this object.
    The input to the accumulators update function is an injective (with respect to a given domain) byte encoding of this object.
    For many use-cases, the AnnotatedUbrUtil can be used to quickly implement this method.
    
    Specified by:
    
    updateAccumulator in interface UniqueByteRepresentable
    
    Returns:
    
    the same accumulator as was input
  - asExponentExpression
```
public ExponentConstantExpr asExponentExpression()
```
  - asInteger
```
public java.math.BigInteger asInteger()
                               throws java.lang.UnsupportedOperationException
```
    Description copied from interface: RingElement
    
    Interprets this element as an integer.
    Formally, this method shall return the inverse of Ring.getElement(BigInteger), i.e. x.getStructure().getElement(x.asInteger()).equals(x) (if asInteger() doesn't throw an exception).
    
    Specified by:
    
    asInteger in interface RingElement
    
    Returns:
    
    the integer corresponding to this element
    
    Throws:
    
    java.lang.UnsupportedOperationException - if no such element exists or cannot be efficiently computed

Class Zn.ZnElement

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.cryptimeleon.math.hash.UniqueByteRepresentable

Field Detail

v

Constructor Detail

ZnElement

ZnElement

Method Detail

getStructure

add

neg

sub

mul

mul

mul

pow

pow

inv

divides

divideWithRemainder

getRank

checkSameModulus

equals

hashCode

getRepresentation

getInteger

toString

updateAccumulator

asExponentExpression

asInteger