# Vector and Matrix types

Infer.NET includes types for representing vectors (1D arrays of double values) and matrices (2D rectangular arrays of double values).

## The Vector type

The Vector class is a comprehensive class for doing efficient operations on vectors of doubles. The Vector class is actually an abstract base class that has three concrete implementations: namely DenseVector, SparseVector and ApproximateSparseVector. However, most of the time you should interact with the Vector class which provides a common gateway for interacting with all the different vector types. The sparse vector types are useful when you have vectors where most of the elements have the same value or approximately the same value. This is common, for example, when working with large Dirichlet and Discrete distributions. The sparsity is specified using the Sparsity class described in the next section.

### Sparsity

Sparsity specifications, which are used in the Vector factory methods described in a later section, can be created using the Sparsity class. This class contains several static properties or methods for creating different sparsity specifications as shown in the following table. Once created, the properties of a sparsity specification cannot be changed.

Static property or method |
Parameters |
Explanation/Comments |

Dense (static property) |
None |
Creates the specification for dense vectors. This specification assumes that most elements of the vector will be different, so there is nothing to gain by having a sparse representation |

Sparse (static property) |
None |
Creates the specification for exact sparse vectors. This specification assumes that most elements of the vector will be the same, and therefore computational and memory advantages can be gained by maintain a sparse representation of the Vector. The common value (i.e. the value shared by most of the Vector elements) is maintained by the Vector rather than the sparsity specification, and will be modified as needed by various vector operations. |

ApproximateWithTolerance (static method) |
Tolerance: The tolerance at which vector element
values are considered equal to the common value. |
The same as Sparse, except that after any operation, any values which are with the tolerance of the common value are considered equal to the common value. |

FromSpec (static method) |
IsDense: Whether the specification should be dense
or not.Tolerance: The tolerance at which vector element
values are considered equal to the common value.CountTolerance: The maximum allowed count of vector
elements not set to the common value. |
This method allows sparsity to be explicitly specified via the method parameters. The only additional option this gives is the count tolerance which is another form of approximation. After each vector operation, if the number of non-common values is greater than the count tolerance, then the elements with values closest to the common value are set to the common value so that the tolerance can be satisfied. If the count tolerance has a value of less than or equal to 0, then it is ignored. |

### Factory Methods

To create a vector, use one of the following static methods on the Vector class. These include settings for the desired sparsity of the generated vector:

Method: Explanation |
C# Examples |

Zero: Creates a vector of a given length with all
elements set to 0.0. |
```
Vector v =
Vector.Zero(2);
// Dense by default
``` |

Constant: Creates a vector of a given length with
all elements are set to a given constant value. |
```
Vector v
= Vector.Constant(2, 3.0);
// Dense by default
``` |

FromArray:
Creates a vector from an array of doubles. |
```
Vector v
= Vector.FromArray(doubleArray);
// Dense by default
``` |

Copy: Create a
copy of an existing vector with a specified target sparsity. |
```
Vector v
= Vector.Copy(v1);
// Dense target by default
``` |

There are many categories of functions on Vector instances which allow efficient processing. These are summarised below; for full details, see the code documentation for the Vector class..

**Indexing**

Indexing allows the getting and setting of individual elements of the vector.
This is only recommended in exceptional circumstances as it is typically an
inefficient way to process vectors. Other methods relating to indexing are
**IndexOfAll**, **IndexOf**, **IndexOfMin**,
and **IndexOfMax**..

### Appending

Vectors can be created by appending one vector or scalar to another vector by
means of the **Append** method. A static version of this, **
Concat**, is also available.

### SetTo

An existing Vector instance can be modified by
setting its values to a set of given values. Instance methods **SetTo**,
**SetToSubarray**, and **SetAllElements** provide this
functionality. The **CopyTo** method provides the reverse
functionality, allowing the current instance to be copied to another specified
Vector iinstance.

### SetToFunction

The Vector class has some methods to set the
current instance to a combination of one or two other vectors. One general such
method is **SetToFunction** which takes one or two vectors along
with a delegate giving the element-wise calculation. Specific such methods
include **SetToSum**, **SetToDifference**, **
SetToProduct**, **SetToRatio** and **SetToPower**.

### Operators

Operators +, - (unary and binary), *, / and ^ are all overridden to provide
addition, subtraction/negation, product, division, and raising to a power. >,
>=, <, <= are all overridden to provide vector comparison. These comparison
operators make use of two general methods **All** and **Any**
which take a condition delegate.

### Reduce

This category of methods allows one or more vectors to be reduced to a scalar
by means of a combining function. The most general method is **Reduce**
which takes a general combining delegate as an argument. Specific versions
include **Sum**, **SumI**, **SumISq**,
**Max**, **Min**, and **Inner**.

### Operations involving matrices

Methods such as **SetToProduct** (with a Matrix and Vector
argument), **PredivideBy**, **Outer**, and **
SetToDiagonal** are provided to support some fundamental operations
involving vectors and matrices. Although these will work with any type of vector
(sparse or dense), they will be quite inefficient for sparse vectors, and there
is no support for sparse matrices in Infer.NET.

## The PositiveDefiniteMatrix type

The PostiveDefiniteMatrix class is used to represent a positive definite matrix which is the domain type for a Wishart distribution. Wishart distributions are used to represent uncertainty in the precision matrix of a VectorGaussian distribution, and many of the methods in the PostiveDefiniteMatrix class are geared towards this usage. For full details see the code documentation for the PositiveDefiniteMatrix class.