fix exception in Bits

Author: 15045120

build.gradle

@@ -26,7 +26,7 @@ tasks.withType(JavaCompile) { options.encoding = "UTF-8" }
 
 group = 'com.github.myibu'
 archivesBaseName = "algorithm-java"
-version = "1.0.3"
+version = "1.0.4"
 
 repositories {
     mavenCentral()

readme.md

@@ -57,7 +57,7 @@ Reference to: [HoffmanAndGolombCoding.pdf](./docs/HoffmanAndGolombCoding.pdf)
 <dependency>
   <groupId>com.github.myibu</groupId>
   <artifactId>algorithm-java</artifactId>
-  <version>1.0.3</version>
+  <version>1.0.4</version>
 </dependency>
 ```
 

src/main/java/com/github/myibu/algorithm/data/Bits.java

@@ -751,21 +751,23 @@ public static double decodeDecimalValue(Bits value) {
 
         public static float decodeFloatValue(Bits value) {
             if (value.length() != 32) throw new IllegalArgumentException("float value must be 32 bits");
+            if (Bits.ofString("00000000000000000000000000000000").equals(value)) return 0.0f;
             Bits bits = value.clone();
             int S = bits.get(0).value();
             int E = bits.subBits(1, 9).toInt() - 127;
             Bits M = Bits.ofOne().append(bits.subBits(9, 32));
-            float floatValue = (float) (decodeIntValue(M.subBits(0, 1 + E)) + decodeDecimalValue(M.subBits(1 + E, M.length())));
+            float floatValue =  (float)((1 + decodeDecimalValue(M.subBits(1, M.length())))* pow(2, E));
             return (S == 0 ? 1 : -1) * floatValue;
         }
 
         public static double decodeDoubleValue(Bits value) {
             if (value.length() != 64) throw new IllegalArgumentException("double value must be 64 bits");
+            if (Bits.ofString("0000000000000000000000000000000000000000000000000000000000000000").equals(value)) return 0.0;
             Bits bits = value.clone();
             int S = bits.get(0).value();
             int E = bits.subBits(1, 12).toInt() - 1023;
             Bits M = Bits.ofOne().append(bits.subBits(12, 64));
-            double doubleValue = decodeIntValue(M.subBits(0, 1 + E)) + decodeDecimalValue(M.subBits(1 + E, M.length()));
+            double doubleValue =  (1 + decodeDecimalValue(M.subBits(1, M.length())))* pow(2, E);
             return (S == 0 ? 1 : -1) * doubleValue;
         }
     }

src/test/java/com/github/myibu/algorithm/AlgorithmTest.java

@@ -350,10 +350,23 @@ public void testBitsEncoder() {
         Assert.assertEquals(Bits.ofString("01000001100011010000000000000000"), Bits.Encoder.encodeFloatValue(17.625f));
         Assert.assertEquals(Bits.ofString("01000000110000000000000000000000"), Bits.Encoder.encodeFloatValue(6.0f));
         Assert.assertEquals(Bits.ofString("00000000000000000000000000000000"), Bits.Encoder.encodeFloatValue(0.0f));
+        Assert.assertEquals(Bits.ofString("10111111011111111111100101110010"), Bits.Encoder.encodeFloatValue(-0.9999f));
 
         Assert.assertEquals(Bits.ofString("0100000000000010000000000000000000000000000000000000000000000000"), Bits.Encoder.encodeDoubleValue(2.25));
         Assert.assertEquals(Bits.ofString("0011111111010110110010001011010000111001010110000001000001100010"), Bits.Encoder.encodeDoubleValue(0.356));
         Assert.assertEquals(Bits.ofString("0100000000101001100100111111011111001110110110010001011010000111"), Bits.Encoder.encodeDoubleValue(12.789));
         Assert.assertEquals(Bits.ofString("1100000000101001100100111111011111001110110110010001011010000111"), Bits.Encoder.encodeDoubleValue(-12.789));
+        Assert.assertEquals(Bits.ofString("1100000011000101101100111010101010101010101010101010101010101011"), Bits.Encoder.encodeDoubleValue(-11111.3333333333333333));
+
+        Assert.assertEquals(0.625f, Bits.Decoder.decodeFloatValue(Bits.ofString("00111111001000000000000000000000")), 0);
+        Assert.assertEquals(0.0f, Bits.Decoder.decodeFloatValue(Bits.ofString("00000000000000000000000000000000")), 0);
+        Assert.assertEquals(0.4f, Bits.Decoder.decodeFloatValue(Bits.ofString("00111110110011001100110011001101")), 0);
+        Assert.assertEquals(-0.9999f, Bits.Decoder.decodeFloatValue(Bits.ofString("10111111011111111111100101110010")), 0);
+
+        Assert.assertEquals(2.25, Bits.Decoder.decodeDoubleValue(Bits.ofString("0100000000000010000000000000000000000000000000000000000000000000")), 0);
+        Assert.assertEquals(0.356, Bits.Decoder.decodeDoubleValue(Bits.ofString("0011111111010110110010001011010000111001010110000001000001100010")), 0);
+        Assert.assertEquals(12.789, Bits.Decoder.decodeDoubleValue(Bits.ofString("0100000000101001100100111111011111001110110110010001011010000111")), 0);
+        Assert.assertEquals(-12.789, Bits.Decoder.decodeDoubleValue(Bits.ofString("1100000000101001100100111111011111001110110110010001011010000111")), 0);
+        Assert.assertEquals(-11111.3333333333333333, Bits.Decoder.decodeDoubleValue(Bits.ofString("1100000011000101101100111010101010101010101010101010101010101011")), 0);
     }
 }