配列Arrays

注意

API リファレンスのリンクをクリックすると MSDN に移動します。The API reference link will take you to MSDN. docs.microsoft.com API リファレンスは完全ではありません。The docs.microsoft.com API reference is not complete.

配列は、0 から始まる一連のデータ要素の、固定サイズの変更可能なコレクションで、その型はすべて同じです。Arrays are fixed-size, zero-based, mutable collections of consecutive data elements that are all of the same type.

配列の作成Creating Arrays

配列は複数の方法で作成できます。You can create arrays in several ways. 次の例に示すように、[||] の間の連続する値をセミコロンで区切って、小さい配列を作成できます。You can create a small array by listing consecutive values between [| and |] and separated by semicolons, as shown in the following examples.

let array1 = [| 1; 2; 3 |]

各要素を別々の行に配置することもでき、その場合は、セミコロンの区切り記号を省略できます。You can also put each element on a separate line, in which case the semicolon separator is optional.

let array1 =
    [|
        1
        2
        3
     |]

配列の要素の型は、使用されるリテラルから推論され、すべて同じである必要があります。The type of the array elements is inferred from the literals used and must be consistent. 次のコードは、1.0 が浮動小数点数で、2 と 3 は整数であるため、エラーになります。The following code causes an error because 1.0 is a float and 2 and 3 are integers.

// Causes an error.
// let array2 = [| 1.0; 2; 3 |]

シーケンス式を使用して配列を作成することもできます。You can also use sequence expressions to create arrays. 1 から 10 までの整数の 2 乗の配列を作成する例を次に示します。Following is an example that creates an array of squares of integers from 1 to 10.

let array3 = [| for i in 1 .. 10 -> i * i |]

すべての要素が 0 に初期化される配列を作成するには、Array.zeroCreate を使用します。To create an array in which all the elements are initialized to zero, use Array.zeroCreate.

let arrayOfTenZeroes : int array = Array.zeroCreate 10

要素へのアクセスAccessing Elements

配列要素には、ドット演算子 (.) と角かっこ ([]) を使用してアクセスできます。You can access array elements by using a dot operator (.) and brackets ([ and ]).

array1.[0]

配列のインデックスは0から始まります。Array indexes start at 0.

また、スライス表記を使用して配列の要素にアクセスすることもできます。この方法では、配列のサブ範囲を指定できます。You can also access array elements by using slice notation, which enables you to specify a subrange of the array. スライス表記の例を次に示します。Examples of slice notation follow.

// 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..]

スライス表記を使用するときは、配列の新しいコピーが作成されます。When slice notation is used, a new copy of the array is created.

配列の型とモジュールArray Types and Modules

F# の配列の型はすべて、.NET Framework 型の System.Array です。The type of all F# arrays is the .NET Framework type System.Array. したがって、F# の配列では、System.Array で使用できるすべての機能がサポートされます。Therefore, F# arrays support all the functionality available in System.Array.

ライブラリモジュールMicrosoft.FSharp.Collections.Arrayは、1次元配列に対する操作をサポートしています。The library module Microsoft.FSharp.Collections.Array supports operations on one-dimensional arrays. Array2DArray3DArray4D の各モジュールには、それぞれ、2 次元、3 次元、4 次元の配列の操作をサポートする関数があります。The modules Array2D, Array3D, and Array4D contain functions that support operations on arrays of two, three, and four dimensions, respectively. 4 より大きいランクの配列は、System.Array を使用して作成できます。You can create arrays of rank greater than four by using System.Array.

単純な関数Simple Functions

Array.get要素を取得します。Array.get gets an element. Array.length配列の長さを示します。Array.length gives the length of an array. 要素を指定された値に設定Array.setます。Array.set sets an element to a specified value. これらの関数の使い方を次のコード例に示します。The following code example illustrates the use of these functions.

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)

出力は次のとおりです。The output is as follows.

0 1 2 3 4 5 6 7 8 9

配列を作成する関数Functions That Create Arrays

既存の配列を必要とせずに配列を作成できる関数がいくつかあります。Several functions create arrays without requiring an existing array. Array.emptyは、要素を含まない新しい配列を作成します。Array.empty creates a new array that does not contain any elements. Array.createは、指定されたサイズの配列を作成し、すべての要素を指定された値に設定します。Array.create creates an array of a specified size and sets all the elements to provided values. Array.initは、要素を生成するためのディメンションと関数を指定して、配列を作成します。Array.init creates an array, given a dimension and a function to generate the elements. Array.zeroCreateは、すべての要素が配列の型の0値に初期化される配列を作成します。Array.zeroCreate creates an array in which all the elements are initialized to the zero value for the array's type. これらの関数の例を次のコードに示します。The following code demonstrates these functions.

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

出力は次のとおりです。The output is as follows.

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は、既存の配列からコピーされる要素を格納する新しい配列を作成します。Array.copy creates a new array that contains elements that are copied from an existing array. コピーは簡易コピーです。つまり、要素の型が参照型である場合は、参照だけがコピーされ、基になっているオブジェクトはコピーされません。Note that the copy is a shallow copy, which means that if the element type is a reference type, only the reference is copied, not the underlying object. これを次のコード例に示します。The following code example illustrates this.

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

このコードによる出力は、次のようになります。The output of the preceding code is as follows:

[|Test1; Test2; |]
[|; Test2; |]

Test1 という文字列は、最初の配列にのみ表示されます。これは、firstArray の参照が、新しい要素を作成する操作によって上書きされるものの、空の文字列への元の参照は影響を受けず、secondArray にまだ存在しているためです。The string Test1 appears only in the first array because the operation of creating a new element overwrites the reference in firstArray but does not affect the original reference to an empty string that is still present in secondArray. Test2 という文字列は、両方の配列で表示されます。これは、Insert 型に対する System.Text.StringBuilder 操作は基になっている System.Text.StringBuilder オブジェクトに影響を与え、このオブジェクトは両方の配列で参照されているためです。The string Test2 appears in both arrays because the Insert operation on the System.Text.StringBuilder type affects the underlying System.Text.StringBuilder object, which is referenced in both arrays.

Array.subは、配列のサブ範囲から新しい配列を生成します。Array.sub generates a new array from a subrange of an array. サブ範囲は、開始インデックスと長さで指定します。You specify the subrange by providing the starting index and the length. Array.sub を使用したコードの例を次に示します。The following code demonstrates the use of Array.sub.

let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2

出力では、サブ配列が要素 5 から開始し、10 個の要素を含むことが示されています。The output shows that the subarray starts at element 5 and contains 10 elements.

[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]

Array.appendは、既存の2つの配列を組み合わせることによって新しい配列を作成します。Array.append creates a new array by combining two existing arrays.

次のコードは、 Array. appendを示しています。The following code demonstrates Array.append.

printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

[|1; 2; 3; 4; 5; 6|]

Array.chooseは、新しい配列に含める配列の要素を選択します。Array.choose selects elements of an array to include in a new array. 次のコードで Array.choose の例を示します。The following code demonstrates Array.choose. 配列の要素の型は、オプションの型で返される値の型と一致している必要はありません。Note that the element type of the array does not have to match the type of the value returned in the option type. この例では、要素の型は int ですが、オプションは多項式関数 elem*elem - 1 の結果であり、浮動小数点数です。In this example, the element type is int and the option is the result of a polynomial function, elem*elem - 1, as a floating point number.

printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
                                            Some(float (elem*elem - 1))
                                        else
                                            None) [| 1 .. 10 |])

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

[|3.0; 15.0; 35.0; 63.0; 99.0|]

Array.collectは、既存の配列の各配列要素に対して指定された関数を実行し、関数によって生成された要素を収集して、新しい配列に結合します。Array.collect runs a specified function on each array element of an existing array and then collects the elements generated by the function and combines them into a new array. 次のコードで Array.collect の例を示します。The following code demonstrates Array.collect.

printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

[|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]

Array.concatは配列のシーケンスを受け取り、それらを1つの配列に結合します。Array.concat takes a sequence of arrays and combines them into a single array. 次のコードで Array.concat の例を示します。The following code demonstrates Array.concat.

Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]

Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

[|(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はブール条件関数を受け取り、条件が true である入力配列の要素のみを含む新しい配列を生成します。Array.filter takes a Boolean condition function and generates a new array that contains only those elements from the input array for which the condition is true. 次のコードで Array.filter の例を示します。The following code demonstrates Array.filter.

printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

[|2; 4; 6; 8; 10|]

Array.revは、既存の配列の順序を逆にして新しい配列を生成します。Array.rev generates a new array by reversing the order of an existing array. 次のコードで Array.rev の例を示します。The following code demonstrates Array.rev.

let stringReverse (s: string) =
    System.String(Array.rev (s.ToCharArray()))

printfn "%A" (stringReverse("!dlrow olleH"))

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

"Hello world!"

次の例に示すように、パイプライン演算子 (|>) を使用して配列を変換する配列モジュールの関数を簡単に組み合わせることができます。You can easily combine functions in the array module that transform arrays by using the pipeline operator (|>), as shown in the following example.

[| 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"

出力は次のようになります。The output is

[|100; 36; 16; 4|]

多次元配列Multidimensional Arrays

多次元配列を作成できますが、多次元配列リテラルを記述するための構文はありません。A multidimensional array can be created, but there is no syntax for writing a multidimensional array literal. 配列要素のシーケンスのシーケンスから配列を作成するには、 array2D演算子を使用します。Use the operator array2D to create an array from a sequence of sequences of array elements. シーケンスには、配列リテラルまたはリスト リテラルを使用できます。The sequences can be array or list literals. たとえば、次のコードでは 2 次元の配列が作成されます。For example, the following code creates a two-dimensional array.

let my2DArray = array2D [ [ 1; 0]; [0; 1] ]

また、関数Array2D.initを使用して2つの次元の配列を初期化することもできます。また、3次元と4次元の配列でも同様の関数を使用できます。You can also use the function Array2D.init to initialize arrays of two dimensions, and similar functions are available for arrays of three and four dimensions. これらの関数は、要素の作成に使用する関数を受け取ります。These functions take a function that is used to create the elements. 関数を指定する代わりに初期値に設定された要素を含む2次元配列を作成するには、 Array2D.create関数を使用します。これは、最大4次元の配列で使用できます。To create a two-dimensional array that contains elements set to an initial value instead of specifying a function, use the Array2D.create function, which is also available for arrays up to four dimensions. 次のコード例では、まず、目的の要素を含む複数の配列から成る 1 つの配列を作成し、次に、Array2D.init を使用して目的の 2 次元配列を生成する方法を示します。The following code example first shows how to create an array of arrays that contain the desired elements, and then uses Array2D.init to generate the desired two-dimensional array.

let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays.[i].[j])

配列インデックスとスライス構文は、4 ランクまでの配列に使用できます。Array indexing and slicing syntax is supported for arrays up to rank 4. 複数の次元でインデックスを指定する場合は、次のコード例に示すように、コンマを使用してインデックスを区切ります。When you specify an index in multiple dimensions, you use commas to separate the indexes, as illustrated in the following code example.

twoDimensionalArray.[0, 1] <- 1.0

2 次元配列の型は <type>[,] として書き出され (int[,]double[,] など)、3 次元配列の型は <type>[,,] として書き出されます。このように、次元が高くなるにつれ、書き出される型が変わります。The type of a two-dimensional array is written out as <type>[,] (for example, int[,], double[,]), and the type of a three-dimensional array is written as <type>[,,], and so on for arrays of higher dimensions.

1 次元配列で使用できる関数のサブセットのうち、多次元配列でも使用できるのは一部だけです。Only a subset of the functions available for one-dimensional arrays is also available for multidimensional arrays. 詳細については、「 Collections.Array ModuleCollections.Array2D ModuleCollections.Array3D Module、およびCollections.Array4D Module」を参照してください。For more information, see Collections.Array Module, Collections.Array2D Module, Collections.Array3D Module, and Collections.Array4D Module.

配列スライスと多次元配列Array Slicing and Multidimensional Arrays

2次元配列 (マトリックス) では、範囲を指定し、ワイルドカード (*) 文字を使用して行または列全体を指定することによって、サブマトリックスを抽出できます。In a two-dimensional array (a matrix), you can extract a sub-matrix by specifying ranges and using a wildcard (*) character to specify whole rows or columns.

// 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]

F# 3.1 では、多次元配列を同じまたは低い次元のサブ配列に多次元配列を分解することができます。As of F# 3.1, you can decompose a multidimensional array into subarrays of the same or lower dimension. たとえば、単一の行または列を指定して、行列からベクターを取得できます。For example, you can obtain a vector from a matrix by specifying a single row or column.

// Get row 3 from a matrix as a vector:
matrix.[3, *]

// Get column 3 from a matrix as a vector:
matrix.[*, 3]

このスライス構文は、要素アクセス演算子およびオーバーロードされた GetSlice メソッドを実装する型に使用できます。You can use this slicing syntax for types that implement the element access operators and overloaded GetSlice methods. たとえば、次のコードは、F# 2D 配列をラップし、配列のインデックスのサポートを提供する項目プロパティを実装し、3 つのバージョンの GetSlice を実装するマトリックス型を作成します。For example, the following code creates a Matrix type that wraps the F# 2D array, implements an Item property to provide support for array indexing, and implements three versions of GetSlice. マトリックス型のテンプレートとしてこのコードの使用が可能であれば、このセクションで説明するすべてのスライスの操作を使用できます。If you can use this code as a template for your matrix types, you can use all the slicing operations that this section describes.

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 "%A" submatrix

    let firstRow = test1.[0,*]
    let secondRow = test1.[1,*]
    let firstCol = test1.[*,0]
    printfn "%A" firstCol

配列に対するブール条件Boolean Functions on Arrays

関数は、1つまたは2つの配列内の各要素をそれぞれArray.existsおよびArray.exists2テストします。The functions Array.exists and Array.exists2 test elements in either one or two arrays, respectively. これらの関数は、テスト用の関数を受け取り、要素 (または true の場合は要素のペア) のうち、条件を満たす要素がある場合は Array.exists2 を返します。These functions take a test function and return true if there is an element (or element pair for Array.exists2) that satisfies the condition.

次のコードは、Array.existsArray.exists2 の使用方法を示しています。The following code demonstrates the use of Array.exists and Array.exists2. これらの例では、ただ 1 つの引数 (この場合は関数引数) を適用することで、新しい関数を作成しています。In these examples, new functions are created by applying only one of the arguments, in these cases, the function argument.

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|])

このコードによる出力は、次のようになります。The output of the preceding code is as follows.

true
false
false
true

同様に、関数Array.forallは配列をテストして、すべての要素がブール条件を満たすかどうかを判断します。Similarly, the function Array.forall tests an array to determine whether every element satisfies a Boolean condition. バリエーションArray.forall2は、同じ長さの2つの配列の要素を含むブール関数を使用することで、同じことを行います。The variation Array.forall2 does the same thing by using a Boolean function that involves elements of two arrays of equal length. これらの関数の使い方を次のコード例に示します。The following code illustrates the use of these functions.

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 |])

これらの例の出力は次のようになります。The output for these examples is as follows.

false
true
true
false

配列の検索Searching Arrays

Array.findはブール関数を受け取り、関数が trueを返す最初の要素を返します。条件を満たす要素が見つからない場合は System.Collections.Generic.KeyNotFoundException を発生させます。Array.find takes a Boolean function and returns the first element for which the function returns true, or raises a System.Collections.Generic.KeyNotFoundException if no element that satisfies the condition is found. Array.findIndexArray.findに似ていますが、要素自体の代わりに要素のインデックスを返す点が異なります。Array.findIndex is like Array.find, except that it returns the index of the element instead of the element itself.

次のコードでは、Array.findArray.findIndex を使用して、完全平方かつ完全立方である値を探しています。The following code uses Array.find and Array.findIndex to locate a number that is both a perfect square and perfect cube.

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

出力は次のとおりです。The output is as follows.

The first element that is both a square and a cube is 64 and its index is 62.

Array.tryFindArray.findに似ていますが、結果がオプションの型であることを除けば、要素が見つからない場合は None が返されます。Array.tryFind is like Array.find, except that its result is an option type, and it returns None if no element is found. 一致する要素が配列内に存在するかどうかわからない場合は、Array.find の代わりに Array.tryFind を使用する必要があります。Array.tryFind should be used instead of Array.find when you do not know whether a matching element is in the array. 同様に、 Array.tryFindIndexArray.findIndexに似ていますが、オプションの型が戻り値である点が異なります。Similarly, Array.tryFindIndex is like Array.findIndex except that the option type is the return value. 要素が見つからない場合、オプションは None です。If no element is found, the option is None.

Array.tryFind を使用したコードの例を次に示します。The following code demonstrates the use of Array.tryFind. このコードでは、前に示したコードを利用しています。This code depends on the previous code.

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 |]

出力は次のとおりです。The output is as follows.

Found an element: 1
Found an element: 729
Failed to find a matching element.

要素を検索するだけでなく、要素を変換する必要がある場合は、 Array.tryPickを使用します。Use Array.tryPick when you need to transform an element in addition to finding it. この関数の結果は、変換した要素をオプションの値として返した最初の要素になります。該当する要素が見つからない場合は、None を返します。The result is the first element for which the function returns the transformed element as an option value, or None if no such element is found.

Array.tryPick の使用方法を次のコードに示します。The following code shows the use of Array.tryPick. この例では、ラムダ式の代わりに、複数のローカル ヘルパー関数を定義することでコードを簡単にしています。In this case, instead of a lambda expression, several local helper functions are defined to simplify the code.

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 |]

出力は次のとおりです。The output is as follows.

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.

配列に対する計算の実行Performing Computations on Arrays

Array.average関数は、配列内の各要素の平均を返します。The Array.average function returns the average of each element in an array. この関数を使用できるのは、整数による正確な除算がサポートされている要素型だけです。そのため、浮動小数点型では使用できますが、整数型では使用できません。It is limited to element types that support exact division by an integer, which includes floating point types but not integral types. Array.averageBy関数は、各要素に対して関数を呼び出した結果の平均を返します。The Array.averageBy function returns the average of the results of calling a function on each element. 整数型の配列の場合は、Array.averageBy を使用し、この関数で各要素を浮動小数点型に変換して計算することもできます。For an array of integral type, you can use Array.averageBy and have the function convert each element to a floating point type for the computation.

要素の型でサポートされている場合は、 Array.maxまたはArray.minを使用して、要素の最大値または最小値を取得します。Use Array.max or Array.min to get the maximum or minimum element, if the element type supports it. 同様に、 Array.maxByArray.minByを使用すると、最初に関数を実行して、比較をサポートする型に変換することができます。Similarly, Array.maxBy and Array.minBy allow a function to be executed first, perhaps to transform to a type that supports comparison.

Array.sumによって配列の要素が追加されArray.sumBy 、各要素に対して関数が呼び出され、結果が加算されます。Array.sum adds the elements of an array, and Array.sumBy calls a function on each element and adds the results together.

戻り値を格納せずに、配列内の各要素に対して関数を実行するには、 Array.iterを使用します。To execute a function on each element in an array without storing the return values, use Array.iter. 同じ長さの2つの配列を含む関数の場合は、 Array.iter2を使用します。For a function involving two arrays of equal length, use Array.iter2. また、関数の結果の配列を保持する必要がある場合は、 Array.mapまたはArray.map2を使用します。これは、一度に2つの配列を操作します。If you also need to keep an array of the results of the function, use Array.map or Array.map2, which operates on two arrays at a time.

バリエーションArray.iteriArray.iteri2を使用すると、要素のインデックスを計算に含めることができます。Array.mapiArray.mapi2にも同じことが当てはまります。The variations Array.iteri and Array.iteri2 allow the index of the element to be involved in the computation; the same is true for Array.mapi and Array.mapi2.

関数は、配列のすべての要素を含む、 Array.foldArray.foldBackArray.reduceArray.reduceBackArray.scan、およびArray.scanBackの実行アルゴリズムを実行します。The functions Array.fold, Array.foldBack, Array.reduce, Array.reduceBack, Array.scan, and Array.scanBack execute algorithms that involve all the elements of an array. 同様にArray.fold2Array.foldBack2のバリエーションは、2つの配列に対して計算を実行します。Similarly, the variations Array.fold2 and Array.foldBack2 perform computations on two arrays.

計算を実行するためのこれらの関数は、 List モジュール内の同じ名前の関数に対応しています。These functions for performing computations correspond to the functions of the same name in the List module. 使用例については、「リスト」を参照してください。For usage examples, see Lists.

配列の変更Modifying Arrays

要素を指定された値に設定Array.setます。Array.set sets an element to a specified value. 配列内の要素の範囲を指定した値にArray.fill設定します。Array.fill sets a range of elements in an array to a specified value. Array.fill のコード例を次に示します。The following code provides an example of Array.fill.

let arrayFill1 = [| 1 .. 25 |]
Array.fill arrayFill1 2 20 0
printfn "%A" arrayFill1

出力は次のとおりです。The output is as follows.

[|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|]

Array.blitを使用すると、ある配列のサブセクションを別の配列にコピーできます。You can use Array.blit to copy a subsection of one array to another array.

他の型との相互変換Converting to and from Other Types

Array.ofListリストから配列を作成します。Array.ofList creates an array from a list. シーケンスから配列を作成Array.ofSeqます。Array.ofSeq creates an array from a sequence. Array.toListおよびArray.toSeq 、配列型から他のコレクション型に変換します。Array.toList and Array.toSeq convert to these other collection types from the array type.

配列の並べ替えSorting Arrays

汎用比較関数を使用して配列を並べ替えるには、 Array.sortを使用します。Use Array.sort to sort an array by using the generic comparison function. キーと呼ばれる値を生成する関数を指定するには、 Array.sortByを使用します。この関数は、キーに対する汎用比較関数を使用して並べ替えます。Use Array.sortBy to specify a function that generates a value, referred to as a key, to sort by using the generic comparison function on the key. カスタム比較関数を指定する場合は、 Array.sortWithを使用します。Use Array.sortWith if you want to provide a custom comparison function. Array.sortArray.sortBy、および Array.sortWith はすべて、並べ替えられた配列を新しい配列として返します。Array.sort, Array.sortBy, and Array.sortWith all return the sorted array as a new array. バリエーションArray.sortInPlaceArray.sortInPlaceByArray.sortInPlaceWith新しい配列を返すのではなく、既存の配列を変更します。The variations Array.sortInPlace, Array.sortInPlaceBy, and Array.sortInPlaceWith modify the existing array instead of returning a new one.

配列とタプルArrays and Tuples

関数は、組のペアの配列を配列のタプルに変換し、その逆もArray.unzip Array.zipします。The functions Array.zip and Array.unzip convert arrays of tuple pairs to tuples of arrays and vice versa. Array.zip3Array.unzip3は似ていますが、3つの要素または3つの配列の組で動作する点が異なります。Array.zip3 and Array.unzip3 are similar except that they work with tuples of three elements or tuples of three arrays.

配列に対する並列計算Parallel Computations on Arrays

モジュールArray.Parallelには、配列に対して並列計算を実行する関数が含まれています。The module Array.Parallel contains functions for performing parallel computations on arrays. このモジュールは、Version 4 より前の .NET Framework を対象とするアプリケーションでは使用できません。This module is not available in applications that target versions of the .NET Framework prior to version 4.

参照See also