`DimArrays.DimArray`

— Type```
DimArray(T) = DimVector(T[])
DimArray(sym) = DimVector(Any[], sym)
```

Empty `DimVector`

into to which you can later `push!`

things, optionally with a dimension name.

`DimArrays.DimArray`

— Method```
DimArray(x, [n1, n2, ...], [f1, f2, ...], n9)
DimArray(x, [n1, n2, ...], [f1]; label=:n9)
```

Vectors of names/maps are simply splatted, then digested as above. Content label `n9`

here is kept separate, equivalent to keyword `label=:n9`

.

`DimArrays.DimArray`

— Method```
DimArray(x, names...)
DimArray(x, names..., maps...)
```

Interprets symbols & strings as dimension names (in order), and numbers, functions & dictionaries as index maps (for each dimension). Numbers are converted to functions `i -> i*n`

to indicate e.g. that we have every n-th data point. The `ndims(x)+1`

-th name (if given) is equivalent to keyword `label=name`

, labelling what the elements of `x`

mean. Giving too few names/maps is no problem, too many will give a warning.

`DimArrays.DimMatrix`

— Method```
DimArray(x, names...)
DimArray(x, names..., maps...)
```

Interprets symbols & strings as dimension names (in order), and numbers, functions & dictionaries as index maps (for each dimension). Numbers are converted to functions `i -> i*n`

to indicate e.g. that we have every n-th data point. The `ndims(x)+1`

-th name (if given) is equivalent to keyword `label=name`

, labelling what the elements of `x`

mean. Giving too few names/maps is no problem, too many will give a warning.

```
DimArray(x, [n1, n2, ...], [f1, f2, ...], n9)
DimArray(x, [n1, n2, ...], [f1]; label=:n9)
```

Vectors of names/maps are simply splatted, then digested as above. Content label `n9`

here is kept separate, equivalent to keyword `label=:n9`

.

`DimArrays.DimVector`

— Type```
DimArray(x, names...)
DimArray(x, names..., maps...)
```

Interprets symbols & strings as dimension names (in order), and numbers, functions & dictionaries as index maps (for each dimension). Numbers are converted to functions `i -> i*n`

to indicate e.g. that we have every n-th data point. The `ndims(x)+1`

-th name (if given) is equivalent to keyword `label=name`

, labelling what the elements of `x`

mean. Giving too few names/maps is no problem, too many will give a warning.

```
DimArray(x, [n1, n2, ...], [f1, f2, ...], n9)
DimArray(x, [n1, n2, ...], [f1]; label=:n9)
```

Vectors of names/maps are simply splatted, then digested as above. Content label `n9`

here is kept separate, equivalent to keyword `label=:n9`

.

```
DimArray(T) = DimVector(T[])
DimArray(sym) = DimVector(Any[], sym)
```

Empty `DimVector`

into to which you can later `push!`

things, optionally with a dimension name.

`DimArrays.dictvector`

— Method```
dictvector(vec, [:first, "second", ...]) = DimVector(vec, Dict(1 => :first, 2 => "second", ...))
dictvector(vec, [:first, ...], :axis, :content)
```

Convenient way to define a (short) `DimVector`

whose index function is a dictionary labelling the entries. A name for the dimension / axis, and a label for its content, can be supplied too.

`DimArrays.name!`

— Method`name!(x, sym1, sym2)`

Name the dimensions of `x::DimArray`

to be `sym1, sym2, ...`

, with the `ndims(x)+1`

-th one interpreted as content label.

`DimArrays.nest`

— Method```
nest([A1, A2, ...])
nest([A1, A2, ...], sym)
```

Creates an array with `ndims(A1)+1`

dimensions. All the constituent arrays should be similar! Optional 2nd argument names the new dimension, giving `DimArray(nest(...),sym)`

; this also happens if `A1 isa DimArray`

.

`[A1, A2, ...] |> nest(s)`

Gives a function which acts on vectors as above.

`Base.push!`

— Method`push!(x, val, sym)`

For `x::DimVector`

of `length(x)==n`

, the result has `x[n+1]=val`

with index label `n+1 => sym`

added to the dictionary. Only works if x's index function is `nothing`

or a `Dict`

. See also `dictvector([val, val2, val3, ...], [sym, sym2, ...])`

for directly creating such things.