Struct geocoding::Coordinate

pub struct Coordinate<T = f64> where
    T: CoordNum,  {
    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 Coordinate 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> Coordinate<T> where
    T: CoordNum, 

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> Coordinate<T> where
    T: CoordNum, 

Create a coordinate at the origin.

Examples

use geo_types::Coordinate;
use num_traits::Zero;

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

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

pub fn zero() -> Coordinate<T>

Trait Implementations

impl<T> Add<Coordinate<T>> for Coordinate<T> where
    T: CoordNum, 

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 = Coordinate<T>

The resulting type after applying the + operator.

fn add(self, rhs: Coordinate<T>) -> Coordinate<T>

Performs the + operation.

impl<T> Clone for Coordinate<T> where
    T: Clone + CoordNum, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Coordinate<T> where
    T: Debug + CoordNum, 

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

Formats the value using the given formatter.

impl<T> Default for Coordinate<T> where
    T: Default + CoordNum, 

fn default() -> Coordinate<T>

Returns the “default value” for a type.

impl<T> Div<T> for Coordinate<T> where
    T: CoordNum, 

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 = Coordinate<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Coordinate<T>

Performs the / operation.

impl<T> From<[T; 2]> for Coordinate<T> where
    T: CoordNum, 

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

Converts to this type from the input type.

impl<T> From<(T, T)> for Coordinate<T> where
    T: CoordNum, 

fn from(coords: (T, T)) -> Coordinate<T>

Converts to this type from the input type.

impl<T> From<Coordinate<T>> for Point<T> where
    T: CoordNum, 

fn from(x: Coordinate<T>) -> Point<T>

Converts to this type from the input type.

impl<T> From<Point<T>> for Coordinate<T> where
    T: CoordNum, 

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

Converts to this type from the input type.

impl<T> Hash for Coordinate<T> where
    T: Hash + CoordNum, 

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

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> Mul<T> for Coordinate<T> where
    T: CoordNum, 

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 = Coordinate<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Coordinate<T>

Performs the * operation.

impl<T> Neg for Coordinate<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 = Coordinate<T>

The resulting type after applying the - operator.

fn neg(self) -> Coordinate<T>

Performs the unary - operation.

impl<T> PartialEq<Coordinate<T>> for Coordinate<T> where
    T: PartialEq<T> + CoordNum, 

fn eq(&self, other: &Coordinate<T>) -> bool

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

fn ne(&self, other: &Coordinate<T>) -> bool

This method tests for !=.

impl<T> Sub<Coordinate<T>> for Coordinate<T> where
    T: CoordNum, 

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 = Coordinate<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Coordinate<T>) -> Coordinate<T>

Performs the - operation.

impl<T> Zero for Coordinate<T> where
    T: CoordNum, 

fn zero() -> Coordinate<T>

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 for Coordinate<T> where
    T: Copy + CoordNum, 

impl<T> Eq for Coordinate<T> where
    T: Eq + CoordNum, 

impl<T> StructuralEq for Coordinate<T> where
    T: CoordNum, 

impl<T> StructuralPartialEq for Coordinate<T> where
    T: CoordNum,