模組 Bigarray

module Bigarray: sig .. end

元素種類

Bigarrays 可以包含以下種類的元素：

• 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）。