xeos
/
num-traits
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implemented from_bytes and to_bytes

This commit is contained in:
Gulshan Singh 2015-01-20 20:38:51 -05:00
parent c05cd530db
commit 7ba31bc3a7
1 changed files with 247 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

252
src/bigint.rs
View File

@ -56,20 +56,22 @@
//! println!("{}", a * b);
//! ```
extern crate "rustc-serialize" as rustc_serialize;
use Integer;
use std::default::Default;
use std::iter::repeat;
use std::num::FromStrRadix;
use std::num::{Int, ToPrimitive, FromPrimitive};
use std::num::{Int, ToPrimitive, FromPrimitive, FromStrRadix};
use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub};
use std::rand::Rng;
use std::str::{self, FromStr};
use std::{cmp, fmt, hash};
use std::cmp::Ordering;
use std::cmp::Ordering::{Less, Greater, Equal};
use std::{cmp, fmt, hash, mem};
use std::cmp::Ordering::{self, Less, Greater, Equal};
use std::{i64, u64};
use rustc_serialize::hex::ToHex;
use {Num, Unsigned, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, Signed, Zero, One};
use self::Sign::{Minus, NoSign, Plus};
@ -872,6 +874,75 @@ impl BigUint {
BigUint::new(slice.to_vec())
}
/// Creates and initializes a `BigUint`.
///
/// The bytes are in big-endian byte order.
///
/// # Examples
///
/// ```
/// use num::bigint::BigUint;
///
/// assert_eq!(BigUint::from_bytes_be("A".as_bytes()),
/// BigUint::parse_bytes("65".as_bytes(), 10).unwrap());
/// assert_eq!(BigUint::from_bytes_be("AA".as_bytes()),
/// BigUint::parse_bytes("16705".as_bytes(), 10).unwrap());
/// assert_eq!(BigUint::from_bytes_be("AB".as_bytes()),
/// BigUint::parse_bytes("16706".as_bytes(), 10).unwrap());
/// assert_eq!(BigUint::from_bytes_be("Hello world!".as_bytes()),
/// BigUint::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap());
/// ```
#[inline]
pub fn from_bytes_be(bytes: &[u8]) -> BigUint {
if bytes.is_empty() {
Zero::zero()
} else {
BigUint::parse_bytes(bytes.to_hex().as_bytes(), 16).unwrap()
}
}
/// Creates and initializes a `BigUint`.
///
/// The bytes are in little-endian byte order.
#[inline]
pub fn from_bytes_le(bytes: &[u8]) -> BigUint {
let mut v = bytes.to_vec();
v.reverse();
BigUint::from_bytes_be(&*v)
}
/// Returns the byte representation of the `BigUint` in little-endian byte order.
#[inline]
pub fn to_bytes_le(&self) -> Vec<u8> {
let mut result = Vec::new();
for word in self.data.iter() {
let mut w = *word;
for _ in 0..mem::size_of::<BigDigit>() {
let b = (w & 0xFF) as u8;
w = w >> 8;
result.push(b);
}
}
if let Some(index) = result.iter().rposition(|x| *x != 0) {
result.truncate(index + 1);
}
if result.is_empty() {
vec![0]
} else {
result
}
}
/// Returns the byte representation of the `BigUint` in big-endian byte order.
#[inline]
pub fn to_bytes_be(&self) -> Vec<u8> {
let mut v = self.to_bytes_le();
v.reverse();
v
}
/// Creates and initializes a `BigUint`.
///
/// # Examples
@ -1576,6 +1647,49 @@ impl BigInt {
BigInt::from_biguint(sign, BigUint::from_slice(slice))
}
/// Creates and initializes a `BigInt`.
///
/// The bytes are in big-endian byte order.
///
/// # Examples
///
/// ```
/// use num::bigint::{BigInt, Sign};
///
/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, "A".as_bytes()),
/// BigInt::parse_bytes("65".as_bytes(), 10).unwrap());
/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, "AA".as_bytes()),
/// BigInt::parse_bytes("16705".as_bytes(), 10).unwrap());
/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, "AB".as_bytes()),
/// BigInt::parse_bytes("16706".as_bytes(), 10).unwrap());
/// assert_eq!(BigInt::from_bytes_be(Sign::Plus, "Hello world!".as_bytes()),
/// BigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap());
/// ```
#[inline]
pub fn from_bytes_be(sign: Sign, bytes: &[u8]) -> BigInt {
BigInt::from_biguint(sign, BigUint::from_bytes_be(bytes))
}
/// Creates and initializes a `BigInt`.
///
/// The bytes are in little-endian byte order.
#[inline]
pub fn from_bytes_le(sign: Sign, bytes: &[u8]) -> BigInt {
BigInt::from_biguint(sign, BigUint::from_bytes_le(bytes))
}
/// Returns the sign and the byte representation of the `BigInt` in little-endian byte order.
#[inline]
pub fn to_bytes_le(&self) -> (Sign, Vec<u8>) {
(self.sign, self.data.to_bytes_le())
}
/// Returns the sign and the byte representation of the `BigInt` in big-endian byte order.
#[inline]
pub fn to_bytes_be(&self) -> (Sign, Vec<u8>) {
(self.sign, self.data.to_bytes_be())
}
/// Creates and initializes a `BigInt`.
///
/// # Examples
@ -1658,6 +1772,68 @@ mod biguint_tests {
check(&[-1], &[-1]);
}
#[test]
fn test_from_bytes_be() {
fn check(s: &str, result: &str) {
assert_eq!(BigUint::from_bytes_be(s.as_bytes()),
BigUint::parse_bytes(result.as_bytes(), 10).unwrap());
}
check("A", "65");
check("AA", "16705");
check("AB", "16706");
check("Hello world!", "22405534230753963835153736737");
assert_eq!(BigUint::from_bytes_be(&[]), Zero::zero());
}
#[test]
fn test_to_bytes_be() {
fn check(s: &str, result: &str) {
let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
assert_eq!(s.as_bytes(), b.to_bytes_be());
}
check("A", "65");
check("AA", "16705");
check("AB", "16706");
check("Hello world!", "22405534230753963835153736737");
let b: BigUint = Zero::zero();
assert_eq!(b.to_bytes_be(), [0]);
// Test with leading/trailing zero bytes and a full BigDigit of value 0
let b: BigUint = FromStrRadix::from_str_radix("00010000000000000200", 16).unwrap();
assert_eq!(b.to_bytes_be(), [1, 0, 0, 0, 0, 0, 0, 2, 0]);
}
#[test]
fn test_from_bytes_le() {
fn check(s: &str, result: &str) {
assert_eq!(BigUint::from_bytes_le(s.as_bytes()),
BigUint::parse_bytes(result.as_bytes(), 10).unwrap());
}
check("A", "65");
check("AA", "16705");
check("BA", "16706");
check("!dlrow olleH", "22405534230753963835153736737");
assert_eq!(BigUint::from_bytes_le(&[]), Zero::zero());
}
#[test]
fn test_to_bytes_le() {
fn check(s: &str, result: &str) {
let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
assert_eq!(s.as_bytes(), b.to_bytes_le());
}
check("A", "65");
check("AA", "16705");
check("BA", "16706");
check("!dlrow olleH", "22405534230753963835153736737");
let b: BigUint = Zero::zero();
assert_eq!(b.to_bytes_le(), [0]);
// Test with leading/trailing zero bytes and a full BigDigit of value 0
let b: BigUint = FromStrRadix::from_str_radix("00010000000000000200", 16).unwrap();
assert_eq!(b.to_bytes_le(), [0, 2, 0, 0, 0, 0, 0, 0, 1]);
}
#[test]
fn test_cmp() {
let data: [&[_]; 7] = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ];
@ -2524,6 +2700,72 @@ mod bigint_tests {
check(NoSign, 1, NoSign, 0);
}
#[test]
fn test_from_bytes_be() {
fn check(s: &str, result: &str) {
assert_eq!(BigInt::from_bytes_be(Plus, s.as_bytes()),
BigInt::parse_bytes(result.as_bytes(), 10).unwrap());
}
check("A", "65");
check("AA", "16705");
check("AB", "16706");
check("Hello world!", "22405534230753963835153736737");
assert_eq!(BigInt::from_bytes_be(Plus, &[]), Zero::zero());
assert_eq!(BigInt::from_bytes_be(Minus, &[]), Zero::zero());
}
#[test]
fn test_to_bytes_be() {
fn check(s: &str, result: &str) {
let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
let (sign, v) = b.to_bytes_be();
assert_eq!((Plus, s.as_bytes()), (sign, &*v));
}
check("A", "65");
check("AA", "16705");
check("AB", "16706");
check("Hello world!", "22405534230753963835153736737");
let b: BigInt = Zero::zero();
assert_eq!(b.to_bytes_be(), (NoSign, vec![0]));
// Test with leading/trailing zero bytes and a full BigDigit of value 0
let b: BigInt = FromStrRadix::from_str_radix("00010000000000000200", 16).unwrap();
assert_eq!(b.to_bytes_be(), (Plus, vec![1, 0, 0, 0, 0, 0, 0, 2, 0]));
}
#[test]
fn test_from_bytes_le() {
fn check(s: &str, result: &str) {
assert_eq!(BigInt::from_bytes_le(Plus, s.as_bytes()),
BigInt::parse_bytes(result.as_bytes(), 10).unwrap());
}
check("A", "65");
check("AA", "16705");
check("BA", "16706");
check("!dlrow olleH", "22405534230753963835153736737");
assert_eq!(BigInt::from_bytes_le(Plus, &[]), Zero::zero());
assert_eq!(BigInt::from_bytes_le(Minus, &[]), Zero::zero());
}
#[test]
fn test_to_bytes_le() {
fn check(s: &str, result: &str) {
let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
let (sign, v) = b.to_bytes_le();
assert_eq!((Plus, s.as_bytes()), (sign, &*v));
}
check("A", "65");
check("AA", "16705");
check("BA", "16706");
check("!dlrow olleH", "22405534230753963835153736737");
let b: BigInt = Zero::zero();
assert_eq!(b.to_bytes_le(), (NoSign, vec![0]));
// Test with leading/trailing zero bytes and a full BigDigit of value 0
let b: BigInt = FromStrRadix::from_str_radix("00010000000000000200", 16).unwrap();
assert_eq!(b.to_bytes_le(), (Plus, vec![0, 2, 0, 0, 0, 0, 0, 0, 1]));
}
#[test]
fn test_cmp() {
let vs: [&[BigDigit]; 4] = [ &[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1] ];