This is an automated email from the ASF dual-hosted git repository.
toulmean pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-tuweni.git
The following commit(s) were added to refs/heads/master by this push:
new 1487d61 Fixes to bytes, unsigned ints. Added convenience methods
(plus, mod0, divideCeil) for uints
1487d61 is described below
commit 1487d6112bef0eea9cfa1c18afddbe1aae0f4489
Author: Antoine Toulme <[email protected]>
AuthorDate: Sat Nov 30 00:43:23 2019 -0800
Fixes to bytes, unsigned ints. Added convenience methods (plus, mod0,
divideCeil) for uints
---
.../main/java/org/apache/tuweni/bytes/Bytes32.java | 3 --
.../tuweni/units/bigints/BaseUInt256Value.java | 31 ++++++++++++
.../org/apache/tuweni/units/bigints/UInt256.java | 35 +++++++++++++
.../apache/tuweni/units/bigints/UInt256Value.java | 58 ++++++++++++++++++++++
.../tuweni/units/bigints/BaseUInt256ValueTest.java | 24 +++++++++
.../apache/tuweni/units/bigints/UInt256Test.java | 56 +++++++++++++++++++++
6 files changed, 204 insertions(+), 3 deletions(-)
diff --git a/bytes/src/main/java/org/apache/tuweni/bytes/Bytes32.java
b/bytes/src/main/java/org/apache/tuweni/bytes/Bytes32.java
index c0cc80b..7d63fd7 100644
--- a/bytes/src/main/java/org/apache/tuweni/bytes/Bytes32.java
+++ b/bytes/src/main/java/org/apache/tuweni/bytes/Bytes32.java
@@ -104,9 +104,6 @@ public interface Bytes32 extends Bytes {
*/
static Bytes32 wrap(Bytes value, int offset) {
checkNotNull(value);
- if (value instanceof Bytes32) {
- return (Bytes32) value;
- }
Bytes slice = value.slice(offset, Bytes32.SIZE);
if (slice instanceof Bytes32) {
return (Bytes32) slice;
diff --git
a/units/src/main/java/org/apache/tuweni/units/bigints/BaseUInt256Value.java
b/units/src/main/java/org/apache/tuweni/units/bigints/BaseUInt256Value.java
index 208db08..490434d 100644
--- a/units/src/main/java/org/apache/tuweni/units/bigints/BaseUInt256Value.java
+++ b/units/src/main/java/org/apache/tuweni/units/bigints/BaseUInt256Value.java
@@ -261,6 +261,27 @@ public abstract class BaseUInt256Value<T extends
UInt256Value<T>> implements UIn
}
@Override
+ public T divideCeil(T value) {
+ return divideCeil(value.toUInt256());
+ }
+
+ /**
+ * Returns a value that is {@code (this / value)}.
+ *
+ * @param value The amount to divide this value by.
+ * @return {@code this / value}
+ * @throws ArithmeticException {@code value} == 0.
+ */
+ public T divideCeil(UInt256 value) {
+ return ctor.apply(this.value.divideCeil(value));
+ }
+
+ @Override
+ public T divideCeil(long value) {
+ return ctor.apply(this.value.divideCeil(value));
+ }
+
+ @Override
public T pow(UInt256 exponent) {
return ctor.apply(this.value.pow(exponent));
}
@@ -281,6 +302,16 @@ public abstract class BaseUInt256Value<T extends
UInt256Value<T>> implements UIn
}
@Override
+ public T mod0(UInt256 modulus) {
+ return ctor.apply(this.value.mod0(modulus));
+ }
+
+ @Override
+ public T mod0(long modulus) {
+ return ctor.apply(this.value.mod0(modulus));
+ }
+
+ @Override
public int compareTo(T other) {
return compareTo(other.toUInt256());
}
diff --git a/units/src/main/java/org/apache/tuweni/units/bigints/UInt256.java
b/units/src/main/java/org/apache/tuweni/units/bigints/UInt256.java
index 57799a1..eb0899f 100644
--- a/units/src/main/java/org/apache/tuweni/units/bigints/UInt256.java
+++ b/units/src/main/java/org/apache/tuweni/units/bigints/UInt256.java
@@ -266,6 +266,9 @@ public final class UInt256 implements UInt256Value<UInt256>
{
if (value.equals(UInt256.ONE)) {
return this;
}
+ if (this.equals(UInt256.ONE)) {
+ return value;
+ }
return multiply(this.ints, value.ints);
}
@@ -313,6 +316,9 @@ public final class UInt256 implements UInt256Value<UInt256>
{
throw new ArithmeticException("multiply unsigned by negative");
}
UInt256 other = new UInt256(value);
+ if (this.equals(UInt256.ONE)) {
+ return other;
+ }
return multiply(this.ints, other.ints);
}
@@ -396,6 +402,16 @@ public final class UInt256 implements
UInt256Value<UInt256> {
}
@Override
+ public UInt256 divideCeil(UInt256 value) {
+ return this.divide(value).add(this.mod(value).isZero() ? 0 : 1);
+ }
+
+ @Override
+ public UInt256 divideCeil(long value) {
+ return this.divide(value).add(this.mod(value).isZero() ? 0 : 1);
+ }
+
+ @Override
public UInt256 pow(UInt256 exponent) {
return UInt256.valueOf(toBigInteger().modPow(exponent.toBigInteger(),
P_2_256));
}
@@ -438,6 +454,25 @@ public final class UInt256 implements
UInt256Value<UInt256> {
return UInt256.valueOf(toBigInteger().mod(BigInteger.valueOf(modulus)));
}
+ @Override
+ public UInt256 mod0(UInt256 modulus) {
+ if (modulus.equals(UInt256.ZERO)) {
+ return UInt256.ZERO;
+ }
+ return mod(modulus);
+ }
+
+ @Override
+ public UInt256 mod0(long modulus) {
+ if (modulus == 0) {
+ return UInt256.ZERO;
+ }
+ if (modulus < 0) {
+ throw new ArithmeticException("mod by negative");
+ }
+ return mod(modulus);
+ }
+
/**
* Return a bit-wise AND of this value and the supplied value.
*
diff --git
a/units/src/main/java/org/apache/tuweni/units/bigints/UInt256Value.java
b/units/src/main/java/org/apache/tuweni/units/bigints/UInt256Value.java
index af993cc..6f15d15 100644
--- a/units/src/main/java/org/apache/tuweni/units/bigints/UInt256Value.java
+++ b/units/src/main/java/org/apache/tuweni/units/bigints/UInt256Value.java
@@ -59,6 +59,30 @@ public interface UInt256Value<T extends UInt256Value<T>>
extends Comparable<T> {
/**
* Returns a value that is {@code (this + value)}.
*
+ * <p>This notation can be used in Kotlin with the {@code +} operator.
+ *
+ * @param value The amount to be added to this value.
+ * @return {@code this + value}
+ */
+ default T plus(T value) {
+ return add(value);
+ }
+
+ /**
+ * Returns a value that is {@code (this + value)}.
+ *
+ * <p>This notation can be used in Kotlin with the {@code +} operator.
+ *
+ * @param value The amount to be added to this value.
+ * @return {@code this + value}
+ */
+ default T plus(long value) {
+ return add(value);
+ }
+
+ /**
+ * Returns a value that is {@code (this + value)}.
+ *
* @param value the amount to be added to this value
* @return {@code this + value}
* @throws ArithmeticException if the result of the addition overflows
@@ -236,6 +260,24 @@ public interface UInt256Value<T extends UInt256Value<T>>
extends Comparable<T> {
T divide(long value);
/**
+ * Returns a value that is {@code ceiling(this / value)}.
+ *
+ * @param value The amount to divide this value by.
+ * @return {@code this / value + ( this % value == 0 ? 0 : 1)}
+ * @throws ArithmeticException {@code value} == 0.
+ */
+ T divideCeil(T value);
+
+ /**
+ * Returns a value that is {@code ceiling(this / value)}.
+ *
+ * @param value The amount to divide this value by.
+ * @return {@code this / value + ( this % value == 0 ? 0 : 1)}
+ * @throws ArithmeticException {@code value} == 0.
+ */
+ T divideCeil(long value);
+
+ /**
* Returns a value that is {@code (this<sup>exponent</sup> mod
2<sup>256</sup>)}
*
* <p>
@@ -279,6 +321,22 @@ public interface UInt256Value<T extends UInt256Value<T>>
extends Comparable<T> {
T mod(long modulus);
/**
+ * Returns a value that is {@code (this mod modulus)}, or 0 if modulus is 0.
+ *
+ * @param modulus The modulus.
+ * @return {@code this mod modulus}.
+ */
+ T mod0(UInt256 modulus);
+
+ /**
+ * Returns a value that is {@code (this mod modulus)}, or 0 if modulus is 0.
+ *
+ * @param modulus The modulus.
+ * @return {@code this mod modulus}.
+ */
+ T mod0(long modulus);
+
+ /**
* @return True if this value fits a java {@code int} (i.e. is less or equal
to {@code Integer.MAX_VALUE}).
*/
default boolean fitsInt() {
diff --git
a/units/src/test/java/org/apache/tuweni/units/bigints/BaseUInt256ValueTest.java
b/units/src/test/java/org/apache/tuweni/units/bigints/BaseUInt256ValueTest.java
index b00c464..bec3bb9 100644
---
a/units/src/test/java/org/apache/tuweni/units/bigints/BaseUInt256ValueTest.java
+++
b/units/src/test/java/org/apache/tuweni/units/bigints/BaseUInt256ValueTest.java
@@ -306,6 +306,12 @@ class BaseUInt256ValueTest {
private static Stream<Arguments> multiplyProvider() {
return Stream.of(
+ Arguments.of(v(0), v(1), v(0)),
+ Arguments.of(v(1), v(0), v(0)),
+ Arguments.of(v(1), v(20), v(20)),
+ Arguments.of(v(20), v(1), v(20)),
+ Arguments.of(hv("0x0a0000000000"), v(1), hv("0x0a0000000000")),
+ Arguments.of(v(1), hv("0x0a0000000000"), hv("0x0a0000000000")),
Arguments.of(v(0), v(2), v(0)),
Arguments.of(v(1), v(2), v(2)),
Arguments.of(v(2), v(2), v(4)),
@@ -332,6 +338,13 @@ class BaseUInt256ValueTest {
private static Stream<Arguments> multiplyUInt256Provider() {
return Stream.of(
+ Arguments.of(v(0), UInt256.valueOf(1), v(0)),
+ Arguments.of(v(1), UInt256.valueOf(0), v(0)),
+ Arguments.of(v(1), UInt256.valueOf(20), v(20)),
+ Arguments.of(v(20), UInt256.valueOf(1), v(20)),
+
+ Arguments.of(hv("0x0a0000000000"), UInt256.valueOf(1),
hv("0x0a0000000000")),
+ Arguments.of(v(1), UInt256.fromHexString("0x0a0000000000"),
hv("0x0a0000000000")),
Arguments.of(v(0), UInt256.valueOf(2), v(0)),
Arguments.of(v(1), UInt256.valueOf(2), v(2)),
Arguments.of(v(2), UInt256.valueOf(2), v(4)),
@@ -370,6 +383,12 @@ class BaseUInt256ValueTest {
private static Stream<Arguments> multiplyLongProvider() {
return Stream.of(
+ Arguments.of(v(0), 1L, v(0)),
+ Arguments.of(v(1), 0L, v(0)),
+ Arguments.of(v(1), 20L, v(20)),
+ Arguments.of(v(20), 1L, v(20)),
+ Arguments.of(hv("0x0a0000000000"), 1L, hv("0x0a0000000000")),
+ Arguments.of(v(1), 10995116277760L, hv("0x0a0000000000")),
Arguments.of(v(0), 2L, v(0)),
Arguments.of(v(1), 2L, v(2)),
Arguments.of(v(2), 2L, v(4)),
@@ -735,6 +754,11 @@ class BaseUInt256ValueTest {
}
@Test
+ void shouldReturnZeroForMod0LongByZero() {
+ assertEquals(UInt256.ZERO, v(5).mod0(0).toUInt256());
+ }
+
+ @Test
void shouldThrowForModLongByNegative() {
Throwable exception = assertThrows(ArithmeticException.class, () ->
v(5).mod(-5));
assertEquals("mod by negative", exception.getMessage());
diff --git
a/units/src/test/java/org/apache/tuweni/units/bigints/UInt256Test.java
b/units/src/test/java/org/apache/tuweni/units/bigints/UInt256Test.java
index 36eb1d1..80a334b 100644
--- a/units/src/test/java/org/apache/tuweni/units/bigints/UInt256Test.java
+++ b/units/src/test/java/org/apache/tuweni/units/bigints/UInt256Test.java
@@ -248,6 +248,11 @@ class UInt256Test {
private static Stream<Arguments> multiplyProvider() {
return Stream.of(
+ Arguments.of(v(0), v(1), v(0)),
+ Arguments.of(v(1), v(0), v(0)),
+ Arguments.of(v(1), v(20), v(20)),
+ Arguments.of(hv("0x0a0000000000"), v(1), hv("0x0a0000000000")),
+ Arguments.of(v(1), hv("0x0a0000000000"), hv("0x0a0000000000")),
Arguments.of(v(0), v(2), v(0)),
Arguments.of(v(1), v(2), v(2)),
Arguments.of(v(2), v(2), v(4)),
@@ -274,6 +279,12 @@ class UInt256Test {
private static Stream<Arguments> multiplyLongProvider() {
return Stream.of(
+ Arguments.of(v(0), 1L, v(0)),
+ Arguments.of(v(1), 0L, v(0)),
+ Arguments.of(v(1), 20L, v(20)),
+ Arguments.of(v(20), 1L, v(20)),
+ Arguments.of(hv("0x0a0000000000"), v(1), hv("0x0a0000000000")),
+ Arguments.of(v(1), hv("0x0a0000000000"), hv("0x0a0000000000")),
Arguments.of(v(0), 2L, v(0)),
Arguments.of(v(1), 2L, v(2)),
Arguments.of(v(2), 2L, v(4)),
@@ -434,6 +445,40 @@ class UInt256Test {
}
@ParameterizedTest
+ @MethodSource("divideCeilProvider")
+ void divideCeil(UInt256 v1, UInt256 v2, UInt256 expected) {
+ assertValueEquals(expected, v1.divideCeil(v2));
+ }
+
+ private static Stream<Arguments> divideCeilProvider() {
+ return Stream.of(
+ Arguments.of(v(0), v(2), v(0)),
+ Arguments.of(v(1), v(2), v(1)),
+ Arguments.of(v(2), v(2), v(1)),
+ Arguments.of(v(3), v(2), v(2)),
+ Arguments.of(v(4), v(2), v(2)),
+ Arguments.of(biv("13492324908428420834234908341"), v(2),
biv("6746162454214210417117454171")),
+ Arguments.of(biv("13492324908428420834234908342"), v(2),
biv("6746162454214210417117454171")),
+ Arguments.of(biv("13492324908428420834234908343"), v(2),
biv("6746162454214210417117454172")),
+ Arguments.of(v(2), v(8), v(1)),
+ Arguments.of(v(7), v(8), v(1)),
+ Arguments.of(v(8), v(8), v(1)),
+ Arguments.of(v(9), v(8), v(2)),
+ Arguments.of(v(17), v(8), v(3)),
+ Arguments.of(v(1024), v(8), v(128)),
+ Arguments.of(v(1026), v(8), v(129)),
+ Arguments.of(biv("13492324908428420834234908342"), v(8),
biv("1686540613553552604279363543")),
+ Arguments.of(biv("13492324908428420834234908342"), v(2048),
biv("6588049271693564860466264")),
+ Arguments.of(biv("13492324908428420834234908342"), v(131072),
biv("102938269870211950944786")));
+ }
+
+ @Test
+ void shouldThrowForDivideCeilByZero() {
+ Throwable exception = assertThrows(ArithmeticException.class, () ->
v(5).divideCeil(v(0)));
+ assertEquals("divide by zero", exception.getMessage());
+ }
+
+ @ParameterizedTest
@MethodSource("divideLongProvider")
void divideLong(UInt256 v1, long v2, UInt256 expected) {
assertValueEquals(expected, v1.divide(v2));
@@ -550,6 +595,17 @@ class UInt256Test {
assertEquals("mod by negative", exception.getMessage());
}
+ @Test
+ void shouldReturnZeroForMod0LongByZero() {
+ assertEquals(UInt256.ZERO, v(5).mod0(0));
+ }
+
+ @Test
+ void shouldThrowForMod0LongByNegative() {
+ Throwable exception = assertThrows(ArithmeticException.class, () ->
v(5).mod0(-5));
+ assertEquals("mod by negative", exception.getMessage());
+ }
+
@ParameterizedTest
@MethodSource("andProvider")
void and(UInt256 v1, UInt256 v2, UInt256 expected) {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
