Add files via upload

const.ml

@@ -13,76 +13,196 @@
 open Num
 open Interval
 
+(*
+input: no
+output: no
+description: Type for constants, which can be a num (build-in of Ocaml) or interval
+*)
 type t = Rat of num | Interval of interval
 
+(*
+input: num
+output: t
+description: cover num to constrant (t type)
+*)
 let of_num n = Rat n
 
+(*
+input: int
+output: t
+description: cover int to constrant (t type)
+*)
 let of_int i = Rat (Int i)
 
+(*
+input: float
+output: t
+description: cover float to constrant (t type)
+*)
 let of_float f = Rat (More_num.num_of_float f)
 
+(*
+input: interval
+output: t
+description: cover interval to constrant (t type)
+*)
 let of_interval v =
   if v.low = v.high then of_float v.low
   else if v.low < v.high && neg_infinity < v.high && v.low < infinity then Interval v
   else failwith ("Const.of_interval: bad argument: " ^ sprintf_I "%.20e" v)
 
+(*
+input: t
+output: bool
+description: return true if the constrant is a num
+*)
 let is_rat = function
   | Rat _ -> true
   | Interval _ -> false
 
+(*
+input: interval
+output: bool
+description: return true if the constrant is an interval
+*)
 let is_interval = function
   | Rat _ -> false
   | Interval _ -> true
 
+(*
+input: t
+output: interval
+description: cover a constant to an interval, if it is a num, return the interval of 2 64-bit floats that contains the num with smallest range
+*)
 let to_interval = function
   | Interval v -> v
   | Rat n -> More_num.interval_of_num n
 
+(*
+input: t
+output: foat
+description: cover a constant to float, if it is an interval, return the mean of 2 bounds
+*)
 let to_float = function
   | Interval v -> 0.5 *. (v.low +. v.high)
   | Rat n -> Num.float_of_num n
 
+(*
+input: t
+output: num
+description: cover a constant to num, if it is an interval, raise an error
+*)
 let to_num = function
   | Rat n -> n
   | Interval _ -> failwith "Const.to_num: interval constant"
 
+(*
+input: t
+output: int
+description: cover a constant to integer
+*)
 let to_int c = int_of_num (to_num c)
 
+(*
+input: t
+output: num
+description: cover the lower bound of an interval constant to num, if the constant is num, just return it
+*)
 let low_bound_to_num = function
   | Rat n -> n
   | Interval v -> More_num.num_of_float v.low
 
+(*
+input: t
+output: num
+description: cover the upper bound of an interval constant to num, if the constant is num, just return it
+*)
 let high_bound_to_num = function
   | Rat n -> n
   | Interval v -> More_num.num_of_float v.high
 
+(*
+input: (num->num,interval->interval), t
+output: t
+description: apply the unary function/operator over the constant and return the new constrant
+*)
 let lift_u_ops (op_n, op_i) c =
   match c with
   | Rat n -> of_num (op_n n)
   | Interval v -> of_interval (op_i v)
 
+(*
+input: (num->num->num,interval->interval->interval), t
+output: t
+description: apply the binary function/operator over the constant and return the new constrant
+*)
 let lift_bin_ops (op_n, op_i) c1 c2 =
   match (c1, c2) with
   | Rat n1, Rat n2 -> of_num (op_n n1 n2)
   | Interval _, _ | _, Interval _ ->
      of_interval (op_i (to_interval c1) (to_interval c2))
 
+(*
+input: t
+output: t
+description: return the constant as the negative of the original one
+*)
 let neg_c = lift_u_ops (minus_num, (~-$))
 
+(*
+input: t
+output: t
+description: return the constant as the absolute value of the original one
+*)
 let abs_c = lift_u_ops (abs_num, abs_I)
 
+(*
+input: t,t
+output: t
+description: return the constant as the minimum of the 2 constants
+*)
 let min_c = lift_bin_ops (min_num, min_I_I)
 
+(*
+input: t,t
+output: t
+description: return the constant as the maximum of the 2 constants
+*)
 let max_c = lift_bin_ops (max_num, max_I_I)
 
+(*
+input: t,t
+output: t
+description: return the constant as the addition of the 2 constants
+*)
 let add_c = lift_bin_ops (add_num, (+$))
 
+(*
+input: t,t
+output: t
+description: return the constant as the subtraction of the 2 constants
+*)
 let sub_c = lift_bin_ops (sub_num, (-$))
 
+(*
+input: t,t
+output: t
+description: return the constant as the multiplication of the 2 constants
+*)
 let mul_c = lift_bin_ops (mult_num, ( *$ ))
 
+(*
+input: t,t
+output: t
+description: return the constant as the division of the 2 constants
+*)
 let div_c = lift_bin_ops (div_num, (/$))
 
+(*
+input: t, t
+output: bool
+description: return true if the 2 constants are the same
+*)
 let eq_c c1 c2 =
   match (c1, c2) with
   | Rat n1, Rat n2 -> n1 =/ n2

default.cfg

@@ -32,7 +32,7 @@ debug = true
 # 2: print additional information for each step
 # 3: print everything (including debug information)
 [short: v]
-verbosity = 2
+verbosity = 0
 
 ## If true then lower bounds are printed for all optimization problems.
 # If the difference between lower and upper bounds is significant
@@ -46,7 +46,7 @@ abs-error = true
 
 ## If true then relative round-off error is computed.
 [short: rel]
-rel-error = false
+rel-error = true
 
 ## If true then ulp round-off error is computed
 [short: ulp]
@@ -242,4 +242,4 @@ nlopt-lib = -lnlopt -lm
 # Extra options
 #**************************
 
-develop = false
+develop = false

eval.ml

@@ -18,6 +18,11 @@ open Expr
 (* Computes a floating-point value of an expression *)
 (* vars : string -> float is a function which associates 
    floating-point values with variable names *)
+(*
+input: string->float
+output: float
+description: estimate an expression and return a float value, the first argument is a function which return the value (float) of a variable's name
+*)
 let eval_float_expr vars =
   let rec eval = function
     | Const c -> Const.to_float c
@@ -74,12 +79,22 @@ let eval_float_expr vars =
   in
   eval
 
+(*
+input: expr
+output: float
+description: estimate a constant expression and return a float value
+*)
 let eval_float_const_expr =
   eval_float_expr (fun v -> failwith ("eval_float_const_expr: Var " ^ v))
 
 (* Computes a rational value of an expression *)
 (* vars : string -> num is a function which associates 
    rational values with variable names *)
+(*
+input: string->num
+output: num
+description: estimate an expression and return a float value, the first argument is a function which return the value (num) of a variable's name
+*)
 let eval_num_expr vars =
   let one = Int 1 in
   let rec eval = function
@@ -125,12 +140,22 @@ let eval_num_expr vars =
   in
   eval
 
+(*
+input: expr
+output: num
+description: estimate a constant expression and return a num value
+*)
 let eval_num_const_expr =
   eval_num_expr (fun v -> failwith ("eval_num_const_expr: Var " ^ v))
 
 (* Computes an interval value of an expression *)
 (* vars : string -> interval is a function which associates 
    inteval values with variable names *)
+(*
+input: string->interval
+output: interval
+description: estimate an expression and return a float value, the first argument is a function which return the value (interval) of a variable's name
+*)
 let eval_interval_expr vars =
   let rec eval = function
     | Const c -> Const.to_interval c
@@ -191,10 +216,19 @@ let eval_interval_expr vars =
   in
   eval
 
+(*
+input: expr
+output: interval
+description: estimate a constant expression and return an interval value
+*)
 let eval_interval_const_expr =
   eval_interval_expr (fun v -> failwith ("eval_interval_const_expr: Var " ^ v))
 
-
+(*
+input: expr
+output: Const.t
+description: estimate a constant expression and return a constant
+*)
 let eval_const_expr e = 
   Log.report `Debug "eval_const_expr: %s" (ExprOut.Info.print_str e);
   let n = eval_num_const_expr e in