rustimization 0.1.1

A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

# rustimization
A rust optimization library which includes **L-BFGS-B** and **Conjugate Gradient** algorithm.

##Documentation
The simplest way to use these optimization algorithm is to use the Funcmin class.
```rust
extern crate rustimization;
use rustimization::minimizer::Funcmin;
fn test(){
    let f = |x: &Vec<f64>| { (x[0]+4.0).powf(2.0)};
    let g = |x: &Vec<f64>| {vec![2.0*(x[0]+4.0)]};
    let mut x = vec![40.0f64];
    {
        //you must create a mutable object
        let mut fmin = Funcmin::new(&mut x,&f,&g,"cg");
        fmin.minimize();
    }
    println!("{:?}",x);
}
```
Output
```
[-4.000000000000021]
```
here Funcmin constructor takes four **parameters** first one is initial estimation **x** second and third one is the function **f** and
the derivative **g** of the function respectively and forth one is the algorithm you want to use. Currently two algorithms 
available **"cg"** and **"lbfgsb"**
if you want more parameter tuning you can use the classes of the algorithm such as for Lbbfgsb_minimizer class
###Example
```rust
let f = |x:&Vec<f64>|{ (x[0]+4.0).powf(2.0)};
    let g = |x:&Vec<f64>|{vec![2.0*(x[0]+4.0)]};
    let mut x = vec![40.0f64];
    {
        //creating lbfgsb object. here it takes three parameter
        let mut fmin = Lbfgsb::new(&mut x,&f,&g);
        //seting upper and lower bound first parameter is the index and second one is value
        fmin.set_upper_bound(0,100.0);
        fmin.set_lower_bound(0,10.0);
        //set verbosity. higher value is more verbosity. the value is -1<= to <=101
        fmin.set_verbosity(101);
        //start the algorithm
        fmin.minimize();
    }
    println!("{:?}",x);
```
Output
```
RUNNING THE L-BFGS-B CODE

           * * *

Machine precision = 2.220D-16
 N =            1     M =            5

 L =  1.0000D+01

X0 =  4.0000D+01

 U =  1.0000D+02

At X0         0 variables are exactly at the bounds

At iterate    0    f=  1.93600D+03    |proj g|=  3.00000D+01


ITERATION     1

---------------- CAUCHY entered-------------------
 There are            1   breakpoints 

Piece      1 --f1, f2 at start point  -7.7440D+03  7.7440D+03
Distance to the next break point =   3.4091D-01
Distance to the stationary point =   1.0000D+00
 Variable             1   is fixed.
Cauchy X =  
      1.0000D+01

---------------- exit CAUCHY----------------------

           0  variables are free at GCP            1
 LINE SEARCH           0  times; norm of step =    30.000000000000000     

At iterate    1    f=  1.96000D+02    |proj g|=  0.00000D+00

 X =  1.0000D+01

 G =  2.8000D+01

           * * *

Tit   = total number of iterations
Tnf   = total number of function evaluations
Tnint = total number of segments explored during Cauchy searches
Skip  = number of BFGS updates skipped
Nact  = number of active bounds at final generalized Cauchy point
Projg = norm of the final projected gradient
F     = final function value

           * * *

   N    Tit     Tnf  Tnint  Skip  Nact     Projg        F
    1      1      2      1     0     1   0.000D+00   1.960D+02

 X =  1.0000D+01
  F =   196.00000000000000     

CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL            

 Cauchy                time 1.570E-04 seconds.
 Subspace minimization time 0.000E+00 seconds.
 Line search           time 1.800E-05 seconds.

 Total User time 9.330E-04 seconds.

convergence!
```
##Requirements
To use this library you must have **gfortran** installed in your pc
* for **windows** use fortran compiler provided by [mingw](http://www.mingw.org/) or [TDM-GCC](http://tdm-gcc.tdragon.net/)
* for **linux** you can use the package manager to install gfortran
* for Mac os you can install it form [here](http://hpc.sourceforge.net/) or [here](http://sourceforge.net/projects/hpc/files/hpc/g95/gfortran-mlion.tar.gz)

The orginal **L-BFGS-B** fortran subroutine is distributed under BSD-3 license. To know more about the condition to use this fortran routine please go [here](http://users.iems.northwestern.edu/~nocedal/lbfgsb.html).

To know more about the condition to use the **Conjugate Gradient** Fortran routine please go [here](http://users.iems.northwestern.edu/~nocedal/lbfgsb.html) 

##References
1. R. H. Byrd, P. Lu and J. Nocedal. [A Limited Memory Algorithm for Bound Constrained Optimization](http://www.ece.northwestern.edu/~nocedal/PSfiles/limited.ps.gz), (1995), SIAM Journal on Scientific and Statistical Computing , 16, 5, pp. 1190-1208.
2. C. Zhu, R. H. Byrd and J. Nocedal. [L-BFGS-B: Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization](http://www.ece.northwestern.edu/~nocedal/PSfiles/lbfgsb.ps.gz) (1997), ACM Transactions on Mathematical Software, Vol 23, Num. 4, pp. 550 - 560.
3. J.L. Morales and J. Nocedal. [L-BFGS-B: Remark on Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization](http://www.ece.northwestern.edu/~morales/PSfiles/acm-remark.pdf) (2011), to appear in ACM Transactions on Mathematical Software.
4. J. C. Gilbert and J. Nocedal. Global Convergence Properties of Conjugate Gradient Methods for Optimization, (1992) SIAM J. on Optimization, 2, 1.