# SCALAR\_VECTOR\_MUL

The `SCALAR_VECTOR_MUL` function multiples each element in a vector with a scalar value. The function returns a vector.

## Syntax

```sql
SCALAR_VECTOR_MUL(scalar_value, vector_expression)
```

## Arguments

* `scalar_value`: A scalar value.

* `vector_expression`: An expression that evaluates to a vector. Vectors can be stored in SingleStore using the native `VECTOR` type ([Vector Type](https://docs.singlestore.com/cloud/reference/sql-reference/data-types/vector-type.md)) or the `BLOB` type ([Binary String Types](https://docs.singlestore.com/cloud/reference/sql-reference/data-types/binary-string-types.md)). SingleStore recommends using the `VECTOR` type when possible.

## Return Type

The function returns the type of the second argument.

## Output Format for Examples

Vectors can be output in JSON or binary format. Use JSON format for examples and for output readability. For production, use the default binary for efficiency.

Use the following command to output vectors in JSON format.

```sql
SET vector_type_project_format = JSON;
```

Use the following command to set the output format back to binary.

```sql
SET vector_type_project_format = BINARY;
```

## Using SCALAR\_VECTOR\_MUL with the VECTOR Data Type

## Example 1 - Vector with F32 Element Type

First create a table of vectors of length 4 using the `VECTOR` data type and insert data into that table.

```sql
CREATE TABLE vectors (id int, vec VECTOR(4) not null);

INSERT INTO vectors VALUES (1, '[0.45, 0.55, 0.495, 0.5]');
INSERT INTO vectors VALUES (2, '[0.1, 0.8, 0.2, 0.555]');
INSERT INTO vectors VALUES (3, '[-0.5, -0.03, -0.1, 0.86]');
INSERT INTO vectors VALUES (4, '[0.5, 0.3, 0.807, 0.1]');
```

> **📝 Note**: The default element type for the VECTOR type is 32-bit floating point (`F32`). The VECTOR type supports other element types, including integer types, as described in the [Vector Type](https://docs.singlestore.com/cloud/reference/sql-reference/data-types/vector-type.md) documentation.

The following SQL multiplies each of those vectors by the scalar number 10.

```sql
SET vector_type_project_format = JSON;  /* to make vector output readable */

SELECT id, SCALAR_VECTOR_MUL(10, vec)
FROM vectors
ORDER BY id;


```

```output

+------+---------------------------------+
| id   | SCALAR_VECTOR_MUL(10, vec)      |
+------+---------------------------------+
|    1 | [4.5,5.5,4.94999981,5]          |
|    2 | [1,8,2,5.55000019]              |
|    3 | [-5,-0.299999982,-1,8.60000038] |
|    4 | [5,3,8.06999969,1]              |
+------+---------------------------------+

```

## Example 2 - Vector with I16 Element Type

This example shows how to use `SCALAR_VECTOR_MUL` with a `VECTOR` with an element type of 16-bit integer (`I16`).

```sql
CREATE TABLE vectors_i16(id INT, vec VECTOR(3, I16));

INSERT INTO vectors_i16 VALUES(1, '[1, 2, 3]');
INSERT INTO vectors_i16 VALUES(2, '[4, 5, 6]');
INSERT INTO vectors_i16 VALUES(3, '[1, 4, 8]');
```

The following SQL multiplies each of the vectors in that table by the scalar number 10.

```sql
SET vector_type_project_format = JSON;  /* to make vector output readable */

SELECT id, SCALAR_VECTOR_MUL(10, vec)
FROM vectors_i16
ORDER BY id;


```

```output

+------+----------------------------+
| id   | SCALAR_VECTOR_MUL(10, vec) |
+------+----------------------------+
|    1 | [10,20,30]                 |
|    2 | [40,50,60]                 |
|    3 | [10,40,80]                 |
+------+----------------------------+

```

## Using SCALAR\_VECTOR\_MUL with Vectors as BLOBs

The following examples and descriptions show the use of `SCALAR_VECTOR_MUL` to multiply the a vector by a scalar when the elements of the vector are stored as a `BLOB`.

## Example 1 - BLOB Argument

Create a table with a column of type `BLOB` to store the vectors. The second column in this table, with column name `vec` and type `BLOB`, will store the vectors. This example demonstrates storing vector data using `BLOB`s, hence the column of type `BLOB` named `vec`.

Then use the `JSON_ARRAY_PACK` built-in function to easily insert properly formatted vectors.

```sql
CREATE TABLE vectors_b (id int, vec BLOB not null);

INSERT INTO vectors_b VALUES (1, JSON_ARRAY_PACK('[0.1, 0.8, 0.2, 0.555]'));
INSERT INTO vectors_b VALUES (2, JSON_ARRAY_PACK('[0.45, 0.55, 0.495, 0.5]'));
```

The following query multiples the vectors in the `vectors_b` table by 10 and uses `JSON_ARRAY_UNPACK` to see the results in JSON format.

```sql
SELECT id, JSON_ARRAY_UNPACK(SCALAR_VECTOR_MUL(10, vec)) as scalar_mul
FROM vectors_b
ORDER BY id;


```

```output

+------+------------------------+
| id   | scalar_mul             |
+------+------------------------+
|    1 | [1,8,2,5.55000019]     |
|    2 | [4.5,5.5,4.94999981,5] |
+------+------------------------+

```

`JSON_ARRAY_UNPACK` was used here to output the vectors in readable format because `VECTOR_SORT` returns a `BLOB` when its second argument is a `BLOB`.

The following query multiples the vectors in the `vectors_b` table by 10 and uses `HEX` to view the results in hexadecimal format.

```sql
SELECT id, HEX(SCALAR_VECTOR_MUL(10, vec)) as scalar_mul
FROM vectors_b
ORDER BY id;


```

```output

+------+----------------------------------+
| id   | scalar_mul                       |
+------+----------------------------------+
|    1 | 0000803F00000041000000409A99B140 |
|    2 | 000090400000B04066669E400000A040 |
+------+----------------------------------+

```

## Using Suffixes for Other Element Types with BLOBs

The default element type for vector storage and processing is 32-bit floating point (`F32`). However, other element types are supported.

You can specify the datatype of the vector elements to be used in the operation by adding a suffix to the function. All operations are done using the specified datatype. Omitting the suffix from the function is equivalent to suffixing it with `_F32`.

When using a suffix, the return type will be the type specified by the suffix.

> **📝 Note**: Vector functions with suffixes do not work with the `VECTOR` type. However, vector functions without suffixes are overloaded to work on `VECTOR` values of any element type.

The following table lists the suffixes and their data type.

| Suffix | Data Type                                           |
| ------ | --------------------------------------------------- |
| `_I8`  | 8-bit signed integer                                |
| `_I16` | 16-bit signed integer                               |
| `_I32` | 32-bit signed integer                               |
| `_I64` | 64-bit signed integer                               |
| `_F32` | 32-bit floating-point number (IEEE standard format) |
| `_F64` | 64-bit floating-point number (IEEE standard format) |

## Example 2 - BLOBs with 16-bit Integers

Below is an example of using `JSON_ARRAY_PACK` and `SCALAR_VECTOR_MUL` with 16-bit signed integers.

First create a table of vectors stored as 16-bit integers. Note the use of the `_I16` suffix on `JSON_ARRAY_PACK`.

```sql
CREATE TABLE vectors_b_i (id int, vec BLOB not null);

INSERT INTO vectors_b_i VALUES (1, JSON_ARRAY_PACK_I16('[1, 3, 2, 5]'));
INSERT INTO vectors_b_i VALUES(2, JSON_ARRAY_PACK_I16('[23, 4, 1, 8]'));
```

This following query multiplies the vectors in the `vectors_b_i` table by the scalar 10.

```sql
SELECT id, JSON_ARRAY_UNPACK_I16(SCALAR_VECTOR_MUL_I16(10, vec)) AS scalar_mul
FROM vectors_b_i
ORDER BY id; 


```

```output

+------+-----------------+
| id   | scalar_mul      |
+------+-----------------+
|    1 | [10,30,20,50]  |
|    2 | [230,40,10,80] |
+------+-----------------+

```

> **📝 Note**: Be sure that the suffixes you use to pack the vector data match the suffixes you use to unpack the data and the suffixes you use on functions to process that data.

## Formatting Binary Vector Data for BLOBs

When using the `BLOB` type for vector operations, vector data can be formatted using `JSON_ARRAY_PACK`. If your vector data is already in a packed binary format, you can load that data into the `BLOB`s. The data must be encoded as a `BLOB` containing packed numbers in little-endian byte order. Vectors stored as `BLOB`s can be of any length; however, the input blob length must be divisible by the size of the packed vector elements .

## Troubleshooting

Should you receive an unexpected `NULL` value or values in the results, check the order of the arguments. The `SCALAR_VECTOR_MUL` function returns `NULL` if the order of arguments is reversed. 

Using the `vectors` table created above, the following query reverses the order of the arguments, putting the `VECTOR` first and the scalar value (`10`) second. The result is four `NULL` values as is expected when the order of arguments is reversed.

```sql
SELECT id, SCALAR_VECTOR_MUL(vec, 10)
FROM vectors
ORDER BY id;


```

```output

+------+----------------------------+
| id   | SCALAR_VECTOR_MUL(vec, 10) |
+------+----------------------------+
|    1 | NULL                       |
|    2 | NULL                       |
|    3 | NULL                       |
|    4 | NULL                       |
+------+----------------------------+
```

## Related Topics

* [Vector Type](https://docs.singlestore.com/cloud/reference/sql-reference/data-types/vector-type.md)
* [JSON\_ARRAY\_PACK](https://docs.singlestore.com/cloud/reference/sql-reference/vector-functions/json-array-pack.md)
* [JSON\_ARRAY\_UNPACK](https://docs.singlestore.com/cloud/reference/sql-reference/vector-functions/json-array-unpack.md)
* [Binary String Types](https://docs.singlestore.com/cloud/reference/sql-reference/data-types/binary-string-types.md)

***

Modified at: June 6, 2024

Source: [/cloud/reference/sql-reference/vector-functions/scalar-vector-mul/](https://docs.singlestore.com/cloud/reference/sql-reference/vector-functions/scalar-vector-mul/)

(An index of the documentation is available at /llms.txt)