Robust

https://docs.rs/robust/1.2.0/robust/
Admin
Robust is a Rust crate providing adaptive precision floating-point arithmetic and fast robust...
Tokens:6,635
Snippets:72
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### CloneToUninit Function (Nightly)

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Performs copy-assignment from self to a mutable pointer to uninitialized memory. This is an experimental, nightly-only API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Implement Any trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides runtime type information for any type T. This is a blanket implementation.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement CloneToUninit trait (Nightly)

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Nightly-only experimental API for cloning data into uninitialized memory. Requires the generic type T to implement Clone.

```rust
impl<T> CloneToUninit for T
where T: Clone,
{
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement StructuralPartialEq for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides structural equality comparison for Coord3D. This is often used in generic contexts.

```rust
impl<T: Into<f64>> StructuralPartialEq for Coord3D<T> {}
```

--------------------------------

### insphere Function Signature

Source: https://docs.rs/robust/1.2.0/robust/fn.insphere.html

This is the function signature for `insphere`. Ensure the first four points have a positive orientation for correct results.

```rust
pub fn insphere<T: Into<f64>>(
    pa: Coord3D<T>,
    pb: Coord3D<T>,
    pc: Coord3D<T>,
    pd: Coord3D<T>,
    pe: Coord3D<T>,
) -> f64
```

--------------------------------

### Implement PartialEq for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Allows for equality comparison between two Coord3D instances. Requires the generic type T to implement PartialEq and Into<f64>.

```rust
impl<T: PartialEq + Into<f64>> PartialEq for Coord3D<T> {
    fn eq(&self, other: &Coord3D<T>) -> bool {
        // ... implementation details ...
    }
    fn ne(&self, other: &Rhs) -> bool {
        // ... implementation details ...
    }
}
```

--------------------------------

### From Implementation

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Provides a way to create a value of type T from another value of type T. It simply returns the argument unchanged.

```rust
fn from(t: T) -> T
```

--------------------------------

### Implement From trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides a way to create an owned value of T from another value of T. This is a blanket implementation.

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T {
        // ... implementation details ...
    }
}
```

--------------------------------

### Into Implementation

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Converts a value of type T into a value of type U, provided that U implements From<T>. This method calls U::from(self).

```rust
fn into(self) -> U
```

--------------------------------

### Implement Clone for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides the ability to create a duplicate of a Coord3D instance. This implementation requires the generic type T to also implement Clone and Into<f64>.

```rust
impl<T: Clone + Into<f64>> Clone for Coord3D<T> {
    fn clone(&self) -> Coord3D<T> {
        // ... implementation details ...
    }
    fn clone_from(&mut self, source: &Self) {
        // ... implementation details ...
    }
}
```

--------------------------------

### PartialEq Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Allows for equality comparison of Coord structs.

```APIDOC
### impl<T: PartialEq + Into<f64>> 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 `!=`.
```

--------------------------------

### StructuralPartialEq Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Provides structural partial equality for the Coord struct.

```APIDOC
### impl<T: Into<f64>> StructuralPartialEq for Coord<T>

```

--------------------------------

### Implement TryFrom trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides a fallible conversion from a value of type U into a value of type T. Requires U to implement Into<T>.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error> {
        // ... implementation details ...
    }
}
```

--------------------------------

### Copy Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Indicates that the Coord struct can be copied.

```APIDOC
### impl<T: Copy + Into<f64>> Copy for Coord<T>

```

--------------------------------

### Clone Trait Implementation for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides cloning capabilities for Coord3D instances.

```APIDOC
### impl<T: Clone + Into<f64>> Clone for Coord3D<T>

#### fn clone(&self) -> Coord3D<T>
Returns a duplicate of the value.
```

```APIDOC
#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### PartialEq Trait Implementation for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Allows for equality comparison between Coord3D instances.

```APIDOC
### impl<T: PartialEq + Into<f64>> PartialEq for Coord3D<T>

#### fn eq(&self, other: &Coord3D<T>) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.
```

```APIDOC
#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.
```

--------------------------------

### TryFrom Implementation

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Attempts to perform a conversion from type U into type T. The `Error` type specifies the error that can occur during conversion. The conversion is performed by `U::into(value)`.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Debug Trait Implementation for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Enables debugging output for Coord3D instances.

```APIDOC
### impl<T: Debug + Into<f64>> Debug for Coord3D<T>

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.
```

--------------------------------

### Implement TryInto trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides a fallible conversion from a value of type T into a value of type U, where U implements TryFrom<T>. This is a blanket implementation.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> {
        // ... implementation details ...
    }
}
```

--------------------------------

### PartialEq Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Allows for equality comparison between Coord instances. The generic type T must implement PartialEq and Into<f64>.

```rust
impl<T: PartialEq + Into<f64>> PartialEq for Coord<T>
fn eq(&self, other: &Coord<T>) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Debug Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Enables debugging for the Coord struct.

```APIDOC
### impl<T: Debug + Into<f64>> Debug for Coord<T>

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.
```

--------------------------------

### Clone Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Provides cloning capabilities for the Coord struct.

```APIDOC
### impl<T: Clone + Into<f64>> Clone for Coord<T>

#### fn clone(&self) -> Coord<T>
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### StructuralPartialEq Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Provides structural partial equality comparison for the Coord struct. The generic type T must implement Into<f64>.

```rust
impl<T: Into<f64>> StructuralPartialEq for Coord<T>
```

--------------------------------

### Implement Into trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Provides a way to convert an owned value of T into an owned value of U, where U implements From<T>. This is a blanket implementation.

```rust
impl<T, U> Into<U> for T
where U: From<T>,
{
    fn into(self) -> U {
        // ... implementation details ...
    }
}
```

--------------------------------

### Clone Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Provides the ability to create a duplicate of a Coord instance. This implementation requires the generic type T to also implement Clone and Into<f64>.

```rust
impl<T: Clone + Into<f64>> Clone for Coord<T>
fn clone(&self) -> Coord<T>
```

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

--------------------------------

### TryInto Implementation

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Attempts to convert a value of type T into a value of type U. The `Error` type specifies the error that can occur during conversion. The conversion is performed by `U::try_from(self)`.

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

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Implement Debug for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Enables the debugging representation of the Coord3D struct. Requires the generic type T to implement Debug and Into<f64>.

```rust
impl<T: Debug + Into<f64>> Debug for Coord3D<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        // ... implementation details ...
    }
}
```

--------------------------------

### orient3d Function

Source: https://docs.rs/robust/1.2.0/robust/fn.orient3d.html

Calculates the orientation of a point `pd` with respect to the plane defined by points `pa`, `pb`, and `pc`. The result indicates whether `pd` is below, above, or coplanar with the plane.

```APIDOC
## orient3d

### Description
Returns a positive value if the point `pd` lies below the plane passing through `pa`, `pb`, and `pc` (“below” is defined so that `pa`, `pb`, and `pc` appear in counterclockwise order when viewed from above the plane). Returns a negative value if `pd` lies above the plane. Returns `0` if they are coplanar.

### Signature
```rust
pub fn orient3d<T: Into<f64>>(
    pa: Coord3D<T>,
    pb: Coord3D<T>,
    pc: Coord3D<T>,
    pd: Coord3D<T>,
) -> f64
```

### Parameters
- `pa` (Coord3D<T>): The first point defining the plane.
- `pb` (Coord3D<T>): The second point defining the plane.
- `pc` (Coord3D<T>): The third point defining the plane.
- `pd` (Coord3D<T>): The point to test the orientation against.

### Returns
- `f64`: A floating-point value indicating the orientation:
  - Positive: `pd` is below the plane.
  - Negative: `pd` is above the plane.
  - Zero: `pd` is coplanar with the plane.
```

--------------------------------

### orient2d Function

Source: https://docs.rs/robust/1.2.0/robust/fn.orient2d.html

Calculates the orientation of three 2D points. Returns a positive value for counterclockwise, negative for clockwise, and zero for collinear points.

```APIDOC
## orient2d

### Description
Returns a positive value if the coordinates `pa`, `pb`, and `pc` occur in counterclockwise order (`pc` lies to the **left** of the directed line defined by coordinates `pa` and `pb`).
Returns a negative value if they occur in clockwise order (`pc` lies to the **right** of the directed line `pa, pb`).
Returns `0` if they are **collinear**.

### Signature
```rust
pub fn orient2d<T: Into<f64>>(pa: Coord<T>, pb: Coord<T>, pc: Coord<T>) -> f64
```
```

--------------------------------

### insphere

Source: https://docs.rs/robust/1.2.0/robust/fn.insphere.html

Returns a positive value if the point `pe` lies inside the sphere passing through `pa`, `pb`, `pc`, and `pd`. Returns a negative value if it lies outside. Returns `0` if the five points are cospherical. The points `pa`, `pb`, `pc`, and `pd` must be ordered so that they have a positive orientation.

```APIDOC
## Function insphere

### Description
Returns a positive value if the point `pe` lies inside the sphere passing through `pa`, `pb`, `pc`, and `pd`. Returns a negative value if it lies outside. Returns `0` if the five points are **cospherical**. The points `pa`, `pb`, `pc`, and `pd` must be ordered so that they have a positive orientation.

### Signature
```rust
pub fn insphere<T: Into<f64>>(
    pa: Coord3D<T>,
    pb: Coord3D<T>,
    pc: Coord3D<T>,
    pd: Coord3D<T>,
    pe: Coord3D<T>,
) -> f64
```

### Parameters
- `pa` (Coord3D<T>): The first point defining the sphere.
- `pb` (Coord3D<T>): The second point defining the sphere.
- `pc` (Coord3D<T>): The third point defining the sphere.
- `pd` (Coord3D<T>): The fourth point defining the sphere.
- `pe` (Coord3D<T>): The point to test against the sphere.

### Returns
- `f64`: A value indicating the position of `pe` relative to the sphere. Positive if inside, negative if outside, zero if cospherical.
```

--------------------------------

### insphere

Source: https://docs.rs/robust

Determines if a point lies inside, outside, or on the sphere defined by four other points. Requires the four defining points to have a positive orientation.

```APIDOC
## insphere

### Description
Returns a positive value if the point `pe` lies inside the sphere passing through `pa`, `pb`, `pc`, and `pd`. Returns a negative value if it lies outside. Returns `0` if the five points are **cospherical**.

### Parameters
- `pa` (Coord3D): First point defining the sphere.
- `pb` (Coord3D): Second point defining the sphere.
- `pc` (Coord3D): Third point defining the sphere.
- `pd` (Coord3D): Fourth point defining the sphere.
- `pe` (Coord3D): The point to test.

### Notes
The points `pa`, `pb`, `pc`, and `pd` must be ordered so that they have a positive orientation.
```

--------------------------------

### orient3d

Source: https://docs.rs/robust/1.2.0/robust/index.html

Determines the orientation of four 3D coordinates. It indicates if the fourth point lies below, above, or on the plane defined by the first three points.

```APIDOC
## orient3d

### Description
Returns a positive value if the point `pd` lies below the plane passing through `pa`, `pb`, and `pc` (“below” is defined so that `pa`, `pb`, and `pc` appear in counterclockwise order when viewed from above the plane). Returns a negative value if `pd` lies above the plane. Returns `0` if they are **coplanar**.
```

--------------------------------

### Copy Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Indicates that the Coord struct can be copied by simply copying its bits. The generic type T must implement Copy and Into<f64>.

```rust
impl<T: Copy + Into<f64>> Copy for Coord<T>
```

--------------------------------

### ToOwned Implementation

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Defines how to create an owned version of a borrowed type, typically by cloning. The associated type `Owned` specifies the owned type.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### orient2d

Source: https://docs.rs/robust

Determines the orientation of three 2D coordinates (counterclockwise, clockwise, or collinear).

```APIDOC
## orient2d

### Description
Returns a positive value if the coordinates `pa`, `pb`, and `pc` occur in counterclockwise order (`pc` lies to the **left** of the directed line defined by coordinates `pa` and `pb`). Returns a negative value if they occur in clockwise order (`pc` lies to the **right** of the directed line `pa, pb`). Returns `0` if they are **collinear**.

### Parameters
- `pa` (Coord): The first point.
- `pb` (Coord): The second point.
- `pc` (Coord): The third point.
```

--------------------------------

### insphere

Source: https://docs.rs/robust/1.2.0/robust/index.html

Determines if a point lies inside, outside, or on the sphere defined by four other points. The four points must have a positive orientation.

```APIDOC
## insphere

### Description
Returns a positive value if the point `pe` lies inside the sphere passing through `pa`, `pb`, `pc`, and `pd`. Returns a negative value if it lies outside. Returns `0` if the five points are **cospherical**.

### NOTE
The points `pa`, `pb`, `pc`, and `pd` must be ordered so that they have a positive orientation.
```

--------------------------------

### Implement BorrowMut trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Allows mutable borrowing of a reference to T from an owned value of T. This is a blanket implementation.

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
{
    fn borrow_mut(&mut self) -> &mut T {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement Borrow trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Allows borrowing a reference to T from an owned value of T. This is a blanket implementation.

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
{
    fn borrow(&self) -> &T {
        // ... implementation details ...
    }
}
```

--------------------------------

### orient2d

Source: https://docs.rs/robust/1.2.0/robust/index.html

Determines the orientation of three 2D coordinates. It indicates if the third point lies to the left, right, or on the directed line defined by the first two points.

```APIDOC
## orient2d

### Description
Returns a positive value if the coordinates `pa`, `pb`, and `pc` occur in counterclockwise order (`pc` lies to the **left** of the directed line defined by coordinates `pa` and `pb`). Returns a negative value if they occur in clockwise order (`pc` lies to the **right** of the directed line `pa, pb`). Returns `0` if they are **collinear**.
```

--------------------------------

### Copy Trait Implementation for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Indicates that Coord3D is a Copy type.

```APIDOC
### impl<T: Copy + Into<f64>> Copy for Coord3D<T>
```

--------------------------------

### Coord Struct Definition

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Defines a generic two-dimensional coordinate structure.

```APIDOC
## Struct Coord

### Summary
```rust
pub struct Coord<T: Into<f64>> {
    pub x: T,
    pub y: T,
}
```

### Description
A two dimensional coordinate.

### Fields
- `x: T`: The x-coordinate.
- `y: T`: The y-coordinate.
```

--------------------------------

### orient3d

Source: https://docs.rs/robust

Determines the position of a point relative to a plane defined by three other points (below, above, or coplanar).

```APIDOC
## orient3d

### Description
Returns a positive value if the point `pd` lies below the plane passing through `pa`, `pb`, and `pc` (“below” is defined so that `pa`, `pb`, and `pc` appear in counterclockwise order when viewed from above the plane). Returns a negative value if `pd` lies above the plane. Returns `0` if they are **coplanar**.

### Parameters
- `pa` (Coord3D): First point defining the plane.
- `pb` (Coord3D): Second point defining the plane.
- `pc` (Coord3D): Third point defining the plane.
- `pd` (Coord3D): The point to test.
```

--------------------------------

### Coord3D Struct Definition

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Defines a three-dimensional coordinate with generic type T. T must be convertible into f64.

```APIDOC
## Struct Coord3D

### Summary
```rust
pub struct Coord3D<T: Into<f64>> {
    pub x: T,
    pub y: T,
    pub z: T,
}
```

### Description
A three dimensional coordinate.

### Fields
* `x: T`
* `y: T`
* `z: T`
```

--------------------------------

### Implement Copy for Coord3D

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Marks the Coord3D struct as copyable. This implies that assignments will create a new copy of the value. Requires the generic type T to implement Copy and Into<f64>.

```rust
impl<T: Copy + Into<f64>> Copy for Coord3D<T> {}
```

--------------------------------

### Define Coord3D Struct

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Defines a generic three-dimensional coordinate struct. The type T must be convertible into f64.

```rust
pub struct Coord3D<T: Into<f64>> {
    pub x: T,
    pub y: T,
    pub z: T,
}
```

--------------------------------

### Debug Implementation for Coord

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Enables the Coord struct to be formatted for debugging purposes. The generic type T must implement Debug and Into<f64>.

```rust
impl<T: Debug + Into<f64>> Debug for Coord<T>
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### incircle

Source: https://docs.rs/robust

Determines if a point lies inside, outside, or on the circle defined by three other points. Requires the three defining points to be in counterclockwise order.

```APIDOC
## incircle

### Description
Returns a positive value if the coordinate `pd` lies **inside** the circle passing through `pa`, `pb`, and `pc`. Returns a negative value if it lies **outside** the circle. Returns `0` if the four points are **cocircular**.

### Parameters
- `pa` (Coord): First point defining the circle.
- `pb` (Coord): Second point defining the circle.
- `pc` (Coord): Third point defining the circle.
- `pd` (Coord): The point to test.

### Notes
The points `pa`, `pb`, and `pc` must be in **counterclockwise order** , or the sign of the result will be reversed.
```

--------------------------------

### incircle

Source: https://docs.rs/robust/1.2.0/robust/index.html

Determines if a point lies inside, outside, or on the circle defined by three other points. The three points must be in counterclockwise order.

```APIDOC
## incircle

### Description
Returns a positive value if the coordinate `pd` lies **inside** the circle passing through `pa`, `pb`, and `pc`. Returns a negative value if it lies **outside** the circle. Returns `0` if the four points are **cocircular**.

### Note
The points `pa`, `pb`, and `pc` must be in **counterclockwise order** , or the sign of the result will be reversed.
```

--------------------------------

### Borrow Function

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Immutably borrows from an owned value. This is part of the Borrow trait implementation.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### incircle

Source: https://docs.rs/robust/1.2.0/robust/fn.incircle.html

Determines if a point lies inside, outside, or on a circle defined by three other points. The order of the first three points is crucial for the sign of the result.

```APIDOC
## incircle

### Description
Returns a positive value if the coordinate `pd` lies **inside** the circle passing through `pa`, `pb`, and `pc`. Returns a negative value if it lies **outside** the circle. Returns `0` if the four points are **cocircular**.

### Parameters
- **pa** (Coord<T>): The first coordinate defining the circle. T must implement Into<f64>.
- **pb** (Coord<T>): The second coordinate defining the circle. T must implement Into<f64>.
- **pc** (Coord<T>): The third coordinate defining the circle. T must implement Into<f64>. Must be in counterclockwise order with pa and pb.
- **pd** (Coord<T>): The coordinate to check against the circle. T must implement Into<f64>.

### Returns
- **f64**: A value indicating the position of `pd` relative to the circle:
  - Positive: `pd` is inside the circle.
  - Negative: `pd` is outside the circle.
  - Zero: `pd` is on the circle (cocircular).

### Note
The points `pa`, `pb`, and `pc` must be in **counterclockwise order**, or the sign of the result will be reversed.
```

--------------------------------

### Type Id Function

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Retrieves the unique type identifier for a given type. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Coord Struct Definition

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Defines a two-dimensional coordinate with generic x and y fields. The type T must be convertible into f64.

```rust
pub struct Coord<T: Into<f64>> {
    pub x: T,
    pub y: T,
}
```

--------------------------------

### BorrowMut Function

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord.html

Mutably borrows from an owned value. This is part of the BorrowMut trait implementation.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### Implement ToOwned trait

Source: https://docs.rs/robust/1.2.0/robust/struct.Coord3D.html

Enables creating an owned version of a type from a borrowed reference, typically by cloning. Requires the generic type T to implement Clone.

```rust
impl<T> ToOwned for T
where T: Clone,
{
    type Owned = T;
    fn to_owned(&self) -> T {
        // ... implementation details ...
    }
    fn clone_into(&self, target: &mut T) {
        // ... implementation details ...
    }
}
```
Tokens:
Raw