Contents

try and catch E

You can generate an MException using new syntax for try/catch. As you can see in the following code, you can generate an MException object now. In the catch segment of code, you see I choose to simply display the message here.

a = [3 , 2]
b = [1 ; 7]
try
    c = a + b;
catch myEx
    disp(myEx.message)
end

a =
     3     2
b =
     1
     7
Matrix dimensions must agree.

Here's the full display of this MException.

myEx

myEx =

 MException object with properties:

    identifier: 'MATLAB:dimagree'
       message: 'Matrix dimensions must agree.'
         stack: [4x1 struct]
         cause: {}

In addition to the message, it has a message identifier, information about the calling stack, and a cause (another, often underlying MException). Get the full details on these properties here.

Adding cause

To explain more about what's happened, you can add a cause which is another MException, to the original MException. Here's another way to generate an MException.

newME = MException('Loren:Blog:MExcepExampleAddCause',...
    'Vector orientations don''t match.');
myEx = addCause(myEx,newME)

myEx =

 MException object with properties:

    identifier: 'MATLAB:dimagree'
       message: 'Matrix dimensions must agree.'
         stack: [4x1 struct]
         cause: {[1x1 MException]}

And to see the added cause, extract it.

myEx.cause{1}

ans =

 MException object with properties:

    identifier: 'Loren:Blog:MExcepExampleAddCause'
       message: 'Vector orientations don't match.'
         stack: [0x1 struct]
         cause: {}

What about error?

There is no difference currently between calling error and throwing an exception directly, since error already throws an exception internally. error is essentially implemented as:

  throw(MException(id,msg))

The reason to throw an exception directly now is to add causes.

Can You Use This Feature?

Do you see yourself using this feature in some of your applications? Post here to let me know.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Some Simple Image Processing

Today I am going to use some features from Image Processing Toolbox. You might also benefit from reading Steve's blog on image processing.

Read an Image

Here's a gray-scale image of my tire photo.

I = imread('tire.tif');
whos I
colormap(gray(256))
image(I), axis image, axis off

  Name        Size             Bytes  Class    Attributes

  I         205x232            47560  uint8              

Crop the Image

Next I want to select the hub to look at it more closely. I happen to know that region I want to look at, having already used imcrop interactively earlier to isolate the central portion.

rect = [90 74 41 41]
midI = imcrop(I,rect);
image(midI), axis image, axis off

rect =
    90    74    41    41

Resize the Image

Next, I want to resize the image so I can see details better.

midI5 = imresize(midI,5);
imshow(midI5)

Rotate the Image

Looking at the function imrotate, I see I specify the rotation I want in a counterclockwise sense. Eyeballing the angle, I choose 135 degrees.

midI5r = imrotate(midI5, 135);
imshow(midI5r)

Check the Tire Rotation

Here's the rotated tire. Now you know what kind of car I drove across the country some years ago.

Ir = imrotate(I,135);
imshow(Ir)

Quick Ideas?

Like today's blog, I occasionally enjoy trying out products in addition to MATLAB, in part so I can learn more about a particular domain or discipline. Have you used MATLAB or other MathWorks tools to teach yourself about some new technology or application? If so, please let me know here.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Sample Data Set

Let's create a dataset that has some missing values.

m = 10;
n = 3;
data = randn(m,n);
missing = abs(data) > 1.2;
data(missing) = NaN

data =
   -0.3999       NaN   -1.0106
    0.6900    0.2573    0.6145
    0.8156   -1.0565    0.5077
    0.7119       NaN       NaN
       NaN   -0.8051    0.5913
    0.6686    0.5287   -0.6436
    1.1908    0.2193    0.3803
       NaN   -0.9219   -1.0091
   -0.0198       NaN   -0.0195
   -0.1567   -0.0592   -0.0482

Calculating the Column Means

Now let's calculate the mean of the data, columnwise.

meanc = sum(data)/m

meanc =
   NaN   NaN   NaN

Assuming NaN indicates missing values, the mean that we've just calculated isn't very useful since the NaN values propagate into the mean.

Calculating the Column Means Accounting for NaN Values

Now let's try calculating the mean, while disregarding the missing values. To do so, first we need to find those values. Actually we will do this using logical indexing, a useful concept in MATLAB. We'll generate a matrix with logical values, i.e., true and false, true indicating locations where NaN values do not exist in our data.

notNaN = ~isnan(data)

notNaN =
     1     0     1
     1     1     1
     1     1     1
     1     0     0
     0     1     1
     1     1     1
     1     1     1
     0     1     1
     1     0     1
     1     1     1

Next we find out how many in each column are legitimate data values.

howMany = sum(notNaN)

howMany =
     8     7     9

We replace the missing data values with 0.

data(~notNaN) = 0

data =
   -0.3999         0   -1.0106
    0.6900    0.2573    0.6145
    0.8156   -1.0565    0.5077
    0.7119         0         0
         0   -0.8051    0.5913
    0.6686    0.5287   -0.6436
    1.1908    0.2193    0.3803
         0   -0.9219   -1.0091
   -0.0198         0   -0.0195
   -0.1567   -0.0592   -0.0482

Next we sum those values.

columnTot = sum(data)

columnTot =
    3.5006   -1.8373   -0.6373

And finally we compute the column means.

colMean = columnTot ./ howMany

colMean =
    0.4376   -0.2625   -0.0708

Generalizing to Other Dimensions

Statistics Toolbox contains functionality similar to what we've just stepped through with the function nanmean, and allows you to choose which dimension to calculate the mean along. In addition, the toolbox includes a suite of related functions for dealing with missing data.

Missing Any Data Yourself?

Do you work with data sets that have gaps or missing data? How do you handle them? Post your thoughts here.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Problem Set Up

Let's compute the rank of magic square matrices of various sizes. Each of these rank computations is independent of the others.

n = 400;
ranksSingle = zeros(1,n);

Because I want to compare some speeds, and I have a dual core laptop, I will run for now using a single processor using the new function maxNumCompThreads.

maxNumCompThreads(1);
tic
for ind = 1:n
    ranksSingle(ind) = rank(magic(ind));
end
toc
plot(1:n,ranksSingle, 'b-o', 1:n, 1:n, 'm--')

Elapsed time is 22.641646 seconds.

Zooming in, youI can see a pattern with the odd order magic squares having full rank.

axis([250 280 0 280])

Since each of the rank calculations is independent from the others, we could have distributed these calculations to lots of processors all at once.

Parallel Version

With Distributed Computing Toolbox, you can use up to 4 local workers to prototype a parallel algorithm. Here's what the algorithm for the rank calculations. parMagic uses parfor, a new construct for executing independent passes through a loop. It is part of the MATLAB language, but behaves essentially like a regular for loop if you do not have access to Distributed Computing Toolbox.

dbtype parMagic

1     function ranks = parMagic(n)
2     
3     ranks = zeros(1,n);
4     parfor (ind = 1:n)
5         ranks(ind) = rank(magic(ind));  % last index could be ind,not n-ind+1
6     end

Run Parallel Algorithm and Compare

Let's run the parallel version of the algorithm from parMagic still using a single process and compare results with the original for loop version.

tic
   ranksSingle2 = parMagic(n);
toc
isequal(ranksSingle, ranksSingle2)

Elapsed time is 22.733663 seconds.
ans =
     1

Run in Parallel Locally

Now let's take advantage of the two cores in my laptop, by creating a pool of workers on which to do the calculations using the matlabpool command.

matlabpool local 2
tic
   ranksPar = parMagic(n);
toc

To learn more about the capabilities and limitations of matlabpool, distributed
arrays, and associated parallel algorithms, use   doc matlabpool

We are very interested in your feedback regarding these capabilities.
Please send it to parallel_feedback@mathworks.com.

Submitted parallel job to the scheduler, waiting for it to start.
Connected to a matlabpool session with 2 labs.
Elapsed time is 13.836088 seconds.

Comparison

Did we get the same answer?

isequal(ranksSingle, ranksPar)

ans =
     1

In fact, we did! And the wall clock time sped up pretty decently as well, though not a full factor of 2.

Let me close the matlabpool to finish off the example.

matlabpool close

Sending a stop signal to all the labs...
Waiting for parallel job to finish...
Performing parallel job cleanup...
Done.

Local Workers

With Distributed Computing Toolbox, I can use up to 4 local workers. So why did I choose to use just 2? Because on a dual-core machine, that just doesn't make lots of sense. However, running without a pool, then using a pool of size 1 perhaps, 2 and, and maybe 4 helps me ensure that my algorithm is ready to run in parallel, perhaps for a larger cluster next. To do so additionally requires MATLAB Distributed Computing Engine.

parfor and matlabpool

matlabpool started 2 local matlab workers in the background. parfor in the current "regular" matlab decided how to divide the parfor range among the 2 matlabpool workers as the workers performed the calculations. To learn a bit more about the constraints of code that works in a parfor loop, I recommend you read the portion of documentation on variable classifications.

Do You Have Access to a Cluster?

I wonder if you have access to a clusters Can you see places in your code that could take advantage of some parallelism if you had access to the right hardware? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Possible Uses

There are at least two cases I can think of where being able to refer to specific arguments by position can be useful.

This can be important to users writing code for broad use, where some of the output might need to be written in different languages or the language the output is written in depends on the locale. Not all languages express certain ideas in the same way, and this may necessitate using the arguments in a different order depending on the output language (sort of like cochon jaune in French vs. yellow pig in English).

There are cases in which you might want to reuse an argument when writing out a string (perhaps a string of code or html). Here's a case where we want to have a string and its value match each other; the radio button label is the actual value.

optionName = 'Case';
optionValue = 'Ignore';
s = sprintf(...
    '<input type=radio name="%1$s" value="%2$s"/>%2$s\n', ...
    optionName, optionValue)

s =
<input type=radio name="Case" value="Ignore"/>Ignore

References

Here are some MATLAB references for formatting strings.

Other Uses?

Can you think of cases where you would take advantage of this? Post them here so we can see them!

Get the MATLAB code

Published with MATLAB® 7.5

Contents

The Skinny on maxNumCompThreads

Here's some pertinent information about maxNumCompThreads.

When to Use maxNumCompThreads

The main message here is that you should not generally need to use this function at all! Why? Because we'd like to make MATLAB do the best job possible for you. However, there are some situations where the use of maxNumCompThreads is merited.

If You Find a Performance Issue...

Please let us know if you encounter a situation in which setting maxNumCompThreads manually is necessary for better performance, by contacting Technical Support. It is our intention that you should not need to use maxNumCompThreads and it will help us to improve the code if you notify us of such situations.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Development Environment

Here are some features that help increase my productivity.

Language

Here's a feature that allows me to write more robust code, including managing errors and exceptions correctly.

Mathematics

Of course there's some new math!

Lots More

There are additional MATLAB features in more areas than I typically cover in this blog. Check out the new release. Then post here and let me know which features you find most interesting and useful.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

The Scene

You want to run some code at least once, regardless of any conditions. You might want to run it more often, depending on some conditions.

At Least Once in a while

Here's a couple of solutions using a while construct, while ensuring the main chunk of code is run at least once, even if the stop condition is already met.

  n = 0;
  i = 1;
  while true
       doStuff();
       if (i > n)
           break;
       end
       i = i + 1;
       n = somethingElse();
  end

Here's another way that inverts the logic surrounding the condition and avoids using an explicit break statement. Instead, it has to check to see that currentState is still true.

  n = 0;
  i = 1;
  currentState = true;
  while currentState
       doStuff();
       currentState = (i <= n);
       if currentState,
          i = i + 1;
          n = somethingElse();
       end
  end

I wonder if this version is any better than the first. It is one line longer so currentState can be explicitly set. This might be more readable to some of you, and less so to others.

Taking Care Using for

To make sure the code doStuff runs at least once, we need to take care using a for-loop. The reason for this is that the loop code is guaranteed to not run at all if the loop counter variable is empty. To ensure the code runs once, we need to repeat the code outside the loop. If the code being run is like this example, encapsulated in another function, then it's not so difficult to be sure we've got things right.

If instead of a single function, we have several statements to run, then we have take care to copy all of the code and ensure that we update both sets if we ever have to make some changes.

doStuff will never be run with the following code sample.

  n = 0;
  count = 0;
  for ind = 1:n
      doStuff();
      count = count + 1;
  end

To replicate the run-at-least-once behavior, we need to replicate the code before the loop.

  n = 0;
  count = 0;
  doStuff();
  for ind = 1:n
      doStuff();
      count = count + 1;
  end

Your Style Preferences?

I have to say that having lots of code in the body that might have to be replicated is something I would avoid. So I'd see if I could reasonably stick the bulk of the loop body code in another function. After that, I still have a slight preference for once style over the others, but I'd like to hear your thoughts first.

Which programming style do you prefer here? Using for, while with an explicit condition, while with a break, or do you have an even better code pattern? Post your thoughts here.

Get the MATLAB code

Published with MATLAB® 7.5