This section covers vector math and vector manipulation functions.

## Arrays

Arrays can be created with the `array`

function.

For example, the expression below creates a numeric array with three elements:

`array(1, 2, 3)`

When this expression is sent to the `/stream`

handler it responds with a JSON array:

```
{
"result-set": {
"docs": [
{
"return-value": [
1,
2,
3
]
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

## Array Operations

Arrays can be passed as parameters to functions that operate on arrays.

For example, an array can be reversed with the `rev`

function:

`rev(array(1, 2, 3))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": [
3,
2,
1
]
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

Another example is the `length`

function, which returns the length of an array:

`length(array(1, 2, 3))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": 3
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

A slice of an array can be taken with the `copyOfRange`

function, which copies elements of an array from a start and end range.

`copyOfRange(array(1,2,3,4,5,6), 1, 4)`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": [
2,
3,
4
]
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

Elements of an array can be trimmed using the `ltrim`

(left trim) and `rtrim`

(right trim) functions. The `ltrim`

and `rtrim`

functions remove a specific number of elements from the left or right of an array.

The example below shows the `lrtim`

function trimming the first 2 elements of an array:

`ltrim(array(0,1,2,3,4,5,6), 2)`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": [
2,
3,
4,
5,
6,
]
},
{
"EOF": true,
"RESPONSE_TIME": 1
}
]
}
}
```

## Vector Sorting

An array can be sorted in natural ascending order with the `asc`

function.

The example below shows the `asc`

function sorting an array:

`asc(array(10,1,2,3,4,5,6))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": [
1,
2,
3,
4,
5,
6,
10
]
},
{
"EOF": true,
"RESPONSE_TIME": 1
}
]
}
}
```

## Vector Summarizations and Norms

There are a set of functions that perform summarizations and return norms of arrays. These functions operate over an array and return a single value. The following vector summarizations and norm functions are available: `mult`

, `add`

, `sumSq`

, `mean`

, `l1norm`

, `l2norm`

, `linfnorm`

.

The example below shows the `mult`

function, which multiples all the values of an array.

`mult(array(2,4,8))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": 64
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

The vector norm functions provide different formulas for calculating vector magnitude.

The example below calculates the `l2norm`

of an array.

`l2norm(array(2,4,8))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": 9.16515138991168
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

## Scalar Vector Math

Scalar vector math functions add, subtract, multiply or divide a scalar value with every value in a vector. The following functions perform these operations: `scalarAdd`

, `scalarSubtract`

, `scalarMultiply`

and `scalarDivide`

.

Below is an example of the `scalarMultiply`

function, which multiplies the scalar value `3`

with every value of an array.

`scalarMultiply(3, array(1,2,3))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": [
3,
6,
9
]
},
{
"EOF": true,
"RESPONSE_TIME": 0
}
]
}
}
```

## Element-By-Element Vector Math

Two vectors can be added, subtracted, multiplied and divided using element-by-element vector math functions. The available element-by-element vector math functions are: `ebeAdd`

, `ebeSubtract`

, `ebeMultiply`

, `ebeDivide`

.

The expression below performs the element-by-element subtraction of two arrays.

`ebeSubtract(array(10, 15, 20), array(1,2,3))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": [
9,
13,
17
]
},
{
"EOF": true,
"RESPONSE_TIME": 5
}
]
}
}
```

## Dot Product and Cosine Similarity

The `dotProduct`

and `cosineSimilarity`

functions are often used as similarity measures between two sparse vectors. The `dotProduct`

is a measure of both angle and magnitude while `cosineSimilarity`

is a measure only of angle.

Below is an example of the `dotProduct`

function:

`dotProduct(array(2,3,0,0,0,1), array(2,0,1,0,0,3))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": 7
},
{
"EOF": true,
"RESPONSE_TIME": 15
}
]
}
}
```

Below is an example of the `cosineSimilarity`

function:

`cosineSimilarity(array(2,3,0,0,0,1), array(2,0,1,0,0,3))`

When this expression is sent to the `/stream`

handler it responds with:

```
{
"result-set": {
"docs": [
{
"return-value": 0.5
},
{
"EOF": true,
"RESPONSE_TIME": 7
}
]
}
}
```