How to move the digit in a double to the end without converting to string in Java

Question

I am trying to make my number move the first character to the end.

For example I would have my double d.

double d = 12345.6;  
double result = 2345.61;

Currently I am removing the first character of d with:

d = d % (int) Math.pow(10, (int) Math.log10(d));

But I do not know how to store the character I am removing so I could put it at the end. I know I could just convert d into an array or a string, but I want to keep it as a double if at all possible.

I am getting my double from a nanosecond clock using Instant.now, so I can guarantee it starts as an 8 digit positive int, which I start by adding .0 to so I can make it a double. I know I can just use string (as I mentioned in the post), but I was wondering if there was a way to do it without conversions.

Thanks for helping!

(this is my first post I apologize if it is bad)

What are the *restrictions* put on the initial `double`? What if `d = -1.23`? `d = 1e100`? `d = 1.23e100`? `d = 1002`? `d = 0`? `d = 1.00023`? `d = 1e-100` etc. — Dmitry Bychenko, Aug 29 '18 at 22:42
Also, note that the last base 10 digit in a decimal floating point literal is not preserved when stored in variable. `12345.6` cannot be exactly represented in a Java double. — President James K. Polk, Aug 29 '18 at 22:43
Side note: `Math.log10(d));` will fail on negative `d` e.g. `d = -123` as well as `d = 0`. — Dmitry Bychenko, Aug 29 '18 at 22:44
What you're asking ("without converting to string") is really impossible, because the only way to find the "last" digit of a `double` is to format to a string, since it is the formatting logic that knows how to round the *imprecise* `double` number to a base-10 number. — Andreas, Aug 29 '18 at 22:46
When moving first digit to the end, does that mean that `0.00123` becomes `0.00231`? But then what about `123000`? Does it become `231000`, `230001`, or `23000.1`? — Andreas, Aug 29 '18 at 22:50
@Andreas , it would move the first digit no matter what, so 0.0123 would become 0.01230, which I know is a little silly, but I'm willing to live with it. 123000 would ideally become 23000.1 — Andrew, Aug 29 '18 at 23:06
Definitely stick with the string-based algorithm. It's going to be much simpler than any logic that deals with having to figure out what the first digit is (and what power of 10 it is scaled to), but you also would have to figure out what position it goes in so it can be properly scaled. Due to their internal representation, there's no easy way of figuring out those things without conversion to base 10 representation, which is all that string conversion does. — Ted Hopp, Aug 30 '18 at 01:23
@TedHopp I know it's easier and works better, I just wanted to know if it was possible to do it without conversion — Andrew, Aug 30 '18 at 03:55
@Andrew Possible? Sure. Just do everything that `Double.toString` is doing to figure out first and last base-10 digits of the `double` value. Insanely complex code, so although it is technically *possible*, my short answer is: Nothing can be gained from trying. Converting to string is an easy and fail-safe solution, and likely not noticeable slower than any other solution, so use the string solution. — Andreas, Aug 30 '18 at 15:54

score 2 · Answer 1 · answered Aug 30 '18 at 17:00

This is a pretty tough problem, and this isn't a working answer but it is pretty close. The only trouble I ran into was java adding decimals to the end of my doubles because it can't represent a number very well. My solution might get you on the right path. The appendChar was messing up because it was adding digits to the end of the double, other than that problem this would have worked.

public static void main(String[] args) {
        double test = 4234.1211;
        boolean hasDecimals = test % 1 > 0;
        double[] leadChar = getLeadDigitAndMulti(test);
        double appendedValue = appendLeadChar(test, (int) leadChar[1], hasDecimals);
    }


    public static double[] getLeadDigitAndMulti(double value) {
        double[] result = new double[2];
        int multiplier = 10;
        int currentMultiplier = 1;
        while (value > currentMultiplier) {
            currentMultiplier *= multiplier;
        }

        currentMultiplier /= multiplier;
        double trail = value % (currentMultiplier);
        result[0] = currentMultiplier;
        double lead = value - trail;
        lead /= currentMultiplier;
        result[1] = lead;
        return result;
    }


    public static double appendLeadChar(double value, int leadChar, boolean hasDecimals) {
        if (!hasDecimals) {
            return (value * 10) + leadChar;
        }

        int multiplier = 10;
        double currentMultiplier = 1;
        while (value > 0) {
            value %= currentMultiplier;
            currentMultiplier = currentMultiplier / multiplier;
        }

        return 0;
    }

score 0 · Answer 2 · answered Aug 30 '18 at 01:11

I would start with at least figuring out how many digits long your double is. I'm not too sure of how to make it work but I saw another question that would answer it. Here is the link to that thread: Number of decimal digits in a double

And the closest code on there that I could find to find the length would be:

double d= 234.12413;
String text = Double.toString(Math.abs(d));
int integerPlaces = text.indexOf('.');
int decimalPlaces = text.length() - integerPlaces - 1;

NOTE THIS SEGMENT OF CODE IS NOT MINE, credit goes to Peter Lawrey who originally answered this in the linked thread.

Then using code or modified code similar to above ^ assuming you would find how to find the length of the double or the total number of digits of your double, you would create a new int or double variable that would store the double and round it using BigDecimal to the highest place value. The place that the BigDecimal will round to will be set using a 10*pow(x) where x is the number of places AFTER the decimal.

Sorry I am unable to provide code on how to make this actually run because I am pretty new to java. Here is what I mean in more detailed pseudocode:

double d = 12345.6; //the double you are evaluating
double dNoDecimal; //will be rounded to have no decimal places in order to calculate place of the 1st digit
double dRoundedFirstDigit;  //stores the rounded number with only the 1st digit
double firstDigit; //stores first digit 

dNoDecimal = d; //transfers value
dNoDecimal = [use BigDecimal to round so no decimal places will be left]
//dNoDecimal would be equal to 12345 right now

[use above code to find total amount of place values]
[knowing place values use BigDecimal to round and isolate 1st digit of double]
dRoundedFirstDigit = dNoDecimal;  //transfers value
dRoundedFirstDigit = [round using BigDecimal to leave only 1st digit]
firstDigit = [dRoundedFirstDigit cut down to 1st digit value using length found from before, again an equation will be needed]

//Now use reverse process
//do the same thing as above, but find the number of decimals by rounding down to leave only decimals (leaving only .6)
//find the length
//use length to calculate what to add to the original value to move the digit to the end (in this case would be  d += firstDigit*Math.pow(10,-2))

I apologize if I just made everything seem more confusing, but I tried my best, hope this helps.

Also, doing this without an array or string is really difficult... may I ask why you need to do it without one?

Since the goal of the question is to do this without converting the `double` value to `String`, using `Double.toString` (first code segment) or `BigDecimal` (second code segment) is not the answer. The reason `BigDecimal` is not the answer is that conversion of `double` to `BigDecimal` requires converting to string as an intermediate value. Just because that conversion is hidden in a helper method [`BigDecimal.valueOf(double val)`](https://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html#valueOf-double-) doesn't change the fact that value is converted to string. Sorry, -1 from me. — Andreas, Aug 30 '18 at 15:48

How to move the digit in a double to the end without converting to string in Java

2 Answers2