quadraticinteger_big.h

Go to the documentation of this file.

/*
Copyright (C) 2014, 2015, 2016
Rafael Guglielmetti, rafael.guglielmetti@unifr.ch
*/

/*
This file is part of AlVin.

CoxIter 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.

CoxIter 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 AlVin. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef QUADRATICINTEGER_BIG_H
#define QUADRATICINTEGER_BIG_H

#include "algebraicinteger.h"
#include "quadraticinteger.h"

#include <cmath>
#include <vector>
#include <map>
#include <array>
#include <string>
#include <gmpxx.h>

using namespace std;

class QuadraticIntegerBig : public AlgebraicInteger
{
    public:
        mpz_class a; 
        mpz_class b; 
        
        static int d; 
        static mpf_class sqrtd; 
        static bool bIsOneMod4; 
        static int iDiscriminant; 
        
        static map< unsigned int, vector< unsigned int > > iPellMinimalSolution; 
        static map< unsigned int, vector< long int > > iFundamentalUnits; 
        
    public:
        QuadraticIntegerBig();
        QuadraticIntegerBig( const int& iVal );
        QuadraticIntegerBig( const mpz_class& iVal );
        QuadraticIntegerBig( const QuadraticIntegerBig& qi );
        QuadraticIntegerBig( const QuadraticInteger& qi );
        QuadraticIntegerBig( const int& a, const int& b );
        QuadraticIntegerBig( const mpz_class& a, const mpz_class& b );
        virtual ~QuadraticIntegerBig();
        
        AlgebraicInteger* copy() const;
        AlgebraicInteger* aiCopyToInteger( const int& n ) const;
        virtual void set( const int& n );
        virtual void set( AlgebraicInteger* ai );
        
        virtual void removeSquareFactors();
        
        virtual bool bIsInvertible() const;
        virtual bool bIsSquareOfIvertible() const;
        
        virtual void gcd( const AlgebraicInteger* ai );
        virtual bool bIsDivisbleBy( const AlgebraicInteger* ) const;
        virtual void divideBy( const AlgebraicInteger *ai );
        virtual bool divideByIfDivisible( const AlgebraicInteger* ai );
        virtual void multiplyBy( const int& n );
        virtual void multiplyBy( const AlgebraicInteger *ai );
        virtual void add( const AlgebraicInteger *ai );
        virtual void substract( const AlgebraicInteger *ai );
        virtual void opp();
        
        virtual bool bIsLessThan( const int& n ) const;
        virtual bool bIsLessThan( const long int& n ) const;
        virtual bool bIsLessThan( const AlgebraicInteger& ai ) const;
        virtual bool bIsLessOEThan( const AlgebraicInteger& ai ) const;
        virtual bool bIsGreaterThan( const int& n ) const;
        virtual bool bIsGreaterThan( const long int& n ) const;
        virtual bool bIsGreaterOEThan( const int& n ) const;
        virtual bool bIsEqualTo( const AlgebraicInteger& ai ) const;
        virtual bool bIsEqualTo( const int& n ) const;
        
        ostream& print( ostream& ) const;
        virtual string to_string( const string& strFormat = "generic", const bool& bProtect = false ) const;
        virtual double to_double() const;
        virtual string get_classname() const;
        
        mpz_class floor() const;
        
    public:
        static bool bIsDAdmissible( const unsigned int& d );
        static void set_d( const unsigned int& d );
        static vector< QuadraticIntegerBig > qiFactorsRationalPrime( const unsigned int& iPrime, bool bWithMultiplicities = false );
        static array< long int, 2 > iPellEquation( const unsigned int& iPrime );
        static mpz_class iSQRT_quotient( const QuadraticIntegerBig &qiNum, const QuadraticIntegerBig &qiDen );
        static mpz_class iSQRTsup_quotient( const QuadraticIntegerBig &qiNum, const QuadraticIntegerBig &qiDen );
        
        void conjugate();
        mpz_class iNorm() const;
        mpz_class iTrace() const;
        
        int iValuation( const QuadraticIntegerBig& qi );

        vector< QuadraticIntegerBig > qiPrimeFactors() const;
        map< QuadraticIntegerBig, unsigned int > qiPrimeDecomposition() const;
        
        bool bIsAssociateTo( QuadraticIntegerBig qi2 );
        
        // --------------------------------------------
        // Operators
        QuadraticIntegerBig& operator=( const QuadraticIntegerBig& );
        QuadraticIntegerBig& operator/=( QuadraticIntegerBig const &qi );
        QuadraticIntegerBig& operator*=( QuadraticIntegerBig const &qi );
        
        QuadraticIntegerBig operator+( const QuadraticIntegerBig& ) const;
        QuadraticIntegerBig operator*( const QuadraticIntegerBig& ) const;
        QuadraticIntegerBig operator-( const QuadraticIntegerBig& ) const;
        QuadraticIntegerBig operator-() const;
        
        bool operator==(const long int& ) const;
        bool operator==(const QuadraticIntegerBig& ) const;
        bool operator>(const QuadraticIntegerBig& ) const;
};

bool operator<( const QuadraticIntegerBig& qi1, const QuadraticIntegerBig& qi2 );

#endif // QUADRATICINTEGER_H