| Chapter 28 |
The bigarray library |
|
The bigarray library implements large, multi-dimensional, numerical
arrays. These arrays are called ``big arrays'' to distinguish them
from the standard Caml arrays described in section 19.2.
The main differences between ``big arrays'' and standard Caml arrays
are as follows:
-
Big arrays are not limited in size, unlike Caml arrays
(float array are limited to 2097151 elements on a 32-bit platform,
other array types to 4194303 elements).
- Big arrays are multi-dimensional. Any number of dimensions
between 1 and 16 is supported. In contrast, Caml arrays are
mono-dimensional and require encoding multi-dimensional arrays as
arrays of arrays.
- Big arrays can only contain integers and floating-point
numbers, while Caml arrays can contain arbitrary Caml data types.
However, big arrays provide more space-efficient storage of integer
and floating-point elements, in particular because they support
``small'' types such as single-precision floats and 8 and 16-bit
integers, in addition to the standard Caml types of double-precision
floats and 32 and 64-bit integers.
- The memory layout of big arrays is entirely compatible with that
of arrays in C and Fortran, allowing large arrays to be passed back
and forth between Caml code and C / Fortran code with no data copying
at all.
- Big arrays support interesting high-level operations that normal
arrays do not provide efficiently, such as extracting sub-arrays and
``slicing'' a multi-dimensional array along certain dimensions, all
without any copying.
Programs that use the bigarray library must be linked as follows:
ocamlc other options bigarray.cma other files
ocamlopt other options bigarray.cmxa other files
For interactive use of the bigarray library, do:
ocamlmktop -o mytop bigarray.cma
./mytop
or (if dynamic linking of C libraries is supported on your platform),
start ocaml and type #load "bigarray.cma";;.
| 28.1 |
Module Bigarray: large, multi-dimensional, numerical arrays |
|
This module implements multi-dimensional arrays of integers and
floating-point numbers, thereafter referred to as ``big arrays''.
The implementation allows efficient sharing of large numerical
arrays between Caml code and C or Fortran numerical libraries.
Concerning the naming conventions, users of this module are encouraged
to do open Bigarray in their source, then refer to array types and
operations via short dot notation, e.g. Array1.t or Array2.sub.
Big arrays support all the Caml ad-hoc polymorphic operations:
comparisons (=, <>, <=, etc, as well as compare);
hashing (module