akabe

open Complex

(** [roots_initvals ?r [c(n); ...; c(2); c(1); c(0)]] computes
 initial values for [roots] by using Aberth's method.
 *)
let roots_initvals ?(r=1000.0) coeff_list =
  match coeff_list with
  | a::b::_ ->
     let n = List.length coeff_list - 1 in
     let s = 3.14159265358979 /. (float n) in

akabe

(** [levinson r] computes AR coefficients by using Levinson-Durvin method.
 @param r values of autocorrelation function: [[r(0); r(1); r(2); ...; r(M)]]
 @return [([ar(1); ar(2); ...; ar(M)], sigma2)] where [ar(i)] is the [i]-th
         coefficient of AR([M]) and [sigma2] is variance of errors.
 *)
let levinson r =
  let rec loop r ar sigma2 = function
    | [] -> (List.rev ar, sigma2)
    | rm :: rest ->
       let rev_ar = List.rev ar in

akabe

(* unfoldingRAE.ml --- Unfolding Recursive Autoencoder and
                       Online Backpropagation Through Structure (BPTS)

   [MIT License] Copyright (C) 2015 Akinori ABE

   Compilation:
   $ ocamlfind ocamlopt -linkpkg -package slap unfoldingRAE.ml

   This program requires Sized Linear Algebra Package (SLAP), a linear algebra
   library for OCaml with static size checking for matrix operations (see

akabe

(* http://akabe.github.io/2015/10/GenerativePhantomTypes *)

#load "str.cma";;

(** Loads a list of integers from a file of a given path (delimiters = spaces,
    tabs, or line feeds). *)
let load_list fname =
  let re = Str.regexp "[ \t]+" in
  let oc = open_in fname in
  let rec aux acc = try aux (input_line oc :: acc) with End_of_file -> acc in

akabe

(* http://akabe.github.io/2015/10/GenerativePhantomTypes *)

#load "str.cma";;

(** Loads a list of integers from a file of a given path (delimiters = spaces,
    tabs, or line feeds). *)
let load_list fname =
  let re = Str.regexp "[ \t]+" in
  let oc = open_in fname in
  let rec aux acc = try aux (input_line oc :: acc) with End_of_file -> acc in

akabe

(* http://akabe.github.io/2015/10/GenerativePhantomTypes *)

#load "str.cma";;

(** Loads a list of integers from a file of a given path (delimiters = spaces,
    tabs, or line feeds). *)
let load_list fname =
  let re = Str.regexp "[ \t]+" in
  let oc = open_in fname in
  let rec aux acc = try aux (input_line oc :: acc) with End_of_file -> acc in

akabe

(* http://akabe.github.io/2015/10/GenerativePhantomTypes *)

#load "str.cma";;

(** Loads a list of integers from a file of a given path (delimiters = spaces,
    tabs, or line feeds). *)
let load_list fname =
  let re = Str.regexp "[ \t]+" in
  let oc = open_in fname in
  let rec aux acc = try aux (input_line oc :: acc) with End_of_file -> acc in

akabe

open Format

(** The types of the source language
    (Hindley-Milner + subtyping + bounded polymorphism) *)
module SL =
struct
  type 'a typ =
    | Base of 'a               (** base type *)
    | Var of string            (** type variable *)
    | Arrow of 'a typ * 'a typ (** function type *)

akabe

open Format

(** The types of the source language
    (Hindley-Milner + subtyping + bounded polymorphism) *)
module SL =
struct
  type 'a typ =
    | Base of 'a               (** base type *)
    | Var of string            (** type variable *)
    | Arrow of 'a typ * 'a typ (** function type *)

akabe

(* recursiveNeuralNetwork.ml --- Recursive Neural Networks and
                                 Online Backpropagation Through Structure (BPTS)

   [MIT License] Copyright (C) 2015 Akinori ABE

   Compilation:
   $ ocamlfind ocamlopt -linkpkg -package slap recursiveNeuralNetwork.ml

   This program requires Sized Linear Algebra Library (SLAP), a linear algebra
   library for OCaml with static size checking for matrix operations (see