Ok, at least one person said they were interested in seeing my idea for an
equation toolkit, so here goes... The files a few hundred lines, so
hopefully that's ok for this group. If I've exceed some message size, I'm
sorry in advance...
======== e.cpp (client code) follows =========
#include "equation.h"
#include "equation_enable_macros.h"
int main()
{
equation::Equation a;
a = _y + _z;
std::cout << a(_y is 5, _z is 10) << std::endl;
a = _x + 8 * (_y - _z);
std::cout << a(_x is 2, _y is 3, _z is -9000.9) << std::endl;
return 0;
}
======== equation.h follows (the real work) =========
// Copyright Stephen Gross 2006
#ifndef api_equation
#define api_equation
#include <string>
#include <iostream>
#include <map>
#include "boost/function.hpp"
#include "boost/lambda/lambda.hpp"
#include "boost/lambda/bind.hpp"
namespace equation {
class ArgTable
{
typedef std::map MapType;
public:
ArgTable & setArg(const std::string & name, double val)
{
my_map[name] = val;
return *this;
}
virtual double getArg (const std::string & name) const
{
MapType::const_iterator f = my_map.find(name);
if(f == my_map.end())
{
std::cout << "Error: Equation requested argument '" << name << "'
which was not given." << std::endl;
exit(0);
}
else
{
return f->second;
}
}
private:
MapType my_map;
};
class ArgTableReporter : public ArgTable
{
public:
virtual double getArg(const std::string & name) const
{
my_last_var = name;
return 0;
}
const std::string & getLastVar() const { return my_last_var; }
private:
mutable std::string my_last_var;
};
///
/// Represents an Equation, simply put.
///
/// The idea here is that, for any Equation that takes named arguments ("x",
"y", etc.) and manipulates them
/// arithmetically, such an Equation can in fact be encapsulated in an
Equation instance.
///
///
class Equation
{
public:
typedef boost::function1 FunctorType;
/// @name Constructors
//@{
Equation() : my_ftr(boost::lambda::constant(0)) { ; }
Equation(const Equation & other) : my_ftr(other.my_ftr) { }
template<typename T> Equation(const T & t) : my_ftr(t) { }
//@}
/// @name The underlying function that invokes the functor:
//@{
double go (const ArgTable & args) const { return my_ftr(args); }
//@}
/// @name operator()
//@{
double operator() () { return go(ArgTable()); }
template<typename A1>
double operator() (const A1 & a1, double v1) const
{
ArgTable args;
ArgTableReporter names;
a1(names); args.setArg(names.getLastVar(), v1);
return go(args);
}
template
double operator() (const A1 & a1, double v1, const A2 & a2, double v2)
const
{
ArgTable args;
ArgTableReporter names;
a1(names); args.setArg(names.getLastVar(), v1);
a2(names); args.setArg(names.getLastVar(), v2);
return go(args);
}
template
double operator() (const A1 & a1, double v1, const A2 & a2, double v2,
const A3 & a3, double v3) const
{
ArgTable args;
ArgTableReporter names;
a1(names); args.setArg(names.getLastVar(), v1);
a2(names); args.setArg(names.getLastVar(), v2);
a3(names); args.setArg(names.getLastVar(), v3);
return go(args);
}
template
double operator() (const A1 & a1, double v1, const A2 & a2, double v2,
const A3 & a3, double v3, const A4 & a4, double v4) const
{
ArgTable args;
ArgTableReporter names;
a1(names); args.setArg(names.getLastVar(), v1);
a2(names); args.setArg(names.getLastVar(), v2);
a3(names); args.setArg(names.getLastVar(), v3);
a4(names); args.setArg(names.getLastVar(), v4);
return go(args);
}
//@}
private:
FunctorType my_ftr;
};
namespace Private {
class Sigma
{
public:
Sigma() : my_start(0), my_stop(0), my_iter(boost::lambda::constant(0.0))
{ }
Sigma(double start, double stop, const Equation & eq) :
my_start((int)start), my_stop((int)stop), my_iter(eq) { }
Sigma(const Sigma & other) : my_start(other.my_start),
my_stop(other.my_stop), my_iter(other.my_iter) { }
Sigma& operator=(const Sigma & other)
{
if(this != &other)
{
my_start = other.my_start;
my_stop = other.my_stop;
my_iter = other.my_iter;
}
return *this;
}
double go (const ArgTable & args) const
{
ArgTable newargs = args;
double result = 0.0;
for(int i = my_start; i <= my_stop; ++i)
{
newargs.setArg("i", (double)i);
result += my_iter.go(newargs);
}
return result;
}
private:
int my_start;
int my_stop;
Equation my_iter;
};
///
/// Helper struct so that unary math functions can be easily macro-ified for
constructing Equations.
struct UnaryFunc
{
UnaryFunc(double (*fn) (double), const Equation::FunctorType & arg_getter)
: my_fn(fn), my_arg_getter(arg_getter) { }
UnaryFunc(double (*fn) (double), double v) : my_fn(fn),
my_arg_getter(boost::lambda::constant(v)) { }
UnaryFunc(const UnaryFunc & other) : my_fn(other.my_fn),
my_arg_getter(other.my_arg_getter) { }
UnaryFunc& operator=(const UnaryFunc & other) { if(this != &other) { my_fn
= other.my_fn; my_arg_getter = other.my_arg_getter; } return *this; }
double go(const ArgTable & args) const { return (*my_fn)
(my_arg_getter(args)); }
double (*my_fn) (double);
Equation::FunctorType my_arg_getter;
};
///
/// Helper struct so that binary math functions can be easily macro-ified
for construction Equations.
struct BinaryFunc
{
BinaryFunc(
double (*fn) (double, double),
const Equation::FunctorType & arg1_getter,
const Equation::FunctorType & arg2_getter) :
my_fn(fn), my_arg1_getter(arg1_getter), my_arg2_getter(arg2_getter)
{ }
BinaryFunc(
double (*fn) (double, double),
double arg1,
const Equation::FunctorType & arg2_getter) :
my_fn(fn), my_arg1_getter(boost::lambda::constant(arg1)),
my_arg2_getter(arg2_getter) { }
BinaryFunc(
double (*fn) (double, double),
const Equation::FunctorType & arg1_getter,
double arg2) :
my_fn(fn), my_arg1_getter(arg1_getter),
my_arg2_getter(boost::lambda::constant(arg2)) { }
BinaryFunc(
double (*fn) (double, double),
double arg1,
double arg2) :
my_fn(fn), my_arg1_getter(boost::lambda::constant(arg1)),
my_arg2_getter(boost::lambda::constant(arg2)) { }
BinaryFunc(const BinaryFunc & other) : my_fn(other.my_fn),
my_arg1_getter(other.my_arg1_getter), my_arg2_getter(other.my_arg2_getter)
{ }
BinaryFunc& operator=(const BinaryFunc & other)
{
if(this != &other)
{
my_fn = other.my_fn;
my_arg1_getter = other.my_arg1_getter;
my_arg2_getter = other.my_arg2_getter;
}
return *this;
}
double go(const ArgTable & args) const
{
return (*my_fn) (my_arg1_getter(args), my_arg2_getter(args));
}
double (*my_fn) (double, double);
Equation::FunctorType my_arg1_getter;
Equation::FunctorType my_arg2_getter;
};
} // End namespace Private
} // End namespace equation
#define VAR(name) boost::lambda::bind<double>(&equation::ArgTable::getArg,
boost::lambda::_1, std::string(#name))
#define EQ(name) boost::lambda::bind<double>(&equation::Equation::go, &name,
boost::lambda::_1)
#endif
=========== equation_enable_macros.h follows ============
#ifndef api_equation_enable_macros
#define api_equation_enable_macros
// Disable macros now available:
#undef api_equation_disable_macros
#define is ,
#define _a VAR(a)
#define _b VAR(b)
#define _c VAR(c)
#define _d VAR(d)
#define _e VAR(e)
#define _f VAR(f)
#define _g VAR(g)
#define _h VAR(h)
#define _i VAR(i)
#define _j VAR(j)
#define _k VAR(k)
#define _l VAR(l)
#define _m VAR(m)
#define _n VAR(n)
#define _o VAR(o)
#define _p VAR(p)
#define _q VAR(q)
#define _r VAR(r)
#define _s VAR(s)
#define _t VAR(t)
#define _u VAR(u)
#define _v VAR(v)
#define _w VAR(w)
#define _x VAR(x)
#define _y VAR(y)
#define _z VAR(z)
#define _sigma(start, stop, iter) boost::lambda::bind<double>
(&equation::Private::Sigma::go, equation::Private::Sigma (start,
stop, iter), boost::lambda::_1)
#define _sqrt(x) boost::lambda::bind<double>
(&equation::Private::UnaryFunc::go, equation::Private::UnaryFunc (&sqrt,
x), boost::lambda::_1)
#define _pow(x, y) boost::lambda::bind<double>
(&equation::Private::BinaryFunc::go, equation::Private::BinaryFunc (&pow,
x, y), boost::lambda::_1)
#endif
========= end of code snippets ==============
