`pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, ArrayStorage<T, D, 1>>;`

## Expand description

A statically sized D-dimensional column vector.

## Aliased Type§

```
struct SVector<T, const D: usize> {
pub data: ArrayStorage<T, D, 1>,
/* private fields */
}
```

## Fields§

§`data: ArrayStorage<T, D, 1>`

The data storage that contains all the matrix components. Disappointed?

Well, if you came here to see how you can access the matrix components,
you may be in luck: you can access the individual components of all vectors with compile-time
dimensions <= 6 using field notation like this:
`vec.x`

, `vec.y`

, `vec.z`

, `vec.w`

, `vec.a`

, `vec.b`

. Reference and assignation work too:

```
let mut vec = Vector3::new(1.0, 2.0, 3.0);
vec.x = 10.0;
vec.y += 30.0;
assert_eq!(vec.x, 10.0);
assert_eq!(vec.y + 100.0, 132.0);
```

Similarly, for matrices with compile-time dimensions <= 6, you can use field notation
like this: `mat.m11`

, `mat.m42`

, etc. The first digit identifies the row to address
and the second digit identifies the column to address. So `mat.m13`

identifies the component
at the first row and third column (note that the count of rows and columns start at 1 instead
of 0 here. This is so we match the mathematical notation).

For all matrices and vectors, independently from their size, individual components can
be accessed and modified using indexing: `vec[20]`

, `mat[(20, 19)]`

. Here the indexing
starts at 0 as you would expect.