diff --git a/src/main/java/ua/net/uid/utils/helpers/NumberHelper.java b/src/main/java/ua/net/uid/utils/helpers/NumberHelper.java
index 8692093..93137f6 100644
--- a/src/main/java/ua/net/uid/utils/helpers/NumberHelper.java
+++ b/src/main/java/ua/net/uid/utils/helpers/NumberHelper.java
@@ -68,7 +68,7 @@
         return parse(source, new ParsePosition(0));
     }
     
-    public byte min(byte ... items) {
+    public static byte min(byte ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         byte first = items[0];
@@ -83,7 +83,7 @@
         return first;
     }
     
-    public byte max(byte ... items) {
+    public static byte max(byte ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         byte first = items[0];
@@ -98,7 +98,7 @@
         return first;
     }
     
-    public short min(short ... items) {
+    public static short min(short ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         short first = items[0];
@@ -113,7 +113,7 @@
         return first;
     }
         
-    public short max(short ... items) {
+    public static short max(short ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         short first = items[0];
@@ -128,7 +128,7 @@
         return first;
     }
 
-    public int min(int ... items) {
+    public static int min(int ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         int first = items[0];
@@ -143,7 +143,7 @@
         return first;
     }
 
-    public int max(int ... items) {
+    public static int max(int ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         int first = items[0];
@@ -158,7 +158,7 @@
         return first;
     }
 
-    public long min(long ... items) {
+    public static long min(long ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         long first = items[0];
@@ -173,7 +173,7 @@
         return first;
     }
 
-    public long max(long ... items) {
+    public static long max(long ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         long first = items[0];
@@ -188,7 +188,7 @@
         return first;
     }
     
-    public float min(float ... items) {
+    public static float min(float ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         float first = items[0];
@@ -203,7 +203,7 @@
         return first;
     }
 
-    public float max(float ... items) {
+    public static float max(float ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         final int length = items.length;
@@ -220,7 +220,7 @@
         return first;
     }
 
-    public double min(double ... items) {
+    public static double min(double ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         double first = items[0];
@@ -235,7 +235,7 @@
         return first;
     }
     
-    public double max(double ... items) {
+    public static double max(double ... items) {
         if (items == null || items.length == 0)
             throw new IllegalArgumentException("the arguments array must not be null or empty");
         final int length = items.length;
@@ -251,13 +251,36 @@
         }
         return first;
     }
+
+    @SafeVarargs
+    public static <T extends Number & Comparable<? super T>> T min(T ... items) {
+        if (items == null || items.length == 0)
+        throw new IllegalArgumentException("the arguments array must not be null or empty");
+            final int length = items.length;
+        T first = items[0];
+        for(int i = 1; i < length; ++i) {
+            final T other = items[i];
+            if (other != null && other.compareTo(first) < 0)
+                first = other;
+        }
+        return first;
+    }
     
-    /*
-    public Number min(Number ... items) {
+    @SafeVarargs
+    public static <T extends Number & Comparable<? super T>> T max(T ... items) {
+        if (items == null || items.length == 0)
+        throw new IllegalArgumentException("the arguments array must not be null or empty");
+            final int length = items.length;
+        T first = items[0];
+        for(int i = 1; i < length; ++i) {
+            final T other = items[i];
+            if (other != null && other.compareTo(first) > 0)
+                first = other;
+        }
+        return first;
     }
-    public Number max(Number ... items) {
-    }
-    */
+
+    
     ////////////////////////////////////////////////////////////////////////////
     private static Number nextZeroDigit(CharSequence source, ParsePosition position, int end, int length) {
         if (end < source.length()) {
diff --git a/src/test/java/ua/net/uid/utils/helpers/NumberHelperTest.java b/src/test/java/ua/net/uid/utils/helpers/NumberHelperTest.java
index d57c72a..219b3f6 100644
--- a/src/test/java/ua/net/uid/utils/helpers/NumberHelperTest.java
+++ b/src/test/java/ua/net/uid/utils/helpers/NumberHelperTest.java
@@ -5,6 +5,7 @@
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.text.ParsePosition;
 
@@ -240,4 +241,101 @@
         assertEquals(75, position.getErrorIndex());
     }
 
+    @Test
+    void testMinOfBytes() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((byte[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new byte[0]));
+        assertEquals((byte)-55, NumberHelper.min(new byte[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMaxOfBytes() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((byte[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new byte[0]));
+        assertEquals((byte)85, NumberHelper.max(new byte[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMinOfShorts() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((short[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new short[0]));
+        assertEquals((short)-55, NumberHelper.min(new short[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMaxOfShorts() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((short[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new short[0]));
+        assertEquals((short)85, NumberHelper.max(new short[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMinOfInts() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((int[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new int[0]));
+        assertEquals((int)-55, NumberHelper.min(new int[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMaxOfInts() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((int[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new int[0]));
+        assertEquals((int)85, NumberHelper.max(new int[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMinOfLongs() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((long[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new long[0]));
+        assertEquals((long)-55, NumberHelper.min(new long[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMaxOfLongs() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((long[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new long[0]));
+        assertEquals((long)85, NumberHelper.max(new long[] {1,85,-4,6,3,-55}) );
+    }
+
+    @Test
+    void testMinOfFloats() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((float[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new float[0]));
+        assertEquals(-55.1f, NumberHelper.min(new float[] {1.1f,85.2f,-4.3f,6.3f,3.2f,-55.1f}) );
+    }
+
+    @Test
+    void testMaxOfFloats() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((float[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new float[0]));
+        assertEquals(85.2f, NumberHelper.max(new float[] {1.1f,85.2f,-4.3f,6.3f,3.2f,-55.1f}) );
+    }
+
+    @Test
+    void testMinOfDoubles() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((double[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new double[0]));
+        assertEquals(-55.1, NumberHelper.min(new double[] {1.1,85.2,-4.3,6.3,3.2,-55.1}) );
+    }
+
+    @Test
+    void testMaxOfDoubles() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((double[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new double[0]));
+        assertEquals(85.2, NumberHelper.max(new double[] {1.1,85.2,-4.3,6.3,3.2,-55.1}) );
+    }
+
+    @Test
+    void testMinOfNumbers() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min((Double[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.min(new Double[0]));
+        assertEquals(-55.1, NumberHelper.min(new Double[] {1.1,85.2,-4.3,6.3,3.2,-55.1}) );
+    }
+
+    @Test
+    void testMaxOfNumbers() {
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max((Double[])null));
+        assertThrows(IllegalArgumentException.class, () -> NumberHelper.max(new Double[0]));
+        assertEquals(85.2, NumberHelper.max(new Double[] {1.1,85.2,-4.3,6.3,3.2,-55.1}) );
+    }
 }