7

I need to store an array of size n with values of cos(x) and sin(x), lets say

array[[cos(0.9), sin(0.9)],
      [cos(0.35),sin(0.35)],
      ...]

The arguments of each pair of cos and sin is given by random choice. My code as far as I have been improving it is like this:

def randvector():
""" Generates random direction for n junctions in the unitary circle """
    x = np.empty([n,2])
    theta = 2 * np.pi * np.random.random_sample((n))
    x[:,0] = np.cos(theta)
    x[:,1] = np.sin(theta)
    return x

Is there a shorter way or more effective way to achieve this?

Improve this question
2
  • Please assume that numpy is imported as np Commented Apr 9, 2014 at 2:58
  • 4
    Your code is effective. The shorter is @justhalf's answer and much shorter can be its lambda version. Commented Apr 9, 2014 at 3:18

3 Answers 3

Reset to default
5

Your code is effective enough. And justhalf's answer is not bad I think.

For effective and short, How about this code?

def randvector(n):
    theta = 2 * np.pi * np.random.random_sample((n))
    return np.vstack((np.cos(theta), np.sin(theta))).T

UPDATE

Append cProfile result.

justhalf's

      5 function calls in 4.707 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1    0.001    0.001    4.707    4.707 <string>:1(<module>)
     1    2.452    2.452    4.706    4.706 test.py:6(randvector1)
     1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     1    0.010    0.010    0.010    0.010 {method 'random_sample' of 'mtrand.RandomState' objects}
     1    2.244    2.244    2.244    2.244 {numpy.core.multiarray.array}

OP's

      5 function calls in 0.088 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1    0.000    0.000    0.088    0.088 <string>:1(<module>)
     1    0.079    0.079    0.088    0.088 test.py:9(randvector2)
     1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     1    0.009    0.009    0.009    0.009 {method 'random_sample' of 'mtrand.RandomState' objects}
     1    0.000    0.000    0.000    0.000 {numpy.core.multiarray.empty}

mine

      21 function calls in 0.087 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1    0.000    0.000    0.087    0.087 <string>:1(<module>)
     2    0.000    0.000    0.000    0.000 numeric.py:322(asanyarray)
     1    0.000    0.000    0.002    0.002 shape_base.py:177(vstack)
     2    0.000    0.000    0.000    0.000 shape_base.py:58(atleast_2d)
     1    0.076    0.076    0.087    0.087 test.py:17(randvector3)
     6    0.000    0.000    0.000    0.000 {len}
     1    0.000    0.000    0.000    0.000 {map}
     2    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}
     1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     1    0.009    0.009    0.009    0.009 {method 'random_sample' of 'mtrand.RandomState' objects}
     2    0.000    0.000    0.000    0.000 {numpy.core.multiarray.array}
     1    0.002    0.002    0.002    0.002 {numpy.core.multiarray.concatenate}
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

maybe a time measure can help to decide which one :P (thanks for the vstack introduction)
Can I include the timing of yours in my answer?
2

Your code already looks fine to me, but here are a few more thoughts.

Here's a one-liner. It is marginally slower than your version.

def randvector2(n):
    return np.exp((2.0j * np.pi) * np.random.rand(n, 1)).view(dtype=np.float64)

I get these timings for n=10000

Yours:

1000 loops, best of 3: 716 µs per loop

my shortened version:

1000 loops, best of 3: 834 µs per loop

Now if speed is a concern, your approach is really very good. Another answer shows how to use hstack. That works well. Here is another version that is just a little different from yours and is marginally faster.

def randvector3(n):
    x = np.empty([n,2])
    theta = (2 * np.pi) * np.random.rand(n)
    np.cos(theta, out=x[:,0])
    np.sin(theta, out=x[:,1])
    return x

This gives me the timing:

1000 loops, best of 3: 698 µs per loop

If you have access to numexpr, the following is faster (at least on my machine).

import numexpr as ne
def randvector3(n):
    sample = np.random.rand(n, 1)
    c = 2.0j * np.pi
    return ne.evaluate('exp(c * sample)').view(dtype=np.float64)

This gives me the timing:

1000 loops, best of 3: 366 µs per loop

Honestly though, if I were writing this for anything that wasn't extremely performance intensive, I'd do pretty much the same thing you did. It makes your intent pretty clear to the reader. The version with hstack works well too.

Another quick note: When I run timings for n=10, my one-line version is fastest. When I do n=10000000, the fast pure-numpy version is fastest.

Improve this answer

Comments

-2

You can use list comprehension to make the code a little bit shorter:

def randvector(n):
    return np.array([(np.cos(theta), np.sin(theta)) for theta in 2*np.pi*np.random.random_sample(n)])

But, as IanH mentioned in comments, this is slower. In fact, through my experiment, this is 5x slower, because this doesn't take advantage of NumPy vectorization.

So to answer your question:

Is there a shorter way?

Yes, which is what I give in this answer, although it's only shorter by a few characters (but it saves many lines!)

Is there a more effective (I believe you meant "efficient") way?

I believe the answer to this question, without overly complicating the code, is no, since numpy already optimizes the vectorization (assigning of the cos and sin values to the array)

Timing

Comparing various methods:

OP's randvector: 0.002131 s

My randvector: 0.013218 s

mskimm's randvector: 0.003175 s

So it seems that mskimm's randvector looks good in terms of code length end efficiency =D

Improve this answer

4 Comments

While this is valid Python, it really doesn't take advantage of NumPy's vectorization. It will be considerably slower because you are moving the for loops involved from C (as in the OP's solution) to Python.
+1 @IanH: Yes, I'm conducting timing experiment and it's indeed slower. Will try to experiment more.
Do you guys think it's better to change the question from "shorter or most eff.." to "most eff"? To avoid answers with two answers inside?
The price of "shorter" is too high in your solution. As pointed out the answer is slow. Also, the one-liner is too long, which makes it ugly and hard to read, while OP's solutions is very clear.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.