# [−][src]Struct geo_types::Coordinate

```pub struct Coordinate<T> 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, `[src]

#### `pub fn x_y(&self) -> (T, T)`[src]

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

# Examples

```use geo_types::Coordinate;

let c = Coordinate {
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> Coordinate<T>`[src]

Create a coordinate at the origin.

# Examples

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

let p: Coordinate<f64> = Zero::zero();

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

# Examples

```use geo_types::Coordinate;

let p: Coordinate<_> = (1.25, 2.5).into();
let q: Coordinate<_> = (1.5, 2.5).into();
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.

### `impl<T> Div<T> for Coordinate<T> where    T: CoordNum, `[src]

Divide coordinate wise by a scalar.

# Examples

```use geo_types::Coordinate;

let p: Coordinate<_> = (5., 10.).into();
let q: Coordinate<_> = 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.

### `impl<T> Mul<T> for Coordinate<T> where    T: CoordNum, `[src]

Multiply coordinate wise by a scalar.

# Examples

```use geo_types::Coordinate;

let p: Coordinate<_> = (1.25, 2.5).into();
let q: Coordinate<_> = 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.

### `impl<T> Neg for Coordinate<T> where    T: CoordNum + Neg<Output = T>, `[src]

Negate a coordinate.

# Examples

```use geo_types::Coordinate;

let p: Coordinate<_> = (1.25, 2.5).into();
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.

### `impl<T> Sub<Coordinate<T>> for Coordinate<T> where    T: CoordNum, `[src]

Subtract a coordinate from another.

# Examples

```use geo_types::Coordinate;

let p: Coordinate<_> = (1.5, 2.5).into();
let q: Coordinate<_> = (1.25, 2.5).into();
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.

## Blanket Implementations

### `impl<T> ToOwned for T where    T: Clone, `[src]

#### `type Owned = T`

The resulting type after obtaining ownership.

### `impl<T, U> TryFrom<U> for T where    U: Into<T>, `[src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

### `impl<T, U> TryInto<U> for T where    U: TryFrom<T>, `[src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.