En programación informática , la segmentación de matrices es una operación que extrae un subconjunto de elementos de una matriz y los empaqueta como otra matriz, posiblemente en una dimensión diferente de la original.
Algunos ejemplos comunes de segmentación de matrices son la extracción de una subcadena de una cadena de caracteres, el " ell " en "h ell o", la extracción de una fila o columna de una matriz bidimensional o la extracción de un vector de una matriz .
Según el lenguaje de programación , una porción de matriz puede estar formada por elementos no consecutivos. También, según el lenguaje, los elementos de la nueva matriz pueden tener alias (es decir, compartir memoria con) los de la matriz original.
En el caso de matrices "unidimensionales" (de índice único) (vectores, secuencias, cadenas, etc.), la operación de segmentación más común es la extracción de cero o más elementos consecutivos. Por lo tanto, si tenemos un vector que contiene los elementos (2, 5, 7, 3, 8, 6, 4, 1) y queremos crear una segmentación de matriz desde el tercer elemento hasta el sexto, obtenemos (7, 3, 8, 6). En los lenguajes de programación que utilizan un esquema de indexación basado en 0, la segmentación sería desde el índice 2 hasta el 5 .
Reducir el rango de cualquier índice a un único valor elimina efectivamente ese índice. Esta característica se puede utilizar, por ejemplo, para extraer porciones unidimensionales (vectores: en 3D, filas, columnas y tubos [1] ) o porciones bidimensionales (matrices rectangulares) de una matriz tridimensional. Sin embargo, dado que el rango se puede especificar en tiempo de ejecución, los lenguajes con verificación de tipos pueden requerir una notación explícita (en tiempo de compilación) para eliminar realmente los índices triviales.
La segmentación general de matrices se puede implementar (ya sea que esté o no incorporada en el lenguaje) haciendo referencia a cada matriz a través de un vector dope o descriptor : un registro que contiene la dirección del primer elemento de la matriz y luego el rango de cada índice y el coeficiente correspondiente en la fórmula de indexación. Esta técnica también permite la transposición inmediata de matrices , la inversión de índices, el submuestreo, etc. Para lenguajes como C , donde los índices siempre comienzan en cero, el vector dope de una matriz con d índices tiene al menos 1 + 2 d parámetros. Para lenguajes que permiten límites inferiores arbitrarios para los índices, como Pascal , el vector dope necesita 1 + 3 d entradas.
Si la abstracción de matriz no admite índices negativos verdaderos (como, por ejemplo, las matrices de Ada y Pascal ), a veces se utilizan índices negativos para los límites de la porción de una dimensión determinada para especificar un desplazamiento desde el final de la matriz en esa dimensión. En los esquemas basados en 1, -1 generalmente indicaría el penúltimo elemento, mientras que en un sistema basado en 0, significaría el último elemento.
El concepto de segmentación seguramente ya se conocía antes de la invención de los compiladores . La segmentación como característica del lenguaje probablemente comenzó con FORTRAN (1957), más como consecuencia de la inexistencia de comprobación de tipos y rangos que por diseño. El concepto también se mencionaba en el informe preliminar para el IAL (ALGOL 58) en el sentido de que la sintaxis permitía omitir uno o más índices de un elemento de matriz (o, en este sentido, de una llamada a un procedimiento) cuando se utilizaba como parámetro real.
El APL de Kenneth Iverson (1957) tenía un corte de matriz multidimensional muy flexible, lo que contribuyó mucho al poder expresivo y a la popularidad del lenguaje.
ALGOL 68 (1968) introdujo funciones integrales de corte y recorte de matrices multidimensionales.
Las funciones de segmentación de matrices se han incorporado en varios lenguajes modernos, como Ada 2005 , Cobra , D , Fortran 90 , Go , Rust , Julia , MATLAB , Perl , Python , S-Lang , Windows PowerShell y los lenguajes matemáticos/estadísticos GNU Octave , S y R.
PL/I proporciona dos facilidades para dividir matrices.
Ycomo una porción unidimensional que consiste en los elementos diagonales de la matriz bidimensional X.DECLARE X(5,5);
DECLARE Y(5) DEFINED(X(1SUB,1SUB));
Una referencia a Y(2)es una referencia a X(2,2), y así sucesivamente.
X , de una matriz utilizando un asterisco como subíndice para una o más dimensiones. El código siguiente establece todos los elementos de la primera columna de a cero. Se pueden especificar uno o más subíndices mediante asteriscos en una expresión. [2] : p.43 DECLARE X(5,5);
X(*,1)=0;
Los programadores de Fortran 66 sólo pudieron aprovechar la división de matrices por filas, y sólo al pasar esa fila a una subrutina :
SUBRUTINA IMPRESIÓN V ( VEC , LEN ) REAL VEC ( * ) IMPRESIÓN * , ( VEC ( I ), I = 1 , LEN ) FINAL PARÁMETRO PRINCIPAL DEL PROGRAMA ( LEN = 3 ) MATRIZ REAL ( LEN , LEN ) MATRIZ DE DATOS / 1 , 1 , 1 , 2 , 4 , 8 , 3 , 9 , 27 / LLAMAR PRINT V ( MATRIZ ( 1 , 2 ), LEN ) FIN Resultado:
2.000000 4.000000 8.000000
Tenga en cuenta que no existe un vector dope en FORTRAN 66, por lo tanto, la longitud de la porción también debe pasarse como argumento (o algún otro medio) al SUBROUTINE. En la década de 1970, Pascal y C tenían restricciones similares.
El informe final de Algol68 contiene un ejemplo temprano de segmentación; las segmentaciones se especifican en el formato:
[límite inferior:límite superior] ¢ para computadoras con conjuntos de caracteres extendidos ¢
o:
(LÍMITE INFERIOR...LÍMITE SUPERIOR) # PARA COMPUTADORAS CON SOLO CARACTERES DE 6 BITS. #
Ambos límites son inclusivos y se pueden omitir, en cuyo caso se establecen de forma predeterminada como los límites de la matriz declarada. Ni la función de paso ni los alias de corte diagonal forman parte del informe revisado.
Ejemplos:
[3, 3]real a := ((1, 1, 1), (2, 4, 8), (3, 9, 27)); # declaración de una matriz variable # [,] real c = ((1, 1, 1), (2, 4, 8), (3, 9, 27)); # matriz constante, el tamaño está implícito #
ref[]real row := a[2,]; # alias/ referencia a una porción de fila # ref[]real col2 = a[, 2]; # alias permanente/ referencia a la segunda columna #
print ((a[:, 2], newline)); # segunda porción de columna # print ((a[1⌈a, :], newline)); # última porción de fila # print ((a[:, 2⌈a], newline)); # última porción de columna # print ((a[:2, :2], newline)); # "porción" inicial de submatriz de 2 por 2 #
+1,0000 10 +0 +4,0000 10 +0 +9,0000 10 +0+3.0000 10 +0 +9.0000 10 +0 +2.7000 10 +1+1,0000 10 +0 +8,0000 10 +0 +2,7000 10 +1+1,0000 10 +0 +1,0000 10 +0 +2,0000 10 +0 +4,0000 10 +0
Los sistemas HP 2000 de HP , introducidos en noviembre de 1968, utilizaban HP Time-Shared BASIC como su interfaz principal y lenguaje de programación. Esta versión de BASIC utilizaba la segmentación para la mayoría de las operaciones de manipulación de cadenas. Una rareza del lenguaje era que permitía el uso indistintamente de llaves y corchetes, y en la práctica, el tipo de llave que se utilizaba dependía normalmente del terminal de ordenador que se utilizase.
Ejemplo:
10 A$ = "HOLA, MUNDO" 20 IMPRIMIR A$ ( 1 , 5 ) 30 IMPRIMIR A$ [ 7 , 11 ] Producirá:
HOLAMUNDO
Los sistemas HP se utilizaron ampliamente a principios de la década de 1970, especialmente en escuelas técnicas secundarias y muchos entornos científicos e industriales pequeños. [3] Cuando surgieron las primeras microcomputadoras a mediados de la década de 1970, HP también se utilizó a menudo como patrón para sus dialectos BASIC. Entre los ejemplos notables se incluyen Apple BASIC de 1977 , Atari BASIC de 1978 y Sinclair BASIC de 1979. Este estilo de manipulación generalmente ofrece ventajas en términos de uso de memoria y a menudo se eligió en sistemas que se entregaban con pequeñas cantidades de memoria. Solo el dialecto de Sinclair difería de alguna manera significativa, utilizando la TOpalabra clave en lugar de una lista separada por comas:
10 LET a$ = "ABCDE" ( 2 a 4 ) 20 PRINT a$ La segmentación también fue seleccionada como base para el estándar ANSI Full BASIC , utilizando dos puntos como separador y diferenciando así entre segmentación y acceso a matriz:
10 DIM A$ ( 5 ) 20 LET A$ ( 2 ) = "HOLA, MUNDO" 30 PRINT A$ ( 2 )( 1 : 5 ) Si bien este estilo de acceso ofrecía una serie de ventajas, especialmente para las máquinas pequeñas de la época, en algún momento después de 1970, Digital Equipment Corporation introdujo su propia variante de BASIC que utilizaba las funciones LEFT$, RIGHT$y string. Microsoft BASIC se escribió en el PDP-10 y su BASIC se utilizó como patrón. A fines de la década de 1970, ambos estilos se usaban ampliamente, pero a principios de la década de 1980, las funciones de estilo DEC eran el estándar de facto .MID$
> A = round ( rand ( 3 , 4 , 5 ) * 10 ) % matriz tridimensional o cúbica de 3x4x5 > A (:, :, 3 ) % matriz bidimensional de 3x4 a lo largo de la primera y la segunda dimensiónrespuesta = 8 3 5 7 8 9 1 4 4 4 2 5> Una matriz bidimensional (:, 2 : 3 , 3 ) % 3x2 a lo largo de la primera y la segunda dimensión respuesta = 3 5 9 1 4 2> Una matriz bidimensional ( 2 : fin , :, 3 ) % 2x4 que utiliza la palabra clave 'fin'; funciona con GNU Octave 3.2.4 respuesta = 6 1 4 6 10 1 3 1> Una matriz unidimensional ( 1 , :, 3 ) % a lo largo de la segunda dimensión respuesta = 8 3 5 7> A ( 1 , 2 , 3 ) % valor único ans = 3Las matrices en S y GNU R siempre se basan en uno, por lo que los índices de una nueva porción comenzarán con uno para cada dimensión, independientemente de los índices anteriores. Las dimensiones con una longitud de uno se eliminarán (a menos que drop = FALSE). Los nombres de las dimensiones (si están presentes) se conservarán.
> A <- array ( 1 : 60 , dim = c ( 3 , 4 , 5 )) # Matriz tridimensional o cúbica de 3x4x5 > A [, , 3 ] # Matriz bidimensional de 3x4 a lo largo de la primera y segunda dimensión [, 1] [, 2] [, 3] [, 4] [1,] 25 28 31 34 [2,] 26 29 32 35 [3,] 27 30 33 36 > A [, 2 : 3 , 3 , drop = FALSE ] # Subconjunto de la matriz cúbica de 3x2x1 (dimensiones conservadas) , , 1 [, 1] [, 2] [1,] 28 31 [2,] 29 32 [3,] 30 33 > A [, 2 , 3 ] # matriz unidimensional a lo largo de la primera dimensión [1] 28 29 30 > A [ 1 , 2 , 3 ] # valor único [1] 28 El estándar Fortran 77 introdujo la capacidad de cortar y concatenar cadenas:
PROGRAMA PRINCIPAL IMPRESIÓN * , 'ABCDE' ( 2 : 4 ) FIN Produce:
BCD
Estas cadenas se podrían pasar por referencia a otra subrutina, y la longitud también se pasaría de forma transparente a la subrutina como una especie de vector corto .
SUBRUTINA IMPRESIÓN S ( STR ) CARÁCTER * ( * ) STR IMPRESIÓN * , STR FIN PROGRAMA PRINCIPAL LLAMADA IMPRIMIR S ( 'ABCDE' ( 2 : 4 )) FIN Produce nuevamente:
BCD
Ada 83 admite segmentos para todos los tipos de matrices. Al igual que Fortran 77, dichas matrices se pueden pasar por referencia a otra subrutina; la longitud también se puede pasar de forma transparente a la subrutina como una especie de vector de información breve .
con Text_IO ; procedimiento Principal es Texto : Cadena := " ABCDE " ; inicio Texto_IO.Put_Line ( Texto ( 2..4 ) ) ; fin Principal ; Produce:
BCD
Nota: Dado que en Ada los índices se basan en n, el término Text (2 .. 4)dará como resultado una matriz con el índice base de 2.
La definición de Text_IO.Put_Linees:
El paquete Ada.Text_IO es procedimiento Put_Line ( Elemento : en String );La definición de Stringes:
El paquete estándar es subtipo Positivo es Entero rango 1 .. Entero ' Último ; tipo String es una matriz ( rango positivo <>) de caracteres ; pragma Pack ( String ); Como Ada admite índices negativos verdaderos, type History_Data_Array is array (-6000 .. 2010) of History_Data;no les da ningún significado especial. En el ejemplo anterior, el término Some_History_Data (-30 .. 30)dividiría el año History_Datadesde el 31 a. C. hasta el 30 d. C. (ya que no había año cero, el año número 0 en realidad se refiere al año 1 a. C. ).
Si tenemos
@a = ( 2 , 5 , 7 , 3 , 8 , 6 , 4 ); Como arriba, entonces los primeros 3 elementos, los 3 elementos del medio y los 3 últimos elementos serían:
@a [ 0 .. 2 ]; # (2, 5, 7) @a [ 2 .. 4 ]; # (7, 3, 8) @a [ - 3 ..- 1 ]; # (8, 6, 4) Perl admite índices de lista negativos. El índice -1 es el último elemento, el -2 el penúltimo, etc. Además, Perl admite la segmentación basada en expresiones, por ejemplo:
@a [ 3 .. $#a ]; # 4to elemento hasta el final (3, 8, 6, 4) @a [ grep { ! ( $_ % 3 ) } ( 0 ... $#a ) ]; # 1er, 4to y 7mo elemento (2,3,4) @a [ grep { ! (( $_ + 1 ) % 3 ) } ( 0 .. $#a ) ]; # cada 3er elemento (7,6) Si tienes la siguiente lista:
>>> números = [ 1 , 3 , 5 , 7 , 8 , 13 , 20 ]Luego es posible realizar el corte utilizando una notación similar a la recuperación de elementos:
>>> nums [ 3 ] # sin cortes 7 >>> nums [: 3 ] # desde el índice 0 (incluido) hasta el índice 3 (excluido) [1, 3, 5] >>> nums [ 1 : 5 ] [3, 5, 7, 8] >>> nums [ - 3 :] [8, 13, 20]Tenga en cuenta que Python permite índices de lista negativos. El índice -1 representa el último elemento, -2 el penúltimo elemento, etc. Python también permite una propiedad de paso agregando dos puntos adicionales y un valor. Por ejemplo:
>>> nums [ 3 :] [7, 8, 13, 20] >>> nums [ 3 ::] # == nums[3:] [7, 8, 13, 20] >>> nums [:: 3 ] # comenzando en el índice 0 y obteniendo cada tercer elemento [1, 7, 20] >>> nums [ 1 : 5 : 2 ] # desde el índice 1 hasta el índice 5 y obteniendo cada segundo elemento [3, 7]La sintaxis stride ( nums[1:5:2]) se introdujo en la segunda mitad de la década de 1990, como resultado de las solicitudes presentadas por los usuarios científicos en el "matrix-SIG" (grupo de interés especial) de Python. [4]
La semántica de las porciones puede diferir según el objeto; se puede introducir una nueva semántica cuando se sobrecarga el operador de indexación. Con las listas estándar de Python (que son matrices dinámicas ), cada porción es una copia. Las porciones de matrices NumPy , por el contrario, son vistas del mismo búfer subyacente.
En Fortran 90, las porciones se especifican en la forma
límite inferior : límite superior [: paso ]Ambos límites son inclusivos y se pueden omitir, en cuyo caso, el valor predeterminado es el límite de la matriz declarada. El valor predeterminado de Stride es 1. Ejemplo:
real , dimensión ( m , n ) :: a ! declaración de una matriz print * , a (:, 2 ) ! segunda columna print * , a ( m , :) ! última fila print * , a (: 10 , : 10 ) ! submatriz inicial de 10 por 10 Cada dimensión de un valor de matriz en Analytica se identifica mediante una variable de índice. Al dividir o crear subíndices, la sintaxis identifica las dimensiones sobre las que se está fragmentando o creando subíndices nombrando la dimensión. Por ejemplo:
Índice I := 1..5 { Definición de un índice numérico }Índice J := ['A', 'B', 'C'] { Definición de un índice con valor de texto }Variable X := Array(I, J, [[10, 20, 30], [1, 2, 3], ....]) { Definición de un valor 2D }X[I = 1, J = 'B'] -> 20 { Subíndice para obtener un único valor }X[I = 1] -> Array(J, [10, 20, 30]) { Divide una matriz 1D. }X[J = 2] -> Array(I, [20, 2, ....]) { Divide una matriz 1D en la otra dimensión. }X[I = 1..3] {Separa los primeros cuatro elementos sobre I con todos los elementos sobre J}La asignación de nombres a los índices en la segmentación y la subdivisión es similar a la asignación de nombres a los parámetros en las llamadas a funciones en lugar de depender de una secuencia fija de parámetros. Una ventaja de la asignación de nombres a los índices en la segmentación es que el programador no tiene que recordar la secuencia de índices en una matriz multidimensional. Una ventaja más profunda es que las expresiones se generalizan de forma automática y segura sin necesidad de volver a escribirlas cuando cambia el número de dimensiones de X.
La segmentación de matrices se introdujo en la versión 1.0. Las versiones anteriores no admitían esta función.
Supongamos que A es una matriz unidimensional tal como
A = [1:50]; % A = [1, 2, 3, ...49, 50]
Luego se puede crear una matriz B de los primeros 5 elementos de A usando
B = A[[:4]];
De manera similar, B puede asignarse a una matriz de los últimos 5 elementos de A mediante:
B = A[[-5:]];
Otros ejemplos de corte 1-d incluyen:
A[-1] % El último elemento de A A[*] % Todos los elementos de A A[[::2]] % Todos los elementos pares de A A[[1::2]] % Todos los elementos impares de A A[[-1::-2]] % Todos los elementos pares en orden inverso A[[[0:3], [10:14]]] % Elementos 0-3 y 10-14
La segmentación de matrices de dimensiones superiores funciona de manera similar:
A[-1, *] % La última fila de A A[[1:5], [2:7]] % Matriz 2d que utiliza las filas 1 a 5 y las columnas 2 a 7 A[[5:1:-1], [2:7]] % Igual que el anterior excepto que las filas están invertidas
Los índices de matriz también pueden ser matrices de números enteros. Por ejemplo, supongamos que I = [0:9]es una matriz de 10 números enteros. Entonces A[I]es equivalente a una matriz de los primeros 10 elementos de A. Un ejemplo práctico de esto es una operación de ordenamiento como:
I = array_sort(A); % Obtener una lista de índices de ordenación B = A[I]; % B es la versión ordenada de A C = A[array_sort(A)]; % Igual que el anterior pero más conciso.
Considere la matriz:
int [] a = [ 2 , 5 , 7 , 3 , 8 , 6 , 4 , 1 ]; Toma un trocito de ello:
int [ ] b = a [ 2..5 ] ; y el contenido de bserá [7, 3, 8]. El primer índice de la porción es inclusivo, el segundo es exclusivo.
auto c = a [$ -4 .. $ - 2 ] ; significa que la matriz dinámica cahora contiene [8, 6]porque dentro de [] el $símbolo se refiere a la longitud de la matriz.
Las porciones de la matriz D tienen un alias con respecto a la matriz original, por lo que:
b [ 2 ] = 10 ; significa que aahora tiene el contenido [2, 5, 7, 3, 10, 6, 4, 1]. Para crear una copia de los datos de la matriz, en lugar de solo un alias, haga lo siguiente:
auto b = a [ 2 .. 5 ]. dup ; A diferencia de Python, los límites de las porciones de D no se saturan, por lo que el código equivalente a este código de Python es un error en D:
>>> d = [ 10 , 20 , 30 ] >>> d [ 1 : 5 ] [20, 30]El lenguaje de programación SuperCollider implementa algunos conceptos de J / APL . El corte se ve de la siguiente manera:
a = [ 3 , 1 , 5 , 7 ] // asigna un array a la variable a a [ 0 .. 1 ] // devuelve los dos primeros elementos de a a [.. 1 ] // devuelve los dos primeros elementos de a: se puede omitir el cero a [ 2 ..] // devuelve el elemento 3 hasta el último a [[ 0 , 3 ]] // devuelve el primer y el cuarto elemento de aa [[ 0 , 3 ]] = [ 100 , 200 ] // reemplaza el primer y el cuarto elemento de a a [ 2 ..] = [ 100 , 200 ] // reemplaza los dos últimos elementos de a// asigna una matriz multidimensional a la variable a a = [[ 0 , 1 , 2 , 3 , 4 ], [ 5 , 6 , 7 , 8 , 9 ], [ 10 , 11 , 12 , 13 , 14 ], [ 15 , 16 , 17 , 18 , 19 ]]; a . slice ( 2 , 3 ); // toma una porción con coordenadas 2 y 3 (devuelve 13) a . slice ( nil , 3 ); // toma una porción ortogonal (devuelve [3, 8, 13, 18])Las matrices en fish siempre están basadas en uno, por lo tanto, los índices de una nueva porción comenzarán con uno , independientemente de los índices anteriores.
> set A ( seq 3 2 11 ) # $A es una matriz con los valores 3, 5, 7, 9, 11 > echo $A [( seq 2 )] # Imprime los dos primeros elementos de $A 3 5 > conjunto B $A [ 1 2 ] # $B contiene el primer y segundo elemento de $A, es decir, 3, 5 > set -e A [ $B ] ; echo $A # Borra el tercer y quinto elemento de $A, imprime $A 3 5 9Cobra admite la segmentación al estilo Python. Si tiene una lista
números = [ 1 , 3 , 5 , 7 , 8 , 13 , 20 ]Entonces los primeros 3 elementos, los 3 elementos del medio y los 3 últimos elementos serían:
nums [: 3 ] # es igual a [1, 3, 5] nums [ 2 : 5 ] # es igual a [5, 7, 8] nums [ - 3 :] # es igual a [8, 13, 20]Cobra también admite la sintaxis de estilo de corte para 'bucles numéricos for':
para i en 2 : 5 imprimir i # imprime 2, 3, 4para j en 3 imprimir j # imprime 0, 1, 2Las matrices están basadas en cero en PowerShell y se pueden definir mediante el operador de coma:
PS> $a = 2 , 5 , 7 , 3 , 8 , 6 , 4 , 1 PS> # Imprime los dos primeros elementos de $a: PS> Write-Host -NoNewline $a [ 0 , 1 ] 2 5 PS> # Toma una porción usando el operador de rango: PS> Write-Host -NoNewline $a [ 2 .. 5 ] 7 3 8 6 PS> # Obtiene los últimos 3 elementos: PS> Write-Host -NoNewline $a [- 3 ..- 1 ] 6 4 1 PS> # Devuelve el contenido de la matriz en orden inverso: PS> Write-Host -NoNewline $a [( $a . Length - 1 ).. 0 ] # Length es una propiedad de System.Object[] 1 4 6 8 3 7 5 2Go admite la sintaxis de estilo Python para segmentar (excepto que no se admiten índices negativos). Se pueden segmentar matrices y segmentos. Si tiene un segmento
números := [] int { 1 , 3 , 5 , 7 , 8 , 13 , 20 } Entonces los primeros 3 elementos, los 3 elementos del medio, los 3 últimos elementos y una copia de la porción completa serían:
nums [: 3 ] // es igual a []int{1, 3, 5} nums [ 2 : 5 ] // es igual a []int{5, 7, 8} nums [ 4 :] // es igual a []int{8, 13, 20} nums [:] // es igual a []int{1, 3, 5, 7, 8, 13, 20} Las porciones en Go son tipos de referencia, lo que significa que diferentes porciones pueden hacer referencia a la misma matriz subyacente.
Cilk Plus admite la sintaxis para la segmentación de matrices como una extensión de C y C++.
matriz_base [ límite_inferior : longitud [ : paso ]] * El corte con Cilk Plus se realiza de la siguiente manera:
A [ : ] // Todo el vector A B [ 2 : 6 ] // Elementos 2 a 7 del vector B C [ : ][ 5 ] // Columna 5 de la matriz C D [ 0 : 3 : 2 ] // Elementos 0, 2, 4 del vector D La segmentación de matrices de Cilk Plus se diferencia de la de Fortran en dos formas:
La segmentación de matrices de Julia es similar a la de MATLAB , pero utiliza corchetes. Ejemplo:
julia> x = rand ( 4 , 3 ) 4x3 Matriz{Float64,2}: 0,323877 0,186253 0,600605 0,404664 0,894781 0,0955007 0,223562 0,18859 0,120011 0,149316 0,779823 0,0690126 julia> x [ : , 2 ] # obtiene la segunda columna. Matriz de 4 elementos{Float64,1}: 0,186253 0,894781 0,18859 0,779823 julia> x [ 1 , : ] # obtener la primera fila. 1x3 Array{Float64,2}: 0.323877 0.186253 0.600605 julia> x [ 1 : 2 , 2 : 3 ] # obtiene la submatriz que abarca las filas 1,2 y las columnas 2,3 2x2 Array{Float64,2}: 0.186253 0.600605 0.894781 0.0955007