using f = clad::gradient, and f.execute possibility of input and output parameters as vectors or arrays?

[stebos100]

Hi all ! I was wondering if you could possible help me.

I want to enquire if it is possible to use f = clad::gradient, and f.execute() with vector or arrays as inputs. so when we specify the inputs for the gradient function itself we simply provide a array or vector ?

ie.
std::vector inputs \with some data;
auto f = clad::gradient(func, inputs);

and when we use the f.execute() we can simply store the derivative outputs to an array or vector instead of manually extracting them (
for eg. f.execute(x1,x2,x3, &dx[0], &dx[1], &dx[3]) will be incredibly tedious if you have 600 inputs that need to be differentiated) and instead do something similar to :

std::vector derivatives;
f.execute(inputs , &derivatives);

Looking forward to hearing from you all !

[parth-07]

Hi @stebos100

Thank you for reaching out.

Yes, it is possible to use Clad with array inputs.

In brief, the derivative type is the same as the value type.

double fn(double x[10]) { ... }

To differentiate the function fn, clad can be used as:

auto fn_grad = clad::gradient(fn);
double x[10], dx[10] = {0};
clad::array_ref<double> dx_ref(dx, 10);
fn_grad.execute(x, dx_ref); // dx_ref stores derivatives of the function's return value with respect to argument x

However, if the function fn is defined as below, then we cannot use an array for derivatives.

double fn(double x1, double x2, double x3) { ... }

In this case, you will need to manually specify input arguments x1, x2, x3 and the derivative arguments dx1, dx2 and dx3 when calling f.execute(...).

Please let us know if you have any questions.

[stebos100]

Hi @parth-07,

thanks so much for clarifying that !

I just have a couple of questions following up on the above.

1.) Can clad accommodate nested functions containing void functions and generate the derivative function thereof ? ie lets say of the following form :

double fn (double* rate) {

fnOne (rate); //void
fnTwo(rate); //void 
double ret = fnThree(rate);

}

---

2.) I have a question regarding functions with multiple double* as inputs. Lets say the function has the form of the following :

double fn(double* IntRates, double* randomNumbers, double* fxRates) {
        
        fnOne (randomNumbers, IntRates ); //void
        fnTwo(fxRates, IntRates); //void 
        double ret = fnThree(IntRates);
}

---

firstly, can clad accomodate this if we only wanted to derive the function w.r.t the input double* intRates ? And if possible how would one specify this to the clad::gradient function ? I have tried the following and it crashes.

---

int main() {
    double* intRates = (double*)malloc(120*sizeof(double));
    double* randomNumbers= (double*)malloc(120*sizeof(double)); 
    double* fxRates= (double*)malloc(120*sizeof(double)); 
    
    //Values are then assigned to the various slots
    
    auto fn_grad = clad::gradient(fn, "IntRates"); //Running this command alone crashes clad so I suspect I am doing something wrong here 
    
    double dx[120] = {0};
    clad::array_ref<double> dx_ref(dx, 120);
    
    fn_grad.execute(IntRates, randomNumbers,  fxRates, dx_ref); 
    
    return 0;

}

---