F # - Matrices
Las matrices son colecciones mutables de tamaño fijo, basadas en cero, de elementos de datos consecutivos que son todos del mismo tipo.
Crear matrices
Puede crear matrices utilizando varias sintaxis y formas o utilizando las funciones del módulo Matriz. En esta sección, discutiremos la creación de matrices sin usar las funciones del módulo.
Hay tres formas sintácticas de crear matrices sin funciones:
- Listando valores consecutivos entre [| y |] y separados por punto y coma.
- Colocando cada elemento en una línea separada, en cuyo caso el separador de punto y coma es opcional.
- Utilizando expresiones de secuencia.
Puede acceder a los elementos de la matriz utilizando un operador de punto (.) Y corchetes ([y]).
El siguiente ejemplo demuestra la creación de matrices:
//using semicolon separator
let array1 = [| 1; 2; 3; 4; 5; 6 |]
for i in 0 .. array1.Length - 1 do
printf "%d " array1.[i]
printfn" "
// without semicolon separator
let array2 =
[|
1
2
3
4
5
|]
for i in 0 .. array2.Length - 1 do
printf "%d " array2.[i]
printfn" "
//using sequence
let array3 = [| for i in 1 .. 10 -> i * i |]
for i in 0 .. array3.Length - 1 do
printf "%d " array3.[i]
printfn" "Cuando compila y ejecuta el programa, produce el siguiente resultado:
1 2 3 4 5 6
1 2 3 4 5
1 4 9 16 25 36 49 64 81 100Operaciones básicas en matrices
El módulo de biblioteca Microsoft.FSharp.Collections.Array admite operaciones en matrices unidimensionales.
La siguiente tabla muestra las operaciones básicas en matrices:
| Valor | Descripción |
|---|---|
| añadir: 'T [] →' T [] → 'T [] | Crea una matriz que contiene los elementos de una matriz seguidos de los elementos de otra matriz. |
| promedio: ^ T [] → ^ T | Devuelve el promedio de los elementos de una matriz. |
| averageBy: ('T → ^ U) →' T [] → ^ U | Devuelve el promedio de los elementos generados al aplicar una función a cada elemento de una matriz. |
| blit: 'T [] → int →' T [] → int → int → unidad | Lee una variedad de elementos de una matriz y los escribe en otra. |
| elegir: ('T → opción U) →' T [] → 'U [] | Aplica una función proporcionada a cada elemento de una matriz. Devuelve una matriz que contiene los resultados x para cada elemento para el que la función devuelve Some (x). |
| recopilar: ('T →' U []) → T [] → 'U [] | Aplica la función proporcionada 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 una de las secuencias de matrices proporcionadas. |
| copiar: 'T →' T [] | Crea una matriz que contiene los elementos de la matriz proporcionada. |
| crear: int → 'T →' T [] | Crea una matriz cuyos elementos son todos inicialmente el valor proporcionado. |
| vacío: 'T [] | Devuelve una matriz vacía del tipo dado. |
| existe: ('T → bool) →' T [] → bool | Comprueba si algún elemento de una matriz satisface el predicado proporcionado. |
| existe2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool | Comprueba si cualquier par de elementos correspondientes de dos matrices satisface la condición proporcionada. |
| relleno: 'T [] → int → int →' T → unidad | Rellena un rango de elementos de una matriz con el valor proporcionado. |
| filtro: ('T → bool) →' T [] → 'T [] | Devuelve una colección que contiene solo los elementos de la matriz proporcionada para la que devuelve la condición proporcionada true. |
| encontrar: ('T → bool) →' T [] → 'T | Devuelve el primer elemento para el que devuelve la función proporcionada true. Genera KeyNotFoundException si no existe tal elemento. |
| findIndex: ('T → bool) →' T [] → int | Devuelve el índice del primer elemento de una matriz que satisface la condición proporcionada. Genera KeyNotFoundException si ninguno de los elementos satisface la condición. |
| fold: ('State →' T → 'State) →' State → 'T [] →' State | Aplica una función a cada elemento de una matriz, pasando un argumento acumulador a través del cálculo. Si la función de entrada es f y los elementos de la matriz son i0 ... iN, esta función calcula f (... (fs i0) ...) iN. |
| fold2: ('Estado →' T1 → 'T2 →' Estado) → 'Estado →' T1 [] → 'T2 [] →' Estado | Aplica una función a pares de elementos de dos matrices suministradas, de izquierda a derecha, enhebrando un argumento de acumulador a través del cálculo. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
| foldBack: ('T →' Estado → 'Estado) →' T [] → 'Estado →' Estado | Aplica una función a cada elemento de una matriz, pasando un argumento acumulador a través del 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 → 'Estado →' Estado) → 'T1 [] →' T2 [] → 'Estado →' Estado | Aplica una función a pares de elementos de dos matrices suministradas, de derecha a izquierda, enhebrando un argumento de acumulador a través del cálculo. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
| forall: ('T → bool) →' T [] → bool | Comprueba si todos los elementos de una matriz satisfacen la condición proporcionada. |
| forall2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool | Prueba si todos los elementos correspondientes de dos matrices suministradas satisfacen una condición suministrada. |
| obtener: 'T [] → int →' T | Obtiene un elemento de una matriz. |
| init: int → (int → 'T) →' T [] | Utiliza una función proporcionada para crear una matriz de la dimensión proporcionada. |
| isEmpty: 'T [] → bool | Comprueba si una matriz tiene elementos. |
| iter: ('T → unidad) →' T [] → unidad | Aplica la función proporcionada a cada elemento de una matriz. |
| iter2: ('T1 →' T2 → unidad) → 'T1 [] →' T2 [] → unidad) | Aplica la función proporcionada a un par de elementos de índices coincidentes en dos matrices. Las dos matrices deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
| iteri: (int → 'T → unidad) →' T [] → unidad | Aplica la función proporcionada a cada elemento de una matriz. El número entero pasado a la función indica el índice del elemento. |
| iteri2: (int → 'T1 →' T2 → unidad) → 'T1 [] →' T2 [] → unidad | Aplica la función proporcionada a un par de elementos de índices coincidentes en dos matrices, pasando también el índice de los elementos. Las dos matrices deben tener la misma longitud; de lo contrario, se genera una ArgumentException. |
| longitud: 'T [] → int | Devuelve la longitud de una matriz. La propiedad Length hace lo mismo. |
| mapa: ('T →' U) → 'T [] →' U [] | Crea una matriz cuyos elementos son el resultado de aplicar la función proporcionada a cada uno de los elementos de una matriz proporcionada. |
| mapa2: ('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 dos matrices proporcionadas. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
| mapi: (int → 'T →' U) → 'T [] →' U [] | Crea una matriz cuyos elementos son el resultado de aplicar la función proporcionada a cada uno de los elementos de una matriz proporcionada. Un índice entero pasado a la función indica el índice del elemento que se está transformando. |
| 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 por pares, pasando también el índice de los elementos. Las dos matrices de entrada deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
| máx: 'T [] →' T | Devuelve el mayor de todos los elementos de una matriz. Operators.max se utiliza para comparar los elementos. |
| maxBy: ('T →' U) → 'T [] →' T | Devuelve el mayor de todos los elementos de una matriz, comparado a través de Operators.max en el resultado de la función. |
| min: ('T [] →' T | Devuelve el más pequeño de todos los elementos de una matriz. Operators.min se utiliza para comparar los elementos. |
| minBy: ('T →' U) → 'T [] →' T | Devuelve el más pequeño de todos los elementos de una matriz. Operators.min se utiliza para comparar los elementos. |
| ofList: 'T lista →' T [] | Crea una matriz a partir de la lista proporcionada. |
| ofSeq: seq <'T> →' T [] | Crea una matriz a partir del objeto enumerable proporcionado. |
| partición: ('T → bool) →' T [] → 'T [] *' T [] | Divide una matriz en dos matrices, una que contiene los elementos para los que devuelve la condición proporcionada true, y el otro que contiene aquellos por los que devuelve false. |
| permutar: (int → int) → 'T [] →' T [] | Permuta los elementos de una matriz según la permutación especificada. |
| elegir: ('T →' U opción) → 'T [] →' U | Aplica la función proporcionada a los elementos sucesivos de una matriz proporcionada, devolviendo el primer resultado donde la función devuelve Some (x) para alguna x. Si la función nunca devuelve Some (x), se genera KeyNotFoundException. |
| reducir: ('T →' T → 'T) →' T [] → 'T | Aplica una función a cada elemento de una matriz, pasando un argumento acumulador a través del 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. Si la matriz tiene un tamaño cero, se genera ArgumentException. |
| reducir Atrás: ('T →' T → 'T) →' T [] → 'T | Aplica una función a cada elemento de una matriz, pasando un argumento acumulador a través del 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)). Si la matriz tiene un tamaño cero, se genera ArgumentException. |
| rev: 'T [] →' T [] | Invierte el orden de los elementos en una matriz proporcionada. |
| escanear: ('Estado →' T → 'Estado) →' Estado → 'T [] →' Estado []) | Se comporta como un pliegue, pero devuelve los resultados intermedios junto con los resultados finales. |
| scanBack: ('T →' Estado → 'Estado) →' T [] → 'Estado →' Estado [] | Se comporta como foldBack, pero devuelve los resultados intermedios junto con los resultados finales. |
| conjunto: 'T [] → int →' T → unidad | Establece un elemento de una matriz. |
| ordenar: 'T [] →' T [] | Ordena los elementos de una matriz y devuelve una nueva matriz. Operators.compare se utiliza para comparar los elementos. |
| sortBy: (Tecla 'T →') → 'T [] →' T [] | Ordena los elementos de una matriz utilizando la función proporcionada para transformar los elementos en el tipo en el que se basa la operación de clasificación y devuelve una nueva matriz. Operators.compare se utiliza para comparar los elementos. |
| sortInPlace: 'T [] → unidad | Ordena los elementos de una matriz cambiando la matriz en su lugar, utilizando la función de comparación proporcionada. Operators.compare se utiliza para comparar los elementos. |
| sortInPlaceBy: ('T →' Tecla) → 'T [] → unidad | Ordena los elementos de una matriz cambiando la matriz en su lugar, utilizando la proyección proporcionada para las claves. Operators.compare se utiliza para comparar los elementos. |
| sortInPlaceWith: ('T →' T → int) → 'T [] → unidad | Ordena los elementos de una matriz utilizando la función de comparación proporcionada para cambiar la matriz en su lugar. |
| sortWith: ('T →' T → int) → 'T [] →' T [] | Ordena los elementos de una matriz utilizando la función de comparación proporcionada y devuelve una nueva matriz. |
| sub: 'T [] → int → int →' T [] | Crea una matriz que contiene el subrango proporcionado, que se especifica mediante el índice inicial y la longitud. |
| suma: 'T [] → ^ T | Devuelve la suma de los elementos de la matriz. |
| sumBy: ('T → ^ U) →' T [] → ^ U | Devuelve la suma de los resultados generados al aplicar una función a cada elemento de una matriz. |
| toList: 'T [] →' T list | Convierte la matriz proporcionada en una lista. |
| toSeq: 'T [] → seq <' T> | Visualiza la matriz proporcionada como una secuencia. |
| tryFind: ('T → bool) →' T [] → 'T opción | Devuelve el primer elemento de la matriz proporcionada para el que devuelve la función proporcionada true. DevolucionesNone si no existe tal elemento. |
| tryFindIndex: ('T → bool) →' T [] → opción int | Devuelve el índice del primer elemento de una matriz que satisface la condición proporcionada. |
| tryPick: ('T →' opción U) → 'T [] →' opción U | Aplica la función proporcionada a los elementos sucesivos de la matriz proporcionada y devuelve el primer resultado donde la función devuelve Some (x) para alguna x. Si la función nunca devuelve Some (x),None es regresado. |
| descomprimir: ('T1 *' T2) [] → 'T1 [] *' T2 [] | Divide una matriz de pares de tuplas en una tupla de dos matrices. |
| descomprimir3: ('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 que tienen dos elementos. Las dos matrices deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
| zip3: 'T1 [] →' T2 [] → 'T3 [] → (' T1 * 'T2 * 113' T3) [] | Combina tres matrices en una matriz de tuplas que tienen tres elementos. Las tres matrices deben tener la misma longitud; de lo contrario, se genera ArgumentException. |
En la siguiente sección, veremos los usos de algunas de estas funcionalidades.
Creación de matrices mediante funciones
El módulo Array proporciona varias funciones que crean una matriz desde cero.
los Array.empty La función crea una nueva matriz vacía.
los Array.create La función crea una matriz de un tamaño específico y establece todos los elementos en valores dados.
los Array.init función crea una matriz, dada una dimensión y una función para generar los elementos.
los Array.zeroCreate La función crea una matriz en la que todos los elementos se inicializan al valor cero.
los Array.copy La función crea una nueva matriz que contiene elementos que se copian de una matriz existente.
los Array.sub La función genera una nueva matriz a partir de un subrango de una matriz.
los Array.append La función crea una nueva matriz combinando dos matrices existentes.
los Array.choose La función selecciona elementos de una matriz para incluir en una nueva matriz.
los Array.collect La función ejecuta una función específica en cada elemento de la matriz de una matriz existente y luego recopila los elementos generados por la función y los combina en una nueva matriz.
los Array.concat La función toma una secuencia de matrices y las combina en una sola matriz.
los Array.filter La función toma una función de condición booleana y genera una nueva matriz que contiene solo aquellos elementos de la matriz de entrada para los que la condición es verdadera.
los Array.rev La función genera una nueva matriz invirtiendo el orden de una matriz existente.
Los siguientes ejemplos demuestran estas funciones:
Ejemplo 1
(* using create and set *)
let array1 = Array.create 10 ""
for i in 0 .. array1.Length - 1 do
Array.set array1 i (i.ToString())
for i in 0 .. array1.Length - 1 do
printf "%s " (Array.get array1 i)
printfn " "
(* empty array *)
let array2 = Array.empty
printfn "Length of empty array: %d" array2.Length
let array3 = Array.create 10 7.0
printfn "Float Array: %A" array3
(* using the init and zeroCreate *)
let array4 = Array.init 10 (fun index -> index * index)
printfn "Array of squares: %A" array4
let array5 : float array = Array.zeroCreate 10
let (myZeroArray : float array) = Array.zeroCreate 10
printfn "Float Array: %A" array5Cuando compila y ejecuta el programa, produce el siguiente resultado:
0 1 2 3 4 5 6 7 8 9
Length of empty array: 0
Float Array: [|7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Float Array: [|0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0|]Ejemplo 2
(* creating subarray from element 5 *)
(* containing 15 elements thereon *)
let array1 = [| 0 .. 50 |]
let array2 = Array.sub array1 5 15
printfn "Sub Array:"
printfn "%A" array2
(* appending two arrays *)
let array3 = [| 1; 2; 3; 4|]
let array4 = [| 5 .. 9 |]
printfn "Appended Array:"
let array5 = Array.append array3 array4
printfn "%A" array5
(* using the Choose function *)
let array6 = [| 1 .. 20 |]
let array7 = Array.choose (fun elem -> if elem % 3 = 0 then
Some(float (elem))
else
None) array6
printfn "Array with Chosen elements:"
printfn "%A" array7
(*using the Collect function *)
let array8 = [| 2 .. 5 |]
let array9 = Array.collect (fun elem -> [| 0 .. elem - 1 |]) array8
printfn "Array with collected elements:"
printfn "%A" array9Cuando compila y ejecuta el programa, produce el siguiente resultado:
Sub Array:
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19|]
Appended Array:
[|1; 2; 3; 4; 5; 6; 7; 8; 9|]
Array with Chosen elements:
[|3.0; 6.0; 9.0; 12.0; 15.0; 18.0|]
Array with collected elements:
[|0; 1; 0; 1; 2; 0; 1; 2; 3; 0; 1; 2; 3; 4|]Búsqueda de matrices
los Array.find La función toma una función booleana y devuelve el primer elemento para el que la función devuelve verdadero; de lo contrario, genera una KeyNotFoundException.
los Array.findIndex La función funciona de manera similar excepto que devuelve el índice del elemento en lugar del elemento en sí.
El siguiente ejemplo demuestra esto.
Microsoft proporciona este interesante ejemplo de programa, que encuentra el primer elemento en el rango de un número dado que es tanto un cuadrado perfecto como un cubo perfecto:
let array1 = [| 2 .. 100 |]
let delta = 1.0e-10
let isPerfectSquare (x:int) =
let y = sqrt (float x)
abs(y - round y) < delta
let isPerfectCube (x:int) =
let y = System.Math.Pow(float x, 1.0/3.0)
abs(y - round y) < delta
let element = Array.find (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
printfn "The first element that is both a square and a cube is %d and its index is %d." element indexCuando compila y ejecuta el programa, produce el siguiente resultado:
The first element that is both a square and a cube is 64 and its index is 62.