IntegerMatrixFunctions.h

 
#pragma once
 
#if defined(IntegerMatrixFunctions_RECURSES)
#error Recursive header files inclusion detected in IntegerMatrixFunctions.h
#else // defined(IntegerMatrixFunctions_RECURSES)
#define IntegerMatrixFunctions_RECURSES
 
#if !defined IntegerMatrixFunctions_h
#define IntegerMatrixFunctions_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/ArithmeticConversionTraits.h"
#include "DGtal/arithmetic/IntegerComputer.h"
#include "DGtal/math/linalg/SimpleMatrix.h"
 
namespace DGtal
{
 
  namespace functions {
 
    template <typename TComponent>
    void
    negate( std::vector<TComponent> &V );
 
    template <typename TComponent>
    bool
    equals( const std::vector<TComponent> &a, const std::vector<TComponent> &b );
 
    template <typename T, typename U >
    typename DGtal::ArithmeticConversionTraits<T,U>::type
    dotProduct( const std::vector<T>& a, const std::vector<U>& b );
 
    double
    dotProduct( const std::vector<BigInteger>& a, const std::vector<double>& b );
 
    double
    dotProduct( const std::vector<double>& a, const std::vector<BigInteger>& b );
 
    template <typename T, typename U >
    std::vector< typename DGtal::ArithmeticConversionTraits<T,U>::type >
    crossProduct( const std::vector<T>& a, const std::vector<U>& b );
 
    template <typename T, typename U, typename Op2 >
    std::vector< typename DGtal::ArithmeticConversionTraits<T,U>::type >
    apply( const std::vector<T>& a, const std::vector<U>& b,
           Op2 op2 );
    
    template <typename T>
    T
    squaredNormL2( const std::vector<T>& a );
    
    template <typename T>
    T
    normL1( const std::vector<T>& a );
 
    template <typename T>
    T
    normLoo( const std::vector<T>& a );
    
    template <typename TOutput, typename T>
    void
    getSquaredNormL2( TOutput& n, const std::vector<T>& a );
 
    template <typename TOutput,
              DGtal::Dimension dim,
              typename TEuclideanRing,
              typename TContainer>
    void
    getSquaredNormL2( TOutput& n,
                      const DGtal::PointVector<dim,TEuclideanRing,TContainer>& a );
    
    template <typename TComponent, DGtal::Dimension TN,
              typename TInternalNumber>
    void
    getDeterminantBareiss( TInternalNumber& result,
                           const SimpleMatrix<TComponent, TN, TN>& matrix );
 
    template <typename TComponent, typename TInternalNumber>
    void
    getDeterminantBareiss( TInternalNumber& result,
                           const std::vector< std::vector< TComponent > >& matrix );
 
    template <typename TComponent>
    std::vector< std::vector< TComponent > >
    matrixAsVectorVector( std::size_t m, std::size_t n,
                          const std::vector< TComponent >& c );
 
    template <typename TComponent, DGtal::Dimension TM, DGtal::Dimension TN>
    std::vector< std::vector< TComponent > >
    matrixAsVectorVector( const SimpleMatrix<TComponent, TM, TN>& M );
 
    template <typename TComponent, typename TDouble = long double >
    std::vector< std::vector< TComponent > >
    computeLLLBasis( const std::vector< std::vector< TComponent > >& B,
                     TDouble delta = 0.75 );
    
    template <typename TComponent, typename TDouble = long double >
    void
    reduceBasisWithLLL( std::vector< std::vector< TComponent > >& B,
                        TDouble delta = 0.75 );
 
    template <typename TComponent>
    TComponent
    makePrimitive( std::vector< TComponent >& N );
 
    template <typename TComponent>
    TComponent
    extendedGcd( TComponent& x, TComponent& y, TComponent a,TComponent b );
 
    template <typename TComponent>
    TComponent
    extendedGcd( std::vector<TComponent> &C, const std::vector<TComponent> &A );
    
    
    template <typename TComponent>
    std::vector< std::vector< TComponent > >
    computeOrthogonalLattice( std::vector< TComponent > N );
 
    template <typename TComponent>
    bool
    shortenVectors( std::vector< TComponent >& u,
                    std::vector< TComponent >& v );
 
    template <typename TComponent>
    std::size_t
    shortenBasis( std::vector< std::vector< TComponent > >& B );
    
  } // namespace functions
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/math/linalg/IntegerMatrixFunctions.ih"
 
//                                                                           //
 
#endif // !defined IntegerMatrixFunctions_h
 
#undef IntegerMatrixFunctions_RECURSES
#endif // else defined(IntegerMatrixFunctions_RECURSES)