Every now and then I discover a useful built-in Matlab function, often by bumping into them within the m-code of standard functions. Such was the case, for example, of the * ismembc* function, that I described here back in 2009, and the

*function that I described in 2011. Today I describe another such function,*

**dtstr2dtnummx***, based on a tip I received from Dirk Engel.*

**sprintfc**### The requirement

The use-case of generating a cell-array of formatted strings is often encountered. Unfortunately, the standard * sprintf* function generates a single string, rather than a cell-array of strings. So, for example,

>> data = pi * (0:.5:2) data = 0 1.5708 3.1416 4.7124 6.2832 >> sprintf('%.3f ',data) ans = 0.000 1.571 3.142 4.712 6.283

This is nice, but not exactly what we need, which is a cell array that looks like this:

>> c % c is a 1x5 cell array c = '0.000' '1.571' '3.142' '4.712' '6.283'

### The standard solutions

There are several standard solution for getting the required cell array. A simple for-loop is one of the fastest of these, due to JIT optimizations in recent Matlab releases. Some of the other alternatives may seem very strange, but they perform faster than the simpler variants. Note that the following code should be run within a testing function, to remove extraneous influences on the timing (JIT compilation etc.):

% 1) Simple for-loop with sprintf tic for idx = 1 : 1000 c = {}; %initialize % note: reallocations are not really a factor here, so don't bother preallocating for dataElement = data c{end+1} = sprintf('%.3f',dataElement); end end toc % Elapsed time is 0.076002 seconds. % 2) Using arrayfun + num2str tic for idx = 1 : 1000 c = arrayfun(@(c) num2str(c,'%.3f'), data, 'uniform',false); end toc % Elapsed time is 0.557993 seconds. % 3) Using cellfun + num2str + num2cell tic for idx = 1 : 1000 c = cellfun(@(c) num2str(c,'%.3f'), num2cell(data), 'uniform',false); end toc % Elapsed time is 0.566924 seconds. % 4) Using num2cell + num2str tic for idx = 1 : 1000 c = num2cell(num2str(data','%.3f'),2)'; end toc % Elapsed time is 0.173026 seconds. % 5) Using cellstr + num2str tic for idx = 1 : 1000 c = reshape(cellstr(num2str(data(:),'%.3f')),size(data)); end toc % Elapsed time is 0.175769 seconds. % 6) Using num2cell + num2str (after Urs Schwartz & Jiro Doke) tic for idx = 1 : 1000 c = reshape(num2cell(num2str(data(:),'%.3f'),2),size(data)); end toc % Elapsed time is 0.170247 seconds. % 7) Using strread + sprintf tic for idx = 1 : 1000 c = reshape(strread(sprintf(['%.3f','$'], data),'%s', 'delimiter','$'),size(data)); end toc % Elapsed time is 0.059457 seconds.

There are also some File Exchange contributions that do a similar thing, including num2cellstr or mtx2charcell, which basically implement the last two variants.

**sprintfc**

**sprintfc**

It turns out that the standard * num2str* function uses an undocumented built-in function

*that already does this for us in one fell swoop – this is both the simplest and the fastest solution:*

**sprintfc**% 8) fastest and simplest - sprintfc tic for idx = 1 : 1000 c = sprintfc('%.3f',data); end toc % Elapsed time is 0.015714 seconds.

This is a 35x speedup compared to * arrayfun/cellfun*, 5x speedup compared to the JIT-optimized for-loop, and 4x speedup compared to the fastest other variant. Useful indeed.

The syntax of the * sprintfc* function can be seen in the

*num2str.m*function:

[cells, errorMsg, isLeft] = sprintfc(format, data, isImaginary);

where `isImaginary`

is an optional flag (default=`false`

) indicating that data should be formatted as imaginary values with the specified magnitude:

>> data = pi * (-1:.5:1) data = -3.1416 -1.5708 0 1.5708 3.1416 >> sprintfc('%.3f', data, false) ans = '-3.142' '-1.571' '0.000' '1.571' '3.142' >> sprintfc('%.3f', data, true) ans = '-3.142i' '-1.571i' '+0.000i' '+1.571i' '+3.142i'

The second returned argument is an `errorMsg`

string that is returned when * sprintfc* fails, typically due to an invalid format:

>> [c,errorMsg] = sprintfc('%r', data) c = {''} errorMsg = Invalid format.

The third returned value, `isLeft`

, is apparently used to indicate whether the output cell-string is left-justified; namely, if the ‘-‘ flag is used within the format (thanks Yaroslav!). For example,

>> [cells, ~, isLeft] = sprintfc('%-8.5g', sqrt(2), false) cells = '1.4142 ' isLeft = 1 >> [cells, ~, isLeft] = sprintfc('%8.5g', sqrt(2), false) cells = ' 1.4142' isLeft = 0

* sprintfc* has apparently remained in its current stable state since it was first introduced in the last decade (sometime between Matlab release 7.1 [in 2005] and R2008a). I do not know why MathWorks chose to keep

*as an internal undocumented and unsupported function, despite its obvious usefulness.*

**sprintfc**If anyone finds any other similar useful built-ins, please do let me know.

** Addendum**: Starting in R2016b, the main functionality of

*(excluding*

**sprintfc***‘s 3rd [*

**sprintfc**`isImaginary`

] input flag, and its 2nd/3rd output args [`errorMsg`

and `isLeft`

]) is included in the new fully-documented/supported function *.*

**compose**### London training course – Feb/Mar 2014

I am planning a week of advanced Matlab training workshops/seminars in London in Feb/Mar 2014. I plan two separate courses:

**Advanced Matlab Programming**– 2 days, including best practices, preparing professional reports and performance tuning. US$ 999 until Jan 19, 2014; US$ 1199 for later registrations.**Advanced Matlab Visualization & GUI**– 3 days, including advanced visualization and GUI techniques. US$ 1499 until Jan 19, 2014; US$ 1799 for later registrations.

This is a unique opportunity to enhance your Matlab skills in a few days, at an affordable cost, by an established expert. This training is not provided anywhere else. If you have a specific topic that you would like me to discuss, then I would be happy to do it. In other words, I can customize the training to your specific needs, within the provided framework. More details on my training can be found here.

If you are interested in the London courses or a private dedicated course, please Email me (altmany at gmail dot com) for details.

Happy Hanukkah/Thanksgiving everyone

Yair hi,

After a short inspection I’ve come to the following conclusion: the third variable,

`isLeft`

, is used to indicate whether the output cell-string is left-justified; namely, if the`'-'`

flag is used within the format. For example,however,

Sincerely, Yaroslav

@Yaroslav – ah! makes sense, also correlates with the

num2str.mcode. I’ve updated the main text accordingly. ThanksHi Yair

I tried to figure out how to do this, and with higher dimension cell arrays, when I was still a Matlab newbie. I was obviously ahead of myself, but with a ton of reading, testing, and asking around, I managed. But if I needed to do that again it is good to know about this function. Great tip, nice post. Thanks

Pingback: Class object creation performance | Undocumented Matlab

Pingback: How do I make a column vector into an array of strings? - DexPage