Contents

My First Attempt

Of course I resorted to using MATLAB for the task, despite other options. I chose the following requirements.

Some Sample Names

I first create a list of some sample names so I have a test suite to try out.

names = {'foo_bar','foo_bar_','foo__bar', ...
    'foo_bar__', 'foo_3','foo_3_','foo_3a', ...
    'foo_bar____baz___234___'};
allnames = names'

allnames = 
    'foo_bar'
    'foo_bar_'
    'foo__bar'
    'foo_bar__'
    'foo_3'
    'foo_3_'
    'foo_3a'
    'foo_bar____baz___234___'

My Solution

Let's first try out my solution on these.

for name = names
    disp(camelCase(name{1}));
end

fooBar
fooBar
fooBar
fooBar
foo3
foo3
foo3a
fooBarBaz234

And now let's look at the code.

type camelCase

function y = camelCase(x)
%camelCase Convert name with underscores to camelCase.

% find the underscores 
indall = find(x=='_');
% figure out where consecutive _ are 
% and remove all but the last 
consec = diff(indall)==1;
ind = indall;
ind(consec) = [];

y = x;
y(min(ind+1,end)) = upper(y(min(ind+1,end)));
y(indall) = '';

I first find all the underscores. Then I look for consecutive ones since I really only want the last one in each sequence, since it's the following character that I want to turn into upper case. That is, if a following character exists! So I have to check for that too. I then have an array of indices to upper case (though I allow myself to uppercase _ at the end if it's the last character so I don't have to lengthen my input array; upper('_') is the same as '_'). Now, I go back and use the original indices pointing to all the instances of '_' and remove them. Voila!

History Lesson

And then I got some pangs, because I am well aware that MATLAB supports regular expressions. First some history. Did you know that Stephen Kleene, an American mathematician, was the inventor of regular expressions? He has also been credited with developing a very approachable proof to Gödel's incompleteness theorems. And some punster then said, "Kleeneliness is next to Gödeliness".

Using regexprep

My friend, colleague, and regexp guru, Jason Breslau gave me the regexprep solution to the problem. Using the same names as before, I next show you Jason's magical 1-line expression, producing the same output as my M-file above.

for name = names
    disp(regexprep(name{1}, '_+(\w?)', '${upper($1)}'));
end

fooBar
fooBar
fooBar
fooBar
foo3
foo3
foo3a
fooBarBaz234

Conclusions

My code is still easier for me to understand, and I conclude from that that I should spend some time trying to master regular expressions. In addition, the regular expression code requires no temporary variables, some of which could be large if the input string is long enough. It also occurs to me that regular expressions are a topic worthy of students learning well in college. What do you think? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.6

Contents

Example Code - Open File

Here's the start of a file I've written that opens up an image file for reading, using fopen.

type openImageFile0

function openImageFile0
% openImageFile Open an image file.
fd = fopen('pout.tif');

If I run it, you can see that I never close the file.

openImageFile0()
fids = fopen('all')
filename = fopen(fids(1));
filename(end-30:end)

fids =
     3
ans =
toolbox\images\imdemos\pout.tif

Tidy up now.

fclose(fids(1));

Example Code - Manage Open, Close, and Errors Using try/catch

Now let's look at another version of the code that will close the file it opens before returning.

type openImageFile1

function openImageFile1
% openImageFile1 Open/process file while ensuring file is 
% closed on finish.
try
    fd = fopen('pout.tif');
    if fid == -1
        error('LS:NoImageFile','no such file')
    end
    doMoreHere(fd);
catch Ex
    disp('Can not read file')
end
if fid ~= -1
    fclose(fid);
end

   

You can see that, even with try/catch, since I always want to close the image file, I have some extra logic at the end of the file. And I have to be careful to know whether the error occurs because the file was never opened, or if instead the error occurs in later processing.

Example Code - Use onCleanup to Ensure File Closes

Here's a file roughly equivalent to the first one, but it ensures that the image file is closed when the function is finished running.

type openImageFile2

function openImageFile2
% openImageFile2 Open an image file for further processing.
%   Note: this doesn't do what you want, since the file will
%   be closed after completing and the file identifier won't
%   be active for use upon completion.
fd = fopen('pout.tif');
C = onCleanup(@()fclose(fd));

To see that this works we first check that no files are open, run the function, and make sure that no files are open afterwards.

fb = fopen('all');
openImageFile2()
fp = fopen('all');
noFilesOpen = isequal(fp,fb,[])

noFilesOpen =
     1

Example Code - Use onCleanup and Process After Opening the File

Let's see the next version of the file.

type openImageFile3

function fd = openImageFile3
% openImageFile3 Open an image file for further processing.
%   Note: this doesn't do what you want, since the file will 
%   be closed after completing and the file identifier won't
%   be active for use upon completion.
fd = fopen('pout.tif');
C = onCleanup(@()fclose(fd));

This function returns the file identifier, but as we'll see, the file is closed once the function returns. This means that any processing/reading we were planning to do with the file after calling the open function will not work (since the file will no longer be open).

fb = fp;
fid = openImageFile3()
fp = fopen('all');
noFilesOpen = isequal(fp,fb,[])

fid =
     3
noFilesOpen =
     1

Even though fid is returned from the function call, the file is no longer open. This is because the onCleanup object C is cleared from existence once openImageFile3 completes execution.

Example Code - Use onCleanup and Process and Close File on Completion

Here's the last version of the file for this blog. As long as you call it with 2 outputs, you are good to go.

type openImageFile4

function [fd, C] = openImageFile4
% openImageFile4 Open an image file for further processing.
%   Note: this does what you want, provided you call the 
%   function with both output arguments.  When you are done
%   cleaned up and the onCleanup object will trigger the file
%   closing.

% Don't even open file if function isn't called with 2 outputs.
if nargout < 2
    error('LS:MustHave2Outputs','must call with 2 outputs')
end

fd = fopen('pout.tif');
C = onCleanup(@()fclose(fd));

This version returns the file identifier and the onCleanup object. Once you have processed your file, simply clear the onCleanup object and the file will close.

To see how this might work, we call it from our function that does the processing.

type run4

function y = run4
% run4 processes an image file.
[fid,C] = openImageFile4();
blocksize = 100;
y = [];
while something
    dat = fread(fid,count);
    y = doSomething(y,dat);
    something = update(something);
end

You can see that run4 calls openImageFile4, and then does the required processing. Because C will vanish once run4 completes, the file will be closed.

Other Uses?

The onCleanup object allows you to more cleanly manage resources such as closing files, closing windows (e.g., last week someone mentioned managing instances of waitbar), managing switching directories. What uses do you foresee for the onCleanup object in your work? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.6

Contents

Highlights of Highlights of New Features for MATLAB

Here's a very short list, in no particular order, of some of my favorite new MATLAB features in this release.

What Are Yours?

After perusing the release notes or using R2008a, I wonder what your favorite new features are. Let me know here.

Get the MATLAB code

Published with MATLAB® 7.6

Contents

The Plan

I will explore this idea by creating my own simplified versions of max and min, working only for real vector inputs, not checking for NaNs, and not doing any error checking. Clearly, the code I show is not meant for production but to get to the heart of the algorithm.

Create Data

Here I create a very small test dataset.

n = 10;
x = rand(n,1)

x =
    0.9145
    0.1215
    0.3765
    0.7912
    0.1848
    0.0508
    0.5562
    0.4633
    0.8539
    0.0384

Simplified min function

This function is simple, as advertized.

type mymin

function xmin = mymin(x)
%MYMIN Minimum value of real vector input.
%   MYMIN is a simplified version of MIN that
%   finds the minimum value for
%   real-valued vector.  NaNs are not treated.
xmin = Inf;
for ind = 1:length(x)
    if x(ind) < xmin
        xmin = x(ind);
    end
end

Test mymin Function

Now I compare the result from mymin to the built-in min function in MATLAB.

xmin = mymin(x);
xminML = min(x);
tf = isequal(xmin, xminML)

tf =
     1

Test mymax Function

Do similar testing with mymax.

xmax = mymax(x);
xmaxML = max(x);
tf = isequal(xmax, xmaxML)

tf =
     1

Larger Data

Now I want to do some timing so I will create a much larger array of data.

n = 3e7;
xL = rand(n,1);
tic
xLmin = mymin(xL);
timeMin = toc
tic
xLmax = mymax(xL);
timeMax = toc

timeMin =
    0.7469
timeMax =
    0.7491

Combined Function

Now let me show you my combined function myminmax that loops through the data the same way mymin and mymax did, but does both calculations in the loop together.

type myminmax

function [xmin, xmax] = myminmax(x)
%MYMINMAX Extreme values of real vector input.
%   MYMINMAX is a simplified version of MIN and 
%   MAX combined and finds the
%   minimum  and maximum values for real-valued vector.
%   NaNs are not treated.
xmin = Inf;
xmax = -Inf;
for ind = 1:length(x)
    if x(ind) < xmin
        xmin = x(ind);
    end
    if x(ind) > xmax
        xmax = x(ind);
    end
end

First, let's check that we get the expected results.

[xminNew, xmaxNew] = myminmax(x);
tf = isequal([xminNew xmaxNew], [xmin xmax])

tf =
     1

Time Combined Function

And now let's time the combined function.

tic
[xLminNew xLmaxNew] = myminmax(xL);
timeMinmax = toc

timeMinmax =
    1.0614

Compare Total Times

To compare the times, let's look at the sum for the times calling the individual functions vs. calling the combined one.

t2 = timeMin+timeMax;
format long
disp('Adding separate times     Combined Time')
disp([t2 timeMinmax])

Adding separate times     Combined Time
   1.495988735998570   1.061442445897453

Reset format to default

format short

Worth It?

Is it worth having a combined function for min and max from a speed point of view? I don't know. It depends on many things, including how often it's needed, and if finding the min and max values is one of the dominant time consumers in the overall algorithm. What do you think? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.6

New Simulink Blog on mathworks.com

I'm very pleased to announce that we have a new blog on mathworks.com. We now have Seth on Simulink. Please read his blog for insight into Simulink, how to use it, what are the new features, etc.

Get the MATLAB code

Published with MATLAB® 7.6

Contents

Newsgroup Statistics

Since accumarray has been in MATLAB (7.0, R14), there have been over 100 threads in the MATLAB newsgroup where accumarray arose as a solution.

Recent Questions

One of the more recent threads asks how to aggregate values in one list based on another list. Suppose the lists are

group = [1 2 2 2 3 3]'
data = [6 43 3 4 2 5]'

group =
     1
     2
     2
     2
     3
     3
data =
     6
    43
     3
     4
     2
     5

and the goal is to sum the data in each group. Let's first create the first input argument. accumarray wants the an array of subscripts of the data pertaining to which output value the data belongs to. Since we're just producing a column vector with 3 values, we just append a column of ones to the group vector.

indices = [group ones(size(group))]

indices =
     1     1
     2     1
     2     1
     2     1
     3     1
     3     1

Next We Accumulate

Since the default function for accumulation is sum, we can use the simplest form of accumarray to get the desired results.

sums = accumarray(indices, data)

sums =
     6
    50
     7

Another Way to Accumulate

We can instead accumulate the results by adding 2 input arguments to the function call. These are the a size vector for the output array and a function handle specifying the accumulating function.

sums1 = accumarray(indices, data, [numel(unique(group)) 1], @sum)

sums1 =
     6
    50
     7

It's easy to see that the results from the two function calls are the same.

isequal(sums, sums1)

ans =
     1

Other Accumulation Functions

Sometimes, summing the results isn't what I'm looking for. Having puzzled out the 4 input call syntax, I can now simply replace the accumulation function. To find the maximum values in each group, I use this code.

maxData = accumarray(indices, data, [numel(unique(group)) 1], @max)

maxData =
     6
    43
     5

maxData = accumarray(indices, data, [numel(unique(group)) 1], ...
    @(x)~any(isfinite(x)))

maxData =
     0
     0
     0

data(end) = Inf
maxData = accumarray(indices, data, [numel(unique(group)) 1], ...
    @(x)~any(isfinite(x)))

data =
     6
    43
     3
     4
     2
   Inf
maxData =
     0
     0
     0

maxData = accumarray(indices, data, [numel(unique(group)) 1], ...
    @(x)all(isfinite(x)))

maxData =
     1
     1
     0

Derivative Work

John D'Errico made a more general function consolidator, found on the MathWorks File Exchange to allow you to do some extra aggregation. For example, consolidator allows the aggregation of elements when they are within a specified tolerance and not just identical.

Do You accum?

Some other obvious accumulation functions you might use include sum, max, min, prod. What functions do you use in situations when you aggregate with accumarray? Let me know here.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Systematically Find Plots

I find plots by creating searching for the tag matlab in flickr. I then set up an RSS feed from this search and see updates to the plots whenever I open my feedreader. For what it's worth, I use the Sage feedreader, a plug-in to the Firefox browser. One thing you will see if you do this is that there are some nice MATLAB graphics.

Who's Posting?

One thing you will quickly notice it many beautiful plots from one particular user: Arenamontanus.

Notice Anything Else?

Do you notice anything else interesting among these pictures? If so, share it with us here.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

What Does hypot Compute?

hypot essentially computes the square root of the sum of the squares of 2 inputs. So what's the big deal, right? For "reasonable" input values, there is no big issue.

fhypot = @(a,b) sqrt(abs(a).^2+abs(b).^2);

Other Ways to Compute hypot

Let's create a set of values and compute hypot 3 ways for these: with hypot, fhypot, and sqrt(2)*x. These should all give the same answers, provide a is real and positive.

a = logspace(0,5,6)
format long
aHypot = hypot(a,a)
aFhypot = fhypot(a,a)
aSqrt2 = sqrt(2)*a

a =
           1          10         100        1000       10000      100000
aHypot =
  1.0e+005 *
  Columns 1 through 3
   0.000014142135624   0.000141421356237   0.001414213562373
  Columns 4 through 6
   0.014142135623731   0.141421356237310   1.414213562373095
aFhypot =
  1.0e+005 *
  Columns 1 through 3
   0.000014142135624   0.000141421356237   0.001414213562373
  Columns 4 through 6
   0.014142135623731   0.141421356237310   1.414213562373095
aSqrt2 =
  1.0e+005 *
  Columns 1 through 3
   0.000014142135624   0.000141421356237   0.001414213562373
  Columns 4 through 6
   0.014142135623731   0.141421356237310   1.414213562373095

Results

The results are the same, to within round-off, for the 3 methods here. But what happens if the magnitude of a is larger, near realmax perhaps?

realmax

ans =
    1.797693134862316e+308

For my computer, a 32-bit Windows machine, realmax for doubles is on the order of 10^308. Let's see what happens if a value nearly that large is used with the different versions of hypot.

a = 1e308
aHypot = hypot(a,a)
aFhypot = fhypot(a,a)
aSqrt2 = sqrt(2)*a

a =
    1.000000000000000e+308
aHypot =
    1.414213562373095e+308
aFhypot =
   Inf
aSqrt2 =
    1.414213562373095e+308

What you can see is that the straight-forward method returns Inf instead of a finite answer. And that's why hypot was added to MATLAB, to compute the hypotenuse robustly, avoiding both underflow and overflow.

Get the MATLAB code

Published with MATLAB® 7.5

Contents

Structures - Mental Model

It first helps to understand how MATLAB treats structures and their fields. First clear the workspace.

clear variables
close all

Let's just start with a scalar structure.

mystruct.FirstName = 'Loren';
mystruct.Height = 150

mystruct = 
    FirstName: 'Loren'
       Height: 150

Each field in the structure mystruct appears to be a separate MAT