technique.cpp

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

	if( pValue3 )
		*pValue3	=	m_pdCache3[nIndex-m_nIndexStart];
	if( pValue4 )
		*pValue4	=	m_pdCache4[nIndex-m_nIndexStart];
	if( pValue5 )
		*pValue5	=	m_pdCache5[nIndex-m_nIndexStart];
	return TRUE;
}

// 将计算好的数据保存至缓冲区
BOOL CTechnique::StoreToCache( int nIndex, double * pValue1, double *pValue2, double *pValue3, double * pValue4, double * pValue5 )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );

	if( m_nLength <= 0 || m_nIndexStart < 0 )
	{
		m_nLength		=	( NULL!=m_pKData ? m_pKData->GetSize() : 0 );
		if( m_nLength > 0 )
			m_nIndexStart	=	0;
	}
	if( m_nLength <= 0 || m_nIndexStart <  0 )
		return FALSE;
	
	// Realocate
	if( pValue1 )
	{
		if( !m_pdCache1 )
			m_pdCache1		=	new double[m_nLength];
		if( !m_pbHasCache1 )
		{
			m_pbHasCache1	=	new BOOL[m_nLength];
			if( !m_pbHasCache1 )	return FALSE;
			for( int i=0; i<m_nLength; i++ )
				m_pbHasCache1[i]	=	FALSE;
		}
		if( NULL == m_pbHasCache1 || NULL == m_pdCache1 )
			return FALSE;
	}
	if( pValue2 )
	{
		if( !m_pdCache2 )
			m_pdCache2		=	new double[m_nLength];
		if( !m_pbHasCache2 )
		{
			m_pbHasCache2	=	new BOOL[m_nLength];
			if( !m_pbHasCache2 )	return FALSE;
			for( int i=0; i<m_nLength; i++ )
				m_pbHasCache2[i]	=	FALSE;
		}
		if( NULL == m_pbHasCache2 || NULL == m_pdCache2 )
			return FALSE;
	}
	if( pValue3 )
	{
		if( !m_pdCache3 )
			m_pdCache3		=	new double[m_nLength];
		if( !m_pbHasCache3 )
		{
			m_pbHasCache3	=	new BOOL[m_nLength];
			if( !m_pbHasCache3 )	return FALSE;
			for( int i=0; i<m_nLength; i++ )
				m_pbHasCache3[i]	=	FALSE;
		}
		if( NULL == m_pbHasCache3 || NULL == m_pdCache3 )
			return FALSE;
	}
	if( pValue4 )
	{
		if( !m_pdCache4 )
			m_pdCache4		=	new double[m_nLength];
		if( !m_pbHasCache4 )
		{
			m_pbHasCache4	=	new BOOL[m_nLength];
			if( !m_pbHasCache4 )	return FALSE;
			for( int i=0; i<m_nLength; i++ )
				m_pbHasCache4[i]	=	FALSE;
		}
		if( NULL == m_pbHasCache4 || NULL == m_pdCache4 )
			return FALSE;
	}
	if( pValue5 )
	{
		if( !m_pdCache5 )
			m_pdCache5		=	new double[m_nLength];
		if( !m_pbHasCache5 )
		{
			m_pbHasCache5	=	new BOOL[m_nLength];
			if( !m_pbHasCache5 )	return FALSE;
			for( int i=0; i<m_nLength; i++ )
				m_pbHasCache5[i]	=	FALSE;
		}
		if( NULL == m_pbHasCache5 || NULL == m_pdCache5 )
			return FALSE;
	}

	if( nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength )
		return FALSE;

	// Store	
	if( pValue1 && m_pdCache1 && m_pbHasCache1 )
	{
		m_pdCache1[nIndex-m_nIndexStart]		=	*pValue1;
		m_pbHasCache1[nIndex-m_nIndexStart]		=	TRUE;
	}
	if( pValue2 && m_pdCache2 && m_pbHasCache2 )
	{
		m_pdCache2[nIndex-m_nIndexStart]		=	*pValue2;
		m_pbHasCache2[nIndex-m_nIndexStart]		=	TRUE;
	}
	if( pValue3 && m_pdCache3 && m_pbHasCache3 )
	{
		m_pdCache3[nIndex-m_nIndexStart]		=	*pValue3;
		m_pbHasCache3[nIndex-m_nIndexStart]		=	TRUE;
	}
	if( pValue4 && m_pdCache4 && m_pbHasCache4 )
	{
		m_pdCache4[nIndex-m_nIndexStart]		=	*pValue4;
		m_pbHasCache4[nIndex-m_nIndexStart]		=	TRUE;
	}
	if( pValue5 && m_pdCache5 && m_pbHasCache5 )
	{
		m_pdCache5[nIndex-m_nIndexStart]		=	*pValue5;
		m_pbHasCache5[nIndex-m_nIndexStart]		=	TRUE;
	}
	return TRUE;
}

// 准备数据，得到较大值和较小值
BOOL CTechnique::IntensityPrepare( int nIndex, UINT * pnCode, int nMaxDays, int nMinMaxDays, double *pdLiminalLow, double *pdLiminalHigh, double dGateLow, double dGateHigh )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;

	if( nIndex < nMaxDays + nMinMaxDays )
		return FALSE;
	int	nStart	=	nIndex - nMinMaxDays + 1;
	if( nStart < 0 )
		return FALSE;

	double	dMin = 0, dMax = 0;
	if( !GetMinMaxInfo( nStart, nIndex, &dMin, &dMax ) )
		return FALSE;

	if( pdLiminalLow )	*pdLiminalLow	=	dMin + (dMax-dMin)*dGateLow;
	if( pdLiminalHigh )	*pdLiminalHigh	=	dMin + (dMax-dMin)*dGateHigh;
	return TRUE;
}

// 准备数据，得到价格较大值和较小值
BOOL CTechnique::IntensityPreparePrice( int nIndex, UINT * pnCode, int nMaxDays, int nMinMaxDays, double *pdLiminalLow, double *pdLiminalHigh, double dGateLow, double dGateHigh )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;

	if( nIndex < nMaxDays + nMinMaxDays )
		return FALSE;
	int	nStart	=	nIndex - nMinMaxDays + 1;
	if( nStart < 0 )
		return FALSE;

	float	fMin = 0, fMax = 0;
	if( !m_pKData || !m_pKData->GetMinMaxInfo( nStart, nIndex, &fMin, &fMax ) )
		return FALSE;

	if( pdLiminalLow )	*pdLiminalLow	=	(fMin + (fMax-fMin)*dGateLow);
	if( pdLiminalHigh )	*pdLiminalHigh	=	(fMin + (fMax-fMin)*dGateHigh);
	return TRUE;
}

// 是否创新高或者创新低
BOOL CTechnique::IsNewValue( int nIndex, BOOL bTopOrBottom, int nDays, double * pdValue1, double * pdValue2 )
{
	SP_ASSERT( nDays > 3 );
	if( nDays < 3 )
		return FALSE;
	SP_ASSERT( NULL != pdValue1 || NULL != pdValue2 );
	if( NULL == pdValue1 && NULL == pdValue2 )
		return FALSE;
	if( m_nLength <= 0 || m_nIndexStart < 0
		|| nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
		|| nIndex-m_nIndexStart < nDays-1 )
		return FALSE;

	BOOL	bFirst = TRUE;
	double	dLast1 = 0, dLast2 = 0;
	int		nLast1 = 0, nLast2 = 0;
	double	dNow1 = 0, dNow2 = 0;
	if( NULL != pdValue1 )
		dNow1	=	pdValue1[nIndex-m_nIndexStart];
	if( NULL != pdValue2 )
		dNow2	=	pdValue2[nIndex-m_nIndexStart];
	for( int k=nIndex-m_nIndexStart-1; k>=0 && k>nIndex-m_nIndexStart-nDays; k-- )
	{
		if( bFirst )
		{
			if( pdValue1 )	dLast1	=	pdValue1[k];
			if( pdValue2 )	dLast2	=	pdValue2[k];
			nLast1	=	nLast2	=	k;
			bFirst	=	FALSE;
		}

		if( bTopOrBottom )
		{
			if( pdValue1 && pdValue1[k] > dNow1 )
				return FALSE;
			if( pdValue2 && pdValue2[k] > dNow2 )
				return FALSE;

			if( pdValue1 && pdValue1[k] > dLast1 )
			{
				dLast1	=	pdValue1[k];
				nLast1	=	k;
			}
			if( pdValue2 && pdValue2[k] > dLast2 )
			{
				dLast2	=	pdValue2[k];
				nLast2	=	k;
			}
		}
		else
		{
			if( pdValue1 && pdValue1[k] < dNow1 )
				return FALSE;
			if( pdValue2 && pdValue2[k] < dNow2 )
				return FALSE;

			if( pdValue1 && pdValue1[k] < dLast1 )
			{
				dLast1	=	pdValue1[k];
				nLast1	=	k;
			}
			if( pdValue2 && pdValue2[k] < dLast2 )
			{
				dLast2	=	pdValue2[k];
				nLast2	=	k;
			}
		}
	}

	if( bFirst )
		return FALSE;

	if( ( !pdValue1 || (nLast1 >= nIndex-30 && nLast1 <= nIndex-5) )
		&& ( !pdValue2 || (nLast2 >= nIndex-30 && nLast2 <= nIndex-5) ) )
		return TRUE;

	return FALSE;
}

// 是否底背离
BOOL CTechnique::IsDeviateOnBottom( int nIndex, double * pdValue1, double * pdValue2 )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );

	if( !m_pKData->IsNewValue( nIndex, FALSE, ITS_DAYS_DEVIATE ) )
		return FALSE;

	if( IsNewValue( nIndex, FALSE, ITS_DAYS_DEVIATE, pdValue1, pdValue2 ) )
		return FALSE;

	return TRUE;
}

// 是否顶背离
BOOL CTechnique::IsDeviateOnTop( int nIndex, double * pdValue1, double * pdValue2 )
{
	STT_ASSERT_CALCULATE1( m_pKData, nIndex );

	if( !m_pKData->IsNewValue( nIndex, TRUE, ITS_DAYS_DEVIATE ) )
		return FALSE;

	if( IsNewValue( nIndex, TRUE, ITS_DAYS_DEVIATE, pdValue1, pdValue2 ) )
		return FALSE;

	return TRUE;
}

// 是否金叉
BOOL CTechnique::IsGoldenFork( int nIndex, double * pdValue1, double * pdValue2 )
{
	SP_ASSERT( NULL != pdValue1 && NULL != pdValue2 );
	if( NULL == pdValue1 || NULL == pdValue2 )
		return FALSE;
	if( m_nLength <= 0 || m_nIndexStart < 0
		|| nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
		|| nIndex-m_nIndexStart < 1 )
		return FALSE;

	int	k	=	nIndex-m_nIndexStart;
	if( pdValue1[k-1] <= pdValue2[k-1] && pdValue1[k] > pdValue2[k]
		&& pdValue1[k] >= pdValue1[k-1] && pdValue2[k] >= pdValue2[k-1] )
		return TRUE;
	return FALSE;
}

// 是否死叉
BOOL CTechnique::IsDeadFork( int nIndex, double * pdValue1, double * pdValue2 )
{
	SP_ASSERT( NULL != pdValue1 && NULL != pdValue2 );
	if( NULL == pdValue1 || NULL == pdValue2 )
		return FALSE;
	if( m_nLength <= 0 || m_nIndexStart < 0
		|| nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
		|| nIndex-m_nIndexStart < 1 )
		return FALSE;

	int	k	=	nIndex-m_nIndexStart;
	if( pdValue1[k-1] >= pdValue2[k-1] && pdValue1[k] < pdValue2[k]
		&& pdValue1[k] <= pdValue1[k-1] && pdValue2[k] <= pdValue2[k-1] )
		return TRUE;
	return FALSE;
}

// 得到金叉或者死叉信号
int CTechnique::GetForkSignal(int nIndex, CSPDWordArray & adwDays,
								 UINT itsGoldenFork, UINT itsDeadFork, UINT * pnCode )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;
	if( nIndex <= 0 )
		return ITS_NOTHING;

	for( int k=1; k<adwDays.GetSize(); k++ )
	{
		double	dMANow1, dMANow2, dMALast1, dMALast2;
		if( !Calculate( &dMANow1, nIndex, min(adwDays[k-1],adwDays[k]), FALSE )
			|| !Calculate( &dMANow2, nIndex, max(adwDays[k-1],adwDays[k]), FALSE )
			|| !Calculate( &dMALast1, nIndex-1, min(adwDays[k-1],adwDays[k]), FALSE )
			|| !Calculate( &dMALast2, nIndex-1, max(adwDays[k-1],adwDays[k]), FALSE ) )
			return ITS_NOTHING;
		
		if( dMALast1 <= dMALast2 && dMANow1 > dMANow2
			&& dMANow1 >= dMALast1 && dMANow2 >= dMALast2 )
		{
			if( adwDays.GetSize()-1 == k )
			{
				if( pnCode )	*pnCode	=	ITSC_GOLDENFORK;
				return itsGoldenFork;
			}
			for( int l=k+1; l<adwDays.GetSize(); l++ )
			{
				double	dMANow3, dMALast3;
				if( !Calculate( &dMANow3, nIndex, adwDays[l], FALSE )
					|| !Calculate( &dMALast3, nIndex-1, adwDays[l], FALSE ) )
					return ITS_NOTHING;
				if( dMANow3 >= dMALast3 )
				{
					if( pnCode )	*pnCode	=	ITSC_GOLDENFORK;
					return itsGoldenFork;
				}
			}
		}
		if( dMALast1 >= dMALast2 && dMANow1 < dMANow2
			&& dMANow1 <= dMALast1 && dMANow2 <= dMALast2 )
		{
			if( adwDays.GetSize()-1 == k )
			{
				if( pnCode )	*pnCode	=	ITSC_DEADFORK;
				return itsDeadFork;
			}
			for( int l=k+1; l<adwDays.GetSize(); l++ )
			{
				double	dMANow3, dMALast3;
				if( !Calculate( &dMANow3, nIndex, adwDays[l], FALSE )
					|| !Calculate( &dMALast3, nIndex-1, adwDays[l], FALSE ) )
					return ITS_NOTHING;
				if( dMANow3 <= dMALast3 )
				{
					if( pnCode )	*pnCode	=	ITSC_DEADFORK;
					return itsDeadFork;
				}
			}
		}
	}
	return ITS_NOTHING;
}

// 得到金叉或者死叉信号
int CTechnique::GetForkSignal( int nIndex, UINT itsGoldenFork, UINT itsDeadFork, UINT *pnCode )
{
	if( pnCode )	*pnCode	=	ITSC_NOTHING;
	if( nIndex <= 0 )
		return ITS_NOTHING;

	double dLast1 = 0, dLast2 = 0, dNow1 = 0, dNow2 = 0;
	if( !Calculate( &dLast1, &dLast2, nIndex-1, FALSE )
		|| !Calculate( &dNow1, &dNow2, nIndex, FALSE ) )
		return ITS_NOTHING;