bau 0.0.2 · OCaml Package

type float32_elt = Bigarray.float32_elt =

| Float32_elt

type float64_elt = Bigarray.float64_elt =

| Float64_elt

type int8_signed_elt = Bigarray.int8_signed_elt =

| Int8_signed_elt

type int8_unsigned_elt = Bigarray.int8_unsigned_elt =

| Int8_unsigned_elt

type int16_signed_elt = Bigarray.int16_signed_elt =

| Int16_signed_elt

type int16_unsigned_elt = Bigarray.int16_unsigned_elt =

| Int16_unsigned_elt

type int32_elt = Bigarray.int32_elt =

| Int32_elt

type int64_elt = Bigarray.int64_elt =

| Int64_elt

type int_elt = Bigarray.int_elt =

| Int_elt

type nativeint_elt = Bigarray.nativeint_elt =

| Nativeint_elt

type complex32_elt = Bigarray.complex32_elt =

| Complex32_elt

type complex64_elt = Bigarray.complex64_elt =

| Complex64_elt

type (!'a, !'b) kind = ('a, 'b) Bigarray.kind =

| Float32 : (float, float32_elt) kind
| Float64 : (float, float64_elt) kind
| Int8_signed : (int, int8_signed_elt) kind
| Int8_unsigned : (int, int8_unsigned_elt) kind
| Int16_signed : (int, int16_signed_elt) kind
| Int16_unsigned : (int, int16_unsigned_elt) kind
| Int32 : (int32, int32_elt) kind
| Int64 : (int64, int64_elt) kind
| Int : (int, int_elt) kind
| Nativeint : (nativeint, nativeint_elt) kind
| Complex32 : (Complex.t, complex32_elt) kind
| Complex64 : (Complex.t, complex64_elt) kind
| Char : (char, int8_unsigned_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 = Bigarray.c_layout =

| C_layout_typ

type fortran_layout = Bigarray.fortran_layout =

| Fortran_layout_typ

type !'a layout = 'a Bigarray.layout =

| C_layout : c_layout layout
| Fortran_layout : fortran_layout layout

val c_layout : c_layout layout

val fortran_layout : fortran_layout layout

module Genarray = Bigarray.Genarray

module Array1 = Bigarray.Array1

module Array2 = Bigarray.Array2

module Array3 = Bigarray.Array3

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

val reshape : ('a, 'b, 'c) Genarray.t -> int array -> ('a, 'b, 'c) Genarray.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

val isf : 'a layout -> bool

val to_offset : 'a layout -> int -> int

val foreach : 'a layout -> int -> (int -> 'b) -> unit

module A1 : sig ... end

module A2 : sig ... end

module A3 : sig ... end

module GA : sig ... end

package bau