Shell Script for running Matlab

This script can be used to run multiple instances of Matlab on OS X.

In /usr/local/bin/matlab,

for i in $*;
do
    params=" $params $d$i"
done

sudo /Applications/MATLAB_R20XXx_Student.app/bin/matlab $params

where /Applications/MATLAB_R20XXx_Student.app/bin/matlab should be your Matlab executable.

Flipping the Y axes in Matlab

In most computer graphics APIs/toolkits, the default Y direction is from top to bottom, i.e. the Y origin (y = 0) is the top and increases as it goes downward. However in most scientific plots, the Y direction is the opposite. The positive Y direction is upwards.
Because of this discrepancy, there is always confusion when drawing images, especially in Matlab (e.g. imagesc). While one possibility would be to flip the data array via flipud, my preferred method is to use the 'ydir' option.

set(gca, 'ydir', 'normal');

This leaves the data as is, no flipping data, and only changes the the plot options, which separates data from presentation. (Model/View)
An interesting point is that the default value for ydir is 'reverse' which is the default direction of most graphics packages.

Timestamps in Matlab

Matlab has a nifty function for taking timestamps to measure the time it takes to run something. The functions are tic and toc.
You start a timer by calling tic then stop it by calling toc. When toc isn't assigned to a variable, it will print a timestamp summary to the console.
You can save a tic_id to use multiple timers.
Here is a simple example that uses the timer ID:

t_id = tic;
your_time_consuming_function();
toc(t_id)

Matlab 2011a on OS X 10.10 Yosemite

I have been able to run Matlab 2011a (Student Version) on Yosemite following the steps below.
The main problem seems to stem from the lack of Java support for the new look-and-feel.

1. Update Java and XQuartz

This may not be a critical component, but keeping Java and XQuartz up-to-date is probably good practice.

Java for OSX 2014-001: http://support.apple.com/kb/dl1572
XQuartz: https://xquartz.macosforge.org/

2. Patch Matlab

Mathworks has released patches for versions 2011a to 2014a.
http://www.mathworks.com/support/bugreports/1098655
The patch will add (compiled Java) files to the app bundle under MATLAB_your_version.app/java/patch/
Without the patch you will randomly get Java null pointer errors caused by missing Aqua look-and-feel(laf) files (files for the old OS X Aqua UI). This will prevent the help dialog from opening.

By now Matlab will run when launched by terminal command line. Trying to run Matlab by clicking the application icon or from a Spotlight search will result in the following error message.

3. Patch Info.plist

Open /Applications/MATLAB_your_version.app/Contents/Info.plist in your text editor of choice. You will need to open it as administrator (using sudo).
The file is an XML file. Find CFBundleVersion. The value for CFBundleVersion will be something like 2.1. Change it to 9.1.
I am not 100% sure what this hack does, but from the looks, it seems like it is bypassing a version check.
By now, everything should be working.

And some thoughts...

Despite an open beta program for OS X 10.10 Yosemite, during which Mathworks seems to have been preparing Matlab 2014b, they apparently did not test the compatibility of previous versions of Matlab with the new OS.
Throughout the beta period and into the first couple of weeks of Yosemite's release, there has been a lot of confusion regarding which versions of Matlab would be supported on Yosemite, especially with versions prior to 2013a. After a period of confusion on Mathworks part, it seems they have settled to support versions 2011a or later.

Given most undergraduate programs last on average 4 years (being a student user myself), I personally think each Matlab version should be supported at least 4 years. Especially when "supporting a release" means patching some missing files and properly reading the OS version. It makes little sense for the relatively expensive software package to have such a randomly short support schedule.

All in all, this may be a good time to move to open source alternatives such as R or Python.

Envelope Detector for Modulated Signals

The following line of code will find the envelope of a modulated signal in Matlab.

env = abs(hilbert(x));

Here is some test code:

% create modulated signal
fc = 100;
fm = 17;
fs = 8000;
t = 0:1/fs:1;
x = sin(2*pi*fc*t) .* (1.5+sin(2*pi*fm*t));

plot(t, x);

%% get modulation envelope
env = abs(hilbert(x));
hold on;
plot(t, env, 'r');
hold off;

Rotating spectrogram

For some unknown reason, by default spectrogram in Matlab has time as the y-axis and frequency as the x-axis. In audio we usually have it the other way around with time as x and frequency as y. There are a number of ways to swap the axes. Matlab's own example in the help documentation uses view(0,90); to rotate the view. (All Matlab plots are actually 3D with an orthographic projection)

My choice is to use 'yaxis' for the flag 'freqloc'.
Eg. spectrogram(x, w, 'yaxis');
This tells the function to put the frequency on the y-axis. Still, why this isn't the default setting is beyond me.

Linking Axes

When using multiple plots, especially subplots, it's possible to link the axes using the (you guessed it) linkaxes function. This function will link the axes so that the plots will move and zoom together, making it easier to compare the plots.

t = (0:(length(rc)-1))/fs;
x = sin(2*pi*1000*t);
y = sin(2*pi*1000*t + pi/4);


subplot(211); plot(t, x); 
ax(1) = gca; 
subplot(212); plot(t, y); 
ax(2) = gca; 
linkaxes(ax, 'xy'); 

Docking Matlab Figures

To dock the figure window in Matlab, create a file named startup.m in Matlab's default directory and add the following line.
set(0,'DefaultFigureWindowStyle','docked')

In case you don't know where the default directory is, open Matlab and enter the command pwd in the command window.

To revert the docking behavior, either change the line in startup.m to
set(0,'DefaultFigureWindowStyle','normal')

or delete startup.m.

Functional Programming in Matlab

It is possible to write functional programming style loops with arrayfun.

Let's start with an lambda function example.

>> y = arrayfun(@(x) x^2,1:10)

y =
     1     4     9    16    25    36    49    64    81   100 

We can also use the function handle @ with custom functions.

testFun.m

function y = testFun(x)

% do something more interesting...
if x > 0.5,
    y = 1;
else,
    y = 0;
end

Code to execute

x = rand(10, 1); % 10 random numbers between 0 and 1
y = arrayfun(@testFun, x);