indexedTensor_tensor_factorisations.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 <limits>

#include "basic.h"

namespace xerus {
    class Tensor;
    
    namespace internal {
        template<class tensor_type> class IndexedTensorReadOnly;
        template<class tensor_type> class IndexedTensor;
    }
    
    class TensorFactorisation {
    public:
        virtual void operator()(const std::vector<internal::IndexedTensor<Tensor>*>& _output) const = 0;
        
        virtual ~TensorFactorisation() = default;
    };
    
    class SVD : public TensorFactorisation{
    public:
        internal::IndexedTensorReadOnly<Tensor>* input;
        const double epsilon;
        const double softThreshold;
        const size_t maxRank;
        const bool preventZero;
        
        SVD(internal::IndexedTensorReadOnly<Tensor>&& _input) : 
            input(&_input), epsilon(EPSILON), softThreshold(0.0), maxRank(std::numeric_limits<size_t>::max()), preventZero(false) { }
            
        SVD(internal::IndexedTensorReadOnly<Tensor>&& _input, const double _softTreshold, const bool _preventZero = false) : 
            input(&_input), epsilon(0.0), softThreshold(_softTreshold), maxRank(std::numeric_limits<size_t>::max()), preventZero(_preventZero) { }
            
        SVD(internal::IndexedTensorReadOnly<Tensor>&& _input, const size_t _maxRank, const double _epsilon = EPSILON) : 
            input(&_input), epsilon(_epsilon), softThreshold(0.0), maxRank(_maxRank), preventZero(false) { }
            
        SVD(internal::IndexedTensorReadOnly<Tensor>&& _input, const size_t _maxRank, const double _epsilon, const double _softTreshold, const bool _preventZero) : 
            input(&_input), epsilon(_epsilon), softThreshold(_softTreshold), maxRank(_maxRank), preventZero(_preventZero) { }
        
        virtual void operator()(const std::vector<internal::IndexedTensor<Tensor>*>& _output) const override;
    };

    class QR : public TensorFactorisation {
    public:
        internal::IndexedTensorReadOnly<Tensor>* input;
        QR(internal::IndexedTensorReadOnly<Tensor>&& _input) : input(&_input) { }
        
        virtual void operator()(const std::vector<internal::IndexedTensor<Tensor>*>& _output) const override;
    };

    class RQ : public TensorFactorisation {
    public:
        internal::IndexedTensorReadOnly<Tensor>* input;
        RQ(internal::IndexedTensorReadOnly<Tensor>&& _input) : input(&_input) { }
        
        virtual void operator()(const std::vector<internal::IndexedTensor<Tensor>*>& _output) const override;
    };
    
    class QC : public TensorFactorisation {
    public:
        internal::IndexedTensorReadOnly<Tensor>* input;
        QC(internal::IndexedTensorReadOnly<Tensor>&& _input) : input(&_input) { }
        
        virtual void operator()(const std::vector<internal::IndexedTensor<Tensor>*>& _output) const override;
    };
    
    class CQ : public TensorFactorisation {
    public:
        internal::IndexedTensorReadOnly<Tensor>* input;
        CQ(internal::IndexedTensorReadOnly<Tensor>&& _input) : input(&_input) { }
        
        virtual void operator()(const std::vector<internal::IndexedTensor<Tensor>*>& _output) const override;
    };
}