### Ordering Implementation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1073741823.html Provides comparison methods for UInt. ```APIDOC ## impl Ord for UInt ### Description Provides ordering comparisons for UInt values. ### Method #### cmp - **cmp**(&self, other: &UInt) -> Ordering This method returns an `Ordering` between `self` and `other`. #### max - **max**(self, other: Self) -> Self Compares and returns the maximum of two values. #### min - **min**(self, other: Self) -> Self Compares and returns the minimum of two values. #### clamp - **clamp**(self, min: Self, max: Self) -> Self Restrict a value to a certain interval. ``` -------------------------------- ### Get Bit Operation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U4096.html Provides functionality to get a specific bit from a `UInt` value. ```APIDOC ## GetBit> for UInt ### Description Retrieves a specific bit from a `UInt` value. ### Type `Output = as Sub>::Output>>::Output` ``` ```APIDOC ## GetBit for UInt ### Description Retrieves the least significant bit (LSB) from a `UInt` value. ### Type `Output = Bn` ``` -------------------------------- ### Get Bit Operation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U32768.html Provides functionality to get a specific bit from a UInt value. ```APIDOC ## impl GetBit> for UInt ### Description Retrieves a bit from `UInt` at a position specified by `UInt`. ### Type #### type Output = as Sub>::Output>>::Output ``` ```APIDOC ## impl GetBit for UInt ### Description Retrieves a bit from `UInt` at the `UTerm` position. ### Type #### type Output = Bn ``` -------------------------------- ### PInt Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P605.html Provides details on the implementations available for the PInt type, which P605 is an alias for. This includes methods for instantiation and various arithmetic and comparison traits. ```APIDOC ## Implementations ### impl PInt This block details the general implementations for `PInt`. #### pub fn new() -> PInt Instantiates a singleton representing this strictly positive integer. ### Trait Implementations #### impl Abs for PInt Provides the absolute value for `PInt`. - **type Output**: `PInt` #### impl Add> for PInt
    Handles addition of a positive integer with a negative integer. - **type Output**: The resulting type after applying the `+` operator. - **fn add(self, rhs: NInt) -> ...** Performs the `+` operation. #### impl Add> for PInt
      Handles addition of two positive integers. - **type Output**: `PInt<
        >::Output>` - **fn add(self, _: PInt) -> ...** Performs the `+` operation. #### impl Add for PInt Handles addition of a positive integer with zero. - **type Output**: `PInt` - **fn add(self, _: Z0) -> ...** Performs the `+` operation. #### impl Binary for PInt Enables binary formatting for `PInt`. - **fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>** Formats the value using the given formatter. #### impl Clone for PInt Allows cloning of `PInt` instances. - **fn clone(&self) -> PInt** Returns a duplicate of the value. - **fn clone_from(&mut self, source: &Self)** Performs copy-assignment from `source`. #### impl Cmp> for PInt

        Compares a positive integer with a negative integer. - **type Output**: `Greater` (or `Less`, `Equal`) #### impl Cmp> for PInt Compares two positive integers. - **type Output**: The result of the comparison (`Greater`, `Less`, or `Equal`). #### impl Cmp for PInt Compares a positive integer with zero. - **type Output**: `Greater` (or `Less`, `Equal`) #### impl Debug for PInt Enables debug formatting for `PInt`. - **fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>** Formats the value using the given formatter. #### impl Default for PInt Provides a default value for `PInt`. - **fn default() -> PInt** Returns the “default value” for a type. #### impl Div> for PInt

          Handles division of a positive integer by a negative integer. - **type Output**: The resulting type after applying the `/` operator. - **fn div(self, rhs: NInt) -> ...** Performs the `/` operation. #### impl Div> for PInt
            Handles division of two positive integers. - **type Output**: The resulting type after applying the `/` operator. - **fn div(self, rhs: PInt) -> ...** Performs the `/` operation. #### impl Gcd> for PInt Calculates the greatest common divisor with a negative integer. - **type Output**: `PInt<>::Output>` #### impl Gcd> for PInt Calculates the greatest common divisor of two positive integers. - **type Output**: `PInt<>::Output>` #### impl Gcd for PInt Calculates the greatest common divisor with zero. ``` -------------------------------- ### Comparison Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U278.html Details on how UInt compares with other types, including specific implementations for different scenarios. ```APIDOC ## Cmp> for UInt ### Description Compares `UInt` with `UInt>::Output` ### Details The result of the comparison is `Equal` when `Ul` is equal to `Ur`. ``` ```APIDOC ## Cmp> for UInt ### Description Compares `UInt` with `UInt>::Output` ### Details The result of the comparison is `Less` when `Ul` is less than `Ur`. ``` ```APIDOC ## Cmp for UInt ### Description Compares `UInt` with `UTerm` (Zero). ### Type `Output = Greater` ### Details Any `UInt` is considered `Greater` than `UTerm`. ``` -------------------------------- ### Length Implementation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U884.html Details how to get the length of a UInt value. ```APIDOC ## Len for UInt ### Description Provides the length of a UInt value as a type-level unsigned integer. ### Type `Output = <::Output as Add>::Output` ### Method `len(&self) -> as Len>::Output` ``` -------------------------------- ### Get Bit Operation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1000000000000.html Retrieves a specific bit from a UInt type. ```APIDOC ## type Output = as Sub>::Output>>::Output ``` ```APIDOC ## type Output = Bn ``` -------------------------------- ### PInt Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P60.html Provides details on various operations and traits implemented for PInt, which P60 is an alias for. ```APIDOC ## PInt Implementations ### impl PInt where U: Unsigned + NonZero, Source #### pub fn new() -> PInt Instantiates a singleton representing this strictly positive integer. ### impl Abs for PInt where U: Unsigned + NonZero, Source #### type Output = PInt The absolute value. ### impl Add> for PInt
              where Ul: Unsigned + NonZero + Cmp + PrivateIntegerAdd<
                >::Output, Ur>, Ur: Unsigned + NonZero, `P(Ul) + N(Ur)`: We resolve this with our `PrivateAdd` Source #### type Output =
                  >::Output, Ur>>::Output The resulting type after applying the `+` operator. Source #### fn add(self, rhs: NInt) -> as Add>>::Output Performs the `+` operation. Read more ### impl Add> for PInt
                    where Ul: Unsigned + NonZero + Add, Ur: Unsigned + NonZero,
                      >::Output: Unsigned + NonZero, `P(Ul) + P(Ur) = P(Ul + Ur)` Source #### type Output = PInt<
                        >::Output> The resulting type after applying the `+` operator. Source #### fn add(self, _: PInt) -> as Add>>::Output Performs the `+` operation. Read more ### impl Add for PInt where U: Unsigned + NonZero, `PInt + Z0 = PInt` Source #### type Output = PInt The resulting type after applying the `+` operator. Source #### fn add(self, _: Z0) -> as Add>::Output Performs the `+` operation. Read more ### impl Binary for PInt where U: Unsigned + NonZero + Binary, Source #### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> Formats the value using the given formatter. Read more ### impl Clone for PInt where U: Clone + Unsigned + NonZero, Source #### fn clone(&self) -> PInt Returns a duplicate of the value. Read more 1.0.0 #### fn clone_from(&mut self, source: &Self) Performs copy-assignment from `source`. Read more Source ### impl Cmp> for PInt

                        where P: Unsigned + NonZero, N: Unsigned + NonZero, X > - Y Source #### type Output = Greater The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`. ### impl Cmp> for PInt where Pl: Cmp + Unsigned + NonZero, Pr: Unsigned + NonZero, X <==> Y Source #### type Output = >::Output The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`. ### impl Cmp for PInt where U: Unsigned + NonZero, X > 0 Source #### type Output = Greater The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`. ### impl Debug for PInt where U: Debug + Unsigned + NonZero, Source #### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> Formats the value using the given formatter. Read more ### impl Default for PInt where U: Default + Unsigned + NonZero, Source #### fn default() -> PInt Returns the “default value” for a type. Read more ### impl Div> for PInt

                          where Ul: Unsigned + NonZero + Cmp, Ur: Unsigned + NonZero, PInt
                            : PrivateDivInt<
                              >::Output, NInt>, `$A
                                / $B = $R
                                  ` Source #### type Output = as PrivateDivInt<
                                    >::Output, NInt>>::Output The resulting type after applying the `/` operator. Source #### fn div(self, rhs: NInt) -> as Div>>::Output Performs the `/` operation. Read more ### impl Div> for PInt
                                      where Ul: Unsigned + NonZero + Cmp, Ur: Unsigned + NonZero, PInt
                                        : PrivateDivInt<
                                          >::Output, PInt>, `$A
                                            / $B = $R
                                              ` Source #### type Output = as PrivateDivInt<
                                                >::Output, PInt>>::Output The resulting type after applying the `/` operator. Source #### fn div(self, rhs: PInt) -> as Div>>::Output Performs the `/` operation. Read more ### impl Gcd> for PInt where U1: Unsigned + NonZero + Gcd, U2: Unsigned + NonZero, >::Output: Unsigned + NonZero, Source #### type Output = PInt<>::Output> The greatest common divisor. ### impl Gcd> for PInt where U1: Unsigned + NonZero + Gcd, U2: Unsigned + NonZero, >::Output: Unsigned + NonZero, Source #### type Output = PInt<>::Output> The greatest common divisor. ### impl Gcd for PInt where U: Unsigned + NonZero, Source #### type Output = PInt The greatest common divisor. ``` -------------------------------- ### GetBit Operations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U962.html Provides functionality to get specific bits from UInt types. ```APIDOC ## GetBit> for UInt ### Description Retrieves a specific bit from `UInt` based on the index `UInt`. ### Type `Output = as Sub>::Output>>::Output` ``` ```APIDOC ## GetBit for UInt ### Description Retrieves the least significant bit from `UInt`. ### Type `Output = Bn` ``` -------------------------------- ### PInt Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P956.html Provides details on the `new` function for instantiating PInt, and various trait implementations like Abs, Add, Binary, Clone, Cmp, Debug, Default, Div, and Gcd. ```APIDOC ## Implementations ### impl PInt where U: Unsigned + NonZero, #### pub fn new() -> PInt Instantiates a singleton representing this strictly positive integer. ### impl Abs for PInt where U: Unsigned + NonZero, #### type Output = PInt The absolute value. ### impl Add> for PInt
                                                  where Ul: Unsigned + NonZero + Cmp + PrivateIntegerAdd<
                                                    >::Output, Ur>, Ur: Unsigned + NonZero, `P(Ul) + N(Ur)`: We resolve this with our `PrivateAdd` #### type Output =
                                                      >::Output, Ur>>::Output The resulting type after applying the `+` operator. #### fn add(self, rhs: NInt) -> as Add>>::Output Performs the `+` operation. ### impl Add> for PInt
                                                        where Ul: Unsigned + NonZero + Add, Ur: Unsigned + NonZero,
                                                          >::Output: Unsigned + NonZero, `P(Ul) + P(Ur) = P(Ul + Ur)` #### type Output = PInt<
                                                            >::Output> The resulting type after applying the `+` operator. #### fn add(self, _: PInt) -> as Add>>::Output Performs the `+` operation. ### impl Add for PInt where U: Unsigned + NonZero, `PInt + Z0 = PInt` #### type Output = PInt The resulting type after applying the `+` operator. #### fn add(self, _: Z0) -> as Add>::Output Performs the `+` operation. ### impl Binary for PInt where U: Unsigned + NonZero + Binary, #### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> Formats the value using the given formatter. ### impl Clone for PInt where U: Clone + Unsigned + NonZero, #### fn clone(&self) -> PInt Returns a duplicate of the value. #### fn clone_from(&mut self, source: &Self) Performs copy-assignment from `source`. ### impl Cmp> for PInt

                                                            where P: Unsigned + NonZero, N: Unsigned + NonZero, X > - Y #### type Output = Greater The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`. ### impl Cmp> for PInt where Pl: Cmp + Unsigned + NonZero, Pr: Unsigned + NonZero, X <==> Y #### type Output = >::Output The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`. ### impl Cmp for PInt where U: Unsigned + NonZero, X > 0 #### type Output = Greater The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`. ### impl Debug for PInt where U: Debug + Unsigned + NonZero, #### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> Formats the value using the given formatter. ### impl Default for PInt where U: Default + Unsigned + NonZero, #### fn default() -> PInt Returns the “default value” for a type. ### impl Div> for PInt

                                                              where Ul: Unsigned + NonZero + Cmp, Ur: Unsigned + NonZero, PInt
                                                                : PrivateDivInt<
                                                                  >::Output, NInt>, `$A
                                                                    / $B = $R
                                                                      ` #### type Output = as PrivateDivInt<
                                                                        >::Output, NInt>>::Output The resulting type after applying the `/` operator. #### fn div(self, rhs: NInt) -> as Div>>::Output Performs the `/` operation. ### impl Div> for PInt
                                                                          where Ul: Unsigned + NonZero + Cmp, Ur: Unsigned + NonZero, PInt
                                                                            : PrivateDivInt<
                                                                              >::Output, PInt>, `$A
                                                                                / $B = $R
                                                                                  ` #### type Output = as PrivateDivInt<
                                                                                    >::Output, PInt>>::Output The resulting type after applying the `/` operator. #### fn div(self, rhs: PInt) -> as Div>>::Output Performs the `/` operation. ### impl Gcd> for PInt where U1: Unsigned + NonZero + Gcd, U2: Unsigned + NonZero, >::Output: Unsigned + NonZero, #### type Output = PInt<>::Output> The greatest common divisor. ### impl Gcd> for PInt where U1: Unsigned + NonZero + Gcd, U2: Unsigned + NonZero, >::Output: Unsigned + NonZero, #### type Output = PInt<>::Output> The greatest common divisor. ### impl Gcd for PInt where U: Unsigned + NonZero, ``` -------------------------------- ### Length Implementation (Len) Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U894.html Provides a way to get the length of a UInt value. ```APIDOC ## Len for UInt ### Description Calculates the length of the `UInt` value. ### Type `Output = <::Output as Add>::Output` ### Method `len(&self) -> as Len>::Output` ### Returns The length of the `UInt` as a type-level unsigned integer. ``` -------------------------------- ### Comparison Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U800.html Details on how UInt compares with other types, including specific implementations for Cmp. ```APIDOC ## Cmp> for UInt ### Description Compares `UInt` with `UInt`. The result is `Equal` if `Ul` equals `Ur`. ### Type `Output =
                                                                                      >::Output` ### Details `UInt` cmp with `UInt`: `SoFar` is `Equal` ## Cmp> for UInt ### Description Compares `UInt` with `UInt`. The result is `Less` if `Ul` is less than `Ur`. ### Type `Output =
                                                                                        >::Output` ### Details `UInt` cmp with `UInt`: `SoFar` is `Less` ## Cmp for UInt ### Description Compares `UInt` with `UTerm`. Any `UInt` is considered `Greater` than `UTerm` (Zero). ### Type `Output = Greater` ### Details Nonzero > Zero ``` -------------------------------- ### Ordering Implementation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U405.html Provides comparison methods for UInt values. ```APIDOC ## impl Ord for UInt ### Description Provides ordering capabilities for UInt values. ### Methods - **cmp**: Compares two UInt values and returns an `Ordering`. - **max**: Returns the maximum of two UInt values. - **min**: Returns the minimum of two UInt values. - **clamp**: Restricts a value to a specified interval. ``` -------------------------------- ### Len Implementation for UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U759.html Provides a method to get the length of a UInt value. ```APIDOC ## Len for UInt ### Description Provides a way to determine the length of a UInt value. ### Type Aliases #### `Output` The length as a type-level unsigned integer. ### Methods #### `len(&self) -> as Len>::Output` Returns the length of the UInt. This function may not be used within this crate but can be useful for others. ``` -------------------------------- ### Get Bit Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U398.html Provides functionality to retrieve a specific bit from a UInt value. ```APIDOC ## GetBit> for UInt ### Description Retrieves a specific bit from a `UInt` value when the index is also a `UInt`. ### Type `Output = as Sub>::Output>>::Output` ``` ```APIDOC ## GetBit for UInt ### Description Retrieves a specific bit from a `UInt` value when the index is `UTerm`. ### Type `Output = Bn` ``` -------------------------------- ### Ordering (`Ord`, `PartialOrd`, `PartialEq`) Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U464.html Provides methods for comparing UInt values, including equality, ordering, finding minimum/maximum, and clamping. ```APIDOC ## impl Ord for UInt ### Description Provides total ordering for `UInt`. ### Method `cmp(&self, other: &UInt) -> Ordering` ### Description Compares `self` and `other` and returns an `Ordering`. ### Method `max(self, other: Self) -> Self` ### Description Returns the maximum of two values. ### Method `min(self, other: Self) -> Self` ### Description Returns the minimum of two values. ### Method `clamp(self, min: Self, max: Self) -> Self` ### Description Restricts a value to a specified interval. ``` ```APIDOC ## impl PartialEq for UInt ### Description Provides equality testing for `UInt`. ### Method `eq(&self, other: &UInt) -> bool` ### Description Tests if `self` and `other` are equal (`==`). ### Method `ne(&self, other: &Rhs) -> bool` ### Description Tests if `self` and `other` are not equal (`!=`). ``` ```APIDOC ## impl PartialOrd for UInt ### Description Provides partial ordering for `UInt`. ### Method `partial_cmp(&self, other: &UInt) -> Option` ### Description Compares `self` and `other` and returns an `Option` if one exists. ### Method `lt(&self, other: &Rhs) -> bool` ### Description Tests if `self` is less than `other` (`<`). ### Method `le(&self, other: &Rhs) -> bool` ### Description Tests if `self` is less than or equal to `other` (`<=`). ### Method `gt(&self, other: &Rhs) -> bool` ### Description Tests if `self` is greater than `other` (`>`). ### Method `ge(&self, other: &Rhs) -> bool` ### Description Tests if `self` is greater than or equal to `other` (`>=`). ``` -------------------------------- ### Comparison (`cmp`, `max`, `min`, `clamp`, `eq`, `ne`, `partial_cmp`, `lt`, `le`, `gt`, `ge`) Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U726.html Provides methods for comparing UInt values, including ordering, equality, finding maximum/minimum, and clamping values within a range. ```APIDOC ## Ord for UInt ### Description Provides total ordering for UInt types. ### Method Signature #### fn cmp(&self, other: &UInt) -> Ordering Compares `self` and `other`. #### fn max(self, other: Self) -> Self Returns the maximum of two values. #### fn min(self, other: Self) -> Self Returns the minimum of two values. #### fn clamp(self, min: Self, max: Self) -> Self Restricts a value to a specified interval. ## PartialEq for UInt ### Description Provides equality testing for UInt types. ### Method Signature #### fn eq(&self, other: &UInt) -> bool Tests if `self` and `other` are equal. #### fn ne(&self, other: &Rhs) -> bool Tests if `self` and `other` are not equal. ## PartialOrd for UInt ### Description Provides partial ordering for UInt types. ### Method Signature #### fn partial_cmp(&self, other: &UInt) -> Option Returns an ordering between `self` and `other` if one exists. #### fn lt(&self, other: &Rhs) -> bool Tests if `self` is less than `other`. #### fn le(&self, other: &Rhs) -> bool Tests if `self` is less than or equal to `other`. #### fn gt(&self, other: &Rhs) -> bool Tests if `self` is greater than `other`. #### fn ge(&self, other: &Rhs) -> bool Tests if `self` is greater than or equal to `other`. ``` -------------------------------- ### Get isize value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the isize representation of the UInt type. ```APIDOC ## fn to_isize() -> isize ### Description Returns the isize representation of the UInt type. ### Method fn to_isize() -> isize ``` -------------------------------- ### Comparison Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1024.html Details on how UInt can be compared with other types. ```APIDOC ## Cmp> for UInt ### Description Compares `UInt` with `UInt`. ### Type - `Output`: The result of the comparison, which can be `Greater`, `Less`, or `Equal`. ``` ```APIDOC ## Cmp> for UInt ### Description Compares `UInt` with `UInt`. ### Type - `Output`: The result of the comparison, which can be `Greater`, `Less`, or `Equal`. ``` ```APIDOC ## Cmp for UInt ### Description Compares `UInt` with `UTerm` (Zero). ### Type - `Output`: Always `Greater` as `UInt` is Nonzero and `UTerm` is Zero. ``` -------------------------------- ### Get i64 value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the i64 representation of the UInt type. ```APIDOC ## fn to_i64() -> i64 ### Description Returns the i64 representation of the UInt type. ### Method fn to_i64() -> i64 ``` -------------------------------- ### Get i32 value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the i32 representation of the UInt type. ```APIDOC ## fn to_i32() -> i32 ### Description Returns the i32 representation of the UInt type. ### Method fn to_i32() -> i32 ``` -------------------------------- ### PInt Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P68.html Provides details on the implementations available for the PInt type, including methods like `new()`. ```APIDOC ## impl PInt where U: Unsigned + NonZero, Source #### pub fn new() -> PInt Instantiates a singleton representing this strictly positive integer. ``` -------------------------------- ### Comparison (`cmp`, `max`, `min`, `clamp`) Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1000.html Provides methods for comparing UInt values, including checking for equality, ordering, finding the maximum and minimum, and clamping values within a range. ```APIDOC ## fn cmp(&self, other: &UInt) -> Ordering This method returns an `Ordering` between `self` and `other`. ### Description Compares two UInt values and returns their ordering. ### Method `cmp` ### Parameters - `other`: &UInt - The other UInt value to compare against. ### Response - `Ordering`: An enum representing the ordering (Less, Equal, Greater). ``` ```APIDOC ## fn max(self, other: Self) -> Self Compares and returns the maximum of two values. ### Description Returns the greater of two UInt values. ### Method `max` ### Parameters - `other`: Self - The other UInt value to compare. ### Response - `Self`: The maximum of the two UInt values. ``` ```APIDOC ## fn min(self, other: Self) -> Self Compares and returns the minimum of two values. ### Description Returns the smaller of two UInt values. ### Method `min` ### Parameters - `other`: Self - The other UInt value to compare. ### Response - `Self`: The minimum of the two UInt values. ``` ```APIDOC ## fn clamp(self, min: Self, max: Self) -> Self Restrict a value to a certain interval. ### Description Clamps a UInt value to be within a specified minimum and maximum range. ### Method `clamp` ### Parameters - `min`: Self - The minimum allowed value. - `max`: Self - The maximum allowed value. ### Response - `Self`: The clamped UInt value. ``` -------------------------------- ### Get i16 value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the i16 representation of the UInt type. ```APIDOC ## fn to_i16() -> i16 ### Description Returns the i16 representation of the UInt type. ### Method fn to_i16() -> i16 ``` -------------------------------- ### Comparison (`cmp`, `max`, `min`, `clamp`) Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U830.html Provides methods for comparing UInt values, including checking for equality, ordering, and finding maximum/minimum values. ```APIDOC ## Ord for UInt Provides ordering capabilities for UInt types. ### Method `fn cmp(&self, other: &UInt) -> Ordering` Compares `self` and `other` and returns an `Ordering`. ``` ```APIDOC ## Ord for UInt Provides methods for finding the maximum and minimum of two values. ### Method `fn max(self, other: Self) -> Self` Compares and returns the maximum of two values. ``` ```APIDOC ## Ord for UInt Provides methods for finding the maximum and minimum of two values. ### Method `fn min(self, other: Self) -> Self` Compares and returns the minimum of two values. ``` ```APIDOC ## Ord for UInt Provides a method for restricting a value within a specified interval. ### Method `fn clamp(self, min: Self, max: Self) -> Self` Restricts a value to a certain interval. ``` -------------------------------- ### Get i8 value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the i8 representation of the UInt type. ```APIDOC ## fn to_i8() -> i8 ### Description Returns the i8 representation of the UInt type. ### Method fn to_i8() -> i8 ``` -------------------------------- ### Comparison Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U694.html Details on how UInt compares with other types, including the output type of the comparison. ```APIDOC ## Cmp> for UInt ### Description Compares `UInt` with `UInt`. ### Type `Output =
                                                                                          >::Output` ## Cmp> for UInt ### Description Compares `UInt` with `UInt`. ### Type `Output =
                                                                                            >::Output` ## Cmp for UInt ### Description Compares `UInt` with `UTerm` (Zero). ### Type `Output = Greater` ``` -------------------------------- ### Get usize value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the usize representation of the UInt type. ```APIDOC ## fn to_usize() -> usize ### Description Returns the usize representation of the UInt type. ### Method fn to_usize() -> usize ``` -------------------------------- ### Ordering Implementation Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U911.html Provides comparison methods for UInt types. ```APIDOC ## Ord for UInt ### Description Implementation of the `Ord` trait for `UInt`. ### Methods - `cmp(&self, other: &UInt) -> Ordering`: Compares `self` and `other`. - `max(self, other: Self) -> Self`: Returns the maximum of two values. - `min(self, other: Self) -> Self`: Returns the minimum of two values. - `clamp(self, min: Self, max: Self) -> Self`: Restricts a value to a given interval. ``` -------------------------------- ### Get u64 value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the u64 representation of the UInt type. ```APIDOC ## fn to_u64() -> u64 ### Description Returns the u64 representation of the UInt type. ### Method fn to_u64() -> u64 ``` -------------------------------- ### UInt Implementations Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U411.html Provides details on the implementations available for the UInt type, including instantiation and arithmetic operations. ```APIDOC ## Implementations ### impl UInt #### pub fn new() -> UInt Instantiates a singleton representing this unsigned integer. ``` ```APIDOC ### impl Add for UInt #### type Output = UInt The resulting type after applying the `+` operator. #### fn add(self, _: B0) -> as Add>::Output Performs the `+` operation. ``` ```APIDOC ### impl Add for UInt #### type Output = UInt<>::Output, B0> The resulting type after applying the `+` operator. #### fn add(self, _: B1) -> as Add>::Output Performs the `+` operation. ``` ```APIDOC ### impl Add> for UInt #### type Output = UInt<
                                                                                              >::Output, B1> The resulting type after applying the `+` operator. #### fn add(self, rhs: UInt) -> as Add>>::Output Performs the `+` operation. ``` ```APIDOC ### impl Add> for UInt #### type Output = UInt<<
                                                                                                >::Output as Add>::Output, B0> The resulting type after applying the `+` operator. #### fn add(self, rhs: UInt) -> as Add>>::Output Performs the `+` operation. ``` ```APIDOC ### impl Add for UInt #### type Output = UInt The resulting type after applying the `+` operator. #### fn add(self, _: UTerm) -> as Add>::Output Performs the `+` operation. ``` ```APIDOC ### impl ArrayLength for UInt #### type ArrayType Associated type representing the array type for the number ``` ```APIDOC ### impl Binary for UInt, B1> #### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> Formats the value using the given formatter. ``` ```APIDOC ### impl BitAnd for UInt #### type Output = < as PrivateAnd>::Output as Trim>::Output Anding unsigned integers. We use our `PrivateAnd` operator and then `Trim` the output. #### fn bitand(self, rhs: Ur) -> as BitAnd>::Output Performs the `&` operation. ``` ```APIDOC ### impl BitOr> for UInt #### type Output = UInt<
                                                                                                  >::Output, B1> #### fn bitor( self, rhs: UInt, ) -> as BitOr>>::Output Performs the `|` operation. ``` ```APIDOC ### impl BitOr> for UInt #### type Output = UInt<
                                                                                                    >::Output, B1> #### fn bitor( self, rhs: UInt, ) -> as BitOr>>::Output Performs the `|` operation. ``` ```APIDOC ### impl BitOr for UInt #### type Output = UInt #### fn bitor(self, _: UTerm) -> as BitOr>::Output Performs the `|` operation. ``` ```APIDOC ### impl BitXor for UInt #### type Output = < as PrivateXor>::Output as Trim>::Output Xoring unsigned integers. We use our `PrivateXor` operator and then `Trim` the output. #### fn bitxor(self, rhs: Ur) -> as BitXor>::Output Performs the `^` operation. ``` -------------------------------- ### Get u32 value from UInt Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U119.html Retrieves the u32 representation of the UInt type. ```APIDOC ## fn to_u32() -> u32 ### Description Returns the u32 representation of the UInt type. ### Method fn to_u32() -> u32 ```