Comments and Ratings

As long as you
- do not know how to optimize codes like this (in matlab, not in C!)
% -- begin of code --
for i=1:a
    for j=1:b
        y(i,j)=0;
        dia(i,j)=0;
     end
end
% -- end of code --

- do not know the advantages of pre-allocation
- do not the difference between functions and scripts
- uses clc and clear all without a good reason

your function is rather useless to others ...

This submission has several problems.
1. The help section is insufficient: add a H1 line, a clear description how to use this function and what to expect, and add an example.

2. The for-loop is not pre-allocated, and therefore quite slow with large n

3. There are several faster alternatives, for instance
n = 4 ;
R = rem(floor([0:((2^n)-1)].'* pow2(0:-1:-n+1)),2)
(adapted from DEC2BIN)

It is nice to see some improvments Franciso! A couple of additional comments: if your sor worried about speed, I suggest you take a look at logical indexing, and replace all the zeros from the struct command by one call to zeros.

Another point: the behavior for 2D matrices should be explained, especially when the groups are specified. I think you did not intend that behavior. For instance, take a look if the following produces what you want them to produce:

A = rand(3,4) ; allstats(A), allstats(A,1:4), allstats(A,1:3)

With respect to the help, you can add examples of the expected output, besides giving only the calling syntax.

Below is the outline of a more optimized code:
function R = allstats(DATA, GROUP)
if isempty(ver('stats'))
    error('Function requires STATS toolbox.') ;
end
if nargin==1,
    GROUP = ones(numel(DATA),1) ;
    Ngroups = 1 ;
    UniqueGroups = 1 ;
else
    if numel(DATA) ~= numel(GROUP)
        error('Number of elements should match') ;
    end
    UniqueGroups = unique(GROUP) ;
    Ngroups = numel(UniqueGroups) ;
end
Z = nan(Ngroups,1) ;
R = struct('min',Z,'max',Z,'mean',Z) ; % etce
for k=1:Ngroups,
    Q = GROUP == UniqueGroups(k) ; % logical indexing
    R(k).min = nanmin(DATA(Q)) ;
    R(k).max = nanmax(DATA(Q)) ;
    R(k).mean = nanmean(DATA(Q)) ;
end

Here are the first few lines of this script:
%Cronometro.
clc
clear
resp='s';
while (resp=='s')

clc
clear
a=input('Ingrese horas\n\n');
disp(' ')
b=input('Ingrese minutos\n\n');
disp(' ')
c=input('Ingrese segundos\n\n');
disp(' ')

Potential users should be aware that running this script does clear the entire workspace without notice (and it do so twice!), so all your work will be lost.
This script serves no purpose other than being a programming exercise for the author, so why share it here?

Besides the existence of various KEEP functions, more recent versions of ML also know CLEARVARS, making this submission rather superfluous ...

Nice utility! Just a thought, for numerical vectors, this might be more convenient:

C = union(A,B) ;
res = C(histc(A,C) > histc(B,C))

To deal with rows of matrices or cell array strings, one could convert A and B into indices using, e.g., the third output of unique.

I was a little sloppy .. I meant the second output ...

No need for for-loops. In logical2cellstr:

c = cell(size(tf));
c(:) = {'false'} ;
c(tf) = {'true') ;

For cellstr2log, take a look at strcmpi or regexp ...

It was pleasure to find good help though with examples!

Why not simply
kron(A,eyes(SZ))

or, for non-numerical arrays,
X = {'a' 'b' ; [1:3] []}
X(kron(reshape(1:numel(X),size(X)), ones(2,3)))
%ans =
% 'a' 'a' 'a' 'b' 'b' 'b'
% 'a' 'a' 'a' 'b' 'b' 'b'
% [1x3 double] [1x3 double] [1x3 double] [] [] []
% [1x3 double] [1x3 double] [1x3 double] [] [] []

It can be expanded to the ND case using reshape etc ...

Good help though!

If it is all about speed, remove the error checks! For larger numbers the following formula is more appropriate:
exp(gammaln(N+1) - gammaln(K+1) - gammaln(N-K+1)) ;

This is poor in several ways. First of all it is a script that starts with: "clc; clear all; in_img = imread('sofa.JPG'); .." Second, it lacks help and comments. Third, it is poorly written: for instance, not pre-allocation and avoidable loops. Finally, it turns color images into an BW oil-paint sketch ...
As it stands, this submission is useless to anyone but the author. Please learn how to write functions that are flexible and do not destroy the users workspace and that contains help!

@Phil, in 3D the lines would become planes. Is this what you want? You can also take a look at REFLINEXYZ to see if that better fills your needs:
http://www.mathworks.com/matlabcentral/fileexchange/16746

Yes, too simple and its functionality is already abundantly available here of the FEX. However, I should compliment you for the nice help section!

The same can be accomplished more efficiently by a minor change to DEC2BASE.

@Hoi Wong: apparently TMW changed the internals of UNIQUE, so it is no longer backward compatible. I will update this function shortly.

A typical example of a file that has no use for others, written in poor C-style code. Do not bother to download!

Nice programming exercise for duplicating the built-in CHAR function. Please remove.

A few suggestions for improvement:
- check that all necessary output arguments are returned. For instance, this function has hardly any use when called with less than 4 output arguments
- make use of the function persistent, so that one can call the function once to initialize it, and then without arguments to update it, without having to go through all the checks and loops again.
- The coding can be improved: instead of the for-loop "% check end >= start" make use of ANY; "hitflag = ~isempty(hitIndex))" instead of the if-statement; etc ...

You missed the eons!

More importantly, you should provide a proper help section, giving details of the input and expected output.The code is also not that nice. Internal comments are almost lacking. MatLab already offers DEBLANK and STRTRIM for trimming white spaces. Moreover, this function is not needed if you had used cell arrays to store the names. The section of "switch plural(amount), case true, ... case false ..., end is much simpler codes as: if amount>1, ... else ... end.

Finally, is it really useful to know the number of seconds remaining when something took millenia, or even days? This focus on unimportant details reminds me of an old russian joke: A man has saved enough money to buy a car in the old Sovjet-Union. The car-dealer tells him that he can pick up his new car two years from now. The man asks: "In the morning or in the afternoon? ". "Why do you care? It is 2 years from now" the car-dealer replies. "Well", the man says, "the plumber is coming in the morning".

An update that resolves a bug in forward shifts has been submitted. Please wait for version 2.0.

This well-written function inspired me to submit my own version that uses simple matrix operations which should be up soon. Well done John and thanks for the inspiration.

The author should be commended for adding a good help section. Although faster and better algorithms exist, I concur with Husam A. that this is indeed a nice effort, and therefor happily raise my rating.

Some indexing will give you the same result
V = IN(:) ;
idx = hankel(1:numel(V),0:numel(V)-1)
% idx = hankel(1:numel(V)) + hankel(zeros(1,numl(V)),0:numel(V)-1)
OUT = V(ix) ;

Please add a proper help section including a H1 line, syntax and example. At present this submission is completely useless for anyone but the author.

This file contains H1 line , no help section and no comments, which makes it rather useless. First, how will you find the name of this file in the future if you cannot use LOOKFOR. Secondly, even if you find it, how will you know how to use it, if you cannot use HELP. Third, the total lack of comments makes it difficult to decipher what an end-user should do. In other words, it is only useful to someone with some matlab skills already. On the other hand, she or he will probably stick to something more matlab-ish like:

TimeInSecs = 7261 ;
disp(datestr(datenum(0,0,0,0,0,TimeInSecs),'HH:MM:SS'))