Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Indexar y ver elementos de arreglo alto

Las matrices altas son demasiado grandes para caber en la memoria, por lo que es común ver subconjuntos de los datos en lugar de toda la matriz. Esta página muestra técnicas para extraer y ver porciones de una matriz alta.

Extraer las filas superiores de la matriz

Utilice la función head para extraer las primeras filas de una matriz alta. head no fuerza la evaluación de la matriz, por lo que debe utilizar gather para ver el resultado.

tt = tall(table(randn(1000,1),randn(1000,1),randn(1000,1)))
tt =    1,000×3 tall table        Var1        Var2        Var3       ________    ________    ________       0.53767      0.6737     0.29617       1.8339    -0.66911      1.2008      -2.2588    -0.40032      1.0902      0.86217     -0.6718     -0.3587      0.31877     0.57563    -0.12993      -1.3077    -0.77809     0.73374     -0.43359     -1.0636     0.12033      0.34262     0.55298      1.1363        :           :           :        :           :           :
t_head = gather(head(tt))
Evaluating tall expression using the Local MATLAB Session: Evaluation completed in 0 sec  t_head =         Var1        Var2        Var3       ________    ________    ________       0.53767      0.6737     0.29617       1.8339    -0.66911      1.2008      -2.2588    -0.40032      1.0902      0.86217     -0.6718     -0.3587      0.31877     0.57563    -0.12993      -1.3077    -0.77809     0.73374     -0.43359     -1.0636     0.12033      0.34262     0.55298      1.1363 

Extraer las filas inferiores de la matriz

De manera similar, puede utilizar la función tail para extraer las filas inferiores de una matriz alta.

t_tail = gather(tail(tt))
Evaluating tall expression using the Local MATLAB Session: Evaluation completed in 0 sec  t_tail =         Var1        Var2        Var3       ________    ________    ________       0.64776     0.47349    -0.27077     -0.31763      1.3656     0.43966        1.769     -1.6378    -0.50614       1.5106      2.0237    -0.18435      0.16401     0.77779       0.402     -0.28276     -0.5489     0.53923       1.1522    -0.12601    -0.73359      -1.1465     0.29958    -0.26837

Indexación de matrices altas

Todos los arrays altos soportan la indexación de paréntesis. Al indexar una matriz alta utilizando paréntesis, como T(A) o T(A,B), el resultado es una nueva matriz alta que contiene sólo las filas y columnas especificadas (o variables). Como la mayoría de las otras operaciones en arreglos de discos altos, las expresiones de indexación no se evalúan inmediatamente. Debe utilizar gather para evaluar la operación de indexación. Para obtener más información, consulte Evaluación diferida de matrices altas.

Puede realizar estos tipos de indexación en la primera dimensión de un arreglo de discos alto:

  • B = A(:,…), donde : selecciona todas las filas en A.

  • B = A(idx,…), donde idx es un vector de columna numérico alto o Vector numérico no alto.

  • B = A(L,…), donde L es un arreglo lógico alto o no alto de la misma altura que A. Por ejemplo, puede utilizar operadores relacionales, como tt(tt.Var1 < 10,:).

  • B = A(P:D:Q,…) o B = A(P:Q,…), donde P:D:Q y P:Q son expresiones de indexación colon válidas.

    • head(tt,k) proporciona un acceso directo para tt(1:k,:).

    • tail(tt,k) proporciona un acceso directo para tt(end-k:end,:).

Además, el número de subíndices que debe especificar depende de cuántas dimensiones tenga la matriz:

  • Para vectores de columna altos, puede especificar un solo subíndice como t(1:10).

  • Para los vectores de fila alta, las tablas altas y los horarios altos, debe especificar dos subíndices.

  • Para matrices altas con dos o más dimensiones, debe especificar dos o más subíndices. Por ejemplo, si la matriz tiene tres dimensiones, se puede utilizar una expresión como tA(1:10,:,:) o tA(1:10,:), pero no expresiones de indexación lineal como tA(1:10) o tA(:).

Sugerencia

La función find localiza elementos no nulos en vectores de columnas altas, y puede ser útil para generar un vector de índices para elementos que cumplen determinadas condiciones. Por ejemplo, k = find(X<0) devuelve los índices lineales para todos los elementos negativos de X.

Por ejemplo, utilice la indización de paréntesis para recuperar las diez primeras filas de tt.

tt(1:10,:)
ans =    10×3 tall table        Var1        Var2        Var3       ________    ________    ________       0.53767      0.6737     0.29617       1.8339    -0.66911      1.2008      -2.2588    -0.40032      1.0902      0.86217     -0.6718     -0.3587      0.31877     0.57563    -0.12993      -1.3077    -0.77809     0.73374     -0.43359     -1.0636     0.12033      0.34262     0.55298      1.1363        :           :           :        :           :           :

Recupere los últimos 5 valores de la variable TABLE Var1.

tt(end-5:end,'Var1')
ans =    6×1 tall table         Var1       ________         1.769       1.5106      0.16401     -0.28276       1.1522      -1.1465

Recuperen cada fila 100 de la mesa alta.

tt(1:100:end,:)
ans =    10×3 tall table        Var1         Var2         Var3       _________    _________    ________        0.53767       0.6737     0.29617       0.84038    -0.041663    -0.52093       0.18323       1.3419    0.052993      0.079934     -0.40492     -1.6163       0.26965      -1.5144     0.98399     -0.079893      -1.6848    -0.91182       0.47586      -2.1746      1.1754        1.9085     -0.79383     0.18343         :            :           :         :            :           :

Extraer variables de la tabla alta

Las variables en una tabla alta o un horario alto son cada una de las matrices altas de diferentes tipos de datos subyacentes. Los métodos estándar de indexación de tablas y horarios también se aplican a mesas altas y horarios altos.

Por ejemplo, indexe una tabla alta utilizando la notación de puntos T.VariableName para recuperar una sola variable de datos como una matriz alta.

tt.Var1
ans =    1,000×1 tall double column vector      0.5377     1.8339    -2.2588     0.8622     0.3188    -1.3077    -0.4336     0.3426       :       :

Utilice Tab complete para buscar las variables en una tabla si no puede recordar un nombre de variable preciso. Por ejemplo, escriba tt. y, a continuación, presione Tab. Aparece un menú:

También puede realizar varios niveles de indexación. Por ejemplo, extraiga los primeros 5 elementos de la variable Var2. En este caso, debe utilizar uno de los formularios soportados de indexación para matrices altas en los paréntesis.

tt.Var2(1:5)
ans =    5×1 tall double column vector      0.6737    -0.6691    -0.4003    -0.6718     0.5756

Consulte Acceso a datos en una tabla o Seleccionar datos de horarios por tiempo de fila y tipo de variable para obtener más información sobre la indización.

Concatenación con matrices altas

Para concatenar dos o más matrices altas, como en [A1 A2 A3 …], cada una de las matrices altas debe derivarse de una sola matriz alta y no debe haber sido indexada de forma diferente en la primera dimensión. Las operaciones de indexación incluyen funciones como vertcat, splitapply, sort, cell2mat, synchronize, retime, etc.

Por ejemplo, concatena algunas columnas de tt para crear una nueva matriz alta.

[tt.Var1 tt.Var2]
ans =    1,000×2 tall double matrix      0.5377    0.6737     1.8339   -0.6691    -2.2588   -0.4003     0.8622   -0.6718     0.3188    0.5756    -1.3077   -0.7781    -0.4336   -1.0636     0.3426    0.5530       :         :       :         :

Para combinar arreglos altos con diferentes almacenes de almacenamiento de la base, se recomienda utilizar write para escribir los arrays (o los resultados de cálculo) en el disco y, a continuación, crear un nuevo almacén de referencias que haga referencia a esas ubicaciones:

files = {'folder/path/to/file1','folder/path/to/file2'}; ds = datastore(files);

Asignación y eliminación con matrices altas

Las mismas reglas de subíndice se aplican si se utiliza la indización para asignar o eliminar elementos de una matriz alta. La eliminación se realiza asignando uno o más elementos a la matriz vacía, [].

asignaCión "()"

Puede asignar elementos a una matriz alta utilizando la sintaxis general A(m,n,...) = B. El array alto A debe existir. El primer subscript m debe ser un : de dos puntos o un vector lógico alto. Con esta sintaxis, B puede ser:

  • Escalar

  • Un array alto derivado de A(m,…) donde m es el mismo subíndice que el anterior. Por ejemplo, A(m,1:10).

  • Una matriz vacía, [] (para la eliminación)

"." Asignación

Para la indexación de tablas mediante la sintaxis A.Var1 = B, el array B debe ser un array alto con el número apropiado de filas. Típicamente, B se deriva de datos existentes en la tabla alta. Var1 puede ser una variable nueva o ya existente en la tabla alta.

No se pueden asignar matrices altas como variables en una tabla regular, incluso si la tabla está vacía.

Extraer el número especificado de filas en orden ordenada

La clasificación de todos los datos en una matriz alta puede ser un cálculo costoso. Con mayor frecuencia, sólo se requiere un subconjunto de filas al principio o al final de una matriz alta para responder preguntas como "¿Cuál es la primera fila de estos datos por año?"

La función topkrows devuelve un número especificado de filas en orden ordenada para este propósito. Por ejemplo, utilice topkrows para extraer las 12 filas superiores ordenadas en orden descendente por la segunda columna.

t_top12 = gather(topkrows(tt,12,2))
Evaluating tall expression using the Local MATLAB Session: Evaluation completed in 0 sec  t_top12 =         Var1       Var2       Var3       ________    ______    ________       -1.0322    3.5699     -1.4689       1.3312    3.4075     0.17694     -0.27097    3.1585     0.50127      0.55095    2.9745       1.382      0.45168    2.9491     -0.8215      -1.7115    2.7526     -0.3384     -0.21317    2.7485      1.9033     -0.43021    2.7335     0.77616     -0.59003    2.7304     0.67702      0.47163    2.7292     0.92099     -0.47615     2.683    -0.26113      0.72689    2.5383    -0.57588

Resumir el contenido del array alto

La función summary devuelve información útil sobre cada variable en una tabla o calendario alto, como los valores mínimos y máximos de las variables numéricas, y el número de apariciones de cada categoría para las variables categóricas.

Por ejemplo, cree una tabla alta para el conjunto de datos outages.csv y muestre la información resumida. Este conjunto de datos contiene variables numéricas, DateTime y categóricas.

fmts = {'%C' '%D' '%f' '%f' '%D' '%C'}; ds = datastore('outages.csv','TextscanFormats',fmts); T = tall(ds); summary(T)
Evaluating tall expression using the Local MATLAB Session: - Pass 1 of 1: Completed in 0 sec Evaluation completed in 0 sec  Variables:      Region: 1,468×1 categorical         Values:              MidWest      142             NorthEast    557             SouthEast    389             SouthWest     26             West         354      OutageTime: 1,468×1 datetime         Values:              min    02/01/2002 12:18             max    01/15/2014 02:41      Loss: 1,468×1 double         Values:              min              0             max     23417.7235             NaNs           604      Customers: 1,468×1 double         Values:              min               0             max     5968874.882             NaNs            328      RestorationTime: 1,468×1 datetime         Values:              min     02/07/2002 16:50             max     09/18/2042 23:31             NaTs                  29      Cause: 1,468×1 categorical         Values:              attack              294             earthquake            2             energy emergency    188             equipment fault     156             fire                 25             severe storm        338             thunder storm       201             unknown              24             wind                 95             winter storm        145

Devolver subconjunto de resultados de cálculo

Muchos de los ejemplos de esta página utilizan gather para evaluar expresiones y llevar los resultados a la memoria. Sin embargo, en estos ejemplos también es trivial que los resultados encajen en la memoria, ya que sólo unas pocas filas se indexan a la vez.

En los casos en que no esté seguro si el resultado de una expresión cabe en la memoria, se recomienda que utilice gather(head(X)) o gather(tail(X)). Estos comandos todavía evalúan todos los cálculos en cola, pero devuelven sólo una pequeña cantidad del resultado que se garantiza que quepa en la memoria.

Si está seguro de que el resultado de un cálculo no cabe en la memoria, utilice write para evaluar la matriz alta y escribir los resultados en el disco en su lugar.

Consulte también

| | | | |

Temas relacionados