multimatrixchain.h

/*
 * Ymir <imminfo.github.io/ymir>
 *
 * This file is part of Ymir, a fast C++ tool for computation of assembling
 * probabilities, statistical inference of assembling statistical model
 * and generation of artificial sequences of T-cell receptors data.
 *
 *
 * Copyright 2015 Vadim Nazarov <vdn at mailbox dot com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _MULTIMATRIXCHAIN_H_
#define _MULTIMATRIXCHAIN_H_


#include <vector>

#include "types.h"


#define YDEBUG


namespace ymir {

    template <typename _Scalar>
    class MultiMatrixChain;


    typedef MultiMatrixChain<event_ind_t> EventIndMMC;

    typedef unique_ptr<EventIndMMC> pEventIndMMC;


    typedef MultiMatrixChain<prob_t> ProbMMC;

    typedef unique_ptr<ProbMMC> pProbMMC;


    typedef seq_len_t error_num_t;
    typedef MultiMatrixChain<error_num_t> ErrMMC;

    typedef unique_ptr<ErrMMC> pErrMMC;


    template <typename _Scalar>
    class MultiMatrixChain {

        friend class MAAGForwardBackwardAlgorithm;  // ):

    public:

        typedef uint8_t node_ind_t;


        typedef uint8_t matrix_ind_t;


//        typedef size_t dim_t;
        typedef seq_len_t dim_t;


//        typedef Matrix<_Scalar, Dynamic, Dynamic> matrix_t;
        typedef Matrix<_Scalar, dim_t> matrix_t;

    protected:

        struct Node {
        public:

            Node() : _n(0), _start_index(0), _rows(0), _cols(0)
            { }


            void init(size_t start_index, matrix_ind_t n, dim_t rows, dim_t cols) {
                _n = n;
                _rows = rows;
                _cols = cols;
                _start_index = start_index;
            }


            size_t operator() (matrix_ind_t mat, dim_t row, dim_t column) const {
#ifndef DNDEBUG
                if (!(mat >= 0 && mat < _n)) { throw(std::runtime_error("Matrix index check failed!")); }

                if (!(row >= 0 && row < _rows && column >= 0 && column < _cols)) { throw(std::runtime_error("Rows / columns number check failed!")); }
#endif
                return _start_index + mat * (_rows * _cols) + row * _cols + column;
            }


            matrix_ind_t size() const { return _n; }

            dim_t rows() const { return _rows; }

            dim_t cols() const { return _cols; }

            size_t start() const { return _start_index; }

            size_t n_values() const { return _n * _rows * _cols; }


        protected:

            size_t _start_index;
            matrix_ind_t _n;
            dim_t _rows, _cols;

        };

    public:

        MultiMatrixChain() {
            _values.reserve(5000);
        }


//        MultiMatrixChain(MultiMatrixChain &) = default;
//
//
//        MultiMatrixChain(MultiMatrixChain &&) = default;
//
//
//        MultiMatrixChain& operator=(MultiMatrixChain &) = default;
//
//
//        MultiMatrixChain& operator=(MultiMatrixChain &&) = default;


        virtual ~MultiMatrixChain()
        {
        }


        void resize(node_ind_t n_nodes) {
            _chain.resize(n_nodes);
        }


        node_ind_t chainSize() const { return _chain.size(); }


        matrix_ind_t nodeSize(node_ind_t node_i) const { return _chain[node_i].size(); }

        dim_t nodeRows(node_ind_t node_i) const { return _chain[node_i].rows(); }

        dim_t nodeColumns(node_ind_t node_i) const { return _chain[node_i].cols(); }


        _Scalar& operator()(node_ind_t node_i, matrix_ind_t mat_i, dim_t row, dim_t col) {
#ifndef DNDEBUG
            if (node_i >= _chain.size()) { throw(std::runtime_error("Number of the Node is out of bounds."));}
#endif
            return _values[_chain[node_i](mat_i, row, col)];
        }

//        const _Scalar& operator()(node_ind_t node_i, matrix_ind_t mat_i, dim_t row, dim_t col) const {
        _Scalar operator()(node_ind_t node_i, matrix_ind_t mat_i, dim_t row, dim_t col) const {
#ifndef DNDEBUG
            if (node_i >= _chain.size()) { throw (std::runtime_error("Number of the Node is out of bounds.")); }
#endif
            return _values[_chain[node_i](mat_i, row, col)];
        }

        _Scalar& at(node_ind_t node_i, matrix_ind_t mat_i, dim_t row, dim_t col) {
#ifndef DNDEBUG
            if (node_i >= _chain.size()) { throw(std::runtime_error("Number of the Node is out of bounds."));}
#endif
            return _values[_chain[node_i](mat_i, row, col)];
        }

//        const _Scalar& operator()(node_ind_t node_i, matrix_ind_t mat_i, dim_t row, dim_t col) const {
        _Scalar at(node_ind_t node_i, matrix_ind_t mat_i, dim_t row, dim_t col) const {
#ifndef DNDEBUG
            if (node_i >= _chain.size()) { throw(std::runtime_error("Number of the Node is out of bounds."));}
#endif
            return _values[_chain[node_i](mat_i, row, col)];
        }


        node_ind_t addNode() {
            _chain.push_back(Node());
            return _chain.size() - 1;
        }

        node_ind_t addNode(matrix_ind_t n_matrices, dim_t rows, dim_t cols) {
            _chain.push_back(Node());
            this->initNode(_chain.size() - 1, n_matrices, rows, cols);
            return _chain.size() - 1;
        }


        void initNode(node_ind_t node_i, matrix_ind_t n_matrices, dim_t rows, dim_t cols) {
            size_t prev_node_size = _chain[node_i].n_values();
            _chain[node_i].init(_values.size(), n_matrices, rows, cols);
            _values.resize(_values.size() + _chain[node_i].n_values() - prev_node_size, 0);
        }


        void swap(MultiMatrixChain &other) {
            _chain.swap(other._chain);
            _values.swap(other._values);
        }


        void finish() {
            _chain.shrink_to_fit();
            _values.shrink_to_fit();
//            cout << _values.size() << endl;
//            cout << _values.capacity() << endl;
        }


        void fill(node_ind_t node, matrix_ind_t mat, _Scalar val = 0) {
            for (dim_t r = 0; r < _chain[node].rows(); ++r) {
                for (dim_t c = 0; c < _chain[node].cols(); ++c) {
                    _values[_chain[node](mat, r, c)] = val;
                }
            }
        }


        matrix_t matrix(node_ind_t node, matrix_ind_t mat) const {
            matrix_t res(_chain[node].rows(), _chain[node].cols(), 0);
            for (dim_t r = 0; r < _chain[node].rows(); ++r) {
                for (dim_t c = 0; c < _chain[node].cols(); ++c) {
                    res(r, c) = (*this)(node, mat, r, c);
                }
            }
            return res;
        }


        _Scalar operator[](size_t index) const { return _values[index]; }


        size_t values_size() const { return _values.size(); }
        

    protected:

        std::vector<Node> _chain;
        std::vector<_Scalar> _values;

    };

}

#endif