> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(T)`](/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*`](/es/reference/data-types/int-uint) o [`Float*`](/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)`](/es/reference/data-types/array) o [`Tuple(T)`](/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*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/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)`](/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(T)`](/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*`](/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)
```

**Alias**: `distanceL2Transposed`

**Argumentos**

* `vectors` — Vectores. [`QBit(T, UInt64)`](/es/reference/data-types/qbit)
* `reference` — Vector de referencia. [`Array(T)`](/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 precisión, mientras que usar más bits aumenta la precisión a costa del rendimiento. [`UInt`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la distancia aproximada de la norma 2. Siempre devuelve `Float64`. [`Float64`](/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.4142135623730951 │
└──────────────────────────────────────────┘
```

<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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)

**Valor devuelto**

Devuelve la norma L2 o la [distancia euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance). [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/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)`](/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(T)`](/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*`](/es/reference/data-types/int-uint) o [`Float*`](/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)`](/es/reference/data-types/array) o [`Tuple(T)`](/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve la norma L2 al cuadrado. [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(T)`](/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*`](/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)`](/es/reference/data-types/array) o [`Tuple(T)`](/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve la norma Linf, es decir, el valor absoluto máximo. [`Float64`](/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)`](/es/reference/data-types/tuple)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `vector2` — Segundo vector. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `p` — La potencia. Valores posibles: número real en `[1; inf)`. [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/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*`](/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `p` — La potencia. Los valores posibles son números reales en el intervalo `[1; inf)`. [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve la [norma p](https://en.wikipedia.org/wiki/Norm_\(mathematics\)#p-norm). [`Float64`](/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)`](/es/reference/data-types/tuple)
* `p` — La potencia. Los valores posibles son cualquier número en el intervalo `[1; inf)`. [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el vector unitario. [`Tuple(Float64)`](/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)`](/es/reference/data-types/tuple) o [`Array(T)`](/es/reference/data-types/array)
* `vector2` — Segunda tupla. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(T)`](/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*`](/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)
```

**Alias**: `distanceCosineTransposed`

**Argumentos**

* `vectors` — Vectores. [`QBit(T, UInt64)`](/es/reference/data-types/qbit)
* `reference` — Vector de referencia. [`Array(T)`](/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`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la distancia de coseno aproximada (uno menos la similitud del coseno). Siempre devuelve Float64. [`Float64`](/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.10557281085638826 │
└──────────────────────────────────────────────┘
```