techother.cpp

股软 通达信行情接收接口, 包括美元汇率

{
	CTechnique::Clear( );
}

int CHLC::GetSignal( int nIndex, UINT * pnCode )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;
	
	int	nMaxDays	=	m_nDays + m_nMADays;
	double	dLiminalLow = 0, dLiminalHigh = 0;
	if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE*3, &dLiminalLow, &dLiminalHigh, 0.4, 0.6 ) )
		return ITS_NOTHING;

	double	dHLC;
	if( !Calculate( &dHLC, nIndex, FALSE ) )
		return ITS_NOTHING;

	int	nSignal	=	GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
	if( nSignal == m_itsGoldenFork )
	{	// 低位金叉
		if( pnCode )	*pnCode	=	ITSC_GOLDENFORK;
		return m_itsGoldenFork;
	}
	if( nSignal == m_itsDeadFork )
	{	// 高位死叉
		if( pnCode )	*pnCode	=	ITSC_DEADFORK;
		return m_itsDeadFork;
	}
	
	return ITS_NOTHING;
}

BOOL CHLC::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
{
	return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
}

/***
	TP = (收盘价+收盘价+最高价+最低价)/4
	HLC = N日TP平均值
*/
BOOL CHLC::Calculate( double * pValue, int nIndex, BOOL bUseLast )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );
	
	if( m_nDays > nIndex+1 )
		return FALSE;

	if( LoadFromCache( nIndex, pValue ) )
		return TRUE;

	double	dMATP = 0;
	int	nCount	=	0;
	for( int k=nIndex; k>=0; k-- )
	{
		KDATA	kd		=	m_pKData->ElementAt(k);
		double	dTP		= (kd.m_fHigh+kd.m_fLow+kd.m_fClose*2)/4.;
		dMATP	+=	dTP;

		nCount	++;
		if( nCount == m_nDays )
		{
			if( pValue )	*pValue	=	dMATP / m_nDays;
			StoreToCache( nIndex, pValue );
			return TRUE;
		}
	}
	return FALSE;
}

/***
	计算HLC及其移动平均值
*/
BOOL CHLC::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
{
	return CTechnique::CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
}

//////////////////////////////////////////////////////////////////////
//	CCDP
CCDP::CCDP( )
{
	SetDefaultParameters( );
}

CCDP::CCDP( CKData * pKData )
	: CTechnique( pKData )
{
	SetDefaultParameters( );
}

CCDP::~CCDP()
{
	Clear( );
}

void CCDP::SetDefaultParameters( )
{
}

void CCDP::AttachParameters( CCDP & src )
{
}

BOOL CCDP::IsValidParameters( )
{
	return TRUE;
}

void CCDP::Clear( )
{
	CTechnique::Clear( );
}

int CCDP::GetSignal( int nIndex, UINT * pnCode )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;
	// 无买卖信号
	return	ITS_NOTHING;
}

BOOL CCDP::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
{
	return AfxGetMinMaxInfo4( nStart, nEnd, pdMin, pdMax, this );
}

/***
	TP = (昨日收盘价+昨日收盘价+昨日最高价+昨日最低价)/4
	AH = TP + 昨日最高价 - 昨日最低价
	AL = TP - 最日最高价 + 昨日最低价
	NH = TP + TP - 最日最低价
	NL = TP + TP - 最日最高价
*/
BOOL CCDP::Calculate( double * pAH, double * pNH, double * pAL, double * pNL, int nIndex, BOOL bUseLast )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );

	if( nIndex < 1 )
		return FALSE;

	if( LoadFromCache( nIndex, pAH, pNH, pAL, pNL ) )
		return TRUE;

	KDATA	kdLast	=	m_pKData->ElementAt(nIndex-1);
	double	dTP	=	(kdLast.m_fHigh+kdLast.m_fLow+kdLast.m_fClose*2)/4.;
	if( pAH )	*pAH	=	(dTP + kdLast.m_fHigh - kdLast.m_fLow);
	if( pNH )	*pNH	=	(dTP + dTP - kdLast.m_fLow);
	if( pAL )	*pAL	=	(dTP - kdLast.m_fHigh + kdLast.m_fLow);
	if( pNL )	*pNL	=	(dTP - kdLast.m_fHigh + dTP);
	StoreToCache( nIndex, pAH, pNH, pAL, pNL );
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
//	CASI
CASI::CASI( )
{
	SetDefaultParameters( );
}

CASI::CASI( CKData * pKData )
	: CTechnique( pKData )
{
	SetDefaultParameters( );
}

CASI::~CASI()
{
	Clear( );
}

void CASI::SetDefaultParameters( )
{
	m_nDays		=	6;
	m_itsDeviateOnBottom	=	ITS_BUY;
	m_itsDeviateOnTop		=	ITS_SELL;
}

void CASI::AttachParameters( CASI & src )
{
	m_nDays		=	src.m_nDays;
	m_itsDeviateOnBottom	=	src.m_itsDeviateOnBottom;
	m_itsDeviateOnTop		=	src.m_itsDeviateOnTop;
}

BOOL CASI::IsValidParameters( )
{
	return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsDeviateOnBottom) && VALID_ITS(m_itsDeviateOnTop) );
}

void CASI::Clear( )
{
	CTechnique::Clear( );
}

int CASI::GetSignal( int nIndex, UINT * pnCode )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;

	int	nMaxDays	=	m_nDays;
	double	dLiminalLow = 0, dLiminalHigh = 0;
	if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
		return ITS_NOTHING;

	if( IsDeviateOnBottom( nIndex, m_pdCache1, m_pdCache2 ) )
	{	// 底背离
		if( pnCode )	*pnCode	=	ITSC_DEVIATEONBOTTOM;
		return m_itsDeviateOnBottom;
	}
	if( IsDeviateOnTop( nIndex, m_pdCache1, m_pdCache2 ) )
	{	// 顶背离
		if( pnCode )	*pnCode	=	ITSC_DEVIATEONTOP;
		return m_itsDeviateOnTop;
	}

	return	ITS_NOTHING;
}

BOOL CASI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
{
	return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
}

/***
	A = 今最高 - 昨收盘
	B = 今最低 - 昨最低
	C = 今最高 - 昨最低
	D = 昨收盘 - 昨开盘
	E = 今收盘 - 昨收盘
	F = 今收盘 - 昨开盘
	G = 昨收盘 - 昨开盘
	X = E + 1/(2F) + G
	K = A、B二者之间较大者
	比较A、B、C三者的大小
		若A大，则R = A+1/(2B)+1/(4D)
		若B大，则R = B+1/(2A)+1/(4D)
		若C大，则R = C+1/(4D)
	L = 3
	SI = 50·X·K/(R·L)
	ASI = N日SI之和
*/
BOOL CASI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );
	
	if( m_nDays > nIndex )
		return FALSE;

	if( LoadFromCache( nIndex, pValue ) )
		return TRUE;

	double	dASI = 0;
	double	A, B, C, D, E, F, G;
	double	R, X, K, SI;
	int	nCount	=	0;
	for( int k=nIndex; k>=1; k-- )
	{
		KDATA	kd		=	m_pKData->ElementAt(k);
		KDATA	kdLast	=	m_pKData->ElementAt(k-1);
		A	=	fabs(((double)kd.m_fHigh) - kdLast.m_fClose);
		B	=	fabs(((double)kd.m_fLow) - kdLast.m_fClose);
		C	=	fabs(((double)kd.m_fHigh) - kdLast.m_fLow);
		D	=	fabs(((double)kdLast.m_fClose) - kdLast.m_fOpen);
		E	=	((double)kd.m_fClose) - kdLast.m_fClose;
		F	=	((double)kd.m_fClose) - kd.m_fOpen;
		G	=	((double)kdLast.m_fClose) - kdLast.m_fOpen;

		if( fabs(A) < 1e-4 || fabs(B) < 1e-4 || fabs(D) < 1e-4 || fabs(F) < 1e-4 )
			continue;

		if( A >= B && A >= C )
			R	=	A + 1/(2*B) + 1/(4*D);
		else if( B >= A && B >= C )
			R	=	B + 1/(2*A) + 1/(4*D);
		else
			R	=	C + 1/(4*D);

		if( fabs(R) < 1e-4 )
			continue;

		X	=	E + 1/(2*F) + G;
		K	=	( A > B ? A : B );
		SI	=	X * K * 50 / (3*R);

		dASI	+=	SI;

		nCount	++;
		if( nCount == m_nDays )
		{
			if( pValue )	*pValue	=	dASI;
			StoreToCache( nIndex, pValue );
			return TRUE;
		}
	}

	return FALSE;
}

//////////////////////////////////////////////////////////////////////
//	CATR
CATR::CATR( )
{
	SetDefaultParameters( );
}

CATR::CATR( CKData * pKData )
	: CTechnique( pKData )
{
	SetDefaultParameters( );
}

CATR::~CATR()
{
	Clear( );
}

void CATR::SetDefaultParameters( )
{
	m_nDays		=	14;
	m_itsSold	=	ITS_BUY;
	m_itsBought	=	ITS_SELL;
}

void CATR::AttachParameters( CATR & src )
{
	m_nDays		=	src.m_nDays;
	m_itsSold	=	src.m_itsSold;
	m_itsBought	=	src.m_itsBought;
}

BOOL CATR::IsValidParameters( )
{
	return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
}

void CATR::Clear( )
{
	CTechnique::Clear( );
}

int CATR::GetSignal( int nIndex, UINT * pnCode )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;

	int	nMaxDays	=	m_nDays;
	double	dLiminalLow = 0, dLiminalHigh = 0;
	if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
		return ITS_NOTHING;

	double	dATR;
	if( !Calculate( &dATR, nIndex, FALSE ) )
		return ITS_NOTHING;

	if( dATR > dLiminalHigh )
	{	// 超卖
		if( pnCode )	*pnCode	=	ITSC_OVERSOLD;
		return m_itsSold;
	}
	if( dATR < dLiminalLow )
	{	// 超买
		if( pnCode )	*pnCode	=	ITSC_OVERBOUGHT;
		return m_itsBought;
	}
	return	ITS_NOTHING;
}

BOOL CATR::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
{
	return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
}

/***
	TR 为以下三者中的最大值
		最高价-最低价，(昨日收盘价-今日最高价)的绝对值，昨日收盘价-昨日最低价

	ATR = TR的N日平均
*/
BOOL CATR::Calculate( double * pValue, int nIndex, BOOL bUseLast )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );
	
	if( m_nDays > nIndex )
		return FALSE;

	if( LoadFromCache( nIndex, pValue ) )
		return TRUE;

	double	dATR = 0;
	int	nCount	=	0;
	for( int k=nIndex; k>=1; k-- )
	{
		KDATA	kd		=	m_pKData->ElementAt(k);
		KDATA	kdLast	=	m_pKData->ElementAt(k-1);

		double	dTR	=	fabs(((double)kd.m_fHigh)-kd.m_fLow);
		if( fabs(((double)kdLast.m_fClose)-kd.m_fHigh) > dTR )
			dTR	=	fabs(((double)kdLast.m_fClose)-kd.m_fHigh);
		if( fabs(((double)kdLast.m_fClose)-kdLast.m_fLow) > dTR )
			dTR	=	fabs(((double)kdLast.m_fClose)-kdLast.m_fLow);

		dATR	+=	dTR;

		nCount	++;
		if( nCount == m_nDays )
		{
			if( pValue )	*pValue	=	dATR/m_nDays;
			StoreToCache( nIndex, pValue );
			return TRUE;
		}
	}
	return FALSE;
}