Add U.subtract(values) method.

Author: Szkocsovszki

src/main/java/com/github/underscore/lodash/U.java

@@ -1111,6 +1111,36 @@ private static Short sum(Short first, Short second) {
         return (short) (first + second);
     }
 
+    @SuppressWarnings("unchecked")
+    public static <T extends Number> T subtract(final T ... values) {
+        if (values.length == 0) {
+            return null;
+        }
+        T result = values[0];
+        for (int i = 1; i < values.length; i++) {
+            if (result instanceof java.math.BigDecimal) {
+                java.math.BigDecimal value = (java.math.BigDecimal) values[i];
+                result = add(result, (T) value.negate());
+            } else if (result instanceof java.math.BigInteger) {
+                java.math.BigInteger value = (java.math.BigInteger) values[i];
+                result = add(result, (T) value.negate());
+            } else if (result instanceof Byte) {
+                result = add(result, (T) Byte.valueOf((byte) (values[i].byteValue() * -1)));
+            } else if (result instanceof Double) {
+                result = add(result, (T) Double.valueOf(values[i].doubleValue() * -1));
+            } else if (result instanceof Float) {
+                result = add(result, (T) Float.valueOf(values[i].floatValue() * -1));
+            } else if (result instanceof Integer) {
+                result = add(result, (T) Integer.valueOf(values[i].intValue() * -1));
+            } else if (result instanceof Long) {
+                result = add(result, (T) Long.valueOf(values[i].longValue() * -1));
+            } else if (result instanceof Short) {
+                result = add(result, (T) Short.valueOf((short) (values[i].shortValue() * -1)));
+            }
+        }
+        return result;
+    }
+
     public static <T extends Number> double mean(final Iterable<T> iterable) {
         T result = null;
         int count = 0;

src/test/java/com/github/underscore/lodash/MathTest.java

@@ -246,6 +246,55 @@ public double doubleValue() {
         U.sum(asList(new MyNumber(), new MyNumber()));
     }
 
+/*
+_.subtract(1, 2);
+=> -1
+_.subtract(1, 2, 3);
+=> -4
+_.subtract();
+=> null
+*/
+    @Test
+    public void subtract() {
+        assertEquals("-1", U.subtract((byte) 1, (byte) 2).toString());
+        assertEquals("-1", U.subtract((short) 1, (short) 2).toString());
+        assertEquals("-1", U.subtract((int) 1, (int) 2).toString());
+        assertEquals("-1", U.subtract((long) 1, (long) 2).toString());
+        assertEquals("-1.0", U.subtract((float) 1, (float) 2).toString());
+        assertEquals("-1.0", U.subtract((double) 1, (double) 2).toString());
+        assertEquals("-1", U.subtract(Byte.valueOf((byte) 1), Byte.valueOf((byte) 2)).toString());
+        assertEquals("-1", U.subtract(Short.valueOf((short) 1), Short.valueOf((short) 2)).toString());
+        assertEquals("-1", U.subtract(Integer.valueOf(1), Integer.valueOf(2)).toString());
+        assertEquals("-1", U.subtract(Long.valueOf(1), Long.valueOf(2)).toString());
+        assertEquals("-1.0", U.subtract(Float.valueOf(1), Float.valueOf(2)).toString());
+        assertEquals("-1.0", U.subtract(Double.valueOf(1), Double.valueOf(2)).toString());
+        assertEquals("-1", U.subtract(java.math.BigDecimal.valueOf(1), java.math.BigDecimal.valueOf(2)).toString());
+        assertEquals("-1", U.subtract(java.math.BigInteger.valueOf(1), java.math.BigInteger.valueOf(2)).toString());
+        assertEquals("-1", U.subtract((Number) 1, (Number) 2).toString());
+        assertEquals("-4", U.subtract((int) 1, (int) 2, (int) 3).toString());
+        assertEquals("1", U.subtract((int) 1).toString());
+        assertEquals(null, U.subtract());
+    }
+
+    @Test
+    public void subtractError() {
+        class MyNumber extends Number {
+            public int intValue() {
+                return 0;
+            }
+            public long longValue() {
+                return 0;
+            }
+            public float floatValue() {
+                return 0;
+            }
+            public double doubleValue() {
+                return 0;
+            }
+        }
+        U.subtract(new MyNumber(), new MyNumber());
+    }
+
 /*
 _.mean([0, 0.5, 1]);
 => 0.5