Expand description
b
formatting.
The Binary
trait should format its output as a number in binary.
For primitive signed integers (i8
to i128
, and isize
),
negative values are formatted as the two’s complement representation.
The alternate flag, #
, adds a 0b
in front of the output.
For more information on formatters, see the module-level documentation.
Examples
Basic usage with i32
:
let x = 42; // 42 is '101010' in binary
assert_eq!(format!("{x:b}"), "101010");
assert_eq!(format!("{x:#b}"), "0b101010");
assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");
Implementing Binary
on a type:
use std::fmt;
struct Length(i32);
impl fmt::Binary for Length {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let val = self.0;
fmt::Binary::fmt(&val, f) // delegate to i32's implementation
}
}
let l = Length(107);
assert_eq!(format!("l as binary is: {l:b}"), "l as binary is: 1101011");
assert_eq!(
format!("l as binary is: {l:#032b}"),
"l as binary is: 0b000000000000000000000001101011"
);
Required methods
Implementations on Foreign Types
sourceimpl<T, const LANES: usize> Binary for Simd<T, LANES> where
T: SimdElement + Binary,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Binary for Simd<T, LANES> where
T: SimdElement + Binary,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<R> Binary for BitMask<R> where
R: BitRegister,
impl<R> Binary for BitMask<R> where
R: BitRegister,
sourceimpl<R> Binary for BitIdx<R> where
R: BitRegister,
impl<R> Binary for BitIdx<R> where
R: BitRegister,
sourceimpl<A, O> Binary for BitArray<A, O> where
O: BitOrder,
A: BitViewSized,
impl<A, O> Binary for BitArray<A, O> where
O: BitOrder,
A: BitViewSized,
sourceimpl<R> Binary for BitSel<R> where
R: BitRegister,
impl<R> Binary for BitSel<R> where
R: BitRegister,
sourceimpl<T, O> Binary for BitSlice<T, O> where
T: BitStore,
O: BitOrder,
impl<T, O> Binary for BitSlice<T, O> where
T: BitStore,
O: BitOrder,
Bit-Slice Rendering
This implementation prints the contents of a &BitSlice
in one of binary,
octal, or hexadecimal. It is important to note that this does not render the
raw underlying memory! They render the semantically-ordered contents of the
bit-slice as numerals. This distinction matters if you use type parameters that
differ from those presumed by your debugger (which is usually <Msb0, u8>
).
The output separates the T
elements as individual list items, and renders each
element as a base- 2, 8, or 16 numeric string. When walking an element, the bits
traversed by the bit-slice are considered to be stored in
most-significant-bit-first ordering. This means that index [0]
is the high bit
of the left-most digit, and index [n]
is the low bit of the right-most digit,
in a given printed word.
In order to render according to expectations of the Arabic numeral system, an
element being transcribed is chunked into digits from the least-significant end
of its rendered form. This is most noticeable in octal, which will always have a
smaller ceiling on the left-most digit in a printed word, while the right-most
digit in that word is able to use the full 0 ..= 7
numeral range.
Examples
use bitvec::prelude::*;
let data = [
0b000000_10u8,
// digits print LTR
0b10_001_101,
// significance is computed RTL
0b01_000000,
];
let bits = &data.view_bits::<Msb0>()[6 .. 18];
assert_eq!(format!("{:b}", bits), "[10, 10001101, 01]");
assert_eq!(format!("{:o}", bits), "[2, 215, 1]");
assert_eq!(format!("{:X}", bits), "[2, 8D, 1]");
The {:#}
format modifier causes the standard 0b
, 0o
, or 0x
prefix to be
applied to each printed word. The other format specifiers are not interpreted by
this implementation, and apply to the entire rendered text, not to individual
words.