Struct aljabar::Vector

#[repr(transparent)]
pub struct Vector<T, const N: usize>(_);

N-element vector.

Vectors can be constructed from arrays of any type and size. There are convenience constructor functions provided for the most common sizes.

let a: Vector::<u32, 4> = vec4( 0u32, 1, 2, 3 );
assert_eq!(
    a, 
    Vector::<u32, 4>::from([ 0u32, 1, 2, 3 ])
);

Swizzling

Swizzling is supported for up to four elements. Swizzling is a technique for easily rearranging and accessing elements of a vector, used commonly in graphics shader programming. Swizzling is available on vectors whose element type implements Clone.

Single-element accessors return the element itself. Multi-element accessors return vectors of the appropriate size.

Element names

Only the first four elements of a vector may be swizzled. If you have vectors larger than length four and want to manipulate their elements, you must do so manually.

Because swizzling is often used in compute graphics contexts when dealing with colors, both 'xyzw' and 'rgba' element names are available.

Element Index	xyzw Name	rgba Name
0	x	r
1	y	g
2	z	b
3	w	a

Restrictions

It is a compilation error to attempt to access an element beyond the bounds of a vector. For example, vec2(1i32, 2).z() would fail because z() is only available on vectors of length 3 or greater.

let z = vec2(1i32, 2).z(); // Fails to compile.

Mixing

Swizzle methods are not implemented for mixed xyzw/rgba methods.

let v = vec4(1i32, 2, 3, 4);
let xy = v.xy(); // OK, only uses xyzw names.
let ba = v.ba(); // OK, only uses rgba names.
assert_eq!(xy, vec2(1i32, 2));
assert_eq!(ba, vec2(3i32, 4));

let v = vec4(1i32, 2, 3, 4);
let bad = v.xyrg(); // Compile error, mixes xyzw and rgba names.

Examples

To get the first two elements of a 4-vector.

let v = vec4(1i32, 2, 3, 4).xy();

To get the first and last element of a 4-vector.

let v = vec4(1i32, 2, 3, 4).xw();

To reverse the order of a 3-vector.

let v = vec3(1i32, 2, 3).zyx();

To select the first and third elements into the second and fourth elements, respectively.

let v = vec4(1i32, 2, 3, 4).xxzz();

Methods

impl<T, const N: usize> Vector<T, { N }>

pub fn transpose(self) -> Matrix<T, 1, { N }>

Converts the Vector into a Matrix with N columns each of size 1.

let v = vec4(1i32, 2, 3, 4);
let m = Matrix::<i32, 1, 4>::from([
    vec1(1i32),
    vec1(2),
    vec1(3),
    vec1(4),
]);
assert_eq!(v.tranpose(), m);

pub fn trunc(self) -> (TruncatedVector<T, { N }>, T)

Drop the last component and return the vector with one fewer dimension.

impl<T, const N: usize> Vector<T, { N }> where
    T: Clone, 

pub fn first<const M: usize>(&self) -> Vector<T, { M }>

Returns the first M elements of self in an appropriately sized Vector.

Calling first with M > N is a compile error.

pub fn last<const M: usize>(&self) -> Vector<T, { M }>

Returns the last M elements of self in an appropriately sized Vector.

Calling last with M > N is a compile error.

pub fn x(&self) -> T

Alias for .get(0).clone().

Calling x on a Vector with N = 0 is a compile error.

pub fn y(&self) -> T

Alias for .get(1).clone().

Calling y on a Vector with N < 2 is a compile error.

pub fn z(&self) -> T

Alias for .get(2).clone().

Calling z on a Vector with N < 3 is a compile error.

pub fn w(&self) -> T

Alias for .get(3).clone().

Calling w on a Vector with N < 4 is a compile error.

pub fn r(&self) -> T

Alias for .x().

pub fn g(&self) -> T

Alias for .y().

pub fn b(&self) -> T

Alias for .z().

pub fn a(&self) -> T

Alias for .w().

pub fn xx(&self) -> Vector<T, 2>

pub fn xxx(&self) -> Vector<T, 3>

pub fn xxxx(&self) -> Vector<T, 4>

pub fn xxxy(&self) -> Vector<T, 4>

pub fn xxxz(&self) -> Vector<T, 4>

pub fn xxxw(&self) -> Vector<T, 4>

pub fn xxy(&self) -> Vector<T, 3>

pub fn xxyx(&self) -> Vector<T, 4>

pub fn xxyy(&self) -> Vector<T, 4>

pub fn xxyz(&self) -> Vector<T, 4>

pub fn xxyw(&self) -> Vector<T, 4>

pub fn xxz(&self) -> Vector<T, 3>

pub fn xxzx(&self) -> Vector<T, 4>

pub fn xxzy(&self) -> Vector<T, 4>

pub fn xxzz(&self) -> Vector<T, 4>

pub fn xxzw(&self) -> Vector<T, 4>

pub fn xxw(&self) -> Vector<T, 3>

pub fn xxwx(&self) -> Vector<T, 4>

pub fn xxwy(&self) -> Vector<T, 4>

pub fn xxwz(&self) -> Vector<T, 4>

pub fn xxww(&self) -> Vector<T, 4>

pub fn xy(&self) -> Vector<T, 2>

pub fn xyx(&self) -> Vector<T, 3>

pub fn xyxx(&self) -> Vector<T, 4>

pub fn xyxy(&self) -> Vector<T, 4>

pub fn xyxz(&self) -> Vector<T, 4>

pub fn xyxw(&self) -> Vector<T, 4>

pub fn xyy(&self) -> Vector<T, 3>

pub fn xyyx(&self) -> Vector<T, 4>

pub fn xyyy(&self) -> Vector<T, 4>

pub fn xyyz(&self) -> Vector<T, 4>

pub fn xyyw(&self) -> Vector<T, 4>

pub fn xyz(&self) -> Vector<T, 3>

pub fn xyzx(&self) -> Vector<T, 4>

pub fn xyzy(&self) -> Vector<T, 4>

pub fn xyzz(&self) -> Vector<T, 4>

pub fn xyzw(&self) -> Vector<T, 4>

pub fn xyw(&self) -> Vector<T, 3>

pub fn xywx(&self) -> Vector<T, 4>

pub fn xywy(&self) -> Vector<T, 4>

pub fn xywz(&self) -> Vector<T, 4>

pub fn xyww(&self) -> Vector<T, 4>

pub fn xz(&self) -> Vector<T, 2>

pub fn xzx(&self) -> Vector<T, 3>

pub fn xzxx(&self) -> Vector<T, 4>

pub fn xzxy(&self) -> Vector<T, 4>

pub fn xzxz(&self) -> Vector<T, 4>

pub fn xzxw(&self) -> Vector<T, 4>

pub fn xzy(&self) -> Vector<T, 3>

pub fn xzyx(&self) -> Vector<T, 4>

pub fn xzyy(&self) -> Vector<T, 4>

pub fn xzyz(&self) -> Vector<T, 4>

pub fn xzyw(&self) -> Vector<T, 4>

pub fn xzz(&self) -> Vector<T, 3>

pub fn xzzx(&self) -> Vector<T, 4>

pub fn xzzy(&self) -> Vector<T, 4>

pub fn xzzz(&self) -> Vector<T, 4>

pub fn xzzw(&self) -> Vector<T, 4>

pub fn xzw(&self) -> Vector<T, 3>

pub fn xzwx(&self) -> Vector<T, 4>

pub fn xzwy(&self) -> Vector<T, 4>

pub fn xzwz(&self) -> Vector<T, 4>

pub fn xzww(&self) -> Vector<T, 4>

pub fn xw(&self) -> Vector<T, 2>

pub fn xwx(&self) -> Vector<T, 3>

pub fn xwxx(&self) -> Vector<T, 4>

pub fn xwxy(&self) -> Vector<T, 4>

pub fn xwxz(&self) -> Vector<T, 4>

pub fn xwxw(&self) -> Vector<T, 4>

pub fn xwy(&self) -> Vector<T, 3>

pub fn xwyx(&self) -> Vector<T, 4>

pub fn xwyy(&self) -> Vector<T, 4>

pub fn xwyz(&self) -> Vector<T, 4>

pub fn xwyw(&self) -> Vector<T, 4>

pub fn xwz(&self) -> Vector<T, 3>

pub fn xwzx(&self) -> Vector<T, 4>

pub fn xwzy(&self) -> Vector<T, 4>

pub fn xwzz(&self) -> Vector<T, 4>

pub fn xwzw(&self) -> Vector<T, 4>

pub fn xww(&self) -> Vector<T, 3>

pub fn xwwx(&self) -> Vector<T, 4>

pub fn xwwy(&self) -> Vector<T, 4>

pub fn xwwz(&self) -> Vector<T, 4>

pub fn xwww(&self) -> Vector<T, 4>

pub fn yx(&self) -> Vector<T, 2>

pub fn yxx(&self) -> Vector<T, 3>

pub fn yxxx(&self) -> Vector<T, 4>

pub fn yxxy(&self) -> Vector<T, 4>

pub fn yxxz(&self) -> Vector<T, 4>

pub fn yxxw(&self) -> Vector<T, 4>

pub fn yxy(&self) -> Vector<T, 3>

pub fn yxyx(&self) -> Vector<T, 4>

pub fn yxyy(&self) -> Vector<T, 4>

pub fn yxyz(&self) -> Vector<T, 4>

pub fn yxyw(&self) -> Vector<T, 4>

pub fn yxz(&self) -> Vector<T, 3>

pub fn yxzx(&self) -> Vector<T, 4>

pub fn yxzy(&self) -> Vector<T, 4>

pub fn yxzz(&self) -> Vector<T, 4>

pub fn yxzw(&self) -> Vector<T, 4>

pub fn yxw(&self) -> Vector<T, 3>

pub fn yxwx(&self) -> Vector<T, 4>

pub fn yxwy(&self) -> Vector<T, 4>

pub fn yxwz(&self) -> Vector<T, 4>

pub fn yxww(&self) -> Vector<T, 4>

pub fn yy(&self) -> Vector<T, 2>

pub fn yyx(&self) -> Vector<T, 3>

pub fn yyxx(&self) -> Vector<T, 4>

pub fn yyxy(&self) -> Vector<T, 4>

pub fn yyxz(&self) -> Vector<T, 4>

pub fn yyxw(&self) -> Vector<T, 4>

pub fn yyy(&self) -> Vector<T, 3>

pub fn yyyx(&self) -> Vector<T, 4>

pub fn yyyy(&self) -> Vector<T, 4>

pub fn yyyz(&self) -> Vector<T, 4>

pub fn yyyw(&self) -> Vector<T, 4>

pub fn yyz(&self) -> Vector<T, 3>

pub fn yyzx(&self) -> Vector<T, 4>

pub fn yyzy(&self) -> Vector<T, 4>

pub fn yyzz(&self) -> Vector<T, 4>

pub fn yyzw(&self) -> Vector<T, 4>

pub fn yyw(&self) -> Vector<T, 3>

pub fn yywx(&self) -> Vector<T, 4>

pub fn yywy(&self) -> Vector<T, 4>

pub fn yywz(&self) -> Vector<T, 4>

pub fn yyww(&self) -> Vector<T, 4>

pub fn yz(&self) -> Vector<T, 2>

pub fn yzx(&self) -> Vector<T, 3>

pub fn yzxx(&self) -> Vector<T, 4>

pub fn yzxy(&self) -> Vector<T, 4>

pub fn yzxz(&self) -> Vector<T, 4>

pub fn yzxw(&self) -> Vector<T, 4>

pub fn yzy(&self) -> Vector<T, 3>

pub fn yzyx(&self) -> Vector<T, 4>

pub fn yzyy(&self) -> Vector<T, 4>

pub fn yzyz(&self) -> Vector<T, 4>

pub fn yzyw(&self) -> Vector<T, 4>

pub fn yzz(&self) -> Vector<T, 3>

pub fn yzzx(&self) -> Vector<T, 4>

pub fn yzzy(&self) -> Vector<T, 4>

pub fn yzzz(&self) -> Vector<T, 4>

pub fn yzzw(&self) -> Vector<T, 4>

pub fn yzw(&self) -> Vector<T, 3>

pub fn yzwx(&self) -> Vector<T, 4>

pub fn yzwy(&self) -> Vector<T, 4>

pub fn yzwz(&self) -> Vector<T, 4>

pub fn yzww(&self) -> Vector<T, 4>

pub fn yw(&self) -> Vector<T, 2>

pub fn ywx(&self) -> Vector<T, 3>

pub fn ywxx(&self) -> Vector<T, 4>

pub fn ywxy(&self) -> Vector<T, 4>

pub fn ywxz(&self) -> Vector<T, 4>

pub fn ywxw(&self) -> Vector<T, 4>

pub fn ywy(&self) -> Vector<T, 3>

pub fn ywyx(&self) -> Vector<T, 4>

pub fn ywyy(&self) -> Vector<T, 4>

pub fn ywyz(&self) -> Vector<T, 4>

pub fn ywyw(&self) -> Vector<T, 4>

pub fn ywz(&self) -> Vector<T, 3>

pub fn ywzx(&self) -> Vector<T, 4>

pub fn ywzy(&self) -> Vector<T, 4>

pub fn ywzz(&self) -> Vector<T, 4>

pub fn ywzw(&self) -> Vector<T, 4>

pub fn yww(&self) -> Vector<T, 3>

pub fn ywwx(&self) -> Vector<T, 4>

pub fn ywwy(&self) -> Vector<T, 4>

pub fn ywwz(&self) -> Vector<T, 4>

pub fn ywww(&self) -> Vector<T, 4>

pub fn zx(&self) -> Vector<T, 2>

pub fn zxx(&self) -> Vector<T, 3>

pub fn zxxx(&self) -> Vector<T, 4>

pub fn zxxy(&self) -> Vector<T, 4>

pub fn zxxz(&self) -> Vector<T, 4>

pub fn zxxw(&self) -> Vector<T, 4>

pub fn zxy(&self) -> Vector<T, 3>

pub fn zxyx(&self) -> Vector<T, 4>

pub fn zxyy(&self) -> Vector<T, 4>

pub fn zxyz(&self) -> Vector<T, 4>

pub fn zxyw(&self) -> Vector<T, 4>

pub fn zxz(&self) -> Vector<T, 3>

pub fn zxzx(&self) -> Vector<T, 4>

pub fn zxzy(&self) -> Vector<T, 4>

pub fn zxzz(&self) -> Vector<T, 4>

pub fn zxzw(&self) -> Vector<T, 4>

pub fn zxw(&self) -> Vector<T, 3>

pub fn zxwx(&self) -> Vector<T, 4>

pub fn zxwy(&self) -> Vector<T, 4>

pub fn zxwz(&self) -> Vector<T, 4>

pub fn zxww(&self) -> Vector<T, 4>

pub fn zy(&self) -> Vector<T, 2>

pub fn zyx(&self) -> Vector<T, 3>

pub fn zyxx(&self) -> Vector<T, 4>

pub fn zyxy(&self) -> Vector<T, 4>

pub fn zyxz(&self) -> Vector<T, 4>

pub fn zyxw(&self) -> Vector<T, 4>

pub fn zyy(&self) -> Vector<T, 3>

pub fn zyyx(&self) -> Vector<T, 4>

pub fn zyyy(&self) -> Vector<T, 4>

pub fn zyyz(&self) -> Vector<T, 4>

pub fn zyyw(&self) -> Vector<T, 4>

pub fn zyz(&self) -> Vector<T, 3>

pub fn zyzx(&self) -> Vector<T, 4>

pub fn zyzy(&self) -> Vector<T, 4>

pub fn zyzz(&self) -> Vector<T, 4>

pub fn zyzw(&self) -> Vector<T, 4>

pub fn zyw(&self) -> Vector<T, 3>

pub fn zywx(&self) -> Vector<T, 4>

pub fn zywy(&self) -> Vector<T, 4>

pub fn zywz(&self) -> Vector<T, 4>

pub fn zyww(&self) -> Vector<T, 4>

pub fn zz(&self) -> Vector<T, 2>

pub fn zzx(&self) -> Vector<T, 3>

pub fn zzxx(&self) -> Vector<T, 4>

pub fn zzxy(&self) -> Vector<T, 4>

pub fn zzxz(&self) -> Vector<T, 4>

pub fn zzxw(&self) -> Vector<T, 4>

pub fn zzy(&self) -> Vector<T, 3>

pub fn zzyx(&self) -> Vector<T, 4>

pub fn zzyy(&self) -> Vector<T, 4>

pub fn zzyz(&self) -> Vector<T, 4>

pub fn zzyw(&self) -> Vector<T, 4>

pub fn zzz(&self) -> Vector<T, 3>

pub fn zzzx(&self) -> Vector<T, 4>

pub fn zzzy(&self) -> Vector<T, 4>

pub fn zzzz(&self) -> Vector<T, 4>

pub fn zzzw(&self) -> Vector<T, 4>

pub fn zzw(&self) -> Vector<T, 3>

pub fn zzwx(&self) -> Vector<T, 4>

pub fn zzwy(&self) -> Vector<T, 4>

pub fn zzwz(&self) -> Vector<T, 4>

pub fn zzww(&self) -> Vector<T, 4>

pub fn zw(&self) -> Vector<T, 2>

pub fn zwx(&self) -> Vector<T, 3>

pub fn zwxx(&self) -> Vector<T, 4>

pub fn zwxy(&self) -> Vector<T, 4>

pub fn zwxz(&self) -> Vector<T, 4>

pub fn zwxw(&self) -> Vector<T, 4>

pub fn zwy(&self) -> Vector<T, 3>

pub fn zwyx(&self) -> Vector<T, 4>

pub fn zwyy(&self) -> Vector<T, 4>

pub fn zwyz(&self) -> Vector<T, 4>

pub fn zwyw(&self) -> Vector<T, 4>

pub fn zwz(&self) -> Vector<T, 3>

pub fn zwzx(&self) -> Vector<T, 4>

pub fn zwzy(&self) -> Vector<T, 4>

pub fn zwzz(&self) -> Vector<T, 4>

pub fn zwzw(&self) -> Vector<T, 4>

pub fn zww(&self) -> Vector<T, 3>

pub fn zwwx(&self) -> Vector<T, 4>

pub fn zwwy(&self) -> Vector<T, 4>

pub fn zwwz(&self) -> Vector<T, 4>

pub fn zwww(&self) -> Vector<T, 4>

pub fn wx(&self) -> Vector<T, 2>

pub fn wxx(&self) -> Vector<T, 3>

pub fn wxxx(&self) -> Vector<T, 4>

pub fn wxxy(&self) -> Vector<T, 4>

pub fn wxxz(&self) -> Vector<T, 4>

pub fn wxxw(&self) -> Vector<T, 4>

pub fn wxy(&self) -> Vector<T, 3>

pub fn wxyx(&self) -> Vector<T, 4>

pub fn wxyy(&self) -> Vector<T, 4>

pub fn wxyz(&self) -> Vector<T, 4>

pub fn wxyw(&self) -> Vector<T, 4>

pub fn wxz(&self) -> Vector<T, 3>

pub fn wxzx(&self) -> Vector<T, 4>

pub fn wxzy(&self) -> Vector<T, 4>

pub fn wxzz(&self) -> Vector<T, 4>

pub fn wxzw(&self) -> Vector<T, 4>

pub fn wxw(&self) -> Vector<T, 3>

pub fn wxwx(&self) -> Vector<T, 4>

pub fn wxwy(&self) -> Vector<T, 4>

pub fn wxwz(&self) -> Vector<T, 4>

pub fn wxww(&self) -> Vector<T, 4>

pub fn wy(&self) -> Vector<T, 2>

pub fn wyx(&self) -> Vector<T, 3>

pub fn wyxx(&self) -> Vector<T, 4>

pub fn wyxy(&self) -> Vector<T, 4>

pub fn wyxz(&self) -> Vector<T, 4>

pub fn wyxw(&self) -> Vector<T, 4>

pub fn wyy(&self) -> Vector<T, 3>

pub fn wyyx(&self) -> Vector<T, 4>

pub fn wyyy(&self) -> Vector<T, 4>

pub fn wyyz(&self) -> Vector<T, 4>

pub fn wyyw(&self) -> Vector<T, 4>

pub fn wyz(&self) -> Vector<T, 3>

pub fn wyzx(&self) -> Vector<T, 4>

pub fn wyzy(&self) -> Vector<T, 4>

pub fn wyzz(&self) -> Vector<T, 4>

pub fn wyzw(&self) -> Vector<T, 4>

pub fn wyw(&self) -> Vector<T, 3>

pub fn wywx(&self) -> Vector<T, 4>

pub fn wywy(&self) -> Vector<T, 4>

pub fn wywz(&self) -> Vector<T, 4>

pub fn wyww(&self) -> Vector<T, 4>

pub fn wz(&self) -> Vector<T, 2>

pub fn wzx(&self) -> Vector<T, 3>

pub fn wzxx(&self) -> Vector<T, 4>

pub fn wzxy(&self) -> Vector<T, 4>

pub fn wzxz(&self) -> Vector<T, 4>

pub fn wzxw(&self) -> Vector<T, 4>

pub fn wzy(&self) -> Vector<T, 3>

pub fn wzyx(&self) -> Vector<T, 4>

pub fn wzyy(&self) -> Vector<T, 4>

pub fn wzyz(&self) -> Vector<T, 4>

pub fn wzyw(&self) -> Vector<T, 4>

pub fn wzz(&self) -> Vector<T, 3>

pub fn wzzx(&self) -> Vector<T, 4>

pub fn wzzy(&self) -> Vector<T, 4>

pub fn wzzz(&self) -> Vector<T, 4>

pub fn wzzw(&self) -> Vector<T, 4>

pub fn wzw(&self) -> Vector<T, 3>

pub fn wzwx(&self) -> Vector<T, 4>

pub fn wzwy(&self) -> Vector<T, 4>

pub fn wzwz(&self) -> Vector<T, 4>

pub fn wzww(&self) -> Vector<T, 4>

pub fn ww(&self) -> Vector<T, 2>

pub fn wwx(&self) -> Vector<T, 3>

pub fn wwxx(&self) -> Vector<T, 4>

pub fn wwxy(&self) -> Vector<T, 4>

pub fn wwxz(&self) -> Vector<T, 4>

pub fn wwxw(&self) -> Vector<T, 4>

pub fn wwy(&self) -> Vector<T, 3>

pub fn wwyx(&self) -> Vector<T, 4>

pub fn wwyy(&self) -> Vector<T, 4>

pub fn wwyz(&self) -> Vector<T, 4>

pub fn wwyw(&self) -> Vector<T, 4>

pub fn wwz(&self) -> Vector<T, 3>

pub fn wwzx(&self) -> Vector<T, 4>

pub fn wwzy(&self) -> Vector<T, 4>

pub fn wwzz(&self) -> Vector<T, 4>

pub fn wwzw(&self) -> Vector<T, 4>

pub fn www(&self) -> Vector<T, 3>

pub fn wwwx(&self) -> Vector<T, 4>

pub fn wwwy(&self) -> Vector<T, 4>

pub fn wwwz(&self) -> Vector<T, 4>

pub fn wwww(&self) -> Vector<T, 4>

pub fn rr(&self) -> Vector<T, 2>

pub fn rrr(&self) -> Vector<T, 3>

pub fn rrrr(&self) -> Vector<T, 4>

pub fn rrrg(&self) -> Vector<T, 4>

pub fn rrrb(&self) -> Vector<T, 4>

pub fn rrra(&self) -> Vector<T, 4>

pub fn rrg(&self) -> Vector<T, 3>

pub fn rrgr(&self) -> Vector<T, 4>

pub fn rrgg(&self) -> Vector<T, 4>

pub fn rrgb(&self) -> Vector<T, 4>

pub fn rrga(&self) -> Vector<T, 4>

pub fn rrb(&self) -> Vector<T, 3>

pub fn rrbr(&self) -> Vector<T, 4>

pub fn rrbg(&self) -> Vector<T, 4>

pub fn rrbb(&self) -> Vector<T, 4>

pub fn rrba(&self) -> Vector<T, 4>

pub fn rra(&self) -> Vector<T, 3>

pub fn rrar(&self) -> Vector<T, 4>

pub fn rrag(&self) -> Vector<T, 4>

pub fn rrab(&self) -> Vector<T, 4>

pub fn rraa(&self) -> Vector<T, 4>

pub fn rg(&self) -> Vector<T, 2>

pub fn rgr(&self) -> Vector<T, 3>

pub fn rgrr(&self) -> Vector<T, 4>

pub fn rgrg(&self) -> Vector<T, 4>

pub fn rgrb(&self) -> Vector<T, 4>

pub fn rgra(&self) -> Vector<T, 4>

pub fn rgg(&self) -> Vector<T, 3>

pub fn rggr(&self) -> Vector<T, 4>

pub fn rggg(&self) -> Vector<T, 4>

pub fn rggb(&self) -> Vector<T, 4>

pub fn rgga(&self) -> Vector<T, 4>

pub fn rgb(&self) -> Vector<T, 3>

pub fn rgbr(&self) -> Vector<T, 4>

pub fn rgbg(&self) -> Vector<T, 4>

pub fn rgbb(&self) -> Vector<T, 4>

pub fn rgba(&self) -> Vector<T, 4>

pub fn rga(&self) -> Vector<T, 3>

pub fn rgar(&self) -> Vector<T, 4>

pub fn rgag(&self) -> Vector<T, 4>

pub fn rgab(&self) -> Vector<T, 4>

pub fn rgaa(&self) -> Vector<T, 4>

pub fn rb(&self) -> Vector<T, 2>

pub fn rbr(&self) -> Vector<T, 3>

pub fn rbrr(&self) -> Vector<T, 4>

pub fn rbrg(&self) -> Vector<T, 4>

pub fn rbrb(&self) -> Vector<T, 4>

pub fn rbra(&self) -> Vector<T, 4>

pub fn rbg(&self) -> Vector<T, 3>

pub fn rbgr(&self) -> Vector<T, 4>

pub fn rbgg(&self) -> Vector<T, 4>

pub fn rbgb(&self) -> Vector<T, 4>

pub fn rbga(&self) -> Vector<T, 4>

pub fn rbb(&self) -> Vector<T, 3>

pub fn rbbr(&self) -> Vector<T, 4>

pub fn rbbg(&self) -> Vector<T, 4>

pub fn rbbb(&self) -> Vector<T, 4>

pub fn rbba(&self) -> Vector<T, 4>

pub fn rba(&self) -> Vector<T, 3>

pub fn rbar(&self) -> Vector<T, 4>

pub fn rbag(&self) -> Vector<T, 4>

pub fn rbab(&self) -> Vector<T, 4>

pub fn rbaa(&self) -> Vector<T, 4>

pub fn ra(&self) -> Vector<T, 2>

pub fn rar(&self) -> Vector<T, 3>

pub fn rarr(&self) -> Vector<T, 4>

pub fn rarg(&self) -> Vector<T, 4>

pub fn rarb(&self) -> Vector<T, 4>

pub fn rara(&self) -> Vector<T, 4>

pub fn rag(&self) -> Vector<T, 3>

pub fn ragr(&self) -> Vector<T, 4>

pub fn ragg(&self) -> Vector<T, 4>

pub fn ragb(&self) -> Vector<T, 4>

pub fn raga(&self) -> Vector<T, 4>

pub fn rab(&self) -> Vector<T, 3>

pub fn rabr(&self) -> Vector<T, 4>

pub fn rabg(&self) -> Vector<T, 4>

pub fn rabb(&self) -> Vector<T, 4>

pub fn raba(&self) -> Vector<T, 4>

pub fn raa(&self) -> Vector<T, 3>

pub fn raar(&self) -> Vector<T, 4>

pub fn raag(&self) -> Vector<T, 4>

pub fn raab(&self) -> Vector<T, 4>

pub fn raaa(&self) -> Vector<T, 4>

pub fn gr(&self) -> Vector<T, 2>

pub fn grr(&self) -> Vector<T, 3>

pub fn grrr(&self) -> Vector<T, 4>

pub fn grrg(&self) -> Vector<T, 4>

pub fn grrb(&self) -> Vector<T, 4>

pub fn grra(&self) -> Vector<T, 4>

pub fn grg(&self) -> Vector<T, 3>

pub fn grgr(&self) -> Vector<T, 4>

pub fn grgg(&self) -> Vector<T, 4>

pub fn grgb(&self) -> Vector<T, 4>

pub fn grga(&self) -> Vector<T, 4>

pub fn grb(&self) -> Vector<T, 3>

pub fn grbr(&self) -> Vector<T, 4>

pub fn grbg(&self) -> Vector<T, 4>

pub fn grbb(&self) -> Vector<T, 4>

pub fn grba(&self) -> Vector<T, 4>

pub fn gra(&self) -> Vector<T, 3>

pub fn grar(&self) -> Vector<T, 4>

pub fn grag(&self) -> Vector<T, 4>

pub fn grab(&self) -> Vector<T, 4>

pub fn graa(&self) -> Vector<T, 4>

pub fn gg(&self) -> Vector<T, 2>

pub fn ggr(&self) -> Vector<T, 3>

pub fn ggrr(&self) -> Vector<T, 4>

pub fn ggrg(&self) -> Vector<T, 4>

pub fn ggrb(&self) -> Vector<T, 4>

pub fn ggra(&self) -> Vector<T, 4>

pub fn ggg(&self) -> Vector<T, 3>

pub fn gggr(&self) -> Vector<T, 4>

pub fn gggg(&self) -> Vector<T, 4>

pub fn gggb(&self) -> Vector<T, 4>

pub fn ggga(&self) -> Vector<T, 4>

pub fn ggb(&self) -> Vector<T, 3>

pub fn ggbr(&self) -> Vector<T, 4>

pub fn ggbg(&self) -> Vector<T, 4>

pub fn ggbb(&self) -> Vector<T, 4>

pub fn ggba(&self) -> Vector<T, 4>

pub fn gga(&self) -> Vector<T, 3>

pub fn ggar(&self) -> Vector<T, 4>

pub fn ggag(&self) -> Vector<T, 4>

pub fn ggab(&self) -> Vector<T, 4>

pub fn ggaa(&self) -> Vector<T, 4>

pub fn gb(&self) -> Vector<T, 2>

pub fn gbr(&self) -> Vector<T, 3>

pub fn gbrr(&self) -> Vector<T, 4>

pub fn gbrg(&self) -> Vector<T, 4>

pub fn gbrb(&self) -> Vector<T, 4>

pub fn gbra(&self) -> Vector<T, 4>

pub fn gbg(&self) -> Vector<T, 3>

pub fn gbgr(&self) -> Vector<T, 4>

pub fn gbgg(&self) -> Vector<T, 4>

pub fn gbgb(&self) -> Vector<T, 4>

pub fn gbga(&self) -> Vector<T, 4>

pub fn gbb(&self) -> Vector<T, 3>

pub fn gbbr(&self) -> Vector<T, 4>

pub fn gbbg(&self) -> Vector<T, 4>

pub fn gbbb(&self) -> Vector<T, 4>

pub fn gbba(&self) -> Vector<T, 4>

pub fn gba(&self) -> Vector<T, 3>

pub fn gbar(&self) -> Vector<T, 4>

pub fn gbag(&self) -> Vector<T, 4>

pub fn gbab(&self) -> Vector<T, 4>

pub fn gbaa(&self) -> Vector<T, 4>

pub fn ga(&self) -> Vector<T, 2>

pub fn gar(&self) -> Vector<T, 3>

pub fn garr(&self) -> Vector<T, 4>

pub fn garg(&self) -> Vector<T, 4>

pub fn garb(&self) -> Vector<T, 4>

pub fn gara(&self) -> Vector<T, 4>

pub fn gag(&self) -> Vector<T, 3>

pub fn gagr(&self) -> Vector<T, 4>

pub fn gagg(&self) -> Vector<T, 4>

pub fn gagb(&self) -> Vector<T, 4>

pub fn gaga(&self) -> Vector<T, 4>

pub fn gab(&self) -> Vector<T, 3>

pub fn gabr(&self) -> Vector<T, 4>

pub fn gabg(&self) -> Vector<T, 4>

pub fn gabb(&self) -> Vector<T, 4>

pub fn gaba(&self) -> Vector<T, 4>

pub fn gaa(&self) -> Vector<T, 3>

pub fn gaar(&self) -> Vector<T, 4>

pub fn gaag(&self) -> Vector<T, 4>

pub fn gaab(&self) -> Vector<T, 4>

pub fn gaaa(&self) -> Vector<T, 4>

pub fn br(&self) -> Vector<T, 2>

pub fn brr(&self) -> Vector<T, 3>

pub fn brrr(&self) -> Vector<T, 4>

pub fn brrg(&self) -> Vector<T, 4>

pub fn brrb(&self) -> Vector<T, 4>

pub fn brra(&self) -> Vector<T, 4>

pub fn brg(&self) -> Vector<T, 3>

pub fn brgr(&self) -> Vector<T, 4>

pub fn brgg(&self) -> Vector<T, 4>

pub fn brgb(&self) -> Vector<T, 4>

pub fn brga(&self) -> Vector<T, 4>

pub fn brb(&self) -> Vector<T, 3>

pub fn brbr(&self) -> Vector<T, 4>

pub fn brbg(&self) -> Vector<T, 4>

pub fn brbb(&self) -> Vector<T, 4>

pub fn brba(&self) -> Vector<T, 4>

pub fn bra(&self) -> Vector<T, 3>

pub fn brar(&self) -> Vector<T, 4>

pub fn brag(&self) -> Vector<T, 4>

pub fn brab(&self) -> Vector<T, 4>

pub fn braa(&self) -> Vector<T, 4>

pub fn bg(&self) -> Vector<T, 2>

pub fn bgr(&self) -> Vector<T, 3>

pub fn bgrr(&self) -> Vector<T, 4>

pub fn bgrg(&self) -> Vector<T, 4>

pub fn bgrb(&self) -> Vector<T, 4>

pub fn bgra(&self) -> Vector<T, 4>

pub fn bgg(&self) -> Vector<T, 3>

pub fn bggr(&self) -> Vector<T, 4>

pub fn bggg(&self) -> Vector<T, 4>

pub fn bggb(&self) -> Vector<T, 4>

pub fn bgga(&self) -> Vector<T, 4>

pub fn bgb(&self) -> Vector<T, 3>

pub fn bgbr(&self) -> Vector<T, 4>

pub fn bgbg(&self) -> Vector<T, 4>

pub fn bgbb(&self) -> Vector<T, 4>

pub fn bgba(&self) -> Vector<T, 4>

pub fn bga(&self) -> Vector<T, 3>

pub fn bgar(&self) -> Vector<T, 4>

pub fn bgag(&self) -> Vector<T, 4>

pub fn bgab(&self) -> Vector<T, 4>

pub fn bgaa(&self) -> Vector<T, 4>

pub fn bb(&self) -> Vector<T, 2>

pub fn bbr(&self) -> Vector<T, 3>

pub fn bbrr(&self) -> Vector<T, 4>

pub fn bbrg(&self) -> Vector<T, 4>

pub fn bbrb(&self) -> Vector<T, 4>

pub fn bbra(&self) -> Vector<T, 4>

pub fn bbg(&self) -> Vector<T, 3>

pub fn bbgr(&self) -> Vector<T, 4>

pub fn bbgg(&self) -> Vector<T, 4>

pub fn bbgb(&self) -> Vector<T, 4>

pub fn bbga(&self) -> Vector<T, 4>

pub fn bbb(&self) -> Vector<T, 3>

pub fn bbbr(&self) -> Vector<T, 4>

pub fn bbbg(&self) -> Vector<T, 4>

pub fn bbbb(&self) -> Vector<T, 4>

pub fn bbba(&self) -> Vector<T, 4>

pub fn bba(&self) -> Vector<T, 3>

pub fn bbar(&self) -> Vector<T, 4>

pub fn bbag(&self) -> Vector<T, 4>

pub fn bbab(&self) -> Vector<T, 4>

pub fn bbaa(&self) -> Vector<T, 4>

pub fn ba(&self) -> Vector<T, 2>

pub fn bar(&self) -> Vector<T, 3>

pub fn barr(&self) -> Vector<T, 4>

pub fn barg(&self) -> Vector<T, 4>

pub fn barb(&self) -> Vector<T, 4>

pub fn bara(&self) -> Vector<T, 4>

pub fn bag(&self) -> Vector<T, 3>

pub fn bagr(&self) -> Vector<T, 4>

pub fn bagg(&self) -> Vector<T, 4>

pub fn bagb(&self) -> Vector<T, 4>

pub fn baga(&self) -> Vector<T, 4>

pub fn bab(&self) -> Vector<T, 3>

pub fn babr(&self) -> Vector<T, 4>

pub fn babg(&self) -> Vector<T, 4>

pub fn babb(&self) -> Vector<T, 4>

pub fn baba(&self) -> Vector<T, 4>

pub fn baa(&self) -> Vector<T, 3>

pub fn baar(&self) -> Vector<T, 4>

pub fn baag(&self) -> Vector<T, 4>

pub fn baab(&self) -> Vector<T, 4>

pub fn baaa(&self) -> Vector<T, 4>

pub fn ar(&self) -> Vector<T, 2>

pub fn arr(&self) -> Vector<T, 3>

pub fn arrr(&self) -> Vector<T, 4>

pub fn arrg(&self) -> Vector<T, 4>

pub fn arrb(&self) -> Vector<T, 4>

pub fn arra(&self) -> Vector<T, 4>

pub fn arg(&self) -> Vector<T, 3>

pub fn argr(&self) -> Vector<T, 4>

pub fn argg(&self) -> Vector<T, 4>

pub fn argb(&self) -> Vector<T, 4>

pub fn arga(&self) -> Vector<T, 4>

pub fn arb(&self) -> Vector<T, 3>

pub fn arbr(&self) -> Vector<T, 4>

pub fn arbg(&self) -> Vector<T, 4>

pub fn arbb(&self) -> Vector<T, 4>

pub fn arba(&self) -> Vector<T, 4>

pub fn ara(&self) -> Vector<T, 3>

pub fn arar(&self) -> Vector<T, 4>

pub fn arag(&self) -> Vector<T, 4>

pub fn arab(&self) -> Vector<T, 4>

pub fn araa(&self) -> Vector<T, 4>

pub fn ag(&self) -> Vector<T, 2>

pub fn agr(&self) -> Vector<T, 3>

pub fn agrr(&self) -> Vector<T, 4>

pub fn agrg(&self) -> Vector<T, 4>

pub fn agrb(&self) -> Vector<T, 4>

pub fn agra(&self) -> Vector<T, 4>

pub fn agg(&self) -> Vector<T, 3>

pub fn aggr(&self) -> Vector<T, 4>

pub fn aggg(&self) -> Vector<T, 4>

pub fn aggb(&self) -> Vector<T, 4>

pub fn agga(&self) -> Vector<T, 4>

pub fn agb(&self) -> Vector<T, 3>

pub fn agbr(&self) -> Vector<T, 4>

pub fn agbg(&self) -> Vector<T, 4>

pub fn agbb(&self) -> Vector<T, 4>

pub fn agba(&self) -> Vector<T, 4>

pub fn aga(&self) -> Vector<T, 3>

pub fn agar(&self) -> Vector<T, 4>

pub fn agag(&self) -> Vector<T, 4>

pub fn agab(&self) -> Vector<T, 4>

pub fn agaa(&self) -> Vector<T, 4>

pub fn ab(&self) -> Vector<T, 2>

pub fn abr(&self) -> Vector<T, 3>

pub fn abrr(&self) -> Vector<T, 4>

pub fn abrg(&self) -> Vector<T, 4>

pub fn abrb(&self) -> Vector<T, 4>

pub fn abra(&self) -> Vector<T, 4>

pub fn abg(&self) -> Vector<T, 3>

pub fn abgr(&self) -> Vector<T, 4>

pub fn abgg(&self) -> Vector<T, 4>

pub fn abgb(&self) -> Vector<T, 4>

pub fn abga(&self) -> Vector<T, 4>

pub fn abb(&self) -> Vector<T, 3>

pub fn abbr(&self) -> Vector<T, 4>

pub fn abbg(&self) -> Vector<T, 4>

pub fn abbb(&self) -> Vector<T, 4>

pub fn abba(&self) -> Vector<T, 4>

pub fn aba(&self) -> Vector<T, 3>

pub fn abar(&self) -> Vector<T, 4>

pub fn abag(&self) -> Vector<T, 4>

pub fn abab(&self) -> Vector<T, 4>

pub fn abaa(&self) -> Vector<T, 4>

pub fn aa(&self) -> Vector<T, 2>

pub fn aar(&self) -> Vector<T, 3>

pub fn aarr(&self) -> Vector<T, 4>

pub fn aarg(&self) -> Vector<T, 4>

pub fn aarb(&self) -> Vector<T, 4>

pub fn aara(&self) -> Vector<T, 4>

pub fn aag(&self) -> Vector<T, 3>

pub fn aagr(&self) -> Vector<T, 4>

pub fn aagg(&self) -> Vector<T, 4>

pub fn aagb(&self) -> Vector<T, 4>

pub fn aaga(&self) -> Vector<T, 4>

pub fn aab(&self) -> Vector<T, 3>

pub fn aabr(&self) -> Vector<T, 4>

pub fn aabg(&self) -> Vector<T, 4>

pub fn aabb(&self) -> Vector<T, 4>

pub fn aaba(&self) -> Vector<T, 4>

pub fn aaa(&self) -> Vector<T, 3>

pub fn aaar(&self) -> Vector<T, 4>

pub fn aaag(&self) -> Vector<T, 4>

pub fn aaab(&self) -> Vector<T, 4>

pub fn aaaa(&self) -> Vector<T, 4>

Trait Implementations

impl<T, const N: usize> Zero for Vector<T, { N }> where
    T: Zero, 

fn zero() -> Self

Returns the additive identity of Self.

fn is_zero(&self) -> bool

Returns true if the value is the additive identity.

impl<T, const N: usize> VectorSpace for Vector<T, { N }> where
    T: Clone + Zero,
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
    T: Div<T, Output = T>, 

type Scalar = T

fn lerp(self, other: Self, amount: Self::Scalar) -> Self

impl<T, const N: usize> MetricSpace for Vector<T, { N }> where
    Self: InnerSpace, 

type Metric = Self::Scalar

fn distance2(self, other: Self) -> Self::Metric

Returns the distance squared between the two values.

impl<T, const N: usize> InnerSpace for Vector<T, { N }> where
    T: Clone + Zero,
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
    T: Div<T, Output = T>,
    T: AddAssign<T>,
    Self: Clone, 

fn dot(self, rhs: Self) -> T

Return the inner (also known as "dot") product.

fn magnitude2(self) -> Self::Scalar

Returns the squared length of the value.

impl<A, B, RHS, const N: usize> PartialEq<RHS> for Vector<A, { N }> where
    RHS: Deref<Target = [B; {N}]>,
    A: PartialEq<B>, 

fn eq(&self, other: &RHS) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, const N: usize> Into<[T; N]> for Vector<T, { N }>

fn into(self) -> [T; {N}]

Performs the conversion.

impl<T, const N: usize> Copy for Vector<T, { N }> where
    T: Copy, 

impl<T, const N: usize> Clone for Vector<T, { N }> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> From<[T; N]> for Vector<T, { N }>

fn from(array: [T; N]) -> Self

Performs the conversion.

impl<T, const N: usize> From<Matrix<T, N, 1>> for Vector<T, { N }>

fn from(mat: Matrix<T, { N }, 1>) -> Self

Performs the conversion.

impl<T, const N: usize> Eq for Vector<T, { N }> where
    T: Eq, 

impl<T, const N: usize> DerefMut for Vector<T, { N }>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, const N: usize> Hash for Vector<T, { N }> where
    T: Hash, 

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

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<A, B, const N: usize> Add<Vector<B, N>> for Vector<A, { N }> where
    A: Add<B>, 

type Output = Vector<<A as Add<B>>::Output, { N }>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<B, { N }>) -> Self::Output

Performs the + operation.

impl<A, B, const N: usize> Sub<Vector<B, N>> for Vector<A, { N }> where
    A: Sub<B>, 

type Output = Vector<<A as Sub<B>>::Output, { N }>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<B, { N }>) -> Self::Output

Performs the - operation.

impl<A, B, const N: usize> Mul<B> for Vector<A, { N }> where
    A: Mul<B>,
    B: Clone, 

Scalar multiply

type Output = Vector<<A as Mul<B>>::Output, { N }>

The resulting type after applying the * operator.

fn mul(self, scalar: B) -> Self::Output

Performs the * operation.

impl<T, const N: usize, const M: usize> Mul<Vector<T, M>> for Matrix<T, { N }, { M }> where
    T: Add<T, Output = T> + Mul<T, Output = T> + Clone,
    Vector<T, { M }>: InnerSpace, 

type Output = Vector<<Vector<T, { M }> as VectorSpace>::Scalar, { N }>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<T, { M }>) -> Self::Output

Performs the * operation.

impl<A, B, const N: usize> Div<B> for Vector<A, { N }> where
    A: Div<B>,
    B: Clone, 

Scalar divide

type Output = Vector<<A as Div<B>>::Output, { N }>

The resulting type after applying the / operator.

fn div(self, scalar: B) -> Self::Output

Performs the / operation.

impl<T, const N: usize> Neg for Vector<T, { N }> where
    T: Neg, 

type Output = Vector<<T as Neg>::Output, { N }>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B, const N: usize> AddAssign<Vector<B, N>> for Vector<A, { N }> where
    A: AddAssign<B>, 

fn add_assign(&mut self, rhs: Vector<B, { N }>)

Performs the += operation.

impl<A, B, const N: usize> SubAssign<Vector<B, N>> for Vector<A, { N }> where
    A: SubAssign<B>, 

fn sub_assign(&mut self, rhs: Vector<B, { N }>)

Performs the -= operation.

impl<A, B, const N: usize> MulAssign<B> for Vector<A, { N }> where
    A: MulAssign<B>,
    B: Clone, 

Scalar multiply assign

fn mul_assign(&mut self, scalar: B)

Performs the *= operation.

impl<A, B, const N: usize> DivAssign<B> for Vector<A, { N }> where
    A: DivAssign<B>,
    B: Clone, 

Scalar divide assign

fn div_assign(&mut self, scalar: B)

Performs the /= operation.

impl<T, const N: usize> Deref for Vector<T, { N }>

type Target = [T; {N}]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const N: usize> Debug for Vector<T, { N }> where
    T: Debug, 

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

Formats the value using the given formatter.