?? kdata.cpp
字號(hào):
/*
Cross Platform Core Code.
Copyright(R) 2001-2002 Balang Software.
All rights reserved.
Using:
class CKData;
*/
#include "StdAfx.h"
#include "Stock.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
/////////////////////////////////////////////////////////////////////////////
CKData::CKData()
{
m_nKType = ktypeDay;
m_nCurFormat= formatOriginal;
m_nCurMaindataType = mdtypeClose;
m_pDataOriginal = NULL;
m_nSizeOriginal = m_nMaxSizeOriginal = 0;
m_pData = NULL;
m_nSize = m_nMaxSize = m_nGrowBy = 0;
}
CKData::CKData( int ktype, int maindatatype )
{
m_nKType = ktype;
m_nCurFormat= formatOriginal;
m_nCurMaindataType = maindatatype;
m_pDataOriginal = NULL;
m_nSizeOriginal = m_nMaxSizeOriginal = 0;
m_pData = NULL;
m_nSize = m_nMaxSize = m_nGrowBy = 0;
}
CKData::CKData( const CKData &src )
{
m_nKType = ktypeDay;
m_nCurFormat= formatOriginal;
m_nCurMaindataType = mdtypeClose;
m_pDataOriginal = NULL;
m_nSizeOriginal = m_nMaxSizeOriginal = 0;
m_pData = NULL;
m_nSize = m_nMaxSize = m_nGrowBy = 0;
*this = src;
}
CKData & CKData::operator = ( const CKData &src )
{
Clear();
m_nKType = src.m_nKType;
m_nCurFormat = src.m_nCurFormat;
m_nCurMaindataType = src.m_nCurMaindataType;
m_drdata = src.m_drdata;
CopyData( src );
return *this;
}
BOOL CKData::IsDayOrMin( int nKType )
{
return (nKType == CKData::ktypeDay || nKType == CKData::ktypeWeek || nKType == CKData::ktypeMonth);
}
CKData::~CKData()
{
Clear();
}
int CKData::GetSize() const
{ return m_nSize; }
int CKData::Add(KDATA newElement)
{ int nIndex = m_nSize;
SetAtGrow(nIndex, newElement);
return nIndex; }
void CKData::SetSize(int nNewSize, int nGrowBy /* = -1 */)
{
SP_ASSERT(nNewSize >= 0);
if (nGrowBy != -1)
m_nGrowBy = nGrowBy; // set new size
if (nNewSize == 0)
{
// shrink to nothing
delete [] (BYTE*)m_pData;
m_pData = NULL;
m_nSize = m_nMaxSize = 0;
}
else if (m_pData == NULL)
{
// create one with exact size
#ifdef SIZE_T_MAX
SP_ASSERT((long)nNewSize * sizeof(KDATA) <= SIZE_T_MAX); // no overflow
#endif
m_pData = (KDATA*) new BYTE[nNewSize * sizeof(KDATA)];
memset(m_pData, 0, nNewSize * sizeof(KDATA)); // zero fill
m_nSize = m_nMaxSize = nNewSize;
}
else if (nNewSize <= m_nMaxSize)
{
// it fits
if (nNewSize > m_nSize)
{
// initialize the new elements
memset(&m_pData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(KDATA));
}
m_nSize = nNewSize;
}
else
{
// Otherwise grow array
int nNewMax;
if (nNewSize < m_nMaxSize + m_nGrowBy)
nNewMax = m_nMaxSize + m_nGrowBy; // granularity
else
nNewMax = nNewSize; // no slush
#ifdef SIZE_T_MAX
SP_ASSERT((long)nNewMax * sizeof(KDATA) <= SIZE_T_MAX); // no overflow
#endif
KDATA* pNewData = (KDATA*) new BYTE[nNewMax * sizeof(KDATA)];
// copy new data from old
memcpy(pNewData, m_pData, m_nSize * sizeof(KDATA));
// construct remaining elements
SP_ASSERT(nNewSize > m_nSize);
memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(KDATA));
// get rid of old stuff (note: no destructors called)
delete [] (BYTE*)m_pData;
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;
}
}
void CKData::FreeExtra()
{
if (m_nSize != m_nMaxSize)
{
// shrink to desired size
#ifdef SIZE_T_MAX
SP_ASSERT((long)m_nSize * sizeof(KDATA) <= SIZE_T_MAX); // no overflow
#endif
KDATA* pNewData = NULL;
if (m_nSize != 0)
{
pNewData = (KDATA*) new BYTE[m_nSize * sizeof(KDATA)];
// copy new data from old
memcpy(pNewData, m_pData, m_nSize * sizeof(KDATA));
}
// get rid of old stuff (note: no destructors called)
delete [] (BYTE*)m_pData;
m_pData = pNewData;
m_nMaxSize = m_nSize;
}
}
BOOL CKData::LatestDate( int &nYear, int &nMonth, int &nDay, int &nHour, int &nMinute ) const
{
nYear = nMonth = nDay = nHour = nMinute = 0;
if( GetSize() > 0 )
return DateAt( GetSize()-1, nYear, nMonth, nDay, nHour, nMinute );
return FALSE;
}
DWORD CKData::GetDate( int nIndex )
{
if( nIndex >=0 && nIndex < GetSize() )
return ElementAt(nIndex).m_date;
if( GetSize() > 0 )
return ElementAt(GetSize()-1).m_date;
return 0;
}
DWORD CKData::GetDateDay( int nIndex )
{
DWORD date = GetDate(nIndex);
if( CKData::ktypeMin5 == m_nKType || CKData::ktypeMin15 == m_nKType
|| CKData::ktypeMin30 == m_nKType || CKData::ktypeMin60 == m_nKType )
{
CSPTime sptime;
if( sptime.FromStockTimeMin( date ) )
return sptime.ToStockTimeDay();
else
return 0;
}
return date;
}
int CKData::GetIndexByDate( DWORD date )
{
if( GetSize() > 0 && ElementAt(GetSize()-1).m_date < date )
return -1;
if( GetSize() > 0 && ElementAt(0).m_date > date )
return -1;
for( int k=GetSize()-1; k >= 0 ; k-- )
{
if( ElementAt(k).m_date == date )
return k;
else if( ElementAt(k).m_date < date )
break;
}
return -1;
}
int CKData::GetAboutIndexByDate( DWORD date )
{
for( int k=GetSize()-1; k >= 0 ; k-- )
{
if( ElementAt(k).m_date <= date )
return k;
}
return -1;
}
/////////////////////////////////////////////////////////////////////////////
void CKData::SetAtGrow(int nIndex, KDATA newElement)
{
SP_ASSERT(nIndex >= 0);
if (nIndex >= m_nSize)
SetSize(nIndex+1);
m_pData[nIndex] = newElement;
}
void CKData::InsertAt(int nIndex, KDATA newElement, int nCount /*=1*/)
{
SP_ASSERT(nIndex >= 0); // will expand to meet need
SP_ASSERT(nCount > 0); // zero or negative size not allowed
if (nIndex >= m_nSize)
{
// adding after the end of the array
SetSize(nIndex + nCount); // grow so nIndex is valid
}
else
{
// inserting in the middle of the array
int nOldSize = m_nSize;
SetSize(m_nSize + nCount); // grow it to new size
// shift old data up to fill gap
memmove(&m_pData[nIndex+nCount], &m_pData[nIndex],
(nOldSize-nIndex) * sizeof(KDATA));
// re-init slots we copied from
memset(&m_pData[nIndex], 0, nCount * sizeof(KDATA));
}
// insert new value in the gap
SP_ASSERT(nIndex + nCount <= m_nSize);
while (nCount--)
m_pData[nIndex++] = newElement;
}
int CKData::InsertKDataSort( KDATA newElement )
{
for( int i=0; i<GetSize(); i++ )
{
KDATA & temp = ElementAt(i);
if( temp.m_date == newElement.m_date )
{
SetAt(i,newElement);
return i;
}
if( temp.m_date > newElement.m_date )
{
InsertAt(i,newElement);
return i;
}
}
return Add( newElement );
}
BOOL CKData::IsNewValue( int nIndex, BOOL bTopOrBottom, int nDays )
{
if( nIndex < nDays-1 || nIndex < 0 || nIndex >= GetSize() || nDays < 3 )
return FALSE;
BOOL bFirst = TRUE;
float fLast = 0;
int nLast = 0;
float fNow = MaindataAt( nIndex );
for( int k=nIndex-1; k>=0 && k>nIndex-nDays; k-- )
{
float fCur = MaindataAt(k);
if( bFirst )
{
fLast = fCur;
nLast = k;
bFirst = FALSE;
}
if( bTopOrBottom )
{
if( fCur > fNow )
return FALSE;
if( fCur > fLast )
{
fLast = fCur;
nLast = k;
}
}
else
{
if( fCur < fNow )
return FALSE;
if( fCur < fLast )
{
fLast = fCur;
nLast = k;
}
}
}
if( bFirst )
return FALSE;
if( nLast >= nIndex-30 && nLast <= nIndex-5 )
return TRUE;
return FALSE;
}
BOOL CKData::GetMinMaxInfo( int nStart, int nEnd, float * pfMin, float *pfMax )
{
if( nStart < 0 || nEnd < 0 || nStart > nEnd || nEnd >= GetSize() )
return FALSE;
float fMin = 0, fMax = 0;
BOOL bFirst = TRUE;
for( int k=nStart; k<=nEnd; k++ )
{
KDATA & kd = ElementAt(k);
if( bFirst )
{
fMin = kd.m_fLow;
fMax = kd.m_fHigh;
bFirst = FALSE;
}
if( kd.m_fLow < fMin )
fMin = kd.m_fLow;
if( kd.m_fHigh > fMax )
fMax = kd.m_fHigh;
}
if( pfMin ) *pfMin = fMin;
if( pfMax ) *pfMax = fMax;
return !bFirst;
}
void CKData::RemoveAt(int nIndex, int nCount /* = 1 */)
{
SP_ASSERT(nIndex >= 0);
SP_ASSERT(nCount >= 0);
SP_ASSERT(nIndex + nCount <= m_nSize);
// just remove a range
int nMoveCount = m_nSize - (nIndex + nCount);
if (nMoveCount)
memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount],
nMoveCount * sizeof(KDATA));
m_nSize -= nCount;
}
void CKData::InsertAt(int nStartIndex, CKData* pNewArray)
{
SP_ASSERT(pNewArray != NULL);
SP_ASSERT(nStartIndex >= 0);
if (pNewArray->GetSize() > 0)
{
InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize());
for (int i = 0; i < pNewArray->GetSize(); i++)
SetAt(nStartIndex + i, pNewArray->GetAt(i));
}
}
/////////////////////////////////////////////////////////////////////////////
// Extra Operations
void CKData::SetKType( int ktype ) { m_nKType = ktype; }
void CKData::AutoSetKType( )
{
if( GetSize() >= 4 )
{
long elapse1 = ElementAt(1).m_time - ElementAt(0).m_time;
long elapse2 = ElementAt(2).m_time - ElementAt(1).m_time;
long elapse3 = ElementAt(3).m_time - ElementAt(2).m_time;
long elapse = min(elapse1,elapse2);
elapse = min(elapse,elapse3);
if( elapse < 600 )
m_nKType = ktypeMin5;
else if( elapse < 1200 )
m_nKType = ktypeMin15;
else if( elapse < 2400 )
m_nKType = ktypeMin30;
else if( elapse < 7200 )
m_nKType = ktypeMin60;
else if( elapse < 172800 )
m_nKType = ktypeDay;
else if( elapse < 864000 )
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號(hào)
Ctrl + =
減小字號(hào)
Ctrl + -