【量化缠论】之分型、笔、线段识别

wuduo 笔
using System;
using System.Collections.Generic;

namespace CHAN
{
    public struct CALCINFO
    {
        public int m_dataType;
        public int m_nNumData;
        public IList m_pData;
        public int[] m_pResultBuf;
        public object m_pfParam1;
        public object m_pfParam2;
    }
    class kbar
    {
        public int flag;
        public double lprice;
        public double hprice;
    }

    enum DATA_TYPE
    {
        TICK_DATA = 2,                                //分笔成交
        MIN1_DATA,                                        //1分钟线
        MIN5_DATA,                                        //5分钟线                                       
        MIN15_DATA,                                        //15分钟线
        MIN30_DATA,                                        //30分钟线
        MIN60_DATA,                                        //60分钟线
        DAY_DATA,                                        //日线
        WEEK_DATA,                                        //周线
        MONTH_DATA,                                        //月线
        YEAR_DATA,                                        //年线
        MULTIDAY_DATA,                                //多日线
        MULTIMIN_DATA                                //多分钟线
    };
    public class ClassChan
    {
        IList pr;

        void init(CALCINFO pData)
        {
            int prnum = pData.m_nNumData;
            pr = new List(prnum);
            for (int i = 0; i < prnum; i++)
            {
                pr.Add(new kbar());
                pr[i].hprice = pData.m_pData[i].High;
                pr[i].lprice = pData.m_pData[i].Low;
                pr[i].flag = 0;
            }
        }

        public int bi(ref CALCINFO pData)
        {
            double biquekou = 0.0001;
            int i = 1, j, k, l, m, n;
            double p1, p2, s;
            bool ctfg, bictfg;
            int prtype = pData.m_dataType;
            int prnum = pData.m_nNumData;
            double[] buf;

            while (i < (prnum - 1))
            {
                if (pData.m_pData[i].Date >= new DateTime(2011, 2, 7, 13, 19, 0))
                    m = 1;
                k = pr[i].flag;
                if (k != 0)
                {
                    j = i + 1;
                    l = pr[j].flag;
                    while ((l == 0) && (j < prnum - 1))//找到下一个不为0的
                    {
                        j++;
                        l = pr[j].flag;
                    }//找到两个值;
                    if (l == 0)
                        break;                         //判断包含后的距离
                    buf = new double[10];
                    for (int ii = 0; ii < 10; ii++)
                        buf[ii] = 0;

                    m = 0;
                    for (k = i; k <= j; k++)
                    {
                        s = pr[k].hprice;
                        ctfg = false;
                        for (l = 0; l <= 5; l++)//查找是否在队列中
                        {
                            if (s == buf[l])
                            {
                                ctfg = true;
                                break;
                            }
                        }
                        if (!ctfg)//如果不在队列中
                        {
                            for (l = 0; l <= 5; l++)
                            {
                                if (buf[l] == 0)
                                {
                                    buf[l] = s;
                                    m++;
                                    break;
                                }
                            }
                        }
                        if (m >= 4)
                            break;
                    }
                    bictfg = false;      //缺口处理过程
                    s = 0;
                    if (pr[i].flag == -1)//向上
                    {
                        for (k = i; k < j; k++)
                        {
                            p1 = pData.m_pData[k].High;
                            p2 = pData.m_pData[k + 1].Low;
                            if (p2 > p1)
                                s = (p2 / p1 - 1) + s;
                        }
                    }
                    else//向下
                    {
                        for (k = i; k < j; k++)
                        {
                            p1 = pData.m_pData[k].Low;
                            p2 = pData.m_pData[k + 1].High;
                            if (p1 > p2)
                                s = Math.Abs(p2 / p1 - 1) + s;
                        }
                    }
                    if (s >= biquekou)
                        bictfg = true;

                    if (m >= 4)//包含后大于4根，再次判断
                    {
                        if (j - i >= 4) //不包含,至少5根
                        {
                            if (prtype != (int)DATA_TYPE.MIN5_DATA)  //5分钟分笔幅度太小的，舍掉
                                bictfg = true;
                            else
                            {
                                if (pr[j].flag == 1)
                                {
                                    s = (pr[j].hprice - pr[i].lprice) / pr[i].lprice;
                                    if ((j - i >= 6) || (s >= 0.008))
                                        bictfg = true;
                                }
                                if (pr[j].flag == -1)
                                {
                                    s = (pr[i].hprice - pr[j].lprice) / pr[i].hprice;
                                    if ((j - i >= 6) || (s >= 0.008))
                                        bictfg = true;
                                }
                            }
                        }
                    }// end m>=4

                    if (!bictfg) //如果不是一笔,进行下面的处理
                    {
                        k = i;
                        l = pr[k].flag;
                        k++;
                        while ((l != pr[k].flag) && (k < prnum - 1))//取下相同的顶或底
                        {
                            k++;
                        }
                        if (l == 1)//如果是顶
                        {
                            p1 = pr[i].hprice;
                            p2 = pr[k].hprice;
                            if (p1 >= p2) //前顶比后顶高;
                            {
                                pr[j].flag = 0;
                                pr[k].flag = 0;
                            }
                            else//前顶比后顶矮
                            {
                                pr[i].flag = 0; //先把自己去掉
                                n = j;
                                m = pr[n].flag;
                                n--;
                                while ((m != pr[n].flag) && (n > 0))
                                    n--;
                                p1 = pr[n].lprice;
                                p2 = pr[j].lprice;
                                if (p1 < p2)
                                {
                                    pr[j].flag = 0;
                                }
                                else
                                    pr[n].flag = 0;
                            }
                            i--;
                        }
                        if (l == -1)
                        {
                            p1 = pr[i].lprice;
                            p2 = pr[k].lprice;
                            if (p1 <= p2)  //前底比后底矮
                            {
                                pr[j].flag = 0;
                                pr[k].flag = 0;
                            }
                            else//前底比后底高
                            {
                                pr[i].flag = 0;
                                n = j;
                                m = pr[n].flag;
                                n--;
                                while ((m != pr[n].flag) && (n > 0))
                                    n--;
                                p1 = pr[n].hprice;
                                p2 = pr[j].hprice;
                                if (p1 > p2)
                                    pr[j].flag = 0;
                                else
                                    pr[n].flag = 0;
                            }
                            i--;
                        }
                    }
                }// end if k<>0;
                i++;
            } // end while;
            ///?        checkhl();          //检查最后一笔的高低点
            i = prnum - 1;
            while ((pr[i].flag == 0) && (i > 0))
                i--;
            if (pr[i].flag == 1)
            {
                for (j = i + 1; j < prnum; j++)
                {
                    if (pr[j].hprice > pr[i].hprice)
                    {
                        pr[i].flag = 0;
                        break;
                    }
                }
            }
            if (pr[i].flag == -1)
            {
                for (j = i + 1; j < prnum; j++)
                    if (pr[j].lprice < pr[i].lprice)
                    {
                        pr[i].flag = 0;
                        break;
                    }
            }
            pData.m_pResultBuf = new int[prnum];
            for (i = 0; i < prnum; i++)
            {
                pData.m_pResultBuf[i] = pr[i].flag;
            }
            return 1;
        }

        //处理kxian顶底的源代码   作者：悟多  c++ version
        public int kxian(ref CALCINFO pData)
        {
            int i, j = 1, k, m, n;
            double h, h1, h2, h3, h4, h5, h6, h7;
            bool tj1, tj2, tj3, tj4, firstduan;
            init(pData);

            if ((pData.m_pfParam1 != null) && (pData.m_pfParam2 != null))
            {
                int prnum = pData.m_nNumData;
                ///?                adjustkline(pData); //处理包含关系;
                //标出顶和底
                pr[0].flag = 0;
                pr[prnum - 1].flag = 0;
                for (i = 1; i < prnum - 1; i++)
                {
                    if (pData.m_pData[i].Date >= new DateTime(2011, 2, 7, 13, 19, 0))
                        m = 1;
                    j = i;
                    h = pr[i].hprice;
                    j--;
                    h1 = pr[j].hprice;
                    while ((h == h1) && (j > 0))//取前一个不同的高值
                    {
                        j--;
                        h1 = pr[j].hprice;
                    }
                    m = j;
                    if (j > 0) j--;
                    h2 = pr[j].hprice;
                    while ((h1 == h2) && (j > 0))//最前2个不同的值
                    {
                        j--;
                        h2 = pr[j].hprice;
                    }
                    if (j > 0) j--;
                    h3 = pr[j].hprice;
                    while ((h2 == h3) && (j > 0))//取前3个不同的值
                    {
                        j--;
                        h3 = pr[j].hprice;
                    }
                    k = i + 1;
                    if (k == prnum)
                        break;
                    h4 = pr[k].hprice;
                    while ((h == h4) && (k < prnum - 1)) //后一个不同高值
                    {
                        k++;
                        h4 = pr[k].hprice;
                    }
                    n = k;
                    if (k < prnum - 1) k++;
                    h5 = pr[k].hprice;
                    while ((h4 == h5) && (k < prnum - 1)) //后2个不同高值
                    {
                        k++;
                        h5 = pr[k].hprice;
                    }
                    if (k < prnum - 1) k++;
                    h6 = pr[k].hprice;
                    while ((h5 == h6) && (k < prnum - 1)) //后3个不同高值
                    {
                        k++;
                        h6 = pr[k].hprice;
                    }
                    if ((k >= prnum) || (n + 3 >= prnum))
                        break;
                    tj1 = false;
                    tj2 = false;
                    tj3 = false;
                    tj4 = false;
                    if ((h >= h1) && (h >= h2) && (h >= h3) && (h >= h4) && (h >= h5) && (h >= h6)) //判断顶底
                        tj1 = true;
                    if (m >= 3)
                        h7 = pr[m - 3].hprice;
                    else
                        h7 = pr[0].hprice;
                    if ((h >= h1) && (h >= h2) && (h >= h3) && (h >= h7) && (h >= pr[n].hprice) && (h >= pr[n + 1].hprice) && (h >= pr[n + 2].hprice) && (h >= pr[n + 3].hprice))
                        tj2 = true;
                    if (!(tj1 && tj2))
                    {
                        j = i;
                        h = pr[i].lprice;
                        j--;
                        h1 = pr[j].lprice;
                        while ((h == h1) && (j > 0))//取前一个不同的低值
                        {
                            j--;
                            h1 = pr[j].lprice;
                        }
                        m = j;
                        if (j > 0) j = j - 1;
                        h2 = pr[j].lprice;
                        while ((h1 == h2) && (j > 0))//最前2个不同的值
                        {
                            j--;
                            h2 = pr[j].lprice;
                        }
                        if (j > 0) j--;
                        h3 = pr[j].lprice;
                        while ((h2 == h3) && (j > 0))//取前3个不同的值
                        {
                            j--;
                            h3 = pr[j].lprice;
                        }
                        k = i;
                        k++;
                        if (k == prnum)
                            break;
                        h4 = pr[k].lprice;
                        while ((h == h4) && (k < prnum - 1)) //后1个不同低值
                        {
                            k++;
                            h4 = pr[k].lprice;
                        }
                        n = k;
                        if (k < prnum - 1) k++;
                        h5 = pr[k].lprice;
                        while ((h4 == h5) && (k < prnum - 1)) //后2个不同高值
                        {
                            k++;
                            h5 = pr[k].lprice;
                        }
                        if (k < prnum - 1) k++;
                        h6 = pr[k].lprice;
                        while ((h5 == h6) && (k < prnum - 1)) //后3个不同高值
                        {
                            k++;
                            h6 = pr[k].lprice;
                        }
                        if ((k >= prnum) || (n + 3 >= prnum)) break;
                        if ((h <= h1) && (h <= h2) && (h <= h3) && (h <= h4) && (h <= h5) && (h <= h6)) //判断底
                            tj3 = true;
                        if (m >= 3)
                            h7 = pr[m - 3].lprice;
                        else
                            h7 = pr[0].lprice;
                        if ((h <= h1) && (h <= h2) && (h <= h3) && (h <= h7) && (h <= pr[n].lprice) && (h <= pr[n + 1].lprice) && (h <= pr[n + 2].lprice) && (h <= pr[n + 3].lprice))
                            tj4 = true;
                    }
                    if (tj1 && tj2)
                        pr[i].flag = 1;
                    else
                        if (tj3 && tj4)
                            pr[i].flag = -1;
                        else
                            pr[i].flag = 0;
                }//end for
                for (i = 1; i <= prnum - 2; i++) //检查几个包含后重复的。
                {
                    m = pr[i].flag;
                    if (m == 1)
                    {
                        j = i;
                        if (pData.m_pData[i].High == pr[i].hprice)
                        {
                            pr[i].flag = 1;
                            j++; //如果前面的相同，只标最后一个
                            h = pr[j].hprice;
                            while ((h == pr[i].hprice) && (j < prnum - 1))
                            {
                                j++;
                                h = pr[j].hprice;
                            }
                            for (k = i + 1; k <= (j - 1); k++)
                                pr[k].flag = 0;
                        }
                        else
                            pr[i].flag = 0;
                    }
                    if (m == -1)
                    {
                        if (pData.m_pData[i].Low == pr[i].lprice)
                        {
                            j = i;
                            pr[i].flag = -1;
                            j++; //如果前面的相同，只标最后一个
                            h = pr[j].lprice;
                            while ((h == pr[i].lprice) && (j < prnum - 1))
                            {
                                j++;
                                h = pr[j].lprice;
                            }
                            for (k = i + 1; k <= (j - 1); k++)
                                pr[k].flag = 0;
                        }
                        else
                            pr[i].flag = 0;
                    }
                }//end 检查重复的
                ///?                adjustdd(1,prnum-2);
                ///?                checkhl();
                pData.m_pResultBuf = new int[prnum];
                for (i = 0; i <= prnum - 1; i++)
                    pData.m_pResultBuf[i] = pr[i].flag;
                return 1;
            } // end if NULL
            else
                return -1;
        }
    }
}