matrix_shape.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* 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 MIO_MATH_MATRIX_SHAPE_H
#define MIO_MATH_MATRIX_SHAPE_H
 
#include "memilio/math/eigen.h" // IWYU pragma: keep
#include "memilio/io/io.h"
 
namespace mio
{
template <typename FP>
class RectMatrixShape
{
public:
    using Matrix = Eigen::MatrixX<FP>;
    RectMatrixShape(Eigen::Index r, Eigen::Index c)
        : m_rows(r)
        , m_cols(c)
    {
    }
 
    template <class ME>
    static RectMatrixShape get_shape_of(const Eigen::MatrixBase<ME>& m)
    {
        return {m.rows(), m.cols()};
    }
 
    Eigen::Index rows() const
    {
        return m_rows;
    }
    Eigen::Index cols() const
    {
        return m_cols;
    }
 
    bool operator==(const RectMatrixShape& other) const
    {
        return other.m_rows == m_rows && other.m_cols == m_cols;
    }
    bool operator!=(const RectMatrixShape& other) const
    {
        return !(*this == other);
    }
 
    template <class IOContext>
    void serialize(IOContext& io) const
    {
        auto obj = io.create_object("RectMatrixShape");
        obj.add_element("Rows", rows());
        obj.add_element("Columns", cols());
    }
 
    template <class IOContext>
    static IOResult<RectMatrixShape> deserialize(IOContext& io)
    {
        auto obj = io.expect_object("RectMatrixShape");
        auto r   = obj.expect_element("Rows", Tag<Eigen::Index>{});
        auto c   = obj.expect_element("Columns", Tag<Eigen::Index>{});
        return apply(
            io,
            [](auto&& r_, auto&& c_) -> IOResult<RectMatrixShape> {
                if (r_ > 0 && c_ > 0)
                    return success(RectMatrixShape{r_, c_});
                else
                    return failure(StatusCode::OutOfRange, "Rows and Columns of RectMatrixShape must be positive.");
            },
            r, c);
    }
 
private:
    Eigen::Index m_rows;
    Eigen::Index m_cols;
};
 
template <typename FP>
class SquareMatrixShape
{
public:
    using Matrix = Eigen::MatrixX<FP>;
    explicit SquareMatrixShape(Eigen::Index r)
        : m_rows(r)
    {
    }
 
    template <class ME>
    static SquareMatrixShape get_shape_of(const Eigen::MatrixBase<ME>& m)
    {
        assert(m.rows() == m.cols());
        return SquareMatrixShape{m.rows()};
    }
 
    Eigen::Index rows() const
    {
        return m_rows;
    }
    Eigen::Index cols() const
    {
        return m_rows;
    }
    Eigen::Index size() const
    {
        return m_rows;
    }
 
    bool operator==(const SquareMatrixShape& other) const
    {
        return other.m_rows == m_rows;
    }
    bool operator!=(const SquareMatrixShape& other) const
    {
        return !(*this == other);
    }
 
    template <class IOContext>
    void serialize(IOContext& io) const
    {
        auto obj = io.create_object("SquareMatrixShape");
        obj.add_element("Rows", rows());
    }
 
    template <class IOContext>
    static IOResult<SquareMatrixShape> deserialize(IOContext& io)
    {
        auto obj = io.expect_object("SquareMatrixShape");
        auto r   = obj.expect_element("Rows", Tag<Eigen::Index>{});
        return apply(
            io,
            [](auto&& r_) -> IOResult<SquareMatrixShape> {
                if (r_ > 0)
                    return success(SquareMatrixShape{r_});
                else
                    return failure(StatusCode::OutOfRange, "Rows of SquareMatrixShape must be positive.");
            },
            r);
    }
 
private:
    Eigen::Index m_rows;
};
 
template <typename FP>
class ColumnVectorShape
{
 
public:
    using Matrix = Eigen::VectorX<FP>;
    explicit ColumnVectorShape(Eigen::Index r)
        : m_rows(r)
    {
    }
 
    template <class ME>
    static ColumnVectorShape get_shape_of(const Eigen::MatrixBase<ME>& m)
    {
        assert(m.cols() == 1);
        return ColumnVectorShape{m.rows()};
    }
 
    Eigen::Index rows() const
    {
        return m_rows;
    }
    Eigen::Index cols() const
    {
        return 1;
    }
    Eigen::Index size() const
    {
        return m_rows;
    }
 
    bool operator==(const ColumnVectorShape& other) const
    {
        return other.m_rows == m_rows;
    }
    bool operator!=(const ColumnVectorShape& other) const
    {
        return !(*this == other);
    }
 
    template <class IOContext>
    void serialize(IOContext& io) const
    {
        auto obj = io.create_object("ColumnVectorShape");
        obj.add_element("Rows", rows());
    }
 
    template <class IOContext>
    static IOResult<ColumnVectorShape> deserialize(IOContext& io)
    {
        auto obj = io.expect_object("ColumnVectorShape");
        auto r   = obj.expect_element("Rows", Tag<Eigen::Index>{});
        return apply(
            io,
            [](auto&& r_) -> IOResult<ColumnVectorShape> {
                if (r_ > 0)
                    return success(ColumnVectorShape{r_});
                else
                    return failure(StatusCode::OutOfRange, "Rows of ColumnVectorShape must be positive");
            },
            r);
    }
 
private:
    Eigen::Index m_rows;
};
 
} // namespace mio
 
#endif // MIO_MATH_MATRIX_SHAPE_H