Re: C++ quiz - Maths and acccuracy
Posted: November 30th, 2018, 12:18 pm
Exactly that is the solution JDC gives. I guess this is the formula should be used always in computational calcs to trust the output.
Serving the Quantitative Finance Community
https://forum.wilmott.com/
Exactly that is the solution JDC gives. I guess this is the formula should be used always in computational calcs to trust the output.
Well, there may be even other solutionsExactly that is the solution JDC gives. I guess this is the formula should be used always in computational calcs to trust the output.
True.It is much more "complex" to use it with a computer code. Suppose you have a C++ program which output some "cost" function and you want compute the derivative of this cost function to do some optimisation problem with respect to the cost function.Computing derivatives without the pain of 1) differentiation, 2) catastrophic round-off errors. Sample code.
The scalar (almost a 1-liner). I leave the vector case as an exercise.
Code: Select all// TestComplexStep.cpp // // Complex-step method to compute approximate derivatives. // Example is scalar-valued function of a scalar argument. // // https://pdfs.semanticscholar.org/3de7/e8ae217a4214507b9abdac66503f057aaae9.pdf // // http://mdolab.engin.umich.edu/sites/default/files/Martins2003CSD.pdf // // (C) Datasim Education BV 2018 // #include <functional> #include <complex> #include <iostream> #include <iomanip> #include <cmath> // Notation and function spaces using value_type = double; template <typename T> using FunctionType = std::function < T(const T& c)>; using CFunctionType = FunctionType<std::complex<value_type>>; // Test case from Squire&Trapp 1998 template <typename T> T func(const T& t) { T n1 = std::exp(t); T d1 = std::sin(t); T d2 = std::cos(t); return n1 / (d1*d1*d1 + d2*d2*d2); } template <typename T> T func2(const T& t) { // Derivative of e^t, sanity check return std::exp(std::pow(t,1)); // return std::exp(std::pow(t, 5)); } value_type Derivative(const CFunctionType& f, value_type x, value_type h) { // df/dx at x using tbe Complex step method std::complex<value_type> z(x, h); // x + ih, i = sqrt(-1) return std::imag(f(z)) / h; } int main() { // Squire Trapp double x = 1.5; double h = 0.1; do { std::cout << std::setprecision(12) << Derivative(func<std::complex<value_type>>, x, h) << '\n'; h *= 0.1; } while (h > 1.0e-300); // Exponential function (101 sanity check) x = 5.0; h = 1.0e-10; std::cout << "Exponential 1: " << std::setprecision(12) << Derivative(func2<std::complex<value_type>>, x, h) << '\n'; return 0; }
You have no choice but complexify your code, e.g define a new class (complex_type) and all the functions that are required for the complex-step method. Replace all "double" with "complex_type" and some cosmetics dealing with IO.
I think I can live with that.
It is much more "complex" to use it with a computer code. Suppose you have a C++ program which output some "cost" function and you want compute the derivative of this cost function to do some optimisation problem with respect to the cost function.
You have no choice but complexify your code, e.g define a new class (complex_type) and all the functions that are required for the complex-step method. Replace all "double" with "complex_type" and some cosmetics dealing with IO.
template <typename T>
class B
{
protected:
T t;
public:
B() {}
B(T n) : t(n) {}
};
template <typename T>
class D1: public B<T>
{
private:
public:
D1(T n) : B<T>(n)
{
this->t = 10;
}
void whatever()
{
std::cout << t << '\n'; //NOT WORK, identifier t not found
// std::cout << this->t << '\n'; // WORKS
}
};
class B2
{
protected:
int t;
public:
B2() {}
B2(int n) : t(n) {}
};
class D2: public B2
{
private:
public:
D2(int n) : B2(n)
{
t = 10; // Works
}
virtual void whatever()
{
std::cout << t << '\n'; // WORKS
}
};
Did you mean to include a link there, or are you calling for mind reading?What are your first impressions of a piece of code I am reading? are the anti-patterns here harmful? It's a kind of santy check question:
Also, in Sewep.cpp there is a function foobar() 1) 218 lines of code 2) 4 -deep nested for lops 3) *many* nested if-else conditionals 4) OMP loop parallelisation 5) unreadable 6) it was written 1 week before going into production.
I've got my own views, but what about the reliability, efficiency, readability and maintainability of this code. On a scale [1, 10] I would give
reliability, 4
efficiency, 5?
readability 1
maintainability 2
I value feedback from the members here.
And what kind of mental makeup do you need to have to write this kind of code.