Struct Vector

pub struct Vector {
    pub rows: Rows,
    pub columns: Columns,
}

A measurement of distance between two Locations

A Vector is the measurement of distance between two Locations. It supports arithmetic operations with itself, as well as anything which can be converted into a Vector. Currently, Rows, Columns, and Direction all have this property, as well as (Rows, Columns), (Columns, Rows), and (isize, isize) (which is treated as (Rows, Columns)).

Fields

rows: Rows

columns: Columns

Implementations

impl Vector

pub fn new(rows: impl Into<Rows>, columns: impl Into<Columns>) -> Self

Create a new Vector with the given rows and columns.

Example

use gridly::vector::*;

assert_eq!(
    Vector::new(3, 4),
    Vector {
        rows: Rows(3),
        columns: Columns(4),
    },
);

pub const fn zero() -> Vector

Create a zero Vector

Example

use gridly::vector::*;

assert_eq!(Vector::zero(), Vector::new(0, 0));

pub const fn upward(size: isize) -> Vector

Create an upward pointing vector of the given size

use gridly::prelude::*;

assert_eq!(Vector::upward(5), Vector::new(-5, 0))

pub const fn downward(size: isize) -> Vector

Create a downward pointing vector of the given size

use gridly::prelude::*;

assert_eq!(Vector::downward(5), Vector::new(5, 0))

pub const fn leftward(size: isize) -> Vector

Create a leftward pointing vector of the given size

use gridly::prelude::*;

assert_eq!(Vector::leftward(5), Vector::new(0, -5))

pub const fn rightward(size: isize) -> Vector

Create a rightward pointing vector of the given size

use gridly::prelude::*;

assert_eq!(Vector::rightward(5), Vector::new(0, 5))

pub fn in_direction(direction: Direction, length: isize) -> Vector

Create a vector of the given size in the given direction

use gridly::prelude::*;

assert_eq!(Vector::in_direction(Up, 10), Vector::new(-10, 0));

Trait Implementations

impl<T: VectorLike> Add<T> for Vector

type Output = Vector

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Vector

Performs the + operation.

impl<T: VectorLike> AddAssign<T> for Vector

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl Clone for Vector

fn clone(&self) -> Vector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Vector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Vector

fn default() -> Vector

Returns the “default value” for a type.

impl Hash for Vector

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Copy> Mul<T> for Vector

where isize: Mul<T, Output = isize>,

Multiply a vector’s components by a constant factor

type Output = Vector

The resulting type after applying the * operator.

fn mul(self, factor: T) -> Vector

Performs the * operation.

impl<T: Copy> MulAssign<T> for Vector

where isize: MulAssign<T>,

Multiply a vector’s components by a constant factor in-place

fn mul_assign(&mut self, factor: T)

Performs the *= operation.

impl Neg for Vector

type Output = Vector

The resulting type after applying the - operator.

fn neg(self) -> Vector

Performs the unary - operation.

impl<T: VectorLike> PartialEq<T> for Vector

fn eq(&self, rhs: &T) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: VectorLike> PartialOrd<T> for Vector

fn partial_cmp(&self, rhs: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: VectorLike> Sub<T> for Vector

type Output = Vector

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Vector

Performs the - operation.

impl<T: VectorLike> SubAssign<T> for Vector

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: VectorLike> Sum<T> for Vector

fn sum<I: Iterator<Item = T>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl VectorLike for Vector

fn rows(&self) -> Rows

fn columns(&self) -> Columns

fn as_vector(&self) -> Vector

fn manhattan_length(&self) -> isize

Return the manhattan length of the vector. The manhattan length of a vector is the sum of the absolute values of its components.

fn checked_manhattan_length(&self) -> Option<isize>

Return the manhattan length of the vector, or None if there are any overflows.

fn clockwise(&self) -> Vector

Return a new vector, rotated 90 degrees clockwise.

fn anticlockwise(&self) -> Vector

Return a new vector, rotated 90 degrees counterclockwise.

fn reverse(&self) -> Vector

Return a new vector, facing the opposite direction of this one

fn rotate(&self, rotation: Rotation) -> Vector

Return a new vector, rotated by a given rotation

fn get_component<T: Component>(&self) -> T

Generically get either the Rows or Columns of a vector

fn transpose(&self) -> Vector

Swap the rows and columns of this Vector

fn direction(&self) -> Option<Direction>

If the vector is pointing in an orthogonal direction, return that direction

impl Copy for Vector

impl Eq for Vector