BigDecimal made Simple

Here is my take on (lighter version of) Java's BigDecimal.

Originally I wrote this as a replacement for BigDecimal in order to improve performance during serialisation and data manipulation.

public class SimpleDecimal implements Comparable<SimpleDecimal> {
    private long    value = 0L;
    private int     fractionalPrecision = 0;
    private boolean debug = false;


    public static SimpleDecimal simplify(SimpleDecimal o) {
        if (!((o.getFractionalPrecision() > 0) && ((o.getValue() % 10) == 0))) {
            return o;
        }
        SimpleDecimal sd = new SimpleDecimal(o);
        do {
                sd.setValue(sd.getValue() / 10);
                sd.setFractionalPrecision(sd.getFractionalPrecision() - 1);
        } while ((sd.getFractionalPrecision() > 0) && ((sd.getValue() % 10) == 0));
        return sd;
    }

    public static SimpleDecimal adjust(SimpleDecimal o, int fractionalPrecision) {
        if (o.getFractionalPrecision() == fractionalPrecision) {
            return o;
        }
        if (o.getFractionalPrecision() > fractionalPrecision) {
            return simplify(o);
        }
        SimpleDecimal sd = new SimpleDecimal(o);
        sd.incFractionalPrecision(fractionalPrecision - sd.getFractionalPrecision());
        return sd;
    }



    // Various constructors
    public SimpleDecimal(int value) {
        this(String.valueOf(value));
    }

    public SimpleDecimal(long value) {
        this(String.valueOf(value));
    }

    public SimpleDecimal(float value) {
        this(String.valueOf(value));
    }

    public SimpleDecimal(double value) {
        this(String.valueOf(value));
    }

    /**
     * This method will expect standard representation of numerical value as returned by
     * String.valueOf(...)
     * @param value
     */
    public SimpleDecimal(String value) {
        int fpsl = value.lastIndexOf('.');
        String strValue;
        if (fpsl > 0) {
            strValue = value.substring(0, fpsl) + value.substring(fpsl + 1);
        } else {
            strValue = value.substring(fpsl + 1);
        }
        setValue(Long.valueOf(strValue));

        if (fpsl < 0) {
            fpsl = 0;
        } else {
            fpsl = value.length() - fpsl - 1;
        }
        setFractionalPrecision(fpsl);
    }

    public SimpleDecimal(SimpleDecimal o) {
        this(o.getValue(), o.getFractionalPrecision());
    }

    public SimpleDecimal add(SimpleDecimal augend) {
        SimpleDecimal result = new SimpleDecimal(this);
        int fp = result.getFractionalPrecision();
        if (fp < augend.getFractionalPrecision()) {
            fp = augend.getFractionalPrecision();
            result = adjust(result, fp);
        } else {
            augend = adjust(augend, fp);
        }
        result.setValue(result.getValue() + augend.getValue());
        return result;
    }

    public SimpleDecimal subtract(SimpleDecimal subtrahend) {
        SimpleDecimal result = new SimpleDecimal(this);
        int fp = result.getFractionalPrecision();
        if (fp < subtrahend.getFractionalPrecision()) {
            fp = subtrahend.getFractionalPrecision();
            result = adjust(result, fp);
        } else {
            subtrahend = adjust(subtrahend, fp);
        }
        result.setValue(result.getValue() - subtrahend.getValue());
        return result;
    }

    public SimpleDecimal multiply(SimpleDecimal multiplicand) {
        SimpleDecimal result = new SimpleDecimal(this);
        result.setValue(result.getValue() * multiplicand.getValue());
        result.setFractionalPrecision(result.getFractionalPrecision() + multiplicand.getFractionalPrecision());
        return result;
    }

    public SimpleDecimal divide(SimpleDecimal divisor) {
        SimpleDecimal result = new SimpleDecimal(this);
        int fp = result.getFractionalPrecision();
        if (fp < divisor.getFractionalPrecision()) {
            fp = divisor.getFractionalPrecision();
            result = adjust(result, fp + fp);
        } else {
            result = adjust(result, fp + fp);
            divisor = adjust(divisor, fp);
        }
        result.setValue(result.getValue() / divisor.getValue());
        result.setFractionalPrecision(fp);
        return result;
    }

    public SimpleDecimal simplify() {
        return simplify(this);
    }

    @Override
    public int compareTo(SimpleDecimal o) {
        SimpleDecimal sd1 = new SimpleDecimal(this);
        return compare(sd1, o);
    }

    // If you need to handle big values use BigDecimal instead
    public static int compare(SimpleDecimal o1, SimpleDecimal o2) {
        int result = 0;
        if (o1.getFractionalPrecision() == o2.getFractionalPrecision()) {
            return (int) (o1.getValue() - o2.getValue());
        }
        SimpleDecimal sd1 = simplify(o1);
        SimpleDecimal sd2 = simplify(o2);
        int maxFractionalPrecision = sd1.getFractionalPrecision();
        if (sd2.getFractionalPrecision() > maxFractionalPrecision) {
            maxFractionalPrecision = sd2.getFractionalPrecision();
        }
        sd1 = adjust(sd1, maxFractionalPrecision);
        sd2 = adjust(sd2, maxFractionalPrecision);
        if (sd1.getFractionalPrecision() == sd2.getFractionalPrecision()) {
            return (int) (sd1.getValue() - sd2.getValue());
        }
        return result;
    }

    @Override
    public String toString() {
        String str;
        if (isDebug()) {
        // Use this for debugging
            str = debugToString();
        } else {
        // Use this for normal output
            str = stdToString();
        }
        return str;
    }

    @Override
    public boolean equals(Object o) {
        if (null == o)
            return false;
        if (!this.getClass().isInstance(o))
            return false;
        SimpleDecimal sd = (SimpleDecimal) o;
        return equals(sd);
    }

    public boolean equals(SimpleDecimal o) {
        boolean result = false;
        if (compareTo(o) == 0) {
            result = true;
        }
        return result;
    }

    public SimpleDecimal movePointLeft(int n) {
        SimpleDecimal sd = new SimpleDecimal(this);
        sd.incFractionalPrecision(n);
        return sd;
    }

    public SimpleDecimal movePointRight(int n) {
        SimpleDecimal sd = new SimpleDecimal(this);
        sd.decFractionalPrecision(n);
        return sd;
    }




    // Standard getters/setters
    public long getValue() {
        return value;
    }

    public void setValue(long value) {
        this.value = value;
    }

    public int getFractionalPrecision() {
        return fractionalPrecision;
    }

    public void setFractionalPrecision(int fractionalPrecision) {
        this.fractionalPrecision = fractionalPrecision;
    }

    public void incFractionalPrecision() {
        int fractionalPrecision = 1;
        incFractionalPrecision(fractionalPrecision);
    }

    public synchronized void incFractionalPrecision(int fractionalPrecision) {
        for (int i = 0; i < fractionalPrecision; i++) {
            this.value *= 10;
        }
        this.fractionalPrecision += fractionalPrecision;
    }

    public void decFractionalPrecision() {
        int fractionalPrecision = 1;
        decFractionalPrecision(fractionalPrecision);
    }

    public synchronized void decFractionalPrecision(int fractionalPrecision) {
        if (fractionalPrecision > this.fractionalPrecision) {
            fractionalPrecision = this.fractionalPrecision;
        }
        for (int i = 0; i < fractionalPrecision; i++) {
            this.value /= 10;
        }
        this.fractionalPrecision -= fractionalPrecision;
    }

    public boolean isDebug() {
        return debug;
    }

    public void setDebug(boolean debug) {
        this.debug = debug;
    }

    private SimpleDecimal(long value, int fractionalPrecision) {
        super();
        this.value = value;
        this.fractionalPrecision = fractionalPrecision;
    }

    private String stdToString() {
        String strValue = String.valueOf(getValue());
        String str;
        if (getFractionalPrecision() > 0) {
            StringBuilder sb = new StringBuilder();
            for (int i = strValue.length(); i < getFractionalPrecision() + 1; i++) {
                sb.append('0');
            }
            sb.append(strValue);
            strValue = sb.toString();

            int dpp = strValue.length() - getFractionalPrecision();
            int p = 0;
            str = 
                ((getValue() >= 0) ? "" : strValue.substring(0, ++p))
                + ((dpp == p) ? "0" : strValue.substring(p, dpp))
                + '.' + strValue.substring(dpp);
        } else {
            str = strValue;
        }
        return str;
    }

    private String debugToString() {
        return "SimpleDecimal [" +
                "value=" + value
                + ", fractionalPrecision=" + fractionalPrecision
                + "]";
    }
}