53 lines
1.9 KiB
Rust
53 lines
1.9 KiB
Rust
#![cfg_attr(not(test),no_std)]
|
|
pub mod signed;
|
|
pub mod unsigned;
|
|
#[cfg(test)]
|
|
mod testing;
|
|
|
|
use core::num::TryFromIntError;
|
|
|
|
/// A trait definition for large numbers.
|
|
pub trait CryptoNum {
|
|
/// Generate a new value of the given type.
|
|
fn zero() -> Self;
|
|
/// Test if the number is zero.
|
|
fn is_zero(&self) -> bool;
|
|
/// Test if the number is even.
|
|
fn is_even(&self) -> bool;
|
|
/// Test if the number is odd.
|
|
fn is_odd(&self) -> bool;
|
|
/// The size of this number in bits.
|
|
fn bit_length() -> usize;
|
|
/// Mask off the high parts of the number. In particular, it
|
|
/// zeros the bits above (len * 64).
|
|
fn mask(&mut self, len: usize);
|
|
/// Test if the given bit is zero, where bits are numbered in
|
|
/// least-significant order (0 is the LSB, etc.).
|
|
fn testbit(&self, bit: usize) -> bool;
|
|
/// Convert a slice into a CryptoNum, assuming big-endian memory layout.
|
|
/// If you pass in a slice bigger than the bit size of the numeric type,
|
|
/// this will assume that the number is in the first `n` bits of the
|
|
/// memory layout. If you pass in a smaller buffer, it will use the bits
|
|
/// available as the low `n` bits of the number.
|
|
fn from_bytes(bytes: &[u8]) -> Self;
|
|
/// Write the cryptonum into the provide slice. If the provided slice
|
|
/// is greater than or equal to `n` bits in length, `to_bytes` will
|
|
/// write to the first `n` bits. If the slice is less than `n` bits
|
|
/// in length, `to_bytes` will write the lower-order bits that fit
|
|
/// into the provided slice.
|
|
fn to_bytes(&self, bytes: &mut [u8]);
|
|
}
|
|
|
|
/// An error in conversion of large numbers (either to primitives or to other numbers
|
|
#[derive(Debug)]
|
|
pub enum ConversionError {
|
|
NegativeToUnsigned,
|
|
Overflow
|
|
}
|
|
|
|
impl From<TryFromIntError> for ConversionError {
|
|
fn from(_: TryFromIntError) -> ConversionError {
|
|
ConversionError::Overflow
|
|
}
|
|
}
|