Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

What is the advantage of linspace over the colon ":" operator?

Is there some advantage of writing

t = linspace(0,20,21)

over

t = 0:1:20

?

I understand the former produces a vector, as the first does.
Can anyone state me some situation where linspace is useful over t = 0:1:20?

like image 492
coool Avatar asked Oct 10 '14 05:10

coool


People also ask

What is difference between Linspace and colon in MATLAB?

linspace() gives you exactly 10 elements and scales the numbers to make sure that's true. Colon steps along until the number is more than the ending number and quits without exceeding the ending number.

What does colon operator do?

Colon operator (":") in R is a function that generates regular sequences. It is most commonly used in for loops, to index and to create a vector with increasing or decreasing sequence. It is a binary operator i.e. it takes two arguments.

What does colon operator mean in MATLAB?

The colon is one of the most useful operators in MATLAB®. It can create vectors, subscript arrays, and specify for iterations. example. x = j : k creates a unit-spaced vector x with elements [j,j+1,j+2,...,j+m] where m = fix(k-j) . If j and k are both integers, then this is simply [j,j+1,...,k] .

How does Linspace work in Python?

The linspace() function returns evenly spaced numbers over a specified interval [start, stop]. The endpoint of the interval can optionally be excluded. The starting value of the sequence. The end value of the sequence, unless endpoint is set to False.


3 Answers

It's not just the usability. Though the documentation says:

The linspace function generates linearly spaced vectors. It is similar to the colon operator :, but gives direct control over the number of points.

it is the same, the main difference and advantage of linspace is that it generates a vector of integers with the desired length (or default 100) and scales it afterwards to the desired range. The : colon creates the vector directly by increments.

Imagine you need to define bin edges for a histogram. And especially you need the certain bin edge 0.35 to be exactly on it's right place:

edges = [0.05:0.10:.55];
X = edges == 0.35

edges =   0.0500    0.1500    0.2500    0.3500    0.4500    0.5500
X =  0     0     0     0     0     0

does not define the right bin edge, but:

edges = linspace(0.05,0.55,6);   %// 6 = (0.55-0.05)/0.1+1
X = edges == 0.35

edges =   0.0500    0.1500    0.2500    0.3500    0.4500    0.5500
X =  0     0     0     1     0     0

does.

Well, it's basically a floating point issue. Which can be avoided by linspace, as a single division of an integer is not that delicate, like the cumulative sum of floting point numbers. But as Mark Dickinson pointed out in the comments: You shouldn't rely on any of the computed values being exactly what you expect. That is not what linspace is for. In my opinion it's a matter of how likely you will get floating point issues and how much you can reduce the probabilty for them or how small can you set the tolerances. Using linspace can reduce the probability of occurance of these issues, it's not a security.

That's the code of linspace:

n1 = n-1
c = (d2 - d1).*(n1-1) % opposite signs may cause overflow
if isinf(c)
    y = d1 + (d2/n1).*(0:n1) - (d1/n1).*(0:n1)
else
    y = d1 + (0:n1).*(d2 - d1)/n1
end

To sum up: linspace and colon are reliable at doing different tasks. linspace tries to ensure (as the name suggests) linear spacing, whereas colon tries to ensure symmetry

In your special case, as you create a vector of integers, there is no advantage of linspace (apart from usability), but when it comes to floating point delicate tasks, there may is.

The answer of Sam Roberts provides some additional information and clarifies further things, including some statements of MathWorks regarding the colon operator.

like image 176
Robert Seifert Avatar answered Nov 13 '22 12:11

Robert Seifert


linspace and the colon operator do different things.

linspace creates a vector of integers of the specified length, and then scales it down to the specified interval with a division. In this way it ensures that the output vector is as linearly spaced as possible.

The colon operator adds increments to the starting point, and subtracts decrements from the end point to reach a middle point. In this way, it ensures that the output vector is as symmetric as possible.

The two methods thus have different aims, and will often give very slightly different answers, e.g.

>> a = 0:pi/1000:10*pi;
>> b = linspace(0,10*pi,10001);
>> all(a==b)
ans =
     0
>> max(a-b)
ans =
   3.5527e-15

In practice, however, the differences will often have little impact unless you are interested in tiny numerical details. I find linspace more convenient when the number of gaps is easy to express, whereas I find the colon operator more convenient when the increment is easy to express.

See this MathWorks technical note for more detail on the algorithm behind the colon operator. For more detail on linspace, you can just type edit linspace to see exactly what it does.

like image 10
Sam Roberts Avatar answered Nov 13 '22 10:11

Sam Roberts


linspace is useful where you know the number of elements you want rather than the size of the "step" between them. So if I said make a vector with 360 elements between 0 and 2*pi as a contrived example it's either going to be

linspace(0, 2*pi, 360)

or if you just had the colon operator you would have to manually calculate the step size:

0:(2*pi - 0)/(360-1):2*pi

linspace is just more convenient

For a simple real world application, see this answer where linspace is helpful in creating a custom colour map

like image 9
Dan Avatar answered Nov 13 '22 11:11

Dan