Struct hacspec_lib::seq::PublicSeq

pub struct PublicSeq<T: Default + PublicInteger> { /* private fields */ }

Variable length byte arrays.

Implementations

impl PublicSeq<u8>

pub fn from_public_slice(v: &[u8]) -> PublicSeq<u8>

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn from_native(b: Vec<u8>) -> PublicSeq<u8>

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn to_native(&self) -> Vec<u8>

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn into_native(self) -> Vec<u8>

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn as_slice(&self) -> &[u8]

Function that is not part of the language but is offered as a helper for tests, etc.

impl<T: Clone + Default + PublicInteger> PublicSeq<T>

pub fn new(l: usize) -> Self

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

pub fn with_capacity(l: usize) -> Self

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

pub fn reserve(self, additional: usize) -> Self

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

pub fn len(&self) -> usize

This function can be called from hacspec programs but its body features Rust constructs that are not part of hacspec Get the size of this sequence.

pub fn slice(&self, start_out: usize, len: usize) -> 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.

pub fn native_slice(&self) -> &[T]

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn into_slice(self, start_out: usize, len: usize) -> Self

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

pub fn slice_range(&self, r: Range<usize>) -> 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.

pub fn into_slice_range(self, r: Range<usize>) -> Self

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

pub fn split_off(self, at: usize) -> (Self, Self)

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

pub fn pop(self) -> (T, Self)

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

pub fn truncate(self, len: usize) -> Self

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

pub fn from_slice<A: SeqTrait<T>>(input: &A, start: usize, len: usize) -> 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.

pub fn concat<A: SeqTrait<T>>(&self, next: &A) -> 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.

pub fn concat_owned(self, next: Self) -> 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.

pub fn push(&self, next: &T) -> 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.

pub fn push_owned(self, next: T) -> 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.

pub fn from_slice_range<A: SeqTrait<T>>(input: &A, r: Range<usize>) -> 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.

pub fn num_chunks(&self, chunk_size: usize) -> usize

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.

pub fn num_exact_chunks(&self, chunk_size: usize) -> usize

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. Get the number of chunks of chunk_size in this array. There might be less than chunk_size remaining elements in this array beyond these.

pub fn get_chunk(&self, chunk_size: usize, chunk_number: usize) -> (usize, 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.

pub fn get_exact_chunk(&self, chunk_size: usize, chunk_number: usize) -> 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. Get the chunk_number chunk of chunk_size from this array as Seq<T>. The resulting sequence is of exactly chunk_size length. Until #84 is fixed this returns an empty sequence if not enough elements are left.

pub fn get_remainder_chunk(&self, chunk_size: usize) -> 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. Get the remaining chunk of this array of length less than chunk_size. If there’s no remainder, i.e. if the length of this array can be divided by chunk_size without a remainder, the function returns an empty sequence (until #84 is fixed).

pub fn set_chunk<A: SeqTrait<T>>(
    self,
    chunk_size: usize,
    chunk_number: usize,
    input: &A
) -> 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.

pub fn set_exact_chunk<A: SeqTrait<T>>(
    self,
    chunk_size: usize,
    chunk_number: usize,
    input: &A
) -> 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.

pub fn update_owned(self, start_out: usize, v: Self) -> 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.

impl<T: Clone + Default + PublicInteger> PublicSeq<T>

pub fn from_vec(b: Vec<T>) -> PublicSeq<T>

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn from_native_slice(x: &[T]) -> PublicSeq<T>

Function that is not part of the language but is offered as a helper for tests, etc.

pub fn from_seq<U: SeqTrait<T>>(x: &U) -> PublicSeq<T>

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.

impl PublicSeq<u8>

pub fn from_hex(s: &str) -> PublicSeq<u8>

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

pub fn from_string(s: String) -> PublicSeq<u8>

Function that is not part of the language but is offered as a helper for tests, etc.

impl PublicSeq<u8>

pub fn to_hex(&self) -> String

Function that is not part of the language but is offered as a helper for tests, etc.

Trait Implementations

impl<T: Numeric + PublicInteger + Copy> Add<PublicSeq<T>> for PublicSeq<T>

Polynomial addition on ℤ[x]

fn add(self, rhs: Self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the + operator.

impl<T: Numeric + PublicInteger + Copy> BitAnd<PublicSeq<T>> for PublicSeq<T>

fn bitand(self, rhs: Self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the & operator.

impl<T: Numeric + PublicInteger + Copy> BitOr<PublicSeq<T>> for PublicSeq<T>

fn bitor(self, rhs: Self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the | operator.

impl<T: Numeric + PublicInteger + Copy> BitXor<PublicSeq<T>> for PublicSeq<T>

fn bitxor(self, rhs: Self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the ^ operator.

impl<T: Clone + Default + PublicInteger> Clone for PublicSeq<T>

fn clone(&self) -> PublicSeq<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Default + PublicInteger> Debug for PublicSeq<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + Default + PublicInteger> Default for PublicSeq<T>

fn default() -> PublicSeq<T>

Returns the “default value” for a type.

impl<T: Clone + Default + PublicInteger> Index<Range<usize>> for PublicSeq<T>

fn index(&self, r: Range<usize>) -> &[T]

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

type Output = [T]

The returned type after indexing.

impl<T: Clone + Default + PublicInteger> Index<i32> for PublicSeq<T>

fn index(&self, i: i32) -> &T

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

type Output = T

The returned type after indexing.

impl<T: Clone + Default + PublicInteger> Index<u32> for PublicSeq<T>

fn index(&self, i: u32) -> &T

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

type Output = T

The returned type after indexing.

impl<T: Clone + Default + PublicInteger> Index<u8> for PublicSeq<T>

fn index(&self, i: u8) -> &T

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

type Output = T

The returned type after indexing.

impl<T: Clone + Default + PublicInteger> Index<usize> for PublicSeq<T>

fn index(&self, i: usize) -> &T

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

type Output = T

The returned type after indexing.

impl<T: Clone + Default + PublicInteger> IndexMut<i32> for PublicSeq<T>

fn index_mut(&mut self, i: i32) -> &mut T

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

impl<T: Clone + Default + PublicInteger> IndexMut<u32> for PublicSeq<T>

fn index_mut(&mut self, i: u32) -> &mut T

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

impl<T: Clone + Default + PublicInteger> IndexMut<u8> for PublicSeq<T>

fn index_mut(&mut self, i: u8) -> &mut T

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

impl<T: Clone + Default + PublicInteger> IndexMut<usize> for PublicSeq<T>

fn index_mut(&mut self, i: usize) -> &mut T

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

impl<T: Numeric + PublicInteger + Copy> ModNumeric for PublicSeq<T>

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

(self - rhs) % n.

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

(self + rhs) % n

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

(self * rhs) % n

fn pow_mod(self, exp: Self, n: Self) -> Self

(self ^ exp) % n

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

self % n

fn absolute(self) -> 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. |self| (coefficient-wise)

fn signed_modulo(self, _n: Self) -> Self

self % n that always returns a positive integer

impl<T: Numeric + PublicInteger + Copy> Mul<PublicSeq<T>> for PublicSeq<T>

Polynomial multiplication on ℤ[x]

fn mul(self, rhs: Self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the * operator.

impl<T: Numeric + PublicInteger + Copy> Not for PublicSeq<T>

fn not(self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the ! operator.

impl<T: Numeric + PublicInteger + Copy> Numeric for PublicSeq<T>

fn max_val() -> Self

Return largest value that can be represented.

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

self ^ exp where exp is a u32.

fn pow_self(self, exp: Self) -> Self

self ^ exp where exp is a Self.

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

Division.

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

Invert self modulo n.

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

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

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

fn wrap_div(self, rhs: Self) -> Self

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

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

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

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

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

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

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

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

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

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

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

impl<T: Copy + Default + PartialEq + PublicInteger> PartialEq<PublicSeq<T>> for PublicSeq<T>

fn eq(&self, other: &Self) -> bool

Function that is not part of the language but is offered as a helper for tests, etc.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Clone + Default + PublicInteger> SeqTrait<T> for PublicSeq<T>

fn create(l: usize) -> 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. Get a new sequence of capacity l.

fn len(&self) -> usize

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

fn iter(&self) -> Iter<'_, T>

Function that is not part of the language but is offered as a helper for tests, etc.

fn update_slice<A: SeqTrait<T>>(
    self,
    start_out: usize,
    v: &A,
    start_in: usize,
    len: usize
) -> 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.

fn update<A: SeqTrait<T>>(self, start: usize, v: &A) -> 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.

fn update_start<A: SeqTrait<T>>(self, v: &A) -> 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.

impl<T: Numeric + PublicInteger + Copy> Shl<usize> for PublicSeq<T>

fn shl(self, rhs: usize) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the << operator.

impl<T: Numeric + PublicInteger + Copy> Shr<usize> for PublicSeq<T>

fn shr(self, rhs: usize) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the >> operator.

impl<T: Numeric + PublicInteger + Copy> Sub<PublicSeq<T>> for PublicSeq<T>

Polynomial subtraction on ℤ[x]

fn sub(self, rhs: Self) -> Self::Output

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.

type Output = PublicSeq<T>

The resulting type after applying the - operator.

impl<T: Copy + Default + PartialEq + PublicInteger> Eq for PublicSeq<T>