Ranking Expressions

A rank feature is a named value calculated or looked up by vespa for each query/document combination. See the rank feature reference for a list of all the rank features available to ranking expressions.

A constant is either a floating point number, a boolean (true/false) or a quoted string. Since ranking expressions can only work on scalars and tensors, strings and booleans are immediately converted to scalars - true becomes 1.0, false 0.0 and a string its hash value. This means that strings can only be used for equality comparisons, other purposes such as parametrizing the key to slice out of a tensor will not work correctly.

Returns a new tensor with the lambda function defined in f(x)(expr) applied to each cell.

Arguments:

• tensor: a tensor expression.
• f(x)(expr): a lambda function with one argument.

map(t, f(x)(log(x)))
map(t, f(i)(if(i < 0, 0, i)))

Returns a new tensor with the aggregator applied across dimensions dim1, dim2, etc. If no dimensions are specified, reduce over all dimensions.

Arguments:

• tensor: a tensor expression.
• aggregator: the aggregator to use. See below.
• dim1, dim2, ...: the dimensions to reduce over. Optional.

Returns a new tensor with the aggregator applied across dimensions dim1, dim2, etc. If no dimensions are specified, reduce over all dimensions.

Available aggregators are:

• avg: arithmetic mean
• count: number of elements
• max: maximum value
• median: median value
• min: minimum value
• prod: product of all values
• sum: sum of all values

reduce(t, sum)         # Sum all values in tensor
reduce(t, count, x)    # Count number of cells along dimension x

Returns a new tensor constructed from the natural join between tensor1 and tensor2, with the resulting cells having the value as calculated from f(x,y)(expr), where x is the cell value from tensor1 and y from tensor2.

Arguments:

• tensor1: a tensor expression.
• tensor2: a tensor expression.
• f(x,y)(expr): a lambda function with two arguments.

Returns a new tensor constructed from the natural join between tensor1 and tensor2, with the resulting cells having the value as calculated from f(x,y)(expr), where x is the cell value from tensor1 and y from tensor2.

Formally, the result of the join is a new tensor with dimensions the union of dimension between tensor1 and tensor2. The cells are the set of all combinations of cells that have equal values on their common dimensions.

Examples:

# With tensors
t1 := {{x:0}: 1.0, {x:1}: 2.0}
t2 := {{x:0,y:0}: 3.0, {x:0,y:1}: 4.0, {x:1,y:0}: 5.0, {x:1,y:1}: 6.0}

# ... you get
join(t1, t2, f(x,y)(x * y)) == { {x:0,y:0}:  3.0, {x:0,y:1}:  4.0,
                                 {x:1,y:0}: 10.0, {x:1,y:1}: 12.0 }
reduce(join(t1, t2, f(x,y)(x * y)), sum) == 29.0

Returns a new tensor consisting of all cells from both the arguments, where the lambda function is used to produce a single value in the cases where both arguments provide a value for a cell.

Arguments:

• tensor1: a tensor expression.
• tensor2: a tensor expression.
• f(x,y)(expr): a lambda function with two arguments.

Returns a new tensor having all the cells of both arguments, where the lambda is invoked to produce a single value only when both arguments have a value for the same cell.

The argument tensors must have the same type, and that will be the type of the resulting tensor. Example:

# With tensors
t1 := tensor(key{},x[4]):{a:[1,2],b:[3,4]}
t2 := tensor(key{},x[2]):{b:[5,6],c:[7,8]}

# ... you get
merge(t1, t2, f(left,right)(right)) == tensor(key{},x[2]):{a:[1,2],b:[5,6],c:[7,8]}

Generates new tensors according to type specification and expression expr.

Arguments:

• tensor-type-spec: an indexed tensor type specification.
• (expression): a lambda function expressing how to generate the tensor.

Generates new tensors according to the type specification and expression expr. The tensor type must be an indexed tensor (e.g. tensor<float>(x[10])). The expression in expr will be evaluated for each cell. The arguments in the expression is implicitly the names of the dimensions defined in the type spec.

Useful for creating transformation tensors. Examples:

# With tensor
t1 := tensor(x[4]):[1.0, 2.0, 3.0, 4.0]

# ... you get
tensor<float>(x[3])(x) == [0.0, 1.0, 2.0]
tensor<float>(x[2],y[2])(x == y) == { {x:0,y:0}: 1.0, {x:0,y:1}: 0.0,
                                      {x:1,y:0}: 0.0, {x:1,y:1}: 1.0 }

# Create a size 2 1d tensor by accessing t1 at two indexes given by adding
# the index of it (f - which is 0 and 1) by a function also named f.
tensor(f[2])(t1{x: f + f()}))

Renames one or more dimensions in the tensor.

Arguments:

• tensor: a tensor expression.
• dim-to-rename: a dimension, or list of dimensions, to rename.
• new-names: new names for the dimensions listed above.

# With tensors
t1 := {{x:0,y:0}: 1.0, {x:0,y:1}: 0.0, {x:1,y:0}: 0.0, {x:1,y:1}: 1.0}

# ... you get
rename(t1,x,z) == {{z:0,y:0}: 1.0, {z:0,y:1}: 0.0, {z:1,y:0}: 0.0, {z:1,y:1}: 1.0}
rename(t1,(x,y),(i,j)) == {{i:0,j:0}: 1.0, {i:0,j:1}: 0.0, {i:1,j:0}: 0.0, {i:1,j:1}: 1.0}

Concatenates two tensors along dimension dim.

Arguments:

• tensor1: a tensor expression.
• tensor2: a tensor expression.
• dim: the dimension to concatenate along.

# With tensors
t1 := {{x:0}: 0.0, {x:1}: 1.0}
t2 := {{x:0}: 2.0, {x:1}: 3.0}

# You get
concat(t1,t2,x) == {{x:0}: 0.0, {x:1}: 1.0}, {x:2}: 2.0, {x:3}: 3.0}}

Slice - returns a new tensor containing the cells matching the partial address.

Arguments:

• tensor: a tensor expression.
• partial-address: Can be given in the form of a tensor address {dimension:label,..}, or for tensors referenced directly and having a single mapped or indexed type respectively as just a label in curly brackets {label} or just an index in square brackets, [index]. Index labels may be specified by a lambda expression enclosed in parentheses.

# With tensors
t1 := tensor(x[2]):[1.0, 2.0]
t2 := tensor(key{}):{ key1:1.0, key2:2.0 }
t3 := tensor(key{},x[2]):{ key1:[1.0, 2.0], key2:[3.0, 4.0] }

# ... you get
t1[1] == {2.0}
t2{key1} == {1.0}
t3{key1} == tensor(x[2]):[1.0, 2.0]
t3[1] == tensor(key{}):{key1:2.0, key2:4.0}
t3{key:key1,x:1} == {2.0}
t3{key:key1,x:(3-2)} == {2.0}
t3{key:key1,x:myFunctionReturning1()} == {2.0}

Returns a new tensor having the type and cell values given explicitly. Each cell value may be supplied by a lambda which can access other features.

Returns a new tensor from the literal form, where the type must be specified explicitly. Each value may be supplied by a lambda, which - in contrast to all other lambdas - may refer to features and expressions from the context. Examples:

# With tensor
t1 := tensor(x[2]):[1.0, 2.0]]

# ... you get
tensor(x{}):{x1:3, x2:4} == tensor(x{}):{x1:3.0, x2:4.0}
# Used in conjunction with slice, to convert an indexed tensor to mapped form:
tensor(x{}):{x1:t1[1], x2:t1[0]} = tensor(x{}):{x1:2.0, x2:1.0}

Returns a new tensor that is the same as the argument, except that all cell values are converted to the given cell type.

Arguments:

• tensor: a tensor expression.
• cell_type: wanted cell type.

# With tensors
t1 := tensor<float>(x[5])(x+1)
t2 := tensor<bfloat16>(x[5])(x+1)

# ... you get
t2 == cell_cast(t1, bfloat16)