RCMatrix_interface.h

Go to the documentation of this file.

/*
**  RCMatrix_interface.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Inspired by Robert Bridson's matrix code, re-written by Ryoichi Ando on Feb 7, 2017.
**
**  Permission is hereby granted, free of charge, to any person obtaining a copy of
**  this software and associated documentation files (the "Software"), to deal in
**  the Software without restriction, including without limitation the rights to use,
**  copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
**  Software, and to permit persons to whom the Software is furnished to do so,
**  subject to the following conditions:
**
**  The above copyright notice and this permission notice shall be included in all copies
**  or substantial portions of the Software.
**
**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
**  INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
**  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
**  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
**  CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
**  OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
//
#ifndef SHKZ_RCMATRIX_INTERFACE_H
#define SHKZ_RCMATRIX_INTERFACE_H
//
#include <shiokaze/core/recursive_configurable_module.h>
#include <shiokaze/core/console.h>
#include <functional>
#include <vector>
#include <memory>
//
SHKZ_BEGIN_NAMESPACE
//
template <class N, class T> class RCMatrix_vector_interface;
template <class N, class T> class RCFixedMatrix_interface;
template <class N, class T> class RCMatrix_interface;
//
template <class N, class T> using RCMatrix_vector_ptr = std::shared_ptr<RCMatrix_vector_interface<N,T> >;
template <class N, class T> using RCFixedMatrix_ptr = std::shared_ptr<RCFixedMatrix_interface<N,T> >;
template <class N, class T> using RCMatrix_ptr = std::shared_ptr<RCMatrix_interface<N,T> >;
//
template <class N, class T> class RCMatrix_allocator_interface {
public:
    virtual RCMatrix_vector_ptr<N,T> allocate_vector( N size=0 ) const = 0;
    virtual RCMatrix_ptr<N,T> allocate_matrix( N rows=0, N columns=0 ) const = 0;
};
//
template <class N, class T> class RCMatrix_vector_interface : public RCMatrix_allocator_interface<N,T> {
public:
    virtual void copy( const RCMatrix_vector_interface<N,T> *x ) {
        resize(x->size());
        x->const_for_each([&]( N row, T value ) {
            set(row,value);
        });
    }
    virtual void resize( N size ) = 0;
    virtual N size() const = 0;
    virtual void clear( T value=T() ) = 0;
    virtual T at( N index ) const = 0;
    virtual void set( N index, T value ) = 0;
    virtual void add( N index, T value ) = 0;
    virtual void add( const RCMatrix_vector_interface<N,T> *x ) {
        add_scaled(1.0,x);
    }
    virtual void subtract( const RCMatrix_vector_interface<N,T> *x ) {
        add_scaled(-1.0,x);
    }
    virtual void subtract( N index, T value ) = 0;
    virtual void multiply( N index, T value ) = 0;
    virtual void divide( N index, T value ) = 0;
    virtual void parallel_for_each( std::function<void( N row, T& value )> func) = 0;
    virtual void const_parallel_for_each( std::function<void( N row, T value )> func) const = 0;
    virtual void interruptible_for_each( std::function<bool( N row, T& value )> func) = 0;
    virtual void const_interruptible_for_each( std::function<bool( N row, T value )> func) const = 0;
    virtual T abs_max() const = 0;
    virtual T dot( const RCMatrix_vector_interface<N,T> *x ) const = 0;
    virtual void add_scaled( T alpha, const RCMatrix_vector_interface<N,T> *x ) = 0;
    RCMatrix_vector_ptr<N,T> duplicate() const {
        auto result = this->allocate_vector();
        result->copy(this);
        return result;
    }
    void for_each( std::function<void( N row, T& value )> func) {
        interruptible_for_each([&]( N row, T& value ) {
            func(row,value);
            return false;
        });
    }
    void const_for_each( std::function<void( N row, T value )> func) const {
        const_interruptible_for_each([&]( N row, T value ) {
            func(row,value);
            return false;
        });
    }
    template<class Y> void convert_from( const std::vector<Y> &v ) {
        resize(v.size());
        for( N i=0; i<v.size(); ++i ) set(i,v[i]);
    }
    template<class Y> void convert_to( std::vector<Y> &v ) const {
        v.resize(size());
        for( N i=0; i<v.size(); ++i ) v[i] = at(i);
    }
};
//
template <class N, class T> class RCFixedMatrix_interface : public RCMatrix_allocator_interface<N,T> {
public:
    virtual void multiply( const RCMatrix_vector_interface<N,T> *rhs, RCMatrix_vector_interface<N,T> *result ) const = 0;
    void apply( RCMatrix_vector_interface<N,T> *x ) const {
        auto x_save = allocate_vector(x->size());
        x_save->copy(x);
        multiply(x_save,x);
    }
    template<class Y> void multiply(const std::vector<Y> &rhs, std::vector<T> &result ) const {
        auto _rhs = allocate_vector(rhs.size()); _rhs->convert_from(rhs);
        auto _result = allocate_vector(rhs.size());
        multiply(_rhs,_result);
        _result->convert_to(result);
    }
};
//
template <class N, class T> class RCMatrix_interface : public RCMatrix_allocator_interface<N,T> {
public:
    virtual void initialize( N rows, N columns ) = 0;
    virtual void copy( const RCMatrix_interface<N,T> *m ) = 0;
    virtual void clear( N row ) = 0;
    virtual T get( N row, N column ) const = 0;
    virtual void add_to_element( N row, N column, T increment_value ) = 0;
    virtual void clear_element( N row, N column ) = 0;
    virtual void interruptible_for_each( N row, std::function<bool( N column, T& value )> func) = 0;
    virtual void const_interruptible_for_each( N row, std::function<bool( N column, T value )> func) const = 0;
    virtual N rows() const = 0;
    virtual N columns() const = 0;
    virtual N non_zeros( N row ) const = 0;
    RCMatrix_ptr<N,T> duplicate() const {
        auto result = this->allocate_matrix();
        result->copy(this);
        return result;
    }
    void clear() {
        initialize(rows(),columns());
    }
    N non_zeros() const {
        N sum (0);
        for( N row=0; row<rows(); ++row ) sum += non_zeros(row);
        return sum;
    }
    bool empty() const {
        return non_zeros() == 0;
    }
    bool empty( N row ) const {
        return non_zeros(row) == 0;
    }
    void for_each( N row, std::function<void( N column, T& value )> func) {
        interruptible_for_each(row,[&]( N column, T& value ) {
            func(column,value);
            return false;
        });
    }
    void const_for_each( N row, std::function<void( N column, T value )> func) const {
        const_interruptible_for_each(row,[&]( N column, T value ) {
            func(column,value);
            return false;
        });
    }
    virtual void multiply(T value) = 0;
    virtual void multiply( const RCMatrix_vector_interface<N,T> *rhs, RCMatrix_vector_interface<N,T> *result ) const = 0;
    virtual void multiply( const RCMatrix_interface<N,T> *m, RCMatrix_interface<N,T> *result ) const = 0;
    virtual void add( const RCMatrix_interface<N,T> *m, RCMatrix_interface<N,T> *result ) const = 0;
    virtual void transpose( RCMatrix_interface<N,T> *result ) const = 0;
    virtual RCFixedMatrix_ptr<N,T> make_fixed() const = 0;
    RCMatrix_vector_ptr<N,T> multiply( const RCMatrix_vector_interface<N,T> *rhs ) const {
        assert( rhs->size() == columns());
        auto result = this->allocate_vector();
        multiply(rhs,result.get());
        return result;
    }
    RCMatrix_ptr<N,T> multiply( const RCMatrix_interface<N,T> *m ) const {
        auto result = this->allocate_matrix();
        multiply(m,result.get());
        return result;
    }
    RCMatrix_ptr<N,T> add( const RCMatrix_interface<N,T> *m ) const {
        auto result = this->allocate_matrix();
        add(m,result.get());
        return result;
    }
    RCMatrix_ptr<N,T> transpose() const {
        auto result = this->allocate_matrix();
        transpose(result.get());
        return result;
    }
    template<class Y> void multiply( const std::vector<Y> &rhs, std::vector<Y> &result ) const {
        assert( rhs.size() == columns());
        auto _rhs = this->allocate_vector(rows()); _rhs->convert_from(rhs);
        auto _result = this->allocate_vector(rows());
        multiply(_rhs.get(),_result.get());
        _result->convert_to(result);
    }
    template<class Y> std::vector<Y> multiply( const std::vector<Y> &rhs ) const {
        assert( rhs.size() == columns());
        std::vector<Y> result;
        multiply<Y>(rhs,result);
        return result;
    }
};
//
template <class N, class T> class RCMatrix_factory_interface : public recursive_configurable_module, public RCMatrix_allocator_interface<N,T> {
public:
    //
    DEFINE_MODULE(RCMatrix_factory_interface,"Row Compressed Matrix Factory","RCMatrix","Row compressed matrix module")
    //
};
//
template <class N, class T> using RCMatrix_factory_driver = recursive_configurable_driver<RCMatrix_factory_interface<N,T> >;
//
SHKZ_END_NAMESPACE
//
#endif
//