We Keep Coding

Convert hexadecimal string to double in Java

I want to convert this hex string 48985DDFAF27A0 to double. The result should be 49.1903648.
I tried
Double.longBitsToDouble
Parsing the hex string with parseInt(x, 16) and then using intBitsToFloat
Nothing of the above approaches seems to work.
Need suggestions please

You have to parse the string of hexadecimal number to long. After doing that, you convert to double by using Double.longBitsToDouble. Here is an example of your hex number:
public class Converter {
public static void main(String[] args) {
String hex = "48985DDFAF27A0";
long longHex = parseUnsignedHex(hex);
double d = Double.longBitsToDouble(longHex);
System.out.println(d);
}
public static long parseUnsignedHex(String text) {
if (text.length() == 16) {
return (parseUnsignedHex(text.substring(0, 1)) << 60)
| parseUnsignedHex(text.substring(1));
}
return Long.parseLong(text, 16);
}
}

Convert time to float and viceversa in Java

I need to show some times value on a linear chart and I built a snippet code to convert the values from time to float in Java.
My code doesn't works very well because I can't convert from float to time...
This is my result:
From time to float:
7:43 --> 7.7166667
From float to time:
7.7166667 --> 7:60 (this is wrong...I would to see 7:43)
This is my snippet code:
public class Test {
public static void main(String[] args)
{
String time = "7:43";
float timeFloat = Float.parseFloat(time.replace(":","."));
float resultTo100 = convertTo100(timeFloat);
System.out.println(resultTo100);
String resultTo60 = convertTo60(resultTo100);
System.out.println(resultTo60);
}
public static float convertTo100(float input)
{
String input_string = Float.toString(input);
BigDecimal inputBD = new BigDecimal(input_string);
String hhStr = input_string.split("\\.")[0];
BigDecimal output = new BigDecimal(Float.toString(Integer.parseInt(hhStr)));
output = output.add((inputBD.subtract(output).divide(BigDecimal.valueOf(60), 10, BigDecimal.ROUND_HALF_EVEN)).multiply(BigDecimal.valueOf(100)));
return Float.parseFloat(output.toString());
}
public static String convertTo60(float input)
{
String input_string = Float.toString(input);
BigDecimal inputBD = new BigDecimal(input_string);
String hhStr = input_string.split("\\.")[0];
BigDecimal output = new BigDecimal(Float.toString(Integer.parseInt(hhStr)));
output = output.add((inputBD.subtract(output).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_HALF_EVEN)).multiply(BigDecimal.valueOf(60)));
return output.toString().replace(".",":");
}
}
What am I doing wrong?
Thanks!

in your convertTo60 switch the order of divide and multiply operations.

Java: convert floating point binary to floating point decimal

I want to convert a string representing the mantissa portion of a IEEE754 double.
Cannot find if there is such a conversion method in Java, in order to avoid manually adding 1 + 1/2 + 1/4 + 1/8 etc.
|0100000011001010000111110000000000000000000000000000000000000000 --> 13374 in IEEE754
|------------1010000111110000000000000000000000000000000000000000 --> mantissa part
| 1.1010000111110000000000000000000000000000000000000000 --> restoring fixed value 1
String s = "1.1010000111110000000000000000000000000000000000000000"
double mant10 = Double.readFromFloatBinary(s); // does such method exists in Java?

Yes, there are ways to read from a binary representation. But you don't have a representation in an IEEE format.
I would ignore the period and read as a BigInteger base2, then create a value to divide by also using BigInteger:
private static double binaryStringToDouble(String s) {
return stringToDouble(s, 2);
}
private static double stringToDouble(String s, int base) {
String withoutPeriod = s.replace(".", "");
double value = new BigInteger(withoutPeriod, base).doubleValue();
String binaryDivisor = "1" + s.split("\\.")[1].replace("1", "0");
double divisor = new BigInteger(binaryDivisor, base).doubleValue();
return value / divisor;
}
#Test
public void test_one_point_5() {
String s = "1.1";
double d = binaryStringToDouble(s);
assertEquals(1.5, d, 0.0001);
}
#Test
public void test_6_8125() {
String s = "110.1101";
double d = binaryStringToDouble(s);
assertEquals(6.8125, d, 0.0001);
}
#Test
public void test_yours() {
String s = "1.1010000111110000000000000000000000000000000000000000";
double d = binaryStringToDouble(s);
assertEquals(1.632568359375, d, 0.000000000000000001);
}
#Test
public void test_yours_no_trailing_zeros() {
String s = "1.101000011111";
double d = binaryStringToDouble(s);
assertEquals(1.632568359375, d, 0.000000000000000001);
}

Java run-time error " Non-terminating decimal expansion; no exact representable decimal result" in BigDecimal class

it give me an error when choosing "Positive improper integration"or"Negative improper integration"
the error is Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
at java.math.BigDecimal.divide(BigDecimal.java:1603)
at SE_Project_2.calculate(SE_Project_2.java:55)
at SE_Project_2.main(SE_Project_2.java:45)
Code:
import java.math.BigDecimal;
import javax.swing.JOptionPane;
public class SE_Project_2 {
private static BigDecimal C0 = new BigDecimal("0.1713245");
private static BigDecimal C1 = new BigDecimal("0.3607616");
private static BigDecimal C2 = new BigDecimal("0.4679139");
private static BigDecimal C3 = new BigDecimal("0.4679139");
private static BigDecimal C4 = new BigDecimal("0.3607616");
private static BigDecimal C5 = new BigDecimal("0.1713245");
private static BigDecimal X0 = new BigDecimal("-0.932469514");
private static BigDecimal X1 = new BigDecimal("-0.661209386");
private static BigDecimal X2 = new BigDecimal("-0.238619186");
private static BigDecimal X3 = new BigDecimal("0.238619186");
private static BigDecimal X4 = new BigDecimal("0.661209386");
private static BigDecimal X5 = new BigDecimal("0.932469514");
private static BigDecimal a=new BigDecimal("0"),b=new BigDecimal("0");
private static int y;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
try{
String[] o = {"Positive improper integration","Negative improper integration","Normal integration"};
y = JOptionPane.showOptionDialog(null,"Welcome to my program! \nYahya Al-Buluwi\nIt can work for big decimal numbers.\n\nThis program will find the integral of: \nf(x)= 5x + 3 dx\nBy using the 6-points Gauss Legendre Quadrature formulae.\n\n What choise is prefered to you?","Welcome",JOptionPane.YES_NO_CANCEL_OPTION,JOptionPane.QUESTION_MESSAGE,null,o,o[2]);
BigDecimal sum = null;
if (y==2){
a = new BigDecimal((String)JOptionPane.showInputDialog(null,"Enter the value of a:","Enter the value of a", JOptionPane.QUESTION_MESSAGE));
b = new BigDecimal((String)JOptionPane.showInputDialog(null,"Enter the value of b:","Enter the value of b", JOptionPane.QUESTION_MESSAGE));
}
sum = calculate(X0,C0).add(calculate(X1,C1).add(calculate(X2,C2)).add(calculate(X3,C3).add(calculate(X4,C4).add(calculate(X5,C5)))));
System.out.println("y=" + y);
JOptionPane.showMessageDialog(null,"The 6-points Gauss Legendre Quadrature formulae solution according to \na= " + a+"\nb= "+b+" \nis: "+ sum,"Result",JOptionPane.INFORMATION_MESSAGE);
}catch(Exception e){
JOptionPane.showMessageDialog(null,"Ooops! an error has occured! the program will be terminated.","Error",JOptionPane.ERROR_MESSAGE);
calculate(X0,C0).add(calculate(X1,C1).add(calculate(X2,C2)).add(calculate(X3,C3).add(calculate(X4,C4).add(calculate(X5,C5)))));
System.out.println("y=" + y);
JOptionPane.showMessageDialog(null,"The 6-points Gauss Legendre Quadrature formulae solution according to \na= " + a+"\nb= "+b+" \nis: "+ calculate(X0,C0).add(calculate(X1,C1).add(calculate(X2,C2)).add(calculate(X3,C3).add(calculate(X4,C4).add(calculate(X5,C5))))),"Result",JOptionPane.INFORMATION_MESSAGE);
}
}
public static BigDecimal calculate(BigDecimal x, BigDecimal c){
BigDecimal h = x.multiply(new BigDecimal("0.5"));
if(y==0){
// PI= (1/(.5x)**2)*((5/(.5+.5x))+3)
return (((new BigDecimal("1")).divide(h.pow(2))).multiply((new BigDecimal("3")).add((new BigDecimal("5")).divide((new BigDecimal("0.5")).add(h)))));
}
if(y==1){
// NI= (1/(-.5x)**2)*((5/(-.5-.5x))+3)
return ((new BigDecimal("1").divide((h.negate()).pow(2))).multiply(new BigDecimal("3").add(new BigDecimal("5").divide(new BigDecimal("-0.5").add(h.negate())))));
}
BigDecimal sum = (b.add(a)).divide(new BigDecimal("2"));
BigDecimal diff =(b.add(a.negate())).divide(new BigDecimal("2"));
return c.multiply(diff.multiply((((diff.multiply(x)).add(sum)).multiply(new BigDecimal("5"))).add(new BigDecimal("3"))));
}
}

You probably need to use one of the divide methods that specify the rounding mode.
Read also here.

This happens when you do 1/3 on BigDecimal and don't specify how precise the result should be and what the round method should be like.
See javadoc (http://download.oracle.com/javase/6/docs/api/java/math/BigDecimal.html)
You may use a MathContext object to wrap up precision and roundupMethod together. You may also choose to specify it directly. Add that information to constructor or when calling divide are both ok.

Divide method throws this exception if the resulting number have infinite decimal expansion. In this case, you need to provide a MathContext, which will define how the number will be rounded, so that it have a finite value.

How to convert hex string to float in Java?

How to convert hexadecimal string to single precision floating point in Java?
For example, how to implement:
float f = HexStringToFloat("BF800000"); // f should now contain -1.0
I ask this because I have tried:
float f = (float)(-1.0);
String s = String.format("%08x", Float.floatToRawIntBits(f));
f = Float.intBitsToFloat(Integer.valueOf(s,16).intValue());
But I get the following exception:
java.lang.NumberFormatException: For input string: "bf800000"

public class Test {
public static void main (String[] args) {
String myString = "BF800000";
Long i = Long.parseLong(myString, 16);
Float f = Float.intBitsToFloat(i.intValue());
System.out.println(f);
System.out.println(Integer.toHexString(Float.floatToIntBits(f)));
}
}

You need to convert the hex value to an int (left as an exercise) and then use Float.intBitsToFloat(int)