Struct geo_types::geometry::Coord

pub struct Coord<T: CoordNum = f64> {
    pub x: T,
    pub y: T,
}

A lightweight struct used to store coordinates on the 2-dimensional Cartesian plane.

Unlike Point (which in the future may contain additional information such as an envelope, a precision model, and spatial reference system information), a Coord only contains ordinate values and accessor methods.

This type implements the vector space operations: Add, Sub, Neg, Zero, Mul<T>, and Div<T> traits.

Semantics

This type does not represent any geospatial primitive, but is used in their definitions. The only requirement is that the coordinates it contains are valid numbers (for eg. not f64::NAN).

Fields

x: T

y: T

Implementations

impl<T: CoordNum> Coord<T>

pub fn x_y(&self) -> (T, T)

Returns a tuple that contains the x/horizontal & y/vertical component of the coordinate.

Examples

use geo_types::coord;

let c = coord! {
    x: 40.02f64,
    y: 116.34,
};
let (x, y) = c.x_y();

assert_eq!(y, 116.34);
assert_eq!(x, 40.02f64);

impl<T: CoordNum> Coord<T>

Create a coordinate at the origin.

Examples

use geo_types::Coord;
use num_traits::Zero;

let p: Coord = Zero::zero();

assert_eq!(p.x, 0.);
assert_eq!(p.y, 0.);

pub fn zero() -> Self

Trait Implementations

impl<T: CoordNum> Add for Coord<T>

Add two coordinates.

Examples

use geo_types::coord;

let p = coord! { x: 1.25, y: 2.5 };
let q = coord! { x: 1.5, y: 2.5 };
let sum = p + q;

assert_eq!(sum.x, 2.75);
assert_eq!(sum.y, 5.0);

type Output = Coord<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T: Clone + CoordNum> Clone for Coord<T>

fn clone(&self) -> Coord<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + CoordNum> Debug for Coord<T>

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

Formats the value using the given formatter.

impl<T: Default + CoordNum> Default for Coord<T>

fn default() -> Coord<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Coord<T>

where T: Deserialize<'de> + CoordNum,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: CoordNum> Div<T> for Coord<T>

Divide coordinate wise by a scalar.

Examples

use geo_types::coord;

let p = coord! { x: 5., y: 10. };
let q = p / 4.;

assert_eq!(q.x, 1.25);
assert_eq!(q.y, 2.5);

type Output = Coord<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self

Performs the / operation.

impl<T: CoordNum> From<[T; 2]> for Coord<T>

fn from(coords: [T; 2]) -> Self

Converts to this type from the input type.

impl<T: CoordNum> From<(T, T)> for Coord<T>

fn from(coords: (T, T)) -> Self

Converts to this type from the input type.

impl<T: CoordNum> From<Coord<T>> for [T; 2]

fn from(coord: Coord<T>) -> Self

Converts to this type from the input type.

impl<T: CoordNum> From<Coord<T>> for (T, T)

fn from(coord: Coord<T>) -> Self

Converts to this type from the input type.

impl<T: CoordNum> From<Coord<T>> for Point<T>

fn from(x: Coord<T>) -> Self

Converts to this type from the input type.

impl<T: CoordNum> From<Point<T>> for Coord<T>

fn from(point: Point<T>) -> Self

Converts to this type from the input type.

impl<T: Hash + CoordNum> Hash for Coord<T>

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: CoordNum> Mul<T> for Coord<T>

Multiply coordinate wise by a scalar.

Examples

use geo_types::coord;

let p = coord! { x: 1.25, y: 2.5 };
let q = p * 4.;

assert_eq!(q.x, 5.0);
assert_eq!(q.y, 10.0);

type Output = Coord<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self

Performs the * operation.

impl<T> Neg for Coord<T>

where T: CoordNum + Neg<Output = T>,

Negate a coordinate.

Examples

use geo_types::coord;

let p = coord! { x: 1.25, y: 2.5 };
let q = -p;

assert_eq!(q.x, -p.x);
assert_eq!(q.y, -p.y);

type Output = Coord<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: PartialEq + CoordNum> PartialEq for Coord<T>

fn eq(&self, other: &Coord<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> Serialize for Coord<T>

where T: Serialize + CoordNum,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: CoordNum> Sub for Coord<T>

Subtract a coordinate from another.

Examples

use geo_types::coord;

let p = coord! { x: 1.5, y: 2.5 };
let q = coord! { x: 1.25, y: 2.5 };
let diff = p - q;

assert_eq!(diff.x, 0.25);
assert_eq!(diff.y, 0.);

type Output = Coord<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T: CoordNum> Zero for Coord<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Copy + CoordNum> Copy for Coord<T>

impl<T: Eq + CoordNum> Eq for Coord<T>

impl<T: CoordNum> StructuralPartialEq for Coord<T>