bitmacarray2.h

Go to the documentation of this file.

/*
**  bitmacarray2.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Created by Ryoichi Ando <rand@nii.ac.jp> on August 8, 2018.
**
**  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_BITMACARRAY2_H
#define SHKZ_BITMACARRAY2_H
//
#include <shiokaze/array/bitarray2.h>
#include <algorithm>
#include <array>
//
SHKZ_BEGIN_NAMESPACE
//
class bitmacarray2 : public recursive_configurable, public messageable {
public:
    bitmacarray2 ( recursive_configurable *parent, const shape2 &shape, std::string core_name="") : m_shape(shape), m_array_0(this,shape.face(0),core_name), m_array_1(this,shape.face(1),core_name) {
            if( parent ) parent->add_child(this);
            else setup_now();
    }
    bitmacarray2( recursive_configurable *parent, std::string core_name="" ) : bitmacarray2(parent,shape2(0,0),core_name) {}
    bitmacarray2 ( std::string core_name="") : bitmacarray2(nullptr,shape2(0,0),core_name) {}
    bitmacarray2( const shape2 &shape, std::string core_name="") : bitmacarray2(nullptr,shape,core_name) {}
    bitmacarray2 ( const bitmacarray2& v ) : m_array_0(this), m_array_1(this) {
        copy(v);
    }
    virtual bool send_message( std::string message, void *ptr ) override {
        bool handled (false);
        if(m_array_0.send_message(message,ptr)) handled = true;
        if(m_array_1.send_message(message,ptr)) handled = true;
        return handled;
    }
    virtual bool const_send_message( std::string message, void *ptr ) const override {
        bool handled (false);
        if(m_array_0.const_send_message(message,ptr)) handled = true;
        if(m_array_1.const_send_message(message,ptr)) handled = true;
        return handled;
    }
    bitmacarray2& operator=(const bitmacarray2 &array) {
        copy(array);
        return *this;
    }
    void copy( const bitmacarray2 &array ) {
        if( this != &array ) {
            set_type(array.type());
            for( int dim : DIMS2 ) (*this)[dim].copy(array[dim]);
        }
    }
    void initialize ( const shape2 &shape ) {
        m_shape = shape;
        for( int dim : DIMS2 )(*this)[dim].initialize(shape.face(dim));
    }
    size_t count () const {
        size_t sum (0);
        for( int dim : DIMS2 ) sum += (*this)[dim].count();
        return sum;
    }
    std::array<std::vector<vec2i>,DIM2> actives() const {
        std::array<std::vector<vec2i>,DIM2> result;
        m_parallel.for_each( DIM2, [&]( size_t dim ) {
            result[dim] = (*this)[dim].actives();
        });
        return result;
    }
    void activate( const std::array<std::vector<vec2i>,DIM2> &active_entries, const std::array<vec2i,DIM2> &offsets={vec2i(),vec2i()} ) {
        m_parallel.for_each( DIM2, [&]( size_t dim ) {
            (*this)[dim].activate(active_entries[dim],offsets[dim]);
        });
    }
    void activate_as_bit( const bitmacarray2 &array, const std::array<vec2i,DIM2> &offsets={vec2i(),vec2i()} ) {
        m_parallel.for_each( DIM2, [&]( size_t dim ) {
            (*this)[dim].activate_as_bit(array[dim],offsets[dim]);
        });
    }
    template <class Y> void activate_as( const Y &array, const std::array<vec2i,DIM2> &offsets={vec2i(),vec2i()} ) {
        m_parallel.for_each( DIM2, [&]( size_t dim ) {
            (*this)[dim].activate_as_bit(array[dim],offsets[dim]);
        });
    }
    void activate_all() {
        m_parallel.for_each( DIM2, [&]( size_t dim ) {
            (*this)[dim].activate_all();
        });
    }
    void copy_active_as( const bitmacarray2 &array, const vec2i &offset=vec2i() ) {
        m_parallel.for_each( DIM2, [&]( size_t dim ) {
            (*this)[dim].copy_active_as(array[dim],offset);
        });
    }
    shape2 shape() const { return m_shape; }
    shape2 shape(int dim) const { return (*this)[dim].shape(); }
    void clear() {
        for( int dim : DIMS2 )(*this)[dim].clear();
    }
    bool operator!=( const bitmacarray2 &v ) const {
        return ! (*this == v);
    }
    bool operator==(const bitmacarray2 &v) const {
        for( int dim : DIMS2 ) {
            if((*this)[dim] != v[dim]) return false;
        }
        return true;
    }
    const bitarray2& operator[](int dim) const {
        return dim==0 ? m_array_0 : m_array_1;
    }
    bitarray2& operator[](int dim) {
        return dim==0 ? m_array_0 : m_array_1;
    }
    void set_thread_num( int number ) {
        for( int dim : DIMS2 ) (*this)[dim].set_thread_num(number);
    }
    int get_thread_num() const {
        return m_array_0.get_thread_num();
    }
    //
    enum { ACTIVES = true, ALL = false };
    inline void parallel_actives( std::function<void(typename bitarray2::iterator& it)> func ) { parallel_op(func,ACTIVES); }
    inline void parallel_all( std::function<void(typename bitarray2::iterator& it)> func ) { parallel_op(func,ALL); }
    inline void parallel_op( std::function<void(typename bitarray2::iterator& it)> func, bool type=ALL ) {
        parallel_op([func](int dim, int i, int j, typename bitarray2::iterator& it, int thread_index){
            func(it);
        },type);
    }
    inline void parallel_actives( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func ) { parallel_op(func,ACTIVES); }
    inline void parallel_all( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func ) { parallel_op(func,ALL); }
    inline void parallel_op( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func, bool type=ALL ) {
        parallel_op([func](int dim, int i, int j, typename bitarray2::iterator& it, int thread_index){
            func(dim,i,j,it);
        },type);
    }
    inline void parallel_actives( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it, int thread_index)> func ) { parallel_op(func,ACTIVES); }
    inline void parallel_all( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it, int thread_index)> func ) { parallel_op(func,ALL); }
    inline void parallel_op( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it, int thread_index)> func, bool type=ALL ) {
        for( int dim : DIMS2 ) {
            (*this)[dim].parallel_op([&](int i, int j, typename bitarray2::iterator& it, int thread_index) {
                func(dim,i,j,it,thread_index);
            },type);
        }
    }
    inline void const_parallel_all( std::function<void(const typename bitarray2::const_iterator& it)> func ) const { const_parallel_op(func,ALL); }
    inline void const_parallel_op( std::function<void(const typename bitarray2::const_iterator& it)> func, bool type=ALL ) const {
        const_parallel_op([func](int dim, int i, int j, const typename bitarray2::const_iterator& it, int thread_index){
            func(it);
        },type);
    }
    inline void const_parallel_actives( std::function<void(int dim, int i, int j)> func ) const {
        const_parallel_op([&](int dim, int i, int j, const typename bitarray2::const_iterator& it){ func(dim,i,j); }, ACTIVES); }
    inline void const_parallel_all( std::function<void(int dim, int i, int j, const typename bitarray2::const_iterator& it)> func ) const { const_parallel_op(func,ALL); }
    inline void const_parallel_op( std::function<void(int dim, int i, int j, const typename bitarray2::const_iterator& it)> func, bool type=ALL ) const {
        const_parallel_op([func](int dim, int i, int j, const typename bitarray2::const_iterator& it, int thread_index){
            func(dim,i,j,it);
        },type);
    }
    inline void const_parallel_actives( std::function<void(int dim, int i, int j, int thread_index)> func ) const { const_parallel_op([&](int dim, int i, int j, const typename bitarray2::const_iterator& it, int thread_index) { func(dim,i,j,thread_index); }, ACTIVES); }
    inline void const_parallel_all( std::function<void(int dim, int i, int j, const typename bitarray2::const_iterator& it, int thread_index)> func ) const { const_parallel_op(func,ALL); }
    inline void const_parallel_op( std::function<void(int dim, int i, int j, const typename bitarray2::const_iterator& it, int thread_index)> func, bool type=ALL ) const {
        for( int dim : DIMS2 ) {
            (*this)[dim].const_parallel_op([&](int i, int j, const typename bitarray2::const_iterator& it, int thread_index) {
                func(dim,i,j,it,thread_index);
            },type);
        };
    }
    inline void serial_actives( std::function<void(typename bitarray2::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void serial_all( std::function<void(typename bitarray2::iterator& it)> func ) { serial_op(func,ALL); }
    inline void serial_op( std::function<void(typename bitarray2::iterator& it)> func, bool type=ALL ) {
        serial_op([func](int dim, int i, int j, typename bitarray2::iterator& it) {
            func(it);
        },type);
    }
    inline void serial_actives( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void serial_all( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func ) { serial_op(func,ALL); }
    inline void serial_op( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func, bool type=ALL ) {
        for( int dim : DIMS2 ) {
            (*this)[dim].serial_op([&](int i, int j, typename bitarray2::iterator& it) {
                func(dim,i,j,it);
            },type);
        }
    }
    inline void const_serial_all( std::function<void(const typename bitarray2::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void const_serial_op( std::function<void(const typename bitarray2::const_iterator& it)> func, bool type=ALL ) const {
        const_serial_op([func](int dim, int i, int j, const typename bitarray2::const_iterator& it) {
            func(it);
        },type);
    }
    inline void const_serial_actives( std::function<void(int dim, int i, int j)> func ) const {
        const_serial_op([&](int dim, int i, int j, const typename bitarray2::const_iterator& it) { func(dim,i,j); }, ACTIVES); }
    inline void const_serial_all( std::function<void(int dim, int i, int j, const typename bitarray2::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void const_serial_op( std::function<void(int dim, int i, int j, const typename bitarray2::const_iterator& it)> func, bool type=ALL ) const {
        for( int dim : DIMS2 ) {
            (*this)[dim].const_serial_op([&](int i, int j, const typename bitarray2::const_iterator& it) {
                func(dim,i,j,it);
            },type);
        }
    }
    inline void interruptible_serial_actives( std::function<bool(typename bitarray2::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void interruptible_serial_all( std::function<bool(typename bitarray2::iterator& it)> func ) { serial_op(func,ALL); }
    inline void interruptible_serial_op( std::function<bool(typename bitarray2::iterator& it)> func, bool type=ALL ) {
        serial_op([func](int dim, int i, int j, typename bitarray2::iterator& it) {
            func(it);
        },type);
    }
    inline void interruptible_serial_actives( std::function<bool(int dim, int i, int j, typename bitarray2::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void interruptible_serial_all( std::function<bool(int dim, int i, int j, typename bitarray2::iterator& it)> func ) { serial_op(func,ALL); }
    inline void interruptible_serial_op( std::function<bool(int dim, int i, int j, typename bitarray2::iterator& it)> func, bool type=ALL ) {
        for( int dim : DIMS2 ) {
            (*this)[dim].serial_op([&](int i, int j, typename bitarray2::iterator& it) {
                func(dim,i,j,it);
            },type);
        }
    }
    inline void interruptible_const_serial_all( std::function<bool(const typename bitarray2::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void interruptible_const_serial_op( std::function<bool(const typename bitarray2::const_iterator& it)> func, bool type=ALL ) const {
        const_serial_op([func](int dim, int i, int j, const typename bitarray2::const_iterator& it) {
            func(it);
        },type);
    }
    inline void interruptible_const_serial_actives( std::function<bool(int dim, int i, int j)> func ) const {
        const_serial_op([&](int dim, int i, int j, const typename bitarray2::const_iterator& it){ return func(dim,i,j); }, ACTIVES); }
    inline void interruptible_const_serial_all( std::function<bool(int dim, int i, int j, const typename bitarray2::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void interruptible_const_serial_op( std::function<bool(int dim, int i, int j, const typename bitarray2::const_iterator& it)> func, bool type=ALL ) const {
        for( int dim : DIMS2 ) {
            (*this)[dim].const_serial_op([&](int i, int j, const typename bitarray2::const_iterator& it) {
                func(dim,i,j,it);
            },type);
        }
    }
    void dilate( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it, int thread_index)> func, int count=1 ) {
        while( count -- ) {
            m_parallel.for_each(DIM2,[&]( size_t dim ) {
                operator[](dim).dilate([&](int i, int j, typename bitarray2::iterator& it, int thread_index) {
                    func(dim,i,j,it,thread_index);
                });
            });
        }
    }
    void dilate( std::function<void(int dim, int i, int j, typename bitarray2::iterator& it)> func, int count=1 ) {
        dilate([&](int dim, int i, int j, typename bitarray2::iterator& it, int thread_index) {
            func(dim,i,j,it);
        },count);
    }
    void dilate( int count=1 ) {
        dilate([&](int dim, int i, int j, typename bitarray2::iterator& it){ it.set(); },count);
    }
    void erode( std::function<bool(int dim, int i, int j, int thread_index)> func, int count=1 ) {
        while( count -- ) {
            m_parallel.for_each(DIM2,[&]( size_t dim ) {
                operator[](dim).erode([&](int i, int j, int thread_index) {
                    return func(dim,i,j,thread_index);
                });
            });
        }
    }
    void erode( std::function<bool(int dim, int i, int j)> func, int count=1 ) {
        erode([&](int dim, int i, int j, int thread_index) {
            return func(dim,i,j);
        },count);
    }
    void erode( int count=1 ) {
        return erode([&](int dim, int i, int j){ return true; },count);
    }
    void set_core_name( std::string core_name ) {
        m_array_0.set_core_name(core_name);
        m_array_1.set_core_name(core_name);
    }
    std::string get_core_name() const {
        return m_array_0.get_core_name();
    }
    struct type2 {
        std::string core_name;
        shape2 shape;
        typename bitarray2::type2 type0;
        typename bitarray2::type2 type1;
        bool operator==( const type2 &type ) const {
            return
                core_name == type.core_name && shape == type.shape &&
                type0 == type.type0 && type1 == type.type1;
        }
    };
    type2 type() const {
        return { get_core_name(), m_shape, m_array_0.type(), m_array_1.type() };
    }
    void set_type( const type2 &type ) {
        m_shape = type.shape;
        m_array_0.set_type(type.type0);
        m_array_1.set_type(type.type1);
    }
private:
    parallel_driver m_parallel{this};
    bitarray2 m_array_0;
    bitarray2 m_array_1;
    shape2 m_shape;
};
//
SHKZ_END_NAMESPACE
//
#endif