General.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
#include "Types/Aliases.hpp"
#include <numeric> //lcm
#include <iostream> //cerr
 
 
namespace mackey
{
 
    template <typename T>
    class InterpolatingVectorGenerator
    {
    public:
        InterpolatingVectorGenerator(const T& min, const T& max);
 
        size_t size() const;
 
        std::vector<T> operator()() const;
 
        class const_iterator
        {
        public:
            const T& operator*() const;
            bool operator!=(const const_iterator& other) const;
            auto& operator++();
 
        private:
            const_iterator(const T& min, const T& max, bool completed);
            const T& min, max;
            bool completed;
            T generated;
            friend class InterpolatingVectorGenerator;
        };
        auto begin() const;
        auto end() const;
 
    private:
        const T& min, max;
    };
 
    template <typename T>
    std::vector<std::vector<T>> combinations(const std::vector<std::vector<T>>& v);
 
    template <typename T>
    std::vector<T> tail(const T* const& ptr, int size, int start);
 
    template <typename rank_t>
    rank_t basisElement(int length, int position, int multiple = 1);
 
    template <typename T, typename S>
    T KeepRow(const T& A, const S& Z);
 
    template <typename T, typename S>
    T KeepCol(const T& A, const S& Z);
 
    template <typename Derived>
    int64_t summation(const Eigen::MatrixBase<Derived>& A);
 
    template <typename rank_t>
    int64_t summation(const rank_t& u, int64_t limit);
 
    template <typename T>
    void rotate(T& V);
 
    template <typename Matrix_t>
    Matrix_t altmatrix(int m, int n, const std::vector<scalar_t<Matrix_t>>& v);
 
    template <typename T>
    bool isZero(const std::vector<T>& a);
 
    template <typename T>
    std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b);
 
    template <typename T>
    std::vector<T> operator-(const std::vector<T>& a, const std::vector<T>& b);
 
    template <typename T>
    std::vector<T> operator-(const std::vector<T>& a);
 
    template <typename T>
    std::vector<T> operator*(T a, const std::vector<T>& b);
 
    template <typename T>
    std::ostream& operator<<(std::ostream& out, const std::vector<T>& a);
 
    template <typename T>
    int lcm(const T& v);
 
    template <typename...>
    class Hash;
 
    template <>
    class Hash<>
    {
    public:
        template <typename S>
        size_t operator()(const S&) const;
    };
 
    template <typename T>
    class Hash<T>
    {
        const T max;
 
    public:
        Hash(const T&);
        size_t max_hash() const;
        template <typename S>
        size_t operator()(const S&) const;
    };
 
    template <typename T>
    class Hash<T, T>
    {
        const T min, max;
 
    public:
        size_t max_hash() const;
        Hash(const T&, const T&);
        template <typename S>
        size_t operator()(const S&) const;
    };
 
    template <typename T, typename S>
    int64_t perfect_hash(const T& deg, const S& min, const S& max);
 
    template <typename T>
    std::vector<triplet_t<T>> make_triplets(const T& a);
 
    template <typename T, typename S>
    std::vector<triplet_t<T>> keep_row_triplets(const T& a, const S& keep);
 
    namespace implementation_details
    {
        template <typename T, bool = mackey::SFINAE::is_Sparse<T>::value>
        class it_nnz_conditional;
    }
 
    template <typename T, bool row_only, bool col_only>
    class IteratorNNZ : implementation_details::it_nnz_conditional<T>
    {
        typedef typename T::StorageIndex storage;
        using implementation_details::it_nnz_conditional<T>::is_sparse;
        using implementation_details::it_nnz_conditional<T>::inner_ind;
        using implementation_details::it_nnz_conditional<T>::it;
    public:
        auto value();                           
        auto row();                             
        auto col();                             
        IteratorNNZ& operator++(); 
        operator bool();                        
 
        IteratorNNZ(const T& matrix, storage row_start, storage col_start);
 
        IteratorNNZ(const T& matrix, storage start);
 
    private:
        const T& matrix;
        const storage inner_start;
        storage outer_ind;
        void increase_until_it_works();
    };
}
#include "impl/General.ipp"