`pub type MatrixN<T, D> = Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>;`

## Expand description

An owned matrix column-major matrix with `D`

columns.

**Because this is an alias, not all its methods are listed here. See the Matrix type too.**

## Aliased TypeÂ§

```
struct MatrixN<T, D> {
pub data: <DefaultAllocator as Allocator<D, D>>::Buffer<T>,
/* private fields */
}
```

## FieldsÂ§

Â§`data: <DefaultAllocator as Allocator<D, D>>::Buffer<T>`

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.