# ToExpression and Fortran notation

ToExpression["9.0E-03"]


interprets the string as

9*e - 3


instead of what I am expecting:

0.009


How can I convert the expression to fortran notation?

-
ToExpression[StringReplace["9.0E-03", "E" -> "*^"]] – ciao May 23 '14 at 7:11
@rasher thank you! – user1541776 May 23 '14 at 7:28
essential duplicate mathematica.stackexchange.com/q/1737/2079 – george2079 Aug 18 '15 at 11:54

You can use ImportString, with the "Table" or "List" argument. See the documentation for details.

ImportString["9.0E-03", "Table"]

(* {{0.009}} *)


or

ImportString["9.0E-03", "List"]

(* {0.009} *)

-
thank you! I'm a bit puzzled though with Mathematica's architecture: why is it a separate function and moreover contains Import in its title? – user1541776 May 23 '14 at 7:30
ImportString takes a String as argument and provides the same output as Import, which takes a file as Argument. – Markus Roellig May 23 '14 at 7:37
thank you, now it's clear. – user1541776 May 23 '14 at 7:45

The given above answer is correct, however if you are not against using undocumented functions, then

InternalStringToDouble["9.0E-03"]


is much faster.

To demonstrate the speedup, first generate some fake data

heads = ToString /@
RandomReal[{1.0000, 9.9999}, 100000, WorkingPrecision -> 5] // Quiet;
exp = ConstantArray["E-", 100000];
tails = ToString /@ RandomInteger[{0, 9}, 100000];
lines = ExportString[strings, "List"];


So strings is a list of strings in the form of "1.3452E-5" and lines is one big string with each number in the same format separated with a newline. The two options are:

InternalStringToDouble /@ strings // AbsoluteTiming // Short

{0.0408109,{2.0525*10^-9,7.983*10^-7,<<99997>>,0.000099743}}


and

ImportString[lines, "List"] // AbsoluteTiming // Short

{0.626226,{2.0525*10^-9,7.983*10^-7,<<99997>>,0.000099743}}


If you have the choice of input format (list of strings or strings with newlines), then InternalStringToDouble is 15 times faster.

Finally, ReadList is useful to juggle the string formats. First option:

InternalStringToDouble /@ ReadList[StringToStream[lines], String] // AbsoluteTiming // Short

{0.0808349,{2.0525*10^-9,<<99998>>,0.000099743}}


That is to say, ReadList[StringToStream[lines], String] is much faster in converting the string with linebreaks to a list of strings than ImportString[lines, "List"]. Additionally, to test everything "for real":

Export["test.dat", lines, "String"] (* this takes a while, but we're
planning to import, not export *)
InternalStringToDouble /@ ReadList["test.dat", String] // AbsoluteTiming // Short

{0.0769682,{2.0525*10^-9,7.983*10^-7,<<99997>>,0.000099743}}
`
-