I was looking at the image below on a web page recently and I decided to extract the locations of all the dots. I thought the procedure might make a nice little end-of-the-week how-to post.

% Did you know that imread can read directly from a URL?
url = 'http://cgm.cs.mcgill.ca/~godfried/teaching/projects97/belair/example1.gif';
[X, map] = imread(url);
imshow(X, map)

First question to answer: What is the index of the color used for the dots? One easy way to go is to use imtool.

Here's a screenshot:

As you can see, when I placed the mouse pointer over the center of one of the dots, the pixel info display at the lower left showed that the index value was 1, and the corresponding colormap color was [1.00, 0.78, 0.00].

Now that we know the index value, we can easily make a binary image of just the interior of the dots.

bw = X == 1;
imshow(bw)

Now we can compute the centroids of the dots.

s = regionprops(bw, 'Centroid')

s = 122x1 struct array with fields: Centroid 

The line above is a new syntax for regionprops that we introduced earlier this year in R2009a. Previously, you always had to compute a label matrix first using bwlabel and then pass that label matrix to regionprops. Now regionprops can do this computation directly on the binary image. Since the label matrix is not computed, this new syntax uses less memory and usually runs faster than the old version.

For those of you using an older version, do this instead:

 L = bwlabel(bw); s = regionprops(L, 'Centroid');

To show the results, display the image and then superimpose the centroid locations.

imshow(X, map)
hold on
for k = 1:numel(s) centroid_k = s(k).Centroid; plot(centroid_k(1), centroid_k(2), 'b.');
end
hold off

Hmm. It looks we got only one dot at some of those locations. Use the zoom button on the Figure Window toolbar to zoom in. Or you can do it noninteractively:

axis([50 100 0 50])

Yep. For overlapping circles, we are only getting one location. The reason is that the interiors of the overlapping circles are 8-connected to each other, so they are regarded by regionprops as single regions. To get two locations for these overlapping circles, we have to label the regions using 4-connectivity instead of 8-connectivity.

To do this we have to compute the connected components in a separate step and then call regionprops.

cc = bwconncomp(bw, 4);
s = regionprops(cc, 'Centroid');

bwconncomp is also new to R2009a. Users of R2008b and earlier can do:

 L = bwlabel(bw, 4); s = regionprops(L, 'Centroid');

imshow(X, map)
hold on
for k = 1:numel(s) centroid_k = s(k).Centroid; plot(centroid_k(1), centroid_k(2), 'b.');
end
hold off
axis([50 100 0 50])

Much better.

This little example showed several useful things:

Have a happy weekend!

Get the MATLAB code

Published with MATLAB® 7.9

I like his slow, clear, methodical presentation with great visualizations. It is the first time I have deeply understood some of the volume visualization techniques we have.

• 1 of 9 Definitions for scalar and vector fields.
• 2 of 9 Examples of scalar and vector fields (temperature in a room vs air currents)
• 3 of 9 Displays scatter3 and slice plots.
• 4 of 9 Displays contourslice and isosurface.
• 5 of 9 Making a 3-d plot ‘pretty’ with lighting, shading, interpolation, etc…
• 6 of 9 Displays quiver3 and coneplot

In my last Pick, I singled out someone who has contributed widely to image-processing discussions on the CSSM newsgroup. Today, I want to recognize a stalwart contributor to the MATLAB community, both through CSSM and through his numerous submissions to the MATLAB Central File Exchange. Anyone who has spent time posing or answering questions on CSSM knows of us. And though he has labeled all of his 41 submissions as "pedestrian," most are anything but.

Today's Pick comes to us from us. (Sounds circular, but power-user us apparently doesn't like capitals--or three-letter names!). In rex: a pedestrian regular expression operator synopsis generator, us has provided a very handy cheat sheet, of sorts, for creating Regular Expressions. For those of you who haven't yet delved the mysteries of regular expressions, they are powerful devices for searching or manipulating strings. But they can be cryptic to create or to decipher. Us's rex is a single-page reference for writing regular expressions. The commands can be written to the Command Window, or displayed in a listbox:

Many of us's files are Pickworthy. His functions are broadly useful, and his code is powerful, concise, and well-written. Give his files a browse--there's something there for everyone!

Comments?

Get the MATLAB code

Published with MATLAB® 7.8

I've fielded some questions recently about how to coordinate multiple arrays changing simultaneously. One example is removing elements for two arrays in the case where either array holds a zero for the location. This is a good opportunity to reiterate the use of logical arrays and some useful associated functions (such as any and all).

Contents

Identify Pairs to Remove

Let's say I have 2 arrays

a = [ 1 4 9 0 25 0 49 0]
b = [ 1 0 3 0 0 6 7 8]

a = 1 4 9 0 25 0 49 0
b = 1 0 3 0 0 6 7 8

and I would like to delete the corresponding elements in a and b when either of them contains a zero value.

First Algorithm

There are several possible algorithms, each with their own trade-offs. Here's the first one.

anyzero = any([a;b] == 0)
a(anyzero) = []
b(anyzero) = []

anyzero = 0 1 0 1 1 1 0 1
a = 1 9 49
b = 1 3 7

This algorithm combines the two arrays into one, a potentially costly move if the arrays are large. Then check for values that equal zero. And finally, check columnwise, using the function any, to identify the columns that have at least one zero. Finally, use this array of logical indices to delete the appropriate elements of a and b.

Second Algorithm

This algorithm (courtesy of Mirek L. in this post doesn't suffer from combining the two arrays.

x1 = a(a.*b ~= 0)
y1 = b(a.*b ~= 0)

x1 = 1 9 49
y1 = 1 3 7

But it calculates the same temporary array twice (and it's the size of one of the vectors). To be able to recalculate the temporary array this way, I can't overwrite the initial arrays as you see in the first algorithm. And finally, is there is a NaN or Inf corresponding to a 0, this algorithm won't find it.

Always Tradeoffs

There are always tradeoffs to make like the ones I mention here, at least when I program. How do you choose which tradeoffs to make? Which one would you choose here? Or would you choose an entirely different algorithm (which I hope you'll post). Let us know here.

Get the MATLAB code

Published with MATLAB® 7.9

This happens to me some times... especially with Simulink models. I want to share with you two Simulink tips that I wish everyone knew.

Tip: Navigating your model – window reuse, and escape.

I spend much of my day looking at models I did not build. Finding your way around large models can be slow due to the many layers of subsystems between the top of the model and the leaf component you are working on. There are two parts to this tip.

Part one is setting window reuse. Make sure the model is set for window reuse. I rarely need to look at two different systems at the same time, so my preference is to set Simulink to reuse the windows as I navigate the diagram. A close alternative is to use mixed.

Part two is using the escape key. Diving down through layers of a model is as easy as double clicking on a subsystem. What do you do when you want to go back up a level? While you can reach for the arrows on the toolbar to go back, or up a level, I use the escape key. Escape will bring you to the level above the current level. This even works if you have opened a reference model, Stateflow chart, Embedded MATLAB function blocks and block dialogs!

What do you know?

What accelerators do you use to work more efficiently? What do you yell when back-seat driving? Leave a comment here and tell me about it.

I like his slow, clear, methodical presentation with great visualizations. It is the first time I have deeply understood some of the volume visualization techniques we have.

• 1 of 9 Definitions for scalar and vector fields.
• 2 of 9 Examples of scalar and vector fields (temperature in a room vs air currents)
• 3 of 9 Displays scatter3 and slice plots.
• 4 of 9 Displays contourslice and isosurface.
• 5 of 9 Making a 3-d plot ‘pretty’ with lighting, shading, interpolation, etc…

If you’re like me, you probably used to publish to doc and then use Google docs to convert it to a PDF. Well now you can go to PDF directly, and get a higher quality document than you would by going through Word and then to pdf.

That’s pretty much the whole peanut butter sandwhich right there. The easiest way to set this up is through a Publish Configuration.

Here is an image of the output of the sine wave publishing demo (click to see a larger version):

.

You can also watch this lovely video on how this new feature works.

However, we can see that on some of the boards, the winning entry did significantly better. The boards that it won on were those with the large valued 80’s randomly around the board.

Surprising to me, the 1000 node solver did noticably better on a couple of the tall skinny boards like this:

That leaves me wondering if someone could have done a quick check to see if the board had 30 colors or so, and then tried the simpler solver. It looks like this would have made some significant gains… A good contest, congratulations to all that participated.]]> http://feedproxy.google.com/~r/mathworks/pick/~3/QzFwQb0PbX8/ Jiro's pick this week is PeakFinder by Nate Yoder. "What? Another peak finder?" you might say. Some of you may classify this as one of those utilities that has been created by many people over the years, like sudoku and waitbar. Well, [...] http://blogs.mathworks.com/pick/2009/11/13/this-peaks-my-interest/ Fri, 13 Nov 2009 05:46:00 -0800

Jiro's pick this week is PeakFinder by Nate Yoder.

"What? Another peak finder?" you might say. Some of you may classify this as one of those utilities that has been created by many people over the years, like sudoku and waitbar. Well, peak finding happens to be something dear to my heart.

I have been using MATLAB for almost 10 years since my first year of graduate school. I initially learned by trying to decipher my advisor's code. One day, I was struggling to write some code for finding peaks in my data.

% Sample data
t = 0:0.01:10;
x = sin(2*t) - 3*cos(3.8*t);

That's when my advisor showed me his code:

dx = diff(x); % get differences between consecutive points
pkIDX = (dx(1:end-1) >= 0) & (dx(2:end) < 0); % look for slope changes
pkIDX = [dx(1)<0, pkIDX, dx(end)>=0]; % deal with edges
plot(t, x, t(pkIDX), x(pkIDX), 'ro');

This was an eye-opener and was the moment I experienced the power of vector operation for the first time. The way I code in MATLAB had changed from that point on. ... So when I see "peak finding", it brings back memories.

There are quite a few File Exchange entries for finding peaks (and valleys), including two previous POTW selections: FPEAK and EXTREMA. But I really like peakfinder by Nate. Not only does his code deal with noisy data (my algorithm above will be useless if the signal is noisy), but also his coding practice is quite solid. He has a great help section, robust error-checking of input arguments, and variable input and output arguments for ease of use.

xNoise = x + 0.3*sin(40*t); % add a few more bumps
peakfinder(xNoise);

I looked through a few peak finding entries, but I'm sure I may have missed some. Feel free to let me know of others you really like here.

Get the MATLAB code

Published with MATLAB® 7.9

After reading last week's post on calculating with empty arrays, one of my colleagues mentioned some other behaviors with empty arrays that have tripped him up in the past. Today I will discuss how empty arrays work in the contexts of flow of control expressions (both conditional and looping, i.e., if and while) and short-circuit operators (i.e., && and | |).

Contents

Empty Arrays in Flow of Control

Let me first start with plain empty arrays in flow of control situations. For example, what will this code do?

 E = []; if E disp('Empty is true') else disp('Empty is false') end

Readers who remember my comment on last week's blog will correctly guess that the empty expression for the if statement is treated as false. Why? The way I think about it is this. If I am looking for locations of some condition in an array, and I don't find them, I end up with an empty output. This very output is the kind of expression I am likely to want to use, somehow, in an if statement. Let's try it to be sure.

E = [];
if E disp('Empty is true')
else disp('Empty is false')
end

Empty is false

The situation gets a bit more complicated if there is a logical expression for the if or while statement that has an empty array as one of its elements. Let me show you what I mean. Paraphrasing the documentation,

 There are some conditions however under which while evaluates as true on an empty array. Two examples of this are

 A = []; while all(A), doSomething, end while 1|A, doSomething, end

Let's see what's going on in each of these examples. In the first one, the function all is being called with an empty input. According to the second reference below (on empty arrays), the function all is one of the functions that returns a nonzero value for empty input. Let's see.

allE = all(E)
allEislogical = islogical(allE)

allE = 1
allEislogical = 1

The way I think about this is that there are no false values in E, hence the true result.

Empty Arrays with Logical Operators

The second expression involves an elementwise logical operator ( | ). In this case, the first part of the expression, 1, is true, so the second part, after the elementwise or, is never evaluated. So the fact that an empty result returns false never comes into play here. Why? Because & and | operators short-circuit when and only when they are in the context of if or while expressions. Otherwise, the elementwise operators do not short-circuit.

In contrast, the logical operators, && and | |, always short-circuit, regardless of context.

Short-circuit Logical Operators (| | and &&)

The next important idea to remember is that the short-circuit logical operators expect scalars as the inputs for the expressions. This means that an empty array, not being a scalar, may cause you some grief if you are unprepared for that situation. Let me show you what I mean. Compare the following 2 code snippets.

true || E

ans = 1

try E || true
catch ME disp(ME.message)
end

Operands to the || and && operators must be convertible to logical scalar values.

In the second snippet, the expression E || true

produced an error, because E isn't a scalar value. Once the error occurs, the second operand is never evaluated. Contrast that with the snippet, where the first input evaluates to true. Short-circuiting then takes over and the second operand, which would cause an error in this context, is never evaluated.

Examples

Here are a few more code examples to help you see the patterns. Try to figure out the answers before reading the results.

if [] disp('hello')
else disp('bye')
end

bye

true | []

ans = []

[] | true

ans = []

true || []

ans = 1

try [] || true
catch ME disp(ME.message)
end

Operands to the || and && operators must be convertible to logical scalar values.

if true | [] disp('hello')
else disp('bye')
end

hello

if [] | true disp('hello')
else disp('bye')
end

bye

if true || [] disp('hello')
else disp('bye')
end

hello

try if [] || true disp('hello') else disp('bye') end
catch ME disp(ME.message)
end

Operands to the || and && operators must be convertible to logical scalar values.

References

Here are a bunch of references to the MATLAB documentation where all of this information is covered.

Empty Thoughts?

The behaviors with empties in MATLAB are, I believe, consistent and useful. Nonetheless, the behaviors have lots of details to master and can be confusing. If you have any thoughts on the matter, please respond here.

Get the MATLAB code

Published with MATLAB® 7.9

Yesterday I posted that I was looking for a replacement for the term truecolor. (I won't repeat the explanation here; take a look at the original post.) Quite a few readers posted interesting and thoughtful ideas.

Gene commented and Rob sent me e-mail about the use of the term truecolor in remotely sensed imagery. I had been thinking about the term as defining a form of representation: each pixel is a vector of color-space component values. They pointed out to me that a "truecolor image" in remote sensing has a more specific meaning: it is a three-band image in which the bands contain data from the red, green, and blue portions of the visible spectrum (in that order).

That caused me to rethink things a little bit. If I'm concerned about the distinction between different kinds of representation, then I can talk about a color image as being multichannel or indexed. That leaves us able to use truecolor to refer a specific kind of multichannel color image. And that has the advantage of leaving our existing doc mostly alone.

What do you think?

It interests me that my posts about terminology questions always seem to draw a lot of comment. And I appreciate that each time I do it, you teach me good stuff.

One of my favorite terminology stories is when Prof. Ron Schafer showed his class a "Sniglet." (Sniglets, which are made-up words with plausible-sounding definitions, were popular in the 1980s.) Since we were a digital signal processing class, we especially appreciated the definition of the Sniglet point blimfark - the point at which the stagecoach wheels in the movie start to look like they're going backward (otherwise known as aliasing).

Get the MATLAB code

Published with MATLAB® 7.9

The Image Processing Toolbox has terminology conventions for four different image types:

You'll also frequently see the term RGB image, which is shorthand for a truecolor image using an RGB color space. (See the User Guide section on image types.)

Over the last few years I've become increasingly dissatisfied with the term truecolor.

Wikipedia has a brief article on truecolor. The article says the term describes a "method of representing and storing graphical image information." It goes on to say that a truecolor representation is one that either:

(a) can represent a large number of colors, typically at least 2^24.

(b) does not use a color look-up table ("colormap" in MATLAB terminology)

Curiously, the article refers to (a) and (b) as "equivalent" statements.

Defining an image representation method in terms of whether it represents a lot of colors is too vague to be very useful in my view. Defining a representation in terms of a characteristic it does not possess (that is, a truecolor representation does not use a color look-up table) is similarly vague.

Also, as I learn more about color science I've grown uncomfortable with the idea that any computer or mathematical representation of color can really be called "true color."

Here's the definition I really want to see:

[blank] is a method of representing image information in which each image pixel is stored as a vector of color-space component values.

But what's a good term to go along with this definition? Help me fill in the blank by commenting with your thoughts.

Get the MATLAB code

Published with MATLAB® 7.9

I like his slow, clear, methodical presentation with great visualizations. It is the first time I have deeply understood some of the volume visualization techniques we have.

• 1 of 9 Definitions for scalar and vector fields.
• 2 of 9 Examples of scalar and vector fields (temperature in a room vs air currents)
• 3 of 9 Displays scatter3 and slice plots.
• 4 of 9 Displays contourslice and isosurface.

I received the following question recently:

I'd like to be able to establish an image size that will be recognized by PDFLATEX when I compile my document. Often, I size an image in MATLAB only to have it occupy more than a page after compiling in PDFLATEX. I know I can use imresize, but I'd like to resize a PNG so that it is exact 2 inches wide, so I can get some consistency of sizing in my document.

It occurred to me that this is a common use case in publishing articles, books, etc: "I need this image to print exactly 3 inches wide in my document so it fits nicely in the column." The document might be LaTeX as above, or a Word file, or something else.

In publishing, TIFF is usually the format of choice. The MATLAB function imwrite can include extra information in the TIFF file to control how wide an image will be printed when included in a document application. This extra information is provided in the form of the 'Resolution' parameter, which gives pixels per inch. (In this context the term dots per inch is also used.)

I wrote about how to use the 'Resolution' parameter way back in 2006, but at the time I didn't explain how to achieve a certain desired printed width.

When publishers specify a certain resolution in pixels per inch (dots per inch), and the image should be printed at a certain width, then generally the image has to be resized to meet both criteria. That is, the number of image pixels may have to be changed.

To help users prepare such image files I wrote the MATLAB function imwritesize, which you can find on the MATLAB Central File Exchange.

In the most simple usage, imwritesize will create a TIFF file or PNG file for you so that the image will have the desired width in a document application.

rgb = imread('peppers.png');
size(rgb)

ans = 384 512 3 

Notice the original image has 512 pixels per row.

Now write the image out using imwritesize:

imwritesize(rgb, 'peppers_3in.tif', 3);

The extension of the output filename determines the image file format. To write out a PNG file instead of TIFF, just use the extension '.png'.

imwritesize(rgb, 'peppers_3in.png', 3);

With this usage, the number of pixels in the image is not changed. imwritesize just saves the image into the file with the right resolution parameter to achieve the desired width;

info = imfinfo('peppers_3in.tif');
image_pixels_per_row = info.Width

image_pixels_per_row = 512 

document_width_in_inches = image_pixels_per_row / info.XResolution

document_width_in_inches = 2.994152046783626 

The width is not exactly 3 inches because the resolution value in a TIFF file is restricted to be an integer number of pixels per inch.

Now suppose you want the document width of the image to be 3 inches and the document image resolution to be 300 dpi? Then you specify 300 as an additional argument to imwritesize:

imwritesize(rgb, 'peppers_3in_at_300dpi.tif', 3, 300);

With this usage, the number of image pixels is changed by calling imresize, an Image Processing Toolbox function.

info2 = imfinfo('peppers_3in_at_300dpi.tif');
image_pixels_per_row = info2.Width

image_pixels_per_row = 900 

document_width_in_inches = image_pixels_per_row / info2.XResolution

document_width_in_inches = 3 

I apologize to those of you living in metric land. I wanted to keep the interface simple so I did not include units options. You could perform a metric conversion in the call to imwritesize, like this:

imwritesize(rgb, 'peppers_7cm.tif', 7/2.54)

Or you can modify the code in imwritesize to suit yourself. I tried to keep the code very straightforward so that users could learn from it.

I hope you find this MATLAB Central File Exchange contribution useful. If you want to use this function and you already have MATLAB R2009b, you should consider taking this chance to experiment with the new MATLAB Desktop / File Exchange integration.

Get the MATLAB code

Published with MATLAB® 7.9

The Plot Selector is available via the    button in the Workspace Browser.

One of our overall goals with user interface design in MATLAB is to help you stay focused on what your doing. To do this, we need to offer you the right information at the right time. In the Plot Selector, this means showing you a graphic of what the plot might look like, as well as more detailed information about the what each plot does. We also show you details about a plot when you hover over it in the Plot Selector, which helps keep you “in flow”:

We also wanted to help streamline your workflow. If there are plots that you frequently use with a particular type of data, you can select the    button and promote that plot to the “Favorites” section, which appears at the top of the Plot Selector.

Finally, the Plot Selector now integrates with toolboxes. So if there is a plot that applies to your selected data, it will show up in the Plot Selector. For example, my Plot Selector shows plots from the Statistics Toolbox, because I have that toolbox installed:

We think this redesign will make it easier for you to plot your data and help keep you focused on the task at hand. What do you think?

I like his slow, clear, methodical presentation with great visualizations. It is the first time I have deeply understood some of the volume visualization techniques we have.

• 1 of 9 Definitions for scalar and vector fields.
• 2 of 9 Examples of scalar and vector fields (temperature in a room vs air currents)
• 3 of 9 Displays scatter3 and slice plots.

Many of us who have used or participated in comp.soft-sys.matlab over the years--particularly those of us who have had occasion to solve image processing problems--have come to appreciate Image Analyst's thoughts on relevant matters.

Recently, Image Analyst had occasion to share his first file through the File Exchange--a demo tutorial on blob analysis. In a nice, well-documented bit of code, IA steps us through an approach to segmenting, and determining the properties of, some objects in an image. In this case, the image is a sample ('coins.png') that ships with the Image Processing Toolbox.

IA's code shows how one might segment objects of interest (coins) from the background, then use regionprops (my favorite IPT function!) to differentiate nickels from dimes, and dull dimes from shiny ones:

This is a nice demo--very informative, and certainly worth a read. Two thoughts: 1) IA's code uses bwlabel to calculate a connected components matrix of the image as a precursor to calling regionprops. As of R2009a, the new IPT function bwconncomp replaces bwlabel as the preferred approach; it uses significantly less memory, and can be markedly faster! Also, 2) IA shows how one can extract the specific pixels (PixelIdxList) associated with each object of interest, then calculate statistics on those pixel intensities to differentiate shiny from dull objects. Note that the fourth syntax of regionprops in the documentation enables one to avoid this step, and instead to operate directly on the original intensity image. Using this syntax, one can calculate directly the MIN, MAX, or MEAN intensitities--or even the weighted centroids-- of each blob in the image.

Nice work, Image Analyst!

Comments?

Get the MATLAB code

Published with MATLAB® 7.9

Aarti,
I would be interested in the effect on RTW generated code for variable size signals. Could you show some examples?
-Han

Here is Aarti's response.

Hi Han,

Thank you for your comment. In the case of a variable size signal, the generated code allocates the maximum possible size for the input/output variables.

This allows signal sizes to vary during execution (as opposed to being hard-coded after model compilation). The generated code also propagates signal sizes through the model and accordingly assign the required dimension to signals. The algorithm code only needs to operate on the portion of memory required (thus saving execution time).

The following model uses the Switch Block to change the size of its output signal.

The generated code looks like this:

 /* Switch: ' /Switch' incorporates: * Inport: ' /In1' * Inport: ' /In2' * Inport: ' /In3' */ if (In2 >= 0.0) { model_XDim = 1; X[0] = In1; } else { model_XDim = 5; for (tmp = 0; tmp < 5; tmp++) { X[tmp] = In3[tmp]; } } /* Gain: ' /Gain' */ model_YDim = model_XDim; loop_ub = model_XDim - 1; for (tmp = 0; tmp <= loop_ub; tmp++) { Y[tmp] = 2.0 * X[tmp]; }

In the generated code, notice how the variable model_Xdim has the lower and upper bound pre-allocated as 1 and 5, 5 being the width of the 3rd Inport block. Using these values, the loop_ub variable for the Switch block is calculated.

Thanks!

Aarti

Is this the code you expected? Leave a comment here and tell me about it.

MATLAB has had empty arrays since before I started using the program. When I started, the only size empty array was 0x0. When version 5 was released, empty arrays came along for the N-dimensional ride and got more shapely.

Contents

Even relatively simple expressions involving empty arrays cause confusion from time to time, especially in concert with other rules in MATLAB (such as NaN values usually propagate from inputs to outputs). Let's play around a little with some empty arrays to get some insight.

From the Newsgroup

This post on the MATLAB newsgroup motivated me to talk about empty arrays. Here's is an excerpt from the original post:

 I knew that Nan+4 = NaN, but why is []+4 = [] ? Is there more 'black hole behaviour' I should know about?

Dimensions Matter in MATLAB

Dimensions matter in MATLAB and you will get error messages when dimensions don't agree. Early on, we found it was convenient to treat scalars as an exception with operators (e.g., ,.) and to treat them as if they were expanded to the size of the other operand. So

rand(3,3) + pi

ans = 4.10648118878907 4.09875960183274 3.28347899221701 3.29920573526734 3.62696830231263 3.56335393621607 4.11218543535041 3.94187312247859 4.05732817877886

adds the value pi to the random 3x3 just created. It's as if a 3x3 constant array filled with the value pi was created and added elementwise to the other array.

So what does that mean for an empty operand? Its size has at least one 0 value. So MATLAB expands pi in this expression [] + pi to be the same size as [] (which happens to be 0x0 here). When that happens, MATLAB creates a second empty array, and then adds the two empty arrays. Hence we get

[] + pi

ans = []

returing an empty output.

MATLAB applies the scalar expansion rule to operators. So, for example, size(anything+scalar) is size(anything). As a logical but sometimes surprising consequence, empty arrays often (but not always) propagate through calculations. When doesn't that happen? With some functions where mathematically logical analysis demands different results.

sum([])

ans = 0

prod([])

ans = 1

So, why is the sum zero and the product 1? Because they are the identity elements (as in group theory) for sum and product respectively. Think about how to start the computation for a sum or a product and how you would initialize the first value. That's the value given before adding or multiplying any of the array elements, hence the values 0 and 1 respectively.

Empty Array Shapes

Empty arrays can be N-dimensional, and don't need all dimensions to be 0. However, they still must obey the rules about dimensions needing to agree. There are consequences that may surprise you, but they do follow logically. Here's an example of trying to add two empty arrays, ending up in an error!

a = zeros(0,1)
b = zeros(1,0)
try a+b
catch MEplus fprintf('\n') disp(MEplus.message)
end

a = Empty matrix: 0-by-1
b = Empty matrix: 1-by-0 Matrix dimensions must agree.

Reference

For more information about empty arrays, check out this page in the documentation.

Got an Empty Question?

Got any empty questions (really, questions about empty!)? Or comments? Post them here.

Get the MATLAB code

Published with MATLAB® 7.9

Get all the information here.

Our more faithful blog readers might have a head start on this puzzle…

Finding four connected regions.

A puzzler about the game that inspired this contest.

Winning entries to the above puzzler.]]> Topic: Puzzler http://feedproxy.google.com/~r/SteveOnImageProcessing/~3/Snab-x9cEHk/ A friend from my grad school days (back in the previous millenium) is an electrical engineering professor. Students in his class recently asked him why the conv function is not implemented using FFTs. I'm not on the team responsible for conv, [...] http://blogs.mathworks.com/steve/2009/11/03/the-conv-function-and-implementation-tradeoffs/ Tue, 03 Nov 2009 06:56:58 -0800

A friend from my grad school days (back in the previous millenium) is an electrical engineering professor. Students in his class recently asked him why the conv function is not implemented using FFTs.

I'm not on the team responsible for conv, but I wrote back with my thoughts, and I thought I would share them here as well.

Let's review the basics. Using the typical convolution formula to compute the one-dimensional convolution of a P-element sequence A with Q-element sequence B has a computational complexity of . However, the discrete Fourier transform (DFT) can be used to implement convolution as follows:

1. Compute the L-point DFT of A, where .

2. Compute the L-point DFT of B.

3. Multiply the two DFTs.

4. Compute the inverse DFT to get the convolution.

Here's a simple MATLAB function for computing convolution using the Fast Fourier Transform (FFT), which is simply a fast algorithm for computing the DFT.

type conv_fft

function c = conv_fft(a, b) P = numel(a);
Q = numel(b);
L = P + Q - 1;
K = 2^nextpow2(L); c = ifft(fft(a, K) .* fft(b, K));
c = c(1:L); 

Note that the code uses the next power-of-two greater than or equal to L, although this is not strictly necessary. The fft function operates in time whether or not L is a power of two.

The overall computational complexity of these steps is . For P and Q sufficiently large, then, using the DFT to implement convolution is a computational win.

So why don't we do it?

There are several technical factors. Let's look at speed, exact computation, and memory.

Speed

One factor is that DFT-based computation is not always faster. Let's do an experiment where we compute the convolution of a 1000-element sequence with another sequence of varying length. (Get the timeit function from the MATLAB Central File Exchange.)

x = rand(1, 1000);
nn = 25:25:1000; t_normal = zeros(size(nn));
t_fft = zeros(size(nn)); for k = 1:numel(nn) n = nn(k); y = rand(1, n); t_normal(k) = timeit(@() conv(x, y)); t_fft(k) = timeit(@() conv_fft(x, y));
end

plot(nn, t_normal, nn, t_fft)
legend({'Normal computation', 'FFT-based computation'})

For sequences y shorter than a certain length, called the cross-over point, it's quicker to use the normal computation.

Exact computation

A second consideration is whether the computation is subject to floating-point round-off errors and to what degree. There are applications, for example, where the convolution of integer-valued sequences is computed. For such applications, a user would reasonably expect the output sequence to be integer-valued as well.

To illustrate, here's a simple function that computes n-th order binomial coefficients using convolution:

type binom

function c = binom(n) c = 1;
for k = 1:n c = conv(c, [1 1]);
end 

binom(7)

ans = 1 7 21 35 35 21 7 1 

I wrote a variation called binom_fft that is the same as binom except that it calls conv_fft.

format long
binom_fft(7)

ans = Columns 1 through 4 1.000000000000000 6.999999999999998 21.000000000000000 35.000000000000000 Columns 5 through 8 35.000000000000000 21.000000000000000 7.000000000000000 0.999999999999996 

Whoops! What's going on? The answer is that the FFT-based implementation of convolution is subject to floating-point round-off error.

I imagine that most MATLAB users would consider the output of binom_fft to be wrong.

Memory

The last technical consideration I want to mention is memory. Because of the padding and complex arithmetic involved in the FFT computations, the FFT-based convolution implementation requires a lot more memory than the normal computation. This may not often be a problem for one-dimensional computations, but it can be a big deal for multidimensional computations.

Final thoughts

The technical considerations listed above can all be solved in principle. The implementation could switch to using the normal method for short or integer-valued sequences, for example. And there are FFT-based techniques such as overlap-and-add to reduce the memory load.

But the problem can get quite complicated. Testing floating-point values to see if they are integers, for example, can be slow. Also, I suspect (but have not checked) that a multithreaded implemention of the normal computation will take advantage of multiple cores better than a multithreaded FFT-based method. That would change the cross-over point between the two methods. And the exact cross-over point will vary from computer to computer, making it likely that our implementation would be somewhat slower for some people for some problems.

Overall, my inclination would be to provide FFT-based convolution as a separate function rather than reimplementing conv. And that's what we've done. See the function fftfilt in the Signal Processing Toolbox.

Do you disagree with this approach? Post your comment.

Get the MATLAB code

Published with MATLAB® 7.9

My argument on the Ultimate Frisbee field was

“Imagine the two Frisbee come up heads 99% of the time, what do you choose?”

“Same!”

“What about 98%?”

“Same”

“This logic holds all the way through, even to 50.00001. At 50% it just does not matter, so always choose same.”

The more rigorous and MATLAB proofs were more along these lines:

This was a GUI that you watched as it went through a Monte Carlo simulation. Thanks Richard

Arman did a more traditional proof, citing Wikipedia

Let p be the probability of having tails.
The probability of having "different" is p(1-p)+(1-p)p.
The probability of having "same" is p^2+(1-p)^2. From the arithmetic mean geometric mean inequality, we know that p^2+(1-p)^2 >= 2*p(1-p) and equality holds if p=1-p which means p=1/2. Therefore “same” is better choice for any p value.

There were many variations on this plot:

I liked Zane’s here because it shows how much better off you are with ’same’ for each value of unfairness in the coin.

Christopher won the challenge by going to the next level, pointing out that you could make these unfair Frisbees almost fair by flipping three and calling for an odd number (1 or 3) vs even number (0 or 2) of heads.

Thank you everyone for playing, and finally putting this question to rest! Now the ethical question, knowing the coin flip is unfair, is it in the Spirit of The Game to let the other guy choose? Should we move to Christopher’s method of flipping three Frisbees?

Frisbee® is a Registered Trademark of © 2004 Wham-o Inc. All Rights Reserved. ]]> http://feedproxy.google.com/~r/mathworks/desktop/~3/DdJAr35ePFc/ Everywhere you look, searching is becoming the standard way of accessing information, and our documentation is no exception. In MATLAB R2009b we’ve updated the Help browser’s search functionality to help you find what you’re looking for more quickly. In this post I’ll give you a quick tour of the changes. First, let’s take a [...] http://blogs.mathworks.com/desktop/2009/11/02/help-browser-search-updates/ Mon, 02 Nov 2009 06:08:03 -0800 Everywhere you look, searching is becoming the standard way of accessing information, and our documentation is no exception. In MATLAB R2009b we’ve updated the Help browser’s search functionality to help you find what you’re looking for more quickly. In this post I’ll give you a quick tour of the changes.

First, let’s take a look at the R2009a search results display. Using the default Help browser layout, here are the results of a search for “fft” with all MathWorks products installed:

We weren’t happy that this display does not give you an easy way to differentiate among the top three results. They’re function reference pages from different products, but you’d never know it because the Product column is scrolled off the right side of the results area. If you want to see what products the results are in (or sort by product), you need to scroll over and lose sight of the title. There are a few other issues that we fixed, but that’s the big one.

Now lets see how the same search looks in R2009b:

The first thing you might notice is that each result takes up a lot more vertical space, so you don’t see as many results. That’s true, but we think the new features are worth the tradeoff - we’re going for quality over quantity in the results. Let’s take a quick look at what we’ve changed:

• There’s no awkward horizontal scrolling in the search results area, ever.
• We’re using an icon to display the type of result - these icons are the same ones that are used in the top level of the new table of contents.
• Demo search results are now listed together with the documentation results.
• Each result includes some snippets from the result page, which shows the context in which the search term is used.
• For reference pages, we’re including the summary line (for example, in the top result above we’re displaying “Discrete Fourier transform”).
• The sorting options have changed.

About those sorting options… In R2009b sorting is all about organizing your search results. Now that we categorize results by type, that was a natural addition to the sort options. We also felt that the old options to sort by title or section didn’t provide a lot of value, so we removed them. To further emphasize the notion that sorting helps you organize your results, when you sort by type or product we group the results into collapsible sections. That way you can easily show or hide entire groups of results that you find useful or not.

We hope that these new features will help you find what you’re looking for when you search our documentation. Give them a shot and let us know what you think.

I like his slow, clear, methodical presentation with great visualizations. It is the first time I have deeply understood some of the volume visualization techniques we have.

• 1 of 9 Definitions for scalar and vector fields.
• 2 of 9 Examples of scalar and vector fields (temperature in a room vs air currents)

Bob's pick this week is Allstats by Francisco de Castro.

The file is simple enough. Given a data set,

x = randn(1000,1);
hist(x,100)

allstats returns a list of statistical values.

myStats = allstats(x)

myStats = min: -3.1289 max: 2.9371 mean: -0.06815 std: 1.0019 mode: -3.1289 q2p5: -1.9519 q5: -1.7128 q25: -0.73464 q50: -0.072006 q75: 0.55077 q95: 1.6351 q97p5: 1.8844

The mean should be close to zero,

myStats.mean

ans = -0.06815

and the standard deviation should be close to one.

myStats.std

ans = 1.0019

How convenient.

As it turns out, this month the File Exchange recently celebrated a major milestone. Allstats has the honor of being the official 10,000-th submission. Congratulations to Francisco and every contributor who made this possible! Growth of the File Exchange has been absolutely amazing.

If only my retirement account was that impressive! (sigh)

Comments?

Get the MATLAB code

Published with MATLAB® 7.9

Governor Patrick speeking about the value of science technology engineering and math (STEM) education during his visit to The MathWorks on October 14, 2009. Photo by Jeff Newcum

On October 14^th, 2009 Massachusetts Governor Deval Patrick signed an executive order to establish the Science Technology Engineering and Math (STEM) Advisory Council. The MathWorks hosted the gathering of local political leaders. MathWorks CEO Jack Little introduced the Lieutenant Governor Timothy Murray and the Governor Deval Patrick to a room filled with MathWorkers. I could describe all the formalities and go into what this means for STEM education in Massachusetts, but other media sources covered those topics (like EDN, Mass High Tech and the Governors official website). Instead I would like to focus on some of the tangents to the main event.

Governor Patrick signing the executive order to establish the STEM Advisory Council. Photo by Jeff Newcum

Talking to the Governor

My fellow blogger, Loren Shure, asked Governor Patrick what he thinks good corporate citizens can do to support STEM education.

Loren Shure expressing her interests in STEM Education to the Governor. Photo by Jeff Newcum

The Governor gave a couple examples of how companies can get involved such as mentoring area students and engaging in student competitions. There already exist many opportunities to do this…

Mentoring

I have known many MathWorkers who volunteer at a local elementary school as math tutors in preparation for standardized tests. The same school has a Lego® Club where some of my colleagues mentor students on building robot using Lego® Mindstorms.

Competitions

In Governor Patrick’s response to Loren, he gave a specific example of a robotics competition, FIRST.

Most people have heard of FIRST (For Inspiration and Recognition of Science and Technology). If you haven’t, browse around the FIRST website for a few minutes and get inspired about the great things available to the next generation of engineers and scientists. They have programs targeted at many different age groups, from the Junior FIRST Lego League for ages 6-9 years all the way up to “the varsity sport for the mind” FIRST Robotics Competition for ages 14 to 18 years.

Targeted toward college students is the EcoCAR Challenge (which I wrote about in a recent post). MathWorks is a sponsor of the competition, and some of my colleagues act at mentors to teams. The goal is to modify GM donate vehicles in an attempt to reduce emissions, minimize fuel consumption AND maintain consumer appeal. Those college students involved are already on their way to careers in engineering.

Another competition I am very excited about is ET Robocon, which MathWorks also sponsors. The site is in Japanese, but you can see videos like this one on YouTube (search for ET Robocon). I see ET Robocon as an embedded software design competition. Teams all start with a standard LEGO® NXTway robot (a two-wheel balancing robot built from LEGOs). They have to develop an autonomous control strategy and implement it to race robot around a pre-set track as fast as possible. Some of my colleagues from Japan developed the balancing algorithm using Simulink and Real-Time Workshop Embedded Coder (available on the File Exchange here). All the teams have to incorporate that balancing software into their larger design. I learned that there are many university teams as well as professional engineers from major companies involved in the competition.

Now It’s Your Turn

Are you a mentor? Are you involved in any of these or other competitions that encourage students to explore STEM fields? Leave a comment here and share your experience.

I made a convincing argument, but I am curious what kind of persuasive MATLAB-based ‘proofs’ can be made. I am offering a MATLAB t-shirt to the most persuasive entry. Use published MATLAB files, GUI’s, MATLAB script or function, whatever you think will be most convincing. Contest ends this time next week.

Assumptions: The Frisbees (or coins) are either ‘heads’ or ‘tails’. The coins may or may not be ‘fair’ (i.e. they might be heads 80% of the time!), however the odds of heads versus tails for the two coins is the same for both coins. Send entries to hull@MathWorks.com (no .rar files please!) (Here is the result of this now closed contest)

Frisbee® is a Registered Trademark of © 2004 Wham-o Inc. All Rights Reserved.]]> http://feedproxy.google.com/~r/mathworks/desktop/~3/W_S6hXl6RiM/ Our friend Yair recently described on his blog how to use the various functionalities of the Editor by accessing its Java components. I imagine for many MATLAB users, especially those not familiar with Java, this is wading into unfamiliar territory. We don’t write very many APIs in Java intended for our users to access, and [...] http://blogs.mathworks.com/desktop/2009/10/26/the-matlab-editor-at-your-fingertips/ Mon, 26 Oct 2009 06:04:55 -0700 Our friend Yair recently described on his blog how to use the various functionalities of the Editor by accessing its Java components. I imagine for many MATLAB users, especially those not familiar with Java, this is wading into unfamiliar territory. We don’t write very many APIs in Java intended for our users to access, and we like to abstract away the implementation components so we can be free to refactor behind the scenes. We’ve been spending time on refactoring projects, and so the Java APIs have been changing quite rapidly.

Over the years we’ve had a lot of requests for programmatic access to various desktop components, and we’re working on a MATLAB API for the Editor. In R2009b, this API is hidden in the product (aka undocumented), but we’re planning on bringing it out in a future release fully supported and documented. The api provides methods to manipulate the text, get information about the buffer, as well as close, save, and open editors. With the object provided users can manage the editor state, write scripts that call their favorite diff tool, open files in other programs, open the folder in the OS, etc.

The 9b version isn’t fully vetted or functional; it’s there to satisfy some back-end requirements. This means I’m officially saying not to use it and don’t complain when things don’t work, but… if you’d like to preview it, give it a go. All of the functionality is part of the editorservices package. A single buffer/file in the Editor is represented by the editorservices.EditorDocument class. These objects are constructed by calling the package functions such as editorservices.new(), editorservices.open(), and editorservices.getActive().

Here is a full list of the package function in MATLAB R2009b.

help editorservices

Contents of editorservices: EditorDocument - Encapsulates all user accessible behavior of the MATLAB Editor
EditorUtils - Static utility methods for editorservices functions
closeGroup - Closes the MATLAB Editor and all open documents.
find - returns an already open EditorDocument for a given file name
getActive - finds the active (topmost) open buffer in the Editor
getAll - Gets all the Editors that are currently open
isOpen - true if the specified file is open in the editor
new - Creates a new buffer, with optional text
open - Opens the MATLAB Editor with the given filename
openAndGoToFunction - open a file in the editor and highlight the indicated function
openAndGoToLine - open a file in the editor and highlight the indicated line

You can try it out now, but keep in mind we’ve already already changed the API, fixed some of the bugs, and enhanced its functionality for its prime-time release, and so any code written with it will likely have to change when we release the documented API.

Please let us know how this new api fits (or doesn’t fit) into your workflows, and what future enhancements you’d like to see and what other Desktop components you’d like to work with programmatically.

I like his slow, clear, methodical presentation with great visualizations. It is the first time I have deeply understood some of the volume visualization techniques we have. Sorry, Dr. H, but I really did not understand Div, Grad, Curl and all of that until Patrick explained it later in this series!

1 of 9 Definitions for scalar and vector fields.

Jiro's pick this week is "Comparison of object oriented code" by our very own Stuart McGarrity.

To some of you, this may be old news, but I know that not everyone is up to date on newer features. The new Object Oriented Programming capability that was introduced in R2008a has been highlighted several times by Loren, Doug, and Steve.

This entry by Stuart provides a nice syntax comparisons between MATLAB and a few of the common object oriented languages (C++, Java, Python, Ruby). Take a look at the published HTML to read about it and get a quick side-by-side comparison of these languages.

Note: as Stuart mentions in the comments, this is a syntax comparison, and it is not meant for showcasing best practices. The documentation is a good place to get such info.

Comments?

Get the MATLAB code

Published with MATLAB® 7.9

A customer recently asked me this question at the MATLAB Virtual Conference.

Contents

Question about Summing Cell Rows

 I was hoping you would cover cells some day. Here is a particular problem I was hoping to have a more elegant solutions for.

 A is a cell that has String (say names) in the first column, Numbers (say scores in tests 1 and 2) in the next two columns. Assume that each cell has only one value. Is there an easier way to calculate, say the sum of the two test scores than a for loop?

Example

Let's make some sample data.

c(1:4,1) = {'Fred' 'Alice' 'Lucy' 'Tom'};
c(1:4,2) = { 90 80 55 102 };
c(1:4,3) = { 43 91 80 44 }

c = 'Fred' [ 90] [43] 'Alice' [ 80] [91] 'Lucy' [ 55] [80] 'Tom' [102] [44]

Answer

To sum the entries in a row for this cell array, I can simply turn the numeric values into a numeric array via comma-separated list notation, and then sum the rows. Let's see the pieces for clarity. Here's the comma-separated list.

c{:,2:3}

ans = 90
ans = 80
ans = 55
ans = 102
ans = 43
ans = 91
ans = 80
ans = 44

Now place the results into a vector.

vec = [c{:,2:3}]

vec = 90 80 55 102 43 91 80 44

Reshape the vector appropriately into a matrix.

array = reshape(vec,[],2)

array = 90 43 80 91 55 80 102 44

Now sum the results along the rows.

tot = sum(array,2)

tot = 133 171 135 146

Or, in one bigger statement, try this.

tot = sum(reshape([c{:,2:3}],[],2),2)

tot = 133 171 135 146

Cell Array Questions

Do you use cell arrays? Can you do what you want without undo contortions? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.9

The R2009b release of MATLAB contains a new Tiff class. The primary purpose of this class is to provide lower-level access to creating and modifying image data and metadata in an existing TIFF file.

Several customers have asked for the ability to embed an ICC profile into a TIFF file. The Image Processing Toolbox function iccread can read a profile embedded in a TIFF file, but iccwrite can only write a stand-alone profile file.

Here is code using the new Tiff class to embed a profile in an existing TIFF file. Let's start by rewriting one of the Image Processing Toolbox sample PNG image files as a TIFF file.

rgb = imread('peppers.png');
imwrite(rgb, 'peppers.tif');
s = dir('peppers.tif')

s = name: 'peppers.tif' date: '20-Oct-2009 09:14:29' bytes: 593880 isdir: 0 datenum: 7.3407e+005 

Now let's embed the sample profile sRGB.icm into the TIFF file we just made.

Step 1. Read in the raw bytes of the profile file.

fid = fopen('sRGB.icm');
raw_profile_bytes = fread(fid, Inf, 'uint8=>uint8');
fclose(fid);

Step 2. Initialize a Tiff object using 'r+' mode (read and modify).

tif = Tiff('peppers.tif', 'r+')

tif = TIFF File: 'peppers.tif' Mode: 'r+' Current Image Directory: 1 Number Of Strips: 77 SubFileType: Tiff.SubFileType.Default Photometric: Tiff.Photometric.RGB ImageLength: 384 ImageWidth: 512 RowsPerStrip: 5 BitsPerSample: 8 Compression: Tiff.Compression.PackBits SampleFormat: Tiff.SampleFormat.UInt SamplesPerPixel: 3 PlanarConfiguration: Tiff.PlanarConfiguration.Chunky Orientation: Tiff.Orientation.TopLeft 

Step 3. Embed the profile bytes as a TIFF tag.

tif.setTag('ICCProfile', raw_profile_bytes);

Step 4. Tell the Tiff object to update the image metadata in the file.

tif.rewriteDirectory();

Step 5. Close the Tiff object.

tif.close();

Now the TIFF file contains the profile. Notice the file size has changed.

s = dir('peppers.tif')

s = name: 'peppers.tif' date: '20-Oct-2009 09:14:30' bytes: 597828 isdir: 0 datenum: 7.3407e+005 

And we can read in the profile using iccread.

p = iccread('peppers.tif')

p = Header: [1x1 struct] TagTable: {17x3 cell} Copyright: 'Copyright (c) 1999 Hewlett-Packard Company' Description: [1x1 struct] MediaWhitePoint: [0.9505 1 1.0891] MediaBlackPoint: [0 0 0] DeviceMfgDesc: [1x1 struct] DeviceModelDesc: [1x1 struct] ViewingCondDesc: [1x1 struct] ViewingConditions: [1x1 struct] Luminance: [76.0365 80 87.1246] Measurement: [1x1 struct] Technology: 'Cathode Ray Tube Display' MatTRC: [1x1 struct] PrivateTags: {} Filename: 'peppers.tif' 

It would be logical to enhance iccwrite to make this easier for you. We'll look into that, although I'm not sure when that might happen.

Get the MATLAB code

Published with MATLAB® 7.9

Here at The MathWorks we’ve been using and testing MATLAB against pre-releases of Windows 7 for some time now. And we know we’re not the only ones, as we’ve seen thousands of MATLAB activations under Windows 7, even though Windows 7 will not be formally release until the end of this week! I’m happy to report that we’ve fully tested and are now officially supporting the 32-bit and 64-bit versions of R2009a (including Student Version) and R2009b. You can see read our official statement here, and we’ve updated our System Requirements pages in the last several days accordingly.

We expect a smooth MATLAB experience when using these modern releases of MATLAB on Windows 7. We expect older versions of MATLAB to work as well (see our statement for potential gotchas), but is not a supported configuration. If you’re using R2009a, we did find one glitch unique to Windows 7 that was fixed for R2009b: If you shell out to the console with the ! shell escape “operator” in MATLAB, Ctrl+C often will not break out of an operation should you choose to abort it. There is no work-around beyond “don’t do that”. Again, this was resolved for 9b and seems to impact Windows 7 only.

Here are two nice usability improvements that I thought I would share:

1. If you mouse over the MATLAB icon in the Windows taskbar, you’ll get thumbnails of all of your MATLAB windows. This may be helpful when you need to locate an undocked Figure window of a GUI that got itself stacked under the MATLAB Desktop or another application.
   
   
2. The “Windows” key on your keyboard will pop-up the Start menu, which you can quickly filter by typing a character or two in the name of the app you wish to launch. No more hunting through the Program Files hierarchy! For me, Windows->”fi” is enough to find Firefox, Windows->”it” is enough to find iTunes, and (of course) Windows->”ma” finds MATLAB. This is great way to find and launch frequently-used applications while keeping your hands on the keyboard. (And, okay, I admit this feature was introduced in Windows Vista, but it is just too good not to share!)

What are your plans for migrating to Windows 7 (or are you already there)? Any productivity tips for fellow MATLAB users?

-by Ken Atwell, The MathWorks

We've been working for a while now to make Image Processing Toolbox functions run faster. The R2009b release notes mention several performance improvements. We've gotten some feedback, though, that our release notes are pretty vague about the improvements. I can't argue with that impression. We tend to be vague because performance optimization is a very complex topic, and it can be quite difficult to characterize performance changes in a way that is brief, understandable, and accurate for every user's own hardware and data.

But I've decided to start posting more detailed information here about the performance improvements. I have more flexibility (and room!) here than we have with the release notes.

Today I'll tackle imreconstruct, which performs morphological reconstruction. Reconstruction is a very useful operation that I've written about here before. For example, see my post from last year on opening by reconstruction. Several other Image Processing Toolbox functions call imreconstruct, including imclearborder, imfill, imhmax, imhmin, imextendedmax, imextendedmin, and imimposemin.

Let me use the opening by reconstruction example as a benchmark case.

url = 'http://blogs.mathworks.com/images/steve/2008/book_text.png';
text = imread(url);
imshow(text, 'InitialMagnification', 25)
title('918-by-2018 image displayed at 25% magnification')

The example task was to find letters containing vertical strokes by eroding with a vertical structuring element and then performing reconstruction.

se = strel(ones(51, 1));
marker = imerode(text, se);
text2 = imreconstruct(marker, text);
imshow(text2, 'InitialMagnification', 25)
title('Output image displayed at 25% magnification')

So how long does that call to imreconstruct take in R2009b? I'll use my function timeit, which you can download from the MATLAB Central File Exchange.

timeit(@() imreconstruct(marker, text))

ans = 0.0241 

That time is about 45 times faster than the same operation performed in R2009a. Note that I'm running on two-core computer; the improved imreconstruct is multithreaded, so the performance improvement would be greater on a four-core computer, for example.

Now let's time gray-scale reconstruction. I'll make a 1024-by-1024 test image and compute a marker image by subtraction. This kind of operation is often used to suppress small peaks in an image.

I = repmat(imread('rice.png'), 4, 4);
marker = I - 20;
timeit(@() imreconstruct(marker, I))

ans = 0.0201 

This time is about 30 times faster than R2009a, again running on my two-core laptop.

Now for some key caveats you should know. For now, the performance improvements described here only work for 2-D inputs that are uint8, uint16, or single, and only when the specified connectivity is 4 or 8. We'll be working in the future to extend the speed improvements to other inputs.

Get the MATLAB code

Published with MATLAB® 7.9

Depending on target ranges, radar systems operate in different modes (different lengths of data etc). Let’s assume we have two planes at two different altitudes. Now, what happens if there is a new plane in sight? Since the number of targets being detected by the radar is now changing, how would you use Simulink to add this plane to its tracking list?

A short and simple answer to this question is: Variable Size Signals.

I’ve read many customer requests wanting to be able to change the dimensions of their Simulink variables while the simulation runs. Be it a radar system which needs to operate in different modes based on its target range to a simple combustion engine that needs to change its frame size based on the number of samples per cycle, each of these system dynamics work with signals whose sizes change during model execution.

Although, earlier I had to tell our customers that Simulink did not have this capacity and you could not change a model’s signals dimensions during execution; with R2009b, Simulink now supports variable-size inputs and outputs in over 40 Simulink blocks.

How does one create a variable size signal?

There are several methods of creating a variable size signal: Switch blocks; Multi-Switch blocks with different input sizes; a Selector block indexing options or custom code blocks (S-functions and Embedded MATLAB blocks).

A common way of generating variable-size signals is to use a Switch block for which each of the input signals differ in size. The Switch Block now allows variable size signals to be passed in as inputs:

By simply selecting the option “Allow different data input sizes”, you can obtain a variable size output signal whose dimensions change with time.

As an experiment, let us look at a simple demo model “sldemo_varsize_basic.mdl”. This demonstration contains examples of how to use variable-size signals in a Simulink model, and to show what kind of operations you can apply to them.

Look at how the Switch block, allowing 2 inputs of different dimensions, can be used for operations like addition, vector concatenation etc.

You can also use the “Selector” blocks to create a variable size signal. The Selector block generates as output selected or reordered elements of an input vector, matrix, or multidimensional signal. Using the “Starting and ending indices (port)” indexing option, you can allow inputs of variable dimensions to generate variable size signals.

You can use the Selector block to subreferece a matrix as shown below:

How can I get the current dimensions or width of a variable-size signal?

You can use the Probe block to output the width of a signal.

The Probe allows you to visualize and save the signal dimensions and view the I/O and state data for blocks selected. This could also be used in a calculation that requires sample size information.

How can I convert a variable-size signal into a fixed-size signal?

To convert a variable size signal into a fixed size signal, you can use the “Assignment” block. The variable-size signal feeds into the second input port of the Assignment block and can be used to convert the incoming signal into a fixed size signal.

By allowing signal sizes in Simulink models to vary during execution, one can easily model systems with varying environments, resources, and constraints. So, coming back to our radar system, using variable size signals, you can now create a conceptual air traffic control (ATC) radar simulation based on your radar range equation(s):

For more details on how this snazzy feature works, check out the Variable Sizing documentation.

Now it’s your turn

Do you plan to upgrade to R2009b and use variable size signals? Leave a comment here and tell me what you plan to model.

Bob's pick this week is Circular Statistics Toolbox (Directional Statistics) by Philipp Berens.

I remember lots of A-ha moments in college when I realized the significance of yet another application for Fourier transforms. For example, calculation of power spectral density in signal processing. The central limit theorem was another pleasant surprise. This submission stirred those memories: not unlike bumping into an old friend you haven't seen for a long time. Now all I need is a compelling problem that requires circular or directional statistics so I can truly internalize the value of these tools for myself.

Philipp first submitted this file in January 2007. There have been a number of review comments over the years. It is currently rated 4.4 (on the 5 point scale).

Downloads have averaged almost 9 per day over the past month as well. So others clearly appreciate it. I also appreciate that Philipp recently updated the submission in response to feedback from others. In addition, follow the Acknowledgements trail to see that Circular Statistics Toolbox (Directional Statistics) was inspired by Circular Cross Correlation which also inspired Fast Circular (Periodic) Cross Correlation. That's social computing. Keep up the great work, everyone.

Comments?

Get the MATLAB code

Published with MATLAB® 7.9

From time to time, I get asked or see queries about how to concatenate two struct arrays to merge the fields. There's even a section in the documentation covering this topic. I thought I'd show it here to help people out.

Contents

Example Data

Suppose I've got some system for which I have collected information on a couple of individuals, including their names and ages.

s1.name = 'fred';
s1.age = 42;
s1(2).name = 'alice';
s1(2).age = 29;

Later, I go back and collect the individual's heights (in cm).

s2.height = 170;
s2(2).height = 160;

It would be great to merge these arrays now.

s1
s2

s1 = 1x2 struct array with fields: name age
s2 = 1x2 struct array with fields: height

Let me collect the field names.

fn1 = fieldnames(s1);
fn2 = fieldnames(s2);
fn = [fn1; fn2];

Next, I ensure the fieldnames are unique.

ufn = length(fn) == unique(length(fn))

ufn = 1

Next let me convert the data in my structs into cell arrays using struct2cell.

c1 = struct2cell(s1)
c2 = struct2cell(s2)

c1(:,:,1) = 'fred' [ 42]
c1(:,:,2) = 'alice' [ 29]
c2(:,:,1) = [170]
c2(:,:,2) = [160]

Next I merge the data from the 2 cell arrays.

c = [c1;c2]

c(:,:,1) = 'fred' [ 42] [ 170]
c(:,:,2) = 'alice' [ 29] [ 160]

And finally, I construct the new struct using cell2struct.

s = cell2struct(c,fn,1)

s = 1x2 struct array with fields: name age height

I can check the output now.

s(1)
s(2)

ans = name: 'fred' age: 42 height: 170
ans = name: 'alice' age: 29 height: 160

mergeStruct

Here's the function mergeStruct that I created to encapsulate the steps in this process, including some error checks.

dbtype mergeStruct

1 function sout = mergestruct(varargin)
2 %MERGESTRUCT Merge structures with unique fields.
3 4 % Copyright 2009 The MathWorks, Inc.
5 6 % Start with collecting fieldnames, checking implicitly 7 % that inputs are structures.
8 fn = [];
9 for k = 1:nargin
10 try
11 fn = [fn ; fieldnames(varargin{k})];
12 catch MEstruct
13 throw(MEstruct)
14 end
15 end
16 17 % Make sure the field names are unique.
18 if length(fn) ~= length(unique(fn))
19 error('mergestruct:FieldsNotUnique',...
20 'Field names must be unique');
21 end
22 23 % Now concatenate the data from each struct. Can't use 24 % structfun since input structs may not be scalar.
25 c = [];
26 for k = 1:nargin
27 try
28 c = [c ; struct2cell(varargin{k})];
29 catch MEdata
30 throw(MEdata);
31 end
32 end
33 34 % Construct the output.
35 sout = cell2struct(c, fn, 1);

Do You Need to Merge struct data?

Do you ever need to merge data stored in structs when you gather new information? Or are your structs static in nature? If the information you collect is always the same sort of information, then you probably know the form of the structure when you start, even if all the data isn't available at first.

There is code on the File Exchange to concatenate structures; I confess I have not tried it, but it is highly rated. Does this post or the File Exchange contribution help your work? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.9

It's not too late to hear the presentations. You can still visit the conference link and listen to the talks there, or you can download them as podcasts.

I started out early in the morning in the Image and Video Processing booth, participating in the group chat there. When it got busy it was a bit challenging to follow all the conversational threads, but I think most people got their questions answered, and I came away with a lot of good product feedback.

Then I went over to hear Tom Kush and Roy Lurie give their "MATLAB Universe" keynote address. If you want to hear about the world-wide impact of MATLAB and get some insight into where we think MATLAB is going, check out this talk. (I didn't get a chance to listen to the other talks yesterday, but I will later.)

The experience reminded me of some of the MATLAB user conferences in the 1990s. One of the only times I've ever heard company president Jack Little tell a joke was during his keynote address at the 1995 user conference in Cambridge, Massachusetts. We had been working for several years on MATLAB 5, which was going to be a huge release. Conference attendees had been promised a preview. So at the opening of the conference, in an enormous ballroom, Jack fired up the development build of MATLAB 5 on the big screen and started to talk about all the exciting new features to come. He said there would be a few changes that might take some getting used to. (We developers were sitting on the back row, holding our breath.) Jack explained that we had decided to adopt RPN (Reverse Polish Notation, popular in HP engineering calculators such as my beloved HP 15C) in MATLAB. He proceeded to type something like:

>> 5 3 +

There was a massive collective gasp! from the audience as we about fell off our chairs in the back trying not to laugh out loud.

To any reader who was there (and is still recovering), I can only say, "We're sorry!" ;-)

OK, back to the present. Later in the day I gave a talk on MATLAB array indexing techniques that are useful for image processing, borrowing heavily from material I originally posted here on the blog. I was afraid the material would be too narrowly focused, but the audience stayed with me to the end and then asked a bunch of great questions about my last topic, neighbor indexing, which was pretty advanced.

For the first five minutes of the talk (which I recorded a couple of weeks ago), I was in a rapidly increasing panic, because a 2-second echo was making the audio completely unintelligible! I bolted out of my office to find someone to help. Kevin calmed me down and helped me figure out that I had a second, forgotten, browser window open to the talk, and the echo was coming there. Boy did I feel silly. Thanks, Kevin!

Readers, I have two questions for you. First, did you attend any of the original MATLAB user conferences in the 90s? Any favorite memories to share?

Second, did you attend the virtual conference yesterday? What did you think? If we do it again, what can we do better next time?

Thanks for taking the time to give us your feedback.

My last post gave an overview of how to use the new keyboard shortcut preference panel. This post is going to delve into the history of keyboard shortcuts in MATLAB, which will help make it clearer why we decided to change some of our default keyboard shortcut assignments.

The MATLAB desktop was developed over many years by a number of different developers. Although the developers attempted to follow platform standards for common actions, some MATLAB-specific actions were assigned different keyboard shortcuts in different desktop tools, depending on which developer created the tool. A good example of this, illustrated below in the legacy R2009a Windows Default Set, is the Open Selection action available across the desktop. In addition to the four different shortcuts that you can see below, there are a few tools with the action that have no shortcut at all.

Further complicating issues, the original keyboard shortcuts assigned to the Command Window were based on Emacs, regardless of platform. Other platform-specific shortcuts were also added to the Command Window, as long as they did not conflict with existing Emacs shortcuts; for example, Ctrl+O was added on Windows to perform Open, but Ctrl+A could not be assigned to the Command Window’s Select All action because Ctrl+A was the Emacs assignment for moving the cursor to the beginning of the line.

Before long, customers began asking for the ability to configure keyboard shortcuts in the Editor and Command Window, which were the primary desktop tools at the time. To help accommodate those requests, three default sets were developed for the Editor and the Command Window, and users could choose between those sets independently (with the caveat that the Macintosh set was only available on the Macintosh platform). To maintain backwards compatibility, the defaults remained as they had been, even though they were inconsistent between the Editor and the Command Window—the Command Window stayed with the Emacs-based shortcuts on all platforms, but the keyboard shortcut set selected for the Editor by default varied by platform. This was very confusing for new MATLAB users, who expected a more consistent user experience.

As MATLAB continued to evolve, additional tools were added to the desktop, and their keyboard shortcuts were hard-coded to the values that the individual developers felt made sense. So although users appreciated having some choice of keyboard shortcuts in the Editor and Command Window, we continued to receive many requests for customization of individual keyboard shortcuts across the whole desktop. This was particularly needed for customers using certain non-English keyboards, which simply could not trigger some of our default shortcuts.

Presented with the challenge of creating a new keyboard shortcut infrastructure, I had several requirements. I wanted to provide a way to unify keyboard shortcuts across desktop tools so that, by default, the same action had the same shortcut, regardless of where it was triggered. However, I knew that making such a change would introduce backwards incompatibilities and possibly annoy existing MATLAB users, so I wanted to ensure that flexibility existed for customers to achieve exactly the same hybrid configurations that we previously supported. At the same time, this flexibility could not be burdensome to users who desired to quickly change a keyboard shortcut across the desktop, without dealing with individual tools.

So now let’s take a look at the solution that I developed, using the Ctrl+A example discussed above. First, compare the Ctrl+A assignments in the new Windows Default Set to the assignments in the legacy R2009a set.

New Windows Default Set as of R2009b

Old Windows Default Set as of R2009a

In R2009a on Windows, Ctrl+A was not assigned to Select All in the Command Window, and instead had the Emacs-based assignment of Cursor Begin Line. Now, let’s assume that you are an existing MATLAB user and you have Ctrl+A committed in your muscle memory to going to the beginning of the line. You have 2 options—you can revert back to the legacy R2009a Windows Default Set, or you can modify the Select All and Cursor Begin Line assignments in the new default set.

Modifying the new default set is a far better long term solution if there are a relatively small number of keyboard shortcuts that are bothering you. If you stick with our new default sets, as new actions and tools are added to the desktop, you will automatically obtain their keyboard shortcuts—this is because we only store the customizations (differences) that you have made from our shipping defaults. In contrast, the legacy sets are complete listings of exactly what we had in release R2009a, and they will not evolve with new features.

So let’s change the assignments related to Ctrl+A in the new Windows Default Set. To do this, first click on Select All and then un-assign the Command Window from the list of tools with the Ctrl+A shortcut.

Then select Cursor Begin Line, press the button, and add a new shortcut of Ctrl+A to the Command Window only.

If you now search for Ctrl+A in the table of actions, and you will see that the assignments match the ones in R2009a.

That is a quick summary of how the new customizable keyboard shortcuts were developed. I hope that you find this feature useful, and I’d love to hear your feedback!

-by Christina Roberts, The MathWorks

We discovered recently that we broke application deployment when using the MATLAB Compiler with Image Processing Toolbox functions in R2009b. The problem happens only on Windows and is caused by some missing shared libraries in the deployed application.

If you use the R2009b MATLAB Compiler on Windows with the Image Processing Toolbox, please see our published bug report for a workaround. (Note: there is no need to apply this workaround to earlier releases.)

We are reviewing our procedures to try to make sure something like this doesn't happen again.

Discrete data arise in many applications and the data may be numeric, or non-numeric, often referred to as categorical. Not all data are strictly numeric, and other characteristics can be pertinent or useful. You can use a variety of techniques and data representations in MATLAB for storing and manipulation discrete data.

Contents

Example: Periodic Table of Elements

The periodic table of elements provides a rich basis for this discussion. If you remember your chemistry class (I did, very imperfectly), you probably remember that each element has a fixed number of protons associated with it, also called the atomic number. You might also remember that the periodic table is arranged so that certain columns of elements have certain characteristics. For example, apart from Hydrogen, the left-most column holds the alkali metals (such as sodium and potassium) and the left side generally contains metallic elements. The right-most column holds Noble gases, with the next column to their left holding halogens. Nonmetals are towards the right side of the table. At standard temperature and pressure (known as STP), elements are in one of three states: solid, liquid, or gas.

We've just talked about 3 different things:

Discrete Data Representation Options

I will try to use the periodic table example for each of the possible discrete data representations, but some of these will be forced examples.

logical

You could imagine use a logical variable to indicate elements that are in the Noble category as true and false for the remainder.

String or Coded Integer

logical variables are fine if you are representing exactly two possible categories. However, looking at the periodic table, you see that I collapsed a subset of categories into "not Noble" (false). Rather than collapsing the set of categories into Noble and not Noble, the entire collection might be better represented as integers that are arbitrarily given meaning, or by strings. For example, I could code alkali metals as 'alkali metals' or as 1, and so on. The first 3 elements of the table would be represented with [8 10 1] or as {'other nonmetals' 'noble gases' 'alkali metals'}.

Coded integers are useful for doing comparisons, for example, subsetting the data, and are memory-efficient. However, integers can cause you some mental overhead trying to remember the mapping between them and their labels.

Strings are good for representing the data in a readable form, but are harder to manipulate, especially for an ordered list such as phase states. Also you may prefer to use numeric type operations such as ==, ~=, and < since they are more direct and show intent. In addition, strings take more memory, especially when your data comprise many repetitions of the same value.

nominal Array

You have additional choices with nominal and ordinal arrays from Statistics Toolbox.

Let's imagine that we create an array representing the element categories by atomic number. The first 10 elements of this array look like this. I collapse some of the traditional categories for brevity.

catLabels = {'metals', 'metalloids','other nonmetals','halogens', ... 'noble gases', 'unknown'};
elemCats = nominal([3 5 1 1 2 3 3 3 4 5]', catLabels, 1:length(catLabels))
elemNames = {'hydrogen','helium','lithium','beryllium','boron', ... 'carbon','nitrogen','oxygen','fluorine','neon'}';

elemCats = other nonmetals noble gases metals metals metalloids other nonmetals other nonmetals other nonmetals halogens noble gases 

Here is the list of all possible values for the categories. Notice that this nominal array carries that information with it. (You can modify this by adding, renaming, and deleting as necessary.)

getlabels(elemCats)

ans = Columns 1 through 5 'metals' 'metalloids' 'other nonmetals' 'halogens' 'noble gases' Column 6 'unknown'

Let's find all the 'other nonmetals' in the list.

nonmets = find(elemCats == 'other nonmetals')
elemNames(nonmets)

nonmets = 1 6 7 8
ans = 'hydrogen' 'carbon' 'nitrogen' 'oxygen'

ordinal Array

Let's investigate the states of the first 10 elements now. For some purposes, the states can be regarded as nominal. However, they can also be viewed as an ordered set, solid < liquid < gas. (At STP, only mercury and bromine are in liquid state.)

stLabels = {'solid' 'liquid' 'gas'};
elemSts = ordinal([3 3 1 1 1 1 3 3 3 3]', stLabels, 1:length(stLabels))

elemSts = gas gas solid solid solid solid gas gas gas gas 

Here is the list of all possible values for the states.

getlabels(elemSts)

ans = 'solid' 'liquid' 'gas'

Let's find all the gases in the list.

gases = find(elemSts > 'liquid') % or == 'gas'
elemNames(gases)

gases = 1 2 7 8 9 10
ans = 'hydrogen' 'helium' 'nitrogen' 'oxygen' 'fluorine' 'neon'

Let's sort the element list by state.

[sts, elemNo] = sort(elemSts)
[cellstr(sts) elemNames(elemNo)]

sts = solid solid solid solid gas gas gas gas gas gas elemNo = 3 4 5 6 1 2 7 8 9 10
ans = 'solid' 'lithium' 'solid' 'beryllium' 'solid' 'boron' 'solid' 'carbon' 'gas' 'hydrogen' 'gas' 'helium' 'gas' 'nitrogen' 'gas' 'oxygen' 'gas' 'fluorine' 'gas' 'neon' 

Integer

For the given list of elements, the atomic number happens to match exactly with the index into the elemNames array. So I only need to create the relevant integer values 1:10 to represent the atomic number. This list is itself clearly ordered, and has numerical meaning (unlike ordinal arrays which are ordered but the spacing between elements has no definition).

Going All the Way

To continue this example, you can collect all the information together into a single dataset array (from Statistics Toolbox). The advantages include being able to "index" by the element name!

atomicNo = (1:length(elemNames))';
periodicTable = dataset(atomicNo ,elemCats, elemSts, 'obsnames', elemNames)

periodicTable = atomicNo elemCats elemSts hydrogen 1 other nonmetals gas helium 2 noble gases gas lithium 3 metals solid beryllium 4 metals solid boron 5 metalloids solid carbon 6 other nonmetals solid nitrogen 7 other nonmetals gas oxygen 8 other nonmetals gas fluorine 9 halogens gas neon 10 noble gases gas 

Your Data or Experiment

Do you have a situation where some of your data can be represented with nominal or ordinal arrays? How do you manage that information now? Let me know by posting here.

Get the MATLAB code

Published with MATLAB® 7.9

Bob's pick this week is Colored Area on a Curved Surface by Michael Wunder.

This is a nice example of quantitative image analysis. Given a heat map and region of interest based on elevation,

compute the surface area.

See Michael's published example for the step by step details.

Comments?

Get the MATLAB code

Published with MATLAB® 7.10

• Conference Info Page
• Register
• Presentation Schedule

I will be facilitating forum discussions on MATLAB tips and tricks from 2-3pm and 4-5pm (Eastern). Fellow bloggers Loren and Jiro will also be hosting forum discussions.

This is the EcoCAR from the EcoCAR Challenge. MathWorks hosted about one hundred students from the EcoCAR teams for the EcoCAR Year 2 Fall Workshop.

A Big Shiny Embedded Target

When I first saw the EcoCAR sitting on the lawn, I wondered what system target file they might use:

I’m sure there are a lot of cool things these students will be able to do with a great piece of hardware like this, but in many ways, it’s just a big, shinny embedded target.

What is EcoCAR?

EcoCAR is an academic competition. A quote from ecocarchallenge.org sums it up:

“The competition challenges 17 universities across North America to reduce the environmental impact of vehicles by minimizing the vehicle’s fuel consumption and reducing its emissions while retaining the vehicle’s performance, safety and consumer appeal. Students use a real-world engineering process to design and integrate their advanced technology solutions into a 2009 Saturn Vue.”

The students had 5 days of training in different tracks to learn and apply MathWorks tools to the design problems facing them. If you read the Green Car Garage blog, you may have read about the event and the fun teams had during their visit to Boston. Nicole Lambiase from Argon National Lab wrote a post commenting that it really takes a village to make these competition events run smoothly. Some of the people in that village are members of the Model-Based Design community. A lot of my colleagues volunteer with EcoCAR Challenge. Many of them traveled from our Michigan office to lead trainings and mentor students that attended.

The Trouble with Model-Based Design

The trouble with Model-Based Design is that there are very few people and institutions available to help you learn it. I never had a class on Model-Based Design when I went to school. The EcoCAR Challenge is an opportunity to develop the next generation of engineers skilled in Model-Based Design. MathWorks is very committed to mentoring these future engineers. This aligns with our academic mission to accelerate the pace of learning, discovery, and research in engineering and science.

How about you?

How did you learn about modeling and Model-Based Design? Who was your mentor? Leave a comment here and share your story.

Here's the presentation schedule to help you find what you'd like to participate in.

I'm planning to attend some of the forums and listen to many of the talks, including ones focused on MATLAB for education. Hope to meet you there!

If you’re a regular user of the Help browser, you’ll notice that its user interface has changed quite a bit in R2009b. One of our main motivations for these changes was to make the Help browser useful in layouts other than its default layout. Time and time again we’ve seen users struggle to use the Editor and Help browser at the same time, because they both work best when they’re laid out relatively wide. Since users can’t get them both on screen at the same time, they end up switching back and forth between them, wasting time and breaking their flow.

If you struggle to see your work and use the Help system at the same time, here are a couple of tips for making the Help browser take up less space in R2009b:

Close the Help navigator

Yes, really, close the Help navigator (the left side of the Help browser, where the table of contents and the search results show up). It used to be that if you closed the Help navigator you wouldn’t be able to navigate the doc at all - the table of contents, demos, and even the search field would go away with it. In R2009b, we’ve moved the search field up into the toolbar when the Help navigator is closed, and even more significantly, we’ve replaced the old location dropdown with a breadcrumb navigation widget that lets you access to the full table of contents and all of the demos from the toolbar. If you’ve always wanted the Help browser to give more space to the documentation without sacrificing so much functionality, R2009b should be a big improvement for you.

Consider a taller, narrower Help browser

Prior to R2009b, it was virtually impossible to use the Help browser once you made it narrow. The Help navigator could only be positioned on the left hand side of the Help browser, and as we discussed above, you lost a ton of functionality if you tried to close it. So if you made the Help browser narrow, you had very little room left to display the documentation. In R2009b, we’ve introduced an alternate layout for the Help browser: if you resize the Help browser so that it’s tall and narrow, the Help navigator moves up above the contents. We’re hoping you’ll find it convenient to try some alternate layouts, like docking the Help browser in a narrow space next to the editor.

Please try out these changes and let us know if they help keep you in your flow - we don’t want you to get bogged down in the Help browser and lose track of your work. We’ll look at some other changes to the Help browser in a later entry.

Today I’d like to introduce a guest blogger, Sarah Wait Zaranek, who is an application engineer here at The MathWorks. Sarah previously has written about speeding up code from a customer to get acceptable performance. She again will be writing about speeding up MATLAB applications, but this time her focus will be on using the parallel computing tools.

Contents

Introduction

I wanted to write a post to help users better understand our parallel computing tools. In this post, I will focus on one of the more commonly used functions in these tools: the parfor-loop.

This post will focus on getting a parallel code using parfor up and running. Performance will not be addressed in this post. I will assume that the reader has a basic knowledge of the parfor-loop construct. Loren has a very nice introduction to using parfor in one of her previous posts. There are also some nice introductory videos.

Note for clarity : Since Loren's introductory post, the toolbox used for parallel computing has changed names from the Distributed Computing Toolbox to the Parallel Computing Toolbox. These are not two separate toolboxes.

Method

In some cases, you may only need to change a for-loop to a parfor-loop to get their code running in parallel. However, in other cases you may need to slightly alter the code so that parfor can work. I decided to show a few examples highlighting the main challenges that one might encounter. I have separated these examples into four encompassing categories:

Background on parfor-loops

In a parfor-loop (just like in a standard for-loop) a series of statements known as the loop body are iterated over a range of values. However, when using a parfor-loop the iterations are run not on the client MATLAB machine but are run in parallel on MATLAB workers.

Each worker has its own unique workspace. So, the data needed to do these calculations is sent from the client to workers, and the results are sent back to the client and pieced together. The cool thing about parfor is this data transfer is handled for the user. When MATLAB gets to the parfor-loop, it statically analyzes the body of the parfor-loop and determines what information goes to which worker and what variables will be returning to the client MATLAB. Understanding this concept will become important when understanding why particular constraints are placed on the use of parfor.

Opening the matlabpool

Before looking at some examples, I will open up a matlabpool so I can run my loops in parallel. I will be opening up the matlabpool using my default local configuration (i.e. my workers will be running on the dual-core laptop machine where my MATLAB has been installed).

if matlabpool('size') == 0 % checking to see if my pool is already open matlabpool open 2
end

Starting matlabpool using the 'local' configuration ... connected to 2 labs.

Note : The 'size' option was new in R2008b.

Independence

The parfor-loop is designed for task-parallel types of problems where each iteration of the loop is independent of each other iteration. This is a critical requirement for using a parfor-loop. Let's see an example of when each iteration is not independent.

type dependentLoop.m

% Example of a dependent for-loop
a = zeros(1,10); parfor it = 1:10 a(it) = someFunction(a(it-1));
end

Checking the above code using M-Lint (MATLAB's static code analyzer) gives a warning message that these iterations are dependent and will not work with the parfor construct. M-Lint can either be accessed via the editor or command line. In this case, I use the command line and have defined a simple function displayMlint so that the display is compact.

output = mlint('dependentLoop.m');
displayMlint(output)

The PARFOR loop cannot run due to the way variable 'a' is used. In a PARFOR loop, variable 'a' is indexed in different ways, potentially causing dependencies between iterations. 

Sometimes loops are intrinsically or unavoidably dependent, and therefore parfor is not a good fit for that type of calculation. However, in some cases it is possible to reformulate the body of the loop to eliminate the dependency or separate it from the main time-consuming calculation.

Globals and Transparency

All variables within the body of a parfor-loop must be transparent. This means that all references to variables must occur in the text of the program. Since MATLAB is statically analyzing the loops to figure out what data goes to what worker and what data comes back, this seems like an understandable restriction.

Therefore, the following commands cannot be used within the body of a parfor-loop : evalc, eval, evalin, and assignin. load can also not be used unless the output of load is assigned to a variable name. It is possible to use the above functions within a function called by parfor, due to the fact that the function has its own workspace. I have found that this is often the easiest workaround for the transparency issue.

Additionally, you cannot define global variables or persistent variables within the body of the parfor loop. I would also suggest being careful with the use of globals since changes in global values on workers are not automatically reflected in local global values.

Classification

A detailed description of the classification of variables in a parfor-loop is in the documentation. I think it is useful to view classification as representing the different ways a variable is passed between client and worker and the different ways it is used within the body of the parfor-loop.

Challenges with Classification

Often challenges arise when first converting for-loops to parfor-loops due to issues with this classification. An often seen issue is the conversion of nested for-loops, where sliced variables are not indexed appropriately.

Sliced variables are variables where each worker is calculating on a different part of that variable. Therefore, sliced variables are sliced or divided amongst the workers. Sliced variables are used to prevent unneeded data transfer from client to worker.

Using parfor with Nested for-Loops

The loop below is nested and encounters some of the restrictions placed on parfor for sliced variables.

type parforNestTry.m

A1 = zeros(10,10); parfor ix = 1:10 for jx = 1:10 A1(ix, jx) = ix + jx; end
end

output = mlint('parforNestTry.m');
displayMlint(output);

The PARFOR loop cannot run due to the way variable 'A1' is used. Valid indices for 'A1' are restricted in PARFOR loops. 

In this case, A1 is a sliced variable. For sliced variables, the restrictions are placed on the first-level variable indices. This allows parfor to easily distribute the right part of the variable to the right workers.

The first level indexing ,in general, refers to indexing within the first set of parenthesis or braces. This is explained in more detail in the same section as classification in the documentation.

One of these first-level indices must be the loop counter variable or the counter variable plus or minus a constant. Every other first-level index must be a constant, a non-loop counter variable, a colon, or an end.

In this case, A1 has an loop counter variable for both first level indices (ix and jx).

The solution to this is make sure a loop counter variable is only one of the indices of A1 and make the other index a colon. To implement this, the results of the inner loop can be saved to a new variable and then that variable can be saved to the desired variable outside the nested loop.

A2 = zeros(10,10); parfor ix = 1:10 myTemp = zeros(1,10); for jx = 1:10 myTemp(jx) = ix + jx; end A2(ix,:) = myTemp;
end

You can also solve this issue by using cells. Since jx is now in the second level of indexing, it can be an loop counter variable.

A3 = cell(10,1); parfor ix = 1:10 for jx = 1:10 A3{ix}(jx) = ix + jx; end
end A3 = cell2mat(A3);

I have found that both solutions have their benefits. While cells may be easier to implement in your code, they also result in A3 using more memory due to the additional memory requirements for cells. The call to cell2mat also adds additional processing time.

A similar technique can be used for several levels of nested for-loops.

Uniqueness

Doing Machine Specific Calculations

This is a way, while using parfor-loops, to determine which machine you are on and do machine specific instructions within the loop. An example of why you would want to do this is if different machines have data files in different directories, and you wanted to make sure to get into the right directory. Do be careful if you make the code machine-specific since it will be harder to port.

% Getting the machine host name [~,hostname] = system('hostname'); % If the loop iterations are the same as the size of matlabpool, the
% command is run once per worker. parfor ix = 1:matlabpool('size') [~,hostnameID{ix}] = system('hostname');
end % Can then do host/machine specific commands
hostnames = unique(hostnameID);
checkhost = hostnames(1); parfor ix = 1:matlabpool('size') [~,myhost] = system('hostname'); if strcmp(myhost,checkhost) display('On Machine 1') else display('NOT on Machine 1') end
end

On Machine 1
On Machine 1

In my case since I am running locally -- all of the workers are on the same machine.

Here's the same code running on a non-local cluster.

matlabpool close
matlabpool open speedy
parfor ix = 1:matlabpool('size') [~,hostnameID{ix}] = system('hostname');
end % Can then do host/machine specific commands
hostnames = unique(hostnameID);
checkhost = hostnames(1); parfor ix = 1:matlabpool('size') [~,myhost] = system('hostname'); if strcmp(myhost,checkhost) display('On Machine 1') else display('NOT on Machine 1') end
end

Sending a stop signal to all the labs ... stopped.
Starting matlabpool using the 'speedy' configuration ... connected to 16 labs.
On Machine 1
On Machine 1
On Machine 1
NOT on Machine 1
On Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1
NOT on Machine 1

Note: The ~ feature is new in R2009b and discussed as a new feature in one of Loren's previous blog posts.

Doing Worker Specific Calculations

I would suggest using the new spmd functionality to do worker specific calculations. For more information about spmd, check out the documentation.

Clean up

matlabpool close

Sending a stop signal to all the labs ... stopped.

Your examples

Tell me about some of the ways you have used parfor-loops or feel free to post questions regarding non-performance related issues that haven't been addressed here. Post your questions and thoughts here.

Get the MATLAB code

Published with MATLAB® 7.9

This week's Pick of the Week takes a turn "out of the box"; rather than select a file, I'd like to highlight new functionality in MATLAB that allows one to interface with the MATLAB Central File Exchange directly from one's MATLAB Desktop.

As of the current release of MATLAB (R2009b), the Desktop includes a new tool called, appropriately, the File Exchange Desktop Tool. To access the tool, simply browse from the MATLAB 'Start' button to 'Desktop Tools,' and then to 'File Exchange':

From there, you'll be presented with a standard MATLAB window that will allow you to find and grab files from the Exchange.

Also, be sure to check out this mini video tutorial demonstrating these new capabilities. And be sure to tell us what you think!

Get the MATLAB code

Published with MATLAB® 7.9

R2009b has a new feature that I am particularly excited about: user-configurable keyboard shortcuts for the MATLAB desktop. This is a project that has been in the works for several years, and I am thrilled that it is now officially released.

I will be splitting up my discussion of this feature into two posts. The first will give a high-level overview of the R2009b functionality, and the second will delve into the somewhat troubled history of keyboard shortcuts in MATLAB. I hope that you will learn some valuable tips from both posts and gain a better understanding of how to leverage customizable keyboard shortcuts.

First, let me explain the layout of the keyboard shortcut preference panel. You can open it from the File Menu: File -> Preferences -> Keyboard -> Shortcuts

The Active settings dropdown list at the top of the preference panel allows you to choose between different keyboard shortcut sets—those that ship with the product, and customized sets that you may obtain from colleagues or MATLAB Central. The shortcut set selected by default matches common keyboard shortcuts on the platform on which you are running. For Windows and Macintosh, these are based on Windows and Macintosh platform standards, respectively. On UNIX, we decided to base our default keyboard shortcuts on the popular Emacs editor; however, if you are more comfortable with Windows-based keyboard shortcuts, that option is also available on UNIX.

The Windows and Emacs sets are both available on non-Macintosh platforms, but the Macintosh Default Set is only available on Macintosh due to the usage of the Command key. In addition to our new default sets, we also ship a set representing the default keyboard shortcuts in R2009a, specific to the platform on which you are running.

To import a customized keyboard shortcut set, choose Browse… from the Active settings combo box and navigate to the location of the set’s XML file. If you would like to share your own customized set, use the Save As… button to create an XML-representation of the set.

The top table of the preference panel lists all the actions that are configurable. You can search the contents of this table using the search field above it. For example, let’s look at the actions relating to pasting an item from the clipboard:

You can see that there are three paste-related actions. The generic Paste action has the keyboard shortcuts Ctrl+V and Shift+Insert. These same keyboard shortcuts are also assigned to Paste to Workspace in the Workspace Browser, as indicated by the informational icon next to the actions as well as their tooltips.

The middle table is where you can change assigned keyboard shortcuts, remove existing assignments, and add new ones. Let’s assume that you want to change Paste’s Ctrl+V shortcut to Ctrl+Shift+P. To do this, click in the table cell displaying Ctrl+V and press your new keyboard shortcut. The text representing the shortcut that you just pressed will then be displayed. Note that you can also insert multi-stroke keyboard shortcuts, popular in Emacs, by selecting Limit to 2 keystrokes from keyboard shortcut editor’s context menu.

If you press the Apply or OK buttons, Ctrl+V will be replaced by Ctrl+Shift+P for all tools which support the Paste action. To see what tools these are, click in the table cell to the right of the new assignment. It is then possible to deselect some of these tools, if you do not wish for Ctrl+Shift+P to be assigned to Paste in all desktop tools.

Now let’s also assign Ctrl+V back to Paste in the Editor only. To do this, press the button under the middle table. Then press Ctrl+V in the shortcut field, and finally deselect all the tools for that shortcut except the MATLAB Editor.

Finally, the bottom table in the panel shows keyboard shortcut conflicts with the action currently being edited. In the example above, informational icons indicate that there are keyboard shortcuts assigned to Paste which are also assigned to Paste to Workspace. However, since the Workspace Browser does not support the default Paste action, this is not an actual conflict. To create a real conflict, try replacing the Ctrl+Shift+P assignment with Ctrl+P.

When you make that change, an error icon appears, indicating that Ctrl+P is assigned to two or more actions within the same desktop tool. This means that you cannot use Ctrl+P for both Paste and Print, but you can instead choose to unassign Ctrl+P from Print by selecting the first row in the bottom table and pressing the Unassign button.

If you now press the OK or Apply button, your modifications to the Windows Default Set will be retained in subsequent sessions of MATLAB. You can go back to the original Windows Default Set by selecting Restore defaults, or you could write this file out as a custom set by selecting Save As….

That is a quick overview of how the preference panel works. In a future post, I will discuss the history of keyboard shortcuts in MATLAB and explain how we made some of our design choices.

-by Christina Roberts, The MathWorks

Introduction to the Simscape Language

I’ve been working with MATLAB and Simulink since my college days, and one of the things I liked most about these tools is that I’m free to create just about anything with the commands and blocks. Whenever my boss asked me, “Do you think you could use MATLAB to...,” the enthusiastic “Yes!” was halfway out of my mouth before he even reached the end of the sentence.

When I started working with the physical modeling products at The MathWorks, I was hoping that I’d have the same freedom there. Well, starting with Release 2008b, I do! Using the Simscape language (an enhancement to Simscape, which was first released in R2007a), I can create my own physical modeling blocks just like I created cool MATLAB scripts and Simulink subsystems to solve all those tricky problems my boss threw at me.

What is the Simscape language?

The Simscape language is a MATLAB-based, object-oriented language for modeling physical systems. The big difference here is that I can use this textual language to create components that have physical connections, such as hydraulic ports on valves and electrical terminals on resistors, instead of inputs and outputs like I’m used to doing in Simulink. Why is this important? Well the models built with physical connections are much easier to understand – models of electrical systems look like an electrical schematic. And, if I create something useful and I want to reuse it in another model, it is much easier, for I don’t have to worry about routing inputs and outputs -- I just plug my new electrical component into the circuit and try it.

Here is an example of a component I have defined using the Simscape language. It’s a DC motor. You’ll see that it has four physical ports (not inputs and outputs) – two electrical and two mechanical. These physical ports let me plug the component into a physical network.

How does it work?

You can use the Simscape language to define physical domains, components, and libraries of components. It’s usually easiest to look at an example, so let’s look at the definition of a DC motor created in the Simscape language.

Here we see the first 11 lines of the file. This is where we define the component name, add a description, and define the physical ports:

You can see that we have two electrical (+ and – terminals) and two mechanical rotational ports (motor shaft and motor housing). These are reflected in the component shown above.

In the next 6 lines of the file, we define the parameters (including units!). These are the values that I or another user may want to change:

You’ll notice that in the final component, the prompt, the default value, and the units all show up in the dialog box shown here:

Just like most Simscape blocks, there a link to the source code! In lines 18-23 of the file, we define the variables associated with the physical domains (electrical and mechanical) we need for the equations we will define in the equations section.

In the setup section, we set up the connections between the variables to the physical ports. Remember Kirchoff’s laws? Well, we’re essentially applying them to both the electrical and mechanical domains (yep, they work in other physical domains, too, if you define them properly).

You’ll also notice that we have used MATLAB to make sure that the value of the resistance in the dialog box is not less than zero. I can use MATLAB code in this section to do other things like calculate values or initialize variables. All that MATLAB I learned is not going to waste!

In the last lines of the file, I define the equations for the motor. Take a look:

See the “==” symbol there? I’ve used that to define an implicit equation. This means I have set up a relationship between these quantities (including time derivatives – see the .der?). I’m not assigning values, nor does this represent a Boolean expression. I could have defined them as shown below and the results would be the same:

And there you have it! Once I have defined the file, I execute ssc_build and it produces a Simscape component I can connect to other Simscape components in my physical model.

Videos of Simscape language in action

I have made a video demo of modeling a nonlinear spring using the Simscape language. Take a look to see the blocks in use and the build process.

For a more complete experience, watch this webinar on the Simscape language.

Now it’s your turn

Want a closer look at this example? Download it from the MATLAB Central File Exchange.

Are you using the physical modeling tools? Have you tried the Simscape language? Post a comment here and tell us about it.

Bob's pick this week is lasso.m by Thomas Rutten.

Suppose you have a set of XY points. You plot them to see how they spread out. You decide a certain clump of points is special. How do you get MATLAB to know which points you care about? With lasso you can select them with your mouse!

To demonstrate I will use the sunspot example data that ships with MATLAB.

load sunspot.dat
[x,y,i] = lasso(sunspot(:,1),sunspot(:,2))

press a KEY to start selection by mouse, LEFT mouse button for selection, RIGHT button closes loop
x = 1836 1837 1848 1870
y = 121.5 138.3 124.7 139
i = 137 138 149 171

centroid = [mean(x) mean(y)]

centroid = 1847.8 130.88

The program prompted me how to start and stop the selection. I left off the semicolon to show the values returned for further analysis (ie, centroid calculation). The first plot shows the polygon region I selected. The second plot shows the selected points with a free legend and point counter. Nice!

Note: if you like graphically interacting with your XY points be sure to check out Data Brushing introduced with R2008a.

Comments?

Get the MATLAB code

Published with MATLAB® 7.9

The File Exchange window is not open by default, so to bring it up, use the toolbar menu: Desktop -> File Exchange.

Downloading is quite simple. Let’s say I wanted to download Ken’s breakpoint muting program:
1. Search
2. Download

3. Go

It’s pretty a simple feature, but the convenience factor is really there. You can search for toolbox functions using the Function Browser, and if we didn’t give you a particular function, you can then turn to the File Exchange and see if one of your friends on the web has already done the work for you.

The file exchange is an active and friendly community and if you’ve come up with useful program, we encourage you to share that with the community through the File Exchange web interface. If your program is up to snuff, it may even be chosen as the File Exchange Pick of the Week.

Resources:

1. FAQ
2. Watch the tutorial video

Back in February 2009 I posted about how to test for NaN in Simulink. The approach I talked about was more of a logical experiment based on the special properties of NaN than an ideal software solution. In Simulink R2009b the Relational Operator block got an upgrade to include isNaN. Let’s see how it works.

Relational Operator Block Upgrade

The Relational Operator is often used to compare signals and test for greater than (>), equals (==), and more. In R2009b it has the following new single input modes: isNaN, isFinite, and isInf.

These functions are familiar to those who program in MATLAB and they work the same way. When the input signal has the properties we are testing for, the block outputs true.

How does it work?

I talked to my colleague Omar who upgraded the block and he shared with me some key points. He mentioned that the block handles:

• real and complex signals
• any data type supported by Simulink including fixed point types
• endianness of your platform

These new operators are only meaningful with data types that can represent Inf and NaN. So how does it work with non-floating point types? If you pass in an integer, or a fixed-point type that cannot represent NaN of Inf, the block returns false. This is a key point for workflows where you might find yourself switching the data types in your design. This often happens when selecting proper fixed-point data type properties. If you are running simulations to gather ideal double precision results, you may need to handle Inf and NaN. When converting the model to fixed-point for implementation, the algorithm does not require any modifications.

Generated Code

The code generated for the isNaN function looks like this:

34 /* Outport: ‘<Root>/Out1’ incorporates:
35 * Inport: ‘<Root>/In1’
36 * RelationalOperator: ‘<Root>/Relational Operator’
37 */
38 isNaNCode_Y.Out1 = rtIsNaN(isNaNCode_U.In1);

The function rtIsNaN is part of rt_nonfinite.c:

 61 /* Test if value is not a number */

 62 boolean_T rtIsNaN(real_T value)

 63 {

 64 

 65 #if defined(_MSC_VER) && (_MSC_VER <= 1200)

 66 

 67  /* For MSVC 6.0, use a compiler specific comparison function */

 68  return _isnan(value)? 1U:0U;

 69 

 70 #else

 71 

 72  return((value!=value) ? 1U : 0U);

 73 

 74 #endif

 75 

 76 }

Further Optimization using Target Function Library

If your embedded target environment has a special function for handling tests for NaN, Inf or Finiteness you can use the Target Function Library to replace the call to rtIsNaN with that call.

What do you think?

Will you use the isInf, isNaN and isFinite mode of this block? Leave a comment here to tell me how.

Brett's Pick this week is exportToZip, by fellow MathWorker Malcolm Wood.

I recently received an email from a File Exchange user informing me that a GUI I had shared for morphologically processing images (i.e., morphTool) didn't work. As it turns out, I had neglected to include in the Zip file that I uploaded a couple of functions that were called internally by morphTool.

I've made the same mistake before, and I've also downloaded File Exchange files that were missing some key functionality.

This email exchange had me thinking about writing a bit of code to automatically create my Zip files, making sure to include all necessary supporting function files. MATLAB has a depfun command that will thoroughly analyze a function and determine its dependencies, including, by default, functions in MATLAB Toolboxes. It can take a little while to generate a report, though, and does a lot more work than is necessary just to create a comprehensive Zip file. Alternatively, one can easily create a dependency report for the current file active in the MATLAB editor by using "Save and Show Dependency Report" from the Tools menu. That approach is much faster than using depfun (with its default options), but leaves you then to manually evaluate one-by-one each function that your top-level function calls. As you might guess, it's easy to miss a necessary file when you create your Zip.

Before I started coding, I thought I'd check the File Exchange (wouldn't you?), and I quickly found Malcolm's exportToZip. Malcolm's file uses his own version of depfun (called mydepfun), that smartly uses non-default behavior of depfun to automatically skip files in MATLAB Toolboxes; mydepfun returns the paths to just those files needed for the target Zip file, which is then automatically created.

I tried exportToZip on morphTool; it worked flawlessly--and quickly! And syntactically, it couldn't be easier to use:

zipfilename = exportToZip(funcname,zipfilename)

Oh, and incidentally, a new version of morphTool will go live soon. Thanks, Malcolm--you saved me a lot of time and effort!

You gotta love the File Exchange!

Comments?

Get the MATLAB code

Published with MATLAB® 7.8

MATLAB R2009b was recently released. My favorite new language feature is the introduction of the ~ notation to denote missing inputs in function declarations, and missing outputs in calls to functions. Let me show you how this works.

Contents

Unused Outputs

I have occasionally found that I would like the indices from sorting a vector, but I don't need the sorted values. In the past, I wrote one of these code variants :

 [dummy, ind] = sort(X) [ind, ind] = sort(X)

In the first case, I end up with a variable dummy in my workspace that I don't need. If my data to sort, X, has a large number of elements, I will have an unneeded large array hanging around afterwards. In the second case, I am banking on MATLAB assigning outputs in order, left to right, and I create somewhat less legible code, but I don't have an extra array hanging around afterwards.

Now you can write this instead:

 [~, ind] = sort(X)

and I hope you find your code readable, with the clear intention to not use the first output variable.

Unused Inputs

You can similarly designate unused inputs with ~ in function declarations. Here's how you'd define the interface where the second input is ignored.

 function out = mySpecialFunction(X,~,dim)

You might ask why that is useful. If I don't use the second input, why put it in at all? The answer is that your function might be called by some other function that expects to send three inputs. This happens for many GUI callbacks, and particularly those you generate using guide. So your function needs to take three inputs. But if it is never going to use the second input, you can denote the second one with ~.

Can M-Lint Help?

Yes! Consider this function mySpecialFunction shown here.

type mySpecialFunction

function ind = mySpecialFunction(X,second,dim)
% mySpecialFunction Function to illustrate ~ for inputs and outputs. [dummy,ind] = sort(X,dim);

Running mlint on this code produces two messages.

msgs = mlint('mySpecialFunction');
disp(msgs(1).message(1:50))
disp(msgs(1).message(51:end))
disp(' ')
disp(msgs(2).message(1:49))
disp(msgs(2).message(50:end))

Input argument 'second' might be unused, although a later one is used. Consider replacing it by ~. The value assigned here to 'dummy' appears to be unused. Consider replacing it by ~.

Since M-Lint is running continuously in the editor, you would see these messages as you edit the file. Here's a cleaned up version of the file.

type mySpecialFunction1

function ind = mySpecialFunction1(X,~,dim)
% mySpecialFunction Function to illustrate ~ for inputs and outputs. [~,ind] = sort(X,dim);

And let's see what M-Lint finds.

mlint mySpecialFunction1

It finds nothing at all.

What's Your Favorite New Feature?

Have you looked through the new features for R2009b? What's your favorite? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.9

Reading the release notes is so R2007b!

Did you know that there is a presentation containing highlights and screen shots from R2009b Simulink? If you have missed this in the past, you can go back and check out R2008a, R2008b and R2009a highlights. Try it yourself, and browse through all the cool new features in R2009b Simulink.

Model Reference Protected Models!

Share your model functionality without sharing your model intellectual property! Anyone with R2009b Simulink can use a protected model. If you have a license to Real-Time Workshop, you can create a protected model.

Model Reference Variants

If you have multiple implementations of your component model, variant objects enable you to control the implementation used. This allows you to globally control and coordinate switching between variant implementations of your model.

Tabs in the Mask Editor!

Now you can create tabs in your custom block masks.

Variably Sized Signals!

Special blocks and Embedded MATLAB now support dynamically sizing signals during simulation!

The SIM command can return a single output!

The SIM command has a new single output syntax so all your results are part of a single SimulationOutput object. This enables SIM to be called within a PARFOR loop, thus enabling easy parallel Simulation using the Parallel Computing Toolbox.

New Library Links Tool for fixing broken links!

After making changes to a model and disabling library links, the Library Links tool will enable you to reestablish those links to your library. Each change in the model can be pushed back into the library, or the block can be restored from the original library source.

Now it’s your turn

Have you downloaded R2009b? Leave a comment here and tell me about your favorite new features.

There are frequent questions on the MATLAB newsgroup about rounding results to a certain number of decimal places. MATLAB itself doesn't provide this functionality explicitly, though it is easy to accomplish.

Contents

Sidetrack : A Little MathWorks History

MathWorks' first Massachusetts office phone number was 653-1415 (ignoring country and area codes). The astute reader will notice that the last 5 digits are an approximation for (or, in MATLAB, pi). A local resident called one day to say that she kept getting calls for MathWorks and she wasn't sure why. But it was quite inconvenient for her because she spent lots of time on the second floor of her home, and the phone was on the first floor. The excess round-trips were taxing her! To understand what was happening, you should know that in some of the early MathWorks materials, the phone number was listed as .

Example

format long
x = 1.23456789

x = 1.234567890000000

Use round. Here we get no decimals at all.

round(x)

ans = 1

There are many ways to get the number of decimals you want. Here's one way to round to 3 decimals.

round(x*1000)/1000

ans = 1.235000000000000

Here's another way.

sprintf('%0.3f',x)

ans =
1.235

And another. In this case, using the "easy" way to specify the format, you need to know how many integral digits there are as well.

str2num(num2str(x,4))

ans = 1.235000000000000

Tools for Rounding Solutions

There are a lot of tools for helping you round numbers. The functions I list here for MATLAB form the basis of many, if not all, of the specific solutions.

MATLAB

Mapping Toolbox

File Exchange Rounding Tools

% N= num2str(X,SF);
% N= str2num(N);

Question for You

When you round values, do you want this for display only, or wanted for calculations? Some applications I can think of might include processing data that has a smaller number of bits of precision to start with. What applications do you need rounding for in your calculations? Post here with your thoughts.

Get the MATLAB code

Published with MATLAB® 7.8

BEEP, What BEEP?

 What I’m talking about is that bell character you sometimes hear. In older version of MATLAB (Pre R14), you could actually display a beep on the screen.

In more recent version, the command window doesn’t display the BEEP character. Instead, you can call the function BEEP.

You hear it under different circumstances for Simulink versus MATLAB.

MATLAB BEEP == Error

In MATLAB, the BEEP alerts you to an error. Sometimes you get it because your calling syntax is wrong, sometimes when the tab completion can’t find anything. In MATLAB, BEEP is bad.

Simulink BEEP == Done

In Simulink, the BEEP happens when your simulation is finished. It is a beautiful sound. The BEEP is an alert to tell you the work is done. The fruit of your simulation is ready to harvest. It is time to review your results. In Simulink, BEEP is a good sound.

Leave your comments, after the BEEP. (THANK YOU Jeannette for alerting me to the difference.)

In a previous post, I answered a question about how to model an If-Else behavior. Here I will restate the algorithm I want to create:

if(sel==0)
out = 2*in1;
elseif (sel==1)
out = 3*in2;

The first answer I gave relied upon a Switch block and the Conditional Input Branch Execution optimization to get an efficient If-Else construct in the model. While this works, I don’t like reliance on an optimization to provide good behavior. Sometimes, small changes to the model prevent Simulink from applying an optimization. I think it is best to implement requirements explicitly. In this post, I want to show you a way to model explicitly an If-Else conditional execution behavior.

Conditionally Executed Subsystems and Merge

The If-Else construct requires decision logic to control the execution of algorithm contained within the expression. One way to do this is using the If block (from the Ports & Subsystems library), combined with the If Action Subsystem. The If Action Subsystem executes based on the conditional expression in the If block. If you have used Function Call subsystems, this is very similar.

The If block provides control over If and ElseIf conditions, and there is even an option to provide an Else signal.

This model will give you the conditional execution of the two subsystem, however, the subsystems write their outputs to separate signals. How do you get two subsystem to write to the same signal?

Merge the Signals

The Merge block provides a way for both subsystems to write to the same signal.

In many ways, the Merge block doesn’t behave like a block with the traditional input/output relationship. I think of it more like a jumper across multiple wires. The merge block specifies that all signals connected to it have the same value and actually share the same memory. This is the programming practice of specifying multiple writers to the same variable.

Generated Code with Merge

The code generated from the above model looks a lot like our original algorithm.

Correct use of Merge

Because Merge blocks are a memory specification rather than an algorithmic construct, there are some guidelines for using merge blocks. The documentation shows some correct and incorrect usage patterns. If you use merge block in your model, I suggest you run the Model Advisor Check for proper Merge block usage.

Now it’s your turn

Do you use the Merge block in your models? Leave a comment here and share your experience.