zec
/
librustzcash
mirror of https://github.com/zcash/librustzcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Consistently use `Debug` and `Display`.

This commit is contained in:
Sean Bowe 2017-07-17 12:20:01 -06:00
parent 1027dda432
commit 1d4710a39e
No known key found for this signature in database
GPG Key ID: 95684257D8F8B031
7 changed files with 78 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/bls12_381/ec.rs
View File

@ -1,5 +1,6 @@
macro_rules! curve_impl { macro_rules! curve_impl {
( (
$name:expr,
$projective:ident, $projective:ident,
$affine:ident, $affine:ident,
$prepared:ident, $prepared:ident,
@ -15,13 +16,31 @@ macro_rules! curve_impl {
pub(crate) infinity: bool pub(crate) infinity: bool
} }
#[derive(Copy, Clone, Debug, Eq)] impl ::std::fmt::Display for $affine
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
if self.infinity {
write!(f, "{}(Infinity)", $name)
} else {
write!(f, "{}(x={}, y={})", $name, self.x, self.y)
}
}
}
#[derive(Copy, Clone, Eq, Debug)]
pub struct $projective { pub struct $projective {
pub(crate) x: $basefield, pub(crate) x: $basefield,
pub(crate) y: $basefield, pub(crate) y: $basefield,
pub(crate) z: $basefield pub(crate) z: $basefield
} }
impl ::std::fmt::Display for $projective
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "{}", self.into_affine())
}
}
impl PartialEq for $projective { impl PartialEq for $projective {
fn eq(&self, other: &$projective) -> bool { fn eq(&self, other: &$projective) -> bool {
if self.is_zero() { if self.is_zero() {
@ -558,7 +577,7 @@ pub mod g1 {
use super::super::{Fq, Fr, FrRepr, FqRepr}; use super::super::{Fq, Fr, FrRepr, FqRepr};
use ::{CurveProjective, CurveAffine, PrimeField, SqrtField, PrimeFieldRepr, Field, BitIterator, EncodedPoint, GroupDecodingError}; use ::{CurveProjective, CurveAffine, PrimeField, SqrtField, PrimeFieldRepr, Field, BitIterator, EncodedPoint, GroupDecodingError};
curve_impl!(G1, G1Affine, G1Prepared, Fq, Fr, G1Uncompressed, G1Compressed); curve_impl!("E", G1, G1Affine, G1Prepared, Fq, Fr, G1Uncompressed, G1Compressed);
pub struct G1Uncompressed([u8; 96]); pub struct G1Uncompressed([u8; 96]);
@ -1114,7 +1133,7 @@ pub mod g2 {
use super::super::{Fq2, Fr, Fq, FrRepr, FqRepr}; use super::super::{Fq2, Fr, Fq, FrRepr, FqRepr};
use ::{CurveProjective, CurveAffine, PrimeField, SqrtField, PrimeFieldRepr, Field, BitIterator, EncodedPoint, GroupDecodingError}; use ::{CurveProjective, CurveAffine, PrimeField, SqrtField, PrimeFieldRepr, Field, BitIterator, EncodedPoint, GroupDecodingError};
curve_impl!(G2, G2Affine, G2Prepared, Fq2, Fr, G2Uncompressed, G2Compressed); curve_impl!("E'", G2, G2Affine, G2Prepared, Fq2, Fr, G2Uncompressed, G2Compressed);
pub struct G2Uncompressed([u8; 192]); pub struct G2Uncompressed([u8; 192]);

28
src/bls12_381/fq.rs
View File

@ -192,7 +192,7 @@ pub const FROBENIUS_COEFF_FQ12_C1: [Fq2; 12] = [
// -((2**384) mod q) mod q // -((2**384) mod q) mod q
pub const NEGATIVE_ONE: Fq = Fq(FqRepr([0x43f5fffffffcaaae, 0x32b7fff2ed47fffd, 0x7e83a49a2e99d69, 0xeca8f3318332bb7a, 0xef148d1ea0f4c069, 0x40ab3263eff0206])); pub const NEGATIVE_ONE: Fq = Fq(FqRepr([0x43f5fffffffcaaae, 0x32b7fff2ed47fffd, 0x7e83a49a2e99d69, 0xeca8f3318332bb7a, 0xef148d1ea0f4c069, 0x40ab3263eff0206]));
#[derive(Copy, Clone, PartialEq, Eq, Default)] #[derive(Copy, Clone, PartialEq, Eq, Default, Debug)]
pub struct FqRepr(pub [u64; 6]); pub struct FqRepr(pub [u64; 6]);
impl ::rand::Rand for FqRepr { impl ::rand::Rand for FqRepr {
@ -202,7 +202,7 @@ impl ::rand::Rand for FqRepr {
} }
} }
impl ::std::fmt::Debug for FqRepr impl ::std::fmt::Display for FqRepr
{ {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
try!(write!(f, "0x")); try!(write!(f, "0x"));
@ -355,7 +355,7 @@ impl PrimeFieldRepr for FqRepr {
} }
} }
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct Fq(FqRepr); pub struct Fq(FqRepr);
/// `Fq` elements are ordered lexicographically. /// `Fq` elements are ordered lexicographically.
@ -373,10 +373,10 @@ impl PartialOrd for Fq {
} }
} }
impl ::std::fmt::Debug for Fq impl ::std::fmt::Display for Fq
{ {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "Fq({:?})", self.into_repr()) write!(f, "Fq({})", self.into_repr())
} }
} }
@ -408,7 +408,7 @@ impl PrimeField for Fq {
Ok(r) Ok(r)
} else { } else {
Err(PrimeFieldDecodingError::NotInField(format!("{:?}", r.0))) Err(PrimeFieldDecodingError::NotInField(format!("{}", r.0)))
} }
} }
@ -1676,33 +1676,33 @@ fn bench_fq_from_repr(b: &mut ::test::Bencher) {
} }
#[test] #[test]
fn test_fq_repr_debug() { fn test_fq_repr_display() {
assert_eq!( assert_eq!(
format!("{:?}", FqRepr([0xa956babf9301ea24, 0x39a8f184f3535c7b, 0xb38d35b3f6779585, 0x676cc4eef4c46f2c, 0xb1d4aad87651e694, 0x1947f0d5f4fe325a])), format!("{}", FqRepr([0xa956babf9301ea24, 0x39a8f184f3535c7b, 0xb38d35b3f6779585, 0x676cc4eef4c46f2c, 0xb1d4aad87651e694, 0x1947f0d5f4fe325a])),
"0x1947f0d5f4fe325ab1d4aad87651e694676cc4eef4c46f2cb38d35b3f677958539a8f184f3535c7ba956babf9301ea24".to_string() "0x1947f0d5f4fe325ab1d4aad87651e694676cc4eef4c46f2cb38d35b3f677958539a8f184f3535c7ba956babf9301ea24".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", FqRepr([0xb4171485fd8622dd, 0x864229a6edec7ec5, 0xc57f7bdcf8dfb707, 0x6db7ff0ecea4584a, 0xf8d8578c4a57132d, 0x6eb66d42d9fcaaa])), format!("{}", FqRepr([0xb4171485fd8622dd, 0x864229a6edec7ec5, 0xc57f7bdcf8dfb707, 0x6db7ff0ecea4584a, 0xf8d8578c4a57132d, 0x6eb66d42d9fcaaa])),
"0x06eb66d42d9fcaaaf8d8578c4a57132d6db7ff0ecea4584ac57f7bdcf8dfb707864229a6edec7ec5b4171485fd8622dd".to_string() "0x06eb66d42d9fcaaaf8d8578c4a57132d6db7ff0ecea4584ac57f7bdcf8dfb707864229a6edec7ec5b4171485fd8622dd".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", FqRepr([0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff])), format!("{}", FqRepr([0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff])),
"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".to_string() "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", FqRepr([0, 0, 0, 0, 0, 0])), format!("{}", FqRepr([0, 0, 0, 0, 0, 0])),
"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".to_string() "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".to_string()
); );
} }
#[test] #[test]
fn test_fq_debug() { fn test_fq_display() {
assert_eq!( assert_eq!(
format!("{:?}", Fq::from_repr(FqRepr([0xa956babf9301ea24, 0x39a8f184f3535c7b, 0xb38d35b3f6779585, 0x676cc4eef4c46f2c, 0xb1d4aad87651e694, 0x1947f0d5f4fe325a])).unwrap()), format!("{}", Fq::from_repr(FqRepr([0xa956babf9301ea24, 0x39a8f184f3535c7b, 0xb38d35b3f6779585, 0x676cc4eef4c46f2c, 0xb1d4aad87651e694, 0x1947f0d5f4fe325a])).unwrap()),
"Fq(0x1947f0d5f4fe325ab1d4aad87651e694676cc4eef4c46f2cb38d35b3f677958539a8f184f3535c7ba956babf9301ea24)".to_string() "Fq(0x1947f0d5f4fe325ab1d4aad87651e694676cc4eef4c46f2cb38d35b3f677958539a8f184f3535c7ba956babf9301ea24)".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", Fq::from_repr(FqRepr([0xe28e79396ac2bbf8, 0x413f6f7f06ea87eb, 0xa4b62af4a792a689, 0xb7f89f88f59c1dc5, 0x9a551859b1e43a9a, 0x6c9f5a1060de974])).unwrap()), format!("{}", Fq::from_repr(FqRepr([0xe28e79396ac2bbf8, 0x413f6f7f06ea87eb, 0xa4b62af4a792a689, 0xb7f89f88f59c1dc5, 0x9a551859b1e43a9a, 0x6c9f5a1060de974])).unwrap()),
"Fq(0x06c9f5a1060de9749a551859b1e43a9ab7f89f88f59c1dc5a4b62af4a792a689413f6f7f06ea87ebe28e79396ac2bbf8)".to_string() "Fq(0x06c9f5a1060de9749a551859b1e43a9ab7f89f88f59c1dc5a4b62af4a792a689413f6f7f06ea87ebe28e79396ac2bbf8)".to_string()
); );
} }

9
src/bls12_381/fq12.rs
View File

@ -5,12 +5,19 @@ use super::fq2::Fq2;
use super::fq::{FROBENIUS_COEFF_FQ12_C1}; use super::fq::{FROBENIUS_COEFF_FQ12_C1};
/// An element of Fq12, represented by c0 + c1 * w. /// An element of Fq12, represented by c0 + c1 * w.
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct Fq12 { pub struct Fq12 {
pub c0: Fq6, pub c0: Fq6,
pub c1: Fq6 pub c1: Fq6
} }
impl ::std::fmt::Display for Fq12
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "Fq12({} + {} * w)", self.c0, self.c1)
}
}
impl Rand for Fq12 { impl Rand for Fq12 {
fn rand<R: Rng>(rng: &mut R) -> Self { fn rand<R: Rng>(rng: &mut R) -> Self {
Fq12 { Fq12 {

9
src/bls12_381/fq2.rs
View File

@ -5,12 +5,19 @@ use super::fq::{Fq, FROBENIUS_COEFF_FQ2_C1, NEGATIVE_ONE};
use std::cmp::Ordering; use std::cmp::Ordering;
/// An element of Fq2, represented by c0 + c1 * u. /// An element of Fq2, represented by c0 + c1 * u.
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct Fq2 { pub struct Fq2 {
pub c0: Fq, pub c0: Fq,
pub c1: Fq pub c1: Fq
} }
impl ::std::fmt::Display for Fq2
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "Fq2({} + {} * u)", self.c0, self.c1)
}
}
/// `Fq2` elements are ordered lexicographically. /// `Fq2` elements are ordered lexicographically.
impl Ord for Fq2 { impl Ord for Fq2 {
#[inline(always)] #[inline(always)]

9
src/bls12_381/fq6.rs
View File

@ -4,13 +4,20 @@ use super::fq2::Fq2;
use super::fq::{FROBENIUS_COEFF_FQ6_C1, FROBENIUS_COEFF_FQ6_C2}; use super::fq::{FROBENIUS_COEFF_FQ6_C1, FROBENIUS_COEFF_FQ6_C2};
/// An element of Fq6, represented by c0 + c1 * v + c2 * v^2. /// An element of Fq6, represented by c0 + c1 * v + c2 * v^2.
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct Fq6 { pub struct Fq6 {
pub c0: Fq2, pub c0: Fq2,
pub c1: Fq2, pub c1: Fq2,
pub c2: Fq2 pub c2: Fq2
} }
impl ::std::fmt::Display for Fq6
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "Fq6({} + {} * v, {} * v^2)", self.c0, self.c1, self.c2)
}
}
impl Rand for Fq6 { impl Rand for Fq6 {
fn rand<R: Rng>(rng: &mut R) -> Self { fn rand<R: Rng>(rng: &mut R) -> Self {
Fq6 { Fq6 {

28
src/bls12_381/fr.rs
View File

@ -28,7 +28,7 @@ const S: usize = 32;
// 2^s root of unity computed by GENERATOR^t // 2^s root of unity computed by GENERATOR^t
const ROOT_OF_UNITY: FrRepr = FrRepr([0xb9b58d8c5f0e466a, 0x5b1b4c801819d7ec, 0xaf53ae352a31e64, 0x5bf3adda19e9b27b]); const ROOT_OF_UNITY: FrRepr = FrRepr([0xb9b58d8c5f0e466a, 0x5b1b4c801819d7ec, 0xaf53ae352a31e64, 0x5bf3adda19e9b27b]);
#[derive(Copy, Clone, PartialEq, Eq, Default)] #[derive(Copy, Clone, PartialEq, Eq, Default, Debug)]
pub struct FrRepr(pub [u64; 4]); pub struct FrRepr(pub [u64; 4]);
impl ::rand::Rand for FrRepr { impl ::rand::Rand for FrRepr {
@ -38,7 +38,7 @@ impl ::rand::Rand for FrRepr {
} }
} }
impl ::std::fmt::Debug for FrRepr impl ::std::fmt::Display for FrRepr
{ {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
try!(write!(f, "0x")); try!(write!(f, "0x"));
@ -191,13 +191,13 @@ impl PrimeFieldRepr for FrRepr {
} }
} }
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct Fr(FrRepr); pub struct Fr(FrRepr);
impl ::std::fmt::Debug for Fr impl ::std::fmt::Display for Fr
{ {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "Fr({:?})", self.into_repr()) write!(f, "Fr({})", self.into_repr())
} }
} }
@ -229,7 +229,7 @@ impl PrimeField for Fr {
Ok(r) Ok(r)
} else { } else {
Err(PrimeFieldDecodingError::NotInField(format!("{:?}", r.0))) Err(PrimeFieldDecodingError::NotInField(format!("{}", r.0)))
} }
} }
@ -1388,33 +1388,33 @@ fn bench_fr_from_repr(b: &mut ::test::Bencher) {
} }
#[test] #[test]
fn test_fr_repr_debug() { fn test_fr_repr_display() {
assert_eq!( assert_eq!(
format!("{:?}", FrRepr([0x2829c242fa826143, 0x1f32cf4dd4330917, 0x932e4e479d168cd9, 0x513c77587f563f64])), format!("{}", FrRepr([0x2829c242fa826143, 0x1f32cf4dd4330917, 0x932e4e479d168cd9, 0x513c77587f563f64])),
"0x513c77587f563f64932e4e479d168cd91f32cf4dd43309172829c242fa826143".to_string() "0x513c77587f563f64932e4e479d168cd91f32cf4dd43309172829c242fa826143".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", FrRepr([0x25ebe3a3ad3c0c6a, 0x6990e39d092e817c, 0x941f900d42f5658e, 0x44f8a103b38a71e0])), format!("{}", FrRepr([0x25ebe3a3ad3c0c6a, 0x6990e39d092e817c, 0x941f900d42f5658e, 0x44f8a103b38a71e0])),
"0x44f8a103b38a71e0941f900d42f5658e6990e39d092e817c25ebe3a3ad3c0c6a".to_string() "0x44f8a103b38a71e0941f900d42f5658e6990e39d092e817c25ebe3a3ad3c0c6a".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", FrRepr([0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff])), format!("{}", FrRepr([0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff])),
"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".to_string() "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", FrRepr([0, 0, 0, 0])), format!("{}", FrRepr([0, 0, 0, 0])),
"0x0000000000000000000000000000000000000000000000000000000000000000".to_string() "0x0000000000000000000000000000000000000000000000000000000000000000".to_string()
); );
} }
#[test] #[test]
fn test_fr_debug() { fn test_fr_display() {
assert_eq!( assert_eq!(
format!("{:?}", Fr::from_repr(FrRepr([0xc3cae746a3b5ecc7, 0x185ec8eb3f5b5aee, 0x684499ffe4b9dd99, 0x7c9bba7afb68faa])).unwrap()), format!("{}", Fr::from_repr(FrRepr([0xc3cae746a3b5ecc7, 0x185ec8eb3f5b5aee, 0x684499ffe4b9dd99, 0x7c9bba7afb68faa])).unwrap()),
"Fr(0x07c9bba7afb68faa684499ffe4b9dd99185ec8eb3f5b5aeec3cae746a3b5ecc7)".to_string() "Fr(0x07c9bba7afb68faa684499ffe4b9dd99185ec8eb3f5b5aeec3cae746a3b5ecc7)".to_string()
); );
assert_eq!( assert_eq!(
format!("{:?}", Fr::from_repr(FrRepr([0x44c71298ff198106, 0xb0ad10817df79b6a, 0xd034a80a2b74132b, 0x41cf9a1336f50719])).unwrap()), format!("{}", Fr::from_repr(FrRepr([0x44c71298ff198106, 0xb0ad10817df79b6a, 0xd034a80a2b74132b, 0x41cf9a1336f50719])).unwrap()),
"Fr(0x41cf9a1336f50719d034a80a2b74132bb0ad10817df79b6a44c71298ff198106)".to_string() "Fr(0x41cf9a1336f50719d034a80a2b74132bb0ad10817df79b6a44c71298ff198106)".to_string()
); );
} }

4
src/lib.rs
View File

@ -92,6 +92,7 @@ pub trait CurveProjective: PartialEq +
Send + Send +
Sync + Sync +
fmt::Debug + fmt::Debug +
fmt::Display +
rand::Rand + rand::Rand +
'static 'static
{ {
@ -159,6 +160,7 @@ pub trait CurveAffine: Copy +
Send + Send +
Sync + Sync +
fmt::Debug + fmt::Debug +
fmt::Display +
PartialEq + PartialEq +
Eq + Eq +
'static 'static
@ -247,6 +249,7 @@ pub trait Field: Sized +
Send + Send +
Sync + Sync +
fmt::Debug + fmt::Debug +
fmt::Display +
'static + 'static +
rand::Rand rand::Rand
{ {
@ -327,6 +330,7 @@ pub trait PrimeFieldRepr: Sized +
Send + Send +
Sync + Sync +
fmt::Debug + fmt::Debug +
fmt::Display +
'static + 'static +
rand::Rand + rand::Rand +
AsRef<[u64]> + AsRef<[u64]> +