Matrices (F#)
Las matrices son colecciones mutables de tamaño fijo, de base cero de elementos de datos consecutivos que son del mismo tipo.
Creación de matrices
Puede crear matrices de varias maneras. Puede crear una matriz pequeña enumerando valores consecutivos entre y separados por punto y coma, como se [| muestra en los ejemplos |] siguientes.
let array1 = [| 1; 2; 3 |]
También puede colocar cada elemento en una línea independiente, en cuyo caso el separador de punto y coma es opcional.
let array1 =
[|
1
2
3
|]
El tipo de los elementos de matriz se deduce de los literales usados y debe ser coherente. El código siguiente produce un error porque 1.0 es un valor float y 2 y 3 son enteros.
// Causes an error.
// let array2 = [| 1.0; 2; 3 |]
También puede usar expresiones de secuencia para crear matrices. A continuación se muestra un ejemplo que crea una matriz de cuadrados de enteros de 1 a 10.
let array3 = [| for i in 1 .. 10 -> i * i |]
Para crear una matriz en la que todos los elementos se inicializan en cero, use Array.zeroCreate .
let arrayOfTenZeroes : int array = Array.zeroCreate 10
Elementos de acceso
Puede acceder a los elementos de la matriz mediante un operador de punto ( . ) y corchetes ( [ y ] ).
array1[0]
Los índices de matriz comienzan en 0.
También puede acceder a los elementos de la matriz mediante la notación de segmento, que le permite especificar un subrango de la matriz. A continuación se muestran ejemplos de la notación de segmento.
// Accesses elements from 0 to 2.
array1[0..2]
// Accesses elements from the beginning of the array to 2.
array1[..2]
// Accesses elements from 2 to the end of the array.
array1[2..]
Cuando se usa la notación de segmento, se crea una nueva copia de la matriz.
Tipos y módulos de matriz
El tipo de todas las matrices de F# es .NET Framework tipo System.Array . Por lo tanto, las matrices de F# admiten toda la funcionalidad disponible en System.Array .
El Array módulo admite operaciones en matrices unidimensionales. Los módulos , y contienen funciones que admiten operaciones en matrices de Array2D Array3D Array4D dos, tres y cuatro dimensiones, respectivamente. Puede crear matrices de rango mayor que cuatro mediante System.Array .
Funciones simples
Array.get obtiene un elemento . Array.length proporciona la longitud de una matriz. Array.set establece un elemento en un valor especificado. En el ejemplo de código siguiente se muestra el uso de estas funciones.
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)
La salida es la siguiente.
0 1 2 3 4 5 6 7 8 9
Funciones que crean matrices
Varias funciones crean matrices sin necesidad de una matriz existente. Array.empty crea una nueva matriz que no contiene ningún elemento. Array.create crea una matriz de un tamaño especificado y establece todos los elementos en los valores proporcionados. Array.init crea una matriz, dada una dimensión y una función para generar los elementos. Array.zeroCreate crea una matriz en la que todos los elementos se inicializan en el valor cero para el tipo de la matriz. En el código siguiente se muestran estas funciones.
let myEmptyArray = Array.empty
printfn "Length of empty array: %d" myEmptyArray.Length
printfn "Array of floats set to 5.0: %A" (Array.create 10 5.0)
printfn "Array of squares: %A" (Array.init 10 (fun index -> index * index))
let (myZeroArray : float array) = Array.zeroCreate 10
La salida es la siguiente.
Length of empty array: 0
Area of floats set to 5.0: [|5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Array.copy crea una nueva matriz que contiene elementos que se copian de una matriz existente. Tenga en cuenta que la copia es una copia superficial, lo que significa que si el tipo de elemento es un tipo de referencia, solo se copia la referencia, no el objeto subyacente. En el siguiente ejemplo código se muestra cómo hacerlo.
open System.Text
let firstArray : StringBuilder array = Array.init 3 (fun index -> new StringBuilder(""))
let secondArray = Array.copy firstArray
// Reset an element of the first array to a new value.
firstArray[0] <- new StringBuilder("Test1")
// Change an element of the first array.
firstArray[1].Insert(0, "Test2") |> ignore
printfn "%A" firstArray
printfn "%A" secondArray
La salida del código anterior es la siguiente:
[|Test1; Test2; |]
[|; Test2; |]
La cadena solo aparece en la primera matriz porque la operación de crear un nuevo elemento sobrescribe la referencia en , pero no afecta a la referencia original a una cadena vacía que todavía está Test1 firstArray presente en secondArray . La cadena aparece en ambas matrices porque la operación en el tipo afecta al objeto subyacente, al que se hace Test2 Insert referencia en ambas System.Text.StringBuilder System.Text.StringBuilder matrices.
Array.sub genera una nueva matriz a partir de un subrango de una matriz. Especifique el subrango proporcionando el índice inicial y la longitud. En el código siguiente se muestra cómo usar Array.sub.
let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2
La salida muestra que la submatriz comienza en el elemento 5 y contiene 10 elementos.
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]
Array.append crea una nueva matriz combinando dos matrices existentes.
En el código siguiente se muestra Array.append.
printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])
La salida del código anterior es la siguiente.
[|1; 2; 3; 4; 5; 6|]
Array.choose selecciona los elementos de una matriz que se incluirán en una nueva matriz. En el código siguiente se muestra Array.choose . Tenga en cuenta que el tipo de elemento de la matriz no tiene que coincidir con el tipo del valor devuelto en el tipo de opción. En este ejemplo, el tipo de elemento es y la opción es el resultado de una función int polinómica, elem*elem - 1 , como un número de punto flotante.
printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
Some(float (elem*elem - 1))
else
None) [| 1 .. 10 |])
La salida del código anterior es la siguiente.
[|3.0; 15.0; 35.0; 63.0; 99.0|]
Array.collect ejecuta una función especificada en cada elemento de matriz de una matriz existente y, a continuación, recopila los elementos generados por la función y los combina en una nueva matriz. En el código siguiente se muestra Array.collect .
printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])
La salida del código anterior es la siguiente.
[|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]
Array.concat toma una secuencia de matrices y las combina en una sola matriz. En el código siguiente se muestra Array.concat .
Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]
Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]
La salida del código anterior es la siguiente.
[|(1, 1, 1); (1, 2, 2); (1, 3, 3); (2, 1, 2); (2, 2, 4); (2, 3, 6); (3, 1, 3);
(3, 2, 6); (3, 3, 9)|]
Array.filter toma una función de condición booleana y genera una nueva matriz que contiene solo los elementos de la matriz de entrada para la que la condición es verdadera. En el código siguiente se muestra Array.filter .
printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])
La salida del código anterior es la siguiente.
[|2; 4; 6; 8; 10|]
Array.rev genera una nueva matriz invirtiendo el orden de una matriz existente. En el código siguiente se muestra Array.rev .
let stringReverse (s: string) =
System.String(Array.rev (s.ToCharArray()))
printfn "%A" (stringReverse("!dlrow olleH"))
La salida del código anterior es la siguiente.
"Hello world!"
Puede combinar fácilmente funciones en el módulo de matriz que transforman matrices mediante el operador de canalización ( ), como |> se muestra en el ejemplo siguiente.
[| 1 .. 10 |]
|> Array.filter (fun elem -> elem % 2 = 0)
|> Array.choose (fun elem -> if (elem <> 8) then Some(elem*elem) else None)
|> Array.rev
|> printfn "%A"
El resultado es
[|100; 36; 16; 4|]
Matrices multidimensionales
Se puede crear una matriz multidimensional, pero no hay ninguna sintaxis para escribir un literal de matriz multidimensional. Use el operador array2D para crear una matriz a partir de una secuencia de secuencias de elementos de matriz. Las secuencias pueden ser literales de matriz o de lista. Por ejemplo, el código siguiente crea una matriz bidimensional.
let my2DArray = array2D [ [ 1; 0]; [0; 1] ]
También puede usar la función para inicializar matrices de dos dimensiones, y funciones similares están disponibles para matrices de Array2D.init tres y cuatro dimensiones. Estas funciones toman una función que se usa para crear los elementos. Para crear una matriz bidimensional que contenga elementos establecidos en un valor inicial en lugar de especificar una función, use la función , que también está disponible para matrices de hasta cuatro Array2D.create dimensiones. En el ejemplo de código siguiente se muestra primero cómo crear una matriz de matrices que contienen los elementos deseados y, a continuación, se usa para generar la Array2D.init matriz bidimensional deseada.
let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays[i][j])
La sintaxis de indexación y selección de matrices es compatible con matrices de hasta el rango 4. Cuando se especifica un índice en varias dimensiones, se usan comas para separar los índices, como se muestra en el ejemplo de código siguiente.
twoDimensionalArray[0, 1] <- 1.0
El tipo de una matriz bidimensional se escribe como (por ejemplo, , ) y el tipo de una matriz tridimensional se escribe como , y así sucesivamente para matrices de dimensiones <type>[,] int[,] double[,] <type>[,,] superiores.
Solo hay disponible un subconjunto de las funciones disponibles para matrices unidimensionales para matrices multidimensionales.
Matriz de matriz y multidimensional
En una matriz bidimensional (una matriz), puede extraer una submatriz especificando intervalos y usando un carácter comodín ( ) para especificar filas o * columnas completas.
// Get rows 1 to N from an NxM matrix (returns a matrix):
matrix[1.., *]
// Get rows 1 to 3 from a matrix (returns a matrix):
matrix[1..3, *]
// Get columns 1 to 3 from a matrix (returns a matrix):
matrix[*, 1..3]
// Get a 3x3 submatrix:
matrix[1..3, 1..3]
Puede descomponer una matriz multidimensional en subarrays de la misma dimensión o inferior. Por ejemplo, puede obtener un vector de una matriz especificando una sola fila o columna.
// Get row 3 from a matrix as a vector:
matrix[3, *]
// Get column 3 from a matrix as a vector:
matrix[*, 3]
Puede usar esta sintaxis delictiva para los tipos que implementan los operadores de acceso a elementos y los métodos GetSlice sobrecargados. Por ejemplo, el código siguiente crea un tipo Matrix que encapsula la matriz 2D de F#, implementa una propiedad Item para proporcionar compatibilidad con la indexación de matrices e implementa tres versiones de GetSlice . Si puede usar este código como plantilla para los tipos de matriz, puede usar todas las operaciones de sección que se describen en esta sección.
type Matrix<'T>(N: int, M: int) =
let internalArray = Array2D.zeroCreate<'T> N M
member this.Item
with get(a: int, b: int) = internalArray[a, b]
and set(a: int, b: int) (value:'T) = internalArray[a, b] <- value
member this.GetSlice(rowStart: int option, rowFinish : int option, colStart: int option, colFinish : int option) =
let rowStart =
match rowStart with
| Some(v) -> v
| None -> 0
let rowFinish =
match rowFinish with
| Some(v) -> v
| None -> internalArray.GetLength(0) - 1
let colStart =
match colStart with
| Some(v) -> v
| None -> 0
let colFinish =
match colFinish with
| Some(v) -> v
| None -> internalArray.GetLength(1) - 1
internalArray[rowStart..rowFinish, colStart..colFinish]
member this.GetSlice(row: int, colStart: int option, colFinish: int option) =
let colStart =
match colStart with
| Some(v) -> v
| None -> 0
let colFinish =
match colFinish with
| Some(v) -> v
| None -> internalArray.GetLength(1) - 1
internalArray[row, colStart..colFinish]
member this.GetSlice(rowStart: int option, rowFinish: int option, col: int) =
let rowStart =
match rowStart with
| Some(v) -> v
| None -> 0
let rowFinish =
match rowFinish with
| Some(v) -> v
| None -> internalArray.GetLength(0) - 1
internalArray[rowStart..rowFinish, col]
module test =
let generateTestMatrix x y =
let matrix = new Matrix<float>(3, 3)
for i in 0..2 do
for j in 0..2 do
matrix[i, j] <- float(i) * x - float(j) * y
matrix
let test1 = generateTestMatrix 2.3 1.1
let submatrix = test1[0..1, 0..1]
printfn $"{submatrix}"
let firstRow = test1[0,*]
let secondRow = test1[1,*]
let firstCol = test1[*,0]
printfn $"{firstCol}"
Funciones booleanas en matrices
Funciones y Array.exists elementos de prueba en una o dos Array.exists2 matrices, respectivamente. Estas funciones toman una función de prueba y devuelven si hay un elemento (o par true de elementos para ) que cumple la Array.exists2 condición.
En el código siguiente se muestra el uso de Array.exists y Array.exists2 . En estos ejemplos, las nuevas funciones se crean aplicando solo uno de los argumentos, en estos casos, el argumento de función.
let allNegative = Array.exists (fun elem -> abs (elem) = elem) >> not
printfn "%A" (allNegative [| -1; -2; -3 |])
printfn "%A" (allNegative [| -10; -1; 5 |])
printfn "%A" (allNegative [| 0 |])
let haveEqualElement = Array.exists2 (fun elem1 elem2 -> elem1 = elem2)
printfn "%A" (haveEqualElement [| 1; 2; 3 |] [| 3; 2; 1|])
La salida del código anterior es la siguiente.
true
false
false
true
De forma similar, la función Array.forall prueba una matriz para determinar si cada elemento satisface una condición booleana. La Array.forall2 variación hace lo mismo mediante una función booleana que implica elementos de dos matrices de igual longitud. En el código siguiente se muestra el uso de estas funciones.
let allPositive = Array.forall (fun elem -> elem > 0)
printfn "%A" (allPositive [| 0; 1; 2; 3 |])
printfn "%A" (allPositive [| 1; 2; 3 |])
let allEqual = Array.forall2 (fun elem1 elem2 -> elem1 = elem2)
printfn "%A" (allEqual [| 1; 2 |] [| 1; 2 |])
printfn "%A" (allEqual [| 1; 2 |] [| 2; 1 |])
La salida de estos ejemplos es la siguiente.
false
true
true
false
Buscar matrices
Array.find toma una función booleana y devuelve el primer elemento para el que la función devuelve o genera si no se encuentra ningún elemento que cumpla true System.Collections.Generic.KeyNotFoundException la condición. Array.findIndex es como Array.find , salvo que devuelve el índice del elemento en lugar del propio elemento.
En el código siguiente Array.find se usa y para buscar un número que sea un cuadrado perfecto y un cubo Array.findIndex perfecto.
let arrayA = [| 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) arrayA
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) arrayA
printfn "The first element that is both a square and a cube is %d and its index is %d." element index
La salida es la siguiente.
The first element that is both a square and a cube is 64 and its index is 62.
Array.tryFind es como , salvo que su resultado es un tipo de opción Array.find y devuelve si no se encuentra ningún None elemento. Array.tryFind debe usarse en lugar Array.find de cuando no se sabe si un elemento correspondiente está en la matriz. De forma similar, Array.tryFindIndex es como , salvo que el tipo de opción es el valor Array.findIndex devuelto. Si no se encuentra ningún elemento, la opción es None .
En el código siguiente se muestra cómo usar Array.tryFind. Este código depende del código anterior.
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 lookForCubeAndSquare array1 =
let result = Array.tryFind (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
match result with
| Some x -> printfn "Found an element: %d" x
| None -> printfn "Failed to find a matching element."
lookForCubeAndSquare [| 1 .. 10 |]
lookForCubeAndSquare [| 100 .. 1000 |]
lookForCubeAndSquare [| 2 .. 50 |]
La salida es la siguiente.
Found an element: 1
Found an element: 729
Failed to find a matching element.
Use Array.tryPick cuando necesite transformar un elemento además de encontrarlo. El resultado es el primer elemento para el que la función devuelve el elemento transformado como un valor de opción, o si None no se encuentra ningún elemento de este tipo.
En el código siguiente se muestra el uso de Array.tryPick. En este caso, en lugar de una expresión lambda, se definen varias funciones auxiliares locales para simplificar el código.
let findPerfectSquareAndCube array1 =
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
// intFunction : (float -> float) -> int -> int
// Allows the use of a floating point function with integers.
let intFunction function1 number = int (round (function1 (float number)))
let cubeRoot x = System.Math.Pow(x, 1.0/3.0)
// testElement: int -> (int * int * int) option
// Test an element to see whether it is a perfect square and a perfect
// cube, and, if so, return the element, square root, and cube root
// as an option value. Otherwise, return None.
let testElement elem =
if isPerfectSquare elem && isPerfectCube elem then
Some(elem, intFunction sqrt elem, intFunction cubeRoot elem)
else None
match Array.tryPick testElement array1 with
| Some (n, sqrt, cuberoot) -> printfn "Found an element %d with square root %d and cube root %d." n sqrt cuberoot
| None -> printfn "Did not find an element that is both a perfect square and a perfect cube."
findPerfectSquareAndCube [| 1 .. 10 |]
findPerfectSquareAndCube [| 2 .. 100 |]
findPerfectSquareAndCube [| 100 .. 1000 |]
findPerfectSquareAndCube [| 1000 .. 10000 |]
findPerfectSquareAndCube [| 2 .. 50 |]
La salida es la siguiente.
Found an element 1 with square root 1 and cube root 1.
Found an element 64 with square root 8 and cube root 4.
Found an element 729 with square root 27 and cube root 9.
Found an element 4096 with square root 64 and cube root 16.
Did not find an element that is both a perfect square and a perfect cube.
Realización de cálculos en matrices
La Array.average función devuelve el promedio de cada elemento de una matriz. Se limita a los tipos de elemento que admiten la división exacta por un entero, que incluye tipos de punto flotante, pero no tipos enteros. La Array.averageBy función devuelve el promedio de los resultados de llamar a una función en cada elemento. Para una matriz de tipo entero, puede usar y hacer que la función convierta cada elemento en un tipo de punto Array.averageBy flotante para el cálculo.
Use Array.max o para obtener el elemento máximo o Array.min mínimo, si el tipo de elemento lo admite. De forma similar, y permiten que una función se ejecute primero, quizás para Array.maxBy Array.minBy transformarse en un tipo que admita la comparación.
Array.sum agrega los elementos de una matriz y llama Array.sumBy a una función en cada elemento y agrega los resultados juntos.
Para ejecutar una función en cada elemento de una matriz sin almacenar los valores devueltos, use Array.iter . Para una función que implica dos matrices de igual longitud, use Array.iter2 . Si también necesita mantener una matriz de los resultados de la función, use o , que funciona en Array.map Array.map2 dos matrices a la vez.
Las variaciones y permiten que el índice del elemento esté implicado en el cálculo; lo Array.iteri mismo se aplica a y Array.iteri2 Array.mapi Array.mapi2 .
Las funciones , , , , y ejecutan algoritmos Array.fold Array.foldBack que Array.reduce Array.reduceBack Array.scan Array.scanBack implican todos los elementos de una matriz. Del mismo modo, las Array.fold2 variaciones y Array.foldBack2 realizan cálculos en dos matrices.
Estas funciones para realizar cálculos corresponden a las funciones del mismo nombre en el módulo List. Para obtener ejemplos de uso, vea Lists.
Modificación de matrices
Array.set establece un elemento en un valor especificado. Array.fill establece un intervalo de elementos de una matriz en un valor especificado. El código siguiente proporciona un ejemplo de Array.fill .
let arrayFill1 = [| 1 .. 25 |]
Array.fill arrayFill1 2 20 0
printfn "%A" arrayFill1
La salida es la siguiente.
[|1; 2; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 23; 24; 25|]
Puede usar para Array.blit copiar una subsección de una matriz en otra matriz.
Convertir a y desde otros tipos
Array.ofList crea una matriz a partir de una lista. Array.ofSeq crea una matriz a partir de una secuencia. Array.toList y Array.toSeq convierten a estos otros tipos de colección desde el tipo de matriz.
Ordenar matrices
Use Array.sort para ordenar una matriz mediante la función de comparación genérica. Use para especificar una función que genera un valor, denominado clave , para ordenar mediante la función de Array.sortBy comparación genérica en la clave. Use Array.sortWith si desea proporcionar una función de comparación personalizada. Array.sort, Array.sortBy y Array.sortWith devuelven la matriz ordenada como una nueva matriz. Las variaciones Array.sortInPlace , Array.sortInPlaceBy y Array.sortInPlaceWith modifican la matriz existente en lugar de devolver una nueva.
Matrices y tuplas
Las funciones Array.zip y Array.unzip convierten matrices de pares de tuplas en tuplas de matrices y viceversa. Array.zip3 y Array.unzip3 son similares, salvo que funcionan con tuplas de tres elementos o tuplas de tres matrices.
Cálculos paralelos en matrices
El módulo Array.Parallel contiene funciones para realizar cálculos paralelos en matrices. Este módulo no está disponible en las aplicaciones destinadas a versiones de .NET Framework anteriores a la versión 4.