# Struct hacspec_lib::prelude::I128

source · [−]`pub struct I128(pub i128);`

## Tuple Fields

`0: i128`

## Implementations

source### impl I128

### impl I128

#### pub fn classify<T>(x: T) -> I128 where

T: Into<i128>,

source#### pub fn declassify(self) -> i128

#### pub fn declassify(self) -> i128

**Warning:** use with caution, breaks the constant-time guarantee.

#### pub fn zero() -> I128

#### pub fn one() -> I128

#### pub fn ones() -> I128

#### pub fn from_le_bytes(bytes: &[U8]) -> Vec<I128, Global>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where`

A: Allocator,

A: Allocator,

#### pub fn to_le_bytes(ints: &[I128]) -> Vec<U8, Global>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where`

A: Allocator,

A: Allocator,

#### pub fn from_be_bytes(bytes: &[U8]) -> Vec<I128, Global>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where`

A: Allocator,

A: Allocator,

#### pub fn to_be_bytes(ints: &[I128]) -> Vec<U8, Global>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where`

A: Allocator,

A: Allocator,

#### pub fn max_value() -> I128

source### impl I128

### impl I128

#### pub fn rotate_left(self, rotval: usize) -> I128

#### pub fn rotate_right(self, rotval: usize) -> I128

source### impl I128

### impl I128

#### pub fn comp_eq(self, rhs: I128) -> I128

source#### pub fn comp_ne(self, rhs: I128) -> I128

#### pub fn comp_ne(self, rhs: I128) -> I128

Produces a new integer which is all ones if the first argument is different from the second argument, and all zeroes otherwise.

source#### pub fn comp_gte(self, rhs: I128) -> I128

#### pub fn comp_gte(self, rhs: I128) -> I128

Produces a new integer which is all ones if the first argument is greater than or equal to the second argument, and all zeroes otherwise. With inspiration from

source#### pub fn comp_gt(self, rhs: I128) -> I128

#### pub fn comp_gt(self, rhs: I128) -> I128

Produces a new integer which is all ones if the first argument is strictly greater than the second argument, and all zeroes otherwise.

## Trait Implementations

source### impl AddAssign<I128> for I128

### impl AddAssign<I128> for I128

**Warning:** has wrapping semantics.

source#### fn add_assign(&mut self, rhs: I128)

#### fn add_assign(&mut self, rhs: I128)

Performs the `+=`

operation. Read more

source### impl BitAndAssign<I128> for I128

### impl BitAndAssign<I128> for I128

source#### fn bitand_assign(&mut self, rhs: I128)

#### fn bitand_assign(&mut self, rhs: I128)

Performs the `&=`

operation. Read more

source### impl BitOrAssign<I128> for I128

### impl BitOrAssign<I128> for I128

source#### fn bitor_assign(&mut self, rhs: I128)

#### fn bitor_assign(&mut self, rhs: I128)

Performs the `|=`

operation. Read more

source### impl BitXorAssign<I128> for I128

### impl BitXorAssign<I128> for I128

source#### fn bitxor_assign(&mut self, rhs: I128)

#### fn bitxor_assign(&mut self, rhs: I128)

Performs the `^=`

operation. Read more

source### impl Integer for I128

### impl Integer for I128

source#### fn ZERO() -> Self

#### fn ZERO() -> Self

*This function is within the hacspec subset of Rust: its signature and body use only hacspec constructs and
call functions whose signatures are in hacspec.*

source#### fn ONE() -> Self

#### fn ONE() -> Self

*This function is within the hacspec subset of Rust: its signature and body use only hacspec constructs and
call functions whose signatures are in hacspec.*

source#### fn TWO() -> Self

#### fn TWO() -> Self

*This function is within the hacspec subset of Rust: its signature and body use only hacspec constructs and
call functions whose signatures are in hacspec.*

source#### fn from_literal(val: u128) -> Self

#### fn from_literal(val: u128) -> Self

source#### fn from_hex_string(s: &String) -> Self

#### fn from_hex_string(s: &String) -> Self

*This function can be called from hacspec programs but its body features Rust constructs that are not part of hacspec*

source#### fn get_bit(self, i: usize) -> Self

#### fn get_bit(self, i: usize) -> Self

`i`

of this integer.

source#### fn set_bit(self, b: Self, i: usize) -> Self

#### fn set_bit(self, b: Self, i: usize) -> Self

`i`

of this integer to `b`

and return the result.
Bit `b`

has to be `0`

or `1`

.

source#### fn set(self, pos: usize, y: Self, yi: usize) -> Self

#### fn set(self, pos: usize, y: Self, yi: usize) -> Self

`pos`

of this integer to bit `yi`

of integer `y`

.

source#### fn rotate_left(self, n: usize) -> Self

#### fn rotate_left(self, n: usize) -> Self

source#### fn rotate_right(self, n: usize) -> Self

#### fn rotate_right(self, n: usize) -> Self

#### const NUM_BITS: usize = 128usize

source### impl ModNumeric for I128

### impl ModNumeric for I128

source#### fn sub_mod(self, rhs: Self, n: Self) -> Self

#### fn sub_mod(self, rhs: Self, n: Self) -> Self

source#### fn add_mod(self, rhs: Self, n: Self) -> Self

#### fn add_mod(self, rhs: Self, n: Self) -> Self

`(self + rhs) % n`

source#### fn mul_mod(self, rhs: Self, n: Self) -> Self

#### fn mul_mod(self, rhs: Self, n: Self) -> Self

`(self * rhs) % n`

source#### fn pow_mod(self, _exp: Self, _n: Self) -> Self

#### fn pow_mod(self, _exp: Self, _n: Self) -> Self

`(self ^ exp) % n`

TODO: implement

source#### fn modulo(self, n: Self) -> Self

#### fn modulo(self, n: Self) -> Self

`self % n`

source#### fn signed_modulo(self, n: Self) -> Self

#### fn signed_modulo(self, n: Self) -> Self

`self % n`

that always returns a positive integer
FIXME: not ct!

source### impl MulAssign<I128> for I128

### impl MulAssign<I128> for I128

**Warning:** has wrapping semantics.

source#### fn mul_assign(&mut self, rhs: I128)

#### fn mul_assign(&mut self, rhs: I128)

Performs the `*=`

operation. Read more

source### impl Numeric for I128

### impl Numeric for I128

source#### fn max_val() -> Self

#### fn max_val() -> Self

source#### fn wrap_add(self, rhs: Self) -> Self

#### fn wrap_add(self, rhs: Self) -> Self

source#### fn wrap_sub(self, rhs: Self) -> Self

#### fn wrap_sub(self, rhs: Self) -> Self

source#### fn wrap_mul(self, rhs: Self) -> Self

#### fn wrap_mul(self, rhs: Self) -> Self

source#### fn wrap_div(self, _rhs: Self) -> Self

#### fn wrap_div(self, _rhs: Self) -> Self

source#### fn exp(self, exp: u32) -> Self

#### fn exp(self, exp: u32) -> Self

`self ^ exp`

where `exp`

is a `u32`

.
**Note:** the exponent `exp`

MUST NOT be secret.

source#### fn pow_self(self, _exp: Self) -> Self

#### fn pow_self(self, _exp: Self) -> Self

`self ^ exp`

where `exp`

is a `Self`

.
Here both, base and exponent, are secret.
TODO: implement

source#### fn divide(self, rhs: Self) -> Self

#### fn divide(self, rhs: Self) -> Self

source#### fn inv(self, n: Self) -> Self

#### fn inv(self, n: Self) -> Self

source#### fn equal(self, other: Self) -> bool

#### fn equal(self, other: Self) -> bool

**Declassifies**

source#### fn greater_than(self, other: Self) -> bool

#### fn greater_than(self, other: Self) -> bool

**Declassifies**

source#### fn greater_than_or_equal(self, other: Self) -> bool

#### fn greater_than_or_equal(self, other: Self) -> bool

**Declassifies**

source#### fn less_than(self, other: Self) -> bool

#### fn less_than(self, other: Self) -> bool

**Declassifies**

source#### fn less_than_or_equal(self, other: Self) -> bool

#### fn less_than_or_equal(self, other: Self) -> bool

**Declassifies**

source#### fn not_equal_bm(self, other: Self) -> Self

#### fn not_equal_bm(self, other: Self) -> Self

source#### fn equal_bm(self, other: Self) -> Self

#### fn equal_bm(self, other: Self) -> Self

source#### fn greater_than_bm(self, other: Self) -> Self

#### fn greater_than_bm(self, other: Self) -> Self

source#### fn greater_than_or_equal_bm(self, other: Self) -> Self

#### fn greater_than_or_equal_bm(self, other: Self) -> Self

source#### fn less_than_bm(self, other: Self) -> Self

#### fn less_than_bm(self, other: Self) -> Self

source#### fn less_than_or_equal_bm(self, other: Self) -> Self

#### fn less_than_or_equal_bm(self, other: Self) -> Self

source### impl SecretInteger for I128

### impl SecretInteger for I128

source#### fn classify(x: Self::PublicVersion) -> Self

#### fn classify(x: Self::PublicVersion) -> Self

#### type PublicVersion = i128

source### impl SecretIntegerCopy for I128

### impl SecretIntegerCopy for I128

#### type PublicVersionCopy = i128

#### fn classify(x: Self::PublicVersionCopy) -> Self

source### impl ShlAssign<usize> for I128

### impl ShlAssign<usize> for I128

source#### fn shl_assign(&mut self, rhs: usize)

#### fn shl_assign(&mut self, rhs: usize)

Performs the `<<=`

operation. Read more

source### impl ShrAssign<usize> for I128

### impl ShrAssign<usize> for I128

source#### fn shr_assign(&mut self, rhs: usize)

#### fn shr_assign(&mut self, rhs: usize)

Performs the `>>=`

operation. Read more

source### impl SubAssign<I128> for I128

### impl SubAssign<I128> for I128

**Warning:** has wrapping semantics.

source#### fn sub_assign(&mut self, rhs: I128)

#### fn sub_assign(&mut self, rhs: I128)

Performs the `-=`

operation. Read more

### impl Copy for I128

### impl NumericCopy for I128

### impl SignedInteger for I128

### impl SignedIntegerCopy for I128

## Auto Trait Implementations

### impl RefUnwindSafe for I128

### impl Send for I128

### impl Sync for I128

### impl Unpin for I128

### impl UnwindSafe for I128

## Blanket Implementations

source### impl<T> BorrowMut<T> for T where

T: ?Sized,

### impl<T> BorrowMut<T> for T where

T: ?Sized,

const: unstable · source#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more