# [−][src]Struct nphysics3d::algebra::Velocity2

```#[repr(C)]
pub struct Velocity2<N: RealField> {
pub linear: Vector2<N>,
pub angular: N,
}```

A velocity structure combining both the linear angular velocities of a point.

## Fields

`linear: Vector2<N>`

The linear velocity.

`angular: N`

The angular velocity.

## Methods

### `impl<N: RealField> Velocity2<N>`[src]

#### `pub fn new(linear: Vector2<N>, angular: N) -> Self`[src]

Create velocity from its linear and angular parts.

#### `pub fn from_vectors(linear: Vector2<N>, angular: Vector1<N>) -> Self`[src]

Create velocity from its linear and angular parts.

#### `pub fn angular(w: N) -> Self`[src]

Create a purely angular velocity.

#### `pub fn linear(vx: N, vy: N) -> Self`[src]

Create a purely linear velocity.

#### `pub fn zero() -> Self`[src]

Create a zero velocity.

#### `pub fn between_positions(    start: &Isometry2<N>,     end: &Isometry2<N>,     time: N) -> Self`[src]

Computes the velocity required to move from `start` to `end` in the given `time`.

#### `pub fn angular_vector(&self) -> Vector1<N>`[src]

The angular part of the velocity.

#### `pub fn integrate(&self, dt: N) -> Isometry2<N>`[src]

Compute the displacement due to this velocity integrated during the time `dt`.

#### `pub fn to_transform(&self) -> Isometry2<N>`[src]

Compute the displacement due to this velocity integrated during a time equal to `1.0`.

This is equivalent to `self.integrate(1.0)`.

#### `pub fn as_slice(&self) -> &[N]`[src]

This velocity seen as a slice.

The linear part is stored first.

#### `pub fn as_mut_slice(&mut self) -> &mut [N]`[src]

This velocity seen as a mutable slice.

The linear part is stored first.

#### `pub fn as_vector(&self) -> &Vector3<N>`[src]

This velocity seen as a vector.

The linear part is stored first.

#### `pub fn as_vector_mut(&mut self) -> &mut Vector3<N>`[src]

This velocity seen as a mutable vector.

The linear part is stored first.

#### `pub fn from_vector<S: Storage<N, U3>>(data: &Vector<N, U3, S>) -> Self`[src]

Create a velocity from a vector.

The linear part of the velocity is expected to be first inside of the input vector.

#### `pub fn from_slice(data: &[N]) -> Self`[src]

Create a velocity from a slice.

The linear part of the velocity is expected to be first inside of the input slice.

#### `pub fn shift(&self, shift: &Vector2<N>) -> Self`[src]

Compute the velocity of a point that is located at the coordinates `shift` relative to the point having `self` as velocity.

#### `pub fn rotated(&self, rot: &Rotation2<N>) -> Self`[src]

Rotate each component of `self` by `rot`.

#### `pub fn transformed(&self, iso: &Isometry2<N>) -> Self`[src]

Transform each component of `self` by `iso`.

## Trait Implementations

### `impl<N: RealField> Add<Velocity2<N>> for Velocity2<N>`[src]

#### `type Output = Self`

The resulting type after applying the `+` operator.

### `impl<N: RealField> Mul<N> for Velocity2<N>`[src]

#### `type Output = Self`

The resulting type after applying the `*` operator.

### `impl<N: RealField> Mul<Velocity2<N>> for Inertia2<N>`[src]

#### `type Output = Force2<N>`

The resulting type after applying the `*` operator.

### `impl<N: RealField> Sub<Velocity2<N>> for Velocity2<N>`[src]

#### `type Output = Self`

The resulting type after applying the `-` operator.

## Blanket Implementations

### `impl<T> Same<T> for T`

#### `type Output = T`

Should always be `Self`

### `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.