Merge pull request #21 from olyutorskii/release/v1.103.2

Release/v1.103.2

CHANGELOG.md

@@ -4,6 +4,11 @@ DoubDabC Changelog
 ## WIP
 Released on 20XX-XX-XX
 
+## v1.103.2
+Released on 2017-03-22
+- Add DecimalWriter which supports print(int) #16
+- Remove overblown terms on perfomance #20
+
 ## v1.102.6
 Released on 2017-02-19
 - Speed-up Arabic-num converting

README.md

@@ -20,7 +20,7 @@ that supports **binary integer value to decimal sequence conversion**.
 aka **Shift-and-add-3**.
 Double-Dabble is a radix-conversion algorithm
 but there is no division\(/\) nor remainder\(%\) operation.
-That means, **Fast !**
+It's a bit fast.
 
 * There is no String constructor during conversion.
 That means, **GC-friendry !**
@@ -43,14 +43,19 @@ Just losing higher decimals over you specified.
 
 * You can assign
 `Appendable`, `Writer`, `StringBuffer`, `StringBuilder`, or `CharBuffer`
-as Arabic numeral characters\(0-9\) output.
+as Arabic numeral characters\(0-9\) sequence output.
 
 * `CharSequence` wrapper class is provided.
 
+* Extended `Writer` class is provided
+which supports `print(int)` & `print(long)` methods
+like `PrintWriter`.
+
 
 ## Limitations ##
 
-* DoubDabC does not support negative values.
+* DoubDabC does not support negative values
+with the exception of `DecimalWriter`.
 Signed-values are treated as Unsigned-value
 like `Integer.toUnsignedString(int)`.
 Let's convert absolute value that follows minus\(-\) sign.
@@ -72,7 +77,7 @@ Just compile Java sources under `src/main/java/` if you don't use Maven.
 
 ## Project founder ##
 
-* By [Olyutorskii](https://github.com/olyutorskii) at 2017
+* By [olyutorskii](https://github.com/olyutorskii) at 2017
 
 
 ## Key technology ##

pom.xml

@@ -16,7 +16,7 @@
     <groupId>io.github.olyutorskii</groupId>
     <artifactId>doubdabc</artifactId>
 
-    <version>1.102.7-SNAPSHOT</version>
+    <version>1.103.2</version>
 
     <packaging>jar</packaging>
     <name>DoubDabC</name>

src/main/java/io/github/olyutorskii/doubdabc/io/DecimalWriter.java

@@ -0,0 +1,110 @@
+/*
+ * License : The MIT License
+ * Copyright(c) 2017 olyutorskii
+ */
+
+package io.github.olyutorskii.doubdabc.io;
+
+import io.github.olyutorskii.doubdabc.BcdRegister;
+import io.github.olyutorskii.doubdabc.BitFeeder;
+import io.github.olyutorskii.doubdabc.DecimalOut;
+import java.io.FilterWriter;
+import java.io.IOException;
+import java.io.Writer;
+
+/**
+ * Decimal-form-integer writer with Double-Dabble algorithm.
+ *
+ * <p>It's similar to {@link java.io.PrintWriter}
+ *
+ * @see java.io.PrintWriter
+ */
+public class DecimalWriter extends FilterWriter{
+
+    private final BcdRegister bcd;
+    private final DecimalOut decOut;
+
+
+    /**
+     * Constructor.
+     * @param out char output stream
+     */
+    public DecimalWriter(Writer out){
+        super(out);
+
+        this.bcd = new BcdRegister(BcdRegister.MAX_COL_UINT64);
+        this.decOut = new DecimalOut(this.bcd);
+
+        return;
+    }
+
+
+    /**
+     * Print signed int value.
+     *
+     * <p>It's similar to {@link java.io.PrintWriter#print(int)}.
+     *
+     * @param iVal int value
+     * @throws IOException output error
+     * @see java.io.PrintWriter#print(int)
+     */
+    public void print(int iVal) throws IOException{
+        boolean negSign;
+        int absVal;
+
+        if(iVal < 0){
+            negSign = true;
+            absVal = -iVal;
+            // -2147483648 does not change. OK, NP.
+        }else{
+            negSign = false;
+            absVal =  iVal;
+        }
+
+        synchronized(this.bcd){
+            BitFeeder.feedUInt32(this.bcd, absVal);
+
+            synchronized(this.lock){
+                if(negSign) append('-');
+                this.decOut.writeDigits(this);
+            }
+        }
+
+        return;
+    }
+
+    /**
+     * Print signed long value.
+     *
+     * <p>It's similar to {@link java.io.PrintWriter#print(long)}.
+     *
+     * @param lVal long value
+     * @throws IOException output error
+     * @see java.io.PrintWriter#print(long)
+     */
+    public void print(long lVal) throws IOException{
+        boolean negSign;
+        long absVal;
+
+        if(lVal < 0){
+            negSign = true;
+            absVal = -lVal;
+            // -9223372036854775808 does not change. OK, NP.
+        }else{
+            negSign = false;
+            absVal =  lVal;
+        }
+
+        synchronized(this.bcd){
+            BitFeeder.feedUInt64(this.bcd, absVal);
+
+            synchronized(this.lock){
+                if(negSign) append('-');
+                this.decOut.writeDigits(this);
+            }
+        }
+
+        return;
+    }
+
+}

src/main/java/io/github/olyutorskii/doubdabc/io/package-info.java

@@ -0,0 +1,12 @@
+/*
+ * License : The MIT License
+ * Copyright(c) 2017 olyutorskii
+ */
+
+/**
+ * Extended I/O-classes with Double-Dabble algorithm.
+ */
+
+package io.github.olyutorskii.doubdabc.io;
+
+/* EOF */

src/main/java/io/github/olyutorskii/doubdabc/package-info.java

@@ -12,8 +12,7 @@
  * but there is no division(/) nor remainder(%) operation.
  *
  * <p>There is no String constructor during conversion.
- *
- * <p>So, DoubDabC is Fast and GC-friendly.
+ * So, DoubDabC is a GC-friendly.
  *
  * <p>Project Home : <u>
  * <a target="_blank"

src/test/java/io/github/olyutorskii/doubdabc/io/DecimalWriterTest.java

@@ -0,0 +1,177 @@
+/*
+ * License : The MIT License
+ * Copyright(c) 2017 olyutorskii
+ */
+
+package io.github.olyutorskii.doubdabc.io;
+
+import java.io.CharArrayWriter;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ *
+ */
+public class DecimalWriterTest {
+
+    public DecimalWriterTest() {
+    }
+
+    @BeforeClass
+    public static void setUpClass() {
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+    }
+
+    @Before
+    public void setUp() {
+    }
+
+    @After
+    public void tearDown() {
+    }
+
+    /**
+     * Test of print method, of class DecimalWriter.
+     */
+    @Test
+    public void testPrint_int() throws Exception {
+        System.out.println("print");
+
+        DecimalWriter writer;
+        CharArrayWriter out;
+
+        out = new CharArrayWriter();
+        writer = new DecimalWriter(out);
+
+        out.reset();
+        writer.print(1);
+        assertEquals("1", out.toString());
+
+        out.reset();
+        writer.print(0);
+        assertEquals("0", out.toString());
+
+        out.reset();
+        writer.print(-1);
+        assertEquals("-1", out.toString());
+
+        out.reset();
+        writer.print(999);
+        assertEquals("999", out.toString());
+
+        out.reset();
+        writer.print(-999);
+        assertEquals("-999", out.toString());
+
+        out.reset();
+        writer.print(1_234_567_890);
+        assertEquals("1234567890", out.toString());
+
+        out.reset();
+        writer.print(-1_234_567_890);
+        assertEquals("-1234567890", out.toString());
+
+        out.reset();
+        writer.print(Integer.MAX_VALUE - 1);
+        assertEquals("2147483646", out.toString());
+
+        out.reset();
+        writer.print(Integer.MAX_VALUE);
+        assertEquals("2147483647", out.toString());
+
+        out.reset();
+        writer.print(Integer.MIN_VALUE);
+        assertEquals("-2147483648", out.toString());
+
+        out.reset();
+        writer.print(Integer.MIN_VALUE + 1);
+        assertEquals("-2147483647", out.toString());
+
+        return;
+    }
+
+    /**
+     * Test of print method, of class DecimalWriter.
+     */
+    @Test
+    public void testPrint_long() throws Exception {
+        System.out.println("print");
+
+        DecimalWriter writer;
+        CharArrayWriter out;
+
+        out = new CharArrayWriter();
+        writer = new DecimalWriter(out);
+
+        out.reset();
+        writer.print(1L);
+        assertEquals("1", out.toString());
+
+        out.reset();
+        writer.print(0L);
+        assertEquals("0", out.toString());
+
+        out.reset();
+        writer.print(-1L);
+        assertEquals("-1", out.toString());
+
+        out.reset();
+        writer.print(999L);
+        assertEquals("999", out.toString());
+
+        out.reset();
+        writer.print(-999L);
+        assertEquals("-999", out.toString());
+
+        out.reset();
+        writer.print(1_234_567_890L);
+        assertEquals("1234567890", out.toString());
+
+        out.reset();
+        writer.print(-1_234_567_890L);
+        assertEquals("-1234567890", out.toString());
+
+        out.reset();
+        writer.print((long)Integer.MAX_VALUE);
+        assertEquals("2147483647", out.toString());
+
+        out.reset();
+        writer.print((long)Integer.MAX_VALUE + 1L);
+        assertEquals("2147483648", out.toString());
+
+        out.reset();
+        writer.print((long)Integer.MIN_VALUE);
+        assertEquals("-2147483648", out.toString());
+
+        out.reset();
+        writer.print((long)Integer.MIN_VALUE - 1L);
+        assertEquals("-2147483649", out.toString());
+
+        out.reset();
+        writer.print(Long.MAX_VALUE - 1L);
+        assertEquals("9223372036854775806", out.toString());
+
+        out.reset();
+        writer.print(Long.MAX_VALUE);
+        assertEquals("9223372036854775807", out.toString());
+
+        out.reset();
+        writer.print(Long.MIN_VALUE);
+        assertEquals("-9223372036854775808", out.toString());
+
+        out.reset();
+        writer.print(Long.MIN_VALUE + 1L);
+        assertEquals("-9223372036854775807", out.toString());
+
+        return;
+    }
+
+}