disturbance to 1 field of a large object

[Hicham Mouline]

Hello

I have a function

double f( const Parameters& p );

the object Parameters is big. sizeof(Parameters) is big.

we wish to calculate the senstivity of f to 1 of the parameters inside p,
a naive implementation is

// forward difference
double fprime( const Parameters& p )
{
const double y = f(p);
Parameters pup = p;
pup.p3 += epsilon;

const double yup = f(pup);

return (yup-y)/epsilon;
}

on a profiler, the problem here looks to be the deep copy of p into pup.

Is there an alternative way that remains readable and concise?

regards,

 

[Pascal J. Bourguignon]

Hello

I have a function

double f( const Parameters& p );

the object Parameters is big. sizeof(Parameters) is big.

we wish to calculate the senstivity of f to 1 of the parameters inside p,
a naive implementation is

// forward difference
double fprime( const Parameters& p )
{
const double y = f(p);
Parameters pup = p;
pup.p3 += epsilon;

const double yup = f(pup);

return (yup-y)/epsilon;
}

on a profiler, the problem here looks to be the deep copy of p into pup.

Is there an alternative way that remains readable and concise?

Write a wrapper that forwards all messages to the Parameters but p3.

Of course, in C++, it's hard to do it.
In any other OO programming language, it's trivial.


But it may remain readable:

// or perhaps: template <class ParametersOrForwarder>
double f(const ParametersOrForwarder& p){
...
}

double fprime( const Parameters& p )
{
const double y = f(p);
Forwarder pup(p);
pup.p3 += epsilon;
const double yup = f(pup);
return (yup-y)/epsilon;
}

 

[Lionel B]

Hello

I have a function

double f( const Parameters& p );

the object Parameters is big. sizeof(Parameters) is big.

we wish to calculate the senstivity of f to 1 of the parameters inside
p, a naive implementation is

// forward difference
double fprime( const Parameters& p )
{
const double y = f(p);
Parameters pup = p;
pup.p3 += epsilon;

const double yup = f(pup);

return (yup-y)/epsilon;
}

on a profiler, the problem here looks to be the deep copy of p into pup.

Is there an alternative way that remains readable and concise?

How about simply:

double fprime( Parameters& p )
{
const double y = f(p);
const p3type p3save = p.p3;
p.p3 += epsilon;
const double yup = f(p);
p.p3 = p3save;
return (yup-y)/epsilon;
}

Not ideal - you lose const-ness of your parameter - but workable.

 

[mzdude]

Hello

double f( const Parameters& p );

the object Parameters is big. sizeof(Parameters) is big.

we wish to calculate the senstivity of f to 1 of the parameters inside p,
a naive implementation is

// forward difference
double fprime( const Parameters& p )
{
   const double y = f(p);
   Parameters pup = p;
   pup.p3 += epsilon;

   const double yup = f(pup);

   return (yup-y)/epsilon;

}

Rewrite f() to do both calculations at the same time.

std:air<double,double> p = f2(p,epsilon);

p.first = original call
p.second = second call

 

[Pascal J. Bourguignon]

How about simply:

double fprime( Parameters& p )
{
const double y = f(p);
const p3type p3save = p.p3;
p.p3 += epsilon;
const double yup = f(p);
p.p3 = p3save;
return (yup-y)/epsilon;
}

Not ideal - you lose const-ness of your parameter - but workable.

You would have to protect against exceptions:

template <class Cleanup>
class Unwinder{
private:
Cleanup& cleanup;
public:
Unwinder(Cleanup& aCleanup):cleanup(aCleanup){};
~Unwinder(){ cleanup(); }
};

#include <boost/bind.hpp>

double fprime( Parameters& p )
{
const double y = f(p);
const p3type p3save = p.p3;
{
Unwinder u(boost::bind(&Parameters::setP3,p,p3,p3save));
p.p3 += epsilon;
const double yup = f(p);
}
return (yup-y)/epsilon;
}

And it doesn't work when several threads use p at the same time...