Struct gridly::vector::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

#[must_use]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),
    },
);

#[must_use]pub const fn zero() -> Vector

Create a zero Vector

Example

use gridly::vector::*;

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

#[must_use]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))

#[must_use]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))

#[must_use]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))

#[must_use]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))

#[must_use]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.

#[must_use]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 copy of the value.

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

Performs copy-assignment from source.

impl Copy for Vector

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 Eq for Vector

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, 

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.

#[must_use]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.

#[must_use]fn neg(self) -> Vector

Performs the unary - operation.

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

#[must_use]fn eq(&self, rhs: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

#[must_use]fn partial_cmp(&self, rhs: &T) -> Option<Ordering>

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl StructuralEq for Vector

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

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl VectorLike for Vector

#[must_use]fn rows(&self) -> Rows

#[must_use]fn columns(&self) -> Columns

#[must_use]fn as_vector(&self) -> Vector

#[must_use]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.

#[must_use]fn checked_manhattan_length(&self) -> Option<isize>

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

#[must_use]fn clockwise(&self) -> Vector

Return a new vector, rotated 90 degrees clockwise.

#[must_use]fn anticlockwise(&self) -> Vector

Return a new vector, rotated 90 degrees counterclockwise.

#[must_use]fn reverse(&self) -> Vector

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

#[must_use]fn rotate(&self, rotation: Rotation) -> Vector

Return a new vector, rotated by a given rotation

#[must_use]fn get_component<T: Component>(&self) -> T

Generically get either the Rows or Columns of a vector

#[must_use]fn transpose(&self) -> Vector

Swap the rows and columns of this Vector

#[must_use]fn direction(&self) -> Option<Direction>

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