Struct I24 

pub struct I24(/* private fields */);

A signed 24-bit integer type.

The I24 type represents a 24-bit signed integer in two’s complement format. It fills the gap between i16 and i32, offering reduced memory usage while preserving a larger numeric range than i16.

This type is particularly suited to applications such as audio processing, binary file manipulation, embedded systems, or networking protocols where 24-bit integers are common.

Range

The valid value range is:

  MIN = -8_388_608   // -2^23
  MAX =  8_388_607   //  2^23 - 1

Arithmetic operations are implemented to match Rust’s standard integer behavior, including overflow and checked variants.

Memory Layout and Safety

I24 is implemented as a #[repr(transparent)] wrapper around a 4-byte internal representation. Although the logical width is 24 bits, one additional byte is used for alignment and padding control.

This struct:

• Contains no uninitialized or padding bytes
• Is safe to use with bytemuck::NoUninit
• Can be cast safely with bytemuck::cast_slice for use in FFI and low-level applications

The layout is verified via compile-time assertions to ensure portability and correctness.

Binary Serialization

Although I24 occupies 4 bytes in memory, binary formats (e.g., WAV files, network protocols) often store 24-bit integers in a 3-byte representation. To support this:

• I24 provides I24::from_be_bytes, I24::from_le_bytes, and I24::from_ne_bytes methods for constructing values from 3-byte on-disk representations
• Corresponding I24::to_be_bytes, I24::to_le_bytes, and I24::to_ne_bytes methods convert to 3-byte representations

For efficient bulk deserialization, use the inherent methods on I24.

Note: Requires the alloc feature to be enabled.

use i24::I24;
let raw: &[u8] = &[0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF];
let values = I24::read_i24s_be(raw).expect("Test value should convert successfully");
assert_eq!(values[0].to_i32(), 1);
assert_eq!(values[1].to_i32(), -1);

Usage Notes

• Use the i24! macro for compile-time checked construction
• Use .to_i32() to convert to standard Rust types
• Supports traits like Add, Sub, Display, Hash, Ord, and FromStr

Features

• serde: Enables Serialize and Deserialize support via JSON or other formats
• pyo3: Exposes the I24 type to Python via PyO3 bindings (as I24)
• alloc: Enables I24DiskMethods for efficient bulk serialization/deserialization

Implementations

impl I24

pub const BITS: u32 = 24u32

The size of this integer type in bits

pub const MIN: I24

The smallest value that can be represented by this integer type (-2²³)

pub const MAX: I24

The largest value that can be represented by this integer type (2²³ − 1).

pub const ZERO: I24

Creates a new I24 with all bits set to zero.

pub const fn as_bits(&self) -> &u32

Returns a reference to the underlying 32-bit representation.

The 24-bit value is stored in the lower 24 bits, with the upper 8 bits guaranteed to be zero. This method provides direct access to the internal bit representation for advanced use cases.

pub const fn to_bits(self) -> u32

Returns the underlying 32-bit representation.

The 24-bit value is stored in the lower 24 bits, with the upper 8 bits guaranteed to be zero. This method extracts the internal bit representation for advanced use cases.

pub const fn to_i32(self) -> i32

Converts the 24-bit integer to a 32-bit signed integer.

This method performs sign extension if the 24-bit integer is negative.

Returns

The 32-bit signed integer representation of this I24.

pub const fn wrapping_from_i32(n: i32) -> I24

Creates an I24 from a 32-bit signed integer.

This method truncates the input to 24 bits if it’s outside the valid range.

Arguments

• n - The 32-bit signed integer to convert.

Returns

An I24 instance representing the input value.

pub const fn saturating_from_i32(n: i32) -> I24

Creates an I24 from a 32-bit signed integer.

This method saturates the input if it’s outside the valid range.

Arguments

• n - The 32-bit signed integer to convert.

Returns

An I24 instance representing the input value.

pub const fn swap_bytes(self) -> I24

Reverses the byte order of the integer.

pub const fn to_le(self) -> I24

Converts self to little endian from the target’s endianness. On little endian this is a no-op. On big endian the bytes are swapped.

pub const fn to_be(self) -> I24

Converts self to big endian from the target’s endianness. On big endian this is a no-op. On little endian the bytes are swapped.

pub const fn to_ne_bytes(self) -> [u8; 3]

Return the memory representation of this integer as a byte array in native byte order. As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

pub const fn to_le_bytes(self) -> [u8; 3]

Create a native endian integer value from its representation as a byte array in little endian.

pub const fn to_be_bytes(self) -> [u8; 3]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

pub const fn from_ne_bytes(bytes: [u8; 3]) -> I24

Creates an I24 from three bytes in native endian order.

Arguments

• bytes - An array of 3 bytes representing the 24-bit integer.

Returns

An I24 instance containing the input bytes.

pub const fn from_le_bytes(bytes: [u8; 3]) -> I24

Creates an I24 from three bytes in little-endian order.

Arguments

• bytes - An array of 3 bytes representing the 24-bit integer in little-endian order.

Returns

An I24 instance containing the input bytes.

pub const fn from_be_bytes(bytes: [u8; 3]) -> I24

Creates an I24 from three bytes in big-endian order.

Arguments

• bytes - An array of 3 bytes representing the 24-bit integer in big-endian order.

Returns

An I24 instance containing the input bytes interpreted as big-endian.

pub fn checked_add(self, other: I24) -> Option<I24>

Performs checked addition.

Arguments

• other - The I24 to add to this value.

Returns

Some(I24) if the addition was successful, or None if it would overflow.

pub fn checked_sub(self, other: I24) -> Option<I24>

Performs checked subtraction.

Arguments

• other - The I24 to subtract from this value.

Returns

Some(I24) if the subtraction was successful, or None if it would overflow.

pub fn checked_mul(self, other: I24) -> Option<I24>

Performs checked multiplication.

Arguments

• other - The I24 to multiply with this value.

Returns

Some(I24) if the multiplication was successful, or None if it would overflow.

pub fn checked_div(self, other: I24) -> Option<I24>

Performs checked division.

Arguments

• other - The I24 to divide this value by.

Returns

Some(I24) if the division was successful, or None if the divisor is zero or if the division would overflow.

pub fn checked_rem(self, other: I24) -> Option<I24>

Performs checked integer remainder.

Arguments

• other - The I24 to divide this value by.

Returns

Some(I24) if the remainder operation was successful, or None if the divisor is zero or if the division would overflow.

pub fn checked_neg(self) -> Option<I24>

Performs checked negation.

Returns

Some(I24) if the negation was successful, or None if it would overflow. This happens when negating I24::MIN (since -I24::MIN cannot be represented in 24 bits).

pub fn abs(self) -> I24

Computes the absolute value of self.

Returns

The absolute value of self. Note that I24::MIN.abs() will overflow and wrap to I24::MIN.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").abs(), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(-10).expect("Test value should convert successfully").abs(), I24::try_from_i32(10).expect("Test value should convert successfully"));

pub fn wrapping_abs(self) -> I24

Computes the absolute value of self without any wrapping or panicking.

Returns

The absolute value of self. For I24::MIN, returns I24::MIN (wrapping behavior).

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").wrapping_abs(), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(-10).expect("Test value should convert successfully").wrapping_abs(), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.wrapping_abs(), I24::MIN); // Wraps around

pub fn saturating_abs(self) -> I24

Computes the absolute value of self, saturating at the bounds instead of overflowing.

Returns

The absolute value of self. For I24::MIN, returns I24::MAX (saturating behavior).

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").saturating_abs(), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(-10).expect("Test value should convert successfully").saturating_abs(), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.saturating_abs(), I24::MAX); // Saturates to MAX

pub fn signum(self) -> I24

Returns a number representing the sign of self.

Returns

• 1 if self is positive
• 0 if self is zero
• -1 if self is negative

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").signum(), I24::try_from_i32(1).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(0).expect("Test value should convert successfully").signum(), I24::try_from_i32(0).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(-10).expect("Test value should convert successfully").signum(), I24::try_from_i32(-1).expect("Test value should convert successfully"));

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

Examples

use i24::I24;;
assert!(!I24::try_from_i32(10).expect("Test value should convert successfully").is_negative());
assert!(!I24::try_from_i32(0).expect("Test value should convert successfully").is_negative());
assert!(I24::try_from_i32(-10).expect("Test value should convert successfully").is_negative());

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

Examples

use i24::I24;;
assert!(I24::try_from_i32(10).expect("Test value should convert successfully").is_positive());
assert!(!I24::try_from_i32(0).expect("Test value should convert successfully").is_positive());
assert!(!I24::try_from_i32(-10).expect("Test value should convert successfully").is_positive());

pub fn abs_sub(&self, other: &I24) -> I24

The positive difference of two numbers.

Returns zero if the number is less than or equal to the other, otherwise the difference between self and other is returned.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").abs_sub(&I24::try_from_i32(5).expect("Test value should convert successfully")), I24::try_from_i32(5).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(5).expect("Test value should convert successfully").abs_sub(&I24::try_from_i32(10).expect("Test value should convert successfully")), I24::try_from_i32(0).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").abs_sub(&I24::try_from_i32(10).expect("Test value should convert successfully")), I24::try_from_i32(0).expect("Test value should convert successfully"));

pub fn clamp(self, min: I24, max: I24) -> I24

Restricts the value to a certain interval.

Returns max if self is greater than max, and min if self is less than min. Otherwise, returns self.

Panics

Panics if min > max.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(-3).expect("Test value should convert successfully").clamp(I24::try_from_i32(-2).expect("Test value should convert successfully"), I24::try_from_i32(1).expect("Test value should convert successfully")), I24::try_from_i32(-2).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(0).expect("Test value should convert successfully").clamp(I24::try_from_i32(-2).expect("Test value should convert successfully"), I24::try_from_i32(1).expect("Test value should convert successfully")), I24::try_from_i32(0).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(2).expect("Test value should convert successfully").clamp(I24::try_from_i32(-2).expect("Test value should convert successfully"), I24::try_from_i32(1).expect("Test value should convert successfully")), I24::try_from_i32(1).expect("Test value should convert successfully"));

pub fn min(self, other: I24) -> I24

Computes the minimum of self and other.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(1).expect("Test value should convert successfully").min(I24::try_from_i32(2).expect("Test value should convert successfully")), I24::try_from_i32(1).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(2).expect("Test value should convert successfully").min(I24::try_from_i32(1).expect("Test value should convert successfully")), I24::try_from_i32(1).expect("Test value should convert successfully"));

pub fn max(self, other: I24) -> I24

Computes the maximum of self and other.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(1).expect("Test value should convert successfully").max(I24::try_from_i32(2).expect("Test value should convert successfully")), I24::try_from_i32(2).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(2).expect("Test value should convert successfully").max(I24::try_from_i32(1).expect("Test value should convert successfully")), I24::try_from_i32(2).expect("Test value should convert successfully"));

pub fn wrapping_add(self, rhs: I24) -> I24

Wrapping (modular) addition. Computes self + rhs, wrapping around at the boundary of the type.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").wrapping_add(I24::try_from_i32(27).expect("Test value should convert successfully")), I24::try_from_i32(127).expect("Test value should convert successfully"));
assert_eq!(I24::MAX.wrapping_add(I24::try_from_i32(2).expect("Test value should convert successfully")), I24::MIN + I24::try_from_i32(1).expect("Test value should convert successfully"));

pub fn wrapping_sub(self, rhs: I24) -> I24

Wrapping (modular) subtraction. Computes self - rhs, wrapping around at the boundary of the type.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").wrapping_sub(I24::try_from_i32(100).expect("Test value should convert successfully")), I24::try_from_i32(0).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.wrapping_sub(I24::try_from_i32(1).expect("Test value should convert successfully")), I24::MAX);

pub fn wrapping_mul(self, rhs: I24) -> I24

Wrapping (modular) multiplication. Computes self * rhs, wrapping around at the boundary of the type.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").wrapping_mul(I24::try_from_i32(12).expect("Test value should convert successfully")), I24::try_from_i32(120).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(25).expect("Test value should convert successfully").wrapping_mul(I24::try_from_i32(4).expect("Test value should convert successfully")), I24::try_from_i32(100).expect("Test value should convert successfully"));

pub fn wrapping_div(self, rhs: I24) -> I24

Wrapping (modular) division. Computes self / rhs, wrapping around at the boundary of the type.

The only case where wrapping can occur is when dividing the minimum value by -1, which would overflow but instead wraps to the minimum value.

Panics

This function will panic if rhs is 0.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").wrapping_div(I24::try_from_i32(10).expect("Test value should convert successfully")), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.wrapping_div(I24::try_from_i32(-1).expect("Test value should convert successfully")), I24::MIN); // Wraps around

pub fn wrapping_rem(self, rhs: I24) -> I24

Wrapping (modular) remainder. Computes self % rhs, wrapping around at the boundary of the type.

The only case where wrapping can occur is when computing the remainder of the minimum value divided by -1, which would overflow but instead wraps to 0.

Panics

This function will panic if rhs is 0.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").wrapping_rem(I24::try_from_i32(10).expect("Test value should convert successfully")), I24::try_from_i32(0).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.wrapping_rem(I24::try_from_i32(-1).expect("Test value should convert successfully")), I24::try_from_i32(0).expect("Test value should convert successfully")); // Wraps around

pub fn wrapping_neg(self) -> I24

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").wrapping_neg(), I24::try_from_i32(-100).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.wrapping_neg(), I24::MIN); // Wraps around

pub fn saturating_add(self, rhs: I24) -> I24

Saturating integer addition. Computes self + rhs, saturating at the numeric bounds.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").saturating_add(I24::try_from_i32(1).expect("Test value should convert successfully")), I24::try_from_i32(101).expect("Test value should convert successfully"));
assert_eq!(I24::MAX.saturating_add(I24::try_from_i32(1).expect("Test value should convert successfully")), I24::MAX);
assert_eq!(I24::MIN.saturating_add(I24::try_from_i32(-1).expect("Test value should convert successfully")), I24::MIN);

pub fn saturating_sub(self, rhs: I24) -> I24

Saturating integer subtraction. Computes self - rhs, saturating at the numeric bounds.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").saturating_sub(I24::try_from_i32(127).expect("Test value should convert successfully")), I24::try_from_i32(-27).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.saturating_sub(I24::try_from_i32(1).expect("Test value should convert successfully")), I24::MIN);
assert_eq!(I24::MAX.saturating_sub(I24::try_from_i32(-1).expect("Test value should convert successfully")), I24::MAX);

pub const fn saturating_mul(self, rhs: I24) -> I24

Saturating integer multiplication. Computes self * rhs, saturating at the numeric bounds.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(10).expect("Test value should convert successfully").saturating_mul(I24::try_from_i32(12).expect("Test value should convert successfully")), I24::try_from_i32(120).expect("Test value should convert successfully"));
assert_eq!(I24::try_from_i32(1000000).expect("Test value should convert successfully").saturating_mul(I24::try_from_i32(10).expect("Test value should convert successfully")), I24::MAX);
assert_eq!(I24::try_from_i32(-1000000).expect("Test value should convert successfully").saturating_mul(I24::try_from_i32(10).expect("Test value should convert successfully")), I24::MIN);

pub fn saturating_div(self, rhs: I24) -> I24

Saturating integer division. Computes self / rhs, saturating at the numeric bounds.

The only case where saturation can occur is when dividing the minimum value by -1, which would overflow but instead saturates to the maximum value.

Panics

This function will panic if rhs is 0.

Examples

use i24::I24;;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").saturating_div(I24::try_from_i32(10).expect("Test value should convert successfully")), I24::try_from_i32(10).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.saturating_div(I24::try_from_i32(-1).expect("Test value should convert successfully")), I24::MAX); // Saturates

pub fn saturating_neg(self) -> I24

Saturating integer negation. Computes -self, saturating at the numeric bounds.

Examples

use i24::I24;
assert_eq!(I24::try_from_i32(100).expect("Test value should convert successfully").saturating_neg(), I24::try_from_i32(-100).expect("Test value should convert successfully"));
assert_eq!(I24::MIN.saturating_neg(), I24::MAX); // Saturates

pub fn read_i24s_le(bytes: &[u8]) -> Option<Vec<I24>>

Converts a byte slice in little-endian order to a Vec of I24 values.

This method interprets the input byte slice as a sequence of 24-bit unsigned integers stored in little-endian format (least significant byte first). Each I24 value requires exactly 3 bytes.

Arguments

• bytes - A byte slice containing 24-bit unsigned integers in little-endian format. The length must be a multiple of 3.

Returns

Some(Vec<I24>) containing the parsed values, or None if the input slice length is not a multiple of 3.

pub const fn read_i24s_le_slice(bytes: &[u8]) -> Option<&[I24]>

Converts a byte slice in little-endian order to a slice of I24 values.

This method interprets the input byte slice as a sequence of 24-bit integers stored in little-endian format. Each I24 value requires exactly 3 bytes.

Arguments

• bytes - A byte slice containing 24-bit integers in little-endian format. The length must be a multiple of 3.

Returns

Some(&[I24]) containing a slice view of the parsed values, or None if the input slice length is not a multiple of 3.

pub fn read_i24s_be(bytes: &[u8]) -> Option<Vec<I24>>

Converts a byte slice in big-endian order to a Vec of I24 values.

This method interprets the input byte slice as a sequence of 24-bit unsigned integers stored in big-endian format (most significant byte first). Each I24 value requires exactly 3 bytes.

Arguments

• bytes - A byte slice containing 24-bit unsigned integers in big-endian format. The length must be a multiple of 3.

Returns

Some(Vec<I24>) containing the parsed values, or None if the input slice length is not a multiple of 3.

pub unsafe fn read_i24s_le_unchecked(bytes: &[u8]) -> Vec<I24>

Reads multiple I24 values from a byte slice in little-endian format without length validation.

Safety

The input slice length must be a multiple of 3 bytes. Undefined behavior will occur if this precondition is not met.

Arguments

• bytes - A byte slice whose length must be a multiple of 3

Returns

A vector containing the parsed I24 values.

pub unsafe fn read_i24s_le_slice_unchecked(bytes: &[u8]) -> &[I24]

Reads multiple I24 values from a byte slice in little-endian format without length validation.

Safety

The caller must ensure that bytes.len() is a multiple of 3.

pub unsafe fn read_i24s_be_unchecked(bytes: &[u8]) -> Vec<I24>

Reads multiple I24 values from a byte slice in big-endian format without length validation.

Safety

The input slice length must be a multiple of 3 bytes. Undefined behavior will occur if this precondition is not met.

Arguments

• bytes - A byte slice whose length must be a multiple of 3

Returns

A vector containing the parsed I24 values.

pub fn write_i24s_le(values: &[I24]) -> Vec<u8>

Converts a slice of I24 values to a Vec of bytes in little-endian order.

pub fn write_i24s_be(values: &[I24]) -> Vec<u8>

Converts a slice of I24 values to a Vec of bytes in big-endian order.

pub fn read_i24s_ne(bytes: &[u8]) -> Option<Vec<I24>>

Reads multiple I24 values from a byte slice in native-endian format.

Arguments

• bytes - A byte slice whose length must be a multiple of 3

Returns

Some(Vec<I24>) containing the parsed values, or None if the input slice length is not a multiple of 3.

pub fn write_i24s_ne(values: &[I24]) -> Vec<u8>

Converts a slice of I24 values to a Vec of bytes in native-endian order.

impl I24

pub const fn from_u8(value: u8) -> I24

Creates an I24 from a u8 value.

This conversion is guaranteed to succeed as the source type fits within the 24-bit range.

impl I24

pub const fn from_u16(value: u16) -> I24

Creates an I24 from a u16 value.

This conversion is guaranteed to succeed as the source type fits within the 24-bit range.

impl I24

pub const fn from_bool(value: bool) -> I24

Creates an I24 from a bool value.

This conversion is guaranteed to succeed as the source type fits within the 24-bit range.

impl I24

pub const fn from_i8(value: i8) -> I24

Creates an I24 from a i8 value.

This conversion is guaranteed to succeed as the source type fits within the 24-bit range.

impl I24

pub const fn from_i16(value: i16) -> I24

Creates an I24 from a i16 value.

This conversion is guaranteed to succeed as the source type fits within the 24-bit range.

impl I24

pub const fn try_from_u32(value: u32) -> Option<I24>

Tries to create an I24 from a u32 value.

Returns Some(I24) if the value fits within the 24-bit signed range [-8,388,608, 8,388,607], or None if the value is out of range.

impl I24

pub const fn try_from_u64(value: u64) -> Option<I24>

Tries to create an I24 from a u64 value.

Returns Some(I24) if the value fits within the 24-bit signed range [-8,388,608, 8,388,607], or None if the value is out of range.

impl I24

pub const fn try_from_u128(value: u128) -> Option<I24>

Tries to create an I24 from a u128 value.

Returns Some(I24) if the value fits within the 24-bit signed range [-8,388,608, 8,388,607], or None if the value is out of range.

impl I24

pub const fn try_from_i32(value: i32) -> Option<I24>

Tries to create an I24 from a i32 value.

Returns Some(I24) if the value fits within the 24-bit signed range [-8,388,608, 8,388,607], or None if the value is out of range.

impl I24

pub const fn try_from_i64(value: i64) -> Option<I24>

Tries to create an I24 from a i64 value.

Returns Some(I24) if the value fits within the 24-bit signed range [-8,388,608, 8,388,607], or None if the value is out of range.

impl I24

pub const fn try_from_i128(value: i128) -> Option<I24>

Tries to create an I24 from a i128 value.

Returns Some(I24) if the value fits within the 24-bit signed range [-8,388,608, 8,388,607], or None if the value is out of range.

Trait Implementations

impl Add<&I24> for &I24

type Output = I24

The resulting type after applying the + operator.

fn add(self, other: &I24) -> I24

Performs the + operation.

impl Add<&I24> for I24

type Output = I24

The resulting type after applying the + operator.

fn add(self, other: &I24) -> I24

Performs the + operation.

impl Add<I24> for &I24

type Output = I24

The resulting type after applying the + operator.

fn add(self, other: I24) -> I24

Performs the + operation.

impl Add for I24

type Output = I24

The resulting type after applying the + operator.

fn add(self, other: I24) -> I24

Performs the + operation.

impl AddAssign<&I24> for I24

fn add_assign(&mut self, rhs: &I24)

Performs the += operation.

impl AddAssign for I24

fn add_assign(&mut self, rhs: I24)

Performs the += operation.

impl AudioSample for I24

const MAX: Self = I24::MAX

Maximum representable value for this sample type.

const MIN: Self = I24::MIN

Minimum representable value for this sample type.

const BITS: u8 = 24u8

Bit depth of this sample type.

const LABEL: &'static str = "I24"

Label used for plotting and display purposes.

const SAMPLE_TYPE: SampleType = SampleType::I24

Sample type enum variant.

fn slice_to_bytes(samples: &[Self]) -> Vec<u8>

Convert a slice of samples into a byte vector in native-endian order.

fn into_inner(self) -> Self

Consumes this sample and returns itself.

fn to_bytes(self) -> Vec<u8>

Convert this sample into a byte vector in native-endian order.

fn as_bytes<const N: usize>(&self) -> [u8; N]

where SampleByteSize<N>: SupportedByteSize,

Convert this sample into a byte array of specified size (must be supported) in native-endian order.

const BYTES: usize = _

Byte length

impl Binary for I24

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

Formats the value using the given formatter.

impl BitAnd<&I24> for &I24

type Output = I24

The resulting type after applying the & operator.

fn bitand(self, other: &I24) -> I24

Performs the & operation.

impl BitAnd<&I24> for I24

type Output = I24

The resulting type after applying the & operator.

fn bitand(self, rhs: &I24) -> I24

Performs the & operation.

impl BitAnd<I24> for &I24

type Output = I24

The resulting type after applying the & operator.

fn bitand(self, other: I24) -> I24

Performs the & operation.

impl BitAnd for I24

type Output = I24

The resulting type after applying the & operator.

fn bitand(self, rhs: I24) -> I24

Performs the & operation.

impl BitAndAssign<&I24> for I24

fn bitand_assign(&mut self, rhs: &I24)

Performs the &= operation.

impl BitAndAssign for I24

fn bitand_assign(&mut self, rhs: I24)

Performs the &= operation.

impl BitOr<&I24> for &I24

type Output = I24

The resulting type after applying the | operator.

fn bitor(self, other: &I24) -> I24

Performs the | operation.

impl BitOr<&I24> for I24

type Output = I24

The resulting type after applying the | operator.

fn bitor(self, rhs: &I24) -> I24

Performs the | operation.

impl BitOr<I24> for &I24

type Output = I24

The resulting type after applying the | operator.

fn bitor(self, other: I24) -> I24

Performs the | operation.

impl BitOr for I24

type Output = I24

The resulting type after applying the | operator.

fn bitor(self, rhs: I24) -> I24

Performs the | operation.

impl BitOrAssign<&I24> for I24

fn bitor_assign(&mut self, rhs: &I24)

Performs the |= operation.

impl BitOrAssign for I24

fn bitor_assign(&mut self, rhs: I24)

Performs the |= operation.

impl BitXor<&I24> for &I24

type Output = I24

The resulting type after applying the ^ operator.

fn bitxor(self, other: &I24) -> I24

Performs the ^ operation.

impl BitXor<&I24> for I24

type Output = I24

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &I24) -> I24

Performs the ^ operation.

impl BitXor<I24> for &I24

type Output = I24

The resulting type after applying the ^ operator.

fn bitxor(self, other: I24) -> I24

Performs the ^ operation.

impl BitXor for I24

type Output = I24

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: I24) -> I24

Performs the ^ operation.

impl BitXorAssign<&I24> for I24

fn bitxor_assign(&mut self, rhs: &I24)

Performs the ^= operation.

impl BitXorAssign for I24

fn bitxor_assign(&mut self, rhs: I24)

Performs the ^= operation.

impl CastFrom<I24> for I24

fn cast_from(value: I24) -> Self

Cast from the source type to Self.

impl CastFrom<I24> for f32

fn cast_from(value: I24) -> Self

Cast from the source type to Self.

impl CastFrom<I24> for f64

fn cast_from(value: I24) -> Self

Cast from the source type to Self.

impl CastFrom<I24> for i16

fn cast_from(value: I24) -> Self

Cast from the source type to Self.

impl CastFrom<I24> for i32

fn cast_from(value: I24) -> Self

Cast from the source type to Self.

impl CastFrom<f32> for I24

fn cast_from(value: f32) -> Self

Cast from the source type to Self.

impl CastFrom<f64> for I24

fn cast_from(value: f64) -> Self

Cast from the source type to Self.

impl CastFrom<i16> for I24

fn cast_from(value: i16) -> Self

Cast from the source type to Self.

impl CastFrom<i32> for I24

fn cast_from(value: i32) -> Self

Cast from the source type to Self.

impl CastFrom<usize> for I24

fn cast_from(value: usize) -> Self

Cast from the source type to Self.

impl CastInto<I24> for I24

fn cast_into(self) -> I24

Cast self into the target type.

impl CastInto<I24> for f32

fn cast_into(self) -> I24

Cast self into the target type.

impl CastInto<I24> for f64

fn cast_into(self) -> I24

Cast self into the target type.

impl CastInto<I24> for i16

fn cast_into(self) -> I24

Cast self into the target type.

impl CastInto<I24> for i32

fn cast_into(self) -> I24

Cast self into the target type.

impl CastInto<f32> for I24

fn cast_into(self) -> f32

Cast self into the target type.

impl CastInto<f64> for I24

fn cast_into(self) -> f64

Cast self into the target type.

impl CastInto<i16> for I24

fn cast_into(self) -> i16

Cast self into the target type.

impl CastInto<i32> for I24

fn cast_into(self) -> i32

Cast self into the target type.

impl Clone for I24

fn clone(&self) -> I24

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConvertTo<I24> for I24

fn convert_to(&self) -> I24

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<I24> for f32

fn convert_to(&self) -> I24

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<I24> for f64

fn convert_to(&self) -> I24

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<I24> for i16

fn convert_to(&self) -> I24

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<I24> for i32

fn convert_to(&self) -> I24

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<f32> for I24

fn convert_to(&self) -> f32

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<f64> for I24

fn convert_to(&self) -> f64

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<i16> for I24

fn convert_to(&self) -> i16

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl ConvertTo<i32> for I24

fn convert_to(&self) -> i32

Convert this sample to another audio sample type.

fn convert_from<F: AudioSample + ConvertTo<T>>(source: F) -> T

Convert from another audio sample type to this type. This is a convenience method that calls convert_to on the source value.

impl Debug for I24

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

Formats the value using the given formatter.

impl Default for I24

fn default() -> I24

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for I24

fn deserialize<D>( deserializer: D, ) -> Result<I24, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for I24

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

Formats the value using the given formatter.

impl Div<&I24> for &I24

type Output = I24

The resulting type after applying the / operator.

fn div(self, other: &I24) -> I24

Performs the / operation.

impl Div<&I24> for I24

type Output = I24

The resulting type after applying the / operator.

fn div(self, other: &I24) -> I24

Performs the / operation.

impl Div<I24> for &I24

type Output = I24

The resulting type after applying the / operator.

fn div(self, other: I24) -> I24

Performs the / operation.

impl Div for I24

type Output = I24

The resulting type after applying the / operator.

fn div(self, other: I24) -> I24

Performs the / operation.

impl DivAssign<&I24> for I24

fn div_assign(&mut self, rhs: &I24)

Performs the /= operation.

impl DivAssign for I24

fn div_assign(&mut self, rhs: I24)

Performs the /= operation.

impl From<bool> for I24

fn from(value: bool) -> I24

Converts to this type from the input type.

impl From<i16> for I24

fn from(value: i16) -> I24

Converts to this type from the input type.

impl From<i8> for I24

fn from(value: i8) -> I24

Converts to this type from the input type.

impl From<u16> for I24

fn from(value: u16) -> I24

Converts to this type from the input type.

impl From<u8> for I24

fn from(value: u8) -> I24

Converts to this type from the input type.

impl FromPrimitive for I24

where LittleEndianI24Repr: FromPrimitive,

fn from_i64(n: i64) -> Option<I24>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<I24>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for I24

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(str: &str) -> Result<I24, <I24 as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for I24

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[I24], state: &mut H)

where H: Hasher, I24: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for I24

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

Formats the value using the given formatter.

impl Mul<&I24> for &I24

type Output = I24

The resulting type after applying the * operator.

fn mul(self, other: &I24) -> I24

Performs the * operation.

impl Mul<&I24> for I24

type Output = I24

The resulting type after applying the * operator.

fn mul(self, other: &I24) -> I24

Performs the * operation.

impl Mul<I24> for &I24

type Output = I24

The resulting type after applying the * operator.

fn mul(self, other: I24) -> I24

Performs the * operation.

impl Mul for I24

type Output = I24

The resulting type after applying the * operator.

fn mul(self, other: I24) -> I24

Performs the * operation.

impl MulAssign<&I24> for I24

fn mul_assign(&mut self, rhs: &I24)

Performs the *= operation.

impl MulAssign for I24

fn mul_assign(&mut self, rhs: I24)

Performs the *= operation.

impl Neg for I24

type Output = I24

The resulting type after applying the - operator.

fn neg(self) -> I24

Performs the unary - operation.

impl Not for I24

type Output = I24

The resulting type after applying the ! operator.

fn not(self) -> I24

Performs the unary ! operation.

impl Num for I24

type FromStrRadixErr = ParseIntError

fn from_str_radix( str: &str, radix: u32, ) -> Result<I24, <I24 as Num>::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl NumCast for I24

Available on crate feature num-cast only.

Implementation of the NumCast trait for I24.

This allows safe casting from any type that implements ToPrimitive to I24. The conversion returns None if the source value cannot be represented within the 24-bit signed integer range [-8,388,608, 8,388,607].

fn from<T>(n: T) -> Option<I24>

where T: ToPrimitive,

Converts a value of type T to I24.

Arguments

• n - The value to convert, which must implement ToPrimitive.

Returns

• Some(I24) if the conversion succeeds and the value is within range.
• None if the conversion fails or the value is out of range.

Examples

use i24::I24;
use num_traits::NumCast;

// Successful conversions
assert_eq!(<I24 as NumCast>::from(1000i32), Some(I24::try_from_i32(1000).unwrap()));
assert_eq!(<I24 as NumCast>::from(500u16), Some(I24::try_from_i32(500).unwrap()));

// Out of range conversions
assert_eq!(<I24 as NumCast>::from(10_000_000i32), None);
assert_eq!(<I24 as NumCast>::from(-10_000_000i32), None);

impl Octal for I24

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

Formats the value using the given formatter.

impl One for I24

fn one() -> I24

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl Ord for I24

fn cmp(&self, other: &I24) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for I24

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for I24

fn partial_cmp(&self, other: &I24) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<&I24> for &I24

type Output = I24

The resulting type after applying the % operator.

fn rem(self, other: &I24) -> I24

Performs the % operation.

impl Rem<&I24> for I24

type Output = I24

The resulting type after applying the % operator.

fn rem(self, other: &I24) -> I24

Performs the % operation.

impl Rem<I24> for &I24

type Output = I24

The resulting type after applying the % operator.

fn rem(self, other: I24) -> I24

Performs the % operation.

impl Rem for I24

type Output = I24

The resulting type after applying the % operator.

fn rem(self, other: I24) -> I24

Performs the % operation.

impl RemAssign<&I24> for I24

fn rem_assign(&mut self, rhs: &I24)

Performs the %= operation.

impl RemAssign for I24

fn rem_assign(&mut self, rhs: I24)

Performs the %= operation.

impl Serialize for I24

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Shl<u32> for I24

type Output = I24

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> <I24 as Shl<u32>>::Output

Performs the << operation.

impl ShlAssign<u32> for I24

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl Shr<u32> for I24

type Output = I24

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> <I24 as Shr<u32>>::Output

Performs the >> operation.

impl ShrAssign<u32> for I24

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl Signed for I24

fn abs(&self) -> I24

Computes the absolute value.

fn abs_sub(&self, other: &I24) -> I24

The positive difference of two numbers.

fn signum(&self) -> I24

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl Sub<&I24> for &I24

type Output = I24

The resulting type after applying the - operator.

fn sub(self, other: &I24) -> I24

Performs the - operation.

impl Sub<&I24> for I24

type Output = I24

The resulting type after applying the - operator.

fn sub(self, other: &I24) -> I24

Performs the - operation.

impl Sub<I24> for &I24

type Output = I24

The resulting type after applying the - operator.

fn sub(self, other: I24) -> I24

Performs the - operation.

impl Sub for I24

type Output = I24

The resulting type after applying the - operator.

fn sub(self, other: I24) -> I24

Performs the - operation.

impl SubAssign<&I24> for I24

fn sub_assign(&mut self, rhs: &I24)

Performs the -= operation.

impl SubAssign for I24

fn sub_assign(&mut self, rhs: I24)

Performs the -= operation.

impl ToBytes for I24

type Bytes = [u8; 3]

fn to_be_bytes(&self) -> <I24 as ToBytes>::Bytes

Return the memory representation of this number as a byte array in big-endian byte order.

fn to_le_bytes(&self) -> <I24 as ToBytes>::Bytes

Return the memory representation of this number as a byte array in little-endian byte order.

fn to_ne_bytes(&self) -> Self::Bytes

Return the memory representation of this number as a byte array in native byte order.

impl ToPrimitive for I24

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

impl TryFrom<i128> for I24

type Error = <i8 as TryFrom<i64>>::Error

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<I24, <I24 as TryFrom<i128>>::Error>

Performs the conversion.

impl TryFrom<i32> for I24

type Error = <i8 as TryFrom<i64>>::Error

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<I24, <I24 as TryFrom<i32>>::Error>

Performs the conversion.

impl TryFrom<i64> for I24

type Error = <i8 as TryFrom<i64>>::Error

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<I24, <I24 as TryFrom<i64>>::Error>

Performs the conversion.

impl TryFrom<u128> for I24

type Error = <i8 as TryFrom<i64>>::Error

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<I24, <I24 as TryFrom<u128>>::Error>

Performs the conversion.

impl TryFrom<u32> for I24

type Error = <i8 as TryFrom<i64>>::Error

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<I24, <I24 as TryFrom<u32>>::Error>

Performs the conversion.

impl TryFrom<u64> for I24

type Error = <i8 as TryFrom<i64>>::Error

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<I24, <I24 as TryFrom<u64>>::Error>

Performs the conversion.

impl UpperHex for I24

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

Formats the value using the given formatter.

impl Zero for I24

fn zero() -> I24

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Zeroable for I24

where LittleEndianI24Repr: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl Copy for I24

impl Eq for I24

impl NoUninit for I24

where LittleEndianI24Repr: NoUninit,

impl ScalarOperand for I24

impl StructuralPartialEq for I24