# Tipos temporales: Operaciones de análisis

## Simplificación

- Simplificar un flotante o un punto temporal asegurándose de que los valores consecutivos estén al menos separados por una cierta distancia o intervalo de tiempo &Z_support; &geography_support;

  `minDistSimplify({tfloat,tpoint},mindist float) → {tfloat,tpoint}`

  `minTimeDeltaSimplify({tfloat,tpoint},mint interval) → {tfloat,tpoint}`

  En el caso de puntos temporales la distancia se especifica en las unidades del sistema de coordenadas. Observe que la simplificación se aplica sólo a secuencias temporales o conjuntos de secuencias con interpolación lineal. En todos los demás casos, se devuelve una copia del punto temporal dado.

      SELECT minDistSimplify(tfloat '[1@2001-01-01,2@2001-01-02,3@2001-01-04,4@2001-01-05]', 1);
      -- [1@2001-01-01, 3@2001-01-04, 4@2001-01-05]
      SELECT asText(minDistSimplify(tgeompoint '[Point(1 1 1)@2001-01-01,
        Point(2 2 2)@2001-01-02, Point(3 3 3)@2001-01-04, Point(5 5 5)@2001-01-05)', sqrt(3)));
      -- [POINT Z (1 1 1)@2001-01-01, POINT Z (3 3 3)@2001-01-04, POINT Z (5 5 5)@2001-01-05)
      SELECT asText(minDistSimplify(tgeompoint '[Point(1 1 1)@2001-01-01,
        Point(2 2 2)@2001-01-02, Point(3 3 3)@2001-01-04, Point(4 4 4)@2001-01-05)', sqrt(3)));
      -- [POINT Z (1 1 1)@2001-01-01, POINT Z (3 3 3)@2001-01-04, POINT Z (4 4 4)@2001-01-05]

      SELECT minTimeDeltaSimplify(tfloat '[1@2001-01-01, 2@2001-01-02, 3@2001-01-04,
        4@2001-01-05]', '1 day');
      -- [1@2001-01-01, 3@2001-01-04, 4@2001-01-05]
      SELECT asText(minTimeDeltaSimplify(tgeogpoint '[Point(1 1 1)@2001-01-01,
        Point(2 2 2)@2001-01-02, Point(3 3 3)@2001-01-04, Point(5 5 5)@2001-01-05)', '1 day'));
      -- [POINT Z (1 1 1)@2001-01-01, POINT Z (3 3 3)@2001-01-04, POINT Z (5 5 5)@2001-01-05]

- Simplificar un flotante o un punto temporal usando el algoritmo de Douglas-Peucker &Z_support;

  `maxDistSimplify({tfloat,tgeompoint},maxdist float,syncdist=true) →`

  `{tfloat,tgeompoint}`

  `douglasPeuckerSimplify({tfloat,tgeompoint},maxdist float,syncdist=true) →`

  `{tfloat,tgeompoint}`

  La diferencia entre las dos funciones es que `maxDistSimplify` usa una versión del algoritmo de un solo recorrido, mientras que `douglasPeuckerSimplify` usa el algoritmo recursivo estándar.

  La función elimina los valores or los puntos cuya distancia es menor que la distancia pasada como segundo argumento. En el caso de puntos temporales la distancia se especifica en las unidades del sistema de coordenadas. El tercer argumento se aplica solo a puntos temporales y especifica si se utiliza la distancia espacial o la distancia sincronizada. Observe que la simplificación se aplica sólo a secuencias temporales o conjuntos de secuencias con interpolación lineal. En todos los demás casos, se devuelve una copia del punto temporal dado.

      -- Only synchronous distance for temporal floats
      SELECT maxDistSimplify(tfloat '[1@2001-01-01, 2@2001-01-02, 1@2001-01-03, 3@2001-01-04,
        1@2001-01-05]', 1, false);
      -- [1@2001-01-01, 1@2001-01-03, 3@2001-01-04, 1@2001-01-05]
      -- Synchronous distance by default for temporal points
      SELECT asText(maxDistSimplify(tgeompoint '[Point(1 1)@2001-01-01, Point(2 2)@2001-01-02,
        Point(3 1)@2001-01-03, Point(3 3)@2001-01-05, Point(5 1)@2001-01-06]', 2));
      -- [POINT(1 1)@2001-01-01, POINT(3 3)@2001-01-05, POINT(5 1)@2001-01-06]
      -- Spatial distance
      SELECT asText(maxDistSimplify(tgeompoint '[Point(1 1)@2001-01-01, Point(2 2)@2001-01-02,
        Point(3 1)@2001-01-03, Point(3 3)@2001-01-05, Point(5 1)@2001-01-06]', 2, false));
      -- [POINT(1 1)@2001-01-01, POINT(5 1)@2001-01-06]

      -- Spatial vs synchronized Euclidean distance
      SELECT asText(douglasPeuckerSimplify(tgeompoint '[Point(1 1)@2001-01-01,
        Point(6 1)@2001-01-06, Point(7 4)@2001-01-07]', 2.3, false));
      -- [POINT(1 1)@2001-01-01, POINT(7 4)@2001-01-07]
      SELECT asText(douglasPeuckerSimplify(tgeompoint '[Point(1 1)@2001-01-01,
        Point(6 1)@2001-01-06, Point(7 4)@2001-01-07]', 2.3, true));
      -- [POINT(1 1)@2001-01-01, POINT(6 1)@2001-01-06, POINT(7 4)@2001-01-07]

  La diferencia entre la distancia espacial y la distancia sincronizada se ilustra en los dos últimos ejemplos anteriores y en la dist_vs_sed. En el primer ejemplo, que usa la distancia espacial, se elimina el segundo instante ya que la distancia perperdicular entre `POINT(2 2)` y la línea definida por `POINT(1 1)` y `POINT(7 4)` es igual a 2.23. Por el contrario, en el segundo ejemplo se mantiene el segundo instante dado que la proyección de `Point(6 2)` en la marca de tiempo `2001-01-06` sobre el segmento de línea temporal da como resultado `Point(6 3.5)` y la distancia entre el punto original y su proyección es 2.5.

  ### Diferencia entre la distancia espacial y la distancia sincronizada.

  Un uso típico de la función `douglasPeuckerSimplify` es reducir el tamaño de un conjunto de datos, en particular con fines de visualización. Si la visualización es estática, se debe preferir la distancia espacial; si la visualización es dinámica o animada, se debe preferir la distancia sincronizada.

## Reducción

- Muestrear un valor temporal con respecto a un intervalo

  `tsample(temporal,duration interval,torigin timestamptz='2000-01-03',`

  `interp='discrete') → temporal`

  Si el origen no se especifica, su valor se establece por defecto en lunes 3 de enero de 2000. El intervalo dado debe ser estrictamente mayor que cero.

      SELECT tsample(tbool '[true@2001-01-01,false@2001-01-02]', '12 hours', '2001-01-01', 'step');
      -- [t@2001-01-01, f@2001-01-02]
      SELECT tsample(tint '{1@2001-01-01,5@2001-01-05}', '3 days', '2001-01-01');
      -- {1@2001-01-01}
      SELECT tsample(tfloat '[1@2001-01-01,5@2001-01-05]', '1 day', '2001-01-01');
      -- {1@2001-01-01, 2@2001-01-02, 3@2001-01-03, 4@2001-01-04, 5@2001-01-05}
      SELECT tsample(tfloat '[1@2001-01-01,5@2001-01-05]', '3 days', '2001-01-01');
      -- {1@2001-01-01, 4@2001-01-04}
      SELECT tsample(tfloat '[1@2001-01-01,5@2001-01-05]', '3 days', '2001-01-01', 'linear');
      -- [1@2001-01-01, 4@2001-01-04]

      SELECT asText(tsample(tgeompoint '[Point(1 1)@2001-01-01, Point(5 5)@2001-01-05]',
        '2 days', '2001-01-01'));
      -- {POINT(1 1)@2001-01-01, POINT(3 3)@2001-01-03, POINT(5 5)@2001-01-05}
      SELECT asText(tsample(tgeompoint '{[Point(1 1)@2001-01-01, Point(5 5)@2001-01-05],
        [Point(1 1)@2001-01-06, Point(5 5)@2001-01-08]}', '3 days', '2001-01-01'));
      -- {POINT(1 1)@2001-01-01, POINT(4 4)@2001-01-04, POINT(3 3)@2001-01-07}
      SELECT asText(tsample(tgeompoint '{[Point(1 1)@2001-01-01, Point(5 5)@2001-01-05],
        [Point(1 1)@2001-01-06, Point(5 5)@2001-01-08]}', '3 days', '2001-01-01', 'step'));
      -- Interp=Step;[POINT(1 1)@2001-01-01, POINT(4 4)@2001-01-04, POINT(3 3)@2001-01-07]

  La fig_tsample ilustra el muestreo para números flotantes temporales con varias interpolaciones. Como ilustra la figura, la operación de muestreo es más adecuada para valores temporales con interpolación continua.

  ### Muestreo de flotantes temporales con interpolación discreta, escalonada y lineal.

- Reducir la precisión temporal de un valor temporal con respecto a un intervalo calculando el promedio/centroide ponderado por el tiempo en cada intervalo de tiempo

  `tprecision({tnumber,tgeompoint},duration interval,torigin timestamptz='2000-01-03')`

  `→ {tnumber,tgeompoint}`

  Si el origen no se especifica, su valor se establece por defecto en lunes 3 de enero de 2000. El intervalo dado debe ser estrictamente mayor que cero.

      SELECT tprecision(tint '[1@2001-01-01,5@2001-01-05,1@2001-01-09]','1 day',
        '2001-01-01');
      -- Interp=Step;[1@2001-01-01, 5@2001-01-05, 1@2001-01-09]
      SELECT tprecision(tfloat '[1@2001-01-01,5@2001-01-05,1@2001-01-09)','1 day',
        '2001-01-01');
      -- [1.5@2001-01-01, 4.5@2001-01-04, 4.5@2001-01-05, 1.5@2001-01-08]
      SELECT tprecision(tfloat '[1@2001-01-01,5@2001-01-05,1@2001-01-09]','1 day',
        '2001-01-01');
      -- [1.5@2001-01-01, 4.5@2001-01-04, 4.5@2001-01-05, 1.5@2001-01-08, 1@2001-01-09]
      SELECT tprecision(tfloat '[1@2001-01-01,5@2001-01-05,1@2001-01-09)','2 days',
        '2001-01-01');
      -- [2@2001-01-01, 4@2001-01-03, 4@2001-01-05, 2@2001-01-07]

      SELECT asText(tprecision(tgeompoint '[Point(1 1)@2001-01-01, Point(5 5)@2001-01-05,
        Point(1 1)@2001-01-09)', '1 day', '2001-01-01'));
      /* [POINT(1.5 1.5)@2001-01-01, POINT(4.5 4.5)@2001-01-04, POINT(4.5 4.5)@2001-01-05,
         POINT(1.5 1.5)@2001-01-08] */
      SELECT asText(tprecision(tgeompoint '[Point(1 1)@2001-01-01, Point(5 5)@2001-01-05,
        Point(1 1)@2001-01-09)', '2 days', '2001-01-01'));
      /* [POINT(2 2)@2001-01-01, POINT(4 4)@2001-01-03, POINT(4 4)@2001-01-05,
         POINT(2 2)@2001-01-07] */
      SELECT asText(tprecision(tgeompoint '[Point(1 1)@2001-01-01, Point(5 5)@2001-01-05,
        Point(1 1)@2001-01-09)', '4 days', '2001-01-01'));
      -- [POINT(3 3)@2001-01-01, POINT(3 3)@2001-01-05]

  Cambiar la precisión de un valor temporal es similar a cambiar su granularidad temporal, por ejemplo, de marcas de tiempo a horas o días, aunque la precisión se puede establecer en un intervalo arbitrario, como 2 horas y 15 minutos. La fig_tprecision ilustra un cambio de precisión temporal para números flotantes temporales con varias interpolaciones.

  ### Cambio de precisión de números flotantes temporales con interpolación discreta, escalonada y lineal.

## Similaridad

- Devuelve la distancia de Hausdorff discreta, la distancia de Fréchet discreta, o la distancia de distorsión de tiempo dinámica (Dynamic Time Warp o DTW) entre dos valores temporales &Z_support; &geography_support;

  `hausdorffDistance({tnumber, tgeo}, {tnumber, tgeo}) → float`

  `frechetDistance({tnumber, tgeo}, {tnumber, tgeo}) → float`

  `dynTimeWarpDistance({tnumber, tgeo}, {tnumber, tgeo}) → float`

  Estas funciones tienen una complejidad de espacio lineal ya que solo dos filas de la matriz de distancia son asignadas en la memoria. Sin embargo, su complejidad de tiempo es cuadrática en el número de instantes de los valores temporales. Por lo tanto, las funciones requerien un tiempo considerable para valores temporales con gran número de instantes.

      SELECT hausdorffDistance(tfloat '[1@2001-01-01, 3@2001-01-03, 1@2001-01-06]',
       tfloat '[1@2001-01-01, 1.5@2001-01-02, 2.5@2001-01-03, 1.5@2001-01-04, 1.5@2001-01-05]');
      -- 0.5
      SELECT round(hausdorffDistance(tgeompoint '[Point(1 1)@2001-01-01, Point(3 3)@2001-01-03,
        Point(1 1)@2001-01-05]', tgeompoint '[Point(1.1 1.1)@2001-01-01,
        Point(2.5 2.5)@2001-01-02, Point(4 4)@2001-01-03, Point(3 3)@2001-01-04,
        Point(1.5 2)@2001-01-05]')::numeric, 6);
      -- 1.414214

      SELECT frechetDistance(tfloat '[1@2001-01-01, 3@2001-01-03, 1@2001-01-06]',
       tfloat '[1@2001-01-01, 1.5@2001-01-02, 2.5@2001-01-03, 1.5@2001-01-04, 1.5@2001-01-05]');
      -- 0.5
      SELECT round(frechetDistance(tgeompoint '[Point(1 1)@2001-01-01, Point(3 3)@2001-01-03,
        Point(1 1)@2001-01-05]', tgeompoint '[Point(1.1 1.1)@2001-01-01,
        Point(2.5 2.5)@2001-01-02, Point(4 4)@2001-01-03, Point(3 3)@2001-01-04,
        Point(1.5 2)@2001-01-05]')::numeric, 6);
      -- 1.414214

      SELECT dynTimeWarpDistance(tfloat '[1@2001-01-01, 3@2001-01-03, 1@2001-01-06]',
       tfloat '[1@2001-01-01, 1.5@2001-01-02, 2.5@2001-01-03, 1.5@2001-01-04, 1.5@2001-01-05]');
      -- 2
      SELECT round(dynTimeWarpDistance(tgeompoint '[Point(1 1)@2001-01-01,
        Point(3 3)@2001-01-03, Point(1 1)@2001-01-05]',
        tgeompoint '[Point(1.1 1.1)@2001-01-01, Point(2.5 2.5)@2001-01-02,
        Point(4 4)@2001-01-03, Point(3 3)@2001-01-04, Point(1.5 2)@2001-01-05]')::numeric, 6);
      -- 3.380776

- Devuelve las parejas de correspondencia entre dos valores temporales con respecto a la distancia de Fréchet discreta o la distance de distorsión de tiempo dinámica (Dynamic Time Warp o DTW) &Z_support; &geography_support; &SRF;

  `frechetDistancePath({tnumber, tgeo}, {tnumber, tgeo}) → {(i,j)}`

  `dynTimeWarpPath({tnumber, tgeo}, {tnumber, tgeo}) → {(i,j)}`

  El resultado es un conjunto de pares `(i,j)`. Esta función requiere ubicar en memoria una matriz de distancias cuyo tamaño es cuadrático en el número de instantes de los valores temporales. Por tanto, la función fallará para valores temporales con gran número de instantes dependiendo de la memoria disponible.

      SELECT frechetDistancePath(tfloat '[1@2001-01-01, 3@2001-01-03, 1@2001-01-06]',
       tfloat '[1@2001-01-01, 1.5@2001-01-02, 2.5@2001-01-03, 1.5@2001-01-04, 1.5@2001-01-05]');
      -- (0,0)
      -- (1,0)
      -- (2,1)
      -- (3,2)
      -- (4,2)
      SELECT frechetDistancePath(tgeompoint '[Point(1 1)@2001-01-01, Point(3 3)@2001-01-03,
        Point(1 1)@2001-01-05]', tgeompoint '[Point(1.1 1.1)@2001-01-01,
        Point(2.5 2.5)@2001-01-02, Point(4 4)@2001-01-03, Point(3 3)@2001-01-04,
        Point(1.5 2)@2001-01-05]');
      -- (0,0)
      -- (1,1)
      -- (2,1)
      -- (3,1)
      -- (4,2)

      SELECT dynTimeWarpPath(tfloat '[1@2001-01-01, 3@2001-01-03, 1@2001-01-06]',
       tfloat '[1@2001-01-01, 1.5@2001-01-02, 2.5@2001-01-03, 1.5@2001-01-04, 1.5@2001-01-05]');
      -- (0,0)
      -- (1,0)
      -- (2,1)
      -- (3,2)
      -- (4,2)
      SELECT dynTimeWarpPath(tgeompoint '[Point(1 1)@2001-01-01, Point(3 3)@2001-01-03,
        Point(1 1)@2001-01-05]', tgeompoint '[Point(1.1 1.1)@2001-01-01,
        Point(2.5 2.5)@2001-01-02, Point(4 4)@2001-01-03, Point(3 3)@2001-01-04,
        Point(1.5 2)@2001-01-05]');
      -- (0,0)
      -- (1,1)
      -- (2,1)
      -- (3,1)
      -- (4,2)

## Operaciones de división

Al crear índices para tipos temporales, lo que se almacena en el índice no es el valor real sino un cuadro delimitador que representa el valor. En este caso, el índice proporcionará una lista de valores candidatos que pueden satisfacer el predicado de la consulta, y se necesita un segundo paso para filtrar los valores candidatos calculando el predicado de la consulta sobre los valores reales.

Sin embargo, cuando los cuadros delimitadores tienen un gran espacio vacío no cubierto por los valores reales, el índice generará muchos valores candidatos que no satisfacen el predicado de la consulta, lo que reduce la eficiencia del índice. En estas situaciones, puede ser mejor representar un valor no con un cuadro delimitador único, sino con múltiples cuadros delimitadores. Esto aumenta considerablemente la eficiencia del índice, siempre que el índice sea capaz de gestionar múltiples cuadros delimitadores por valor. Las siguientes funciones se utilizan para generar múltiples cuadros delimitadores para un único valor temporal.

- Devuelve una matriz de N rangos de tiempo a partir de los instantes o segmentos de un valor temporal &Z_support; &geography_support;

  `splitNSpans(temp, integer) → tstzspan[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta o continua. El último argumento especifica el número de rangos de salida. Si el número de instantes o segmentos es inferior o igual al número especificado, la matriz resultante tendrá un rango por instante o segmento del valor temporal. En caso contrario, el número de rangos especificado se obtendrá fusionando instantes o segmentos consecutivos.

      SELECT splitNSpans(ttext '{A@2000-01-01, B@2000-01-02, A@2000-01-03, B@2000-01-04,
        A@2000-01-05}', 1);
      -- {"[2000-01-01, 2000-01-05]"}
      SELECT splitNSpans(tfloat '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 2@2000-01-04,
        1@2000-01-05}', 2);
      -- {"[2000-01-01, 2000-01-03]","[2000-01-04, 2000-01-05]"}
      SELECT splitNSpans(tgeompoint '[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(1 1)@2000-01-03, Point(2 2)@2000-01-04, Point(1 1)@2000-01-05]', 2);
      -- {"[2000-01-01, 2000-01-03]","[2000-01-03, 2000-01-05]"}
      SELECT splitNSpans(tgeogpoint '{[Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02],
        [Point(1 1 1)@2000-01-03, Point(2 2 2)@2000-01-04], [Point(1 1 1)@2000-01-05]}', 2);
      -- {"[2000-01-01, 2000-01-04])","[2000-01-05, 2000-01-05])"}
      SELECT splitNSpans(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 2@2000-01-04,
        2@2000-01-05}', 6);
      /* {"[2000-01-01, 2000-01-01]","[2000-01-02, 2000-01-02]","[2000-01-03, 2000-01-03]",
          "[2000-01-04, 2000-01-04]","[2000-01-05, 2000-01-05]"} */
      SELECT splitNSpans(ttext '[A@2000-01-01, B@2000-01-02, A@2000-01-03, B@2000-01-04,
        A@2000-01-05]', 6);
      /* {"[2000-01-01, 2000-01-02]","[2000-01-02, 2000-01-03]",
          "[2000-01-03, 2000-01-04]","[2000-01-04, 2000-01-05]"} */

- Devuelve una matriz de rangos de tiempo obtenida fusionando N instantes o segmentos consecutivos de un valor temporal &Z_support; &geography_support;

  `splitEachNSpans(temp, integer) → tstzspan[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta o continua. El último argumento especifica el número de instantes o segmentos de entrada que se fusionan para producir un rango de salida. Si el número de instantes o segmentos es inferior o igual al número especificado, la matriz resultante tendrá un único rango por secuencia. En caso contrario, el número especificado de instantes o segmentos consecutivos será fusionado en cada rango de salida. Observe que, a diferencia de la función `splitNSpans`, el número de cuadros en el resultado depende del número de instantes o de segmentos de entrada.

      SELECT splitEachNSpans(ttext '{A@2000-01-01, B@2000-01-02, A@2000-01-03, B@2000-01-04,
        A@2000-01-05}', 1);
      /* {"[2000-01-01, 2000-01-01]","[2000-01-02, 2000-01-02]","[2000-01-03, 2000-01-03]",
           "[2000-01-04, 2000-01-04]","[2000-01-05, 2000-01-05]} */
      SELECT splitEachNSpans(tfloat '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 2@2000-01-04,
        1@2000-01-05]', 2);
      --  {"[2000-01-01, 2000-01-03]","[2000-01-03, 2000-01-05]"}
      SELECT splitEachNSpans(tgeompoint '{[Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02],
        [Point(1 1 1)@2000-01-03, Point(2 2 2)@2000-01-04], [Point(1 1 1)@2000-01-05]}', 2);
      --  {"[2000-01-01, 2000-01-02]","[2000-01-03, 2000-01-04]","[2000-01-05, 2000-01-05]"}
      SELECT splitEachNSpans(tgeogpoint '[Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02,
        Point(1 1 1)@2000-01-03, Point(2 2 2)@2000-01-04, Point(1 1 1)@2000-01-05]', 6);
      -- {"[2000-01-01, 2000-01-05])"}
      SELECT splitEachNSpans(tgeogpoint '{[Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02],
        [Point(1 1 1)@2000-01-03, Point(2 2 2)@2000-01-04], [Point(1 1 1)@2000-01-05]}', 6);
      -- {"[2000-01-01, 2000-01-02]","[2000-01-03, 2000-01-04]","[2000-01-05, 2000-01-05]"}

- Devuelve una matriz de N cuadros temporales obtenida fusionando los instantes o segmentos de un número temporal

  `splitNTboxes(tnumber, integer) → tbox[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta or continua. El último argumento especifica el número de cuadros de salida. Si el número de instantes o segmentos es inferior o igual al numéro especificado, la matriz resultante tendrá un cuadro por instante o segmento del número temporal. En caso contrario, En caso contrario, el número de cuadros especificado se obtendrá fusionando instantes o segmentos consecutivos.

      SELECT splitNTboxes(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05}', 1);
      -- {"TBOXINT XT([1, 5),[2000-01-01, 2000-01-05])"}
      SELECT splitNTboxes(tfloat '{[1@2000-01-01, 2@2000-01-02], [1@2000-01-03, 4@2000-01-04],
        [1@2000-01-05]}', 2);
      /* {"TBOXFLOAT XT([1, 4],[2000-01-01, 2000-01-04])",
          "TBOXFLOAT XT([1, 1],[2000-01-05, 2000-01-05])"} */
      SELECT splitNTboxes(tfloat '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', 3);
      /* {"TBOXFLOAT XT([1, 2],[2000-01-01, 2000-01-03])",
          "TBOXFLOAT XT([1, 4],[2000-01-03, 2000-01-04])",
          "TBOXFLOAT XT([1, 4],[2000-01-04, 2000-01-05])"} */
      SELECT splitNTboxes(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05}', 6);
      /* {"TBOXINT XT([1, 2),[2000-01-01, 2000-01-01])",
          "TBOXINT XT([2, 3),[2000-01-02, 2000-01-02])",
          "TBOXINT XT([1, 2),[2000-01-03, 2000-01-03])",
          "TBOXINT XT([4, 5),[2000-01-04, 2000-01-04])",
          "TBOXINT XT([1, 2),[2000-01-05, 2000-01-05])"} */
      SELECT splitNTboxes(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', 6);
      /* {"TBOXINT XT([1, 3),[2000-01-01, 2000-01-02])",
          "TBOXINT XT([1, 3),[2000-01-02, 2000-01-03])",
          "TBOXINT XT([1, 5),[2000-01-03, 2000-01-04])",
          "TBOXINT XT([1, 5),[2000-01-04, 2000-01-05])"} */

- Devuelve una matriz de cuadros temporales obtenida fusionando N instantes o segmentos consecutivos de un número temporal

  `splitEachNTboxes(tnumber, integer) → tbox[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta or continua. El último argumento especifica el número de instantes o segmentos de entrada que se fusionan para producir un cuadro de salida. Si el número de instantes o segmentos es inferior o igual al número especificado, la matriz resultante tendrá un único cuadro por secuencia. En caso contrario, el número especificado de instantes o segmentos consecutivos será fusionado en cada cuadro de salida. Observe que, a diferencia de la función `splitNTboxes`, el número de cuadros en el resultado depende del número de instantes o de segmentos de entrada.

      SELECT splitEachNTboxes(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05}', 1);
      /* {"TBOXINT XT([1, 2),[2000-01-01, 2000-01-01])",
          "TBOXINT XT([2, 3),[2000-01-02, 2000-01-02])",
          "TBOXINT XT([1, 2),[2000-01-03, 2000-01-03])",
          "TBOXINT XT([4, 5),[2000-01-04, 2000-01-04])"} */
      SELECT splitEachNTboxes(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', 1);
      /* {"TBOXINT XT([1, 3),[2000-01-01, 2000-01-02])",
          "TBOXINT XT([1, 3),[2000-01-02, 2000-01-03])",
          "TBOXINT XT([1, 5),[2000-01-03, 2000-01-04])",
          "TBOXINT XT([1, 5),[2000-01-04, 2000-01-05])"} */
      SELECT splitEachNTboxes(tfloat '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', 3);
      /* {"TBOXFLOAT XT([1, 4],[2000-01-01, 2000-01-04])",
          "TBOXFLOAT XT([1, 4],[2000-01-04, 2000-01-05])"} */
      SELECT splitEachNTboxes(tfloat '{[1@2000-01-01, 2@2000-01-02], [1@2000-01-03, 4@2000-01-04],
        [1@2000-01-05]}', 6);
      /* {"TBOXFLOAT XT([1, 2],[2000-01-01, 2000-01-02])",
          "TBOXFLOAT XT([1, 4],[2000-01-03, 2000-01-04])",
          "TBOXFLOAT XT([1, 1],[2000-01-05, 2000-01-05])"} */

- Devuelve ya sea una matriz de N cuadros espaciales obtenida fusionando los segmentos de una (multi)línea o una matriz de N cuadros espaciotemporales obtenida fusionando los instantes o segmentos de un punto temporal &Z_support; &geography_support;

  `splitNStboxes(lines, integer) → stbox[]`

  `splitNStboxes(tpoint, integer) → stbox[]`

  Para puntos temporales, la elección entre instantes o segmentos depende de si la interpolación es discreta or continua. El último argumento especifica el número de cuadros de salida. Si el número de instantes o segmentos es menor que el número dado, la matriz resultante tendrá un cuadro por segmento de la (multi)línea o un cuadro por instante o segmento del punto temporal. En caso contrario, el número de cuadros especificado se obtendrá fusionando instantes o segmentos consecutivos.

      SELECT splitNStboxes(geometry 'Linestring(1 1,2 2,3 1,4 2,5 1)', 1);
      -- {"STBOX X((1,1),(5,2))"}
      SELECT splitNStboxes(geometry 'Linestring(1 1,2 2,3 1,4 2,5 1)', 2);
      -- {"STBOX X((1,1),(3,2))","STBOX X((3,1),(5,2))"}
      SELECT splitNStboxes(geography 'Linestring(1 1 1,2 2 1,3 1 1,4 2 1,5 1 1)', 6);
      /* {"SRID=4326;GEODSTBOX Z((1,1,1),(2,2,1))",
          "SRID=4326;GEODSTBOX Z((2,1,1),(3,2,1))",
          "SRID=4326;GEODSTBOX Z((3,1,1),(4,2,1))",
          "SRID=4326;GEODSTBOX Z((4,1,1),(5,2,1))"} */
      SELECT splitNStboxes(geometry 'MultiLinestring((1 1,2 2),(3 1,4 2),(5 1,6 2))', 2);
      -- {"STBOX X((1,1),(4,2))","STBOX X((5,1),(6,2))"}

      SELECT splitNStboxes(tgeompoint '{Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(3 1)@2000-01-03, Point(4 2)@2000-01-04, Point(5 1)@2000-01-05}', 1);
      -- {"STBOX XT(((1,1),(5,2)),[2000-01-01, 2000-01-05])"}
      SELECT splitNStboxes(tgeompoint '[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(3 1)@2000-01-03, Point(4 2)@2000-01-04, Point(5 1)@2000-01-05]');
      /* {"STBOX XT(((1,1),(2,2)),[2000-01-01, 2000-01-02])",
          "STBOX XT(((2,1),(3,2)),[2000-01-02, 2000-01-03])",
          "STBOX XT(((3,1),(4,2)),[2000-01-03, 2000-01-04])",
          "STBOX XT(((4,1),(5,2)),[2000-01-04, 2000-01-05])"} */
      SELECT splitNStboxes(tgeompoint '{[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02],
        [Point(3 1)@2000-01-03, Point(4 2)@2000-01-04], [Point(5 1)@2000-01-05]}', 2);
      /* {"STBOX XT(((1,1),(4,2)),[2000-01-01, 2000-01-04])",
          "STBOX XT(((5,1),(5,1)),[2000-01-05, 2000-01-05])"} */
      SELECT splitNStboxes(tgeogpoint '{Point(1 1 1)@2000-01-01, Point(2 2 1)@2000-01-02,
        Point(3 1 1)@2000-01-03, Point(4 2 1)@2000-01-04, Point(5 1 1)@2000-01-05}', 6);
      /* {"SRID=4326;GEODSTBOX ZT(((1,1,1),(1,1,1)),[2000-01-01, 2000-01-01])",
          "SRID=4326;GEODSTBOX ZT(((2,2,1),(2,2,1)),[2000-01-02, 2000-01-02])",
          "SRID=4326;GEODSTBOX ZT(((3,1,1),(3,1,1)),[2000-01-03, 2000-01-03])",
          "SRID=4326;GEODSTBOX ZT(((4,2,1),(4,2,1)),[2000-01-04, 2000-01-04])",
          "SRID=4326;GEODSTBOX ZT(((5,1,1),(5,1,1)),[2000-01-05, 2000-01-05])"} */
      SELECT splitNStboxes(tgeompoint '[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(3 1)@2000-01-03, Point(4 2)@2000-01-04, Point(5 1)@2000-01-05]', 6);
      /* {"STBOX XT(((1,1),(2,2)),[2000-01-01, 2000-01-02])",
          "STBOX XT(((2,1),(3,2)),[2000-01-02, 2000-01-03])",
          "STBOX XT(((3,1),(4,2)),[2000-01-03, 2000-01-04])",
          "STBOX XT(((4,1),(5,2)),[2000-01-04, 2000-01-05])"} */

- Devuelve ya sea una matriz de cuadros espaciales obtenida fusionando N segmentos consecutivos de una (multi)línea o una matriz de cuadros espaciotemporales obtenida fusionando N instantes o segmentos consecutivos de un punto temporal &Z_support; &geography_support;

  `splitEachNStboxes(lines, integer) → stbox[]`

  `splitEachNStboxes(tpoint, integer) → stbox[]`

  Para puntos temporales, la elección entre instantes o segmentos depende de si la interpolación es discreta or continua. El último argumento especifica el número de instantes o segmentos de entrada que se fusionan para producir un cuadro de salida. Si el número de instantes o segmentos es menor que el número dado, la matriz resultante tendrá un único cuadro por secuencia. En caso contrario, el número especificado de instantes o segmentos consecutivos será fusionado en cada cuadro de salida. Observe que, a diferencia de la función `splitNStboxes`, el número de cuadros en el resultado depende del número de instantes o de segmentos de entrada.

      SELECT splitEachNStboxes(geometry 'Linestring(1 1,2 2,3 1,4 2,5 1)', 1);
      -- {"STBOX X((1,1),(5,2))"}
      SELECT splitEachNStboxes(geometry 'Linestring(1 1,2 2,3 1,4 2,5 1)', 2);
      -- {"STBOX X((1,1),(3,2))","STBOX X((3,1),(5,2))"}
      SELECT splitEachNStboxes(geography 'Linestring(1 1 1,2 2 1,3 1 1,4 2 1,5 1 1)', 6);
      /* {"SRID=4326;GEODSTBOX Z((1,1,1),(2,2,1))",
          "SRID=4326;GEODSTBOX Z((2,1,1),(3,2,1))",
          "SRID=4326;GEODSTBOX Z((3,1,1),(4,2,1))",
          "SRID=4326;GEODSTBOX Z((4,1,1),(5,2,1))"} */
      SELECT splitEachNStboxes(geometry 'MultiLinestring((1 1,2 2),(3 1,4 2),(5 1,6 2))', 2);
      -- {"STBOX X((1,1),(4,2))","STBOX X((5,1),(6,2))"}

      SELECT splitEachNStboxes(tgeompoint '{Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(3 1)@2000-01-03, Point(4 2)@2000-01-04, Point(5 1)@2000-01-05}', 1);
      /* {"STBOX XT(((1,1),(1,1)),[2000-01-01, 2000-01-01])",
          "STBOX XT(((2,2),(2,2)),[2000-01-02, 2000-01-02])",
          "STBOX XT(((3,1),(3,1)),[2000-01-03, 2000-01-03])",
          "STBOX XT(((4,2),(4,2)),[2000-01-04, 2000-01-04])",
          "STBOX XT(((5,1),(5,1)),[2000-01-05, 2000-01-05])"} */
      SELECT splitEachNStboxes(tgeompoint '[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(3 1)@2000-01-03, Point(4 2)@2000-01-04, Point(5 1)@2000-01-05]', 1);
      /* {"STBOX XT(((1,1),(2,2)),[2000-01-01, 2000-01-02])",
          "STBOX XT(((2,1),(3,2)),[2000-01-02, 2000-01-03])",
          "STBOX XT(((3,1),(4,2)),[2000-01-03, 2000-01-04])",
          "STBOX XT(((4,1),(5,2)),[2000-01-04, 2000-01-05])"} */
      SELECT splitEachNStboxes(tgeogpoint '{[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02],
        [Point(3 1)@2000-01-03, Point(4 2)@2000-01-04], [Point(5 1)@2000-01-05]}', 2);
      /* {"SRID=4326;GEODSTBOX XT(((1,1),(2,2)),[2000-01-01, 2000-01-02])",
          "SRID=4326;GEODSTBOX XT(((3,1),(4,2)),[2000-01-03, 2000-01-04])",
          "SRID=4326;GEODSTBOX XT(((5,1),(5,1)),[2000-01-05, 2000-01-05])"} */

## Mosaicos multidimensionales

Los mosaicos multidimensionales son un mecanismo que se utiliza para dividir el dominio de valores temporales en intervalos o mosaicos de un número variable de dimensiones. En el caso de una sola dimensión, el dominio se puede dividir por valor o por tiempo utilizando intervalos del mismo ancho o la misma duración, respectivamente. Para los números temporales, el dominio se puede dividir en mosaicos bidimensionales del mismo ancho para la dimensión de valor y la misma duración para la dimensión de tiempo. Para los puntos temporales, el dominio se puede dividir en el espacio en mosaicos bidimensionales o tridimensionales, dependiendo del número de dimensiones de las coordenadas espaciales. Finalmente, para los puntos temporales, el dominio se puede dividir por espacio y por tiempo usando mosaicos tridimensionales o tetradimensionales. Además, los valores temporales también se pueden fragmentar de acuerdo con una malla multidimensional definida sobre el dominio subyacente.

Los mosaicos multidimensionales se pueden utilizar para diversos fines. Se pueden utilizar para calcular histogramas multidimensionales, donde los valores temporales se agregan de acuerdo con la partición subyacente del dominio. Por otro lado, los mosaicos multidimensionales también se pueden utilizar para fines de indexación, donde el cuadro delimitador de un valor temporal se puede fragmentar en múltiples cuadros para mejorar la eficiencia del índice. Finalmente, los mosaicos multidimensionales se pueden utilizar para fragmentar valores temporales de acuerdo con una malla multidimensional definida sobre el dominio subyacente. Esto permite la distribución de un conjunto de datos en un clúster de servidores, donde cada servidor contiene una partición del conjunto de datos. La ventaja de este mecanismo de partición es que preserva la proximidad en valor/espacio y tiempo, a diferencia de los mecanismos de partición tradicionales basados ​​en hash.

### Mosaicos multidimensionales para números flotantes temporales.

La tiling ilustra un mosaico multidimensional para números flotantes temporales. El dominio bidimensional se divide en mosaicos que tienen el mismo tamaño para la dimensión de valor y la misma duración para la dimensión de tiempo. Suponga que este esquema de mosaicos se usa para distribuir un conjunto de datos en un clúster de seis servidores, como sugiere el patrón gris en la figura. En este caso, los valores se fragmentan para que cada servidor reciba los datos de mosaicos contiguos. Esto implica en particular que cuatro nodos recibirán un fragmento del número flotante temporal que se muestra en la figura. Una ventaja de esta distribución de datos basada en mosaicos multidimensionales es que reduce los datos que deben intercambiarse entre nodos cuando se procesan consultas, un proceso que generalmente se denomina reshuffling.

Muchas de las funciones de esta sección son funciones de retorno de conjuntos (también conocidas como funciones de tabla) ya que normalmente devuelven más de un valor. En este caso, las funciones están marcadas con el símbolo &SRF;.

### Operaciones de intervalos

- Devuelve una matriz de intervalos que cubre el rango de valores o de tiempo con intervalos de la misma amplitud o duración

  `bins(numspans,width number,origin number=0) → span[]`

  `bins(datespans,duration interval,origin date='2000-01-03') → span[]`

  `bins(tstzspans,duration interval,origin timestamptz='2000-01-03') → span[]`

  Si el origen no se especifica, su valor se establece por defecto en 0 para rangos de valores y en lunes 3 de enero de 2000 para rangos de tiempo.

      SELECT bins(floatspan '[-10, -1]', 2.5, -7);
      -- {"[-12, -9.5)","[-9.5, -7)","[-7, -4.5)","[-4.5, -2)","[-2, 0.5)"}
      SELECT bins(intspan '[15, 25]', 2);
      -- {"[14, 16)","[16, 18)","[18, 20)","[20, 22)","[22, 24)","[24, 26)","[26, 28)"}
      SELECT index, span
      FROM unnest(bins(datespan '[2001-01-15, 2001-01-25]', '2 days'))
        WITH ORDINALITY t(span, index);
      -- 1 | [2001-01-15, 2001-01-17)
      -- 2 | [2001-01-17, 2001-01-19)
      -- 3 | [2001-01-19, 2001-01-21)
      -- ...
      SELECT index, span
      FROM unnest(bins(tstzspanset '{[2001-01-15, 2001-01-17],[2001-01-22, 2001-01-25]}',
        '2 days', '2001-01-02')) WITH ORDINALITY t(span, index);
      -- 1 | [2001-01-15, 2001-01-16)
      -- 2 | [2001-01-16, 2001-01-17]
      -- 3 | [2001-01-22, 2001-01-24)
      -- 4 | [2001-01-24, 2001-01-25]

- Devuelve el rango que contiene un número o una marca de tiempo

  `getBin(number,size number,origin number=0) → span`

  `getBin(date,duration interval,origin date='2000-01-03') →`

  `getBin(timestamptz,duration interval,origin timestamptz='2000-01-03') →`

  `timestamptz`

  Si el origen no se especifica, su valor se establece por defecto en 0 para rangos de valores y en lunes 3 de enero de 2000 para rangos de tiempo.

      SELECT getBin(2, 2);
      -- [2, 4)
      SELECT getBin(2, 2.5, 1.5);
      -- [1.5, 4)
      SELECT getBin('2001-01-04', interval '1 week');
      -- [2001-01-03, 2001-01-10)
      SELECT getBin('2001-01-04', interval '1 week', '2001-01-07');
      -- [2000-12-31, 2001-01-07)

### Operaciones de mosaicos

- Devuelve el conjunto de mosaicos que cubre un cuadro delimitador temporal con mosaicos del mismo tamaño y/o duración &SRF;

  `valueTiles(tbox,size float,vorigin float=0) → {(index,tile)}`

  `timeTiles(tbox,duration interval,torigin timestamptz='2000-01-03') →`

  `{(index,tile)}`

  `valueTimeTiles(tbox,size float,duration interval,vorigin float=0,`

  `torigin timestamptz='2000-01-03') → {(index,tile)}`

  Si el origen de la dimensión de valores y/o de tiempo no se especifica, su valor se establece por defecto en 0 y en el lunes 3 de enero de 2000, respectivamente.

      SELECT (gr).index, (gr).tile
      FROM (SELECT valueTiles(tfloat '[15@2001-01-15, 25@2001-01-25]'::tbox, 2.0) AS gr) t;
      -- 1 | TBOXFLOAT X([14, 16))
      -- 2 | TBOXFLOAT X([16, 18))
      -- 3 | TBOXFLOAT X([18, 20))
      -- ...
      SELECT (gr).index, (gr).tile
      FROM (SELECT timeTiles(tfloat '[15@2001-01-15, 25@2001-01-25]'::tbox, '2 days') AS gr) t;
      -- 1 | TBOX T([2001-01-15, 2001-01-17))
      -- 2 | TBOX T([2001-01-17, 2001-01-19))
      -- 3 | TBOX T([2001-01-19, 2001-01-21))
      -- ...
      SELECT (gr).index, (gr).tile
      FROM (SELECT valueTimeTiles(tfloat '[15@2001-01-15, 25@2001-01-25]'::tbox, 2.0, '2 days')
        AS gr) t;
      -- 1 | TBOX XT([14,16),[2001-01-15,2001-01-17))
      -- 2 | TBOX XT([16,18),[2001-01-15,2001-01-17))
      -- 3 | TBOX XT([18,20),[2001-01-15,2001-01-17),)
      -- ...
      SELECT valueTimeTiles(tfloat '[15@2001-01-15, 25@2001-01-25]'::tbox, 2.0, '2 days', 11.5);
      -- (1,"TBOX XT([13.5,15.5),[2001-01-15,2001-01-17))")
      -- (2,"TBOX XT([15.5,17.5),[2001-01-15,2001-01-17))")
      -- (3,"TBOX XT([17.5,19.5),[2001-01-15,2001-01-17))")
      -- ...

- Devuelve el conjunto de mosaicos que cubre un cuadro delimitador espaciotemporal con mosaicos del mismo tamaño y/o duración &Z_support; &SRF;

  `spaceTiles(stbox,xsize float,[ysize float,zsize float,]`

  `sorigin geompoint='Point(0 0 0)',borderInc bool=true) → {(index,tile)}`

  `timeTiles(stbox,duration interval,torigin timestamptz='2000-01-03',`

  `borderInc bool=true) → {(index,tile)}`

  `spaceTimeTiles(stbox,xsize float,[ysize float,zsize float,]duration interval,`

  `sorigin geompoint='Point(0 0 0)',torigin timestamptz='2000-01-03',`

  `borderInc bool=true) → {(index,tile)}`

  Si el origen de las dimensiones espacial y/o de tiempo no se especifican, su valor se establece por defecto en `'Point (0 0 0)'` y en el lunes 3 de enero de 2000, respectivamente. El argumento opcional `borderInc` indica si se incluye el borde superior de la extensión y, por lo tanto, se generan mosaicos adicionales que contienen el borde.

  En el caso de una malla espacio-temporal, `ysize` y `zsize` son opcionales, se supone que el tamaño de las dimensiones faltantes es igual a `xsize`. El SRID de las coordenadas de los mosaicos está determinado por el del cuadro de entrada y el tamaño se da en las unidades del SRID. Si se especifica el origen de las coordenadas espaciales, que debe ser un punto, su dimensionalidad y SRID deben ser iguales al del cuadro delimitador, de lo contrario se genera un error.

      SELECT spaceTiles(tgeompoint '[Point(3 3)@2001-01-15,
        Point(15 15)@2001-01-25]'::stbox, 2.0);
      -- (1,"STBOX X((2,2),(4,4))")
      -- (2,"STBOX X((4,2),(6,4))")
      -- (3,"STBOX X((6,2),(8,4))")
      -- ...
      SELECT timeTiles(tgeompoint '[Point(3 3)@2001-01-15,
        Point(15 15)@2001-01-25]'::stbox, '2 days');
      -- (1,"STBOX T([2001-01-15, 2001-01-17))")
      -- (2,"STBOX T([2001-01-17, 2001-01-19))")
      -- (3,"STBOX T([2001-01-19, 2001-01-21))")
      -- ...
      SELECT spaceTiles(tgeompoint 'SRID=3812;[Point(3 3)@2001-01-15,
        Point(15 15)@2001-01-25]'::stbox, 2.0, geometry 'Point(3 3)');
      -- (1,"SRID=3812;STBOX X((3,3),(5,5))")
      -- (2,"SRID=3812;STBOX X((5,3),(7,5))")
      -- (3,"SRID=3812;STBOX X((7,3),(9,5))")
      -- ...
      SELECT spaceTiles(tgeompoint '[Point(3 3 3)@2001-01-15,
        Point(15 15 15)@2001-01-25]'::stbox, 2.0, geometry 'Point(3 3 3)');
      -- (1,"STBOX Z((3,3,3),(5,5,5))")
      -- (2,"STBOX Z((5,3,3),(7,5,5))")
      -- (3,"STBOX Z((7,3,3),(9,5,5))")
      -- ...
      SELECT spaceTimeTiles(tgeompoint '[Point(3 3)@2001-01-15,
        Point(15 15)@2001-01-25]'::stbox, 2.0, interval '2 days');
      -- (1,"STBOX XT(((2,2),(4,4)),[2001-01-15,2001-01-17))")
      -- (2,"STBOX XT(((4,2),(6,4)),[2001-01-15,2001-01-17))")
      -- (3,"STBOX XT(((6,2),(8,4)),[2001-01-15,2001-01-17))")
      -- ...
      SELECT spaceTimeTiles(tgeompoint '[Point(3 3 3)@2001-01-15,
        Point(15 15 15)@2001-01-25]'::stbox, 2.0, interval '2 days',
        'Point(3 3 3)', '2001-01-15');
      -- (1,"STBOX ZT(((3,3,3),(5,5,5)),[2001-01-15,2001-01-17))")
      -- (2,"STBOX ZT(((5,3,3),(7,5,5)),[2001-01-15,2001-01-17))")
      -- (3,"STBOX ZT(((7,3,3),(9,5,5)),[2001-01-15,2001-01-17))")
      -- ...

- Devuelve el mosaico temporal que cubre un valor y/o una marca de tiempo

  `getValueTile(value float,vsize float,vorigin float=0.0) → tbox`

  `getTboxTimeTile(time timestamptz,duration interval,torigin timestamptz='2000-01-03')`

  `torigin timestamptz='2000-01-03') → tbox`

  `getValueTimeTile(value float,time timestamptz,vsize float,duration interval,`

  `vorigin float=0.0,torigin timestamptz='2000-01-03') → tbox`

  Si el origen de las dimensiones de valores y/o de tiempo no se especifica, su valor se establece por defecto en 0 y en el lunes 3 de enero de 2000, respectivamente.

      SELECT getValueTile(15, 2);
      -- TBOX ([14,16))
      SELECT getTboxTimeTile('2001-01-15', interval '2 days');
      -- TBOX ([2001-01-15,2001-01-17))
      SELECT getValueTimeTile(15, '2001-01-15', 2, interval '2 days');
      -- TBOX ([14,16),[2001-01-15,2001-01-17))
      SELECT getValueTimeTile(15, '2001-01-15', 2, interval '2 days', 1, '2001-01-02');
      -- TBOX XT([15,17),[2001-01-14,2001-01-16))

- Devuelve el mosaico espaciotemporal que cubre un punto y/o una marca de tiempo &Z_support;

  `getSpaceTile(point geometry,xsize float,[ysize float,zsize float],`

  `sorigin geompoint='Point(0 0 0)') → stbox`

  `getStboxTimeTile(time timestamptz,duration interval,`

  `torigin timestamptz='2000-01-03') → stbox`

  `getSpaceTimeTile(point geometry,time timestamptz,xsize float,`

  `[ysize float,zsize float,]duration,interval,sorigin geompoint='Point(0 0 0)',`

  `torigin timestamptz='2000-01-03') → stbox`

  Si el origen de la dimensión espacial y/o de tiempo no se especifica, su valor se establece por defecto en `'Point(0 0 0)'` y en el lunes 3 de enero de 2000, respectivamente.

  En el caso de una malla espacio-temporal, `ysize` y `zsize` son opcionales, se supone que el tamaño de las dimensiones faltantes es igual a `xsize`. El SRID de las coordenadas de los mosaicos está determinado por el del cuadro de entrada y el tamaño se da en las unidades del SRID. Si se especifica el origen de las coordenadas espaciales, que debe ser un punto, su dimensionalidad y SRID deben ser iguales al del cuadro delimitador, de lo contrario se genera un error.

      SELECT getSpaceTile(geometry 'Point(1 1 1)', 2.0);
      -- STBOX Z((0,0,0),(2,2,2))
      SELECT getStboxTimeTile(timestamptz '2001-01-01', interval '2 days');
      -- STBOX T([2001-01-01,2001-01-03))
      SELECT getSpaceTimeTile(geometry 'Point(1 1)', '2001-01-01', 2.0, interval '2 days');
      -- STBOX XT((0,0),(2,2),[2001-01-01,2001-01-03))
      SELECT getSspaceTimeTile(geometry 'Point(1 1)', '2001-01-01', 2.0, interval '2 days',
        'Point(1 1)', '2001-01-02');
      -- STBOX XT(((1,1),(3,3)),[2000-12-31,2001-01-02))

### Operaciones de cuadro delimitador

Estas operaciones fragmentan el cuadro delimitador de un valor temporal con respecto a un mosaico multidimensional. Ofrecen una alternativa a las operaciones de la ttype_splitting para dividir los cuadros delimitadores especificando el tamaño máximo de los cuadros en las distintas dimensiones.

- Devuelve una matriz de rangos de valores o de tiempo obtenidos a partir de los instantes o segmentos de un número temporal con respecto a un mosaico de valores o de tiempo

  `valueBins(tnumber,vsize number,vorigin number=0) → numspan[]`

  `timeBins(temp,duration interval,torigin timestamptz='2000-01-03') → tstzspan[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta o continua. Si no se especifica el origen de los valores, se establece por defecto en 0 para los rangos de valores y en el lunes 3 de enero de 2000 para los rangos de tiempo.

      SELECT valueBins(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05}', 3);
      -- {"[1, 3)","[4, 5)"}
      SELECT valueBins(tfloat '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', 3, 1);
      -- {"[1, 4)","[4, 4]"}

      SELECT timeBins(ttext '{AAA@2000-01-01, BBB@2000-01-02, AAA@2000-01-03, CCC@2000-01-04,
        AAA@2000-01-05}', '3 days');
      -- {"[2000-01-01, 2000-01-02]","[2000-01-03, 2000-01-05]"}
      SELECT timeBins(tfloat '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', '3 days', '2000-01-01');
      -- {"[2000-01-01, 2000-01-04)","[2000-01-04, 2000-01-05)"}

- Devuelve una matriz de cuadros temporales obtenidos a partir de los instantes o segmentos de un número temporal con respecto a un mosaico de valores y/o tiempo

  `valueBoxes(tnumber,size number,vorigin number=0) → tbox[]`

  `timeBoxes(tnumber,duration interval,torigin timestamptz='2000-01-03') → tbox[]`

  `valueTimeBoxes(tnumber,size number,duration interval,vorigin number=0,`

  `torigin timestamptz='2000-01-03') → tbox[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta o continua. Si el origen de la dimensión de valores y/o de tiempo no se especifica, se establece por defecto en 0 y en el lunes 3 de enero de 2000, respectivamente.

      SELECT valueBoxes(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
      1@2000-01-05}', 3);
      /* {"TBOXINT XT([1, 3),[2000-01-01, 2000-01-05])",
          "TBOXINT XT([4, 5),[2000-01-04, 2000-01-04])"} */
      SELECT timeBoxes(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
      1@2000-01-05}', '3 days');
      /* {"TBOXINT XT([1, 3),[2000-01-01, 2000-01-02])",
          "TBOXINT XT([1, 5),[2000-01-03, 2000-01-05])"} */
      SELECT valueTimeBoxes(tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05}', 3, '3 days');
      /* {"TBOXINT XT([1, 3),[2000-01-01, 2000-01-02])",
          "TBOXINT XT([1, 2),[2000-01-03, 2000-01-05])",
          "TBOXINT XT([4, 5),[2000-01-04, 2000-01-04])"} */
      SELECT valueTimeBoxes(tfloat '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03, 4@2000-01-04,
        1@2000-01-05]', 3, '3 days', 1, '2000-01-01');
      /* {"TBOXFLOAT XT([1, 4),[2000-01-01, 2000-01-04))",
          "TBOXFLOAT XT([1, 4),(2000-01-04, 2000-01-05])",
          "TBOXFLOAT XT([4, 4],[2000-01-04, 2000-01-04])"} */

- Devuelve una matriz de cuadros espaciotemporales obtenidos a partir de los instantes o segmentos de un punto temporal con respecto a un mosaico espacial y/o temporal &Z_support;

  `spaceBoxes(tgeompoint,xsize float,[ysize float,zsize float,]`

  `sorigin geompoint='Point(0 0 0)',borderInc bool=true) → stbox[]`

  `timeBoxes(tgeompoint,duration interval,torigin timestamptz='2000-01-03',`

  `borderInc bool=true) → stbox[]`

  `spaceTimeBoxes(tgeompoint,xsize float,[ysize float,zsize float,]duration interval,`

  `sorigin geompoint='Point(0 0 0)',torigin timestamptz='2000-01-03',`

  `borderInc bool=true) → stbox[]`

  La elección entre instantes o segmentos depende de si la interpolación es discreta o continua. Los argumentos `ysize` y `zsize` son opcionales, se supone que el tamaño de las dimensiones faltantes es igual a `xsize`. El SRID de las coordenadas del mosaico se determina por el punto temporal y los tamaños se dan en las unidades del SRID. Si se proporciona el origen de las coordenadas espaciales, que debe ser un punto, su dimensionalidad y SRID deben ser iguales a los del punto temporal, de lo contrario se genera un error. Si el origen de la dimensión espacial y/o el tiempo no se especifica, su valor se establece por defecto en `'Point(0 0 0)'` y en el lunes 3 de enero de 2000, respectivamente. El argumento opcional `borderInc` indica si se incluye el borde superior de la extensión y, por lo tanto, se generan mosaicos adicionales que contienen el borde.

      SELECT spaceBoxes(tgeompoint '{Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(1 1)@2000-01-03, Point(4 4)@2000-01-04, Point(1 1)@2000-01-05}', 3);
      /* {"STBOX XT(((1,1),(2,2)),[2000-01-01, 2000-01-05])",
         "STBOX XT(((4,4),(4,4)),[2000-01-04, 2000-01-04])"} */
      SELECT timeBoxes(tgeompoint '{Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02,
        Point(1 1 1)@2000-01-03, Point(4 4 4)@2000-01-04, Point(1 1 1)@2000-01-05}',
        interval '2 days', '2000-01-01');
      /* {"STBOX ZT(((1,1,1),(2,2,2)),[2000-01-01, 2000-01-02])",
          "STBOX ZT(((1,1,1),(4,4,4)),[2000-01-03, 2000-01-04])",
          "STBOX ZT(((1,1,1),(1,1,1)),[2000-01-05, 2000-01-05])"} */
      SELECT spaceTimeBoxes(tgeompoint '{Point(1 1)@2000-01-01, Point(2 2)@2000-01-02,
        Point(1 1)@2000-01-03, Point(4 4)@2000-01-04, Point(1 1)@2000-01-05}', 3, '3 days');
      /* {"STBOX XT(((1,1),(2,2)),[2000-01-01, 2000-01-02])",
          "STBOX XT(((1,1),(1,1)),[2000-01-03, 2000-01-05])",
          "STBOX XT(((4,4),(4,4)),[2000-01-04, 2000-01-04])"} */
      SELECT spaceTimeBoxes(tgeompoint '[Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02,
        Point(1 1 1)@2000-01-03, Point(4 4 4)@2000-01-04, Point(1 1 1)@2000-01-05]',
        3, interval '3 days', 'Point(1 1 1)', '2000-01-01');
      /* {"STBOX ZT(((1,1,1),(4,4,4)),[2000-01-01, 2000-01-04))",
          "STBOX ZT(((1,1,1),(4,4,4)),(2000-01-04, 2000-01-05])",
          "STBOX ZT(((4,4,4),(4,4,4)),[2000-01-04, 2000-01-04])"} */

### Operaciones de división

Estas funciones fragmentan un valor temporal con respecto a una secuencia de intervalos (ver la bin_functions) o un mosaico multidimensional (ver la tile_functions).

- Fragmentar un número temporal con respecto a intervalos de valores y/o de tiempo &SRF;

  `valueSplit(tnumber,width number,origin number=0) → {(number,tnumber)}`

  `timeSplit(ttype,duration interval,origin timestamptz='2000-01-03') →`

  `{(time,temp)}`

  `valueTimeSplit(tnumber,width number,duration interval,vorigin number=0,`

  `torigin timestamptz='2000-01-03') → {(number,time,tnumber)}`

  El resultado es un conjunto de pares o un conjunto de triples. Si no se especifica el origen de la dimensión de valores o temporal, se establecen por defecto en 0 y en el lunes 3 de enero de 2000, respectivamente.

      SELECT (sp).number, (sp).tnumber
      FROM (SELECT valueSplit(tint '[1@2001-01-01, 2@2001-01-02, 5@2001-01-05, 10@2001-01-10]',
        2) AS sp) t;
      --  0 | {[1@2001-01-01 00:00:00+01, 1@2001-01-02 00:00:00+01)}
      --  2 | {[2@2001-01-02 00:00:00+01, 2@2001-01-05 00:00:00+01)}
      --  4 | {[5@2001-01-05 00:00:00+01, 5@2001-01-10 00:00:00+01)}
      -- 10 | {[10@2001-01-10 00:00:00+01]}
      SELECT valueSplit(tfloat '[1@2001-01-01, 10@2001-01-10)', 2.0, 1.0);
      -- (1,"{[1@2001-01-01 00:00:00+01, 3@2001-01-03 00:00:00+01)}")
      -- (3,"{[3@2001-01-03 00:00:00+01, 5@2001-01-05 00:00:00+01)}")
      -- (5,"{[5@2001-01-05 00:00:00+01, 7@2001-01-07 00:00:00+01)}")
      -- (7,"{[7@2001-01-07 00:00:00+01, 9@2001-01-09 00:00:00+01)}")
      -- (9,"{[9@2001-01-09 00:00:00+01, 10@2001-01-10 00:00:00+01)}")

      SELECT (ts).time, (ts).temp
      FROM (SELECT timeSplit(tfloat '[1@2001-02-01, 10@2001-02-10)', '2 days') AS ts) t;
      -- 2001-01-31 | [1@2001-02-01, 2@2001-02-02)
      -- 2001-02-02 | [2@2001-02-02, 4@2001-02-04)
      -- 2001-02-04 | [4@2001-02-04, 6@2001-02-06)
      -- ...
      SELECT (ts).time, asText((ts).temp) AS temp
      FROM (SELECT timeSplit(tgeompoint '[Point(1 1)@2001-02-01, Point(10 10)@2001-02-10]',
        '2 days', '2001-02-01') AS ts) AS t;
      -- 2001-02-01 | [POINT(1 1)@2001-02-01, POINT(3 3)@2001-02-03)
      -- 2001-02-03 | [POINT(3 3)@2001-02-03, POINT(5 5)@2001-02-05)
      -- 2001-02-05 | [POINT(5 5)@2001-02-05, POINT(7 7)@2001-02-07)
      -- ...

  Observe que se puede fragmentar un valor temporal en intervalos de tiempo cíclicos (en lugar de lineales). Los siguientes dos ejemplos muestran cómo fragmentar un valor temporal por hora y por día de la semana.

      SELECT (ts).time::time AS hour, merge((ts).temp) AS temp
      FROM (SELECT timeSplit(tfloat '[1@2001-01-01, 10@2001-01-03]', '1 hour') AS ts) t
      GROUP BY hour ORDER BY hour;
      /* 00:00:00 | {[1@2001-01-01 00:00:00+01, 1.1875@2001-01-01 01:00:00+01),
                     [5.5@2001-01-02 00:00:00+01, 5.6875@2001-01-02 01:00:00+01)} */
      /* 01:00:00 | {[1.1875@2001-01-01 01:00:00+01, 1.375@2001-01-01 02:00:00+01),
                     [5.6875@2001-01-02 01:00:00+01, 5.875@2001-01-02 02:00:00+01)} */
      /* 02:00:00 | {[1.375@2001-01-01 02:00:00+01, 1.5625@2001-01-01 03:00:00+01),
                     [5.875@2001-01-02 02:00:00+01, 6.0625@2001-01-02 03:00:00+01)} */
      /* 03:00:00 | {[1.5625@2001-01-01 03:00:00+01, 1.75@2001-01-01 04:00:00+01),
                     [6.0625@2001-01-02 03:00:00+01, 6.25@2001-01-02 04:00:00+01)} */
      /* ... */
      SELECT EXTRACT(DOW FROM (ts).time) AS dow_no, TO_CHAR((ts).time, 'Dy') AS dow,
        asText(round(merge((ts).temp), 2)) AS temp
      FROM (SELECT timeSplit(tgeompoint '[Point(1 1)@2001-01-01, Point(10 10)@2001-01-14)',
        '1 hour') AS ts) t
      GROUP BY dow, dow_no ORDER BY dow_no;
      /* 0 | Sun | {[POINT(1 1)@2001-01-01, POINT(1.69 1.69)@2001-01-02),
                    [POINT(5.85 5.85)@2001-01-08, POINT(6.54 6.54)@2001-01-09)} */
      /* 1 | Mon | {[POINT(1.69 1.69)@2001-01-02, POINT(2.38 2.38)@2001-01-03),
                    [POINT(6.54 6.54)@2001-01-09, POINT(7.23 7.23)@2001-01-10)} */
      /* 2 | Tue | {[POINT(2.38 2.38)@2001-01-03, POINT(3.08 3.08)@2001-01-04),
                    [POINT(7.23 7.23)@2001-01-10, POINT(7.92 7.92)@2001-01-11)} */
      /* ... */

      SELECT (sp).number, (sp).time, (sp).tnumber
      FROM (SELECT valueTimeSplit(tint '[1@2001-02-01, 2@2001-02-02, 5@2001-02-05,
        10@2001-02-10]', 5, '5 days') AS sp) t;
      --  0 | 2001-02-01 | {[1@2001-02-01, 2@2001-02-02, 2@2001-02-05)}
      --  5 | 2001-02-01 | {[5@2001-02-05, 5@2001-02-06)}
      --  5 | 2001-02-06 | {[5@2001-02-06, 5@2001-02-10)}
      -- 10 | 2001-02-06 | {[10@2001-02-10]}
      SELECT (sp).number, (sp).time, (sp).tnumber
      FROM (SELECT valueTimeSplit(tfloat '[1@2001-02-01, 10@2001-02-10)', 5.0, '5 days', 1.0,
        '2001-02-01') AS sp) t;
      -- 1 | 2001-01-01 | [1@2001-01-01, 6@2001-01-06)
      -- 6 | 2001-01-06 | [6@2001-01-06, 10@2001-01-10)

- Fragmentar un punto temporal con respecto a una malla espacial o espacio-temporal &SRF;

  `spaceSplit(tgeompoint,xsize float,[ysize float,zsize float,]`

  `origin geompoint='Point(0 0 0)',bitmatrix boolean=true,borderInc bool=true) →`

  `{(point,tpoint)}`

  `timeSplit(tgeompoint,duration interval,torigin timestamptz='2000-01-03',`

  `bitmatrix boolean=true,borderInc boolean=true) → {(point,time,tpoint)}`

  `spaceTimeSplit(tgeompoint,xsize float,[ysize float,zsize float,]`

  `duration interval,sorigin geompoint='Point(0 0 0)',`

  `torigin timestamptz='2000-01-03',bitmatrix boolean=true,borderInc boolean=true) →`

  `{(point,time,tpoint)}`

  El resultado es un conjunto de pares o un conjunto de triples. Si el origen de la dimensión espacial y/o el tiempo no se especifica, su valor se establece por defecto en `'Point(0 0 0)'` y en el lunes 3 de enero de 2000, respectivamente. Los argumentos `ysize` y `zsize` son opcionales, se supone que el tamaño de las dimensiones faltantes es igual a `xsize`. Si no se especifica el argumento `bitmatrix`, el cálculo utilizará una matriz de bits para acelerar el proceso. El argumento opcional `borderInc` indica si se incluye el borde superior de la extensión espacial y, por lo tanto, se generan mosaicos adicionales que contienen el borde.

      SELECT ST_AsText((sp).point) AS point, asText((sp).tpoint) AS tpoint
      FROM (SELECT spaceSplit(tgeompoint '[Point(1 1)@2001-03-01, Point(10 10)@2001-03-10]',
        2.0) AS sp) t;
      -- POINT(0 0) | {[POINT(1 1)@2001-03-01, POINT(2 2)@2001-03-02)}
      -- POINT(2 2) | {[POINT(2 2)@2001-03-02, POINT(4 4)@2001-03-04)}
      -- POINT(4 4) | {[POINT(4 4)@2001-03-04, POINT(6 6)@2001-03-06)}
      -- ...
      SELECT ST_AsText((sp).point) AS point, asText((sp).tpoint) AS tpoint
      FROM (SELECT spaceSplit(tgeompoint '[Point(1 1 1)@2001-03-01,
        Point(10 10 10)@2001-03-10]', 2.0, geometry 'Point(1 1 1)') AS sp) t;
      -- POINT Z(1 1 1) | {[POINT Z (1 1 1)@2001-03-01, POINT Z (3 3 3)@2001-03-03)}
      -- POINT Z(3 3 3) | {[POINT Z (3 3 3)@2001-03-03, POINT Z (5 5 5)@2001-03-05)}
      -- POINT Z(5 5 5) | {[POINT Z (5 5 5)@2001-03-05, POINT Z (7 7 7)@2001-03-07)}
      -- ...

      SELECT (sp).time, astext((sp).temp) AS tpoint
      FROM (SELECT timeSplit(tgeompoint '[Point(1 1)@2001-02-01, Point(10 10)@2001-02-10]',
        interval '2 days') AS sp) t;
      -- 2001-01-31 | [POINT(1 1)@2001-02-01, POINT(2 2)@2001-02-02)
      -- 2001-02-02 | [POINT(2 2)@2001-02-02, POINT(4 4)@2001-02-04)
      -- 2001-02-04 | [POINT(4 4)@2001-02-04, POINT(6 6)@2001-02-06)
      -- ...

      SELECT ST_AsText((sp).point) AS point, (sp).time, asText((sp).tpoint) AS tpoint
      FROM (SELECT spaceTimeSplit(tgeompoint '[Point(1 1)@2001-02-01, Point(10 10)@2001-02-10]',
        2.0, interval '2 days') AS sp) t;
      -- POINT(0 0) | 2001-01-31 | {[POINT(1 1)@2001-02-01, POINT(2 2)@2001-02-02)}
      -- POINT(2 2) | 2001-01-31 | {[POINT(2 2)@2001-02-02]}
      -- POINT(2 2) | 2001-02-02 | {[POINT(2 2)@2001-02-02, POINT(4 4)@2001-02-04)}
      -- ...
      SELECT ST_AsText((sp).point) AS point, (sp).time, asText((sp).tpoint) AS tpoint
      FROM (SELECT spaceTimeSplit(tgeompoint '[Point(1 1 1)@2001-02-01,
        Point(10 10 10)@2001-02-10]', 2.0, interval '2 days', 'Point(1 1 1)',
        '2001-03-01') AS sp) t;
      -- POINT Z(1 1 1) | 2001-02-01 | {[POINT Z(1 1 1)@2001-02-01, POINT Z(3 3 3)@2001-02-03)}
      -- POINT Z(3 3 3) | 2001-02-01 | {[POINT Z(3 3 3)@2001-02-03]}
      -- POINT Z(3 3 3) | 2001-02-03 | {[POINT Z(3 3 3)@2001-02-03, POINT Z (5 5 5)@2001-02-05)}
      -- ...