ringz2.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// Elements of the ring Z_2.
///
/////////////////////////////////////////////////////////////////////////////

// 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: January 4, 2013.


#ifndef _CHAINCON_RINGZ2_H_
#define _CHAINCON_RINGZ2_H_


// include some standard C++ header files
#include <istream>
#include <ostream>
#include <sstream>
#include <string>

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


// --------------------------------------------------
// ------------ elements of the ring Z_2 ------------
// --------------------------------------------------

/// An element of the ring Z_2.
class tZ2
{
public:
        /// Default constructor of a ring element.
        /// Note: The default copy constructor, destructor,
        /// and assignment operators are fine.
        tZ2 ();

        /// Constructor from an integer number
        /// (to be used mainly for 0 or 1).
        explicit tZ2 (int n);

        /// Conversion to an integer.
        /// Note that in some rings this conversion may not be valid.
        operator int () const;

        /// The delta function.
        int delta () const;

        /// Negates the ring element.
        tZ2 &negate ();

        /// Inverts the ring element.
        tZ2 &invert ();

        /// Adds another ring element.
        tZ2 &operator += (const tZ2 &another);

        /// Multiplies by another ring element.
        tZ2 &operator *= (const tZ2 &another);

        /// Swaps the internal data with another ring element.
        void swap (tZ2 &another);

        /// Returns the symbol of the ring.
        static std::string ringsymbol ();

        /// Performs the division with remainder in the ring.
        /// Returns true if the remainer is zero, false otherwise.
        friend bool divide
                (const tZ2 &a, const tZ2 &b,
                tZ2 &quotient, tZ2 &remainder);

private:
        /// The number corresponding to the ring element.
        bool _n;

}; /* class tZ2 */

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

inline tZ2::tZ2 ()
{
        return;
} /* tZ2::tZ2 */

inline tZ2::tZ2 (int n)
{
        _n = (n & 1) ? true : false;
        return;
} /* tZ2::tZ2 */


inline tZ2::operator int () const
{
        return (_n ? 1 : 0);
} /* tZ2::operator int */

inline int tZ2::delta () const
{
        return (_n ? 1 : 0);
} /* tZ2::delta */

inline tZ2 &tZ2::negate ()
{
        return *this;
} /* tZ2::negate */

inline tZ2 &tZ2::invert ()
{
        if (!_n)
                throw "Trying to invert the zero element of Z_2.";
        return *this;
} /* tZ2::invert */

inline tZ2 &tZ2::operator += (const tZ2 &another)
{
        if (another. _n)
                _n = !_n;
        return *this;
} /* tZ2::operator += */

inline tZ2 &tZ2::operator *= (const tZ2 &another)
{
        if (!another. _n)
                _n = false;
        return *this;
} /* tZ2::operator *= */

inline void tZ2::swap (tZ2 &another)
{
        bool tmp (_n);
        _n = another. _n;
        another. _n = tmp;
        return;
} /* tZ2::swap */

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

inline std::string tZ2::ringsymbol ()
{
        return std::string ("Z_2");
} /* tZ2::ringsymbol */

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

/// Generates a hashing key no. 1 for an element of the Zp ring.
/// This key is to be used in a hashed set.
inline int_t hashkey1 (const tZ2 &n)
{
        return (static_cast<int> (n) ? 1 : 0);
} /* hashkey1 */

/// Generates a hashing key no. 2 for a general pair of elements,
/// based on hashing keys of the elements.
/// This key is to be used in a hashed set.
inline int_t hashkey2 (const tZ2 &n)
{
        return (static_cast<int> (n) ? 0 : 1);
} /* hashkey2 */

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

/// Reads an element from an input stream.
inline std::istream &operator >> (std::istream &in, tZ2 &n)
{
        int number;
        in >> number;
        n = tZ2 (number);
        return in;
} /* operator >> */

/// Writes an element to an output stream.
inline std::ostream &operator << (std::ostream &out, const tZ2 &n)
{
        out << static_cast<int> (n);
        return out;
} /* operator << */

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

/// Operator == for checking whether a ring element is equivalent
/// to an integer number. Intended to compare with 0 and 1 only.
template <class intType>
inline bool operator == (const tZ2 &n1, const intType &n2)
{
        return (static_cast<intType> (static_cast<int> (n1)) == n2);
} /* operator == */

/// Operator == for checking whether a ring element is equivalent
/// to an integer number. Intended to compare with 0 and 1 only.
template <class intType>
inline bool operator == (const intType &n1, const tZ2 &n2)
{
        return (n1 == static_cast<intType> (static_cast<int> (n2)));
} /* operator == */


#endif // _CHAINCON_RINGZ2_H_