package tensorflow

You can search for identifiers within the package.

in-package search v0.2.0

package tensorflow

tensorflow
- Tensorflow

Legend:
Library
Module
Module type
Parameter
Class
Class type

exception Error of int * string

val string_of_loc : int -> string

val strerr : int -> string -> string

val buf_error : int -> string -> 'a

val error : 'a -> string -> 'b

type string_slice = {

s : string;
start_pos : int;
len : int;
mutable pos : int;

}

val list_map_slow : ('a -> 'b) -> 'a list -> 'b list

val list_count_map : ('a -> 'b) -> 'a list -> int -> 'b list

val list_map : ('a -> 'b) -> 'a list -> 'b list

module List : sig ... end

module IBuf : sig ... end

type t =

| Varint of int
| Varint64 of int64
| Int32 of int32
| Int64 of int64
| Block of IBuf.t
| Top_block of IBuf.t

val init_from_channel : Pervasives.in_channel -> t

val init_from_string : string -> t

val error_variant : 'a -> int -> 'b

val error_missing : 'a -> int -> 'b

val error_enum_const : 'a -> 'b

val check_unparsed_fields : 'a -> unit

val next_varint_byte : IBuf.t -> int * int

val parse_varint64 : int -> IBuf.t -> int -> int -> int -> t

val parse_varint_common : IBuf.t -> int -> int -> t

val parse_varint : IBuf.t -> t

val try_parse_varint : IBuf.t -> t

val parse_fixed32 : IBuf.t -> int32

val parse_fixed64 : IBuf.t -> int64

val try_parse_fixed32 : IBuf.t -> int32

val try_parse_fixed64 : IBuf.t -> int64

val parse_field_header : IBuf.t -> int * int

val parse_field : IBuf.t -> (int * t) option

val parse_toplevel_header : IBuf.t -> t

val expect_int32 : t -> int32

val expect_int64 : t -> int64

val zigzag_varint_of_varint : t -> t

val max_uint : int64

val int64_of_uint : int -> int64

val int64_of_uint32 : int32 -> int64

val int_of_varint : t -> int

val int_of_signed_varint : t -> int

val int_of_zigzag_varint : t -> int

val int_of_fixed32 : t -> int

val int_of_fixed64 : t -> int

val int64_of_varint : t -> int64

val int64_of_signed_varint : t -> int64

val int64_of_zigzag_varint : t -> int64

val int64_of_fixed32 : t -> int64

val int64_of_fixed64 : t -> int64

val int64_of_signed_fixed32 : t -> int64

val int64_of_signed_fixed64 : t -> int64

val int32_of_varint : t -> int32

val int32_of_signed_varint : t -> int32

val int32_of_zigzag_varint : t -> int32

val int32_of_fixed32 : t -> int32

val int32_of_signed_fixed32 : t -> int32

val float_of_int32 : int32 -> float

val float_of_int64 : int64 -> float

val float_of_fixed64 : t -> float

val float_of_fixed32 : t -> float

val bool_of_varint : t -> bool

val parse_bool_field : t -> bool

val parse_binary_field : t -> string

val validate_string : 'a -> 'a

val parse_string_field : t -> string

val string_of_block : t -> string

val word_of_block : t -> string

val text_of_block : t -> string

val int_of_packed_varint : IBuf.t -> int

val int_of_packed_signed_varint : IBuf.t -> int

val int_of_packed_zigzag_varint : IBuf.t -> int

val int_of_packed_fixed32 : IBuf.t -> int

val int_of_packed_fixed64 : IBuf.t -> int

val int64_of_packed_varint : IBuf.t -> int64

val int64_of_packed_signed_varint : IBuf.t -> int64

val int64_of_packed_zigzag_varint : IBuf.t -> int64

val int64_of_packed_fixed64 : IBuf.t -> int64

val int64_of_packed_fixed32 : IBuf.t -> int64

val int64_of_packed_signed_fixed64 : IBuf.t -> int64

val int64_of_packed_signed_fixed32 : IBuf.t -> int64

val int32_of_packed_varint : IBuf.t -> int32

val int32_of_packed_signed_varint : IBuf.t -> int32

val int32_of_packed_zigzag_varint : IBuf.t -> int32

val int32_of_packed_fixed32 : IBuf.t -> int32

val int32_of_packed_signed_fixed32 : IBuf.t -> int32

val float_of_packed_fixed32 : IBuf.t -> float

val float_of_packed_fixed64 : IBuf.t -> float

val bool_of_packed_varint : IBuf.t -> bool

val parse_record_buf : IBuf.t -> (int * t) list

val parse_record : t -> (int * t) list

val parse_variant : t -> int * t

val find_fields : 'a -> ('a * 'b) list -> 'b list * ('a * 'b) list

val find_field : 'a -> ('a * 'b) list -> 'b option * ('a * 'b) list

val parse_binobj : (t -> 'a) -> string -> 'a

val parse_default : string -> t

val parse_required_field : 
  int ->
  (t -> 'a) ->
  ?default:string ->
  (int * t) list ->
  'a * (int * t) list

val parse_optional_field : 
  'a ->
  (t -> 'b) ->
  ?default:string ->
  ('a * t) list ->
  'b option * ('a * t) list

val parse_repeated_field : 
  'a ->
  ('b -> 'c) ->
  ('a * 'b) list ->
  'c list * ('a * 'b) list

val map_l2a : ('a -> 'b) -> 'a list -> 'b array

val parse_repeated_array_field : 
  'a ->
  ('b -> 'c) ->
  ('a * 'b) list ->
  'c array * ('a * 'b) list

val parse_packed_fields : ('a -> 'b) -> 'a -> 'b list

val parse_packed_field : (IBuf.t -> 'a) -> (t -> 'a) -> t -> 'a list

val parse_packed_array_field : int -> (IBuf.t -> 'a) -> IBuf.t -> 'a array

val rev_flatmap : ('a -> 'b list) -> 'a list -> 'b list

val parse_packed_repeated_field : 
  'a ->
  (IBuf.t -> 'b) ->
  (t -> 'b) ->
  ('a * t) list ->
  'b list * ('a * t) list

val parse_packed_repeated_array_field : 
  'a ->
  (IBuf.t -> 'b) ->
  (t -> 'b) ->
  ('a * t) list ->
  'b array * ('a * t) list

val parse_packed_repeated_array_fixed_field : 
  int ->
  'a ->
  (IBuf.t -> 'b) ->
  (t -> 'b) ->
  ('a * t) list ->
  'b array * ('a * t) list

val parse_packed_repeated_array32_field : 
  'a ->
  (IBuf.t -> 'b) ->
  (t -> 'b) ->
  ('a * t) list ->
  'b array * ('a * t) list

val parse_packed_repeated_array64_field : 
  'a ->
  (IBuf.t -> 'b) ->
  (t -> 'b) ->
  ('a * t) list ->
  'b array * ('a * t) list

val parse_flag : 'a -> ('a * t) list -> bool * ('a * t) list

val parse_list_elem : ('a -> 'b) -> (int * 'a) -> 'b

val parse_list : (t -> 'a) -> t -> 'a list

val parse_array : (t -> 'a) -> t -> 'a array

val parse_packed_list_1 : 
  (IBuf.t -> 'a) ->
  (t -> 'a) ->
  (int * t) list ->
  'a list

val parse_packed_list : (IBuf.t -> 'a) -> (t -> 'a) -> t -> 'a list

val parse_packed_array : (IBuf.t -> 'a) -> (t -> 'a) -> t -> 'a array

val parse_packed_array_fixed : 
  int ->
  (IBuf.t -> 'a) ->
  (t -> 'a) ->
  t ->
  'a array

val parse_packed_array32 : (IBuf.t -> 'a) -> (t -> 'a) -> t -> 'a array

val parse_packed_array64 : (IBuf.t -> 'a) -> (t -> 'a) -> t -> 'a array

module OBuf : sig ... end

val to_string : OBuf.t -> string

val to_buffer : OBuf.t -> Buffer.t

val to_channel : Pervasives.out_channel -> OBuf.t -> unit

val iob : int -> OBuf.t

val gen_varint64_value : int64 -> OBuf.t

val gen_unsigned_varint_value : int -> OBuf.t

val gen_signed_varint_value : int -> OBuf.t

val gen_unsigned_varint32_value : int32 -> OBuf.t

val gen_signed_varint32_value : Int32.t -> OBuf.t

val gen_key : int -> int -> OBuf.t

val gen_primitive_key : int -> int -> OBuf.t

val gen_signed_varint_field : int -> int -> OBuf.t

val gen_varint_field : int -> int -> OBuf.t

val gen_signed_varint32_field : int -> Int32.t -> OBuf.t

val gen_varint32_field : int -> int32 -> OBuf.t

val gen_varint64_field : int -> int64 -> OBuf.t

val gen_fixed32_value : int32 -> OBuf.t

val gen_fixed64_value : int64 -> OBuf.t

val gen_fixed32_field : int -> int32 -> OBuf.t

val gen_fixed64_field : int -> int64 -> OBuf.t

val zigzag_of_int : int -> int

val zigzag_of_int32 : int32 -> int32

val zigzag_of_int64 : int64 -> int64

val int_to_varint : int -> int -> OBuf.t

val int_to_signed_varint : int -> int -> OBuf.t

val int_to_zigzag_varint : int -> int -> OBuf.t

val int64_to_varint : int -> int64 -> OBuf.t

val int64_to_signed_varint : int -> int64 -> OBuf.t

val int64_to_zigzag_varint : int -> int64 -> OBuf.t

val int64_to_fixed64 : int -> int64 -> OBuf.t

val int64_to_fixed32 : int -> int64 -> OBuf.t

val int64_to_signed_fixed64 : int -> int64 -> OBuf.t

val int64_to_signed_fixed32 : int -> int64 -> OBuf.t

val int32_to_varint : int -> int32 -> OBuf.t

val int32_to_signed_varint : int -> Int32.t -> OBuf.t

val int32_to_zigzag_varint : int -> int32 -> OBuf.t

val int32_to_fixed32 : int -> int32 -> OBuf.t

val int32_to_signed_fixed32 : int -> int32 -> OBuf.t

val int32_of_float : float -> int32

val int64_of_float : float -> int64

val float_to_fixed32 : int -> float -> OBuf.t

val float_to_fixed64 : int -> float -> OBuf.t

val int_of_bool : bool -> int

val bool_to_varint : int -> bool -> OBuf.t

val gen_bool_field : int -> bool -> OBuf.t

val gen_string_field : int -> string -> OBuf.t

val string_to_block : int -> string -> OBuf.t

val binary_to_block : int -> string -> OBuf.t

val word_to_block : int -> string -> OBuf.t

val text_to_block : int -> string -> OBuf.t

val gen_parsed_field : (int * t) -> OBuf.t

val gen_parsed_field_list : (int * t) list -> OBuf.t list

val int_to_packed_varint : int -> OBuf.t

val int_to_packed_signed_varint : int -> OBuf.t

val int_to_packed_zigzag_varint : int -> OBuf.t

val int64_to_packed_varint : int64 -> OBuf.t

val int64_to_packed_signed_varint : int64 -> OBuf.t

val int64_to_packed_zigzag_varint : int64 -> OBuf.t

val int64_to_packed_fixed64 : int64 -> OBuf.t

val int64_to_packed_fixed32 : int64 -> OBuf.t

val int64_to_packed_signed_fixed64 : int64 -> OBuf.t

val int64_to_packed_signed_fixed32 : int64 -> OBuf.t

val int32_to_packed_varint : int32 -> OBuf.t

val int32_to_packed_signed_varint : Int32.t -> OBuf.t

val int32_to_packed_zigzag_varint : int32 -> OBuf.t

val int32_to_packed_fixed32 : int32 -> OBuf.t

val int32_to_packed_signed_fixed32 : int32 -> OBuf.t

val float_to_packed_fixed32 : float -> OBuf.t

val float_to_packed_fixed64 : float -> OBuf.t

val bool_to_packed_varint : bool -> OBuf.t

val gen_required_field : 'a -> ('a -> 'b -> 'c) -> 'b -> 'c

val gen_optional_field : 'a -> ('a -> 'b -> OBuf.t) -> 'b option -> OBuf.t

val gen_repeated_field : 'a -> ('a -> 'b -> OBuf.t) -> 'b list -> OBuf.t

val map_a2l : ('a -> 'b) -> 'a array -> 'b list

val gen_repeated_array_field : 'a -> ('a -> 'b -> OBuf.t) -> 'b array -> OBuf.t

val gen_packed_repeated_field_common : int -> OBuf.t -> OBuf.t

val gen_packed_repeated_field : int -> ('a -> OBuf.t) -> 'a list -> OBuf.t

val gen_packed_repeated_array_field : 
  int ->
  ('a -> OBuf.t) ->
  'a array ->
  OBuf.t

val gen_packed_repeated_array32_field : 
  int ->
  ('a -> OBuf.t) ->
  'a array ->
  OBuf.t

val gen_packed_repeated_array64_field : 
  int ->
  ('a -> OBuf.t) ->
  'a array ->
  OBuf.t

val gen_flag : int -> bool -> OBuf.t

val gen_record : int -> OBuf.t list -> OBuf.t

val gen_list : (int -> 'a -> OBuf.t) -> int -> 'a list -> OBuf.t

val gen_array : (int -> 'a -> OBuf.t) -> int -> 'a array -> OBuf.t

val gen_packed_list : ('a -> OBuf.t) -> int -> 'a list -> OBuf.t

val gen_packed_array : ('a -> OBuf.t) -> int -> 'a array -> OBuf.t

val gen_packed_array32 : ('a -> OBuf.t) -> int -> 'a array -> OBuf.t

val gen_packed_array64 : ('a -> OBuf.t) -> int -> 'a array -> OBuf.t

val gen_binobj : (int -> 'a -> OBuf.t) -> 'a -> string

val gen_block : OBuf.t -> OBuf.t

val parse_block : IBuf.t -> t