Matrizes F#
As matrizes F# são mutáveis, o que significa que elas podem ser atualizadas e redimensionadas conforme desejado, embora isso seja menos eficiente do que criar uma matriz totalmente nova do zero.
Neste artigo, você aprenderá o uso de arrays F#. Isso inclui criar arrays, inicializar arrays, acessar e modificar elementos de arrays, iterar arrays com loops e funções de ordem superior , bem como usar funções relacionadas a arrays na biblioteca padrão, entre outras coisas.
Índice-
Criando uma matriz F#
Existem diferentes sintaxes e técnicas que você pode usar para criar arrays e você pode usar as funções do módulo Array para fazer isso.
Aqui, discutiremos como criar arrays sem ter que usar as funções do módulo nesta seção.
Arrays podem ser criados de três maneiras diferentes, dependendo de sua estrutura sintática:
- Para listar valores consecutivos, os valores devem ser separados por ponto e vírgula entre [| e |].
- Alternativamente, você pode colocar cada elemento em uma linha separada, caso em que o separador de ponto e vírgula não é necessário.
- Isso pode ser obtido usando expressões de sequência.
Um operador de ponto ( . ) e colchetes ( [ e ] ) são usados para acessar os elementos de uma matriz.
O exemplo a seguir mostra como criar matrizes F#:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//using semicolon separator
let arr1 = [| 1; 3; 5; 7; 9; 11 |]
for i in 0 .. arr1.Length – 1 do
printf "%d " arr1.[i]
printfn" "
// without semicolon separator
let arr2 =
[|
1
3
5
7
9
11
|]
for i in 0 .. arr2.Length – 1 do
printf "%d " arr2.[i]
printfn" "
//using sequence
let arr3 = [| for i in 1 .. 10 -> i * i |]
for i in 0 .. arr3.Length – 1 do
printf "%d " arr3.[i]
printfn" "
Operações básicas em arrays
Arrays unidimensionais podem ser operados usando o módulo de biblioteca Microsoft.FSharp.Collections.Array no Microsoft FSharp.
Arrays podem ser usados de várias maneiras, conforme mostrado na tabela a seguir:
| Valor | Visão geral |
| anexar: 'T [] → 'T [] → 'T [] | Uma matriz é criada separando os elementos da primeira matriz pelos da segunda matriz no início da matriz. |
| média: ^T [] → ^T | A média de cada elemento em uma matriz é retornada como resultado. |
| médiaPor : ('T → ^U) → 'T [] → ^U | Esta função calcula a média de todos os elementos de uma matriz que são gerados como resultado da aplicação de uma função a cada elemento. |
| blit : 'T [] → int → 'T [] → int → int → unidade | Este método é usado para ler um intervalo de elementos de um array e escrevê-los em outro |
| escolha: (opção 'T → U) → 'T [] → 'U [] | A função é aplicada a cada elemento de uma matriz de acordo com uma função fornecida. Esta função retorna uma matriz que contém os valores x para cada elemento para o qual a função retorna Some(x). |
| coletar: ('T → 'U []) → T [] → 'U [] | Uma função é aplicada a cada elemento de uma matriz, os resultados são concatenados e o resultado é retornado como a combinação de todos os elementos da matriz. |
| concat : seq<'T []> → 'T [] | Nesta função, uma sequência de arrays é criada e cada array contém os elementos dos arrays anteriores na sequência. |
| copiar: 'T → 'T [] | A função retorna um array contendo os elementos encontrados no array que foi fornecido. |
| criar: int → 'T → 'T [] | Uma nova matriz é criada com todos os elementos iguais ao valor fornecido no início. |
| vazio : 'T [] | Este método retorna uma matriz vazia do tipo fornecido no argumento. |
| existe : ('T → bool) → 'T [] → bool | Esta função verifica se o predicado fornecido é satisfeito por qualquer elemento em uma matriz. |
| existe2 : ('T1 → 'T2 → bool) → 'T1 [] → 'T2 [] → bool | Esta função determina se duas matrizes com elementos correspondentes satisfazem as condições fornecidas. |
| fill: 'T [] → int → int → 'T → unidade | Este método usa o valor fornecido para preencher um intervalo de elementos em uma matriz. |
| filtro: ('T → bool) → 'T [] → 'T [] | Será retornada uma coleção que contém apenas os elementos da matriz fornecida que são verdadeiros quando a condição fornecida é atendida. |
| encontrar: ('T → bool) → 'T [] → 'T | A função retorna o primeiro elemento para o qual um valor verdadeiro é retornado pela função fornecida. O KeyNotFoundException é levantado se não houver elementos correspondentes aos critérios de pesquisa. |
| findIndex : ('T → bool) → 'T [] → int | Uma matriz cujo primeiro elemento satisfaça a condição fornecida será indexada pelo índice do primeiro elemento na matriz. Quando nenhum elemento atende à condição, esse método gera uma KeyNotFoundException. |
| fold : ('Estado → 'T → 'Estado) → 'Estado → 'T [] → 'Estado | Essa função encadeia um argumento de acumulador por meio de cada elemento da coleção. Aplica a função ao segundo argumento e ao primeiro elemento do array. Este resultado será então passado pelo programa junto com o segundo elemento, e o processo continuará desta forma. Em seguida, retorna o resultado final. Uma função f é dada, e os elementos são i0…iN, então esta função calcula f (… (fs i0) i1 …) iN. |
| fold2 : ('Estado → 'T1 → 'T2 → 'Estado) → 'Estado → 'T1 [] → 'T2 [] → 'Estado | Essa função aplica uma função aos elementos de duas coleções que correspondem entre si e também encadeia um argumento de acumulador por meio da computação. Deve haver coleções idênticas. Usando i0…iN e j0…jN como funções de entrada, esta função calcula f (… (fs i0 j0)…) iN jN. |
| foldBack : ('T → 'Estado → 'Estado) → 'T [] → 'Estado → 'Estado | Essa função aplica uma função a cada elemento da coleção, por meio da qual um argumento do acumulador é passado para a computação de cada elemento. Uma função f é passada como uma entrada, e os elementos de entrada i0…iN são passados como entrada que calcula f i0 (…(f iN s)). |
| foldBack2 : ('T1 → 'T2 → 'Estado → 'Estado) → 'T1 [] → 'T2 [] → 'Estado → 'Estado | Nesta função, um elemento de duas coleções é encadeado através da computação e uma referência de função é passada como um argumento. As coleções devem ser idênticas. Uma função f é passada para esta função e se os elementos em cada caso forem i0…iN e j0…jN, então esta função calculará o valor de f i0 j0 (…(f iN jN s )). |
| forall : ('T → bool) → 'T [] → bool | Esta função verifica se todos os elementos satisfazem o predicado fornecido na coleção. |
| forall2 : ('T1 → 'T2 → bool) → 'T1 [] → 'T2 [] → bool | Identifica se todos os elementos correspondentes ao predicado fornecido são satisfeitos aos pares na coleção. |
| get : 'T [] → int → 'T | Uma função que retorna um elemento de uma matriz. |
| init : int → (int → 'T) → 'T [] | Ele cria uma matriz de uma dimensão especificada usando uma função fornecida pelo usuário. |
| isEmpty : 'T [] → bool | Esta função determina se há algum elemento em uma matriz. |
| iter : ('T → unidade) → 'T [] → unidade | Cada elemento da matriz é aplicado à função fornecida pelo usuário. |
| iter2 : ('T1 → 'T2 → unidade) → 'T1 [] → 'T2 [] → unidade) | Um par de elementos é aplicado à função fornecida usando índices correspondentes em duas matrizes para obter um par de elementos. Se os comprimentos das duas matrizes não corresponderem entre si, ArgumentException será levantado como resultado. |
| iteri : (int → 'T → unidade) → 'T [] → unidade | Uma matriz é usada para aplicar a função fornecida a cada elemento da matriz. Este inteiro indica o índice do elemento na matriz que foi passado para a função. |
| iteri2 : (int → 'T1 → 'T2 → unidade) → 'T1 [] → 'T2 [] → unidade | Um par de elementos de duas matrizes contendo índices correspondentes são aplicados a um par de elementos aplicando a função fornecida, passando também o índice dos elementos. Deve haver uma correspondência entre o comprimento das duas matrizes; caso contrário, um ArgumentException será lançado. |
| comprimento: 'T [] → int | Uma função de comprimento retorna o número de elementos em uma matriz. Da mesma forma, a propriedade Length tem a mesma função. |
| mapa: ('T → 'U) → 'T [] → 'U [] | Aplicar a função fornecida a cada elemento de uma matriz fornecida cria uma matriz cujos elementos são os resultados. |
| map2 : ('T1 → 'T2 → 'U) → 'T1 [] → 'T2 [] → 'U [] | Esta função cria um novo array que contém os elementos que foram obtidos aplicando a função fornecida aos elementos correspondentes dos dois arrays fornecidos. Deve haver o mesmo comprimento em ambas as matrizes de entrada; caso contrário, ArgumentException será lançado. |
| mapi : (int → 'T → 'U) → 'T [] → 'U [] | Fornece uma função para criar uma matriz cujos elementos são os resultados da aplicação da função fornecida a cada elemento de uma matriz fornecida para produzir resultados. Usando um índice inteiro como entrada, a função é capaz de determinar o índice do elemento que está sendo transformado pela passagem de um número inteiro. |
| mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 [] → 'T2 [] → 'U [] | Como parte dessa função, a matriz é criada aplicando a função fornecida aos respectivos elementos das duas coleções aos pares e, em seguida, passando o índice do elemento correspondente para a função também. Deve haver uma correspondência entre os tamanhos das duas matrizes de entrada; caso contrário, ArgumentException é lançado. |
| max : 'T [] → 'T | Essa função retorna o maior elemento em uma matriz de todos os elementos da matriz. Para comparar os elementos, operator.max é usado como uma função de comparação. |
| maxBy : ('T → 'U) → 'T [] → 'T | A função retorna o maior elemento do array entre todos os elementos do array, comparando o resultado da função com seu método Operators.max . |
| min: ('T [] → 'T | Essa função retorna o menor elemento em uma matriz, comparado usando Operators.min como método de comparação. |
| minBy : ('T → 'U) → 'T [] → 'T | Usando Operators.min no resultado da função, esta função retorna o menor elemento dentro de todos os elementos do array |
| ofList : 'T lista → 'T [] | Esta função cria uma matriz com base na lista fornecida. |
| ofSeq : seq<'T> → 'T [] | Arrays são criados a partir de objetos enumeráveis fornecidos pelo usuário. |
| partição: ('T → bool) → 'T [] → 'T [] * 'T [] | Há duas matrizes nessa função, uma que contém os elementos que são verdadeiros quando a condição fornecida é satisfeita e a outra que contém os elementos que são falsos quando a condição fornecida é satisfeita. |
| permutar : (int → int) → 'T [] → 'T [] | O método de permutação funciona permutando os elementos em uma matriz de acordo com a permutação especificada. |
| pick : (opção 'T → 'U) → 'T [] → 'U | Usando a função fornecida, elementos sucessivos de uma matriz fornecida serão passados pela função e o primeiro resultado retornado será Some(x) para algum x. É gerado um KeyNotFoundException se a função nunca retornar Some(x) como parte de seu valor de retorno. |
| reduzir: ('T → 'T → 'T) → 'T [] → 'T | Esse método encadeia um argumento de acumulador por meio de cada elemento de uma matriz para executar uma computação para cada elemento. A função calcula f (…(f i0 i1)…) iN com base na função de entrada f e nos elementos da matriz i0…iN na matriz. Haverá um ArgumentException lançado se a matriz tiver um tamanho de zero. |
| reduzBack : ('T → 'T → 'T) → 'T [] → 'T | Usando um argumento acumulador, encadeia uma função por meio de cada elemento em uma matriz. A função calcula f i0 (…(f iN-1 iN)) se a função de entrada f for fornecida e os elementos forem i0…iN. Isso gera um ArgumentException se a matriz for de tamanho zero. |
| rev : 'T [] → 'T [] | Uma função que inverte a ordem na qual os elementos de uma matriz são exibidos. |
| scan: ('Estado → 'T → 'Estado) → 'Estado → 'T [] → 'Estado []) | Essa função se comporta de maneira semelhante a fold, mas ao invés de retornar apenas os resultados finais, ela também retorna os resultados intermediários. |
| scanBack : ('T → 'Estado → 'Estado) → 'T [] → 'Estado → 'Estado [] | Essa função se comporta de maneira semelhante a foldBack, exceto que ela também retorna os resultados intermediários junto com os resultados finais. |
| set : 'T [] → int → 'T → unidade | Um elemento set é usado para definir um elemento em uma matriz. |
| classificar: 'T[] → 'T[] | Retorna um novo array contendo os elementos do array que foram ordenados. Os elementos podem ser comparados usando a função operator.compare . |
| sortBy : ('T → 'Chave) → 'T [] → 'T [] | Usando a função fornecida, classifique os elementos da matriz transformando os elementos no tipo no qual a operação de classificação é baseada e retorne uma nova matriz contendo os itens da matriz. Os elementos na matriz são comparados usando o operador operator.compare . |
| sortInPlace : 'T [] → unidade | Usando a função de comparação fornecida, os elementos de dados em uma matriz são classificados alterando a matriz no local enquanto a matriz está sendo alterada. Uma comparação é realizada entre os elementos usando o operador operator.compare. |
| sortInPlaceBy : ('T → 'Chave) → 'T [] → unidade | Atribui chaves aos elementos em uma matriz, usando a projeção de chave fornecida, para classificar os elementos da matriz no lugar. Usando o operador compare, os elementos são comparados usando o operador operator.compare. |
| sortInPlaceWith : ('T → 'T → int) → 'T [] → unidade | Usando a função de comparação fornecida com a matriz, é possível classificar os elementos na matriz trocando os elementos no lugar. |
| sortWith : ('T → 'T → int) → 'T [] → 'T [] | Esta função realiza a classificação de uma matriz usando a função de comparação fornecida e retorna uma nova matriz que contém os elementos classificados. |
| sub : 'T [] → int → int → 'T [] | Essa função retorna uma matriz de string contendo o comprimento total e o índice inicial do subintervalo fornecido que é especificado pelo índice inicial. |
| soma: 'T [] → ^ T | Os elementos da matriz são somados para obter a soma de seus valores. |
| somaPor : ('T → ^U) → 'T [] → ^U | Uma matriz na qual cada elemento é tratado como um elemento individual é resumida pela aplicação de uma função a cada elemento da matriz. |
| toList : 'T [] → 'T lista | A função converte a matriz F# fornecida em uma lista de elementos. |
| toSeq : 'T [] → seq<'T> | A matriz fornecida é visualizada na forma de uma sequência. |
| tryFind : ('T → bool) → 'T [] → 'T opção | Para a matriz fornecida, retorna o primeiro elemento para o qual true é retornado pela função fornecida. Se não houver tal elemento, ele retorna None. |
| tryFindIndex : ('T → bool) → 'T [] → opção int | Especifica uma condição com base na qual retornar o índice do primeiro elemento em uma matriz. |
| tryPick : ('T → 'U opção) → 'T [] → 'U opção | Usando a função fornecida, o primeiro resultado é retornado quando a função é aplicada a elementos sucessivos da matriz fornecida e retorna Some(x) para algum x quando a função fornecida retorna Some(x). A função retorna None se nunca retornar Some(x). |
| descompacte: ('T1 * 'T2) [] → 'T1 [] * 'T2 [] | Esta função permite dividir um array de pares de tuplas em dois arrays de tuplas . |
| unzip3 : ('T1 * 'T2 * 'T3) [] → 'T1 [] * 'T2 [] * 'T3 [] | A função split divide uma tupla de três elementos em uma tupla de três arrays com base em cada elemento da tupla. |
| zeroCriar : int → 'T [] | Arrays são criados definindo seus elementos como valores padrão. Usando o exemplo a seguir, definimos Unchecked.defaultof <T> . |
| zip : 'T1 [] → 'T2 [] → ('T1 * 'T2) [] | O objetivo desta função é criar uma matriz de pares a partir das duas matrizes que foram combinadas. O comprimento das duas matrizes deve ser igual entre elas. |
| zip3 : 'T1 [] → 'T2 [] → 'T3 [] → ('T1 * 'T2 * 113 'T3) [] | Uma tupla é um array de três elementos que foi criado pela combinação de três arrays. Deve-se garantir que os comprimentos das três matrizes sejam iguais; caso contrário, ArgumentException será levantado. |
Na seção a seguir, você descobrirá como usar alguns desses recursos em cenários práticos, conforme nos aprofundamos em exemplos que mostram seus recursos.
Funções de Matriz F#
Várias funções são fornecidas pelo módulo Array para permitir a criação de arrays a partir do zero.
- Uma nova matriz vazia pode ser criada usando a função Array.empty .
- Com a função Array.create , você pode criar uma matriz de um determinado tamanho e definir todos os elementos da matriz para um valor especificado.
- Um array pode ser criado chamando a função Array.init , que recebe como entrada uma dimensão e uma função que gera os elementos do array.
- Usando a função Array.zeroCreate , você pode criar uma matriz cujos elementos são todos inicializados com zero no momento da criação.
- Existe uma função Array.copy que é usada para criar um novo array que contém elementos que foram copiados de um array existente.
- Array.sub é uma função que cria um novo array a partir de um subintervalo de um array, que pode ser selecionado pelo usuário.
- Na função Array.append , dois arrays são combinados para formar um novo array adicionando novos elementos a eles.
- Uma matriz pode ser escolhida para incluir elementos em uma nova matriz usando a função Array.choose .
- Quando a função Array.collect é executada em cada elemento de um array existente, uma especificação da função é executada em cada elemento do array, após o que os elementos gerados pela função são reunidos e um novo array é criado.
- Na função Array.concat , combinamos uma sequência de arrays em um array pegando uma sequência de arrays e combinando-os.
- Array.filter é uma função que removerá os elementos de uma matriz que não estão presentes na matriz de entrada se uma condição booleana for atendida. O resultado será um array com apenas os elementos do array de entrada que estão presentes no array de entrada.
- Uma nova matriz pode ser gerada invertendo a ordem de uma matriz existente com a ajuda da função Array.rev .
Essas funções são demonstradas nos exemplos a seguir.
Aqui está um exemplo de como criar um array usando as funções acima:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Array.empty
let emptyArray = Array.empty // creates an empty array of any type
printfn "Empty Array.empty: %A" emptyArray
// Array.create
let newArray = Array.create 5 2 // creates a new array of length 5 with default value 2
printfn "By using Array.create: %A" newArray
// Array.init
let squares = Array.init 5 (fun i -> i * i) // creates an array of the first 5 squares
printfn "By using Array.init: %A" squares
// Array.copy
let originalArray = [|1; 2; 3|]
let copyArray = Array.copy originalArray // creates a copy of the original array
printfn "By using Array.copy: %A" copyArray
// Array.sub
let subArray = Array.sub originalArray 1 2 // creates a sub-array from the original array, starting at index 1 and containing 2 elements
printfn "By using Array.sub: %A" subArray
// Array.append
let firstArray = [|1; 2|]
let secondArray = [|3; 4|]
let combinedArray = Array.append firstArray secondArray // creates a new array by combining the two input arrays
printfn "By using Array.append: %A" combinedArray
Saída:
Empty Array.empty: By using Array.create: 2,2,2,2,2 By using Array.init: 0,1,4,9,16 By using Array.copy: 1,2,3 By using Array.sub: 2,3 By using Array.append: 1,2,3,4
Mais alguns exemplos da função array são:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Array.choose
let inputArray = [|1; 2; 3; 4; 5;|]
let outputArray = Array.choose (fun x -> if x % 2 = 0 then Some x else None) inputArray // creates a new array by selecting only the even numbers from the input array
printfn "By using Array.choose: %A" outputArray
// Array.collect
let nestedArray = [| [|1; 2|]; [|3; 4|] |]
let flatArray = Array.collect (fun x -> x) nestedArray // creates a new array by flattening the nested array into a single-dimensional array
printfn "By using Array.collect%A" flatArray
// Array.concat
let arraysToConcat = [| [|1; 2|]; [|3; 4|]; [|5; 6|] |]
let concatenatedArray = Array.concat arraysToConcat // creates a new array by concatenating all of the input arrays into a single-dimensional array
printfn "By using Array.concat: %A" concatenatedArray
// Array.filter
let filteredArray = Array.filter (fun x -> x % 2 = 0) inputArray // creates a new array by selecting only the even numbers from the input array
printfn "By using Array.filter: %A" filteredArray
// Array.rev
let reversedArray = Array.rev inputArray // creates a new array with the elements in reverse order
printfn "By using Array.rev: %A" reversedArray
E a saída será a seguinte:
By using Array.choose: 2,4 By using Array.collect1,2,3,4 By using Array.concat: 1,2,3,4,5,6 By using Array.filter: 2,4 By using Array.rev: 5,4,3,2,1
Exemplo de Explicação
Esse código usa a função Array.choose para criar uma nova matriz chamada outputArray selecionando apenas os números pares da matriz de entrada inputArray . A função passada para Array.choose pega um elemento da matriz de entrada e retorna um tipo de opção. Some x é retornado para números pares e None é retornado para números ímpares. O outputArray resultante contém apenas os elementos para os quais Some x foi retornado, que são números pares neste caso. Finalmente, a função printfn imprime o outputArray resultante.
Esse código usa a função Array.collect para criar uma nova matriz chamada flatArray , nivelando a matriz aninhada nestedArray em uma matriz unidimensional. A função passada para Array.collect pega um elemento do array de entrada, que é um sub-array neste caso, e retorna o próprio sub-array. O flatArray resultante contém todos os elementos de cada subarray concatenados em um array unidimensional. Finalmente, a função printfn imprime o flatArray resultante.
Esse código usa a função Array.concat para criar uma nova matriz chamada concatenatedArray concatenando todas as matrizes de entrada e arraysToConcat em uma matriz unidimensional. O concatenatedArray resultante contém todos os elementos de cada array de entrada concatenados em ordem. Por fim, a função printfn imprime o concatenatedArray resultante.
Esse código usa a função Array.filter para criar uma nova matriz chamada filtradaArray selecionando apenas os números pares da matriz de entrada inputArray . A função passada para Array.filter pega um elemento do array de entrada e retorna true se ele deve ser incluído no array resultante. Ele retorna false se deve ser excluído. Nesse caso, apenas os números pares passam por esse filtro e são incluídos no filterArray resultante. Por fim, a função printfn imprime o FilterArray resultante.
Pesquisando Arrays em F#
Quando você passa uma função booleana para a função Array.find , ela retorna o primeiro elemento que satisfaz a condição especificada pela função. Se a função retornar false para todos os elementos, uma KeyNotFoundException será lançada.
Para tornar esse processo mais eficiente, você pode usar a função Array.findIndex, que funciona de maneira semelhante a Array.find, mas retorna o índice do primeiro elemento que atende à condição.
Aqui está um exemplo para ilustrar como usar essas funções:
A Microsoft fornece um programa de exemplo interessante que demonstra como encontrar o primeiro elemento dentro de um determinado intervalo que é um quadrado perfeito e um cubo perfeito, usando o Microsoft Visual Basic.
Example:
1
Saída:
The first element that is both a square and a cube is 16 and its index is 14.
Conclusão
As matrizes F# são uma estrutura de dados poderosa que pode ser usada para armazenar e manipular coleções de valores do mesmo tipo. Com a capacidade de criar, acessar, modificar e iterar em arrays, o F# fornece uma ferramenta flexível e eficiente para trabalhar com dados. Ao dominar as matrizes F#, você pode melhorar sua capacidade de escrever código eficiente e eficaz.
Se você gostou deste artigo e achou informativo sobre F# Arrays, você pode deixar seu feedback reagindo abaixo.
Nós valorizamos o seu feedback.
+1
+1
+1
+1
+1
+1
+1
