XTargets Matlab Snippets: Code Repository

need help

Tue May 13 07:02:51 +0000 2008

Can any one have any idea ..........about mouse programming.....in MATLAB.................

In 3 Dimensions.......means 3D point generation/line/curve etc.......using mouse.

Snippets is being retired

Sun Apr 20 13:03:10 +0000 2008

Have moved to a new blog engine and a new url.

http://xtargets.com/blog

This site will stay live for historical purposes but no new content will be added.

Radio Frequency Kill Switch is On ( Acer Wireless Stops Working )

Wed Apr 16 05:03:04 +0000 2008

Today I opened up my three year old acer 3002wlmi laptop to vacuum all the dust out of it in a vain attempt to make the fan a little quieter and the box to run a little less hot.

The vacuuming semi successful I turn the box back on, running Ubuntu 7.10 (Feisty), only to find that the wireless networking is not recognized. The horror of life without internet suddenly struck me. However I found in my bag of bits and old Netgear USB wireless stick. I didn't have much faith in it working but I plugged it in and it worked immediately.

However how to get my built-in wireless working. I ran dmesg and found the following.


[ 124.663287] ipw2200: Radio Frequency Kill Switch is On:
[ 124.663290] Kill switch must be turned off for wireless networking to work.

After nosing around the newsgroups I ended up running the following commands.
mod ipw2200


sudo rmmod ipw2200
sudo modprobe fsam7400
sudo su
sudo modprobe ipw2200
echo_ "1" > /proc/driver/wireless/radio
exit

Not sure if I needed all the above. The line starting "echo" is definitely needed as that is what is started the wireless radio again.

Now all is working again but the fan still runs loud and the box is hot.

Update

The above all gets cleared on reboot. To make it permanent
do.


sudo echo_ fsam7400 >> /etc/modules
sudo echo_ options fsam7400 radio=1 >> etc/modprob.d/options

Liquid Planner : Project Management Tool

Wed Apr 02 19:39:42 +0000 2008

I have been looking for a project management tool for ages, one that doesn't make me curl up inside and want to die and one that helps my team get stuff done rather than waste their time.

Finally stumbled across Liquid Planner which turns out to be an amazing little tool.

The features that I really like are

* Range estimation for tasks.
* Category vs Project views.

LP takes a novel approach to planning. Instead of giving a single point estimate. ie this task will take 10d to complete I estimate that the task will take between 8d and 12d to complete. This uncertainty is percolated up into the estimates for the rollup tasks and eventually to the estimate for the entire project. Range estimates fit my brain better than single point estimates and I think they make me more honest.

The second feature I like is that there are two views of the system.

The category view allows you to do a functional decomposition of the project. Containers can be nested and are navigable via a tree view. So this view is great for design and requirements capture.

The "project view" is again a tree view but items higher up on the screen and containers represent milestones. Containers are nested so you can model intermediate deliverables or sprints within you greater plan.

The project view is orthogonal to the category view and this is important because when designing a view you want to see the functional layout. When planning you want to see the order in which things need to be delivered.

This has solved my one gripe about other tools I see. They are either good for requirements capture or good for scheduling but never for both.

Scheduling works quite well. It performs resource leveling and supports precedes and depends on dependencies. Scheduling is done in the background and you are notified by an icon when the scheduling is finished and you should refresh the screen.

On the downside, here in Europe the site is a bit sluggish but to be fair they are still in beta and the devs seems quite responsive on the forums. As it is in beta it is currently free to sign up to but will eventually cost about $25 USD per user per month. Fair enough if it saves me an hour a month in time.

As a final note the site is a Ruby On Rails application which may excite or turn some people off depending on their religion :)

Joining technorati

Thu Mar 20 20:45:33 +0000 2008

Technorati Profile

Matlab onCleanup fatally flawed?

Thu Mar 20 20:14:51 +0000 2008

Matlab 2008a provides a new function

onCleanup

Loren Shure writes about it here http://blogs.mathworks.com/loren/

However I think the class is fatally flawed.

As I read the Matlab documentation the implementation of onCleanup is fatally flawed and I don’t think anybody should use it unless some things can be clarified.

According to the Matlab documentation

‘the lifecycle of an object ends *sometime* between the time its variable is no longer used inside the function and the end of the function’

The implementation of onCleanup seems to rely on a subtly different interpretation of object lifecyle.

‘the lifecycle of an object ends at the end of the function within which it’s last reference is lost’

This means the following example


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

is broken.

According to Matlab spec C could be deleted any time after it appears in the line

[fid,C] = openImageFile4();

thus deleting the file handle whilst it was being used. It looks like a classic race condition problem.

To be safe you could rewrite the code


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
C;

But somehow I see the Matlab optimiser at some time in the future stripping out such dead code and rendering the trick useless anyway.

Stylistically it is also not obvious to a reader of the code what C is being used for and it’s inclusion in the code could easily be deleted by an eager maintainer unless the ode is accompanied by copious documentation.

There are however neater ways to solve the same problem in other languages.

The Python way:

http://docs.python.org/whatsnew/pep-343.html



with open(’/etc/passwd’, ‘r’) as f:
 for line in f:
 print line

lexical scoping is used to clarify the required lifetime of the file handle f. As well if any exception is thrown from within the block the file is also closed.

The Ruby way:



File.open ‘/etc/passwd’ do |f|
 f.each_line do |l|
 puts l
 end
end

Very similar to the python way and again there is no requirement by the user to provide any cleanup or close functionality. In case of normal block termination or in the event of an error the open function will *always* close the file handle when the block terminates.

The onCleanup functionality could also be dealt with by adding an ensure keyword to the Matlab language as has Ruby and Python.


function do_open(file, flags, action)
 fid = fopen(file, flags)
 try
 action(fid)
 ensure
 fclose(fid)
 end
end

Notice there is no catch above. We don’t want to catch an error we just want to *ensure* that we cleanup if there is an error or not. Any error is propagated to code further upstream to handle. The ensure can be substituted with a catch and rethrow but is a bit uglier as you need to write code to handle closing the file if and if not an error occurs.

Using do_open in Matlab would be like


do_open(’/etc/passwd’, ‘r’, @body)
function body(fid)
 read(fid, 10)
 function_with_error()
end

As is obvious the function definition is kind of superfluous and would be nicer with some kind of multi line anonymous function


do_open(’/etc/passwd’, ‘r’ ) @(fid)
 read(fid, 10)
 function_with_error()
end

C++ lambdas

Mon Mar 10 21:38:06 +0000 2008

I've just noticed that the C++0x standard has just accepted lambda functions as part of the upcoming standard. So you will be able to do



std::vector<int> someList;
int total = 0;
std::for_each(someList.begin(), someList.end(), <>(int x) : [&total] (total += x));
std::cout << total;

It actually comes in two forms, an expression form where a return value is not required for one line quickies and a function form which is surrounded by curly braces and requires a return statement.

Note that Matlab only allows the expression form. Multi line anonymous functions are not possible which is quite strange and limiting.

See < handle
properties (Hidden)
AccountStatus = 'open';
end
% The following properties can be set only by class methods
properties (SetAccess = private)
AccountNumber
AccountBalance = 0;
end
% Define an event called InsufficientFunds
events
InsufficientFunds
end
methods
function BA = BankAccount(AccountNumber,InitialBalance)
BA.AccountNumber = AccountNumber;
BA.AccountBalance = InitialBalance;
% Calling a static method requires the class name
% addAccount registers the InsufficientFunds listener on this instance
AccountManager.addAccount(BA);
end
function deposit(BA,amt)
BA.AccountBalance = BA.AccountBalance + amt;
if BA.AccountBalance > 0
BA.AccountStatus = 'open';
end
end
function withdraw(BA,amt)
if (strcmp(BA.AccountStatus,'closed')&& BA.AccountBalance < 0)
disp(['Account ',num2str(BA.AccountNumber),' has been closed.'])
return
end
newbal = obj.AccountBalance - amt;
BA.AccountBalance = newbal;
% If a withdrawal results in a negative balance,
% trigger the InsufficientFunds event using notify
if newbal < 0
notify(BA,'InsufficientFunds')
end
end % withdraw
end % methods
end % classdef

See Mathworks for more information.

Demangling C++ type information at run time

Fri Feb 15 11:58:38 +0000 2008

Here's a nice way to print the type of an object to an ostream. Handy during debugging when you have nested template horrors shriveling your brain.



#include <cxxabi.h>

template <typename T> struct TypeInfo {
 friend std::ostream &
 operator <<(std::ostream & os, TypeInfo<T> t){
 const std::type_info & ti = typeid(T);

 int status;
 char * realname = abi::__cxa_demangle(ti.name(), 0, 0, &status);
 os << realname;
 free(realname);
 return os;

 }
};

use as



std::cout << TypeInfo<std::vector<std::vector<int> > >() << std::endl

will print

std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >

Convert a string to anything using a function.

Thu Feb 14 16:45:36 +0000 2008

Not sure where this would be usefull but was playing around with the C++ cast operator and came up with this gem. Allows you to assign a string to any type in the declaration.


#!c++!#

int a = strconv("1");

struct strconv {
 std::string s;
 Convert(std::string s):s(s){

 }

 template <typename T> operator T ( ){
 std::istringstream ss(s);
 T t;
 ss >> t;
 return t;
 }

};