Mat2d.h

Go to the documentation of this file.

//
// Copyright(C) 2013-2016  OpenCascade [www.opencascade.org]
//
// This library is free software; you can redistribute it and / or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street,
// Fifth Floor, Boston, MA  02110 - 1301  USA
//

#pragma once


namespace Geom
{
class GTrsf2d;
class Trsf2d;
class XY;

class LX_GEOM_EXPORT Mat2d
{
public:
    Mat2d();

    Mat2d(const XY& Col1, const XY& Col2);
    void add(const Mat2d& Other);
    Mat2d added(const Mat2d& Other) const;
    double& changeValue(const int Row, const int Col);
    XY column(const int Col) const;
    double determinant() const;
    XY diagonal() const;
    void divide(const double Scalar);
    Mat2d divided(const double Scalar) const;
    void invert();

    Mat2d inverted() const;

    static inline bool isEven(const int Value) { return Value % 2 == 0; }

    static inline bool isOdd(const int Value) { return Value % 2 != 0; }
    bool isSingular() const;

    Mat2d multiplied(const Mat2d& Other) const;
    void multiply(const Mat2d& Other);
    Mat2d multiplied(const double Scalar) const;
    void multiply(const double Scalar);
    void operator+=(const Mat2d& Other) { add(Other); }

    Mat2d operator+(const Mat2d& Other) const { return added(Other); }

    void operator-=(const Mat2d& Other) { subtract(Other); }

    Mat2d operator-(const Mat2d& Other) const { return subtracted(Other); }

    void operator*=(const double Scalar) { multiply(Scalar); }

    Mat2d operator*(const double Scalar) const { return multiplied(Scalar); }

    Mat2d operator*(const Mat2d& Other) const { return multiplied(Other); }

    void operator/=(const double Scalar) { divide(Scalar); }

    Mat2d operator/(const double Scalar) const { return divided(Scalar); }

    const double& operator()(const int Row, const int Col) const { return value(Row, Col); }
    double& operator()(const int Row, const int Col) { return changeValue(Row, Col); }

    void power(const int N);

    Mat2d powered(const int N) const;

    void preMultiply(const Mat2d& Other);

    XY row(const int Row) const;
    void setCol(const int Col, const XY& Value);
    void setCols(const XY& Col1, const XY& Col2);

    void setDiagonal(const double X1, const double X2);
    void setIdentity();

    void setRotation(const double Ang);
    void setRow(const int Row, const XY& Value);
    void setRows(const XY& Row1, const XY& Row2);

    void setScale(const double S);
    void setValue(const int Row, const int Col, const double Value);
    void subtract(const Mat2d& Other);
    Mat2d subtracted(const Mat2d& Other) const;
    void transpose();

    Mat2d transposed() const;

    const double& value(const int Row, const int Col) const;
    friend class GTrsf2d;
    friend class Trsf2d;
    friend class XY;

protected:
private:
    double _matrix[2][2];
};
}  // namespace Geom