To convert a cell array of character vectors to numbers, you can use the |str2double| function. This function is the simplest method. C = {'0.000000'; '10.000000'; '100000.000000'}; M = str2double(C) The |cell2mat| function converts a cell array of character vectors to a character array, and only if all the character vectors have the same length. |cell2mat| also preserves the data type of the contents of the cells, so it does not convert characters to numbers. If you need your code to be fast, then use the following code instead. This code is faster than |str2double|: C = {'0.000000'; '1.000000'; '2.000000'; ... '3.000000'; '4.000000'; '5.000000'; '6.000000' '7.000000'; '8.000000'; '9.000000'; '10.000000'}; S = sprintf('%s*', C{:}); N = sscanf(S, '%f*'); Unfortunately |sprintf| seems to forget a proper pre-allocation. This C-Mex is 4 times faster: : S = CStr2String(C, '*'); N = sscanf(S, '%f*'); Timings in 2011b, Core2Duo: n = 100; C = cell(1, n); for iC = 1:n; C{i} = sprintf('%f', i); end tic; for i=1:1000; N = cellfun(@(x)str2double(x), C); end; toc >> 3.61 sec tic; for i=1:1000; N = cellfun(@(x) sscanf(x, '%f'), C); end; toc >> 3.01 sec tic; for i=1:1000; N = str2double(C); end; toc >> 2.79 sec tic; for i=1:1000; N = cellfun(@str2double, C); end; toc >> 2.49 sec tic; for i=1:1000; N = zeros(1,100); for j=1:100; N(j) = sscanf(C{j}, '%f'); end; end; toc >> 1.40 sec tic; for i=1:1000; N = sscanf(sprintf('%s*', C{:}), '%f*'); end; toc >> 0.14 sec tic; for i=1:1000; N = sscanf(CStr2String(C, '*'), '%f*'); end; toc >> 0.071 sec To my surprise a full implementation in C is *slower* than |sscanf(sprintf())|, see . Matlab's sscanf seems to be much better than the MSVC implementation.

str2num(chr) converts a character array or string scalar to a numeric matrix. The input can include spaces, commas, and semicolons to indicate separate elements. If str2num cannot parse the input as numeric values, then it returns an empty matrix. The str2num function does not convert cell arrays or nonscalar string arrays, and is sensitive to spacing around + and - operators. str2num() contains a call to eval(), which means that if your string has the same form as an array (e.g. with semicolons) then it is simply executed and the resulting array is returned. The problems with str2num() are that it doesn’t support cell arrays, and that because it uses an eval() function, wierd things can happen if your string includes a function call. str2double() is supposedly faster as well. So the general rule seems to be, use str2double() unless you are wanting to convert a string array of numbers to a numerical array. There is one catch though- if you are converting a single number from a string to a number, then it would SEEM like str2num() and str2double() are interchangable, drop in replacements. However, if the string is not a number, they behave differently

If you convert your matrix into a column vector, each character will be positioned in a different row, so that it can be handled independently by str2num. Then reshape back:

result = reshape(str2num(A(:)), size(A))

The function *str2num* can be used to convert the strings that inherently contain numbers to double class. In your case there are no numbers in the outputs from *sprintf* function. Therefore, it results in empty [] which belongs to double class by default. The reason why it worked for other data types is that they all belong to or contain numbers except for *char & string* Hope this clarifies

It might help to specify the option to readtable, and perhaps the Format option as well. Using and passing the result to readtable() might help.

MATLAB does not force one to use str2double(), but mlint may recommend it. >> str2num('sqrt(pi)') ans = 1.77245385090552 Did you really want people to be able to enter arbitrary text and have it executed by MATLAB ?

rawStrMod = '0.0000000001, 0.3'; "It gives me 0.000000000100000, not exactly the same as 0.0000000001." Ignoring formatting issues, none of the Mathworks toolboxes are able to give you *exactly* the same as 0.0000000001 . MATLAB is not able to store 0.0000000001 *exactly* in binary floating point: the closest it can get in binary floating point is 0.00000000010000000000000000364321973154977415791655470655996396089904010295867919921875 The closest Mathworks tool can get is by using the Symbolic Toolbox, for which sym('0.0000000001') gives you something that is _closer_ to 0.0000000001 than you can get without the Symbolic Toolbox, but if you probe hard enough you can prove that sym('0.0000000001') is implemented as a binary ratio whose asymptotic accuracy is bounded by truncations of 10/3 bits per digit of accuracy requested (log2(10) would perhaps be expected but the model turned out to be 10/3: some of the bits are being used for overhead of extended precision values.) Everything else is just formatting (and perhaps keeping track of sizes). There are only a few formatting options available for default numeric display. For anything else you should be using sprintf() or fprintf() for fine detailed display. rawStrMod = '0.0000000001, 0.3, 0.0000000001000, 123'; T = regexp(rawStrMod, '\s*,\s*', 'split'); T_numeric = str2double(T); T_input_digits = cellfun(@length,regexprep(T,{'^[^.]*$', '^.*\.'},{'', ''},'once', 'lineanchors')); T_data = num2cell( [T_input_digits(:),T_numeric(:)].' ); fprintf('%.*f\n', T_data{:}); Output is 0.0000000001 0.3 0.0000000001000 123 The input was converted to numeric (T_numeric), but the number of decimal places was tracked, and that number is used to format the output. This code does have a subtle problem: * if you have an integer like the 123, then it is entirely reasonable that the output should not contain a decimal place, like happens here, with the number of decimal places being detected to be 0 * however, if the 123 were instead 123. with no digits following the decimal places, then the number of decimal places would be considered to be 0, and when told to use 0 decimal places, the %f format item does not put in the trailing decimal point, so 123. would print out as 123 with the code as implemented being unable to format 123 on input differently than 123. on input.