numpy issue with concatenating arrays

Question

I am porting some Matlab code to python and I have the following statement in Matlab:

cross([pt1,1]-[pp,0],[pt2,1]-[pp,0]);

pt1, pt2 and pp are 2D points.

So, my corresponding python code looks as follows:

np.cross(np.c_[pt1 - pp, 1], np.c_[pt2 - pp, 1])

The points are defined as:

pt1  = np.asarray((440.0, 59.0))
pt2 = np.asarray((-2546.23, 591.03))
pp = np.asarray([563.,  456.5])

When I execute the statement with the cross product, I get the following error:

ValueError: all the input array dimensions except for the concatenation axis must match exactly

So looking at some other posts, here I thought I would try np.column_stack but I get the same error:

np.cross(np.column_stack((pt1 - pp, 1)), np.column_stack((pt2 - pp, 1)))

I got the following error: ValueError: incompatible dimensions for cross product (dimension must be 2 or 3) — C.Nivs
– C.Nivs, Commented Dec 12, 2018 at 23:25
pt1 - pp = array([-123. , -397.5]), are you hoping to get array([-123. , -397.5, 1])? — Indominus
– Indominus, Commented Dec 12, 2018 at 23:30

Indominus · Accepted Answer · 2018-12-12 23:33:18Z

2

This might be what you are looking for:

np.cross(np.append(pt1-pp, 1), np.append(pt2-pp, 1))

answered Dec 12, 2018 at 23:33

Indominus

1,25815 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Luca Over a year ago

facepalm :)))

Indominus Over a year ago

If you do this type of vector/matrix manipulations a lot, be prepared that the migration from Matlab to Python would make your life a little worse, especially bench-marked to the newer versions of Matlab. Python's matrix syntax is not as concise, also the way numpy handles matrix dimensions is less intuitive than Matlab. Your question is a typical example of numpy not able to easily differentiate a nx1 matrix and a 1xn matrix

hpaulj Over a year ago

While I know what you are driving at, I'd differ in how you phrase it. numpy is perfectly able to distinguish between (1,n) and (n,1) arrays. But it also has (n,) arrays, which apparently are a mystery to someone raised on MATLAB :) And it also has real scalars (not the pseudo 1x1 MATLAB ones). I tend to discourage the use of np.append because it is often misused. Here, though, it is useful, turning the scalar 1 into a 1d array that can be concatenated with the rest.

Indominus Over a year ago

You are absolutely right. What I meant by "easily" is just I like to write arr[i, :] instead of arr[[i], :]. Matlab defaults array dimension to 2 (unless above 2). It is true that it is pseudo, but we humans see and do things in 2-dim. Sorry, I'll stop here before I go completely off topic.

hpaulj · Accepted Answer · 2018-12-13 01:57:26Z

If you use np.r_ instead it works:

In [40]: np.cross(np.r_[pt1 - pp, 1], np.r_[pt2 - pp, 1])
Out[40]: array([-5.32030000e+02, -2.98623000e+03, -1.25246611e+06])

Your pt1 and pp are (2,) arrays. To add a 1 to them you need to use a 1d concatenate, np.r_ for 'row', as opposed to columns.

There are lots of ways of constructing a 3 element array:

In [43]: np.r_[pt1 - pp, 1]
Out[43]: array([-123. , -397.5,    1. ])
In [44]: np.append(pt1 - pp, 1)
Out[44]: array([-123. , -397.5,    1. ])
In [45]: np.concatenate((pt1 - pp, [1]))
Out[45]: array([-123. , -397.5,    1. ])

concatenate is the base operation. The others tweak the 1 to produce a 1d array that can be joined with the (2,) shape array to make a (3,).

Concatenate turns all of its inputs into arrays, if they aren't already: np.concatenate((pt1 - pp, np.array([1]))).

Note that np.c_ docs say it is the equivalent of

np.r_['-1,2,0', index expression]

That initial string expression is a bit complicated. The key point is it tries to concatenate 2d arrays (whereas your pt1 is 1d).

It is like column_stack, joiningn(2,1)arrays to make a(2,n)` array.

In [48]: np.c_[pt1, pt2]
Out[48]: 
array([[  440.  , -2546.23],
       [   59.  ,   591.03]])
In [50]: np.column_stack((pt1, pt2))
Out[50]: 
array([[  440.  , -2546.23],
       [   59.  ,   591.03]])

In MATLAB everything has at least 2 dimensions, and because it is Fortran based, the outer dimensions are last. So in a sense its most natural 'vector' shape is n x 1, a column matrix. numpy is built on Python, with a natural interface to its scalars and nested lists. Order is c based; the initial dimensions are outer most. So numpy code can have true scalars (Python numbers without shape or size), or arrays with 0 or more dimensions. A 'vector' most naturally has shape (n,) (a 1 element tuple). It can easily be reshaped to (1,n) or (n,1) if needed.

If you want a (3,1) array (instead of (3,) shaped), you'd need to use some sort of 'vertical' concatenation, joining a (2,1) array with a (1,1):

In [51]: np.r_['0,2,0', pt1-pp, 1]
Out[51]: 
array([[-123. ],
       [-397.5],
       [   1. ]])
In [53]: np.vstack([(pt1-pp)[:,None], 1])
Out[53]: 
array([[-123. ],
       [-397.5],
       [   1. ]])

(But np.cross wants (n,3) or (3,) arrays, not (3,1)!)

In [58]: np.cross(np.r_['0,2,0', pt1-pp, 1], np.r_['0,2,0', pt2-pp, 1])
...
ValueError: incompatible dimensions for cross product
(dimension must be 2 or 3)

To get around this specify an axis:

In [59]: np.cross(np.r_['0,2,0', pt1-pp, 1], np.r_['0,2,0', pt2-pp, 1], axis=0)
Out[59]: 
array([[-5.32030000e+02],
       [-2.98623000e+03],
       [-1.25246611e+06]])

Study np.cross if you want an example of manipulating dimensions. In this axis=0 case it transposes the arrays so they are (1,3) and then does the calculation.

Collectives™ on Stack Overflow

numpy issue with concatenating arrays

2 Answers 2

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related