> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentación de las funciones de distancia

# Funciones de distancia

{/*AUTOGENERATED_START*/}

<div id="L1Distance">
  ## L1Distance
</div>

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio `L1` (norma 1 (distancia de la [geometría del taxista](https://en.wikipedia.org/wiki/Taxicab_geometry))).

**Sintaxis**

```sql theme={null}
L1Distance(vector1, vector2)
```

**Alias**: `distanceL1`

**Argumentos**

* `vector1` — Primer vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)

**Valor devuelto**

Devuelve la distancia de norma 1. Para entradas `Array`, devuelve `Float32` si el supertipo común más específico de los tipos de elemento es `Float32` o `BFloat16`; de lo contrario, `Float64`. Para entradas `Tuple`, el tipo de retorno sigue el tipo de resultado aritmético de las operaciones elemento a elemento (los tipos enteros se conservan). [`(U)Int*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L1Distance((1, 2), (2, 3))
```

```response title=Response theme={null}
┌─L1Distance((1, 2), (2, 3))─┐
│                          2 │
└────────────────────────────┘
```

<div id="L1Norm">
  ## L1Norm
</div>

Introducido en: v21.11.0

Calcula la suma de los valores absolutos de los elementos de un vector.

**Sintaxis**

```sql theme={null}
L1Norm(vector)
```

**Alias**: `normL1`

**Argumentos**

* `vector` — Vector o tupla de valores numéricos. [`Array(T)`](/docs/es/reference/data-types/array) o [`Tuple(T)`](/docs/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve la norma L1 o la distancia de la [geometría del taxista](https://en.wikipedia.org/wiki/Taxicab_geometry). [`UInt*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float) o [`Decimal`](/docs/es/reference/data-types/decimal)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L1Norm((1, 2))
```

```response title=Response theme={null}
┌─L1Norm((1, 2))─┐
│              3 │
└────────────────┘
```

<div id="L1Normalize">
  ## L1Normalize
</div>

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla representan las coordenadas) en el espacio `L1` ([geometría del taxista](https://en.wikipedia.org/wiki/Taxicab_geometry)).

**Sintaxis**

```sql theme={null}
L1Normalize(tuple)
```

**Aliases**: `normalizeL1`

**Argumentos**

* `tuple` — Una tupla de valores numéricos. [`Tuple(T)`](/docs/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/docs/es/reference/data-types/tuple)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L1Normalize((1, 2))
```

```response title=Response theme={null}
┌─L1Normalize((1, 2))─────────────────────┐
│ (0.3333333333333333,0.6666666666666666) │
└─────────────────────────────────────────┘
```

<div id="L2Distance">
  ## L2Distance
</div>

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio euclidiano ([distancia euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance)).

**Sintaxis**

```sql theme={null}
L2Distance(vector1, vector2)
```

**Aliases**: `distanceL2`

**Argumentos**

* `vector1` — Primer vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)

**Valor devuelto**

Devuelve la distancia L2. Para entradas `Array`, devuelve `Float32` si el supertipo común mínimo de los tipos de elemento es `Float32` o `BFloat16`; en caso contrario, `Float64`. Para entradas `Tuple`, siempre devuelve `Float64`. [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L2Distance((1, 2), (2, 3))
```

```response title=Response theme={null}
┌─L2Distance((1, 2), (2, 3))─┐
│         1.4142135623730951 │
└────────────────────────────┘
```

<div id="L2DistanceTransposed">
  ## L2DistanceTransposed
</div>

Introducido en: v25.10.0

Calcula la distancia aproximada entre dos puntos (los valores de los vectores corresponden a las coordenadas) en el espacio euclidiano ([distancia euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance)).

**Sintaxis**

```sql theme={null}
L2DistanceTransposed(vector1, vector2, p[, used_dims])
```

**Alias**: `distanceL2Transposed`

**Argumentos**

* `vectors` — Vectores. [`QBit(T, UInt64[, UInt64])`](/docs/es/reference/data-types/qbit)
* `reference` — Vector de referencia. [`Array(T)`](/docs/es/reference/data-types/array)
* `p` — Número de bits de cada elemento del vector que se usarán en el cálculo de la distancia (de 1 hasta el ancho de bits del elemento). El nivel de cuantización controla el equilibrio entre precisión y velocidad. Usar menos bits da lugar a operaciones de E/S y cálculos más rápidos, pero con menor exactitud, mientras que usar más bits aumenta la exactitud a costa del rendimiento. [`UInt`](/docs/es/reference/data-types/int-uint)
* `used_dims` — Opcional. Número de dimensiones iniciales que se leerán para una búsqueda de dimensión reducida (Matryoshka) en un `QBit` con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (los elementos adicionales al final se ignoran). Solo se leen los grupos de stride que cubren estas dimensiones. [`UInt`](/docs/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la distancia aproximada de la norma 2. Siempre devuelve `Float64`. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT L2DistanceTransposed(vec, array(1, 2), 16) FROM qbit;
```

```response title=Response theme={null}
┌─L2DistanceTransposed([0, 1], [1, 2], 16)─┐
│                       1.3922918381215914 │
└──────────────────────────────────────────┘
```

<div id="L2DistanceTransposedQuantized">
  ## L2DistanceTransposedQuantized
</div>

Introducido en: v26.7.0

Calcula la [distancia euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance) aproximada entre un `QBit(Int8)` de códigos `quantizeBFloat16ToInt8` (descuantizados sobre la marcha) y un vector de referencia. Un vector de referencia (consulta) `Float` se compara directamente con precisión `Float32` --la precisión de reconstrucción de los códigos descuantizados--, por lo que una consulta `Float64` se reduce a `Float32`, mientras que una consulta `BFloat16` se amplía a este exactamente (cálculo de distancia asimétrico); una referencia `Array(Int8)` se trata, a su vez, como códigos `quantizeBFloat16ToInt8` y se descuantiza a sus niveles de reconstrucción. Tenga en cuenta que `p` trunca solo los códigos `QBit` almacenados; la referencia `Array(Int8)` es una consulta completa y siempre se reconstruye con precisión completa de 8 bits, por lo que esta es una distancia simétrica entre cuantizado y cuantizado solo cuando `p = 8` (para `p < 8`, solo el lado almacenado se lee con una precisión más gruesa). Debe estar en el mismo espacio en el que estaban los valores antes de la cuantización (es decir, después de la misma rotación aleatoria y el mismo escalado), lo cual es responsabilidad de quien realiza la llamada. La distancia de coseno es invariante a la escala; el producto escalar y la distancia L2 no lo son.

**Sintaxis**

```sql theme={null}
L2DistanceTransposedQuantized(vectors, reference, p[, used_dims])
```

**Argumentos**

* `vectors` — Vectores de códigos `quantizeBFloat16ToInt8`. [`QBit(Int8, UInt64[, UInt64])`](/docs/es/reference/data-types/qbit)
* `reference` — Vector de referencia (consulta): un array `Float` (la consulta, comparada con precisión `Float32` -- una consulta `Float64` se reduce a `Float32`), o un `Array(Int8)` de códigos `quantizeBFloat16ToInt8` descuantizados sobre la marcha. [`Array(Float32)`](/docs/es/reference/data-types/array) o [`Array(Int8)`](/docs/es/reference/data-types/array)
* `p` — Número de bits superiores de cada código `QBit` almacenado que se usarán (de 1 a 8). Menos bits reconstruyen un cuantizador embebido más tosco para una E/S más rápida con menor exactitud; 8 bits es la reconstrucción con precisión completa. `p` solo trunca el `QBit` almacenado; una referencia `Array(Int8)` siempre se reconstruye con precisión completa de 8 bits. [`UInt`](/docs/es/reference/data-types/int-uint)
* `used_dims` — Opcional. Número de dimensiones iniciales que se leerán para una búsqueda de dimensión reducida (Matryoshka) en un `QBit` con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (cualquier elemento adicional al final se ignora). Solo se leen los grupos de stride que cubren estas dimensiones. [`UInt`](/docs/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la distancia aproximada de la norma 2. Siempre devuelve `Float64`. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT L2DistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;
```

<div id="L2Norm">
  ## L2Norm
</div>

Introducida en: v21.11.0

Calcula la raíz cuadrada de la suma de los cuadrados de los elementos de un vector.

**Sintaxis**

```sql theme={null}
L2Norm(vector)
```

**Alias**: `normL2`

**Argumentos**

* `vector` — Vector o tupla de valores numéricos. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)

**Valor devuelto**

Devuelve la norma L2 o la [distancia euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance). [`UInt*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L2Norm((1, 2))
```

```response title=Response theme={null}
┌───L2Norm((1, 2))─┐
│ 2.23606797749979 │
└──────────────────┘
```

<div id="L2Normalize">
  ## L2Normalize
</div>

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla son las coordenadas) en el espacio euclidiano (mediante la [distancia euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance)).

**Sintaxis**

```sql theme={null}
L2Normalize(tuple)
```

**Alias**: `normalizeL2`

**Argumentos**

* `tuple` — Una tupla de valores numéricos. [`Tuple(T)`](/docs/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/docs/es/reference/data-types/tuple)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L2Normalize((3, 4))
```

```response title=Response theme={null}
┌─L2Normalize((3, 4))─┐
│ (0.6,0.8)           │
└─────────────────────┘
```

<div id="L2SquaredDistance">
  ## L2SquaredDistance
</div>

Introducida en: v22.7.0

Calcula la suma de los cuadrados de las diferencias entre los elementos correspondientes de dos vectores.

**Sintaxis**

```sql theme={null}
L2SquaredDistance(vector1, vector2)
```

**Alias**: `distanceL2Squared`

**Argumentos**

* `vector1` — Primer vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)

**Valor devuelto**

Devuelve la suma de los cuadrados de las diferencias entre los elementos correspondientes de dos vectores. Para entradas `Array`, devuelve `Float32` si el menor supertipo común de los tipos de elemento es `Float32` o `BFloat16`; de lo contrario, `Float64`. Para entradas `Tuple`, el tipo de retorno sigue el tipo de resultado aritmético de las operaciones elemento a elemento (se conservan los tipos enteros). [`(U)Int*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L2SquaredDistance([1, 2, 3], [0, 0, 0])
```

```response title=Response theme={null}
┌─L2SquaredDis⋯ [0, 0, 0])─┐
│                       14 │
└──────────────────────────┘
```

<div id="L2SquaredNorm">
  ## L2SquaredNorm
</div>

Introducido en: v22.7.0

Calcula el cuadrado de la raíz cuadrada de la suma de los cuadrados de los elementos del vector (la [`L2Norm`](#L2Norm)).

**Sintaxis**

```sql theme={null}
L2SquaredNorm(vector)
```

**Alias**: `normL2Squared`

**Argumentos**

* `vector` — Vector o tupla de valores numéricos. [`Array(T)`](/docs/es/reference/data-types/array) o [`Tuple(T)`](/docs/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve la norma L2 al cuadrado. [`UInt*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float) o [`Decimal`](/docs/es/reference/data-types/decimal)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT L2SquaredNorm((1, 2))
```

```response title=Response theme={null}
┌─L2SquaredNorm((1, 2))─┐
│                     5 │
└───────────────────────┘
```

<div id="LinfDistance">
  ## LinfDistance
</div>

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio `L_{inf}` ([norma máxima](https://en.wikipedia.org/wiki/Norm_\(mathematics\)#Maximum_norm_\(special_case_of:_infinity_norm,_uniform_norm,_or_supremum_norm\))).

**Sintaxis**

```sql theme={null}
LinfDistance(vector1, vector2)
```

**Alias**: `distanceLinf`

**Argumentos**

* `vector1` — Primer vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)

**Valor devuelto**

Devuelve la distancia en norma infinito. Para entradas `Array`, devuelve `Float32` si el supertipo común mínimo de los tipos de los elementos es `Float32` o `BFloat16`; de lo contrario, `Float64`. Para entradas `Tuple`, siempre devuelve `Float64`. [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT LinfDistance((1, 2), (2, 3))
```

```response title=Response theme={null}
┌─LinfDistance((1, 2), (2, 3))─┐
│                            1 │
└──────────────────────────────┘
```

<div id="LinfNorm">
  ## LinfNorm
</div>

Introducido en: v21.11.0

Calcula el valor máximo absoluto de los elementos de un vector.

**Sintaxis**

```sql theme={null}
LinfNorm(vector)
```

**Alias**: `normLinf`

**Argumentos**

* `vector` — Vector o tupla de valores numéricos. [`Array(T)`](/docs/es/reference/data-types/array) o [`Tuple(T)`](/docs/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve la norma Linf, es decir, el valor absoluto máximo. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT LinfNorm((1, -2))
```

```response title=Response theme={null}
┌─LinfNorm((1, -2))─┐
│                 2 │
└───────────────────┘
```

<div id="LinfNormalize">
  ## LinfNormalize
</div>

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla son las coordenadas) en el espacio `L_{inf}` (utilizando la [norma máxima](https://en.wikipedia.org/wiki/Norm_\(mathematics\)#Maximum_norm_\(special_case_of:_infinity_norm,_uniform_norm,_or_supremum_norm\))).

**Sintaxis**

```sql theme={null}
LinfNormalize(tuple)
```

**Alias**: `normalizeLinf`

**Argumentos**

* `tuple` — Una tupla de valores numéricos. [`Tuple(T)`](/docs/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/docs/es/reference/data-types/tuple)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT LinfNormalize((3, 4))
```

```response title=Response theme={null}
┌─LinfNormalize((3, 4))─┐
│ (0.75,1)              │
└───────────────────────┘
```

<div id="LpDistance">
  ## LpDistance
</div>

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio `Lp` ([distancia según la norma p](https://en.wikipedia.org/wiki/Norm_\(mathematics\)#p-norm)).

**Sintaxis**

```sql theme={null}
LpDistance(vector1, vector2, p)
```

**Alias**: `distanceLp`

**Argumentos**

* `vector1` — Primer vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `p` — La potencia. Valores posibles: número real en `[1; inf)`. [`UInt*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float)

**Valor devuelto**

Devuelve la distancia de norma p. Para entradas `Array`, devuelve `Float32` si el supertipo común mínimo de los tipos de elemento es `Float32` o `BFloat16`; de lo contrario, `Float64`. Para entradas `Tuple`, siempre devuelve `Float64`. [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT LpDistance((1, 2), (2, 3), 3)
```

```response title=Response theme={null}
┌─LpDistance((1, 2), (2, 3), 3)─┐
│            1.2599210498948732 │
└───────────────────────────────┘
```

<div id="LpNorm">
  ## LpNorm
</div>

Introducido en: v21.11.0

Calcula la norma p de un vector, que es la raíz p-ésima de la suma de las potencias p-ésimas de los valores absolutos de cada uno de sus elementos.

Casos especiales:

* Cuando p=1, es equivalente a L1Norm (distancia de Manhattan).
* Cuando p=2, es equivalente a L2Norm (distancia euclidiana).
* Cuando p=∞, es equivalente a LinfNorm (norma máxima).

**Sintaxis**

```sql theme={null}
LpNorm(vector, p)
```

**Alias**: `normLp`

**Argumentos**

* `vector` — Vector o tupla de valores numéricos. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `p` — La potencia. Los valores posibles son números reales en el intervalo `[1; inf)`. [`UInt*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float)

**Valor devuelto**

Devuelve la [norma p](https://en.wikipedia.org/wiki/Norm_\(mathematics\)#p-norm). [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT LpNorm((1, -2), 2)
```

```response title=Response theme={null}
┌─LpNorm((1, -2), 2)─┐
│   2.23606797749979 │
└────────────────────┘
```

<div id="LpNormalize">
  ## LpNormalize
</div>

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla son las coordenadas) en el espacio `Lp` (usando la [norma p](https://en.wikipedia.org/wiki/Norm_\(mathematics\)#p-norm)).

**Sintaxis**

```sql theme={null}
LpNormalize(tuple, p)
```

**Alias**: `normalizeLp`

**Argumentos**

* `tuple` — Una tupla de valores numéricos. [`Tuple(T)`](/docs/es/reference/data-types/tuple)
* `p` — La potencia. Los valores posibles son cualquier número en el intervalo `[1; inf)`. [`UInt*`](/docs/es/reference/data-types/int-uint) o [`Float*`](/docs/es/reference/data-types/float)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/docs/es/reference/data-types/tuple)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT LpNormalize((3, 4), 5)
```

```response title=Response theme={null}
┌─LpNormalize((3, 4), 5)──────────────────┐
│ (0.7187302630182624,0.9583070173576831) │
└─────────────────────────────────────────┘
```

<div id="cosineDistance">
  ## cosineDistance
</div>

Introducido en: v21.11.0

Calcula la [distancia de coseno](https://en.wikipedia.org/wiki/Cosine_similarity#Cosine_distance) entre dos vectores (los elementos de las tuplas son las coordenadas). Cuanto menor sea el valor devuelto, más similares serán los vectores.

**Sintaxis**

```sql theme={null}
cosineDistance(vector1, vector2)
```

**Alias**: `distanceCosine`

**Argumentos**

* `vector1` — Primera tupla. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)
* `vector2` — Segunda tupla. [`Tuple(T)`](/docs/es/reference/data-types/tuple) o [`Array(T)`](/docs/es/reference/data-types/array)

**Valor devuelto**

Devuelve la distancia de coseno (uno menos la similitud coseno). Para entradas de tipo `Array`, devuelve `Float32` si el supertipo común de los tipos de elemento es `Float32` o `BFloat16`; en caso contrario, `Float64`. Para entradas de tipo `Tuple`, siempre devuelve `Float64`. [`Float*`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT cosineDistance((1, 2), (2, 3));
```

```response title=Response theme={null}
┌─cosineDistance((1, 2), (2, 3))─┐
│           0.007722123286332261 │
└────────────────────────────────┘
```

<div id="cosineDistanceTransposed">
  ## cosineDistanceTransposed
</div>

Introducido en: v26.1.0

Calcula la [distancia de coseno](https://en.wikipedia.org/wiki/Cosine_similarity#Cosine_distance) aproximada entre dos puntos (los valores de los vectores son las coordenadas). Cuanto menor sea el valor devuelto, más similares serán los vectores.

**Sintaxis**

```sql theme={null}
cosineDistanceTransposed(vector1, vector2, p[, used_dims])
```

**Alias**: `distanceCosineTransposed`

**Argumentos**

* `vectors` — Vectores. [`QBit(T, UInt64[, UInt64])`](/docs/es/reference/data-types/qbit)
* `reference` — Vector de referencia. [`Array(T)`](/docs/es/reference/data-types/array)
* `p` — Número de bits de cada elemento del vector que se usarán en el cálculo de la distancia (de 1 al ancho de bits del elemento). El nivel de cuantización controla el equilibrio entre precisión y velocidad. Usar menos bits da lugar a E/S y cálculos más rápidos, pero con menor exactitud, mientras que usar más bits aumenta la exactitud a costa del rendimiento. [`UInt`](/docs/es/reference/data-types/int-uint)
* `used_dims` — Opcional. Número de dimensiones iniciales que se leerán para una búsqueda de dimensión reducida (Matryoshka) en un `QBit` con stride. Debe ser un múltiplo del stride de QBit que no supere su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (se ignoran los elementos adicionales al final). Solo se leen los grupos de stride que cubren estas dimensiones. [`UInt`](/docs/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la distancia de coseno aproximada (uno menos la similitud coseno). Siempre devuelve Float64. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT cosineDistanceTransposed(vec, array(1, 2), 16) FROM qbit;
```

```response title=Response theme={null}
┌─cosineDistanceTransposed([0, 1], [1, 2], 16)─┐
│                          0.10557280905788935 │
└──────────────────────────────────────────────┘
```

<div id="cosineDistanceTransposedQuantized">
  ## cosineDistanceTransposedQuantized
</div>

Introducido en: v26.7.0

Calcula la [distancia de coseno](https://en.wikipedia.org/wiki/Cosine_similarity#Cosine_distance) aproximada entre un `QBit(Int8)` de códigos `quantizeBFloat16ToInt8` (descuantizados sobre la marcha) y un vector de referencia. Cuanto menor sea el valor devuelto, más similares serán los vectores. Un vector de referencia (de consulta) `Float` se compara directamente con precisión `Float32` --la precisión de reconstrucción de los códigos descuantizados--, por lo que una consulta `Float64` se reduce a `Float32`, mientras que una consulta `BFloat16` se amplía exactamente a este formato (cálculo de distancia asimétrico); una referencia `Array(Int8)` se trata, a su vez, como códigos `quantizeBFloat16ToInt8` y se descuantiza a sus niveles de reconstrucción. Tenga en cuenta que `p` trunca solo los códigos `QBit` almacenados; la referencia `Array(Int8)` es en sí misma una consulta completa y siempre se reconstruye con la precisión completa de 8 bits, por lo que esta es una distancia simétrica entre cuantizado y cuantizado solo cuando `p = 8` (para `p < 8`, solo el lado almacenado se lee con una precisión más baja). Debe estar en el mismo espacio en el que estaban los valores antes de la cuantización (es decir, después de la misma rotación aleatoria y el mismo escalado), lo cual es responsabilidad de quien realiza la llamada. La distancia de coseno es invariante a la escala; el producto escalar y la distancia L2 no lo son.

**Sintaxis**

```sql theme={null}
cosineDistanceTransposedQuantized(vectors, reference, p[, used_dims])
```

**Argumentos**

* `vectors` — Vectores de códigos `quantizeBFloat16ToInt8`. [`QBit(Int8, UInt64[, UInt64])`](/docs/es/reference/data-types/qbit)
* `reference` — Vector de referencia (consulta): un array de `Float` (la consulta, comparada con precisión `Float32` -- una consulta `Float64` se reduce a `Float32`), o un `Array(Int8)` de códigos `quantizeBFloat16ToInt8` descuantizados sobre la marcha. [`Array(Float32)`](/docs/es/reference/data-types/array) o [`Array(Int8)`](/docs/es/reference/data-types/array)
* `p` — Número de bits más altos de cada código `QBit` almacenado que se usarán (de 1 a 8). Menos bits reconstruyen un cuantizador embebido más grueso para obtener una E/S más rápida con menor exactitud; 8 bits corresponden a la reconstrucción de precisión completa. `p` trunca solo el `QBit` almacenado; una referencia `Array(Int8)` siempre se reconstruye con precisión completa de 8 bits. [`UInt`](/docs/es/reference/data-types/int-uint)
* `used_dims` — Opcional. Número de dimensiones iniciales que se leerán, para una búsqueda de dimensión reducida (Matryoshka) en un `QBit` con stride. Debe ser un múltiplo del stride de QBit que no supere su dimensión, y el vector de referencia debe tener al menos esta cantidad de elementos (cualquier elemento adicional al final se ignora). Solo se leen los grupos de stride que cubren estas dimensiones. [`UInt`](/docs/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la distancia de coseno aproximada (uno menos la similitud coseno). Siempre devuelve `Float64`. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT cosineDistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;
```

<div id="dotProductTransposed">
  ## dotProductTransposed
</div>

Introducido en: v26.7.0

Calcula el [producto escalar](https://en.wikipedia.org/wiki/Dot_product) aproximado (producto interno) de dos vectores (los valores de los vectores son las coordenadas). A diferencia de las funciones de distancia, esta es una medida de similitud: cuanto mayor sea el valor devuelto, más similares serán los vectores.

**Sintaxis**

```sql theme={null}
dotProductTransposed(vector1, vector2, p[, used_dims])
```

**Alias**: `scalarProductTransposed`

**Argumentos**

* `vectors` — Vectores. [`QBit(T, UInt64[, UInt64])`](/docs/es/reference/data-types/qbit)
* `reference` — Vector de referencia. [`Array(T)`](/docs/es/reference/data-types/array)
* `p` — Número de bits de cada elemento del vector que se usarán en el cálculo (de 1 al ancho de bits del elemento). El nivel de cuantización controla el equilibrio entre precisión y velocidad. Usar menos bits da lugar a E/S y cálculos más rápidos, pero con menor exactitud, mientras que usar más bits aumenta la exactitud a costa del rendimiento. [`UInt`](/docs/es/reference/data-types/int-uint)
* `used_dims` — Opcional. Número de dimensiones iniciales que se leerán, para una búsqueda de dimensión reducida (Matryoshka) en un `QBit` con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (se ignoran los elementos adicionales al final). Solo se leen los grupos de stride que cubren estas dimensiones. [`UInt`](/docs/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el producto escalar aproximado de los dos vectores. Siempre devuelve `Float64`. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT dotProductTransposed(vec, array(1, 2), 16) FROM qbit;
```

```response title=Response theme={null}
┌─dotProductTransposed([0, 1], [1, 2], 16)─┐
│                                   2.0625 │
└──────────────────────────────────────────┘
```

<div id="dotProductTransposedQuantized">
  ## dotProductTransposedQuantized
</div>

Introducido en: v26.7.0

Calcula el [producto escalar](https://en.wikipedia.org/wiki/Dot_product) aproximado (producto interno) entre un `QBit(Int8)` de códigos `quantizeBFloat16ToInt8` (descuantizados sobre la marcha) y un vector de referencia. Esta es una medida de similitud: cuanto mayor sea el valor devuelto, más similares serán los vectores. Un vector de referencia (consulta) `Float` se compara directamente con precisión `Float32` -- la precisión de reconstrucción de los códigos descuantizados, por lo que una consulta `Float64` se reduce a `Float32`, mientras que una consulta `BFloat16` se amplía exactamente a esa precisión (cálculo asimétrico de la distancia); una referencia `Array(Int8)` se trata como códigos `quantizeBFloat16ToInt8` y se descuantiza a sus niveles de reconstrucción. Tenga en cuenta que `p` trunca solo los códigos `QBit` almacenados; la referencia `Array(Int8)` es en sí misma una consulta completa y siempre se reconstruye con la precisión completa de 8 bits, por lo que esta es una distancia simétrica entre cuantizado y cuantizado solo cuando `p = 8` (para `p < 8`, solo el lado almacenado se lee con una precisión más baja). Debe estar en el mismo espacio en el que estaban los valores antes de la cuantización (es decir, después de la misma rotación aleatoria y el mismo escalado), lo cual es responsabilidad del llamador. La distancia de coseno es invariante a la escala; el producto escalar y la distancia L2 no lo son.

**Sintaxis**

```sql theme={null}
dotProductTransposedQuantized(vectors, reference, p[, used_dims])
```

**Argumentos**

* `vectors` — Vectores de códigos `quantizeBFloat16ToInt8`. [`QBit(Int8, UInt64[, UInt64])`](/docs/es/reference/data-types/qbit)
* `reference` — Vector de referencia (consulta): un array de `Float` (la consulta, comparada con precisión `Float32` -- una consulta `Float64` se convierte a `Float32`), o un `Array(Int8)` de códigos `quantizeBFloat16ToInt8` descuantizados sobre la marcha. [`Array(Float32)`](/docs/es/reference/data-types/array) o [`Array(Int8)`](/docs/es/reference/data-types/array)
* `p` — Número de bits superiores de cada código `QBit` almacenado que se usarán (de 1 a 8). Menos bits reconstruyen un cuantizador embebido más grueso para una E/S más rápida con menor exactitud; 8 bits es la reconstrucción de precisión completa. `p` trunca solo el `QBit` almacenado; una referencia `Array(Int8)` siempre se reconstruye con precisión completa de 8 bits. [`UInt`](/docs/es/reference/data-types/int-uint)
* `used_dims` — Opcional. Número de dimensiones iniciales que se leerán, para una búsqueda de dimensión reducida (Matryoshka) en un `QBit` con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (se ignoran los elementos adicionales al final). Solo se leen los grupos de stride que cubren estas dimensiones. [`UInt`](/docs/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el producto escalar aproximado de los dos vectores. Siempre devuelve Float64. [`Float64`](/docs/es/reference/data-types/float)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT dotProductTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;
```