Compartir a través de


Collections.Array (Módulo de F#)

Proporciona operaciones básicas con matrices.

Espacio de nombres/Ruta de acceso del módulo: Microsoft.FSharp.Collections

Ensamblado: FSharp.Core (en FSharp.Core.dll)

module Array

Comentarios

Para obtener información general sobre las matrices en F#, vea Matrices (F#).

Valores

Valor

Descripción

append : 'T [] -> 'T [] -> 'T []

Crea una matriz que contiene los elementos de una matriz, seguidos de los elementos de otra matriz.

average : ^T [] -> ^T

Devuelve el promedio de los elementos de una matriz.

averageBy : ('T -> ^U) -> 'T [] -> ^U

Devuelve el promedio de los elementos que se genera aplicando una función a cada uno de los elementos de una matriz.

blit : 'T [] -> int -> 'T [] -> int -> int -> unit

Lee un intervalo de elementos de una matriz y los escribe en otra.

choose : ('T ->'U option) -> 'T [] -> 'U []

Aplica una función proporcionada a cada elemento de una matriz. Devuelve una matriz que contiene los resultados x de cada elemento para el que la función devuelve Some(x).

collect : ('T -> 'U []) -> 'T [] -> 'U []

Aplica la función especificada a cada elemento de una matriz, concatena los resultados y devuelve la matriz combinada.

concat : seq<'T []> -> 'T []

Crea una matriz que contiene los elementos de cada secuencia de matrices proporcionada.

copy : 'T -> 'T []

Crea una matriz que contiene los elementos de la matriz proporcionada.

create : int -> 'T -> 'T []

Crea una matriz cuyos elementos son todos inicialmente el valor proporcionado.

empty : 'T []

Devuelve una matriz vacía del tipo especificado.

exists : ('T -> bool) -> 'T [] -> bool

Comprueba si alguno de los elementos de una matriz cumple el predicado especificado.

exists2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool

Comprueba si algún par de elementos correspondientes de dos matrices cumple el predicado especificado.

fill : 'T [] -> int -> int -> 'T -> unit

Rellena un intervalo de elementos de una matriz con el valor proporcionado.

filter : ('T -> bool) -> 'T [] -> 'T []

Devuelve una colección que contiene solamente los elementos de la matriz proporcionada para la que la condición especificada devuelve true.

find : ('T -> bool) -> 'T [] -> 'T

Devuelve el primer elemento para el cual la función suministrada devuelve true Se produce la excepción KeyNotFoundException si no existe ese elemento.

findIndex : ('T -> bool) -> 'T [] -> int

Devuelve el índice del primer elemento de una matriz que cumple la condición proporcionada. Produce la excepción KeyNotFoundException si ninguno de los elementos cumple la condición.

fold : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State

Aplica una función a cada elemento de una matriz y subprocesa un argumento acumulador durante el cálculo. Si la función de entrada es f y los elementos de la matriz son i0...iN, esta función calcula f (...(f s i0)...) iN.

fold2 : ('State -> 'T1 -> 'T2 -> 'State) -> 'State -> 'T1 [] -> 'T2 [] -> 'State

Aplica una función a pares de elementos de dos matrices proporcionadas, de izquierda a derecha, y subprocesa un argumento acumulador durante el cálculo. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

foldBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State

Aplica una función a cada elemento de una matriz y subprocesa un argumento acumulador durante el cálculo. Si la función de entrada es f y los elementos de la matriz son i0...iN, esta función calcula f i0 (...(f iN s)).

foldBack2 : ('T1 -> 'T2 -> 'State -> 'State) -> 'T1 [] -> 'T2 [] -> 'State -> 'State

Aplica una función a pares de elementos de dos matrices proporcionadas, de derecha a izquierda, y subprocesa un argumento acumulador durante el cálculo. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

forall : ('T -> bool) -> 'T [] -> bool

Comprueba si todos los elementos de una matriz cumplen la condición especificada.

forall2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool

Comprueba si todos los elementos correspondientes de dos matrices proporcionadas cumplen una condición especificada.

get : 'T [] -> int -> 'T

Obtiene un elemento de una matriz.

init : int -> (int -> 'T) -> 'T []

Utiliza una función especificada para crear una matriz de la dimensión proporcionada.

isEmpty : 'T [] -> bool

Comprueba si una matriz tiene elementos.

iter : ('T -> unit) -> 'T [] -> unit

Aplica la función proporcionada a cada elemento de una matriz.

iter2 : ('T1 -> 'T2 -> unit) -> 'T1 [] -> 'T2 [] -> unit)

Aplica la función especificada a un par de elementos de los índices correspondientes de dos matrices. Las dos matrices deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

iteri : (int -> 'T -> unit) -> 'T [] -> unit

Aplica la función proporcionada a cada elemento de una matriz. El entero que se pasa a la función indica el índice del elemento.

iteri2 : (int -> 'T1 -> 'T2 -> unit) -> 'T1 [] -> 'T2 [] -> unit

Aplica la función especificada a un par de elementos de los índices correspondientes de dos matrices y pasa también el índice de los elementos. Las dos matrices deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

length : 'T [] -> int

Devuelve la longitud de una matriz. La propiedad Length tendrá el mismo efecto.

map : ('T -> 'U) -> 'T [] -> 'U []

Crea una matriz cuyos elementos son los resultados de aplicar la función proporcionada a cada uno de los elementos de una matriz especificada.

map2 : ('T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []

Crea una matriz cuyos elementos son los resultados de aplicar la función proporcionada a los elementos correspondientes de dos matrices especificadas. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

mapi : (int -> 'T -> 'U) -> 'T [] -> 'U []

Crea una matriz cuyos elementos son los resultados de aplicar la función proporcionada a cada uno de los elementos de una matriz especificada. Un índice de entero que se pasa a la función señala el índice del elemento que se va a transformar.

mapi2 : (int -> 'T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []

Crea una matriz cuyos elementos son el resultado de aplicar la función proporcionada a los elementos correspondientes de las dos colecciones en pares y también pasa el índice de los elementos. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

max : 'T [] -> 'T

Devuelve el mayor de todos los elementos de una matriz. Operators.max se usa para comparar los elementos.

maxBy : ('T -> 'U) -> 'T [] -> 'T

Devuelve el mayor de todos los elementos de una matriz, comparados mediante Operators.max en el resultado de la función.

min : ('T [] -> 'T

Devuelve el menor de todos los elementos de una matriz. Operators.min se usa para comparar los elementos.

minBy : ('T -> 'U) -> 'T [] -> 'T

Devuelve el menor de todos los elementos de una matriz. Operators.min se usa para comparar los elementos.

ofList : 'T list -> 'T []

Crea una matriz a partir de la lista especificada.

ofSeq : seq<'T> -> 'T []

Crea una matriz a partir del objeto enumerable especificado.

partition : ('T -> bool) -> 'T [] -> 'T [] * 'T []

Divide una matriz en dos distintas, una que contiene los elementos para los que la condición proporcionada devuelve true y otra que contiene aquellos para los que devuelve false.

permute : (int -> int) -> 'T [] -> 'T []

Permuta los elementos de una matriz según la permutación especificada.

pick : ('T -> 'U option) -> 'T [] -> 'U

Aplica la función especificada a elementos sucesivos de una matriz dada y devuelve el primer resultado para el cual la función devuelve Some(x) para algunos resultados x. Si la función nunca devuelve Some(x), se producirá una excepción KeyNotFoundException.

reduce : ('T -> 'T -> 'T) -> 'T [] -> 'T

Aplica una función a cada elemento de una matriz y subprocesa un argumento acumulador durante el cálculo. Si la función de entrada es f y los elementos de la matriz son i0...iN, esta función calcula f (...(f i0 i1)...) iN. Se produce una excepción ArgumentException si la matriz tiene un tamaño cero.

reduceBack : ('T -> 'T -> 'T) -> 'T [] -> 'T

Aplica una función a cada elemento de una matriz y subprocesa un argumento acumulador durante el cálculo. Si la función de entrada es f y los elementos son i0...iN, esta función calcula f i0 (...(f iN-1 iN)). Se produce una excepción ArgumentException si la matriz tiene un tamaño cero.

rev : 'T [] -> 'T []

Invierte el orden de los elementos en una matriz proporcionada.

scan : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State [])

Se comporta como fold, pero devuelve los resultados intermedios junto con los finales.

scanBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State []

Se comporta como foldBack, pero devuelve los resultados intermedios junto con los finales.

set : 'T [] -> int -> 'T -> unit

Establece un elemento de una matriz.

sort : 'T[] -> 'T []

Ordena los elementos de una matriz y devuelve una nueva matriz. Operators.compare se usa para comparar los elementos.

sortBy : ('T -> 'Key) -> 'T [] -> 'T []

Ordena los elementos de una matriz usando la función proporcionada para transformar dichos elementos en el tipo en el que se basa la operación de ordenación y devuelve una nueva matriz. Operators.compare se usa para comparar los elementos.

sortInPlace : 'T [] -> unit

Ordena los elementos de una matriz cambiando la matriz de lugar, usando la función de comparación. Operators.compare se usa para comparar los elementos.

sortInPlaceBy : ('T -> 'Key) -> 'T [] -> unit

Ordena los elementos de una matriz cambiando la matriz en contexto y con la proyección suministrada para las claves. Operators.compare se usa para comparar los elementos.

sortInPlaceWith : ('T -> 'T -> int) -> 'T [] -> unit

Ordena los elementos de una matriz usando la función de comparación proporcionada para cambiar la matriz en contexto.

sortWith : ('T -> 'T -> int) -> 'T [] -> 'T []

Ordena los elementos de una matriz usando la función de comparación proporcionada y devuelve una nueva matriz.

sub : 'T [] -> int -> int -> 'T []

Crea una matriz que contiene el subintervalo proporcionado, especificado por el índice de inicio y la longitud.

sum : 'T [] -> ^T

Devuelve la suma de los elementos de la matriz.

sumBy : ('T -> ^U) -> 'T [] -> ^U

Devuelve la suma de los resultados que se generan aplicando la función a cada uno de los elementos de una matriz.

toList : 'T [] -> 'T list

Convierte la matriz proporcionada en una lista.

toSeq : 'T [] -> seq<'T>

Muestra la matriz especificada como secuencia.

tryFind : ('T -> bool) -> 'T [] -> 'T option

Devuelve el primer elemento de la matriz proporcionada para el que la función especificada devuelve true. Si no existe ningún elemento, devuelve None.

tryFindIndex : ('T -> bool) -> 'T [] -> int option

Devuelve el índice del primer elemento de una matriz que cumple la condición proporcionada.

tryPick : ('T -> 'U option) -> 'T [] -> 'U option

Aplica la función especificada a elementos sucesivos de la matriz dada y devuelve el primer resultado para el cual la función devuelve Some(x) para algunos resultados x. Si la función nunca devuelve Some(x), se devolverá None.

unzip : ('T1 * 'T2) [] -> 'T1 [] * 'T2 []

Divide una matriz de pares de tupla en una tupla de dos matrices.

unzip3 : ('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []

Divide una matriz de tuplas de tres elementos en una tupla de tres matrices.

zeroCreate : int -> 'T []

Crea una matriz cuyos elementos se establecen inicialmente en el valor predeterminado Unchecked.defaultof<'T>.

zip : 'T1 [] -> 'T2 [] -> ('T1 * 'T2) []

Combina dos matrices en una matriz de tuplas con dos elementos. Las dos matrices deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

zip3 : 'T1 [] -> 'T2 [] -> 'T3 [] -> ('T1 * 'T2 * 'T3) []

Combina tres matrices en una matriz de tuplas con tres elementos. Las tres matrices deben tener la misma longitud; de lo contrario, se producirá una excepción ArgumentException.

Plataformas

Windows 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Información de versiones

Runtime de F#

Se admite en las versiones: 2.0, 4.0

Silverlight

Se admite en la versión: 3

Vea también

Referencia

Microsoft.FSharp.Collections (Espacio de nombres de F#)

Array

Collections.Array2D (Módulo de F#)

Collections.Array3D (Módulo de F#)

Collections.Array4D (Módulo de F#)

Otros recursos

Matrices (F#)