delta.hxx

Go to the documentation of this file.

/*
 *   xyzzy
 *   Copyright (C) 2007    Karl W. Pfalzer
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation; either version 2
 *   of the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the
 *   Free Software Foundation, Inc.
 *   51 Franklin Street, Fifth Floor
 *   Boston, MA  02110-1301, USA.
 */
#if !defined(_xyzzy_delta_hxx_)
#    define  _xyzzy_delta_hxx_

#include <utility>
#include "xyzzy/slist.hxx"
#include "xyzzy/array.hxx"

namespace xyzzy
{

using std::pair;

class TDeltaDouble
{
public:
    static void setTrace(bool on);

    static void dumpTrace(const char *fname);

protected:
    static void addDelta(double d);

    static bool m_stDoTrace;

private:
    static PTSlist<double>  m_stList;   
};

template<typename TR>
class PTDelta : private TDeltaDouble
{
public:
    explicit PTDelta()
    {}

    PTDelta(double gold, TR rev)
    :   m_dat(gold, rev)
    {
        delta(*this);
    }

    PTDelta(double gold)
    :   m_dat(gold, gold)
    {}

    const PTDelta&
    operator =(double gold)
    {
        m_dat.first = gold;
        m_dat.second = gold;
        return *this;
    }

    const PTDelta&
    operator =(const PTDelta& r)
    {
        if (this != &r)
        {
            m_dat.first = r.gold();
            m_dat.second = r.rev();
            delta(*this);
        }
        return *this;
    }

    double gold() const
    {
        return m_dat.first;
    }

    TR rev() const
    {
        return m_dat.second;
    }

    static void toDouble(const PTArray<PTDelta<TR> > &r, PTArray<double> &dbl, 
                         bool rev = true)
    {
        const int N = r.length();
        for (int i = 0; i < N; i++)
        {
            const PTDelta<TR> &ri = r[i];
            dbl[i] = rev ? (double)ri.rev() : (double)ri.gold();
            if (rev && m_stDoTrace)
            {
                delta(ri);
            }
        }
    }

    const PTDelta& operator +=(const PTDelta& r);

    const PTDelta& operator *=(const PTDelta& r);

private:
    pair<double, TR>    m_dat;

    static void delta(const PTDelta &r)
    {
        if (m_stDoTrace)
            addDelta(r.rev() - r.gold());
    }
};

template<typename TR>
PTDelta<TR>
operator +(const PTDelta<TR> &a, const PTDelta<TR> &b)
{
    double y2 = a.gold() + b.gold();
    TR y1 = a.rev() + b.rev();
    return PTDelta<TR>(y2, y1);
}

template<typename TR>
PTDelta<TR>
operator *(const PTDelta<TR> &a, const PTDelta<TR> &b)
{
    double y2 = a.gold() * b.gold();
    TR y1 = a.rev() * b.rev();
    return PTDelta<TR>(y2, y1);
}

template<typename TR>
const PTDelta<TR>& 
PTDelta<TR>::operator +=(const PTDelta& r)
{
    this->operator=(*this + r);
    return *this;
}

template<typename TR>
const PTDelta<TR>& 
PTDelta<TR>::operator *=(const PTDelta& r)
{
    this->operator=(*this * r);
    return *this;
}

}
#endif  //_xyzzy_delta_hxx_

---