# `pymunk.vec2d` Module

This module contain the Vec2d class that is used in all of pymunk when a vector is needed.

The Vec2d class is used almost everywhere in pymunk for 2d coordinates and vectors, for example to define gravity vector in a space. However, pymunk is smart enough to convert tuples or tuple like objects to Vec2ds so you usually do not need to explicitly do conversions if you happen to have a tuple:

    >>> import pymunk
    >>> space = pymunk.Space()
    >>> space.gravity
    Vec2d(0.0, 0.0)
    >>> space.gravity = 3,5
    >>> space.gravity
    Vec2d(3.0, 5.0)
    >>> space.gravity += 2,6
    >>> space.gravity
    Vec2d(5.0, 11.0)

More examples:

    >>> from pymunk.vec2d import Vec2d
    >>> Vec2d(7.3, 4.2)
    Vec2d(7.3, 4.2)
    >>> Vec2d(7.3, 4.2) + Vec2d(1, 2)
    Vec2d(8.3, 6.2)

class pymunk.vec2d.Vec2d(x: float, y: float)

  Bases: `NamedTuple`

  2d vector class, supports vector and scalar operators, and also provides some high level functions.

  __abs__() → float

    Return the length of the Vec2d

        >>> abs(Vec2d(3,4))
        5.0

  __add__(other: Tuple[float, float]) → Vec2d

    Add a Vec2d with another Vec2d or Tuple of size 2

        >>> Vec2d(3,4) + Vec2d(1,2)
        Vec2d(4, 6)
        >>> Vec2d(3,4) + (1,2)
        Vec2d(4, 6)

  __floordiv__(other: float) → Vec2d

    Floor division by a float (also known as integer division)

        >>> Vec2d(3,6) // 2.0
        Vec2d(1.0, 3.0)

  __mul__(other: float) → Vec2d

    Multiply with a float

        >>> Vec2d(3,6) * 2.5
        Vec2d(7.5, 15.0)

  __neg__() → Vec2d

    Return the negated version of the Vec2d

        >>> -Vec2d(1,-2)
        Vec2d(-1, 2)

  __pos__() → Vec2d

    Return the unary pos of the Vec2d.

        >>> +Vec2d(1,-2)
        Vec2d(1, -2)

  __sub__(other: Tuple[float, float]) → Vec2d

    Subtract a Vec2d with another Vec2d or Tuple of size 2

        >>> Vec2d(3,4) - Vec2d(1,2)
        Vec2d(2, 2)
        >>> Vec2d(3,4) - (1,2)
        Vec2d(2, 2)

  __truediv__(other: float) → Vec2d

    Division by a float

        >>> Vec2d(3,6) / 2.0
        Vec2d(1.5, 3.0)

  property angle: float

    The angle (in radians) of the vector

  property angle_degrees: float

    Gets the angle (in degrees) of a vector

  convert_to_basis(x_vector: Tuple[float, float], y_vector: Tuple[float, float]) → Vec2d
  cpvrotate(other: Tuple[float, float]) → Vec2d

    Uses complex multiplication to rotate this vector by the other.

  cpvunrotate(other: Tuple[float, float]) → Vec2d

    The inverse of cpvrotate

  cross(other: Tuple[float, float]) → float
    The cross product between the vector and other vector

      v1.cross(v2) -> v1.x*v2.y - v1.y*v2.x

    Returns:

      The cross product

  dot(other: Tuple[float, float]) → float
    The dot product between the vector and other vector

      v1.dot(v2) -> v1.x*v2.x + v1.y*v2.y

    Returns:

      The dot product

  get_angle_between(other: Tuple[float, float]) → float

    Get the angle between the vector and the other in radians

    Returns:

      The angle

  get_angle_degrees_between(other: Vec2d) → float

    Get the angle between the vector and the other in degrees

    Returns:

      The angle (in degrees)

  get_dist_sqrd(other: Tuple[float, float]) → float

    The squared distance between the vector and other vector It is more efficent to use this method than to call get_distance() first and then do a sqrt() on the result.

    Returns:

      The squared distance

  get_distance(other: Tuple[float, float]) → float

    The distance between the vector and other vector

    Returns:

      The distance

  get_length_sqrd() → float

    Get the squared length of the vector. If the squared length is enough it is more efficient to use this method instead of first calling get_length() or access .length and then do a x**2.

        >>> v = Vec2d(3,4)
        >>> v.get_length_sqrd() == v.length**2
        True

    Returns:

      The squared length

  property int_tuple: Tuple[int, int]

    The x and y values of this vector as a tuple of ints. Uses round() to round to closest int.

        >>> Vec2d(0.9, 2.4).int_tuple
        (1, 2)

  interpolate_to(other: Tuple[float, float], range: float) → Vec2d
  property length: float

    Get the length of the vector.

        >>> Vec2d(10, 0).length
        10.0
        >>> '%.2f' % Vec2d(10, 20).length
        '22.36'

    Returns:

      The length

  normalized() → Vec2d

    Get a normalized copy of the vector Note: This function will return 0 if the length of the vector is 0.

    Returns:

      A normalized vector

  normalized_and_length() → Tuple[Vec2d, float]

    Normalize the vector and return its length before the normalization

    Returns:

      The length before the normalization

  static ones() → Vec2d

    A vector where both x and y is 1

        >>> Vec2d.ones()
        Vec2d(1, 1)

  perpendicular() → Vec2d
  perpendicular_normal() → Vec2d
  projection(other: Tuple[float, float]) → Vec2d

    Project this vector on top of other vector

  rotated(angle_radians: float) → Vec2d

    Create and return a new vector by rotating this vector by angle_radians radians.

    Returns:

      Rotated vector

  rotated_degrees(angle_degrees: float) → Vec2d

    Create and return a new vector by rotating this vector by angle_degrees degrees.

    Returns:

      Rotade vector

  scale_to_length(length: float) → Vec2d

    Return a copy of this vector scaled to the given length.

        >>> '%.2f, %.2f' % Vec2d(10, 20).scale_to_length(20)
        '8.94, 17.89'

  static unit() → Vec2d

    A unit vector pointing up

        >>> Vec2d.unit()
        Vec2d(0, 1)

  x: float

    Alias for field number 0

  y: float

    Alias for field number 1

  static zero() → Vec2d

    A vector of zero length.

        >>> Vec2d.zero()
        Vec2d(0, 0)