# [Numpy-discussion] [AstroPy] Rotating and Transforming Vectors--Flight Path of a Celestial Body

Charles R Harris charlesr.harris@gmail....
Sat Dec 19 00:54:01 CST 2009

```On Thu, Dec 17, 2009 at 11:14 PM, Anne Archibald
<peridot.faceted@gmail.com>wrote:

> 2009/12/18 Wayne Watson <sierra_mtnview@sbcglobal.net>:
> > It's starting to come back to me. I found a few old graphics books that
> > get into transformation matrices and such. Yes, earth centered. I ground
> > out some code with geometry and trig that at least gets the first point
> > on the path right. I think I can probably apply a rotation around the
> > x-axis several times with a 1/2 degree rotation for each step towards
> > the north to get the job done.
> >
> > I'm still fairly fresh with Python, and found a little bit of info in a
> > Tentative numpy tutorial. I found this on getting started with matrices:
> >
> > from numpy import matrix
> >
> > Apparently matrix is a class in numpy, and there are many others, linalg
> > I think is one. How
> > does one find all the classes, and are there rules that keep them apart.
> > It was tempting to add
> > import numpy in addition to the above, but how is what is in numpy
> > different that the classes?
> > Is numpy solely class driven? That is, if one does a from as above to
> > get all the classes, does
> > it give all the capabilities that just using import numpy does?
>
> Many things in python are classes; a class is a way of attaching
> relevant functions to a collection of data (more precisely, a class is
> a *type*, defining the interpretation of data; usually they also carry
> a collection of functions to operate on that data). So the central
> feature of numpy is a class, ndarray, that represents a collection of
> values of homogeneous type. This may be one, two, or many-dimensional,
> and there are various operations, including linear algebra, on them
> available in numpy.
>
> The matrix class is a special kind of ndarray in which a number of
> modifications have been made. In particular, the * operator no longer
> does element-wise operations, it does matrix multiplication. There are
> also various rules designed to ensure that matrix objects are always
> two-dimensional. I avoid matrix objects like the plague, but some
> people find them useful.
>
> numpy.linalg is an entirely different beast. It is a *module*, a
> collection of functions (and potentially objects and classes). It is
> like sys or os: you import it and the functions, objects and classes
> it contains become available. This is a basic feature of python. What
> is unusual (but not unique) is that rather than having to explicitly
> import it like:
>
> import numpy
> import numpy.linalg
>
> numpy.linalg.svd(numpy.ones((3,2)))
>
> numpy automatically imports it for you, every time. This is done for
> historical reasons and won't change, but is a wart.
>
> For your purposes, I recommend simply using numpy arrays -
> three-element arrays for vectors, three-by-three for matrices - and
> using the linear algebra functions numpy provides to act on them. For
> example, dot does matrix-matrix, matrix-vector, and vector-vector
> multiplication.
>
>
> Anne
>
> P.S. you can usually write out a rotation explicitly, e.g. as
> [[cos(t), sin(t), 0],
>  [-sin(t), cos(t), 0],
>  [0, 0, 1]]
> but if you want a more general one I believe there's a clever way to
> make it using two reflections. -A
>

Two reflections in two (hyper)planes gives a rotation of twice the angle
between their normals and leaves their intersection invariant. It's hard to
visualize in more than three dimensions ;) It's also a good trick for
rotating vector values in place using only exchanges.

Chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.scipy.org/pipermail/numpy-discussion/attachments/20091218/b91a1e4d/attachment.html
```