Parse string to floating points

Hi,
I'm trying unsucessfully to parse the following string out to multiple outputs of floating point. Any idea?
Input String:
              Data     1            5           8          11
                      15.134 12.682   3.583    0.534
Want output to look like
output1: 15.134
output2: 12.682
output3: 3.583
output4: 0.534
thanks,
Anh

Anh
If thats what you want then you can get around it. Just wire the error out from the scan from string to a case statement selector. It will automatically fill out the error and no error. Pass through the scan from string values through both cases. Like this
David
Message Edited by David Crawford on 05-12-2006 10:28 AM
Attachments:
Scan From String Error Defaults.jpg ‏13 KB

Similar Messages

Convert string to floating-point

Hi all,
..very basic question, but I tryed it for hours and only received short-dumps
<b>How can I convert a string into a floating-point number?</b>
Kind regards,
Stefan

hi
try this
to convert string to float.
data : a type f,
s type string value '1.023'.
a = s.
write :/ a.
to convert float to string.
data : a type f value '1.023',
s type string.
s = a.
write : s.

Convertion Hex String to 32bits Decimal floating point??

Hi,
I would like to know how to convert hexa like: 416b0ac3 in decimal 32bits floating-point. The result of this string is suppose to be 14.690127.
So i must be able to do:
From 32-bit Hexadecimal Representation To Decimal Floating-Point
Thanks for your support
RiderMerlin

RiderMerlin
You can use the typecast function to do this.
David
Message Edited by David Crawford on 09-06-2006 03:31 PM
Attachments:
Typecast to Single.jpg ‏6 KB

Convert string to float

It seems extremely rudimentary but I haven't been able to find an answer yet.
I would like to pass in a string representing a human-readable floating point (ie, non IEEE 754) and get its value.
A straight up assignment of a string variable into a f variable doesn't work for thousand dividers. We would also need it for every scenarios:
123.456
123,456
123456
123456,789
123.456,789
123,456.789
all should be valid inputs and the resolution should be dependent on system setting for number formats.
I would like a built-in ABAP call with no manual processing. I'm sure this problem has been encountered thousands of times and solved thousands of times. No point reinventing the wheel.

Tested Code
Output as below
String : 123,456,789,123.456
String : 123456789123.456
Float : 1.2345678912345599E+11
DATA v_str TYPE STRING VALUE '123,456,789,123.456'.
DATA v_flt TYPE F.
WRITE: / 'String :', v_str. "With Commas
REPLACE ALL OCCURRENCES OF ',' IN v_str WITH ''.
WRITE: / 'String :', v_str. "Without Commas
CATCH SYSTEM-EXCEPTIONS ARITHMETIC_ERRORS = 1
CONVERSION_ERRORS = 2.
MOVE v_str TO v_flt.
ENDCATCH.
WRITE: / 'Float :', v_flt. "Float value

How to gather a set of floating point numbers from a web page form?

I am pretty new to Java and I am working on a project to apply Benfords law to find the probability of digits submitted by the user. My first step is to gather set of floating point numbers from a web page. How do I go about doing this? Any suggestion or a proper site where I can learn this stuff will be highly appreciated.

I am using NetBeans IDE 5.5.1 and for this project. I have realized that the first question was not well phrased.
I created a web project with 2 jsp files and a class file in it. When my jsp file runs I ask the user to enter a number for finding the probablility based on Benfords law.
This is what I got so far:
This is input.jsp
<h1></h1>
Please enter a number to be checked
<form action="result.jsp" method="post">
<input type="number" name="number" >
<input type="submit" value="Check number">
</form>
</body>
</html>
This is result.jsp
String number=request.getParameter("number");

Convert from String to float

How do I convert from String to float?

Hi,
you can use a Double for example - assuming value is that string to parse
float f;
try { Double d = new Double(value); f = d.floatValue(); }
catch (NumberFormatException e) { f = 0.0; } // error - string value could not be parsed
// here use your float fHope, that helps
greetings Marsian
P.S.: the Double class is usefull for that, because you also can get intValue(), doubleValue() or longValue() out of it for example. The StreamTokenizer for example parses numbers also only to double.

Floating point

i understand that floating point numbers are represented in java at binary numbers..
and that there are decimal values that cannot exactly representable in binary..
one of that i think is 0.1
but why is it that 0.1 can be represented exactly but in the computation it cannot.
i have this program..
public class CTest
    public static void main(String[] args)
          double d = 1.0;
          double d2 = 0.9;
          double d3 = 0.1;
          System.out.println(""+(d-d2));
          System.out.println(""+d3);
}please help..
thanks

I mean this one..
class D {
     public static void main(String[] args){
         double d = 0.1;
         double d2 = 1.0 - 0.9;
         System.out.println("d: " + d);
        System.out.println("d: " + d2);
[\code]

Single Precision Floating Point Numbers to Bytes

Ok here is some code that i have written w hile back with some help from the support staff. It is designed to take in precision floating point numbers that are stored as 4 bytes and convert then to a decimal value. It works off of a udp input string and then also reformats the string. I have the ability to look at up to 4000 parameters from this one udp string. But now what i want to do is do the opposite of what i have written, and also perhaps get rid of the matlab i used in it as well. What i would like to be able to do is input a decimal value and then have it converted in to the 4 byte groupings that make up this decimal nd then have it inputed back in to a single long string witht hat grouping of bytes in the right order. A better explanation of what was done can be found on this website
http://www.jefflewis.net/XPlaneUDP_8.html
as the original code followed the "Single Precision Floating Point Numbers and Bytes" example on that site but what i want to do is "Going from Single Precision Floating Point Numbers to Bytes". The site also explains the udp string that is being represented. Also attached is the original code that i am trying to simply reverse.
Attachments:
x-plane_udp_master.vi ‏34 KB

Perhaps what you are doing is an exercise in the programming of the math conversion of the bytes.
But if you are just interested in getting the conversion done, why not use the typecast function?
If the bytes happen to be in the wrong order for wherever you need to send the string, then you can use string functions to rearrange them.
Message Edited by Ravens Fan on 10-02-2007 08:50 PM
Attachments:
Example_BD.png ‏3 KB

Converting string to float

I have a decimal string "122339994" which i am trying to convert to float using Float.parseFloat. This results in incorrect value of 1.22339992E8.
I thought for floats precsision comes into effect after decimal places.
public static void main(String[] args) {
String floatString = "122339994";
float floatNumber = Float.parseFloat(floatString);
System.out.println("Float is "+floatNumber+". Now double "+Double.valueOf(floatString));
}

See this API
[Java2SE Float|http://download-llnw.oracle.com/javase/6/docs/api/java/lang/Float.html#valueOf%28java.lang.String%29]
Note that trailing format specifiers, specifiers that determine the type of a floating-point literal (1.0f is a float value; 1.0d is a double value), do not influence the results of this method. In other words, the numerical value of the input string is converted directly to the target floating-point type. In general, the two-step sequence of conversions, string to double followed by double to float, is not equivalent to converting a string directly to float. For example, if first converted to an intermediate double and then to float, the string
"1.00000017881393421514957253748434595763683319091796875001d"
results in the float value 1.0000002f; if the string is converted directly to float, 1.0000001f results.
Its better to see the Java APIs first for any information, we will get almost all the information we need from APIs
Regards,
Venkatesh

Designing for floating point error

Hello,
I am stuck with floating point errors and I'm not sure what to do. Specifically, to determine if a point is inside of a triangle, or if it is on the exact edge of the triangle. I use three cross products with the edge as one vector and the other vector is from the edge start to the query point.
The theory says that if the cross product is 0 then the point is directly on the line. If the cross product is <0, then the point is inside the triangle. If >0, then the point is outside the triangle.
To account for the floating point error I was running into, I changed it from =0 to abs(cross_product)<1e-6.
The trouble is, I run into cases where the algorithm is wrong and fails because there is a point which is classified as being on the edge of the triangle which isn't.
I'm not really sure how to handle this.
Thanks,
Eric

So, I changed epsilon from 1e-6 to 1e-10 and it seems to work better (I am using doubles btw). However, that doesn't really solve the problem, it just buries it deeper. I'm interested in how actual commercial applications (such as video games or robots) deal with this issue. Obviously you don't see them giving you an error every time a floating point error messes something up. I think the issue here is that I am using data gathered from physical sensors, meaning the inputs can be arbitrarily close to each other. I am worried though that if I round the inputs, that I will get different data points with the exact same x and y value, and I'm not sure how the geometry algorithms will handle that. Also, I am creating a global navigation mesh of triangles with this data. Floating point errors that are not accounted for correctly lead to triangles inside one another (as opposed to adjacent to each other), which damages the integrity of the entire mesh, as its hard to get your program to fix its own mistake.
FYI:
I am running java 1.6.0_20 in Eclipse Helios with Ubuntu 10.04x64
Here is some code that didn't work using 1e-6 for delta. The test point new Point(-294.18294451166435,-25.496614108304477), is outside the triangle, but because of the delta choice it is seen as on the edge:
class Point
     double x,y;
class Edge
     Point start, end;
class Triangle
     Edge[] edges;
     public Point[] getOrderedPoints() throws Exception{
          Point[] points = new Point[3];
          points[0]=edges[0].getStart();
          points[1]=edges[0].getEnd();
          if (edges[1].getStart().equals(points[0]) || edges[1].getStart().equals(points[1]))
               points[2]=edges[1].getEnd();
          else if (edges[1].getEnd().equals(points[0]) || edges[1].getEnd().equals(points[1]))
               points[2]=edges[1].getStart();
          else
               throw new Exception("MalformedTriangleException\n"+this.print());
          orderNodes(points);
          return points;
        /** Orders node1 node2 and node3 in clockwise order, more specifically
      * node1 is swapped with node2 if doing so will order the nodes clockwise
      * with respect to the other nodes.
      * Does not modify node1, node2, or node3; Modifies only the nodes reference
      * Note: "order" of nodes 1, 2, and 3 is clockwise when the path from point
      * 1 to 2 to 3 back to 1 travels clockwise on the circumcircle of points 1,
      * 2, and 3.
     private void orderNodes(Point[] points){
          //the K component (z axis) of the cross product a x b
          double xProductK = crossProduct(points[0],points[0], points[1], points[2]);
          /*        (3)
           *          +
           *        ^
           *      B
           * (1)+             + (2)
           *       ------A-->
           * Graphical representation of vector A and B. 1, 2, and 3 are not in
           * clockwise order, and the x product of A and B is positive.
          if(xProductK > 0)
               //the cross product is positive so B is oriented as such with
               //respect to A and 1, 2, 3 are not clockwise in order.
               //swapping any 2 points in a triangle changes its "clockwise order"
               Point temp = points[0];
               points[0] = points[1];
               points[1] = temp;
class TriangleTest
     private double delta = 1e-6;
     public static void main(String[] args) {
                Point a = new Point(-294.183483785282, -25.498196740397056);
          Point b = new Point(-294.18345625812026, -25.49859505161433);
          Point c = new Point(-303.88217906116796, -63.04183512930035);
          Edge aa = new Edge (a, b);
          Edge bb = new Edge (c, a);
          Edge cc = new Edge (b, c);
          Triangle aaa = new Triangle(aa, bb, cc);
          Point point = new Point(-294.18294451166435,-25.496614108304477);
          System.out.println(aaa.enclosesPointDetailed(point));
      * Check if a point is inside this triangle
      * @param point The test point
      * @return     1 if the point is inside the triangle, 0 if the point is on a triangle, -1 if the point is not is the triangle
      * @throws MalformedTriangleException
     public int enclosesPointDetailed(LocalPose point, boolean verbose) throws Exception
          Point[] points = getOrderedPoints();
          int cp1 = crossProduct(points[0], points[0], points[1], point);
          int cp2 = crossProduct(points[1], points[1], points[2], point);
          int cp3 = crossProduct(points[2], points[2], points[0], point);
          if (cp1 < 0 && cp2 <0 && cp3 <0)
               return 1;
          else if (cp1 <=0 && cp2 <=0 && cp3 <=0)
               return 0;
          else
               return -1;
         public static int crossProduct(Point start1, Point start2, Point end1, POint end2){
          double crossProduct = (end1.getX()-start1.getX())*(end2.getY()-start2.getY())-(end1.getY()-start1.getY())*(end2.getX()-start2.getX());
          if (crossProduct>floatingPointDelta){
               return 1;
          else if (Math.abs(crossProduct)<floatingPointDelta){
               return 0;
          else{
               return -1;
}

The BIG failure of the floating point computation

The Big failure of the floating point computation .... Mmmm
You are writing some code .. writing a simple function ... and using type Double for your computation.
You are then expecting to get a result from your function that is at least close to the exact value ...
Are you right ??
Let see this from an example.
In my example, I will approximate the value of pi. To do so, I will inscribe a circle into a polygon, starting with an hexagon, and compute the half perimeter of the polygon. this will give me an approximation for pi.
Then I will in a loop doubling the number of sides of that polygon. Therefore, each iteration will give me a better approximation.
I will perform this twice, using the same algorithm and the same equation ... with the only difference that I will write that equation in two different form
Since I don't want to throw at you equations and algorithm without explanation, here the idea:
(I wrote that with Word to make it easier to read)
====================
Simple enough ...
It is important to understand that the two forms of the equation are mathematically always equal for a given value of "t" ... Since it is in fact the exact same equation written in two different way.
Now let put these two equations in code
Public Class Form1
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
RichTextBox1.Font = New Font("Consolas", 9)
RichTextBox2.Font = New Font("Consolas", 9)
TextBox1.Font = New Font("Consolas", 12)
TextBox1.TextAlign = HorizontalAlignment.Center
TextBox1.Text = "3.14159265358979323846264338327..."
Dim tt As Double
Dim Pi As Double
'===============================================================
'Using First Form of the equation
'===============================================================
'start with an hexagon
tt = 1 / Math.Sqrt(3)
Pi = 6 * tt
PrintPi(Pi, 0, RichTextBox1)
'Now we will double the number of sides of the polygon 25 times
For n = 1 To 25
tt = (Math.Sqrt((tt ^ 2) + 1) - 1) / tt
Pi = 6 * (2 ^ n) * tt
PrintPi(Pi, n, RichTextBox1)
Next
'===============================================================
'Using Second Form of the equation
'===============================================================
'start with an hexagon
tt = 1 / Math.Sqrt(3)
Pi = 6 * tt
PrintPi(Pi, 0, RichTextBox2)
'Now we will double the number of sides of the polygon 25 times
For n = 1 To 25
tt = tt / (Math.Sqrt((tt ^ 2) + 1) + 1)
Pi = 6 * (2 ^ n) * tt
PrintPi(Pi, n, RichTextBox2)
Next
End Sub
Private Sub PrintPi(t As Double, n As Integer, RTB As RichTextBox)
Dim S As String = t.ToString("#.00000000000000")
RTB.AppendText(S & " " & Format((6 * (2 ^ n)), "#,##0").PadLeft(13) & " sides polygon")
Dim i As Integer = 0
While S(i) = TextBox1.Text(i)
i += 1
End While
Dim CS = RTB.GetFirstCharIndexFromLine(RTB.Lines.Count - 1)
RTB.SelectionStart = CS
RTB.SelectionLength = i
RTB.SelectionColor = Color.Red
RTB.AppendText(vbCrLf)
End Sub
End Class
The results:
The text box contains the real value of PI.
The set of results on the left were obtain with the first form of the equation .. on the right with the second form of the equation
The red digits show the digits that are exact for pi.
On the right, where we used the second form of the equation, we see that the result converge nicely toward Pi as the number of sides of the polygon increases.
But on the left, with the first form of the equation, we see the after just a few iterations, the function stop converging and then start diverging from the expected value.
What is wrong ... did I made an error in the first form of the equation?
Well probably not since this first form of the equation is the one you will find in your math book.
So, what up here ??
The problem is this:
What is happening is that at each iteration when using the first form, I subtract 1 from the radical, This subtraction always gives a result smaller than 1. Since the type double has a fixed number of digits on the left of the decimal
point, at each iteration I am loosing precision caused by rounding.
And after only 25 iterations, I have accumulate such a big rounding error that even the digit on the left of the decimal point is wrong.
When using the second form of the equation, I am adding 1 to the radical, therefore the value grows and I get no lost of precision.
So, what should we learn from this ?
Well, ... we should at least remember that when using floating point to compute a formula, even a simple one, as I show here, we should always check the exactitude of the result. There are some functions that a floating point is unable to evaluate.

I manually (yes, manually) did the computations with calc.exe. It has a higher accuracy. PI after 25 iterations is 3.1415926535897934934541990520762.
This means tt = 0.000000015604459512183037864437694609544 compared to 0.0000000138636291675699 computed by the code.
Armin
Manually ...
You did better than Archimedes.
He only got to the 96 sides polygon and gave up. Than he said that PI was 3.1427

How to restrict the decimal place of a floating point number?

Hi,
Here is my code:
public void TwoDecimal(double u){
     String w = Double.toString(u);
     int c = w.length();
     System.out.println(c);
     if (c <= 5)
        double a = Double.parseDouble(w);
        System.out.println(a);
     else
        System.out.println("Invalid input!");
}I want to show a floating point number which has 2 digits and 2 decimal places, e.g. 45.82, 29.67. This number is input by user and passed as a parameter.
For those case like the above sample floating point numbers, it can display the proper value of 'c'. e.g. 45.67 will display 5.
However, when I passed 99999, it will show 7; 9999 will return 6, not 5.
So, if the user does not input the '.', does it append 2 implicit chars to it? i.e. 99999.0 and 9999.0. So, that's why it returned 7 and 6 for the length of the string respectively.
How can I fix it?
and
Does it has better algorithm?
Pls advise.
gogo

When dealing with a known precision, in your case hundredths, it is often a good idea to use an integer type and add in the decimals on printing only. This is often the case in banking systems. Almost all of them use integer types, (read long) in pennies to store monitary values. Ever seen someone type in a value for a credit card machine? For something like $20 they press.. "2" "0" "0" "0" The machine knows the lowest denomonation in a cent, so it knows where to put the decimal place. I suggest you do something like this. It also helps to avoid base 2 round off errors.
-Spinoza

Floating point operations is slower when small values are used?

I have the following simple program that multiplies two different floating point numbers many times. As you can see, one of the numbers is very small. When I calculate the time of executing both multiplications, I was surprised that the little number takes much longer than the other one. It seems that working with small doubles is slower... Does anyone know what is happening?
public static void main(String[] args) throws Exception
        long iterations = 10000000;
        double result;
        double number = 0.1D;
        double numberA = Double.MIN_VALUE;
        double numberB = 0.0008D;
        long startTime, endTime,elapsedTime;
        //Multiply numberA
        startTime = System.currentTimeMillis();
        for(int i=0; i < iterations; i++)
            result = number * numberA;
        endTime = System.currentTimeMillis();
        elapsedTime = endTime - startTime;
        System.out.println("
        System.out.println("Number A)
Time elapsed: " + elapsedTime + " ms");
        //Multiply numberB
        startTime = System.currentTimeMillis();
        for(int i=0; i < iterations; i++)
            result = number * numberB;
        endTime = System.currentTimeMillis();
        elapsedTime = endTime - startTime;
        System.out.println("
        System.out.println("Number B)
Time elapsed: " + elapsedTime + " ms");
    } Result:
Number A) Time elapsed: 3546 ms
Number B) Time elapsed: 110 ms
Thanks,
Diego

Verrry interrresting... After a few tweaks (sum & print multiplication result to prevent Hotspot from removing the entire loop, move stuff to one method to avoid code alignment effects or such, loop to get Hotspot compile everything; code below),
I find that "java -server" gives the same times for both the small and the big value, whereas "java -Xint" and "java -client" exhibit the unsymmetry. So should I conclude that my CPU floating point unit treats both values the same, but the client/server compilers do something ...what?
(You may need to add or remove a zero in "iterations" so that you get sane times with -client and -server.)
public class t
    public static void main(String[] args)
     for (int n = 0; n < 10; n++) {
         doit(Double.MIN_VALUE);
         doit(0.0008D);
    static void doit(double x)
        long iterations = 100000000;
        double result = 0;
        double number = 0.1D;
        long start = System.currentTimeMillis();
        for (int i=0; i < iterations; i++)
            result += number * x;
        long end = System.currentTimeMillis();
        System.out.println("time for " + x + ": " + (end - start) + " ms, result " + result);
}

How can floating point division be faster than integer division?

Hello,
I don't know if this is a Java quirk, or if I am doing something wrong. Check out this code:
public class TestApp
     public static void main(String args[])
          long lngOldTime;
          long lngNewTime;
          long lngTimeDiff;
          int Tmp;
          lngOldTime = System.currentTimeMillis();
          for( int A=1 ; A<=20000 ; A++)
               for( int B=1 ; B<=20000 ; B++)
                    Tmp = A / B;
          lngNewTime = System.currentTimeMillis();
          lngTimeDiff = lngNewTime - lngOldTime;
          System.out.println(lngTimeDiff);
}It reports that the division operations took 18,116 milliseconds.
Now check out this code (integers replaced with doubles):
public class TestApp
     public static void main(String args[])
          long lngOldTime;
          long lngNewTime;
          long lngTimeDiff;
          double Tmp;
          lngOldTime = System.currentTimeMillis();
          for( double A=1 ; A<=20000 ; A++)
               for( double B=1 ; B<=20000 ; B++)
                    Tmp = A / B;
          lngNewTime = System.currentTimeMillis();
          lngTimeDiff = lngNewTime - lngOldTime;
          System.out.println(lngTimeDiff);
}It runs in 11,276 milliseconds.
How is it that the second code snippet could be so much faster than the first? I am using jdk1.4.2_04
Thanks in advance!

I'm afraid you missed several key points. I only used
Longs for measuring the time (System.currentTimeMillis
returns a long). Sorry you are correct I did miss that.
However, even if I had, double is
also a 64-bit data type - so technically that would
have been a more fair test. The fact that 64-bit
floating point divisions are faster than 32-bit
integer divisions is what confuses me.
Oh, just in case you're interested, using float's in
that same snippet takes only 7,471 milliseconds to
execute!Then the other explaination is that the Hotspot compiler is optimizing the floating point code to use the cpu floating point instructions but it is not optimizing the integer divide in the same way.

Photoshop CS3 vs CS2 32 bit floating point tiff loading

Hi,
The application I'm developing exports 3 channel 32 bit floating point tiff's.
The exported files could have been loaded into PS CS2, but PS CS3 can't load them anymore, all I get is a message box with this message:
"Could not complete your request because of a problem parsing the TIFF file."
I've uploaded the file here, so you guys can have a look at: www.thepixelmachine.com/dispmap.tiff

Where should I've posted this thread instead? I suppose people here write plugins by programming them (right?), so they suppose to be programmers, not regular PS users. I thought a programmer would be much more familiar with programming related issues, such as tiff file saving c++ routines. Correct me if I'm wrong.
The people who tested the file have Photoshop CS3 and didn't manage to open it, they even sent me screenshots with the error message box. In CS2 however, the file loads perfectly. Also, the single strip version opened just fine in CS3.
You may close this thread, the problem was solved and more than that it looks like I haven't posted it in the right forum.
Thanks.

Parse string to floating points

Similar Messages

Maybe you are looking for