Struct turtle::Point[−][src]

pub struct Point {
pub x: f64,
pub y: f64,
}

A point in 2D space

Creating a Point

Methods like Turtle::go_to(), Turtle::turn_towards() and Drawing::set_center() all support any type that can be converted into Point. That means that you can pass the same value into those methods in several different ways depending on what you prefer:

// These are equivalent
turtle.go_to([100.0, 40.0]);
turtle.go_to((100.0, 40.0));
// This is equivalent too, but the above examples are easier to type
use turtle::Point;
turtle.go_to(Point {x: 100.0, y: 40.0});

Each of these different styles works because the methods call .into() internally.

assert_eq!(Point {x: 100.0, y: 40.0}, [100.0, 40.0].into());
assert_eq!(Point {x: 100.0, y: 40.0}, (100.0, 40.0).into());

Notice that we need to convert the right side using into() before it can be compared in assert_eq!().

// This will not compile
assert_eq!(Point {x: 100.0, y: 40.0}, [100.0, 40.0]);
assert_eq!(Point {x: 100.0, y: 40.0}, (100.0, 40.0));

Manipulating Points

You can add or subtract points and multiply or divide points by scalar (f64) values. There are a variety of method functions described in the documentation below that provide even more operations.

// Let's say you have two points with f64 values a, b, c, and d
let pt = Point {x: a, y: b};
let pt2 = Point {x: c, y: d};
assert_eq!(pt + pt2, Point {x: a + c, y: b + d});
assert_eq!(pt - pt2, Point {x: a - c, y: b - d});
assert_eq!(pt * 2.0, Point {x: a * 2.0, y: b * 2.0});
assert_eq!(pt2 / 5.0, Point {x: c / 5.0, y: d / 5.0});
assert_eq!(pt2 * 2.0 - pt, Point {x: c * 2.0 - a, y: d * 2.0 - b});

Accessing Point Components

Point supports either using the x and y fields to access its components or using indexing if you prefer that style.

let p = Point {x: 100.0, y: 120.0};

// Get x coordinate
let x = p.x;
assert_eq!(x, 100.0);
assert_eq!(p, x);

// Get y coordinate
let y = p.y;
assert_eq!(y, 120.0);
assert_eq!(p, y);

// With pattern matching
let Point {x, y} = p;
assert_eq!(x, 100.0);
assert_eq!(y, 120.0);

// Modifying x and y
let mut pt: Point = [240.0, 430.0].into();
pt.x = 73.0;
pt.y = 89.0;
assert_eq!(pt.x, 73.0);
assert_eq!(pt.y, 89.0);
// Using indexing
let mut pt2: Point = [100.0, 200.0].into();
pt2 = pt.x;
pt2 = pt.y;
assert_eq!(pt2.x, 73.0);
assert_eq!(pt2.y, 89.0);

Generating Random Points

let pt: Point = random();
assert!(pt.x >= 0.0 && pt.x < 1.0);
assert!(pt.y >= 0.0 && pt.y < 1.0);

See the documentation for the rand module and the section Generating Random Values in a Range for more information.

Fields

The x-coordinate of the Point

The y-coordinate of the Point

Methods

impl Point[src]

pub fn origin() -> Self[src]

Returns a Point that represents the origin of the coordinate system.

For our "cartesian" coordinate system, this is always (0.0, 0.0)

pub fn is_finite(self) -> bool[src]

Returns true if both x and y are finite (neither infinite nor NaN).

pub fn is_normal(self) -> bool[src]

Returns true if both x and y are neither zero, infinite, subnormal, or NaN.

pub fn is_not_normal(self) -> bool[src]

Returns true if both x and y are either zero, infinite, subnormal, or NaN.

pub fn abs(self) -> Self[src]

Computes the absolute value of x and y and returns a new Point

pub fn round(self) -> Self[src]

Returns a new Point with x and y set to the nearest integer to each of their values. Rounds half-way cases away from 0.0.

pub fn min(self, other: Self) -> Self[src]

Returns the minimum x and y coordinates of the two points

let p1 = Point {x: 100.0, y: 203.18};
let p2 = Point {x: 3.0, y: 1029.677};
assert_eq!(p1.min(p2), Point {x: 3.0, y: 203.18});

pub fn max(self, other: Self) -> Self[src]

Returns the maximum x and y coordinates of the two points

let p1 = Point {x: 100.0, y: 203.18};
let p2 = Point {x: 3.0, y: 1029.677};
assert_eq!(p1.max(p2), Point {x: 100.0, y: 1029.677});

pub fn square_len(self) -> f64[src]

Returns the square of the length of this point.

The length of a point is defined as sqrt(x^2 + y^2)

pub fn len(self) -> f64[src]

Returns the length of this point.

The length of a point is defined as sqrt(x^2 + y^2)

pub fn atan2(self) -> f64[src]

Computes the four quadrant arctangent of self.y and self.x.

Trait Implementations

impl Debug for Point[src]

fn fmt(&self, f: &mut Formatter) -> Result[src]

Formats the value using the given formatter. Read more

impl Clone for Point[src]

fn clone(&self) -> Point[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl PartialEq for Point[src]

fn eq(&self, other: &Point) -> bool[src]

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

fn ne(&self, other: &Point) -> bool[src]

This method tests for !=.

impl From<(f64, f64)> for Point[src]

fn from(pt: (f64, f64)) -> Self[src]

Performs the conversion.

impl From<[f64; 2]> for Point[src]

fn from(pt: [f64; 2]) -> Self[src]

Performs the conversion.

impl From<Point> for [f64; 2][src]

fn from(pt: Point) -> Self[src]

Performs the conversion.

impl Add for Point[src]

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output[src]

Performs the + operation.

impl Sub for Point[src]

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output[src]

Performs the - operation.

impl Mul<f64> for Point[src]

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Self::Output[src]

Performs the * operation.

impl Div<f64> for Point[src]

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self::Output[src]

Performs the / operation.

impl Index<usize> for Point[src]

type Output = f64

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output[src]

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Point[src]

fn index_mut(&mut self, index: usize) -> &mut Self::Output[src]

Performs the mutable indexing (container[index]) operation.

impl Spatial for Point[src]

The scalar type.

Subtract

fn scale(&self, scalar: &Self::Scalar) -> Self[src]

Scales with a scalar.

impl Distribution<Point> for Standard[src]

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Point[src]

Generate a random value of T, using rng as the source of randomness.

ⓘImportant traits for DistIter<'a, D, R, T>Important traits for DistIter<'a, D, R, T> impl<'a, D, R, T> Iterator for DistIter<'a, D, R, T> where    D: Distribution<T>,    R: Rng + 'a,  type Item = T;fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where    R: Rng, [src]

Create an iterator that generates random values of T, using rng as the source of randomness. Read more