How to pass an struct (with no atributes, only methods) to a trigonometrical function? - class

Question

my problem is, I have an class that is supposed to be an X for a function, for example
auto f = x * x + 7.0;
and when called with f.e(3) it would return the function value.
It was resolved with operator overload on the * and +, but when i would try to do with trigonometrical functions, it doesnt work.
Here's what i've been trying to do:
auto f = sin(x);
that would later be invoked with an
f.e(5);
But its unable to do that because sin only accepts numbers as arguments, how would i go about doing that?
Here's class X:
class X {
public:
double e( double v ) {
return v;
}
};
The full code required to simply make it work is quite big, so I'm posting it on pastebin:
pastebin.com/SwKUUbyr
It also calculates the 1st derivative of the function.
This is the error:
error: no matching function for call to 'sin(X&)'
I'd love any input you guys can provide.

Answer 1

#include <cmath>
namespace formula {
template<class Lhs, class Rhs>
struct Times;
template<class Lhs, class Rhs>
struct Plus;
template<class D>
struct Formula {
double ex( double in ) { return static_cast<D&>(*this).ex(in); }
double dx( double in ) { return static_cast<D&>(*this).dx(in); }
template<class Rhs>
friend auto operator*( Formula<D>, Formula<Rhs> ) {
return Formula< Times<D, Rhs> >{};
}
template<class Rhs>
friend auto operator+( Formula<D>, Formula<Rhs> ) {
return Formula< Plus<D, Rhs> >{};
}
};
struct X:Formula<X> {
double ex(double in){ return in; }
double dx(double in){ return 1; }
};
X x;
template<class Lhs, class Rhs>
struct Times:Formula<Times<Lhs, Rhs>> {
double ex( double in ) {
return Lhs{}.ex(in) * Rhs{}.ex(in);
}
double dx( double in ) {
return Lhs{}.ex(in) * Rhs{}.dx(in) + Lhs{}.dx(in) * Rhs{}.ex(in);
}
};
template<class Lhs, class Rhs>
struct Plus:Formula<Plus<Lhs, Rhs>> {
double ex( double in ) {
return Lhs{}.ex(in) + Rhs{}.ex(in);
}
double dx( double in ) {
return Lhs{}.dx(in) + Rhs{}.dx(in);
}
};
That is a bit better machinery that replicates what yours does.
Now to extend it:
template<class X>
struct Sin:Formula<Sin<X>> {
double ex( double in ) {
return ::std::sin(X{}.ex(in));
}
double dx( double in ) {
return X{}.dx(in) * ::std::cos(X{}.ex(in));
}
};
template<class X>
auto sin( Formula<X> ) {
return Sin<X>{};
}
}
Test code:
using namespace formula;
auto x_2 = x*x;
auto sin_x_2 = sin(x_2);
std::cout << sin_x_2.ex(0.) << "\n";
std::cout << sin_x_2.dx(0.) << "\n";
std::cout << sin(x).ex(0.) << "\n";
std::cout << sin(x).dx(0.) << "\n";
std::cout << (x*x).ex(1.) << "\n";
std::cout << (x*x).dx(1.) << "\n";
This can be extended with storing copies of the formula you depend upon to allow equations to contain some state.