mod.h

Ugrás a fájl dokumentációjához.

#ifndef MOD_H
#define MOD_H
#include <iostream>
using namespace std;
 
namespace bme {

    const int INITIAL_DEFAULT_MODULUS = 2;
    const int NORMAL_PRINT_MODE = 1;
    const int SHORT_PRINT_MODE = 2;
    const int INITIAL_PRINT_MODE = NORMAL_PRINT_MODE;

 
    class Mod {
 
    private:
        int mod;
        int val;
        static int default_modulus;

        static int print_mode;


        void adjust_val() {
            val = val % mod;
            if (val < 0) { 
                val += mod; 
            }
        }
 
    public:


        Mod() : mod(get_default_modulus()), val(0)  {}


        Mod(int _val) : mod(get_default_modulus()), val(_val) { adjust_val(); }


        Mod(int _val, int _mod){
            if (_mod <= 0) {
                val = 0;
                mod = 0;
            }
            else {
                mod = _mod;
                val = _val;
                adjust_val();
            }
        }

        Mod(const Mod& other) : mod(other.mod), val(other.val)  {}


        int get_val()const { return val; }


        void set_val(int _val) {
            if (mod == 0) { return; }   //invalid példányt nem változtatunk
            val = _val;
            adjust_val();
        }

        int get_mod()const { return mod; }


        void set_mod(int _mod) {
            if (_mod <= 0) {
                mod = 0;
                val = 0;
            }
            else {
                mod = _mod;
                adjust_val();
            }
        }


        static void set_default_modulus(int _def_mod) {
            default_modulus = _def_mod <= 0 ? INITIAL_DEFAULT_MODULUS : _def_mod;
        }


        static void set_normal_print_mode() {
            print_mode = NORMAL_PRINT_MODE;
        }


        static void set_short_print_mode() {
            print_mode = SHORT_PRINT_MODE;
        }

        static int get_print_mode() {
            return print_mode;
        }


        static int get_default_modulus() {
            if (default_modulus <= 0) {
                set_default_modulus(INITIAL_DEFAULT_MODULUS);
            }
            return default_modulus;
        }


        bool is_invalid()const { return mod == 0; }
 
        bool operator==(const Mod& other)const {
            return ((val == other.val) && (mod == other.mod));
        }
 
        bool operator==(int other)const {
            return (*this) == Mod(other, mod);
        }
 
        bool operator!=(const Mod& other)const {
            return !((*this) == other);
        }
 
        bool operator!=(int other)const {
            return (*this) != Mod(other, mod);
        }
 
        bool operator<(const Mod& other)const {
            if (mod < other.mod) { return true; }
            if (mod > other.mod) { return false; }
            if (val < other.val) { return true; }
            return false;
        }
 
        bool operator<=(const Mod& other)const {
            return (*this) < other || (*this) == other;
        }
 
        bool operator>(const Mod& other) const {
            return !((*this) <= other);
        }
 
        bool operator>=(const Mod& other) const {
            return !((*this) < other);
        }
 
 
        Mod& operator=(const Mod& other) {
            mod = other.mod;
            val = other.val;
            return *this;
        }


        Mod add(const Mod& other)const;
 
        Mod operator+(const Mod& other)const { return add(other); }
        Mod operator+(int other)const { return add(Mod(other,mod)); }
        Mod& operator+=(const Mod& other) { return *this = add(other); }
        Mod& operator+=(int other) { return *this = add(Mod(other, mod)); }
        Mod operator-() const { return Mod(-val, mod); }
        Mod operator-(const Mod& other)const { return (*this) + (-other); }
        Mod operator-(int other)const { return (*this) + (-other); }
        Mod& operator-=(const Mod& other) { return *this = add(-other); }
        Mod& operator-=(int other) { return *this = add(Mod(-other, mod)); }


        Mod multiply(const Mod& other)const;
 
        Mod operator*(const Mod& other)const { return multiply(other); }
        Mod operator*(int other)const { return multiply(Mod(other,mod)); }       
        Mod& operator*=(const Mod& other) { return *this = multiply(other); }
        Mod& operator*=(int other) { return *this = multiply(Mod(other,mod)); }


        Mod inverse()const;
 
        Mod operator/(const Mod& other)const { return multiply(other.inverse()); }
        Mod operator/(int other)const { return multiply(Mod(other,mod).inverse()); }
        Mod& operator/=(const Mod& other) { return *this = multiply(other.inverse()); }
        Mod& operator/=(int other) { return *this = multiply(Mod(other,mod).inverse()); }


        Mod pow(int k)const;
    };

    ostream& operator<<(ostream& os, const Mod& M);
 
    inline bool operator==(int x, const Mod& M) { return M == x; }
    inline bool operator!=(int x, const Mod& M) { return M != x; }
    inline Mod operator+(int x, const Mod& M) { return M + x; }
    inline Mod operator-(int x, const Mod& M) { return (-M) + x; }
    inline Mod operator*(int x, const Mod& M) { return M * x; }
    inline Mod operator/(int x, const Mod& M) { return M.inverse() * x; }
 
}
 
#endif