{"id":1376,"date":"2015-08-07T16:26:19","date_gmt":"2015-08-07T20:26:19","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/?p=1376"},"modified":"2019-11-01T11:44:24","modified_gmt":"2019-11-01T15:44:24","slug":"typecast-got-faster-in-r2014b","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2015\/08\/07\/typecast-got-faster-in-r2014b\/","title":{"rendered":"Typecast got faster in R2014b"},"content":{"rendered":"

Some years ago we added the function typecast<\/tt><\/a> to MATLAB. I've been wanting to write about this useful little function ever since we significantly speeded it up in the R2014b release.<\/p>

The function typecast<\/tt> converts numeric values from one type to another based on the underlying bytes in the numeric representation.<\/p>

Clear as mud, right? Let me try a simple example to illustrate. Here is a vector of two numbers, each of which is represented using one byte:<\/p>

x = uint8([128 6])\r\n<\/pre>
\r\nx =\r\n\r\n  128    6\r\n\r\n<\/pre>
The call typecast(x,'uint16')<\/tt> takes those two one-byte numbers and converts them to one 16-bit number by jamming together the original bytes.<\/p>
y = typecast(x,'uint16'<\/span>)\r\n<\/pre>
\r\ny =\r\n\r\n   1664\r\n\r\n<\/pre>
Here's how the number 1664 is related to the original pair of numbers:<\/p>
128 + 6*2^8\r\n<\/pre>
\r\nans =\r\n\r\n        1664\r\n\r\n<\/pre>
If you give typecast<\/tt> four one-byte numbers, it will happily convert them into a pair of two-byte numbers.<\/p>
p = uint8([128 6 200 3])\r\n<\/pre>
\r\np =\r\n\r\n  128    6  200    3\r\n\r\n<\/pre>
typecast(p,'uint16'<\/span>)\r\n<\/pre>
\r\nans =\r\n\r\n   1664    968\r\n\r\n<\/pre>
Or, if you prefer, it will convert them into one four-byte number:<\/p>
typecast(p,'uint32'<\/span>)\r\n<\/pre>
\r\nans =\r\n\r\n    63440512\r\n\r\n<\/pre>
The function typecast<\/tt> performs these conversions between all of the integer and floating-point numeric types. These days I tend to use typecast<\/tt> (together with its cousin swapbytes<\/tt>) when writing low-level binary file reading code. For files that fit easily into memory, I might just read all the file bytes at once using fileread<\/tt>, and then I'll use indexing, swapbytes<\/tt>, and typecast<\/tt> into meaningful MATLAB data.<\/p>
Let's examine how long it takes to perform this conversion. First, make a vector containing 256 one-byte values.<\/p>
bytes = uint8(0:255);\r\n<\/pre>
Now use timeit<\/tt> to estimate how long it takes to convert those values to 128 two-byte values.<\/p>
f = @() typecast(bytes,'uint16'<\/span>);\r\nt_microseconds = timeit(f) * 1e6\r\n<\/pre>
\r\nt_microseconds =\r\n\r\n   19.8762\r\n\r\n<\/pre>
How would you expect the computation time to change as the input vector gets longer?<\/p>
Here's a plot of computation times that I measured using MATLAB R2014a.<\/p>
r2014a = load('typecast speedup R2014a ah-eddins-maci'<\/span>);\r\nplot(r2014a.n*256,r2014a.times*1e6)\r\nxlabel('Number of input bytes'<\/span>)\r\nylabel('Conversion time (microseconds)'<\/span>)\r\nax = gca;\r\nax.YLim(1) = 0;\r\ntitle('typecast performance (R2014a)'<\/span>)\r\n<\/pre>\"\" 
The computation time appears to be proportional to the input vector length, which is not too surprising.<\/p>
And here are the results measured using the latest MATLAB (R2015a).<\/p>
r2015a = load('typecast speedup R2015a ah-eddins-maci'<\/span>);\r\nplot(r2015a.n*256,r2015a.times*1e6)\r\nxlabel('Number of input bytes'<\/span>)\r\nylabel('Conversion time (microseconds)'<\/span>)\r\nax = gca;\r\nax.YLim(1) = 0;\r\ntitle('typecast performance (R2015a)'<\/span>)\r\n<\/pre>\"\" 
To make the comparison easier, show the results on the same plot.<\/p>
plot(r2014a.n*256,r2014a.times*1e6)\r\nhold on<\/span>\r\nplot(r2015a.n*256,r2015a.times*1e6)\r\nxlabel('Number of input bytes'<\/span>)\r\nylabel('Conversion time (microseconds)'<\/span>)\r\nax = gca;\r\nax.YLim(1) = 0;\r\ntitle('typecast performance'<\/span>)\r\nlegend({'R2014a'<\/span>,'R2015a'<\/span>})\r\n<\/pre>\"\" 
Now that is a little surprising! Not only is the R2015a computation time lower, it appears to be independent of the input vector length. That's because the implementation has been optimized to avoid making a copy in memory of the input vector's data. (For more about this kind of optimization, see Loren's 2006 blog post about MATLAB memory use for functions and variables<\/a>.)<\/p>
Have you had reason to use typecast<\/tt> in your own work? If so, please leave a comment. I'd be very interested to hear about your application.<\/p>