The following elementwise unary operations can be performed on vectors, producing a vector result:

The following elementwise binary operations can be performed on vectors, producing a vector result:

The following elementwise ternary operations can be performed on vectors, producing a vector result:

A vector with one type of values can be converted a vector with another type of values using view_cast.

For example, to convert a vector of floats A into a vector of ints Z:

Vector<float> A(size);
Vector<int>   Z(size);
Z = view_cast<int>(A)

The following arithmetic elementwise binary operations and functions are available on vectors:

Addition, subtraction, multiplication, and division can also be written in operator form:

In all the preceding functions and operations, either of the vector operands can be replaced with scalar operands.

For example, to perform a scalar-vector multiply:

Z = a * B;

or

Z = mul(a, B);

The following arithmetic elementwise ternary operations and functions are available on vectors:

In all the preceding functions and operations, one or more of the vector operands can be replaced with scalar operands.

For example, to scale a vector, then apply an offset:

Z = scale * A + offset;

or

Z = ma(scale, A, offset);

(where scale and offset are scalar values)

In all the preceding functions and operations, one or more of the vector operands can be replaced with scalar operands.

For example, the apply a scalar threshold b to a vector:

Z = ite(A > b, A, b);

The following functions reduce a vector to a single value:

The following functions reduce a vector to a single value that corresponds to an element within the vector.

VSIPL++ provides facilities to perform convolutions on vectors through the class template Convolution (section 4.8.1). Once constructed with compile-time selections, a convolution object can be applied to an input vector to produce results in an output vector.

VSIPL++ provides facilities to perform correlations on vectors through the class template Correlation (section 4.8.2). Once constructed with compile-time selections, a correlation object can be applied to an input vector and a kernel vector to produce results in an output vector.

VSIPL++ provides facilities to perform an FIR filter on vectors through the class template Fir (section 4.8.3). Once constructed with compile-time selections, an FIR object can be applied to an input vector to produce results in an output vector.

VSIPL++ provides facilities to perform an histogram on vectors through the class template Histogram. Once constructed with compile-time selections, a histogram object can be applied to an input vector to produce results in an output vector.

VSIPL++ provides facilities to generate vectors of random number   through the class template Rand. Once constructed with compile-time selections, a Rand object can generate a vector of random numbers through   the invocation of one of its member functions..

VSIPL++ provides a function freqswap to swap halves of vectors. (section 4.7.3)

VSIPL++ allows subviews of vectors to be created. A subview represents a subset of the original vector. The subview aliases the original vector, that is changes to the subview will be reflected in the original vector, and visa versa.

To represent a vector subview in a variable, it is necessary to use the correct block type. Otherwise the variable will copy the values in the subview.

Vector<T>::subview_type A = view(Domain<1>(f, s, l));

User-defined functions that accept a vector as a parameter should use a template parameter to represent the vector's block type. This allows vectors with different block types, such as those created by subview operators, to be handled by the function.

For example, to write a function that accepts a vector of floating-point values:

template <typename BlockT>
...
function(Vector<float, BlockT> vector)
{
   ...
}

If the function can handle different value types (such as single- and double-precision), the value type can also be made a template parameter:

template <typename, T
          typename BlockT>
...
function(Vector<T, BlockT> vector)
{
   ...
}