Zn.ZnElement (math 3.1.2 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\).
`ExponentExpr`	`add(ExponentExpr e)`
`ExponentConstantExpr`	`asExponentExpression()`
`java.math.BigInteger`	`asInteger()` Interprets this element as an integer.
`protected void`	`checkSameModulus(Element e)`
`Zn.ZnElement`	`div(Element e)` Computes \(\text{this} / e = \text{this} \cdot e^{-1}\).
`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`	`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.
`ExponentEqualityExpr`	`isEqualTo(java.math.BigInteger other)` Returns an expression "this = other mod n".
`ExponentEqualityExpr`	`isEqualTo(ExponentExpr other)` Returns an expression "this = other".
`ExponentEqualityExpr`	`isEqualTo(long other)` Returns an expression "this = other mod n".
`ExponentEqualityExpr`	`isEqualTo(Zn.ZnElement other)` Returns an expression "this = other".
`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\).
`ExponentExpr`	`mul(ExponentExpr 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\).
`ExponentExpr`	`pow(ExponentExpr e)`
`Zn.ZnElement`	`pow(long k)` Calculates \(\text{this}^k\).
`Zn.ZnElement`	`square()` Computes \(\text{this}^2\).
`Zn.ZnElement`	`sub(Element e)` Computes \(\text{this} - e\).
`ExponentExpr`	`sub(ExponentExpr 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
isOne, isUnit, isZero, 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
  - add
```
public ExponentExpr add(ExponentExpr e)
```
  - 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
  - sub
```
public ExponentExpr sub(ExponentExpr e)
```
  - 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
  - mul
```
public ExponentExpr mul(ExponentExpr e)
```
  - 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
  - pow
```
public ExponentExpr pow(ExponentExpr e)
```
  - 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
  - square
```
public Zn.ZnElement square()
```
    Description copied from interface: RingElement
    
    Computes \(\text{this}^2\).
    Useful if the ring allows squaring to be more efficiently implemented than general exponentiation.
    
    Specified by:
    
    square in interface RingElement
  - div
```
public Zn.ZnElement div(Element e)
                 throws java.lang.IllegalArgumentException
```
    Description copied from interface: RingElement
    
    Computes \(\text{this} / e = \text{this} \cdot e^{-1}\).
    
    Specified by:
    
    div in interface RingElement
    
    Parameters:
    
    e - the divisor
    
    Returns:
    
    the result
    
    Throws:
    
    java.lang.IllegalArgumentException - if e 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
  - 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()
```
  - isEqualTo
```
public ExponentEqualityExpr isEqualTo(ExponentExpr other)
```
    Returns an expression "this = other". This is for building expressions, i.e. only useful if unknown variables are involved. To compare two Zn.ZnElements normally, just use equals(Object).
  - isEqualTo
```
public ExponentEqualityExpr isEqualTo(Zn.ZnElement other)
```
    Returns an expression "this = other". This is for building expressions, i.e. only useful if unknown variables are involved. To compare two Zn.ZnElements normally, just use equals(Object).
  - isEqualTo
```
public ExponentEqualityExpr isEqualTo(java.math.BigInteger other)
```
    Returns an expression "this = other mod n". This is for building expressions, i.e. only useful if unknown variables are involved. To compare two Zn.ZnElements normally, just use equals(Object).
  - isEqualTo
```
public ExponentEqualityExpr isEqualTo(long other)
```
    Returns an expression "this = other mod n". This is for building expressions, i.e. only useful if unknown variables are involved. To compare two Zn.ZnElements normally, just use equals(Object).
  - asInteger
```
public java.math.BigInteger asInteger()
                               throws java.lang.UnsupportedOperationException
```
    Description copied from interface: RingElement
    
    Interprets this element as an integer.
    Result will be between 0 and the ring's characteristic.
    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

add

neg

sub

sub

mul

mul

mul

mul

pow

pow

pow

inv

square

div

divides

divideWithRemainder

getRank

checkSameModulus

equals

hashCode

getRepresentation

toString

updateAccumulator

asExponentExpression

isEqualTo

isEqualTo

isEqualTo

isEqualTo

asInteger