retractions.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 <vector>
#include "../tensor.h"

namespace xerus {

    class TTTangentVector {
    public:
        TTTensor baseL;
        
        void set_base(const TTTensor &_newBase);
        
        std::vector<Tensor> components;
        TTTangentVector() {};
        TTTangentVector(const TTTensor &_base, const TTTensor &_direction);
        TTTangentVector &operator+=(const TTTangentVector &_rhs);
        TTTangentVector &operator-=(const TTTangentVector &_rhs);
        TTTangentVector &operator*=(value_t _alpha);
        TTTangentVector operator*(value_t _alpha) const;
        value_t scalar_product(const TTTangentVector &_other) const;
        value_t frob_norm() const;
    private:
        TTTensor change_direction_incomplete() const;
    public:
        explicit operator TTTensor() const;
        TTTensor added_to_base() const;
    };
    
    TTTangentVector operator*(value_t _alpha, const TTTangentVector &_rhs);
    
    struct HOSVDRetraction {
        bool roundByVector;
        size_t rank;
        std::vector<size_t> rankVector;
        void operator()(TTTensor &_U, const TTTensor &_change) const;
        void operator()(TTTensor &_U, const TTTangentVector &_change) const;
        HOSVDRetraction(size_t _rank) : roundByVector(false), rank(_rank) {}
        HOSVDRetraction(const std::vector<size_t> &_rank) : roundByVector(true), rank(~0ul), rankVector(_rank) {}
    };
    
    using TTRetractionI = std::function<void(TTTensor &, const TTTangentVector &)>;
    using TTRetractionII = std::function<void(TTTensor &, const TTTensor &)>;
    using TTVectorTransport = std::function<void(const TTTensor &, TTTangentVector &)>;
    
    void HOSVDRetractionI(TTTensor &_U, const TTTangentVector &_change);
    void HOSVDRetractionII(TTTensor &_U, const TTTensor &_change);
    
    void ALSRetractionII(TTTensor &_U, const TTTensor &_change);
    
    void ALSRetractionI(TTTensor &_U, const TTTangentVector &_change);
    
    void SubmanifoldRetractionII(TTTensor &_U, const TTTensor &_change);
    
    void SubmanifoldRetractionI(TTTensor &_U, const TTTangentVector &_change);
    
    
    void ProjectiveVectorTransport(const TTTensor &_newBase, TTTangentVector &_tangentVector);
    
}