J
jack
Hi there,
I have a function F(x, y, z)
and I want to calculate f(a) + f(b), where f(x) = F(x, x, z0)
z0 is fixed.
Suppose somebody wrote a routine called "Compute" which simply
computes f(a) + f(b) for any one dimensional function f.
Then I create a f1dim which converts any n-dimensional function
G to a one dimensional f(x) = G(x, x, ..., x), via a class
Three_Tne which suppresses (fixes) 1) dimension and 2) function G
in f's argument list.
Also create a class Three_To_Vec which fixes parameter z
in my origional function F, and make it look like a function
with a single array/pointer parameter, i.e., H(w[]) = F(w[0], w[1], z0).
1) If I do not provide a default constructor in Three_To_Vec,
the program won't compile. Why?
2) Why are the destructors of both classes (Three_Tne and Three_To_Vec)
called multiple times, while the constructors are only called once?
Thank you for your help.
Jack
========================== source code in a single file ==================
#include <iostream>
using namespace std;
/* ================= Original function ================== */
double my_3d_f(double x, double y, double z)
{
return x*x*x + 2.0*x*y + 3.0*x*z + x + 3.0*z + 6.0;
}
/* ================= Two Classes used in Functor ============= */
template <class T>
class Three_Tne
{
public:
double (*m_f)(double, int, T);
int m_p1;
T m_p2;
Three_Tne(double(*f)(double, int, T), int p1, T p2)
{
cout << " 3-to-1: c-tor" << endl;
m_f=f;
m_p1=p1;
m_p2=p2;
}
~Three_Tne() { cout << " 3-to-1: D-tor" << endl; }
double operator()(double x)
{
return m_f(x, m_p1, m_p2);
}
};
class Three_To_Vec
{
public:
double (*m_f)(double, double, double);
double m_p;
Three_To_Vec()
{
cout << "3-to-V: default" << endl;
}
Three_To_Vec(double(*f)(double, double, double), double p)
{
cout << "3-to-V: c-tor" << endl;
m_f = f;
m_p = p;
}
~Three_To_Vec() { cout << "3-to-V: D-tor" << endl; }
double operator()(double theta[])
{
return m_f(theta[0], theta[1], m_p);
}
};
/* ========== Somebody's function to compute f(a) + f(b) =================== */
template <class T>
double Compute(T f, double a, double b)
{
return f(a) + f(b);
}
/* ========== Convert n-dimensional to 1-dimensional ================= */
template <class T>
double f1dim(double t, int n, T fnd)
{
int j;
double fval, *x;
x = new double[n];
for(j=0; j < n; ++j)
x[j] = t;
fval = fnd(x);
delete []x;
return fval;
}
/* =========== My function to compute F(a,a,z0) + F(b, b, z0) =================== */
template <class T>
double Go(T fnv, int n, double a, double b)
{
return Compute(Three_Tne<T>(f1dim, n, fnv), a, b);
}
int main()
{
double result;
result = Go(Three_To_Vec(my_3d_f, 3.14159), 3, 2.0, 9.0);
// compute F(2, 2, pi) + F(9, 9, pi)
cout << "result = " << result << endl;
return 0;
}
I have a function F(x, y, z)
and I want to calculate f(a) + f(b), where f(x) = F(x, x, z0)
z0 is fixed.
Suppose somebody wrote a routine called "Compute" which simply
computes f(a) + f(b) for any one dimensional function f.
Then I create a f1dim which converts any n-dimensional function
G to a one dimensional f(x) = G(x, x, ..., x), via a class
Three_Tne which suppresses (fixes) 1) dimension and 2) function G
in f's argument list.
Also create a class Three_To_Vec which fixes parameter z
in my origional function F, and make it look like a function
with a single array/pointer parameter, i.e., H(w[]) = F(w[0], w[1], z0).
1) If I do not provide a default constructor in Three_To_Vec,
the program won't compile. Why?
2) Why are the destructors of both classes (Three_Tne and Three_To_Vec)
called multiple times, while the constructors are only called once?
Thank you for your help.
Jack
========================== source code in a single file ==================
#include <iostream>
using namespace std;
/* ================= Original function ================== */
double my_3d_f(double x, double y, double z)
{
return x*x*x + 2.0*x*y + 3.0*x*z + x + 3.0*z + 6.0;
}
/* ================= Two Classes used in Functor ============= */
template <class T>
class Three_Tne
{
public:
double (*m_f)(double, int, T);
int m_p1;
T m_p2;
Three_Tne(double(*f)(double, int, T), int p1, T p2)
{
cout << " 3-to-1: c-tor" << endl;
m_f=f;
m_p1=p1;
m_p2=p2;
}
~Three_Tne() { cout << " 3-to-1: D-tor" << endl; }
double operator()(double x)
{
return m_f(x, m_p1, m_p2);
}
};
class Three_To_Vec
{
public:
double (*m_f)(double, double, double);
double m_p;
Three_To_Vec()
{
cout << "3-to-V: default" << endl;
}
Three_To_Vec(double(*f)(double, double, double), double p)
{
cout << "3-to-V: c-tor" << endl;
m_f = f;
m_p = p;
}
~Three_To_Vec() { cout << "3-to-V: D-tor" << endl; }
double operator()(double theta[])
{
return m_f(theta[0], theta[1], m_p);
}
};
/* ========== Somebody's function to compute f(a) + f(b) =================== */
template <class T>
double Compute(T f, double a, double b)
{
return f(a) + f(b);
}
/* ========== Convert n-dimensional to 1-dimensional ================= */
template <class T>
double f1dim(double t, int n, T fnd)
{
int j;
double fval, *x;
x = new double[n];
for(j=0; j < n; ++j)
x[j] = t;
fval = fnd(x);
delete []x;
return fval;
}
/* =========== My function to compute F(a,a,z0) + F(b, b, z0) =================== */
template <class T>
double Go(T fnv, int n, double a, double b)
{
return Compute(Three_Tne<T>(f1dim, n, fnv), a, b);
}
int main()
{
double result;
result = Go(Three_To_Vec(my_3d_f, 3.14159), 3, 2.0, 9.0);
// compute F(2, 2, pi) + F(9, 9, pi)
cout << "result = " << result << endl;
return 0;
}