//
-// Open Service Platform
// Copyright (c) 2012 Samsung Electronics Co., Ltd.
//
// Licensed under the Apache License, Version 2.0 (the License);
* @file FBaseFloatMatrix.cpp
* @brief This is the implementation for FloatMatrix class.
*/
-
#include <FBaseFloatMatrix.h>
#include <FBaseSysLog.h>
#include <unique_ptr.h>
FloatMatrix::~FloatMatrix(void)
{
- for ( int i = 0 ; i < __row ; i++ )
+ for (int i = 0; i < __row; i++)
{
delete[] __pMatrix[i];
}
bool
FloatMatrix::Equals(const Tizen::Base::Object& obj) const
{
- const FloatMatrix* pOther = dynamic_cast <const FloatMatrix*>(&obj);
+ const FloatMatrix* pOther = dynamic_cast< const FloatMatrix* >(&obj);
if (pOther == null)
{
bool
FloatMatrix::AllocateCapacity(int rowCount, int columnCount)
{
- std::unique_ptr<float* []> pMatrix(new (std::nothrow) float* [rowCount]);
+ std::unique_ptr< float*[] > pMatrix(new (std::nothrow) float*[rowCount]);
SysTryReturn(NID_BASE, pMatrix != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
- for ( int i = 0 ; i < rowCount ; i++ )
+ for (int i = 0; i < rowCount; i++)
{
pMatrix[i] = new (std::nothrow) float[columnCount];
if (pMatrix[i] == null)
{
- for (int j = 0; j < i; j++)
+ for (int j = 0; j < i; j++)
{
delete[] pMatrix[j];
}
- return false;
+ return false;
}
}
}
float determinant = 0.0f;
- std::unique_ptr<float* []> pMinor(new (std::nothrow) float* [order - 1]);
+ std::unique_ptr< float*[] > pMinor(new (std::nothrow) float*[order - 1]);
SysTryReturn(NID_BASE, pMinor != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
for (int i = 0; i < order - 1; i++)
pMinor[i] = new (std::nothrow) float[order - 1];
if (pMinor[i] == null)
{
- for (int j = 0; j < i; j++)
+ for (int j = 0; j < i; j++)
{
delete[] pMinor[j];
}
- return determinant;
+ return determinant;
}
}
for (int i = 0; i < order; i++)
{
GetMinor(pMatrix, pMinor.get(), 0, i, order);
-
+
if (signFlag == true)
{
determinant += pMatrix[0][i] * CalculateDeterminant(pMinor.get(), order - 1);
else
{
determinant += -pMatrix[0][i] * CalculateDeterminant(pMinor.get(), order - 1);
- signFlag = true;
+ signFlag = true;
}
}
"[%s] Invalid argument is used. The columnIndex is larger than the column count of the current instance.",
GetErrorMessage(E_INVALID_ARG));
- std::unique_ptr<float []> pColumn(new (std::nothrow) float [__row]);
+ std::unique_ptr< float[] > pColumn(new (std::nothrow) float[__row]);
SysTryReturn(NID_BASE, pColumn != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
SysTryReturn(NID_BASE, __row == __column, null, E_INVALID_OPERATION,
"[%s] The current instance is not a square matrix.", GetErrorMessage(E_INVALID_OPERATION));
- std::unique_ptr<FloatMatrix> pInverseMatrix(new (std::nothrow) FloatMatrix(__row, __column));
+ std::unique_ptr< FloatMatrix > pInverseMatrix(new (std::nothrow) FloatMatrix(__row, __column));
SysTryReturn(NID_BASE, pInverseMatrix != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
float determinant = CalculateDeterminant(__pMatrix, __row);
- if (Tizen::Base::Float::Compare(determinant,0.0f) == 0)
+ if (Tizen::Base::Float::Compare(determinant, 0.0f) == 0)
{
return null;
}
- std::unique_ptr<float* []> pMinor(new (std::nothrow) float* [__row - 1]);
+ std::unique_ptr< float*[] > pMinor(new (std::nothrow) float*[__row - 1]);
SysTryReturn(NID_BASE, pMinor != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
- for (int i = 0; i < __row -1; i++)
+ for (int i = 0; i < __row - 1; i++)
{
pMinor[i] = new (std::nothrow) float[__row - 1];
if (pMinor[i] == null)
{
- for (int j = 0; j < i; j++)
+ for (int j = 0; j < i; j++)
{
delete[] pMinor[j];
- }
+ }
return null;
}
{
pInverseMatrix->__pMatrix[j][i] = -pInverseMatrix->__pMatrix[j][i];
}
- }
+ }
}
- for ( int i = 0 ; i < __row -1 ; i++ )
+ for (int i = 0; i < __row - 1; i++)
{
delete[] pMinor[i];
}
if (i != rowIndex)
{
columnCount = 0;
-
+
for (int j = 0; j < order; j++)
{
if (j != columnIndex)
"[%s] Invalid argument is used. The rowIndex is larger than the row count of the current instance.",
GetErrorMessage(E_INVALID_ARG));
- std::unique_ptr<float []> pRow(new (std::nothrow) float [__column]);
+ std::unique_ptr< float[] > pRow(new (std::nothrow) float[__column]);
SysTryReturn(NID_BASE, pRow != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
SysTryReturn(NID_BASE, __row == __column, null, E_INVALID_OPERATION,
"[%s] The current instance is not a square matrix.", GetErrorMessage(E_INVALID_OPERATION));
- std::unique_ptr<FloatMatrix> pTransposeMatrix(new (std::nothrow) FloatMatrix(*this));
+ std::unique_ptr< FloatMatrix > pTransposeMatrix(new (std::nothrow) FloatMatrix(*this));
SysTryReturn(NID_BASE, pTransposeMatrix != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
{
if (i == j)
{
- if (Tizen::Base::Float::Compare(__pMatrix[i][j],1.0f) != 0)
+ if (Tizen::Base::Float::Compare(__pMatrix[i][j], 1.0f) != 0)
{
return false;
}
}
else
{
- if (Tizen::Base::Float::Compare(__pMatrix[i][j],0.0f) != 0)
+ if (Tizen::Base::Float::Compare(__pMatrix[i][j], 0.0f) != 0)
{
return false;
}
}
-
+
}
}
return true;
bool
FloatMatrix::IsInvertible(void) const
{
- int ret = Tizen::Base::Float::Compare(GetDeterminant(),0.0f);
+ int ret = Tizen::Base::Float::Compare(GetDeterminant(), 0.0f);
if (ret == 0)
{
SysTryReturnResult(NID_BASE, __column == matrix.__row, E_INVALID_ARG,
"The column count of the current instance is not same with the row count of the specified instance.");
- std::unique_ptr<float* []> pResult(new (std::nothrow) float* [__row]);
+ std::unique_ptr< float*[] > pResult(new (std::nothrow) float*[__row]);
SysTryReturnResult(NID_BASE, pResult != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
- for ( int i = 0 ; i < __row ; i++ )
+ for (int i = 0; i < __row; i++)
{
pResult[i] = new (std::nothrow) float[matrix.__column];
if (pResult[i] == null)
{
- for (int j = 0; j < i; j++)
+ for (int j = 0; j < i; j++)
{
delete[] pResult[j];
}
}
}
- for ( int i = 0 ; i < __row ; i++ )
+ for (int i = 0; i < __row; i++)
{
delete[] __pMatrix[i];
}
{
SysTryReturnResult(NID_BASE, __row == __column, E_INVALID_OPERATION, "The current instance is not a square matrix.");
- for (int i = 0; i < __row; i ++)
+ for (int i = 0; i < __row; i++)
{
for (int j = 0; j < __column; j++)
{
else
{
__pMatrix[i][j] = 0.0f;
- }
+ }
}
}
SysTryReturnResult(NID_BASE, Tizen::Base::Float::Compare(determinant, 0.0f) != 0, E_INVALID_OPERATION,
"The current instance is not invertible.");
- std::unique_ptr<float* []> pInverse(new (std::nothrow) float* [__row]);
+ std::unique_ptr< float*[] > pInverse(new (std::nothrow) float*[__row]);
SysTryReturn(NID_BASE, pInverse != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
GetErrorMessage(E_OUT_OF_MEMORY));
pInverse[i] = new (std::nothrow) float[__row];
if (pInverse[i] == null)
{
- for (int j = 0; j < i; j++)
+ for (int j = 0; j < i; j++)
{
delete[] pInverse[j];
- }
+ }
return E_OUT_OF_MEMORY;
}
}
- std::unique_ptr<float* []> pMinor(new (std::nothrow) float* [__row - 1]);
+ std::unique_ptr< float*[] > pMinor(new (std::nothrow) float*[__row - 1]);
if (pMinor == null)
{
- for ( int i = 0 ; i < __row ; i++ )
+ for (int i = 0; i < __row; i++)
{
delete[] pInverse[i];
}
pMinor[i] = new (std::nothrow) float[__row - 1];
if (pMinor[i] == null)
{
- for (int i = 0 ; i < __row ; i++)
+ for (int k = 0; k < __row; k++)
{
- delete[] pInverse[i];
+ delete[] pInverse[k];
}
- for (int j = 0; j < i; j++)
+ for (int j = 0; j < i; j++)
{
delete[] pMinor[j];
}
{
GetMinor(__pMatrix, pMinor.get(), i, j, __row);
pInverse[j][i] = CalculateDeterminant(pMinor.get(), __row - 1) / determinant;
- if ((i +j +2) % 2 == 1)
+ if ((i + j + 2) % 2 == 1)
{
pInverse[j][i] = -pInverse[j][i];
}
- }
+ }
}
- for ( int i = 0 ; i < __row ; i++ )
+ for (int i = 0; i < __row; i++)
{
delete[] __pMatrix[i];
}
__pMatrix = pInverse.release();
- for ( int i = 0 ; i < __row -1; i++ )
+ for (int i = 0; i < __row - 1; i++)
{
delete[] pMinor[i];
}
for (int i = 0; i < __row; i++)
{
- __pMatrix[i][columnIndex] = pArray[i];
+ __pMatrix[i][columnIndex] = pArray[i];
}
return E_SUCCESS;
for (int i = 0; i < __column; i++)
{
- __pMatrix[rowIndex][i] = pArray[i];
+ __pMatrix[rowIndex][i] = pArray[i];
}
return E_SUCCESS;
{
for (int j = 0; j < __column; j++)
{
- __pMatrix[i][j] = 0.0f;
+ __pMatrix[i][j] = 0.0f;
}
}
}