table2array

Convertir una tabla en un arreglo homogéneo

Sintaxis

A = table2array(T)

Descripción

A = table2array(T) convierte una tabla o un horario de entrada en un arreglo homogéneo. Las variables en la entrada T se convierten en columnas en el arreglo de salida A.

La salida A no incluye las propiedades de la tabla en T.Properties.

• Si T es una tabla con nombres de fila, A no incluye los nombres de las filas.

• Si T es un horario, A no incluye las horas de las filas.

Ejemplos

Convertir una tabla de datos numéricos en un arreglo

Cree una tabla, T, que conste de datos numéricos.

T = table([1;2;3],[2 8; 4 10; 6 12],[3 12 21; 6 15 24; 9 18 27],...
    'VariableNames',["One" "Two" "Three"])

T=3×3 table
    One      Two          Three    
    ___    _______    _____________

     1     2     8    3    12    21
     2     4    10    6    15    24
     3     6    12    9    18    27

Convierta la tabla, T, en un arreglo.

A = table2array(T)

A = 3×6

     1     2     8     3    12    21
     2     4    10     6    15    24
     3     6    12     9    18    27

A contiene dos columnas de la variable Two y tres columnas de la variable Three.

Convertir un subconjunto numérico de una tabla en un arreglo

Defina el subconjunto numérico de una tabla para convertirlo en un arreglo.

Cree una tabla con datos no numéricos en la primera variable.

T = table(categorical(["Y";"Y";"N";"N";"F"]),[38;43;38;40;49],...
    [71;69;64;67;64],[176;163;131;133;119],...
    'VariableNames',["Smoker" "Age" "Height" "Weight"])

T=5×4 table
    Smoker    Age    Height    Weight
    ______    ___    ______    ______

      Y       38       71       176  
      Y       43       69       163  
      N       38       64       131  
      N       40       67       133  
      F       49       64       119  

Convierta T(:,2:4) en un arreglo.

A = table2array(T(:,2:4))

A = 5×3

    38    71   176
    43    69   163
    38    64   131
    40    67   133
    49    64   119

A no incluye datos de la variable Smoker.

Convertir una tabla con variables tridimensionales en un arreglo

Cree una tabla, T, con dos filas y tres variables donde cada variable tenga tres dimensiones.

T = table(ones(2,1,3),2*ones(2,2,3),3*ones(2,3,3),...
    'VariableNames',["One" "Two" "Three"])

T=2×3 table
        One             Two            Three    
    ____________    ____________    ____________

    1×1×3 double    1×2×3 double    1×3×3 double
    1×1×3 double    1×2×3 double    1×3×3 double

El tamaño de la tabla es 2 por 3.

Convierta la tabla T en un arreglo.

A = table2array(T)

A = 
A(:,:,1) =

     1     2     2     3     3     3
     1     2     2     3     3     3


A(:,:,2) =

     1     2     2     3     3     3
     1     2     2     3     3     3


A(:,:,3) =

     1     2     2     3     3     3
     1     2     2     3     3     3

El tamaño de A es 2 por 6 por 3.

Argumentos de entrada

T — Tabla de entrada

tabla | horario

Tabla de entrada, especificada como tabla u horario. Todas las variables en T deben tener tamaños y tipos de datos compatibles para concatenación horizontal. En concreto, el tamaño de todas las dimensiones de las variables mayor que 2 debe coincidir.

• Si T es una tabla u horario de m por n con variables que tienen una columna cada una, cada variable se convierte en una columna en A, y A es un arreglo de m por n.

• Si T contiene variables que constan de más de una columna, las variables se convierten en múltiples columnas en A, y el tamaño de A es mayor que el tamaño de T.

• Si T contiene variables con más de dos dimensiones, el número de dimensiones de A es igual que el número de dimensiones de las variables.

Sugerencias

• table2array concatena horizontalmente las variables en T para crear A. Si las variables en T son arreglos de celdas, table2array no concatena sus contenidos, y A es un arreglo de celdas equivalente a table2cell(T). Para crear un arreglo que contenga los contenidos de las variables que son todas arreglos de celdas, utilice cell2mat(table2cell(T)).

• Estas sintaxis devuelven el mismo arreglo como table2array(T).

  • T{:,:}

  • T.Variables, cuando el nombre de la segunda dimensión de la tabla es el nombre predeterminado, 'Variables'

  • T.(T.Properties.DimensionNames{2}), cuando el nombre de la segunda dimensión de la tabla no es 'Variables'

Algoritmos

Si T contiene variables con distintos tipos de datos que son compatibles para concatenación horizontal, table2array crea un arreglo homogéneo, A, del tipo de datos dominante. Por ejemplo, si T contiene datos numéricos double y single, table2array(T) devuelve un arreglo con un tipo de datos single.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

La función table2array es totalmente compatible con los arreglos altos. Para obtener más información, consulte Arreglos altos.

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• En código generado, los nombres de las variables de tabla deben ser constantes cuando se utiliza esta función. Para obtener más información, consulte Code Generation for Tables (MATLAB Coder) y Table Limitations for Code Generation (MATLAB Coder).

Entorno basado en subprocesos
Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

Esta función es totalmente compatible con los arreglos distribuidos. Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido en R2013b

Consulte también

array2table | table2cell | table2struct | table

Temas

• Concatenating Objects of Different Classes