You can subscribe to this list here.
2001 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}
(8) 
_{Nov}
(8) 
_{Dec}
(4) 

2002 
_{Jan}
(53) 
_{Feb}
(15) 
_{Mar}
(51) 
_{Apr}
(54) 
_{May}
(41) 
_{Jun}
(48) 
_{Jul}
(32) 
_{Aug}
(22) 
_{Sep}
(61) 
_{Oct}
(31) 
_{Nov}
(31) 
_{Dec}
(27) 
2003 
_{Jan}
(45) 
_{Feb}
(18) 
_{Mar}
(25) 
_{Apr}
(39) 
_{May}
(34) 
_{Jun}
(20) 
_{Jul}
(13) 
_{Aug}
(16) 
_{Sep}
(18) 
_{Oct}
(14) 
_{Nov}
(17) 
_{Dec}
(13) 
2004 
_{Jan}
(53) 
_{Feb}
(12) 
_{Mar}
(38) 
_{Apr}
(29) 
_{May}
(72) 
_{Jun}
(38) 
_{Jul}
(41) 
_{Aug}
(11) 
_{Sep}
(21) 
_{Oct}
(30) 
_{Nov}
(35) 
_{Dec}
(14) 
2005 
_{Jan}
(66) 
_{Feb}
(14) 
_{Mar}
(24) 
_{Apr}
(50) 
_{May}
(40) 
_{Jun}
(29) 
_{Jul}
(37) 
_{Aug}
(27) 
_{Sep}
(26) 
_{Oct}
(58) 
_{Nov}
(43) 
_{Dec}
(23) 
2006 
_{Jan}
(84) 
_{Feb}
(36) 
_{Mar}
(24) 
_{Apr}
(42) 
_{May}
(20) 
_{Jun}
(41) 
_{Jul}
(40) 
_{Aug}
(42) 
_{Sep}
(23) 
_{Oct}
(38) 
_{Nov}
(31) 
_{Dec}
(28) 
2007 
_{Jan}
(11) 
_{Feb}
(34) 
_{Mar}
(14) 
_{Apr}
(29) 
_{May}
(45) 
_{Jun}
(5) 
_{Jul}
(10) 
_{Aug}
(6) 
_{Sep}
(38) 
_{Oct}
(44) 
_{Nov}
(19) 
_{Dec}
(22) 
2008 
_{Jan}
(37) 
_{Feb}
(24) 
_{Mar}
(29) 
_{Apr}
(14) 
_{May}
(24) 
_{Jun}
(47) 
_{Jul}
(26) 
_{Aug}
(4) 
_{Sep}
(14) 
_{Oct}
(45) 
_{Nov}
(25) 
_{Dec}
(16) 
2009 
_{Jan}
(33) 
_{Feb}
(34) 
_{Mar}
(45) 
_{Apr}
(45) 
_{May}
(30) 
_{Jun}
(47) 
_{Jul}
(37) 
_{Aug}
(19) 
_{Sep}
(15) 
_{Oct}
(16) 
_{Nov}
(24) 
_{Dec}
(31) 
2010 
_{Jan}
(32) 
_{Feb}
(25) 
_{Mar}
(12) 
_{Apr}
(5) 
_{May}
(2) 
_{Jun}
(9) 
_{Jul}
(31) 
_{Aug}
(10) 
_{Sep}
(12) 
_{Oct}
(20) 
_{Nov}
(6) 
_{Dec}
(41) 
2011 
_{Jan}
(23) 
_{Feb}
(8) 
_{Mar}
(41) 
_{Apr}
(8) 
_{May}
(15) 
_{Jun}
(10) 
_{Jul}
(8) 
_{Aug}
(14) 
_{Sep}
(16) 
_{Oct}
(13) 
_{Nov}
(15) 
_{Dec}
(8) 
2012 
_{Jan}
(6) 
_{Feb}
(14) 
_{Mar}
(22) 
_{Apr}
(40) 
_{May}
(27) 
_{Jun}
(18) 
_{Jul}
(2) 
_{Aug}
(6) 
_{Sep}
(10) 
_{Oct}
(32) 
_{Nov}
(5) 
_{Dec}
(2) 
2013 
_{Jan}
(14) 
_{Feb}
(2) 
_{Mar}
(15) 
_{Apr}
(2) 
_{May}
(6) 
_{Jun}
(7) 
_{Jul}
(25) 
_{Aug}
(6) 
_{Sep}
(3) 
_{Oct}

_{Nov}
(8) 
_{Dec}

2014 
_{Jan}
(3) 
_{Feb}
(3) 
_{Mar}
(3) 
_{Apr}

_{May}
(19) 
_{Jun}
(6) 
_{Jul}
(1) 
_{Aug}
(4) 
_{Sep}
(18) 
_{Oct}
(5) 
_{Nov}
(1) 
_{Dec}

2015 
_{Jan}
(2) 
_{Feb}
(4) 
_{Mar}
(2) 
_{Apr}
(1) 
_{May}
(17) 
_{Jun}
(1) 
_{Jul}

_{Aug}
(2) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 

1
(1) 
2
(3) 
3
(2) 
4

5

6

7

8

9

10
(3) 
11
(2) 
12

13
(3) 
14
(1) 
15

16
(4) 
17
(6) 
18
(1) 
19

20

21

22
(3) 
23

24

25

26
(2) 
27
(2) 
28
(1) 
From: David Doria <daviddoria@gm...>  20090216 22:15:01

I am using lbfgs to minimize a function in 1D (later to be expanded to more dimensions). It seems like after only 3 iterations, it converges. However, it just keeps going until it hits the iteration limit and then fails. I set it up with these params: vnl_lbfgs Minimizer(Cost); Minimizer.set_verbose(true); Minimizer.set_f_tolerance(1e2);//when difference in function value in successive iterations is at least this small, stop. Minimizer.set_x_tolerance(1e2);//when steps are at least this small, stop. Minimizer.set_epsilon_function(1e3); //finite difference step length Minimizer.default_step_length = 1e1; Minimizer.set_max_function_evals(10); And this is the output: vnl_lbfgs: n = 1, memory = 5, Workspace = 21[ 0.000160217 MB], ErrorScale = 1, xnorm = 0 Iter 1, Eval 1: Best F = 103879 ************************************************* N=1 NUMBER OF CORRECTIONS=5 INITIAL VALUES F= 103879 GNORM= 172625 ************************************************* I NFN FUNC GNORM STEPLENGTH Iter 2, Eval 2: Best F = 103879 1 3 65313.580 2765.688 0.000 Iter 3, Eval 3: Best F = 65313.6 Iter 4, Eval 4: Best F = 65313.6 Iter 5, Eval 5: Best F = 65313.6 Iter 6, Eval 6: Best F = 65313.6 Iter 7, Eval 7: Best F = 65313.6 Iter 8, Eval 8: Best F = 65313.6 Iter 9, Eval 9: Best F = 65313.6 Iter 10, Eval 10: Best F = 65313.6 vnl_lbfgs: Error. Netlib routine lbfgs failed. IFLAG= 1 LINE SEARCH FAILED. SEE DOCUMENTATION OF ROUTINE MCSRCH ERROR RETURN OF LINE SEARCH: INFO= 6 POSSIBLE CAUSES: FUNCTION OR GRADIENT ARE INCORRECT OR INCORRECT TOLERANCES These iterations are different than the "minimizer iterations", right? They are the line search iterations. Is this problem something that is tuned with the line_search_accuracy variable? I didn't understand what the values were? It said set it to .1 if the function evaluations are cheap (they are not, they take 1 minute each), or .9 is the default. What is the meaning of these values? Thanks, David 
From: Brendan McCane <brendan.mccane@gm...>  20090216 21:10:38

Hi Moe, First a question  why do you want to turn the dependency off? If you don't have a native geotiff library on your system, then the v3p/geotiff library should be compiled and linked in instead. Either way, it shouldn't be a problem (at least it isn't on my linux build). 2009/2/14 Moe Goldberg <goldberg@...>: > Hi > I recently just installed vxl1.12.0 and I noticed that by default it > vil has a dependency on libgeotiff. Previously when I built older > versions of vxl, and the did not depend on libgeotiff. I am building on > linux with ccmake  I can't figure out how to turn off this dependency. > Any help is appreciated. > > thanks! > Moe > >  > Open Source Business Conference (OSBC), March 2425, 2009, San Francisco, CA > OSBC tackles the biggest issue in open source: Open Sourcing the Enterprise > Strategies to boost innovation and cut costs with open source participation > Receive a $600 discount off the registration fee with the source code: SFAD > http://p.sf.net/sfu/XcvMzF8H > _______________________________________________ > Vxlusers mailing list > Vxlusers@... > https://lists.sourceforge.net/lists/listinfo/vxlusers >  Cheers, Brendan 
From: David Doria <daviddoria@gm...>  20090216 19:17:34

I made a little demo for lbfgsb: The minimum of the cost function I provide (a simple quadratic surface) is (7,4). By setting a lower bound of (7.1, 4.2), this should then be the minimum. However, the first thing lbfgsb says is "This problem is unconstrained" and it still returns (7,4) as the minimum. What have I done wrong? DistanceFunction Distance(2); vnl_lbfgsb Minimizer(Distance); vnl_vector<double> l(2); l(0) = 7.1; l(1) = 4.2; vnl_vector<double> u(2); u(0) = 10; u(1) = 10; Minimizer.set_lower_bound(l); Minimizer.set_upper_bound(u); vnl_vector<double> x0(2); x0(0) = 9; x0(1) = 5; cout << "Started at: " << x0 << endl; Minimizer.minimize(x0); cout << "Ended at: " << x0 << endl; Thanks, David 
From: David Doria <daviddoria@gm...>  20090216 19:08:18

I'm testing my cost function by only varying 1 parameter for the time being. The gradf function I implemented simply calls fdgradf() void gradf(vnl_vector<double> const &x, vnl_vector<double> &dx) { fdgradf(x, dx); //Finite Difference Gradient cout << "Grad: " << dx[0] << endl; } I output the value that is returned at each function evaluation I'm assuming the first one is to get the value of the function at the initial position. The next 2 are the values that are averaged to get the value of the gradient. F: 103879 F: 103880 F: 103876 Grad: 172625 Since the step_size is 1e5, this gradient makes sense (because the difference in function values is about 4, so 4/(2*1e5) is about 200,000). Because the gradient is so big, it takes a step of size 1.0. The range of values which I would like to search is [.5, .5]. I know there is lbfgsb for constrained optimization, but I don't really want to use a constrained method, I'd rather just take a smaller step. Should I just clip the gradient to a max value in the gradf function? Or is there a better way to do this? Thanks, David 