alvin.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 ALVIN_H
#define ALVIN_H

#include <vector>
#include <iterator>
#include <iostream>
#include <cmath>
#include <algorithm>

#include <map>
#include <memory>

#include "CoxIter/coxiter.h"
#include "CoxIter/lib/math_tools.h"

#include "algebraicinteger.h"
#include "alvinfractions.h"

using namespace std;
using namespace MathTools;

class AlVin
{
    protected:
        vector< AlgebraicInteger* > aiQF;
        unsigned int iDimension; 
        
        bool bComputeInvariantsPolyhedron; 
        bool bDebug; 
        bool bWriteInfo; 
        int iCreateImage; 
        
        string strAlgebraicIntegerType; 
        
        vector< unsigned int > iQBlocksSize; 
        vector< unsigned int > iComponentLessThan; 
        
        vector< vector< AlgebraicInteger* > > aiVectors; 
        unsigned int iVectorsCount; 
        unsigned int iVectorsCount_second; 
        
        vector< vector< AlgebraicInteger* > > aiVectors_candidates; 
        
        vector< vector< unsigned int > > iCoxeterMatrix;

        vector< AlgebraicInteger* > iBilinearProducts; 
        
        AlVinFractions *vf;
        
        string strOuputMathematicalFormat;
        
        string strFinalInformation; 
        
    private:
        CoxIter* ptrCI;
        
    public:
        AlVin( const string& strOuputMathematicalFormat, const bool& bWriteInfo, const bool& bDebug );
        
        virtual ~AlVin();
        
        virtual bool PreRun() = 0;
        
        bool Run( unsigned int iMinVectors = 0, unsigned int iMaxVectors = 0, bool bLastCheckFV = true );
        
        AlgebraicInteger* aiBilinearProduct( const vector< AlgebraicInteger* >& v1, const vector< AlgebraicInteger* >& v2 );
        
        void print_iQF() const;
        
        void print_vectors() const;
        
        vector< vector< unsigned int > > get_iCoxeterMatrix() const;
        
        unsigned int get_iDimension() const;
        
        string get_strFinalInformation() const;
        
        string get_strCoxeterMatrix() const;
        
        virtual string get_strField() const = 0;
        
        string get_strQF( const string& strSeparator = ", " ) const;
        
        string get_strAlgebraicIntegerType() const;
        
        vector< vector< AlgebraicInteger* > > get_aiVectors() const;
        
        unsigned int get_iVectorsCount() const;
        
        vector< AlgebraicInteger* > get_aiQF() const;
        
        vector< AlgebraicInteger* > get_aiPossibleNorm2() const;
        
        const vector< AlgebraicInteger* >* get_ptraiPossibleNorm2() const;
        
        CoxIter* get_ptrCI() const;
        
        // ---------------------------------------------------
        // Setters
        
        void set_iCreateImage( const int& iValue );
        
        void set_bComputeInvariantsPolyhedron( const bool& bValue );
        
    protected:
        void initializations();
        
        void print_initialInformation() const;
        virtual void print_initialInformationChild() const;
        void print_finallInformation() const;

    private:
        virtual void findPossibleNorms2() = 0;
        virtual void findVector( AlgebraicInteger* aiX0, AlgebraicInteger* aiNorm2 ) = 0;
        
        void findFirstVectors();

        void addVector( const vector< AlgebraicInteger* >& aiVect );
        virtual int addVector_iFindWeight( AlgebraicInteger* aiNumerator, AlgebraicInteger* aiDenominator ) = 0;
        
        void printFoundVector( vector< AlgebraicInteger* > aiV, const unsigned int& iIndex, const bool& bFirst = false ) const;
        
        virtual void addVectorChild( const vector< AlgebraicInteger* >& aiVector ) = 0;
};

inline AlgebraicInteger* AlVin::aiBilinearProduct( const vector< AlgebraicInteger* >& v1, const vector< AlgebraicInteger* >& v2 )
{
    AlgebraicInteger* aiProduct( aiQF[0]->copy() );
    AlgebraicInteger* aiTemp( aiQF[0]->copy() );
    
    aiProduct->opp();
    aiProduct->multiplyBy( v1[0] );
    aiProduct->multiplyBy( v2[0] );
    
    for( unsigned int j( 1 ); j <= iDimension; j++ )
    {
        aiTemp->set( aiQF[j] );
        aiTemp->multiplyBy( v1[j] );
        aiTemp->multiplyBy( v2[j] );
        aiProduct->add( aiTemp );
    }
    
    delete aiTemp;
    
    return aiProduct;
}

#endif // ALVIN_H