tensorNetwork.h

Go to the documentation of this file.

// Xerus - A General Purpose Tensor Library
// Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
// 
// Xerus is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
// 
// Xerus 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 Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with Xerus. If not, see <http://www.gnu.org/licenses/>.
//
// For further information on Xerus visit https://libXerus.org 
// or contact us at contact@libXerus.org.

#pragma once

#include <set>
#include <memory>
#include <functional>
#include "misc/fileIO.h"
 
#include "indexedTensor.h"

namespace xerus {
    // Necessary forward declaritons
    class Tensor;
    
    class TensorNetwork {
    public:
        using RankTuple = std::vector<size_t>; 
        
        class Link final {
        public:
            size_t other; 
            
            size_t indexPosition;
            
            size_t dimension;
            
            bool external;
            
            Link() noexcept = default;
            Link(const Link& ) noexcept = default;
            Link(      Link&&) noexcept = default;
            
            Link(const size_t _other, const size_t _indexPos, const size_t _dim, const bool _external) noexcept;
            
            Link& operator=(const Link& ) noexcept = default;
            Link& operator=(      Link&&) noexcept = default;
            
            bool links(const size_t _other) const noexcept;
        };
        
        
        class TensorNode final {
        public:
            std::unique_ptr<Tensor> tensorObject;
            
            std::vector<Link> neighbors;
            
            bool erased;
            
            explicit TensorNode();
            
            TensorNode(const TensorNode&  _other);
            TensorNode(      TensorNode&& _other) noexcept = default;
            
            explicit TensorNode(      std::unique_ptr<Tensor>&& _tensorObject);
            
            explicit TensorNode(std::unique_ptr<Tensor>&& _tensorObject, std::vector<Link> _neighbors);
            
            ~TensorNode();
            
            TensorNode& operator=(const TensorNode&  _other);
            TensorNode& operator=(      TensorNode&& _other) noexcept;

            TensorNode strippped_copy() const;
            
            // All getters are written without the use of tensorObject so that they also work for empty nodes
            
            size_t size() const noexcept;
            
            size_t degree() const noexcept;
            
            void erase() noexcept;
        };
        
    protected:
        
        enum class ZeroNode : bool { None, Add };
        
        
    public:
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Member variables - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
            
        std::vector<size_t> dimensions;
        
        std::vector<TensorNode> nodes;
            
        std::vector<Link> externalLinks;
        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Constructors - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
            
        explicit TensorNetwork();
        
        
        TensorNetwork(const TensorNetwork& _cpy) = default;
        
        
        TensorNetwork(TensorNetwork&& _mv) noexcept = default;
        
        
        TensorNetwork(Tensor _other);
        
        
        TensorNetwork(std::unique_ptr<Tensor>&&  _tensor);
        
        
        TensorNetwork(size_t _degree);
        
        explicit TensorNetwork(const ZeroNode _nodeStatus);
        
        
        virtual ~TensorNetwork() = default;
        
        
        virtual TensorNetwork* get_copy() const;
            
    protected:
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Internal Helper functions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
        std::vector<Link> init_from_dimension_array();
        
        
        TensorNetwork stripped_subnet(const std::function<bool(size_t)>& _idF = [](size_t){ return true;}) const;
        
        
        virtual void contract_unconnected_subnetworks();
        
        
        void perform_traces(const size_t _nodeId);
        
    public:
        
        std::pair<size_t, size_t> find_common_edge(const size_t _nodeA, const size_t _nodeB) const;
        
        
        
        void sanitize();

        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Standard operators - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
        
        TensorNetwork& operator=(const TensorNetwork &_cpy) = default;
            
        TensorNetwork& operator=(TensorNetwork &&_mv) = default;
        
        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Conversions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
        
        explicit operator Tensor() const;
        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Access - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
        value_t operator[](const size_t _position) const;
        
        
        value_t operator[](const std::vector<size_t>& _positions) const;
        
        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Basic arithmetics - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
    
        virtual void operator*=(const value_t _factor);
        
        
        virtual void operator/=(const value_t _divisor);
        
        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Indexing - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
        template<typename... args>
        internal::IndexedTensor<TensorNetwork> operator()(args... _args) {
            return internal::IndexedTensor<TensorNetwork>(this, std::vector<Index>({_args...}), false);
        }
        
        
        template<typename... args>
        internal::IndexedTensorReadOnly<TensorNetwork> operator()(args... _args) const {
            return internal::IndexedTensorReadOnly<TensorNetwork>(this, std::vector<Index>({_args...}));
        }
        
        
        internal::IndexedTensor<TensorNetwork> operator()(const std::vector<Index> & _indices);
        
        
        internal::IndexedTensor<TensorNetwork> operator()(      std::vector<Index>&& _indices);
        
        
        internal::IndexedTensorReadOnly<TensorNetwork> operator()(const std::vector<Index> & _indices) const;
        
        
        internal::IndexedTensorReadOnly<TensorNetwork> operator()(      std::vector<Index>&& _indices) const;
        
        
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Operator specializations - - - - - - - - - - - - - - - - - - - - - - - - - - */
        
        virtual bool specialized_contraction(std::unique_ptr<internal::IndexedTensorMoveable<TensorNetwork>>& _out, internal::IndexedTensorReadOnly<TensorNetwork>&& _me, internal::IndexedTensorReadOnly<TensorNetwork>&& _other) const;
        
        
        virtual bool specialized_sum(std::unique_ptr<internal::IndexedTensorMoveable<TensorNetwork>>& _out, internal::IndexedTensorReadOnly<TensorNetwork>&& _me, internal::IndexedTensorReadOnly<TensorNetwork>&& _other) const;
        
        
        virtual void specialized_evaluation(internal::IndexedTensorWritable<TensorNetwork>&& _me, internal::IndexedTensorReadOnly<TensorNetwork>&& _other);
            
        /*- - - - - - - - - - - - - - - - - - - - - - - - - - Miscellaneous - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
    
        size_t degree() const;
        
        size_t datasize() const;
        
        
        void reshuffle_nodes(const std::function<size_t(size_t)>& _f);
        
        
        void require_valid_network(const bool _check_erased = true) const;
        
        
        virtual void require_correct_format() const;
        
        
        void swap_external_links(const size_t _i, const size_t _j);
        
        
        static void add_network_to_network(internal::IndexedTensorWritable<TensorNetwork>&& _base, internal::IndexedTensorReadOnly<TensorNetwork>&& _toInsert);
        
        
        static void link_traces_and_fix(internal::IndexedTensorWritable<TensorNetwork>&& _base);
        
        
        
    public:
        virtual void round_edge(const size_t _nodeA, const size_t _nodeB, const size_t _maxRank, const double _eps, const double _softThreshold);
        
        
        virtual void transfer_core(const size_t _from, const size_t _to, const bool _allowRankReduction = true);
        
        
        void reduce_representation();
        
        
        virtual void fix_mode(const size_t _mode, const size_t _slatePosition);
        
        virtual void remove_slate(const size_t _mode, const size_t _slatePosition);
        
        virtual void resize_mode(const size_t _mode, const size_t _newDim, const size_t _cutPos=~0ul);
        
        void contract(const size_t _nodeId1, const size_t _nodeId2);
        
        
        double contraction_cost(const size_t _nodeId1, const size_t _nodeId2) const;
        
        
        size_t contract(const std::set<size_t>& _ids);
        
        
        virtual value_t frob_norm() const;
        
        
        void draw(const std::string& _filename) const;
    };
    
    TensorNetwork operator*(TensorNetwork &_lhs, value_t _factor);
    
    TensorNetwork operator*(value_t _factor, TensorNetwork &_rhs);
    
    TensorNetwork operator/(TensorNetwork &_lhs, value_t _factor);
    
    static XERUS_force_inline value_t frob_norm(const TensorNetwork& _network) { return _network.frob_norm(); }
    
    
    bool approx_equal(const TensorNetwork& _a, const TensorNetwork& _b, const value_t _eps = EPSILON);
    
    
    bool approx_equal(const TensorNetwork& _a, const Tensor& _b, const value_t _eps = EPSILON);
    
    
    bool approx_equal(const Tensor& _a, const TensorNetwork& _b, const value_t _eps = EPSILON);
    
    
    std::ostream &operator<<(std::ostream &_out, const TensorNetwork::Link &_rhs);
    
    namespace misc {
        void stream_writer(std::ostream &_stream, const TensorNetwork &_obj, const FileFormat _format);
        
        void stream_reader(std::istream &_stream, TensorNetwork &_obj, const FileFormat _format);
    }
}