euclwrap.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A wrapper of a generic coefficient type for the CHomP library.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 3 of the License, or (at your option) any later version.
//
// This software 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 software; see the file "license.txt". If not,
// please, see <http://www.gnu.org/licenses/>.

// Started on March 24, 2009. Last revision: June 20, 2012.


#ifndef _CHAINCON_EUCLWRAP_H_
#define _CHAINCON_EUCLWRAP_H_


// include some standard C++ header files
#include <istream>
#include <ostream>
#include <algorithm>
#include <vector>

// include selected header files from the CHomP library
#include "chomp/system/config.h"


// --------------------------------------------------
// ----------- a wrapper for coefficients -----------
// --------------------------------------------------

/// A wrapper of coefficients as defined in this sofware package
/// for what is required by CHomP.
template <class CoefT>
class tEuclWrap
{
public:
        /// The default constructor of an undefined element.
        tEuclWrap ();

        /// Constructor from a coefficient element.
        explicit tEuclWrap (const CoefT &element);

        /// Extraction of the actual coefficient inside.
        const CoefT &getCoef () const;

        /// Assignment of an integer number.
        tEuclWrap<CoefT> &operator = (int n);

        /// Computes the delta function for the element.
        int delta (void) const;

        /// Returns a normalized number (does nothing here).
        tEuclWrap<CoefT> normalized () const;

        /// The negation operator.
        tEuclWrap<CoefT> operator - () const;

        /// The addition operator.
        tEuclWrap<CoefT> &operator += (const tEuclWrap<CoefT> &n);

        /// The multiplication operator.
        tEuclWrap<CoefT> &operator *= (const tEuclWrap<CoefT> &n);

        /// The addition operator that returns the result separately.
        tEuclWrap<CoefT> operator + (const tEuclWrap<CoefT> &n) const;

        /// The multiplication operator that returns the result separately.
        tEuclWrap<CoefT> operator * (const tEuclWrap<CoefT> &n) const;

        /// The division with remainder operator.
        tEuclWrap<CoefT> operator / (const tEuclWrap<CoefT> &n) const;

        /// The remainder operator.
        tEuclWrap<CoefT> operator % (const tEuclWrap<CoefT> &n) const;

        /// The equality operator.
        int operator == (const tEuclWrap<CoefT> &n) const;

        /// Returns the name of the ring (returns its symbol here).
        static const char *ringname ();

        /// Returns the symbol of the ring.
        static const char *ringsymbol ();

private:
        /// An element of the coefficient type.
        CoefT e;

}; /* class tEuclWrap */

// --------------------------------------------------

template <class CoefT>
inline tEuclWrap<CoefT>::tEuclWrap ()
{
        return;
} /* tEuclWrap::tEuclWrap */

template <class CoefT>
inline tEuclWrap<CoefT>::tEuclWrap (const CoefT &element): e (element)
{
        return;
} /* tEuclWrap::tEuclWrap */

template <class CoefT>
inline const CoefT &tEuclWrap<CoefT>::getCoef () const
{
        return e;
} /* tEuclWrap::getCoef */

template <class CoefT>
inline tEuclWrap<CoefT> &tEuclWrap<CoefT>::operator = (int n)
{
        e = CoefT (n);
        return *this;
} /* tEuclWrap::operator = */

template <class CoefT>
inline int tEuclWrap<CoefT>::delta (void) const
{
        return e. delta ();
} /* tEuclWrap::delta */

template <class CoefT>
inline tEuclWrap<CoefT> tEuclWrap<CoefT>::normalized () const
{
        return *this;
} /* tEuclWrap::normalized */

template <class CoefT>
inline tEuclWrap<CoefT> tEuclWrap<CoefT>::operator - () const
{
        CoefT n (e);
        n. negate ();
        return tEuclWrap<CoefT> (n);
} /* tEuclWrap::operator - */

template <class CoefT>
inline tEuclWrap<CoefT> &tEuclWrap<CoefT>::operator +=
        (const tEuclWrap<CoefT> &n)
{
        e += n. e;
        return *this;
} /* tEuclWrap::operator += */

template <class CoefT>
inline tEuclWrap<CoefT> &tEuclWrap<CoefT>::operator *=
        (const tEuclWrap<CoefT> &n)
{
        e *= n. e;
        return *this;
} /* tEuclWrap::operator *= */

template <class CoefT>
inline tEuclWrap<CoefT> tEuclWrap<CoefT>::operator +
        (const tEuclWrap<CoefT> &n) const
{
        CoefT m (e);
        m += n. e;
        return tEuclWrap<CoefT> (m);
} /* tEuclWrap::operator + */

template <class CoefT>
inline tEuclWrap<CoefT> tEuclWrap<CoefT>::operator *
        (const tEuclWrap<CoefT> &n) const
{
        CoefT m (e);
        m *= n. e;
        return tEuclWrap<CoefT> (m);
} /* tEuclWrap::operator * */

template <class CoefT>
inline tEuclWrap<CoefT> tEuclWrap<CoefT>::operator /
        (const tEuclWrap<CoefT> &n) const
{
        CoefT q, r;
        divide (e, n. e, q, r);
        return tEuclWrap<CoefT> (q);
} /* tEuclWrap::operator / */

template <class CoefT>
inline tEuclWrap<CoefT> tEuclWrap<CoefT>::operator %
        (const tEuclWrap<CoefT> &n) const
{
        CoefT q, r;
        divide (e, n. e, q, r);
        return tEuclWrap<CoefT> (r);
} /* tEuclWrap::operator % */

template <class CoefT>
inline int tEuclWrap<CoefT>::operator == (const tEuclWrap<CoefT> &n) const
{
        return (e == n. e);
} /* tEuclWrap::operator == */

template <class CoefT>
inline const char *tEuclWrap<CoefT>::ringname ()
{
        return CoefT::ringsymbol (). c_str ();
} /* tEuclWrap::ringname */

template <class CoefT>
inline const char *tEuclWrap<CoefT>::ringsymbol ()
{
        return CoefT::ringsymbol (). c_str ();
} /* tEuclWrap::ringsymbol */

// --------------------------------------------------

template <class CoefT>
inline bool operator != (const tEuclWrap<CoefT> &n,
        const tEuclWrap<CoefT> &m)
{
        return (!(n == m));
} /* operator != */

template <class CoefT>
inline bool operator == (const tEuclWrap<CoefT> &n, int m)
{
        tEuclWrap<CoefT> intm;
        intm = m;
        return (n == intm);
} /* operator == */

template <class CoefT>
inline int operator != (const tEuclWrap<CoefT> &n, int m)
{
        return !(n == m);
} /* operator != */

template <class CoefT>
inline tEuclWrap<CoefT> operator - (const tEuclWrap<CoefT> &n,
        const tEuclWrap<CoefT> &m)
{
        return (n + -m);
} /* operator - */

// --------------------------------------------------

template <class CoefT>
inline std::istream &operator >> (std::istream &in,
        tEuclWrap<CoefT> &n)
{
        CoefT element;
        in >> element;
        n = tEuclWrap<CoefT> (element);
        return in;
} /* operator >> */

/// Writing an element to an output stream.
template <class CoefT>
inline std::ostream &operator << (std::ostream &out,
        const tEuclWrap<CoefT> &n)
{
        out << n. getCoef ();
        return out;
} /* operator << */


#endif // _CHAINCON_EUCLWRAP_H_