Matrix2D dot(Matrix2D a, Matrix2D b)
{
return Matrix2D((a.m[0][0] * b.m[0][0]) + (a.m[0][1] * b.m[1][0]),
(a.m[0][0] * b.m[0][1]) + (a.m[0][1] * b.m[1][1]),
(a.m[1][0] * b.m[0][0]) + (a.m[1][1] * b.m[1][0]),
(a.m[1][0] * b.m[0][1]) + (a.m[1][1] * b.m[1][1]));
}
Matrix2D Matrix2D::Invert()
{
//tmp[0] = m[4] * m[8] - m[5] * m[7];
//tmp[1] = m[1] * m[8] - m[2] * m[7];
//tmp[2] = m[1] * m[5] - m[2] * m[4];
//tmp[3] = m[3] * m[8] - m[5] * m[6];
//tmp[4] = m[0] * m[8] - m[2] * m[6];
//tmp[5] = m[0] * m[5] - m[2] * m[3];
//tmp[6] = m[3] * m[7] - m[4] * m[6];
//tmp[7] = m[0] * m[7] - m[1] * m[6];
//tmp[8] = m[0] * m[4] - m[1] * m[3];
//tmp[1] *= -1;
//tmp[3] *= -1;
//tmp[5] *= -1;
//tmp[7] *= -1;
float determinant, invDeterminant;
float tmp[9];
tmp[0] = m[4] * m[8] - m[5] * m[7];
tmp[1] = m[2] * m[7] - m[1] * m[8];
tmp[2] = m[1] * m[5] - m[2] * m[4];
tmp[3] = m[5] * m[6] - m[3] * m[8];
tmp[4] = m[0] * m[8] - m[2] * m[6];
tmp[5] = m[2] * m[3] - m[0] * m[5];
tmp[6] = m[3] * m[7] - m[4] * m[6];
tmp[7] = m[1] * m[6] - m[0] * m[7];
tmp[8] = m[0] * m[4] - m[1] * m[3];
// check determinant if it is 0
determinant = m[0] * tmp[0] + m[1] * tmp[3] + m[2] * tmp[6];
if (fabs(determinant) <= EPSILON)
return Identity(); // cannot inverse, make it idenety matrix
// divide by the determinant
invDeterminant = 1.0f / determinant;
Matrix2D matInverse = Matrix2D(invDeterminant * tmp[0],
invDeterminant * tmp[1],
invDeterminant * tmp[2],
invDeterminant * tmp[3],
invDeterminant * tmp[4],
invDeterminant * tmp[5],
invDeterminant * tmp[6],
invDeterminant * tmp[7],
invDeterminant * tmp[8]);
//m[0] = invDeterminant * tmp[0];
//m[1] = invDeterminant * tmp[1];
//m[2] = invDeterminant * tmp[2];
//m[3] = invDeterminant * tmp[3];
//m[4] = invDeterminant * tmp[4];
//m[5] = invDeterminant * tmp[5];
//m[6] = invDeterminant * tmp[6];
//m[7] = invDeterminant * tmp[7];
//m[8] = invDeterminant * tmp[8];
return matInverse;
}
Matrix2D operator*(const Matrix2D& m0, const Matrix2D& m1)
{
float m11 = m0.m11() * m1.m11() + m0.m12() * m1.m21();
float m12 = m0.m11() * m1.m12() + m0.m12() * m1.m22();
float m21 = m0.m21() * m1.m11() + m0.m22() * m1.m21();
float m22 = m0.m21() * m1.m12() + m0.m22() * m1.m22();
float tx = m0.m11() * m1.tx() + m0.m12() * m1.ty() + m0.tx();
float ty = m0.m21() * m1.tx() + m0.m22() * m1.ty() + m0.ty();
return Matrix2D(m11, m12, m21, m22, tx, ty);
}
Matrix2D Matrix2D::operator*(const Matrix2D& rhs) const
{
return Matrix2D(m[0] * rhs[0] + m[3] * rhs[1] + m[6] * rhs[2],
m[1] * rhs[0] + m[4] * rhs[1] + m[7] * rhs[2],
m[2] * rhs[0] + m[5] * rhs[1] + m[8] * rhs[2],
m[0] * rhs[3] + m[3] * rhs[4] + m[6] * rhs[5],
m[1] * rhs[3] + m[4] * rhs[4] + m[7] * rhs[5],
m[2] * rhs[3] + m[5] * rhs[4] + m[8] * rhs[5],
m[0] * rhs[6] + m[3] * rhs[7] + m[6] * rhs[8],
m[1] * rhs[6] + m[4] * rhs[7] + m[7] * rhs[8],
m[2] * rhs[6] + m[5] * rhs[7] + m[8] * rhs[8]);
}
HitOutline::HitOutline(ID2D1Geometry* geometryPtr, ID2D1GeometrySink* targetSink, int maxDegree, Scalar flatteningTolerance)
{
SimplifiedGeometrySink sink(targetSink, flatteningTolerance, m_Lines, m_Quads);
// TODO: Call Outline first?
geometryPtr->Simplify(
maxDegree >= 2
? D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES
: D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
Matrix2D(),
(float)flatteningTolerance,
&sink);
}
// @brief : 行列同士の乗算
//--------------------------------------------------------------------
Matrix2D Matrix2D::operator * ( const Matrix2D &_m ) const
{
return Matrix2D(
_11 * _m._11 + _12 * _m._21 + _13 * _m._31,
_11 * _m._12 + _12 * _m._22 + _13 * _m._32,
_11 * _m._13 + _12 * _m._23 + _13 * _m._33,
_21 * _m._11 + _22 * _m._21 + _23 * _m._31,
_21 * _m._12 + _22 * _m._22 + _23 * _m._32,
_21 * _m._13 + _22 * _m._23 + _23 * _m._33,
_31 * _m._11 + _32 * _m._21 + _33 * _m._31,
_31 * _m._12 + _32 * _m._22 + _33 * _m._32,
_31 * _m._13 + _32 * _m._23 + _33 * _m._33
);
}
@author : Ayumi Yasui
*-----------------------------------------------------------------------------*/
//--- インクルード ------------------------------------------------------------
#include <math.h>
#if _WIN32
#include <d3dx9math.h>
#endif
#include "matrix2d.h"
// 定数
//--------------------------------------------------------------------
const Matrix2D Matrix2D::ZERO = Matrix2D(0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f);
const Matrix2D Matrix2D::IDENTITY = Matrix2D(1.0f,0.0f,0.0f,0.0f,1.0f,0.0f,0.0f,0.0f,1.0f);
// @brief : コンストラクタ
// @param : 行列の値
//--------------------------------------------------------------------
Matrix2D::Matrix2D(
float _11, float _12, float _13,
float _21, float _22, float _23,
float _31, float _32, float _33 ) :
_11(_11),_12(_12),_13(_13),
_21(_21),_22(_22),_23(_23),
_31(_31),_32(_32),_33(_33)
{
}
Model::Model(size_t s, size_t a, double discount) : S(s), A(a), discount_(discount), transitions_(A, Matrix2D(S, S)), rewards_(A, Matrix2D(S, S)),
rand_(Impl::Seeder::getSeed())
{
// Make transition table true probability
for ( size_t a = 0; a < A; ++a ) {
transitions_[a].setIdentity();
rewards_[a].fill(0.0);
}
}
Matrix2D Matrix2D::CreateTranslationMatrix(const Vector2D& origin)
{
return Matrix2D(1.0f, 0.0f, (float)origin.x,
0.0f, 1.0f, (float)origin.y,
0.0f, 0.0f, 1.0f);
}
Matrix2D Matrix2D::CreateScalingMatrix(double scaleX, double scaleY)
{
return Matrix2D((float)scaleX, 0.0f, 0.0f,
0.0f, (float)scaleY, 0.0f,
0.0f, 0.0f, 1.0f);
}
Matrix2D Matrix2D::CreateRotationMatrix(double angle)
{
return Matrix2D((float)cos(angle), (float)-sin(angle), 0.0f,
(float)sin(angle), (float)cos(angle), 0.0f,
0.0f, 0.0f, 1.0f);
}
Matrix2D Matrix2D::CreateIdentityMatrix()
{
return Matrix2D();
}
Matrix2D Matrix2D::operator-(const Matrix2D& rhs) const
{
return Matrix2D(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2],
m[3] - rhs[3], m[4] - rhs[4], m[5] - rhs[5],
m[6] - rhs[6], m[7] - rhs[7], m[8] - rhs[8]);
}
Matrix2D Matrix2D::operator+(const Matrix2D& rhs) const
{
return Matrix2D(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2],
m[3] + rhs[3], m[4] + rhs[4], m[5] + rhs[5],
m[6] + rhs[6], m[7] + rhs[7], m[8] + rhs[8]);
}
/// vector-matrix product
inline Matrix2D operator * (const Matrix2D& a, const Matrix2D& m) {
return Matrix2D(a.mx * m, a.my * m);
}
void SymbolPart::updateBounds() {
calculateBounds(Vector2D(), Matrix2D(), true);
}
