模組 Stdlib.Bigarray

module Bigarray: Bigarray

元素種類

Bigarray 可以包含以下種類的元素

• IEEE 半精度（16 位元）浮點數 (Bigarray.float16_elt),
• IEEE 單精度（32 位元）浮點數 (Bigarray.float32_elt),
• IEEE 雙精度（64 位元）浮點數 (Bigarray.float64_elt),
• IEEE 單精度（2 * 32 位元）浮點複數 (Bigarray.complex32_elt),
• IEEE 雙精度（2 * 64 位元）浮點複數 (Bigarray.complex64_elt),
• 8 位元整數（有號或無號）(Bigarray.int8_signed_elt 或 Bigarray.int8_unsigned_elt),
• 16 位元整數（有號或無號）(Bigarray.int16_signed_elt 或 Bigarray.int16_unsigned_elt),
• OCaml 整數（有號，在 32 位元架構上為 31 位元，在 64 位元架構上為 63 位元）(Bigarray.int_elt),
• 32 位元有號整數 (Bigarray.int32_elt),
• 64 位元有號整數 (Bigarray.int64_elt),
• 平台原生有號整數（在 32 位元架構上為 32 位元，在 64 位元架構上為 64 位元）(Bigarray.nativeint_elt)。

每個元素種類在型別層級上都由以下定義的 *_elt 型別之一表示（為了技術上的內射性原因，使用單一建構子而非抽象型別定義）。

type float16_elt = 

type float32_elt = 

type float64_elt = 

type int8_signed_elt = 

type int8_unsigned_elt = 

type int16_signed_elt = 

type int16_unsigned_elt = 

type int32_elt = 

type int64_elt = 

type int_elt = 

type nativeint_elt = 

type complex32_elt = 

type complex64_elt = 

type ('a, 'b) kind = 

  let zero : type a b. (a, b) kind -> a = function
    | Float32 -> 0.0 | Complex32 -> Complex.zero
    | Float64 -> 0.0 | Complex64 -> Complex.zero
    | Float16 -> 0.0
    | Int8_signed -> 0 | Int8_unsigned -> 0
    | Int16_signed -> 0 | Int16_unsigned -> 0
    | Int32 -> 0l | Int64 -> 0L
    | Int -> 0 | Nativeint -> 0n
    | Char -> '\000'

val float16 : (float, float16_elt) kind

val float32 : (float, float32_elt) kind

val float64 : (float, float64_elt) kind

val complex32 : (Complex.t, complex32_elt) kind

val complex64 : (Complex.t, complex64_elt) kind

val int8_signed : (int, int8_signed_elt) kind

val int8_unsigned : (int, int8_unsigned_elt) kind

val int16_signed : (int, int16_signed_elt) kind

val int16_unsigned : (int, int16_unsigned_elt) kind

val int : (int, int_elt) kind

val int32 : (int32, int32_elt) kind

val int64 : (int64, int64_elt) kind

val nativeint : (nativeint, nativeint_elt) kind

val char : (char, int8_unsigned_elt) kind

val kind_size_in_bytes : ('a, 'b) kind -> int

陣列配置

type c_layout = 

type fortran_layout = 

支援的配置

GADT 型別 'a layout 代表兩種支援的記憶體配置之一：C 風格或 Fortran 風格。它的建構子在下方重新匯出為值，以確保向後相容性。

type 'a layout = 

val c_layout : c_layout layout

val fortran_layout : fortran_layout layout

通用陣列（任意多維度）

module Genarray: sig .. end

零維陣列

module Array0: sig .. end

一維陣列

module Array1: sig .. end

二維陣列

module Array2: sig .. end

三維陣列

module Array3: sig .. end

通用 Bigarray 和固定維度 Bigarray 之間的轉換

val genarray_of_array0 : ('a, 'b, 'c) Array0.t -> ('a, 'b, 'c) Genarray.t

val genarray_of_array1 : ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.t

val genarray_of_array2 : ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.t

val genarray_of_array3 : ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.t

val array0_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.t

val array1_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.t

val array2_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.t

val array3_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.t

重新塑造 Bigarray

val reshape : ('a, 'b, 'c) Genarray.t ->
       int array -> ('a, 'b, 'c) Genarray.t

val reshape_0 : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.t

val reshape_1 : ('a, 'b, 'c) Genarray.t -> int -> ('a, 'b, 'c) Array1.t

val reshape_2 : ('a, 'b, 'c) Genarray.t ->
       int -> int -> ('a, 'b, 'c) Array2.t

val reshape_3 : ('a, 'b, 'c) Genarray.t ->
       int -> int -> int -> ('a, 'b, 'c) Array3.t

Bigarray 和並發安全

當從多個域並發存取 bigarray 時，必須小心：存取 bigarray 永遠不會使程式崩潰，但是未同步的存取可能會產生令人驚訝的（非循序一致）結果。

原子性

每個存取多個陣列元素的 bigarray 操作都不是原子操作。這包括切片、複製和填充 bigarray。

例如，考慮以下程式碼

open Bigarray
let size = 100_000_000
let a = Array1.init Int C_layout size (fun _ -> 1)
let update f a () =
  for i = 0 to size - 1 do a.{i} <- f a.{i} done
let d1 = Domain.spawn (update (fun x -> x + 1) a)
let d2 = Domain.spawn (update (fun x -> 2 * x + 1) a)
let () = Domain.join d1; Domain.join d2

執行此程式碼後，bigarray a 的每個欄位不是 2，就是 3、4 或 5。如果需要原子性，則使用者必須實作自己的同步機制（例如，使用 Mutex.t）。

資料競爭

如果兩個域僅存取 bigarray 的不相交部分，則觀察到的行為等效於來自兩個域的操作的一些循序交錯。

當兩個域在沒有同步的情況下存取相同的 bigarray 元素，並且至少有一個存取是寫入操作時，就會發生資料競爭。在沒有資料競爭的情況下，觀察到的行為等效於來自不同域的操作的一些循序交錯。

應盡可能避免資料競爭，方法是使用同步來調節對 bigarray 元素的存取。

實際上，在存在資料競爭的情況下，程式不會崩潰，但是觀察到的行為可能不等效於來自不同域的操作的任何循序交錯。

撕裂

Bigarray 在存在資料競爭時有一個明顯的警告：由於撕裂，並發的 bigarray 操作可能會產生令人驚訝的值。更精確地說，部分寫入和讀取的交錯可能會產生在循序執行中不存在的值。例如，在結尾的

let res = Array1.init Complex64 c_layout size (fun _ -> Complex.zero)
let d1 = Domain.spawn (fun () -> Array1.fill res Complex.one)
let d2 = Domain.spawn (fun () -> Array1.fill res Complex.i)
let () = Domain.join d1; Domain.join d2

res bigarray 可能包含既不是 Complex.i 也不是 Complex.one 的值（例如 1 + i）。