# Vectors¶

## Overview¶

A vector in vif is basically an enhanced `std::vector`

(which, in fact, is used to implement the vif vectors), and it therefore shares most of its features and strengths.

In particular, a vector can contain zero, one, or as many elements as your computer can handle. Its size is defined at *runtime*, meaning that its content can vary depending on user input, and that it can change its total number of elements at any time. The elements of a vector are stored *contiguously* in memory, which provides optimal performances in most situations. Lastly, a vector is an *homogeneous* container, meaning that a given vector can only contain a single type of elements; for example `int`

or `float`

, but not both.

On top of the `std::vector`

interface, the vif vectors have some extra functionalities. The most important ones are Operator overloading (which allows writing `v+w`

instead of writing a loop to sum all the elements one by one), structured Indexing for multi-dimensional data (i.e., images, data cubes, and objects of higher dimensions), and Views (which allow accessing and modifying subsets of existing vectors).

Like in most advanced C++ libraries, vif vectors are *template-based*. This means they are designed to work with *any* data type `T`

for their elements, for example `int`

, `float`

, or `std::string`

. The type of a vector is therefore spelled `vec<1,T>`

, where `T`

can be replaced by any type (it could be a vector itself). There is no explicit restriction regarding the data type `T`

, however some features may obviously not be available depending on the capabilities of your type. For example, if your type has no `operator*`

(such as `std::string`

), you will not be able to multiply vectors of this type. Lastly, the vif vector shares the same restrictions as the `std::vector`

regarding the *copyable* and *movable* capabilities of the stored type.

The number of dimensions of a vector is specified in its type; this is the `1`

in `vec<1,T>`

. For example, a 2D image of `float`

will be declared as `vec<2,float>`

(or `vec2f`

, see Type aliases below), while a 1D tabulated data set of `int`

will be `vec<1,int>`

(or `vec1i`

). The fact that the number of dimensions is part of the type means that, while the number of *elements* in a vector is determined at runtime, the multi-dimensional nature of a vector is determined at *compile time*. In other words, a 1D vector cannot be turned into a 2D vector; you would have to create a new variable (using the `reform()`

and `flatten()`

functions). However it is possible to change, say, a 128x128 2D vector into a 256x256 2D vector. Only the *number* of dimensions is fixed, the length of each dimension is free to vary.

This restriction was imposed for two reasons: first, type safety, and second, performance. Since the compiler knows how many dimensions there are, it will output an error whenever you try to perform operations on two vectors of different dimensionality (for example, adding a 1D array to a 2D image; which would make no sense). In terms of performance, this also means that we also know at the time of compilation how many dimensions we need to deal with, so the compiler can more easily decide whether (or how) to unroll loops.

The hard limit on the number of dimensions depends on your compiler, as each dimension involves an additional level of template recursion. The C++ standard does not guarantee anything in this respect, but you should be able to go as high as 256 on all major compilers. Beyond this, you should probably see a therapist first.

## Type aliases¶

While templates are a fantastic tool for library writers, they can easily become a burden for the *user* of the library, because of the additional syntax complexity (the `<...>`

in the name of the vector type). Since vif is a numerical analysis library, we know in advance what types will most often be stored inside the vectors, and we therefore introduce type aliases for the most common vector types:

`vec1f`

: vector of`float`

,`vec1d`

: vector of`double`

,`vec1cf`

: vector of`std::complex<float>`

,`vec1cd`

: vector of`std::complex<double>`

,`vec1i`

: vector of`int`

(precisely,`int_t = std::ptrdiff_t`

),`vec1u`

: vector of`unsigned int`

(precisely,`uint_t = std::size_t`

),`vec1b`

: vector of`bool`

,`vec1s`

: vector of`std::string`

,`vec1c`

: vector of`char`

.

Such type aliases are provided for dimensions up to 6 (i.e., `vec6f`

exists, but not `vec7f`

).

## Size and dimensions¶

For any vector `v`

, `v.dims`

is an `std::array`

that holds the length of each dimension of the vector: `v.dims[0]`

is the number of elements along the first dimension, etc. This array is set automatically when the vector is created or resized, and should not be modified manually (except in very specific and rare circumstances).

The total number of elements in a vector can be obtained using `v.size()`

, and this is equal to the product of all the dimensions of the vector. This is a cheap function, as the size is stored internally and does not need to be computed for each call. One can check if a vector is empty (i.e., contains no element) using `v.empty()`

, which returns either `true`

or `false`

(this does *not* empty the vector).

## Initialization and assignment¶

There are several ways to initialize and assign data to a vector:

- The “default” initialization, where the vector is empty.
- The “size” initialization, where the vector contains
`n`

default-constructed elements. - The “list” initialization, where the vector is assigned a set of values.
- The “copy” initialization, where the vector contains a copy of the data from another vector.
- The “move” initialization, where the vector steals the data from another vector.

The last three can be used both for initialization and assignment (using `operator=`

).

The “default” initialization is very cheap, since it involves no (or very little) allocation:

```
vec1f v; // empty
```

The “size” initialization pre-allocates memory for the data, which is very useful if you know in advance how many elements your vector needs to contain. The allocated data consists of elements which are default-constructed; this means a value of `0`

for arithmetic types, `false`

for `bool`

, and empty strings for `std::string`

.

```
vec1f v(10); // 10 zeros
vec2f w(10,20); // 200 zeros, arranged in a 2D shape of 10x20
vec3f z(w.dims,4); // 800 zeros, arranged in a 3D shape of 10x20x4
```

As shown in the last example (initializing `z`

), the arguments of the constructor can be a mixture of integer values and `std::array`

; the arrays can come, for example, from the dimensions of other existing vectors.

The “list” initialization explicitly specifies a set of values to be stored in the vector. This uses initializer lists, which can be nested for multidimensional vectors.

```
vec1f v = {1, 2, 3, 4); // values from 1 to 4
vec2f w = {{1, 2}, {3, 4}, {5, 6}}; // values from 1 to 6 arranged in a 2D shape of 3x2
```

The “copy” initialization trivially copies (and optionally converts, see Type conversion, and casting) the values of a vector into another one.

```
vec1f v = {1, 2, 3, 4); // values from 1 to 4
vec1f w = v; // also contains values from 1 to 4
```

The “move” initialization will “steal” the values of another vector. The vector from which the values are “stolen” then becomes empty, and can be reused for other purposes later. This will usually be much faster than the “copy” initialization above, if you do not mind the side effect.

```
vec1f v = {1, 2, 3, 4); // values from 1 to 4
vec1f w = std::move(v); // also contains values from 1 to 4, but now 'v' is empty
```

## Resizing and adding elements¶

The dimensions and size of a vector can be modified in three main ways.

First, `v.clear()`

will erase all the values from the vector and set all its dimensions to zero. This will set the vector in the state of a default-initialized vector (see above).

Second, `v.resize(...)`

will change the dimensions of the vector. The parameters it accepts are the same as the “size” constructor (see above), i.e., either integral values for individual dimensions, or an `std::array`

containing multiple dimensions, or any combination of these. While the total number of elements can be modified at will, the number of *dimensions* of the vector must remain unchanged.

```
vec2f w; // empty, zero elements
w.resize(20,10); // 20x10, 200 elements
w.resize(200,10); // 200x10, 2000 elements
w.resize(200,10,5); // error: cannot change a 2D vector into a 3D vector
```

Once the vector has been resized, its previous content is left in an undefined state, i.e., you can generally assume the previous values (if any) have been lost and replaced by meaningless garbage. The only exception is for 1D vectors. If the resize operation *decreases* the total number of elements, then values are erased from the end of the vector and the rest remains untouched. On the other hand, if the resize operation *increased* the total number of elements, new elements are inserted at the end of the vector, default constructed (i.e., zeros for integral types, etc.). This is the same behavior as `std::vector`

.

Third, `v.push_back(...)`

will add new values at the end of the vector, increasing its size. The behavior of this function is different for 1D and multidimensional vectors. For 1D vectors, this function appends a new element at the end of the vector, and therefore takes for argument a single scalar value. For multidimensional vectors, this function takes for argument another vector of `D-1`

dimensions, and whose lengths match the *last* `D-1`

dimensions of the first vector. The new vector is inserted after the existing elements in memory, and the *first* dimension of the first vector is increased by one.

```
vec1i v = {1,2,3};
v.push_back(4); // {1,2,3,4}
vec2i w = {{1,2,3}, {4,5,6}}; // shape 2x3
w.push_back({7,8,9}); // shape 3x3
w.push_back({7,8}); // error: dimensions do not match
```

For optimization, the `push_back(...)`

function will generally be used in conjunction with `v.reserve()`

. This function is identical to `std::vector::reserve()`

. To understand what this function actually does, one needs to know the internal behavior of `std::vector`

. At any instant, the `std::vector`

only has enough memory to hold `N`

elements, which is usually larger than the actual size of the vector. `N`

is called the capacity of the vector. Once the allocated memory is full, and a new `push_back()`

is called, `std::vector`

allocates a larger amount of memory (typically `2*N`

elements), copies the existing elements inside this new memory, and frees the old memory. This strategy allows virtually unlimited growth of a given vector; it is quite efficiently tuned, but it remains an expensive operation. Performances can be greatly improved if one knows *in advance* (and even approximatively) the total number of objects that need to be stored in the vector, so that the right amount of memory is allocated from the start, and no further reallocation is required. This function does just that: it tells `std::vector`

how many elements it will (or might) contain at some point, so that the vector can already allocate enough memory to store them contiguously. Later, if you have reserved way too much memory, you can always ask the vector to free the surplus by calling `std::vector::shrink_to_fit()`

, which will result in an additional reallocation but will free some unused memory.

## Type conversion, and casting¶

The rules for converting a vector of a type `T`

into a vector of another type `U`

follow the rules for converting `T`

itself into `U`

. If `T`

is implicitly/explicitly convertible to `U`

, then it is always possible to implicitly/explicitly convert a `vec<1,T>`

into `vec<1,U>`

. For example here with a conversion from `vec1f`

to `vec1i`

:

```
vec1f v1 = {1.5, -2.2, 100.0};
vec1i v2 = v1; // this works
```

There is one notable exception to this rule, which is for vectors of type `bool`

. In C++, `bool`

can be implicitly converted to (and from) any other arithmetic type (such as `int`

or `float`

). While implicit conversion is very convenient in most cases, in the case of `bool`

the risk of unwanted narrowing conversion (where data is lost) is much greater, while the actual use cases for implicit conversion are rarer; `bool`

indeed carries a very different semantic compared to the other arithmetic types. For this reason, in vif it was decided to disable implicit conversion to and from `bool`

. If needed, the conversion is still possible at no extra cost by using an explicit cast:

```
vec1f v1 = {1.5, -2.2, 100.0};
vec1b v2 = v1; // does *not* work! compiler error
vec1b v2 = vec1b{v1}; // this works
```

## Operator overloading¶

When dealing with `std::vector`

, the only thing you can do to operate on all the elements of an `std::vector`

is to iterate over these elements explicitly, either using a C++11 range-based loop, or using indices:

```
// Goal: multiply all elements by two.
std::vector<float> v = {1,2,3,4};
// Either using a range-based loop,
for (float& x : v) {
x *= 2;
}
// ... or an index-based loop.
for (std::size_t i = 0; i < v.size(); ++i) {
v[i] *= 2;
}
```

While this is fairly readable (especially the first version), it is still not very concise and expressive. For vif vectors, we have *overloaded* the usual mathematical operators to make it possible to write the above code in a much simpler way:

```
// Using vif vector.
vec1f v = {1,2,3,4};
v *= 2;
```

Not only this, but we can also perform operations on a pair of vectors:

```
// Goal: sum the content of the two vectors.
vec1f x = {1,2,3,4}, y = {4,3,2,1};
vec1f z = x + y;
// z: {5,5,5,5}
```

Almost all the mathematical and logical operators are overloaded. Therefore, as a rule of thumb, if you can do an operation with a type `T`

, you can do it with `vec<1,T>`

as well. The one notable exception are bitwise operators: `|`

, `&`

, and `^`

. The reason is twofold: first, these are not so commonly used in data analysis, and second, the `^`

operator can be mistakenly interpreted as the exponentiation operator, that some other languages possess (if you need to do exponentiation, use `pow()`

).

Note

In Python+NumPy and some C++ libraries (like xtensor), it is possible to mix vectors with different numbers of dimensions in a given operation, if some conditions are satisfied. For example, this allows multiplying the same 1D vector to each row or column of a 2D vector without having to write an explicit loop. This mechanism is called *broadcasting*. It is *not* implemented in vif, and will likely never be. Indeed, it is perceived that the benefits are not worth the costs, both in terms of making the vif codebase more complex, but also in introducing more complex rules for the user of the library. Therefore, in vif, one can only do arithmetics on vectors which have the *exact* same dimensions. If you require an operation similar to what broadcasting provides, you can always write the loop explicitly.

Note

Contrary to some other C++ libraries with vectorized arithmetic (such as Eigen, blazelib, or xtensor), vif does not use *expression templates*. Instead, each operation is executed immediately (no lazy evaluation) and operates if necessary on temporary intermediate vectors. While this may appear to be a sub-optimal implementation, vif was tuned to makes good use of return value optimization, move semantics, and for reusing the memory of temporaries in chained expressions. As a result, performance was found to be on par with expression templates in the most common situations, but memory consumption is generally higher in vif. This is of course dependent on the precise calculation to perform. The benefit of not using expression templates is a reduced compilation time, and a much simpler code base.

## Constant vectors¶

It is not possible to create a vector of constant elements, `vec<1, const int>`

will not compile. The correct way to create a constant vector is to make the vector itself constant: `const vec<1,int>`

.