Sign up ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

interprets the string as

9*e - 3

instead of what I am expecting:


How can I convert the expression to fortran notation?

share|improve this question
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 – george2079 Aug 18 at 11:54

2 Answers 2

up vote 7 down vote accepted

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

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

(* {{0.009}} *)


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

(* {0.009} *)
share|improve this answer
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


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];
strings = MapThread[StringJoin, {heads, exp, tails}]
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:

Internal`StringToDouble /@ strings // AbsoluteTiming // Short


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

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

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

Internal`StringToDouble /@ ReadList[StringToStream[lines], String] // AbsoluteTiming // Short

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 *)
Internal`StringToDouble /@ ReadList["test.dat", String] // AbsoluteTiming // Short
share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.