Goulib.geom.Vector2¶

class Goulib.geom.Vector2(*args)[source]

Bases: object

Mutable 2D vector:

Construct a vector in the obvious way:

>>> Vector2(1.5, 2.0)
Vector2(1.50, 2.00)

>>> Vector3(1.0, 2.0, 3.0)
Vector3(1.00, 2.00, 3.00)

Element access

Components may be accessed as attributes (examples that follow use Vector3, but all results are similar for Vector2, using only the x and y components):

>>> v = Vector3(1, 2, 3)
>>> v.x
1
>>> v.y
2
>>> v.z
3

Vectors support the list interface via slicing:

>>> v = Vector3(1, 2, 3)
>>> len(v)
3
>>> v
1
>>> v[:]
(1, 2, 3)

You can also “swizzle” the components (a la GLSL or Cg):

>>> v = Vector3(1, 2, 3)
>>> v.xyz
(1, 2, 3)
>>> v.zx
(3, 1)
>>> v.zzzz
(3, 3, 3, 3)

Operators

Addition and subtraction are supported via operator overloading (note that in-place operators perform faster than those that create a new object):

>>> v1 = Vector3(1, 2, 3)
>>> v2 = Vector3(4, 5, 6)
>>> v1 + v2
Vector3(5.00, 7.00, 9.00)
>>> v1 -= v2
>>> v1
Vector3(-3.00, -3.00, -3.00)

Multiplication and division can be performed with a scalar only:

>>> Vector3(1, 2, 3) * 2
Vector3(2.00, 4.00, 6.00)
>>> v1 = Vector3(1., 2., 3.)
>>> v1 /= 2
>>> v1
Vector3(0.50, 1.00, 1.50)

The magnitude of a vector can be found with abs:

>>> v = Vector3(1., 2., 3.)
>>> abs(v)
3.7416573867739413

A vector can be normalized in-place (note that the in-place method also returns self, so you can chain it with further operators):

>>> v = Vector3(1., 2., 3.)
>>> v.normalize()
Vector3(0.27, 0.53, 0.80)
>>> v
Vector3(0.27, 0.53, 0.80)

The following methods do not alter the original vector or their arguments:

magnitude()

Returns the magnitude of the vector; equivalent to abs(v). Example:

>>> v = Vector3(1., 2., 3.)
>>> v.magnitude()
3.7416573867739413
magnitude_squared()

Returns the sum of the squares of each component. Useful for comparing the length of two vectors without the expensive square root operation. Example:

>>> v = Vector3(1., 2., 3.)
>>> v.magnitude_squared()
14.0
normalized()

Return a unit length vector in the same direction. Note that this method differs from normalize in that it does not modify the vector in-place. Example:

>>> v = Vector3(1., 2., 3.)
>>> v.normalized()
Vector3(0.27, 0.53, 0.80)
>>> v
Vector3(1.00, 2.00, 3.00)
dot(other)

Return the scalar “dot” product of two vectors. Example:

>>> v1 = Vector3(1., 2., 3.)
>>> v2 = Vector3(4., 5., 6.)
>>> v1.dot(v2)
32.0
cross() and cross(other)

Return the cross product of a vector (for Vector2), or the cross product of two vectors (for Vector3). The return type is a vector. Example:

>>> v1 = Vector3(1., 2., 3.)
>>> v2 = Vector3(4., 5., 6.)
>>> v1.cross(v2)
Vector3(-3.00, 6.00, -3.00)

In two dimensions there can be no argument to cross:

>>> v1 = Vector2(1., 2.)
>>> v1.cross()
Vector2(2.00, -1.00)
reflect(normal)

Return the vector reflected about the given normal. In two dimensions, normal is the normal to a line, in three dimensions it is the normal to a plane. The normal must have unit length. Example:

>>> v = Vector3(1., 2., 3.)
>>> v.reflect(Vector3(0, 1, 0))
Vector3(1.00, -2.00, 3.00)
>>> v = Vector2(1., 2.)
>>> v.reflect(Vector2(1, 0))
Vector2(-1.00, 2.00)
rotate_around(axes, theta)

For 3D vectors, return the vector rotated around axis by the angle theta.

>>> v = Vector3(1., 2., 3.)
>>> axes = Vector3(1.,1.,0)
>>> v.rotate_around(axes,math.pi/4)
Vector3(2.65, 0.35, 2.62)

Constructor. :param *args: x,y values

__init__(*args)[source]

Constructor. :param *args: x,y values

Methods

 __init__(*args) Constructor. angle([other, unit]) angle between two vectors. cross() dot(other) mag() mag2() normalize() normalized() project(other) Return the projection (the component) of the vector on other. reflect(normal)

Attributes

length
xy
return: tuple (x,y)
__init__(*args)[source]

Constructor. :param *args: x,y values

xy
Returns: tuple (x,y)
__repr__()[source]

Return repr(self).

__hash__()[source]

Return hash(self).

__eq__(other)[source]

Tests for equality include comparing against other sequences:

>>> v2 = Vector2(1, 2)
>>> v2 == Vector2(3, 4)

False >>> v2 != Vector2(1, 2) False >>> v2 == (1, 2) True

>>> v3 = Vector3(1, 2, 3)
>>> v3 == Vector3(3, 4, 5)
False
>>> v3 != Vector3(1, 2, 3)
False
>>> v3 == (1, 2, 3)
True
__len__()[source]
__iter__()[source]
__sub__(other)[source]
__rsub__(other)[source]

Point2 - Vector 2 substraction :param other: Point2 or (x,y) tuple :return: Vector2

__mul__(other)[source]
__rmul__(other)
__imul__(other)[source]
__div__(other)[source]
__rdiv__(other)[source]
__floordiv__(other)[source]
__rfloordiv__(other)[source]
__truediv__(other)[source]
__rtruediv__(other)[source]
__neg__()[source]
__pos__()[source]
__abs__()[source]
mag()
length
mag2()[source]
normalize()[source]
normalized()[source]
dot(other)[source]
cross()[source]
reflect(normal)[source]
angle(other=None, unit=False)[source]

angle between two vectors. :param unit: bool True if vectors are unit vectors. False increases computations :return: float angle in radians to the other vector, or self direction if other=None

project(other)[source]

Return the projection (the component) of the vector on other.