I am getting the following error in one of my projects. It seems to be a new issue with more recent version of Cargo.

Steps to reproduce

Create a new project

cargo new rustimization_bug

Add rustimization==0.1.1 as a dependency in Cargo.

Create src/main.rs as follows

extern crate rustimization;                                                     
                                                                                
use rustimization::minimizer::Funcmin;                                          
                                                                                
fn main() {                                                                     
                                                                                
    let f = |x : &Vec<f64>| {                                                   
        0.0f64                                                                  
    };                                                                          
    let g = |x : &Vec<f64>| {                                                   
        vec![0.0f64]                                                            
    };                                                                          
                                                                                
    let mut x = Vec::new();                                                     
    let mut fmin = Funcmin::new(&mut x, &f, &g, "cg");                          
    fmin.max_iteration(10);                                                     
    fmin.minimize();                                                            
                                                                                
    println!("Hello, world!");                                                  
}                                                                               

Build the system with cargo build and the running the executable creates the following error

-> % target/debug/rustimization_bug
target/debug/rustimization_bug: error while loading shared libraries: libcgfam.so: cannot open shared object file: No such file or directory

This works with cargo run

-> % cargo run
warning: unused variable: `x`
 --> src/main.rs:7:14
  |
7 |     let f = |x : &Vec<f64>| {
  |              ^ help: if this is intentional, prefix it with an underscore: `_x`
  |
  = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `x`
  --> src/main.rs:10:14
   |
10 |     let g = |x : &Vec<f64>| {
   |              ^ help: if this is intentional, prefix it with an underscore: `_x`

warning: `rustimization_bug` (bin "rustimization_bug") generated 2 warnings
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/rustimization_bug`

 IFLAG= -3
 IMPROPER INPUT PARAMETERS (N IS NOT POSITIVE)
Hello, world!

Environment

-> % lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 22.04 LTS
Release:	22.04
Codename:	jammy
-> % cargo --version
cargo 1.61.0 (a028ae4 2022-04-29)

According to the fortran code

c     f is a double precision variable.
c       On first entry f is unspecified.
c       On final exit f is the value of the function at x.
c
c     g is a double precision array of dimension n.
c       On first entry g is unspecified.
c       On final exit g is the value of the gradient at x.

It is not clear whether f & g are not modified in the subroutine.

Calling set_matric_correction() leads to a segfault since the wa variable is not reallocated to handle the new size.

Perhaps the constructor could be refactored into a builder pattern?

Hi, I'm trying to port a python project to Rust and I'm using your library as a replacement to scipy.optimize. rustimization seems to be working ok but there's something I don't like. In scipy/optimize/lbfgsb.py, we can find this

    if jac is None:
        def func_and_grad(x):
            f = fun(x, *args)
            g = _approx_fprime_helper(x, fun, epsilon, args=args, f0=f)
            return f, g

which is to say 1) use this if g wasn't provided 2) use the last value of f() when calling g(). Using your library, doing 1) is possible, but it's impossible to do 2). It's quite important if f() is expensive.

I already coded _approx_fprime_helper and I'm pretty sure I can code this myself in your library. My question is more: is this project still alive? Do you accept PR?