atria-soft/etk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] update Basic element capabilities

Browse Source
This commit is contained in:
Edouard DUPIN 2012-12-12 21:56:05 +01:00
parent 033c9dd63a
commit 74a6e35fa3
2 changed files with 223 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
etk/Vector.h
View File

@ -184,9 +184,9 @@ namespace etk
* @return --- * @return ---
* *
*/ */
Iterator(Vector<MY_TYPE> * Evb, int32_t pos): Iterator(Vector<MY_TYPE> * obj, int32_t pos):
m_current(pos), m_current(pos),
m_vector(Evb) m_vector(obj)
{ {
// nothing to do ... // nothing to do ...
} }
@ -209,15 +209,14 @@ namespace etk
{ {
ChangeAllocation(count); ChangeAllocation(count);
} }
/** /**
* @brief Re-copy constructor (copy all needed data) * @brief Re-copy constructor (copy all needed data)
* @param[in] Evb Vector that might be copy * @param[in] Evb Vector that might be copy
*/ */
Vector(const etk::Vector<MY_TYPE> & Evb) Vector(const etk::Vector<MY_TYPE> & obj)
{ {
m_allocated = Evb.m_allocated; m_allocated = obj.m_allocated;
m_size = Evb.m_size; m_size = obj.m_size;
m_data = NULL; m_data = NULL;
//TK_DEBUG("USE Specific vector allocator ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment); //TK_DEBUG("USE Specific vector allocator ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment);
// allocate all same data // allocate all same data
@ -229,10 +228,9 @@ namespace etk
// Copy all data ... // Copy all data ...
for(int32_t iii=0; iii<m_allocated; iii++) { for(int32_t iii=0; iii<m_allocated; iii++) {
// copy operator ... // copy operator ...
m_data[iii] = Evb.m_data[iii]; m_data[iii] = obj.m_data[iii];
} }
} }
/** /**
* @brief Destructor of the current Class * @brief Destructor of the current Class
*/ */
@ -245,24 +243,43 @@ namespace etk
m_allocated = 0; m_allocated = 0;
m_size = 0; m_size = 0;
} }
/**
* @brief Swap the data of 2 Vectors
* @param[in] obj second vector to swap data.
*/
void Swap(etk::Vector<MY_TYPE>& obj)
{
// avoid Swap of itself
if(this != &obj) {
MY_TYPE* tmpData = m_data;
int32_t tmpAllocated = m_allocated;
int32_t tmpSize = m_size;
m_data = obj.m_data;
m_allocated = obj.m_allocated;
m_size = obj.m_size;
obj.m_data = tmpData;
obj.m_allocated = tmpAllocated;
obj.m_size = tmpSize;
}
}
/** /**
* @brief Re-copy operator * @brief Re-copy operator
* @param[in] Evb Vector that might be copy * @param[in] Evb Vector that might be copy
* @return reference on the curent re-copy vector * @return reference on the curent re-copy vector
*/ */
Vector& operator=(const etk::Vector<MY_TYPE> & Evb) Vector& operator=(const etk::Vector<MY_TYPE> & obj)
{ {
//TK_DEBUG("USE RECOPY vector ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment); //TK_DEBUG("USE RECOPY vector ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment);
if( this != &Evb ) // avoid copy to itself if( this != &obj ) // avoid copy to itself
{ {
if (NULL!=m_data) { if (NULL!=m_data) {
delete[] m_data; delete[] m_data;
m_data = NULL; m_data = NULL;
} }
// Set the new value // Set the new value
m_allocated = Evb.m_allocated; m_allocated = obj.m_allocated;
m_size = Evb.m_size; m_size = obj.m_size;
// allocate all same data // allocate all same data
m_data = new MY_TYPE[m_allocated]; m_data = new MY_TYPE[m_allocated];
if (NULL==m_data) { if (NULL==m_data) {
@ -271,7 +288,7 @@ namespace etk
} }
for(int32_t iii=0; iii<m_allocated; iii++) { for(int32_t iii=0; iii<m_allocated; iii++) {
// copy operator ... // copy operator ...
m_data[iii] = Evb.m_data[iii]; m_data[iii] = obj.m_data[iii];
} }
} }
// Return the curent pointer // Return the curent pointer
@ -282,9 +299,9 @@ namespace etk
* @brief Add at the Last position of the Vector * @brief Add at the Last position of the Vector
* @param[in] item Element to add at the end of vector * @param[in] item Element to add at the end of vector
*/ */
Vector& operator+= (const etk::Vector<MY_TYPE> & Evb) // += operator Vector& operator+= (const etk::Vector<MY_TYPE> & obj) // += operator
{ {
int32_t nbElememt = Evb.Size(); int32_t nbElememt = obj.Size();
int32_t idx = m_size; int32_t idx = m_size;
Resize(m_size+nbElememt); Resize(m_size+nbElememt);
if (m_size<=idx) { if (m_size<=idx) {
@ -293,13 +310,11 @@ namespace etk
} }
for(int32_t iii=0; iii<nbElememt; iii++) { for(int32_t iii=0; iii<nbElememt; iii++) {
// copy operator ... // copy operator ...
m_data[idx+iii] = Evb.m_data[iii]; m_data[idx+iii] = obj.m_data[iii];
} }
// Return the curent pointer // Return the curent pointer
return *this; return *this;
} }
/** /**
* @brief Get the number of element in the vector * @brief Get the number of element in the vector
* @return The number requested * @return The number requested
@ -308,7 +323,6 @@ namespace etk
{ {
return m_size; return m_size;
} }
/** /**
* @brief Get the number of element in the vector * @brief Get the number of element in the vector
* @return The number requested * @return The number requested
@ -328,7 +342,6 @@ namespace etk
} }
} }
} }
/** /**
* @brief Get the Allocated size in the vector * @brief Get the Allocated size in the vector
* @return The size of allocation * @return The size of allocation
@ -337,7 +350,6 @@ namespace etk
{ {
return m_allocated; return m_allocated;
} }
/** /**
* @brief Get a current element in the vector * @brief Get a current element in the vector
* @param[in] pos Desired position read * @param[in] pos Desired position read
@ -354,7 +366,6 @@ namespace etk
#endif #endif
return m_data[pos]; return m_data[pos];
} }
/** /**
* @brief Get an copy Element an a special position * @brief Get an copy Element an a special position
* @param[in] pos Position in the vector that might be get [0..Size()] * @param[in] pos Position in the vector that might be get [0..Size()]
@ -364,7 +375,6 @@ namespace etk
{ {
return Get(pos); return Get(pos);
} }
/** /**
* @brief Get an Element an a special position * @brief Get an Element an a special position
* @param[in] pos Position in the vector that might be get [0..Size()] * @param[in] pos Position in the vector that might be get [0..Size()]
@ -381,7 +391,6 @@ namespace etk
#endif #endif
return m_data[pos]; return m_data[pos];
} }
/** /**
* @brief Add at the Last position of the Vector * @brief Add at the Last position of the Vector
* @param[in] item Element to add at the end of vector * @param[in] item Element to add at the end of vector
@ -396,7 +405,6 @@ namespace etk
TK_ERROR("Resize does not work corectly ... not added item"); TK_ERROR("Resize does not work corectly ... not added item");
} }
} }
/** /**
* @brief Add at the Last position of the Vector * @brief Add at the Last position of the Vector
* @param[in] item Element to add at the end of vector * @param[in] item Element to add at the end of vector
@ -416,7 +424,6 @@ namespace etk
m_data[idx+iii] = item[iii]; m_data[idx+iii] = item[iii];
} }
} }
/** /**
* @brief Remove the last element of the vector * @brief Remove the last element of the vector
*/ */
@ -426,7 +433,6 @@ namespace etk
Resize(m_size-1); Resize(m_size-1);
} }
} }
/** /**
* @brief Remove all alement in the current vector * @brief Remove all alement in the current vector
*/ */
@ -436,15 +442,11 @@ namespace etk
Resize(0); Resize(0);
} }
} }
/** /**
* @brief * @brief Insert N element in the Vector.
* * @param[in] pos Position to add the elements.
* @param[in,out] --- * @param[in] item Pointer on a table of the elements to add.
* * @param[in] nbElement Number of element to add in the Vector
* @return ---
*
*/ */
void Insert(int32_t pos, const MY_TYPE * item, int32_t nbElement) void Insert(int32_t pos, const MY_TYPE * item, int32_t nbElement)
{ {
@ -472,28 +474,19 @@ namespace etk
m_data[pos+iii] = item[iii]; m_data[pos+iii] = item[iii];
} }
} }
/** /**
* @brief * @brief Insert one element in the Vector at a specific position
* * @param[in] pos Position to add the elements.
* @param[in,out] --- * @param[in] item Element to add.
*
* @return ---
*
*/ */
void Insert(int32_t pos, const MY_TYPE& item) void Insert(int32_t pos, const MY_TYPE& item)
{ {
Insert(pos, &item, 1); Insert(pos, &item, 1);
} }
/** /**
* @brief Remove N element * @brief Remove N element
*
* @param[in] pos Position to remove the data * @param[in] pos Position to remove the data
* @param[in] nbElement number of element to remove * @param[in] nbElement number of element to remove
*
* @return ---
*
*/ */
void EraseLen(int32_t pos, int32_t nbElement) void EraseLen(int32_t pos, int32_t nbElement)
{ {
@ -515,28 +508,26 @@ namespace etk
// Request resize of the current buffer // Request resize of the current buffer
Resize(m_size-nbElement); Resize(m_size-nbElement);
} }
/** /**
* @brief Remove one element * @brief Remove one element
*
* @param[in] pos Position to remove the data * @param[in] pos Position to remove the data
*
* @return ---
*
*/ */
void Erase(int32_t pos) inline void Erase(int32_t pos)
{
EraseLen(pos, 1);
}
/**
* @brief Remove one element
* @param[in] pos Position to remove the data
*/
inline void Remove(int32_t pos)
{ {
EraseLen(pos, 1); EraseLen(pos, 1);
} }
/** /**
* @brief Remove N elements * @brief Remove N elements
*
* @param[in] pos Position to remove the data * @param[in] pos Position to remove the data
* @param[in] posEnd Last position number * @param[in] posEnd Last position number
*
* @return ---
*
*/ */
void Erase(int32_t pos, int32_t posEnd) void Erase(int32_t pos, int32_t posEnd)
{ {
@ -559,8 +550,6 @@ namespace etk
// Request resize of the current buffer // Request resize of the current buffer
Resize(m_size-nbElement); Resize(m_size-nbElement);
} }
/** /**
* @brief extract data between two point : * @brief extract data between two point :
* @param[in] posStart start position to extract data * @param[in] posStart start position to extract data
@ -583,7 +572,14 @@ namespace etk
out.PushBack(&m_data[posStart], posEnd-posStart); out.PushBack(&m_data[posStart], posEnd-posStart);
return out; return out;
} }
/**
* @brief Get the pointer on the sata
* @return the type pointer on data
*/
MY_TYPE* DataPointer(void)
{
return &m_data[0];
}
/** /**
* @brief Get an iterator an an specific position * @brief Get an iterator an an specific position
* @param[in] pos Requested position of the iterator in the vector * @param[in] pos Requested position of the iterator in the vector
@ -593,7 +589,6 @@ namespace etk
{ {
return Iterator(this, pos); return Iterator(this, pos);
} }
/** /**
* @brief Get an Iterator on the start position of the Vector * @brief Get an Iterator on the start position of the Vector
* @return The Iterator * @return The Iterator
@ -602,7 +597,6 @@ namespace etk
{ {
return Position(0); return Position(0);
} }
/** /**
* @brief Get an Iterator on the end position of the Vector * @brief Get an Iterator on the end position of the Vector
* @return The Iterator * @return The Iterator
@ -611,7 +605,6 @@ namespace etk
{ {
return Position( Size()-1 ); return Position( Size()-1 );
} }
private: private:
/** /**
* @brief Change the current size of the vector * @brief Change the current size of the vector
@ -625,7 +618,6 @@ namespace etk
} }
m_size = newSize; m_size = newSize;
} }
/** /**
* @brief Change the current allocation to the corect one (depend on the current size) * @brief Change the current allocation to the corect one (depend on the current size)
* @param[in] newSize Minimum number of element needed * @param[in] newSize Minimum number of element needed

208
etk/math/Matrix.h
View File

@ -252,6 +252,15 @@ namespace etk
T& operator () (int32_t line, int32_t colomn) { T& operator () (int32_t line, int32_t colomn) {
return m_data[line*m_size.x + colomn]; return m_data[line*m_size.x + colomn];
} }
/*****************************************************
* - operator
*****************************************************/
Matrix<T> operator - (void) {
Matrix<T> tmp(m_size);
for (int32_t iii=0; iii<m_data.Size(); iii++) {
tmp.m_data[iii] = -m_data[iii];
return tmp;
}
/***************************************************** /*****************************************************
* Other mathematical function * Other mathematical function
*****************************************************/ *****************************************************/
@ -265,7 +274,7 @@ namespace etk
Matrix<T> tmpMatrix(m_size.x, m_size.y); Matrix<T> tmpMatrix(m_size.x, m_size.y);
for (int32_t jjj=0; jjj< m_size.y; jjj++) { for (int32_t jjj=0; jjj< m_size.y; jjj++) {
for (int32_t iii=0; iii< m_size.x; iii++) { for (int32_t iii=0; iii< m_size.x; iii++) {
tmpMatrix[jjj][iii] = (*this)[iii][jjj]; tmpMatrix(jjj,iii) = (*this)(iii,jjj);
} }
} }
return tmpMatrix; return tmpMatrix;
@ -275,7 +284,7 @@ namespace etk
* @ param[in] obj The convolution operator * @ param[in] obj The convolution operator
* @ return the value of the convolution * @ return the value of the convolution
*/ */
Matrix<T> Convolution(Matrix<T>& obj) Matrix<T>& Convolution(Matrix<T>& obj)
{ {
Matrix<T> tmppp(1,1); Matrix<T> tmppp(1,1);
// TODO : ... // TODO : ...
@ -288,8 +297,18 @@ namespace etk
*/ */
Matrix<T>& Fix(int32_t decalage) Matrix<T>& Fix(int32_t decalage)
{ {
Matrix<T> tmppp(1,1); Matrix<T> tmppp(m_size);
// TODO : ... T tmpVal = 0;
for(int32_t iii=0; iii<m_data.Size(); iii++) {
tmpVal = m_data[iii];
if (tmpVal < 0 && (tmpVal & ~(~0 << decalage))) {
tmpVal = tmpVal >> decalage;
tmpVal++;
} else {
tmpVal = tmpVal >> decalage;
}
tmppp.m_data[iii] = tmpVal;
}
return tmppp; return tmppp;
}; };
/** /**
@ -297,16 +316,136 @@ namespace etk
* @ param[in] decalage The power of 2 of the division * @ param[in] decalage The power of 2 of the division
* @ return the result * @ return the result
*/ */
Matrix<T>& Round2(int32_t decalage) Matrix<T>& Round(int32_t decalage)
{ {
Matrix<T> tmppp(1,1); Matrix<T> tmppp(m_size);
// TODO : ... for(int32_t iii=0; iii<m_data.Size(); iii++) {
tmppp.m_data[iii] = ( m_data[iii]+(1<<(decalage-1)) ) >> decalage;
}
return tmppp; return tmppp;
}; };
/**
* @ brief Generate a resised matrix
* @ param[in] size new output size
* @ return Te resied matrix
*/
Matrix<T>& Resize(etk::Vector2D<int32_t> size)
{
Matrix<T> tmppp(size);
for(int32_t iii=0; iii<m_data.m_size.x && iii<tmppp.m_size.x; iii++) {
for(int32_t jjj=0; jjj<m_data.m_size.y && jjj<tmppp.m_size.y; jjj++) {
tmppp(iii,jjj) = (*this)(iii,jjj);
}
}
return tmppp;
};
/**
* @brief Select element in the matrix from a list of element Ids
* @param[in] np Width of the output matrix
* @param[in] p List pointer of x
* @param[in] np Heigh of the output matrix
* @param[in] q List pointer of y
* @return the new matrix
*/
Matrix<T>& Select(int32_t np, int32_t *p, int32_t nq, int32_t *q)
{
if (np < 1 || nq < 1) {
TK_WARNING("bad index array sizes");
}
Matrix<T> tmppp(np,nq);
for (int32_t iii=0; iii<np; iii++) {
for (int32_t jjj=0; jjj<nq; jjj++) {
if( p[i] < 0
|| p[i] >= m_size.x
|| q[i] < 0
|| q[i] >= m_size.y) {
TK_WARNING("bad index arrays");
}
tmppp(iii,jjj) = (*this)(p[i],q[j]);
}
}
return tmppp;
}
/***************************************************** /*****************************************************
* other stupid action : * utilities :
*****************************************************/ *****************************************************/
Vector2D<int32_t> Size(void) { return m_size; }; /**
* @brief Clear the Upper triangle of the current Matrix
* <pre>
* x 0 0 0 0
* x x 0 0 0
* x x x 0 0
* x x x x 0
* x x x x x
* </pre>
*/
void ClearUpperTriangle(void)
{
if (m_size.x != m_size.y) {
TK_WARNING("better to do with square Matrix");
}
for (int32_t iii=0; iii<m_size.x; iii++) {
for (int32_t jjj=iii+1; jjj<m_size.y; jjj++)
m_data[iii*m_size.x + jjj] = 0;
}
}
};
/**
* @brief Clear the Lower triangle of the current Matrix
* <pre>
* x x x x x
* 0 x x x x
* 0 0 x x x
* 0 0 0 x x
* 0 0 0 0 x
* </pre>
*/
void ClearLowerTriangle(void)
{
if (m_size.x != m_size.y) {
TK_WARNING("better to do with square Matrix");
}
for (int32_t iii=0; iii<m_size.x; iii++) {
for (int32_t jjj=0; jjj<m_size.y && jjj<iii; jjj++)
m_data[iii*m_size.x + jjj] = 0;
}
}
};
/**
* @brief Generate a compleate random Matrix.
* @param[in] range The min/max value of the random Generation [-range..range].
*/
void MakeRandom(float range)
{
for(int32_t iii=0; iii<m_data.Size(); iii++) {
m_data[iii] = (T)etk::tool::frand(-range, range);
}
};
/**
* @brief Return the maximum of the diff for this Matrix.
* @param[in] input The compared Matix.
* @return The absolute max value.
*/
T MaxDifference(const Matrix<T>& input)
{
if (m_size != input.m_size)
TK_WARNING("better to do with same size Matrix");
}
T max = 0;
for(int32_t iii=0; iii<m_data.Size() && iii<input.m_data.Size(); iii++) {
T diff = m_data[iii] - input.m_data[iii];
if (diff<0) {
diff = -diff;
}
if (diff > max)
max = diff;
}
}
return max;
};
/**
* @brief Clear all the matrix.
*/
void Clear(void) void Clear(void)
{ {
// copy data for the same size : // copy data for the same size :
@ -314,46 +453,31 @@ namespace etk
m_data[iii] = (T)0; m_data[iii] = (T)0;
} }
}; };
/**
* @brief Set the diagonal at 1
*/
void Identity(void) void Identity(void)
{ {
// copy data for the same size : // copy data for the same size :
for (int32_t iii=0; iii< etk_min(m_size.x, m_size.y); iii++) { for (int32_t iii=0; iii< etk_min(m_size.x, m_size.y); iii++) {
(*this)[iii][iii] = (T)1; (*this)(iii,iii) = (T)1;
} }
}; };
/**
void Set(int32_t iii, int32_t jjj, T value) * @brief Clear and set the diagonal at 1
{
m_data[iii*m_size.x+jjj] = value;
}
T Get(int32_t iii, int32_t jjj)
{
return m_data[iii*m_size.x+jjj];
}
void Display(void)
{
/*
TK_INFO("Matrix display : ");
for (int32_t jjj=0; jjj< m_size.y; jjj++) {
if (m_size.x == 0) {
TK_INFO(" --- , ");
} else if (m_size.x == 1) {
TK_INFO(" " << (*this)[jjj][0] << " , ");
} else if (m_size.x == 2) {
TK_INFO(" " << (*this)[jjj][0] << " , " << (*this)[jjj][1] << " , ");
} else if (m_size.x == 3) {
TK_INFO(" " << (*this)[jjj][0] << " , " << (*this)[jjj][1] << " , " << (*this)[jjj][2] << " , ");
} else if (m_size.x == 4) {
TK_INFO(" " << (*this)[jjj][0] << " , " << (*this)[jjj][1] << " , " << (*this)[jjj][2] << " , " << (*this)[jjj][3] << " , ");
} else if (m_size.x == 5) {
TK_INFO(" " << (*this)[jjj][0] << " , " << (*this)[jjj][1] << " , " << (*this)[jjj][2] << " , " << (*this)[jjj][3] << " , " << (*this)[jjj][4] << " , ");
} else if (m_size.x == 6) {
TK_INFO(" " << (*this)[jjj][0] << " , " << (*this)[jjj][1] << " , " << (*this)[jjj][2] << " , " << (*this)[jjj][3] << " , " << (*this)[jjj][4] << " , " << (*this)[jjj][5] << " , ");
} else {
TK_INFO(" " << (*this)[jjj][0] << " , " << (*this)[jjj][1] << " , " << (*this)[jjj][2] << " , " << (*this)[jjj][3] << " , " << (*this)[jjj][4] << " , " << (*this)[jjj][5] << " , " << (*this)[jjj][6] << " , ");
}
}
*/ */
void Eye(void)
{
Clear();
Identity();
};
/**
* @brief Get the size of the current Matrix.
* @return Dimention of the matrix
*/
Vector2D<int32_t> Size(void)
{
return m_size;
}; };
}; };
}; };